diff --git a/.aztec-sync-commit b/.aztec-sync-commit
index 42ef1037b17..46138f41929 100644
--- a/.aztec-sync-commit
+++ b/.aztec-sync-commit
@@ -1 +1 @@
-b0d1bab1f02819e7efbe0db73c3c805b5927b66a
+fca96007d6055dcf00b72a46630c680fcb6d190d
diff --git a/.github/ACVM_NOT_PUBLISHABLE.md b/.github/ACVM_NOT_PUBLISHABLE.md
index 33230f8e8d8..06c9505ebae 100644
--- a/.github/ACVM_NOT_PUBLISHABLE.md
+++ b/.github/ACVM_NOT_PUBLISHABLE.md
@@ -5,7 +5,7 @@ assignees: TomAFrench, Savio-Sou
 
 The ACVM crates are currently unpublishable, making a release will NOT push our crates to crates.io.
 
-This is likely due to a crate we depend on bumping its MSRV above our own. Our lockfile is not taken into account when publishing to crates.io (as people downloading our crate don't use it) so we need to be able to use the most up to date versions of our dependencies (including transient dependencies) specified. 
+This is likely due to a crate we depend on bumping its MSRV above our own. Our lockfile is not taken into account when publishing to crates.io (as people downloading our crate don't use it) so we need to be able to use the most up-to-date versions of our dependencies (including transient dependencies) specified. 
 
 Check the [MSRV check]({{env.WORKFLOW_URL}}) workflow for details.
 
diff --git a/.github/scripts/backend-barretenberg-build.sh b/.github/scripts/backend-barretenberg-build.sh
deleted file mode 100755
index d90995397d8..00000000000
--- a/.github/scripts/backend-barretenberg-build.sh
+++ /dev/null
@@ -1,4 +0,0 @@
-#!/bin/bash
-set -eu
-
-yarn workspace @noir-lang/backend_barretenberg build
diff --git a/.github/scripts/backend-barretenberg-test.sh b/.github/scripts/backend-barretenberg-test.sh
deleted file mode 100755
index 1bd6f8e410d..00000000000
--- a/.github/scripts/backend-barretenberg-test.sh
+++ /dev/null
@@ -1,4 +0,0 @@
-#!/bin/bash
-set -eu
-
-yarn workspace @noir-lang/backend_barretenberg test
diff --git a/.github/scripts/merge-bench-reports.sh b/.github/scripts/merge-bench-reports.sh
new file mode 100755
index 00000000000..23a62874148
--- /dev/null
+++ b/.github/scripts/merge-bench-reports.sh
@@ -0,0 +1,27 @@
+#!/bin/bash
+set -eu
+
+echo "Merging reports"
+
+REPORT_NAME=$1
+NAME_PLURAL=""$REPORT_NAME"s"
+
+combined_reports="[]"
+
+# Iterate over each report and merge them
+for report in ./reports/*; do
+  # The report is saved under ./$REPORT_NAME_{ matrix_report }/$REPORT_NAME_{ matrix_report }.json
+  FILE_PATH=$(echo $(ls $report)) 
+
+  # Extract the $NAME_PLURAL array from each report and merge it
+  combined_reports=$(jq '[."'"$NAME_PLURAL"'"[]] + '"$combined_reports" <<< "$(cat "$report/$FILE_PATH")")
+done
+
+combined_reports=$(jq '[."'$NAME_PLURAL'"[]] + '"$combined_reports" <<< "$(cat ./$REPORT_NAME.json)")
+
+# Wrap the merged memory reports into a new object as to keep the $NAME_PLURAL key
+final_report="{\"$NAME_PLURAL\": $combined_reports}"
+
+echo "$final_report" > $REPORT_NAME.json
+
+cat $REPORT_NAME.json
\ No newline at end of file
diff --git a/.github/workflows/cache-cleanup.yml b/.github/workflows/cache-cleanup.yml
index cf2b0ec413e..bb05c5454e5 100644
--- a/.github/workflows/cache-cleanup.yml
+++ b/.github/workflows/cache-cleanup.yml
@@ -12,7 +12,7 @@ on:
 
 jobs:
   cleanup:
-    runs-on: ubuntu-latest
+    runs-on: ubuntu-22.04
     steps:
       - name: Cleanup
         run: |
diff --git a/.github/workflows/deny.yml b/.github/workflows/deny.yml
index 8ae7d03e076..11dbc3eef4b 100644
--- a/.github/workflows/deny.yml
+++ b/.github/workflows/deny.yml
@@ -18,7 +18,7 @@ concurrency: deny-${{ github.head_ref || github.run_id }}
 jobs:
   deny:
     name: deny
-    runs-on: ubuntu-latest
+    runs-on: ubuntu-22.04
     steps:
       - uses: actions/checkout@v4
       - uses: EmbarkStudios/cargo-deny-action@v1
diff --git a/.github/workflows/docs-dead-links.yml b/.github/workflows/docs-dead-links.yml
index 40e948fe2c1..b46c5393f8d 100644
--- a/.github/workflows/docs-dead-links.yml
+++ b/.github/workflows/docs-dead-links.yml
@@ -13,7 +13,7 @@ concurrency:
 
 jobs:
   markdown-link-check:
-    runs-on: ubuntu-latest
+    runs-on: ubuntu-22.04
     steps:
     - uses: actions/checkout@master
     - uses: gaurav-nelson/github-action-markdown-link-check@v1
diff --git a/.github/workflows/docs-pr.yml b/.github/workflows/docs-pr.yml
index 9cb6775bfb7..fdd4d25f5ae 100644
--- a/.github/workflows/docs-pr.yml
+++ b/.github/workflows/docs-pr.yml
@@ -5,7 +5,7 @@ on:
 
 jobs:
   add_label:
-    runs-on: ubuntu-latest
+    runs-on: ubuntu-22.04
     outputs:
       has_label: ${{ steps.check-labels.outputs.result }}
     steps:
@@ -49,7 +49,7 @@ jobs:
           }
 
   build_preview:
-    runs-on: ubuntu-latest
+    runs-on: ubuntu-22.04
     steps:
       - name: Checkout code
         uses: actions/checkout@v4
@@ -80,7 +80,7 @@ jobs:
 
       - name: Build docs
         env:
-          MATOMO_ENV: staging # not really a secret, it will show in the footer anyway
+          ENV: staging # not really a secret, it will show in the footer anyway
         run: yarn workspaces foreach -Rpt --from docs run build
 
       - name: Upload artifact
@@ -93,7 +93,7 @@ jobs:
 
   deploy_preview:
     needs: [build_preview, add_label]
-    runs-on: ubuntu-latest
+    runs-on: ubuntu-22.04
     permissions:
       pull-requests: write
     if: needs.add_label.outputs.has_label == 'true'
@@ -121,7 +121,7 @@ jobs:
 
   add_comment:
     needs: [deploy_preview]
-    runs-on: ubuntu-latest
+    runs-on: ubuntu-22.04
     permissions:
       pull-requests: write
     steps:
diff --git a/.github/workflows/formatting.yml b/.github/workflows/formatting.yml
index 08c02af519f..f8ebd53dc70 100644
--- a/.github/workflows/formatting.yml
+++ b/.github/workflows/formatting.yml
@@ -15,18 +15,11 @@ concurrency:
 jobs:
   clippy:
     name: cargo clippy
-    runs-on: ${{ matrix.runner }}
+    runs-on: ubuntu-22.04
     timeout-minutes: 30
     env:
       RUSTFLAGS: -Dwarnings
 
-    strategy:
-      fail-fast: false
-      matrix:
-        include:
-          - runner: ubuntu-latest
-            target: x86_64-unknown-linux-gnu
-
     steps:
       - name: Checkout
         uses: actions/checkout@v4
@@ -34,24 +27,47 @@ jobs:
       - name: Setup toolchain
         uses: dtolnay/rust-toolchain@1.74.1
         with:
-          targets: ${{ matrix.target }}
+          targets: x86_64-unknown-linux-gnu
           components: clippy, rustfmt
 
       - uses: Swatinem/rust-cache@v2
         with:
-          key: ${{ matrix.target }}
+          key: x86_64-unknown-linux-gnu
           cache-on-failure: true
           save-if: ${{ github.event_name != 'merge_group' }}
 
       - name: Run `cargo clippy`
         run: cargo clippy --all-targets --workspace --locked --release
 
+  rustfmt:
+    name: cargo fmt
+    runs-on: ubuntu-22.04
+    timeout-minutes: 30
+    env:
+      RUSTFLAGS: -Dwarnings
+
+    steps:
+      - name: Checkout
+        uses: actions/checkout@v4
+
+      - name: Setup toolchain
+        uses: dtolnay/rust-toolchain@1.74.1
+        with:
+          targets: x86_64-unknown-linux-gnu
+          components: clippy, rustfmt
+
+      - uses: Swatinem/rust-cache@v2
+        with:
+          key: x86_64-unknown-linux-gnu
+          cache-on-failure: true
+          save-if: ${{ github.event_name != 'merge_group' }}
+
       - name: Run `cargo fmt`
         run: cargo fmt --all --check
 
   eslint:
     name: eslint
-    runs-on: ubuntu-latest
+    runs-on: ubuntu-22.04
     timeout-minutes: 30
 
     steps:
@@ -88,7 +104,6 @@ jobs:
         run: |
           mkdir dist
           cp ./target/release/nargo ./dist/nargo
-          7z a -ttar -so -an ./dist/* | 7z a -si ./nargo-x86_64-unknown-linux-gnu.tar.gz
 
       - name: Upload artifact
         uses: actions/upload-artifact@v4
@@ -100,7 +115,7 @@ jobs:
   nargo_fmt:
     needs: [build-nargo]
     name: Nargo fmt
-    runs-on: ubuntu-latest
+    runs-on: ubuntu-22.04
     timeout-minutes: 30
 
     steps:
diff --git a/.github/workflows/gates_report.yml b/.github/workflows/gates_report.yml
deleted file mode 100644
index 0b0a527b69e..00000000000
--- a/.github/workflows/gates_report.yml
+++ /dev/null
@@ -1,94 +0,0 @@
-name: Report gates diff
-
-on:
-  push:
-    branches:
-      - master
-  pull_request:
-
-jobs:
-  build-nargo:
-    runs-on: ubuntu-latest
-    strategy:
-      matrix:
-        target: [x86_64-unknown-linux-gnu]
-
-    steps:
-      - name: Checkout Noir repo
-        uses: actions/checkout@v4
-
-      - name: Setup toolchain
-        uses: dtolnay/rust-toolchain@1.74.1
-
-      - uses: Swatinem/rust-cache@v2
-        with:
-          key: ${{ matrix.target }}
-          cache-on-failure: true
-          save-if: ${{ github.event_name != 'merge_group' }}
-
-      - name: Build Nargo
-        run: cargo build --package nargo_cli --release
-
-      - name: Package artifacts
-        run: |
-          mkdir dist
-          cp ./target/release/nargo ./dist/nargo
-          7z a -ttar -so -an ./dist/* | 7z a -si ./nargo-x86_64-unknown-linux-gnu.tar.gz
-
-      - name: Upload artifact
-        uses: actions/upload-artifact@v4
-        with:
-          name: nargo
-          path: ./dist/*
-          retention-days: 3
-
-
-  compare_gates_reports:
-    needs: [build-nargo]
-    runs-on: ubuntu-latest
-    permissions:
-      pull-requests: write
-
-    steps:
-      - uses: actions/checkout@v4
-
-      - name: Install `bb`
-        run: |
-          ./scripts/install_bb.sh
-          echo "$HOME/.bb/" >> $GITHUB_PATH
-
-      - name: Download nargo binary
-        uses: actions/download-artifact@v4
-        with:
-          name: nargo
-          path: ./nargo
-
-      - name: Set nargo on PATH
-        run: |
-          nargo_binary="${{ github.workspace }}/nargo/nargo"
-          chmod +x $nargo_binary
-          echo "$(dirname $nargo_binary)" >> $GITHUB_PATH
-          export PATH="$PATH:$(dirname $nargo_binary)"
-          nargo -V
-
-      - name: Generate gates report
-        working-directory: ./test_programs
-        run: |
-          ./rebuild.sh
-          ./gates_report.sh
-          mv gates_report.json ../gates_report.json
-      
-      - name: Compare gates reports
-        id: gates_diff
-        uses: noir-lang/noir-gates-diff@1931aaaa848a1a009363d6115293f7b7fc72bb87
-        with:
-          report: gates_report.json
-          summaryQuantile: 0.9 # only display the 10% most significant circuit size diffs in the summary (defaults to 20%)
-
-      - name: Add gates diff to sticky comment
-        if: github.event_name == 'pull_request' || github.event_name == 'pull_request_target'
-        uses: marocchino/sticky-pull-request-comment@v2
-        with:
-          # delete the comment in case changes no longer impact circuit sizes
-          delete: ${{ !steps.gates_diff.outputs.markdown }}
-          message: ${{ steps.gates_diff.outputs.markdown }}
diff --git a/.github/workflows/gates_report_brillig.yml b/.github/workflows/gates_report_brillig.yml
deleted file mode 100644
index e7ec30923f0..00000000000
--- a/.github/workflows/gates_report_brillig.yml
+++ /dev/null
@@ -1,92 +0,0 @@
-name: Report Brillig bytecode size diff
-
-on:
-  push:
-    branches:
-      - master
-  pull_request:
-
-jobs:
-  build-nargo:
-    runs-on: ubuntu-latest
-    strategy:
-      matrix:
-        target: [x86_64-unknown-linux-gnu]
-
-    steps:
-      - name: Checkout Noir repo
-        uses: actions/checkout@v4
-
-      - name: Setup toolchain
-        uses: dtolnay/rust-toolchain@1.74.1
-
-      - uses: Swatinem/rust-cache@v2
-        with:
-          key: ${{ matrix.target }}
-          cache-on-failure: true
-          save-if: ${{ github.event_name != 'merge_group' }}
-
-      - name: Build Nargo
-        run: cargo build --package nargo_cli --release
-
-      - name: Package artifacts
-        run: |
-          mkdir dist
-          cp ./target/release/nargo ./dist/nargo
-          7z a -ttar -so -an ./dist/* | 7z a -si ./nargo-x86_64-unknown-linux-gnu.tar.gz
-
-      - name: Upload artifact
-        uses: actions/upload-artifact@v4
-        with:
-          name: nargo
-          path: ./dist/*
-          retention-days: 3
-
-  compare_brillig_bytecode_size_reports:
-    needs: [build-nargo]
-    runs-on: ubuntu-latest
-    permissions:
-      pull-requests: write
-
-    steps:
-      - uses: actions/checkout@v4
-
-      - name: Download nargo binary
-        uses: actions/download-artifact@v4
-        with:
-          name: nargo
-          path: ./nargo
-
-      - name: Set nargo on PATH
-        run: |
-          nargo_binary="${{ github.workspace }}/nargo/nargo"
-          chmod +x $nargo_binary
-          echo "$(dirname $nargo_binary)" >> $GITHUB_PATH
-          export PATH="$PATH:$(dirname $nargo_binary)"
-          nargo -V
-
-      - name: Generate Brillig bytecode size report
-        working-directory: ./test_programs
-        run: |
-          chmod +x gates_report_brillig.sh
-          ./gates_report_brillig.sh
-          mv gates_report_brillig.json ../gates_report_brillig.json
-
-      - name: Compare Brillig bytecode size reports
-        id: brillig_bytecode_diff
-        uses: noir-lang/noir-gates-diff@d88f7523b013b9edd3f31c5cfddaef87a3fe1b48
-        with:
-          report: gates_report_brillig.json
-          header: |
-            # Changes to Brillig bytecode sizes
-          brillig_report: true
-          summaryQuantile: 0.9 # only display the 10% most significant bytecode size diffs in the summary (defaults to 20%)
-
-      - name: Add bytecode size diff to sticky comment
-        if: github.event_name == 'pull_request' || github.event_name == 'pull_request_target'
-        uses: marocchino/sticky-pull-request-comment@v2
-        with:
-          header: brillig
-          # delete the comment in case changes no longer impact brillig bytecode sizes
-          delete: ${{ !steps.brillig_bytecode_diff.outputs.markdown }}
-          message: ${{ steps.brillig_bytecode_diff.outputs.markdown }}
\ No newline at end of file
diff --git a/.github/workflows/lockfile.yml b/.github/workflows/lockfile.yml
deleted file mode 100644
index 190e01745af..00000000000
--- a/.github/workflows/lockfile.yml
+++ /dev/null
@@ -1,23 +0,0 @@
-name: Lockfile check
-
-on:
-  pull_request:
-  
-# This will cancel previous runs when a branch or PR is updated
-concurrency:
-  group: ${{ github.workflow }}-${{ github.head_ref || github.ref || github.run_id }}
-  cancel-in-progress: true
-
-jobs:
-  yarn-lock:
-    runs-on: ubuntu-latest
-    timeout-minutes: 30
-    
-    steps:
-      - name: Checkout
-        uses: actions/checkout@v4
-
-      # Errors if installation would result in modifications to yarn.lock
-      - name: Install
-        run: yarn --immutable
-        shell: bash
diff --git a/.github/workflows/publish-acvm.yml b/.github/workflows/publish-acvm.yml
index feb4d4216c3..fb2e2001e40 100644
--- a/.github/workflows/publish-acvm.yml
+++ b/.github/workflows/publish-acvm.yml
@@ -10,7 +10,7 @@ on:
 jobs:
   publish:
     name: Publish in order
-    runs-on: ubuntu-latest
+    runs-on: ubuntu-22.04
     steps:
       - name: Checkout sources
         uses: actions/checkout@v4
diff --git a/.github/workflows/publish-docs.yml b/.github/workflows/publish-docs.yml
index 8896e613608..16959256d2a 100644
--- a/.github/workflows/publish-docs.yml
+++ b/.github/workflows/publish-docs.yml
@@ -10,7 +10,7 @@ on:
 jobs:
   publish-docs:
     name: Publish docs
-    runs-on: ubuntu-latest
+    runs-on: ubuntu-22.04
 
     steps:
       - name: Checkout release branch
diff --git a/.github/workflows/publish-es-packages.yml b/.github/workflows/publish-es-packages.yml
index 682fed69c7b..e629ae1f133 100644
--- a/.github/workflows/publish-es-packages.yml
+++ b/.github/workflows/publish-es-packages.yml
@@ -16,7 +16,7 @@ run-name: Publish ES Packages from ${{ inputs.noir-ref }} under @${{ inputs.npm-
 
 jobs:
   build-noirc_abi_wasm:
-    runs-on: ubuntu-latest
+    runs-on: ubuntu-22.04
     steps:
       - name: Checkout Noir repo
         uses: actions/checkout@v4
@@ -50,7 +50,7 @@ jobs:
           retention-days: 10
 
   build-noir_wasm:
-    runs-on: ubuntu-latest
+    runs-on: ubuntu-22.04
     steps:
       - name: Checkout sources
         uses: actions/checkout@v4
@@ -87,7 +87,7 @@ jobs:
           retention-days: 3
 
   build-acvm_js:
-    runs-on: ubuntu-latest
+    runs-on: ubuntu-22.04
     steps:
       - name: Checkout sources
         uses: actions/checkout@v4
@@ -121,7 +121,7 @@ jobs:
           retention-days: 3
           
   publish-es-packages:
-    runs-on: ubuntu-latest
+    runs-on: ubuntu-22.04
     needs: [build-acvm_js, build-noirc_abi_wasm, build-noir_wasm]
     steps:
       - name: Checkout sources
diff --git a/.github/workflows/publish-nargo.yml b/.github/workflows/publish-nargo.yml
index 55ba754e6ae..fa0b6f2d9fb 100644
--- a/.github/workflows/publish-nargo.yml
+++ b/.github/workflows/publish-nargo.yml
@@ -23,7 +23,7 @@ permissions:
 
 jobs:
   build-apple-darwin:
-    runs-on: macos-12
+    runs-on: macos-14
     env:
       CROSS_CONFIG: ${{ github.workspace }}/.github/Cross.toml
       NIGHTLY_RELEASE: ${{ inputs.tag == '' }}
@@ -41,7 +41,7 @@ jobs:
       - name: Setup for Apple Silicon
         if: matrix.target == 'aarch64-apple-darwin'
         run: |
-          sudo xcode-select -s /Applications/Xcode_13.2.1.app/Contents/Developer/
+          sudo xcode-select -s /Applications/Xcode_15.4.0.app/Contents/Developer/
           echo "SDKROOT=$(xcrun -sdk macosx$(sw_vers -productVersion) --show-sdk-path)" >> $GITHUB_ENV
           echo "MACOSX_DEPLOYMENT_TARGET=$(xcrun -sdk macosx$(sw_vers -productVersion) --show-sdk-platform-version)" >> $GITHUB_ENV
 
diff --git a/.github/workflows/publish-nightly.yml b/.github/workflows/publish-nightly.yml
index f5c013883bb..2eef9ab60f7 100644
--- a/.github/workflows/publish-nightly.yml
+++ b/.github/workflows/publish-nightly.yml
@@ -7,7 +7,7 @@ on:
 
 jobs:
   dispatch-publish-es:
-    runs-on: ubuntu-latest
+    runs-on: ubuntu-22.04
     steps:
       - name: Dispatch to publish-nargo
         uses: benc-uk/workflow-dispatch@v1
diff --git a/.github/workflows/pull-request-title.yml b/.github/workflows/pull-request-title.yml
index 7e9b729da28..41922bd32ab 100644
--- a/.github/workflows/pull-request-title.yml
+++ b/.github/workflows/pull-request-title.yml
@@ -15,7 +15,7 @@ permissions:
 jobs:
   conventional-title:
     name: Validate PR title is Conventional Commit
-    runs-on: ubuntu-latest
+    runs-on: ubuntu-22.04
     steps:
       - name: Check title
         if: github.event_name == 'pull_request_target'
@@ -30,7 +30,7 @@ jobs:
 
   force-push-comment:
     name: Warn external contributors about force-pushing
-    runs-on: ubuntu-latest
+    runs-on: ubuntu-22.04
     if: ${{ github.event_name == 'pull_request_target' && github.event.pull_request.head.repo.full_name != 'noir-lang/noir' }} 
     permissions:
       pull-requests: write
diff --git a/.github/workflows/recrawler.yml b/.github/workflows/recrawler.yml
index ee832e273a1..808e5819353 100644
--- a/.github/workflows/recrawler.yml
+++ b/.github/workflows/recrawler.yml
@@ -7,7 +7,7 @@ on:
 jobs:
   algolia_recrawl:
     name: Algolia Recrawl
-    runs-on: ubuntu-latest
+    runs-on: ubuntu-22.04
     steps:
       - name: Algolia crawler creation and crawl
         uses: algolia/algoliasearch-crawler-github-actions@v1.1.0
diff --git a/.github/workflows/release.yml b/.github/workflows/release.yml
index 5124592a3fe..bbe9a7fff62 100644
--- a/.github/workflows/release.yml
+++ b/.github/workflows/release.yml
@@ -11,20 +11,19 @@ jobs:
     outputs:
       release-pr: ${{ steps.release.outputs.pr }}
       tag-name: ${{ steps.release.outputs.tag_name }}
-    runs-on: ubuntu-latest
+    runs-on: ubuntu-22.04
     steps:
       - name: Run release-please
         id: release
-        uses: google-github-actions/release-please-action@v3
+        uses: googleapis/release-please-action@v4
         with:
           token: ${{ secrets.NOIR_RELEASES_TOKEN }}
-          command: manifest
 
   update-acvm-workspace-package-versions:
     name: Update acvm workspace package versions
     needs: [release-please]
     if: ${{ needs.release-please.outputs.release-pr }}
-    runs-on: ubuntu-latest
+    runs-on: ubuntu-22.04
     steps:
       - name: Checkout release branch
         uses: actions/checkout@v4
@@ -67,7 +66,7 @@ jobs:
     name: Update docs
     needs: [release-please, update-acvm-workspace-package-versions]
     if: ${{ needs.release-please.outputs.release-pr }}
-    runs-on: ubuntu-latest
+    runs-on: ubuntu-22.04
  
     steps:
       - name: Checkout release branch
@@ -111,7 +110,7 @@ jobs:
 
   release-end:
     name: Release End
-    runs-on: ubuntu-latest
+    runs-on: ubuntu-22.04
     # We want this job to always run (even if the dependant jobs fail) as we need apply changes to the sticky comment.
     if: ${{ always() }}
     
@@ -146,7 +145,7 @@ jobs:
     name: Build binaries
     needs: [release-please]
     if: ${{ needs.release-please.outputs.tag-name }}
-    runs-on: ubuntu-latest
+    runs-on: ubuntu-22.04
     steps:
       - name: Dispatch to publish workflow
         uses: benc-uk/workflow-dispatch@v1
@@ -161,7 +160,7 @@ jobs:
     name: Publish ES packages
     needs: [release-please]
     if: ${{ needs.release-please.outputs.tag-name }}
-    runs-on: ubuntu-latest
+    runs-on: ubuntu-22.04
     steps:
       - name: Dispatch to publish-es-packages
         uses: benc-uk/workflow-dispatch@v1
@@ -175,7 +174,7 @@ jobs:
     name: Publish acvm
     needs: [release-please]
     if: ${{ needs.release-please.outputs.tag-name }}
-    runs-on: ubuntu-latest
+    runs-on: ubuntu-22.04
     
     steps:
       - name: Dispatch to publish-acvm
diff --git a/.github/workflows/reports.yml b/.github/workflows/reports.yml
new file mode 100644
index 00000000000..0a03add8338
--- /dev/null
+++ b/.github/workflows/reports.yml
@@ -0,0 +1,492 @@
+name: Reports
+
+on:
+  push:
+    branches:
+      - master
+  pull_request:
+
+jobs:
+  build-nargo:
+    runs-on: ubuntu-22.04
+
+    steps:
+      - name: Checkout Noir repo
+        uses: actions/checkout@v4
+
+      - name: Setup toolchain
+        uses: dtolnay/rust-toolchain@1.74.1
+
+      - uses: Swatinem/rust-cache@v2
+        with:
+          key: x86_64-unknown-linux-gnu
+          cache-on-failure: true
+          save-if: ${{ github.event_name != 'merge_group' }}
+
+      - name: Build Nargo
+        run: cargo build --package nargo_cli --release
+
+      - name: Package artifacts
+        run: |
+          mkdir dist
+          cp ./target/release/nargo ./dist/nargo
+
+      - name: Upload artifact
+        uses: actions/upload-artifact@v4
+        with:
+          name: nargo
+          path: ./dist/*
+          retention-days: 3
+
+  compare_gates_reports:
+    name: Circuit sizes
+    needs: [build-nargo]
+    runs-on: ubuntu-22.04
+    permissions:
+      pull-requests: write
+
+    steps:
+      - uses: actions/checkout@v4
+
+      - name: Install `bb`
+        run: |
+          ./scripts/install_bb.sh
+          echo "$HOME/.bb/" >> $GITHUB_PATH
+
+      - name: Download nargo binary
+        uses: actions/download-artifact@v4
+        with:
+          name: nargo
+          path: ./nargo
+
+      - name: Set nargo on PATH
+        run: |
+          nargo_binary="${{ github.workspace }}/nargo/nargo"
+          chmod +x $nargo_binary
+          echo "$(dirname $nargo_binary)" >> $GITHUB_PATH
+          export PATH="$PATH:$(dirname $nargo_binary)"
+          nargo -V
+
+      - name: Generate gates report
+        working-directory: ./test_programs
+        run: |
+          ./rebuild.sh
+          ./gates_report.sh
+          mv gates_report.json ../gates_report.json
+      
+      - name: Compare gates reports
+        id: gates_diff
+        uses: noir-lang/noir-gates-diff@1931aaaa848a1a009363d6115293f7b7fc72bb87
+        with:
+          report: gates_report.json
+          summaryQuantile: 0.9 # only display the 10% most significant circuit size diffs in the summary (defaults to 20%)
+
+      - name: Add gates diff to sticky comment
+        if: github.event_name == 'pull_request' || github.event_name == 'pull_request_target'
+        uses: marocchino/sticky-pull-request-comment@v2
+        with:
+          # delete the comment in case changes no longer impact circuit sizes
+          delete: ${{ !steps.gates_diff.outputs.markdown }}
+          message: ${{ steps.gates_diff.outputs.markdown }}
+
+  compare_brillig_bytecode_size_reports:
+    name: Brillig bytecode sizes
+    needs: [build-nargo]
+    runs-on: ubuntu-22.04
+    permissions:
+      pull-requests: write
+
+    steps:
+      - uses: actions/checkout@v4
+
+      - name: Download nargo binary
+        uses: actions/download-artifact@v4
+        with:
+          name: nargo
+          path: ./nargo
+
+      - name: Set nargo on PATH
+        run: |
+          nargo_binary="${{ github.workspace }}/nargo/nargo"
+          chmod +x $nargo_binary
+          echo "$(dirname $nargo_binary)" >> $GITHUB_PATH
+          export PATH="$PATH:$(dirname $nargo_binary)"
+          nargo -V
+
+      - name: Generate Brillig bytecode size report
+        working-directory: ./test_programs
+        run: |
+          ./gates_report_brillig.sh
+          mv gates_report_brillig.json ../gates_report_brillig.json
+
+      - name: Compare Brillig bytecode size reports
+        id: brillig_bytecode_diff
+        uses: noir-lang/noir-gates-diff@d88f7523b013b9edd3f31c5cfddaef87a3fe1b48
+        with:
+          report: gates_report_brillig.json
+          header: |
+            # Changes to Brillig bytecode sizes
+          brillig_report: true
+          summaryQuantile: 0.9 # only display the 10% most significant bytecode size diffs in the summary (defaults to 20%)
+
+      - name: Add bytecode size diff to sticky comment
+        if: github.event_name == 'pull_request' || github.event_name == 'pull_request_target'
+        uses: marocchino/sticky-pull-request-comment@v2
+        with:
+          header: brillig
+          # delete the comment in case changes no longer impact brillig bytecode sizes
+          delete: ${{ !steps.brillig_bytecode_diff.outputs.markdown }}
+          message: ${{ steps.brillig_bytecode_diff.outputs.markdown }}
+
+  compare_brillig_execution_reports:
+    name: Brillig execution trace sizes  
+    needs: [build-nargo]
+    runs-on: ubuntu-22.04
+    permissions:
+      pull-requests: write
+
+    steps:
+      - uses: actions/checkout@v4
+
+      - name: Download nargo binary
+        uses: actions/download-artifact@v4
+        with:
+          name: nargo
+          path: ./nargo
+
+      - name: Set nargo on PATH
+        run: |
+          nargo_binary="${{ github.workspace }}/nargo/nargo"
+          chmod +x $nargo_binary
+          echo "$(dirname $nargo_binary)" >> $GITHUB_PATH
+          export PATH="$PATH:$(dirname $nargo_binary)"
+          nargo -V
+
+      - name: Generate Brillig execution report
+        working-directory: ./test_programs
+        run: |
+          ./gates_report_brillig_execution.sh
+          mv gates_report_brillig_execution.json ../gates_report_brillig_execution.json
+
+      - name: Compare Brillig execution reports
+        id: brillig_execution_diff
+        uses: noir-lang/noir-gates-diff@d88f7523b013b9edd3f31c5cfddaef87a3fe1b48
+        with:
+          report: gates_report_brillig_execution.json
+          header: |
+            # Changes to number of Brillig opcodes executed
+          brillig_report: true
+          summaryQuantile: 0.9 # only display the 10% most significant bytecode size diffs in the summary (defaults to 20%)
+
+      - name: Add bytecode size diff to sticky comment
+        if: github.event_name == 'pull_request' || github.event_name == 'pull_request_target'
+        uses: marocchino/sticky-pull-request-comment@v2
+        with:
+          header: brillig_execution
+          # delete the comment in case changes no longer impact brillig bytecode sizes
+          delete: ${{ !steps.brillig_execution_diff.outputs.markdown }}
+          message: ${{ steps.brillig_execution_diff.outputs.markdown }}
+
+  generate_memory_report:
+    name: Peak memory usage  
+    needs: [build-nargo]
+    runs-on: ubuntu-22.04
+    permissions:
+      pull-requests: write
+
+    steps:
+      - uses: actions/checkout@v4
+
+      - name: Download nargo binary
+        uses: actions/download-artifact@v4
+        with:
+          name: nargo
+          path: ./nargo
+
+      - name: Set nargo on PATH
+        run: |
+          nargo_binary="${{ github.workspace }}/nargo/nargo"
+          chmod +x $nargo_binary
+          echo "$(dirname $nargo_binary)" >> $GITHUB_PATH
+          export PATH="$PATH:$(dirname $nargo_binary)"
+          nargo -V
+
+      - name: Generate Memory report
+        working-directory: ./test_programs
+        run: |
+          ./memory_report.sh
+          mv memory_report.json ../memory_report.json
+
+      - name: Upload memory report
+        uses: actions/upload-artifact@v4
+        with:
+          name: in_progress_memory_report
+          path: memory_report.json
+          retention-days: 3
+          overwrite: true
+
+  generate_compilation_report:
+    name: Compilation time
+    needs: [build-nargo]
+    runs-on: ubuntu-22.04
+    permissions:
+      pull-requests: write
+
+    steps:
+      - uses: actions/checkout@v4
+
+      - name: Download nargo binary
+        uses: actions/download-artifact@v4
+        with:
+          name: nargo
+          path: ./nargo
+
+      - name: Set nargo on PATH
+        run: |
+          nargo_binary="${{ github.workspace }}/nargo/nargo"
+          chmod +x $nargo_binary
+          echo "$(dirname $nargo_binary)" >> $GITHUB_PATH
+          export PATH="$PATH:$(dirname $nargo_binary)"
+          nargo -V
+
+      - name: Generate Compilation report
+        working-directory: ./test_programs
+        run: |
+          ./compilation_report.sh
+          cat compilation_report.json
+          mv compilation_report.json ../compilation_report.json
+
+      - name: Upload compilation report
+        uses: actions/upload-artifact@v4
+        with:
+          name: in_progress_compilation_report
+          path: compilation_report.json
+          retention-days: 3
+          overwrite: true
+
+  external_repo_compilation_report:
+    needs: [build-nargo]
+    runs-on: ubuntu-latest
+    timeout-minutes: 15
+    strategy:
+      fail-fast: false
+      matrix:
+        include:
+          - project: { repo: AztecProtocol/aztec-packages, path: noir-projects/noir-contracts }
+          - project: { repo: AztecProtocol/aztec-packages, path: noir-projects/noir-protocol-circuits/crates/parity-root }
+          - project: { repo: AztecProtocol/aztec-packages, path: noir-projects/noir-protocol-circuits/crates/private-kernel-inner }
+          - project: { repo: AztecProtocol/aztec-packages, path: noir-projects/noir-protocol-circuits/crates/private-kernel-tail }
+          - project: { repo: AztecProtocol/aztec-packages, path: noir-projects/noir-protocol-circuits/crates/private-kernel-reset }
+          - project: { repo: AztecProtocol/aztec-packages, path: noir-projects/noir-protocol-circuits/crates/rollup-base-private }
+          - project: { repo: AztecProtocol/aztec-packages, path: noir-projects/noir-protocol-circuits/crates/rollup-base-public }
+
+    name: External repo compilation report - ${{ matrix.project.repo }}/${{ matrix.project.path }}
+    steps:
+      - name: Download nargo binary
+        uses: actions/download-artifact@v4
+        with:
+          name: nargo
+          path: ./nargo
+
+      - name: Set nargo on PATH
+        run: |
+          nargo_binary="${{ github.workspace }}/nargo/nargo"
+          chmod +x $nargo_binary
+          echo "$(dirname $nargo_binary)" >> $GITHUB_PATH
+          export PATH="$PATH:$(dirname $nargo_binary)"
+          nargo -V
+
+      - uses: actions/checkout@v4
+        with:
+          path: scripts
+          sparse-checkout: |
+            test_programs/compilation_report.sh
+          sparse-checkout-cone-mode: false
+
+      - name: Checkout
+        uses: actions/checkout@v4
+        with:
+          repository: ${{ matrix.project.repo }}
+          path: test-repo
+          ref: ${{ matrix.project.ref }}
+
+      - name: Generate compilation report
+        working-directory: ./test-repo/${{ matrix.project.path }}
+        run: |
+          mv /home/runner/work/noir/noir/scripts/test_programs/compilation_report.sh ./compilation_report.sh
+          chmod +x ./compilation_report.sh
+          ./compilation_report.sh 1
+
+      - name: Move compilation report
+        id: report
+        shell: bash
+        run: |
+          PACKAGE_NAME=${{ matrix.project.path }}
+          PACKAGE_NAME=$(basename $PACKAGE_NAME)
+          mv ./test-repo/${{ matrix.project.path }}/compilation_report.json ./compilation_report_$PACKAGE_NAME.json
+          echo "compilation_report_name=$PACKAGE_NAME" >> $GITHUB_OUTPUT
+
+      - name: Upload compilation report
+        uses: actions/upload-artifact@v4
+        with:
+          name: compilation_report_${{ steps.report.outputs.compilation_report_name }}
+          path: compilation_report_${{ steps.report.outputs.compilation_report_name }}.json
+          retention-days: 3
+          overwrite: true
+
+  upload_compilation_report:
+    name: Upload compilation report 
+    needs: [generate_compilation_report, external_repo_compilation_report]
+    # We want this job to run even if one variation of the matrix in `external_repo_compilation_report` fails
+    if: always() 
+    runs-on: ubuntu-latest
+    permissions:
+      pull-requests: write
+
+    steps:
+      - uses: actions/checkout@v4
+
+      - name: Download initial compilation report
+        uses: actions/download-artifact@v4
+        with:
+          name: in_progress_compilation_report
+
+      - name: Download matrix compilation reports
+        uses: actions/download-artifact@v4
+        with:
+          pattern: compilation_report_*
+          path: ./reports
+
+      - name: Merge compilation reports using jq
+        run: |
+          mv ./.github/scripts/merge-bench-reports.sh merge-bench-reports.sh
+          ./merge-bench-reports.sh compilation_report
+
+      - name: Parse compilation report
+        id: compilation_report
+        uses: noir-lang/noir-bench-report@0d7464a8c39170523932d7846b6e6b458a294aea
+        with:
+          report: compilation_report.json
+          header: |
+            # Compilation Report
+          memory_report: false
+
+      - name: Add memory report to sticky comment
+        if: github.event_name == 'pull_request' || github.event_name == 'pull_request_target'
+        uses: marocchino/sticky-pull-request-comment@v2
+        with:
+          header: compilation
+          message: ${{ steps.compilation_report.outputs.markdown }}
+
+  external_repo_memory_report:
+    needs: [build-nargo]
+    runs-on: ubuntu-latest
+    timeout-minutes: 30
+    strategy:
+      fail-fast: false
+      matrix:
+        include:
+          # TODO: Bring this report back under a flag. The `noir-contracts` report takes just under 30 minutes.
+          # - project: { repo: AztecProtocol/aztec-packages, path: noir-projects/noir-contracts }
+          - project: { repo: AztecProtocol/aztec-packages, path: noir-projects/noir-protocol-circuits/crates/parity-root }
+          - project: { repo: AztecProtocol/aztec-packages, path: noir-projects/noir-protocol-circuits/crates/private-kernel-inner }
+          - project: { repo: AztecProtocol/aztec-packages, path: noir-projects/noir-protocol-circuits/crates/private-kernel-reset }
+          - project: { repo: AztecProtocol/aztec-packages, path: noir-projects/noir-protocol-circuits/crates/private-kernel-tail }
+
+    name: External repo memory report - ${{ matrix.project.repo }}/${{ matrix.project.path }}
+    steps:
+      - name: Download nargo binary
+        uses: actions/download-artifact@v4
+        with:
+          name: nargo
+          path: ./nargo
+
+      - name: Set nargo on PATH
+        run: |
+          nargo_binary="${{ github.workspace }}/nargo/nargo"
+          chmod +x $nargo_binary
+          echo "$(dirname $nargo_binary)" >> $GITHUB_PATH
+          export PATH="$PATH:$(dirname $nargo_binary)"
+          nargo -V
+
+      - uses: actions/checkout@v4
+        with:
+          path: scripts
+          sparse-checkout: |
+            test_programs/memory_report.sh
+          sparse-checkout-cone-mode: false
+
+      - name: Checkout
+        uses: actions/checkout@v4
+        with:
+          repository: ${{ matrix.project.repo }}
+          path: test-repo
+          ref: ${{ matrix.project.ref }}
+
+      - name: Generate compilation report
+        working-directory: ./test-repo/${{ matrix.project.path }}
+        run: |
+          mv /home/runner/work/noir/noir/scripts/test_programs/memory_report.sh ./memory_report.sh
+          chmod +x ./memory_report.sh
+          ./memory_report.sh 1
+
+      - name: Move compilation report
+        id: report
+        shell: bash
+        run: |
+          PACKAGE_NAME=${{ matrix.project.path }}
+          PACKAGE_NAME=$(basename $PACKAGE_NAME)
+          mv ./test-repo/${{ matrix.project.path }}/memory_report.json ./memory_report_$PACKAGE_NAME.json
+          echo "memory_report_name=$PACKAGE_NAME" >> $GITHUB_OUTPUT
+
+      - name: Upload memory report
+        uses: actions/upload-artifact@v4
+        with:
+          name: memory_report_${{ steps.report.outputs.memory_report_name }}
+          path: memory_report_${{ steps.report.outputs.memory_report_name }}.json
+          retention-days: 3
+          overwrite: true
+
+  upload_memory_report:
+    name: Upload memory report 
+    needs: [generate_memory_report, external_repo_memory_report]
+    # We want this job to run even if one variation of the matrix in `external_repo_memory_report` fails
+    if: always() 
+    runs-on: ubuntu-latest
+    permissions:
+      pull-requests: write
+
+    steps:
+      - uses: actions/checkout@v4
+
+      - name: Download initial memory report
+        uses: actions/download-artifact@v4
+        with:
+          name: in_progress_memory_report
+
+      - name: Download matrix memory reports
+        uses: actions/download-artifact@v4
+        with:
+          pattern: memory_report_*
+          path: ./reports
+
+      - name: Merge memory reports using jq
+        run: |
+          mv ./.github/scripts/merge-bench-reports.sh merge-bench-reports.sh
+          ./merge-bench-reports.sh memory_report
+
+      - name: Parse memory report
+        id: memory_report
+        uses: noir-lang/noir-bench-report@0d7464a8c39170523932d7846b6e6b458a294aea
+        with:
+          report: memory_report.json
+          header: |
+            # Memory Report
+          memory_report: true
+
+      - name: Add memory report to sticky comment
+        if: github.event_name == 'pull_request' || github.event_name == 'pull_request_target'
+        uses: marocchino/sticky-pull-request-comment@v2
+        with:
+          header: memory
+          message: ${{ steps.memory_report.outputs.markdown }}
diff --git a/.github/workflows/spellcheck.yml b/.github/workflows/spellcheck.yml
index 83d67325775..2b9a1461231 100644
--- a/.github/workflows/spellcheck.yml
+++ b/.github/workflows/spellcheck.yml
@@ -10,7 +10,7 @@ concurrency:
 jobs:
   code:
     name: Code
-    runs-on: ubuntu-latest
+    runs-on: ubuntu-22.04
     steps:
       - name: Checkout sources
         uses: actions/checkout@v4
@@ -25,7 +25,7 @@ jobs:
 
   docs:
     name: Documentation
-    runs-on: ubuntu-latest
+    runs-on: ubuntu-22.04
     steps:
       - name: Checkout sources
         uses: actions/checkout@v4
diff --git a/.github/workflows/test-js-packages.yml b/.github/workflows/test-js-packages.yml
index ff894f061ee..dde0deed0cf 100644
--- a/.github/workflows/test-js-packages.yml
+++ b/.github/workflows/test-js-packages.yml
@@ -13,6 +13,19 @@ concurrency:
   cancel-in-progress: true
 
 jobs:
+  yarn-lock:
+    runs-on: ubuntu-22.04
+    timeout-minutes: 30
+    
+    steps:
+      - name: Checkout
+        uses: actions/checkout@v4
+
+      # Errors if installation would result in modifications to yarn.lock
+      - name: Install
+        run: yarn --immutable
+        shell: bash
+
   build-nargo:
     runs-on: ubuntu-22.04
     timeout-minutes: 30
@@ -47,7 +60,7 @@ jobs:
           retention-days: 3
 
   build-noirc-abi:
-    runs-on: ubuntu-latest
+    runs-on: ubuntu-22.04
     timeout-minutes: 30
 
     steps:
@@ -73,14 +86,13 @@ jobs:
         uses: actions/upload-artifact@v4
         with:
           name: noirc_abi_wasm
-          path: | 
+          path: |
             ./tooling/noirc_abi_wasm/nodejs
             ./tooling/noirc_abi_wasm/web
           retention-days: 10
 
-
   build-noir-wasm:
-    runs-on: ubuntu-latest
+    runs-on: ubuntu-22.04
     timeout-minutes: 30
 
     steps:
@@ -115,7 +127,7 @@ jobs:
           retention-days: 3
 
   build-acvm-js:
-    runs-on: ubuntu-latest
+    runs-on: ubuntu-22.04
     timeout-minutes: 30
 
     steps:
@@ -149,7 +161,7 @@ jobs:
   test-acvm_js-node:
     needs: [build-acvm-js]
     name: ACVM JS (Node.js)
-    runs-on: ubuntu-latest
+    runs-on: ubuntu-22.04
     timeout-minutes: 30
 
     steps:
@@ -171,7 +183,7 @@ jobs:
   test-acvm_js-browser:
     needs: [build-acvm-js]
     name: ACVM JS (Browser)
-    runs-on: ubuntu-latest
+    runs-on: ubuntu-22.04
     timeout-minutes: 30
 
     steps:
@@ -196,7 +208,7 @@ jobs:
   test-noirc-abi:
     needs: [build-noirc-abi]
     name: noirc_abi
-    runs-on: ubuntu-latest
+    runs-on: ubuntu-22.04
     timeout-minutes: 30
 
     steps:
@@ -224,7 +236,7 @@ jobs:
   test-noir-js:
     needs: [build-nargo, build-acvm-js, build-noirc-abi]
     name: Noir JS
-    runs-on: ubuntu-latest
+    runs-on: ubuntu-22.04
     timeout-minutes: 30
 
     steps:
@@ -263,9 +275,6 @@ jobs:
       - name: Build noir_js_types
         run: yarn workspace @noir-lang/types build
 
-      - name: Build barretenberg wrapper
-        run: yarn workspace @noir-lang/backend_barretenberg build
-
       - name: Run noir_js tests
         run: |
           yarn workspace @noir-lang/noir_js build
@@ -274,7 +283,7 @@ jobs:
   test-noir-wasm:
     needs: [build-noir-wasm, build-nargo]
     name: noir_wasm
-    runs-on: ubuntu-latest
+    runs-on: ubuntu-22.04
     timeout-minutes: 30
 
     steps:
@@ -318,7 +327,7 @@ jobs:
   test-noir-codegen:
     needs: [build-acvm-js, build-noirc-abi, build-nargo]
     name: noir_codegen
-    runs-on: ubuntu-latest
+    runs-on: ubuntu-22.04
     timeout-minutes: 30
 
     steps:
@@ -365,7 +374,7 @@ jobs:
 
   test-integration-node:
     name: Integration Tests (Node)
-    runs-on: ubuntu-latest
+    runs-on: ubuntu-22.04
     needs: [build-acvm-js, build-noir-wasm, build-nargo, build-noirc-abi]
     timeout-minutes: 30
 
@@ -416,7 +425,7 @@ jobs:
       - name: Setup `integration-tests`
         run: |
           # Note the lack of spaces between package names.
-          PACKAGES_TO_BUILD="@noir-lang/types,@noir-lang/backend_barretenberg,@noir-lang/noir_js"
+          PACKAGES_TO_BUILD="@noir-lang/types,@noir-lang/noir_js"
           yarn workspaces foreach -vtp --from "{$PACKAGES_TO_BUILD}" run build
 
       - name: Run `integration-tests`
@@ -426,7 +435,7 @@ jobs:
 
   test-integration-browser:
     name: Integration Tests (Browser)
-    runs-on: ubuntu-latest
+    runs-on: ubuntu-22.04
     needs: [build-acvm-js, build-noir-wasm, build-noirc-abi]
     timeout-minutes: 30
 
@@ -461,7 +470,7 @@ jobs:
       - name: Setup `integration-tests`
         run: |
           # Note the lack of spaces between package names.
-          PACKAGES_TO_BUILD="@noir-lang/types,@noir-lang/backend_barretenberg,@noir-lang/noir_js"
+          PACKAGES_TO_BUILD="@noir-lang/types,@noir-lang/noir_js"
           yarn workspaces foreach -vtp --from "{$PACKAGES_TO_BUILD}" run build
 
       - name: Run `integration-tests`
@@ -471,7 +480,7 @@ jobs:
 
   test-examples:
     name: Example scripts
-    runs-on: ubuntu-latest
+    runs-on: ubuntu-22.04
     needs: [build-nargo]
     timeout-minutes: 30
 
@@ -481,6 +490,9 @@ jobs:
 
       - name: Install Foundry
         uses: foundry-rs/foundry-toolchain@v1.2.0
+        with:
+          version: nightly-8660e5b941fe7f4d67e246cfd3dafea330fb53b1
+          
 
       - name: Install `bb`
         run: |
@@ -509,23 +521,45 @@ jobs:
         working-directory: ./examples/codegen_verifier
         run: ./test.sh
 
+  critical-library-list:
+    name: Load critical library list
+    runs-on: ubuntu-22.04
+    outputs:
+      libraries: ${{ steps.get_critical_libraries.outputs.libraries }}
+
+    steps:
+      - name: Checkout
+        uses: actions/checkout@v4
+   
+      - name: Build list of libraries
+        id: get_critical_libraries
+        run: |         
+          LIBRARIES=$(grep -Po "^https://github.com/\K.+"  ./CRITICAL_NOIR_LIBRARIES | jq -R -s -c 'split("\n") | map(select(. != "")) | map({ repo: ., path: ""})')
+          echo "libraries=$LIBRARIES"
+          echo "libraries=$LIBRARIES" >> $GITHUB_OUTPUT
+        env:
+          GH_TOKEN: ${{ github.token }}
+
   external-repo-checks:
-    needs: [build-nargo]
-    runs-on: ubuntu-latest
+    needs: [build-nargo, critical-library-list]
+    runs-on: ubuntu-22.04
     # Only run when 'run-external-checks' label is present
     if: contains(github.event.pull_request.labels.*.name, 'run-external-checks')
     timeout-minutes: 30
     strategy:
       fail-fast: false
       matrix:
-        project:
-        # Disabled as these are currently failing with many visibility errors
-        - { repo: AztecProtocol/aztec-nr, path: ./ }
-        - { repo: AztecProtocol/aztec-packages, path: ./noir-projects/noir-contracts }
-        # Disabled as aztec-packages requires a setup-step in order to generate a `Nargo.toml`
-        #- { repo: AztecProtocol/aztec-packages, path: ./noir-projects/noir-protocol-circuits }
-        - { repo: zac-williamson/noir-edwards, path: ./, ref: 037e44b2ee8557c51f6aef9bb9d63ea9e32722d1  }
-    name: Check external repo - ${{ matrix.project.repo }}
+        project: ${{ fromJson( needs.critical-library-list.outputs.libraries )}}
+        include:
+          - project: { repo: AztecProtocol/aztec-packages, path: noir-projects/aztec-nr }
+          - project: { repo: AztecProtocol/aztec-packages, path: noir-projects/noir-contracts }
+          - project: { repo: AztecProtocol/aztec-packages, path: noir-projects/noir-protocol-circuits/crates/parity-lib }
+          - project: { repo: AztecProtocol/aztec-packages, path: noir-projects/noir-protocol-circuits/crates/private-kernel-lib }
+          - project: { repo: AztecProtocol/aztec-packages, path: noir-projects/noir-protocol-circuits/crates/reset-kernel-lib }
+          - project: { repo: AztecProtocol/aztec-packages, path: noir-projects/noir-protocol-circuits/crates/rollup-lib }
+          - project: { repo: AztecProtocol/aztec-packages, path: noir-projects/noir-protocol-circuits/crates/types }
+
+    name: Check external repo - ${{ matrix.project.repo }}/${{ matrix.project.path }}
     steps:
       - name: Checkout
         uses: actions/checkout@v4
@@ -554,18 +588,22 @@ jobs:
           # Github actions seems to not expand "**" in globs by default.
           shopt -s globstar
           sed -i '/^compiler_version/d' ./**/Nargo.toml
-      - name: Run nargo check
+      
+      - name: Run nargo test
         working-directory: ./test-repo/${{ matrix.project.path }}
-        run: nargo check
+        run: nargo test -q --silence-warnings
+        env:
+          NARGO_IGNORE_TEST_FAILURES_FROM_FOREIGN_CALLS: true
 
   # This is a job which depends on all test jobs and reports the overall status.
   # This allows us to add/remove test jobs without having to update the required workflows.
   tests-end:
     name: End
-    runs-on: ubuntu-latest
+    runs-on: ubuntu-22.04
     # We want this job to always run (even if the dependant jobs fail) as we want this job to fail rather than skipping.
     if: ${{ always() }}
-    needs: 
+    needs:
+      - yarn-lock
       - test-acvm_js-node
       - test-acvm_js-browser
       - test-noirc-abi
diff --git a/.github/workflows/test-rust-workspace-msrv.yml b/.github/workflows/test-rust-workspace-msrv.yml
index ae016169830..6fd71eb56a2 100644
--- a/.github/workflows/test-rust-workspace-msrv.yml
+++ b/.github/workflows/test-rust-workspace-msrv.yml
@@ -21,7 +21,7 @@ concurrency:
 jobs:
   build-test-artifacts:
     name: Build test artifacts
-    runs-on: ubuntu-latest
+    runs-on: ubuntu-22.04
     timeout-minutes: 30
 
     steps:
@@ -62,7 +62,7 @@ jobs:
 
   run-tests:
     name: "Run tests (partition ${{matrix.partition}})"
-    runs-on: ubuntu-latest
+    runs-on: ubuntu-22.04
     needs: [build-test-artifacts]
     strategy:
       fail-fast: false
@@ -87,6 +87,7 @@ jobs:
           name: nextest-archive
       - name: Run tests
         run: |
+          RUST_MIN_STACK=8388608 \
           cargo nextest run --archive-file nextest-archive.tar.zst \
             --partition count:${{ matrix.partition }}/4 \
             --no-fail-fast
@@ -95,7 +96,7 @@ jobs:
   # This allows us to add/remove test jobs without having to update the required workflows.
   tests-end:
     name: Rust End
-    runs-on: ubuntu-latest
+    runs-on: ubuntu-22.04
     # We want this job to always run (even if the dependant jobs fail) as we want this job to fail rather than skipping.
     if: ${{ always() }}
     needs: 
diff --git a/.github/workflows/test-rust-workspace.yml b/.github/workflows/test-rust-workspace.yml
index 1f3ee5e2268..1514270ff56 100644
--- a/.github/workflows/test-rust-workspace.yml
+++ b/.github/workflows/test-rust-workspace.yml
@@ -15,7 +15,7 @@ concurrency:
 jobs:
   build-test-artifacts:
     name: Build test artifacts
-    runs-on: ubuntu-latest
+    runs-on: ubuntu-22.04
     timeout-minutes: 30
 
     steps:
@@ -49,7 +49,7 @@ jobs:
 
   run-tests:
     name: "Run tests (partition ${{matrix.partition}})"
-    runs-on: ubuntu-latest
+    runs-on: ubuntu-22.04
     needs: [build-test-artifacts]
     strategy:
       fail-fast: false
@@ -74,6 +74,7 @@ jobs:
           name: nextest-archive
       - name: Run tests
         run: |
+          RUST_MIN_STACK=8388608 \
           cargo nextest run --archive-file nextest-archive.tar.zst \
             --partition count:${{ matrix.partition }}/4 \
             --no-fail-fast
@@ -82,7 +83,7 @@ jobs:
   # This allows us to add/remove test jobs without having to update the required workflows.
   tests-end:
     name: Rust End
-    runs-on: ubuntu-latest
+    runs-on: ubuntu-22.04
     # We want this job to always run (even if the dependant jobs fail) as we want this job to fail rather than skipping.
     if: ${{ always() }}
     needs: 
diff --git a/.gitignore b/.gitignore
index aeb7d8757c4..8442d688fbf 100644
--- a/.gitignore
+++ b/.gitignore
@@ -34,6 +34,8 @@ tooling/noir_js/lib
 
 gates_report.json
 gates_report_brillig.json
+gates_report_brillig_execution.json
+compilation_report.json
 
 # Github Actions scratch space
 # This gives a location to download artifacts into the repository in CI without making git dirty.
diff --git a/.release-please-manifest.json b/.release-please-manifest.json
index 8be8ad41ac0..b5c8da729e3 100644
--- a/.release-please-manifest.json
+++ b/.release-please-manifest.json
@@ -1,4 +1,3 @@
 {
-  ".": "0.34.0",
-  "acvm-repo": "0.50.0"
+  ".": "1.0.0-beta.0"
 }
diff --git a/CHANGELOG.md b/CHANGELOG.md
index 9779d7ab964..19d36b885ed 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -1,5 +1,377 @@
 # Changelog
 
+## [1.0.0-beta.0](https://github.com/noir-lang/noir/compare/v0.39.0...v1.0.0-beta.0) (2024-11-22)
+
+
+### ⚠ BREAKING CHANGES
+
+* Require types of globals to be specified ([#6592](https://github.com/noir-lang/noir/issues/6592))
+* remove eddsa from stdlib ([#6591](https://github.com/noir-lang/noir/issues/6591))
+
+### Features
+
+* Add `array_refcount` and `slice_refcount` builtins for debugging ([#6584](https://github.com/noir-lang/noir/issues/6584)) ([45eb756](https://github.com/noir-lang/noir/commit/45eb7568d56b2d254453b85f236d554232aa5df9))
+* Avoid incrementing reference counts in some cases ([#6568](https://github.com/noir-lang/noir/issues/6568)) ([01c4a9f](https://github.com/noir-lang/noir/commit/01c4a9fb62ffe2190c73f0d5b12933d2eb8f6b5d))
+* **ssa:** Loop invariant code motion ([#6563](https://github.com/noir-lang/noir/issues/6563)) ([7216f08](https://github.com/noir-lang/noir/commit/7216f0829dcece948d3243471e6d57380522e997))
+* Trait aliases ([#6431](https://github.com/noir-lang/noir/issues/6431)) ([68c32b4](https://github.com/noir-lang/noir/commit/68c32b4ffd9b069fe4b119327dbf4018c17ab9d4))
+* Try to inline brillig calls with all constant arguments  ([#6548](https://github.com/noir-lang/noir/issues/6548)) ([e4c66b9](https://github.com/noir-lang/noir/commit/e4c66b91d42b20d17837fe5e7c32c9a83b6ab354))
+
+
+### Bug Fixes
+
+* Consider prereleases to be compatible with pre-1.0.0 releases ([#6580](https://github.com/noir-lang/noir/issues/6580)) ([013e200](https://github.com/noir-lang/noir/commit/013e2000f1d7e7346b5cac0427732d545f501444))
+* Correct type when simplifying `derive_pedersen_generators` ([#6579](https://github.com/noir-lang/noir/issues/6579)) ([efa5cc4](https://github.com/noir-lang/noir/commit/efa5cc4bf173b0ce49f47b1954165a2bdb276792))
+* Don't report visibility errors when elaborating comptime value ([#6498](https://github.com/noir-lang/noir/issues/6498)) ([3c361c9](https://github.com/noir-lang/noir/commit/3c361c9f78a5d9de1b1bcb5a839d3bc481f89898))
+* Parse a bit more SSA stuff ([#6599](https://github.com/noir-lang/noir/issues/6599)) ([0a6207d](https://github.com/noir-lang/noir/commit/0a6207dde6c744e2853905014e70d33b29b3e53b))
+* Preserve newlines between comments when formatting statements ([#6601](https://github.com/noir-lang/noir/issues/6601)) ([d94eb08](https://github.com/noir-lang/noir/commit/d94eb085adf2cdd8f0e80d9cfd712c19c8810974))
+* Remove `compiler_version` from new `Nargo.toml` ([#6590](https://github.com/noir-lang/noir/issues/6590)) ([df8f2ee](https://github.com/noir-lang/noir/commit/df8f2eee5c27d3cd4b6128056afdd9bd4a0322fe))
+
+
+### Miscellaneous Chores
+
+* Remove eddsa from stdlib ([#6591](https://github.com/noir-lang/noir/issues/6591)) ([8e046af](https://github.com/noir-lang/noir/commit/8e046afbbe3fba06c1e177f74aacefdd1bf871b6))
+* Require types of globals to be specified ([#6592](https://github.com/noir-lang/noir/issues/6592)) ([8ff4efd](https://github.com/noir-lang/noir/commit/8ff4efda5589d39d31ced31c6575f43133fceebc))
+* Switch to 1.0.0-beta versioning ([#6503](https://github.com/noir-lang/noir/issues/6503)) ([44e7dc1](https://github.com/noir-lang/noir/commit/44e7dc1037b047db866af675cd8caa0fc8aee324))
+
+## [0.39.0](https://github.com/noir-lang/noir/compare/v0.38.0...v0.39.0) (2024-11-19)
+
+
+### ⚠ BREAKING CHANGES
+
+* Remove `recursive` from ACIR format; add them to API and CLI (https://github.com/AztecProtocol/aztec-packages/pull/9479)
+
+### Features
+
+* Avoid unnecessary ssa passes while loop unrolling ([#6509](https://github.com/noir-lang/noir/issues/6509)) ([f81c649](https://github.com/noir-lang/noir/commit/f81c6497ff88e1cc6f3f5c183e679090c6433c65))
+* Deduplicate instructions across blocks ([#6499](https://github.com/noir-lang/noir/issues/6499)) ([b65a63d](https://github.com/noir-lang/noir/commit/b65a63d8d898e46cc686baa500f0b8070e45df14))
+* Encode static error strings in the ABI (https://github.com/AztecProtocol/aztec-packages/pull/9552) ([7dd71c1](https://github.com/noir-lang/noir/commit/7dd71c15cbcbf025ba049b506c94924903b32754))
+* Parallelize DIE pass (https://github.com/AztecProtocol/aztec-packages/pull/9933) ([7dd71c1](https://github.com/noir-lang/noir/commit/7dd71c15cbcbf025ba049b506c94924903b32754))
+* **profiler:** Reduce memory in Brillig execution flamegraph ([#6538](https://github.com/noir-lang/noir/issues/6538)) ([1cad7c8](https://github.com/noir-lang/noir/commit/1cad7c887893ebfb5de57a71d7965c8b88158a14))
+* Simplify constant MSM calls in SSA ([#6547](https://github.com/noir-lang/noir/issues/6547)) ([f291e37](https://github.com/noir-lang/noir/commit/f291e3702589a5cd043acfded5e187f56ec765cc))
+* SSA parser ([#6489](https://github.com/noir-lang/noir/issues/6489)) ([21c9db5](https://github.com/noir-lang/noir/commit/21c9db5f325beef91df024838c4b33ff7f704332))
+* **ssa:** Unroll small loops in brillig ([#6505](https://github.com/noir-lang/noir/issues/6505)) ([5d5175e](https://github.com/noir-lang/noir/commit/5d5175e1c076bd651702b6c84a00c85bc4fea860))
+* Stop with HeapVector (https://github.com/AztecProtocol/aztec-packages/pull/9810) ([7dd71c1](https://github.com/noir-lang/noir/commit/7dd71c15cbcbf025ba049b506c94924903b32754))
+* Sync from noir (https://github.com/AztecProtocol/aztec-packages/pull/9711) ([7dd71c1](https://github.com/noir-lang/noir/commit/7dd71c15cbcbf025ba049b506c94924903b32754))
+* Use a full `BlackBoxFunctionSolver` implementation when execution brillig during acirgen ([#6481](https://github.com/noir-lang/noir/issues/6481)) ([22fc11a](https://github.com/noir-lang/noir/commit/22fc11ace31b515287f62219c0e6d6ed3d1bedd7))
+
+
+### Bug Fixes
+
+* Allow range checks to be performed within the comptime intepreter ([#6514](https://github.com/noir-lang/noir/issues/6514)) ([852c87a](https://github.com/noir-lang/noir/commit/852c87ae9ecdd441ee4c2ab3e78e86b2da07d8a4))
+* Disallow `#[test]` on associated functions ([#6449](https://github.com/noir-lang/noir/issues/6449)) ([35408ab](https://github.com/noir-lang/noir/commit/35408ab303f1018c1e2c38e6ea55430a2c89dc4c))
+* Do a shallow follow_bindings before unification ([#6558](https://github.com/noir-lang/noir/issues/6558)) ([32a9ed9](https://github.com/noir-lang/noir/commit/32a9ed9ad19cf81275c31ca77e4970bc1598c112))
+* **docs:** Fix broken links in oracles doc ([#6488](https://github.com/noir-lang/noir/issues/6488)) ([aa37cd5](https://github.com/noir-lang/noir/commit/aa37cd5be25412919f466a938260ae1a485ee096))
+* Fix poor handling of aliased references in flattening pass causing some values to be zeroed ([#6434](https://github.com/noir-lang/noir/issues/6434)) ([8932dac](https://github.com/noir-lang/noir/commit/8932dac4847c643341320c2893f7e4297c78c621))
+* Parse Slice type in SSa ([#6507](https://github.com/noir-lang/noir/issues/6507)) ([34ad666](https://github.com/noir-lang/noir/commit/34ad6669b210173ddf0484b04e47161b2cfbcadf))
+* Perform arithmetic simplification through `CheckedCast` ([#6502](https://github.com/noir-lang/noir/issues/6502)) ([72e8de0](https://github.com/noir-lang/noir/commit/72e8de0656c4789f57ff1d3ddecc8901df627aab))
+* Set local_module before elaborating each trait ([#6506](https://github.com/noir-lang/noir/issues/6506)) ([1df8c45](https://github.com/noir-lang/noir/commit/1df8c456d6d256f120d6df6ae3e6735cb7eb7dae))
+* Take blackbox function outputs into account when merging expressions ([#6532](https://github.com/noir-lang/noir/issues/6532)) ([713df69](https://github.com/noir-lang/noir/commit/713df69aad56fc5aaefd5d140275a3217de4d866))
+* **tests:** Use a file lock as well as a mutex to isolate tests cases ([#6508](https://github.com/noir-lang/noir/issues/6508)) ([cfc22cb](https://github.com/noir-lang/noir/commit/cfc22cb0ca133fce49a25c3f055f5a6b8bd9b58e))
+* Treat all parameters as possible aliases of each other ([#6477](https://github.com/noir-lang/noir/issues/6477)) ([0262e5b](https://github.com/noir-lang/noir/commit/0262e5b93ab71a420365c6e56d3250b2d1eea659))
+* Typing of artifacts (https://github.com/AztecProtocol/aztec-packages/pull/9581) ([7dd71c1](https://github.com/noir-lang/noir/commit/7dd71c15cbcbf025ba049b506c94924903b32754))
+
+
+### Miscellaneous Chores
+
+* Remove `recursive` from ACIR format; add them to API and CLI (https://github.com/AztecProtocol/aztec-packages/pull/9479) ([7dd71c1](https://github.com/noir-lang/noir/commit/7dd71c15cbcbf025ba049b506c94924903b32754))
+
+## [0.38.0](https://github.com/noir-lang/noir/compare/v0.37.0...v0.38.0) (2024-11-08)
+
+
+### ⚠ BREAKING CHANGES
+
+* Always Check Arithmetic Generics at Monomorphization ([#6329](https://github.com/noir-lang/noir/issues/6329))
+
+### Features
+
+* Always Check Arithmetic Generics at Monomorphization ([#6329](https://github.com/noir-lang/noir/issues/6329)) ([2972db2](https://github.com/noir-lang/noir/commit/2972db20fc00ed0e43b662092f0d0712421d122f))
+* Ensure that generated ACIR is solvable ([#6415](https://github.com/noir-lang/noir/issues/6415)) ([b473d99](https://github.com/noir-lang/noir/commit/b473d99b2b70b595596b8392617256dbaf5d5642))
+* Nargo command to generate shell completions ([#6413](https://github.com/noir-lang/noir/issues/6413)) ([13856a1](https://github.com/noir-lang/noir/commit/13856a121125b1ccca15919942081a5d157d280e))
+
+
+### Bug Fixes
+
+* Check infix expression is valid in program input ([#6450](https://github.com/noir-lang/noir/issues/6450)) ([35dedb5](https://github.com/noir-lang/noir/commit/35dedb54a0853ba0fa85038d832a520f9ba01a98))
+* Discard optimisation that would change execution ordering or that is related to call outputs ([#6461](https://github.com/noir-lang/noir/issues/6461)) ([b8654f7](https://github.com/noir-lang/noir/commit/b8654f700b218cc09c5381af65df11ead9ffcdaf))
+* Don't crash on AsTraitPath with empty path ([#6454](https://github.com/noir-lang/noir/issues/6454)) ([fc72dcd](https://github.com/noir-lang/noir/commit/fc72dcdf3e8eeff73f72756e7ab87dddf2920657))
+* Fix Alias and Error kinds ([#6426](https://github.com/noir-lang/noir/issues/6426)) ([3cb259f](https://github.com/noir-lang/noir/commit/3cb259f419cf352f768728b15f849e520fc233cb))
+* Let formatter respect newlines between comments ([#6458](https://github.com/noir-lang/noir/issues/6458)) ([fb1a8ca](https://github.com/noir-lang/noir/commit/fb1a8ca67c58d87991358078e6c532b49824fdb8))
+* Right shift is not a regular division ([#6400](https://github.com/noir-lang/noir/issues/6400)) ([2247814](https://github.com/noir-lang/noir/commit/2247814f951f5d33257cd123a3bdcba857c9b167))
+* **sea:** Mem2reg to treat block input references as alias ([#6452](https://github.com/noir-lang/noir/issues/6452)) ([5310064](https://github.com/noir-lang/noir/commit/53100647bf1dc7917b66c9a7041c06b1e716fbe7))
+* **ssa:** Change array_set to not mutate slices coming from function inputs ([#6463](https://github.com/noir-lang/noir/issues/6463)) ([371bd45](https://github.com/noir-lang/noir/commit/371bd45130c9095e5dfb20dc79fbf41c02ed087c))
+* **ssa:** Resolve value IDs in terminator before comparing to array ([#6448](https://github.com/noir-lang/noir/issues/6448)) ([66f15ca](https://github.com/noir-lang/noir/commit/66f15caba8466501256a98cee289c49376b27097))
+* **tests:** Prevent EOF error while running test programs ([#6455](https://github.com/noir-lang/noir/issues/6455)) ([358e381](https://github.com/noir-lang/noir/commit/358e38107edbc4f40c97b88196456d82f5557e3f))
+* Type-check turbofish in trait before function call ([#6416](https://github.com/noir-lang/noir/issues/6416)) ([f8fd813](https://github.com/noir-lang/noir/commit/f8fd813b09ce870364700659e3ea8499ab51105e))
+
+## [0.37.0](https://github.com/noir-lang/noir/compare/v0.36.0...v0.37.0) (2024-10-31)
+
+
+### ⚠ BREAKING CHANGES
+
+* remove mimc from stdlib ([#6402](https://github.com/noir-lang/noir/issues/6402))
+* **avm/brillig:** revert/rethrow oracle (https://github.com/AztecProtocol/aztec-packages/pull/9408)
+* use Brillig opcode when possible for less-than operations on fields (https://github.com/AztecProtocol/aztec-packages/pull/9416)
+* remove noir_js_backend_barretenberg (https://github.com/AztecProtocol/aztec-packages/pull/9338)
+* replace usage of vector in keccakf1600 input with array (https://github.com/AztecProtocol/aztec-packages/pull/9350)
+* **profiler:** New flamegraph command that profiles the opcodes executed ([#6327](https://github.com/noir-lang/noir/issues/6327))
+
+### Features
+
+* Add capacities to brillig vectors and use them in slice ops ([#6332](https://github.com/noir-lang/noir/issues/6332)) ([c9ff9a3](https://github.com/noir-lang/noir/commit/c9ff9a392f6142c04a3a512722ef6c9f9a7c3439))
+* **avm/brillig:** Revert/rethrow oracle (https://github.com/AztecProtocol/aztec-packages/pull/9408) ([321a493](https://github.com/noir-lang/noir/commit/321a493216e19a2f077007c3447a3030db0df0d0))
+* Better LSP hover for functions ([#6376](https://github.com/noir-lang/noir/issues/6376)) ([e92b519](https://github.com/noir-lang/noir/commit/e92b519bdfbd2a149a46745ad2ecffdd0e91f3f1))
+* Check trait where clause ([#6325](https://github.com/noir-lang/noir/issues/6325)) ([0de3241](https://github.com/noir-lang/noir/commit/0de3241bd290b1737ff831c30e5a2a0633a53eb3))
+* **ci:** Add report of Brillig opcodes executed ([#6396](https://github.com/noir-lang/noir/issues/6396)) ([e04b026](https://github.com/noir-lang/noir/commit/e04b02621e3651ddbb8e314563d614171a8a9933))
+* Do not increment reference counts on arrays through references ([#6375](https://github.com/noir-lang/noir/issues/6375)) ([60c770f](https://github.com/noir-lang/noir/commit/60c770f5f2594eea31ac75c852980edefa40d9eb))
+* Improve malformed test attribute error ([#6414](https://github.com/noir-lang/noir/issues/6414)) ([8f516d7](https://github.com/noir-lang/noir/commit/8f516d73d2d33988f6cdb9367244c11bc36ede22))
+* Let LSP suggest traits in trait bounds ([#6370](https://github.com/noir-lang/noir/issues/6370)) ([e909dcb](https://github.com/noir-lang/noir/commit/e909dcbb06c7b0043ffc79d5b8af99835b0096e5))
+* Let the formatter remove lambda block braces for single-statement blocks ([#6335](https://github.com/noir-lang/noir/issues/6335)) ([52f7c0b](https://github.com/noir-lang/noir/commit/52f7c0b67fa2f70848512c87fabcefc4c5426dd1))
+* Let the LSP import code action insert into existing use statements ([#6358](https://github.com/noir-lang/noir/issues/6358)) ([308717b](https://github.com/noir-lang/noir/commit/308717b6c44db4b206ad371cd6322478ce68746b))
+* LSP auto-import will try to add to existing use statements ([#6354](https://github.com/noir-lang/noir/issues/6354)) ([647f6a4](https://github.com/noir-lang/noir/commit/647f6a4bd3d00fd3b3b3e4ff17dce512287ee5b4))
+* Merge and sort imports ([#6322](https://github.com/noir-lang/noir/issues/6322)) ([07ab515](https://github.com/noir-lang/noir/commit/07ab5150857ec6719b132ec91d5f90af0564a046))
+* **perf:** Use [u32;16] for message block in sha256 ([#6324](https://github.com/noir-lang/noir/issues/6324)) ([81c612f](https://github.com/noir-lang/noir/commit/81c612f281cddf41d12ea62d9f610eab05ad1973))
+* **profiler:** Add Brillig procedure info to debug artifact for more informative profiling ([#6385](https://github.com/noir-lang/noir/issues/6385)) ([f5f65dc](https://github.com/noir-lang/noir/commit/f5f65dc29eb1f71926e6f8ed6681df563a85bd23))
+* **profiler:** New flamegraph command that profiles the opcodes executed ([#6327](https://github.com/noir-lang/noir/issues/6327)) ([4d87c9a](https://github.com/noir-lang/noir/commit/4d87c9ac78b48b4bd0ae81316df28aab390d004e))
+* Reject programs with unconditional recursion ([#6292](https://github.com/noir-lang/noir/issues/6292)) ([00c5c51](https://github.com/noir-lang/noir/commit/00c5c5154b818d0b50802721eae621efb3379a4e))
+* Remove 'single use' intermediate variables ([#6268](https://github.com/noir-lang/noir/issues/6268)) ([ec75e8e](https://github.com/noir-lang/noir/commit/ec75e8ec59e0f2a2169aea67372411ede4074d09))
+* Remove mimc from stdlib ([#6402](https://github.com/noir-lang/noir/issues/6402)) ([ec03e77](https://github.com/noir-lang/noir/commit/ec03e779f438069e51e973d8f29727e1e0fb5665))
+* Sha256 refactoring and benchmark with longer input ([#6318](https://github.com/noir-lang/noir/issues/6318)) ([d606491](https://github.com/noir-lang/noir/commit/d606491a61a9fe2153666f7d0a3ec6cae7bfaecb))
+* **ssa:** Various mem2reg reverts to reduce memory and compilation time ([#6307](https://github.com/noir-lang/noir/issues/6307)) ([b820328](https://github.com/noir-lang/noir/commit/b82032888819eac82b2bfce8300c2c8b66507c64))
+* Suggest removing `!` from macro call that doesn't return Quoted ([#6384](https://github.com/noir-lang/noir/issues/6384)) ([0232b57](https://github.com/noir-lang/noir/commit/0232b573c418ab74715b7cc1d3e858d993bc1c07))
+* Support specifying generics on a struct when calling an associated function ([#6306](https://github.com/noir-lang/noir/issues/6306)) ([eba151e](https://github.com/noir-lang/noir/commit/eba151ecf59c61f7ffc6bec00d455dce84e7b927))
+* **test:** Run test matrix on stdlib tests ([#6352](https://github.com/noir-lang/noir/issues/6352)) ([4c39514](https://github.com/noir-lang/noir/commit/4c39514fccf3595de6bdfad755b6ae2d3ef11aa1))
+
+
+### Bug Fixes
+
+* (formatter) correctly format quote delimiters ([#6377](https://github.com/noir-lang/noir/issues/6377)) ([b42accf](https://github.com/noir-lang/noir/commit/b42accf59c9294131ce2773ac3ebdb20f548ece5))
+* (formatter) indent after infix lhs ([#6331](https://github.com/noir-lang/noir/issues/6331)) ([c891ffd](https://github.com/noir-lang/noir/commit/c891ffda9df17eabcaf2035f098d29f97bfc463a))
+* (LSP) check visibility of module that re-exports item, if any ([#6371](https://github.com/noir-lang/noir/issues/6371)) ([a4fc6e8](https://github.com/noir-lang/noir/commit/a4fc6e861492ab5ff12ebc5fdbb248f983eab0a2))
+* Aliases in path ([#6399](https://github.com/noir-lang/noir/issues/6399)) ([be882f1](https://github.com/noir-lang/noir/commit/be882f11ee661bf19ed6d78a7b3085099d4273e8))
+* Allow globals in format strings ([#6382](https://github.com/noir-lang/noir/issues/6382)) ([15c729a](https://github.com/noir-lang/noir/commit/15c729a7f29564092411658be613145b18ddd226))
+* Allow type aliases in let patterns ([#6356](https://github.com/noir-lang/noir/issues/6356)) ([91c0842](https://github.com/noir-lang/noir/commit/91c08421fdc5df7edcf502fb7fc1d343bb860b03))
+* Always inline `derive_generators` ([#6350](https://github.com/noir-lang/noir/issues/6350)) ([7c98b36](https://github.com/noir-lang/noir/commit/7c98b36305ffdbbaee3947723f248fa718e7a950))
+* Better formatting of leading/trailing line/block comments in expression lists ([#6338](https://github.com/noir-lang/noir/issues/6338)) ([3299c25](https://github.com/noir-lang/noir/commit/3299c25cefb6e3eb4b55396b2f842138b658e42f))
+* Display every bit in integer tokens ([#6360](https://github.com/noir-lang/noir/issues/6360)) ([b985fdf](https://github.com/noir-lang/noir/commit/b985fdf6e635570b8db3af83d9ec14e7cd749062))
+* Distinguish TypePath with and without turbofish ([#6404](https://github.com/noir-lang/noir/issues/6404)) ([0e974c2](https://github.com/noir-lang/noir/commit/0e974c22a1de0f6d38bc7a59280f86222f864698))
+* Fix panic in comptime code ([#6361](https://github.com/noir-lang/noir/issues/6361)) ([2f37610](https://github.com/noir-lang/noir/commit/2f376100d3ee7ab519d6ea30153395bb3e7af7b1))
+* Formatter didn't format `&gt;>=` well ([#6337](https://github.com/noir-lang/noir/issues/6337)) ([598230d](https://github.com/noir-lang/noir/commit/598230d9427cf988fc6da8fe9e1eb2b7c00a2fa6))
+* LSP auto-import would import public item inside private module ([#6366](https://github.com/noir-lang/noir/issues/6366)) ([51eb295](https://github.com/noir-lang/noir/commit/51eb2954e8dfb3da298431a82f36fa72ebbee8eb))
+* Make keccak256 work with input lengths greater than 136 bytes ([#6393](https://github.com/noir-lang/noir/issues/6393)) ([07c9322](https://github.com/noir-lang/noir/commit/07c9322332e147c0e8fade5e238552ecbf3e7849))
+* Mutable global pattern didn't have a span ([#6328](https://github.com/noir-lang/noir/issues/6328)) ([5a6dae9](https://github.com/noir-lang/noir/commit/5a6dae9a9ee9c3650695a16d18fb8b7ac12180f4))
+* Numeric generic doesn't have a default type ([#6405](https://github.com/noir-lang/noir/issues/6405)) ([3a073f7](https://github.com/noir-lang/noir/commit/3a073f7446e3cd78ca963b221e05f341a6041067))
+* Remove assumed parent traits ([#6365](https://github.com/noir-lang/noir/issues/6365)) ([83d29f2](https://github.com/noir-lang/noir/commit/83d29f259debe41d0b5cdfb6e63d31733ae4e0c7))
+* Slightly better formatting of empty blocks with comments ([#6367](https://github.com/noir-lang/noir/issues/6367)) ([da72979](https://github.com/noir-lang/noir/commit/da729791b7ffcfcd2f58ba1f8bf2c274c04f303e))
+* **ssa:** Do not mark an array from a parameter mutable ([#6355](https://github.com/noir-lang/noir/issues/6355)) ([bcd8976](https://github.com/noir-lang/noir/commit/bcd897627c69b1ebcadc8b84abe2922ce3473c56))
+
+
+### Miscellaneous Chores
+
+* Remove noir_js_backend_barretenberg (https://github.com/AztecProtocol/aztec-packages/pull/9338) ([3925228](https://github.com/noir-lang/noir/commit/392522880e102e275ebcf42f16651a8ffa0bbbd2))
+* Replace usage of vector in keccakf1600 input with array (https://github.com/AztecProtocol/aztec-packages/pull/9350) ([3925228](https://github.com/noir-lang/noir/commit/392522880e102e275ebcf42f16651a8ffa0bbbd2))
+* Use Brillig opcode when possible for less-than operations on fields (https://github.com/AztecProtocol/aztec-packages/pull/9416) ([321a493](https://github.com/noir-lang/noir/commit/321a493216e19a2f077007c3447a3030db0df0d0))
+
+## [0.36.0](https://github.com/noir-lang/noir/compare/v0.35.0...v0.36.0) (2024-10-22)
+
+
+### ⚠ BREAKING CHANGES
+
+* remove pedersen commitment (https://github.com/AztecProtocol/aztec-packages/pull/9107)
+* remove pedersen hash opcode (https://github.com/AztecProtocol/aztec-packages/pull/9245)
+* Brillig and AVM default all uninitialized memory cells to Field 0 (https://github.com/AztecProtocol/aztec-packages/pull/9057)
+* remove keccak256 opcode from ACIR/Brillig (https://github.com/AztecProtocol/aztec-packages/pull/9104)
+* Brillig with a stack and conditional inlining (https://github.com/AztecProtocol/aztec-packages/pull/8989)
+* **avm:** remove CMOV opcode (https://github.com/AztecProtocol/aztec-packages/pull/9030)
+* Integer division is not the inverse of integer multiplication ([#6243](https://github.com/noir-lang/noir/issues/6243))
+* kind size checks ([#6137](https://github.com/noir-lang/noir/issues/6137))
+* Change tag attributes to require a ' prefix ([#6235](https://github.com/noir-lang/noir/issues/6235))
+
+### Features
+
+* Add `checked_transmute` ([#6262](https://github.com/noir-lang/noir/issues/6262)) ([2618061](https://github.com/noir-lang/noir/commit/2618061ee88e47fb063904d50af7a4eea26d3db9))
+* Add more `Type` and `UnresolvedType` methods ([#5994](https://github.com/noir-lang/noir/issues/5994)) ([8236cbd](https://github.com/noir-lang/noir/commit/8236cbdff60c1aaf41fc53142b6f0f9ea2fc2fa8))
+* Allow `unconstrained` after visibility ([#6246](https://github.com/noir-lang/noir/issues/6246)) ([f6dfbcf](https://github.com/noir-lang/noir/commit/f6dfbcf057efc95141b36499152dbd0b919a31b3))
+* Brillig and AVM default all uninitialized memory cells to Field 0 (https://github.com/AztecProtocol/aztec-packages/pull/9057) ([70dcf4a](https://github.com/noir-lang/noir/commit/70dcf4a25dcad10daeb427f0887d3a0bf10c9916))
+* Brillig with a stack and conditional inlining (https://github.com/AztecProtocol/aztec-packages/pull/8989) ([70dcf4a](https://github.com/noir-lang/noir/commit/70dcf4a25dcad10daeb427f0887d3a0bf10c9916))
+* Don't crash LSP when there are errors resolving the workspace ([#6257](https://github.com/noir-lang/noir/issues/6257)) ([7cc7197](https://github.com/noir-lang/noir/commit/7cc7197bf7b2e41c07e8d1979f7e9d45c676d11b))
+* Don't suggest private struct fields in LSP ([#6256](https://github.com/noir-lang/noir/issues/6256)) ([2a727b3](https://github.com/noir-lang/noir/commit/2a727b3f7f7fb84ab88b0d08e1ab29ae012a8c4f))
+* Handwritten parser ([#6180](https://github.com/noir-lang/noir/issues/6180)) ([c4273a0](https://github.com/noir-lang/noir/commit/c4273a0c8f8b751a3dbe097e070e4e7b2c8ec438))
+* **improve:** Remove scan through globals ([#6282](https://github.com/noir-lang/noir/issues/6282)) ([fd91913](https://github.com/noir-lang/noir/commit/fd91913806a49255ba721012c2e302959a82c4f6))
+* Inclusive for loop ([#6200](https://github.com/noir-lang/noir/issues/6200)) ([bd861f2](https://github.com/noir-lang/noir/commit/bd861f282144056ecb52954fa9f6fd8db918e093))
+* Integrate databus in the private kernels (https://github.com/AztecProtocol/aztec-packages/pull/9028) ([70dcf4a](https://github.com/noir-lang/noir/commit/70dcf4a25dcad10daeb427f0887d3a0bf10c9916))
+* **interpreter:** Comptime derive generators ([#6303](https://github.com/noir-lang/noir/issues/6303)) ([d8767b3](https://github.com/noir-lang/noir/commit/d8767b364f4db9a52c823e7f39f36feac3c90fcd))
+* Kind size checks ([#6137](https://github.com/noir-lang/noir/issues/6137)) ([6e40f62](https://github.com/noir-lang/noir/commit/6e40f628a87ab4b5e9e817b7b3a790920dc01683))
+* New formatter ([#6300](https://github.com/noir-lang/noir/issues/6300)) ([62404d7](https://github.com/noir-lang/noir/commit/62404d7ff349ddf7551f2efd865adafc5213a742))
+* Optimize `Quoted::as_expr` by parsing just once ([#6237](https://github.com/noir-lang/noir/issues/6237)) ([a4fcd00](https://github.com/noir-lang/noir/commit/a4fcd0017e019f05b5a4d6b97c50b75f9e560210))
+* Optimize reading a workspace's files ([#6281](https://github.com/noir-lang/noir/issues/6281)) ([b54ed26](https://github.com/noir-lang/noir/commit/b54ed2671c8bc0e198e262883598936b9e49d69e))
+* **perf:** Flamegraphs for test program execution benchmarks ([#6253](https://github.com/noir-lang/noir/issues/6253)) ([c186791](https://github.com/noir-lang/noir/commit/c186791636c2afb2d3763bccee956298039feed2))
+* **perf:** Follow array sets backwards in array set from get optimization ([#6208](https://github.com/noir-lang/noir/issues/6208)) ([999071b](https://github.com/noir-lang/noir/commit/999071b80e61a37cb994a4e359eabbac27cd53f1))
+* Recover from '=' instead of ':' in struct constructor/pattern ([#6236](https://github.com/noir-lang/noir/issues/6236)) ([9a12f31](https://github.com/noir-lang/noir/commit/9a12f31e909bbd4d4f0538704b3f40ea654fabaf))
+* Remove byte decomposition in `compute_decomposition` ([#6159](https://github.com/noir-lang/noir/issues/6159)) ([a8bcae2](https://github.com/noir-lang/noir/commit/a8bcae215bf19356226ad052710c94b64da90ffa))
+* Show LSP diagnostic related information ([#6277](https://github.com/noir-lang/noir/issues/6277)) ([c8a91a5](https://github.com/noir-lang/noir/commit/c8a91a55d69c54e3ea9b6a16053fa83ce17b1426))
+* Slightly improve "unexpected token" error message ([#6279](https://github.com/noir-lang/noir/issues/6279)) ([8232bfa](https://github.com/noir-lang/noir/commit/8232bfaf0a88dcba5a6949489b81d78c3413c5bc))
+* Sync from noir (https://github.com/AztecProtocol/aztec-packages/pull/8934) ([70dcf4a](https://github.com/noir-lang/noir/commit/70dcf4a25dcad10daeb427f0887d3a0bf10c9916))
+* Sync from noir (https://github.com/AztecProtocol/aztec-packages/pull/9034) ([70dcf4a](https://github.com/noir-lang/noir/commit/70dcf4a25dcad10daeb427f0887d3a0bf10c9916))
+* Sync from noir (https://github.com/AztecProtocol/aztec-packages/pull/9099) ([70dcf4a](https://github.com/noir-lang/noir/commit/70dcf4a25dcad10daeb427f0887d3a0bf10c9916))
+* Sync from noir (https://github.com/AztecProtocol/aztec-packages/pull/9275) ([70dcf4a](https://github.com/noir-lang/noir/commit/70dcf4a25dcad10daeb427f0887d3a0bf10c9916))
+* **test:** Fuzz poseidon hases against an external library ([#6273](https://github.com/noir-lang/noir/issues/6273)) ([8d8ea89](https://github.com/noir-lang/noir/commit/8d8ea8963c5e4e23bd387aa729e09d3a9553a698))
+* **test:** Fuzz test poseidon2 hash equivalence ([#6265](https://github.com/noir-lang/noir/issues/6265)) ([f61ba03](https://github.com/noir-lang/noir/commit/f61ba037c6726e19be4f894d9447fe396df95417))
+* **test:** Fuzz test stdlib hash functions ([#6233](https://github.com/noir-lang/noir/issues/6233)) ([1a2ca46](https://github.com/noir-lang/noir/commit/1a2ca46af0d1c05813dbe28670a2bc39b79e4c9f))
+* **test:** Include the PoseidonHasher in the fuzzing ([#6280](https://github.com/noir-lang/noir/issues/6280)) ([afb8a7c](https://github.com/noir-lang/noir/commit/afb8a7cf7b1751a10dd2cdd87817945fa4c1ed1f))
+* Trait inheritance ([#6252](https://github.com/noir-lang/noir/issues/6252)) ([d3301a4](https://github.com/noir-lang/noir/commit/d3301a4f5558cf4e173f7d0edc08186ad4fb2eee))
+* Visibility for impl functions ([#6179](https://github.com/noir-lang/noir/issues/6179)) ([1b26440](https://github.com/noir-lang/noir/commit/1b26440889379f491315cd9d088537b1898d57c5))
+* Visibility for struct fields ([#6221](https://github.com/noir-lang/noir/issues/6221)) ([fc1c7ab](https://github.com/noir-lang/noir/commit/fc1c7ab6ee7be7c9d57fab5b2efe252c613f326b))
+* Warn about private types leaking in public functions and struct fields ([#6296](https://github.com/noir-lang/noir/issues/6296)) ([67ac0d6](https://github.com/noir-lang/noir/commit/67ac0d60c3e8b450a9e871f3edb29322ac5045d2))
+
+
+### Bug Fixes
+
+* Add missing visibility for auto-import names ([#6205](https://github.com/noir-lang/noir/issues/6205)) ([c3cb38a](https://github.com/noir-lang/noir/commit/c3cb38a7c4de6fc321b367eda3fca6d06e76b77a))
+* Address inactive public key check in `verify_signature_noir` ([#6270](https://github.com/noir-lang/noir/issues/6270)) ([e4325aa](https://github.com/noir-lang/noir/commit/e4325aace424d5c4552c92cdb360974fdd294048))
+* Allow array map on empty arrays ([#6305](https://github.com/noir-lang/noir/issues/6305)) ([51ae1b3](https://github.com/noir-lang/noir/commit/51ae1b324cd73fdb4fe3695b5d483a44b4aff4a9))
+* Change tag attributes to require a ' prefix ([#6235](https://github.com/noir-lang/noir/issues/6235)) ([b43dcb2](https://github.com/noir-lang/noir/commit/b43dcb2b30ce090c393990b2192411f9b3dc6a9e))
+* Check for Schnorr null signature ([#6226](https://github.com/noir-lang/noir/issues/6226)) ([2430920](https://github.com/noir-lang/noir/commit/24309200f600ad20a51d9f2c6c53849466fccda4))
+* Display function name and body when inlining recursion limit hit ([#6291](https://github.com/noir-lang/noir/issues/6291)) ([33a1e7d](https://github.com/noir-lang/noir/commit/33a1e7d2246bdea48dd6fe925d427c7be8c4659d))
+* Do not warn on unused self in traits ([#6298](https://github.com/noir-lang/noir/issues/6298)) ([4d524bf](https://github.com/noir-lang/noir/commit/4d524bf34de98449419a025aa53d593bf42e70a7))
+* Don't warn on unuse global if it has an abi annotation ([#6258](https://github.com/noir-lang/noir/issues/6258)) ([e13f617](https://github.com/noir-lang/noir/commit/e13f61741d17ed2e03ff26cb858cb3d243e67c88))
+* Don't warn on unused struct that has an abi annotation ([#6254](https://github.com/noir-lang/noir/issues/6254)) ([8a31632](https://github.com/noir-lang/noir/commit/8a316324a971a10d46392d7c64125d1d6ac9d557))
+* Don't warn twice when referring to private item ([#6216](https://github.com/noir-lang/noir/issues/6216)) ([619c545](https://github.com/noir-lang/noir/commit/619c5451b152d62e01d3c4c1da7e13ff6502f915))
+* Enforce correctness of decompositions performed at compile time ([#6278](https://github.com/noir-lang/noir/issues/6278)) ([53252fd](https://github.com/noir-lang/noir/commit/53252fd521ce7818a1d97824be30466590d879f5))
+* **frontend:** Do not warn when a nested struct is provided as input to main ([#6239](https://github.com/noir-lang/noir/issues/6239)) ([9dfe223](https://github.com/noir-lang/noir/commit/9dfe223e4dc168351c5cceb9d1abda326141b014))
+* Handle dfg databus in SSA normalization ([#6249](https://github.com/noir-lang/noir/issues/6249)) ([9d8bee5](https://github.com/noir-lang/noir/commit/9d8bee5b4e9308a812b1f93c3a48ddd11971ac17))
+* Handle nested arrays in calldata ([#6232](https://github.com/noir-lang/noir/issues/6232)) ([0ab8f5e](https://github.com/noir-lang/noir/commit/0ab8f5e3c32af05a3c158562c0fcf9729741e0ab))
+* Homogeneous input points for EC ADD ([#6241](https://github.com/noir-lang/noir/issues/6241)) ([f6a7306](https://github.com/noir-lang/noir/commit/f6a7306436ea1a37ec7f3b884721b50467e9a063))
+* Integer division is not the inverse of integer multiplication ([#6243](https://github.com/noir-lang/noir/issues/6243)) ([1cd2587](https://github.com/noir-lang/noir/commit/1cd2587bf67143832f76f90c25aecca1a46b1284))
+* Panic on composite types within databus ([#6225](https://github.com/noir-lang/noir/issues/6225)) ([29bd125](https://github.com/noir-lang/noir/commit/29bd125314b58e2eac23742ff1de022a97dcc60a))
+* Prevent compiler panic when popping from empty slices ([#6274](https://github.com/noir-lang/noir/issues/6274)) ([87137d8](https://github.com/noir-lang/noir/commit/87137d8d93622052dbe1c8a933d542a5c147c15c))
+* Reject invalid expression with in CLI parser ([#6287](https://github.com/noir-lang/noir/issues/6287)) ([052aee8](https://github.com/noir-lang/noir/commit/052aee80ff3e1e4fd2ca45310d7bb8b980af126a))
+* Remove need for duplicate attributes on each function (https://github.com/AztecProtocol/aztec-packages/pull/9244) ([70dcf4a](https://github.com/noir-lang/noir/commit/70dcf4a25dcad10daeb427f0887d3a0bf10c9916))
+* Visibility for impl methods ([#6261](https://github.com/noir-lang/noir/issues/6261)) ([70cbeb4](https://github.com/noir-lang/noir/commit/70cbeb4322a0b11c1c167ab27bf0408d04fe7b7d))
+
+
+### Miscellaneous Chores
+
+* Remove keccak256 opcode from ACIR/Brillig (https://github.com/AztecProtocol/aztec-packages/pull/9104) ([70dcf4a](https://github.com/noir-lang/noir/commit/70dcf4a25dcad10daeb427f0887d3a0bf10c9916))
+* Remove pedersen commitment (https://github.com/AztecProtocol/aztec-packages/pull/9107) ([70dcf4a](https://github.com/noir-lang/noir/commit/70dcf4a25dcad10daeb427f0887d3a0bf10c9916))
+* Remove pedersen hash opcode (https://github.com/AztecProtocol/aztec-packages/pull/9245) ([70dcf4a](https://github.com/noir-lang/noir/commit/70dcf4a25dcad10daeb427f0887d3a0bf10c9916))
+
+
+### Code Refactoring
+
+* **avm:** Remove CMOV opcode (https://github.com/AztecProtocol/aztec-packages/pull/9030) ([70dcf4a](https://github.com/noir-lang/noir/commit/70dcf4a25dcad10daeb427f0887d3a0bf10c9916))
+
+## [0.35.0](https://github.com/noir-lang/noir/compare/v0.34.0...v0.35.0) (2024-10-03)
+
+
+### ⚠ BREAKING CHANGES
+
+* Syncing TypeVariableKind with Kind ([#6094](https://github.com/noir-lang/noir/issues/6094))
+* remove sha256 opcode (https://github.com/AztecProtocol/aztec-packages/pull/4571)
+* add support for u1 in the avm, ToRadix's radix arg is a memory addr (https://github.com/AztecProtocol/aztec-packages/pull/8570)
+* Infer globals to be u32 when used in a type ([#6083](https://github.com/noir-lang/noir/issues/6083))
+* removing implicit numeric generics ([#5837](https://github.com/noir-lang/noir/issues/5837))
+
+### Features
+
+* (LSP) if in runtime code, always suggest functions that return Quoted as macro calls ([#6098](https://github.com/noir-lang/noir/issues/6098)) ([4a160cb](https://github.com/noir-lang/noir/commit/4a160cb99cbd9928c034a7009f398974fc6fdb11))
+* (LSP) remove unused imports ([#6129](https://github.com/noir-lang/noir/issues/6129)) ([98bc460](https://github.com/noir-lang/noir/commit/98bc46002cdd8daff1baf0756ecc60dbdf420fd9))
+* (LSP) show global value on hover ([#6097](https://github.com/noir-lang/noir/issues/6097)) ([3d9d072](https://github.com/noir-lang/noir/commit/3d9d07210544c9d27051eb5e629585760f48cd1c))
+* (LSP) suggest $vars inside `quote { ... }` ([#6114](https://github.com/noir-lang/noir/issues/6114)) ([73245b3](https://github.com/noir-lang/noir/commit/73245b3aae0c65780a102ac6842f06df65e5fc35))
+* Add `Expr::as_constructor` ([#5980](https://github.com/noir-lang/noir/issues/5980)) ([76dea7b](https://github.com/noir-lang/noir/commit/76dea7b409baa98236f6433f17c2ce9206dd4ba3))
+* Add `Expr::as_for` and `Expr::as_for_range` ([#6039](https://github.com/noir-lang/noir/issues/6039)) ([abcae75](https://github.com/noir-lang/noir/commit/abcae750f022dd7c49cee616edddd7b1cc93f3b8))
+* Add `Expr::as_lambda` ([#6048](https://github.com/noir-lang/noir/issues/6048)) ([31130dc](https://github.com/noir-lang/noir/commit/31130dc7aec24a7a7b9f342df94b14f295eb2103))
+* Add a `comptime` string type for string handling at compile-time ([#6026](https://github.com/noir-lang/noir/issues/6026)) ([5d2984f](https://github.com/noir-lang/noir/commit/5d2984fce4f55e43cb418e40462d430227b71768))
+* Add support for u1 in the avm, ToRadix's radix arg is a memory addr (https://github.com/AztecProtocol/aztec-packages/pull/8570) ([e8bbce7](https://github.com/noir-lang/noir/commit/e8bbce71fde3fc7af410c30920c2a547389d8248))
+* Allow silencing an unused variable defined via `let` ([#6149](https://github.com/noir-lang/noir/issues/6149)) ([a2bc059](https://github.com/noir-lang/noir/commit/a2bc059f993d3e9ca06a2fe4857ef1c522c97286))
+* Allow visibility modifiers in struct definitions ([#6054](https://github.com/noir-lang/noir/issues/6054)) ([199be58](https://github.com/noir-lang/noir/commit/199be584a36d20660ada49473050c5191251d6c5))
+* Check unconstrained trait impl method matches ([#6057](https://github.com/noir-lang/noir/issues/6057)) ([aedc983](https://github.com/noir-lang/noir/commit/aedc9832240e55473c504fa2e6e3b3af618bda08))
+* Default to outputting witness with file named after package ([#6031](https://github.com/noir-lang/noir/issues/6031)) ([e74b4ae](https://github.com/noir-lang/noir/commit/e74b4ae3ebcf301eedc5d0059bcebd5dced75d72))
+* Detect unconstructed structs ([#6061](https://github.com/noir-lang/noir/issues/6061)) ([bcb438b](https://github.com/noir-lang/noir/commit/bcb438b0816fbe08344535545612d32b4730af79))
+* Do not double error on import with error ([#6131](https://github.com/noir-lang/noir/issues/6131)) ([9b26650](https://github.com/noir-lang/noir/commit/9b26650f4a45c220484fc187500c7307af9c88d7))
+* Expose `derived_generators` and `pedersen_commitment_with_separator` from the stdlib ([#6154](https://github.com/noir-lang/noir/issues/6154)) ([877b806](https://github.com/noir-lang/noir/commit/877b806ee02cb640472c6bb2b1ed7bc76b861a9b))
+* Faster LSP by caching file managers ([#6047](https://github.com/noir-lang/noir/issues/6047)) ([c48a4f8](https://github.com/noir-lang/noir/commit/c48a4f83063ff55574d5b4a6277950a9edbc6317))
+* Hoist constant allocation outside of loops ([#6158](https://github.com/noir-lang/noir/issues/6158)) ([180bfc9](https://github.com/noir-lang/noir/commit/180bfc99944cd42b3f44048213458d1399687cef))
+* Implement `to_be_radix` in the comptime interpreter ([#6043](https://github.com/noir-lang/noir/issues/6043)) ([1550278](https://github.com/noir-lang/noir/commit/1550278f1e96392967b477b9b12be3bb0eea8fd6))
+* Implement solver for mov_registers_to_registers ([#6089](https://github.com/noir-lang/noir/issues/6089)) ([4170c55](https://github.com/noir-lang/noir/commit/4170c55019bd27fd51be8a46637514dfe86de53c))
+* Implement type paths ([#6093](https://github.com/noir-lang/noir/issues/6093)) ([2174ffb](https://github.com/noir-lang/noir/commit/2174ffb92b5d88e7e0926c91f42bc7f849e8ddc1))
+* Let `Module::functions` and `Module::structs` return them in definition order ([#6178](https://github.com/noir-lang/noir/issues/6178)) ([dec9874](https://github.com/noir-lang/noir/commit/dec98747197442f6c2a15e6543c5d453dff4b967))
+* Let LSP suggest macro calls too ([#6090](https://github.com/noir-lang/noir/issues/6090)) ([26d275b](https://github.com/noir-lang/noir/commit/26d275b65fa339d877c90d5c6c13ac8ef47189e1))
+* Let LSP suggest trait impl methods as you are typing them ([#6029](https://github.com/noir-lang/noir/issues/6029)) ([dfed81b](https://github.com/noir-lang/noir/commit/dfed81b4b39b2f783d6e81a78ee27fba7032e01c))
+* LSP autocompletion for `TypePath` ([#6117](https://github.com/noir-lang/noir/issues/6117)) ([3f79d8f](https://github.com/noir-lang/noir/commit/3f79d8f04c5f90c6b21359a3d0960446ebf84b2d))
+* **metaprogramming:** Add `#[use_callers_scope]` ([#6050](https://github.com/noir-lang/noir/issues/6050)) ([8c34046](https://github.com/noir-lang/noir/commit/8c340461c3f7054839009c4b1ed5ac8a0dd55e09))
+* Optimize allocating immediate amounts of memory (https://github.com/AztecProtocol/aztec-packages/pull/8579) ([e8bbce7](https://github.com/noir-lang/noir/commit/e8bbce71fde3fc7af410c30920c2a547389d8248))
+* Optimize constraints in sha256 ([#6145](https://github.com/noir-lang/noir/issues/6145)) ([164d29e](https://github.com/noir-lang/noir/commit/164d29e4d1960d16fdeafe2cc8ea8144a769f7b2))
+* **perf:** Allow array set last uses optimization in return block of Brillig functions ([#6119](https://github.com/noir-lang/noir/issues/6119)) ([5598059](https://github.com/noir-lang/noir/commit/5598059576c6cbc72474aff4b18bc5e4bb9f08e1))
+* **perf:** Handle array set optimization across blocks for Brillig functions ([#6153](https://github.com/noir-lang/noir/issues/6153)) ([12cb80a](https://github.com/noir-lang/noir/commit/12cb80a214fd81eb7619413a6d0663369be38512))
+* **perf:** Optimize array set from get ([#6207](https://github.com/noir-lang/noir/issues/6207)) ([dfeb1c5](https://github.com/noir-lang/noir/commit/dfeb1c51c564ec345978a9a0efef3e4e96ab638a))
+* **perf:** Remove inc_rc instructions for arrays which are never mutably borrowed ([#6168](https://github.com/noir-lang/noir/issues/6168)) ([a195442](https://github.com/noir-lang/noir/commit/a19544247fffaf5d2fe0d6d45013f833576f7c61))
+* **perf:** Remove redundant inc rc without instructions between ([#6183](https://github.com/noir-lang/noir/issues/6183)) ([be9dcfe](https://github.com/noir-lang/noir/commit/be9dcfe56d808b1bd5ef552d41274705b2df7062))
+* **perf:** Remove unused loads in mem2reg and last stores per function ([#5925](https://github.com/noir-lang/noir/issues/5925)) ([19eef30](https://github.com/noir-lang/noir/commit/19eef30cdbd8a3a4671aabbbe66b5481a5dec3f7))
+* **perf:** Remove useless paired RC instructions within a block during DIE ([#6160](https://github.com/noir-lang/noir/issues/6160)) ([59c4118](https://github.com/noir-lang/noir/commit/59c41182faa19d1cb8c9be5c11d50636fc17dad7))
+* **perf:** Simplify the cfg after DIE ([#6184](https://github.com/noir-lang/noir/issues/6184)) ([a1b5046](https://github.com/noir-lang/noir/commit/a1b50466bfd8c44d50440e00ecb50e29425471e5))
+* Pretty print Quoted token stream ([#6111](https://github.com/noir-lang/noir/issues/6111)) ([cd81f85](https://github.com/noir-lang/noir/commit/cd81f85856a477e208533ebd0915b5901c1bb184))
+* Refactor SSA passes to run on individual functions ([#6072](https://github.com/noir-lang/noir/issues/6072)) ([85c502c](https://github.com/noir-lang/noir/commit/85c502c9fa69b151fdff1a97b5a97ad78cb599ab))
+* Remove aztec macros ([#6087](https://github.com/noir-lang/noir/issues/6087)) ([9d96207](https://github.com/noir-lang/noir/commit/9d962077630131840f0cb7c211f462b579b0b577))
+* Remove orphaned blocks from cfg to improve `simplify_cfg` pass. ([#6198](https://github.com/noir-lang/noir/issues/6198)) ([b4712c5](https://github.com/noir-lang/noir/commit/b4712c5ba50ef38789978522afcd251ffbcf8780))
+* Remove sha256 opcode (https://github.com/AztecProtocol/aztec-packages/pull/4571) ([e8bbce7](https://github.com/noir-lang/noir/commit/e8bbce71fde3fc7af410c30920c2a547389d8248))
+* Remove unnecessary branching in keccak impl ([#6133](https://github.com/noir-lang/noir/issues/6133)) ([9c69dce](https://github.com/noir-lang/noir/commit/9c69dce2250b6fc656af8d9c06d7fac34b35c73a))
+* Represent assertions more similarly to function calls ([#6103](https://github.com/noir-lang/noir/issues/6103)) ([3ecd0e2](https://github.com/noir-lang/noir/commit/3ecd0e29441d27bc77c49993495209a70be0d86e))
+* Show test output when running via LSP ([#6049](https://github.com/noir-lang/noir/issues/6049)) ([9fb010e](https://github.com/noir-lang/noir/commit/9fb010ef8a93cf25e4d361ee42aa8969e5a46bab))
+* Simplify sha256 implementation ([#6142](https://github.com/noir-lang/noir/issues/6142)) ([acdfbbc](https://github.com/noir-lang/noir/commit/acdfbbc4ecc9d213dc885a12952e29e188420dff))
+* Skip `remove_enable_side_effects` pass on brillig functions ([#6199](https://github.com/noir-lang/noir/issues/6199)) ([2303615](https://github.com/noir-lang/noir/commit/2303615815a2a60de8ac3dd53349f85201660917))
+* **ssa:** Simplify signed casts ([#6166](https://github.com/noir-lang/noir/issues/6166)) ([eec3a61](https://github.com/noir-lang/noir/commit/eec3a6152493e56866ec5338ff52f823c530778e))
+* Swap endianness in-place in keccak implementation ([#6128](https://github.com/noir-lang/noir/issues/6128)) ([e3cdebe](https://github.com/noir-lang/noir/commit/e3cdebe515e4dc4ee6e16e01bd8af25135939798))
+* Syncing TypeVariableKind with Kind ([#6094](https://github.com/noir-lang/noir/issues/6094)) ([6440e18](https://github.com/noir-lang/noir/commit/6440e183085160d77563b4e735ccaaf199e21693))
+* Visibility for globals ([#6161](https://github.com/noir-lang/noir/issues/6161)) ([103b54d](https://github.com/noir-lang/noir/commit/103b54db8a5a81ecf76381fe99320c1e1f606898))
+* Visibility for modules ([#6165](https://github.com/noir-lang/noir/issues/6165)) ([fcdbcb9](https://github.com/noir-lang/noir/commit/fcdbcb91afb18771cbb5ee48628e171845f22f5f))
+* Visibility for traits ([#6056](https://github.com/noir-lang/noir/issues/6056)) ([5bbd9ba](https://github.com/noir-lang/noir/commit/5bbd9ba9a6d6494fd16813b44036b78c871f6613))
+* Visibility for type aliases ([#6058](https://github.com/noir-lang/noir/issues/6058)) ([66d2a07](https://github.com/noir-lang/noir/commit/66d2a07f0fedb04422c218cbe8d6fb080efac994))
+
+
+### Bug Fixes
+
+* (LSP) make goto and hover work well for attributes ([#6152](https://github.com/noir-lang/noir/issues/6152)) ([c679bc6](https://github.com/noir-lang/noir/commit/c679bc6bbd291b6264820dd497b37279116a1cd2))
+* Allow macros to change types on each iteration of a comptime loop ([#6105](https://github.com/noir-lang/noir/issues/6105)) ([0864e7c](https://github.com/noir-lang/noir/commit/0864e7c945089cc06f8cc9e5c7d933c465d8c892))
+* Allow providing default implementations of unconstrained trait methods ([#6138](https://github.com/noir-lang/noir/issues/6138)) ([7679bbc](https://github.com/noir-lang/noir/commit/7679bbc10cb2fa480489fe1aad83fe77ec2af7e8))
+* Always parse all tokens from quoted token streams ([#6064](https://github.com/noir-lang/noir/issues/6064)) ([23ed74b](https://github.com/noir-lang/noir/commit/23ed74bc94ec4da8dbd35da0ae39b26c7ef601e5))
+* Be more lenient with semicolons on interned expressions ([#6062](https://github.com/noir-lang/noir/issues/6062)) ([052c4fe](https://github.com/noir-lang/noir/commit/052c4fe52a4df9d6492f9b0d6b449151b87b18d5))
+* Consider constants as used values to keep their rc ops ([#6122](https://github.com/noir-lang/noir/issues/6122)) ([1217005](https://github.com/noir-lang/noir/commit/12170056102ea15698aacc820876fee0bb7d0c68))
+* Correct stack trace order in comptime assertion failures ([#6066](https://github.com/noir-lang/noir/issues/6066)) ([04f1636](https://github.com/noir-lang/noir/commit/04f1636ca0ccd741c72fa98d6c26227ea9835b0c))
+* Databus panic for fns with empty params (https://github.com/AztecProtocol/aztec-packages/pull/8847) ([d252748](https://github.com/noir-lang/noir/commit/d2527482dafef694be2f389e5b4dbc813234da71))
+* Decode databus return values ([#6095](https://github.com/noir-lang/noir/issues/6095)) ([c40eb1f](https://github.com/noir-lang/noir/commit/c40eb1fd8a0ba63b2d122e42b47dfa9dca5bf7b0))
+* Disable side-effects for no_predicates functions ([#6027](https://github.com/noir-lang/noir/issues/6027)) ([fc74c55](https://github.com/noir-lang/noir/commit/fc74c55ffed892962413c6fe15af62e1d2e7b785))
+* Disambiguate field or int static trait method call ([#6112](https://github.com/noir-lang/noir/issues/6112)) ([5b27ea4](https://github.com/noir-lang/noir/commit/5b27ea4d8031318723cc2b97f76758d401a565a0))
+* Do not duplicate constant arrays in brillig ([#6155](https://github.com/noir-lang/noir/issues/6155)) ([68f3022](https://github.com/noir-lang/noir/commit/68f3022fcdaab6e379e43091b3242e6ea51cff26))
+* **docs:** Rename recursion.md to recursion.mdx ([#6195](https://github.com/noir-lang/noir/issues/6195)) ([054e48b](https://github.com/noir-lang/noir/commit/054e48b76e7b083feb500d30c54912f9db57c565))
+* Don't crash on untyped global used as array length ([#6076](https://github.com/noir-lang/noir/issues/6076)) ([426f295](https://github.com/noir-lang/noir/commit/426f2955cbe4f086581d05eea7d06c47e0491195))
+* Ensure to_bytes returns the canonical decomposition ([#6084](https://github.com/noir-lang/noir/issues/6084)) ([b280a79](https://github.com/noir-lang/noir/commit/b280a79cf8a4fd2a97200e5436e0ec7cb7134711))
+* Error on `&mut x` when `x` is not mutable ([#6037](https://github.com/noir-lang/noir/issues/6037)) ([57afc7d](https://github.com/noir-lang/noir/commit/57afc7ddd424220106af7b9c6e0715007f6ea8b8))
+* Fix canonicalization bug ([#6033](https://github.com/noir-lang/noir/issues/6033)) ([7397772](https://github.com/noir-lang/noir/commit/739777214863de4088162711953f26ca992b356e))
+* Fix comptime type formatting ([#6079](https://github.com/noir-lang/noir/issues/6079)) ([e678091](https://github.com/noir-lang/noir/commit/e67809165c277423e25110c3f1f8eff6e8daa0e4))
+* Handle multi-byte utf8 characters in formatter ([#6118](https://github.com/noir-lang/noir/issues/6118)) ([b1d0619](https://github.com/noir-lang/noir/commit/b1d061926376965805ef3ece3e32d94df81462a6))
+* Handle parenthesized expressions in array length ([#6132](https://github.com/noir-lang/noir/issues/6132)) ([9f0b397](https://github.com/noir-lang/noir/commit/9f0b3971ee41e78241cbea4e3f81bac4edd5897d))
+* Ignore compression of blocks after msg.len in sha256_var ([#6206](https://github.com/noir-lang/noir/issues/6206)) ([76eec71](https://github.com/noir-lang/noir/commit/76eec710ff73e5e45fdddcd41ae2cd74e879cfa5))
+* Infer globals to be u32 when used in a type ([#6083](https://github.com/noir-lang/noir/issues/6083)) ([78262c9](https://github.com/noir-lang/noir/commit/78262c96d5b116c77e50653f9059da60824db812))
+* Initialise databus using return values ([#6074](https://github.com/noir-lang/noir/issues/6074)) ([e17dfa5](https://github.com/noir-lang/noir/commit/e17dfa55719f0cfb1080dd25eeda7b70ed44b60d))
+* Let LSP suggest fields and methods in LValue chains ([#6051](https://github.com/noir-lang/noir/issues/6051)) ([5bf6567](https://github.com/noir-lang/noir/commit/5bf6567320629835ef6fa7765ca87e9b38ae4c9a))
+* Let token pretty printer handle `+=` and similar token sequences ([#6135](https://github.com/noir-lang/noir/issues/6135)) ([684b6cc](https://github.com/noir-lang/noir/commit/684b6cc7deb3ed7ecbb2cea4663e8e9a3ae075f0))
+* **mem2reg:** Remove possibility of underflow ([#6107](https://github.com/noir-lang/noir/issues/6107)) ([aea5cc7](https://github.com/noir-lang/noir/commit/aea5cc789ccf4a4d16b1d238d99474f37920b37e))
+* Parse a statement as an expression ([#6040](https://github.com/noir-lang/noir/issues/6040)) ([ab203e4](https://github.com/noir-lang/noir/commit/ab203e4ee902b9137519f9a4261ec368d22f0a25))
+* Pass radix directly to the blackbox ([#6164](https://github.com/noir-lang/noir/issues/6164)) ([82b89c4](https://github.com/noir-lang/noir/commit/82b89c421da80b719922416d574c1bbaa73d55b4))
+* Preserve generic kind on trait methods ([#6099](https://github.com/noir-lang/noir/issues/6099)) ([1df102a](https://github.com/noir-lang/noir/commit/1df102a1ee0eb39dcbada50e10b226c7f7be0f26))
+* Prevent check_can_mutate crashing on undefined variable ([#6044](https://github.com/noir-lang/noir/issues/6044)) ([b3accfc](https://github.com/noir-lang/noir/commit/b3accfc99249ccd198051ecb98cf7962af64a629))
+* Revert mistaken stack size change ([#6212](https://github.com/noir-lang/noir/issues/6212)) ([a37117a](https://github.com/noir-lang/noir/commit/a37117aca3340447d807c1cf3ca79ba573ceaf8b))
+* **ssa:** Check if result of array set is used in value of another array set ([#6197](https://github.com/noir-lang/noir/issues/6197)) ([594ec91](https://github.com/noir-lang/noir/commit/594ec91de55c4cf191d7cdc94a00bb16711cd430))
+* **ssa:** RC correctness issue  ([#6134](https://github.com/noir-lang/noir/issues/6134)) ([5b1c896](https://github.com/noir-lang/noir/commit/5b1c896c605ed1047fc17a437e0b58792a778e2d))
+* Type variables by default should have Any kind ([#6203](https://github.com/noir-lang/noir/issues/6203)) ([268f2a0](https://github.com/noir-lang/noir/commit/268f2a0240c507646c65c932748d1bdf062d00b1))
+* Unify macro result type with actual type ([#6086](https://github.com/noir-lang/noir/issues/6086)) ([af52873](https://github.com/noir-lang/noir/commit/af52873dbec9ab980d17d9ba4336181c006a9a53))
+* Update databus in flattening ([#6063](https://github.com/noir-lang/noir/issues/6063)) ([e993da1](https://github.com/noir-lang/noir/commit/e993da1b01aa98deed2af7b5cba2da216fb036a0))
+
+
+### Miscellaneous Chores
+
+* Removing implicit numeric generics ([#5837](https://github.com/noir-lang/noir/issues/5837)) ([eda9043](https://github.com/noir-lang/noir/commit/eda904328b269b5926f8a82ab82e52a485903bbe))
+
 ## [0.34.0](https://github.com/noir-lang/noir/compare/v0.33.0...v0.34.0) (2024-09-13)
 
 
diff --git a/CRITICAL_NOIR_LIBRARIES b/CRITICAL_NOIR_LIBRARIES
new file mode 100644
index 00000000000..c753b76a4fc
--- /dev/null
+++ b/CRITICAL_NOIR_LIBRARIES
@@ -0,0 +1,13 @@
+https://github.com/noir-lang/ec
+https://github.com/noir-lang/eddsa
+https://github.com/noir-lang/mimc
+https://github.com/noir-lang/schnorr
+https://github.com/noir-lang/noir_sort
+https://github.com/noir-lang/noir-edwards
+https://github.com/noir-lang/noir-bignum
+https://github.com/noir-lang/noir_bigcurve
+https://github.com/noir-lang/noir_base64
+https://github.com/noir-lang/noir_string_search
+https://github.com/noir-lang/sparse_array
+https://github.com/noir-lang/noir_rsa
+https://github.com/noir-lang/noir_json_parser
diff --git a/Cargo.lock b/Cargo.lock
index cdc1d75a421..4907de7ae62 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -4,7 +4,7 @@ version = 3
 
 [[package]]
 name = "acir"
-version = "0.50.0"
+version = "1.0.0-beta.0"
 dependencies = [
  "acir_field",
  "base64 0.21.7",
@@ -13,7 +13,7 @@ dependencies = [
  "criterion",
  "flate2",
  "fxhash",
- "pprof 0.13.0",
+ "pprof",
  "serde",
  "serde-big-array",
  "serde-generate",
@@ -26,7 +26,7 @@ dependencies = [
 
 [[package]]
 name = "acir_field"
-version = "0.50.0"
+version = "1.0.0-beta.0"
 dependencies = [
  "ark-bls12-381",
  "ark-bn254",
@@ -40,7 +40,7 @@ dependencies = [
 
 [[package]]
 name = "acvm"
-version = "0.50.0"
+version = "1.0.0-beta.0"
 dependencies = [
  "acir",
  "acvm_blackbox_solver",
@@ -48,6 +48,7 @@ dependencies = [
  "ark-bn254",
  "bn254_blackbox_solver",
  "brillig_vm",
+ "fxhash",
  "indexmap 1.9.3",
  "num-bigint",
  "proptest",
@@ -59,7 +60,7 @@ dependencies = [
 
 [[package]]
 name = "acvm_blackbox_solver"
-version = "0.50.0"
+version = "1.0.0-beta.0"
 dependencies = [
  "acir",
  "blake2",
@@ -71,7 +72,6 @@ dependencies = [
  "p256",
  "proptest",
  "sha2",
- "sha3",
  "thiserror",
 ]
 
@@ -90,14 +90,14 @@ dependencies = [
  "proptest",
  "rand 0.8.5",
  "thiserror",
- "toml 0.7.6",
+ "toml 0.7.8",
  "tracing-appender",
  "tracing-subscriber",
 ]
 
 [[package]]
 name = "acvm_js"
-version = "0.50.0"
+version = "1.0.0-beta.0"
 dependencies = [
  "acvm",
  "bn254_blackbox_solver",
@@ -118,9 +118,9 @@ dependencies = [
 
 [[package]]
 name = "addr2line"
-version = "0.20.0"
+version = "0.21.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "f4fa78e18c64fce05e902adecd7a5eed15a5e0a3439f7b0e169f0252214865e3"
+checksum = "8a30b2e23b9e17a9f90641c7ab1549cd9b44f296d3ccbf309d2863cfe398a0cb"
 dependencies = [
  "gimli",
 ]
@@ -132,15 +132,10 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "f26201604c87b1e01bd3d98f8d5d9a8fcbb815e8cedb41ffccbeb4bf593a35fe"
 
 [[package]]
-name = "ahash"
-version = "0.7.8"
+name = "adler2"
+version = "2.0.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "891477e0c6a8957309ee5c45a6368af3ae14bb510732d2684ffa19af310920f9"
-dependencies = [
- "getrandom 0.2.15",
- "once_cell",
- "version_check",
-]
+checksum = "512761e0bb2578dd7380c6baaa0f4ce03e84f95e960231d1dec8bf4d7d6e2627"
 
 [[package]]
 name = "ahash"
@@ -157,13 +152,22 @@ dependencies = [
 
 [[package]]
 name = "aho-corasick"
-version = "1.0.2"
+version = "1.1.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "43f6cb1bf222025340178f382c426f13757b2960e89779dfcb319c32542a5a41"
+checksum = "8e60d3430d3a69478ad0993f19238d2df97c507009a52b3c10addcd7f6bcb916"
 dependencies = [
  "memchr",
 ]
 
+[[package]]
+name = "aligned-vec"
+version = "0.6.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "7e0966165eaf052580bd70eb1b32cb3d6245774c0104d1b2793e9650bf83b52a"
+dependencies = [
+ "equator",
+]
+
 [[package]]
 name = "android-tzdata"
 version = "0.1.1"
@@ -187,57 +191,58 @@ checksum = "4b46cbb362ab8752921c97e041f5e366ee6297bd428a31275b9fcf1e380f7299"
 
 [[package]]
 name = "anstream"
-version = "0.6.4"
+version = "0.6.18"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "2ab91ebe16eb252986481c5b62f6098f3b698a45e34b5b98200cf20dd2484a44"
+checksum = "8acc5369981196006228e28809f761875c0327210a891e941f4c683b3a99529b"
 dependencies = [
  "anstyle",
  "anstyle-parse",
  "anstyle-query",
  "anstyle-wincon",
  "colorchoice",
+ "is_terminal_polyfill",
  "utf8parse",
 ]
 
 [[package]]
 name = "anstyle"
-version = "1.0.1"
+version = "1.0.10"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "3a30da5c5f2d5e72842e00bcb57657162cdabef0931f40e2deb9b4140440cecd"
+checksum = "55cc3b69f167a1ef2e161439aa98aed94e6028e5f9a59be9a6ffb47aef1651f9"
 
 [[package]]
 name = "anstyle-parse"
-version = "0.2.1"
+version = "0.2.6"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "938874ff5980b03a87c5524b3ae5b59cf99b1d6bc836848df7bc5ada9643c333"
+checksum = "3b2d16507662817a6a20a9ea92df6652ee4f94f914589377d69f3b21bc5798a9"
 dependencies = [
  "utf8parse",
 ]
 
 [[package]]
 name = "anstyle-query"
-version = "1.0.0"
+version = "1.1.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "5ca11d4be1bab0c8bc8734a9aa7bf4ee8316d462a08c6ac5052f888fef5b494b"
+checksum = "79947af37f4177cfead1110013d678905c37501914fba0efea834c3fe9a8d60c"
 dependencies = [
- "windows-sys 0.48.0",
+ "windows-sys 0.59.0",
 ]
 
 [[package]]
 name = "anstyle-wincon"
-version = "3.0.1"
+version = "3.0.6"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "f0699d10d2f4d628a98ee7b57b289abbc98ff3bad977cb3152709d4bf2330628"
+checksum = "2109dbce0e72be3ec00bed26e6a7479ca384ad226efdd66db8fa2e3a38c83125"
 dependencies = [
  "anstyle",
- "windows-sys 0.48.0",
+ "windows-sys 0.59.0",
 ]
 
 [[package]]
 name = "anyhow"
-version = "1.0.75"
+version = "1.0.93"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "a4668cab20f66d8d020e1fbc0ebe47217433c1b6c8f2040faf858554e394ace6"
+checksum = "4c95c10ba0b00a02636238b814946408b1322d5ac4760326e6fb8ec956d85775"
 
 [[package]]
 name = "ark-bls12-381"
@@ -370,26 +375,27 @@ dependencies = [
 
 [[package]]
 name = "arrayref"
-version = "0.3.7"
+version = "0.3.9"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "6b4930d2cb77ce62f89ee5d5289b4ac049559b1c45539271f5ed4fdc7db34545"
+checksum = "76a2e8124351fda1ef8aaaa3bbd7ebbcb486bbcd4225aca0aa0d84bb2db8fecb"
 
 [[package]]
 name = "arrayvec"
-version = "0.7.4"
+version = "0.7.6"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "96d30a06541fbafbc7f82ed10c06164cfbd2c401138f6addd8404629c4b16711"
+checksum = "7c02d123df017efcdfbd739ef81735b36c5ba83ec3c59c80a9d7ecc718f92e50"
 
 [[package]]
 name = "assert_cmd"
-version = "2.0.12"
+version = "2.0.16"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "88903cb14723e4d4003335bb7f8a14f27691649105346a0f0957466c096adfe6"
+checksum = "dc1835b7f27878de8525dc71410b5a31cdcc5f230aed5ba5df968e09c201b23d"
 dependencies = [
  "anstyle",
- "bstr 1.6.0",
+ "bstr",
  "doc-comment",
- "predicates 3.0.3",
+ "libc",
+ "predicates 3.1.2",
  "predicates-core",
  "predicates-tree",
  "wait-timeout",
@@ -397,14 +403,14 @@ dependencies = [
 
 [[package]]
 name = "assert_fs"
-version = "1.0.13"
+version = "1.1.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "f070617a68e5c2ed5d06ee8dd620ee18fb72b99f6c094bed34cf8ab07c875b48"
+checksum = "7efdb1fdb47602827a342857666feb372712cbc64b414172bd6b167a02927674"
 dependencies = [
  "anstyle",
  "doc-comment",
  "globwalk",
- "predicates 3.0.3",
+ "predicates 3.1.2",
  "predicates-core",
  "predicates-tree",
  "tempfile",
@@ -416,7 +422,7 @@ version = "0.1.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "138985dd8aefbefeaa66b01b7f5b2b6b4c333fcef1cc5f32c63a2aabe37d6de3"
 dependencies = [
- "futures 0.3.30",
+ "futures 0.3.31",
  "lsp-types 0.94.1",
  "pin-project-lite",
  "rustix",
@@ -432,21 +438,21 @@ dependencies = [
 
 [[package]]
 name = "autocfg"
-version = "1.1.0"
+version = "1.4.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "d468802bab17cbc0cc575e9b053f41e72aa36bfa6b7f55e3529ffa43161b97fa"
+checksum = "ace50bade8e6234aa140d9a2f552bbee1db4d353f69b8217bc503490fc1a9f26"
 
 [[package]]
 name = "backtrace"
-version = "0.3.68"
+version = "0.3.71"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "4319208da049c43661739c5fade2ba182f09d1dc2299b32298d3a31692b17e12"
+checksum = "26b05800d2e817c8b3b4b54abd461726265fa9789ae34330622f2db9ee696f9d"
 dependencies = [
  "addr2line",
  "cc",
  "cfg-if 1.0.0",
  "libc",
- "miniz_oxide",
+ "miniz_oxide 0.7.4",
  "object",
  "rustc-demangle",
 ]
@@ -469,6 +475,12 @@ version = "0.21.7"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "9d297deb1925b89f2ccc13d7635fa0714f12c87adce1c75356b39ca9b7178567"
 
+[[package]]
+name = "base64"
+version = "0.22.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "72b3254f16251a8381aa12e40e3c4d2f0199f8c6508fbecb9d91f575e0fbb8c6"
+
 [[package]]
 name = "base64ct"
 version = "1.6.0"
@@ -507,9 +519,9 @@ checksum = "bef38d45163c2f1dde094a7dfd33ccf595c92905c8f8f4fdc18d06fb1037718a"
 
 [[package]]
 name = "bitflags"
-version = "2.5.0"
+version = "2.6.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "cf4b9d6a944f767f8e5e0db018570623c85f3d925ac718db4e06d0187adb21c1"
+checksum = "b048fb63fd8b5923fc5aa7b340d8e156aec7ec02f0c78fa8a6ddc2613f6f71de"
 
 [[package]]
 name = "bitmaps"
@@ -554,9 +566,9 @@ dependencies = [
 
 [[package]]
 name = "blake3"
-version = "1.5.0"
+version = "1.5.4"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "0231f06152bf547e9c2b5194f247cd97aacf6dcd8b15d8e5ec0663f64580da87"
+checksum = "d82033247fd8e890df8f740e407ad4d038debb9eb1f40533fffb32e7d17dc6f7"
 dependencies = [
  "arrayref",
  "arrayvec",
@@ -589,7 +601,7 @@ dependencies = [
 
 [[package]]
 name = "bn254_blackbox_solver"
-version = "0.50.0"
+version = "1.0.0-beta.0"
 dependencies = [
  "acir",
  "acvm_blackbox_solver",
@@ -602,12 +614,12 @@ dependencies = [
  "lazy_static",
  "noir_grumpkin",
  "num-bigint",
- "pprof 0.12.1",
+ "pprof",
 ]
 
 [[package]]
 name = "brillig"
-version = "0.50.0"
+version = "1.0.0-beta.0"
 dependencies = [
  "acir_field",
  "serde",
@@ -615,7 +627,7 @@ dependencies = [
 
 [[package]]
 name = "brillig_vm"
-version = "0.50.0"
+version = "1.0.0-beta.0"
 dependencies = [
  "acir",
  "acvm_blackbox_solver",
@@ -626,31 +638,20 @@ dependencies = [
 
 [[package]]
 name = "bstr"
-version = "0.2.17"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "ba3569f383e8f1598449f1a423e72e99569137b47740b1da11ef19af3d5c3223"
-dependencies = [
- "lazy_static",
- "memchr",
- "regex-automata 0.1.10",
-]
-
-[[package]]
-name = "bstr"
-version = "1.6.0"
+version = "1.10.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "6798148dccfbff0fae41c7574d2fa8f1ef3492fba0face179de5d8d447d67b05"
+checksum = "40723b8fb387abc38f4f4a37c09073622e41dd12327033091ef8950659e6dc0c"
 dependencies = [
  "memchr",
- "regex-automata 0.3.9",
+ "regex-automata 0.4.8",
  "serde",
 ]
 
 [[package]]
 name = "build-data"
-version = "0.1.4"
+version = "0.1.5"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "4ac83c47416b2db78a5a8a45d7d229a730b62806fa41ac6b4dbde6d016798776"
+checksum = "aed3884e2cab7c973c8fd2d150314b6a932df7fdc830edcaf1e8e7c4ae9db3c0"
 dependencies = [
  "chrono",
  "safe-lock",
@@ -659,48 +660,42 @@ dependencies = [
 
 [[package]]
 name = "bumpalo"
-version = "3.13.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "a3e2c3daef883ecc1b5d58c15adae93470a91d425f3532ba1695849656af3fc1"
-
-[[package]]
-name = "bytecount"
-version = "0.6.3"
+version = "3.16.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "2c676a478f63e9fa2dd5368a42f28bba0d6c560b775f38583c8bbaa7fcd67c9c"
+checksum = "79296716171880943b8470b5f8d03aa55eb2e645a4874bdbb28adb49162e012c"
 
 [[package]]
 name = "bytemuck"
-version = "1.13.1"
+version = "1.19.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "17febce684fd15d89027105661fec94afb475cb995fbc59d2865198446ba2eea"
+checksum = "8334215b81e418a0a7bdb8ef0849474f40bb10c8b71f1c4ed315cff49f32494d"
 
 [[package]]
 name = "byteorder"
-version = "1.4.3"
+version = "1.5.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "14c189c53d098945499cdfa7ecc63567cf3886b3332b312a5b4585d8d3a6a610"
+checksum = "1fd0f2584146f6f2ef48085050886acf353beff7305ebd1ae69500e27c67f64b"
 
 [[package]]
 name = "bytes"
-version = "1.4.0"
+version = "1.8.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "89b2fd2a0dcf38d7971e2194b6b6eebab45ae01067456a7fd93d5547a61b70be"
+checksum = "9ac0150caa2ae65ca5bd83f25c7de183dea78d4d366469f148435e2acfbad0da"
 
 [[package]]
 name = "camino"
-version = "1.1.6"
+version = "1.1.9"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "c59e92b5a388f549b863a7bea62612c09f24c8393560709a54558a9abdfb3b9c"
+checksum = "8b96ec4966b5813e2c0507c1f86115c8c5abaadc3980879c3424042a02fd1ad3"
 dependencies = [
  "serde",
 ]
 
 [[package]]
 name = "cargo-platform"
-version = "0.1.3"
+version = "0.1.8"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "2cfa25e60aea747ec7e1124f238816749faa93759c6ff5b31f1ccdda137f4479"
+checksum = "24b1f0365a6c6bb4020cd05806fd0d33c44d38046b8bd7f0e40814b9763cabfc"
 dependencies = [
  "serde",
 ]
@@ -727,11 +722,11 @@ checksum = "37b2a672a2cb129a2e41c10b1224bb368f9f37a2b16b612598138befd7b37eb5"
 
 [[package]]
 name = "cc"
-version = "1.0.83"
+version = "1.1.36"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "f1174fb0b6ec23863f8b971027804a42614e347eafb0a95bf0b12cdae21fc4d0"
+checksum = "baee610e9452a8f6f0a1b6194ec09ff9e2d85dea54432acdae41aa0761c95d70"
 dependencies = [
- "libc",
+ "shlex",
 ]
 
 [[package]]
@@ -761,19 +756,11 @@ dependencies = [
  "windows-targets 0.52.6",
 ]
 
-[[package]]
-name = "chumsky"
-version = "0.8.0"
-source = "git+https://github.com/jfecher/chumsky?rev=ad9d312#ad9d312d9ffbc66c14514fa2b5752f4127b44f1e"
-dependencies = [
- "hashbrown 0.11.2",
-]
-
 [[package]]
 name = "ciborium"
-version = "0.2.1"
+version = "0.2.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "effd91f6c78e5a4ace8a5d3c0b6bfaec9e2baaef55f3efc00e45fb2e477ee926"
+checksum = "42e69ffd6f0917f5c029256a24d0161db17cea3997d185db0d35926308770f0e"
 dependencies = [
  "ciborium-io",
  "ciborium-ll",
@@ -782,15 +769,15 @@ dependencies = [
 
 [[package]]
 name = "ciborium-io"
-version = "0.2.1"
+version = "0.2.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "cdf919175532b369853f5d5e20b26b43112613fd6fe7aee757e35f7a44642656"
+checksum = "05afea1e0a06c9be33d539b876f1ce3692f4afea2cb41f740e7743225ed1c757"
 
 [[package]]
 name = "ciborium-ll"
-version = "0.2.1"
+version = "0.2.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "defaa24ecc093c77630e6c15e17c51f5e187bf35ee514f4e2d67baaa96dae22b"
+checksum = "57663b653d948a338bfb3eeba9bb2fd5fcfaecb9e199e87e1eda4d9e8b240fd9"
 dependencies = [
  "ciborium-io",
  "half",
@@ -798,9 +785,9 @@ dependencies = [
 
 [[package]]
 name = "clap"
-version = "4.4.11"
+version = "4.5.20"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "bfaff671f6b22ca62406885ece523383b9b64022e341e53e009a62ebc47a45f2"
+checksum = "b97f376d85a664d5837dbae44bf546e6477a679ff6610010f17276f686d867e8"
 dependencies = [
  "clap_builder",
  "clap_derive",
@@ -816,9 +803,9 @@ dependencies = [
 
 [[package]]
 name = "clap_builder"
-version = "4.4.11"
+version = "4.5.20"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "a216b506622bb1d316cd51328dce24e07bdff4a6128a47c7e7fad11878d5adbb"
+checksum = "19bc80abd44e4bed93ca373a0704ccbd1b710dc5749406201bb018272808dc54"
 dependencies = [
  "anstream",
  "anstyle",
@@ -826,23 +813,32 @@ dependencies = [
  "strsim",
 ]
 
+[[package]]
+name = "clap_complete"
+version = "4.5.37"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "11611dca53440593f38e6b25ec629de50b14cdfa63adc0fb856115a2c6d97595"
+dependencies = [
+ "clap",
+]
+
 [[package]]
 name = "clap_derive"
-version = "4.4.7"
+version = "4.5.18"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "cf9804afaaf59a91e75b022a30fb7229a7901f60c755489cc61c9b423b836442"
+checksum = "4ac6a0c7b1a9e9a5186361f67dfa1b88213572f427fb9ab038efb2bd8c582dab"
 dependencies = [
- "heck 0.4.1",
+ "heck 0.5.0",
  "proc-macro2",
  "quote",
- "syn 2.0.64",
+ "syn 2.0.87",
 ]
 
 [[package]]
 name = "clap_lex"
-version = "0.6.0"
+version = "0.7.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "702fc72eb24e5a1e48ce58027a675bc24edd52096d5397d4aea7c6dd9eca0bd1"
+checksum = "1462739cb27611015575c0c11df5df7601141071f07518d56fcc1be504cbec97"
 
 [[package]]
 name = "clipboard-win"
@@ -873,7 +869,7 @@ checksum = "fc4159b76af02757139baf42c0c971c6dc155330999fbfd8eddb29b97fb2db68"
 dependencies = [
  "codespan-reporting",
  "lsp-types 0.88.0",
- "url 2.5.0",
+ "url 2.5.4",
 ]
 
 [[package]]
@@ -889,9 +885,9 @@ dependencies = [
 
 [[package]]
 name = "color-eyre"
-version = "0.6.2"
+version = "0.6.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "5a667583cca8c4f8436db8de46ea8233c42a7d9ae424a82d338f2e4675229204"
+checksum = "55146f5e46f237f7423d74111267d4597b59b0dad0ffaf7303bce9945d843ad5"
 dependencies = [
  "backtrace",
  "color-spantrace",
@@ -904,9 +900,9 @@ dependencies = [
 
 [[package]]
 name = "color-spantrace"
-version = "0.2.0"
+version = "0.2.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "1ba75b3d9449ecdccb27ecbc479fdc0b87fa2dd43d2f8298f9bf0e59aacc8dce"
+checksum = "cd6be1b2a7e382e2b98b43b2adcca6bb0e465af0bdd38123873ae61eb17a72c2"
 dependencies = [
  "once_cell",
  "owo-colors",
@@ -916,9 +912,9 @@ dependencies = [
 
 [[package]]
 name = "colorchoice"
-version = "1.0.0"
+version = "1.0.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "acbf1af155f9b9ef647e42cdc158db4b64a1b61f743629225fde6f3e0be2a7c7"
+checksum = "5b63caa9aa9397e2d9480a9b13673856c78d8ac123288526c37d7839f2a86990"
 
 [[package]]
 name = "comma"
@@ -950,30 +946,30 @@ dependencies = [
 
 [[package]]
 name = "const-oid"
-version = "0.9.4"
+version = "0.9.6"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "795bc6e66a8e340f075fcf6227e417a2dc976b92b91f3cdc778bb858778b6747"
+checksum = "c2459377285ad874054d797f3ccebf984978aa39129f6eafde5cdc8315b612f8"
 
 [[package]]
 name = "const-str"
-version = "0.5.6"
+version = "0.5.7"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "aca749d3d3f5b87a0d6100509879f9cf486ab510803a4a4e1001da1ff61c2bd6"
+checksum = "3618cccc083bb987a415d85c02ca6c9994ea5b44731ec28b9ecf09658655fba9"
 
 [[package]]
 name = "const_format"
-version = "0.2.31"
+version = "0.2.33"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "c990efc7a285731f9a4378d81aff2f0e85a2c8781a05ef0f8baa8dac54d0ff48"
+checksum = "50c655d81ff1114fb0dcdea9225ea9f0cc712a6f8d189378e82bdf62a473a64b"
 dependencies = [
  "const_format_proc_macros",
 ]
 
 [[package]]
 name = "const_format_proc_macros"
-version = "0.2.31"
+version = "0.2.33"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "e026b6ce194a874cb9cf32cd5772d1ef9767cc8fcb5765948d74f37a9d8b2bf6"
+checksum = "eff1a44b93f47b1bac19a27932f5c591e43d1ba357ee4f61526c8a25603f0eb1"
 dependencies = [
  "proc-macro2",
  "quote",
@@ -982,9 +978,9 @@ dependencies = [
 
 [[package]]
 name = "constant_time_eq"
-version = "0.3.0"
+version = "0.3.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "f7144d30dcf0fafbce74250a3963025d8d52177934239851c917d29f1df280c2"
+checksum = "7c74b8349d32d297c9134b8c88677813a227df8f779daa29bfc29c183fe3dca6"
 
 [[package]]
 name = "convert_case"
@@ -1003,33 +999,33 @@ dependencies = [
 
 [[package]]
 name = "core-foundation-sys"
-version = "0.8.6"
+version = "0.8.7"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "06ea2b9bc92be3c2baa9334a323ebca2d6f074ff852cd1d7b11064035cd3868f"
+checksum = "773648b94d0e5d620f64f280777445740e61fe701025087ec8b57f45c791888b"
 
 [[package]]
 name = "cpp_demangle"
-version = "0.4.2"
+version = "0.4.4"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "ee34052ee3d93d6d8f3e6f81d85c47921f6653a19a7b70e939e3e602d893a674"
+checksum = "96e58d342ad113c2b878f16d5d034c03be492ae460cdbc02b7f0f2284d310c7d"
 dependencies = [
  "cfg-if 1.0.0",
 ]
 
 [[package]]
 name = "cpufeatures"
-version = "0.2.9"
+version = "0.2.14"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "a17b76ff3a4162b0b27f354a0c87015ddad39d35f9c0c36607a3bdd175dde1f1"
+checksum = "608697df725056feaccfa42cffdaeeec3fccc4ffc38358ecd19b243e716a78e0"
 dependencies = [
  "libc",
 ]
 
 [[package]]
 name = "crc32fast"
-version = "1.3.2"
+version = "1.4.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "b540bd8bc810d3885c6ea91e2018302f68baba2129ab3e88f32389ee9370880d"
+checksum = "a97769d94ddab943e4510d138150169a2758b5ef3eb191a9ee688de3e23ef7b3"
 dependencies = [
  "cfg-if 1.0.0",
 ]
@@ -1072,43 +1068,43 @@ dependencies = [
 
 [[package]]
 name = "crossbeam-channel"
-version = "0.5.9"
+version = "0.5.13"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "14c3242926edf34aec4ac3a77108ad4854bffaa2e4ddc1824124ce59231302d5"
+checksum = "33480d6946193aa8033910124896ca395333cae7e2d1113d1fef6c3272217df2"
 dependencies = [
- "cfg-if 1.0.0",
  "crossbeam-utils",
 ]
 
 [[package]]
 name = "crossbeam-deque"
-version = "0.8.3"
+version = "0.8.5"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "ce6fd6f855243022dcecf8702fef0c297d4338e226845fe067f6341ad9fa0cef"
+checksum = "613f8cc01fe9cf1a3eb3d7f488fd2fa8388403e97039e2f73692932e291a770d"
 dependencies = [
- "cfg-if 1.0.0",
  "crossbeam-epoch",
  "crossbeam-utils",
 ]
 
 [[package]]
 name = "crossbeam-epoch"
-version = "0.9.15"
+version = "0.9.18"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "ae211234986c545741a7dc064309f67ee1e5ad243d0e48335adc0484d960bcc7"
+checksum = "5b82ac4a3c2ca9c3460964f020e1402edd5753411d7737aa39c3714ad1b5420e"
 dependencies = [
- "autocfg",
- "cfg-if 1.0.0",
  "crossbeam-utils",
- "memoffset 0.9.1",
- "scopeguard",
 ]
 
 [[package]]
 name = "crossbeam-utils"
-version = "0.8.19"
+version = "0.8.20"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "22ec99545bb0ed0ea7bb9b8e1e9122ea386ff8a48c0922e43f36d45ab09e0e80"
+
+[[package]]
+name = "crunchy"
+version = "0.2.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "248e3bacc7dc6baa3b21e405ee045c3047101a49145e7e9eca583ab4c2ca5345"
+checksum = "7a81dae078cea95a014a339291cec439d2f232ebe854a9d672b796c6afafa9b7"
 
 [[package]]
 name = "crypto-bigint"
@@ -1134,9 +1130,9 @@ dependencies = [
 
 [[package]]
 name = "csv"
-version = "1.2.2"
+version = "1.3.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "626ae34994d3d8d668f4269922248239db4ae42d538b14c398b74a52208e8086"
+checksum = "ac574ff4d437a7b5ad237ef331c17ccca63c46479e5b5453eb8e10bb99a759fe"
 dependencies = [
  "csv-core",
  "itoa",
@@ -1146,9 +1142,9 @@ dependencies = [
 
 [[package]]
 name = "csv-core"
-version = "0.1.10"
+version = "0.1.11"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "2b2466559f260f48ad25fe6317b3c8dac77b5bdb5763ac7d9d6103530663bc90"
+checksum = "5efa2b3d7902f4b634a20cae3c9c4e6209dc4779feb6863329607560143efa70"
 dependencies = [
  "memchr",
 ]
@@ -1166,9 +1162,9 @@ dependencies = [
 
 [[package]]
 name = "darling"
-version = "0.20.3"
+version = "0.20.10"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "0209d94da627ab5605dcccf08bb18afa5009cfbef48d8a8b7d7bdbc79be25c5e"
+checksum = "6f63b86c8a8826a49b8c21f08a2d07338eec8d900540f8630dc76284be802989"
 dependencies = [
  "darling_core",
  "darling_macro",
@@ -1176,40 +1172,41 @@ dependencies = [
 
 [[package]]
 name = "darling_core"
-version = "0.20.3"
+version = "0.20.10"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "177e3443818124b357d8e76f53be906d60937f0d3a90773a664fa63fa253e621"
+checksum = "95133861a8032aaea082871032f5815eb9e98cef03fa916ab4500513994df9e5"
 dependencies = [
  "fnv",
  "ident_case",
  "proc-macro2",
  "quote",
  "strsim",
- "syn 2.0.64",
+ "syn 2.0.87",
 ]
 
 [[package]]
 name = "darling_macro"
-version = "0.20.3"
+version = "0.20.10"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "836a9bbc7ad63342d6d6e7b815ccab164bc77a2d95d84bc3117a8c0d5c98e2d5"
+checksum = "d336a2a514f6ccccaa3e09b02d41d35330c07ddf03a62165fcec10bb561c7806"
 dependencies = [
  "darling_core",
  "quote",
- "syn 2.0.64",
+ "syn 2.0.87",
 ]
 
 [[package]]
 name = "dashmap"
-version = "5.5.3"
+version = "6.1.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "978747c1d849a7d2ee5e8adc0159961c48fb7e5db2f06af6723b80123bb53856"
+checksum = "5041cc499144891f3790297212f32a74fb938e5136a14943f338ef9e0ae276cf"
 dependencies = [
  "cfg-if 1.0.0",
+ "crossbeam-utils",
  "hashbrown 0.14.5",
  "lock_api",
  "once_cell",
- "parking_lot_core 0.9.8",
+ "parking_lot_core 0.9.10",
 ]
 
 [[package]]
@@ -1233,10 +1230,11 @@ dependencies = [
 
 [[package]]
 name = "deranged"
-version = "0.3.7"
+version = "0.3.11"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "7684a49fb1af197853ef7b2ee694bc1f5b4179556f1e5710e1760c5db6f5e929"
+checksum = "b42b6fa04a440b495c8b04d0e71b707c585f83cb9cb28cf8cd0d976c315e31b4"
 dependencies = [
+ "powerfmt",
  "serde",
 ]
 
@@ -1253,15 +1251,15 @@ dependencies = [
 
 [[package]]
 name = "derive_more"
-version = "0.99.17"
+version = "0.99.18"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "4fb810d30a7c1953f91334de7244731fc3f3c10d7fe163338a35b9f640960321"
+checksum = "5f33878137e4dafd7fa914ad4e259e18a4e8e532b9617a2d0150262bf53abfce"
 dependencies = [
  "convert_case 0.4.0",
  "proc-macro2",
  "quote",
  "rustc_version",
- "syn 1.0.109",
+ "syn 2.0.87",
 ]
 
 [[package]]
@@ -1322,6 +1320,17 @@ dependencies = [
  "winapi",
 ]
 
+[[package]]
+name = "displaydoc"
+version = "0.2.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "97369cbbc041bc366949bc74d34658d6cda5621039731c6310521892a3a20ae0"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn 2.0.87",
+]
+
 [[package]]
 name = "doc-comment"
 version = "0.3.3"
@@ -1357,9 +1366,9 @@ dependencies = [
 
 [[package]]
 name = "either"
-version = "1.8.1"
+version = "1.13.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "7fcaabb2fef8c910e7f4c7ce9f67a1283a1715879a7c230ca9d6d1ae31f16d91"
+checksum = "60b1af1c220855b6ceac025d3f6ecdd2b7c4894bfe9cd9bda4fbb4bc7c0d4cf0"
 
 [[package]]
 name = "elliptic-curve"
@@ -1399,15 +1408,45 @@ version = "0.1.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "c34f04666d835ff5d62e058c3995147c06f42fe86ff053337632bca83e42702d"
 
+[[package]]
+name = "env_filter"
+version = "0.1.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "4f2c92ceda6ceec50f43169f9ee8424fe2db276791afde7b2cd8bc084cb376ab"
+dependencies = [
+ "log",
+]
+
 [[package]]
 name = "env_logger"
-version = "0.10.2"
+version = "0.11.5"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "4cd405aab171cb85d6735e5c8d9db038c17d3ca007a4d2c25f337935c3d90580"
+checksum = "e13fa619b91fb2381732789fc5de83b45675e882f66623b7d8cb4f643017018d"
 dependencies = [
+ "env_filter",
  "log",
 ]
 
+[[package]]
+name = "equator"
+version = "0.2.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "c35da53b5a021d2484a7cc49b2ac7f2d840f8236a286f84202369bd338d761ea"
+dependencies = [
+ "equator-macro",
+]
+
+[[package]]
+name = "equator-macro"
+version = "0.2.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "3bf679796c0322556351f287a51b49e48f7c4986e727b5dd78c972d30e2e16cc"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn 2.0.87",
+]
+
 [[package]]
 name = "equivalent"
 version = "1.0.1"
@@ -1436,9 +1475,9 @@ dependencies = [
 
 [[package]]
 name = "eyre"
-version = "0.6.8"
+version = "0.6.12"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "4c2b6b5a29c02cdc822728b7d7b8ae1bab3e3b05d44522770ddd49722eeac7eb"
+checksum = "7cd915d99f24784cdc19fd37ef22b97e3ff0ae756c7e492e9fbfe897d61e2aec"
 dependencies = [
  "indenter",
  "once_cell",
@@ -1446,9 +1485,9 @@ dependencies = [
 
 [[package]]
 name = "fastrand"
-version = "2.0.1"
+version = "2.2.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "25cbce373ec4653f1a01a31e8a5e5ec0c622dc27ff9c4e6606eefef5cbbed4a5"
+checksum = "486f806e73c5707928240ddc295403b1b93c96a02038563881c4a2fd84b81ac4"
 
 [[package]]
 name = "fd-lock"
@@ -1494,23 +1533,33 @@ dependencies = [
 
 [[package]]
 name = "file-id"
-version = "0.2.1"
+version = "0.2.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "6584280525fb2059cba3db2c04abf947a1a29a45ddae89f3870f8281704fafc9"
+checksum = "6bc904b9bbefcadbd8e3a9fb0d464a9b979de6324c03b3c663e8994f46a5be36"
 dependencies = [
- "windows-sys 0.48.0",
+ "windows-sys 0.52.0",
+]
+
+[[package]]
+name = "file-lock"
+version = "2.1.11"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "040b48f80a749da50292d0f47a1e2d5bf1d772f52836c07f64bfccc62ba6e664"
+dependencies = [
+ "cc",
+ "libc",
 ]
 
 [[package]]
 name = "filetime"
-version = "0.2.22"
+version = "0.2.25"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "d4029edd3e734da6fe05b6cd7bd2960760a616bd2ddd0d59a0124746d6272af0"
+checksum = "35c0522e981e68cbfa8c3f978441a5f34b30b96e146b33cd3359176b50fe8586"
 dependencies = [
  "cfg-if 1.0.0",
  "libc",
- "redox_syscall 0.3.5",
- "windows-sys 0.48.0",
+ "libredox 0.1.3",
+ "windows-sys 0.59.0",
 ]
 
 [[package]]
@@ -1533,12 +1582,12 @@ checksum = "0ce7134b9999ecaf8bcd65542e436736ef32ddca1b3e06094cb6ec5755203b80"
 
 [[package]]
 name = "flate2"
-version = "1.0.28"
+version = "1.0.34"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "46303f565772937ffe1d394a4fac6f411c6013172fadde9dcdb1e147a086940e"
+checksum = "a1b589b4dc103969ad3cf85c950899926ec64300a1a46d76c03a6072957036f0"
 dependencies = [
  "crc32fast",
- "miniz_oxide",
+ "miniz_oxide 0.8.0",
 ]
 
 [[package]]
@@ -1552,7 +1601,7 @@ dependencies = [
 
 [[package]]
 name = "fm"
-version = "0.34.0"
+version = "1.0.0-beta.0"
 dependencies = [
  "codespan-reporting",
  "iter-extended",
@@ -1597,9 +1646,9 @@ checksum = "3a471a38ef8ed83cd6e40aa59c1ffe17db6855c18e3604d9c4ed8c08ebc28678"
 
 [[package]]
 name = "futures"
-version = "0.3.30"
+version = "0.3.31"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "645c6916888f6cb6350d2550b80fb63e734897a8498abe35cfb732b6487804b0"
+checksum = "65bc07b1a8bc7c85c5f2e110c476c7389b4554ba72af57d8445ea63a576b0876"
 dependencies = [
  "futures-channel",
  "futures-core",
@@ -1612,9 +1661,9 @@ dependencies = [
 
 [[package]]
 name = "futures-channel"
-version = "0.3.30"
+version = "0.3.31"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "eac8f7d7865dcb88bd4373ab671c8cf4508703796caa2b1985a9ca867b3fcb78"
+checksum = "2dff15bf788c671c1934e366d07e30c1814a8ef514e1af724a602e8a2fbe1b10"
 dependencies = [
  "futures-core",
  "futures-sink",
@@ -1622,15 +1671,15 @@ dependencies = [
 
 [[package]]
 name = "futures-core"
-version = "0.3.30"
+version = "0.3.31"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "dfc6580bb841c5a68e9ef15c77ccc837b40a7504914d52e47b8b0e9bbda25a1d"
+checksum = "05f29059c0c2090612e8d742178b0580d2dc940c837851ad723096f87af6663e"
 
 [[package]]
 name = "futures-executor"
-version = "0.3.30"
+version = "0.3.31"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "a576fc72ae164fca6b9db127eaa9a9dda0d61316034f33a0a0d4eda41f02b01d"
+checksum = "1e28d1d997f585e54aebc3f97d39e72338912123a67330d723fdbb564d646c9f"
 dependencies = [
  "futures-core",
  "futures-task",
@@ -1640,38 +1689,38 @@ dependencies = [
 
 [[package]]
 name = "futures-io"
-version = "0.3.30"
+version = "0.3.31"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "a44623e20b9681a318efdd71c299b6b222ed6f231972bfe2f224ebad6311f0c1"
+checksum = "9e5c1b78ca4aae1ac06c48a526a655760685149f0d465d21f37abfe57ce075c6"
 
 [[package]]
 name = "futures-macro"
-version = "0.3.30"
+version = "0.3.31"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "87750cf4b7a4c0625b1529e4c543c2182106e4dedc60a2a6455e00d212c489ac"
+checksum = "162ee34ebcb7c64a8abebc059ce0fee27c2262618d7b60ed8faf72fef13c3650"
 dependencies = [
  "proc-macro2",
  "quote",
- "syn 2.0.64",
+ "syn 2.0.87",
 ]
 
 [[package]]
 name = "futures-sink"
-version = "0.3.30"
+version = "0.3.31"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "9fb8e00e87438d937621c1c6269e53f536c14d3fbd6a042bb24879e57d474fb5"
+checksum = "e575fab7d1e0dcb8d0c7bcf9a63ee213816ab51902e6d244a95819acacf1d4f7"
 
 [[package]]
 name = "futures-task"
-version = "0.3.30"
+version = "0.3.31"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "38d84fa142264698cdce1a9f9172cf383a0c82de1bddcf3092901442c4097004"
+checksum = "f90f7dce0722e95104fcb095585910c0977252f286e354b5e3bd38902cd99988"
 
 [[package]]
 name = "futures-util"
-version = "0.3.30"
+version = "0.3.31"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "3d6401deb83407ab3da39eba7e33987a73c3df0c82b4bb5813ee871c19c41d48"
+checksum = "9fa08315bb612088cc391249efdc3bc77536f16c91f6cf495e6fbe85b20a4a81"
 dependencies = [
  "futures 0.1.31",
  "futures-channel",
@@ -1731,9 +1780,9 @@ dependencies = [
 
 [[package]]
 name = "gimli"
-version = "0.27.3"
+version = "0.28.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "b6c80984affa11d98d1b88b66ac8853f143217b399d3c74116778ff8fdb4ed2e"
+checksum = "4271d37baee1b8c7e4b708028c57d816cf9d2434acb33a549475f78c181f6253"
 
 [[package]]
 name = "glob"
@@ -1743,24 +1792,24 @@ checksum = "d2fabcfbdc87f4758337ca535fb41a6d701b65693ce38287d856d1674551ec9b"
 
 [[package]]
 name = "globset"
-version = "0.4.11"
+version = "0.4.15"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "1391ab1f92ffcc08911957149833e682aa3fe252b9f45f966d2ef972274c97df"
+checksum = "15f1ce686646e7f1e19bf7d5533fe443a45dbfb990e00629110797578b42fb19"
 dependencies = [
  "aho-corasick",
- "bstr 1.6.0",
- "fnv",
+ "bstr",
  "log",
- "regex",
+ "regex-automata 0.4.8",
+ "regex-syntax 0.8.5",
 ]
 
 [[package]]
 name = "globwalk"
-version = "0.8.1"
+version = "0.9.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "93e3af942408868f6934a7b85134a3230832b9977cf66125df2f9edcfce4ddcc"
+checksum = "0bf760ebf69878d9fd8f110c89703d90ce35095324d1f1edcb595c63945ee757"
 dependencies = [
- "bitflags 1.3.2",
+ "bitflags 2.6.0",
  "ignore",
  "walkdir",
 ]
@@ -1803,9 +1852,13 @@ dependencies = [
 
 [[package]]
 name = "half"
-version = "1.8.2"
+version = "2.4.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "eabb4a44450da02c90444cf74558da904edde8fb4e9035a9a6a4e15445af0bd7"
+checksum = "6dd08c532ae367adf81c312a4580bc67f1d0fe8bc9c460520283f4c0ff277888"
+dependencies = [
+ "cfg-if 1.0.0",
+ "crunchy",
+]
 
 [[package]]
 name = "halo2"
@@ -1830,15 +1883,6 @@ dependencies = [
  "rayon",
 ]
 
-[[package]]
-name = "hashbrown"
-version = "0.11.2"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "ab5ef0d4909ef3724cc8cce6ccc8572c5c817592e9285f5464f8e86f8bd3726e"
-dependencies = [
- "ahash 0.7.8",
-]
-
 [[package]]
 name = "hashbrown"
 version = "0.12.3"
@@ -1851,7 +1895,7 @@ version = "0.13.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "43a3c133739dddd0d2990f9a4bdf8eb4b21ef50e4851ca85ab661199821d510e"
 dependencies = [
- "ahash 0.8.11",
+ "ahash",
 ]
 
 [[package]]
@@ -1860,6 +1904,12 @@ version = "0.14.5"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "e5274423e17b7c9fc20b6e7e208532f9b19825d82dfd615708b70edd83df41f1"
 
+[[package]]
+name = "hashbrown"
+version = "0.15.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "3a9bfc1af68b1726ea47d3d5109de126281def866b33970e10fbab11b5dafab3"
+
 [[package]]
 name = "heck"
 version = "0.3.3"
@@ -1875,11 +1925,23 @@ version = "0.4.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "95505c38b4572b2d910cecb0281560f54b440a19336cbbcb27bf6ce6adc6f5a8"
 
+[[package]]
+name = "heck"
+version = "0.5.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "2304e00983f87ffb38b55b444b5e3b60a884b5d30c0fca7d82fe33449bbe55ea"
+
 [[package]]
 name = "hermit-abi"
-version = "0.3.2"
+version = "0.3.9"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "443144c8cdadd93ebf52ddb4056d257f5b52c04d3c804e657d19eb73fc33668b"
+checksum = "d231dfb89cfffdbc30e7fc41579ed6066ad03abda9e567ccafae602b97ec5024"
+
+[[package]]
+name = "hermit-abi"
+version = "0.4.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "fbf6a919d6cf397374f7dfeeea91d974c7c0a7221d0d0f4f20d859d329e53fcc"
 
 [[package]]
 name = "hex"
@@ -1898,9 +1960,9 @@ dependencies = [
 
 [[package]]
 name = "http"
-version = "0.2.9"
+version = "0.2.12"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "bd6effc99afb63425aff9b05836f029929e345a6148a14b7ecd5ab67af944482"
+checksum = "601cbb57e577e2f5ef5be8e7b83f0f63994f25aa94d673e54a92d5c516d101f1"
 dependencies = [
  "bytes",
  "fnv",
@@ -1909,9 +1971,9 @@ dependencies = [
 
 [[package]]
 name = "http-body"
-version = "0.4.5"
+version = "0.4.6"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "d5f38f16d184e36f2408a55281cd658ecbd3ca05cce6d6510a176eca393e26d1"
+checksum = "7ceab25649e9960c0311ea418d17bee82c0dcec1bd053b5f9a66e265a693bed2"
 dependencies = [
  "bytes",
  "http",
@@ -1920,21 +1982,21 @@ dependencies = [
 
 [[package]]
 name = "httparse"
-version = "1.8.0"
+version = "1.9.5"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "d897f394bad6a705d5f4104762e116a75639e470d80901eed05a860a95cb1904"
+checksum = "7d71d3574edd2771538b901e6549113b4006ece66150fb69c0fb6d9a2adae946"
 
 [[package]]
 name = "httpdate"
-version = "1.0.2"
+version = "1.0.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "c4a1e36c821dbe04574f602848a19f742f4fb3c98d40449f11bcad18d6b17421"
+checksum = "df3b46402a9d5adb4c86a0cf463f42e19994e3ee891101b1841f30a545cb49a9"
 
 [[package]]
 name = "hyper"
-version = "0.14.28"
+version = "0.14.31"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "bf96e135eb83a2a8ddf766e426a841d8ddd7449d5f00d34ea02b41d2f19eef80"
+checksum = "8c08302e8fa335b151b788c775ff56e7a03ae64ff85c548ee820fecb70356e85"
 dependencies = [
  "bytes",
  "futures-channel",
@@ -1961,9 +2023,9 @@ checksum = "71a816c97c42258aa5834d07590b718b4c9a598944cd39a52dc25b351185d678"
 
 [[package]]
 name = "iana-time-zone"
-version = "0.1.58"
+version = "0.1.60"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "8326b86b6cff230b97d0d312a6c40a60726df3332e721f72a1b035f451663b20"
+checksum = "e7ffbb5a1b541ea2561f8c41c087286cc091e21e556a4f09a8f6cbf17b69b141"
 dependencies = [
  "android_system_properties",
  "core-foundation-sys",
@@ -1982,6 +2044,124 @@ dependencies = [
  "cc",
 ]
 
+[[package]]
+name = "icu_collections"
+version = "1.5.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "db2fa452206ebee18c4b5c2274dbf1de17008e874b4dc4f0aea9d01ca79e4526"
+dependencies = [
+ "displaydoc",
+ "yoke",
+ "zerofrom",
+ "zerovec",
+]
+
+[[package]]
+name = "icu_locid"
+version = "1.5.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "13acbb8371917fc971be86fc8057c41a64b521c184808a698c02acc242dbf637"
+dependencies = [
+ "displaydoc",
+ "litemap",
+ "tinystr",
+ "writeable",
+ "zerovec",
+]
+
+[[package]]
+name = "icu_locid_transform"
+version = "1.5.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "01d11ac35de8e40fdeda00d9e1e9d92525f3f9d887cdd7aa81d727596788b54e"
+dependencies = [
+ "displaydoc",
+ "icu_locid",
+ "icu_locid_transform_data",
+ "icu_provider",
+ "tinystr",
+ "zerovec",
+]
+
+[[package]]
+name = "icu_locid_transform_data"
+version = "1.5.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "fdc8ff3388f852bede6b579ad4e978ab004f139284d7b28715f773507b946f6e"
+
+[[package]]
+name = "icu_normalizer"
+version = "1.5.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "19ce3e0da2ec68599d193c93d088142efd7f9c5d6fc9b803774855747dc6a84f"
+dependencies = [
+ "displaydoc",
+ "icu_collections",
+ "icu_normalizer_data",
+ "icu_properties",
+ "icu_provider",
+ "smallvec",
+ "utf16_iter",
+ "utf8_iter",
+ "write16",
+ "zerovec",
+]
+
+[[package]]
+name = "icu_normalizer_data"
+version = "1.5.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "f8cafbf7aa791e9b22bec55a167906f9e1215fd475cd22adfcf660e03e989516"
+
+[[package]]
+name = "icu_properties"
+version = "1.5.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "93d6020766cfc6302c15dbbc9c8778c37e62c14427cb7f6e601d849e092aeef5"
+dependencies = [
+ "displaydoc",
+ "icu_collections",
+ "icu_locid_transform",
+ "icu_properties_data",
+ "icu_provider",
+ "tinystr",
+ "zerovec",
+]
+
+[[package]]
+name = "icu_properties_data"
+version = "1.5.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "67a8effbc3dd3e4ba1afa8ad918d5684b8868b3b26500753effea8d2eed19569"
+
+[[package]]
+name = "icu_provider"
+version = "1.5.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "6ed421c8a8ef78d3e2dbc98a973be2f3770cb42b606e3ab18d6237c4dfde68d9"
+dependencies = [
+ "displaydoc",
+ "icu_locid",
+ "icu_provider_macros",
+ "stable_deref_trait",
+ "tinystr",
+ "writeable",
+ "yoke",
+ "zerofrom",
+ "zerovec",
+]
+
+[[package]]
+name = "icu_provider_macros"
+version = "1.5.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "1ec89e9337638ecdc08744df490b221a7399bf8d164eb52a665454e60e075ad6"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn 2.0.87",
+]
+
 [[package]]
 name = "ident_case"
 version = "1.0.1"
@@ -2001,27 +2181,37 @@ dependencies = [
 
 [[package]]
 name = "idna"
-version = "0.5.0"
+version = "1.0.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "634d9b1461af396cad843f47fdba5597a4f9e6ddd4bfb6ff5d85028c25cb12f6"
+checksum = "686f825264d630750a544639377bae737628043f20d38bbc029e8f29ea968a7e"
 dependencies = [
- "unicode-bidi",
- "unicode-normalization",
+ "idna_adapter",
+ "smallvec",
+ "utf8_iter",
+]
+
+[[package]]
+name = "idna_adapter"
+version = "1.2.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "daca1df1c957320b2cf139ac61e7bd64fed304c5040df000a745aa1de3b4ef71"
+dependencies = [
+ "icu_normalizer",
+ "icu_properties",
 ]
 
 [[package]]
 name = "ignore"
-version = "0.4.20"
+version = "0.4.23"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "dbe7873dab538a9a44ad79ede1faf5f30d49f9a5c883ddbab48bce81b64b7492"
+checksum = "6d89fd380afde86567dfba715db065673989d6253f42b88179abd3eae47bda4b"
 dependencies = [
+ "crossbeam-deque",
  "globset",
- "lazy_static",
  "log",
  "memchr",
- "regex",
+ "regex-automata 0.4.8",
  "same-file",
- "thread_local",
  "walkdir",
  "winapi-util",
 ]
@@ -2084,28 +2274,28 @@ dependencies = [
 
 [[package]]
 name = "indexmap"
-version = "2.2.6"
+version = "2.6.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "168fb715dda47215e360912c096649d23d58bf392ac62f73919e831745e40f26"
+checksum = "707907fe3c25f5424cce2cb7e1cbcafee6bdbe735ca90ef77c29e84591e5b9da"
 dependencies = [
  "equivalent",
- "hashbrown 0.14.5",
+ "hashbrown 0.15.1",
  "serde",
 ]
 
 [[package]]
 name = "inferno"
-version = "0.11.19"
+version = "0.11.21"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "321f0f839cd44a4686e9504b0a62b4d69a50b62072144c71c68f5873c167b8d9"
+checksum = "232929e1d75fe899576a3d5c7416ad0d88dbfbb3c3d6aa00873a7408a50ddb88"
 dependencies = [
- "ahash 0.8.11",
+ "ahash",
  "clap",
  "crossbeam-channel",
  "crossbeam-utils",
  "dashmap",
  "env_logger",
- "indexmap 2.2.6",
+ "indexmap 2.6.0",
  "is-terminal",
  "itoa",
  "log",
@@ -2138,27 +2328,33 @@ dependencies = [
 
 [[package]]
 name = "instant"
-version = "0.1.12"
+version = "0.1.13"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "7a5bbe824c507c5da5956355e86a746d82e0e1464f65d862cc5e71da70e94b2c"
+checksum = "e0242819d153cba4b4b05a5a8f2a7e9bbf97b6055b2a002b395c96b5ff3c0222"
 dependencies = [
  "cfg-if 1.0.0",
 ]
 
 [[package]]
 name = "is-terminal"
-version = "0.4.9"
+version = "0.4.13"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "cb0889898416213fab133e1d33a0e5858a48177452750691bde3666d0fdbaf8b"
+checksum = "261f68e344040fbd0edea105bef17c66edf46f984ddb1115b775ce31be948f4b"
 dependencies = [
- "hermit-abi",
- "rustix",
- "windows-sys 0.48.0",
+ "hermit-abi 0.4.0",
+ "libc",
+ "windows-sys 0.52.0",
 ]
 
+[[package]]
+name = "is_terminal_polyfill"
+version = "1.70.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "7943c866cc5cd64cbc25b2e01621d07fa8eb2a1a23160ee81ce38704e97b8ecf"
+
 [[package]]
 name = "iter-extended"
-version = "0.34.0"
+version = "1.0.0-beta.0"
 
 [[package]]
 name = "itertools"
@@ -2171,9 +2367,9 @@ dependencies = [
 
 [[package]]
 name = "itoa"
-version = "1.0.9"
+version = "1.0.11"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "af150ab688ff2122fcef229be89cb50dd66af9e01a4ff320cc137eecc9bacc38"
+checksum = "49f1f14873335454500d59611f1cf4a4b0f786f9ac11f4312a78e4cf2566695b"
 
 [[package]]
 name = "js-sys"
@@ -2203,7 +2399,7 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "d2b99d4207e2a04fb4581746903c2bb7eb376f88de9c699d0f3e10feeac0cd3a"
 dependencies = [
  "derive_more",
- "futures 0.3.30",
+ "futures 0.3.31",
  "jsonrpc-core",
  "jsonrpc-pubsub",
  "log",
@@ -2218,7 +2414,7 @@ version = "18.0.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "14f7f76aef2d054868398427f6c54943cf3d1caa9a7ec7d0c38d69df97a965eb"
 dependencies = [
- "futures 0.3.30",
+ "futures 0.3.31",
  "futures-executor",
  "futures-util",
  "log",
@@ -2233,7 +2429,7 @@ version = "18.0.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "b51da17abecbdab3e3d4f26b01c5ec075e88d3abe3ab3b05dc9aa69392764ec0"
 dependencies = [
- "futures 0.3.30",
+ "futures 0.3.31",
  "jsonrpc-client-transports",
 ]
 
@@ -2255,7 +2451,7 @@ version = "18.0.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "e1dea6e07251d9ce6a552abfb5d7ad6bc290a4596c8dcc3d795fae2bbdc1f3ff"
 dependencies = [
- "futures 0.3.30",
+ "futures 0.3.31",
  "hyper",
  "jsonrpc-core",
  "jsonrpc-server-utils",
@@ -2271,7 +2467,7 @@ version = "18.0.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "240f87695e6c6f62fb37f05c02c04953cf68d6408b8c1c89de85c7a0125b1011"
 dependencies = [
- "futures 0.3.30",
+ "futures 0.3.31",
  "jsonrpc-core",
  "lazy_static",
  "log",
@@ -2287,7 +2483,7 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "fa4fdea130485b572c39a460d50888beb00afb3e35de23ccd7fad8ff19f0e0d4"
 dependencies = [
  "bytes",
- "futures 0.3.30",
+ "futures 0.3.31",
  "globset",
  "jsonrpc-core",
  "lazy_static",
@@ -2326,9 +2522,9 @@ dependencies = [
 
 [[package]]
 name = "keccak"
-version = "0.1.4"
+version = "0.1.5"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "8f6d5ed8676d904364de097082f4e7d240b571b67989ced0240f08b7f966f940"
+checksum = "ecc2af9a1119c51f12a14607e783cb977bde58bc069ff0c3da1095e635d70654"
 dependencies = [
  "cpufeatures",
 ]
@@ -2355,9 +2551,9 @@ dependencies = [
 
 [[package]]
 name = "lazy_static"
-version = "1.4.0"
+version = "1.5.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "e2abad23fbc42b3700f2f279844dc832adb2b2eb069b2df918f455c4e18cc646"
+checksum = "bbd2bcb4c963f2ddae06a2efc7e9f3591312473c50c6685e1f298068316e66fe"
 dependencies = [
  "spin",
 ]
@@ -2370,15 +2566,15 @@ checksum = "82903360c009b816f5ab72a9b68158c27c301ee2c3f20655b55c5e589e7d3bb7"
 
 [[package]]
 name = "libc"
-version = "0.2.155"
+version = "0.2.162"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "97b3888a4aecf77e811145cadf6eef5901f4782c53886191b2f693f24761847c"
+checksum = "18d287de67fe55fd7e1581fe933d965a5a9477b38e949cfa9f8574ef01506398"
 
 [[package]]
 name = "libm"
-version = "0.2.7"
+version = "0.2.11"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "f7012b1bbb0719e1097c47611d3898568c546d597c2e74d66f6087edd5233ff4"
+checksum = "8355be11b20d696c8f18f6cc018c4e372165b1fa8126cef092399c9951984ffa"
 
 [[package]]
 name = "libredox"
@@ -2386,22 +2582,51 @@ version = "0.0.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "3af92c55d7d839293953fcd0fda5ecfe93297cfde6ffbdec13b41d99c0ba6607"
 dependencies = [
- "bitflags 2.5.0",
+ "bitflags 2.6.0",
  "libc",
  "redox_syscall 0.4.1",
 ]
 
+[[package]]
+name = "libredox"
+version = "0.1.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "c0ff37bd590ca25063e35af745c343cb7a0271906fb7b37e4813e8f79f00268d"
+dependencies = [
+ "bitflags 2.6.0",
+ "libc",
+ "redox_syscall 0.5.7",
+]
+
+[[package]]
+name = "light-poseidon"
+version = "0.2.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "3c9a85a9752c549ceb7578064b4ed891179d20acd85f27318573b64d2d7ee7ee"
+dependencies = [
+ "ark-bn254",
+ "ark-ff",
+ "num-bigint",
+ "thiserror",
+]
+
 [[package]]
 name = "linux-raw-sys"
 version = "0.4.14"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "78b3ae25bc7c8c38cec158d1f2757ee79e9b3740fbc7ccf0e59e4b08d793fa89"
 
+[[package]]
+name = "litemap"
+version = "0.7.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "643cb0b8d4fcc284004d5fd0d67ccf61dfffadb7f75e1e71bc420f4688a3a704"
+
 [[package]]
 name = "lock_api"
-version = "0.4.10"
+version = "0.4.12"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "c1cc9717a20b1bb222f333e6a92fd32f7d8a18ddc5a3191a11af45dcbf4dcd16"
+checksum = "07af8b9cdd281b7915f413fa73f29ebd5d55d0d3f0155584dade1ff18cea1b17"
 dependencies = [
  "autocfg",
  "scopeguard",
@@ -2409,9 +2634,9 @@ dependencies = [
 
 [[package]]
 name = "log"
-version = "0.4.19"
+version = "0.4.22"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "b06a4cde4c0f271a446782e3eff8de789548ce57dbc8eca9292c27f4a42004b4"
+checksum = "a7a70ba024b9dc04c27ea2f0c0548feb474ec5c54bba33a7f72f873a39d07b24"
 
 [[package]]
 name = "louds-rs"
@@ -2432,7 +2657,7 @@ dependencies = [
  "serde",
  "serde_json",
  "serde_repr",
- "url 2.5.0",
+ "url 2.5.4",
 ]
 
 [[package]]
@@ -2445,7 +2670,7 @@ dependencies = [
  "serde",
  "serde_json",
  "serde_repr",
- "url 2.5.0",
+ "url 2.5.4",
 ]
 
 [[package]]
@@ -2465,15 +2690,15 @@ checksum = "2532096657941c2fea9c289d370a250971c689d4f143798ff67113ec042024a5"
 
 [[package]]
 name = "memchr"
-version = "2.7.1"
+version = "2.7.4"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "523dc4f511e55ab87b694dc30d0f820d60906ef06413f93d4d7a1385599cc149"
+checksum = "78ca9ab1a0babb1e7d5695e3530886289c18cf2f87ec19a575a0abdce112e3a3"
 
 [[package]]
 name = "memmap2"
-version = "0.5.10"
+version = "0.9.5"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "83faa42c0a078c393f6b29d5db232d8be22776a891f8f56e5284faee4a20b327"
+checksum = "fd3f7eed9d3848f8b98834af67102b720745c4ec028fcd0aa0239277e7de374f"
 dependencies = [
  "libc",
 ]
@@ -2487,15 +2712,6 @@ dependencies = [
  "autocfg",
 ]
 
-[[package]]
-name = "memoffset"
-version = "0.9.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "488016bfae457b036d996092f6cb448677611ce4449e970ceaf42695203f218a"
-dependencies = [
- "autocfg",
-]
-
 [[package]]
 name = "memuse"
 version = "0.2.1"
@@ -2511,11 +2727,20 @@ dependencies = [
  "adler",
 ]
 
+[[package]]
+name = "miniz_oxide"
+version = "0.8.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "e2d80299ef12ff69b16a84bb182e3b9df68b5a91574d3d4fa6e41b65deec4df1"
+dependencies = [
+ "adler2",
+]
+
 [[package]]
 name = "minreq"
-version = "2.11.0"
+version = "2.12.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "cb3371dfc7b772c540da1380123674a8e20583aca99907087d990ca58cf44203"
+checksum = "763d142cdff44aaadd9268bebddb156ef6c65a0e13486bb81673cf2d8739f9b0"
 dependencies = [
  "log",
  "serde",
@@ -2534,9 +2759,21 @@ dependencies = [
  "windows-sys 0.48.0",
 ]
 
+[[package]]
+name = "mio"
+version = "1.0.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "80e04d1dcff3aae0704555fe5fee3bcfaf3d1fdf8a7e521d5b9d2b42acb52cec"
+dependencies = [
+ "hermit-abi 0.3.9",
+ "libc",
+ "wasi 0.11.0+wasi-snapshot-preview1",
+ "windows-sys 0.52.0",
+]
+
 [[package]]
 name = "nargo"
-version = "0.34.0"
+version = "1.0.0-beta.0"
 dependencies = [
  "acvm",
  "fm",
@@ -2556,16 +2793,17 @@ dependencies = [
  "rand 0.8.5",
  "rayon",
  "serde",
- "tempfile",
  "thiserror",
  "tracing",
+ "walkdir",
 ]
 
 [[package]]
 name = "nargo_cli"
-version = "0.34.0"
+version = "1.0.0-beta.0"
 dependencies = [
  "acvm",
+ "ark-bn254",
  "assert_cmd",
  "assert_fs",
  "async-lsp",
@@ -2573,14 +2811,19 @@ dependencies = [
  "build-data",
  "clap",
  "clap-markdown",
+ "clap_complete",
  "color-eyre",
  "const_format",
  "criterion",
  "dap",
  "dirs",
+ "file-lock",
  "fm",
+ "fxhash",
  "iai",
  "iter-extended",
+ "lazy_static",
+ "light-poseidon",
  "nargo",
  "nargo_fmt",
  "nargo_toml",
@@ -2594,21 +2837,25 @@ dependencies = [
  "notify",
  "notify-debouncer-full",
  "paste",
- "pprof 0.13.0",
+ "pprof",
  "predicates 2.1.5",
  "prettytable-rs",
+ "proptest",
  "rayon",
  "serde",
  "serde_json",
+ "sha2",
+ "sha3",
  "similar-asserts",
  "tempfile",
  "termcolor",
  "termion",
  "test-binary",
+ "test-case",
  "thiserror",
  "tokio",
- "tokio-util 0.7.10",
- "toml 0.7.6",
+ "tokio-util 0.7.12",
+ "toml 0.7.8",
  "tower",
  "tracing-appender",
  "tracing-subscriber",
@@ -2616,19 +2863,18 @@ dependencies = [
 
 [[package]]
 name = "nargo_fmt"
-version = "0.34.0"
+version = "1.0.0-beta.0"
 dependencies = [
- "bytecount",
  "noirc_frontend",
  "serde",
  "similar-asserts",
  "thiserror",
- "toml 0.7.6",
+ "toml 0.7.8",
 ]
 
 [[package]]
 name = "nargo_toml"
-version = "0.34.0"
+version = "1.0.0-beta.0"
 dependencies = [
  "dirs",
  "fm",
@@ -2637,9 +2883,11 @@ dependencies = [
  "noirc_frontend",
  "semver",
  "serde",
+ "tempfile",
+ "test-case",
  "thiserror",
- "toml 0.7.6",
- "url 2.5.0",
+ "toml 0.7.8",
+ "url 2.5.4",
 ]
 
 [[package]]
@@ -2672,7 +2920,7 @@ dependencies = [
  "cc",
  "cfg-if 1.0.0",
  "libc",
- "memoffset 0.6.5",
+ "memoffset",
 ]
 
 [[package]]
@@ -2685,7 +2933,7 @@ dependencies = [
  "bitflags 1.3.2",
  "cfg-if 1.0.0",
  "libc",
- "memoffset 0.6.5",
+ "memoffset",
  "pin-utils",
 ]
 
@@ -2702,7 +2950,7 @@ dependencies = [
 
 [[package]]
 name = "noir_debugger"
-version = "0.34.0"
+version = "1.0.0-beta.0"
 dependencies = [
  "acvm",
  "assert_cmd",
@@ -2726,7 +2974,7 @@ dependencies = [
 
 [[package]]
 name = "noir_fuzzer"
-version = "0.34.0"
+version = "1.0.0-beta.0"
 dependencies = [
  "acvm",
  "noirc_abi",
@@ -2749,11 +2997,10 @@ dependencies = [
 
 [[package]]
 name = "noir_lsp"
-version = "0.34.0"
+version = "1.0.0-beta.0"
 dependencies = [
  "acvm",
  "async-lsp",
- "chumsky",
  "codespan-lsp",
  "convert_case 0.6.0",
  "fm",
@@ -2762,14 +3009,12 @@ dependencies = [
  "nargo",
  "nargo_fmt",
  "nargo_toml",
- "noirc_artifacts",
  "noirc_driver",
  "noirc_errors",
  "noirc_frontend",
  "rayon",
  "serde",
  "serde_json",
- "serde_with",
  "strum",
  "thiserror",
  "tokio",
@@ -2779,19 +3024,23 @@ dependencies = [
 
 [[package]]
 name = "noir_profiler"
-version = "0.34.0"
+version = "1.0.0-beta.0"
 dependencies = [
  "acir",
+ "bn254_blackbox_solver",
  "clap",
  "color-eyre",
  "const_format",
  "fm",
+ "fxhash",
  "im",
  "inferno",
+ "nargo",
  "noirc_abi",
  "noirc_artifacts",
  "noirc_driver",
  "noirc_errors",
+ "noirc_evaluator",
  "serde",
  "serde_json",
  "tempfile",
@@ -2801,7 +3050,7 @@ dependencies = [
 
 [[package]]
 name = "noir_wasm"
-version = "0.34.0"
+version = "1.0.0-beta.0"
 dependencies = [
  "acvm",
  "build-data",
@@ -2825,7 +3074,7 @@ dependencies = [
 
 [[package]]
 name = "noirc_abi"
-version = "0.34.0"
+version = "1.0.0-beta.0"
 dependencies = [
  "acvm",
  "iter-extended",
@@ -2833,18 +3082,18 @@ dependencies = [
  "num-bigint",
  "num-traits",
  "proptest",
- "proptest-derive",
+ "proptest-derive 0.4.0",
  "serde",
  "serde_json",
  "strum",
  "strum_macros",
  "thiserror",
- "toml 0.7.6",
+ "toml 0.7.8",
 ]
 
 [[package]]
 name = "noirc_abi_wasm"
-version = "0.34.0"
+version = "1.0.0-beta.0"
 dependencies = [
  "acvm",
  "build-data",
@@ -2861,11 +3110,11 @@ dependencies = [
 
 [[package]]
 name = "noirc_arena"
-version = "0.34.0"
+version = "1.0.0-beta.0"
 
 [[package]]
 name = "noirc_artifacts"
-version = "0.34.0"
+version = "1.0.0-beta.0"
 dependencies = [
  "acvm",
  "codespan-reporting",
@@ -2880,7 +3129,7 @@ dependencies = [
 
 [[package]]
 name = "noirc_driver"
-version = "0.34.0"
+version = "1.0.0-beta.0"
 dependencies = [
  "acvm",
  "build-data",
@@ -2899,11 +3148,10 @@ dependencies = [
 
 [[package]]
 name = "noirc_errors"
-version = "0.34.0"
+version = "1.0.0-beta.0"
 dependencies = [
  "acvm",
  "base64 0.21.7",
- "chumsky",
  "codespan",
  "codespan-reporting",
  "flate2",
@@ -2917,7 +3165,7 @@ dependencies = [
 
 [[package]]
 name = "noirc_evaluator"
-version = "0.34.0"
+version = "1.0.0-beta.0"
 dependencies = [
  "acvm",
  "bn254_blackbox_solver",
@@ -2929,24 +3177,27 @@ dependencies = [
  "noirc_errors",
  "noirc_frontend",
  "num-bigint",
+ "num-traits",
  "proptest",
  "rayon",
  "serde",
  "serde_json",
  "serde_with",
+ "similar-asserts",
+ "test-case",
  "thiserror",
  "tracing",
+ "tracing-test",
 ]
 
 [[package]]
 name = "noirc_frontend"
-version = "0.34.0"
+version = "1.0.0-beta.0"
 dependencies = [
  "acvm",
  "base64 0.21.7",
  "bn254_blackbox_solver",
  "cfg-if 1.0.0",
- "chumsky",
  "fm",
  "im",
  "iter-extended",
@@ -2956,8 +3207,9 @@ dependencies = [
  "num-bigint",
  "num-traits",
  "petgraph",
+ "proptest",
+ "proptest-derive 0.5.0",
  "rangemap",
- "regex",
  "rustc-hash",
  "serde",
  "serde_json",
@@ -2971,12 +3223,11 @@ dependencies = [
 
 [[package]]
 name = "noirc_printable_type"
-version = "0.34.0"
+version = "1.0.0-beta.0"
 dependencies = [
  "acvm",
  "iter-extended",
  "jsonrpc",
- "regex",
  "serde",
  "serde_json",
  "thiserror",
@@ -2994,7 +3245,7 @@ version = "6.1.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "6205bd8bb1e454ad2e27422015fb5e4f2bcc7e08fa8f27058670d208324a4d2d"
 dependencies = [
- "bitflags 2.5.0",
+ "bitflags 2.6.0",
  "crossbeam-channel",
  "filetime",
  "fsevent-sys",
@@ -3002,22 +3253,22 @@ dependencies = [
  "kqueue",
  "libc",
  "log",
- "mio",
+ "mio 0.8.11",
  "walkdir",
  "windows-sys 0.48.0",
 ]
 
 [[package]]
 name = "notify-debouncer-full"
-version = "0.3.1"
+version = "0.3.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "49f5dab59c348b9b50cf7f261960a20e389feb2713636399cd9082cd4b536154"
+checksum = "fb7fd166739789c9ff169e654dc1501373db9d80a4c3f972817c8a4d7cf8f34e"
 dependencies = [
  "crossbeam-channel",
  "file-id",
  "log",
  "notify",
- "parking_lot 0.12.1",
+ "parking_lot 0.12.3",
  "walkdir",
 ]
 
@@ -3033,15 +3284,20 @@ dependencies = [
 
 [[package]]
 name = "num-bigint"
-version = "0.4.3"
+version = "0.4.6"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "f93ab6289c7b344a8a9f60f88d80aa20032336fe78da341afc91c8a2341fc75f"
+checksum = "a5e44f723f1133c9deac646763579fdb3ac745e418f2a7af9cd0c431da1f20b9"
 dependencies = [
- "autocfg",
  "num-integer",
  "num-traits",
 ]
 
+[[package]]
+name = "num-conv"
+version = "0.1.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "51d515d32fb182ee37cda2ccdcb92950d6a3c2893aa280e540671c2cd0f3b1d9"
+
 [[package]]
 name = "num-format"
 version = "0.4.4"
@@ -3054,19 +3310,18 @@ dependencies = [
 
 [[package]]
 name = "num-integer"
-version = "0.1.45"
+version = "0.1.46"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "225d3389fb3509a24c93f5c29eb6bde2586b98d9f016636dff58d7c6f7569cd9"
+checksum = "7969661fd2958a5cb096e56c8e1ad0444ac2bbcd0061bd28660485a44879858f"
 dependencies = [
- "autocfg",
  "num-traits",
 ]
 
 [[package]]
 name = "num-traits"
-version = "0.2.15"
+version = "0.2.19"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "578ede34cf02f8924ab9447f50c28075b4d3e5b269972345e7e0372b38c6cdcd"
+checksum = "071dfc062690e90b734c0b2273ce72ad0ffa95f0c74596bc250dcfd960262841"
 dependencies = [
  "autocfg",
  "libm",
@@ -3078,7 +3333,7 @@ version = "1.16.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "4161fcb6d602d4d2081af7c3a45852d875a03dd337a6bfdd6e06407b61342a43"
 dependencies = [
- "hermit-abi",
+ "hermit-abi 0.3.9",
  "libc",
 ]
 
@@ -3090,24 +3345,24 @@ checksum = "b8f8bdf33df195859076e54ab11ee78a1b208382d3a26ec40d142ffc1ecc49ef"
 
 [[package]]
 name = "object"
-version = "0.31.1"
+version = "0.32.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "8bda667d9f2b5051b8833f59f3bf748b28ef54f850f4fcb389a252aa383866d1"
+checksum = "a6a622008b6e321afc04970976f62ee297fdbaa6f95318ca343e3eebb9648441"
 dependencies = [
  "memchr",
 ]
 
 [[package]]
 name = "once_cell"
-version = "1.18.0"
+version = "1.20.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "dd8b5dd2ae5ed71462c540258bedcb51965123ad7e7ccf4b9a8cafaa4a63576d"
+checksum = "1261fe7e33c73b354eab43b1273a57c8f967d0391e80353e51f764ac02cf6775"
 
 [[package]]
 name = "oorandom"
-version = "11.1.3"
+version = "11.1.4"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "0ab1bc2a289d34bd04a330323ac98a1b4bc82c9d9fcb1e66b63caa84da26b575"
+checksum = "b410bbe7e14ab526a0e86877eb47c6996a2bd7746f027ba551028c925390e4e9"
 
 [[package]]
 name = "overload"
@@ -3154,12 +3409,12 @@ dependencies = [
 
 [[package]]
 name = "parking_lot"
-version = "0.12.1"
+version = "0.12.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "3742b2c103b9f06bc9fff0a37ff4912935851bee6d36f3c02bcc755bcfec228f"
+checksum = "f1bf18183cf54e8d6059647fc3063646a1801cf30896933ec2311622cc4b9a27"
 dependencies = [
  "lock_api",
- "parking_lot_core 0.9.8",
+ "parking_lot_core 0.9.10",
 ]
 
 [[package]]
@@ -3178,15 +3433,15 @@ dependencies = [
 
 [[package]]
 name = "parking_lot_core"
-version = "0.9.8"
+version = "0.9.10"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "93f00c865fe7cabf650081affecd3871070f26767e7b2070a3ffae14c654b447"
+checksum = "1e401f977ab385c9e4e3ab30627d6f26d00e2c73eef317493c4ec6d468726cf8"
 dependencies = [
  "cfg-if 1.0.0",
  "libc",
- "redox_syscall 0.3.5",
+ "redox_syscall 0.5.7",
  "smallvec",
- "windows-targets 0.48.5",
+ "windows-targets 0.52.6",
 ]
 
 [[package]]
@@ -3221,9 +3476,9 @@ dependencies = [
 
 [[package]]
 name = "paste"
-version = "1.0.14"
+version = "1.0.15"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "de3145af08024dea9fa9914f381a17b8fc6034dfb00f3a84013f7ff43f29ed4c"
+checksum = "57c0d7b74b563b49d38dae00a0c37d4d6de9b432382b2892f0574ddcae73fd0a"
 
 [[package]]
 name = "percent-encoding"
@@ -3239,12 +3494,12 @@ checksum = "e3148f5046208a5d56bcfc03053e3ca6334e51da8dfb19b6cdc8b306fae3283e"
 
 [[package]]
 name = "petgraph"
-version = "0.6.4"
+version = "0.6.5"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "e1d3afd2628e69da2be385eb6f2fd57c8ac7977ceeff6dc166ff1657b0e386a9"
+checksum = "b4c5cc86750666a3ed20bdaf5ca2a0344f9c67674cae0515bec2da16fbaa47db"
 dependencies = [
  "fixedbitset",
- "indexmap 2.2.6",
+ "indexmap 2.6.0",
 ]
 
 [[package]]
@@ -3293,9 +3548,9 @@ dependencies = [
 
 [[package]]
 name = "pin-project-lite"
-version = "0.2.13"
+version = "0.2.15"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "8afb450f006bf6385ca15ef45d71d2288452bc3683ce2e2cacc0d18e4be60b58"
+checksum = "915a1e146535de9163f3987b8944ed8cf49a18bb0056bcebcdcece385cece4ff"
 
 [[package]]
 name = "pin-utils"
@@ -3315,15 +3570,15 @@ dependencies = [
 
 [[package]]
 name = "pkg-config"
-version = "0.3.27"
+version = "0.3.31"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "26072860ba924cbfa98ea39c8c19b4dd6a4a25423dbdf219c1eca91aa0cf6964"
+checksum = "953ec861398dccce10c670dfeaf3ec4911ca479e9c02154b3a215178c5f566f2"
 
 [[package]]
 name = "plotters"
-version = "0.3.5"
+version = "0.3.6"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "d2c224ba00d7cadd4d5c660deaf2098e5e80e07846537c51f9cfa4be50c1fd45"
+checksum = "a15b6eccb8484002195a3e44fe65a4ce8e93a625797a063735536fd59cb01cf3"
 dependencies = [
  "num-traits",
  "plotters-backend",
@@ -3334,47 +3589,32 @@ dependencies = [
 
 [[package]]
 name = "plotters-backend"
-version = "0.3.5"
+version = "0.3.7"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "9e76628b4d3a7581389a35d5b6e2139607ad7c75b17aed325f210aa91f4a9609"
+checksum = "df42e13c12958a16b3f7f4386b9ab1f3e7933914ecea48da7139435263a4172a"
 
 [[package]]
 name = "plotters-svg"
-version = "0.3.5"
+version = "0.3.7"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "38f6d39893cca0701371e3c27294f09797214b86f1fb951b89ade8ec04e2abab"
+checksum = "51bae2ac328883f7acdfea3d66a7c35751187f870bc81f94563733a154d7a670"
 dependencies = [
  "plotters-backend",
 ]
 
 [[package]]
-name = "pprof"
-version = "0.12.1"
+name = "powerfmt"
+version = "0.2.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "978385d59daf9269189d052ca8a84c1acfd0715c0599a5d5188d4acc078ca46a"
-dependencies = [
- "backtrace",
- "cfg-if 1.0.0",
- "criterion",
- "findshlibs",
- "inferno",
- "libc",
- "log",
- "nix 0.26.4",
- "once_cell",
- "parking_lot 0.12.1",
- "smallvec",
- "symbolic-demangle",
- "tempfile",
- "thiserror",
-]
+checksum = "439ee305def115ba05938db6eb1644ff94165c5ab5e9420d1c1bcedbba909391"
 
 [[package]]
 name = "pprof"
-version = "0.13.0"
+version = "0.14.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "ef5c97c51bd34c7e742402e216abdeb44d415fbe6ae41d56b114723e953711cb"
+checksum = "ebbe2f8898beba44815fdc9e5a4ae9c929e21c5dc29b0c774a15555f7f58d6d0"
 dependencies = [
+ "aligned-vec",
  "backtrace",
  "cfg-if 1.0.0",
  "criterion",
@@ -3384,7 +3624,7 @@ dependencies = [
  "log",
  "nix 0.26.4",
  "once_cell",
- "parking_lot 0.12.1",
+ "parking_lot 0.12.3",
  "smallvec",
  "symbolic-demangle",
  "tempfile",
@@ -3393,9 +3633,12 @@ dependencies = [
 
 [[package]]
 name = "ppv-lite86"
-version = "0.2.17"
+version = "0.2.20"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "5b40af805b3121feab8a3c29f04d8ad262fa8e0561883e7653e024ae4479e6de"
+checksum = "77957b295656769bb8ad2b6a6b09d897d94f05c41b069aede1fcdaa675eaea04"
+dependencies = [
+ "zerocopy",
+]
 
 [[package]]
 name = "predicates"
@@ -3413,27 +3656,26 @@ dependencies = [
 
 [[package]]
 name = "predicates"
-version = "3.0.3"
+version = "3.1.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "09963355b9f467184c04017ced4a2ba2d75cbcb4e7462690d388233253d4b1a9"
+checksum = "7e9086cc7640c29a356d1a29fd134380bee9d8f79a17410aa76e7ad295f42c97"
 dependencies = [
  "anstyle",
  "difflib",
- "itertools",
  "predicates-core",
 ]
 
 [[package]]
 name = "predicates-core"
-version = "1.0.6"
+version = "1.0.8"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "b794032607612e7abeb4db69adb4e33590fa6cf1149e95fd7cb00e634b92f174"
+checksum = "ae8177bee8e75d6846599c6b9ff679ed51e882816914eec639944d7c9aa11931"
 
 [[package]]
 name = "predicates-tree"
-version = "1.0.9"
+version = "1.0.11"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "368ba315fb8c5052ab692e68a0eefec6ec57b23a36959c14496f0b0df2c0cecf"
+checksum = "41b740d195ed3166cd147c8047ec98db0e22ec019eb8eeb76d343b795304fb13"
 dependencies = [
  "predicates-core",
  "termtree",
@@ -3470,28 +3712,28 @@ checksum = "dc375e1527247fe1a97d8b7156678dfe7c1af2fc075c9a4db3690ecd2a148068"
 
 [[package]]
 name = "proc-macro2"
-version = "1.0.82"
+version = "1.0.89"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "8ad3d49ab951a01fbaafe34f2ec74122942fe18a3f9814c3268f1bb72042131b"
+checksum = "f139b0662de085916d1fb67d2b4169d1addddda1919e696f3252b740b629986e"
 dependencies = [
  "unicode-ident",
 ]
 
 [[package]]
 name = "proptest"
-version = "1.4.0"
+version = "1.5.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "31b476131c3c86cb68032fdc5cb6d5a1045e3e42d96b69fa599fd77701e1f5bf"
+checksum = "b4c2511913b88df1637da85cc8d96ec8e43a3f8bb8ccb71ee1ac240d6f3df58d"
 dependencies = [
  "bit-set",
  "bit-vec",
- "bitflags 2.5.0",
+ "bitflags 2.6.0",
  "lazy_static",
  "num-traits",
  "rand 0.8.5",
  "rand_chacha 0.3.1",
  "rand_xorshift",
- "regex-syntax 0.8.2",
+ "regex-syntax 0.8.5",
  "rusty-fork",
  "tempfile",
  "unarray",
@@ -3508,6 +3750,17 @@ dependencies = [
  "syn 1.0.109",
 ]
 
+[[package]]
+name = "proptest-derive"
+version = "0.5.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "6ff7ff745a347b87471d859a377a9a404361e7efc2a971d73424a6d183c0fc77"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn 2.0.87",
+]
+
 [[package]]
 name = "quick-error"
 version = "1.2.3"
@@ -3525,9 +3778,9 @@ dependencies = [
 
 [[package]]
 name = "quote"
-version = "1.0.36"
+version = "1.0.37"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "0fa76aaf39101c457836aec0ce2316dbdc3ab723cdda1c6bd4e6ad4208acaca7"
+checksum = "b5b9d34b8991d19d98081b46eacdd8eb58c6f2b201139f7c5f643cc155a633af"
 dependencies = [
  "proc-macro2",
 ]
@@ -3639,9 +3892,9 @@ dependencies = [
 
 [[package]]
 name = "rangemap"
-version = "1.4.0"
+version = "1.5.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "977b1e897f9d764566891689e642653e5ed90c6895106acd005eb4c1d0203991"
+checksum = "f60fcc7d6849342eff22c4350c8b9a989ee8ceabc4b481253e8946b9fe83d684"
 
 [[package]]
 name = "rayon"
@@ -3674,20 +3927,20 @@ dependencies = [
 
 [[package]]
 name = "redox_syscall"
-version = "0.3.5"
+version = "0.4.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "567664f262709473930a4bf9e51bf2ebf3348f2e748ccc50dea20646858f8f29"
+checksum = "4722d768eff46b75989dd134e5c353f0d6296e5aaa3132e776cbdb56be7731aa"
 dependencies = [
  "bitflags 1.3.2",
 ]
 
 [[package]]
 name = "redox_syscall"
-version = "0.4.1"
+version = "0.5.7"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "4722d768eff46b75989dd134e5c353f0d6296e5aaa3132e776cbdb56be7731aa"
+checksum = "9b6dfecf2c74bce2466cabf93f6664d6998a69eb21e39f4207930065b27b771f"
 dependencies = [
- "bitflags 1.3.2",
+ "bitflags 2.6.0",
 ]
 
 [[package]]
@@ -3698,25 +3951,25 @@ checksum = "20145670ba436b55d91fc92d25e71160fbfbdd57831631c8d7d36377a476f1cb"
 
 [[package]]
 name = "redox_users"
-version = "0.4.3"
+version = "0.4.6"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "b033d837a7cf162d7993aded9304e30a83213c648b6e389db233191f891e5c2b"
+checksum = "ba009ff324d1fc1b900bd1fdb31564febe58a8ccc8a6fdbb93b543d33b13ca43"
 dependencies = [
  "getrandom 0.2.15",
- "redox_syscall 0.2.16",
+ "libredox 0.1.3",
  "thiserror",
 ]
 
 [[package]]
 name = "regex"
-version = "1.10.3"
+version = "1.11.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "b62dbe01f0b06f9d8dc7d49e05a0785f153b00b2c227856282f671e0318c9b15"
+checksum = "b544ef1b4eac5dc2db33ea63606ae9ffcfac26c1416a2806ae0bf5f56b201191"
 dependencies = [
  "aho-corasick",
  "memchr",
- "regex-automata 0.4.7",
- "regex-syntax 0.8.2",
+ "regex-automata 0.4.8",
+ "regex-syntax 0.8.5",
 ]
 
 [[package]]
@@ -3730,19 +3983,13 @@ dependencies = [
 
 [[package]]
 name = "regex-automata"
-version = "0.3.9"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "59b23e92ee4318893fa3fe3e6fb365258efbfe6ac6ab30f090cdcbb7aa37efa9"
-
-[[package]]
-name = "regex-automata"
-version = "0.4.7"
+version = "0.4.8"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "38caf58cc5ef2fed281f89292ef23f6365465ed9a41b7a7754eb4e26496c92df"
+checksum = "368758f23274712b504848e9d5a6f010445cc8b87a7cdb4d7cbee666c1288da3"
 dependencies = [
  "aho-corasick",
  "memchr",
- "regex-syntax 0.8.2",
+ "regex-syntax 0.8.5",
 ]
 
 [[package]]
@@ -3753,9 +4000,9 @@ checksum = "f162c6dd7b008981e4d40210aca20b4bd0f9b60ca9271061b07f78537722f2e1"
 
 [[package]]
 name = "regex-syntax"
-version = "0.8.2"
+version = "0.8.5"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "c08c74e62047bb2de4ff487b251e4a92e24f48745648451635cec7d591162d9f"
+checksum = "2b15c43186be67a4fd63bee50d0303afffcef381492ebe2c5d87f324e1b8815c"
 
 [[package]]
 name = "rexpect"
@@ -3783,9 +4030,9 @@ dependencies = [
 
 [[package]]
 name = "rgb"
-version = "0.8.36"
+version = "0.8.50"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "20ec2d3e3fc7a92ced357df9cebd5a10b6fb2aa1ee797bf7e9ce2f17dffc8f59"
+checksum = "57397d16646700483b67d2dd6511d79318f9d057fdbd21a4066aeac8b41d310a"
 dependencies = [
  "bytemuck",
 ]
@@ -3810,7 +4057,7 @@ dependencies = [
  "proc-macro2",
  "quote",
  "rust-embed-utils",
- "syn 2.0.64",
+ "syn 2.0.87",
  "walkdir",
 ]
 
@@ -3826,9 +4073,9 @@ dependencies = [
 
 [[package]]
 name = "rustc-demangle"
-version = "0.1.23"
+version = "0.1.24"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "d626bb9dae77e28219937af045c257c28bfd3f69333c512553507f5f9798cb76"
+checksum = "719b953e2095829ee67db738b3bfa9fa368c94900df327b3f07fe6e794d2fe1f"
 
 [[package]]
 name = "rustc-hash"
@@ -3838,20 +4085,20 @@ checksum = "08d43f7aa6b08d49f382cde6a7982047c3426db949b1424bc4b7ec9ae12c6ce2"
 
 [[package]]
 name = "rustc_version"
-version = "0.4.0"
+version = "0.4.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "bfa0f585226d2e68097d4f95d113b15b83a82e819ab25717ec0590d9584ef366"
+checksum = "cfcb3a22ef46e85b45de6ee7e79d063319ebb6594faafcf1c225ea92ab6e9b92"
 dependencies = [
  "semver",
 ]
 
 [[package]]
 name = "rustix"
-version = "0.38.34"
+version = "0.38.39"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "70dc5ec042f7a43c4a73241207cecc9873a06d45debb38b329f8541d85c2730f"
+checksum = "375116bee2be9ed569afe2154ea6a99dfdffd257f533f187498c2a8f5feaf4ee"
 dependencies = [
- "bitflags 2.5.0",
+ "bitflags 2.6.0",
  "errno",
  "libc",
  "linux-raw-sys",
@@ -3860,9 +4107,9 @@ dependencies = [
 
 [[package]]
 name = "rustversion"
-version = "1.0.14"
+version = "1.0.18"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "7ffc183a10b4478d04cbbbfc96d0873219d962dd5accaff2ffbd4ceb7df837f4"
+checksum = "0e819f2bc632f285be6d7cd36e25940d45b2391dd6d9b939e79de557f7014248"
 
 [[package]]
 name = "rusty-fork"
@@ -3912,23 +4159,23 @@ dependencies = [
 
 [[package]]
 name = "ryu"
-version = "1.0.15"
+version = "1.0.18"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "1ad4cc8da4ef723ed60bced201181d83791ad433213d8c24efffda1eec85d741"
+checksum = "f3cb5ba0dc43242ce17de99c180e96db90b235b8a9fdc9543c96d2209116bd9f"
 
 [[package]]
 name = "safe-lock"
-version = "0.1.3"
+version = "0.1.4"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "077d73db7973cccf63eb4aff1e5a34dc2459baa867512088269ea5f2f4253c90"
+checksum = "f29841ed0a577196bca5b753cd4e4022fa50b718e56fc0d35919ed32e20ec65c"
 
 [[package]]
 name = "safe-proc-macro2"
-version = "1.0.36"
+version = "1.0.67"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "814c536dcd27acf03296c618dab7ad62d28e70abd7ba41d3f34a2ce707a2c666"
+checksum = "7fd85be67db87168aa3c13fd0da99f48f2ab005dccad5af5626138dc1df20eb6"
 dependencies = [
- "unicode-xid",
+ "unicode-ident",
 ]
 
 [[package]]
@@ -3942,18 +4189,18 @@ dependencies = [
 
 [[package]]
 name = "safe-regex"
-version = "0.2.5"
+version = "0.2.6"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "a15289bf322e0673d52756a18194167f2378ec1a15fe884af6e2d2cb934822b0"
+checksum = "e6ab4bc484ef480a9ce79b381efd7b6767700f514d47bc599036e9d6f7f3c49d"
 dependencies = [
  "safe-regex-macro",
 ]
 
 [[package]]
 name = "safe-regex-compiler"
-version = "0.2.5"
+version = "0.2.6"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "fba76fae590a2aa665279deb1f57b5098cbace01a0c5e60e262fcf55f7c51542"
+checksum = "6d71f8c78bffb07962595e1bfa5ed11d24dd855eedc50b6a735f5ef648ce621b"
 dependencies = [
  "safe-proc-macro2",
  "safe-quote",
@@ -3961,9 +4208,9 @@ dependencies = [
 
 [[package]]
 name = "safe-regex-macro"
-version = "0.2.5"
+version = "0.2.6"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "96c2e96b5c03f158d1b16ba79af515137795f4ad4e8de3f790518aae91f1d127"
+checksum = "0909ab4b77511df24201cd66541d6a028887c77ecc065f277c68a12a663274ef"
 dependencies = [
  "safe-proc-macro2",
  "safe-regex-compiler",
@@ -4006,18 +4253,18 @@ dependencies = [
 
 [[package]]
 name = "semver"
-version = "1.0.20"
+version = "1.0.23"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "836fa6a3e1e547f9a2c4040802ec865b5d85f4014efe00555d7090a3dcaa1090"
+checksum = "61697e0a1c7e512e84a621326239844a24d8207b4669b41bc18b32ea5cbf988b"
 dependencies = [
  "serde",
 ]
 
 [[package]]
 name = "serde"
-version = "1.0.209"
+version = "1.0.214"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "99fce0ffe7310761ca6bf9faf5115afbc19688edd00171d81b1bb1b116c63e09"
+checksum = "f55c3193aca71c12ad7890f1785d2b73e1b9f63a0bbc353c08ef26fe03fc56b5"
 dependencies = [
  "serde_derive",
 ]
@@ -4058,58 +4305,60 @@ dependencies = [
 
 [[package]]
 name = "serde_derive"
-version = "1.0.209"
+version = "1.0.214"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "a5831b979fd7b5439637af1752d535ff49f4860c0f341d1baeb6faf0f4242170"
+checksum = "de523f781f095e28fa605cdce0f8307e451cc0fd14e2eb4cd2e98a355b147766"
 dependencies = [
  "proc-macro2",
  "quote",
- "syn 2.0.64",
+ "syn 2.0.87",
 ]
 
 [[package]]
 name = "serde_json"
-version = "1.0.108"
+version = "1.0.132"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "3d1c7e3eac408d115102c4c24ad393e0821bb3a5df4d506a80f85f7a742a526b"
+checksum = "d726bfaff4b320266d395898905d0eba0345aae23b54aee3a737e260fd46db03"
 dependencies = [
  "itoa",
+ "memchr",
  "ryu",
  "serde",
 ]
 
 [[package]]
 name = "serde_repr"
-version = "0.1.14"
+version = "0.1.19"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "1d89a8107374290037607734c0b73a85db7ed80cae314b3c5791f192a496e731"
+checksum = "6c64451ba24fc7a6a2d60fc75dd9c83c90903b19028d4eff35e88fc1e86564e9"
 dependencies = [
  "proc-macro2",
  "quote",
- "syn 2.0.64",
+ "syn 2.0.87",
 ]
 
 [[package]]
 name = "serde_spanned"
-version = "0.6.3"
+version = "0.6.8"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "96426c9936fd7a0124915f9185ea1d20aa9445cc9821142f0a73bc9207a2e186"
+checksum = "87607cb1398ed59d48732e575a4c28a7a8ebf2454b964fe3f224f2afc07909e1"
 dependencies = [
  "serde",
 ]
 
 [[package]]
 name = "serde_with"
-version = "3.2.0"
+version = "3.11.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "1402f54f9a3b9e2efe71c1cea24e648acce55887983553eeb858cf3115acfd49"
+checksum = "8e28bdad6db2b8340e449f7108f020b3b092e8583a9e3fb82713e1d4e71fe817"
 dependencies = [
- "base64 0.21.7",
+ "base64 0.22.1",
  "chrono",
  "hex",
  "indexmap 1.9.3",
- "indexmap 2.2.6",
+ "indexmap 2.6.0",
  "serde",
+ "serde_derive",
  "serde_json",
  "serde_with_macros",
  "time",
@@ -4117,21 +4366,21 @@ dependencies = [
 
 [[package]]
 name = "serde_with_macros"
-version = "3.2.0"
+version = "3.11.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "9197f1ad0e3c173a0222d3c4404fb04c3afe87e962bcb327af73e8301fa203c7"
+checksum = "9d846214a9854ef724f3da161b426242d8de7c1fc7de2f89bb1efcb154dca79d"
 dependencies = [
  "darling",
  "proc-macro2",
  "quote",
- "syn 2.0.64",
+ "syn 2.0.87",
 ]
 
 [[package]]
 name = "sha2"
-version = "0.10.7"
+version = "0.10.8"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "479fb9d862239e610720565ca91403019f2f00410f1864c5aa7479b950a76ed8"
+checksum = "793db75ad2bcafc3ffa7c68b215fee268f537982cd901d132f89c6343f3a3dc8"
 dependencies = [
  "cfg-if 1.0.0",
  "cpufeatures",
@@ -4150,9 +4399,9 @@ dependencies = [
 
 [[package]]
 name = "sharded-slab"
-version = "0.1.4"
+version = "0.1.7"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "900fba806f70c630b0a382d0d825e17a0f19fcd059a2ade1ff237bcddf446b31"
+checksum = "f40ca3c46823713e0d4209592e8d6e826aa57e928f09752619fc696c499637f6"
 dependencies = [
  "lazy_static",
 ]
@@ -4163,6 +4412,12 @@ version = "1.1.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "24188a676b6ae68c3b2cb3a01be17fbf7240ce009799bb56d5b1409051e78fde"
 
+[[package]]
+name = "shlex"
+version = "1.3.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "0fda2ff0d084019ba4d7c6f371c95d8fd75ce3524c3cb8fb653a3023f6323e64"
+
 [[package]]
 name = "signature"
 version = "1.6.4"
@@ -4175,19 +4430,19 @@ dependencies = [
 
 [[package]]
 name = "similar"
-version = "2.3.0"
+version = "2.6.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "2aeaf503862c419d66959f5d7ca015337d864e9c49485d771b732e2a20453597"
+checksum = "1de1d4f81173b03af4c0cbed3c898f6bff5b870e4a7f5d6f4057d62a7a4b686e"
 dependencies = [
- "bstr 0.2.17",
+ "bstr",
  "unicode-segmentation",
 ]
 
 [[package]]
 name = "similar-asserts"
-version = "1.5.0"
+version = "1.6.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "e041bb827d1bfca18f213411d51b665309f1afb37a04a5d1464530e13779fc0f"
+checksum = "cfe85670573cd6f0fa97940f26e7e6601213c3b0555246c24234131f88c5709e"
 dependencies = [
  "console",
  "similar",
@@ -4211,9 +4466,9 @@ dependencies = [
 
 [[package]]
 name = "slab"
-version = "0.4.8"
+version = "0.4.9"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "6528351c9bc8ab22353f9d776db39a20288e8d6c37ef8cfe3317cf875eecfc2d"
+checksum = "8f92a496fb766b417c996b9c5e57daf2f7ad3b0bebe1ccfca4856390e3d3bb67"
 dependencies = [
  "autocfg",
 ]
@@ -4250,19 +4505,19 @@ dependencies = [
 
 [[package]]
 name = "socket2"
-version = "0.5.5"
+version = "0.5.7"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "7b5fac59a5cb5dd637972e5fca70daf0523c9067fcdc4842f053dae04a18f8e9"
+checksum = "ce305eb0b4296696835b71df73eb912e0f1ffd2556a501fcede6e0c50349191c"
 dependencies = [
  "libc",
- "windows-sys 0.48.0",
+ "windows-sys 0.52.0",
 ]
 
 [[package]]
 name = "spin"
-version = "0.5.2"
+version = "0.9.8"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "6e63cff320ae2c57904679ba7cb63280a3dc4613885beafb148ee7bf9aa9042d"
+checksum = "6980e8d7511241f8acf4aebddbb1ff938df5eebe98691418c4468d0b72a96a67"
 
 [[package]]
 name = "spki"
@@ -4300,9 +4555,9 @@ checksum = "9091b6114800a5f2141aee1d1b9d6ca3592ac062dc5decb3764ec5895a47b4eb"
 
 [[package]]
 name = "strsim"
-version = "0.10.0"
+version = "0.11.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "73473c0e59e6d5812c5dfe2a064a6444949f089e20eec9a2e5506596494e4623"
+checksum = "7da8b5736845d9f2fcb837ea5d9e2628564b3b043a70948a3f0b778838c5fb4f"
 
 [[package]]
 name = "strum"
@@ -4325,15 +4580,15 @@ dependencies = [
 
 [[package]]
 name = "subtle"
-version = "2.5.0"
+version = "2.6.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "81cdd64d312baedb58e21336b31bc043b77e01cc99033ce76ef539f78e965ebc"
+checksum = "13c2bddecc57b384dee18652358fb23172facb8a2c51ccc10d74c157bdea3292"
 
 [[package]]
 name = "symbolic-common"
-version = "12.3.0"
+version = "12.12.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "167a4ffd7c35c143fd1030aa3c2caf76ba42220bd5a6b5f4781896434723b8c3"
+checksum = "3d4d73159efebfb389d819fd479afb2dbd57dcb3e3f4b7fcfa0e675f5a46c1cb"
 dependencies = [
  "debugid",
  "memmap2",
@@ -4343,9 +4598,9 @@ dependencies = [
 
 [[package]]
 name = "symbolic-demangle"
-version = "12.3.0"
+version = "12.12.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "e378c50e80686c1c5c205674e1f86a2858bec3d2a7dfdd690331a8a19330f293"
+checksum = "a767859f6549c665011970874c3f541838b4835d5aaaa493d3ee383918be9f10"
 dependencies = [
  "cpp_demangle",
  "rustc-demangle",
@@ -4365,15 +4620,26 @@ dependencies = [
 
 [[package]]
 name = "syn"
-version = "2.0.64"
+version = "2.0.87"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "7ad3dee41f36859875573074334c200d1add8e4a87bb37113ebd31d926b7b11f"
+checksum = "25aa4ce346d03a6dcd68dd8b4010bcb74e54e62c90c573f394c46eae99aba32d"
 dependencies = [
  "proc-macro2",
  "quote",
  "unicode-ident",
 ]
 
+[[package]]
+name = "synstructure"
+version = "0.13.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "c8af7666ab7b6390ab78131fb5b0fce11d6b7a6951602017c35fa82800708971"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn 2.0.87",
+]
+
 [[package]]
 name = "tap"
 version = "1.0.1"
@@ -4382,15 +4648,15 @@ checksum = "55937e1799185b12863d447f42597ed69d9928686b8d88a1df17376a097d8369"
 
 [[package]]
 name = "tempfile"
-version = "3.8.0"
+version = "3.14.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "cb94d2f3cc536af71caac6b6fcebf65860b347e7ce0cc9ebe8f70d3e521054ef"
+checksum = "28cce251fcbc87fac86a866eeb0d6c2d536fc16d06f184bb61aeae11aa4cee0c"
 dependencies = [
  "cfg-if 1.0.0",
  "fastrand",
- "redox_syscall 0.3.5",
+ "once_cell",
  "rustix",
- "windows-sys 0.48.0",
+ "windows-sys 0.59.0",
 ]
 
 [[package]]
@@ -4406,9 +4672,9 @@ dependencies = [
 
 [[package]]
 name = "termcolor"
-version = "1.2.0"
+version = "1.4.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "be55cf8942feac5c765c2c993422806843c9a9a45d4d5c407ad6dd2ea95eb9b6"
+checksum = "06794f8f6c5c898b3275aebefa6b8a1cb24cd2c6c79397ab15774837a0bc5755"
 dependencies = [
  "winapi-util",
 ]
@@ -4420,7 +4686,7 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "417813675a504dfbbf21bfde32c03e5bf9f2413999962b479023c02848c1c7a5"
 dependencies = [
  "libc",
- "libredox",
+ "libredox 0.0.2",
  "numtoa",
  "redox_termios",
 ]
@@ -4444,6 +4710,39 @@ dependencies = [
  "thiserror",
 ]
 
+[[package]]
+name = "test-case"
+version = "3.3.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "eb2550dd13afcd286853192af8601920d959b14c401fcece38071d53bf0768a8"
+dependencies = [
+ "test-case-macros",
+]
+
+[[package]]
+name = "test-case-core"
+version = "3.3.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "adcb7fd841cd518e279be3d5a3eb0636409487998a4aff22f3de87b81e88384f"
+dependencies = [
+ "cfg-if 1.0.0",
+ "proc-macro2",
+ "quote",
+ "syn 2.0.87",
+]
+
+[[package]]
+name = "test-case-macros"
+version = "3.3.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "5c89e72a01ed4c579669add59014b9a524d609c0c88c6a585ce37485879f6ffb"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn 2.0.87",
+ "test-case-core",
+]
+
 [[package]]
 name = "textwrap"
 version = "0.13.4"
@@ -4467,29 +4766,29 @@ dependencies = [
 
 [[package]]
 name = "thiserror"
-version = "1.0.43"
+version = "1.0.68"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "a35fc5b8971143ca348fa6df4f024d4d55264f3468c71ad1c2f365b0a4d58c42"
+checksum = "02dd99dc800bbb97186339685293e1cc5d9df1f8fae2d0aecd9ff1c77efea892"
 dependencies = [
  "thiserror-impl",
 ]
 
 [[package]]
 name = "thiserror-impl"
-version = "1.0.43"
+version = "1.0.68"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "463fe12d7993d3b327787537ce8dd4dfa058de32fc2b195ef3cde03dc4771e8f"
+checksum = "a7c61ec9a6f64d2793d8a45faba21efbe3ced62a886d44c36a009b2b519b4c7e"
 dependencies = [
  "proc-macro2",
  "quote",
- "syn 2.0.64",
+ "syn 2.0.87",
 ]
 
 [[package]]
 name = "thread_local"
-version = "1.1.7"
+version = "1.1.8"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "3fdd6f064ccff2d6567adcb3873ca630700f00b5ad3f060c25b5dcfd9a4ce152"
+checksum = "8b9ef9bad013ada3808854ceac7b46812a6465ba368859a37e2100283d2d719c"
 dependencies = [
  "cfg-if 1.0.0",
  "once_cell",
@@ -4497,12 +4796,14 @@ dependencies = [
 
 [[package]]
 name = "time"
-version = "0.3.25"
+version = "0.3.36"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "b0fdd63d58b18d663fbdf70e049f00a22c8e42be082203be7f26589213cd75ea"
+checksum = "5dfd88e563464686c916c7e46e623e520ddc6d79fa6641390f2e3fa86e83e885"
 dependencies = [
  "deranged",
  "itoa",
+ "num-conv",
+ "powerfmt",
  "serde",
  "time-core",
  "time-macros",
@@ -4510,19 +4811,30 @@ dependencies = [
 
 [[package]]
 name = "time-core"
-version = "0.1.1"
+version = "0.1.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "7300fbefb4dadc1af235a9cef3737cea692a9d97e1b9cbcd4ebdae6f8868e6fb"
+checksum = "ef927ca75afb808a4d64dd374f00a2adf8d0fcff8e7b184af886c3c87ec4a3f3"
 
 [[package]]
 name = "time-macros"
-version = "0.2.11"
+version = "0.2.18"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "eb71511c991639bb078fd5bf97757e03914361c48100d52878b8e52b46fb92cd"
+checksum = "3f252a68540fde3a3877aeea552b832b40ab9a69e318efd078774a01ddee1ccf"
 dependencies = [
+ "num-conv",
  "time-core",
 ]
 
+[[package]]
+name = "tinystr"
+version = "0.7.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "9117f5d4db391c1cf6927e7bea3db74b9a1c1add8f7eda9ffd5364f40f57b82f"
+dependencies = [
+ "displaydoc",
+ "zerovec",
+]
+
 [[package]]
 name = "tinytemplate"
 version = "1.2.1"
@@ -4535,9 +4847,9 @@ dependencies = [
 
 [[package]]
 name = "tinyvec"
-version = "1.6.0"
+version = "1.8.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "87cc5ceb3875bb20c2890005a4e226a4651264a5c75edb2421b52861a0a0cb50"
+checksum = "445e881f4f6d382d5f27c034e25eb92edd7c784ceab92a0937db7f2e9471b938"
 dependencies = [
  "tinyvec_macros",
 ]
@@ -4550,37 +4862,36 @@ checksum = "1f3ccbac311fea05f86f61904b462b55fb3df8837a366dfc601a0161d0532f20"
 
 [[package]]
 name = "tokio"
-version = "1.38.1"
+version = "1.41.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "eb2caba9f80616f438e09748d5acda951967e1ea58508ef53d9c6402485a46df"
+checksum = "22cfb5bee7a6a52939ca9224d6ac897bb669134078daa8735560897f69de4d33"
 dependencies = [
  "backtrace",
  "bytes",
  "libc",
- "mio",
- "num_cpus",
+ "mio 1.0.2",
  "pin-project-lite",
  "socket2",
  "tokio-macros",
- "windows-sys 0.48.0",
+ "windows-sys 0.52.0",
 ]
 
 [[package]]
 name = "tokio-macros"
-version = "2.3.0"
+version = "2.4.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "5f5ae998a069d4b5aba8ee9dad856af7d520c3699e6159b185c2acd48155d39a"
+checksum = "693d596312e88961bc67d7f1f97af8a70227d9f90c31bba5806eec004978d752"
 dependencies = [
  "proc-macro2",
  "quote",
- "syn 2.0.64",
+ "syn 2.0.87",
 ]
 
 [[package]]
 name = "tokio-stream"
-version = "0.1.15"
+version = "0.1.16"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "267ac89e0bec6e691e5813911606935d77c476ff49024f98abcea3e7b15e37af"
+checksum = "4f4e6ce100d0eb49a2734f8c0812bcd324cf357d21810932c5df6b96ef2b86f1"
 dependencies = [
  "futures-core",
  "pin-project-lite",
@@ -4603,9 +4914,9 @@ dependencies = [
 
 [[package]]
 name = "tokio-util"
-version = "0.7.10"
+version = "0.7.12"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "5419f34732d9eb6ee4c3578b7989078579b7f039cbbb9ca2c4da015749371e15"
+checksum = "61e7c3654c13bcd040d4a03abee2c75b1d14a37b423cf5a813ceae1cc903ec6a"
 dependencies = [
  "bytes",
  "futures-core",
@@ -4626,9 +4937,9 @@ dependencies = [
 
 [[package]]
 name = "toml"
-version = "0.7.6"
+version = "0.7.8"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "c17e963a819c331dcacd7ab957d80bc2b9a9c1e71c804826d2f283dd65306542"
+checksum = "dd79e69d3b627db300ff956027cc6c3798cef26d22526befdfcd12feeb6d2257"
 dependencies = [
  "serde",
  "serde_spanned",
@@ -4638,20 +4949,20 @@ dependencies = [
 
 [[package]]
 name = "toml_datetime"
-version = "0.6.3"
+version = "0.6.8"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "7cda73e2f1397b1262d6dfdcef8aafae14d1de7748d66822d3bfeeb6d03e5e4b"
+checksum = "0dd7358ecb8fc2f8d014bf86f6f638ce72ba252a2c3a2572f2a795f1d23efb41"
 dependencies = [
  "serde",
 ]
 
 [[package]]
 name = "toml_edit"
-version = "0.19.14"
+version = "0.19.15"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "f8123f27e969974a3dfba720fdb560be359f57b44302d280ba72e76a74480e8a"
+checksum = "1b5bb770da30e5cbfde35a2d7b9b8a2c4b8ef89548a7a6aeab5c9a576e3e7421"
 dependencies = [
- "indexmap 2.2.6",
+ "indexmap 2.6.0",
  "serde",
  "serde_spanned",
  "toml_datetime",
@@ -4671,15 +4982,15 @@ dependencies = [
 
 [[package]]
 name = "tower-layer"
-version = "0.3.2"
+version = "0.3.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "c20c8dbed6283a09604c3e69b4b7eeb54e298b8a600d4d5ecb5ad39de609f1d0"
+checksum = "121c2a6cda46980bb0fcd1647ffaf6cd3fc79a013de288782836f6df9c48780e"
 
 [[package]]
 name = "tower-service"
-version = "0.3.2"
+version = "0.3.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "b6bc1c9ce2b5135ac7f93c72918fc37feb872bdc6a5533a8b85eb4b86bfdae52"
+checksum = "8df9b6e13f2d32c91b9bd719c00d1958837bc7dec474d94952798cc8e69eeec3"
 
 [[package]]
 name = "tracing"
@@ -4713,7 +5024,7 @@ checksum = "34704c8d6ebcbc939824180af020566b01a7c01f80641264eba0999f6c2b6be7"
 dependencies = [
  "proc-macro2",
  "quote",
- "syn 2.0.64",
+ "syn 2.0.87",
 ]
 
 [[package]]
@@ -4765,6 +5076,27 @@ dependencies = [
  "tracing-log",
 ]
 
+[[package]]
+name = "tracing-test"
+version = "0.2.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "557b891436fe0d5e0e363427fc7f217abf9ccd510d5136549847bdcbcd011d68"
+dependencies = [
+ "tracing-core",
+ "tracing-subscriber",
+ "tracing-test-macro",
+]
+
+[[package]]
+name = "tracing-test-macro"
+version = "0.2.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "04659ddb06c87d233c566112c1c9c5b9e98256d9af50ec3bc9c8327f873a7568"
+dependencies = [
+ "quote",
+ "syn 2.0.87",
+]
+
 [[package]]
 name = "tracing-web"
 version = "0.1.3"
@@ -4789,15 +5121,15 @@ dependencies = [
 
 [[package]]
 name = "try-lock"
-version = "0.2.4"
+version = "0.2.5"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "3528ecfd12c466c6f163363caf2d02a71161dd5e1cc6ae7b34207ea2d42d81ed"
+checksum = "e421abadd41a4225275504ea4d6566923418b7f05506fbc9c0fe86ba7396114b"
 
 [[package]]
 name = "typenum"
-version = "1.16.0"
+version = "1.17.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "497961ef93d974e23eb6f433eb5fe1b7930b659f06d12dec6fc44a8f554c0bba"
+checksum = "42ff0bf0c66b8238c6f3b578df37d0b7848e55df8577b3f74f92a69acceeb825"
 
 [[package]]
 name = "unarray"
@@ -4807,24 +5139,21 @@ checksum = "eaea85b334db583fe3274d12b4cd1880032beab409c0d774be044d4480ab9a94"
 
 [[package]]
 name = "unicase"
-version = "2.7.0"
+version = "2.8.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "f7d2d4dafb69621809a81864c9c1b864479e1235c0dd4e199924b9742439ed89"
-dependencies = [
- "version_check",
-]
+checksum = "7e51b68083f157f853b6379db119d1c1be0e6e4dec98101079dec41f6f5cf6df"
 
 [[package]]
 name = "unicode-bidi"
-version = "0.3.13"
+version = "0.3.17"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "92888ba5573ff080736b3648696b70cafad7d250551175acbaa4e0385b3e1460"
+checksum = "5ab17db44d7388991a428b2ee655ce0c212e862eff1768a455c58f9aad6e7893"
 
 [[package]]
 name = "unicode-ident"
-version = "1.0.11"
+version = "1.0.13"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "301abaae475aa91687eb82514b328ab47a211a533026cb25fc3e519b86adfc3c"
+checksum = "e91b56cd4cadaeb79bbf1a5645f6b4f8dc5bde8834ad5894a8db35fda9efa1fe"
 
 [[package]]
 name = "unicode-linebreak"
@@ -4834,30 +5163,30 @@ checksum = "3b09c83c3c29d37506a3e260c08c03743a6bb66a9cd432c6934ab501a190571f"
 
 [[package]]
 name = "unicode-normalization"
-version = "0.1.22"
+version = "0.1.24"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "5c5713f0fc4b5db668a2ac63cdb7bb4469d8c9fed047b1d0292cc7b0ce2ba921"
+checksum = "5033c97c4262335cded6d6fc3e5c18ab755e1a3dc96376350f3d8e9f009ad956"
 dependencies = [
  "tinyvec",
 ]
 
 [[package]]
 name = "unicode-segmentation"
-version = "1.10.1"
+version = "1.12.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "1dd624098567895118886609431a7c3b8f516e41d30e0643f03d94592a147e36"
+checksum = "f6ccf251212114b54433ec949fd6a7841275f9ada20dddd2f29e9ceea4501493"
 
 [[package]]
 name = "unicode-width"
-version = "0.1.10"
+version = "0.1.14"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "c0edd1e5b14653f783770bce4a4dabb4a5108a5370a5f5d8cfe8710c361f6c8b"
+checksum = "7dd6e30e90baa6f72411720665d41d89b9a3d039dc45b8faea1ddd07f617f6af"
 
 [[package]]
 name = "unicode-xid"
-version = "0.2.4"
+version = "0.2.6"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "f962df74c8c05a667b5ee8bcf162993134c104e96440b663c8daa176dc772d8c"
+checksum = "ebc1c04c71510c7f702b52b7c350734c9ff1295c464a03335b00bb84fc54f853"
 
 [[package]]
 name = "url"
@@ -4872,27 +5201,39 @@ dependencies = [
 
 [[package]]
 name = "url"
-version = "2.5.0"
+version = "2.5.4"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "31e6302e3bb753d46e83516cae55ae196fc0c309407cf11ab35cc51a4c2a4633"
+checksum = "32f8b686cadd1473f4bd0117a5d28d36b1ade384ea9b5069a1c40aefed7fda60"
 dependencies = [
  "form_urlencoded",
- "idna 0.5.0",
+ "idna 1.0.3",
  "percent-encoding 2.3.1",
  "serde",
 ]
 
+[[package]]
+name = "utf16_iter"
+version = "1.0.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "c8232dd3cdaed5356e0f716d285e4b40b932ac434100fe9b7e0e8e935b9e6246"
+
+[[package]]
+name = "utf8_iter"
+version = "1.0.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b6c140620e7ffbb22c2dee59cafe6084a59b5ffc27a8859a5f0d494b5d52b6be"
+
 [[package]]
 name = "utf8parse"
-version = "0.2.1"
+version = "0.2.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "711b9620af191e0cdc7468a8d14e709c3dcdb115b36f838e601583af800a370a"
+checksum = "06abde3611657adf66d383f00b093d7faecc7fa57071cce2578660c9f1010821"
 
 [[package]]
 name = "uuid"
-version = "1.4.1"
+version = "1.11.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "79daa5ed5740825c40b389c5e50312b9c86df53fccd33f281df655642b43869d"
+checksum = "f8c5f0a0af699448548ad1a2fbf920fb4bee257eae39953ba95cb84891a0446a"
 
 [[package]]
 name = "valuable"
@@ -4902,9 +5243,9 @@ checksum = "830b7e5d4d90034032940e4ace0d9a9a057e7a45cd94e6c007832e39edb82f6d"
 
 [[package]]
 name = "version_check"
-version = "0.9.4"
+version = "0.9.5"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "49874b5167b65d7193b8aba1567f5c7d93d001cafc34600cee003eda787e483f"
+checksum = "0b928f33d975fc6ad9f86c8f283853ad26bdd5b10b7f1542aa2fa15e2289105a"
 
 [[package]]
 name = "wait-timeout"
@@ -4917,12 +5258,12 @@ dependencies = [
 
 [[package]]
 name = "waitpid-any"
-version = "0.2.0"
+version = "0.2.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "54f8c3c56044fc359f905b72879576a15d49c46d085ed6266a98826716f14033"
+checksum = "0189157c93c54d86e5c61ddf0c1223baa25e5bfb2f6f9983c678985b028d7c12"
 dependencies = [
  "rustix",
- "windows-sys 0.48.0",
+ "windows-sys 0.52.0",
 ]
 
 [[package]]
@@ -4979,7 +5320,7 @@ dependencies = [
  "once_cell",
  "proc-macro2",
  "quote",
- "syn 2.0.64",
+ "syn 2.0.87",
  "wasm-bindgen-shared",
 ]
 
@@ -5013,7 +5354,7 @@ checksum = "e128beba882dd1eb6200e1dc92ae6c5dbaa4311aa7bb211ca035779e5efc39f8"
 dependencies = [
  "proc-macro2",
  "quote",
- "syn 2.0.64",
+ "syn 2.0.87",
  "wasm-bindgen-backend",
  "wasm-bindgen-shared",
 ]
@@ -5076,11 +5417,11 @@ checksum = "ac3b87c63620426dd9b991e5ce0329eff545bccbbb34f3be09ff6fb6ab51b7b6"
 
 [[package]]
 name = "winapi-util"
-version = "0.1.5"
+version = "0.1.9"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "70ec6ce85bb158151cae5e5c87f95a8e97d2c0c4b001223f33a334e3ce5de178"
+checksum = "cf221c93e13a30d793f7645a0e7762c55d169dbb0a49671918a2319d289b10bb"
 dependencies = [
- "winapi",
+ "windows-sys 0.48.0",
 ]
 
 [[package]]
@@ -5091,11 +5432,11 @@ checksum = "712e227841d057c1ee1cd2fb22fa7e5a5461ae8e48fa2ca79ec42cfc1931183f"
 
 [[package]]
 name = "windows-core"
-version = "0.50.0"
+version = "0.52.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "af6041b3f84485c21b57acdc0fee4f4f0c93f426053dc05fa5d6fc262537bbff"
+checksum = "33ab640c8d7e35bf8ba19b884ba838ceb4fba93a4e8c65a9059d08afcfc683d9"
 dependencies = [
- "windows-targets 0.48.5",
+ "windows-targets 0.52.6",
 ]
 
 [[package]]
@@ -5116,6 +5457,15 @@ dependencies = [
  "windows-targets 0.52.6",
 ]
 
+[[package]]
+name = "windows-sys"
+version = "0.59.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "1e38bc4d79ed67fd075bcc251a1c39b32a1776bbe92e5bef1f0bf1f8c531853b"
+dependencies = [
+ "windows-targets 0.52.6",
+]
+
 [[package]]
 name = "windows-targets"
 version = "0.48.5"
@@ -5239,13 +5589,25 @@ checksum = "589f6da84c646204747d1270a2a5661ea66ed1cced2631d546fdfb155959f9ec"
 
 [[package]]
 name = "winnow"
-version = "0.5.0"
+version = "0.5.40"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "81fac9742fd1ad1bd9643b991319f72dd031016d44b77039a26977eb667141e7"
+checksum = "f593a95398737aeed53e489c785df13f3618e41dbcd6718c6addbf1395aa6876"
 dependencies = [
  "memchr",
 ]
 
+[[package]]
+name = "write16"
+version = "1.0.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d1890f4022759daae28ed4fe62859b1236caebfc61ede2f63ed4e695f3f6d936"
+
+[[package]]
+name = "writeable"
+version = "0.5.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "1e9df38ee2d2c3c5948ea468a8406ff0db0b29ae1ffde1bcf20ef305bcc95c51"
+
 [[package]]
 name = "wyz"
 version = "0.5.1"
@@ -5255,31 +5617,77 @@ dependencies = [
  "tap",
 ]
 
+[[package]]
+name = "yoke"
+version = "0.7.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "6c5b1314b079b0930c31e3af543d8ee1757b1951ae1e1565ec704403a7240ca5"
+dependencies = [
+ "serde",
+ "stable_deref_trait",
+ "yoke-derive",
+ "zerofrom",
+]
+
+[[package]]
+name = "yoke-derive"
+version = "0.7.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "28cc31741b18cb6f1d5ff12f5b7523e3d6eb0852bbbad19d73905511d9849b95"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn 2.0.87",
+ "synstructure",
+]
+
 [[package]]
 name = "zerocopy"
-version = "0.7.32"
+version = "0.7.35"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "74d4d3961e53fa4c9a25a8637fc2bfaf2595b3d3ae34875568a5cf64787716be"
+checksum = "1b9b4fd18abc82b8136838da5d50bae7bdea537c574d8dc1a34ed098d6c166f0"
 dependencies = [
+ "byteorder",
  "zerocopy-derive",
 ]
 
 [[package]]
 name = "zerocopy-derive"
-version = "0.7.32"
+version = "0.7.35"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "fa4f8080344d4671fb4e831a13ad1e68092748387dfc4f55e356242fae12ce3e"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn 2.0.87",
+]
+
+[[package]]
+name = "zerofrom"
+version = "0.1.4"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "9ce1b18ccd8e73a9321186f97e46f9f04b778851177567b1975109d26a08d2a6"
+checksum = "91ec111ce797d0e0784a1116d0ddcdbea84322cd79e5d5ad173daeba4f93ab55"
+dependencies = [
+ "zerofrom-derive",
+]
+
+[[package]]
+name = "zerofrom-derive"
+version = "0.1.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "0ea7b4a3637ea8669cedf0f1fd5c286a17f3de97b8dd5a70a6c167a1730e63a5"
 dependencies = [
  "proc-macro2",
  "quote",
- "syn 2.0.64",
+ "syn 2.0.87",
+ "synstructure",
 ]
 
 [[package]]
 name = "zeroize"
-version = "1.6.0"
+version = "1.8.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "2a0956f1ba7c7909bfb66c2e9e4124ab6f6482560f6628b5aaeba39207c9aad9"
+checksum = "ced3678a2879b30306d323f4542626697a464a97c0a07c9aebf7ebca65cd4dde"
 dependencies = [
  "zeroize_derive",
 ]
@@ -5292,7 +5700,29 @@ checksum = "ce36e65b0d2999d2aafac989fb249189a141aee1f53c612c1f37d72631959f69"
 dependencies = [
  "proc-macro2",
  "quote",
- "syn 2.0.64",
+ "syn 2.0.87",
+]
+
+[[package]]
+name = "zerovec"
+version = "0.10.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "aa2b893d79df23bfb12d5461018d408ea19dfafe76c2c7ef6d4eba614f8ff079"
+dependencies = [
+ "yoke",
+ "zerofrom",
+ "zerovec-derive",
+]
+
+[[package]]
+name = "zerovec-derive"
+version = "0.10.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "6eafa6dfb17584ea3e2bd6e76e0cc15ad7af12b09abdd1ca55961bed9b1063c6"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn 2.0.87",
 ]
 
 [[package]]
diff --git a/Cargo.toml b/Cargo.toml
index a6cfa7de07f..0acee2a040b 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -40,7 +40,7 @@ resolver = "2"
 
 [workspace.package]
 # x-release-please-start-version
-version = "0.34.0"
+version = "1.0.0-beta.0"
 # x-release-please-end
 authors = ["The Noir Team <team@noir-lang.org>"]
 edition = "2021"
@@ -57,13 +57,13 @@ unused_qualifications = "warn"
 [workspace.dependencies]
 
 # ACVM workspace dependencies
-acir_field = { version = "0.50.0", path = "acvm-repo/acir_field", default-features = false }
-acir = { version = "0.50.0", path = "acvm-repo/acir", default-features = false }
-acvm = { version = "0.50.0", path = "acvm-repo/acvm" }
-brillig = { version = "0.50.0", path = "acvm-repo/brillig", default-features = false }
-brillig_vm = { version = "0.50.0", path = "acvm-repo/brillig_vm", default-features = false }
-acvm_blackbox_solver = { version = "0.50.0", path = "acvm-repo/blackbox_solver", default-features = false }
-bn254_blackbox_solver = { version = "0.50.0", path = "acvm-repo/bn254_blackbox_solver", default-features = false }
+acir_field = { version = "1.0.0-beta.0", path = "acvm-repo/acir_field", default-features = false }
+acir = { version = "1.0.0-beta.0", path = "acvm-repo/acir", default-features = false }
+acvm = { version = "1.0.0-beta.0", path = "acvm-repo/acvm" }
+brillig = { version = "1.0.0-beta.0", path = "acvm-repo/brillig", default-features = false }
+brillig_vm = { version = "1.0.0-beta.0", path = "acvm-repo/brillig_vm", default-features = false }
+acvm_blackbox_solver = { version = "1.0.0-beta.0", path = "acvm-repo/blackbox_solver", default-features = false }
+bn254_blackbox_solver = { version = "1.0.0-beta.0", path = "acvm-repo/bn254_blackbox_solver", default-features = false }
 
 # Noir compiler workspace dependencies
 fm = { path = "compiler/fm" }
@@ -87,8 +87,12 @@ bb_abstraction_leaks = { path = "tooling/bb_abstraction_leaks" }
 acvm_cli = { path = "tooling/acvm_cli" }
 
 # Arkworks
-ark-bn254 = { version = "^0.4.0", default-features = false, features = ["curve"] }
-ark-bls12-381 = { version = "^0.4.0", default-features = false, features = ["curve"] }
+ark-bn254 = { version = "^0.4.0", default-features = false, features = [
+    "curve",
+] }
+ark-bls12-381 = { version = "^0.4.0", default-features = false, features = [
+    "curve",
+] }
 grumpkin = { version = "0.1.0", package = "noir_grumpkin", features = ["std"] }
 ark-ec = { version = "^0.4.0", default-features = false }
 ark-ff = { version = "^0.4.0", default-features = false }
@@ -117,16 +121,12 @@ clap = { version = "4.3.19", features = ["derive", "env"] }
 codespan = { version = "0.11.1", features = ["serialization"] }
 codespan-lsp = "0.11.1"
 codespan-reporting = "0.11.1"
-chumsky = { git = "https://github.com/jfecher/chumsky", rev = "ad9d312", default-features = false, features = [
-    "ahash",
-    "std",
-] }
 
 # Benchmarking
 criterion = "0.5.0"
 # Note that using the "frame-pointer" feature breaks framegraphs on linux
 # https://github.com/tikv/pprof-rs/pull/172
-pprof = { version = "0.13", features = ["flamegraph", "criterion"] }
+pprof = { version = "0.14", features = ["flamegraph", "criterion"] }
 
 cfg-if = "1.0.0"
 dirs = "4"
@@ -135,17 +135,19 @@ serde_json = "1.0"
 smol_str = { version = "0.1.17", features = ["serde"] }
 thiserror = "1.0.21"
 toml = "0.7.2"
-url = "2.2.0"
+url = "2.5.4"
 base64 = "0.21.2"
 fxhash = "0.2.1"
 build-data = "0.1.3"
 bincode = "1.3.3"
 hex = "0.4.2"
 const_format = "0.2.30"
+lazy_static = "1.4"
 num-bigint = "0.4"
 num-traits = "0.2"
 similar-asserts = "1.5.0"
 tempfile = "3.6.0"
+test-case = "3.3.1"
 jsonrpc = { version = "0.16.0", features = ["minreq_http"] }
 flate2 = "1.0.24"
 color-eyre = "0.6.2"
@@ -153,6 +155,10 @@ rand = "0.8.5"
 proptest = "1.2.0"
 proptest-derive = "0.4.0"
 rayon = "1.8.0"
+sha2 = { version = "0.10.6", features = ["compress"] }
+sha3 = "0.10.6"
+strum = "0.24"
+strum_macros = "0.24"
 
 im = { version = "15.1", features = ["serde"] }
 tracing = "0.1.40"
diff --git a/README.md b/README.md
index eea2280c50c..7f5cd5ce522 100644
--- a/README.md
+++ b/README.md
@@ -43,7 +43,7 @@ Noir is free and open source. It is distributed under a dual license. (MIT/APACH
 Unless you explicitly state otherwise, any contribution intentionally submitted for inclusion in this repository by you, as defined in the Apache-2.0 license, shall be dual licensed as above, without any additional terms or conditions.
 
 [Noir]: https://www.noir-lang.org/
-[Getting Started]: https://noir-lang.org/docs/getting_started/installation/
+[Getting Started]: https://noir-lang.org/docs/getting_started/quick_start/
 [Forum]: https://forum.aztec.network/c/noir
 [Discord]: https://discord.gg/JtqzkdeQ6G
 [Documentation]: https://noir-lang.org/docs
diff --git a/acvm-repo/CHANGELOG.md b/acvm-repo/CHANGELOG.md
index 8d47e10c45a..70d5840be6a 100644
--- a/acvm-repo/CHANGELOG.md
+++ b/acvm-repo/CHANGELOG.md
@@ -5,6 +5,575 @@ All notable changes to this project will be documented in this file.
 The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/),
 and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 
+## [0.55.0](https://github.com/noir-lang/noir/compare/v0.54.0...v0.55.0) (2024-11-19)
+
+
+### ⚠ BREAKING CHANGES
+
+* Remove `recursive` from ACIR format; add them to API and CLI (https://github.com/AztecProtocol/aztec-packages/pull/9479)
+* **avm/brillig:** revert/rethrow oracle (https://github.com/AztecProtocol/aztec-packages/pull/9408)
+* use Brillig opcode when possible for less-than operations on fields (https://github.com/AztecProtocol/aztec-packages/pull/9416)
+* remove noir_js_backend_barretenberg (https://github.com/AztecProtocol/aztec-packages/pull/9338)
+* replace usage of vector in keccakf1600 input with array (https://github.com/AztecProtocol/aztec-packages/pull/9350)
+* **profiler:** New flamegraph command that profiles the opcodes executed ([#6327](https://github.com/noir-lang/noir/issues/6327))
+* remove pedersen commitment (https://github.com/AztecProtocol/aztec-packages/pull/9107)
+* remove pedersen hash opcode (https://github.com/AztecProtocol/aztec-packages/pull/9245)
+* Brillig and AVM default all uninitialized memory cells to Field 0 (https://github.com/AztecProtocol/aztec-packages/pull/9057)
+* remove keccak256 opcode from ACIR/Brillig (https://github.com/AztecProtocol/aztec-packages/pull/9104)
+* Brillig with a stack and conditional inlining (https://github.com/AztecProtocol/aztec-packages/pull/8989)
+* **avm:** remove CMOV opcode (https://github.com/AztecProtocol/aztec-packages/pull/9030)
+* remove sha256 opcode (https://github.com/AztecProtocol/aztec-packages/pull/4571)
+* add support for u1 in the avm, ToRadix's radix arg is a memory addr (https://github.com/AztecProtocol/aztec-packages/pull/8570)
+* Add Not instruction in brillig (https://github.com/AztecProtocol/aztec-packages/pull/8488)
+* **avm:** variants for SET opcode (https://github.com/AztecProtocol/aztec-packages/pull/8441)
+* **avm/brillig:** take addresses in calldatacopy (https://github.com/AztecProtocol/aztec-packages/pull/8388)
+
+### Features
+
+* (bb) 128-bit challenges (https://github.com/AztecProtocol/aztec-packages/pull/8406) ([3c3ed1e](https://github.com/noir-lang/noir/commit/3c3ed1e3d28946a02071c524dd128afe131bc3da))
+* Add assertions for ACVM `FunctionInput` `bit_size` ([#5864](https://github.com/noir-lang/noir/issues/5864)) ([8712f4c](https://github.com/noir-lang/noir/commit/8712f4c20d23f3809bcfb03f2e3ba0e5ace20a1d))
+* Add Not instruction in brillig (https://github.com/AztecProtocol/aztec-packages/pull/8488) ([95e19ab](https://github.com/noir-lang/noir/commit/95e19ab9486ad054241b6e53e40e55bdba9dc7e5))
+* Add recursive aggregation object to proving/verification keys (https://github.com/AztecProtocol/aztec-packages/pull/6770) ([4ea25db](https://github.com/noir-lang/noir/commit/4ea25dbde87488e758139619a3ce4edf93c6ebd6))
+* Add reusable procedures to brillig generation (https://github.com/AztecProtocol/aztec-packages/pull/7981) ([5c4f19f](https://github.com/noir-lang/noir/commit/5c4f19f097dd3704522996330c961bf0a2db8d99))
+* Add support for u1 in the avm, ToRadix's radix arg is a memory addr (https://github.com/AztecProtocol/aztec-packages/pull/8570) ([e8bbce7](https://github.com/noir-lang/noir/commit/e8bbce71fde3fc7af410c30920c2a547389d8248))
+* Added indirect const instruction (https://github.com/AztecProtocol/aztec-packages/pull/8065) ([5c4f19f](https://github.com/noir-lang/noir/commit/5c4f19f097dd3704522996330c961bf0a2db8d99))
+* Adding aggregation to honk and rollup (https://github.com/AztecProtocol/aztec-packages/pull/7466) ([4ea25db](https://github.com/noir-lang/noir/commit/4ea25dbde87488e758139619a3ce4edf93c6ebd6))
+* Automate verify_honk_proof input generation (https://github.com/AztecProtocol/aztec-packages/pull/8092) ([5c4f19f](https://github.com/noir-lang/noir/commit/5c4f19f097dd3704522996330c961bf0a2db8d99))
+* **avm/brillig:** Revert/rethrow oracle (https://github.com/AztecProtocol/aztec-packages/pull/9408) ([321a493](https://github.com/noir-lang/noir/commit/321a493216e19a2f077007c3447a3030db0df0d0))
+* **avm/brillig:** Take addresses in calldatacopy (https://github.com/AztecProtocol/aztec-packages/pull/8388) ([3c3ed1e](https://github.com/noir-lang/noir/commit/3c3ed1e3d28946a02071c524dd128afe131bc3da))
+* **avm:** Variants for SET opcode (https://github.com/AztecProtocol/aztec-packages/pull/8441) ([3c3ed1e](https://github.com/noir-lang/noir/commit/3c3ed1e3d28946a02071c524dd128afe131bc3da))
+* Brillig and AVM default all uninitialized memory cells to Field 0 (https://github.com/AztecProtocol/aztec-packages/pull/9057) ([70dcf4a](https://github.com/noir-lang/noir/commit/70dcf4a25dcad10daeb427f0887d3a0bf10c9916))
+* Brillig with a stack and conditional inlining (https://github.com/AztecProtocol/aztec-packages/pull/8989) ([70dcf4a](https://github.com/noir-lang/noir/commit/70dcf4a25dcad10daeb427f0887d3a0bf10c9916))
+* Change the layout of arrays and vectors to be a single pointer (https://github.com/AztecProtocol/aztec-packages/pull/8448) ([d4832ec](https://github.com/noir-lang/noir/commit/d4832ece9d3ad16544afea49cc7caf40501a2cc3))
+* Encode static error strings in the ABI (https://github.com/AztecProtocol/aztec-packages/pull/9552) ([7dd71c1](https://github.com/noir-lang/noir/commit/7dd71c15cbcbf025ba049b506c94924903b32754))
+* Ensure that generated ACIR is solvable ([#6415](https://github.com/noir-lang/noir/issues/6415)) ([b473d99](https://github.com/noir-lang/noir/commit/b473d99b2b70b595596b8392617256dbaf5d5642))
+* Hook up secondary calldata column in dsl (https://github.com/AztecProtocol/aztec-packages/pull/7759) ([4ea25db](https://github.com/noir-lang/noir/commit/4ea25dbde87488e758139619a3ce4edf93c6ebd6))
+* Integrate databus in the private kernels (https://github.com/AztecProtocol/aztec-packages/pull/9028) ([70dcf4a](https://github.com/noir-lang/noir/commit/70dcf4a25dcad10daeb427f0887d3a0bf10c9916))
+* Make token transfer be recursive (https://github.com/AztecProtocol/aztec-packages/pull/7730) ([4ea25db](https://github.com/noir-lang/noir/commit/4ea25dbde87488e758139619a3ce4edf93c6ebd6))
+* New test programs for wasm benchmarking (https://github.com/AztecProtocol/aztec-packages/pull/8389) ([95e19ab](https://github.com/noir-lang/noir/commit/95e19ab9486ad054241b6e53e40e55bdba9dc7e5))
+* Note hashes as points (https://github.com/AztecProtocol/aztec-packages/pull/7618) ([4ea25db](https://github.com/noir-lang/noir/commit/4ea25dbde87488e758139619a3ce4edf93c6ebd6))
+* Optimize allocating immediate amounts of memory (https://github.com/AztecProtocol/aztec-packages/pull/8579) ([e8bbce7](https://github.com/noir-lang/noir/commit/e8bbce71fde3fc7af410c30920c2a547389d8248))
+* Optimize constant array handling in brillig_gen (https://github.com/AztecProtocol/aztec-packages/pull/7661) ([4ea25db](https://github.com/noir-lang/noir/commit/4ea25dbde87488e758139619a3ce4edf93c6ebd6))
+* Optimize to_radix (https://github.com/AztecProtocol/aztec-packages/pull/8073) ([5c4f19f](https://github.com/noir-lang/noir/commit/5c4f19f097dd3704522996330c961bf0a2db8d99))
+* Parallelize DIE pass (https://github.com/AztecProtocol/aztec-packages/pull/9933) ([7dd71c1](https://github.com/noir-lang/noir/commit/7dd71c15cbcbf025ba049b506c94924903b32754))
+* Pass calldata ids to the backend (https://github.com/AztecProtocol/aztec-packages/pull/7875) ([4ea25db](https://github.com/noir-lang/noir/commit/4ea25dbde87488e758139619a3ce4edf93c6ebd6))
+* Poseidon2 gates for Ultra arithmetisation (https://github.com/AztecProtocol/aztec-packages/pull/7494) ([5c4f19f](https://github.com/noir-lang/noir/commit/5c4f19f097dd3704522996330c961bf0a2db8d99))
+* **profiler:** Add support for brillig functions in opcodes-flamegraph (https://github.com/AztecProtocol/aztec-packages/pull/7698) ([4ea25db](https://github.com/noir-lang/noir/commit/4ea25dbde87488e758139619a3ce4edf93c6ebd6))
+* **profiler:** New flamegraph command that profiles the opcodes executed ([#6327](https://github.com/noir-lang/noir/issues/6327)) ([4d87c9a](https://github.com/noir-lang/noir/commit/4d87c9ac78b48b4bd0ae81316df28aab390d004e))
+* Remove 'single use' intermediate variables ([#6268](https://github.com/noir-lang/noir/issues/6268)) ([ec75e8e](https://github.com/noir-lang/noir/commit/ec75e8ec59e0f2a2169aea67372411ede4074d09))
+* Remove sha256 opcode (https://github.com/AztecProtocol/aztec-packages/pull/4571) ([e8bbce7](https://github.com/noir-lang/noir/commit/e8bbce71fde3fc7af410c30920c2a547389d8248))
+* Removing superfluous call to MSM (https://github.com/AztecProtocol/aztec-packages/pull/7708) ([4ea25db](https://github.com/noir-lang/noir/commit/4ea25dbde87488e758139619a3ce4edf93c6ebd6))
+* Report gates and VKs of private protocol circuits with megahonk (https://github.com/AztecProtocol/aztec-packages/pull/7722) ([4ea25db](https://github.com/noir-lang/noir/commit/4ea25dbde87488e758139619a3ce4edf93c6ebd6))
+* Simplify constant calls to `poseidon2_permutation`, `schnorr_verify` and `embedded_curve_add` ([#5140](https://github.com/noir-lang/noir/issues/5140)) ([2823ba7](https://github.com/noir-lang/noir/commit/2823ba7242db788ca1d7f6e7a48be2f1de62f278))
+* Simplify constant MSM calls in SSA ([#6547](https://github.com/noir-lang/noir/issues/6547)) ([f291e37](https://github.com/noir-lang/noir/commit/f291e3702589a5cd043acfded5e187f56ec765cc))
+* Small optimization in toradix (https://github.com/AztecProtocol/aztec-packages/pull/8040) ([5c4f19f](https://github.com/noir-lang/noir/commit/5c4f19f097dd3704522996330c961bf0a2db8d99))
+* Stop with HeapVector (https://github.com/AztecProtocol/aztec-packages/pull/9810) ([7dd71c1](https://github.com/noir-lang/noir/commit/7dd71c15cbcbf025ba049b506c94924903b32754))
+* Sync from noir (https://github.com/AztecProtocol/aztec-packages/pull/7743) ([4ea25db](https://github.com/noir-lang/noir/commit/4ea25dbde87488e758139619a3ce4edf93c6ebd6))
+* Sync from noir (https://github.com/AztecProtocol/aztec-packages/pull/7862) ([4ea25db](https://github.com/noir-lang/noir/commit/4ea25dbde87488e758139619a3ce4edf93c6ebd6))
+* Sync from noir (https://github.com/AztecProtocol/aztec-packages/pull/7945) ([4ea25db](https://github.com/noir-lang/noir/commit/4ea25dbde87488e758139619a3ce4edf93c6ebd6))
+* Sync from noir (https://github.com/AztecProtocol/aztec-packages/pull/7958) ([5c4f19f](https://github.com/noir-lang/noir/commit/5c4f19f097dd3704522996330c961bf0a2db8d99))
+* Sync from noir (https://github.com/AztecProtocol/aztec-packages/pull/8008) ([5c4f19f](https://github.com/noir-lang/noir/commit/5c4f19f097dd3704522996330c961bf0a2db8d99))
+* Sync from noir (https://github.com/AztecProtocol/aztec-packages/pull/8093) ([5c4f19f](https://github.com/noir-lang/noir/commit/5c4f19f097dd3704522996330c961bf0a2db8d99))
+* Sync from noir (https://github.com/AztecProtocol/aztec-packages/pull/8125) ([f0c2686](https://github.com/noir-lang/noir/commit/f0c268606a71381ab4504396695a0adb9b3258b6))
+* Sync from noir (https://github.com/AztecProtocol/aztec-packages/pull/8237) ([f0c2686](https://github.com/noir-lang/noir/commit/f0c268606a71381ab4504396695a0adb9b3258b6))
+* Sync from noir (https://github.com/AztecProtocol/aztec-packages/pull/8423) ([3c3ed1e](https://github.com/noir-lang/noir/commit/3c3ed1e3d28946a02071c524dd128afe131bc3da))
+* Sync from noir (https://github.com/AztecProtocol/aztec-packages/pull/8435) ([3c3ed1e](https://github.com/noir-lang/noir/commit/3c3ed1e3d28946a02071c524dd128afe131bc3da))
+* Sync from noir (https://github.com/AztecProtocol/aztec-packages/pull/8466) ([3c3ed1e](https://github.com/noir-lang/noir/commit/3c3ed1e3d28946a02071c524dd128afe131bc3da))
+* Sync from noir (https://github.com/AztecProtocol/aztec-packages/pull/8482) ([d4832ec](https://github.com/noir-lang/noir/commit/d4832ece9d3ad16544afea49cc7caf40501a2cc3))
+* Sync from noir (https://github.com/AztecProtocol/aztec-packages/pull/8512) ([95e19ab](https://github.com/noir-lang/noir/commit/95e19ab9486ad054241b6e53e40e55bdba9dc7e5))
+* Sync from noir (https://github.com/AztecProtocol/aztec-packages/pull/8526) ([95e19ab](https://github.com/noir-lang/noir/commit/95e19ab9486ad054241b6e53e40e55bdba9dc7e5))
+* Sync from noir (https://github.com/AztecProtocol/aztec-packages/pull/8934) ([70dcf4a](https://github.com/noir-lang/noir/commit/70dcf4a25dcad10daeb427f0887d3a0bf10c9916))
+* Sync from noir (https://github.com/AztecProtocol/aztec-packages/pull/9034) ([70dcf4a](https://github.com/noir-lang/noir/commit/70dcf4a25dcad10daeb427f0887d3a0bf10c9916))
+* Sync from noir (https://github.com/AztecProtocol/aztec-packages/pull/9099) ([70dcf4a](https://github.com/noir-lang/noir/commit/70dcf4a25dcad10daeb427f0887d3a0bf10c9916))
+* Sync from noir (https://github.com/AztecProtocol/aztec-packages/pull/9275) ([70dcf4a](https://github.com/noir-lang/noir/commit/70dcf4a25dcad10daeb427f0887d3a0bf10c9916))
+* Sync from noir (https://github.com/AztecProtocol/aztec-packages/pull/9711) ([7dd71c1](https://github.com/noir-lang/noir/commit/7dd71c15cbcbf025ba049b506c94924903b32754))
+* **test:** Fuzz test poseidon2 hash equivalence ([#6265](https://github.com/noir-lang/noir/issues/6265)) ([f61ba03](https://github.com/noir-lang/noir/commit/f61ba037c6726e19be4f894d9447fe396df95417))
+* **test:** Fuzz test stdlib hash functions ([#6233](https://github.com/noir-lang/noir/issues/6233)) ([1a2ca46](https://github.com/noir-lang/noir/commit/1a2ca46af0d1c05813dbe28670a2bc39b79e4c9f))
+* TXE nr deployments, dependency cleanup for CLI (https://github.com/AztecProtocol/aztec-packages/pull/7548) ([4ea25db](https://github.com/noir-lang/noir/commit/4ea25dbde87488e758139619a3ce4edf93c6ebd6))
+* Unify all acir recursion constraints based on RecursionConstraint and proof_type (https://github.com/AztecProtocol/aztec-packages/pull/7993) ([5c4f19f](https://github.com/noir-lang/noir/commit/5c4f19f097dd3704522996330c961bf0a2db8d99))
+
+
+### Bug Fixes
+
+* **debugger:** Update the debugger to handle the new Brillig debug metadata format ([#5706](https://github.com/noir-lang/noir/issues/5706)) ([a31f82e](https://github.com/noir-lang/noir/commit/a31f82e598def60d00c65b79b8c5411f8aa832aa))
+* Deflatten databus visibilities (https://github.com/AztecProtocol/aztec-packages/pull/7761) ([4ea25db](https://github.com/noir-lang/noir/commit/4ea25dbde87488e758139619a3ce4edf93c6ebd6))
+* Discard optimisation that would change execution ordering or that is related to call outputs ([#6461](https://github.com/noir-lang/noir/issues/6461)) ([b8654f7](https://github.com/noir-lang/noir/commit/b8654f700b218cc09c5381af65df11ead9ffcdaf))
+* Display every bit in integer tokens ([#6360](https://github.com/noir-lang/noir/issues/6360)) ([b985fdf](https://github.com/noir-lang/noir/commit/b985fdf6e635570b8db3af83d9ec14e7cd749062))
+* Do not duplicate redundant Brillig debug metadata ([#5696](https://github.com/noir-lang/noir/issues/5696)) ([e4f7dbe](https://github.com/noir-lang/noir/commit/e4f7dbe63b55807b3ff0b4d6f47a8b7f847299fb))
+* Export brillig names in contract functions (https://github.com/AztecProtocol/aztec-packages/pull/8212) ([f0c2686](https://github.com/noir-lang/noir/commit/f0c268606a71381ab4504396695a0adb9b3258b6))
+* Handle multiple entry points for Brillig call stack resolution after metadata deduplication ([#5788](https://github.com/noir-lang/noir/issues/5788)) ([38fe9dd](https://github.com/noir-lang/noir/commit/38fe9dda111952fdb894df90a319c087382edfc9))
+* Homogeneous input points for EC ADD ([#6241](https://github.com/noir-lang/noir/issues/6241)) ([f6a7306](https://github.com/noir-lang/noir/commit/f6a7306436ea1a37ec7f3b884721b50467e9a063))
+* Reject invalid expression with in CLI parser ([#6287](https://github.com/noir-lang/noir/issues/6287)) ([052aee8](https://github.com/noir-lang/noir/commit/052aee80ff3e1e4fd2ca45310d7bb8b980af126a))
+* Remove need for duplicate attributes on each function (https://github.com/AztecProtocol/aztec-packages/pull/9244) ([70dcf4a](https://github.com/noir-lang/noir/commit/70dcf4a25dcad10daeb427f0887d3a0bf10c9916))
+* Restrict keccak256_injective test input to 8 bits ([#5977](https://github.com/noir-lang/noir/issues/5977)) ([a1b1346](https://github.com/noir-lang/noir/commit/a1b1346bf7525c508fd390393c307475cc2345d7))
+* Take blackbox function outputs into account when merging expressions ([#6532](https://github.com/noir-lang/noir/issues/6532)) ([713df69](https://github.com/noir-lang/noir/commit/713df69aad56fc5aaefd5d140275a3217de4d866))
+* **tests:** Prevent EOF error while running test programs ([#6455](https://github.com/noir-lang/noir/issues/6455)) ([358e381](https://github.com/noir-lang/noir/commit/358e38107edbc4f40c97b88196456d82f5557e3f))
+* Typing of artifacts (https://github.com/AztecProtocol/aztec-packages/pull/9581) ([7dd71c1](https://github.com/noir-lang/noir/commit/7dd71c15cbcbf025ba049b506c94924903b32754))
+
+
+### Miscellaneous Chores
+
+* Remove `recursive` from ACIR format; add them to API and CLI (https://github.com/AztecProtocol/aztec-packages/pull/9479) ([7dd71c1](https://github.com/noir-lang/noir/commit/7dd71c15cbcbf025ba049b506c94924903b32754))
+* Remove keccak256 opcode from ACIR/Brillig (https://github.com/AztecProtocol/aztec-packages/pull/9104) ([70dcf4a](https://github.com/noir-lang/noir/commit/70dcf4a25dcad10daeb427f0887d3a0bf10c9916))
+* Remove noir_js_backend_barretenberg (https://github.com/AztecProtocol/aztec-packages/pull/9338) ([3925228](https://github.com/noir-lang/noir/commit/392522880e102e275ebcf42f16651a8ffa0bbbd2))
+* Remove pedersen commitment (https://github.com/AztecProtocol/aztec-packages/pull/9107) ([70dcf4a](https://github.com/noir-lang/noir/commit/70dcf4a25dcad10daeb427f0887d3a0bf10c9916))
+* Remove pedersen hash opcode (https://github.com/AztecProtocol/aztec-packages/pull/9245) ([70dcf4a](https://github.com/noir-lang/noir/commit/70dcf4a25dcad10daeb427f0887d3a0bf10c9916))
+* Replace usage of vector in keccakf1600 input with array (https://github.com/AztecProtocol/aztec-packages/pull/9350) ([3925228](https://github.com/noir-lang/noir/commit/392522880e102e275ebcf42f16651a8ffa0bbbd2))
+* Use Brillig opcode when possible for less-than operations on fields (https://github.com/AztecProtocol/aztec-packages/pull/9416) ([321a493](https://github.com/noir-lang/noir/commit/321a493216e19a2f077007c3447a3030db0df0d0))
+
+
+### Code Refactoring
+
+* **avm:** Remove CMOV opcode (https://github.com/AztecProtocol/aztec-packages/pull/9030) ([70dcf4a](https://github.com/noir-lang/noir/commit/70dcf4a25dcad10daeb427f0887d3a0bf10c9916))
+
+## [0.54.0](https://github.com/noir-lang/noir/compare/v0.53.0...v0.54.0) (2024-11-08)
+
+
+### ⚠ BREAKING CHANGES
+
+* **avm/brillig:** revert/rethrow oracle (https://github.com/AztecProtocol/aztec-packages/pull/9408)
+* use Brillig opcode when possible for less-than operations on fields (https://github.com/AztecProtocol/aztec-packages/pull/9416)
+* remove noir_js_backend_barretenberg (https://github.com/AztecProtocol/aztec-packages/pull/9338)
+* replace usage of vector in keccakf1600 input with array (https://github.com/AztecProtocol/aztec-packages/pull/9350)
+* **profiler:** New flamegraph command that profiles the opcodes executed ([#6327](https://github.com/noir-lang/noir/issues/6327))
+* remove pedersen commitment (https://github.com/AztecProtocol/aztec-packages/pull/9107)
+* remove pedersen hash opcode (https://github.com/AztecProtocol/aztec-packages/pull/9245)
+* Brillig and AVM default all uninitialized memory cells to Field 0 (https://github.com/AztecProtocol/aztec-packages/pull/9057)
+* remove keccak256 opcode from ACIR/Brillig (https://github.com/AztecProtocol/aztec-packages/pull/9104)
+* Brillig with a stack and conditional inlining (https://github.com/AztecProtocol/aztec-packages/pull/8989)
+* **avm:** remove CMOV opcode (https://github.com/AztecProtocol/aztec-packages/pull/9030)
+* remove sha256 opcode (https://github.com/AztecProtocol/aztec-packages/pull/4571)
+* add support for u1 in the avm, ToRadix's radix arg is a memory addr (https://github.com/AztecProtocol/aztec-packages/pull/8570)
+* Add Not instruction in brillig (https://github.com/AztecProtocol/aztec-packages/pull/8488)
+* **avm:** variants for SET opcode (https://github.com/AztecProtocol/aztec-packages/pull/8441)
+* **avm/brillig:** take addresses in calldatacopy (https://github.com/AztecProtocol/aztec-packages/pull/8388)
+
+### Features
+
+* (bb) 128-bit challenges (https://github.com/AztecProtocol/aztec-packages/pull/8406) ([3c3ed1e](https://github.com/noir-lang/noir/commit/3c3ed1e3d28946a02071c524dd128afe131bc3da))
+* **acir_gen:** Width aware ACIR gen addition ([#5493](https://github.com/noir-lang/noir/issues/5493)) ([85fa592](https://github.com/noir-lang/noir/commit/85fa592fdef3b8589ce03b232e1b51565837b540))
+* Add assertions for ACVM `FunctionInput` `bit_size` ([#5864](https://github.com/noir-lang/noir/issues/5864)) ([8712f4c](https://github.com/noir-lang/noir/commit/8712f4c20d23f3809bcfb03f2e3ba0e5ace20a1d))
+* Add Not instruction in brillig (https://github.com/AztecProtocol/aztec-packages/pull/8488) ([95e19ab](https://github.com/noir-lang/noir/commit/95e19ab9486ad054241b6e53e40e55bdba9dc7e5))
+* Add recursive aggregation object to proving/verification keys (https://github.com/AztecProtocol/aztec-packages/pull/6770) ([4ea25db](https://github.com/noir-lang/noir/commit/4ea25dbde87488e758139619a3ce4edf93c6ebd6))
+* Add reusable procedures to brillig generation (https://github.com/AztecProtocol/aztec-packages/pull/7981) ([5c4f19f](https://github.com/noir-lang/noir/commit/5c4f19f097dd3704522996330c961bf0a2db8d99))
+* Add support for u1 in the avm, ToRadix's radix arg is a memory addr (https://github.com/AztecProtocol/aztec-packages/pull/8570) ([e8bbce7](https://github.com/noir-lang/noir/commit/e8bbce71fde3fc7af410c30920c2a547389d8248))
+* Added indirect const instruction (https://github.com/AztecProtocol/aztec-packages/pull/8065) ([5c4f19f](https://github.com/noir-lang/noir/commit/5c4f19f097dd3704522996330c961bf0a2db8d99))
+* Adding aggregation to honk and rollup (https://github.com/AztecProtocol/aztec-packages/pull/7466) ([4ea25db](https://github.com/noir-lang/noir/commit/4ea25dbde87488e758139619a3ce4edf93c6ebd6))
+* Automate verify_honk_proof input generation (https://github.com/AztecProtocol/aztec-packages/pull/8092) ([5c4f19f](https://github.com/noir-lang/noir/commit/5c4f19f097dd3704522996330c961bf0a2db8d99))
+* **avm/brillig:** Revert/rethrow oracle (https://github.com/AztecProtocol/aztec-packages/pull/9408) ([321a493](https://github.com/noir-lang/noir/commit/321a493216e19a2f077007c3447a3030db0df0d0))
+* **avm/brillig:** Take addresses in calldatacopy (https://github.com/AztecProtocol/aztec-packages/pull/8388) ([3c3ed1e](https://github.com/noir-lang/noir/commit/3c3ed1e3d28946a02071c524dd128afe131bc3da))
+* **avm:** Variants for SET opcode (https://github.com/AztecProtocol/aztec-packages/pull/8441) ([3c3ed1e](https://github.com/noir-lang/noir/commit/3c3ed1e3d28946a02071c524dd128afe131bc3da))
+* Avoid heap allocs when going to/from field (https://github.com/AztecProtocol/aztec-packages/pull/7547) ([daad75c](https://github.com/noir-lang/noir/commit/daad75c26d19ae707b90a7424b77dab9937e8575))
+* Brillig and AVM default all uninitialized memory cells to Field 0 (https://github.com/AztecProtocol/aztec-packages/pull/9057) ([70dcf4a](https://github.com/noir-lang/noir/commit/70dcf4a25dcad10daeb427f0887d3a0bf10c9916))
+* Brillig with a stack and conditional inlining (https://github.com/AztecProtocol/aztec-packages/pull/8989) ([70dcf4a](https://github.com/noir-lang/noir/commit/70dcf4a25dcad10daeb427f0887d3a0bf10c9916))
+* Change the layout of arrays and vectors to be a single pointer (https://github.com/AztecProtocol/aztec-packages/pull/8448) ([d4832ec](https://github.com/noir-lang/noir/commit/d4832ece9d3ad16544afea49cc7caf40501a2cc3))
+* Ensure that generated ACIR is solvable ([#6415](https://github.com/noir-lang/noir/issues/6415)) ([b473d99](https://github.com/noir-lang/noir/commit/b473d99b2b70b595596b8392617256dbaf5d5642))
+* Hook up secondary calldata column in dsl (https://github.com/AztecProtocol/aztec-packages/pull/7759) ([4ea25db](https://github.com/noir-lang/noir/commit/4ea25dbde87488e758139619a3ce4edf93c6ebd6))
+* Integrate databus in the private kernels (https://github.com/AztecProtocol/aztec-packages/pull/9028) ([70dcf4a](https://github.com/noir-lang/noir/commit/70dcf4a25dcad10daeb427f0887d3a0bf10c9916))
+* Integrate new proving systems in e2e (https://github.com/AztecProtocol/aztec-packages/pull/6971) ([daad75c](https://github.com/noir-lang/noir/commit/daad75c26d19ae707b90a7424b77dab9937e8575))
+* Make Brillig do integer arithmetic operations using u128 instead of Bigint (https://github.com/AztecProtocol/aztec-packages/pull/7518) ([daad75c](https://github.com/noir-lang/noir/commit/daad75c26d19ae707b90a7424b77dab9937e8575))
+* Make token transfer be recursive (https://github.com/AztecProtocol/aztec-packages/pull/7730) ([4ea25db](https://github.com/noir-lang/noir/commit/4ea25dbde87488e758139619a3ce4edf93c6ebd6))
+* New test programs for wasm benchmarking (https://github.com/AztecProtocol/aztec-packages/pull/8389) ([95e19ab](https://github.com/noir-lang/noir/commit/95e19ab9486ad054241b6e53e40e55bdba9dc7e5))
+* Note hashes as points (https://github.com/AztecProtocol/aztec-packages/pull/7618) ([4ea25db](https://github.com/noir-lang/noir/commit/4ea25dbde87488e758139619a3ce4edf93c6ebd6))
+* Optimize allocating immediate amounts of memory (https://github.com/AztecProtocol/aztec-packages/pull/8579) ([e8bbce7](https://github.com/noir-lang/noir/commit/e8bbce71fde3fc7af410c30920c2a547389d8248))
+* Optimize constant array handling in brillig_gen (https://github.com/AztecProtocol/aztec-packages/pull/7661) ([4ea25db](https://github.com/noir-lang/noir/commit/4ea25dbde87488e758139619a3ce4edf93c6ebd6))
+* Optimize to_radix (https://github.com/AztecProtocol/aztec-packages/pull/8073) ([5c4f19f](https://github.com/noir-lang/noir/commit/5c4f19f097dd3704522996330c961bf0a2db8d99))
+* Pass calldata ids to the backend (https://github.com/AztecProtocol/aztec-packages/pull/7875) ([4ea25db](https://github.com/noir-lang/noir/commit/4ea25dbde87488e758139619a3ce4edf93c6ebd6))
+* Poseidon2 gates for Ultra arithmetisation (https://github.com/AztecProtocol/aztec-packages/pull/7494) ([5c4f19f](https://github.com/noir-lang/noir/commit/5c4f19f097dd3704522996330c961bf0a2db8d99))
+* **profiler:** Add support for brillig functions in opcodes-flamegraph (https://github.com/AztecProtocol/aztec-packages/pull/7698) ([4ea25db](https://github.com/noir-lang/noir/commit/4ea25dbde87488e758139619a3ce4edf93c6ebd6))
+* **profiler:** New flamegraph command that profiles the opcodes executed ([#6327](https://github.com/noir-lang/noir/issues/6327)) ([4d87c9a](https://github.com/noir-lang/noir/commit/4d87c9ac78b48b4bd0ae81316df28aab390d004e))
+* Remove 'single use' intermediate variables ([#6268](https://github.com/noir-lang/noir/issues/6268)) ([ec75e8e](https://github.com/noir-lang/noir/commit/ec75e8ec59e0f2a2169aea67372411ede4074d09))
+* Remove sha256 opcode (https://github.com/AztecProtocol/aztec-packages/pull/4571) ([e8bbce7](https://github.com/noir-lang/noir/commit/e8bbce71fde3fc7af410c30920c2a547389d8248))
+* Removing superfluous call to MSM (https://github.com/AztecProtocol/aztec-packages/pull/7708) ([4ea25db](https://github.com/noir-lang/noir/commit/4ea25dbde87488e758139619a3ce4edf93c6ebd6))
+* Report gates and VKs of private protocol circuits with megahonk (https://github.com/AztecProtocol/aztec-packages/pull/7722) ([4ea25db](https://github.com/noir-lang/noir/commit/4ea25dbde87488e758139619a3ce4edf93c6ebd6))
+* Simplify constant calls to `poseidon2_permutation`, `schnorr_verify` and `embedded_curve_add` ([#5140](https://github.com/noir-lang/noir/issues/5140)) ([2823ba7](https://github.com/noir-lang/noir/commit/2823ba7242db788ca1d7f6e7a48be2f1de62f278))
+* Small optimization in toradix (https://github.com/AztecProtocol/aztec-packages/pull/8040) ([5c4f19f](https://github.com/noir-lang/noir/commit/5c4f19f097dd3704522996330c961bf0a2db8d99))
+* Sync from noir (https://github.com/AztecProtocol/aztec-packages/pull/7432) ([daad75c](https://github.com/noir-lang/noir/commit/daad75c26d19ae707b90a7424b77dab9937e8575))
+* Sync from noir (https://github.com/AztecProtocol/aztec-packages/pull/7444) ([daad75c](https://github.com/noir-lang/noir/commit/daad75c26d19ae707b90a7424b77dab9937e8575))
+* Sync from noir (https://github.com/AztecProtocol/aztec-packages/pull/7454) ([daad75c](https://github.com/noir-lang/noir/commit/daad75c26d19ae707b90a7424b77dab9937e8575))
+* Sync from noir (https://github.com/AztecProtocol/aztec-packages/pull/7512) ([daad75c](https://github.com/noir-lang/noir/commit/daad75c26d19ae707b90a7424b77dab9937e8575))
+* Sync from noir (https://github.com/AztecProtocol/aztec-packages/pull/7577) ([daad75c](https://github.com/noir-lang/noir/commit/daad75c26d19ae707b90a7424b77dab9937e8575))
+* Sync from noir (https://github.com/AztecProtocol/aztec-packages/pull/7583) ([daad75c](https://github.com/noir-lang/noir/commit/daad75c26d19ae707b90a7424b77dab9937e8575))
+* Sync from noir (https://github.com/AztecProtocol/aztec-packages/pull/7743) ([4ea25db](https://github.com/noir-lang/noir/commit/4ea25dbde87488e758139619a3ce4edf93c6ebd6))
+* Sync from noir (https://github.com/AztecProtocol/aztec-packages/pull/7862) ([4ea25db](https://github.com/noir-lang/noir/commit/4ea25dbde87488e758139619a3ce4edf93c6ebd6))
+* Sync from noir (https://github.com/AztecProtocol/aztec-packages/pull/7945) ([4ea25db](https://github.com/noir-lang/noir/commit/4ea25dbde87488e758139619a3ce4edf93c6ebd6))
+* Sync from noir (https://github.com/AztecProtocol/aztec-packages/pull/7958) ([5c4f19f](https://github.com/noir-lang/noir/commit/5c4f19f097dd3704522996330c961bf0a2db8d99))
+* Sync from noir (https://github.com/AztecProtocol/aztec-packages/pull/8008) ([5c4f19f](https://github.com/noir-lang/noir/commit/5c4f19f097dd3704522996330c961bf0a2db8d99))
+* Sync from noir (https://github.com/AztecProtocol/aztec-packages/pull/8093) ([5c4f19f](https://github.com/noir-lang/noir/commit/5c4f19f097dd3704522996330c961bf0a2db8d99))
+* Sync from noir (https://github.com/AztecProtocol/aztec-packages/pull/8125) ([f0c2686](https://github.com/noir-lang/noir/commit/f0c268606a71381ab4504396695a0adb9b3258b6))
+* Sync from noir (https://github.com/AztecProtocol/aztec-packages/pull/8237) ([f0c2686](https://github.com/noir-lang/noir/commit/f0c268606a71381ab4504396695a0adb9b3258b6))
+* Sync from noir (https://github.com/AztecProtocol/aztec-packages/pull/8423) ([3c3ed1e](https://github.com/noir-lang/noir/commit/3c3ed1e3d28946a02071c524dd128afe131bc3da))
+* Sync from noir (https://github.com/AztecProtocol/aztec-packages/pull/8435) ([3c3ed1e](https://github.com/noir-lang/noir/commit/3c3ed1e3d28946a02071c524dd128afe131bc3da))
+* Sync from noir (https://github.com/AztecProtocol/aztec-packages/pull/8466) ([3c3ed1e](https://github.com/noir-lang/noir/commit/3c3ed1e3d28946a02071c524dd128afe131bc3da))
+* Sync from noir (https://github.com/AztecProtocol/aztec-packages/pull/8482) ([d4832ec](https://github.com/noir-lang/noir/commit/d4832ece9d3ad16544afea49cc7caf40501a2cc3))
+* Sync from noir (https://github.com/AztecProtocol/aztec-packages/pull/8512) ([95e19ab](https://github.com/noir-lang/noir/commit/95e19ab9486ad054241b6e53e40e55bdba9dc7e5))
+* Sync from noir (https://github.com/AztecProtocol/aztec-packages/pull/8526) ([95e19ab](https://github.com/noir-lang/noir/commit/95e19ab9486ad054241b6e53e40e55bdba9dc7e5))
+* Sync from noir (https://github.com/AztecProtocol/aztec-packages/pull/8934) ([70dcf4a](https://github.com/noir-lang/noir/commit/70dcf4a25dcad10daeb427f0887d3a0bf10c9916))
+* Sync from noir (https://github.com/AztecProtocol/aztec-packages/pull/9034) ([70dcf4a](https://github.com/noir-lang/noir/commit/70dcf4a25dcad10daeb427f0887d3a0bf10c9916))
+* Sync from noir (https://github.com/AztecProtocol/aztec-packages/pull/9099) ([70dcf4a](https://github.com/noir-lang/noir/commit/70dcf4a25dcad10daeb427f0887d3a0bf10c9916))
+* Sync from noir (https://github.com/AztecProtocol/aztec-packages/pull/9275) ([70dcf4a](https://github.com/noir-lang/noir/commit/70dcf4a25dcad10daeb427f0887d3a0bf10c9916))
+* **test:** Fuzz test poseidon2 hash equivalence ([#6265](https://github.com/noir-lang/noir/issues/6265)) ([f61ba03](https://github.com/noir-lang/noir/commit/f61ba037c6726e19be4f894d9447fe396df95417))
+* **test:** Fuzz test stdlib hash functions ([#6233](https://github.com/noir-lang/noir/issues/6233)) ([1a2ca46](https://github.com/noir-lang/noir/commit/1a2ca46af0d1c05813dbe28670a2bc39b79e4c9f))
+* TXE nr deployments, dependency cleanup for CLI (https://github.com/AztecProtocol/aztec-packages/pull/7548) ([4ea25db](https://github.com/noir-lang/noir/commit/4ea25dbde87488e758139619a3ce4edf93c6ebd6))
+* Typing return values of embedded_curve_ops (https://github.com/AztecProtocol/aztec-packages/pull/7413) ([daad75c](https://github.com/noir-lang/noir/commit/daad75c26d19ae707b90a7424b77dab9937e8575))
+* Unify all acir recursion constraints based on RecursionConstraint and proof_type (https://github.com/AztecProtocol/aztec-packages/pull/7993) ([5c4f19f](https://github.com/noir-lang/noir/commit/5c4f19f097dd3704522996330c961bf0a2db8d99))
+
+
+### Bug Fixes
+
+* Add trailing extra arguments for backend in gates_flamegraph (https://github.com/AztecProtocol/aztec-packages/pull/7472) ([daad75c](https://github.com/noir-lang/noir/commit/daad75c26d19ae707b90a7424b77dab9937e8575))
+* **debugger:** Update the debugger to handle the new Brillig debug metadata format ([#5706](https://github.com/noir-lang/noir/issues/5706)) ([a31f82e](https://github.com/noir-lang/noir/commit/a31f82e598def60d00c65b79b8c5411f8aa832aa))
+* Deflatten databus visibilities (https://github.com/AztecProtocol/aztec-packages/pull/7761) ([4ea25db](https://github.com/noir-lang/noir/commit/4ea25dbde87488e758139619a3ce4edf93c6ebd6))
+* Discard optimisation that would change execution ordering or that is related to call outputs ([#6461](https://github.com/noir-lang/noir/issues/6461)) ([b8654f7](https://github.com/noir-lang/noir/commit/b8654f700b218cc09c5381af65df11ead9ffcdaf))
+* Display every bit in integer tokens ([#6360](https://github.com/noir-lang/noir/issues/6360)) ([b985fdf](https://github.com/noir-lang/noir/commit/b985fdf6e635570b8db3af83d9ec14e7cd749062))
+* Do not duplicate redundant Brillig debug metadata ([#5696](https://github.com/noir-lang/noir/issues/5696)) ([e4f7dbe](https://github.com/noir-lang/noir/commit/e4f7dbe63b55807b3ff0b4d6f47a8b7f847299fb))
+* Export brillig names in contract functions (https://github.com/AztecProtocol/aztec-packages/pull/8212) ([f0c2686](https://github.com/noir-lang/noir/commit/f0c268606a71381ab4504396695a0adb9b3258b6))
+* Handle multiple entry points for Brillig call stack resolution after metadata deduplication ([#5788](https://github.com/noir-lang/noir/issues/5788)) ([38fe9dd](https://github.com/noir-lang/noir/commit/38fe9dda111952fdb894df90a319c087382edfc9))
+* Homogeneous input points for EC ADD ([#6241](https://github.com/noir-lang/noir/issues/6241)) ([f6a7306](https://github.com/noir-lang/noir/commit/f6a7306436ea1a37ec7f3b884721b50467e9a063))
+* Reject invalid expression with in CLI parser ([#6287](https://github.com/noir-lang/noir/issues/6287)) ([052aee8](https://github.com/noir-lang/noir/commit/052aee80ff3e1e4fd2ca45310d7bb8b980af126a))
+* Remove need for duplicate attributes on each function (https://github.com/AztecProtocol/aztec-packages/pull/9244) ([70dcf4a](https://github.com/noir-lang/noir/commit/70dcf4a25dcad10daeb427f0887d3a0bf10c9916))
+* Restrict keccak256_injective test input to 8 bits ([#5977](https://github.com/noir-lang/noir/issues/5977)) ([a1b1346](https://github.com/noir-lang/noir/commit/a1b1346bf7525c508fd390393c307475cc2345d7))
+* Revert "feat: Sync from noir (https://github.com/AztecProtocol/aztec-packages/pull/7512)" (https://github.com/AztecProtocol/aztec-packages/pull/7558) ([daad75c](https://github.com/noir-lang/noir/commit/daad75c26d19ae707b90a7424b77dab9937e8575))
+* **tests:** Prevent EOF error while running test programs ([#6455](https://github.com/noir-lang/noir/issues/6455)) ([358e381](https://github.com/noir-lang/noir/commit/358e38107edbc4f40c97b88196456d82f5557e3f))
+
+
+### Miscellaneous Chores
+
+* Remove keccak256 opcode from ACIR/Brillig (https://github.com/AztecProtocol/aztec-packages/pull/9104) ([70dcf4a](https://github.com/noir-lang/noir/commit/70dcf4a25dcad10daeb427f0887d3a0bf10c9916))
+* Remove noir_js_backend_barretenberg (https://github.com/AztecProtocol/aztec-packages/pull/9338) ([3925228](https://github.com/noir-lang/noir/commit/392522880e102e275ebcf42f16651a8ffa0bbbd2))
+* Remove pedersen commitment (https://github.com/AztecProtocol/aztec-packages/pull/9107) ([70dcf4a](https://github.com/noir-lang/noir/commit/70dcf4a25dcad10daeb427f0887d3a0bf10c9916))
+* Remove pedersen hash opcode (https://github.com/AztecProtocol/aztec-packages/pull/9245) ([70dcf4a](https://github.com/noir-lang/noir/commit/70dcf4a25dcad10daeb427f0887d3a0bf10c9916))
+* Replace usage of vector in keccakf1600 input with array (https://github.com/AztecProtocol/aztec-packages/pull/9350) ([3925228](https://github.com/noir-lang/noir/commit/392522880e102e275ebcf42f16651a8ffa0bbbd2))
+* Use Brillig opcode when possible for less-than operations on fields (https://github.com/AztecProtocol/aztec-packages/pull/9416) ([321a493](https://github.com/noir-lang/noir/commit/321a493216e19a2f077007c3447a3030db0df0d0))
+
+
+### Code Refactoring
+
+* **avm:** Remove CMOV opcode (https://github.com/AztecProtocol/aztec-packages/pull/9030) ([70dcf4a](https://github.com/noir-lang/noir/commit/70dcf4a25dcad10daeb427f0887d3a0bf10c9916))
+
+## [0.53.0](https://github.com/noir-lang/noir/compare/v0.52.0...v0.53.0) (2024-10-31)
+
+
+### ⚠ BREAKING CHANGES
+
+* **avm/brillig:** revert/rethrow oracle (https://github.com/AztecProtocol/aztec-packages/pull/9408)
+* use Brillig opcode when possible for less-than operations on fields (https://github.com/AztecProtocol/aztec-packages/pull/9416)
+* remove noir_js_backend_barretenberg (https://github.com/AztecProtocol/aztec-packages/pull/9338)
+* replace usage of vector in keccakf1600 input with array (https://github.com/AztecProtocol/aztec-packages/pull/9350)
+* **profiler:** New flamegraph command that profiles the opcodes executed ([#6327](https://github.com/noir-lang/noir/issues/6327))
+* remove pedersen commitment (https://github.com/AztecProtocol/aztec-packages/pull/9107)
+* remove pedersen hash opcode (https://github.com/AztecProtocol/aztec-packages/pull/9245)
+* Brillig and AVM default all uninitialized memory cells to Field 0 (https://github.com/AztecProtocol/aztec-packages/pull/9057)
+* remove keccak256 opcode from ACIR/Brillig (https://github.com/AztecProtocol/aztec-packages/pull/9104)
+* Brillig with a stack and conditional inlining (https://github.com/AztecProtocol/aztec-packages/pull/8989)
+* **avm:** remove CMOV opcode (https://github.com/AztecProtocol/aztec-packages/pull/9030)
+* remove sha256 opcode (https://github.com/AztecProtocol/aztec-packages/pull/4571)
+* add support for u1 in the avm, ToRadix's radix arg is a memory addr (https://github.com/AztecProtocol/aztec-packages/pull/8570)
+* Add Not instruction in brillig (https://github.com/AztecProtocol/aztec-packages/pull/8488)
+* **avm:** variants for SET opcode (https://github.com/AztecProtocol/aztec-packages/pull/8441)
+* **avm/brillig:** take addresses in calldatacopy (https://github.com/AztecProtocol/aztec-packages/pull/8388)
+
+### Features
+
+* (bb) 128-bit challenges (https://github.com/AztecProtocol/aztec-packages/pull/8406) ([3c3ed1e](https://github.com/noir-lang/noir/commit/3c3ed1e3d28946a02071c524dd128afe131bc3da))
+* **acir_gen:** Width aware ACIR gen addition ([#5493](https://github.com/noir-lang/noir/issues/5493)) ([85fa592](https://github.com/noir-lang/noir/commit/85fa592fdef3b8589ce03b232e1b51565837b540))
+* Add assertions for ACVM `FunctionInput` `bit_size` ([#5864](https://github.com/noir-lang/noir/issues/5864)) ([8712f4c](https://github.com/noir-lang/noir/commit/8712f4c20d23f3809bcfb03f2e3ba0e5ace20a1d))
+* Add Not instruction in brillig (https://github.com/AztecProtocol/aztec-packages/pull/8488) ([95e19ab](https://github.com/noir-lang/noir/commit/95e19ab9486ad054241b6e53e40e55bdba9dc7e5))
+* Add recursive aggregation object to proving/verification keys (https://github.com/AztecProtocol/aztec-packages/pull/6770) ([4ea25db](https://github.com/noir-lang/noir/commit/4ea25dbde87488e758139619a3ce4edf93c6ebd6))
+* Add reusable procedures to brillig generation (https://github.com/AztecProtocol/aztec-packages/pull/7981) ([5c4f19f](https://github.com/noir-lang/noir/commit/5c4f19f097dd3704522996330c961bf0a2db8d99))
+* Add support for u1 in the avm, ToRadix's radix arg is a memory addr (https://github.com/AztecProtocol/aztec-packages/pull/8570) ([e8bbce7](https://github.com/noir-lang/noir/commit/e8bbce71fde3fc7af410c30920c2a547389d8248))
+* Added indirect const instruction (https://github.com/AztecProtocol/aztec-packages/pull/8065) ([5c4f19f](https://github.com/noir-lang/noir/commit/5c4f19f097dd3704522996330c961bf0a2db8d99))
+* Adding aggregation to honk and rollup (https://github.com/AztecProtocol/aztec-packages/pull/7466) ([4ea25db](https://github.com/noir-lang/noir/commit/4ea25dbde87488e758139619a3ce4edf93c6ebd6))
+* Automate verify_honk_proof input generation (https://github.com/AztecProtocol/aztec-packages/pull/8092) ([5c4f19f](https://github.com/noir-lang/noir/commit/5c4f19f097dd3704522996330c961bf0a2db8d99))
+* **avm/brillig:** Revert/rethrow oracle (https://github.com/AztecProtocol/aztec-packages/pull/9408) ([321a493](https://github.com/noir-lang/noir/commit/321a493216e19a2f077007c3447a3030db0df0d0))
+* **avm/brillig:** Take addresses in calldatacopy (https://github.com/AztecProtocol/aztec-packages/pull/8388) ([3c3ed1e](https://github.com/noir-lang/noir/commit/3c3ed1e3d28946a02071c524dd128afe131bc3da))
+* **avm:** Variants for SET opcode (https://github.com/AztecProtocol/aztec-packages/pull/8441) ([3c3ed1e](https://github.com/noir-lang/noir/commit/3c3ed1e3d28946a02071c524dd128afe131bc3da))
+* Avoid heap allocs when going to/from field (https://github.com/AztecProtocol/aztec-packages/pull/7547) ([daad75c](https://github.com/noir-lang/noir/commit/daad75c26d19ae707b90a7424b77dab9937e8575))
+* Brillig and AVM default all uninitialized memory cells to Field 0 (https://github.com/AztecProtocol/aztec-packages/pull/9057) ([70dcf4a](https://github.com/noir-lang/noir/commit/70dcf4a25dcad10daeb427f0887d3a0bf10c9916))
+* Brillig with a stack and conditional inlining (https://github.com/AztecProtocol/aztec-packages/pull/8989) ([70dcf4a](https://github.com/noir-lang/noir/commit/70dcf4a25dcad10daeb427f0887d3a0bf10c9916))
+* Change the layout of arrays and vectors to be a single pointer (https://github.com/AztecProtocol/aztec-packages/pull/8448) ([d4832ec](https://github.com/noir-lang/noir/commit/d4832ece9d3ad16544afea49cc7caf40501a2cc3))
+* Hook up secondary calldata column in dsl (https://github.com/AztecProtocol/aztec-packages/pull/7759) ([4ea25db](https://github.com/noir-lang/noir/commit/4ea25dbde87488e758139619a3ce4edf93c6ebd6))
+* Integrate databus in the private kernels (https://github.com/AztecProtocol/aztec-packages/pull/9028) ([70dcf4a](https://github.com/noir-lang/noir/commit/70dcf4a25dcad10daeb427f0887d3a0bf10c9916))
+* Integrate new proving systems in e2e (https://github.com/AztecProtocol/aztec-packages/pull/6971) ([daad75c](https://github.com/noir-lang/noir/commit/daad75c26d19ae707b90a7424b77dab9937e8575))
+* Make Brillig do integer arithmetic operations using u128 instead of Bigint (https://github.com/AztecProtocol/aztec-packages/pull/7518) ([daad75c](https://github.com/noir-lang/noir/commit/daad75c26d19ae707b90a7424b77dab9937e8575))
+* Make token transfer be recursive (https://github.com/AztecProtocol/aztec-packages/pull/7730) ([4ea25db](https://github.com/noir-lang/noir/commit/4ea25dbde87488e758139619a3ce4edf93c6ebd6))
+* New test programs for wasm benchmarking (https://github.com/AztecProtocol/aztec-packages/pull/8389) ([95e19ab](https://github.com/noir-lang/noir/commit/95e19ab9486ad054241b6e53e40e55bdba9dc7e5))
+* Note hashes as points (https://github.com/AztecProtocol/aztec-packages/pull/7618) ([4ea25db](https://github.com/noir-lang/noir/commit/4ea25dbde87488e758139619a3ce4edf93c6ebd6))
+* Optimize allocating immediate amounts of memory (https://github.com/AztecProtocol/aztec-packages/pull/8579) ([e8bbce7](https://github.com/noir-lang/noir/commit/e8bbce71fde3fc7af410c30920c2a547389d8248))
+* Optimize constant array handling in brillig_gen (https://github.com/AztecProtocol/aztec-packages/pull/7661) ([4ea25db](https://github.com/noir-lang/noir/commit/4ea25dbde87488e758139619a3ce4edf93c6ebd6))
+* Optimize to_radix (https://github.com/AztecProtocol/aztec-packages/pull/8073) ([5c4f19f](https://github.com/noir-lang/noir/commit/5c4f19f097dd3704522996330c961bf0a2db8d99))
+* Pass calldata ids to the backend (https://github.com/AztecProtocol/aztec-packages/pull/7875) ([4ea25db](https://github.com/noir-lang/noir/commit/4ea25dbde87488e758139619a3ce4edf93c6ebd6))
+* Poseidon2 gates for Ultra arithmetisation (https://github.com/AztecProtocol/aztec-packages/pull/7494) ([5c4f19f](https://github.com/noir-lang/noir/commit/5c4f19f097dd3704522996330c961bf0a2db8d99))
+* **profiler:** Add support for brillig functions in opcodes-flamegraph (https://github.com/AztecProtocol/aztec-packages/pull/7698) ([4ea25db](https://github.com/noir-lang/noir/commit/4ea25dbde87488e758139619a3ce4edf93c6ebd6))
+* **profiler:** New flamegraph command that profiles the opcodes executed ([#6327](https://github.com/noir-lang/noir/issues/6327)) ([4d87c9a](https://github.com/noir-lang/noir/commit/4d87c9ac78b48b4bd0ae81316df28aab390d004e))
+* Remove 'single use' intermediate variables ([#6268](https://github.com/noir-lang/noir/issues/6268)) ([ec75e8e](https://github.com/noir-lang/noir/commit/ec75e8ec59e0f2a2169aea67372411ede4074d09))
+* Remove sha256 opcode (https://github.com/AztecProtocol/aztec-packages/pull/4571) ([e8bbce7](https://github.com/noir-lang/noir/commit/e8bbce71fde3fc7af410c30920c2a547389d8248))
+* Removing superfluous call to MSM (https://github.com/AztecProtocol/aztec-packages/pull/7708) ([4ea25db](https://github.com/noir-lang/noir/commit/4ea25dbde87488e758139619a3ce4edf93c6ebd6))
+* Report gates and VKs of private protocol circuits with megahonk (https://github.com/AztecProtocol/aztec-packages/pull/7722) ([4ea25db](https://github.com/noir-lang/noir/commit/4ea25dbde87488e758139619a3ce4edf93c6ebd6))
+* Simplify constant calls to `poseidon2_permutation`, `schnorr_verify` and `embedded_curve_add` ([#5140](https://github.com/noir-lang/noir/issues/5140)) ([2823ba7](https://github.com/noir-lang/noir/commit/2823ba7242db788ca1d7f6e7a48be2f1de62f278))
+* Small optimization in toradix (https://github.com/AztecProtocol/aztec-packages/pull/8040) ([5c4f19f](https://github.com/noir-lang/noir/commit/5c4f19f097dd3704522996330c961bf0a2db8d99))
+* Sync from noir (https://github.com/AztecProtocol/aztec-packages/pull/7432) ([daad75c](https://github.com/noir-lang/noir/commit/daad75c26d19ae707b90a7424b77dab9937e8575))
+* Sync from noir (https://github.com/AztecProtocol/aztec-packages/pull/7444) ([daad75c](https://github.com/noir-lang/noir/commit/daad75c26d19ae707b90a7424b77dab9937e8575))
+* Sync from noir (https://github.com/AztecProtocol/aztec-packages/pull/7454) ([daad75c](https://github.com/noir-lang/noir/commit/daad75c26d19ae707b90a7424b77dab9937e8575))
+* Sync from noir (https://github.com/AztecProtocol/aztec-packages/pull/7512) ([daad75c](https://github.com/noir-lang/noir/commit/daad75c26d19ae707b90a7424b77dab9937e8575))
+* Sync from noir (https://github.com/AztecProtocol/aztec-packages/pull/7577) ([daad75c](https://github.com/noir-lang/noir/commit/daad75c26d19ae707b90a7424b77dab9937e8575))
+* Sync from noir (https://github.com/AztecProtocol/aztec-packages/pull/7583) ([daad75c](https://github.com/noir-lang/noir/commit/daad75c26d19ae707b90a7424b77dab9937e8575))
+* Sync from noir (https://github.com/AztecProtocol/aztec-packages/pull/7743) ([4ea25db](https://github.com/noir-lang/noir/commit/4ea25dbde87488e758139619a3ce4edf93c6ebd6))
+* Sync from noir (https://github.com/AztecProtocol/aztec-packages/pull/7862) ([4ea25db](https://github.com/noir-lang/noir/commit/4ea25dbde87488e758139619a3ce4edf93c6ebd6))
+* Sync from noir (https://github.com/AztecProtocol/aztec-packages/pull/7945) ([4ea25db](https://github.com/noir-lang/noir/commit/4ea25dbde87488e758139619a3ce4edf93c6ebd6))
+* Sync from noir (https://github.com/AztecProtocol/aztec-packages/pull/7958) ([5c4f19f](https://github.com/noir-lang/noir/commit/5c4f19f097dd3704522996330c961bf0a2db8d99))
+* Sync from noir (https://github.com/AztecProtocol/aztec-packages/pull/8008) ([5c4f19f](https://github.com/noir-lang/noir/commit/5c4f19f097dd3704522996330c961bf0a2db8d99))
+* Sync from noir (https://github.com/AztecProtocol/aztec-packages/pull/8093) ([5c4f19f](https://github.com/noir-lang/noir/commit/5c4f19f097dd3704522996330c961bf0a2db8d99))
+* Sync from noir (https://github.com/AztecProtocol/aztec-packages/pull/8125) ([f0c2686](https://github.com/noir-lang/noir/commit/f0c268606a71381ab4504396695a0adb9b3258b6))
+* Sync from noir (https://github.com/AztecProtocol/aztec-packages/pull/8237) ([f0c2686](https://github.com/noir-lang/noir/commit/f0c268606a71381ab4504396695a0adb9b3258b6))
+* Sync from noir (https://github.com/AztecProtocol/aztec-packages/pull/8423) ([3c3ed1e](https://github.com/noir-lang/noir/commit/3c3ed1e3d28946a02071c524dd128afe131bc3da))
+* Sync from noir (https://github.com/AztecProtocol/aztec-packages/pull/8435) ([3c3ed1e](https://github.com/noir-lang/noir/commit/3c3ed1e3d28946a02071c524dd128afe131bc3da))
+* Sync from noir (https://github.com/AztecProtocol/aztec-packages/pull/8466) ([3c3ed1e](https://github.com/noir-lang/noir/commit/3c3ed1e3d28946a02071c524dd128afe131bc3da))
+* Sync from noir (https://github.com/AztecProtocol/aztec-packages/pull/8482) ([d4832ec](https://github.com/noir-lang/noir/commit/d4832ece9d3ad16544afea49cc7caf40501a2cc3))
+* Sync from noir (https://github.com/AztecProtocol/aztec-packages/pull/8512) ([95e19ab](https://github.com/noir-lang/noir/commit/95e19ab9486ad054241b6e53e40e55bdba9dc7e5))
+* Sync from noir (https://github.com/AztecProtocol/aztec-packages/pull/8526) ([95e19ab](https://github.com/noir-lang/noir/commit/95e19ab9486ad054241b6e53e40e55bdba9dc7e5))
+* Sync from noir (https://github.com/AztecProtocol/aztec-packages/pull/8934) ([70dcf4a](https://github.com/noir-lang/noir/commit/70dcf4a25dcad10daeb427f0887d3a0bf10c9916))
+* Sync from noir (https://github.com/AztecProtocol/aztec-packages/pull/9034) ([70dcf4a](https://github.com/noir-lang/noir/commit/70dcf4a25dcad10daeb427f0887d3a0bf10c9916))
+* Sync from noir (https://github.com/AztecProtocol/aztec-packages/pull/9099) ([70dcf4a](https://github.com/noir-lang/noir/commit/70dcf4a25dcad10daeb427f0887d3a0bf10c9916))
+* Sync from noir (https://github.com/AztecProtocol/aztec-packages/pull/9275) ([70dcf4a](https://github.com/noir-lang/noir/commit/70dcf4a25dcad10daeb427f0887d3a0bf10c9916))
+* **test:** Fuzz test poseidon2 hash equivalence ([#6265](https://github.com/noir-lang/noir/issues/6265)) ([f61ba03](https://github.com/noir-lang/noir/commit/f61ba037c6726e19be4f894d9447fe396df95417))
+* **test:** Fuzz test stdlib hash functions ([#6233](https://github.com/noir-lang/noir/issues/6233)) ([1a2ca46](https://github.com/noir-lang/noir/commit/1a2ca46af0d1c05813dbe28670a2bc39b79e4c9f))
+* TXE nr deployments, dependency cleanup for CLI (https://github.com/AztecProtocol/aztec-packages/pull/7548) ([4ea25db](https://github.com/noir-lang/noir/commit/4ea25dbde87488e758139619a3ce4edf93c6ebd6))
+* Typing return values of embedded_curve_ops (https://github.com/AztecProtocol/aztec-packages/pull/7413) ([daad75c](https://github.com/noir-lang/noir/commit/daad75c26d19ae707b90a7424b77dab9937e8575))
+* Unify all acir recursion constraints based on RecursionConstraint and proof_type (https://github.com/AztecProtocol/aztec-packages/pull/7993) ([5c4f19f](https://github.com/noir-lang/noir/commit/5c4f19f097dd3704522996330c961bf0a2db8d99))
+
+
+### Bug Fixes
+
+* Add trailing extra arguments for backend in gates_flamegraph (https://github.com/AztecProtocol/aztec-packages/pull/7472) ([daad75c](https://github.com/noir-lang/noir/commit/daad75c26d19ae707b90a7424b77dab9937e8575))
+* **debugger:** Update the debugger to handle the new Brillig debug metadata format ([#5706](https://github.com/noir-lang/noir/issues/5706)) ([a31f82e](https://github.com/noir-lang/noir/commit/a31f82e598def60d00c65b79b8c5411f8aa832aa))
+* Deflatten databus visibilities (https://github.com/AztecProtocol/aztec-packages/pull/7761) ([4ea25db](https://github.com/noir-lang/noir/commit/4ea25dbde87488e758139619a3ce4edf93c6ebd6))
+* Display every bit in integer tokens ([#6360](https://github.com/noir-lang/noir/issues/6360)) ([b985fdf](https://github.com/noir-lang/noir/commit/b985fdf6e635570b8db3af83d9ec14e7cd749062))
+* Do not duplicate redundant Brillig debug metadata ([#5696](https://github.com/noir-lang/noir/issues/5696)) ([e4f7dbe](https://github.com/noir-lang/noir/commit/e4f7dbe63b55807b3ff0b4d6f47a8b7f847299fb))
+* Export brillig names in contract functions (https://github.com/AztecProtocol/aztec-packages/pull/8212) ([f0c2686](https://github.com/noir-lang/noir/commit/f0c268606a71381ab4504396695a0adb9b3258b6))
+* Handle multiple entry points for Brillig call stack resolution after metadata deduplication ([#5788](https://github.com/noir-lang/noir/issues/5788)) ([38fe9dd](https://github.com/noir-lang/noir/commit/38fe9dda111952fdb894df90a319c087382edfc9))
+* Homogeneous input points for EC ADD ([#6241](https://github.com/noir-lang/noir/issues/6241)) ([f6a7306](https://github.com/noir-lang/noir/commit/f6a7306436ea1a37ec7f3b884721b50467e9a063))
+* Reject invalid expression with in CLI parser ([#6287](https://github.com/noir-lang/noir/issues/6287)) ([052aee8](https://github.com/noir-lang/noir/commit/052aee80ff3e1e4fd2ca45310d7bb8b980af126a))
+* Remove need for duplicate attributes on each function (https://github.com/AztecProtocol/aztec-packages/pull/9244) ([70dcf4a](https://github.com/noir-lang/noir/commit/70dcf4a25dcad10daeb427f0887d3a0bf10c9916))
+* Restrict keccak256_injective test input to 8 bits ([#5977](https://github.com/noir-lang/noir/issues/5977)) ([a1b1346](https://github.com/noir-lang/noir/commit/a1b1346bf7525c508fd390393c307475cc2345d7))
+* Revert "feat: Sync from noir (https://github.com/AztecProtocol/aztec-packages/pull/7512)" (https://github.com/AztecProtocol/aztec-packages/pull/7558) ([daad75c](https://github.com/noir-lang/noir/commit/daad75c26d19ae707b90a7424b77dab9937e8575))
+
+
+### Miscellaneous Chores
+
+* Remove keccak256 opcode from ACIR/Brillig (https://github.com/AztecProtocol/aztec-packages/pull/9104) ([70dcf4a](https://github.com/noir-lang/noir/commit/70dcf4a25dcad10daeb427f0887d3a0bf10c9916))
+* Remove noir_js_backend_barretenberg (https://github.com/AztecProtocol/aztec-packages/pull/9338) ([3925228](https://github.com/noir-lang/noir/commit/392522880e102e275ebcf42f16651a8ffa0bbbd2))
+* Remove pedersen commitment (https://github.com/AztecProtocol/aztec-packages/pull/9107) ([70dcf4a](https://github.com/noir-lang/noir/commit/70dcf4a25dcad10daeb427f0887d3a0bf10c9916))
+* Remove pedersen hash opcode (https://github.com/AztecProtocol/aztec-packages/pull/9245) ([70dcf4a](https://github.com/noir-lang/noir/commit/70dcf4a25dcad10daeb427f0887d3a0bf10c9916))
+* Replace usage of vector in keccakf1600 input with array (https://github.com/AztecProtocol/aztec-packages/pull/9350) ([3925228](https://github.com/noir-lang/noir/commit/392522880e102e275ebcf42f16651a8ffa0bbbd2))
+* Use Brillig opcode when possible for less-than operations on fields (https://github.com/AztecProtocol/aztec-packages/pull/9416) ([321a493](https://github.com/noir-lang/noir/commit/321a493216e19a2f077007c3447a3030db0df0d0))
+
+
+### Code Refactoring
+
+* **avm:** Remove CMOV opcode (https://github.com/AztecProtocol/aztec-packages/pull/9030) ([70dcf4a](https://github.com/noir-lang/noir/commit/70dcf4a25dcad10daeb427f0887d3a0bf10c9916))
+
+## [0.52.0](https://github.com/noir-lang/noir/compare/v0.51.0...v0.52.0) (2024-10-22)
+
+
+### ⚠ BREAKING CHANGES
+
+* remove pedersen commitment (https://github.com/AztecProtocol/aztec-packages/pull/9107)
+* remove pedersen hash opcode (https://github.com/AztecProtocol/aztec-packages/pull/9245)
+* Brillig and AVM default all uninitialized memory cells to Field 0 (https://github.com/AztecProtocol/aztec-packages/pull/9057)
+* remove keccak256 opcode from ACIR/Brillig (https://github.com/AztecProtocol/aztec-packages/pull/9104)
+* Brillig with a stack and conditional inlining (https://github.com/AztecProtocol/aztec-packages/pull/8989)
+* **avm:** remove CMOV opcode (https://github.com/AztecProtocol/aztec-packages/pull/9030)
+* remove sha256 opcode (https://github.com/AztecProtocol/aztec-packages/pull/4571)
+* add support for u1 in the avm, ToRadix's radix arg is a memory addr (https://github.com/AztecProtocol/aztec-packages/pull/8570)
+* Add Not instruction in brillig (https://github.com/AztecProtocol/aztec-packages/pull/8488)
+* **avm:** variants for SET opcode (https://github.com/AztecProtocol/aztec-packages/pull/8441)
+* **avm/brillig:** take addresses in calldatacopy (https://github.com/AztecProtocol/aztec-packages/pull/8388)
+* constant inputs for blackbox (https://github.com/AztecProtocol/aztec-packages/pull/7222)
+
+### Features
+
+* (bb) 128-bit challenges (https://github.com/AztecProtocol/aztec-packages/pull/8406) ([3c3ed1e](https://github.com/noir-lang/noir/commit/3c3ed1e3d28946a02071c524dd128afe131bc3da))
+* **acir_gen:** Width aware ACIR gen addition ([#5493](https://github.com/noir-lang/noir/issues/5493)) ([85fa592](https://github.com/noir-lang/noir/commit/85fa592fdef3b8589ce03b232e1b51565837b540))
+* Add assertions for ACVM `FunctionInput` `bit_size` ([#5864](https://github.com/noir-lang/noir/issues/5864)) ([8712f4c](https://github.com/noir-lang/noir/commit/8712f4c20d23f3809bcfb03f2e3ba0e5ace20a1d))
+* Add Not instruction in brillig (https://github.com/AztecProtocol/aztec-packages/pull/8488) ([95e19ab](https://github.com/noir-lang/noir/commit/95e19ab9486ad054241b6e53e40e55bdba9dc7e5))
+* Add recursive aggregation object to proving/verification keys (https://github.com/AztecProtocol/aztec-packages/pull/6770) ([4ea25db](https://github.com/noir-lang/noir/commit/4ea25dbde87488e758139619a3ce4edf93c6ebd6))
+* Add reusable procedures to brillig generation (https://github.com/AztecProtocol/aztec-packages/pull/7981) ([5c4f19f](https://github.com/noir-lang/noir/commit/5c4f19f097dd3704522996330c961bf0a2db8d99))
+* Add support for u1 in the avm, ToRadix's radix arg is a memory addr (https://github.com/AztecProtocol/aztec-packages/pull/8570) ([e8bbce7](https://github.com/noir-lang/noir/commit/e8bbce71fde3fc7af410c30920c2a547389d8248))
+* Added indirect const instruction (https://github.com/AztecProtocol/aztec-packages/pull/8065) ([5c4f19f](https://github.com/noir-lang/noir/commit/5c4f19f097dd3704522996330c961bf0a2db8d99))
+* Adding aggregation to honk and rollup (https://github.com/AztecProtocol/aztec-packages/pull/7466) ([4ea25db](https://github.com/noir-lang/noir/commit/4ea25dbde87488e758139619a3ce4edf93c6ebd6))
+* Automate verify_honk_proof input generation (https://github.com/AztecProtocol/aztec-packages/pull/8092) ([5c4f19f](https://github.com/noir-lang/noir/commit/5c4f19f097dd3704522996330c961bf0a2db8d99))
+* **avm/brillig:** Take addresses in calldatacopy (https://github.com/AztecProtocol/aztec-packages/pull/8388) ([3c3ed1e](https://github.com/noir-lang/noir/commit/3c3ed1e3d28946a02071c524dd128afe131bc3da))
+* **avm:** Variants for SET opcode (https://github.com/AztecProtocol/aztec-packages/pull/8441) ([3c3ed1e](https://github.com/noir-lang/noir/commit/3c3ed1e3d28946a02071c524dd128afe131bc3da))
+* Avoid heap allocs when going to/from field (https://github.com/AztecProtocol/aztec-packages/pull/7547) ([daad75c](https://github.com/noir-lang/noir/commit/daad75c26d19ae707b90a7424b77dab9937e8575))
+* Brillig and AVM default all uninitialized memory cells to Field 0 (https://github.com/AztecProtocol/aztec-packages/pull/9057) ([70dcf4a](https://github.com/noir-lang/noir/commit/70dcf4a25dcad10daeb427f0887d3a0bf10c9916))
+* Brillig with a stack and conditional inlining (https://github.com/AztecProtocol/aztec-packages/pull/8989) ([70dcf4a](https://github.com/noir-lang/noir/commit/70dcf4a25dcad10daeb427f0887d3a0bf10c9916))
+* Change the layout of arrays and vectors to be a single pointer (https://github.com/AztecProtocol/aztec-packages/pull/8448) ([d4832ec](https://github.com/noir-lang/noir/commit/d4832ece9d3ad16544afea49cc7caf40501a2cc3))
+* Constant inputs for blackbox (https://github.com/AztecProtocol/aztec-packages/pull/7222) ([fb97bb9](https://github.com/noir-lang/noir/commit/fb97bb9b795c9d7af395b82fd6f0ea8111d59c11))
+* Hook up secondary calldata column in dsl (https://github.com/AztecProtocol/aztec-packages/pull/7759) ([4ea25db](https://github.com/noir-lang/noir/commit/4ea25dbde87488e758139619a3ce4edf93c6ebd6))
+* Integrate databus in the private kernels (https://github.com/AztecProtocol/aztec-packages/pull/9028) ([70dcf4a](https://github.com/noir-lang/noir/commit/70dcf4a25dcad10daeb427f0887d3a0bf10c9916))
+* Integrate new proving systems in e2e (https://github.com/AztecProtocol/aztec-packages/pull/6971) ([daad75c](https://github.com/noir-lang/noir/commit/daad75c26d19ae707b90a7424b77dab9937e8575))
+* Make Brillig do integer arithmetic operations using u128 instead of Bigint (https://github.com/AztecProtocol/aztec-packages/pull/7518) ([daad75c](https://github.com/noir-lang/noir/commit/daad75c26d19ae707b90a7424b77dab9937e8575))
+* Make token transfer be recursive (https://github.com/AztecProtocol/aztec-packages/pull/7730) ([4ea25db](https://github.com/noir-lang/noir/commit/4ea25dbde87488e758139619a3ce4edf93c6ebd6))
+* New test programs for wasm benchmarking (https://github.com/AztecProtocol/aztec-packages/pull/8389) ([95e19ab](https://github.com/noir-lang/noir/commit/95e19ab9486ad054241b6e53e40e55bdba9dc7e5))
+* Note hashes as points (https://github.com/AztecProtocol/aztec-packages/pull/7618) ([4ea25db](https://github.com/noir-lang/noir/commit/4ea25dbde87488e758139619a3ce4edf93c6ebd6))
+* Optimize allocating immediate amounts of memory (https://github.com/AztecProtocol/aztec-packages/pull/8579) ([e8bbce7](https://github.com/noir-lang/noir/commit/e8bbce71fde3fc7af410c30920c2a547389d8248))
+* Optimize constant array handling in brillig_gen (https://github.com/AztecProtocol/aztec-packages/pull/7661) ([4ea25db](https://github.com/noir-lang/noir/commit/4ea25dbde87488e758139619a3ce4edf93c6ebd6))
+* Optimize to_radix (https://github.com/AztecProtocol/aztec-packages/pull/8073) ([5c4f19f](https://github.com/noir-lang/noir/commit/5c4f19f097dd3704522996330c961bf0a2db8d99))
+* Pass calldata ids to the backend (https://github.com/AztecProtocol/aztec-packages/pull/7875) ([4ea25db](https://github.com/noir-lang/noir/commit/4ea25dbde87488e758139619a3ce4edf93c6ebd6))
+* Poseidon2 gates for Ultra arithmetisation (https://github.com/AztecProtocol/aztec-packages/pull/7494) ([5c4f19f](https://github.com/noir-lang/noir/commit/5c4f19f097dd3704522996330c961bf0a2db8d99))
+* **profiler:** Add support for brillig functions in opcodes-flamegraph (https://github.com/AztecProtocol/aztec-packages/pull/7698) ([4ea25db](https://github.com/noir-lang/noir/commit/4ea25dbde87488e758139619a3ce4edf93c6ebd6))
+* Remove sha256 opcode (https://github.com/AztecProtocol/aztec-packages/pull/4571) ([e8bbce7](https://github.com/noir-lang/noir/commit/e8bbce71fde3fc7af410c30920c2a547389d8248))
+* Removing superfluous call to MSM (https://github.com/AztecProtocol/aztec-packages/pull/7708) ([4ea25db](https://github.com/noir-lang/noir/commit/4ea25dbde87488e758139619a3ce4edf93c6ebd6))
+* Report gates and VKs of private protocol circuits with megahonk (https://github.com/AztecProtocol/aztec-packages/pull/7722) ([4ea25db](https://github.com/noir-lang/noir/commit/4ea25dbde87488e758139619a3ce4edf93c6ebd6))
+* Simplify constant calls to `poseidon2_permutation`, `schnorr_verify` and `embedded_curve_add` ([#5140](https://github.com/noir-lang/noir/issues/5140)) ([2823ba7](https://github.com/noir-lang/noir/commit/2823ba7242db788ca1d7f6e7a48be2f1de62f278))
+* Small optimization in toradix (https://github.com/AztecProtocol/aztec-packages/pull/8040) ([5c4f19f](https://github.com/noir-lang/noir/commit/5c4f19f097dd3704522996330c961bf0a2db8d99))
+* Sync from noir (https://github.com/AztecProtocol/aztec-packages/pull/7392) ([fb97bb9](https://github.com/noir-lang/noir/commit/fb97bb9b795c9d7af395b82fd6f0ea8111d59c11))
+* Sync from noir (https://github.com/AztecProtocol/aztec-packages/pull/7400) ([fb97bb9](https://github.com/noir-lang/noir/commit/fb97bb9b795c9d7af395b82fd6f0ea8111d59c11))
+* Sync from noir (https://github.com/AztecProtocol/aztec-packages/pull/7432) ([daad75c](https://github.com/noir-lang/noir/commit/daad75c26d19ae707b90a7424b77dab9937e8575))
+* Sync from noir (https://github.com/AztecProtocol/aztec-packages/pull/7444) ([daad75c](https://github.com/noir-lang/noir/commit/daad75c26d19ae707b90a7424b77dab9937e8575))
+* Sync from noir (https://github.com/AztecProtocol/aztec-packages/pull/7454) ([daad75c](https://github.com/noir-lang/noir/commit/daad75c26d19ae707b90a7424b77dab9937e8575))
+* Sync from noir (https://github.com/AztecProtocol/aztec-packages/pull/7512) ([daad75c](https://github.com/noir-lang/noir/commit/daad75c26d19ae707b90a7424b77dab9937e8575))
+* Sync from noir (https://github.com/AztecProtocol/aztec-packages/pull/7577) ([daad75c](https://github.com/noir-lang/noir/commit/daad75c26d19ae707b90a7424b77dab9937e8575))
+* Sync from noir (https://github.com/AztecProtocol/aztec-packages/pull/7583) ([daad75c](https://github.com/noir-lang/noir/commit/daad75c26d19ae707b90a7424b77dab9937e8575))
+* Sync from noir (https://github.com/AztecProtocol/aztec-packages/pull/7743) ([4ea25db](https://github.com/noir-lang/noir/commit/4ea25dbde87488e758139619a3ce4edf93c6ebd6))
+* Sync from noir (https://github.com/AztecProtocol/aztec-packages/pull/7862) ([4ea25db](https://github.com/noir-lang/noir/commit/4ea25dbde87488e758139619a3ce4edf93c6ebd6))
+* Sync from noir (https://github.com/AztecProtocol/aztec-packages/pull/7945) ([4ea25db](https://github.com/noir-lang/noir/commit/4ea25dbde87488e758139619a3ce4edf93c6ebd6))
+* Sync from noir (https://github.com/AztecProtocol/aztec-packages/pull/7958) ([5c4f19f](https://github.com/noir-lang/noir/commit/5c4f19f097dd3704522996330c961bf0a2db8d99))
+* Sync from noir (https://github.com/AztecProtocol/aztec-packages/pull/8008) ([5c4f19f](https://github.com/noir-lang/noir/commit/5c4f19f097dd3704522996330c961bf0a2db8d99))
+* Sync from noir (https://github.com/AztecProtocol/aztec-packages/pull/8093) ([5c4f19f](https://github.com/noir-lang/noir/commit/5c4f19f097dd3704522996330c961bf0a2db8d99))
+* Sync from noir (https://github.com/AztecProtocol/aztec-packages/pull/8125) ([f0c2686](https://github.com/noir-lang/noir/commit/f0c268606a71381ab4504396695a0adb9b3258b6))
+* Sync from noir (https://github.com/AztecProtocol/aztec-packages/pull/8237) ([f0c2686](https://github.com/noir-lang/noir/commit/f0c268606a71381ab4504396695a0adb9b3258b6))
+* Sync from noir (https://github.com/AztecProtocol/aztec-packages/pull/8423) ([3c3ed1e](https://github.com/noir-lang/noir/commit/3c3ed1e3d28946a02071c524dd128afe131bc3da))
+* Sync from noir (https://github.com/AztecProtocol/aztec-packages/pull/8435) ([3c3ed1e](https://github.com/noir-lang/noir/commit/3c3ed1e3d28946a02071c524dd128afe131bc3da))
+* Sync from noir (https://github.com/AztecProtocol/aztec-packages/pull/8466) ([3c3ed1e](https://github.com/noir-lang/noir/commit/3c3ed1e3d28946a02071c524dd128afe131bc3da))
+* Sync from noir (https://github.com/AztecProtocol/aztec-packages/pull/8482) ([d4832ec](https://github.com/noir-lang/noir/commit/d4832ece9d3ad16544afea49cc7caf40501a2cc3))
+* Sync from noir (https://github.com/AztecProtocol/aztec-packages/pull/8512) ([95e19ab](https://github.com/noir-lang/noir/commit/95e19ab9486ad054241b6e53e40e55bdba9dc7e5))
+* Sync from noir (https://github.com/AztecProtocol/aztec-packages/pull/8526) ([95e19ab](https://github.com/noir-lang/noir/commit/95e19ab9486ad054241b6e53e40e55bdba9dc7e5))
+* Sync from noir (https://github.com/AztecProtocol/aztec-packages/pull/8934) ([70dcf4a](https://github.com/noir-lang/noir/commit/70dcf4a25dcad10daeb427f0887d3a0bf10c9916))
+* Sync from noir (https://github.com/AztecProtocol/aztec-packages/pull/9034) ([70dcf4a](https://github.com/noir-lang/noir/commit/70dcf4a25dcad10daeb427f0887d3a0bf10c9916))
+* Sync from noir (https://github.com/AztecProtocol/aztec-packages/pull/9099) ([70dcf4a](https://github.com/noir-lang/noir/commit/70dcf4a25dcad10daeb427f0887d3a0bf10c9916))
+* Sync from noir (https://github.com/AztecProtocol/aztec-packages/pull/9275) ([70dcf4a](https://github.com/noir-lang/noir/commit/70dcf4a25dcad10daeb427f0887d3a0bf10c9916))
+* **test:** Fuzz test poseidon2 hash equivalence ([#6265](https://github.com/noir-lang/noir/issues/6265)) ([f61ba03](https://github.com/noir-lang/noir/commit/f61ba037c6726e19be4f894d9447fe396df95417))
+* **test:** Fuzz test stdlib hash functions ([#6233](https://github.com/noir-lang/noir/issues/6233)) ([1a2ca46](https://github.com/noir-lang/noir/commit/1a2ca46af0d1c05813dbe28670a2bc39b79e4c9f))
+* TXE nr deployments, dependency cleanup for CLI (https://github.com/AztecProtocol/aztec-packages/pull/7548) ([4ea25db](https://github.com/noir-lang/noir/commit/4ea25dbde87488e758139619a3ce4edf93c6ebd6))
+* Typing return values of embedded_curve_ops (https://github.com/AztecProtocol/aztec-packages/pull/7413) ([daad75c](https://github.com/noir-lang/noir/commit/daad75c26d19ae707b90a7424b77dab9937e8575))
+* Unify all acir recursion constraints based on RecursionConstraint and proof_type (https://github.com/AztecProtocol/aztec-packages/pull/7993) ([5c4f19f](https://github.com/noir-lang/noir/commit/5c4f19f097dd3704522996330c961bf0a2db8d99))
+
+
+### Bug Fixes
+
+* Add trailing extra arguments for backend in gates_flamegraph (https://github.com/AztecProtocol/aztec-packages/pull/7472) ([daad75c](https://github.com/noir-lang/noir/commit/daad75c26d19ae707b90a7424b77dab9937e8575))
+* **debugger:** Update the debugger to handle the new Brillig debug metadata format ([#5706](https://github.com/noir-lang/noir/issues/5706)) ([a31f82e](https://github.com/noir-lang/noir/commit/a31f82e598def60d00c65b79b8c5411f8aa832aa))
+* Deflatten databus visibilities (https://github.com/AztecProtocol/aztec-packages/pull/7761) ([4ea25db](https://github.com/noir-lang/noir/commit/4ea25dbde87488e758139619a3ce4edf93c6ebd6))
+* Do not duplicate redundant Brillig debug metadata ([#5696](https://github.com/noir-lang/noir/issues/5696)) ([e4f7dbe](https://github.com/noir-lang/noir/commit/e4f7dbe63b55807b3ff0b4d6f47a8b7f847299fb))
+* Export brillig names in contract functions (https://github.com/AztecProtocol/aztec-packages/pull/8212) ([f0c2686](https://github.com/noir-lang/noir/commit/f0c268606a71381ab4504396695a0adb9b3258b6))
+* Handle multiple entry points for Brillig call stack resolution after metadata deduplication ([#5788](https://github.com/noir-lang/noir/issues/5788)) ([38fe9dd](https://github.com/noir-lang/noir/commit/38fe9dda111952fdb894df90a319c087382edfc9))
+* Homogeneous input points for EC ADD ([#6241](https://github.com/noir-lang/noir/issues/6241)) ([f6a7306](https://github.com/noir-lang/noir/commit/f6a7306436ea1a37ec7f3b884721b50467e9a063))
+* Move BigInt modulus checks to runtime in brillig ([#5374](https://github.com/noir-lang/noir/issues/5374)) ([741d339](https://github.com/noir-lang/noir/commit/741d33991f8e2918bf092c354ca56047e0274533))
+* Reject invalid expression with in CLI parser ([#6287](https://github.com/noir-lang/noir/issues/6287)) ([052aee8](https://github.com/noir-lang/noir/commit/052aee80ff3e1e4fd2ca45310d7bb8b980af126a))
+* Remove need for duplicate attributes on each function (https://github.com/AztecProtocol/aztec-packages/pull/9244) ([70dcf4a](https://github.com/noir-lang/noir/commit/70dcf4a25dcad10daeb427f0887d3a0bf10c9916))
+* Restrict keccak256_injective test input to 8 bits ([#5977](https://github.com/noir-lang/noir/issues/5977)) ([a1b1346](https://github.com/noir-lang/noir/commit/a1b1346bf7525c508fd390393c307475cc2345d7))
+* Revert "feat: Sync from noir (https://github.com/AztecProtocol/aztec-packages/pull/7512)" (https://github.com/AztecProtocol/aztec-packages/pull/7558) ([daad75c](https://github.com/noir-lang/noir/commit/daad75c26d19ae707b90a7424b77dab9937e8575))
+
+
+### Miscellaneous Chores
+
+* Remove keccak256 opcode from ACIR/Brillig (https://github.com/AztecProtocol/aztec-packages/pull/9104) ([70dcf4a](https://github.com/noir-lang/noir/commit/70dcf4a25dcad10daeb427f0887d3a0bf10c9916))
+* Remove pedersen commitment (https://github.com/AztecProtocol/aztec-packages/pull/9107) ([70dcf4a](https://github.com/noir-lang/noir/commit/70dcf4a25dcad10daeb427f0887d3a0bf10c9916))
+* Remove pedersen hash opcode (https://github.com/AztecProtocol/aztec-packages/pull/9245) ([70dcf4a](https://github.com/noir-lang/noir/commit/70dcf4a25dcad10daeb427f0887d3a0bf10c9916))
+
+
+### Code Refactoring
+
+* **avm:** Remove CMOV opcode (https://github.com/AztecProtocol/aztec-packages/pull/9030) ([70dcf4a](https://github.com/noir-lang/noir/commit/70dcf4a25dcad10daeb427f0887d3a0bf10c9916))
+
+## [0.51.0](https://github.com/noir-lang/noir/compare/v0.50.0...v0.51.0) (2024-10-03)
+
+
+### ⚠ BREAKING CHANGES
+
+* remove sha256 opcode (https://github.com/AztecProtocol/aztec-packages/pull/4571)
+* add support for u1 in the avm, ToRadix's radix arg is a memory addr (https://github.com/AztecProtocol/aztec-packages/pull/8570)
+* Add Not instruction in brillig (https://github.com/AztecProtocol/aztec-packages/pull/8488)
+* **avm:** variants for SET opcode (https://github.com/AztecProtocol/aztec-packages/pull/8441)
+* **avm/brillig:** take addresses in calldatacopy (https://github.com/AztecProtocol/aztec-packages/pull/8388)
+* constant inputs for blackbox (https://github.com/AztecProtocol/aztec-packages/pull/7222)
+
+### Features
+
+* (bb) 128-bit challenges (https://github.com/AztecProtocol/aztec-packages/pull/8406) ([3c3ed1e](https://github.com/noir-lang/noir/commit/3c3ed1e3d28946a02071c524dd128afe131bc3da))
+* **acir_gen:** Width aware ACIR gen addition ([#5493](https://github.com/noir-lang/noir/issues/5493)) ([85fa592](https://github.com/noir-lang/noir/commit/85fa592fdef3b8589ce03b232e1b51565837b540))
+* Add assertions for ACVM `FunctionInput` `bit_size` ([#5864](https://github.com/noir-lang/noir/issues/5864)) ([8712f4c](https://github.com/noir-lang/noir/commit/8712f4c20d23f3809bcfb03f2e3ba0e5ace20a1d))
+* Add Not instruction in brillig (https://github.com/AztecProtocol/aztec-packages/pull/8488) ([95e19ab](https://github.com/noir-lang/noir/commit/95e19ab9486ad054241b6e53e40e55bdba9dc7e5))
+* Add recursive aggregation object to proving/verification keys (https://github.com/AztecProtocol/aztec-packages/pull/6770) ([4ea25db](https://github.com/noir-lang/noir/commit/4ea25dbde87488e758139619a3ce4edf93c6ebd6))
+* Add reusable procedures to brillig generation (https://github.com/AztecProtocol/aztec-packages/pull/7981) ([5c4f19f](https://github.com/noir-lang/noir/commit/5c4f19f097dd3704522996330c961bf0a2db8d99))
+* Add support for u1 in the avm, ToRadix's radix arg is a memory addr (https://github.com/AztecProtocol/aztec-packages/pull/8570) ([e8bbce7](https://github.com/noir-lang/noir/commit/e8bbce71fde3fc7af410c30920c2a547389d8248))
+* Added indirect const instruction (https://github.com/AztecProtocol/aztec-packages/pull/8065) ([5c4f19f](https://github.com/noir-lang/noir/commit/5c4f19f097dd3704522996330c961bf0a2db8d99))
+* Adding aggregation to honk and rollup (https://github.com/AztecProtocol/aztec-packages/pull/7466) ([4ea25db](https://github.com/noir-lang/noir/commit/4ea25dbde87488e758139619a3ce4edf93c6ebd6))
+* Automate verify_honk_proof input generation (https://github.com/AztecProtocol/aztec-packages/pull/8092) ([5c4f19f](https://github.com/noir-lang/noir/commit/5c4f19f097dd3704522996330c961bf0a2db8d99))
+* **avm/brillig:** Take addresses in calldatacopy (https://github.com/AztecProtocol/aztec-packages/pull/8388) ([3c3ed1e](https://github.com/noir-lang/noir/commit/3c3ed1e3d28946a02071c524dd128afe131bc3da))
+* **avm:** Variants for SET opcode (https://github.com/AztecProtocol/aztec-packages/pull/8441) ([3c3ed1e](https://github.com/noir-lang/noir/commit/3c3ed1e3d28946a02071c524dd128afe131bc3da))
+* Avoid heap allocs when going to/from field (https://github.com/AztecProtocol/aztec-packages/pull/7547) ([daad75c](https://github.com/noir-lang/noir/commit/daad75c26d19ae707b90a7424b77dab9937e8575))
+* Change the layout of arrays and vectors to be a single pointer (https://github.com/AztecProtocol/aztec-packages/pull/8448) ([d4832ec](https://github.com/noir-lang/noir/commit/d4832ece9d3ad16544afea49cc7caf40501a2cc3))
+* Constant inputs for blackbox (https://github.com/AztecProtocol/aztec-packages/pull/7222) ([fb97bb9](https://github.com/noir-lang/noir/commit/fb97bb9b795c9d7af395b82fd6f0ea8111d59c11))
+* Hook up secondary calldata column in dsl (https://github.com/AztecProtocol/aztec-packages/pull/7759) ([4ea25db](https://github.com/noir-lang/noir/commit/4ea25dbde87488e758139619a3ce4edf93c6ebd6))
+* Integrate new proving systems in e2e (https://github.com/AztecProtocol/aztec-packages/pull/6971) ([daad75c](https://github.com/noir-lang/noir/commit/daad75c26d19ae707b90a7424b77dab9937e8575))
+* Make Brillig do integer arithmetic operations using u128 instead of Bigint (https://github.com/AztecProtocol/aztec-packages/pull/7518) ([daad75c](https://github.com/noir-lang/noir/commit/daad75c26d19ae707b90a7424b77dab9937e8575))
+* Make token transfer be recursive (https://github.com/AztecProtocol/aztec-packages/pull/7730) ([4ea25db](https://github.com/noir-lang/noir/commit/4ea25dbde87488e758139619a3ce4edf93c6ebd6))
+* New test programs for wasm benchmarking (https://github.com/AztecProtocol/aztec-packages/pull/8389) ([95e19ab](https://github.com/noir-lang/noir/commit/95e19ab9486ad054241b6e53e40e55bdba9dc7e5))
+* Note hashes as points (https://github.com/AztecProtocol/aztec-packages/pull/7618) ([4ea25db](https://github.com/noir-lang/noir/commit/4ea25dbde87488e758139619a3ce4edf93c6ebd6))
+* Optimize allocating immediate amounts of memory (https://github.com/AztecProtocol/aztec-packages/pull/8579) ([e8bbce7](https://github.com/noir-lang/noir/commit/e8bbce71fde3fc7af410c30920c2a547389d8248))
+* Optimize constant array handling in brillig_gen (https://github.com/AztecProtocol/aztec-packages/pull/7661) ([4ea25db](https://github.com/noir-lang/noir/commit/4ea25dbde87488e758139619a3ce4edf93c6ebd6))
+* Optimize to_radix (https://github.com/AztecProtocol/aztec-packages/pull/8073) ([5c4f19f](https://github.com/noir-lang/noir/commit/5c4f19f097dd3704522996330c961bf0a2db8d99))
+* Pass calldata ids to the backend (https://github.com/AztecProtocol/aztec-packages/pull/7875) ([4ea25db](https://github.com/noir-lang/noir/commit/4ea25dbde87488e758139619a3ce4edf93c6ebd6))
+* Poseidon2 gates for Ultra arithmetisation (https://github.com/AztecProtocol/aztec-packages/pull/7494) ([5c4f19f](https://github.com/noir-lang/noir/commit/5c4f19f097dd3704522996330c961bf0a2db8d99))
+* **profiler:** Add support for brillig functions in opcodes-flamegraph (https://github.com/AztecProtocol/aztec-packages/pull/7698) ([4ea25db](https://github.com/noir-lang/noir/commit/4ea25dbde87488e758139619a3ce4edf93c6ebd6))
+* Remove sha256 opcode (https://github.com/AztecProtocol/aztec-packages/pull/4571) ([e8bbce7](https://github.com/noir-lang/noir/commit/e8bbce71fde3fc7af410c30920c2a547389d8248))
+* Removing superfluous call to MSM (https://github.com/AztecProtocol/aztec-packages/pull/7708) ([4ea25db](https://github.com/noir-lang/noir/commit/4ea25dbde87488e758139619a3ce4edf93c6ebd6))
+* Report gates and VKs of private protocol circuits with megahonk (https://github.com/AztecProtocol/aztec-packages/pull/7722) ([4ea25db](https://github.com/noir-lang/noir/commit/4ea25dbde87488e758139619a3ce4edf93c6ebd6))
+* Simplify constant calls to `poseidon2_permutation`, `schnorr_verify` and `embedded_curve_add` ([#5140](https://github.com/noir-lang/noir/issues/5140)) ([2823ba7](https://github.com/noir-lang/noir/commit/2823ba7242db788ca1d7f6e7a48be2f1de62f278))
+* Small optimization in toradix (https://github.com/AztecProtocol/aztec-packages/pull/8040) ([5c4f19f](https://github.com/noir-lang/noir/commit/5c4f19f097dd3704522996330c961bf0a2db8d99))
+* Sync from noir (https://github.com/AztecProtocol/aztec-packages/pull/7392) ([fb97bb9](https://github.com/noir-lang/noir/commit/fb97bb9b795c9d7af395b82fd6f0ea8111d59c11))
+* Sync from noir (https://github.com/AztecProtocol/aztec-packages/pull/7400) ([fb97bb9](https://github.com/noir-lang/noir/commit/fb97bb9b795c9d7af395b82fd6f0ea8111d59c11))
+* Sync from noir (https://github.com/AztecProtocol/aztec-packages/pull/7432) ([daad75c](https://github.com/noir-lang/noir/commit/daad75c26d19ae707b90a7424b77dab9937e8575))
+* Sync from noir (https://github.com/AztecProtocol/aztec-packages/pull/7444) ([daad75c](https://github.com/noir-lang/noir/commit/daad75c26d19ae707b90a7424b77dab9937e8575))
+* Sync from noir (https://github.com/AztecProtocol/aztec-packages/pull/7454) ([daad75c](https://github.com/noir-lang/noir/commit/daad75c26d19ae707b90a7424b77dab9937e8575))
+* Sync from noir (https://github.com/AztecProtocol/aztec-packages/pull/7512) ([daad75c](https://github.com/noir-lang/noir/commit/daad75c26d19ae707b90a7424b77dab9937e8575))
+* Sync from noir (https://github.com/AztecProtocol/aztec-packages/pull/7577) ([daad75c](https://github.com/noir-lang/noir/commit/daad75c26d19ae707b90a7424b77dab9937e8575))
+* Sync from noir (https://github.com/AztecProtocol/aztec-packages/pull/7583) ([daad75c](https://github.com/noir-lang/noir/commit/daad75c26d19ae707b90a7424b77dab9937e8575))
+* Sync from noir (https://github.com/AztecProtocol/aztec-packages/pull/7743) ([4ea25db](https://github.com/noir-lang/noir/commit/4ea25dbde87488e758139619a3ce4edf93c6ebd6))
+* Sync from noir (https://github.com/AztecProtocol/aztec-packages/pull/7862) ([4ea25db](https://github.com/noir-lang/noir/commit/4ea25dbde87488e758139619a3ce4edf93c6ebd6))
+* Sync from noir (https://github.com/AztecProtocol/aztec-packages/pull/7945) ([4ea25db](https://github.com/noir-lang/noir/commit/4ea25dbde87488e758139619a3ce4edf93c6ebd6))
+* Sync from noir (https://github.com/AztecProtocol/aztec-packages/pull/7958) ([5c4f19f](https://github.com/noir-lang/noir/commit/5c4f19f097dd3704522996330c961bf0a2db8d99))
+* Sync from noir (https://github.com/AztecProtocol/aztec-packages/pull/8008) ([5c4f19f](https://github.com/noir-lang/noir/commit/5c4f19f097dd3704522996330c961bf0a2db8d99))
+* Sync from noir (https://github.com/AztecProtocol/aztec-packages/pull/8093) ([5c4f19f](https://github.com/noir-lang/noir/commit/5c4f19f097dd3704522996330c961bf0a2db8d99))
+* Sync from noir (https://github.com/AztecProtocol/aztec-packages/pull/8125) ([f0c2686](https://github.com/noir-lang/noir/commit/f0c268606a71381ab4504396695a0adb9b3258b6))
+* Sync from noir (https://github.com/AztecProtocol/aztec-packages/pull/8237) ([f0c2686](https://github.com/noir-lang/noir/commit/f0c268606a71381ab4504396695a0adb9b3258b6))
+* Sync from noir (https://github.com/AztecProtocol/aztec-packages/pull/8423) ([3c3ed1e](https://github.com/noir-lang/noir/commit/3c3ed1e3d28946a02071c524dd128afe131bc3da))
+* Sync from noir (https://github.com/AztecProtocol/aztec-packages/pull/8435) ([3c3ed1e](https://github.com/noir-lang/noir/commit/3c3ed1e3d28946a02071c524dd128afe131bc3da))
+* Sync from noir (https://github.com/AztecProtocol/aztec-packages/pull/8466) ([3c3ed1e](https://github.com/noir-lang/noir/commit/3c3ed1e3d28946a02071c524dd128afe131bc3da))
+* Sync from noir (https://github.com/AztecProtocol/aztec-packages/pull/8482) ([d4832ec](https://github.com/noir-lang/noir/commit/d4832ece9d3ad16544afea49cc7caf40501a2cc3))
+* Sync from noir (https://github.com/AztecProtocol/aztec-packages/pull/8512) ([95e19ab](https://github.com/noir-lang/noir/commit/95e19ab9486ad054241b6e53e40e55bdba9dc7e5))
+* Sync from noir (https://github.com/AztecProtocol/aztec-packages/pull/8526) ([95e19ab](https://github.com/noir-lang/noir/commit/95e19ab9486ad054241b6e53e40e55bdba9dc7e5))
+* TXE nr deployments, dependency cleanup for CLI (https://github.com/AztecProtocol/aztec-packages/pull/7548) ([4ea25db](https://github.com/noir-lang/noir/commit/4ea25dbde87488e758139619a3ce4edf93c6ebd6))
+* Typing return values of embedded_curve_ops (https://github.com/AztecProtocol/aztec-packages/pull/7413) ([daad75c](https://github.com/noir-lang/noir/commit/daad75c26d19ae707b90a7424b77dab9937e8575))
+* Unify all acir recursion constraints based on RecursionConstraint and proof_type (https://github.com/AztecProtocol/aztec-packages/pull/7993) ([5c4f19f](https://github.com/noir-lang/noir/commit/5c4f19f097dd3704522996330c961bf0a2db8d99))
+
+
+### Bug Fixes
+
+* Add trailing extra arguments for backend in gates_flamegraph (https://github.com/AztecProtocol/aztec-packages/pull/7472) ([daad75c](https://github.com/noir-lang/noir/commit/daad75c26d19ae707b90a7424b77dab9937e8575))
+* **debugger:** Update the debugger to handle the new Brillig debug metadata format ([#5706](https://github.com/noir-lang/noir/issues/5706)) ([a31f82e](https://github.com/noir-lang/noir/commit/a31f82e598def60d00c65b79b8c5411f8aa832aa))
+* Deflatten databus visibilities (https://github.com/AztecProtocol/aztec-packages/pull/7761) ([4ea25db](https://github.com/noir-lang/noir/commit/4ea25dbde87488e758139619a3ce4edf93c6ebd6))
+* Do not duplicate redundant Brillig debug metadata ([#5696](https://github.com/noir-lang/noir/issues/5696)) ([e4f7dbe](https://github.com/noir-lang/noir/commit/e4f7dbe63b55807b3ff0b4d6f47a8b7f847299fb))
+* Export brillig names in contract functions (https://github.com/AztecProtocol/aztec-packages/pull/8212) ([f0c2686](https://github.com/noir-lang/noir/commit/f0c268606a71381ab4504396695a0adb9b3258b6))
+* Handle multiple entry points for Brillig call stack resolution after metadata deduplication ([#5788](https://github.com/noir-lang/noir/issues/5788)) ([38fe9dd](https://github.com/noir-lang/noir/commit/38fe9dda111952fdb894df90a319c087382edfc9))
+* Move BigInt modulus checks to runtime in brillig ([#5374](https://github.com/noir-lang/noir/issues/5374)) ([741d339](https://github.com/noir-lang/noir/commit/741d33991f8e2918bf092c354ca56047e0274533))
+* Restrict keccak256_injective test input to 8 bits ([#5977](https://github.com/noir-lang/noir/issues/5977)) ([a1b1346](https://github.com/noir-lang/noir/commit/a1b1346bf7525c508fd390393c307475cc2345d7))
+* Revert "feat: Sync from noir (https://github.com/AztecProtocol/aztec-packages/pull/7512)" (https://github.com/AztecProtocol/aztec-packages/pull/7558) ([daad75c](https://github.com/noir-lang/noir/commit/daad75c26d19ae707b90a7424b77dab9937e8575))
+* Runtime brillig bigint id assignment ([#5369](https://github.com/noir-lang/noir/issues/5369)) ([a8928dd](https://github.com/noir-lang/noir/commit/a8928ddcffcae15babf7aa5aff0e462e4549552e))
+
 ## [0.50.0](https://github.com/noir-lang/noir/compare/v0.49.0...v0.50.0) (2024-09-13)
 
 
diff --git a/acvm-repo/acir/Cargo.toml b/acvm-repo/acir/Cargo.toml
index b707ae9ad79..8139a58eefc 100644
--- a/acvm-repo/acir/Cargo.toml
+++ b/acvm-repo/acir/Cargo.toml
@@ -2,7 +2,7 @@
 name = "acir"
 description = "ACIR is the IR that the VM processes, it is analogous to LLVM IR"
 # x-release-please-start-version
-version = "0.50.0"
+version = "1.0.0-beta.0"
 # x-release-please-end
 authors.workspace = true
 edition.workspace = true
@@ -24,11 +24,11 @@ flate2.workspace = true
 bincode.workspace = true
 base64.workspace = true
 serde-big-array = "0.5.1"
+strum = { workspace = true }
+strum_macros = { workspace = true }
 
 [dev-dependencies]
 serde_json = "1.0"
-strum = "0.24"
-strum_macros = "0.24"
 serde-reflection = "0.3.6"
 serde-generate = "0.25.1"
 fxhash.workspace = true
diff --git a/acvm-repo/acir/README.md b/acvm-repo/acir/README.md
index 902769e3ad7..a0e7094b4d6 100644
--- a/acvm-repo/acir/README.md
+++ b/acvm-repo/acir/README.md
@@ -77,7 +77,7 @@ In summary, the workflow is the following:
 1. user program -> (compilation) ACIR, a list of opcodes which constrain
     (partial) witnesses
 2. user inputs + ACIR -> (execution/solving) assign values to all the
-    (partial) witnesses 
+    (partial) witnesses
 3. witness assignment + ACIR -> (proving system) proof
 
 Although the ordering of opcode does not matter in theory, since a system of
@@ -121,7 +121,7 @@ proving system and are only used by the solver.
 Finally, some opcodes will have a predicate, whose value is `0` or `1`. Its
 purpose is to nullify the opcode when the value is `0`, so that it has no
 effect. Note that removing the opcode is not a solution because this modifies
-the circuit (the circuit being mainly the list of the opcodes). 
+the circuit (the circuit being mainly the list of the opcodes).
 
 *Remark*: Opcodes operate on witnesses, but we will see that some opcode work on
     expressions of witnesses. We call an expression a linear combination of
@@ -265,16 +265,6 @@ without adding any constraint.
 NOTE: see the [circuit/opcodes.rs](src/circuit/opcodes.rs) file for the most
 up-to-date documentation on these opcodes.
 
-#### Directive
-
-This opcode is a specialization of Brillig opcode. Instead of having some generic
-assembly code like Brillig, a directive has a hardcoded name which tells the
-solver which computation to do: with Brillig, the computation refers to the
-compiled bytecode of an unconstrained Noir function, but with a directive, the
-computation is hardcoded inside the compiler.
-
-Directives will be replaced by Brillig opcodes in the future.
-
 #### MemoryOp: memory abstraction for ACIR
 
 ACIR is able to address any array of witnesses. Each array is assigned an ID
diff --git a/acvm-repo/acir/benches/serialization.rs b/acvm-repo/acir/benches/serialization.rs
index 792200c8912..dd6a5c8b1cf 100644
--- a/acvm-repo/acir/benches/serialization.rs
+++ b/acvm-repo/acir/benches/serialization.rs
@@ -38,7 +38,6 @@ fn sample_program(num_opcodes: usize) -> Program<FieldElement> {
             public_parameters: PublicInputs(BTreeSet::from([Witness(5)])),
             return_values: PublicInputs(BTreeSet::from([Witness(6)])),
             assert_messages: Vec::new(),
-            recursive: false,
         }],
         unconstrained_functions: Vec::new(),
     }
diff --git a/acvm-repo/acir/codegen/acir.cpp b/acvm-repo/acir/codegen/acir.cpp
index 70ad596a93a..e94f36535d2 100644
--- a/acvm-repo/acir/codegen/acir.cpp
+++ b/acvm-repo/acir/codegen/acir.cpp
@@ -145,12 +145,6 @@ namespace Program {
 
     struct IntegerBitSize {
 
-        struct U0 {
-            friend bool operator==(const U0&, const U0&);
-            std::vector<uint8_t> bincodeSerialize() const;
-            static U0 bincodeDeserialize(std::vector<uint8_t>);
-        };
-
         struct U1 {
             friend bool operator==(const U1&, const U1&);
             std::vector<uint8_t> bincodeSerialize() const;
@@ -187,7 +181,7 @@ namespace Program {
             static U128 bincodeDeserialize(std::vector<uint8_t>);
         };
 
-        std::variant<U0, U1, U8, U16, U32, U64, U128> value;
+        std::variant<U1, U8, U16, U32, U64, U128> value;
 
         friend bool operator==(const IntegerBitSize&, const IntegerBitSize&);
         std::vector<uint8_t> bincodeSerialize() const;
@@ -218,7 +212,24 @@ namespace Program {
     };
 
     struct MemoryAddress {
-        uint64_t value;
+
+        struct Direct {
+            uint64_t value;
+
+            friend bool operator==(const Direct&, const Direct&);
+            std::vector<uint8_t> bincodeSerialize() const;
+            static Direct bincodeDeserialize(std::vector<uint8_t>);
+        };
+
+        struct Relative {
+            uint64_t value;
+
+            friend bool operator==(const Relative&, const Relative&);
+            std::vector<uint8_t> bincodeSerialize() const;
+            static Relative bincodeDeserialize(std::vector<uint8_t>);
+        };
+
+        std::variant<Direct, Relative> value;
 
         friend bool operator==(const MemoryAddress&, const MemoryAddress&);
         std::vector<uint8_t> bincodeSerialize() const;
@@ -274,17 +285,8 @@ namespace Program {
             static Blake3 bincodeDeserialize(std::vector<uint8_t>);
         };
 
-        struct Keccak256 {
-            Program::HeapVector message;
-            Program::HeapArray output;
-
-            friend bool operator==(const Keccak256&, const Keccak256&);
-            std::vector<uint8_t> bincodeSerialize() const;
-            static Keccak256 bincodeDeserialize(std::vector<uint8_t>);
-        };
-
         struct Keccakf1600 {
-            Program::HeapVector message;
+            Program::HeapArray input;
             Program::HeapArray output;
 
             friend bool operator==(const Keccakf1600&, const Keccakf1600&);
@@ -316,38 +318,6 @@ namespace Program {
             static EcdsaSecp256r1 bincodeDeserialize(std::vector<uint8_t>);
         };
 
-        struct SchnorrVerify {
-            Program::MemoryAddress public_key_x;
-            Program::MemoryAddress public_key_y;
-            Program::HeapVector message;
-            Program::HeapVector signature;
-            Program::MemoryAddress result;
-
-            friend bool operator==(const SchnorrVerify&, const SchnorrVerify&);
-            std::vector<uint8_t> bincodeSerialize() const;
-            static SchnorrVerify bincodeDeserialize(std::vector<uint8_t>);
-        };
-
-        struct PedersenCommitment {
-            Program::HeapVector inputs;
-            Program::MemoryAddress domain_separator;
-            Program::HeapArray output;
-
-            friend bool operator==(const PedersenCommitment&, const PedersenCommitment&);
-            std::vector<uint8_t> bincodeSerialize() const;
-            static PedersenCommitment bincodeDeserialize(std::vector<uint8_t>);
-        };
-
-        struct PedersenHash {
-            Program::HeapVector inputs;
-            Program::MemoryAddress domain_separator;
-            Program::MemoryAddress output;
-
-            friend bool operator==(const PedersenHash&, const PedersenHash&);
-            std::vector<uint8_t> bincodeSerialize() const;
-            static PedersenHash bincodeDeserialize(std::vector<uint8_t>);
-        };
-
         struct MultiScalarMul {
             Program::HeapVector points;
             Program::HeapVector scalars;
@@ -442,8 +412,8 @@ namespace Program {
         };
 
         struct Sha256Compression {
-            Program::HeapVector input;
-            Program::HeapVector hash_values;
+            Program::HeapArray input;
+            Program::HeapArray hash_values;
             Program::HeapArray output;
 
             friend bool operator==(const Sha256Compression&, const Sha256Compression&);
@@ -462,7 +432,7 @@ namespace Program {
             static ToRadix bincodeDeserialize(std::vector<uint8_t>);
         };
 
-        std::variant<AES128Encrypt, Blake2s, Blake3, Keccak256, Keccakf1600, EcdsaSecp256k1, EcdsaSecp256r1, SchnorrVerify, PedersenCommitment, PedersenHash, MultiScalarMul, EmbeddedCurveAdd, BigIntAdd, BigIntSub, BigIntMul, BigIntDiv, BigIntFromLeBytes, BigIntToLeBytes, Poseidon2Permutation, Sha256Compression, ToRadix> value;
+        std::variant<AES128Encrypt, Blake2s, Blake3, Keccakf1600, EcdsaSecp256k1, EcdsaSecp256r1, MultiScalarMul, EmbeddedCurveAdd, BigIntAdd, BigIntSub, BigIntMul, BigIntDiv, BigIntFromLeBytes, BigIntToLeBytes, Poseidon2Permutation, Sha256Compression, ToRadix> value;
 
         friend bool operator==(const BlackBoxOp&, const BlackBoxOp&);
         std::vector<uint8_t> bincodeSerialize() const;
@@ -712,7 +682,7 @@ namespace Program {
         };
 
         struct Trap {
-            Program::HeapArray revert_data;
+            Program::HeapVector revert_data;
 
             friend bool operator==(const Trap&, const Trap&);
             std::vector<uint8_t> bincodeSerialize() const;
@@ -720,8 +690,7 @@ namespace Program {
         };
 
         struct Stop {
-            uint64_t return_data_offset;
-            uint64_t return_data_size;
+            Program::HeapVector return_data;
 
             friend bool operator==(const Stop&, const Stop&);
             std::vector<uint8_t> bincodeSerialize() const;
@@ -836,38 +805,6 @@ namespace Program {
             static Blake3 bincodeDeserialize(std::vector<uint8_t>);
         };
 
-        struct SchnorrVerify {
-            Program::FunctionInput public_key_x;
-            Program::FunctionInput public_key_y;
-            std::array<Program::FunctionInput, 64> signature;
-            std::vector<Program::FunctionInput> message;
-            Program::Witness output;
-
-            friend bool operator==(const SchnorrVerify&, const SchnorrVerify&);
-            std::vector<uint8_t> bincodeSerialize() const;
-            static SchnorrVerify bincodeDeserialize(std::vector<uint8_t>);
-        };
-
-        struct PedersenCommitment {
-            std::vector<Program::FunctionInput> inputs;
-            uint32_t domain_separator;
-            std::array<Program::Witness, 2> outputs;
-
-            friend bool operator==(const PedersenCommitment&, const PedersenCommitment&);
-            std::vector<uint8_t> bincodeSerialize() const;
-            static PedersenCommitment bincodeDeserialize(std::vector<uint8_t>);
-        };
-
-        struct PedersenHash {
-            std::vector<Program::FunctionInput> inputs;
-            uint32_t domain_separator;
-            Program::Witness output;
-
-            friend bool operator==(const PedersenHash&, const PedersenHash&);
-            std::vector<uint8_t> bincodeSerialize() const;
-            static PedersenHash bincodeDeserialize(std::vector<uint8_t>);
-        };
-
         struct EcdsaSecp256k1 {
             std::array<Program::FunctionInput, 32> public_key_x;
             std::array<Program::FunctionInput, 32> public_key_y;
@@ -912,16 +849,6 @@ namespace Program {
             static EmbeddedCurveAdd bincodeDeserialize(std::vector<uint8_t>);
         };
 
-        struct Keccak256 {
-            std::vector<Program::FunctionInput> inputs;
-            Program::FunctionInput var_message_size;
-            std::array<Program::Witness, 32> outputs;
-
-            friend bool operator==(const Keccak256&, const Keccak256&);
-            std::vector<uint8_t> bincodeSerialize() const;
-            static Keccak256 bincodeDeserialize(std::vector<uint8_t>);
-        };
-
         struct Keccakf1600 {
             std::array<Program::FunctionInput, 25> inputs;
             std::array<Program::Witness, 25> outputs;
@@ -1022,7 +949,7 @@ namespace Program {
             static Sha256Compression bincodeDeserialize(std::vector<uint8_t>);
         };
 
-        std::variant<AES128Encrypt, AND, XOR, RANGE, Blake2s, Blake3, SchnorrVerify, PedersenCommitment, PedersenHash, EcdsaSecp256k1, EcdsaSecp256r1, MultiScalarMul, EmbeddedCurveAdd, Keccak256, Keccakf1600, RecursiveAggregation, BigIntAdd, BigIntSub, BigIntMul, BigIntDiv, BigIntFromLeBytes, BigIntToLeBytes, Poseidon2Permutation, Sha256Compression> value;
+        std::variant<AES128Encrypt, AND, XOR, RANGE, Blake2s, Blake3, EcdsaSecp256k1, EcdsaSecp256r1, MultiScalarMul, EmbeddedCurveAdd, Keccakf1600, RecursiveAggregation, BigIntAdd, BigIntSub, BigIntMul, BigIntDiv, BigIntFromLeBytes, BigIntToLeBytes, Poseidon2Permutation, Sha256Compression> value;
 
         friend bool operator==(const BlackBoxFuncCall&, const BlackBoxFuncCall&);
         std::vector<uint8_t> bincodeSerialize() const;
@@ -1134,25 +1061,6 @@ namespace Program {
         static BrilligOutputs bincodeDeserialize(std::vector<uint8_t>);
     };
 
-    struct Directive {
-
-        struct ToLeRadix {
-            Program::Expression a;
-            std::vector<Program::Witness> b;
-            uint32_t radix;
-
-            friend bool operator==(const ToLeRadix&, const ToLeRadix&);
-            std::vector<uint8_t> bincodeSerialize() const;
-            static ToLeRadix bincodeDeserialize(std::vector<uint8_t>);
-        };
-
-        std::variant<ToLeRadix> value;
-
-        friend bool operator==(const Directive&, const Directive&);
-        std::vector<uint8_t> bincodeSerialize() const;
-        static Directive bincodeDeserialize(std::vector<uint8_t>);
-    };
-
     struct MemOp {
         Program::Expression operation;
         Program::Expression index;
@@ -1181,14 +1089,6 @@ namespace Program {
             static BlackBoxFuncCall bincodeDeserialize(std::vector<uint8_t>);
         };
 
-        struct Directive {
-            Program::Directive value;
-
-            friend bool operator==(const Directive&, const Directive&);
-            std::vector<uint8_t> bincodeSerialize() const;
-            static Directive bincodeDeserialize(std::vector<uint8_t>);
-        };
-
         struct MemoryOp {
             Program::BlockId block_id;
             Program::MemOp op;
@@ -1231,7 +1131,7 @@ namespace Program {
             static Call bincodeDeserialize(std::vector<uint8_t>);
         };
 
-        std::variant<AssertZero, BlackBoxFuncCall, Directive, MemoryOp, MemoryInit, BrilligCall, Call> value;
+        std::variant<AssertZero, BlackBoxFuncCall, MemoryOp, MemoryInit, BrilligCall, Call> value;
 
         friend bool operator==(const Opcode&, const Opcode&);
         std::vector<uint8_t> bincodeSerialize() const;
@@ -1264,24 +1164,8 @@ namespace Program {
     };
 
     struct AssertionPayload {
-
-        struct StaticString {
-            std::string value;
-
-            friend bool operator==(const StaticString&, const StaticString&);
-            std::vector<uint8_t> bincodeSerialize() const;
-            static StaticString bincodeDeserialize(std::vector<uint8_t>);
-        };
-
-        struct Dynamic {
-            std::tuple<uint64_t, std::vector<Program::ExpressionOrMemory>> value;
-
-            friend bool operator==(const Dynamic&, const Dynamic&);
-            std::vector<uint8_t> bincodeSerialize() const;
-            static Dynamic bincodeDeserialize(std::vector<uint8_t>);
-        };
-
-        std::variant<StaticString, Dynamic> value;
+        uint64_t error_selector;
+        std::vector<Program::ExpressionOrMemory> payload;
 
         friend bool operator==(const AssertionPayload&, const AssertionPayload&);
         std::vector<uint8_t> bincodeSerialize() const;
@@ -1353,7 +1237,6 @@ namespace Program {
         Program::PublicInputs public_parameters;
         Program::PublicInputs return_values;
         std::vector<std::tuple<Program::OpcodeLocation, Program::AssertionPayload>> assert_messages;
-        bool recursive;
 
         friend bool operator==(const Circuit&, const Circuit&);
         std::vector<uint8_t> bincodeSerialize() const;
@@ -1383,7 +1266,8 @@ namespace Program {
 namespace Program {
 
     inline bool operator==(const AssertionPayload &lhs, const AssertionPayload &rhs) {
-        if (!(lhs.value == rhs.value)) { return false; }
+        if (!(lhs.error_selector == rhs.error_selector)) { return false; }
+        if (!(lhs.payload == rhs.payload)) { return false; }
         return true;
     }
 
@@ -1408,7 +1292,8 @@ template <>
 template <typename Serializer>
 void serde::Serializable<Program::AssertionPayload>::serialize(const Program::AssertionPayload &obj, Serializer &serializer) {
     serializer.increase_container_depth();
-    serde::Serializable<decltype(obj.value)>::serialize(obj.value, serializer);
+    serde::Serializable<decltype(obj.error_selector)>::serialize(obj.error_selector, serializer);
+    serde::Serializable<decltype(obj.payload)>::serialize(obj.payload, serializer);
     serializer.decrease_container_depth();
 }
 
@@ -1417,87 +1302,12 @@ template <typename Deserializer>
 Program::AssertionPayload serde::Deserializable<Program::AssertionPayload>::deserialize(Deserializer &deserializer) {
     deserializer.increase_container_depth();
     Program::AssertionPayload obj;
-    obj.value = serde::Deserializable<decltype(obj.value)>::deserialize(deserializer);
+    obj.error_selector = serde::Deserializable<decltype(obj.error_selector)>::deserialize(deserializer);
+    obj.payload = serde::Deserializable<decltype(obj.payload)>::deserialize(deserializer);
     deserializer.decrease_container_depth();
     return obj;
 }
 
-namespace Program {
-
-    inline bool operator==(const AssertionPayload::StaticString &lhs, const AssertionPayload::StaticString &rhs) {
-        if (!(lhs.value == rhs.value)) { return false; }
-        return true;
-    }
-
-    inline std::vector<uint8_t> AssertionPayload::StaticString::bincodeSerialize() const {
-        auto serializer = serde::BincodeSerializer();
-        serde::Serializable<AssertionPayload::StaticString>::serialize(*this, serializer);
-        return std::move(serializer).bytes();
-    }
-
-    inline AssertionPayload::StaticString AssertionPayload::StaticString::bincodeDeserialize(std::vector<uint8_t> input) {
-        auto deserializer = serde::BincodeDeserializer(input);
-        auto value = serde::Deserializable<AssertionPayload::StaticString>::deserialize(deserializer);
-        if (deserializer.get_buffer_offset() < input.size()) {
-            throw serde::deserialization_error("Some input bytes were not read");
-        }
-        return value;
-    }
-
-} // end of namespace Program
-
-template <>
-template <typename Serializer>
-void serde::Serializable<Program::AssertionPayload::StaticString>::serialize(const Program::AssertionPayload::StaticString &obj, Serializer &serializer) {
-    serde::Serializable<decltype(obj.value)>::serialize(obj.value, serializer);
-}
-
-template <>
-template <typename Deserializer>
-Program::AssertionPayload::StaticString serde::Deserializable<Program::AssertionPayload::StaticString>::deserialize(Deserializer &deserializer) {
-    Program::AssertionPayload::StaticString obj;
-    obj.value = serde::Deserializable<decltype(obj.value)>::deserialize(deserializer);
-    return obj;
-}
-
-namespace Program {
-
-    inline bool operator==(const AssertionPayload::Dynamic &lhs, const AssertionPayload::Dynamic &rhs) {
-        if (!(lhs.value == rhs.value)) { return false; }
-        return true;
-    }
-
-    inline std::vector<uint8_t> AssertionPayload::Dynamic::bincodeSerialize() const {
-        auto serializer = serde::BincodeSerializer();
-        serde::Serializable<AssertionPayload::Dynamic>::serialize(*this, serializer);
-        return std::move(serializer).bytes();
-    }
-
-    inline AssertionPayload::Dynamic AssertionPayload::Dynamic::bincodeDeserialize(std::vector<uint8_t> input) {
-        auto deserializer = serde::BincodeDeserializer(input);
-        auto value = serde::Deserializable<AssertionPayload::Dynamic>::deserialize(deserializer);
-        if (deserializer.get_buffer_offset() < input.size()) {
-            throw serde::deserialization_error("Some input bytes were not read");
-        }
-        return value;
-    }
-
-} // end of namespace Program
-
-template <>
-template <typename Serializer>
-void serde::Serializable<Program::AssertionPayload::Dynamic>::serialize(const Program::AssertionPayload::Dynamic &obj, Serializer &serializer) {
-    serde::Serializable<decltype(obj.value)>::serialize(obj.value, serializer);
-}
-
-template <>
-template <typename Deserializer>
-Program::AssertionPayload::Dynamic serde::Deserializable<Program::AssertionPayload::Dynamic>::deserialize(Deserializer &deserializer) {
-    Program::AssertionPayload::Dynamic obj;
-    obj.value = serde::Deserializable<decltype(obj.value)>::deserialize(deserializer);
-    return obj;
-}
-
 namespace Program {
 
     inline bool operator==(const BinaryFieldOp &lhs, const BinaryFieldOp &rhs) {
@@ -2694,144 +2504,6 @@ Program::BlackBoxFuncCall::Blake3 serde::Deserializable<Program::BlackBoxFuncCal
     return obj;
 }
 
-namespace Program {
-
-    inline bool operator==(const BlackBoxFuncCall::SchnorrVerify &lhs, const BlackBoxFuncCall::SchnorrVerify &rhs) {
-        if (!(lhs.public_key_x == rhs.public_key_x)) { return false; }
-        if (!(lhs.public_key_y == rhs.public_key_y)) { return false; }
-        if (!(lhs.signature == rhs.signature)) { return false; }
-        if (!(lhs.message == rhs.message)) { return false; }
-        if (!(lhs.output == rhs.output)) { return false; }
-        return true;
-    }
-
-    inline std::vector<uint8_t> BlackBoxFuncCall::SchnorrVerify::bincodeSerialize() const {
-        auto serializer = serde::BincodeSerializer();
-        serde::Serializable<BlackBoxFuncCall::SchnorrVerify>::serialize(*this, serializer);
-        return std::move(serializer).bytes();
-    }
-
-    inline BlackBoxFuncCall::SchnorrVerify BlackBoxFuncCall::SchnorrVerify::bincodeDeserialize(std::vector<uint8_t> input) {
-        auto deserializer = serde::BincodeDeserializer(input);
-        auto value = serde::Deserializable<BlackBoxFuncCall::SchnorrVerify>::deserialize(deserializer);
-        if (deserializer.get_buffer_offset() < input.size()) {
-            throw serde::deserialization_error("Some input bytes were not read");
-        }
-        return value;
-    }
-
-} // end of namespace Program
-
-template <>
-template <typename Serializer>
-void serde::Serializable<Program::BlackBoxFuncCall::SchnorrVerify>::serialize(const Program::BlackBoxFuncCall::SchnorrVerify &obj, Serializer &serializer) {
-    serde::Serializable<decltype(obj.public_key_x)>::serialize(obj.public_key_x, serializer);
-    serde::Serializable<decltype(obj.public_key_y)>::serialize(obj.public_key_y, serializer);
-    serde::Serializable<decltype(obj.signature)>::serialize(obj.signature, serializer);
-    serde::Serializable<decltype(obj.message)>::serialize(obj.message, serializer);
-    serde::Serializable<decltype(obj.output)>::serialize(obj.output, serializer);
-}
-
-template <>
-template <typename Deserializer>
-Program::BlackBoxFuncCall::SchnorrVerify serde::Deserializable<Program::BlackBoxFuncCall::SchnorrVerify>::deserialize(Deserializer &deserializer) {
-    Program::BlackBoxFuncCall::SchnorrVerify obj;
-    obj.public_key_x = serde::Deserializable<decltype(obj.public_key_x)>::deserialize(deserializer);
-    obj.public_key_y = serde::Deserializable<decltype(obj.public_key_y)>::deserialize(deserializer);
-    obj.signature = serde::Deserializable<decltype(obj.signature)>::deserialize(deserializer);
-    obj.message = serde::Deserializable<decltype(obj.message)>::deserialize(deserializer);
-    obj.output = serde::Deserializable<decltype(obj.output)>::deserialize(deserializer);
-    return obj;
-}
-
-namespace Program {
-
-    inline bool operator==(const BlackBoxFuncCall::PedersenCommitment &lhs, const BlackBoxFuncCall::PedersenCommitment &rhs) {
-        if (!(lhs.inputs == rhs.inputs)) { return false; }
-        if (!(lhs.domain_separator == rhs.domain_separator)) { return false; }
-        if (!(lhs.outputs == rhs.outputs)) { return false; }
-        return true;
-    }
-
-    inline std::vector<uint8_t> BlackBoxFuncCall::PedersenCommitment::bincodeSerialize() const {
-        auto serializer = serde::BincodeSerializer();
-        serde::Serializable<BlackBoxFuncCall::PedersenCommitment>::serialize(*this, serializer);
-        return std::move(serializer).bytes();
-    }
-
-    inline BlackBoxFuncCall::PedersenCommitment BlackBoxFuncCall::PedersenCommitment::bincodeDeserialize(std::vector<uint8_t> input) {
-        auto deserializer = serde::BincodeDeserializer(input);
-        auto value = serde::Deserializable<BlackBoxFuncCall::PedersenCommitment>::deserialize(deserializer);
-        if (deserializer.get_buffer_offset() < input.size()) {
-            throw serde::deserialization_error("Some input bytes were not read");
-        }
-        return value;
-    }
-
-} // end of namespace Program
-
-template <>
-template <typename Serializer>
-void serde::Serializable<Program::BlackBoxFuncCall::PedersenCommitment>::serialize(const Program::BlackBoxFuncCall::PedersenCommitment &obj, Serializer &serializer) {
-    serde::Serializable<decltype(obj.inputs)>::serialize(obj.inputs, serializer);
-    serde::Serializable<decltype(obj.domain_separator)>::serialize(obj.domain_separator, serializer);
-    serde::Serializable<decltype(obj.outputs)>::serialize(obj.outputs, serializer);
-}
-
-template <>
-template <typename Deserializer>
-Program::BlackBoxFuncCall::PedersenCommitment serde::Deserializable<Program::BlackBoxFuncCall::PedersenCommitment>::deserialize(Deserializer &deserializer) {
-    Program::BlackBoxFuncCall::PedersenCommitment obj;
-    obj.inputs = serde::Deserializable<decltype(obj.inputs)>::deserialize(deserializer);
-    obj.domain_separator = serde::Deserializable<decltype(obj.domain_separator)>::deserialize(deserializer);
-    obj.outputs = serde::Deserializable<decltype(obj.outputs)>::deserialize(deserializer);
-    return obj;
-}
-
-namespace Program {
-
-    inline bool operator==(const BlackBoxFuncCall::PedersenHash &lhs, const BlackBoxFuncCall::PedersenHash &rhs) {
-        if (!(lhs.inputs == rhs.inputs)) { return false; }
-        if (!(lhs.domain_separator == rhs.domain_separator)) { return false; }
-        if (!(lhs.output == rhs.output)) { return false; }
-        return true;
-    }
-
-    inline std::vector<uint8_t> BlackBoxFuncCall::PedersenHash::bincodeSerialize() const {
-        auto serializer = serde::BincodeSerializer();
-        serde::Serializable<BlackBoxFuncCall::PedersenHash>::serialize(*this, serializer);
-        return std::move(serializer).bytes();
-    }
-
-    inline BlackBoxFuncCall::PedersenHash BlackBoxFuncCall::PedersenHash::bincodeDeserialize(std::vector<uint8_t> input) {
-        auto deserializer = serde::BincodeDeserializer(input);
-        auto value = serde::Deserializable<BlackBoxFuncCall::PedersenHash>::deserialize(deserializer);
-        if (deserializer.get_buffer_offset() < input.size()) {
-            throw serde::deserialization_error("Some input bytes were not read");
-        }
-        return value;
-    }
-
-} // end of namespace Program
-
-template <>
-template <typename Serializer>
-void serde::Serializable<Program::BlackBoxFuncCall::PedersenHash>::serialize(const Program::BlackBoxFuncCall::PedersenHash &obj, Serializer &serializer) {
-    serde::Serializable<decltype(obj.inputs)>::serialize(obj.inputs, serializer);
-    serde::Serializable<decltype(obj.domain_separator)>::serialize(obj.domain_separator, serializer);
-    serde::Serializable<decltype(obj.output)>::serialize(obj.output, serializer);
-}
-
-template <>
-template <typename Deserializer>
-Program::BlackBoxFuncCall::PedersenHash serde::Deserializable<Program::BlackBoxFuncCall::PedersenHash>::deserialize(Deserializer &deserializer) {
-    Program::BlackBoxFuncCall::PedersenHash obj;
-    obj.inputs = serde::Deserializable<decltype(obj.inputs)>::deserialize(deserializer);
-    obj.domain_separator = serde::Deserializable<decltype(obj.domain_separator)>::deserialize(deserializer);
-    obj.output = serde::Deserializable<decltype(obj.output)>::deserialize(deserializer);
-    return obj;
-}
-
 namespace Program {
 
     inline bool operator==(const BlackBoxFuncCall::EcdsaSecp256k1 &lhs, const BlackBoxFuncCall::EcdsaSecp256k1 &rhs) {
@@ -3020,50 +2692,6 @@ Program::BlackBoxFuncCall::EmbeddedCurveAdd serde::Deserializable<Program::Black
     return obj;
 }
 
-namespace Program {
-
-    inline bool operator==(const BlackBoxFuncCall::Keccak256 &lhs, const BlackBoxFuncCall::Keccak256 &rhs) {
-        if (!(lhs.inputs == rhs.inputs)) { return false; }
-        if (!(lhs.var_message_size == rhs.var_message_size)) { return false; }
-        if (!(lhs.outputs == rhs.outputs)) { return false; }
-        return true;
-    }
-
-    inline std::vector<uint8_t> BlackBoxFuncCall::Keccak256::bincodeSerialize() const {
-        auto serializer = serde::BincodeSerializer();
-        serde::Serializable<BlackBoxFuncCall::Keccak256>::serialize(*this, serializer);
-        return std::move(serializer).bytes();
-    }
-
-    inline BlackBoxFuncCall::Keccak256 BlackBoxFuncCall::Keccak256::bincodeDeserialize(std::vector<uint8_t> input) {
-        auto deserializer = serde::BincodeDeserializer(input);
-        auto value = serde::Deserializable<BlackBoxFuncCall::Keccak256>::deserialize(deserializer);
-        if (deserializer.get_buffer_offset() < input.size()) {
-            throw serde::deserialization_error("Some input bytes were not read");
-        }
-        return value;
-    }
-
-} // end of namespace Program
-
-template <>
-template <typename Serializer>
-void serde::Serializable<Program::BlackBoxFuncCall::Keccak256>::serialize(const Program::BlackBoxFuncCall::Keccak256 &obj, Serializer &serializer) {
-    serde::Serializable<decltype(obj.inputs)>::serialize(obj.inputs, serializer);
-    serde::Serializable<decltype(obj.var_message_size)>::serialize(obj.var_message_size, serializer);
-    serde::Serializable<decltype(obj.outputs)>::serialize(obj.outputs, serializer);
-}
-
-template <>
-template <typename Deserializer>
-Program::BlackBoxFuncCall::Keccak256 serde::Deserializable<Program::BlackBoxFuncCall::Keccak256>::deserialize(Deserializer &deserializer) {
-    Program::BlackBoxFuncCall::Keccak256 obj;
-    obj.inputs = serde::Deserializable<decltype(obj.inputs)>::deserialize(deserializer);
-    obj.var_message_size = serde::Deserializable<decltype(obj.var_message_size)>::deserialize(deserializer);
-    obj.outputs = serde::Deserializable<decltype(obj.outputs)>::deserialize(deserializer);
-    return obj;
-}
-
 namespace Program {
 
     inline bool operator==(const BlackBoxFuncCall::Keccakf1600 &lhs, const BlackBoxFuncCall::Keccakf1600 &rhs) {
@@ -3675,208 +3303,23 @@ Program::BlackBoxOp::Blake3 serde::Deserializable<Program::BlackBoxOp::Blake3>::
     return obj;
 }
 
-namespace Program {
-
-    inline bool operator==(const BlackBoxOp::Keccak256 &lhs, const BlackBoxOp::Keccak256 &rhs) {
-        if (!(lhs.message == rhs.message)) { return false; }
-        if (!(lhs.output == rhs.output)) { return false; }
-        return true;
-    }
-
-    inline std::vector<uint8_t> BlackBoxOp::Keccak256::bincodeSerialize() const {
-        auto serializer = serde::BincodeSerializer();
-        serde::Serializable<BlackBoxOp::Keccak256>::serialize(*this, serializer);
-        return std::move(serializer).bytes();
-    }
-
-    inline BlackBoxOp::Keccak256 BlackBoxOp::Keccak256::bincodeDeserialize(std::vector<uint8_t> input) {
-        auto deserializer = serde::BincodeDeserializer(input);
-        auto value = serde::Deserializable<BlackBoxOp::Keccak256>::deserialize(deserializer);
-        if (deserializer.get_buffer_offset() < input.size()) {
-            throw serde::deserialization_error("Some input bytes were not read");
-        }
-        return value;
-    }
-
-} // end of namespace Program
-
-template <>
-template <typename Serializer>
-void serde::Serializable<Program::BlackBoxOp::Keccak256>::serialize(const Program::BlackBoxOp::Keccak256 &obj, Serializer &serializer) {
-    serde::Serializable<decltype(obj.message)>::serialize(obj.message, serializer);
-    serde::Serializable<decltype(obj.output)>::serialize(obj.output, serializer);
-}
-
-template <>
-template <typename Deserializer>
-Program::BlackBoxOp::Keccak256 serde::Deserializable<Program::BlackBoxOp::Keccak256>::deserialize(Deserializer &deserializer) {
-    Program::BlackBoxOp::Keccak256 obj;
-    obj.message = serde::Deserializable<decltype(obj.message)>::deserialize(deserializer);
-    obj.output = serde::Deserializable<decltype(obj.output)>::deserialize(deserializer);
-    return obj;
-}
-
 namespace Program {
 
     inline bool operator==(const BlackBoxOp::Keccakf1600 &lhs, const BlackBoxOp::Keccakf1600 &rhs) {
-        if (!(lhs.message == rhs.message)) { return false; }
+        if (!(lhs.input == rhs.input)) { return false; }
         if (!(lhs.output == rhs.output)) { return false; }
         return true;
     }
 
-    inline std::vector<uint8_t> BlackBoxOp::Keccakf1600::bincodeSerialize() const {
-        auto serializer = serde::BincodeSerializer();
-        serde::Serializable<BlackBoxOp::Keccakf1600>::serialize(*this, serializer);
-        return std::move(serializer).bytes();
-    }
-
-    inline BlackBoxOp::Keccakf1600 BlackBoxOp::Keccakf1600::bincodeDeserialize(std::vector<uint8_t> input) {
-        auto deserializer = serde::BincodeDeserializer(input);
-        auto value = serde::Deserializable<BlackBoxOp::Keccakf1600>::deserialize(deserializer);
-        if (deserializer.get_buffer_offset() < input.size()) {
-            throw serde::deserialization_error("Some input bytes were not read");
-        }
-        return value;
-    }
-
-} // end of namespace Program
-
-template <>
-template <typename Serializer>
-void serde::Serializable<Program::BlackBoxOp::Keccakf1600>::serialize(const Program::BlackBoxOp::Keccakf1600 &obj, Serializer &serializer) {
-    serde::Serializable<decltype(obj.message)>::serialize(obj.message, serializer);
-    serde::Serializable<decltype(obj.output)>::serialize(obj.output, serializer);
-}
-
-template <>
-template <typename Deserializer>
-Program::BlackBoxOp::Keccakf1600 serde::Deserializable<Program::BlackBoxOp::Keccakf1600>::deserialize(Deserializer &deserializer) {
-    Program::BlackBoxOp::Keccakf1600 obj;
-    obj.message = serde::Deserializable<decltype(obj.message)>::deserialize(deserializer);
-    obj.output = serde::Deserializable<decltype(obj.output)>::deserialize(deserializer);
-    return obj;
-}
-
-namespace Program {
-
-    inline bool operator==(const BlackBoxOp::EcdsaSecp256k1 &lhs, const BlackBoxOp::EcdsaSecp256k1 &rhs) {
-        if (!(lhs.hashed_msg == rhs.hashed_msg)) { return false; }
-        if (!(lhs.public_key_x == rhs.public_key_x)) { return false; }
-        if (!(lhs.public_key_y == rhs.public_key_y)) { return false; }
-        if (!(lhs.signature == rhs.signature)) { return false; }
-        if (!(lhs.result == rhs.result)) { return false; }
-        return true;
-    }
-
-    inline std::vector<uint8_t> BlackBoxOp::EcdsaSecp256k1::bincodeSerialize() const {
-        auto serializer = serde::BincodeSerializer();
-        serde::Serializable<BlackBoxOp::EcdsaSecp256k1>::serialize(*this, serializer);
-        return std::move(serializer).bytes();
-    }
-
-    inline BlackBoxOp::EcdsaSecp256k1 BlackBoxOp::EcdsaSecp256k1::bincodeDeserialize(std::vector<uint8_t> input) {
-        auto deserializer = serde::BincodeDeserializer(input);
-        auto value = serde::Deserializable<BlackBoxOp::EcdsaSecp256k1>::deserialize(deserializer);
-        if (deserializer.get_buffer_offset() < input.size()) {
-            throw serde::deserialization_error("Some input bytes were not read");
-        }
-        return value;
-    }
-
-} // end of namespace Program
-
-template <>
-template <typename Serializer>
-void serde::Serializable<Program::BlackBoxOp::EcdsaSecp256k1>::serialize(const Program::BlackBoxOp::EcdsaSecp256k1 &obj, Serializer &serializer) {
-    serde::Serializable<decltype(obj.hashed_msg)>::serialize(obj.hashed_msg, serializer);
-    serde::Serializable<decltype(obj.public_key_x)>::serialize(obj.public_key_x, serializer);
-    serde::Serializable<decltype(obj.public_key_y)>::serialize(obj.public_key_y, serializer);
-    serde::Serializable<decltype(obj.signature)>::serialize(obj.signature, serializer);
-    serde::Serializable<decltype(obj.result)>::serialize(obj.result, serializer);
-}
-
-template <>
-template <typename Deserializer>
-Program::BlackBoxOp::EcdsaSecp256k1 serde::Deserializable<Program::BlackBoxOp::EcdsaSecp256k1>::deserialize(Deserializer &deserializer) {
-    Program::BlackBoxOp::EcdsaSecp256k1 obj;
-    obj.hashed_msg = serde::Deserializable<decltype(obj.hashed_msg)>::deserialize(deserializer);
-    obj.public_key_x = serde::Deserializable<decltype(obj.public_key_x)>::deserialize(deserializer);
-    obj.public_key_y = serde::Deserializable<decltype(obj.public_key_y)>::deserialize(deserializer);
-    obj.signature = serde::Deserializable<decltype(obj.signature)>::deserialize(deserializer);
-    obj.result = serde::Deserializable<decltype(obj.result)>::deserialize(deserializer);
-    return obj;
-}
-
-namespace Program {
-
-    inline bool operator==(const BlackBoxOp::EcdsaSecp256r1 &lhs, const BlackBoxOp::EcdsaSecp256r1 &rhs) {
-        if (!(lhs.hashed_msg == rhs.hashed_msg)) { return false; }
-        if (!(lhs.public_key_x == rhs.public_key_x)) { return false; }
-        if (!(lhs.public_key_y == rhs.public_key_y)) { return false; }
-        if (!(lhs.signature == rhs.signature)) { return false; }
-        if (!(lhs.result == rhs.result)) { return false; }
-        return true;
-    }
-
-    inline std::vector<uint8_t> BlackBoxOp::EcdsaSecp256r1::bincodeSerialize() const {
-        auto serializer = serde::BincodeSerializer();
-        serde::Serializable<BlackBoxOp::EcdsaSecp256r1>::serialize(*this, serializer);
-        return std::move(serializer).bytes();
-    }
-
-    inline BlackBoxOp::EcdsaSecp256r1 BlackBoxOp::EcdsaSecp256r1::bincodeDeserialize(std::vector<uint8_t> input) {
-        auto deserializer = serde::BincodeDeserializer(input);
-        auto value = serde::Deserializable<BlackBoxOp::EcdsaSecp256r1>::deserialize(deserializer);
-        if (deserializer.get_buffer_offset() < input.size()) {
-            throw serde::deserialization_error("Some input bytes were not read");
-        }
-        return value;
-    }
-
-} // end of namespace Program
-
-template <>
-template <typename Serializer>
-void serde::Serializable<Program::BlackBoxOp::EcdsaSecp256r1>::serialize(const Program::BlackBoxOp::EcdsaSecp256r1 &obj, Serializer &serializer) {
-    serde::Serializable<decltype(obj.hashed_msg)>::serialize(obj.hashed_msg, serializer);
-    serde::Serializable<decltype(obj.public_key_x)>::serialize(obj.public_key_x, serializer);
-    serde::Serializable<decltype(obj.public_key_y)>::serialize(obj.public_key_y, serializer);
-    serde::Serializable<decltype(obj.signature)>::serialize(obj.signature, serializer);
-    serde::Serializable<decltype(obj.result)>::serialize(obj.result, serializer);
-}
-
-template <>
-template <typename Deserializer>
-Program::BlackBoxOp::EcdsaSecp256r1 serde::Deserializable<Program::BlackBoxOp::EcdsaSecp256r1>::deserialize(Deserializer &deserializer) {
-    Program::BlackBoxOp::EcdsaSecp256r1 obj;
-    obj.hashed_msg = serde::Deserializable<decltype(obj.hashed_msg)>::deserialize(deserializer);
-    obj.public_key_x = serde::Deserializable<decltype(obj.public_key_x)>::deserialize(deserializer);
-    obj.public_key_y = serde::Deserializable<decltype(obj.public_key_y)>::deserialize(deserializer);
-    obj.signature = serde::Deserializable<decltype(obj.signature)>::deserialize(deserializer);
-    obj.result = serde::Deserializable<decltype(obj.result)>::deserialize(deserializer);
-    return obj;
-}
-
-namespace Program {
-
-    inline bool operator==(const BlackBoxOp::SchnorrVerify &lhs, const BlackBoxOp::SchnorrVerify &rhs) {
-        if (!(lhs.public_key_x == rhs.public_key_x)) { return false; }
-        if (!(lhs.public_key_y == rhs.public_key_y)) { return false; }
-        if (!(lhs.message == rhs.message)) { return false; }
-        if (!(lhs.signature == rhs.signature)) { return false; }
-        if (!(lhs.result == rhs.result)) { return false; }
-        return true;
-    }
-
-    inline std::vector<uint8_t> BlackBoxOp::SchnorrVerify::bincodeSerialize() const {
+    inline std::vector<uint8_t> BlackBoxOp::Keccakf1600::bincodeSerialize() const {
         auto serializer = serde::BincodeSerializer();
-        serde::Serializable<BlackBoxOp::SchnorrVerify>::serialize(*this, serializer);
+        serde::Serializable<BlackBoxOp::Keccakf1600>::serialize(*this, serializer);
         return std::move(serializer).bytes();
     }
 
-    inline BlackBoxOp::SchnorrVerify BlackBoxOp::SchnorrVerify::bincodeDeserialize(std::vector<uint8_t> input) {
+    inline BlackBoxOp::Keccakf1600 BlackBoxOp::Keccakf1600::bincodeDeserialize(std::vector<uint8_t> input) {
         auto deserializer = serde::BincodeDeserializer(input);
-        auto value = serde::Deserializable<BlackBoxOp::SchnorrVerify>::deserialize(deserializer);
+        auto value = serde::Deserializable<BlackBoxOp::Keccakf1600>::deserialize(deserializer);
         if (deserializer.get_buffer_offset() < input.size()) {
             throw serde::deserialization_error("Some input bytes were not read");
         }
@@ -3887,44 +3330,40 @@ namespace Program {
 
 template <>
 template <typename Serializer>
-void serde::Serializable<Program::BlackBoxOp::SchnorrVerify>::serialize(const Program::BlackBoxOp::SchnorrVerify &obj, Serializer &serializer) {
-    serde::Serializable<decltype(obj.public_key_x)>::serialize(obj.public_key_x, serializer);
-    serde::Serializable<decltype(obj.public_key_y)>::serialize(obj.public_key_y, serializer);
-    serde::Serializable<decltype(obj.message)>::serialize(obj.message, serializer);
-    serde::Serializable<decltype(obj.signature)>::serialize(obj.signature, serializer);
-    serde::Serializable<decltype(obj.result)>::serialize(obj.result, serializer);
+void serde::Serializable<Program::BlackBoxOp::Keccakf1600>::serialize(const Program::BlackBoxOp::Keccakf1600 &obj, Serializer &serializer) {
+    serde::Serializable<decltype(obj.input)>::serialize(obj.input, serializer);
+    serde::Serializable<decltype(obj.output)>::serialize(obj.output, serializer);
 }
 
 template <>
 template <typename Deserializer>
-Program::BlackBoxOp::SchnorrVerify serde::Deserializable<Program::BlackBoxOp::SchnorrVerify>::deserialize(Deserializer &deserializer) {
-    Program::BlackBoxOp::SchnorrVerify obj;
-    obj.public_key_x = serde::Deserializable<decltype(obj.public_key_x)>::deserialize(deserializer);
-    obj.public_key_y = serde::Deserializable<decltype(obj.public_key_y)>::deserialize(deserializer);
-    obj.message = serde::Deserializable<decltype(obj.message)>::deserialize(deserializer);
-    obj.signature = serde::Deserializable<decltype(obj.signature)>::deserialize(deserializer);
-    obj.result = serde::Deserializable<decltype(obj.result)>::deserialize(deserializer);
+Program::BlackBoxOp::Keccakf1600 serde::Deserializable<Program::BlackBoxOp::Keccakf1600>::deserialize(Deserializer &deserializer) {
+    Program::BlackBoxOp::Keccakf1600 obj;
+    obj.input = serde::Deserializable<decltype(obj.input)>::deserialize(deserializer);
+    obj.output = serde::Deserializable<decltype(obj.output)>::deserialize(deserializer);
     return obj;
 }
 
 namespace Program {
 
-    inline bool operator==(const BlackBoxOp::PedersenCommitment &lhs, const BlackBoxOp::PedersenCommitment &rhs) {
-        if (!(lhs.inputs == rhs.inputs)) { return false; }
-        if (!(lhs.domain_separator == rhs.domain_separator)) { return false; }
-        if (!(lhs.output == rhs.output)) { return false; }
+    inline bool operator==(const BlackBoxOp::EcdsaSecp256k1 &lhs, const BlackBoxOp::EcdsaSecp256k1 &rhs) {
+        if (!(lhs.hashed_msg == rhs.hashed_msg)) { return false; }
+        if (!(lhs.public_key_x == rhs.public_key_x)) { return false; }
+        if (!(lhs.public_key_y == rhs.public_key_y)) { return false; }
+        if (!(lhs.signature == rhs.signature)) { return false; }
+        if (!(lhs.result == rhs.result)) { return false; }
         return true;
     }
 
-    inline std::vector<uint8_t> BlackBoxOp::PedersenCommitment::bincodeSerialize() const {
+    inline std::vector<uint8_t> BlackBoxOp::EcdsaSecp256k1::bincodeSerialize() const {
         auto serializer = serde::BincodeSerializer();
-        serde::Serializable<BlackBoxOp::PedersenCommitment>::serialize(*this, serializer);
+        serde::Serializable<BlackBoxOp::EcdsaSecp256k1>::serialize(*this, serializer);
         return std::move(serializer).bytes();
     }
 
-    inline BlackBoxOp::PedersenCommitment BlackBoxOp::PedersenCommitment::bincodeDeserialize(std::vector<uint8_t> input) {
+    inline BlackBoxOp::EcdsaSecp256k1 BlackBoxOp::EcdsaSecp256k1::bincodeDeserialize(std::vector<uint8_t> input) {
         auto deserializer = serde::BincodeDeserializer(input);
-        auto value = serde::Deserializable<BlackBoxOp::PedersenCommitment>::deserialize(deserializer);
+        auto value = serde::Deserializable<BlackBoxOp::EcdsaSecp256k1>::deserialize(deserializer);
         if (deserializer.get_buffer_offset() < input.size()) {
             throw serde::deserialization_error("Some input bytes were not read");
         }
@@ -3935,40 +3374,46 @@ namespace Program {
 
 template <>
 template <typename Serializer>
-void serde::Serializable<Program::BlackBoxOp::PedersenCommitment>::serialize(const Program::BlackBoxOp::PedersenCommitment &obj, Serializer &serializer) {
-    serde::Serializable<decltype(obj.inputs)>::serialize(obj.inputs, serializer);
-    serde::Serializable<decltype(obj.domain_separator)>::serialize(obj.domain_separator, serializer);
-    serde::Serializable<decltype(obj.output)>::serialize(obj.output, serializer);
+void serde::Serializable<Program::BlackBoxOp::EcdsaSecp256k1>::serialize(const Program::BlackBoxOp::EcdsaSecp256k1 &obj, Serializer &serializer) {
+    serde::Serializable<decltype(obj.hashed_msg)>::serialize(obj.hashed_msg, serializer);
+    serde::Serializable<decltype(obj.public_key_x)>::serialize(obj.public_key_x, serializer);
+    serde::Serializable<decltype(obj.public_key_y)>::serialize(obj.public_key_y, serializer);
+    serde::Serializable<decltype(obj.signature)>::serialize(obj.signature, serializer);
+    serde::Serializable<decltype(obj.result)>::serialize(obj.result, serializer);
 }
 
 template <>
 template <typename Deserializer>
-Program::BlackBoxOp::PedersenCommitment serde::Deserializable<Program::BlackBoxOp::PedersenCommitment>::deserialize(Deserializer &deserializer) {
-    Program::BlackBoxOp::PedersenCommitment obj;
-    obj.inputs = serde::Deserializable<decltype(obj.inputs)>::deserialize(deserializer);
-    obj.domain_separator = serde::Deserializable<decltype(obj.domain_separator)>::deserialize(deserializer);
-    obj.output = serde::Deserializable<decltype(obj.output)>::deserialize(deserializer);
+Program::BlackBoxOp::EcdsaSecp256k1 serde::Deserializable<Program::BlackBoxOp::EcdsaSecp256k1>::deserialize(Deserializer &deserializer) {
+    Program::BlackBoxOp::EcdsaSecp256k1 obj;
+    obj.hashed_msg = serde::Deserializable<decltype(obj.hashed_msg)>::deserialize(deserializer);
+    obj.public_key_x = serde::Deserializable<decltype(obj.public_key_x)>::deserialize(deserializer);
+    obj.public_key_y = serde::Deserializable<decltype(obj.public_key_y)>::deserialize(deserializer);
+    obj.signature = serde::Deserializable<decltype(obj.signature)>::deserialize(deserializer);
+    obj.result = serde::Deserializable<decltype(obj.result)>::deserialize(deserializer);
     return obj;
 }
 
 namespace Program {
 
-    inline bool operator==(const BlackBoxOp::PedersenHash &lhs, const BlackBoxOp::PedersenHash &rhs) {
-        if (!(lhs.inputs == rhs.inputs)) { return false; }
-        if (!(lhs.domain_separator == rhs.domain_separator)) { return false; }
-        if (!(lhs.output == rhs.output)) { return false; }
+    inline bool operator==(const BlackBoxOp::EcdsaSecp256r1 &lhs, const BlackBoxOp::EcdsaSecp256r1 &rhs) {
+        if (!(lhs.hashed_msg == rhs.hashed_msg)) { return false; }
+        if (!(lhs.public_key_x == rhs.public_key_x)) { return false; }
+        if (!(lhs.public_key_y == rhs.public_key_y)) { return false; }
+        if (!(lhs.signature == rhs.signature)) { return false; }
+        if (!(lhs.result == rhs.result)) { return false; }
         return true;
     }
 
-    inline std::vector<uint8_t> BlackBoxOp::PedersenHash::bincodeSerialize() const {
+    inline std::vector<uint8_t> BlackBoxOp::EcdsaSecp256r1::bincodeSerialize() const {
         auto serializer = serde::BincodeSerializer();
-        serde::Serializable<BlackBoxOp::PedersenHash>::serialize(*this, serializer);
+        serde::Serializable<BlackBoxOp::EcdsaSecp256r1>::serialize(*this, serializer);
         return std::move(serializer).bytes();
     }
 
-    inline BlackBoxOp::PedersenHash BlackBoxOp::PedersenHash::bincodeDeserialize(std::vector<uint8_t> input) {
+    inline BlackBoxOp::EcdsaSecp256r1 BlackBoxOp::EcdsaSecp256r1::bincodeDeserialize(std::vector<uint8_t> input) {
         auto deserializer = serde::BincodeDeserializer(input);
-        auto value = serde::Deserializable<BlackBoxOp::PedersenHash>::deserialize(deserializer);
+        auto value = serde::Deserializable<BlackBoxOp::EcdsaSecp256r1>::deserialize(deserializer);
         if (deserializer.get_buffer_offset() < input.size()) {
             throw serde::deserialization_error("Some input bytes were not read");
         }
@@ -3979,19 +3424,23 @@ namespace Program {
 
 template <>
 template <typename Serializer>
-void serde::Serializable<Program::BlackBoxOp::PedersenHash>::serialize(const Program::BlackBoxOp::PedersenHash &obj, Serializer &serializer) {
-    serde::Serializable<decltype(obj.inputs)>::serialize(obj.inputs, serializer);
-    serde::Serializable<decltype(obj.domain_separator)>::serialize(obj.domain_separator, serializer);
-    serde::Serializable<decltype(obj.output)>::serialize(obj.output, serializer);
+void serde::Serializable<Program::BlackBoxOp::EcdsaSecp256r1>::serialize(const Program::BlackBoxOp::EcdsaSecp256r1 &obj, Serializer &serializer) {
+    serde::Serializable<decltype(obj.hashed_msg)>::serialize(obj.hashed_msg, serializer);
+    serde::Serializable<decltype(obj.public_key_x)>::serialize(obj.public_key_x, serializer);
+    serde::Serializable<decltype(obj.public_key_y)>::serialize(obj.public_key_y, serializer);
+    serde::Serializable<decltype(obj.signature)>::serialize(obj.signature, serializer);
+    serde::Serializable<decltype(obj.result)>::serialize(obj.result, serializer);
 }
 
 template <>
 template <typename Deserializer>
-Program::BlackBoxOp::PedersenHash serde::Deserializable<Program::BlackBoxOp::PedersenHash>::deserialize(Deserializer &deserializer) {
-    Program::BlackBoxOp::PedersenHash obj;
-    obj.inputs = serde::Deserializable<decltype(obj.inputs)>::deserialize(deserializer);
-    obj.domain_separator = serde::Deserializable<decltype(obj.domain_separator)>::deserialize(deserializer);
-    obj.output = serde::Deserializable<decltype(obj.output)>::deserialize(deserializer);
+Program::BlackBoxOp::EcdsaSecp256r1 serde::Deserializable<Program::BlackBoxOp::EcdsaSecp256r1>::deserialize(Deserializer &deserializer) {
+    Program::BlackBoxOp::EcdsaSecp256r1 obj;
+    obj.hashed_msg = serde::Deserializable<decltype(obj.hashed_msg)>::deserialize(deserializer);
+    obj.public_key_x = serde::Deserializable<decltype(obj.public_key_x)>::deserialize(deserializer);
+    obj.public_key_y = serde::Deserializable<decltype(obj.public_key_y)>::deserialize(deserializer);
+    obj.signature = serde::Deserializable<decltype(obj.signature)>::deserialize(deserializer);
+    obj.result = serde::Deserializable<decltype(obj.result)>::deserialize(deserializer);
     return obj;
 }
 
@@ -5732,8 +5181,7 @@ Program::BrilligOpcode::Trap serde::Deserializable<Program::BrilligOpcode::Trap>
 namespace Program {
 
     inline bool operator==(const BrilligOpcode::Stop &lhs, const BrilligOpcode::Stop &rhs) {
-        if (!(lhs.return_data_offset == rhs.return_data_offset)) { return false; }
-        if (!(lhs.return_data_size == rhs.return_data_size)) { return false; }
+        if (!(lhs.return_data == rhs.return_data)) { return false; }
         return true;
     }
 
@@ -5757,16 +5205,14 @@ namespace Program {
 template <>
 template <typename Serializer>
 void serde::Serializable<Program::BrilligOpcode::Stop>::serialize(const Program::BrilligOpcode::Stop &obj, Serializer &serializer) {
-    serde::Serializable<decltype(obj.return_data_offset)>::serialize(obj.return_data_offset, serializer);
-    serde::Serializable<decltype(obj.return_data_size)>::serialize(obj.return_data_size, serializer);
+    serde::Serializable<decltype(obj.return_data)>::serialize(obj.return_data, serializer);
 }
 
 template <>
 template <typename Deserializer>
 Program::BrilligOpcode::Stop serde::Deserializable<Program::BrilligOpcode::Stop>::deserialize(Deserializer &deserializer) {
     Program::BrilligOpcode::Stop obj;
-    obj.return_data_offset = serde::Deserializable<decltype(obj.return_data_offset)>::deserialize(deserializer);
-    obj.return_data_size = serde::Deserializable<decltype(obj.return_data_size)>::deserialize(deserializer);
+    obj.return_data = serde::Deserializable<decltype(obj.return_data)>::deserialize(deserializer);
     return obj;
 }
 
@@ -5898,7 +5344,6 @@ namespace Program {
         if (!(lhs.public_parameters == rhs.public_parameters)) { return false; }
         if (!(lhs.return_values == rhs.return_values)) { return false; }
         if (!(lhs.assert_messages == rhs.assert_messages)) { return false; }
-        if (!(lhs.recursive == rhs.recursive)) { return false; }
         return true;
     }
 
@@ -5930,7 +5375,6 @@ void serde::Serializable<Program::Circuit>::serialize(const Program::Circuit &ob
     serde::Serializable<decltype(obj.public_parameters)>::serialize(obj.public_parameters, serializer);
     serde::Serializable<decltype(obj.return_values)>::serialize(obj.return_values, serializer);
     serde::Serializable<decltype(obj.assert_messages)>::serialize(obj.assert_messages, serializer);
-    serde::Serializable<decltype(obj.recursive)>::serialize(obj.recursive, serializer);
     serializer.decrease_container_depth();
 }
 
@@ -5946,7 +5390,6 @@ Program::Circuit serde::Deserializable<Program::Circuit>::deserialize(Deserializ
     obj.public_parameters = serde::Deserializable<decltype(obj.public_parameters)>::deserialize(deserializer);
     obj.return_values = serde::Deserializable<decltype(obj.return_values)>::deserialize(deserializer);
     obj.assert_messages = serde::Deserializable<decltype(obj.assert_messages)>::deserialize(deserializer);
-    obj.recursive = serde::Deserializable<decltype(obj.recursive)>::deserialize(deserializer);
     deserializer.decrease_container_depth();
     return obj;
 }
@@ -6069,92 +5512,6 @@ Program::ConstantOrWitnessEnum::Witness serde::Deserializable<Program::ConstantO
     return obj;
 }
 
-namespace Program {
-
-    inline bool operator==(const Directive &lhs, const Directive &rhs) {
-        if (!(lhs.value == rhs.value)) { return false; }
-        return true;
-    }
-
-    inline std::vector<uint8_t> Directive::bincodeSerialize() const {
-        auto serializer = serde::BincodeSerializer();
-        serde::Serializable<Directive>::serialize(*this, serializer);
-        return std::move(serializer).bytes();
-    }
-
-    inline Directive Directive::bincodeDeserialize(std::vector<uint8_t> input) {
-        auto deserializer = serde::BincodeDeserializer(input);
-        auto value = serde::Deserializable<Directive>::deserialize(deserializer);
-        if (deserializer.get_buffer_offset() < input.size()) {
-            throw serde::deserialization_error("Some input bytes were not read");
-        }
-        return value;
-    }
-
-} // end of namespace Program
-
-template <>
-template <typename Serializer>
-void serde::Serializable<Program::Directive>::serialize(const Program::Directive &obj, Serializer &serializer) {
-    serializer.increase_container_depth();
-    serde::Serializable<decltype(obj.value)>::serialize(obj.value, serializer);
-    serializer.decrease_container_depth();
-}
-
-template <>
-template <typename Deserializer>
-Program::Directive serde::Deserializable<Program::Directive>::deserialize(Deserializer &deserializer) {
-    deserializer.increase_container_depth();
-    Program::Directive obj;
-    obj.value = serde::Deserializable<decltype(obj.value)>::deserialize(deserializer);
-    deserializer.decrease_container_depth();
-    return obj;
-}
-
-namespace Program {
-
-    inline bool operator==(const Directive::ToLeRadix &lhs, const Directive::ToLeRadix &rhs) {
-        if (!(lhs.a == rhs.a)) { return false; }
-        if (!(lhs.b == rhs.b)) { return false; }
-        if (!(lhs.radix == rhs.radix)) { return false; }
-        return true;
-    }
-
-    inline std::vector<uint8_t> Directive::ToLeRadix::bincodeSerialize() const {
-        auto serializer = serde::BincodeSerializer();
-        serde::Serializable<Directive::ToLeRadix>::serialize(*this, serializer);
-        return std::move(serializer).bytes();
-    }
-
-    inline Directive::ToLeRadix Directive::ToLeRadix::bincodeDeserialize(std::vector<uint8_t> input) {
-        auto deserializer = serde::BincodeDeserializer(input);
-        auto value = serde::Deserializable<Directive::ToLeRadix>::deserialize(deserializer);
-        if (deserializer.get_buffer_offset() < input.size()) {
-            throw serde::deserialization_error("Some input bytes were not read");
-        }
-        return value;
-    }
-
-} // end of namespace Program
-
-template <>
-template <typename Serializer>
-void serde::Serializable<Program::Directive::ToLeRadix>::serialize(const Program::Directive::ToLeRadix &obj, Serializer &serializer) {
-    serde::Serializable<decltype(obj.a)>::serialize(obj.a, serializer);
-    serde::Serializable<decltype(obj.b)>::serialize(obj.b, serializer);
-    serde::Serializable<decltype(obj.radix)>::serialize(obj.radix, serializer);
-}
-
-template <>
-template <typename Deserializer>
-Program::Directive::ToLeRadix serde::Deserializable<Program::Directive::ToLeRadix>::deserialize(Deserializer &deserializer) {
-    Program::Directive::ToLeRadix obj;
-    obj.a = serde::Deserializable<decltype(obj.a)>::deserialize(deserializer);
-    obj.b = serde::Deserializable<decltype(obj.b)>::deserialize(deserializer);
-    obj.radix = serde::Deserializable<decltype(obj.radix)>::deserialize(deserializer);
-    return obj;
-}
-
 namespace Program {
 
     inline bool operator==(const Expression &lhs, const Expression &rhs) {
@@ -6772,41 +6129,6 @@ Program::IntegerBitSize serde::Deserializable<Program::IntegerBitSize>::deserial
     return obj;
 }
 
-namespace Program {
-
-    inline bool operator==(const IntegerBitSize::U0 &lhs, const IntegerBitSize::U0 &rhs) {
-        return true;
-    }
-
-    inline std::vector<uint8_t> IntegerBitSize::U0::bincodeSerialize() const {
-        auto serializer = serde::BincodeSerializer();
-        serde::Serializable<IntegerBitSize::U0>::serialize(*this, serializer);
-        return std::move(serializer).bytes();
-    }
-
-    inline IntegerBitSize::U0 IntegerBitSize::U0::bincodeDeserialize(std::vector<uint8_t> input) {
-        auto deserializer = serde::BincodeDeserializer(input);
-        auto value = serde::Deserializable<IntegerBitSize::U0>::deserialize(deserializer);
-        if (deserializer.get_buffer_offset() < input.size()) {
-            throw serde::deserialization_error("Some input bytes were not read");
-        }
-        return value;
-    }
-
-} // end of namespace Program
-
-template <>
-template <typename Serializer>
-void serde::Serializable<Program::IntegerBitSize::U0>::serialize(const Program::IntegerBitSize::U0 &obj, Serializer &serializer) {
-}
-
-template <>
-template <typename Deserializer>
-Program::IntegerBitSize::U0 serde::Deserializable<Program::IntegerBitSize::U0>::deserialize(Deserializer &deserializer) {
-    Program::IntegerBitSize::U0 obj;
-    return obj;
-}
-
 namespace Program {
 
     inline bool operator==(const IntegerBitSize::U1 &lhs, const IntegerBitSize::U1 &rhs) {
@@ -7109,20 +6431,20 @@ Program::MemoryAddress serde::Deserializable<Program::MemoryAddress>::deserializ
 
 namespace Program {
 
-    inline bool operator==(const Opcode &lhs, const Opcode &rhs) {
+    inline bool operator==(const MemoryAddress::Direct &lhs, const MemoryAddress::Direct &rhs) {
         if (!(lhs.value == rhs.value)) { return false; }
         return true;
     }
 
-    inline std::vector<uint8_t> Opcode::bincodeSerialize() const {
+    inline std::vector<uint8_t> MemoryAddress::Direct::bincodeSerialize() const {
         auto serializer = serde::BincodeSerializer();
-        serde::Serializable<Opcode>::serialize(*this, serializer);
+        serde::Serializable<MemoryAddress::Direct>::serialize(*this, serializer);
         return std::move(serializer).bytes();
     }
 
-    inline Opcode Opcode::bincodeDeserialize(std::vector<uint8_t> input) {
+    inline MemoryAddress::Direct MemoryAddress::Direct::bincodeDeserialize(std::vector<uint8_t> input) {
         auto deserializer = serde::BincodeDeserializer(input);
-        auto value = serde::Deserializable<Opcode>::deserialize(deserializer);
+        auto value = serde::Deserializable<MemoryAddress::Direct>::deserialize(deserializer);
         if (deserializer.get_buffer_offset() < input.size()) {
             throw serde::deserialization_error("Some input bytes were not read");
         }
@@ -7133,38 +6455,34 @@ namespace Program {
 
 template <>
 template <typename Serializer>
-void serde::Serializable<Program::Opcode>::serialize(const Program::Opcode &obj, Serializer &serializer) {
-    serializer.increase_container_depth();
+void serde::Serializable<Program::MemoryAddress::Direct>::serialize(const Program::MemoryAddress::Direct &obj, Serializer &serializer) {
     serde::Serializable<decltype(obj.value)>::serialize(obj.value, serializer);
-    serializer.decrease_container_depth();
 }
 
 template <>
 template <typename Deserializer>
-Program::Opcode serde::Deserializable<Program::Opcode>::deserialize(Deserializer &deserializer) {
-    deserializer.increase_container_depth();
-    Program::Opcode obj;
+Program::MemoryAddress::Direct serde::Deserializable<Program::MemoryAddress::Direct>::deserialize(Deserializer &deserializer) {
+    Program::MemoryAddress::Direct obj;
     obj.value = serde::Deserializable<decltype(obj.value)>::deserialize(deserializer);
-    deserializer.decrease_container_depth();
     return obj;
 }
 
 namespace Program {
 
-    inline bool operator==(const Opcode::AssertZero &lhs, const Opcode::AssertZero &rhs) {
+    inline bool operator==(const MemoryAddress::Relative &lhs, const MemoryAddress::Relative &rhs) {
         if (!(lhs.value == rhs.value)) { return false; }
         return true;
     }
 
-    inline std::vector<uint8_t> Opcode::AssertZero::bincodeSerialize() const {
+    inline std::vector<uint8_t> MemoryAddress::Relative::bincodeSerialize() const {
         auto serializer = serde::BincodeSerializer();
-        serde::Serializable<Opcode::AssertZero>::serialize(*this, serializer);
+        serde::Serializable<MemoryAddress::Relative>::serialize(*this, serializer);
         return std::move(serializer).bytes();
     }
 
-    inline Opcode::AssertZero Opcode::AssertZero::bincodeDeserialize(std::vector<uint8_t> input) {
+    inline MemoryAddress::Relative MemoryAddress::Relative::bincodeDeserialize(std::vector<uint8_t> input) {
         auto deserializer = serde::BincodeDeserializer(input);
-        auto value = serde::Deserializable<Opcode::AssertZero>::deserialize(deserializer);
+        auto value = serde::Deserializable<MemoryAddress::Relative>::deserialize(deserializer);
         if (deserializer.get_buffer_offset() < input.size()) {
             throw serde::deserialization_error("Some input bytes were not read");
         }
@@ -7175,34 +6493,34 @@ namespace Program {
 
 template <>
 template <typename Serializer>
-void serde::Serializable<Program::Opcode::AssertZero>::serialize(const Program::Opcode::AssertZero &obj, Serializer &serializer) {
+void serde::Serializable<Program::MemoryAddress::Relative>::serialize(const Program::MemoryAddress::Relative &obj, Serializer &serializer) {
     serde::Serializable<decltype(obj.value)>::serialize(obj.value, serializer);
 }
 
 template <>
 template <typename Deserializer>
-Program::Opcode::AssertZero serde::Deserializable<Program::Opcode::AssertZero>::deserialize(Deserializer &deserializer) {
-    Program::Opcode::AssertZero obj;
+Program::MemoryAddress::Relative serde::Deserializable<Program::MemoryAddress::Relative>::deserialize(Deserializer &deserializer) {
+    Program::MemoryAddress::Relative obj;
     obj.value = serde::Deserializable<decltype(obj.value)>::deserialize(deserializer);
     return obj;
 }
 
 namespace Program {
 
-    inline bool operator==(const Opcode::BlackBoxFuncCall &lhs, const Opcode::BlackBoxFuncCall &rhs) {
+    inline bool operator==(const Opcode &lhs, const Opcode &rhs) {
         if (!(lhs.value == rhs.value)) { return false; }
         return true;
     }
 
-    inline std::vector<uint8_t> Opcode::BlackBoxFuncCall::bincodeSerialize() const {
+    inline std::vector<uint8_t> Opcode::bincodeSerialize() const {
         auto serializer = serde::BincodeSerializer();
-        serde::Serializable<Opcode::BlackBoxFuncCall>::serialize(*this, serializer);
+        serde::Serializable<Opcode>::serialize(*this, serializer);
         return std::move(serializer).bytes();
     }
 
-    inline Opcode::BlackBoxFuncCall Opcode::BlackBoxFuncCall::bincodeDeserialize(std::vector<uint8_t> input) {
+    inline Opcode Opcode::bincodeDeserialize(std::vector<uint8_t> input) {
         auto deserializer = serde::BincodeDeserializer(input);
-        auto value = serde::Deserializable<Opcode::BlackBoxFuncCall>::deserialize(deserializer);
+        auto value = serde::Deserializable<Opcode>::deserialize(deserializer);
         if (deserializer.get_buffer_offset() < input.size()) {
             throw serde::deserialization_error("Some input bytes were not read");
         }
@@ -7213,34 +6531,76 @@ namespace Program {
 
 template <>
 template <typename Serializer>
-void serde::Serializable<Program::Opcode::BlackBoxFuncCall>::serialize(const Program::Opcode::BlackBoxFuncCall &obj, Serializer &serializer) {
+void serde::Serializable<Program::Opcode>::serialize(const Program::Opcode &obj, Serializer &serializer) {
+    serializer.increase_container_depth();
     serde::Serializable<decltype(obj.value)>::serialize(obj.value, serializer);
+    serializer.decrease_container_depth();
 }
 
 template <>
 template <typename Deserializer>
-Program::Opcode::BlackBoxFuncCall serde::Deserializable<Program::Opcode::BlackBoxFuncCall>::deserialize(Deserializer &deserializer) {
-    Program::Opcode::BlackBoxFuncCall obj;
+Program::Opcode serde::Deserializable<Program::Opcode>::deserialize(Deserializer &deserializer) {
+    deserializer.increase_container_depth();
+    Program::Opcode obj;
+    obj.value = serde::Deserializable<decltype(obj.value)>::deserialize(deserializer);
+    deserializer.decrease_container_depth();
+    return obj;
+}
+
+namespace Program {
+
+    inline bool operator==(const Opcode::AssertZero &lhs, const Opcode::AssertZero &rhs) {
+        if (!(lhs.value == rhs.value)) { return false; }
+        return true;
+    }
+
+    inline std::vector<uint8_t> Opcode::AssertZero::bincodeSerialize() const {
+        auto serializer = serde::BincodeSerializer();
+        serde::Serializable<Opcode::AssertZero>::serialize(*this, serializer);
+        return std::move(serializer).bytes();
+    }
+
+    inline Opcode::AssertZero Opcode::AssertZero::bincodeDeserialize(std::vector<uint8_t> input) {
+        auto deserializer = serde::BincodeDeserializer(input);
+        auto value = serde::Deserializable<Opcode::AssertZero>::deserialize(deserializer);
+        if (deserializer.get_buffer_offset() < input.size()) {
+            throw serde::deserialization_error("Some input bytes were not read");
+        }
+        return value;
+    }
+
+} // end of namespace Program
+
+template <>
+template <typename Serializer>
+void serde::Serializable<Program::Opcode::AssertZero>::serialize(const Program::Opcode::AssertZero &obj, Serializer &serializer) {
+    serde::Serializable<decltype(obj.value)>::serialize(obj.value, serializer);
+}
+
+template <>
+template <typename Deserializer>
+Program::Opcode::AssertZero serde::Deserializable<Program::Opcode::AssertZero>::deserialize(Deserializer &deserializer) {
+    Program::Opcode::AssertZero obj;
     obj.value = serde::Deserializable<decltype(obj.value)>::deserialize(deserializer);
     return obj;
 }
 
 namespace Program {
 
-    inline bool operator==(const Opcode::Directive &lhs, const Opcode::Directive &rhs) {
+    inline bool operator==(const Opcode::BlackBoxFuncCall &lhs, const Opcode::BlackBoxFuncCall &rhs) {
         if (!(lhs.value == rhs.value)) { return false; }
         return true;
     }
 
-    inline std::vector<uint8_t> Opcode::Directive::bincodeSerialize() const {
+    inline std::vector<uint8_t> Opcode::BlackBoxFuncCall::bincodeSerialize() const {
         auto serializer = serde::BincodeSerializer();
-        serde::Serializable<Opcode::Directive>::serialize(*this, serializer);
+        serde::Serializable<Opcode::BlackBoxFuncCall>::serialize(*this, serializer);
         return std::move(serializer).bytes();
     }
 
-    inline Opcode::Directive Opcode::Directive::bincodeDeserialize(std::vector<uint8_t> input) {
+    inline Opcode::BlackBoxFuncCall Opcode::BlackBoxFuncCall::bincodeDeserialize(std::vector<uint8_t> input) {
         auto deserializer = serde::BincodeDeserializer(input);
-        auto value = serde::Deserializable<Opcode::Directive>::deserialize(deserializer);
+        auto value = serde::Deserializable<Opcode::BlackBoxFuncCall>::deserialize(deserializer);
         if (deserializer.get_buffer_offset() < input.size()) {
             throw serde::deserialization_error("Some input bytes were not read");
         }
@@ -7251,14 +6611,14 @@ namespace Program {
 
 template <>
 template <typename Serializer>
-void serde::Serializable<Program::Opcode::Directive>::serialize(const Program::Opcode::Directive &obj, Serializer &serializer) {
+void serde::Serializable<Program::Opcode::BlackBoxFuncCall>::serialize(const Program::Opcode::BlackBoxFuncCall &obj, Serializer &serializer) {
     serde::Serializable<decltype(obj.value)>::serialize(obj.value, serializer);
 }
 
 template <>
 template <typename Deserializer>
-Program::Opcode::Directive serde::Deserializable<Program::Opcode::Directive>::deserialize(Deserializer &deserializer) {
-    Program::Opcode::Directive obj;
+Program::Opcode::BlackBoxFuncCall serde::Deserializable<Program::Opcode::BlackBoxFuncCall>::deserialize(Deserializer &deserializer) {
+    Program::Opcode::BlackBoxFuncCall obj;
     obj.value = serde::Deserializable<decltype(obj.value)>::deserialize(deserializer);
     return obj;
 }
diff --git a/acvm-repo/acir/src/circuit/black_box_functions.rs b/acvm-repo/acir/src/circuit/black_box_functions.rs
index 5c07a61af7e..700589d2040 100644
--- a/acvm-repo/acir/src/circuit/black_box_functions.rs
+++ b/acvm-repo/acir/src/circuit/black_box_functions.rs
@@ -4,12 +4,10 @@
 //! implemented in more basic constraints.
 
 use serde::{Deserialize, Serialize};
-#[cfg(test)]
 use strum_macros::EnumIter;
 
 #[allow(clippy::upper_case_acronyms)]
-#[derive(Clone, Debug, Hash, Copy, PartialEq, Eq, Serialize, Deserialize)]
-#[cfg_attr(test, derive(EnumIter))]
+#[derive(Clone, Debug, Hash, Copy, PartialEq, Eq, Serialize, Deserialize, EnumIter)]
 pub enum BlackBoxFunc {
     /// Ciphers (encrypts) the provided plaintext using AES128 in CBC mode,
     /// padding the input using PKCS#7.
@@ -53,33 +51,6 @@ pub enum BlackBoxFunc {
     /// (witness, 8), constrained to be the blake3 of the inputs.
     Blake3,
 
-    /// Verify a Schnorr signature over the embedded curve
-    /// - inputs are:
-    ///     - Public key as 2 (witness, 254)
-    ///     - signature as a vector of 64 bytes (witness, 8)
-    ///     - message as a vector of (witness, 8)
-    /// - output: A witness representing the result of the signature
-    /// verification; 0 for failure and 1 for success.
-    ///
-    /// Since the scalar field of the embedded curve is NOT the ACIR field, the
-    /// `(r,s)` signature is represented as a 64 bytes array for the two field
-    /// elements. On the other hand, the public key coordinates are ACIR fields.
-    /// The proving system decides how the message is to be hashed. Barretenberg
-    /// uses Blake2s.
-    ///
-    /// Verifies a Schnorr signature over a curve which is "pairing friendly"
-    /// with the curve on which the ACIR circuit is defined.
-    ///
-    /// The exact curve which this signature uses will vary based on the curve
-    /// being used by ACIR. For example, the BN254 curve supports Schnorr
-    /// signatures over the [Grumpkin][grumpkin] curve.
-    ///
-    /// [grumpkin]: https://hackmd.io/@aztec-network/ByzgNxBfd#2-Grumpkin---A-curve-on-top-of-BN-254-for-SNARK-efficient-group-operations
-    SchnorrVerify,
-    /// Will be deprecated
-    PedersenCommitment,
-    /// Will be deprecated
-    PedersenHash,
     /// Verifies a ECDSA signature over the secp256k1 curve.
     /// - inputs:
     ///     - x coordinate of public key as 32 bytes
@@ -87,11 +58,6 @@ pub enum BlackBoxFunc {
     ///     - the signature, as a 64 bytes array
     ///     - the hash of the message, as a vector of bytes
     /// - output: 0 for failure and 1 for success
-    ///
-    /// Inputs and outputs are similar to SchnorrVerify, except that because we
-    /// use a different curve (secp256k1), the field elements involved in the
-    /// signature and the public key are defined as an array of 32 bytes.
-    /// Another difference is that we assume the message is already hashed.
     EcdsaSecp256k1,
 
     /// Verifies a ECDSA signature over the secp256r1 curve.
@@ -117,11 +83,6 @@ pub enum BlackBoxFunc {
     /// scalar $a$: `a=low+high*2^{128}`, with `low, high < 2^{128}`
     MultiScalarMul,
 
-    /// Computes the Keccak-256 (Ethereum version) of the inputs.
-    /// - inputs: Vector of bytes (witness, 8)
-    /// - outputs: Array of 32 bytes (witness, 8)
-    Keccak256,
-
     /// Keccak Permutation function of width 1600
     /// - inputs: An array of 25 64-bit Keccak lanes that represent a keccak sponge of 1600 bits
     /// - outputs: The result of a keccak f1600 permutation on the input state. Also an array of 25 Keccak lanes.
@@ -207,7 +168,6 @@ impl BlackBoxFunc {
     pub fn name(&self) -> &'static str {
         match self {
             BlackBoxFunc::AES128Encrypt => "aes128_encrypt",
-            BlackBoxFunc::SchnorrVerify => "schnorr_verify",
             BlackBoxFunc::Blake2s => "blake2s",
             BlackBoxFunc::Blake3 => "blake3",
             BlackBoxFunc::EcdsaSecp256k1 => "ecdsa_secp256k1",
@@ -216,7 +176,6 @@ impl BlackBoxFunc {
             BlackBoxFunc::AND => "and",
             BlackBoxFunc::XOR => "xor",
             BlackBoxFunc::RANGE => "range",
-            BlackBoxFunc::Keccak256 => "keccak256",
             BlackBoxFunc::Keccakf1600 => "keccakf1600",
             BlackBoxFunc::RecursiveAggregation => "recursive_aggregation",
             BlackBoxFunc::EcdsaSecp256r1 => "ecdsa_secp256r1",
@@ -228,15 +187,12 @@ impl BlackBoxFunc {
             BlackBoxFunc::BigIntToLeBytes => "bigint_to_le_bytes",
             BlackBoxFunc::Poseidon2Permutation => "poseidon2_permutation",
             BlackBoxFunc::Sha256Compression => "sha256_compression",
-            BlackBoxFunc::PedersenCommitment => "pedersen_commitment",
-            BlackBoxFunc::PedersenHash => "pedersen_hash",
         }
     }
 
     pub fn lookup(op_name: &str) -> Option<BlackBoxFunc> {
         match op_name {
             "aes128_encrypt" => Some(BlackBoxFunc::AES128Encrypt),
-            "schnorr_verify" => Some(BlackBoxFunc::SchnorrVerify),
             "blake2s" => Some(BlackBoxFunc::Blake2s),
             "blake3" => Some(BlackBoxFunc::Blake3),
             "ecdsa_secp256k1" => Some(BlackBoxFunc::EcdsaSecp256k1),
@@ -246,7 +202,6 @@ impl BlackBoxFunc {
             "and" => Some(BlackBoxFunc::AND),
             "xor" => Some(BlackBoxFunc::XOR),
             "range" => Some(BlackBoxFunc::RANGE),
-            "keccak256" => Some(BlackBoxFunc::Keccak256),
             "keccakf1600" => Some(BlackBoxFunc::Keccakf1600),
             "recursive_aggregation" => Some(BlackBoxFunc::RecursiveAggregation),
             "bigint_add" => Some(BlackBoxFunc::BigIntAdd),
@@ -257,8 +212,6 @@ impl BlackBoxFunc {
             "bigint_to_le_bytes" => Some(BlackBoxFunc::BigIntToLeBytes),
             "poseidon2_permutation" => Some(BlackBoxFunc::Poseidon2Permutation),
             "sha256_compression" => Some(BlackBoxFunc::Sha256Compression),
-            "pedersen_commitment" => Some(BlackBoxFunc::PedersenCommitment),
-            "pedersen_hash" => Some(BlackBoxFunc::PedersenHash),
             _ => None,
         }
     }
diff --git a/acvm-repo/acir/src/circuit/brillig.rs b/acvm-repo/acir/src/circuit/brillig.rs
index a9714ce29b2..ef75d088f8c 100644
--- a/acvm-repo/acir/src/circuit/brillig.rs
+++ b/acvm-repo/acir/src/circuit/brillig.rs
@@ -5,7 +5,7 @@ use serde::{Deserialize, Serialize};
 
 /// Inputs for the Brillig VM. These are the initial inputs
 /// that the Brillig VM will use to start.
-#[derive(Clone, PartialEq, Eq, Serialize, Deserialize, Debug)]
+#[derive(Clone, PartialEq, Eq, Serialize, Deserialize, Debug, Hash)]
 pub enum BrilligInputs<F> {
     Single(Expression<F>),
     Array(Vec<Expression<F>>),
@@ -14,7 +14,7 @@ pub enum BrilligInputs<F> {
 
 /// Outputs for the Brillig VM. Once the VM has completed
 /// execution, this will be the object that is returned.
-#[derive(Clone, PartialEq, Eq, Serialize, Deserialize, Debug)]
+#[derive(Clone, PartialEq, Eq, Serialize, Deserialize, Debug, Hash)]
 pub enum BrilligOutputs {
     Simple(Witness),
     Array(Vec<Witness>),
@@ -23,7 +23,7 @@ pub enum BrilligOutputs {
 /// This is purely a wrapper struct around a list of Brillig opcode's which represents
 /// a full Brillig function to be executed by the Brillig VM.
 /// This is stored separately on a program and accessed through a [BrilligPointer].
-#[derive(Clone, PartialEq, Eq, Serialize, Deserialize, Default, Debug)]
+#[derive(Clone, PartialEq, Eq, Serialize, Deserialize, Default, Debug, Hash)]
 pub struct BrilligBytecode<F> {
     pub bytecode: Vec<BrilligOpcode<F>>,
 }
diff --git a/acvm-repo/acir/src/circuit/directives.rs b/acvm-repo/acir/src/circuit/directives.rs
deleted file mode 100644
index 3bc66288590..00000000000
--- a/acvm-repo/acir/src/circuit/directives.rs
+++ /dev/null
@@ -1,11 +0,0 @@
-use crate::native_types::{Expression, Witness};
-use serde::{Deserialize, Serialize};
-
-#[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize)]
-/// Directives do not apply any constraints.
-/// You can think of them as opcodes that allow one to use non-determinism
-/// In the future, this can be replaced with asm non-determinism blocks
-pub enum Directive<F> {
-    //decomposition of a: a=\sum b[i]*radix^i where b is an array of witnesses < radix in little endian form
-    ToLeRadix { a: Expression<F>, b: Vec<Witness>, radix: u32 },
-}
diff --git a/acvm-repo/acir/src/circuit/mod.rs b/acvm-repo/acir/src/circuit/mod.rs
index f700fefe0cd..4ff581bf17a 100644
--- a/acvm-repo/acir/src/circuit/mod.rs
+++ b/acvm-repo/acir/src/circuit/mod.rs
@@ -1,6 +1,5 @@
 pub mod black_box_functions;
 pub mod brillig;
-pub mod directives;
 pub mod opcodes;
 
 use crate::native_types::{Expression, Witness};
@@ -26,7 +25,7 @@ use self::{brillig::BrilligBytecode, opcodes::BlockId};
 /// Bounded Expressions are useful if you are eventually going to pass the ACIR
 /// into a proving system which supports PLONK, where arithmetic expressions have a
 /// finite fan-in.
-#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize, Default)]
+#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize, Default, Hash)]
 pub enum ExpressionWidth {
     #[default]
     Unbounded,
@@ -37,13 +36,13 @@ pub enum ExpressionWidth {
 
 /// A program represented by multiple ACIR circuits. The execution trace of these
 /// circuits is dictated by construction of the [crate::native_types::WitnessStack].
-#[derive(Clone, PartialEq, Eq, Serialize, Deserialize, Default)]
+#[derive(Clone, PartialEq, Eq, Serialize, Deserialize, Default, Hash)]
 pub struct Program<F> {
     pub functions: Vec<Circuit<F>>,
     pub unconstrained_functions: Vec<BrilligBytecode<F>>,
 }
 
-#[derive(Clone, PartialEq, Eq, Serialize, Deserialize, Default)]
+#[derive(Clone, PartialEq, Eq, Serialize, Deserialize, Default, Hash)]
 pub struct Circuit<F> {
     // current_witness_index is the highest witness index in the circuit. The next witness to be added to this circuit
     // will take on this value. (The value is cached here as an optimization.)
@@ -68,23 +67,18 @@ pub struct Circuit<F> {
     // c++ code at the moment when it is, due to OpcodeLocation needing a comparison
     // implementation which is never generated.
     pub assert_messages: Vec<(OpcodeLocation, AssertionPayload<F>)>,
-
-    /// States whether the backend should use a SNARK recursion friendly prover.
-    /// If implemented by a backend, this means that proofs generated with this circuit
-    /// will be friendly for recursively verifying inside of another SNARK.
-    pub recursive: bool,
 }
 
-#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
+#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize, Hash)]
 pub enum ExpressionOrMemory<F> {
     Expression(Expression<F>),
     Memory(BlockId),
 }
 
-#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
-pub enum AssertionPayload<F> {
-    StaticString(String),
-    Dynamic(/* error_selector */ u64, Vec<ExpressionOrMemory<F>>),
+#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize, Hash)]
+pub struct AssertionPayload<F> {
+    pub error_selector: u64,
+    pub payload: Vec<ExpressionOrMemory<F>>,
 }
 
 #[derive(Debug, Copy, PartialEq, Eq, Hash, Clone, PartialOrd, Ord)]
@@ -120,12 +114,6 @@ impl<'de> Deserialize<'de> for ErrorSelector {
     }
 }
 
-/// This selector indicates that the payload is a string.
-/// This is used to parse any error with a string payload directly,
-/// to avoid users having to parse the error externally to the ACVM.
-/// Only non-string errors need to be parsed externally to the ACVM using the circuit ABI.
-pub const STRING_ERROR_SELECTOR: ErrorSelector = ErrorSelector(0);
-
 #[derive(Clone, PartialEq, Eq, Debug, Serialize, Deserialize)]
 pub struct RawAssertionPayload<F> {
     pub selector: ErrorSelector,
@@ -367,7 +355,7 @@ impl<F: AcirField> std::fmt::Debug for Program<F> {
     }
 }
 
-#[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize, Default)]
+#[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize, Default, Hash)]
 pub struct PublicInputs(pub BTreeSet<Witness>);
 
 impl PublicInputs {
@@ -418,34 +406,16 @@ mod tests {
         Opcode::BlackBoxFuncCall(BlackBoxFuncCall::Keccakf1600 { inputs, outputs })
     }
 
-    fn schnorr_verify_opcode<F: AcirField>() -> Opcode<F> {
-        let public_key_x = FunctionInput::witness(Witness(1), FieldElement::max_num_bits());
-        let public_key_y = FunctionInput::witness(Witness(2), FieldElement::max_num_bits());
-        let signature: Box<[FunctionInput<F>; 64]> =
-            Box::new(std::array::from_fn(|i| FunctionInput::witness(Witness(i as u32 + 3), 8)));
-        let message: Vec<FunctionInput<F>> = vec![FunctionInput::witness(Witness(67), 8)];
-        let output = Witness(68);
-
-        Opcode::BlackBoxFuncCall(BlackBoxFuncCall::SchnorrVerify {
-            public_key_x,
-            public_key_y,
-            signature,
-            message,
-            output,
-        })
-    }
-
     #[test]
     fn serialization_roundtrip() {
         let circuit = Circuit {
             current_witness_index: 5,
             expression_width: ExpressionWidth::Unbounded,
-            opcodes: vec![and_opcode::<FieldElement>(), range_opcode(), schnorr_verify_opcode()],
+            opcodes: vec![and_opcode::<FieldElement>(), range_opcode()],
             private_parameters: BTreeSet::new(),
             public_parameters: PublicInputs(BTreeSet::from_iter(vec![Witness(2), Witness(12)])),
             return_values: PublicInputs(BTreeSet::from_iter(vec![Witness(4), Witness(12)])),
             assert_messages: Default::default(),
-            recursive: false,
         };
         let program = Program { functions: vec![circuit], unconstrained_functions: Vec::new() };
 
@@ -475,13 +445,11 @@ mod tests {
                 range_opcode(),
                 and_opcode(),
                 keccakf1600_opcode(),
-                schnorr_verify_opcode(),
             ],
             private_parameters: BTreeSet::new(),
             public_parameters: PublicInputs(BTreeSet::from_iter(vec![Witness(2)])),
             return_values: PublicInputs(BTreeSet::from_iter(vec![Witness(2)])),
             assert_messages: Default::default(),
-            recursive: false,
         };
         let program = Program { functions: vec![circuit], unconstrained_functions: Vec::new() };
 
diff --git a/acvm-repo/acir/src/circuit/opcodes.rs b/acvm-repo/acir/src/circuit/opcodes.rs
index 848d7bda84b..f47c40b0dd7 100644
--- a/acvm-repo/acir/src/circuit/opcodes.rs
+++ b/acvm-repo/acir/src/circuit/opcodes.rs
@@ -1,7 +1,4 @@
-use super::{
-    brillig::{BrilligFunctionId, BrilligInputs, BrilligOutputs},
-    directives::Directive,
-};
+use super::brillig::{BrilligFunctionId, BrilligInputs, BrilligOutputs};
 
 pub mod function_id;
 pub use function_id::AcirFunctionId;
@@ -18,7 +15,7 @@ pub use black_box_function_call::{
 };
 pub use memory_operation::{BlockId, MemOp};
 
-#[derive(Clone, PartialEq, Eq, Serialize, Deserialize)]
+#[derive(Clone, PartialEq, Eq, Serialize, Deserialize, Hash)]
 pub enum BlockType {
     Memory,
     CallData(u32),
@@ -32,7 +29,7 @@ impl BlockType {
 }
 
 #[allow(clippy::large_enum_variant)]
-#[derive(Clone, PartialEq, Eq, Serialize, Deserialize)]
+#[derive(Clone, PartialEq, Eq, Serialize, Deserialize, Hash)]
 pub enum Opcode<F> {
     /// An `AssertZero` opcode adds the constraint that `P(w) = 0`, where
     /// `w=(w_1,..w_n)` is a tuple of `n` witnesses, and `P` is a multi-variate
@@ -60,7 +57,7 @@ pub enum Opcode<F> {
     /// specialized constraints.
     ///
     /// Often used for exposing more efficient implementations of
-    /// SNARK-unfriendly computations.  
+    /// SNARK-unfriendly computations.
     ///
     /// All black box functions take as input a tuple `(witness, num_bits)`,
     /// where `num_bits` is a constant representing the bit size of the input
@@ -75,16 +72,6 @@ pub enum Opcode<F> {
     /// embedded curve.
     BlackBoxFuncCall(BlackBoxFuncCall<F>),
 
-    /// This opcode is a specialization of a Brillig opcode. Instead of having
-    /// some generic assembly code like Brillig, a directive has a hardcoded
-    /// name which tells the solver which computation to do: with Brillig, the
-    /// computation refers to the compiled bytecode of an unconstrained Noir
-    /// function, but with a directive, the computation is hardcoded inside the
-    /// compiler.
-    ///
-    /// Directives will be replaced by Brillig opcodes in the future.
-    Directive(Directive<F>),
-
     /// Atomic operation on a block of memory
     ///
     /// ACIR is able to address any array of witnesses. Each array is assigned
@@ -158,18 +145,6 @@ impl<F: AcirField> std::fmt::Display for Opcode<F> {
             }
 
             Opcode::BlackBoxFuncCall(g) => write!(f, "{g}"),
-            Opcode::Directive(Directive::ToLeRadix { a, b, radix: _ }) => {
-                write!(f, "DIR::TORADIX ")?;
-                write!(
-                    f,
-                    // TODO (Note): this assumes that the decomposed bits have contiguous witness indices
-                    // This should be the case, however, we can also have a function which checks this
-                    "(_{}, [_{}..._{}] )",
-                    a,
-                    b.first().unwrap().witness_index(),
-                    b.last().unwrap().witness_index(),
-                )
-            }
             Opcode::MemoryOp { block_id, op, predicate } => {
                 write!(f, "MEM ")?;
                 if let Some(pred) = predicate {
diff --git a/acvm-repo/acir/src/circuit/opcodes/black_box_function_call.rs b/acvm-repo/acir/src/circuit/opcodes/black_box_function_call.rs
index fbe179d7c04..9cf31e94eb4 100644
--- a/acvm-repo/acir/src/circuit/opcodes/black_box_function_call.rs
+++ b/acvm-repo/acir/src/circuit/opcodes/black_box_function_call.rs
@@ -1,3 +1,5 @@
+use std::collections::BTreeSet;
+
 use crate::native_types::Witness;
 use crate::{AcirField, BlackBoxFunc};
 
@@ -7,13 +9,13 @@ use thiserror::Error;
 // Note: Some functions will not use all of the witness
 // So we need to supply how many bits of the witness is needed
 
-#[derive(Clone, Copy, Debug, PartialEq, Eq, Serialize, Deserialize)]
+#[derive(Clone, Copy, Debug, PartialEq, Eq, Serialize, Deserialize, Hash)]
 pub enum ConstantOrWitnessEnum<F> {
     Constant(F),
     Witness(Witness),
 }
 
-#[derive(Clone, Copy, Debug, PartialEq, Eq, Serialize, Deserialize)]
+#[derive(Clone, Copy, Debug, PartialEq, Eq, Serialize, Deserialize, Hash)]
 pub struct FunctionInput<F> {
     input: ConstantOrWitnessEnum<F>,
     num_bits: u32,
@@ -42,6 +44,10 @@ impl<F> FunctionInput<F> {
     pub fn witness(witness: Witness, num_bits: u32) -> FunctionInput<F> {
         FunctionInput { input: ConstantOrWitnessEnum::Witness(witness), num_bits }
     }
+
+    pub fn is_constant(&self) -> bool {
+        matches!(self.input, ConstantOrWitnessEnum::Constant(_))
+    }
 }
 
 #[derive(Clone, PartialEq, Eq, Debug, Error)]
@@ -73,7 +79,7 @@ impl<F: std::fmt::Display> std::fmt::Display for FunctionInput<F> {
     }
 }
 
-#[derive(Clone, PartialEq, Eq, Serialize, Deserialize)]
+#[derive(Clone, PartialEq, Eq, Serialize, Deserialize, Hash)]
 pub enum BlackBoxFuncCall<F> {
     AES128Encrypt {
         inputs: Vec<FunctionInput<F>>,
@@ -102,29 +108,6 @@ pub enum BlackBoxFuncCall<F> {
         inputs: Vec<FunctionInput<F>>,
         outputs: Box<[Witness; 32]>,
     },
-    SchnorrVerify {
-        public_key_x: FunctionInput<F>,
-        public_key_y: FunctionInput<F>,
-        #[serde(
-            serialize_with = "serialize_big_array",
-            deserialize_with = "deserialize_big_array_into_box"
-        )]
-        signature: Box<[FunctionInput<F>; 64]>,
-        message: Vec<FunctionInput<F>>,
-        output: Witness,
-    },
-    /// Will be deprecated
-    PedersenCommitment {
-        inputs: Vec<FunctionInput<F>>,
-        domain_separator: u32,
-        outputs: (Witness, Witness),
-    },
-    /// Will be deprecated
-    PedersenHash {
-        inputs: Vec<FunctionInput<F>>,
-        domain_separator: u32,
-        output: Witness,
-    },
     EcdsaSecp256k1 {
         public_key_x: Box<[FunctionInput<F>; 32]>,
         public_key_y: Box<[FunctionInput<F>; 32]>,
@@ -157,15 +140,6 @@ pub enum BlackBoxFuncCall<F> {
         input2: Box<[FunctionInput<F>; 3]>,
         outputs: (Witness, Witness, Witness),
     },
-    Keccak256 {
-        inputs: Vec<FunctionInput<F>>,
-        /// This is the number of bytes to take
-        /// from the input. Note: if `var_message_size`
-        /// is more than the number of bytes in the input,
-        /// then an error is returned.
-        var_message_size: FunctionInput<F>,
-        outputs: Box<[Witness; 32]>,
-    },
     Keccakf1600 {
         inputs: Box<[FunctionInput<F>; 25]>,
         outputs: Box<[Witness; 25]>,
@@ -249,12 +223,10 @@ impl<F: Copy> BlackBoxFuncCall<F> {
             BlackBoxFuncCall::RANGE { .. } => BlackBoxFunc::RANGE,
             BlackBoxFuncCall::Blake2s { .. } => BlackBoxFunc::Blake2s,
             BlackBoxFuncCall::Blake3 { .. } => BlackBoxFunc::Blake3,
-            BlackBoxFuncCall::SchnorrVerify { .. } => BlackBoxFunc::SchnorrVerify,
             BlackBoxFuncCall::EcdsaSecp256k1 { .. } => BlackBoxFunc::EcdsaSecp256k1,
             BlackBoxFuncCall::EcdsaSecp256r1 { .. } => BlackBoxFunc::EcdsaSecp256r1,
             BlackBoxFuncCall::MultiScalarMul { .. } => BlackBoxFunc::MultiScalarMul,
             BlackBoxFuncCall::EmbeddedCurveAdd { .. } => BlackBoxFunc::EmbeddedCurveAdd,
-            BlackBoxFuncCall::Keccak256 { .. } => BlackBoxFunc::Keccak256,
             BlackBoxFuncCall::Keccakf1600 { .. } => BlackBoxFunc::Keccakf1600,
             BlackBoxFuncCall::RecursiveAggregation { .. } => BlackBoxFunc::RecursiveAggregation,
             BlackBoxFuncCall::BigIntAdd { .. } => BlackBoxFunc::BigIntAdd,
@@ -265,8 +237,6 @@ impl<F: Copy> BlackBoxFuncCall<F> {
             BlackBoxFuncCall::BigIntToLeBytes { .. } => BlackBoxFunc::BigIntToLeBytes,
             BlackBoxFuncCall::Poseidon2Permutation { .. } => BlackBoxFunc::Poseidon2Permutation,
             BlackBoxFuncCall::Sha256Compression { .. } => BlackBoxFunc::Sha256Compression,
-            BlackBoxFuncCall::PedersenCommitment { .. } => BlackBoxFunc::PedersenCommitment,
-            BlackBoxFuncCall::PedersenHash { .. } => BlackBoxFunc::PedersenHash,
         }
     }
 
@@ -280,8 +250,6 @@ impl<F: Copy> BlackBoxFuncCall<F> {
             | BlackBoxFuncCall::Blake2s { inputs, .. }
             | BlackBoxFuncCall::Blake3 { inputs, .. }
             | BlackBoxFuncCall::BigIntFromLeBytes { inputs, .. }
-            | BlackBoxFuncCall::PedersenCommitment { inputs, .. }
-            | BlackBoxFuncCall::PedersenHash { inputs, .. }
             | BlackBoxFuncCall::Poseidon2Permutation { inputs, .. } => inputs.to_vec(),
 
             BlackBoxFuncCall::Keccakf1600 { inputs, .. } => inputs.to_vec(),
@@ -308,21 +276,6 @@ impl<F: Copy> BlackBoxFuncCall<F> {
                 vec![input1[0], input1[1], input2[0], input2[1]]
             }
             BlackBoxFuncCall::RANGE { input } => vec![*input],
-            BlackBoxFuncCall::SchnorrVerify {
-                public_key_x,
-                public_key_y,
-                signature,
-                message,
-                ..
-            } => {
-                let mut inputs: Vec<FunctionInput<F>> =
-                    Vec::with_capacity(2 + signature.len() + message.len());
-                inputs.push(*public_key_x);
-                inputs.push(*public_key_y);
-                inputs.extend(signature.iter().copied());
-                inputs.extend(message.iter().copied());
-                inputs
-            }
             BlackBoxFuncCall::EcdsaSecp256k1 {
                 public_key_x,
                 public_key_y,
@@ -361,11 +314,6 @@ impl<F: Copy> BlackBoxFuncCall<F> {
                 inputs.extend(hashed_message.iter().copied());
                 inputs
             }
-            BlackBoxFuncCall::Keccak256 { inputs, var_message_size, .. } => {
-                let mut inputs = inputs.clone();
-                inputs.push(*var_message_size);
-                inputs
-            }
             BlackBoxFuncCall::RecursiveAggregation {
                 verification_key: key,
                 proof,
@@ -386,8 +334,7 @@ impl<F: Copy> BlackBoxFuncCall<F> {
     pub fn get_outputs_vec(&self) -> Vec<Witness> {
         match self {
             BlackBoxFuncCall::Blake2s { outputs, .. }
-            | BlackBoxFuncCall::Blake3 { outputs, .. }
-            | BlackBoxFuncCall::Keccak256 { outputs, .. } => outputs.to_vec(),
+            | BlackBoxFuncCall::Blake3 { outputs, .. } => outputs.to_vec(),
 
             BlackBoxFuncCall::Keccakf1600 { outputs, .. } => outputs.to_vec(),
 
@@ -398,11 +345,8 @@ impl<F: Copy> BlackBoxFuncCall<F> {
 
             BlackBoxFuncCall::AND { output, .. }
             | BlackBoxFuncCall::XOR { output, .. }
-            | BlackBoxFuncCall::SchnorrVerify { output, .. }
             | BlackBoxFuncCall::EcdsaSecp256k1 { output, .. }
-            | BlackBoxFuncCall::PedersenHash { output, .. }
             | BlackBoxFuncCall::EcdsaSecp256r1 { output, .. } => vec![*output],
-            BlackBoxFuncCall::PedersenCommitment { outputs, .. } => vec![outputs.0, outputs.1],
             BlackBoxFuncCall::MultiScalarMul { outputs, .. }
             | BlackBoxFuncCall::EmbeddedCurveAdd { outputs, .. } => {
                 vec![outputs.0, outputs.1, outputs.2]
@@ -419,6 +363,16 @@ impl<F: Copy> BlackBoxFuncCall<F> {
             BlackBoxFuncCall::BigIntToLeBytes { outputs, .. } => outputs.to_vec(),
         }
     }
+
+    pub fn get_input_witnesses(&self) -> BTreeSet<Witness> {
+        let mut result = BTreeSet::new();
+        for input in self.get_inputs_vec() {
+            if let ConstantOrWitnessEnum::Witness(w) = input.input() {
+                result.insert(w);
+            }
+        }
+        result
+    }
 }
 
 const ABBREVIATION_LIMIT: usize = 5;
@@ -475,14 +429,6 @@ fn get_outputs_string(outputs: &[Witness]) -> String {
 
 impl<F: std::fmt::Display + Copy> std::fmt::Display for BlackBoxFuncCall<F> {
     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
-        match self {
-            BlackBoxFuncCall::PedersenCommitment { .. } => {
-                return write!(f, "BLACKBOX::Deprecated")
-            }
-            BlackBoxFuncCall::PedersenHash { .. } => return write!(f, "BLACKBOX::Deprecated"),
-            _ => (),
-        }
-
         let uppercase_name = self.name().to_uppercase();
         write!(f, "BLACKBOX::{uppercase_name} ")?;
         // INPUTS
@@ -551,22 +497,6 @@ mod tests {
 
         Opcode::BlackBoxFuncCall(BlackBoxFuncCall::Keccakf1600 { inputs, outputs })
     }
-    fn schnorr_verify_opcode<F: AcirField>() -> Opcode<F> {
-        let public_key_x = FunctionInput::witness(Witness(1), FieldElement::max_num_bits());
-        let public_key_y = FunctionInput::witness(Witness(2), FieldElement::max_num_bits());
-        let signature: Box<[FunctionInput<F>; 64]> =
-            Box::new(std::array::from_fn(|i| FunctionInput::witness(Witness(i as u32 + 3), 8)));
-        let message: Vec<FunctionInput<F>> = vec![FunctionInput::witness(Witness(67), 8)];
-        let output = Witness(68);
-
-        Opcode::BlackBoxFuncCall(BlackBoxFuncCall::SchnorrVerify {
-            public_key_x,
-            public_key_y,
-            signature,
-            message,
-            output,
-        })
-    }
 
     #[test]
     fn keccakf1600_serialization_roundtrip() {
@@ -575,12 +505,4 @@ mod tests {
         let recovered_opcode = bincode::deserialize(&buf).unwrap();
         assert_eq!(opcode, recovered_opcode);
     }
-
-    #[test]
-    fn schnorr_serialization_roundtrip() {
-        let opcode = schnorr_verify_opcode::<FieldElement>();
-        let buf = bincode::serialize(&opcode).unwrap();
-        let recovered_opcode = bincode::deserialize(&buf).unwrap();
-        assert_eq!(opcode, recovered_opcode);
-    }
 }
diff --git a/acvm-repo/acir/src/circuit/opcodes/memory_operation.rs b/acvm-repo/acir/src/circuit/opcodes/memory_operation.rs
index 90e3ee0563a..c9a78983204 100644
--- a/acvm-repo/acir/src/circuit/opcodes/memory_operation.rs
+++ b/acvm-repo/acir/src/circuit/opcodes/memory_operation.rs
@@ -7,7 +7,7 @@ pub struct BlockId(pub u32);
 
 /// Operation on a block of memory
 /// We can either write or read at an index in memory
-#[derive(Clone, PartialEq, Eq, Serialize, Deserialize, Debug)]
+#[derive(Clone, PartialEq, Eq, Serialize, Deserialize, Debug, Hash)]
 pub struct MemOp<F> {
     /// A constant expression that can be 0 (read) or 1 (write)
     pub operation: Expression<F>,
diff --git a/acvm-repo/acir/src/lib.rs b/acvm-repo/acir/src/lib.rs
index 36331427b9f..bb5b50c0daf 100644
--- a/acvm-repo/acir/src/lib.rs
+++ b/acvm-repo/acir/src/lib.rs
@@ -35,14 +35,13 @@ mod reflection {
     use acir_field::FieldElement;
     use brillig::{
         BinaryFieldOp, BinaryIntOp, BitSize, BlackBoxOp, HeapValueType, IntegerBitSize,
-        Opcode as BrilligOpcode, ValueOrArray,
+        MemoryAddress, Opcode as BrilligOpcode, ValueOrArray,
     };
     use serde_reflection::{Tracer, TracerConfig};
 
     use crate::{
         circuit::{
             brillig::{BrilligInputs, BrilligOutputs},
-            directives::Directive,
             opcodes::{BlackBoxFuncCall, BlockType, ConstantOrWitnessEnum, FunctionInput},
             AssertionPayload, Circuit, ExpressionOrMemory, ExpressionWidth, Opcode, OpcodeLocation,
             Program,
@@ -77,13 +76,13 @@ mod reflection {
         tracer.trace_simple_type::<BrilligOpcode<FieldElement>>().unwrap();
         tracer.trace_simple_type::<BinaryIntOp>().unwrap();
         tracer.trace_simple_type::<BlackBoxOp>().unwrap();
-        tracer.trace_simple_type::<Directive<FieldElement>>().unwrap();
         tracer.trace_simple_type::<ValueOrArray>().unwrap();
         tracer.trace_simple_type::<HeapValueType>().unwrap();
         tracer.trace_simple_type::<AssertionPayload<FieldElement>>().unwrap();
         tracer.trace_simple_type::<ExpressionOrMemory<FieldElement>>().unwrap();
         tracer.trace_simple_type::<BitSize>().unwrap();
         tracer.trace_simple_type::<IntegerBitSize>().unwrap();
+        tracer.trace_simple_type::<MemoryAddress>().unwrap();
 
         let registry = tracer.registry().unwrap();
 
diff --git a/acvm-repo/acir/tests/test_program_serialization.rs b/acvm-repo/acir/tests/test_program_serialization.rs
index 6bf5afe52d9..305d94abcee 100644
--- a/acvm-repo/acir/tests/test_program_serialization.rs
+++ b/acvm-repo/acir/tests/test_program_serialization.rs
@@ -20,7 +20,9 @@ use acir::{
     native_types::{Expression, Witness},
 };
 use acir_field::{AcirField, FieldElement};
-use brillig::{BitSize, HeapArray, HeapValueType, IntegerBitSize, MemoryAddress, ValueOrArray};
+use brillig::{
+    BitSize, HeapArray, HeapValueType, HeapVector, IntegerBitSize, MemoryAddress, ValueOrArray,
+};
 
 #[test]
 fn addition_circuit() {
@@ -47,11 +49,11 @@ fn addition_circuit() {
 
     let expected_serialization: Vec<u8> = vec![
         31, 139, 8, 0, 0, 0, 0, 0, 0, 255, 173, 144, 65, 14, 128, 32, 12, 4, 65, 124, 80, 75, 91,
-        104, 111, 126, 69, 34, 252, 255, 9, 106, 228, 64, 162, 55, 153, 164, 217, 158, 38, 155,
-        245, 238, 97, 189, 206, 187, 55, 161, 231, 214, 19, 254, 129, 126, 162, 107, 25, 92, 4,
-        137, 185, 230, 88, 145, 112, 135, 104, 69, 5, 88, 74, 82, 84, 20, 149, 35, 42, 81, 85, 214,
-        108, 197, 50, 24, 50, 85, 108, 98, 212, 186, 44, 204, 235, 5, 183, 99, 233, 46, 63, 252,
-        110, 216, 56, 184, 15, 78, 146, 74, 173, 20, 141, 1, 0, 0,
+        104, 111, 126, 69, 34, 252, 255, 9, 106, 228, 64, 194, 81, 38, 105, 182, 167, 201, 102,
+        189, 251, 216, 159, 243, 110, 38, 244, 60, 122, 194, 63, 208, 47, 116, 109, 131, 139, 32,
+        49, 215, 28, 43, 18, 158, 16, 173, 168, 0, 75, 73, 138, 138, 162, 114, 69, 37, 170, 202,
+        154, 173, 88, 6, 67, 166, 138, 77, 140, 90, 151, 133, 117, 189, 224, 117, 108, 221, 229,
+        135, 223, 13, 27, 135, 121, 106, 119, 3, 58, 173, 124, 163, 140, 1, 0, 0,
     ];
 
     assert_eq!(bytes, expected_serialization)
@@ -91,67 +93,10 @@ fn multi_scalar_mul_circuit() {
     let bytes = Program::serialize_program(&program);
 
     let expected_serialization: Vec<u8> = vec![
-        31, 139, 8, 0, 0, 0, 0, 0, 0, 255, 93, 141, 11, 10, 0, 32, 8, 67, 43, 181, 15, 221, 255,
-        186, 145, 210, 130, 149, 240, 112, 234, 212, 156, 78, 12, 39, 67, 71, 158, 142, 80, 29, 44,
-        228, 66, 90, 168, 119, 189, 74, 115, 131, 174, 78, 115, 58, 124, 70, 254, 130, 59, 74, 253,
-        68, 255, 255, 221, 39, 54, 29, 134, 27, 102, 193, 0, 0, 0,
-    ];
-
-    assert_eq!(bytes, expected_serialization)
-}
-
-#[test]
-fn schnorr_verify_circuit() {
-    let public_key_x = FunctionInput::witness(Witness(1), FieldElement::max_num_bits());
-    let public_key_y = FunctionInput::witness(Witness(2), FieldElement::max_num_bits());
-    let signature: [FunctionInput<FieldElement>; 64] = (3..(3 + 64))
-        .map(|i| FunctionInput::witness(Witness(i), 8))
-        .collect::<Vec<_>>()
-        .try_into()
-        .unwrap();
-    let message =
-        ((3 + 64)..(3 + 64 + 10)).map(|i| FunctionInput::witness(Witness(i), 8)).collect();
-    let output = Witness(3 + 64 + 10);
-    let last_input = output.witness_index() - 1;
-
-    let schnorr = Opcode::BlackBoxFuncCall(BlackBoxFuncCall::SchnorrVerify {
-        public_key_x,
-        public_key_y,
-        signature: Box::new(signature),
-        message,
-        output,
-    });
-
-    let circuit: Circuit<FieldElement> = Circuit {
-        current_witness_index: 100,
-        opcodes: vec![schnorr],
-        private_parameters: BTreeSet::from_iter((1..=last_input).map(Witness)),
-        return_values: PublicInputs(BTreeSet::from([output])),
-        ..Circuit::default()
-    };
-    let program = Program { functions: vec![circuit], unconstrained_functions: vec![] };
-
-    let bytes = Program::serialize_program(&program);
-
-    let expected_serialization: Vec<u8> = vec![
-        31, 139, 8, 0, 0, 0, 0, 0, 0, 255, 85, 211, 103, 78, 2, 81, 24, 70, 225, 193, 130, 96, 239,
-        189, 96, 239, 189, 35, 34, 34, 34, 34, 238, 130, 253, 47, 129, 192, 9, 223, 36, 7, 146,
-        201, 60, 209, 31, 144, 123, 207, 155, 73, 250, 159, 118, 239, 201, 132, 121, 103, 227, 205,
-        211, 137, 247, 144, 60, 220, 123, 114, 225, 17, 121, 84, 206, 202, 99, 114, 78, 206, 203,
-        227, 242, 132, 60, 41, 79, 201, 211, 242, 140, 60, 43, 207, 201, 243, 242, 130, 188, 40,
-        47, 201, 203, 242, 138, 188, 42, 175, 201, 235, 242, 134, 188, 41, 111, 201, 219, 242, 142,
-        92, 144, 119, 229, 61, 121, 95, 62, 144, 15, 229, 35, 249, 88, 62, 145, 79, 229, 51, 249,
-        92, 190, 144, 47, 229, 43, 249, 90, 190, 145, 111, 229, 59, 249, 94, 126, 144, 31, 229, 39,
-        249, 89, 126, 145, 95, 229, 162, 252, 38, 151, 228, 119, 185, 44, 127, 200, 21, 249, 83,
-        174, 134, 233, 52, 137, 191, 125, 233, 255, 53, 249, 91, 174, 203, 63, 114, 67, 254, 149,
-        155, 242, 159, 220, 10, 255, 199, 247, 183, 244, 59, 216, 38, 155, 100, 139, 108, 144, 237,
-        165, 155, 203, 199, 111, 102, 83, 108, 137, 13, 177, 29, 54, 195, 86, 216, 8, 219, 96, 19,
-        108, 129, 13, 208, 62, 205, 211, 58, 141, 211, 54, 77, 211, 50, 13, 211, 46, 205, 22, 146,
-        126, 163, 180, 73, 147, 180, 72, 131, 180, 71, 115, 180, 70, 99, 180, 69, 83, 180, 68, 67,
-        180, 67, 51, 180, 66, 35, 180, 65, 19, 180, 64, 3, 220, 61, 119, 206, 93, 115, 199, 197,
-        184, 211, 82, 220, 97, 57, 238, 172, 18, 119, 84, 141, 187, 168, 197, 217, 215, 227, 172,
-        27, 113, 182, 205, 56, 203, 244, 204, 210, 115, 75, 116, 158, 3, 159, 46, 43, 32, 188, 53,
-        25, 5, 0, 0,
+        31, 139, 8, 0, 0, 0, 0, 0, 0, 255, 93, 77, 9, 10, 0, 48, 8, 114, 107, 231, 255, 255, 59,
+        86, 204, 64, 22, 136, 102, 89, 5, 175, 182, 163, 80, 7, 47, 135, 73, 31, 56, 228, 42, 218,
+        196, 203, 221, 38, 243, 78, 61, 28, 147, 119, 65, 31, 146, 53, 230, 210, 135, 252, 255,
+        179, 90, 23, 212, 196, 199, 187, 192, 0, 0, 0,
     ];
 
     assert_eq!(bytes, expected_serialization)
@@ -162,31 +107,37 @@ fn simple_brillig_foreign_call() {
     let w_input = Witness(1);
     let w_inverted = Witness(2);
 
+    let value_address = MemoryAddress::direct(0);
+    let zero_usize = MemoryAddress::direct(1);
+    let one_usize = MemoryAddress::direct(2);
+
     let brillig_bytecode = BrilligBytecode {
         bytecode: vec![
             brillig::Opcode::Const {
-                destination: MemoryAddress(0),
+                destination: zero_usize,
                 bit_size: BitSize::Integer(IntegerBitSize::U32),
-                value: FieldElement::from(1_usize),
+                value: FieldElement::from(0_usize),
             },
             brillig::Opcode::Const {
-                destination: MemoryAddress(1),
+                destination: one_usize,
                 bit_size: BitSize::Integer(IntegerBitSize::U32),
-                value: FieldElement::from(0_usize),
+                value: FieldElement::from(1_usize),
             },
             brillig::Opcode::CalldataCopy {
-                destination_address: MemoryAddress(0),
-                size_address: MemoryAddress(0),
-                offset_address: MemoryAddress(1),
+                destination_address: value_address,
+                size_address: one_usize,
+                offset_address: zero_usize,
             },
             brillig::Opcode::ForeignCall {
                 function: "invert".into(),
-                destinations: vec![ValueOrArray::MemoryAddress(MemoryAddress::from(0))],
+                destinations: vec![ValueOrArray::MemoryAddress(value_address)],
                 destination_value_types: vec![HeapValueType::field()],
-                inputs: vec![ValueOrArray::MemoryAddress(MemoryAddress::from(0))],
+                inputs: vec![ValueOrArray::MemoryAddress(value_address)],
                 input_value_types: vec![HeapValueType::field()],
             },
-            brillig::Opcode::Stop { return_data_offset: 0, return_data_size: 1 },
+            brillig::Opcode::Stop {
+                return_data: HeapVector { pointer: zero_usize, size: one_usize },
+            },
         ],
     };
 
@@ -214,12 +165,12 @@ fn simple_brillig_foreign_call() {
     let bytes = Program::serialize_program(&program);
 
     let expected_serialization: Vec<u8> = vec![
-        31, 139, 8, 0, 0, 0, 0, 0, 0, 255, 173, 81, 73, 10, 192, 48, 8, 140, 165, 91, 160, 183,
-        126, 196, 254, 160, 159, 233, 161, 151, 30, 74, 200, 251, 19, 136, 130, 132, 196, 75, 28,
-        16, 199, 17, 212, 65, 112, 5, 123, 14, 32, 190, 80, 230, 90, 130, 181, 155, 50, 142, 225,
-        2, 187, 89, 40, 239, 157, 106, 2, 82, 116, 138, 51, 118, 239, 171, 222, 108, 232, 218, 139,
-        125, 198, 179, 113, 83, 188, 29, 57, 86, 226, 239, 23, 159, 63, 104, 63, 238, 213, 45, 237,
-        108, 244, 18, 195, 174, 252, 193, 92, 2, 0, 0,
+        31, 139, 8, 0, 0, 0, 0, 0, 0, 255, 173, 81, 203, 10, 128, 48, 12, 179, 243, 57, 240, 230,
+        143, 108, 127, 224, 207, 120, 240, 226, 65, 196, 239, 119, 98, 11, 101, 100, 94, 214, 64,
+        73, 26, 88, 73, 24, 53, 31, 166, 52, 196, 186, 99, 150, 93, 67, 188, 149, 57, 212, 33, 146,
+        221, 173, 160, 243, 186, 92, 144, 54, 127, 138, 245, 204, 62, 243, 95, 110, 13, 195, 122,
+        144, 207, 240, 126, 28, 65, 71, 7, 250, 206, 105, 6, 214, 251, 113, 111, 231, 133, 190, 93,
+        191, 40, 237, 37, 127, 1, 190, 36, 121, 0, 128, 254, 118, 42, 127, 2, 0, 0,
     ];
 
     assert_eq!(bytes, expected_serialization)
@@ -242,55 +193,61 @@ fn complex_brillig_foreign_call() {
     let brillig_bytecode = BrilligBytecode {
         bytecode: vec![
             brillig::Opcode::Const {
-                destination: MemoryAddress(0),
+                destination: MemoryAddress::direct(0),
                 bit_size: BitSize::Integer(IntegerBitSize::U32),
                 value: FieldElement::from(3_usize),
             },
             brillig::Opcode::Const {
-                destination: MemoryAddress(1),
+                destination: MemoryAddress::direct(1),
                 bit_size: BitSize::Integer(IntegerBitSize::U32),
                 value: FieldElement::from(0_usize),
             },
             brillig::Opcode::CalldataCopy {
-                destination_address: MemoryAddress(32),
-                size_address: MemoryAddress(0),
-                offset_address: MemoryAddress(1),
+                destination_address: MemoryAddress::direct(32),
+                size_address: MemoryAddress::direct(0),
+                offset_address: MemoryAddress::direct(1),
             },
             brillig::Opcode::Const {
-                destination: MemoryAddress(0),
+                destination: MemoryAddress::direct(0),
                 value: FieldElement::from(32_usize),
                 bit_size: BitSize::Integer(IntegerBitSize::U32),
             },
             brillig::Opcode::Const {
-                destination: MemoryAddress(3),
+                destination: MemoryAddress::direct(3),
                 bit_size: BitSize::Integer(IntegerBitSize::U32),
                 value: FieldElement::from(1_usize),
             },
             brillig::Opcode::Const {
-                destination: MemoryAddress(4),
+                destination: MemoryAddress::direct(4),
                 bit_size: BitSize::Integer(IntegerBitSize::U32),
                 value: FieldElement::from(3_usize),
             },
             brillig::Opcode::CalldataCopy {
-                destination_address: MemoryAddress(1),
-                size_address: MemoryAddress(3),
-                offset_address: MemoryAddress(4),
+                destination_address: MemoryAddress::direct(1),
+                size_address: MemoryAddress::direct(3),
+                offset_address: MemoryAddress::direct(4),
             },
             // Oracles are named 'foreign calls' in brillig
             brillig::Opcode::ForeignCall {
                 function: "complex".into(),
                 inputs: vec![
-                    ValueOrArray::HeapArray(HeapArray { pointer: 0.into(), size: 3 }),
-                    ValueOrArray::MemoryAddress(MemoryAddress::from(1)),
+                    ValueOrArray::HeapArray(HeapArray {
+                        pointer: MemoryAddress::direct(0),
+                        size: 3,
+                    }),
+                    ValueOrArray::MemoryAddress(MemoryAddress::direct(1)),
                 ],
                 input_value_types: vec![
                     HeapValueType::Array { size: 3, value_types: vec![HeapValueType::field()] },
                     HeapValueType::field(),
                 ],
                 destinations: vec![
-                    ValueOrArray::HeapArray(HeapArray { pointer: 0.into(), size: 3 }),
-                    ValueOrArray::MemoryAddress(MemoryAddress::from(35)),
-                    ValueOrArray::MemoryAddress(MemoryAddress::from(36)),
+                    ValueOrArray::HeapArray(HeapArray {
+                        pointer: MemoryAddress::direct(0),
+                        size: 3,
+                    }),
+                    ValueOrArray::MemoryAddress(MemoryAddress::direct(35)),
+                    ValueOrArray::MemoryAddress(MemoryAddress::direct(36)),
                 ],
                 destination_value_types: vec![
                     HeapValueType::Array { size: 3, value_types: vec![HeapValueType::field()] },
@@ -298,7 +255,22 @@ fn complex_brillig_foreign_call() {
                     HeapValueType::field(),
                 ],
             },
-            brillig::Opcode::Stop { return_data_offset: 32, return_data_size: 5 },
+            brillig::Opcode::Const {
+                destination: MemoryAddress::direct(0),
+                bit_size: BitSize::Integer(IntegerBitSize::U32),
+                value: FieldElement::from(32_usize),
+            },
+            brillig::Opcode::Const {
+                destination: MemoryAddress::direct(1),
+                bit_size: BitSize::Integer(IntegerBitSize::U32),
+                value: FieldElement::from(5_usize),
+            },
+            brillig::Opcode::Stop {
+                return_data: HeapVector {
+                    pointer: MemoryAddress::direct(0),
+                    size: MemoryAddress::direct(1),
+                },
+            },
         ],
     };
 
@@ -338,17 +310,17 @@ fn complex_brillig_foreign_call() {
 
     let bytes = Program::serialize_program(&program);
     let expected_serialization: Vec<u8> = vec![
-        31, 139, 8, 0, 0, 0, 0, 0, 0, 255, 213, 85, 81, 14, 194, 48, 8, 133, 118, 186, 53, 241,
-        207, 11, 152, 232, 1, 58, 189, 128, 119, 49, 254, 105, 244, 211, 227, 59, 50, 154, 49, 214,
-        100, 31, 163, 201, 246, 146, 133, 174, 5, 10, 15, 72, 17, 122, 52, 221, 135, 188, 222, 177,
-        116, 44, 105, 223, 195, 24, 73, 247, 206, 50, 46, 67, 139, 118, 190, 98, 169, 24, 221, 6,
-        98, 244, 5, 98, 4, 81, 255, 21, 214, 219, 178, 46, 166, 252, 249, 204, 252, 84, 208, 207,
-        215, 158, 255, 107, 150, 141, 38, 154, 140, 28, 76, 7, 111, 132, 212, 61, 65, 201, 116, 86,
-        217, 101, 115, 11, 226, 62, 99, 223, 145, 88, 56, 205, 228, 102, 127, 239, 53, 6, 69, 184,
-        97, 78, 109, 96, 127, 37, 106, 81, 11, 126, 100, 103, 17, 14, 48, 116, 213, 227, 243, 254,
-        190, 158, 63, 175, 40, 149, 102, 132, 179, 88, 95, 212, 57, 42, 59, 109, 43, 33, 31, 140,
-        156, 46, 102, 244, 230, 124, 31, 97, 104, 141, 244, 48, 253, 1, 180, 46, 168, 159, 181, 6,
-        0, 0,
+        31, 139, 8, 0, 0, 0, 0, 0, 0, 255, 213, 85, 205, 14, 130, 48, 12, 238, 54, 20, 136, 222,
+        124, 1, 19, 125, 128, 161, 241, 238, 187, 24, 111, 26, 61, 250, 248, 178, 216, 198, 89, 26,
+        56, 216, 18, 248, 146, 165, 12, 218, 175, 255, 193, 193, 7, 85, 123, 28, 62, 23, 40, 61,
+        202, 244, 62, 192, 47, 72, 247, 140, 50, 254, 135, 198, 233, 113, 69, 171, 24, 253, 12, 98,
+        12, 6, 49, 66, 214, 255, 9, 246, 91, 179, 47, 170, 245, 11, 194, 254, 164, 221, 90, 180,
+        103, 137, 247, 18, 101, 197, 11, 157, 140, 60, 116, 23, 47, 7, 13, 207, 10, 101, 45, 124,
+        87, 76, 232, 88, 51, 191, 202, 252, 145, 138, 177, 133, 254, 124, 109, 243, 60, 68, 226,
+        15, 38, 252, 177, 33, 254, 194, 168, 79, 37, 171, 87, 158, 75, 238, 119, 13, 223, 1, 188,
+        60, 238, 207, 219, 245, 21, 4, 83, 110, 158, 176, 99, 247, 189, 80, 178, 33, 14, 66, 254,
+        159, 233, 211, 119, 130, 254, 144, 205, 88, 163, 98, 180, 18, 167, 13, 116, 65, 190, 222,
+        250, 76, 4, 233, 188, 7, 0, 0,
     ];
 
     assert_eq!(bytes, expected_serialization)
@@ -386,11 +358,11 @@ fn memory_op_circuit() {
     let bytes = Program::serialize_program(&program);
 
     let expected_serialization: Vec<u8> = vec![
-        31, 139, 8, 0, 0, 0, 0, 0, 0, 255, 213, 82, 65, 10, 0, 32, 8, 211, 180, 255, 216, 15, 250,
-        255, 171, 10, 82, 176, 232, 150, 30, 26, 200, 118, 144, 49, 135, 8, 11, 117, 14, 169, 102,
-        229, 162, 140, 78, 219, 206, 137, 174, 44, 111, 104, 217, 190, 24, 236, 75, 113, 94, 146,
-        93, 174, 252, 86, 46, 71, 223, 78, 46, 104, 129, 253, 155, 45, 60, 195, 5, 3, 89, 11, 161,
-        73, 39, 3, 0, 0,
+        31, 139, 8, 0, 0, 0, 0, 0, 0, 255, 213, 144, 75, 10, 0, 32, 8, 68, 253, 117, 31, 187, 65,
+        247, 63, 85, 65, 10, 82, 203, 116, 209, 128, 60, 221, 12, 227, 32, 108, 181, 53, 108, 187,
+        147, 140, 24, 118, 231, 169, 97, 212, 55, 245, 106, 95, 76, 246, 229, 60, 47, 173, 46, 87,
+        127, 43, 87, 178, 127, 231, 16, 148, 194, 29, 195, 11, 220, 154, 119, 139, 115, 25, 38, 3,
+        0, 0,
     ];
 
     assert_eq!(bytes, expected_serialization)
@@ -489,15 +461,15 @@ fn nested_acir_call_circuit() {
     let bytes = Program::serialize_program(&program);
 
     let expected_serialization: Vec<u8> = vec![
-        31, 139, 8, 0, 0, 0, 0, 0, 0, 255, 205, 146, 97, 10, 195, 32, 12, 133, 163, 66, 207, 147,
-        24, 173, 241, 223, 174, 50, 153, 189, 255, 17, 214, 177, 148, 57, 17, 250, 99, 14, 250,
-        224, 97, 144, 16, 146, 143, 231, 224, 45, 167, 126, 105, 217, 109, 118, 91, 248, 200, 168,
-        225, 248, 63, 107, 114, 208, 233, 104, 188, 233, 139, 191, 137, 108, 51, 139, 113, 13, 161,
-        38, 95, 137, 233, 142, 62, 23, 137, 24, 98, 89, 133, 132, 162, 196, 135, 23, 230, 42, 65,
-        82, 46, 57, 97, 166, 192, 149, 182, 152, 121, 211, 97, 110, 222, 94, 8, 13, 132, 182, 54,
-        48, 144, 235, 8, 254, 11, 22, 76, 132, 101, 231, 237, 229, 23, 189, 213, 54, 119, 15, 83,
-        212, 199, 172, 175, 191, 226, 102, 96, 140, 251, 202, 84, 13, 204, 141, 224, 25, 176, 161,
-        158, 53, 121, 144, 73, 14, 4, 0, 0,
+        31, 139, 8, 0, 0, 0, 0, 0, 0, 255, 213, 146, 81, 10, 195, 48, 8, 134, 77, 164, 247, 209,
+        152, 52, 230, 109, 87, 89, 88, 122, 255, 35, 172, 99, 41, 11, 89, 161, 15, 77, 31, 250,
+        193, 143, 34, 34, 250, 35, 194, 23, 172, 250, 48, 173, 50, 171, 44, 252, 48, 85, 176, 213,
+        143, 154, 16, 58, 182, 198, 71, 141, 116, 14, 182, 205, 44, 161, 217, 251, 18, 93, 97, 225,
+        39, 185, 148, 53, 144, 15, 121, 86, 86, 14, 26, 94, 78, 69, 138, 122, 141, 41, 167, 72,
+        137, 189, 20, 94, 66, 146, 165, 14, 195, 113, 123, 17, 52, 38, 180, 185, 129, 127, 176, 51,
+        240, 42, 175, 96, 160, 87, 118, 220, 94, 110, 170, 183, 218, 230, 238, 221, 39, 234, 191,
+        172, 207, 177, 171, 153, 155, 153, 106, 96, 236, 3, 30, 249, 181, 199, 27, 99, 149, 130,
+        253, 11, 4, 0, 0,
     ];
     assert_eq!(bytes, expected_serialization);
 }
diff --git a/acvm-repo/acir_field/Cargo.toml b/acvm-repo/acir_field/Cargo.toml
index 168628b0d4a..039aefe355e 100644
--- a/acvm-repo/acir_field/Cargo.toml
+++ b/acvm-repo/acir_field/Cargo.toml
@@ -2,7 +2,7 @@
 name = "acir_field"
 description = "The field implementation being used by ACIR."
 # x-release-please-start-version
-version = "0.50.0"
+version = "1.0.0-beta.0"
 # x-release-please-end
 authors.workspace = true
 edition.workspace = true
diff --git a/acvm-repo/acir_field/src/field_element.rs b/acvm-repo/acir_field/src/field_element.rs
index 2323f008dbe..0249b410aa7 100644
--- a/acvm-repo/acir_field/src/field_element.rs
+++ b/acvm-repo/acir_field/src/field_element.rs
@@ -8,8 +8,8 @@ use std::ops::{Add, AddAssign, Div, Mul, Neg, Sub, SubAssign};
 use crate::AcirField;
 
 // XXX: Switch out for a trait and proper implementations
-// This implementation is in-efficient, can definitely remove hex usage and Iterator instances for trivial functionality
-#[derive(Default, Clone, Copy, Eq, PartialOrd, Ord)]
+// This implementation is inefficient, can definitely remove hex usage and Iterator instances for trivial functionality
+#[derive(Default, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
 pub struct FieldElement<F: PrimeField>(F);
 
 impl<F: PrimeField> std::fmt::Display for FieldElement<F> {
@@ -33,46 +33,6 @@ impl<F: PrimeField> std::fmt::Display for FieldElement<F> {
             write!(f, "-")?;
         }
 
-        // Number of bits needed to represent the smaller representation
-        let num_bits = smaller_repr.bits();
-
-        // Check if the number represents a power of 2
-        if smaller_repr.count_ones() == 1 {
-            let mut bit_index = 0;
-            for i in 0..num_bits {
-                if smaller_repr.bit(i) {
-                    bit_index = i;
-                    break;
-                }
-            }
-            return match bit_index {
-                0 => write!(f, "1"),
-                1 => write!(f, "2"),
-                2 => write!(f, "4"),
-                3 => write!(f, "8"),
-                _ => write!(f, "2{}", superscript(bit_index)),
-            };
-        }
-
-        // Check if number is a multiple of a power of 2.
-        // This is used because when computing the quotient
-        // we usually have numbers in the form 2^t * q + r
-        // We focus on 2^64, 2^32, 2^16, 2^8, 2^4 because
-        // they are common. We could extend this to a more
-        // general factorization strategy, but we pay in terms of CPU time
-        let mul_sign = "×";
-        for power in [64, 32, 16, 8, 4] {
-            let power_of_two = BigUint::from(2_u128).pow(power);
-            if &smaller_repr % &power_of_two == BigUint::zero() {
-                return write!(
-                    f,
-                    "2{}{}{}",
-                    superscript(power as u64),
-                    mul_sign,
-                    smaller_repr / &power_of_two,
-                );
-            }
-        }
         write!(f, "{smaller_repr}")
     }
 }
@@ -83,18 +43,6 @@ impl<F: PrimeField> std::fmt::Debug for FieldElement<F> {
     }
 }
 
-impl<F: PrimeField> std::hash::Hash for FieldElement<F> {
-    fn hash<H: std::hash::Hasher>(&self, state: &mut H) {
-        state.write(&self.to_be_bytes());
-    }
-}
-
-impl<F: PrimeField> PartialEq for FieldElement<F> {
-    fn eq(&self, other: &Self) -> bool {
-        self.to_be_bytes() == other.to_be_bytes()
-    }
-}
-
 impl<F: PrimeField> From<i128> for FieldElement<F> {
     fn from(mut a: i128) -> FieldElement<F> {
         let mut negative = false;
@@ -198,23 +146,6 @@ impl<F: PrimeField> FieldElement<F> {
         let fr = F::from_str(input).ok()?;
         Some(FieldElement(fr))
     }
-
-    fn bits(&self) -> Vec<bool> {
-        fn byte_to_bit(byte: u8) -> Vec<bool> {
-            let mut bits = Vec::with_capacity(8);
-            for index in (0..=7).rev() {
-                bits.push((byte & (1 << index)) >> index == 1);
-            }
-            bits
-        }
-
-        let bytes = self.to_be_bytes();
-        let mut bits = Vec::with_capacity(bytes.len() * 8);
-        for byte in bytes {
-            bits.extend(byte_to_bit(byte));
-        }
-        bits
-    }
 }
 
 impl<F: PrimeField> AcirField for FieldElement<F> {
@@ -264,12 +195,26 @@ impl<F: PrimeField> AcirField for FieldElement<F> {
 
     /// This is the number of bits required to represent this specific field element
     fn num_bits(&self) -> u32 {
-        let bits = self.bits();
-        // Iterate the number of bits and pop off all leading zeroes
-        let iter = bits.iter().skip_while(|x| !(**x));
+        let bytes = self.to_be_bytes();
+
+        // Iterate through the byte decomposition and pop off all leading zeroes
+        let mut iter = bytes.iter().skip_while(|x| (**x) == 0);
+
+        // The first non-zero byte in the decomposition may have some leading zero-bits.
+        let Some(head_byte) = iter.next() else {
+            // If we don't have a non-zero byte then the field element is zero,
+            // which we consider to require a single bit to represent.
+            return 1;
+        };
+        let num_bits_for_head_byte = head_byte.ilog2();
+
+        // Each remaining byte in the byte decomposition requires 8 bits.
+        //
         // Note: count will panic if it goes over usize::MAX.
         // This may not be suitable for devices whose usize < u16
-        iter.count() as u32
+        let tail_length = iter.count() as u32;
+
+        8 * tail_length + num_bits_for_head_byte + 1
     }
 
     fn to_u128(self) -> u128 {
@@ -409,40 +354,35 @@ impl<F: PrimeField> SubAssign for FieldElement<F> {
     }
 }
 
-// For pretty printing powers
-fn superscript(n: u64) -> String {
-    if n == 0 {
-        "⁰".to_owned()
-    } else if n == 1 {
-        "¹".to_owned()
-    } else if n == 2 {
-        "²".to_owned()
-    } else if n == 3 {
-        "³".to_owned()
-    } else if n == 4 {
-        "⁴".to_owned()
-    } else if n == 5 {
-        "⁵".to_owned()
-    } else if n == 6 {
-        "⁶".to_owned()
-    } else if n == 7 {
-        "⁷".to_owned()
-    } else if n == 8 {
-        "⁸".to_owned()
-    } else if n == 9 {
-        "⁹".to_owned()
-    } else if n >= 10 {
-        superscript(n / 10) + &superscript(n % 10)
-    } else {
-        panic!("{}", n.to_string() + " can't be converted to superscript.");
-    }
-}
-
 #[cfg(test)]
 mod tests {
     use super::{AcirField, FieldElement};
     use proptest::prelude::*;
 
+    #[test]
+    fn requires_one_bit_to_hold_zero() {
+        let field = FieldElement::<ark_bn254::Fr>::zero();
+        assert_eq!(field.num_bits(), 1);
+    }
+
+    proptest! {
+        #[test]
+        fn num_bits_agrees_with_ilog2(num in 1u128..) {
+            let field = FieldElement::<ark_bn254::Fr>::from(num);
+            prop_assert_eq!(field.num_bits(), num.ilog2() + 1);
+        }
+    }
+
+    #[test]
+    fn test_fits_in_u128() {
+        let field = FieldElement::<ark_bn254::Fr>::from(u128::MAX);
+        assert_eq!(field.num_bits(), 128);
+        assert!(field.fits_in_u128());
+        let big_field = field + FieldElement::one();
+        assert_eq!(big_field.num_bits(), 129);
+        assert!(!big_field.fits_in_u128());
+    }
+
     #[test]
     fn serialize_fixed_test_vectors() {
         // Serialized field elements from of 0, -1, -2, -3
diff --git a/acvm-repo/acvm/Cargo.toml b/acvm-repo/acvm/Cargo.toml
index 29375a57a6e..ba01ac8ec16 100644
--- a/acvm-repo/acvm/Cargo.toml
+++ b/acvm-repo/acvm/Cargo.toml
@@ -2,7 +2,7 @@
 name = "acvm"
 description = "The virtual machine that processes ACIR given a backend/proof system."
 # x-release-please-start-version
-version = "0.50.0"
+version = "1.0.0-beta.0"
 # x-release-please-end
 authors.workspace = true
 edition.workspace = true
@@ -14,11 +14,10 @@ repository.workspace = true
 workspace = true
 
 [dependencies]
-num-bigint.workspace = true
 thiserror.workspace = true
 tracing.workspace = true
 serde.workspace = true
-
+fxhash.workspace = true
 acir.workspace = true
 brillig_vm.workspace = true
 acvm_blackbox_solver.workspace = true
@@ -26,11 +25,7 @@ acvm_blackbox_solver.workspace = true
 indexmap = "1.7.0"
 
 [features]
-bn254 = [
-    "acir/bn254",
-    "brillig_vm/bn254",
-    "acvm_blackbox_solver/bn254",
-]
+bn254 = ["acir/bn254", "brillig_vm/bn254", "acvm_blackbox_solver/bn254"]
 bls12_381 = [
     "acir/bls12_381",
     "brillig_vm/bls12_381",
@@ -38,8 +33,11 @@ bls12_381 = [
 ]
 
 [dev-dependencies]
-ark-bls12-381 = { version = "^0.4.0", default-features = false, features = ["curve"] }
+ark-bls12-381 = { version = "^0.4.0", default-features = false, features = [
+    "curve",
+] }
 ark-bn254.workspace = true
 bn254_blackbox_solver.workspace = true
 proptest.workspace = true
 zkhash = { version = "^0.2.0", default-features = false }
+num-bigint.workspace = true
diff --git a/acvm-repo/acvm/src/compiler/mod.rs b/acvm-repo/acvm/src/compiler/mod.rs
index 5ece3d19a6e..daedd77c4a0 100644
--- a/acvm-repo/acvm/src/compiler/mod.rs
+++ b/acvm-repo/acvm/src/compiler/mod.rs
@@ -7,12 +7,18 @@ use acir::{
 
 // The various passes that we can use over ACIR
 mod optimizers;
+mod simulator;
 mod transformers;
 
 pub use optimizers::optimize;
 use optimizers::optimize_internal;
-pub use transformers::transform;
+pub use simulator::CircuitSimulator;
 use transformers::transform_internal;
+pub use transformers::{transform, MIN_EXPRESSION_WIDTH};
+
+/// We need multiple passes to stabilize the output.
+/// The value was determined by running tests.
+const MAX_OPTIMIZER_PASSES: usize = 3;
 
 /// This module moves and decomposes acir opcodes. The transformation map allows consumers of this module to map
 /// metadata they had about the opcodes to the new opcode structure generated after the transformation.
@@ -26,9 +32,9 @@ impl AcirTransformationMap {
     /// Builds a map from a vector of pointers to the old acir opcodes.
     /// The index of the vector is the new opcode index.
     /// The value of the vector is the old opcode index pointed.
-    fn new(acir_opcode_positions: Vec<usize>) -> Self {
+    fn new(acir_opcode_positions: &[usize]) -> Self {
         let mut old_indices_to_new_indices = HashMap::with_capacity(acir_opcode_positions.len());
-        for (new_index, old_index) in acir_opcode_positions.into_iter().enumerate() {
+        for (new_index, old_index) in acir_opcode_positions.iter().copied().enumerate() {
             old_indices_to_new_indices.entry(old_index).or_insert_with(Vec::new).push(new_index);
         }
         AcirTransformationMap { old_indices_to_new_indices }
@@ -70,17 +76,51 @@ fn transform_assert_messages<F: Clone>(
 }
 
 /// Applies [`ProofSystemCompiler`][crate::ProofSystemCompiler] specific optimizations to a [`Circuit`].
+///
+/// Runs multiple passes until the output stabilizes.
 pub fn compile<F: AcirField>(
     acir: Circuit<F>,
     expression_width: ExpressionWidth,
 ) -> (Circuit<F>, AcirTransformationMap) {
-    let (acir, acir_opcode_positions) = optimize_internal(acir);
+    let acir_opcode_positions = (0..acir.opcodes.len()).collect::<Vec<_>>();
+
+    if MAX_OPTIMIZER_PASSES == 0 {
+        return (acir, AcirTransformationMap::new(&acir_opcode_positions));
+    }
+
+    let mut pass = 0;
+    let mut prev_opcodes_hash = fxhash::hash64(&acir.opcodes);
+    let mut prev_acir = acir;
+    let mut prev_acir_opcode_positions = acir_opcode_positions;
+
+    // For most test programs it would be enough to only loop `transform_internal`,
+    // but some of them don't stabilize unless we also repeat the backend agnostic optimizations.
+    let (mut acir, acir_opcode_positions) = loop {
+        let (acir, acir_opcode_positions) =
+            optimize_internal(prev_acir, prev_acir_opcode_positions);
 
-    let (mut acir, acir_opcode_positions) =
-        transform_internal(acir, expression_width, acir_opcode_positions);
+        // Stop if we have already done at least one transform and an extra optimization changed nothing.
+        if pass > 0 && prev_opcodes_hash == fxhash::hash64(&acir.opcodes) {
+            break (acir, acir_opcode_positions);
+        }
+
+        let (acir, acir_opcode_positions) =
+            transform_internal(acir, expression_width, acir_opcode_positions);
+
+        let opcodes_hash = fxhash::hash64(&acir.opcodes);
+
+        // Stop if the output hasn't change in this loop or we went too long.
+        if pass == MAX_OPTIMIZER_PASSES - 1 || prev_opcodes_hash == opcodes_hash {
+            break (acir, acir_opcode_positions);
+        }
 
-    let transformation_map = AcirTransformationMap::new(acir_opcode_positions);
+        pass += 1;
+        prev_acir = acir;
+        prev_opcodes_hash = opcodes_hash;
+        prev_acir_opcode_positions = acir_opcode_positions;
+    };
 
+    let transformation_map = AcirTransformationMap::new(&acir_opcode_positions);
     acir.assert_messages = transform_assert_messages(acir.assert_messages, &transformation_map);
 
     (acir, transformation_map)
diff --git a/acvm-repo/acvm/src/compiler/optimizers/constant_backpropagation.rs b/acvm-repo/acvm/src/compiler/optimizers/constant_backpropagation.rs
index 5b778f63f07..994cfc84e66 100644
--- a/acvm-repo/acvm/src/compiler/optimizers/constant_backpropagation.rs
+++ b/acvm-repo/acvm/src/compiler/optimizers/constant_backpropagation.rs
@@ -3,14 +3,13 @@ use std::collections::{BTreeMap, BTreeSet, HashMap};
 use crate::{
     compiler::optimizers::GeneralOptimizer,
     pwg::{
-        arithmetic::ExpressionSolver, blackbox::solve_range_opcode, directives::solve_directives,
-        BrilligSolver, BrilligSolverStatus,
+        arithmetic::ExpressionSolver, blackbox::solve_range_opcode, BrilligSolver,
+        BrilligSolverStatus,
     },
 };
 use acir::{
     circuit::{
         brillig::{Brillig, BrilligInputs, BrilligOutputs},
-        directives::Directive,
         opcodes::BlackBoxFuncCall,
         Circuit, Opcode,
     },
@@ -212,34 +211,6 @@ impl ConstantBackpropagationOptimizer {
                     }
                 }
 
-                Opcode::Directive(Directive::ToLeRadix { a, b, radix }) => {
-                    if b.iter().all(|output| known_witnesses.contains_key(output)) {
-                        continue;
-                    } else if b.iter().any(|witness| required_witnesses.contains(witness)) {
-                        // If one of the brillig opcode's outputs is a required witness then we can't remove the opcode. In this case we can't replace
-                        // all of the uses of this witness with the calculated constant so we'll be attempting to use an uninitialized witness.
-                        //
-                        // We then do not attempt execution of this opcode and just simplify the inputs.
-                        Opcode::Directive(Directive::ToLeRadix {
-                            a: remap_expression(&known_witnesses, a),
-                            b,
-                            radix,
-                        })
-                    } else {
-                        let directive = Directive::ToLeRadix {
-                            a: remap_expression(&known_witnesses, a),
-                            b,
-                            radix,
-                        };
-                        let result = solve_directives(&mut known_witnesses, &directive);
-
-                        match result {
-                            Ok(()) => continue,
-                            Err(_) => Opcode::Directive(directive),
-                        }
-                    }
-                }
-
                 Opcode::BlackBoxFuncCall(BlackBoxFuncCall::RANGE { input }) => {
                     if solve_range_opcode(&known_witnesses, &input).is_ok() {
                         continue;
@@ -288,7 +259,6 @@ mod tests {
             public_parameters: PublicInputs::default(),
             return_values: PublicInputs::default(),
             assert_messages: Default::default(),
-            recursive: false,
         }
     }
 
diff --git a/acvm-repo/acvm/src/compiler/optimizers/merge_expressions.rs b/acvm-repo/acvm/src/compiler/optimizers/merge_expressions.rs
new file mode 100644
index 00000000000..43e32101cc5
--- /dev/null
+++ b/acvm-repo/acvm/src/compiler/optimizers/merge_expressions.rs
@@ -0,0 +1,472 @@
+use std::collections::{BTreeMap, BTreeSet, HashMap};
+
+use acir::{
+    circuit::{
+        brillig::{BrilligInputs, BrilligOutputs},
+        opcodes::BlockId,
+        Circuit, Opcode,
+    },
+    native_types::{Expression, Witness},
+    AcirField,
+};
+
+use crate::compiler::CircuitSimulator;
+
+pub(crate) struct MergeExpressionsOptimizer<F> {
+    resolved_blocks: HashMap<BlockId, BTreeSet<Witness>>,
+    modified_gates: HashMap<usize, Opcode<F>>,
+    deleted_gates: BTreeSet<usize>,
+}
+
+impl<F: AcirField> MergeExpressionsOptimizer<F> {
+    pub(crate) fn new() -> Self {
+        MergeExpressionsOptimizer {
+            resolved_blocks: HashMap::new(),
+            modified_gates: HashMap::new(),
+            deleted_gates: BTreeSet::new(),
+        }
+    }
+    /// This pass analyzes the circuit and identifies intermediate variables that are
+    /// only used in two gates. It then merges the gate that produces the
+    /// intermediate variable into the second one that uses it
+    /// Note: This pass is only relevant for backends that can handle unlimited width
+    pub(crate) fn eliminate_intermediate_variable(
+        &mut self,
+        circuit: &Circuit<F>,
+        acir_opcode_positions: Vec<usize>,
+    ) -> (Vec<Opcode<F>>, Vec<usize>) {
+        // Initialization
+        self.modified_gates.clear();
+        self.deleted_gates.clear();
+        self.resolved_blocks.clear();
+
+        // Keep track, for each witness, of the gates that use it
+        let circuit_io: BTreeSet<Witness> =
+            circuit.circuit_arguments().union(&circuit.public_inputs().0).cloned().collect();
+
+        let mut used_witness: BTreeMap<Witness, BTreeSet<usize>> = BTreeMap::new();
+        for (i, opcode) in circuit.opcodes.iter().enumerate() {
+            let witnesses = self.witness_inputs(opcode);
+            if let Opcode::MemoryInit { block_id, .. } = opcode {
+                self.resolved_blocks.insert(*block_id, witnesses.clone());
+            }
+            for w in witnesses {
+                // We do not simplify circuit inputs and outputs
+                if !circuit_io.contains(&w) {
+                    used_witness.entry(w).or_default().insert(i);
+                }
+            }
+        }
+
+        // For each opcode, try to get a target opcode to merge with
+        for (i, opcode) in circuit.opcodes.iter().enumerate() {
+            if !matches!(opcode, Opcode::AssertZero(_)) {
+                continue;
+            }
+            if let Some(opcode) = self.get_opcode(i, circuit) {
+                let input_witnesses = self.witness_inputs(&opcode);
+                for w in input_witnesses {
+                    let Some(gates_using_w) = used_witness.get(&w) else {
+                        continue;
+                    };
+                    // We only consider witness which are used in exactly two arithmetic gates
+                    if gates_using_w.len() == 2 {
+                        let first = *gates_using_w.first().expect("gates_using_w.len == 2");
+                        let second = *gates_using_w.last().expect("gates_using_w.len == 2");
+                        let b = if second == i {
+                            first
+                        } else {
+                            // sanity check
+                            assert!(i == first);
+                            second
+                        };
+                        // Merge the opcode with smaller index into the other one
+                        // by updating modified_gates/deleted_gates/used_witness
+                        // returns false if it could not merge them
+                        let mut merge_opcodes = |op1, op2| -> bool {
+                            if op1 == op2 {
+                                return false;
+                            }
+                            let (source, target) = if op1 < op2 { (op1, op2) } else { (op2, op1) };
+                            let source_opcode = self.get_opcode(source, circuit);
+                            let target_opcode = self.get_opcode(target, circuit);
+                            if let (
+                                Some(Opcode::AssertZero(expr_use)),
+                                Some(Opcode::AssertZero(expr_define)),
+                            ) = (target_opcode, source_opcode)
+                            {
+                                if let Some(expr) =
+                                    Self::merge_expression(&expr_use, &expr_define, w)
+                                {
+                                    self.modified_gates.insert(target, Opcode::AssertZero(expr));
+                                    self.deleted_gates.insert(source);
+                                    // Update the 'used_witness' map to account for the merge.
+                                    let mut witness_list = CircuitSimulator::expr_wit(&expr_use);
+                                    witness_list.extend(CircuitSimulator::expr_wit(&expr_define));
+                                    for w2 in witness_list {
+                                        if !circuit_io.contains(&w2) {
+                                            used_witness.entry(w2).and_modify(|v| {
+                                                v.insert(target);
+                                                v.remove(&source);
+                                            });
+                                        }
+                                    }
+                                    return true;
+                                }
+                            }
+                            false
+                        };
+
+                        if merge_opcodes(b, i) {
+                            // We need to stop here and continue with the next opcode
+                            // because the merge invalidates the current opcode.
+                            break;
+                        }
+                    }
+                }
+            }
+        }
+
+        // Construct the new circuit from modified/deleted gates
+        let mut new_circuit = Vec::new();
+        let mut new_acir_opcode_positions = Vec::new();
+
+        for (i, opcode_position) in acir_opcode_positions.iter().enumerate() {
+            if let Some(op) = self.get_opcode(i, circuit) {
+                new_circuit.push(op);
+                new_acir_opcode_positions.push(*opcode_position);
+            }
+        }
+        (new_circuit, new_acir_opcode_positions)
+    }
+
+    fn brillig_input_wit(&self, input: &BrilligInputs<F>) -> BTreeSet<Witness> {
+        let mut result = BTreeSet::new();
+        match input {
+            BrilligInputs::Single(expr) => {
+                result.extend(CircuitSimulator::expr_wit(expr));
+            }
+            BrilligInputs::Array(exprs) => {
+                for expr in exprs {
+                    result.extend(CircuitSimulator::expr_wit(expr));
+                }
+            }
+            BrilligInputs::MemoryArray(block_id) => {
+                let witnesses = self.resolved_blocks.get(block_id).expect("Unknown block id");
+                result.extend(witnesses);
+            }
+        }
+        result
+    }
+
+    fn brillig_output_wit(&self, output: &BrilligOutputs) -> BTreeSet<Witness> {
+        let mut result = BTreeSet::new();
+        match output {
+            BrilligOutputs::Simple(witness) => {
+                result.insert(*witness);
+            }
+            BrilligOutputs::Array(witnesses) => {
+                result.extend(witnesses);
+            }
+        }
+        result
+    }
+
+    // Returns the input witnesses used by the opcode
+    fn witness_inputs(&self, opcode: &Opcode<F>) -> BTreeSet<Witness> {
+        match opcode {
+            Opcode::AssertZero(expr) => CircuitSimulator::expr_wit(expr),
+            Opcode::BlackBoxFuncCall(bb_func) => {
+                let mut witnesses = bb_func.get_input_witnesses();
+                witnesses.extend(bb_func.get_outputs_vec());
+
+                witnesses
+            }
+            Opcode::MemoryOp { block_id: _, op, predicate } => {
+                //index et value, et predicate
+                let mut witnesses = CircuitSimulator::expr_wit(&op.index);
+                witnesses.extend(CircuitSimulator::expr_wit(&op.value));
+                if let Some(p) = predicate {
+                    witnesses.extend(CircuitSimulator::expr_wit(p));
+                }
+                witnesses
+            }
+
+            Opcode::MemoryInit { block_id: _, init, block_type: _ } => {
+                init.iter().cloned().collect()
+            }
+            Opcode::BrilligCall { inputs, outputs, .. } => {
+                let mut witnesses = BTreeSet::new();
+                for i in inputs {
+                    witnesses.extend(self.brillig_input_wit(i));
+                }
+                for i in outputs {
+                    witnesses.extend(self.brillig_output_wit(i));
+                }
+                witnesses
+            }
+            Opcode::Call { id: _, inputs, outputs, predicate } => {
+                let mut witnesses: BTreeSet<Witness> = BTreeSet::from_iter(inputs.iter().copied());
+                witnesses.extend(outputs);
+
+                if let Some(p) = predicate {
+                    witnesses.extend(CircuitSimulator::expr_wit(p));
+                }
+                witnesses
+            }
+        }
+    }
+
+    // Merge 'expr' into 'target' via Gaussian elimination on 'w'
+    // Returns None if the expressions cannot be merged
+    fn merge_expression(
+        target: &Expression<F>,
+        expr: &Expression<F>,
+        w: Witness,
+    ) -> Option<Expression<F>> {
+        // Check that the witness is not part of multiplication terms
+        for m in &target.mul_terms {
+            if m.1 == w || m.2 == w {
+                return None;
+            }
+        }
+        for m in &expr.mul_terms {
+            if m.1 == w || m.2 == w {
+                return None;
+            }
+        }
+
+        for k in &target.linear_combinations {
+            if k.1 == w {
+                for i in &expr.linear_combinations {
+                    if i.1 == w {
+                        return Some(target.add_mul(-(k.0 / i.0), expr));
+                    }
+                }
+            }
+        }
+        None
+    }
+
+    fn get_opcode(&self, g: usize, circuit: &Circuit<F>) -> Option<Opcode<F>> {
+        if self.deleted_gates.contains(&g) {
+            return None;
+        }
+        self.modified_gates.get(&g).or(circuit.opcodes.get(g)).cloned()
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use crate::compiler::{optimizers::MergeExpressionsOptimizer, CircuitSimulator};
+    use acir::{
+        acir_field::AcirField,
+        circuit::{
+            brillig::{BrilligFunctionId, BrilligOutputs},
+            opcodes::{BlackBoxFuncCall, FunctionInput},
+            Circuit, ExpressionWidth, Opcode, PublicInputs,
+        },
+        native_types::{Expression, Witness},
+        FieldElement,
+    };
+    use std::collections::BTreeSet;
+
+    fn check_circuit(circuit: Circuit<FieldElement>) -> Circuit<FieldElement> {
+        assert!(CircuitSimulator::default().check_circuit(&circuit));
+        let mut merge_optimizer = MergeExpressionsOptimizer::new();
+        let acir_opcode_positions = vec![0; 20];
+        let (opcodes, _) =
+            merge_optimizer.eliminate_intermediate_variable(&circuit, acir_opcode_positions);
+        let mut optimized_circuit = circuit;
+        optimized_circuit.opcodes = opcodes;
+        // check that the circuit is still valid after optimization
+        assert!(CircuitSimulator::default().check_circuit(&optimized_circuit));
+        optimized_circuit
+    }
+
+    #[test]
+    fn does_not_eliminate_witnesses_returned_from_brillig() {
+        let opcodes = vec![
+            Opcode::BrilligCall {
+                id: BrilligFunctionId::default(),
+                inputs: Vec::new(),
+                outputs: vec![BrilligOutputs::Simple(Witness(1))],
+                predicate: None,
+            },
+            Opcode::AssertZero(Expression {
+                mul_terms: Vec::new(),
+                linear_combinations: vec![
+                    (FieldElement::from(2_u128), Witness(0)),
+                    (FieldElement::from(3_u128), Witness(1)),
+                    (FieldElement::from(1_u128), Witness(2)),
+                ],
+                q_c: FieldElement::one(),
+            }),
+            Opcode::AssertZero(Expression {
+                mul_terms: Vec::new(),
+                linear_combinations: vec![
+                    (FieldElement::from(2_u128), Witness(0)),
+                    (FieldElement::from(2_u128), Witness(1)),
+                    (FieldElement::from(1_u128), Witness(5)),
+                ],
+                q_c: FieldElement::one(),
+            }),
+        ];
+
+        let mut private_parameters = BTreeSet::new();
+        private_parameters.insert(Witness(0));
+
+        let circuit = Circuit {
+            current_witness_index: 1,
+            expression_width: ExpressionWidth::Bounded { width: 4 },
+            opcodes,
+            private_parameters,
+            public_parameters: PublicInputs::default(),
+            return_values: PublicInputs::default(),
+            assert_messages: Default::default(),
+        };
+        check_circuit(circuit);
+    }
+
+    #[test]
+    fn does_not_eliminate_witnesses_returned_from_circuit() {
+        let opcodes = vec![
+            Opcode::AssertZero(Expression {
+                mul_terms: vec![(FieldElement::from(-1i128), Witness(0), Witness(0))],
+                linear_combinations: vec![(FieldElement::from(1i128), Witness(1))],
+                q_c: FieldElement::zero(),
+            }),
+            Opcode::AssertZero(Expression {
+                mul_terms: Vec::new(),
+                linear_combinations: vec![
+                    (FieldElement::from(-1i128), Witness(1)),
+                    (FieldElement::from(1i128), Witness(2)),
+                ],
+                q_c: FieldElement::zero(),
+            }),
+        ];
+        // Witness(1) could be eliminated because it's only used by 2 opcodes.
+
+        let mut private_parameters = BTreeSet::new();
+        private_parameters.insert(Witness(0));
+
+        let mut return_values = BTreeSet::new();
+        return_values.insert(Witness(1));
+        return_values.insert(Witness(2));
+
+        let circuit = Circuit {
+            current_witness_index: 2,
+            expression_width: ExpressionWidth::Bounded { width: 4 },
+            opcodes,
+            private_parameters,
+            public_parameters: PublicInputs::default(),
+            return_values: PublicInputs(return_values),
+            assert_messages: Default::default(),
+        };
+
+        let mut merge_optimizer = MergeExpressionsOptimizer::new();
+        let acir_opcode_positions = vec![0; 20];
+        let (opcodes, _) =
+            merge_optimizer.eliminate_intermediate_variable(&circuit, acir_opcode_positions);
+
+        assert_eq!(opcodes.len(), 2);
+    }
+
+    #[test]
+    fn does_not_attempt_to_merge_into_previous_opcodes() {
+        let opcodes = vec![
+            Opcode::AssertZero(Expression {
+                mul_terms: vec![(FieldElement::one(), Witness(0), Witness(0))],
+                linear_combinations: vec![(-FieldElement::one(), Witness(4))],
+                q_c: FieldElement::zero(),
+            }),
+            Opcode::AssertZero(Expression {
+                mul_terms: vec![(FieldElement::one(), Witness(0), Witness(1))],
+                linear_combinations: vec![(FieldElement::one(), Witness(5))],
+                q_c: FieldElement::zero(),
+            }),
+            Opcode::AssertZero(Expression {
+                mul_terms: Vec::new(),
+                linear_combinations: vec![
+                    (-FieldElement::one(), Witness(2)),
+                    (FieldElement::one(), Witness(4)),
+                    (FieldElement::one(), Witness(5)),
+                ],
+                q_c: FieldElement::zero(),
+            }),
+            Opcode::AssertZero(Expression {
+                mul_terms: Vec::new(),
+                linear_combinations: vec![
+                    (FieldElement::one(), Witness(2)),
+                    (-FieldElement::one(), Witness(3)),
+                    (FieldElement::one(), Witness(4)),
+                    (FieldElement::one(), Witness(5)),
+                ],
+                q_c: FieldElement::zero(),
+            }),
+            Opcode::BlackBoxFuncCall(acir::circuit::opcodes::BlackBoxFuncCall::RANGE {
+                input: FunctionInput::witness(Witness(3), 32),
+            }),
+        ];
+
+        let mut private_parameters = BTreeSet::new();
+        private_parameters.insert(Witness(0));
+        private_parameters.insert(Witness(1));
+        let circuit = Circuit {
+            current_witness_index: 5,
+            expression_width: ExpressionWidth::Bounded { width: 4 },
+            opcodes,
+            private_parameters,
+            public_parameters: PublicInputs::default(),
+            return_values: PublicInputs::default(),
+            assert_messages: Default::default(),
+        };
+        check_circuit(circuit);
+    }
+
+    #[test]
+    fn takes_blackbox_opcode_outputs_into_account() {
+        // Regression test for https://github.com/noir-lang/noir/issues/6527
+        // Previously we would not track the usage of witness 4 in the output of the blackbox function.
+        // We would then merge the final two opcodes losing the check that the brillig call must match
+        // with `_0 ^ _1`.
+
+        let circuit: Circuit<FieldElement> = Circuit {
+            current_witness_index: 7,
+            opcodes: vec![
+                Opcode::BrilligCall {
+                    id: BrilligFunctionId(0),
+                    inputs: Vec::new(),
+                    outputs: vec![BrilligOutputs::Simple(Witness(3))],
+                    predicate: None,
+                },
+                Opcode::BlackBoxFuncCall(BlackBoxFuncCall::AND {
+                    lhs: FunctionInput::witness(Witness(0), 8),
+                    rhs: FunctionInput::witness(Witness(1), 8),
+                    output: Witness(4),
+                }),
+                Opcode::AssertZero(Expression {
+                    linear_combinations: vec![
+                        (FieldElement::one(), Witness(3)),
+                        (-FieldElement::one(), Witness(4)),
+                    ],
+                    ..Default::default()
+                }),
+                Opcode::AssertZero(Expression {
+                    linear_combinations: vec![
+                        (-FieldElement::one(), Witness(2)),
+                        (FieldElement::one(), Witness(4)),
+                    ],
+                    ..Default::default()
+                }),
+            ],
+            expression_width: ExpressionWidth::Bounded { width: 4 },
+            private_parameters: BTreeSet::from([Witness(0), Witness(1)]),
+            return_values: PublicInputs(BTreeSet::from([Witness(2)])),
+            ..Default::default()
+        };
+
+        let new_circuit = check_circuit(circuit.clone());
+        assert_eq!(circuit, new_circuit);
+    }
+}
diff --git a/acvm-repo/acvm/src/compiler/optimizers/mod.rs b/acvm-repo/acvm/src/compiler/optimizers/mod.rs
index e20ad97a108..3531825c709 100644
--- a/acvm-repo/acvm/src/compiler/optimizers/mod.rs
+++ b/acvm-repo/acvm/src/compiler/optimizers/mod.rs
@@ -5,10 +5,12 @@ use acir::{
 
 // mod constant_backpropagation;
 mod general;
+mod merge_expressions;
 mod redundant_range;
 mod unused_memory;
 
 pub(crate) use general::GeneralOptimizer;
+pub(crate) use merge_expressions::MergeExpressionsOptimizer;
 pub(crate) use redundant_range::RangeOptimizer;
 use tracing::info;
 
@@ -19,9 +21,13 @@ use super::{transform_assert_messages, AcirTransformationMap};
 
 /// Applies [`ProofSystemCompiler`][crate::ProofSystemCompiler] independent optimizations to a [`Circuit`].
 pub fn optimize<F: AcirField>(acir: Circuit<F>) -> (Circuit<F>, AcirTransformationMap) {
-    let (mut acir, new_opcode_positions) = optimize_internal(acir);
+    // Track original acir opcode positions throughout the transformation passes of the compilation
+    // by applying the modifications done to the circuit opcodes and also to the opcode_positions (delete and insert)
+    let acir_opcode_positions = (0..acir.opcodes.len()).collect();
+
+    let (mut acir, new_opcode_positions) = optimize_internal(acir, acir_opcode_positions);
 
-    let transformation_map = AcirTransformationMap::new(new_opcode_positions);
+    let transformation_map = AcirTransformationMap::new(&new_opcode_positions);
 
     acir.assert_messages = transform_assert_messages(acir.assert_messages, &transformation_map);
 
@@ -29,12 +35,13 @@ pub fn optimize<F: AcirField>(acir: Circuit<F>) -> (Circuit<F>, AcirTransformati
 }
 
 /// Applies [`ProofSystemCompiler`][crate::ProofSystemCompiler] independent optimizations to a [`Circuit`].
-#[tracing::instrument(level = "trace", name = "optimize_acir" skip(acir))]
-pub(super) fn optimize_internal<F: AcirField>(acir: Circuit<F>) -> (Circuit<F>, Vec<usize>) {
-    // Track original acir opcode positions throughout the transformation passes of the compilation
-    // by applying the modifications done to the circuit opcodes and also to the opcode_positions (delete and insert)
-    let acir_opcode_positions = (0..acir.opcodes.len()).collect();
-
+///
+/// Accepts an injected `acir_opcode_positions` to allow optimizations to be applied in a loop.
+#[tracing::instrument(level = "trace", name = "optimize_acir" skip(acir, acir_opcode_positions))]
+pub(super) fn optimize_internal<F: AcirField>(
+    acir: Circuit<F>,
+    acir_opcode_positions: Vec<usize>,
+) -> (Circuit<F>, Vec<usize>) {
     if acir.opcodes.len() == 1 && matches!(acir.opcodes[0], Opcode::BrilligCall { .. }) {
         info!("Program is fully unconstrained, skipping optimization pass");
         return (acir, acir_opcode_positions);
diff --git a/acvm-repo/acvm/src/compiler/optimizers/redundant_range.rs b/acvm-repo/acvm/src/compiler/optimizers/redundant_range.rs
index 3570a36a7e7..f9c715a277f 100644
--- a/acvm-repo/acvm/src/compiler/optimizers/redundant_range.rs
+++ b/acvm-repo/acvm/src/compiler/optimizers/redundant_range.rs
@@ -191,7 +191,6 @@ mod tests {
             public_parameters: PublicInputs::default(),
             return_values: PublicInputs::default(),
             assert_messages: Default::default(),
-            recursive: false,
         }
     }
 
diff --git a/acvm-repo/acvm/src/compiler/simulator.rs b/acvm-repo/acvm/src/compiler/simulator.rs
new file mode 100644
index 00000000000..893195f342a
--- /dev/null
+++ b/acvm-repo/acvm/src/compiler/simulator.rs
@@ -0,0 +1,292 @@
+use acir::{
+    circuit::{
+        brillig::{BrilligInputs, BrilligOutputs},
+        opcodes::{BlockId, FunctionInput},
+        Circuit, Opcode,
+    },
+    native_types::{Expression, Witness},
+    AcirField,
+};
+use std::collections::{BTreeSet, HashMap, HashSet};
+
+#[derive(PartialEq)]
+enum BlockStatus {
+    Initialized,
+    Used,
+}
+
+/// Simulate a symbolic solve for a circuit
+#[derive(Default)]
+pub struct CircuitSimulator {
+    /// Track the witnesses that can be solved
+    solvable_witness: HashSet<Witness>,
+
+    /// Tells whether a Memory Block is:
+    /// - Not initialized if not in the map
+    /// - Initialized if its status is Initialized in the Map
+    /// - Used, indicating that the block cannot be written anymore.
+    resolved_blocks: HashMap<BlockId, BlockStatus>,
+}
+
+impl CircuitSimulator {
+    /// Simulate a symbolic solve for a circuit by keeping track of the witnesses that can be solved.
+    /// Returns false if the circuit cannot be solved
+    #[tracing::instrument(level = "trace", skip_all)]
+    pub fn check_circuit<F: AcirField>(&mut self, circuit: &Circuit<F>) -> bool {
+        let circuit_inputs = circuit.circuit_arguments();
+        self.solvable_witness.extend(circuit_inputs.iter());
+        for op in &circuit.opcodes {
+            if !self.try_solve(op) {
+                return false;
+            }
+        }
+        true
+    }
+
+    /// Check if the Opcode can be solved, and if yes, add the solved witness to set of solvable witness
+    fn try_solve<F: AcirField>(&mut self, opcode: &Opcode<F>) -> bool {
+        let mut unresolved = HashSet::new();
+        match opcode {
+            Opcode::AssertZero(expr) => {
+                for (_, w1, w2) in &expr.mul_terms {
+                    if !self.solvable_witness.contains(w1) {
+                        if !self.solvable_witness.contains(w2) {
+                            return false;
+                        }
+                        unresolved.insert(*w1);
+                    }
+                    if !self.solvable_witness.contains(w2) && w1 != w2 {
+                        unresolved.insert(*w2);
+                    }
+                }
+                for (_, w) in &expr.linear_combinations {
+                    if !self.solvable_witness.contains(w) {
+                        unresolved.insert(*w);
+                    }
+                }
+                if unresolved.len() == 1 {
+                    self.mark_solvable(*unresolved.iter().next().unwrap());
+                    return true;
+                }
+                unresolved.is_empty()
+            }
+            Opcode::BlackBoxFuncCall(black_box_func_call) => {
+                let inputs = black_box_func_call.get_inputs_vec();
+                for input in inputs {
+                    if !self.can_solve_function_input(&input) {
+                        return false;
+                    }
+                }
+                let outputs = black_box_func_call.get_outputs_vec();
+                for output in outputs {
+                    self.mark_solvable(output);
+                }
+                true
+            }
+            Opcode::MemoryOp { block_id, op, predicate } => {
+                if !self.can_solve_expression(&op.index) {
+                    return false;
+                }
+                if let Some(predicate) = predicate {
+                    if !self.can_solve_expression(predicate) {
+                        return false;
+                    }
+                }
+                if op.operation.is_zero() {
+                    let w = op.value.to_witness().unwrap();
+                    self.mark_solvable(w);
+                    true
+                } else {
+                    if let Some(BlockStatus::Used) = self.resolved_blocks.get(block_id) {
+                        // Writing after having used the block should not be allowed
+                        return false;
+                    }
+                    self.try_solve(&Opcode::AssertZero(op.value.clone()))
+                }
+            }
+            Opcode::MemoryInit { block_id, init, .. } => {
+                for w in init {
+                    if !self.solvable_witness.contains(w) {
+                        return false;
+                    }
+                }
+                self.resolved_blocks.insert(*block_id, BlockStatus::Initialized);
+                true
+            }
+            Opcode::BrilligCall { id: _, inputs, outputs, predicate } => {
+                for input in inputs {
+                    if !self.can_solve_brillig_input(input) {
+                        return false;
+                    }
+                }
+                if let Some(predicate) = predicate {
+                    if !self.can_solve_expression(predicate) {
+                        return false;
+                    }
+                }
+                for output in outputs {
+                    match output {
+                        BrilligOutputs::Simple(w) => self.mark_solvable(*w),
+                        BrilligOutputs::Array(arr) => {
+                            for w in arr {
+                                self.mark_solvable(*w);
+                            }
+                        }
+                    }
+                }
+                true
+            }
+            Opcode::Call { id: _, inputs, outputs, predicate } => {
+                for w in inputs {
+                    if !self.solvable_witness.contains(w) {
+                        return false;
+                    }
+                }
+                if let Some(predicate) = predicate {
+                    if !self.can_solve_expression(predicate) {
+                        return false;
+                    }
+                }
+                for w in outputs {
+                    self.mark_solvable(*w);
+                }
+                true
+            }
+        }
+    }
+
+    /// Adds the witness to set of solvable witness
+    pub(crate) fn mark_solvable(&mut self, witness: Witness) {
+        self.solvable_witness.insert(witness);
+    }
+
+    pub fn can_solve_function_input<F: AcirField>(&self, input: &FunctionInput<F>) -> bool {
+        if !input.is_constant() {
+            return self.solvable_witness.contains(&input.to_witness());
+        }
+        true
+    }
+    fn can_solve_expression<F>(&self, expr: &Expression<F>) -> bool {
+        for w in Self::expr_wit(expr) {
+            if !self.solvable_witness.contains(&w) {
+                return false;
+            }
+        }
+        true
+    }
+    fn can_solve_brillig_input<F>(&mut self, input: &BrilligInputs<F>) -> bool {
+        match input {
+            BrilligInputs::Single(expr) => self.can_solve_expression(expr),
+            BrilligInputs::Array(exprs) => {
+                for expr in exprs {
+                    if !self.can_solve_expression(expr) {
+                        return false;
+                    }
+                }
+                true
+            }
+
+            BrilligInputs::MemoryArray(block_id) => match self.resolved_blocks.entry(*block_id) {
+                std::collections::hash_map::Entry::Vacant(_) => false,
+                std::collections::hash_map::Entry::Occupied(entry)
+                    if *entry.get() == BlockStatus::Used =>
+                {
+                    true
+                }
+                std::collections::hash_map::Entry::Occupied(mut entry) => {
+                    entry.insert(BlockStatus::Used);
+                    true
+                }
+            },
+        }
+    }
+
+    pub(crate) fn expr_wit<F>(expr: &Expression<F>) -> BTreeSet<Witness> {
+        let mut result = BTreeSet::new();
+        result.extend(expr.mul_terms.iter().flat_map(|i| vec![i.1, i.2]));
+        result.extend(expr.linear_combinations.iter().map(|i| i.1));
+        result
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use std::collections::BTreeSet;
+
+    use crate::compiler::CircuitSimulator;
+    use acir::{
+        acir_field::AcirField,
+        circuit::{Circuit, ExpressionWidth, Opcode, PublicInputs},
+        native_types::{Expression, Witness},
+        FieldElement,
+    };
+
+    fn test_circuit(
+        opcodes: Vec<Opcode<FieldElement>>,
+        private_parameters: BTreeSet<Witness>,
+        public_parameters: PublicInputs,
+    ) -> Circuit<FieldElement> {
+        Circuit {
+            current_witness_index: 1,
+            expression_width: ExpressionWidth::Bounded { width: 4 },
+            opcodes,
+            private_parameters,
+            public_parameters,
+            return_values: PublicInputs::default(),
+            assert_messages: Default::default(),
+        }
+    }
+
+    #[test]
+    fn reports_true_for_empty_circuit() {
+        let empty_circuit = test_circuit(vec![], BTreeSet::default(), PublicInputs::default());
+
+        assert!(CircuitSimulator::default().check_circuit(&empty_circuit));
+    }
+
+    #[test]
+    fn reports_true_for_connected_circuit() {
+        let connected_circuit = test_circuit(
+            vec![Opcode::AssertZero(Expression {
+                mul_terms: Vec::new(),
+                linear_combinations: vec![
+                    (FieldElement::one(), Witness(1)),
+                    (-FieldElement::one(), Witness(2)),
+                ],
+                q_c: FieldElement::zero(),
+            })],
+            BTreeSet::from([Witness(1)]),
+            PublicInputs::default(),
+        );
+
+        assert!(CircuitSimulator::default().check_circuit(&connected_circuit));
+    }
+
+    #[test]
+    fn reports_false_for_disconnected_circuit() {
+        let disconnected_circuit = test_circuit(
+            vec![
+                Opcode::AssertZero(Expression {
+                    mul_terms: Vec::new(),
+                    linear_combinations: vec![
+                        (FieldElement::one(), Witness(1)),
+                        (-FieldElement::one(), Witness(2)),
+                    ],
+                    q_c: FieldElement::zero(),
+                }),
+                Opcode::AssertZero(Expression {
+                    mul_terms: Vec::new(),
+                    linear_combinations: vec![
+                        (FieldElement::one(), Witness(3)),
+                        (-FieldElement::one(), Witness(4)),
+                    ],
+                    q_c: FieldElement::zero(),
+                }),
+            ],
+            BTreeSet::from([Witness(1)]),
+            PublicInputs::default(),
+        );
+
+        assert!(!CircuitSimulator::default().check_circuit(&disconnected_circuit));
+    }
+}
diff --git a/acvm-repo/acvm/src/compiler/transformers/csat.rs b/acvm-repo/acvm/src/compiler/transformers/csat.rs
index f258e0a8818..bdd6998835a 100644
--- a/acvm-repo/acvm/src/compiler/transformers/csat.rs
+++ b/acvm-repo/acvm/src/compiler/transformers/csat.rs
@@ -6,6 +6,9 @@ use acir::{
 };
 use indexmap::IndexMap;
 
+/// Minimum width accepted by the `CSatTransformer`.
+pub const MIN_EXPRESSION_WIDTH: usize = 3;
+
 /// A transformer which processes any [`Expression`]s to break them up such that they
 /// fit within the [`ProofSystemCompiler`][crate::ProofSystemCompiler]'s width.
 ///
@@ -22,9 +25,11 @@ pub(crate) struct CSatTransformer {
 }
 
 impl CSatTransformer {
-    // Configure the width for the optimizer
+    /// Create an optimizer with a given width.
+    ///
+    /// Panics if `width` is less than `MIN_EXPRESSION_WIDTH`.
     pub(crate) fn new(width: usize) -> CSatTransformer {
-        assert!(width > 2);
+        assert!(width >= MIN_EXPRESSION_WIDTH, "width has to be at least {MIN_EXPRESSION_WIDTH}");
 
         CSatTransformer { width, solvable_witness: HashSet::new() }
     }
diff --git a/acvm-repo/acvm/src/compiler/transformers/mod.rs b/acvm-repo/acvm/src/compiler/transformers/mod.rs
index 4fd8ba7883f..a499aec1b30 100644
--- a/acvm-repo/acvm/src/compiler/transformers/mod.rs
+++ b/acvm-repo/acvm/src/compiler/transformers/mod.rs
@@ -1,5 +1,10 @@
 use acir::{
-    circuit::{brillig::BrilligOutputs, directives::Directive, Circuit, ExpressionWidth, Opcode},
+    circuit::{
+        self,
+        brillig::{BrilligInputs, BrilligOutputs},
+        opcodes::{BlackBoxFuncCall, FunctionInput, MemOp},
+        Circuit, ExpressionWidth, Opcode,
+    },
     native_types::{Expression, Witness},
     AcirField,
 };
@@ -8,8 +13,12 @@ use indexmap::IndexMap;
 mod csat;
 
 pub(crate) use csat::CSatTransformer;
+pub use csat::MIN_EXPRESSION_WIDTH;
 
-use super::{transform_assert_messages, AcirTransformationMap};
+use super::{
+    optimizers::MergeExpressionsOptimizer, transform_assert_messages, AcirTransformationMap,
+    MAX_OPTIMIZER_PASSES,
+};
 
 /// Applies [`ProofSystemCompiler`][crate::ProofSystemCompiler] specific optimizations to a [`Circuit`].
 pub fn transform<F: AcirField>(
@@ -23,7 +32,7 @@ pub fn transform<F: AcirField>(
     let (mut acir, acir_opcode_positions) =
         transform_internal(acir, expression_width, acir_opcode_positions);
 
-    let transformation_map = AcirTransformationMap::new(acir_opcode_positions);
+    let transformation_map = AcirTransformationMap::new(&acir_opcode_positions);
 
     acir.assert_messages = transform_assert_messages(acir.assert_messages, &transformation_map);
 
@@ -33,9 +42,52 @@ pub fn transform<F: AcirField>(
 /// Applies [`ProofSystemCompiler`][crate::ProofSystemCompiler] specific optimizations to a [`Circuit`].
 ///
 /// Accepts an injected `acir_opcode_positions` to allow transformations to be applied directly after optimizations.
+///
+/// Does multiple passes until the output stabilizes.
 #[tracing::instrument(level = "trace", name = "transform_acir", skip(acir, acir_opcode_positions))]
 pub(super) fn transform_internal<F: AcirField>(
-    acir: Circuit<F>,
+    mut acir: Circuit<F>,
+    expression_width: ExpressionWidth,
+    mut acir_opcode_positions: Vec<usize>,
+) -> (Circuit<F>, Vec<usize>) {
+    // Allow multiple passes until we have stable output.
+    let mut prev_opcodes_hash = fxhash::hash64(&acir.opcodes);
+
+    // For most test programs it would be enough to loop here, but some of them
+    // don't stabilize unless we also repeat the backend agnostic optimizations.
+    for _ in 0..MAX_OPTIMIZER_PASSES {
+        let (new_acir, new_acir_opcode_positions) =
+            transform_internal_once(acir, expression_width, acir_opcode_positions);
+
+        acir = new_acir;
+        acir_opcode_positions = new_acir_opcode_positions;
+
+        let new_opcodes_hash = fxhash::hash64(&acir.opcodes);
+
+        if new_opcodes_hash == prev_opcodes_hash {
+            break;
+        }
+        prev_opcodes_hash = new_opcodes_hash;
+    }
+    // After the elimination of intermediate variables the `current_witness_index` is potentially higher than it needs to be,
+    // which would cause gaps if we ran the optimization a second time, making it look like new variables were added.
+    acir.current_witness_index = max_witness(&acir).witness_index();
+
+    (acir, acir_opcode_positions)
+}
+
+/// Applies [`ProofSystemCompiler`][crate::ProofSystemCompiler] specific optimizations to a [`Circuit`].
+///
+/// Accepts an injected `acir_opcode_positions` to allow transformations to be applied directly after optimizations.
+///
+/// Does a single optimization pass.
+#[tracing::instrument(
+    level = "trace",
+    name = "transform_acir_once",
+    skip(acir, acir_opcode_positions)
+)]
+fn transform_internal_once<F: AcirField>(
+    mut acir: Circuit<F>,
     expression_width: ExpressionWidth,
     acir_opcode_positions: Vec<usize>,
 ) -> (Circuit<F>, Vec<usize>) {
@@ -76,8 +128,6 @@ pub(super) fn transform_internal<F: AcirField>(
                     &mut next_witness_index,
                 );
 
-                // Update next_witness counter
-                next_witness_index += (intermediate_variables.len() - len) as u32;
                 let mut new_opcodes = Vec::new();
                 for (g, (norm, w)) in intermediate_variables.iter().skip(len) {
                     // de-normalize
@@ -101,17 +151,6 @@ pub(super) fn transform_internal<F: AcirField>(
                 new_acir_opcode_positions.push(acir_opcode_positions[index]);
                 transformed_opcodes.push(opcode);
             }
-            Opcode::Directive(ref directive) => {
-                match directive {
-                    Directive::ToLeRadix { b, .. } => {
-                        for witness in b {
-                            transformer.mark_solvable(*witness);
-                        }
-                    }
-                }
-                new_acir_opcode_positions.push(acir_opcode_positions[index]);
-                transformed_opcodes.push(opcode);
-            }
             Opcode::MemoryInit { .. } => {
                 // `MemoryInit` does not write values to the `WitnessMap`
                 new_acir_opcode_positions.push(acir_opcode_positions[index]);
@@ -158,7 +197,7 @@ pub(super) fn transform_internal<F: AcirField>(
 
     let current_witness_index = next_witness_index - 1;
 
-    let acir = Circuit {
+    acir = Circuit {
         current_witness_index,
         expression_width,
         opcodes: transformed_opcodes,
@@ -166,5 +205,267 @@ pub(super) fn transform_internal<F: AcirField>(
         ..acir
     };
 
+    let mut merge_optimizer = MergeExpressionsOptimizer::new();
+
+    let (opcodes, new_acir_opcode_positions) =
+        merge_optimizer.eliminate_intermediate_variable(&acir, new_acir_opcode_positions);
+
+    // n.b. if we do not update current_witness_index after the eliminate_intermediate_variable pass, the real index could be less.
+    acir = Circuit {
+        opcodes,
+        // The optimizer does not add new public inputs
+        ..acir
+    };
+
     (acir, new_acir_opcode_positions)
 }
+
+/// Find the witness with the highest ID in the circuit.
+fn max_witness<F: AcirField>(circuit: &Circuit<F>) -> Witness {
+    let mut witnesses = WitnessFolder::new(Witness::default(), |state, witness| {
+        *state = witness.max(*state);
+    });
+    witnesses.fold_circuit(circuit);
+    witnesses.into_state()
+}
+
+/// Fold all witnesses in a circuit.
+struct WitnessFolder<S, A> {
+    state: S,
+    accumulate: A,
+}
+
+impl<S, A> WitnessFolder<S, A>
+where
+    A: Fn(&mut S, Witness),
+{
+    /// Create the folder with some initial state and an accumulator function.
+    fn new(init: S, accumulate: A) -> Self {
+        Self { state: init, accumulate }
+    }
+
+    /// Take the accumulated state.
+    fn into_state(self) -> S {
+        self.state
+    }
+
+    /// Add all witnesses from the circuit.
+    fn fold_circuit<F: AcirField>(&mut self, circuit: &Circuit<F>) {
+        self.fold_many(circuit.private_parameters.iter());
+        self.fold_many(circuit.public_parameters.0.iter());
+        self.fold_many(circuit.return_values.0.iter());
+        for opcode in &circuit.opcodes {
+            self.fold_opcode(opcode);
+        }
+    }
+
+    /// Fold a witness into the state.
+    fn fold(&mut self, witness: Witness) {
+        (self.accumulate)(&mut self.state, witness);
+    }
+
+    /// Fold many witnesses into the state.
+    fn fold_many<'w, I: Iterator<Item = &'w Witness>>(&mut self, witnesses: I) {
+        for w in witnesses {
+            self.fold(*w);
+        }
+    }
+
+    /// Add witnesses from the opcode.
+    fn fold_opcode<F: AcirField>(&mut self, opcode: &Opcode<F>) {
+        match opcode {
+            Opcode::AssertZero(expr) => {
+                self.fold_expr(expr);
+            }
+            Opcode::BlackBoxFuncCall(call) => self.fold_blackbox(call),
+            Opcode::MemoryOp { block_id: _, op, predicate } => {
+                let MemOp { operation, index, value } = op;
+                self.fold_expr(operation);
+                self.fold_expr(index);
+                self.fold_expr(value);
+                if let Some(pred) = predicate {
+                    self.fold_expr(pred);
+                }
+            }
+            Opcode::MemoryInit { block_id: _, init, block_type: _ } => {
+                for w in init {
+                    self.fold(*w);
+                }
+            }
+            // We keep the display for a BrilligCall and circuit Call separate as they
+            // are distinct in their functionality and we should maintain this separation for debugging.
+            Opcode::BrilligCall { id: _, inputs, outputs, predicate } => {
+                if let Some(pred) = predicate {
+                    self.fold_expr(pred);
+                }
+                self.fold_brillig_inputs(inputs);
+                self.fold_brillig_outputs(outputs);
+            }
+            Opcode::Call { id: _, inputs, outputs, predicate } => {
+                if let Some(pred) = predicate {
+                    self.fold_expr(pred);
+                }
+                self.fold_many(inputs.iter());
+                self.fold_many(outputs.iter());
+            }
+        }
+    }
+
+    fn fold_expr<F: AcirField>(&mut self, expr: &Expression<F>) {
+        for i in &expr.mul_terms {
+            self.fold(i.1);
+            self.fold(i.2);
+        }
+        for i in &expr.linear_combinations {
+            self.fold(i.1);
+        }
+    }
+
+    fn fold_brillig_inputs<F: AcirField>(&mut self, inputs: &[BrilligInputs<F>]) {
+        for input in inputs {
+            match input {
+                BrilligInputs::Single(expr) => {
+                    self.fold_expr(expr);
+                }
+                BrilligInputs::Array(exprs) => {
+                    for expr in exprs {
+                        self.fold_expr(expr);
+                    }
+                }
+                BrilligInputs::MemoryArray(_) => {}
+            }
+        }
+    }
+
+    fn fold_brillig_outputs(&mut self, outputs: &[BrilligOutputs]) {
+        for output in outputs {
+            match output {
+                BrilligOutputs::Simple(w) => {
+                    self.fold(*w);
+                }
+                BrilligOutputs::Array(ws) => self.fold_many(ws.iter()),
+            }
+        }
+    }
+
+    fn fold_blackbox<F: AcirField>(&mut self, call: &BlackBoxFuncCall<F>) {
+        match call {
+            BlackBoxFuncCall::AES128Encrypt { inputs, iv, key, outputs } => {
+                self.fold_function_inputs(inputs.as_slice());
+                self.fold_function_inputs(iv.as_slice());
+                self.fold_function_inputs(key.as_slice());
+                self.fold_many(outputs.iter());
+            }
+            BlackBoxFuncCall::AND { lhs, rhs, output } => {
+                self.fold_function_input(lhs);
+                self.fold_function_input(rhs);
+                self.fold(*output);
+            }
+            BlackBoxFuncCall::XOR { lhs, rhs, output } => {
+                self.fold_function_input(lhs);
+                self.fold_function_input(rhs);
+                self.fold(*output);
+            }
+            BlackBoxFuncCall::RANGE { input } => {
+                self.fold_function_input(input);
+            }
+            BlackBoxFuncCall::Blake2s { inputs, outputs } => {
+                self.fold_function_inputs(inputs.as_slice());
+                self.fold_many(outputs.iter());
+            }
+            BlackBoxFuncCall::Blake3 { inputs, outputs } => {
+                self.fold_function_inputs(inputs.as_slice());
+                self.fold_many(outputs.iter());
+            }
+            BlackBoxFuncCall::EcdsaSecp256k1 {
+                public_key_x,
+                public_key_y,
+                signature,
+                hashed_message,
+                output,
+            } => {
+                self.fold_function_inputs(public_key_x.as_slice());
+                self.fold_function_inputs(public_key_y.as_slice());
+                self.fold_function_inputs(signature.as_slice());
+                self.fold_function_inputs(hashed_message.as_slice());
+                self.fold(*output);
+            }
+            BlackBoxFuncCall::EcdsaSecp256r1 {
+                public_key_x,
+                public_key_y,
+                signature,
+                hashed_message,
+                output,
+            } => {
+                self.fold_function_inputs(public_key_x.as_slice());
+                self.fold_function_inputs(public_key_y.as_slice());
+                self.fold_function_inputs(signature.as_slice());
+                self.fold_function_inputs(hashed_message.as_slice());
+                self.fold(*output);
+            }
+            BlackBoxFuncCall::MultiScalarMul { points, scalars, outputs } => {
+                self.fold_function_inputs(points.as_slice());
+                self.fold_function_inputs(scalars.as_slice());
+                let (x, y, i) = outputs;
+                self.fold(*x);
+                self.fold(*y);
+                self.fold(*i);
+            }
+            BlackBoxFuncCall::EmbeddedCurveAdd { input1, input2, outputs } => {
+                self.fold_function_inputs(input1.as_slice());
+                self.fold_function_inputs(input2.as_slice());
+                let (x, y, i) = outputs;
+                self.fold(*x);
+                self.fold(*y);
+                self.fold(*i);
+            }
+            BlackBoxFuncCall::Keccakf1600 { inputs, outputs } => {
+                self.fold_function_inputs(inputs.as_slice());
+                self.fold_many(outputs.iter());
+            }
+            BlackBoxFuncCall::RecursiveAggregation {
+                verification_key,
+                proof,
+                public_inputs,
+                key_hash,
+                proof_type: _,
+            } => {
+                self.fold_function_inputs(verification_key.as_slice());
+                self.fold_function_inputs(proof.as_slice());
+                self.fold_function_inputs(public_inputs.as_slice());
+                self.fold_function_input(key_hash);
+            }
+            BlackBoxFuncCall::BigIntAdd { .. }
+            | BlackBoxFuncCall::BigIntSub { .. }
+            | BlackBoxFuncCall::BigIntMul { .. }
+            | BlackBoxFuncCall::BigIntDiv { .. } => {}
+            BlackBoxFuncCall::BigIntFromLeBytes { inputs, modulus: _, output: _ } => {
+                self.fold_function_inputs(inputs.as_slice());
+            }
+            BlackBoxFuncCall::BigIntToLeBytes { input: _, outputs } => {
+                self.fold_many(outputs.iter());
+            }
+            BlackBoxFuncCall::Poseidon2Permutation { inputs, outputs, len: _ } => {
+                self.fold_function_inputs(inputs.as_slice());
+                self.fold_many(outputs.iter());
+            }
+            BlackBoxFuncCall::Sha256Compression { inputs, hash_values, outputs } => {
+                self.fold_function_inputs(inputs.as_slice());
+                self.fold_function_inputs(hash_values.as_slice());
+                self.fold_many(outputs.iter());
+            }
+        }
+    }
+
+    fn fold_function_input<F: AcirField>(&mut self, input: &FunctionInput<F>) {
+        if let circuit::opcodes::ConstantOrWitnessEnum::Witness(witness) = input.input() {
+            self.fold(witness);
+        }
+    }
+
+    fn fold_function_inputs<F: AcirField>(&mut self, inputs: &[FunctionInput<F>]) {
+        for input in inputs {
+            self.fold_function_input(input);
+        }
+    }
+}
diff --git a/acvm-repo/acvm/src/pwg/blackbox/hash.rs b/acvm-repo/acvm/src/pwg/blackbox/hash.rs
index f177cd071d0..7476b0dc2dc 100644
--- a/acvm-repo/acvm/src/pwg/blackbox/hash.rs
+++ b/acvm-repo/acvm/src/pwg/blackbox/hash.rs
@@ -49,7 +49,7 @@ fn get_hash_input<F: AcirField>(
             // in the message, then we error.
             if num_bytes_to_take > message_input.len() {
                 return Err(OpcodeResolutionError::BlackBoxFunctionFailed(
-                        acir::BlackBoxFunc::Keccak256,
+                        acir::BlackBoxFunc::Blake2s,
                         format!("the number of bytes to take from the message is more than the number of bytes in the message. {} > {}", num_bytes_to_take, message_input.len()),
                     ));
             }
diff --git a/acvm-repo/acvm/src/pwg/blackbox/mod.rs b/acvm-repo/acvm/src/pwg/blackbox/mod.rs
index 1cca14cc680..5137b18179b 100644
--- a/acvm-repo/acvm/src/pwg/blackbox/mod.rs
+++ b/acvm-repo/acvm/src/pwg/blackbox/mod.rs
@@ -3,7 +3,7 @@ use acir::{
     native_types::{Witness, WitnessMap},
     AcirField,
 };
-use acvm_blackbox_solver::{blake2s, blake3, keccak256, keccakf1600};
+use acvm_blackbox_solver::{blake2s, blake3, keccakf1600};
 
 use self::{
     aes128::solve_aes128_encryption_opcode, bigint::AcvmBigIntSolver,
@@ -18,7 +18,6 @@ pub(crate) mod bigint;
 mod embedded_curve_ops;
 mod hash;
 mod logic;
-mod pedersen;
 mod range;
 mod signature;
 pub(crate) mod utils;
@@ -27,12 +26,8 @@ use embedded_curve_ops::{embedded_curve_add, multi_scalar_mul};
 // Hash functions should eventually be exposed for external consumers.
 use hash::{solve_generic_256_hash_opcode, solve_sha_256_permutation_opcode};
 use logic::{and, xor};
-use pedersen::{pedersen, pedersen_hash};
 pub(crate) use range::solve_range_opcode;
-use signature::{
-    ecdsa::{secp256k1_prehashed, secp256r1_prehashed},
-    schnorr::schnorr_verify,
-};
+use signature::ecdsa::{secp256k1_prehashed, secp256r1_prehashed};
 
 /// Check if all of the inputs to the function have assignments
 ///
@@ -90,16 +85,6 @@ pub(crate) fn solve<F: AcirField>(
         BlackBoxFuncCall::Blake3 { inputs, outputs } => {
             solve_generic_256_hash_opcode(initial_witness, inputs, None, outputs, blake3)
         }
-
-        BlackBoxFuncCall::Keccak256 { inputs, var_message_size, outputs } => {
-            solve_generic_256_hash_opcode(
-                initial_witness,
-                inputs,
-                Some(var_message_size),
-                outputs,
-                keccak256,
-            )
-        }
         BlackBoxFuncCall::Keccakf1600 { inputs, outputs } => {
             let mut state = [0; 25];
             for (it, input) in state.iter_mut().zip(inputs.as_ref()) {
@@ -115,27 +100,6 @@ pub(crate) fn solve<F: AcirField>(
             }
             Ok(())
         }
-        BlackBoxFuncCall::SchnorrVerify {
-            public_key_x,
-            public_key_y,
-            signature,
-            message,
-            output,
-        } => schnorr_verify(
-            backend,
-            initial_witness,
-            *public_key_x,
-            *public_key_y,
-            signature.as_ref(),
-            message,
-            *output,
-        ),
-        BlackBoxFuncCall::PedersenCommitment { inputs, domain_separator, outputs } => {
-            pedersen(backend, initial_witness, inputs, *domain_separator, *outputs)
-        }
-        BlackBoxFuncCall::PedersenHash { inputs, domain_separator, output } => {
-            pedersen_hash(backend, initial_witness, inputs, *domain_separator, *output)
-        }
         BlackBoxFuncCall::EcdsaSecp256k1 {
             public_key_x,
             public_key_y,
diff --git a/acvm-repo/acvm/src/pwg/blackbox/pedersen.rs b/acvm-repo/acvm/src/pwg/blackbox/pedersen.rs
deleted file mode 100644
index 654814bf92d..00000000000
--- a/acvm-repo/acvm/src/pwg/blackbox/pedersen.rs
+++ /dev/null
@@ -1,47 +0,0 @@
-use acir::{
-    circuit::opcodes::FunctionInput,
-    native_types::{Witness, WitnessMap},
-    AcirField,
-};
-
-use crate::{
-    pwg::{input_to_value, insert_value, OpcodeResolutionError},
-    BlackBoxFunctionSolver,
-};
-
-pub(super) fn pedersen<F: AcirField>(
-    backend: &impl BlackBoxFunctionSolver<F>,
-    initial_witness: &mut WitnessMap<F>,
-    inputs: &[FunctionInput<F>],
-    domain_separator: u32,
-    outputs: (Witness, Witness),
-) -> Result<(), OpcodeResolutionError<F>> {
-    let scalars: Result<Vec<_>, _> =
-        inputs.iter().map(|input| input_to_value(initial_witness, *input, false)).collect();
-    let scalars: Vec<_> = scalars?.into_iter().collect();
-
-    let (res_x, res_y) = backend.pedersen_commitment(&scalars, domain_separator)?;
-
-    insert_value(&outputs.0, res_x, initial_witness)?;
-    insert_value(&outputs.1, res_y, initial_witness)?;
-
-    Ok(())
-}
-
-pub(super) fn pedersen_hash<F: AcirField>(
-    backend: &impl BlackBoxFunctionSolver<F>,
-    initial_witness: &mut WitnessMap<F>,
-    inputs: &[FunctionInput<F>],
-    domain_separator: u32,
-    output: Witness,
-) -> Result<(), OpcodeResolutionError<F>> {
-    let scalars: Result<Vec<_>, _> =
-        inputs.iter().map(|input| input_to_value(initial_witness, *input, false)).collect();
-    let scalars: Vec<_> = scalars?.into_iter().collect();
-
-    let res = backend.pedersen_hash(&scalars, domain_separator)?;
-
-    insert_value(&output, res, initial_witness)?;
-
-    Ok(())
-}
diff --git a/acvm-repo/acvm/src/pwg/blackbox/signature/mod.rs b/acvm-repo/acvm/src/pwg/blackbox/signature/mod.rs
index 0cfb96740b8..b36ff499c6a 100644
--- a/acvm-repo/acvm/src/pwg/blackbox/signature/mod.rs
+++ b/acvm-repo/acvm/src/pwg/blackbox/signature/mod.rs
@@ -1,2 +1 @@
 pub(super) mod ecdsa;
-pub(super) mod schnorr;
diff --git a/acvm-repo/acvm/src/pwg/blackbox/signature/schnorr.rs b/acvm-repo/acvm/src/pwg/blackbox/signature/schnorr.rs
deleted file mode 100644
index a856303d065..00000000000
--- a/acvm-repo/acvm/src/pwg/blackbox/signature/schnorr.rs
+++ /dev/null
@@ -1,36 +0,0 @@
-use crate::{
-    pwg::{
-        blackbox::utils::{to_u8_array, to_u8_vec},
-        input_to_value, insert_value, OpcodeResolutionError,
-    },
-    BlackBoxFunctionSolver,
-};
-use acir::{
-    circuit::opcodes::FunctionInput,
-    native_types::{Witness, WitnessMap},
-    AcirField,
-};
-
-#[allow(clippy::too_many_arguments)]
-pub(crate) fn schnorr_verify<F: AcirField>(
-    backend: &impl BlackBoxFunctionSolver<F>,
-    initial_witness: &mut WitnessMap<F>,
-    public_key_x: FunctionInput<F>,
-    public_key_y: FunctionInput<F>,
-    signature: &[FunctionInput<F>; 64],
-    message: &[FunctionInput<F>],
-    output: Witness,
-) -> Result<(), OpcodeResolutionError<F>> {
-    let public_key_x: &F = &input_to_value(initial_witness, public_key_x, false)?;
-    let public_key_y: &F = &input_to_value(initial_witness, public_key_y, false)?;
-
-    let signature = to_u8_array(initial_witness, signature)?;
-    let message = to_u8_vec(initial_witness, message)?;
-
-    let valid_signature =
-        backend.schnorr_verify(public_key_x, public_key_y, &signature, &message)?;
-
-    insert_value(&output, F::from(valid_signature), initial_witness)?;
-
-    Ok(())
-}
diff --git a/acvm-repo/acvm/src/pwg/brillig.rs b/acvm-repo/acvm/src/pwg/brillig.rs
index 5ec3224dbaa..a5f5783478e 100644
--- a/acvm-repo/acvm/src/pwg/brillig.rs
+++ b/acvm-repo/acvm/src/pwg/brillig.rs
@@ -6,13 +6,12 @@ use acir::{
         brillig::{BrilligFunctionId, BrilligInputs, BrilligOutputs},
         opcodes::BlockId,
         ErrorSelector, OpcodeLocation, RawAssertionPayload, ResolvedAssertionPayload,
-        STRING_ERROR_SELECTOR,
     },
     native_types::WitnessMap,
     AcirField,
 };
 use acvm_blackbox_solver::BlackBoxFunctionSolver;
-use brillig_vm::{FailureReason, MemoryValue, VMStatus, VM};
+use brillig_vm::{BrilligProfilingSamples, FailureReason, MemoryValue, VMStatus, VM};
 use serde::{Deserialize, Serialize};
 
 use crate::{pwg::OpcodeNotSolvable, OpcodeResolutionError};
@@ -58,6 +57,7 @@ impl<'b, B: BlackBoxFunctionSolver<F>, F: AcirField> BrilligSolver<'b, F, B> {
 
     /// Constructs a solver for a Brillig block given the bytecode and initial
     /// witness.
+    #[allow(clippy::too_many_arguments)]
     pub(crate) fn new_call(
         initial_witness: &WitnessMap<F>,
         memory: &HashMap<BlockId, MemoryOpSolver<F>>,
@@ -66,9 +66,16 @@ impl<'b, B: BlackBoxFunctionSolver<F>, F: AcirField> BrilligSolver<'b, F, B> {
         bb_solver: &'b B,
         acir_index: usize,
         brillig_function_id: BrilligFunctionId,
+        profiling_active: bool,
     ) -> Result<Self, OpcodeResolutionError<F>> {
-        let vm =
-            Self::setup_brillig_vm(initial_witness, memory, inputs, brillig_bytecode, bb_solver)?;
+        let vm = Self::setup_brillig_vm(
+            initial_witness,
+            memory,
+            inputs,
+            brillig_bytecode,
+            bb_solver,
+            profiling_active,
+        )?;
         Ok(Self { vm, acir_index, function_id: brillig_function_id })
     }
 
@@ -78,6 +85,7 @@ impl<'b, B: BlackBoxFunctionSolver<F>, F: AcirField> BrilligSolver<'b, F, B> {
         inputs: &[BrilligInputs<F>],
         brillig_bytecode: &'b [BrilligOpcode<F>],
         bb_solver: &'b B,
+        profiling_active: bool,
     ) -> Result<VM<'b, F, B>, OpcodeResolutionError<F>> {
         // Set input values
         let mut calldata: Vec<F> = Vec::new();
@@ -125,7 +133,7 @@ impl<'b, B: BlackBoxFunctionSolver<F>, F: AcirField> BrilligSolver<'b, F, B> {
 
         // Instantiate a Brillig VM given the solved calldata
         // along with the Brillig bytecode.
-        let vm = VM::new(calldata, brillig_bytecode, vec![], bb_solver);
+        let vm = VM::new(calldata, brillig_bytecode, vec![], bb_solver, profiling_active);
         Ok(vm)
     }
 
@@ -203,6 +211,25 @@ impl<'b, B: BlackBoxFunctionSolver<F>, F: AcirField> BrilligSolver<'b, F, B> {
         self,
         witness: &mut WitnessMap<F>,
         outputs: &[BrilligOutputs],
+    ) -> Result<(), OpcodeResolutionError<F>> {
+        assert!(!self.vm.is_profiling_active(), "Expected VM profiling to not be active");
+        self.finalize_inner(witness, outputs)
+    }
+
+    pub(crate) fn finalize_with_profiling(
+        mut self,
+        witness: &mut WitnessMap<F>,
+        outputs: &[BrilligOutputs],
+    ) -> Result<BrilligProfilingSamples, OpcodeResolutionError<F>> {
+        assert!(self.vm.is_profiling_active(), "Expected VM profiling to be active");
+        self.finalize_inner(witness, outputs)?;
+        Ok(self.vm.take_profiling_samples())
+    }
+
+    fn finalize_inner(
+        &self,
+        witness: &mut WitnessMap<F>,
+        outputs: &[BrilligOutputs],
     ) -> Result<(), OpcodeResolutionError<F>> {
         // Finish the Brillig execution by writing the outputs to the witness map
         let vm_status = self.vm.get_status();
@@ -279,25 +306,10 @@ fn extract_failure_payload_from_memory<F: AcirField>(
                 .expect("Error selector is not u64"),
         );
 
-        match error_selector {
-            STRING_ERROR_SELECTOR => {
-                // If the error selector is 0, it means the error is a string
-                let string = revert_values_iter
-                    .map(|&memory_value| {
-                        let as_u8: u8 = memory_value.try_into().expect("String item is not u8");
-                        as_u8 as char
-                    })
-                    .collect();
-                Some(ResolvedAssertionPayload::String(string))
-            }
-            _ => {
-                // If the error selector is not 0, it means the error is a custom error
-                Some(ResolvedAssertionPayload::Raw(RawAssertionPayload {
-                    selector: error_selector,
-                    data: revert_values_iter.map(|value| value.to_field()).collect(),
-                }))
-            }
-        }
+        Some(ResolvedAssertionPayload::Raw(RawAssertionPayload {
+            selector: error_selector,
+            data: revert_values_iter.map(|value| value.to_field()).collect(),
+        }))
     }
 }
 
diff --git a/acvm-repo/acvm/src/pwg/directives/mod.rs b/acvm-repo/acvm/src/pwg/directives/mod.rs
deleted file mode 100644
index d7bee88c278..00000000000
--- a/acvm-repo/acvm/src/pwg/directives/mod.rs
+++ /dev/null
@@ -1,49 +0,0 @@
-use acir::{circuit::directives::Directive, native_types::WitnessMap, AcirField};
-use num_bigint::BigUint;
-
-use crate::OpcodeResolutionError;
-
-use super::{get_value, insert_value, ErrorLocation};
-
-/// Attempts to solve the [`Directive`] opcode `directive`.
-/// If successful, `initial_witness` will be mutated to contain the new witness assignment.
-///
-/// Returns `Ok(OpcodeResolution)` to signal whether the directive was successful solved.
-///
-/// Returns `Err(OpcodeResolutionError)` if a circuit constraint is unsatisfied.
-pub(crate) fn solve_directives<F: AcirField>(
-    initial_witness: &mut WitnessMap<F>,
-    directive: &Directive<F>,
-) -> Result<(), OpcodeResolutionError<F>> {
-    match directive {
-        Directive::ToLeRadix { a, b, radix } => {
-            let value_a = get_value(a, initial_witness)?;
-            let big_integer = BigUint::from_bytes_be(&value_a.to_be_bytes());
-
-            // Decompose the integer into its radix digits in little endian form.
-            let decomposed_integer = big_integer.to_radix_le(*radix);
-
-            if b.len() < decomposed_integer.len() {
-                return Err(OpcodeResolutionError::UnsatisfiedConstrain {
-                    opcode_location: ErrorLocation::Unresolved,
-                    payload: None,
-                });
-            }
-
-            for (i, witness) in b.iter().enumerate() {
-                // Fetch the `i'th` digit from the decomposed integer list
-                // and convert it to a field element.
-                // If it is not available, which can happen when the decomposed integer
-                // list is shorter than the witness list, we return 0.
-                let value = match decomposed_integer.get(i) {
-                    Some(digit) => F::from_be_bytes_reduce(&[*digit]),
-                    None => F::zero(),
-                };
-
-                insert_value(witness, value, initial_witness)?;
-            }
-
-            Ok(())
-        }
-    }
-}
diff --git a/acvm-repo/acvm/src/pwg/mod.rs b/acvm-repo/acvm/src/pwg/mod.rs
index c73893ceea6..f9188cca700 100644
--- a/acvm-repo/acvm/src/pwg/mod.rs
+++ b/acvm-repo/acvm/src/pwg/mod.rs
@@ -10,7 +10,7 @@ use acir::{
             AcirFunctionId, BlockId, ConstantOrWitnessEnum, FunctionInput, InvalidInputBitSize,
         },
         AssertionPayload, ErrorSelector, ExpressionOrMemory, Opcode, OpcodeLocation,
-        RawAssertionPayload, ResolvedAssertionPayload, STRING_ERROR_SELECTOR,
+        RawAssertionPayload, ResolvedAssertionPayload,
     },
     native_types::{Expression, Witness, WitnessMap},
     AcirField, BlackBoxFunc,
@@ -18,8 +18,7 @@ use acir::{
 use acvm_blackbox_solver::BlackBoxResolutionError;
 
 use self::{
-    arithmetic::ExpressionSolver, blackbox::bigint::AcvmBigIntSolver, directives::solve_directives,
-    memory_op::MemoryOpSolver,
+    arithmetic::ExpressionSolver, blackbox::bigint::AcvmBigIntSolver, memory_op::MemoryOpSolver,
 };
 use crate::BlackBoxFunctionSolver;
 
@@ -29,8 +28,6 @@ use thiserror::Error;
 pub(crate) mod arithmetic;
 // Brillig bytecode
 pub(crate) mod brillig;
-// Directives
-pub(crate) mod directives;
 // black box functions
 pub(crate) mod blackbox;
 mod memory_op;
@@ -168,6 +165,14 @@ impl<F> From<InvalidInputBitSize> for OpcodeResolutionError<F> {
     }
 }
 
+pub type ProfilingSamples = Vec<ProfilingSample>;
+
+#[derive(Default)]
+pub struct ProfilingSample {
+    pub call_stack: Vec<OpcodeLocation>,
+    pub brillig_function_id: Option<BrilligFunctionId>,
+}
+
 pub struct ACVM<'a, F, B: BlackBoxFunctionSolver<F>> {
     status: ACVMStatus<F>,
 
@@ -198,6 +203,10 @@ pub struct ACVM<'a, F, B: BlackBoxFunctionSolver<F>> {
     unconstrained_functions: &'a [BrilligBytecode<F>],
 
     assertion_payloads: &'a [(OpcodeLocation, AssertionPayload<F>)],
+
+    profiling_active: bool,
+
+    profiling_samples: ProfilingSamples,
 }
 
 impl<'a, F: AcirField, B: BlackBoxFunctionSolver<F>> ACVM<'a, F, B> {
@@ -222,9 +231,16 @@ impl<'a, F: AcirField, B: BlackBoxFunctionSolver<F>> ACVM<'a, F, B> {
             acir_call_results: Vec::default(),
             unconstrained_functions,
             assertion_payloads,
+            profiling_active: false,
+            profiling_samples: Vec::new(),
         }
     }
 
+    // Enable profiling
+    pub fn with_profiler(&mut self, profiling_active: bool) {
+        self.profiling_active = profiling_active;
+    }
+
     /// Returns a reference to the current state of the ACVM's [`WitnessMap`].
     ///
     /// Once execution has completed, the witness map can be extracted using [`ACVM::finalize`]
@@ -246,6 +262,10 @@ impl<'a, F: AcirField, B: BlackBoxFunctionSolver<F>> ACVM<'a, F, B> {
         self.instruction_pointer
     }
 
+    pub fn take_profiling_samples(&mut self) -> ProfilingSamples {
+        std::mem::take(&mut self.profiling_samples)
+    }
+
     /// Finalize the ACVM execution, returning the resulting [`WitnessMap`].
     pub fn finalize(self) -> WitnessMap<F> {
         if self.status != ACVMStatus::Solved {
@@ -339,7 +359,6 @@ impl<'a, F: AcirField, B: BlackBoxFunctionSolver<F>> ACVM<'a, F, B> {
 
     pub fn solve_opcode(&mut self) -> ACVMStatus<F> {
         let opcode = &self.opcodes[self.instruction_pointer];
-
         let resolution = match opcode {
             Opcode::AssertZero(expr) => ExpressionSolver::solve(&mut self.witness_map, expr),
             Opcode::BlackBoxFuncCall(bb_func) => blackbox::solve(
@@ -348,7 +367,6 @@ impl<'a, F: AcirField, B: BlackBoxFunctionSolver<F>> ACVM<'a, F, B> {
                 bb_func,
                 &mut self.bigint_solver,
             ),
-            Opcode::Directive(directive) => solve_directives(&mut self.witness_map, directive),
             Opcode::MemoryInit { block_id, init, .. } => {
                 let solver = self.block_solvers.entry(*block_id).or_default();
                 solver.init(init, &self.witness_map)
@@ -422,59 +440,32 @@ impl<'a, F: AcirField, B: BlackBoxFunctionSolver<F>> ACVM<'a, F, B> {
         &self,
         location: OpcodeLocation,
     ) -> Option<ResolvedAssertionPayload<F>> {
-        let (_, found_assertion_payload) =
+        let (_, assertion_descriptor) =
             self.assertion_payloads.iter().find(|(loc, _)| location == *loc)?;
-        match found_assertion_payload {
-            AssertionPayload::StaticString(string) => {
-                Some(ResolvedAssertionPayload::String(string.clone()))
-            }
-            AssertionPayload::Dynamic(error_selector, expression) => {
-                let mut fields = vec![];
-                for expr in expression {
-                    match expr {
-                        ExpressionOrMemory::Expression(expr) => {
-                            let value = get_value(expr, &self.witness_map).ok()?;
-                            fields.push(value);
-                        }
-                        ExpressionOrMemory::Memory(block_id) => {
-                            let memory_block = self.block_solvers.get(block_id)?;
-                            fields.extend((0..memory_block.block_len).map(|memory_index| {
-                                *memory_block
-                                    .block_value
-                                    .get(&memory_index)
-                                    .expect("All memory is initialized on creation")
-                            }));
-                        }
-                    }
+        let mut fields = Vec::new();
+        for expr in assertion_descriptor.payload.iter() {
+            match expr {
+                ExpressionOrMemory::Expression(expr) => {
+                    let value = get_value(expr, &self.witness_map).ok()?;
+                    fields.push(value);
+                }
+                ExpressionOrMemory::Memory(block_id) => {
+                    let memory_block = self.block_solvers.get(block_id)?;
+                    fields.extend((0..memory_block.block_len).map(|memory_index| {
+                        *memory_block
+                            .block_value
+                            .get(&memory_index)
+                            .expect("All memory is initialized on creation")
+                    }));
                 }
-                let error_selector = ErrorSelector::new(*error_selector);
-
-                Some(match error_selector {
-                    STRING_ERROR_SELECTOR => {
-                        // If the error selector is 0, it means the error is a string
-                        let string = fields
-                            .iter()
-                            .map(|field| {
-                                let as_u8: u8 = field
-                                    .try_to_u64()
-                                    .expect("String character doesn't fit in u64")
-                                    .try_into()
-                                    .expect("String character doesn't fit in u8");
-                                as_u8 as char
-                            })
-                            .collect();
-                        ResolvedAssertionPayload::String(string)
-                    }
-                    _ => {
-                        // If the error selector is not 0, it means the error is a custom error
-                        ResolvedAssertionPayload::Raw(RawAssertionPayload {
-                            selector: error_selector,
-                            data: fields,
-                        })
-                    }
-                })
             }
         }
+        let error_selector = ErrorSelector::new(assertion_descriptor.error_selector);
+
+        Some(ResolvedAssertionPayload::Raw(RawAssertionPayload {
+            selector: error_selector,
+            data: fields,
+        }))
     }
 
     fn solve_brillig_call_opcode(
@@ -503,10 +494,11 @@ impl<'a, F: AcirField, B: BlackBoxFunctionSolver<F>> ACVM<'a, F, B> {
                 self.backend,
                 self.instruction_pointer,
                 *id,
+                self.profiling_active,
             )?,
         };
 
-        let result = solver.solve().map_err(|err| self.map_brillig_error(err))?;
+        let result = solver.solve()?;
 
         match result {
             BrilligSolverStatus::ForeignCallWait(foreign_call) => {
@@ -519,34 +511,30 @@ impl<'a, F: AcirField, B: BlackBoxFunctionSolver<F>> ACVM<'a, F, B> {
             }
             BrilligSolverStatus::Finished => {
                 // Write execution outputs
-                solver.finalize(&mut self.witness_map, outputs)?;
-                Ok(None)
-            }
-        }
-    }
-
-    fn map_brillig_error(&self, mut err: OpcodeResolutionError<F>) -> OpcodeResolutionError<F> {
-        match &mut err {
-            OpcodeResolutionError::BrilligFunctionFailed { call_stack, payload, .. } => {
-                // Some brillig errors have static strings as payloads, we can resolve them here
-                let last_location =
-                    call_stack.last().expect("Call stacks should have at least one item");
-                let assertion_descriptor =
-                    self.assertion_payloads.iter().find_map(|(loc, payload)| {
-                        if loc == last_location {
-                            Some(payload)
-                        } else {
-                            None
-                        }
+                if self.profiling_active {
+                    let profiling_info =
+                        solver.finalize_with_profiling(&mut self.witness_map, outputs)?;
+                    profiling_info.into_iter().for_each(|sample| {
+                        let mapped =
+                            sample.call_stack.into_iter().map(|loc| OpcodeLocation::Brillig {
+                                acir_index: self.instruction_pointer,
+                                brillig_index: loc,
+                            });
+                        self.profiling_samples.push(ProfilingSample {
+                            call_stack: std::iter::once(OpcodeLocation::Acir(
+                                self.instruction_pointer,
+                            ))
+                            .chain(mapped)
+                            .collect(),
+                            brillig_function_id: Some(*id),
+                        });
                     });
-
-                if let Some(AssertionPayload::StaticString(string)) = assertion_descriptor {
-                    *payload = Some(ResolvedAssertionPayload::String(string.clone()));
+                } else {
+                    solver.finalize(&mut self.witness_map, outputs)?;
                 }
 
-                err
+                Ok(None)
             }
-            _ => err,
         }
     }
 
@@ -575,6 +563,7 @@ impl<'a, F: AcirField, B: BlackBoxFunctionSolver<F>> ACVM<'a, F, B> {
             self.backend,
             self.instruction_pointer,
             *id,
+            self.profiling_active,
         );
         match solver {
             Ok(solver) => StepResult::IntoBrillig(solver),
diff --git a/acvm-repo/acvm/tests/solver.rs b/acvm-repo/acvm/tests/solver.rs
index 6ad52999820..8b164b7c0f2 100644
--- a/acvm-repo/acvm/tests/solver.rs
+++ b/acvm-repo/acvm/tests/solver.rs
@@ -1,10 +1,10 @@
 use std::collections::{BTreeMap, HashSet};
 use std::sync::Arc;
 
-use acir::brillig::{BitSize, IntegerBitSize};
+use acir::brillig::{BitSize, HeapVector, IntegerBitSize};
 use acir::{
     acir_field::GenericFieldElement,
-    brillig::{BinaryFieldOp, HeapArray, MemoryAddress, Opcode as BrilligOpcode, ValueOrArray},
+    brillig::{BinaryFieldOp, MemoryAddress, Opcode as BrilligOpcode, ValueOrArray},
     circuit::{
         brillig::{BrilligBytecode, BrilligFunctionId, BrilligInputs, BrilligOutputs},
         opcodes::{BlackBoxFuncCall, BlockId, BlockType, FunctionInput, MemOp},
@@ -77,13 +77,6 @@ fn inversion_brillig_oracle_equivalence() {
     let w_x_plus_y = Witness(6);
     let w_equal_res = Witness(7);
 
-    let equal_opcode = BrilligOpcode::BinaryFieldOp {
-        op: BinaryFieldOp::Equals,
-        lhs: MemoryAddress::from(0),
-        rhs: MemoryAddress::from(1),
-        destination: MemoryAddress::from(2),
-    };
-
     let opcodes = vec![
         Opcode::BrilligCall {
             id: BrilligFunctionId(0),
@@ -122,33 +115,51 @@ fn inversion_brillig_oracle_equivalence() {
         }),
     ];
 
+    let equal_opcode = BrilligOpcode::BinaryFieldOp {
+        op: BinaryFieldOp::Equals,
+        lhs: MemoryAddress::direct(0),
+        rhs: MemoryAddress::direct(1),
+        destination: MemoryAddress::direct(2),
+    };
+
+    let zero_usize = MemoryAddress::direct(3);
+    let two_usize = MemoryAddress::direct(4);
+    let three_usize = MemoryAddress::direct(5);
+
     let brillig_bytecode = BrilligBytecode {
         bytecode: vec![
             BrilligOpcode::Const {
-                destination: MemoryAddress(0),
+                destination: zero_usize,
+                bit_size: BitSize::Integer(IntegerBitSize::U32),
+                value: FieldElement::from(0u64),
+            },
+            BrilligOpcode::Const {
+                destination: two_usize,
                 bit_size: BitSize::Integer(IntegerBitSize::U32),
                 value: FieldElement::from(2u64),
             },
             BrilligOpcode::Const {
-                destination: MemoryAddress(1),
+                destination: three_usize,
                 bit_size: BitSize::Integer(IntegerBitSize::U32),
-                value: FieldElement::from(0u64),
+                value: FieldElement::from(3u64),
             },
             BrilligOpcode::CalldataCopy {
-                destination_address: MemoryAddress(0),
-                size_address: MemoryAddress(0),
-                offset_address: MemoryAddress(1),
+                destination_address: MemoryAddress::direct(0),
+                size_address: two_usize,
+                offset_address: zero_usize,
             },
             equal_opcode,
             // Oracles are named 'foreign calls' in brillig
             BrilligOpcode::ForeignCall {
                 function: "invert".into(),
-                destinations: vec![ValueOrArray::MemoryAddress(MemoryAddress::from(1))],
+                destinations: vec![ValueOrArray::MemoryAddress(MemoryAddress::direct(1))],
                 destination_value_types: vec![HeapValueType::field()],
-                inputs: vec![ValueOrArray::MemoryAddress(MemoryAddress::from(0))],
+                inputs: vec![ValueOrArray::MemoryAddress(MemoryAddress::direct(0))],
                 input_value_types: vec![HeapValueType::field()],
             },
-            BrilligOpcode::Stop { return_data_offset: 0, return_data_size: 3 },
+            BrilligOpcode::Stop {
+                return_data: HeapVector { pointer: zero_usize, size: three_usize },
+            },
         ],
     };
 
@@ -216,13 +227,6 @@ fn double_inversion_brillig_oracle() {
     let w_ij_oracle = Witness(10);
     let w_i_plus_j = Witness(11);
 
-    let equal_opcode = BrilligOpcode::BinaryFieldOp {
-        op: BinaryFieldOp::Equals,
-        lhs: MemoryAddress::from(0),
-        rhs: MemoryAddress::from(1),
-        destination: MemoryAddress::from(4),
-    };
-
     let opcodes = vec![
         Opcode::BrilligCall {
             id: BrilligFunctionId(0),
@@ -268,40 +272,58 @@ fn double_inversion_brillig_oracle() {
         }),
     ];
 
+    let zero_usize = MemoryAddress::direct(5);
+    let three_usize = MemoryAddress::direct(6);
+    let five_usize = MemoryAddress::direct(7);
+
+    let equal_opcode = BrilligOpcode::BinaryFieldOp {
+        op: BinaryFieldOp::Equals,
+        lhs: MemoryAddress::direct(0),
+        rhs: MemoryAddress::direct(1),
+        destination: MemoryAddress::direct(4),
+    };
+
     let brillig_bytecode = BrilligBytecode {
         bytecode: vec![
             BrilligOpcode::Const {
-                destination: MemoryAddress(0),
+                destination: zero_usize,
+                bit_size: BitSize::Integer(IntegerBitSize::U32),
+                value: FieldElement::from(0u64),
+            },
+            BrilligOpcode::Const {
+                destination: three_usize,
                 bit_size: BitSize::Integer(IntegerBitSize::U32),
                 value: FieldElement::from(3u64),
             },
             BrilligOpcode::Const {
-                destination: MemoryAddress(1),
+                destination: five_usize,
                 bit_size: BitSize::Integer(IntegerBitSize::U32),
-                value: FieldElement::from(0u64),
+                value: FieldElement::from(5u64),
             },
             BrilligOpcode::CalldataCopy {
-                destination_address: MemoryAddress(0),
-                size_address: MemoryAddress(0),
-                offset_address: MemoryAddress(1),
+                destination_address: MemoryAddress::direct(0),
+                size_address: three_usize,
+                offset_address: zero_usize,
             },
             equal_opcode,
             // Oracles are named 'foreign calls' in brillig
             BrilligOpcode::ForeignCall {
                 function: "invert".into(),
-                destinations: vec![ValueOrArray::MemoryAddress(MemoryAddress::from(1))],
+                destinations: vec![ValueOrArray::MemoryAddress(MemoryAddress::direct(1))],
                 destination_value_types: vec![HeapValueType::field()],
-                inputs: vec![ValueOrArray::MemoryAddress(MemoryAddress::from(0))],
+                inputs: vec![ValueOrArray::MemoryAddress(MemoryAddress::direct(0))],
                 input_value_types: vec![HeapValueType::field()],
             },
             BrilligOpcode::ForeignCall {
                 function: "invert".into(),
-                destinations: vec![ValueOrArray::MemoryAddress(MemoryAddress::from(3))],
+                destinations: vec![ValueOrArray::MemoryAddress(MemoryAddress::direct(3))],
                 destination_value_types: vec![HeapValueType::field()],
-                inputs: vec![ValueOrArray::MemoryAddress(MemoryAddress::from(2))],
+                inputs: vec![ValueOrArray::MemoryAddress(MemoryAddress::direct(2))],
                 input_value_types: vec![HeapValueType::field()],
             },
-            BrilligOpcode::Stop { return_data_offset: 0, return_data_size: 5 },
+            BrilligOpcode::Stop {
+                return_data: HeapVector { pointer: zero_usize, size: five_usize },
+            },
         ],
     };
 
@@ -386,38 +408,49 @@ fn oracle_dependent_execution() {
     let w_x_inv = Witness(3);
     let w_y_inv = Witness(4);
 
+    let zero_usize = MemoryAddress::direct(4);
+    let three_usize = MemoryAddress::direct(5);
+    let four_usize = MemoryAddress::direct(6);
+
     let brillig_bytecode = BrilligBytecode {
         bytecode: vec![
             BrilligOpcode::Const {
-                destination: MemoryAddress(0),
+                destination: zero_usize,
+                bit_size: BitSize::Integer(IntegerBitSize::U32),
+                value: FieldElement::from(0u64),
+            },
+            BrilligOpcode::Const {
+                destination: three_usize,
                 bit_size: BitSize::Integer(IntegerBitSize::U32),
                 value: FieldElement::from(3u64),
             },
             BrilligOpcode::Const {
-                destination: MemoryAddress(1),
+                destination: four_usize,
                 bit_size: BitSize::Integer(IntegerBitSize::U32),
-                value: FieldElement::from(0u64),
+                value: FieldElement::from(4u64),
             },
             BrilligOpcode::CalldataCopy {
-                destination_address: MemoryAddress(0),
-                size_address: MemoryAddress(0),
-                offset_address: MemoryAddress(1),
+                destination_address: MemoryAddress::direct(0),
+                size_address: three_usize,
+                offset_address: zero_usize,
             }, // Oracles are named 'foreign calls' in brillig
             BrilligOpcode::ForeignCall {
                 function: "invert".into(),
-                destinations: vec![ValueOrArray::MemoryAddress(MemoryAddress::from(1))],
+                destinations: vec![ValueOrArray::MemoryAddress(MemoryAddress::direct(1))],
                 destination_value_types: vec![HeapValueType::field()],
-                inputs: vec![ValueOrArray::MemoryAddress(MemoryAddress::from(0))],
+                inputs: vec![ValueOrArray::MemoryAddress(MemoryAddress::direct(0))],
                 input_value_types: vec![HeapValueType::field()],
             },
             BrilligOpcode::ForeignCall {
                 function: "invert".into(),
-                destinations: vec![ValueOrArray::MemoryAddress(MemoryAddress::from(3))],
+                destinations: vec![ValueOrArray::MemoryAddress(MemoryAddress::direct(3))],
                 destination_value_types: vec![HeapValueType::field()],
-                inputs: vec![ValueOrArray::MemoryAddress(MemoryAddress::from(2))],
+                inputs: vec![ValueOrArray::MemoryAddress(MemoryAddress::direct(2))],
                 input_value_types: vec![HeapValueType::field()],
             },
-            BrilligOpcode::Stop { return_data_offset: 0, return_data_size: 4 },
+            BrilligOpcode::Stop {
+                return_data: HeapVector { pointer: zero_usize, size: four_usize },
+            },
         ],
     };
 
@@ -522,35 +555,35 @@ fn brillig_oracle_predicate() {
 
     let equal_opcode = BrilligOpcode::BinaryFieldOp {
         op: BinaryFieldOp::Equals,
-        lhs: MemoryAddress::from(0),
-        rhs: MemoryAddress::from(1),
-        destination: MemoryAddress::from(2),
+        lhs: MemoryAddress::direct(0),
+        rhs: MemoryAddress::direct(1),
+        destination: MemoryAddress::direct(2),
     };
 
     let brillig_bytecode = BrilligBytecode {
         bytecode: vec![
             BrilligOpcode::Const {
-                destination: MemoryAddress(0),
+                destination: MemoryAddress::direct(0),
                 bit_size: BitSize::Integer(IntegerBitSize::U32),
                 value: FieldElement::from(2u64),
             },
             BrilligOpcode::Const {
-                destination: MemoryAddress(1),
+                destination: MemoryAddress::direct(1),
                 bit_size: BitSize::Integer(IntegerBitSize::U32),
                 value: FieldElement::from(0u64),
             },
             BrilligOpcode::CalldataCopy {
-                destination_address: MemoryAddress(0),
-                size_address: MemoryAddress(0),
-                offset_address: MemoryAddress(1),
+                destination_address: MemoryAddress::direct(0),
+                size_address: MemoryAddress::direct(0),
+                offset_address: MemoryAddress::direct(1),
             },
             equal_opcode,
             // Oracles are named 'foreign calls' in brillig
             BrilligOpcode::ForeignCall {
                 function: "invert".into(),
-                destinations: vec![ValueOrArray::MemoryAddress(MemoryAddress::from(1))],
+                destinations: vec![ValueOrArray::MemoryAddress(MemoryAddress::direct(1))],
                 destination_value_types: vec![HeapValueType::field()],
-                inputs: vec![ValueOrArray::MemoryAddress(MemoryAddress::from(0))],
+                inputs: vec![ValueOrArray::MemoryAddress(MemoryAddress::direct(0))],
                 input_value_types: vec![HeapValueType::field()],
             },
         ],
@@ -649,36 +682,51 @@ fn unsatisfied_opcode_resolved_brillig() {
     let w_result = Witness(6);
 
     let calldata_copy_opcode = BrilligOpcode::CalldataCopy {
-        destination_address: MemoryAddress(0),
-        size_address: MemoryAddress(0),
-        offset_address: MemoryAddress(1),
+        destination_address: MemoryAddress::direct(0),
+        size_address: MemoryAddress::direct(0),
+        offset_address: MemoryAddress::direct(1),
     };
 
     let equal_opcode = BrilligOpcode::BinaryFieldOp {
         op: BinaryFieldOp::Equals,
-        lhs: MemoryAddress::from(0),
-        rhs: MemoryAddress::from(1),
-        destination: MemoryAddress::from(2),
+        lhs: MemoryAddress::direct(0),
+        rhs: MemoryAddress::direct(1),
+        destination: MemoryAddress::direct(2),
     };
     // Jump pass the trap if the values are equal, else
     // jump to the trap
-    let location_of_stop = 3;
+    let location_of_stop = 7;
 
     let jmp_if_opcode =
-        BrilligOpcode::JumpIf { condition: MemoryAddress::from(2), location: location_of_stop };
+        BrilligOpcode::JumpIf { condition: MemoryAddress::direct(2), location: location_of_stop };
 
-    let trap_opcode = BrilligOpcode::Trap { revert_data: HeapArray::default() };
-    let stop_opcode = BrilligOpcode::Stop { return_data_offset: 0, return_data_size: 0 };
+    let trap_opcode = BrilligOpcode::Trap {
+        revert_data: HeapVector {
+            pointer: MemoryAddress::direct(0),
+            size: MemoryAddress::direct(3),
+        },
+    };
+    let stop_opcode = BrilligOpcode::Stop {
+        return_data: HeapVector {
+            pointer: MemoryAddress::direct(0),
+            size: MemoryAddress::direct(3),
+        },
+    };
 
     let brillig_bytecode = BrilligBytecode {
         bytecode: vec![
             BrilligOpcode::Const {
-                destination: MemoryAddress(0),
+                destination: MemoryAddress::direct(0),
                 bit_size: BitSize::Integer(IntegerBitSize::U32),
                 value: FieldElement::from(2u64),
             },
             BrilligOpcode::Const {
-                destination: MemoryAddress(1),
+                destination: MemoryAddress::direct(1),
+                bit_size: BitSize::Integer(IntegerBitSize::U32),
+                value: FieldElement::from(0u64),
+            },
+            BrilligOpcode::Const {
+                destination: MemoryAddress::direct(3),
                 bit_size: BitSize::Integer(IntegerBitSize::U32),
                 value: FieldElement::from(0u64),
             },
@@ -739,7 +787,7 @@ fn unsatisfied_opcode_resolved_brillig() {
         ACVMStatus::Failure(OpcodeResolutionError::BrilligFunctionFailed {
             function_id: BrilligFunctionId(0),
             payload: None,
-            call_stack: vec![OpcodeLocation::Brillig { acir_index: 0, brillig_index: 5 }]
+            call_stack: vec![OpcodeLocation::Brillig { acir_index: 0, brillig_index: 6 }]
         }),
         "The first opcode is not satisfiable, expected an error indicating this"
     );
@@ -1099,45 +1147,6 @@ fn blake3_op(
     })
 }
 
-// variable inputs
-// 32 outputs
-fn keccak256_op(
-    function_inputs_and_outputs: (Vec<FunctionInput<FieldElement>>, Vec<Witness>),
-) -> Result<BlackBoxFuncCall<FieldElement>, OpcodeResolutionError<FieldElement>> {
-    let (function_inputs, outputs) = function_inputs_and_outputs;
-    let function_inputs_len = function_inputs.len();
-    Ok(BlackBoxFuncCall::Keccak256 {
-        inputs: function_inputs,
-        var_message_size: FunctionInput::constant(
-            function_inputs_len.into(),
-            FieldElement::max_num_bits(),
-        )?,
-        outputs: outputs.try_into().expect("Keccak256 returns 32 outputs"),
-    })
-}
-
-// var_message_size is the number of bytes to take
-// from the input. Note: if `var_message_size`
-// is more than the number of bytes in the input,
-// then an error is returned.
-//
-// variable inputs
-// 32 outputs
-fn keccak256_invalid_message_size_op(
-    function_inputs_and_outputs: (Vec<FunctionInput<FieldElement>>, Vec<Witness>),
-) -> Result<BlackBoxFuncCall<FieldElement>, OpcodeResolutionError<FieldElement>> {
-    let (function_inputs, outputs) = function_inputs_and_outputs;
-    let function_inputs_len = function_inputs.len();
-    Ok(BlackBoxFuncCall::Keccak256 {
-        inputs: function_inputs,
-        var_message_size: FunctionInput::constant(
-            (function_inputs_len - 1).into(),
-            FieldElement::max_num_bits(),
-        )?,
-        outputs: outputs.try_into().expect("Keccak256 returns 32 outputs"),
-    })
-}
-
 // 25 inputs
 // 25 outputs
 fn keccakf1600_op(
@@ -1489,19 +1498,6 @@ fn blake3_zeros() {
     assert_eq!(results, Ok(expected_results));
 }
 
-#[test]
-fn keccak256_zeros() {
-    let results = solve_array_input_blackbox_call(vec![], 32, None, keccak256_op);
-    let expected_results: Vec<_> = vec![
-        197, 210, 70, 1, 134, 247, 35, 60, 146, 126, 125, 178, 220, 199, 3, 192, 229, 0, 182, 83,
-        202, 130, 39, 59, 123, 250, 216, 4, 93, 133, 164, 112,
-    ]
-    .into_iter()
-    .map(|x: u128| FieldElement::from(x))
-    .collect();
-    assert_eq!(results, Ok(expected_results));
-}
-
 #[test]
 fn keccakf1600_zeros() {
     let results = solve_array_input_blackbox_call(
@@ -1642,24 +1638,6 @@ proptest! {
         prop_assert!(result, "{}", message);
     }
 
-    #[test]
-    fn keccak256_injective(inputs_distinct_inputs in any_distinct_inputs(Some(8), 0, 32)) {
-        let (inputs, distinct_inputs) = inputs_distinct_inputs;
-        let (result, message) = prop_assert_injective(inputs, distinct_inputs, 32, Some(8), keccak256_op);
-        prop_assert!(result, "{}", message);
-    }
-
-    // TODO(https://github.com/noir-lang/noir/issues/5689): doesn't fail with a user error
-    // The test failing with "not injective" demonstrates that it returns constant output instead
-    // of failing with a user error.
-    #[test]
-    #[should_panic(expected = "Test failed: not injective")]
-    fn keccak256_invalid_message_size_fails(inputs_distinct_inputs in any_distinct_inputs(Some(8), 0, 32)) {
-        let (inputs, distinct_inputs) = inputs_distinct_inputs;
-        let (result, message) = prop_assert_injective(inputs, distinct_inputs, 32, Some(8), keccak256_invalid_message_size_op);
-        prop_assert!(result, "{}", message);
-    }
-
     #[test]
     fn keccakf1600_injective(inputs_distinct_inputs in any_distinct_inputs(Some(8), 25, 25)) {
         let (inputs, distinct_inputs) = inputs_distinct_inputs;
diff --git a/acvm-repo/acvm_js/Cargo.toml b/acvm-repo/acvm_js/Cargo.toml
index b5b55dbb91a..bd536817428 100644
--- a/acvm-repo/acvm_js/Cargo.toml
+++ b/acvm-repo/acvm_js/Cargo.toml
@@ -2,7 +2,7 @@
 name = "acvm_js"
 description = "Typescript wrapper around the ACVM allowing execution of ACIR code"
 # x-release-please-start-version
-version = "0.50.0"
+version = "1.0.0-beta.0"
 # x-release-please-end
 authors.workspace = true
 edition.workspace = true
diff --git a/acvm-repo/acvm_js/package.json b/acvm-repo/acvm_js/package.json
index 95b8a46456f..904263b5e27 100644
--- a/acvm-repo/acvm_js/package.json
+++ b/acvm-repo/acvm_js/package.json
@@ -1,6 +1,6 @@
 {
   "name": "@noir-lang/acvm_js",
-  "version": "0.50.0",
+  "version": "1.0.0-beta.0",
   "publishConfig": {
     "access": "public"
   },
diff --git a/acvm-repo/acvm_js/src/black_box_solvers.rs b/acvm-repo/acvm_js/src/black_box_solvers.rs
index 6046d52943c..0e35851ee78 100644
--- a/acvm-repo/acvm_js/src/black_box_solvers.rs
+++ b/acvm-repo/acvm_js/src/black_box_solvers.rs
@@ -37,12 +37,6 @@ pub fn blake2s256(inputs: &[u8]) -> Vec<u8> {
     acvm::blackbox_solver::blake2s(inputs).unwrap().into()
 }
 
-/// Calculates the Keccak256 hash of the input bytes
-#[wasm_bindgen]
-pub fn keccak256(inputs: &[u8]) -> Vec<u8> {
-    acvm::blackbox_solver::keccak256(inputs).unwrap().into()
-}
-
 /// Verifies a ECDSA signature over the secp256k1 curve.
 #[wasm_bindgen]
 pub fn ecdsa_secp256k1_verify(
diff --git a/acvm-repo/acvm_js/src/lib.rs b/acvm-repo/acvm_js/src/lib.rs
index 8fe64afbba9..e2468e6d939 100644
--- a/acvm-repo/acvm_js/src/lib.rs
+++ b/acvm-repo/acvm_js/src/lib.rs
@@ -17,8 +17,7 @@ mod logging;
 mod public_witness;
 
 pub use black_box_solvers::{
-    and, blake2s256, ecdsa_secp256k1_verify, ecdsa_secp256r1_verify, keccak256, sha256_compression,
-    xor,
+    and, blake2s256, ecdsa_secp256k1_verify, ecdsa_secp256r1_verify, sha256_compression, xor,
 };
 pub use build_info::build_info;
 pub use compression::{
diff --git a/acvm-repo/acvm_js/test/browser/black_box_solvers.test.ts b/acvm-repo/acvm_js/test/browser/black_box_solvers.test.ts
index 9dc5be2c682..b99fe9e3d88 100644
--- a/acvm-repo/acvm_js/test/browser/black_box_solvers.test.ts
+++ b/acvm-repo/acvm_js/test/browser/black_box_solvers.test.ts
@@ -4,7 +4,6 @@ import initACVM, {
   blake2s256,
   ecdsa_secp256k1_verify,
   ecdsa_secp256r1_verify,
-  keccak256,
   sha256_compression,
   xor,
 } from '@noir-lang/acvm_js';
@@ -51,16 +50,6 @@ it('successfully calculates the blake2s256 hash', async () => {
   }
 });
 
-it('successfully calculates the keccak256 hash', async () => {
-  const { keccak256_test_cases } = await import('../shared/black_box_solvers');
-
-  for (const testCase of keccak256_test_cases) {
-    const [preimage, expectedResult] = testCase;
-    const hash = keccak256(preimage);
-    hash.forEach((value, index) => expect(value).to.be.eq(expectedResult.at(index)));
-  }
-});
-
 it('successfully verifies secp256k1 ECDSA signatures', async () => {
   const { ecdsa_secp256k1_test_cases } = await import('../shared/black_box_solvers');
 
diff --git a/acvm-repo/acvm_js/test/browser/execute_circuit.test.ts b/acvm-repo/acvm_js/test/browser/execute_circuit.test.ts
index aaa82f8f1e5..4d8f0acbd38 100644
--- a/acvm-repo/acvm_js/test/browser/execute_circuit.test.ts
+++ b/acvm-repo/acvm_js/test/browser/execute_circuit.test.ts
@@ -85,16 +85,6 @@ it('successfully executes a MultiScalarMul opcode', async () => {
   expect(solvedWitness).to.be.deep.eq(expectedWitnessMap);
 });
 
-it('successfully executes a SchnorrVerify opcode', async () => {
-  const { bytecode, initialWitnessMap, expectedWitnessMap } = await import('../shared/schnorr_verify');
-
-  const solvedWitness: WitnessMap = await executeCircuit(bytecode, initialWitnessMap, () => {
-    throw Error('unexpected oracle');
-  });
-
-  expect(solvedWitness).to.be.deep.eq(expectedWitnessMap);
-});
-
 it('successfully executes a MemoryOp opcode', async () => {
   const { bytecode, initialWitnessMap, expectedWitnessMap } = await import('../shared/memory_op');
 
diff --git a/acvm-repo/acvm_js/test/node/black_box_solvers.test.ts b/acvm-repo/acvm_js/test/node/black_box_solvers.test.ts
index fc998ced5a5..74553f6b692 100644
--- a/acvm-repo/acvm_js/test/node/black_box_solvers.test.ts
+++ b/acvm-repo/acvm_js/test/node/black_box_solvers.test.ts
@@ -4,7 +4,6 @@ import {
   blake2s256,
   ecdsa_secp256k1_verify,
   ecdsa_secp256r1_verify,
-  keccak256,
   sha256_compression,
   xor,
 } from '@noir-lang/acvm_js';
@@ -47,28 +46,6 @@ it('successfully calculates the blake2s256 hash', async () => {
   }
 });
 
-it('successfully calculates the keccak256 hash', async () => {
-  const { keccak256_test_cases } = await import('../shared/black_box_solvers');
-
-  for (const testCase of keccak256_test_cases) {
-    const [preimage, expectedResult] = testCase;
-    const hash = keccak256(preimage);
-    hash.forEach((value, index) => expect(value).to.be.eq(expectedResult.at(index)));
-  }
-});
-
-// it("successfully calculates the hash_to_field_128_security field", async () => {
-//   const { hash_to_field_128_security_test_cases } = await import(
-//     "../shared/black_box_solvers"
-//   );
-
-//   for (const testCase of hash_to_field_128_security_test_cases) {
-//     const [preimage, expectedResult] = testCase;
-//     const hashField = hash_to_field_128_security(preimage);
-//     expect(hashField).to.be.eq(expectedResult);
-//   }
-// });
-
 it('successfully verifies secp256k1 ECDSA signatures', async () => {
   const { ecdsa_secp256k1_test_cases } = await import('../shared/black_box_solvers');
 
diff --git a/acvm-repo/acvm_js/test/node/execute_circuit.test.ts b/acvm-repo/acvm_js/test/node/execute_circuit.test.ts
index 120ad0fa738..67f7de2129c 100644
--- a/acvm-repo/acvm_js/test/node/execute_circuit.test.ts
+++ b/acvm-repo/acvm_js/test/node/execute_circuit.test.ts
@@ -86,16 +86,6 @@ it('successfully executes a MultiScalarMul opcode', async () => {
   expect(solvedWitness).to.be.deep.eq(expectedWitnessMap);
 });
 
-it('successfully executes a SchnorrVerify opcode', async () => {
-  const { bytecode, initialWitnessMap, expectedWitnessMap } = await import('../shared/schnorr_verify');
-
-  const solvedWitness: WitnessMap = await executeCircuit(bytecode, initialWitnessMap, () => {
-    throw Error('unexpected oracle');
-  });
-
-  expect(solvedWitness).to.be.deep.eq(expectedWitnessMap);
-});
-
 it('successfully executes a MemoryOp opcode', async () => {
   const { bytecode, initialWitnessMap, expectedWitnessMap } = await import('../shared/memory_op');
 
diff --git a/acvm-repo/acvm_js/test/shared/addition.ts b/acvm-repo/acvm_js/test/shared/addition.ts
index 820a415acf3..2b8124e77d7 100644
--- a/acvm-repo/acvm_js/test/shared/addition.ts
+++ b/acvm-repo/acvm_js/test/shared/addition.ts
@@ -3,10 +3,10 @@ import { WitnessMap } from '@noir-lang/acvm_js';
 // See `addition_circuit` integration test in `acir/tests/test_program_serialization.rs`.
 export const bytecode = Uint8Array.from([
   31, 139, 8, 0, 0, 0, 0, 0, 0, 255, 173, 144, 65, 14, 128, 32, 12, 4, 65, 124, 80, 75, 91, 104, 111, 126, 69, 34, 252,
-  255, 9, 106, 228, 64, 162, 55, 153, 164, 217, 158, 38, 155, 245, 238, 97, 189, 206, 187, 55, 161, 231, 214, 19, 254,
-  129, 126, 162, 107, 25, 92, 4, 137, 185, 230, 88, 145, 112, 135, 104, 69, 5, 88, 74, 82, 84, 20, 149, 35, 42, 81, 85,
-  214, 108, 197, 50, 24, 50, 85, 108, 98, 212, 186, 44, 204, 235, 5, 183, 99, 233, 46, 63, 252, 110, 216, 56, 184, 15,
-  78, 146, 74, 173, 20, 141, 1, 0, 0,
+  255, 9, 106, 228, 64, 194, 81, 38, 105, 182, 167, 201, 102, 189, 251, 216, 159, 243, 110, 38, 244, 60, 122, 194, 63,
+  208, 47, 116, 109, 131, 139, 32, 49, 215, 28, 43, 18, 158, 16, 173, 168, 0, 75, 73, 138, 138, 162, 114, 69, 37, 170,
+  202, 154, 173, 88, 6, 67, 166, 138, 77, 140, 90, 151, 133, 117, 189, 224, 117, 108, 221, 229, 135, 223, 13, 27, 135,
+  121, 106, 119, 3, 58, 173, 124, 163, 140, 1, 0, 0,
 ]);
 
 export const initialWitnessMap: WitnessMap = new Map([
diff --git a/acvm-repo/acvm_js/test/shared/complex_foreign_call.ts b/acvm-repo/acvm_js/test/shared/complex_foreign_call.ts
index 60e4c8d5829..24fbc1a921a 100644
--- a/acvm-repo/acvm_js/test/shared/complex_foreign_call.ts
+++ b/acvm-repo/acvm_js/test/shared/complex_foreign_call.ts
@@ -2,14 +2,14 @@ import { WitnessMap } from '@noir-lang/acvm_js';
 
 // See `complex_brillig_foreign_call` integration test in `acir/tests/test_program_serialization.rs`.
 export const bytecode = Uint8Array.from([
-  31, 139, 8, 0, 0, 0, 0, 0, 0, 255, 213, 85, 81, 14, 194, 48, 8, 133, 118, 186, 53, 241, 207, 11, 152, 232, 1, 58, 189,
-  128, 119, 49, 254, 105, 244, 211, 227, 59, 50, 154, 49, 214, 100, 31, 163, 201, 246, 146, 133, 174, 5, 10, 15, 72, 17,
-  122, 52, 221, 135, 188, 222, 177, 116, 44, 105, 223, 195, 24, 73, 247, 206, 50, 46, 67, 139, 118, 190, 98, 169, 24,
-  221, 6, 98, 244, 5, 98, 4, 81, 255, 21, 214, 219, 178, 46, 166, 252, 249, 204, 252, 84, 208, 207, 215, 158, 255, 107,
-  150, 141, 38, 154, 140, 28, 76, 7, 111, 132, 212, 61, 65, 201, 116, 86, 217, 101, 115, 11, 226, 62, 99, 223, 145, 88,
-  56, 205, 228, 102, 127, 239, 53, 6, 69, 184, 97, 78, 109, 96, 127, 37, 106, 81, 11, 126, 100, 103, 17, 14, 48, 116,
-  213, 227, 243, 254, 190, 158, 63, 175, 40, 149, 102, 132, 179, 88, 95, 212, 57, 42, 59, 109, 43, 33, 31, 140, 156, 46,
-  102, 244, 230, 124, 31, 97, 104, 141, 244, 48, 253, 1, 180, 46, 168, 159, 181, 6, 0, 0,
+  31, 139, 8, 0, 0, 0, 0, 0, 0, 255, 213, 85, 205, 14, 130, 48, 12, 238, 54, 20, 136, 222, 124, 1, 19, 125, 128, 161,
+  241, 238, 187, 24, 111, 26, 61, 250, 248, 178, 216, 198, 89, 26, 56, 216, 18, 248, 146, 165, 12, 218, 175, 255, 193,
+  193, 7, 85, 123, 28, 62, 23, 40, 61, 202, 244, 62, 192, 47, 72, 247, 140, 50, 254, 135, 198, 233, 113, 69, 171, 24,
+  253, 12, 98, 12, 6, 49, 66, 214, 255, 9, 246, 91, 179, 47, 170, 245, 11, 194, 254, 164, 221, 90, 180, 103, 137, 247,
+  18, 101, 197, 11, 157, 140, 60, 116, 23, 47, 7, 13, 207, 10, 101, 45, 124, 87, 76, 232, 88, 51, 191, 202, 252, 145,
+  138, 177, 133, 254, 124, 109, 243, 60, 68, 226, 15, 38, 252, 177, 33, 254, 194, 168, 79, 37, 171, 87, 158, 75, 238,
+  119, 13, 223, 1, 188, 60, 238, 207, 219, 245, 21, 4, 83, 110, 158, 176, 99, 247, 189, 80, 178, 33, 14, 66, 254, 159,
+  233, 211, 119, 130, 254, 144, 205, 88, 163, 98, 180, 18, 167, 13, 116, 65, 190, 222, 250, 76, 4, 233, 188, 7, 0, 0,
 ]);
 export const initialWitnessMap: WitnessMap = new Map([
   [1, '0x0000000000000000000000000000000000000000000000000000000000000001'],
diff --git a/acvm-repo/acvm_js/test/shared/foreign_call.ts b/acvm-repo/acvm_js/test/shared/foreign_call.ts
index 9bf57535c87..da0b9974c61 100644
--- a/acvm-repo/acvm_js/test/shared/foreign_call.ts
+++ b/acvm-repo/acvm_js/test/shared/foreign_call.ts
@@ -2,11 +2,11 @@ import { WitnessMap } from '@noir-lang/acvm_js';
 
 // See `simple_brillig_foreign_call` integration test in `acir/tests/test_program_serialization.rs`.
 export const bytecode = Uint8Array.from([
-  31, 139, 8, 0, 0, 0, 0, 0, 0, 255, 173, 81, 73, 10, 192, 48, 8, 140, 165, 91, 160, 183, 126, 196, 254, 160, 159, 233,
-  161, 151, 30, 74, 200, 251, 19, 136, 130, 132, 196, 75, 28, 16, 199, 17, 212, 65, 112, 5, 123, 14, 32, 190, 80, 230,
-  90, 130, 181, 155, 50, 142, 225, 2, 187, 89, 40, 239, 157, 106, 2, 82, 116, 138, 51, 118, 239, 171, 222, 108, 232,
-  218, 139, 125, 198, 179, 113, 83, 188, 29, 57, 86, 226, 239, 23, 159, 63, 104, 63, 238, 213, 45, 237, 108, 244, 18,
-  195, 174, 252, 193, 92, 2, 0, 0,
+  31, 139, 8, 0, 0, 0, 0, 0, 0, 255, 173, 81, 203, 10, 128, 48, 12, 179, 243, 57, 240, 230, 143, 108, 127, 224, 207,
+  120, 240, 226, 65, 196, 239, 119, 98, 11, 101, 100, 94, 214, 64, 73, 26, 88, 73, 24, 53, 31, 166, 52, 196, 186, 99,
+  150, 93, 67, 188, 149, 57, 212, 33, 146, 221, 173, 160, 243, 186, 92, 144, 54, 127, 138, 245, 204, 62, 243, 95, 110,
+  13, 195, 122, 144, 207, 240, 126, 28, 65, 71, 7, 250, 206, 105, 6, 214, 251, 113, 111, 231, 133, 190, 93, 191, 40,
+  237, 37, 127, 1, 190, 36, 121, 0, 128, 254, 118, 42, 127, 2, 0, 0,
 ]);
 export const initialWitnessMap: WitnessMap = new Map([
   [1, '0x0000000000000000000000000000000000000000000000000000000000000005'],
diff --git a/acvm-repo/acvm_js/test/shared/memory_op.ts b/acvm-repo/acvm_js/test/shared/memory_op.ts
index f7443c2258b..2f0fbfb85f1 100644
--- a/acvm-repo/acvm_js/test/shared/memory_op.ts
+++ b/acvm-repo/acvm_js/test/shared/memory_op.ts
@@ -1,9 +1,9 @@
 // See `memory_op_circuit` integration test in `acir/tests/test_program_serialization.rs`.
 export const bytecode = Uint8Array.from([
-  31, 139, 8, 0, 0, 0, 0, 0, 0, 255, 213, 82, 65, 10, 0, 32, 8, 211, 180, 255, 216, 15, 250, 255, 171, 10, 82, 176, 232,
-  150, 30, 26, 200, 118, 144, 49, 135, 8, 11, 117, 14, 169, 102, 229, 162, 140, 78, 219, 206, 137, 174, 44, 111, 104,
-  217, 190, 24, 236, 75, 113, 94, 146, 93, 174, 252, 86, 46, 71, 223, 78, 46, 104, 129, 253, 155, 45, 60, 195, 5, 3, 89,
-  11, 161, 73, 39, 3, 0, 0,
+  31, 139, 8, 0, 0, 0, 0, 0, 0, 255, 213, 144, 75, 10, 0, 32, 8, 68, 253, 117, 31, 187, 65, 247, 63, 85, 65, 10, 82,
+  203, 116, 209, 128, 60, 221, 12, 227, 32, 108, 181, 53, 108, 187, 147, 140, 24, 118, 231, 169, 97, 212, 55, 245, 106,
+  95, 76, 246, 229, 60, 47, 173, 46, 87, 127, 43, 87, 178, 127, 231, 16, 148, 194, 29, 195, 11, 220, 154, 119, 139, 115,
+  25, 38, 3, 0, 0,
 ]);
 
 export const initialWitnessMap = new Map([
diff --git a/acvm-repo/acvm_js/test/shared/multi_scalar_mul.ts b/acvm-repo/acvm_js/test/shared/multi_scalar_mul.ts
index f23847a75fc..fac77e4ee27 100644
--- a/acvm-repo/acvm_js/test/shared/multi_scalar_mul.ts
+++ b/acvm-repo/acvm_js/test/shared/multi_scalar_mul.ts
@@ -1,8 +1,8 @@
 // See `multi_scalar_mul_circuit` integration test in `acir/tests/test_program_serialization.rs`.
 export const bytecode = Uint8Array.from([
-  31, 139, 8, 0, 0, 0, 0, 0, 0, 255, 93, 141, 11, 10, 0, 32, 8, 67, 43, 181, 15, 221, 255, 186, 145, 210, 130, 149, 240,
-  112, 234, 212, 156, 78, 12, 39, 67, 71, 158, 142, 80, 29, 44, 228, 66, 90, 168, 119, 189, 74, 115, 131, 174, 78, 115,
-  58, 124, 70, 254, 130, 59, 74, 253, 68, 255, 255, 221, 39, 54, 29, 134, 27, 102, 193, 0, 0, 0,
+  31, 139, 8, 0, 0, 0, 0, 0, 0, 255, 93, 77, 9, 10, 0, 48, 8, 114, 107, 231, 255, 255, 59, 86, 204, 64, 22, 136, 102,
+  89, 5, 175, 182, 163, 80, 7, 47, 135, 73, 31, 56, 228, 42, 218, 196, 203, 221, 38, 243, 78, 61, 28, 147, 119, 65, 31,
+  146, 53, 230, 210, 135, 252, 255, 179, 90, 23, 212, 196, 199, 187, 192, 0, 0, 0,
 ]);
 export const initialWitnessMap = new Map([
   [1, '0x0000000000000000000000000000000000000000000000000000000000000001'],
diff --git a/acvm-repo/acvm_js/test/shared/nested_acir_call.ts b/acvm-repo/acvm_js/test/shared/nested_acir_call.ts
index 64051dff93f..3464809dfc4 100644
--- a/acvm-repo/acvm_js/test/shared/nested_acir_call.ts
+++ b/acvm-repo/acvm_js/test/shared/nested_acir_call.ts
@@ -2,13 +2,13 @@ import { WitnessMap, StackItem, WitnessStack } from '@noir-lang/acvm_js';
 
 // See `nested_acir_call_circuit` integration test in `acir/tests/test_program_serialization.rs`.
 export const bytecode = Uint8Array.from([
-  31, 139, 8, 0, 0, 0, 0, 0, 0, 255, 205, 146, 97, 10, 195, 32, 12, 133, 163, 66, 207, 147, 24, 173, 241, 223, 174, 50,
-  153, 189, 255, 17, 214, 177, 148, 57, 17, 250, 99, 14, 250, 224, 97, 144, 16, 146, 143, 231, 224, 45, 167, 126, 105,
-  217, 109, 118, 91, 248, 200, 168, 225, 248, 63, 107, 114, 208, 233, 104, 188, 233, 139, 191, 137, 108, 51, 139, 113,
-  13, 161, 38, 95, 137, 233, 142, 62, 23, 137, 24, 98, 89, 133, 132, 162, 196, 135, 23, 230, 42, 65, 82, 46, 57, 97,
-  166, 192, 149, 182, 152, 121, 211, 97, 110, 222, 94, 8, 13, 132, 182, 54, 48, 144, 235, 8, 254, 11, 22, 76, 132, 101,
-  231, 237, 229, 23, 189, 213, 54, 119, 15, 83, 212, 199, 172, 175, 191, 226, 102, 96, 140, 251, 202, 84, 13, 204, 141,
-  224, 25, 176, 161, 158, 53, 121, 144, 73, 14, 4, 0, 0,
+  31, 139, 8, 0, 0, 0, 0, 0, 0, 255, 213, 146, 81, 10, 195, 48, 8, 134, 77, 164, 247, 209, 152, 52, 230, 109, 87, 89,
+  88, 122, 255, 35, 172, 99, 41, 11, 89, 161, 15, 77, 31, 250, 193, 143, 34, 34, 250, 35, 194, 23, 172, 250, 48, 173,
+  50, 171, 44, 252, 48, 85, 176, 213, 143, 154, 16, 58, 182, 198, 71, 141, 116, 14, 182, 205, 44, 161, 217, 251, 18, 93,
+  97, 225, 39, 185, 148, 53, 144, 15, 121, 86, 86, 14, 26, 94, 78, 69, 138, 122, 141, 41, 167, 72, 137, 189, 20, 94, 66,
+  146, 165, 14, 195, 113, 123, 17, 52, 38, 180, 185, 129, 127, 176, 51, 240, 42, 175, 96, 160, 87, 118, 220, 94, 110,
+  170, 183, 218, 230, 238, 221, 39, 234, 191, 172, 207, 177, 171, 153, 155, 153, 106, 96, 236, 3, 30, 249, 181, 199, 27,
+  99, 149, 130, 253, 11, 4, 0, 0,
 ]);
 
 export const initialWitnessMap: WitnessMap = new Map([
diff --git a/acvm-repo/acvm_js/test/shared/schnorr_verify.ts b/acvm-repo/acvm_js/test/shared/schnorr_verify.ts
deleted file mode 100644
index 830ca1026d6..00000000000
--- a/acvm-repo/acvm_js/test/shared/schnorr_verify.ts
+++ /dev/null
@@ -1,101 +0,0 @@
-// See `schnorr_verify_circuit` integration test in `acir/tests/test_program_serialization.rs`.
-export const bytecode = Uint8Array.from([
-  31, 139, 8, 0, 0, 0, 0, 0, 0, 255, 85, 211, 103, 78, 2, 81, 24, 70, 225, 193, 130, 96, 239, 189, 96, 239, 189, 35, 34,
-  34, 34, 34, 238, 130, 253, 47, 129, 192, 9, 223, 36, 7, 146, 201, 60, 209, 31, 144, 123, 207, 155, 73, 250, 159, 118,
-  239, 201, 132, 121, 103, 227, 205, 211, 137, 247, 144, 60, 220, 123, 114, 225, 17, 121, 84, 206, 202, 99, 114, 78,
-  206, 203, 227, 242, 132, 60, 41, 79, 201, 211, 242, 140, 60, 43, 207, 201, 243, 242, 130, 188, 40, 47, 201, 203, 242,
-  138, 188, 42, 175, 201, 235, 242, 134, 188, 41, 111, 201, 219, 242, 142, 92, 144, 119, 229, 61, 121, 95, 62, 144, 15,
-  229, 35, 249, 88, 62, 145, 79, 229, 51, 249, 92, 190, 144, 47, 229, 43, 249, 90, 190, 145, 111, 229, 59, 249, 94, 126,
-  144, 31, 229, 39, 249, 89, 126, 145, 95, 229, 162, 252, 38, 151, 228, 119, 185, 44, 127, 200, 21, 249, 83, 174, 134,
-  233, 52, 137, 191, 125, 233, 255, 53, 249, 91, 174, 203, 63, 114, 67, 254, 149, 155, 242, 159, 220, 10, 255, 199, 247,
-  183, 244, 59, 216, 38, 155, 100, 139, 108, 144, 237, 165, 155, 203, 199, 111, 102, 83, 108, 137, 13, 177, 29, 54, 195,
-  86, 216, 8, 219, 96, 19, 108, 129, 13, 208, 62, 205, 211, 58, 141, 211, 54, 77, 211, 50, 13, 211, 46, 205, 22, 146,
-  126, 163, 180, 73, 147, 180, 72, 131, 180, 71, 115, 180, 70, 99, 180, 69, 83, 180, 68, 67, 180, 67, 51, 180, 66, 35,
-  180, 65, 19, 180, 64, 3, 220, 61, 119, 206, 93, 115, 199, 197, 184, 211, 82, 220, 97, 57, 238, 172, 18, 119, 84, 141,
-  187, 168, 197, 217, 215, 227, 172, 27, 113, 182, 205, 56, 203, 244, 204, 210, 115, 75, 116, 158, 3, 159, 46, 43, 32,
-  188, 53, 25, 5, 0, 0,
-]);
-
-export const initialWitnessMap = new Map([
-  [1, '0x04b260954662e97f00cab9adb773a259097f7a274b83b113532bce27fa3fb96a'],
-  [2, '0x2fd51571db6c08666b0edfbfbc57d432068bccd0110a39b166ab243da0037197'],
-  [3, '0x000000000000000000000000000000000000000000000000000000000000002e'],
-  [4, '0x00000000000000000000000000000000000000000000000000000000000000ce'],
-  [5, '0x0000000000000000000000000000000000000000000000000000000000000052'],
-  [6, '0x00000000000000000000000000000000000000000000000000000000000000aa'],
-  [7, '0x0000000000000000000000000000000000000000000000000000000000000087'],
-  [8, '0x000000000000000000000000000000000000000000000000000000000000002a'],
-  [9, '0x0000000000000000000000000000000000000000000000000000000000000049'],
-  [10, '0x000000000000000000000000000000000000000000000000000000000000009d'],
-  [11, '0x0000000000000000000000000000000000000000000000000000000000000050'],
-  [12, '0x000000000000000000000000000000000000000000000000000000000000007c'],
-  [13, '0x000000000000000000000000000000000000000000000000000000000000009a'],
-  [14, '0x00000000000000000000000000000000000000000000000000000000000000aa'],
-  [15, '0x00000000000000000000000000000000000000000000000000000000000000df'],
-  [16, '0x0000000000000000000000000000000000000000000000000000000000000023'],
-  [17, '0x0000000000000000000000000000000000000000000000000000000000000034'],
-  [18, '0x0000000000000000000000000000000000000000000000000000000000000010'],
-  [19, '0x000000000000000000000000000000000000000000000000000000000000008a'],
-  [20, '0x0000000000000000000000000000000000000000000000000000000000000047'],
-  [21, '0x0000000000000000000000000000000000000000000000000000000000000063'],
-  [22, '0x00000000000000000000000000000000000000000000000000000000000000e8'],
-  [23, '0x0000000000000000000000000000000000000000000000000000000000000037'],
-  [24, '0x0000000000000000000000000000000000000000000000000000000000000054'],
-  [25, '0x0000000000000000000000000000000000000000000000000000000000000096'],
-  [26, '0x000000000000000000000000000000000000000000000000000000000000003e'],
-  [27, '0x00000000000000000000000000000000000000000000000000000000000000d5'],
-  [28, '0x00000000000000000000000000000000000000000000000000000000000000ae'],
-  [29, '0x0000000000000000000000000000000000000000000000000000000000000024'],
-  [30, '0x000000000000000000000000000000000000000000000000000000000000002d'],
-  [31, '0x0000000000000000000000000000000000000000000000000000000000000020'],
-  [32, '0x0000000000000000000000000000000000000000000000000000000000000080'],
-  [33, '0x000000000000000000000000000000000000000000000000000000000000004d'],
-  [34, '0x0000000000000000000000000000000000000000000000000000000000000047'],
-  [35, '0x00000000000000000000000000000000000000000000000000000000000000a5'],
-  [36, '0x00000000000000000000000000000000000000000000000000000000000000bb'],
-  [37, '0x00000000000000000000000000000000000000000000000000000000000000f6'],
-  [38, '0x00000000000000000000000000000000000000000000000000000000000000c3'],
-  [39, '0x000000000000000000000000000000000000000000000000000000000000000b'],
-  [40, '0x000000000000000000000000000000000000000000000000000000000000003b'],
-  [41, '0x0000000000000000000000000000000000000000000000000000000000000065'],
-  [42, '0x00000000000000000000000000000000000000000000000000000000000000c9'],
-  [43, '0x0000000000000000000000000000000000000000000000000000000000000001'],
-  [44, '0x0000000000000000000000000000000000000000000000000000000000000085'],
-  [45, '0x0000000000000000000000000000000000000000000000000000000000000006'],
-  [46, '0x000000000000000000000000000000000000000000000000000000000000009e'],
-  [47, '0x000000000000000000000000000000000000000000000000000000000000002f'],
-  [48, '0x0000000000000000000000000000000000000000000000000000000000000010'],
-  [49, '0x00000000000000000000000000000000000000000000000000000000000000e6'],
-  [50, '0x0000000000000000000000000000000000000000000000000000000000000030'],
-  [51, '0x000000000000000000000000000000000000000000000000000000000000004a'],
-  [52, '0x0000000000000000000000000000000000000000000000000000000000000018'],
-  [53, '0x000000000000000000000000000000000000000000000000000000000000007c'],
-  [54, '0x00000000000000000000000000000000000000000000000000000000000000d0'],
-  [55, '0x00000000000000000000000000000000000000000000000000000000000000ab'],
-  [56, '0x0000000000000000000000000000000000000000000000000000000000000031'],
-  [57, '0x00000000000000000000000000000000000000000000000000000000000000d5'],
-  [58, '0x0000000000000000000000000000000000000000000000000000000000000063'],
-  [59, '0x0000000000000000000000000000000000000000000000000000000000000084'],
-  [60, '0x00000000000000000000000000000000000000000000000000000000000000a3'],
-  [61, '0x00000000000000000000000000000000000000000000000000000000000000a6'],
-  [62, '0x00000000000000000000000000000000000000000000000000000000000000d5'],
-  [63, '0x0000000000000000000000000000000000000000000000000000000000000091'],
-  [64, '0x000000000000000000000000000000000000000000000000000000000000000d'],
-  [65, '0x000000000000000000000000000000000000000000000000000000000000009c'],
-  [66, '0x00000000000000000000000000000000000000000000000000000000000000f9'],
-  [67, '0x0000000000000000000000000000000000000000000000000000000000000000'],
-  [68, '0x0000000000000000000000000000000000000000000000000000000000000001'],
-  [69, '0x0000000000000000000000000000000000000000000000000000000000000002'],
-  [70, '0x0000000000000000000000000000000000000000000000000000000000000003'],
-  [71, '0x0000000000000000000000000000000000000000000000000000000000000004'],
-  [72, '0x0000000000000000000000000000000000000000000000000000000000000005'],
-  [73, '0x0000000000000000000000000000000000000000000000000000000000000006'],
-  [74, '0x0000000000000000000000000000000000000000000000000000000000000007'],
-  [75, '0x0000000000000000000000000000000000000000000000000000000000000008'],
-  [76, '0x0000000000000000000000000000000000000000000000000000000000000009'],
-]);
-
-export const expectedWitnessMap = new Map(initialWitnessMap).set(
-  77,
-  '0x0000000000000000000000000000000000000000000000000000000000000001',
-);
diff --git a/acvm-repo/blackbox_solver/Cargo.toml b/acvm-repo/blackbox_solver/Cargo.toml
index b8b17db433c..fe3a938c503 100644
--- a/acvm-repo/blackbox_solver/Cargo.toml
+++ b/acvm-repo/blackbox_solver/Cargo.toml
@@ -2,7 +2,7 @@
 name = "acvm_blackbox_solver"
 description = "A solver for the blackbox functions found in ACIR and Brillig"
 # x-release-please-start-version
-version = "0.50.0"
+version = "1.0.0-beta.0"
 # x-release-please-end
 authors.workspace = true
 edition.workspace = true
@@ -22,8 +22,7 @@ num-bigint = "0.4"
 
 blake2 = "0.10.6"
 blake3 = "1.5.0"
-sha2 = { version="0.10.6", features = ["compress",] }
-sha3 = "0.10.6"
+sha2.workspace = true
 keccak = "0.1.4"
 k256 = { version = "0.11.0", features = [
     "ecdsa",
diff --git a/acvm-repo/blackbox_solver/src/bigint.rs b/acvm-repo/blackbox_solver/src/bigint.rs
index b8bc9dc0d70..540862843ab 100644
--- a/acvm-repo/blackbox_solver/src/bigint.rs
+++ b/acvm-repo/blackbox_solver/src/bigint.rs
@@ -97,3 +97,51 @@ impl BigIntSolver {
         Ok(())
     }
 }
+
+/// Wrapper over the generic bigint solver to automatically assign bigint IDs.
+#[derive(Default, Debug, Clone, PartialEq, Eq)]
+pub struct BigIntSolverWithId {
+    solver: BigIntSolver,
+    last_id: u32,
+}
+
+impl BigIntSolverWithId {
+    pub fn create_bigint_id(&mut self) -> u32 {
+        let output = self.last_id;
+        self.last_id += 1;
+        output
+    }
+
+    pub fn bigint_from_bytes(
+        &mut self,
+        inputs: &[u8],
+        modulus: &[u8],
+    ) -> Result<u32, BlackBoxResolutionError> {
+        let id = self.create_bigint_id();
+        self.solver.bigint_from_bytes(inputs, modulus, id)?;
+        Ok(id)
+    }
+
+    pub fn bigint_to_bytes(&self, input: u32) -> Result<Vec<u8>, BlackBoxResolutionError> {
+        self.solver.bigint_to_bytes(input)
+    }
+
+    pub fn bigint_op(
+        &mut self,
+        lhs: u32,
+        rhs: u32,
+        func: BlackBoxFunc,
+    ) -> Result<u32, BlackBoxResolutionError> {
+        let modulus_lhs = self.solver.get_modulus(lhs, func)?;
+        let modulus_rhs = self.solver.get_modulus(rhs, func)?;
+        if modulus_lhs != modulus_rhs {
+            return Err(BlackBoxResolutionError::Failed(
+                func,
+                "moduli should be identical in BigInt operation".to_string(),
+            ));
+        }
+        let id = self.create_bigint_id();
+        self.solver.bigint_op(lhs, rhs, id, func)?;
+        Ok(id)
+    }
+}
diff --git a/acvm-repo/blackbox_solver/src/curve_specific_solver.rs b/acvm-repo/blackbox_solver/src/curve_specific_solver.rs
index f729a5033fb..b8fc3f47033 100644
--- a/acvm-repo/blackbox_solver/src/curve_specific_solver.rs
+++ b/acvm-repo/blackbox_solver/src/curve_specific_solver.rs
@@ -7,23 +7,6 @@ use crate::BlackBoxResolutionError;
 ///
 /// Returns an [`BlackBoxResolutionError`] if the backend does not support the given [`acir::BlackBoxFunc`].
 pub trait BlackBoxFunctionSolver<F> {
-    fn schnorr_verify(
-        &self,
-        public_key_x: &F,
-        public_key_y: &F,
-        signature: &[u8; 64],
-        message: &[u8],
-    ) -> Result<bool, BlackBoxResolutionError>;
-    fn pedersen_commitment(
-        &self,
-        inputs: &[F],
-        domain_separator: u32,
-    ) -> Result<(F, F), BlackBoxResolutionError>;
-    fn pedersen_hash(
-        &self,
-        inputs: &[F],
-        domain_separator: u32,
-    ) -> Result<F, BlackBoxResolutionError>;
     fn multi_scalar_mul(
         &self,
         points: &[F],
@@ -58,30 +41,6 @@ impl StubbedBlackBoxSolver {
 }
 
 impl<F> BlackBoxFunctionSolver<F> for StubbedBlackBoxSolver {
-    fn schnorr_verify(
-        &self,
-        _public_key_x: &F,
-        _public_key_y: &F,
-        _signature: &[u8; 64],
-        _message: &[u8],
-    ) -> Result<bool, BlackBoxResolutionError> {
-        Err(Self::fail(BlackBoxFunc::SchnorrVerify))
-    }
-    fn pedersen_commitment(
-        &self,
-        _inputs: &[F],
-        _domain_separator: u32,
-    ) -> Result<(F, F), BlackBoxResolutionError> {
-        Err(Self::fail(BlackBoxFunc::PedersenCommitment))
-    }
-    fn pedersen_hash(
-        &self,
-        _inputs: &[F],
-        _domain_separator: u32,
-    ) -> Result<F, BlackBoxResolutionError> {
-        Err(Self::fail(BlackBoxFunc::PedersenHash))
-    }
-
     fn multi_scalar_mul(
         &self,
         _points: &[F],
diff --git a/acvm-repo/blackbox_solver/src/hash.rs b/acvm-repo/blackbox_solver/src/hash.rs
index af503117466..660a1fb0e5d 100644
--- a/acvm-repo/blackbox_solver/src/hash.rs
+++ b/acvm-repo/blackbox_solver/src/hash.rs
@@ -1,7 +1,6 @@
 use acir::BlackBoxFunc;
 use blake2::digest::generic_array::GenericArray;
 use blake2::{Blake2s256, Digest};
-use sha3::Keccak256;
 
 use crate::BlackBoxResolutionError;
 
@@ -22,11 +21,6 @@ pub fn blake3(inputs: &[u8]) -> Result<[u8; 32], BlackBoxResolutionError> {
     Ok(blake3::hash(inputs).into())
 }
 
-pub fn keccak256(inputs: &[u8]) -> Result<[u8; 32], BlackBoxResolutionError> {
-    generic_hash_256::<Keccak256>(inputs)
-        .map_err(|err| BlackBoxResolutionError::Failed(BlackBoxFunc::Keccak256, err))
-}
-
 pub fn sha256_compression(state: &mut [u32; 8], msg_blocks: &[u32; 16]) {
     let mut blocks = [0_u8; 64];
     for (i, block) in msg_blocks.iter().enumerate() {
diff --git a/acvm-repo/blackbox_solver/src/lib.rs b/acvm-repo/blackbox_solver/src/lib.rs
index 87ca539f435..0fa56c2f531 100644
--- a/acvm-repo/blackbox_solver/src/lib.rs
+++ b/acvm-repo/blackbox_solver/src/lib.rs
@@ -5,7 +5,7 @@
 
 //! This crate provides the implementation of BlackBox functions of ACIR and Brillig.
 //! For functions that are backend-dependent, it provides a Trait [BlackBoxFunctionSolver] that must be implemented by the backend.
-//! For functions that have a reference implementation, such as [keccak256], this crate exports the reference implementation directly.
+//! For functions that have a reference implementation, such as [keccakf1600], this crate exports the reference implementation directly.
 
 use acir::BlackBoxFunc;
 use thiserror::Error;
@@ -18,10 +18,10 @@ mod hash;
 mod logic;
 
 pub use aes128::aes128_encrypt;
-pub use bigint::BigIntSolver;
+pub use bigint::{BigIntSolver, BigIntSolverWithId};
 pub use curve_specific_solver::{BlackBoxFunctionSolver, StubbedBlackBoxSolver};
 pub use ecdsa::{ecdsa_secp256k1_verify, ecdsa_secp256r1_verify};
-pub use hash::{blake2s, blake3, keccak256, keccakf1600, sha256_compression};
+pub use hash::{blake2s, blake3, keccakf1600, sha256_compression};
 pub use logic::{bit_and, bit_xor};
 
 #[derive(Clone, PartialEq, Eq, Debug, Error)]
diff --git a/acvm-repo/bn254_blackbox_solver/Cargo.toml b/acvm-repo/bn254_blackbox_solver/Cargo.toml
index c892dc45fdd..825a0ef0481 100644
--- a/acvm-repo/bn254_blackbox_solver/Cargo.toml
+++ b/acvm-repo/bn254_blackbox_solver/Cargo.toml
@@ -2,7 +2,7 @@
 name = "bn254_blackbox_solver"
 description = "Solvers for black box functions which are specific for the bn254 curve"
 # x-release-please-start-version
-version = "0.50.0"
+version = "1.0.0-beta.0"
 # x-release-please-end
 authors.workspace = true
 edition.workspace = true
@@ -19,10 +19,10 @@ workspace = true
 acir.workspace = true
 acvm_blackbox_solver.workspace = true
 hex.workspace = true
-lazy_static = "1.4"
+lazy_static.workspace = true
 
 ark-bn254.workspace = true
-grumpkin.workspace = true 
+grumpkin.workspace = true
 ark-ec.workspace = true
 ark-ff.workspace = true
 num-bigint.workspace = true
@@ -30,7 +30,7 @@ num-bigint.workspace = true
 [dev-dependencies]
 ark-std.workspace = true
 criterion = "0.5.0"
-pprof = { version = "0.12", features = [
+pprof = { version = "0.14", features = [
     "flamegraph",
     "frame-pointer",
     "criterion",
diff --git a/acvm-repo/bn254_blackbox_solver/benches/criterion.rs b/acvm-repo/bn254_blackbox_solver/benches/criterion.rs
index e7917fa1adc..fc566b70a26 100644
--- a/acvm-repo/bn254_blackbox_solver/benches/criterion.rs
+++ b/acvm-repo/bn254_blackbox_solver/benches/criterion.rs
@@ -2,8 +2,7 @@ use criterion::{criterion_group, criterion_main, Criterion};
 use std::{hint::black_box, time::Duration};
 
 use acir::{AcirField, FieldElement};
-use acvm_blackbox_solver::BlackBoxFunctionSolver;
-use bn254_blackbox_solver::{poseidon2_permutation, Bn254BlackBoxSolver};
+use bn254_blackbox_solver::poseidon2_permutation;
 
 use pprof::criterion::{Output, PProfProfiler};
 
@@ -13,40 +12,10 @@ fn bench_poseidon2(c: &mut Criterion) {
     c.bench_function("poseidon2", |b| b.iter(|| poseidon2_permutation(black_box(&inputs), 4)));
 }
 
-fn bench_schnorr_verify(c: &mut Criterion) {
-    let pub_key_x = FieldElement::from_hex(
-        "0x04b260954662e97f00cab9adb773a259097f7a274b83b113532bce27fa3fb96a",
-    )
-    .unwrap();
-    let pub_key_y = FieldElement::from_hex(
-        "0x2fd51571db6c08666b0edfbfbc57d432068bccd0110a39b166ab243da0037197",
-    )
-    .unwrap();
-    let sig_bytes: [u8; 64] = [
-        1, 13, 119, 112, 212, 39, 233, 41, 84, 235, 255, 93, 245, 172, 186, 83, 157, 253, 76, 77,
-        33, 128, 178, 15, 214, 67, 105, 107, 177, 234, 77, 48, 27, 237, 155, 84, 39, 84, 247, 27,
-        22, 8, 176, 230, 24, 115, 145, 220, 254, 122, 135, 179, 171, 4, 214, 202, 64, 199, 19, 84,
-        239, 138, 124, 12,
-    ];
-
-    let message: &[u8] = &[0, 1, 2, 3, 4, 5, 6, 7, 8, 9];
-
-    c.bench_function("schnorr_verify", |b| {
-        b.iter(|| {
-            Bn254BlackBoxSolver.schnorr_verify(
-                black_box(&pub_key_x),
-                black_box(&pub_key_y),
-                black_box(&sig_bytes),
-                black_box(message),
-            )
-        })
-    });
-}
-
 criterion_group!(
     name = benches;
     config = Criterion::default().sample_size(40).measurement_time(Duration::from_secs(20)).with_profiler(PProfProfiler::new(100, Output::Flamegraph(None)));
-    targets = bench_poseidon2, bench_schnorr_verify
+    targets = bench_poseidon2
 );
 
 criterion_main!(benches);
diff --git a/acvm-repo/bn254_blackbox_solver/src/embedded_curve_ops.rs b/acvm-repo/bn254_blackbox_solver/src/embedded_curve_ops.rs
index 35cc68051d7..e599fd25593 100644
--- a/acvm-repo/bn254_blackbox_solver/src/embedded_curve_ops.rs
+++ b/acvm-repo/bn254_blackbox_solver/src/embedded_curve_ops.rs
@@ -1,6 +1,5 @@
 // TODO(https://github.com/noir-lang/noir/issues/4932): rename this file to something more generic
 use ark_ec::AffineRepr;
-use ark_ff::MontConfig;
 use num_bigint::BigUint;
 
 use crate::FieldElement;
@@ -16,7 +15,6 @@ pub fn multi_scalar_mul(
     scalars_hi: &[FieldElement],
 ) -> Result<(FieldElement, FieldElement, FieldElement), BlackBoxResolutionError> {
     if points.len() != 3 * scalars_lo.len() || scalars_lo.len() != scalars_hi.len() {
-        dbg!(&points.len(), &scalars_lo.len(), &scalars_hi.len());
         return Err(BlackBoxResolutionError::Failed(
             BlackBoxFunc::MultiScalarMul,
             "Points and scalars must have the same length".to_string(),
@@ -47,15 +45,15 @@ pub fn multi_scalar_mul(
         let mut bytes = scalar_high.to_be_bytes().to_vec();
         bytes.extend_from_slice(&scalar_low.to_be_bytes());
 
-        // Check if this is smaller than the grumpkin modulus
         let grumpkin_integer = BigUint::from_bytes_be(&bytes);
 
-        if grumpkin_integer >= grumpkin::FrConfig::MODULUS.into() {
-            return Err(BlackBoxResolutionError::Failed(
-                BlackBoxFunc::MultiScalarMul,
-                format!("{} is not a valid grumpkin scalar", grumpkin_integer.to_str_radix(16)),
-            ));
-        }
+        // Check if this is smaller than the grumpkin modulus
+        // if grumpkin_integer >= grumpkin::FrConfig::MODULUS.into() {
+        //     return Err(BlackBoxResolutionError::Failed(
+        //         BlackBoxFunc::MultiScalarMul,
+        //         format!("{} is not a valid grumpkin scalar", grumpkin_integer.to_str_radix(16)),
+        //     ));
+        // }
 
         let iteration_output_point =
             grumpkin::SWAffine::from(point.mul_bigint(grumpkin_integer.to_u64_digits()));
@@ -121,8 +119,6 @@ fn create_point(
 mod tests {
     use super::*;
 
-    use ark_ff::BigInteger;
-
     fn get_generator() -> [FieldElement; 3] {
         let generator = grumpkin::SWAffine::generator();
         let generator_x = FieldElement::from_repr(*generator.x().unwrap());
@@ -176,23 +172,23 @@ mod tests {
         assert_eq!(res, expected_error);
     }
 
-    #[test]
-    fn rejects_grumpkin_modulus() {
-        let x = grumpkin::FrConfig::MODULUS.to_bytes_be();
+    // #[test]
+    // fn rejects_grumpkin_modulus() {
+    //     let x = grumpkin::FrConfig::MODULUS.to_bytes_be();
 
-        let low = FieldElement::from_be_bytes_reduce(&x[16..32]);
-        let high = FieldElement::from_be_bytes_reduce(&x[0..16]);
+    //     let low = FieldElement::from_be_bytes_reduce(&x[16..32]);
+    //     let high = FieldElement::from_be_bytes_reduce(&x[0..16]);
 
-        let res = multi_scalar_mul(&get_generator(), &[low], &[high]);
+    //     let res = multi_scalar_mul(&get_generator(), &[low], &[high]);
 
-        assert_eq!(
-            res,
-            Err(BlackBoxResolutionError::Failed(
-                BlackBoxFunc::MultiScalarMul,
-                "30644e72e131a029b85045b68181585d97816a916871ca8d3c208c16d87cfd47 is not a valid grumpkin scalar".into(),
-            ))
-        );
-    }
+    //     assert_eq!(
+    //         res,
+    //         Err(BlackBoxResolutionError::Failed(
+    //             BlackBoxFunc::MultiScalarMul,
+    //             "30644e72e131a029b85045b68181585d97816a916871ca8d3c208c16d87cfd47 is not a valid grumpkin scalar".into(),
+    //         ))
+    //     );
+    // }
 
     #[test]
     fn rejects_invalid_point() {
diff --git a/acvm-repo/bn254_blackbox_solver/src/lib.rs b/acvm-repo/bn254_blackbox_solver/src/lib.rs
index 952c4498d84..f738a375ab1 100644
--- a/acvm-repo/bn254_blackbox_solver/src/lib.rs
+++ b/acvm-repo/bn254_blackbox_solver/src/lib.rs
@@ -6,11 +6,8 @@ use acvm_blackbox_solver::{BlackBoxFunctionSolver, BlackBoxResolutionError};
 
 mod embedded_curve_ops;
 mod generator;
-mod pedersen;
 mod poseidon2;
-mod schnorr;
 
-use ark_ec::AffineRepr;
 pub use embedded_curve_ops::{embedded_curve_add, multi_scalar_mul};
 pub use generator::generators::derive_generators;
 pub use poseidon2::{
@@ -26,51 +23,6 @@ type FieldElement = acir::acir_field::GenericFieldElement<ark_bn254::Fr>;
 pub struct Bn254BlackBoxSolver;
 
 impl BlackBoxFunctionSolver<FieldElement> for Bn254BlackBoxSolver {
-    fn schnorr_verify(
-        &self,
-        public_key_x: &FieldElement,
-        public_key_y: &FieldElement,
-        signature: &[u8; 64],
-        message: &[u8],
-    ) -> Result<bool, BlackBoxResolutionError> {
-        let sig_s: [u8; 32] = signature[0..32].try_into().unwrap();
-        let sig_e: [u8; 32] = signature[32..64].try_into().unwrap();
-        Ok(schnorr::verify_signature(
-            public_key_x.into_repr(),
-            public_key_y.into_repr(),
-            sig_s,
-            sig_e,
-            message,
-        ))
-    }
-
-    fn pedersen_commitment(
-        &self,
-        inputs: &[FieldElement],
-        domain_separator: u32,
-    ) -> Result<(FieldElement, FieldElement), BlackBoxResolutionError> {
-        let inputs: Vec<grumpkin::Fq> = inputs.iter().map(|input| input.into_repr()).collect();
-        let result = pedersen::commitment::commit_native_with_index(&inputs, domain_separator);
-        let result = if let Some((x, y)) = result.xy() {
-            (FieldElement::from_repr(*x), FieldElement::from_repr(*y))
-        } else {
-            (FieldElement::from(0_u128), FieldElement::from(0_u128))
-        };
-
-        Ok(result)
-    }
-
-    fn pedersen_hash(
-        &self,
-        inputs: &[FieldElement],
-        domain_separator: u32,
-    ) -> Result<FieldElement, BlackBoxResolutionError> {
-        let inputs: Vec<grumpkin::Fq> = inputs.iter().map(|input| input.into_repr()).collect();
-        let result = pedersen::hash::hash_with_index(&inputs, domain_separator);
-        let result = FieldElement::from_repr(result);
-        Ok(result)
-    }
-
     fn multi_scalar_mul(
         &self,
         points: &[FieldElement],
diff --git a/acvm-repo/bn254_blackbox_solver/src/pedersen/commitment.rs b/acvm-repo/bn254_blackbox_solver/src/pedersen/commitment.rs
deleted file mode 100644
index 03f03fcf5ab..00000000000
--- a/acvm-repo/bn254_blackbox_solver/src/pedersen/commitment.rs
+++ /dev/null
@@ -1,77 +0,0 @@
-// Taken from: https://github.com/laudiacay/barustenberg/blob/df6bc6f095fe7f288bf6a12e7317fd8eb33d68ae/barustenberg/src/crypto/pedersen/pederson.rs
-
-use ark_ec::{short_weierstrass::Affine, AffineRepr, CurveGroup};
-use ark_ff::{MontConfig, PrimeField};
-use grumpkin::{Fq, FqConfig, Fr, FrConfig, GrumpkinParameters};
-
-use crate::generator::generators::{derive_generators, DEFAULT_DOMAIN_SEPARATOR};
-
-/// Given a vector of fields, generate a pedersen commitment using the indexed generators.
-pub(crate) fn commit_native_with_index(
-    inputs: &[Fq],
-    starting_index: u32,
-) -> Affine<GrumpkinParameters> {
-    let generators =
-        derive_generators(DEFAULT_DOMAIN_SEPARATOR, inputs.len() as u32, starting_index);
-
-    // As |F_r| > |F_q|, we can safely convert any `F_q` into an `F_r` uniquely.
-    assert!(FrConfig::MODULUS > FqConfig::MODULUS);
-
-    inputs.iter().enumerate().fold(Affine::zero(), |mut acc, (i, input)| {
-        acc = (acc + (generators[i] * Fr::from_bigint(input.into_bigint()).unwrap()).into_affine())
-            .into_affine();
-        acc
-    })
-}
-
-#[cfg(test)]
-mod test {
-
-    use acir::AcirField;
-    use ark_ec::short_weierstrass::Affine;
-    use ark_std::{One, Zero};
-    use grumpkin::Fq;
-
-    use crate::pedersen::commitment::commit_native_with_index;
-    use crate::FieldElement;
-
-    #[test]
-    fn commitment() {
-        // https://github.com/AztecProtocol/aztec-packages/blob/72931bdb8202c34042cdfb8cee2ef44b75939879/barretenberg/cpp/src/barretenberg/crypto/pedersen_commitment/pedersen.test.cpp#L10-L18
-        let res = commit_native_with_index(&[Fq::one(), Fq::one()], 0);
-        let expected = Affine::new(
-            FieldElement::from_hex(
-                "0x2f7a8f9a6c96926682205fb73ee43215bf13523c19d7afe36f12760266cdfe15",
-            )
-            .unwrap()
-            .into_repr(),
-            FieldElement::from_hex(
-                "0x01916b316adbbf0e10e39b18c1d24b33ec84b46daddf72f43878bcc92b6057e6",
-            )
-            .unwrap()
-            .into_repr(),
-        );
-
-        assert_eq!(res, expected);
-    }
-
-    #[test]
-    fn commitment_with_zero() {
-        // https://github.com/AztecProtocol/aztec-packages/blob/72931bdb8202c34042cdfb8cee2ef44b75939879/barretenberg/cpp/src/barretenberg/crypto/pedersen_commitment/pedersen.test.cpp#L20-L29
-        let res = commit_native_with_index(&[Fq::zero(), Fq::one()], 0);
-        let expected = Affine::new(
-            FieldElement::from_hex(
-                "0x054aa86a73cb8a34525e5bbed6e43ba1198e860f5f3950268f71df4591bde402",
-            )
-            .unwrap()
-            .into_repr(),
-            FieldElement::from_hex(
-                "0x209dcfbf2cfb57f9f6046f44d71ac6faf87254afc7407c04eb621a6287cac126",
-            )
-            .unwrap()
-            .into_repr(),
-        );
-
-        assert_eq!(res, expected);
-    }
-}
diff --git a/acvm-repo/bn254_blackbox_solver/src/pedersen/hash.rs b/acvm-repo/bn254_blackbox_solver/src/pedersen/hash.rs
deleted file mode 100644
index 152526a9943..00000000000
--- a/acvm-repo/bn254_blackbox_solver/src/pedersen/hash.rs
+++ /dev/null
@@ -1,69 +0,0 @@
-// Taken from: https://github.com/laudiacay/barustenberg/blob/df6bc6f095fe7f288bf6a12e7317fd8eb33d68ae/barustenberg/src/crypto/pedersen/pederson_hash.rs
-
-use std::sync::OnceLock;
-
-use ark_ec::{short_weierstrass::Affine, CurveConfig, CurveGroup};
-use grumpkin::GrumpkinParameters;
-
-use crate::generator::generators::derive_generators;
-
-use super::commitment::commit_native_with_index;
-
-/// Given a vector of fields, generate a pedersen hash using the indexed generators.
-pub(crate) fn hash_with_index(
-    inputs: &[grumpkin::Fq],
-    starting_index: u32,
-) -> <GrumpkinParameters as CurveConfig>::BaseField {
-    let length_as_scalar: <GrumpkinParameters as CurveConfig>::ScalarField =
-        (inputs.len() as u64).into();
-    let length_prefix = *length_generator() * length_as_scalar;
-    let result = length_prefix + commit_native_with_index(inputs, starting_index);
-    result.into_affine().x
-}
-
-fn length_generator() -> &'static Affine<GrumpkinParameters> {
-    static INSTANCE: OnceLock<Affine<GrumpkinParameters>> = OnceLock::new();
-    INSTANCE.get_or_init(|| derive_generators("pedersen_hash_length".as_bytes(), 1, 0)[0])
-}
-
-#[cfg(test)]
-pub(crate) mod test {
-
-    use super::*;
-    use crate::FieldElement;
-
-    use acir::AcirField;
-    use ark_std::One;
-    use grumpkin::Fq;
-
-    //reference: https://github.com/AztecProtocol/barretenberg/blob/master/cpp/src/barretenberg/crypto/pedersen_hash/pedersen.test.cpp
-    #[test]
-    fn hash_one() {
-        // https://github.com/AztecProtocol/aztec-packages/blob/72931bdb8202c34042cdfb8cee2ef44b75939879/barretenberg/cpp/src/barretenberg/crypto/pedersen_hash/pedersen.test.cpp#L21-L26
-        let res = hash_with_index(&[Fq::one(), Fq::one()], 0);
-
-        assert_eq!(
-            res,
-            FieldElement::from_hex(
-                "0x07ebfbf4df29888c6cd6dca13d4bb9d1a923013ddbbcbdc3378ab8845463297b",
-            )
-            .unwrap()
-            .into_repr(),
-        );
-    }
-
-    #[test]
-    fn test_hash_with_index() {
-        // https://github.com/AztecProtocol/aztec-packages/blob/72931bdb8202c34042cdfb8cee2ef44b75939879/barretenberg/cpp/src/barretenberg/crypto/pedersen_hash/pedersen.test.cpp#L28-L33
-        let res = hash_with_index(&[Fq::one(), Fq::one()], 5);
-
-        assert_eq!(
-            res,
-            FieldElement::from_hex(
-                "0x1c446df60816b897cda124524e6b03f36df0cec333fad87617aab70d7861daa6",
-            )
-            .unwrap()
-            .into_repr(),
-        );
-    }
-}
diff --git a/acvm-repo/bn254_blackbox_solver/src/pedersen/mod.rs b/acvm-repo/bn254_blackbox_solver/src/pedersen/mod.rs
deleted file mode 100644
index c3c4ed56450..00000000000
--- a/acvm-repo/bn254_blackbox_solver/src/pedersen/mod.rs
+++ /dev/null
@@ -1,2 +0,0 @@
-pub(crate) mod commitment;
-pub(crate) mod hash;
diff --git a/acvm-repo/bn254_blackbox_solver/src/poseidon2.rs b/acvm-repo/bn254_blackbox_solver/src/poseidon2.rs
index 64823e37029..3aa735388ca 100644
--- a/acvm-repo/bn254_blackbox_solver/src/poseidon2.rs
+++ b/acvm-repo/bn254_blackbox_solver/src/poseidon2.rs
@@ -544,13 +544,23 @@ impl<'a> Poseidon2<'a> {
 }
 
 /// Performs a poseidon hash with a sponge construction equivalent to the one in poseidon2.nr
-pub fn poseidon_hash(inputs: &[FieldElement]) -> Result<FieldElement, BlackBoxResolutionError> {
+///
+/// The `is_variable_length` parameter is there to so we can produce an equivalent hash with
+/// the Barretenberg implementation which distinguishes between variable and fixed length inputs.
+/// Set it to true if the input length matches the static size expected by the Noir function.
+pub fn poseidon_hash(
+    inputs: &[FieldElement],
+    is_variable_length: bool,
+) -> Result<FieldElement, BlackBoxResolutionError> {
     let two_pow_64 = 18446744073709551616_u128.into();
     let iv = FieldElement::from(inputs.len()) * two_pow_64;
     let mut sponge = Poseidon2Sponge::new(iv, 3);
     for input in inputs.iter() {
         sponge.absorb(*input)?;
     }
+    if is_variable_length {
+        sponge.absorb(FieldElement::from(1u32))?;
+    }
     sponge.squeeze()
 }
 
@@ -640,7 +650,7 @@ mod test {
             FieldElement::from(3u128),
             FieldElement::from(4u128),
         ];
-        let result = super::poseidon_hash(&fields).expect("should hash successfully");
+        let result = super::poseidon_hash(&fields, false).expect("should hash successfully");
         assert_eq!(
             result,
             field_from_hex("130bf204a32cac1f0ace56c78b731aa3809f06df2731ebcf6b3464a15788b1b9"),
diff --git a/acvm-repo/bn254_blackbox_solver/src/schnorr/mod.rs b/acvm-repo/bn254_blackbox_solver/src/schnorr/mod.rs
deleted file mode 100644
index 8e3a40803f8..00000000000
--- a/acvm-repo/bn254_blackbox_solver/src/schnorr/mod.rs
+++ /dev/null
@@ -1,147 +0,0 @@
-use acvm_blackbox_solver::blake2s;
-use ark_ec::{
-    short_weierstrass::{Affine, SWCurveConfig},
-    AffineRepr, CurveConfig, CurveGroup,
-};
-use ark_ff::{BigInteger, PrimeField, Zero};
-use grumpkin::{Fq, GrumpkinParameters};
-
-pub(crate) fn verify_signature(
-    pub_key_x: Fq,
-    pub_key_y: Fq,
-    sig_s_bytes: [u8; 32],
-    sig_e_bytes: [u8; 32],
-    message: &[u8],
-) -> bool {
-    let pub_key = Affine::<GrumpkinParameters>::new_unchecked(pub_key_x, pub_key_y);
-
-    if !pub_key.is_on_curve()
-        || !pub_key.is_in_correct_subgroup_assuming_on_curve()
-        || pub_key.is_zero()
-    {
-        return false;
-    }
-
-    let sig_s =
-        <GrumpkinParameters as CurveConfig>::ScalarField::from_be_bytes_mod_order(&sig_s_bytes);
-    let sig_e =
-        <GrumpkinParameters as CurveConfig>::ScalarField::from_be_bytes_mod_order(&sig_e_bytes);
-
-    if sig_s.is_zero() || sig_e.is_zero() {
-        return false;
-    }
-
-    // R = g^{sig.s} • pub^{sig.e}
-    let r = GrumpkinParameters::GENERATOR * sig_s + pub_key * sig_e;
-    if r.is_zero() {
-        // this result implies k == 0, which would be catastrophic for the prover.
-        // it is a cheap check that ensures this doesn't happen.
-        return false;
-    }
-
-    // compare the _hashes_ rather than field elements modulo r
-    // e = H(pedersen(r, pk.x, pk.y), m), where r = R.x
-    let target_e_bytes = schnorr_generate_challenge(message, pub_key_x, pub_key_y, r.into_affine());
-
-    sig_e_bytes == target_e_bytes
-}
-
-fn schnorr_generate_challenge(
-    message: &[u8],
-    pub_key_x: Fq,
-    pub_key_y: Fq,
-    r: Affine<GrumpkinParameters>,
-) -> [u8; 32] {
-    // create challenge message pedersen_commitment(R.x, pubkey)
-
-    let r_x = *r.x().expect("r has been checked to be non-zero");
-    let pedersen_hash = crate::pedersen::hash::hash_with_index(&[r_x, pub_key_x, pub_key_y], 0);
-
-    let mut hash_input: Vec<u8> = pedersen_hash.into_bigint().to_bytes_be();
-    hash_input.extend(message);
-
-    blake2s(&hash_input).unwrap()
-}
-
-#[cfg(test)]
-mod schnorr_tests {
-    use acir::AcirField;
-
-    use super::verify_signature;
-    use crate::FieldElement;
-
-    #[test]
-    fn verifies_valid_signature() {
-        let pub_key_x: grumpkin::Fq = FieldElement::from_hex(
-            "0x04b260954662e97f00cab9adb773a259097f7a274b83b113532bce27fa3fb96a",
-        )
-        .unwrap()
-        .into_repr();
-        let pub_key_y: grumpkin::Fq = FieldElement::from_hex(
-            "0x2fd51571db6c08666b0edfbfbc57d432068bccd0110a39b166ab243da0037197",
-        )
-        .unwrap()
-        .into_repr();
-        let sig_s_bytes: [u8; 32] = [
-            1, 13, 119, 112, 212, 39, 233, 41, 84, 235, 255, 93, 245, 172, 186, 83, 157, 253, 76,
-            77, 33, 128, 178, 15, 214, 67, 105, 107, 177, 234, 77, 48,
-        ];
-        let sig_e_bytes: [u8; 32] = [
-            27, 237, 155, 84, 39, 84, 247, 27, 22, 8, 176, 230, 24, 115, 145, 220, 254, 122, 135,
-            179, 171, 4, 214, 202, 64, 199, 19, 84, 239, 138, 124, 12,
-        ];
-        let message: &[u8] = &[0, 1, 2, 3, 4, 5, 6, 7, 8, 9];
-
-        assert!(verify_signature(pub_key_x, pub_key_y, sig_s_bytes, sig_e_bytes, message));
-    }
-
-    #[test]
-    fn rejects_zero_e() {
-        let pub_key_x: grumpkin::Fq = FieldElement::from_hex(
-            "0x04b260954662e97f00cab9adb773a259097f7a274b83b113532bce27fa3fb96a",
-        )
-        .unwrap()
-        .into_repr();
-        let pub_key_y: grumpkin::Fq = FieldElement::from_hex(
-            "0x2fd51571db6c08666b0edfbfbc57d432068bccd0110a39b166ab243da0037197",
-        )
-        .unwrap()
-        .into_repr();
-        let sig_s_bytes: [u8; 32] = [
-            1, 13, 119, 112, 212, 39, 233, 41, 84, 235, 255, 93, 245, 172, 186, 83, 157, 253, 76,
-            77, 33, 128, 178, 15, 214, 67, 105, 107, 177, 234, 77, 48,
-        ];
-        let sig_e_bytes: [u8; 32] = [
-            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,
-        ];
-        let message: &[u8] = &[0, 1, 2, 3, 4, 5, 6, 7, 8, 9];
-
-        assert!(!verify_signature(pub_key_x, pub_key_y, sig_s_bytes, sig_e_bytes, message));
-    }
-
-    #[test]
-    fn rejects_zero_s() {
-        let pub_key_x: grumpkin::Fq = FieldElement::from_hex(
-            "0x04b260954662e97f00cab9adb773a259097f7a274b83b113532bce27fa3fb96a",
-        )
-        .unwrap()
-        .into_repr();
-        let pub_key_y: grumpkin::Fq = FieldElement::from_hex(
-            "0x2fd51571db6c08666b0edfbfbc57d432068bccd0110a39b166ab243da0037197",
-        )
-        .unwrap()
-        .into_repr();
-        let sig_s_bytes: [u8; 32] = [
-            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,
-        ];
-        let sig_e_bytes: [u8; 32] = [
-            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,
-        ];
-        let message: &[u8] = &[0, 1, 2, 3, 4, 5, 6, 7, 8, 9];
-
-        assert!(!verify_signature(pub_key_x, pub_key_y, sig_s_bytes, sig_e_bytes, message));
-    }
-}
diff --git a/acvm-repo/brillig/Cargo.toml b/acvm-repo/brillig/Cargo.toml
index 0dec8fa2147..9cc724f2b11 100644
--- a/acvm-repo/brillig/Cargo.toml
+++ b/acvm-repo/brillig/Cargo.toml
@@ -2,7 +2,7 @@
 name = "brillig"
 description = "Brillig is the bytecode ACIR uses for non-determinism."
 # x-release-please-start-version
-version = "0.50.0"
+version = "1.0.0-beta.0"
 # x-release-please-end
 authors.workspace = true
 edition.workspace = true
diff --git a/acvm-repo/brillig/src/black_box.rs b/acvm-repo/brillig/src/black_box.rs
index 534ef7d318e..f185b36e6c8 100644
--- a/acvm-repo/brillig/src/black_box.rs
+++ b/acvm-repo/brillig/src/black_box.rs
@@ -3,7 +3,7 @@ use serde::{Deserialize, Serialize};
 
 /// These opcodes provide an equivalent of ACIR blackbox functions.
 /// They are implemented as native functions in the VM.
-#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize)]
+#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize, Hash)]
 pub enum BlackBoxOp {
     /// Encrypts a message using AES128.
     AES128Encrypt {
@@ -22,14 +22,9 @@ pub enum BlackBoxOp {
         message: HeapVector,
         output: HeapArray,
     },
-    /// Calculates the Keccak256 hash of the inputs.
-    Keccak256 {
-        message: HeapVector,
-        output: HeapArray,
-    },
     /// Keccak Permutation function of 1600 width
     Keccakf1600 {
-        message: HeapVector,
+        input: HeapArray,
         output: HeapArray,
     },
     /// Verifies a ECDSA signature over the secp256k1 curve.
@@ -48,26 +43,7 @@ pub enum BlackBoxOp {
         signature: HeapArray,
         result: MemoryAddress,
     },
-    /// Verifies a Schnorr signature over a curve which is "pairing friendly" with the curve on which the Brillig bytecode is defined.
-    SchnorrVerify {
-        public_key_x: MemoryAddress,
-        public_key_y: MemoryAddress,
-        message: HeapVector,
-        signature: HeapVector,
-        result: MemoryAddress,
-    },
-    /// Will be deprecated
-    PedersenCommitment {
-        inputs: HeapVector,
-        domain_separator: MemoryAddress,
-        output: HeapArray,
-    },
-    /// Will be deprecated
-    PedersenHash {
-        inputs: HeapVector,
-        domain_separator: MemoryAddress,
-        output: MemoryAddress,
-    },
+
     /// Performs multi scalar multiplication over the embedded curve.
     MultiScalarMul {
         points: HeapVector,
@@ -119,8 +95,8 @@ pub enum BlackBoxOp {
         len: MemoryAddress,
     },
     Sha256Compression {
-        input: HeapVector,
-        hash_values: HeapVector,
+        input: HeapArray,
+        hash_values: HeapArray,
         output: HeapArray,
     },
     ToRadix {
diff --git a/acvm-repo/brillig/src/lib.rs b/acvm-repo/brillig/src/lib.rs
index 5bd9f898d59..cf31ff79996 100644
--- a/acvm-repo/brillig/src/lib.rs
+++ b/acvm-repo/brillig/src/lib.rs
@@ -4,7 +4,6 @@
 #![cfg_attr(not(test), warn(unused_crate_dependencies, unused_extern_crates))]
 
 //! The Brillig bytecode is distinct from regular [ACIR][acir] in that it does not generate constraints.
-//! This is a generalization over the fixed directives that exists within in the ACVM.
 //!
 //! [acir]: https://crates.io/crates/acir
 //! [acvm]: https://crates.io/crates/acvm
diff --git a/acvm-repo/brillig/src/opcodes.rs b/acvm-repo/brillig/src/opcodes.rs
index 45df2aca2d8..1cb31ca3d0a 100644
--- a/acvm-repo/brillig/src/opcodes.rs
+++ b/acvm-repo/brillig/src/opcodes.rs
@@ -5,23 +5,58 @@ use serde::{Deserialize, Serialize};
 pub type Label = usize;
 
 #[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Serialize, Deserialize)]
-pub struct MemoryAddress(pub usize);
+pub enum MemoryAddress {
+    Direct(usize),
+    Relative(usize),
+}
 
 /// `MemoryAddress` refers to the index in VM memory.
 impl MemoryAddress {
+    pub fn direct(address: usize) -> Self {
+        MemoryAddress::Direct(address)
+    }
+    pub fn relative(offset: usize) -> Self {
+        MemoryAddress::Relative(offset)
+    }
+
+    pub fn unwrap_direct(self) -> usize {
+        match self {
+            MemoryAddress::Direct(address) => address,
+            MemoryAddress::Relative(_) => panic!("Expected direct memory address"),
+        }
+    }
+
+    pub fn unwrap_relative(self) -> usize {
+        match self {
+            MemoryAddress::Direct(_) => panic!("Expected relative memory address"),
+            MemoryAddress::Relative(offset) => offset,
+        }
+    }
+
     pub fn to_usize(self) -> usize {
-        self.0
+        match self {
+            MemoryAddress::Direct(address) => address,
+            MemoryAddress::Relative(offset) => offset,
+        }
+    }
+
+    pub fn is_relative(&self) -> bool {
+        match self {
+            MemoryAddress::Relative(_) => true,
+            MemoryAddress::Direct(_) => false,
+        }
     }
-}
 
-impl From<usize> for MemoryAddress {
-    fn from(value: usize) -> Self {
-        MemoryAddress(value)
+    pub fn offset(&self, amount: usize) -> Self {
+        match self {
+            MemoryAddress::Direct(address) => MemoryAddress::Direct(address + amount),
+            MemoryAddress::Relative(offset) => MemoryAddress::Relative(offset + amount),
+        }
     }
 }
 
 /// Describes the memory layout for an array/vector element
-#[derive(Debug, Clone, Eq, PartialEq, Serialize, Deserialize)]
+#[derive(Debug, Clone, Eq, PartialEq, Serialize, Deserialize, Hash)]
 pub enum HeapValueType {
     // A single field element is enough to represent the value with a given bit size
     Simple(BitSize),
@@ -46,7 +81,7 @@ impl HeapValueType {
 }
 
 /// A fixed-sized array starting from a Brillig memory location.
-#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize, Copy)]
+#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize, Copy, Hash)]
 pub struct HeapArray {
     pub pointer: MemoryAddress,
     pub size: usize,
@@ -54,20 +89,19 @@ pub struct HeapArray {
 
 impl Default for HeapArray {
     fn default() -> Self {
-        Self { pointer: MemoryAddress(0), size: 0 }
+        Self { pointer: MemoryAddress::direct(0), size: 0 }
     }
 }
 
 /// A memory-sized vector passed starting from a Brillig memory location and with a memory-held size
-#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize, Copy)]
+#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize, Copy, Hash)]
 pub struct HeapVector {
     pub pointer: MemoryAddress,
     pub size: MemoryAddress,
 }
 
-#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize, Copy, PartialOrd, Ord)]
+#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize, Copy, PartialOrd, Ord, Hash)]
 pub enum IntegerBitSize {
-    U0, // Uninitialized
     U1,
     U8,
     U16,
@@ -79,7 +113,6 @@ pub enum IntegerBitSize {
 impl From<IntegerBitSize> for u32 {
     fn from(bit_size: IntegerBitSize) -> u32 {
         match bit_size {
-            IntegerBitSize::U0 => 0,
             IntegerBitSize::U1 => 1,
             IntegerBitSize::U8 => 8,
             IntegerBitSize::U16 => 16,
@@ -95,7 +128,6 @@ impl TryFrom<u32> for IntegerBitSize {
 
     fn try_from(value: u32) -> Result<Self, Self::Error> {
         match value {
-            0 => Ok(IntegerBitSize::U0),
             1 => Ok(IntegerBitSize::U1),
             8 => Ok(IntegerBitSize::U8),
             16 => Ok(IntegerBitSize::U16),
@@ -110,7 +142,6 @@ impl TryFrom<u32> for IntegerBitSize {
 impl std::fmt::Display for IntegerBitSize {
     fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
         match self {
-            IntegerBitSize::U0 => write!(f, "null"),
             IntegerBitSize::U1 => write!(f, "bool"),
             IntegerBitSize::U8 => write!(f, "u8"),
             IntegerBitSize::U16 => write!(f, "u16"),
@@ -121,7 +152,7 @@ impl std::fmt::Display for IntegerBitSize {
     }
 }
 
-#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize, Copy, PartialOrd, Ord)]
+#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize, Copy, PartialOrd, Ord, Hash)]
 pub enum BitSize {
     Field,
     Integer(IntegerBitSize),
@@ -150,7 +181,7 @@ impl BitSize {
 /// While we are usually agnostic to how memory is passed within Brillig,
 /// this needs to be encoded somehow when dealing with an external system.
 /// For simplicity, the extra type information is given right in the ForeignCall instructions.
-#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize, Copy)]
+#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize, Copy, Hash)]
 pub enum ValueOrArray {
     /// A single value passed to or from an external call
     /// It is an 'immediate' value - used without dereferencing.
@@ -167,7 +198,7 @@ pub enum ValueOrArray {
     HeapVector(HeapVector),
 }
 
-#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
+#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize, Hash)]
 pub enum BrilligOpcode<F> {
     /// Takes the fields in addresses `lhs` and `rhs`
     /// Performs the specified binary operation
@@ -274,17 +305,16 @@ pub enum BrilligOpcode<F> {
     BlackBox(BlackBoxOp),
     /// Used to denote execution failure, returning data after the offset
     Trap {
-        revert_data: HeapArray,
+        revert_data: HeapVector,
     },
     /// Stop execution, returning data after the offset
     Stop {
-        return_data_offset: usize,
-        return_data_size: usize,
+        return_data: HeapVector,
     },
 }
 
 /// Binary fixed-length field expressions
-#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize)]
+#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize, Hash)]
 pub enum BinaryFieldOp {
     Add,
     Sub,
@@ -302,7 +332,7 @@ pub enum BinaryFieldOp {
 }
 
 /// Binary fixed-length integer expressions
-#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize)]
+#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize, Hash)]
 pub enum BinaryIntOp {
     Add,
     Sub,
diff --git a/acvm-repo/brillig_vm/Cargo.toml b/acvm-repo/brillig_vm/Cargo.toml
index a5e1f7182b1..8225244f9a7 100644
--- a/acvm-repo/brillig_vm/Cargo.toml
+++ b/acvm-repo/brillig_vm/Cargo.toml
@@ -2,7 +2,7 @@
 name = "brillig_vm"
 description = "The virtual machine that processes Brillig bytecode, used to introduce non-determinism to the ACVM"
 # x-release-please-start-version
-version = "0.50.0"
+version = "1.0.0-beta.0"
 # x-release-please-end
 authors.workspace = true
 edition.workspace = true
diff --git a/acvm-repo/brillig_vm/src/black_box.rs b/acvm-repo/brillig_vm/src/black_box.rs
index 56f715c13a9..79aea2adf76 100644
--- a/acvm-repo/brillig_vm/src/black_box.rs
+++ b/acvm-repo/brillig_vm/src/black_box.rs
@@ -1,9 +1,8 @@
 use acir::brillig::{BlackBoxOp, HeapArray, HeapVector, IntegerBitSize};
 use acir::{AcirField, BlackBoxFunc};
-use acvm_blackbox_solver::BigIntSolver;
 use acvm_blackbox_solver::{
-    aes128_encrypt, blake2s, blake3, ecdsa_secp256k1_verify, ecdsa_secp256r1_verify, keccak256,
-    keccakf1600, sha256_compression, BlackBoxFunctionSolver, BlackBoxResolutionError,
+    aes128_encrypt, blake2s, blake3, ecdsa_secp256k1_verify, ecdsa_secp256r1_verify, keccakf1600,
+    sha256_compression, BigIntSolverWithId, BlackBoxFunctionSolver, BlackBoxResolutionError,
 };
 use num_bigint::BigUint;
 use num_traits::Zero;
@@ -39,11 +38,13 @@ fn to_value_vec<F: AcirField>(input: &[u8]) -> Vec<MemoryValue<F>> {
     input.iter().map(|&x| x.into()).collect()
 }
 
+pub(crate) type BrilligBigIntSolver = BigIntSolverWithId;
+
 pub(crate) fn evaluate_black_box<F: AcirField, Solver: BlackBoxFunctionSolver<F>>(
     op: &BlackBoxOp,
     solver: &Solver,
     memory: &mut Memory<F>,
-    bigint_solver: &mut BrilligBigintSolver,
+    bigint_solver: &mut BrilligBigIntSolver,
 ) -> Result<(), BlackBoxResolutionError> {
     match op {
         BlackBoxOp::AES128Encrypt { inputs, iv, key, outputs } => {
@@ -56,7 +57,7 @@ pub(crate) fn evaluate_black_box<F: AcirField, Solver: BlackBoxFunctionSolver<F>
             })?;
             let key: [u8; 16] =
                 to_u8_vec(read_heap_array(memory, key)).try_into().map_err(|_| {
-                    BlackBoxResolutionError::Failed(bb_func, "Invalid ley length".to_string())
+                    BlackBoxResolutionError::Failed(bb_func, "Invalid key length".to_string())
                 })?;
             let ciphertext = aes128_encrypt(&inputs, iv, key)?;
 
@@ -77,14 +78,8 @@ pub(crate) fn evaluate_black_box<F: AcirField, Solver: BlackBoxFunctionSolver<F>
             memory.write_slice(memory.read_ref(output.pointer), &to_value_vec(&bytes));
             Ok(())
         }
-        BlackBoxOp::Keccak256 { message, output } => {
-            let message = to_u8_vec(read_heap_vector(memory, message));
-            let bytes = keccak256(message.as_slice())?;
-            memory.write_slice(memory.read_ref(output.pointer), &to_value_vec(&bytes));
-            Ok(())
-        }
-        BlackBoxOp::Keccakf1600 { message, output } => {
-            let state_vec: Vec<u64> = read_heap_vector(memory, message)
+        BlackBoxOp::Keccakf1600 { input, output } => {
+            let state_vec: Vec<u64> = read_heap_array(memory, input)
                 .iter()
                 .map(|&memory_value| memory_value.try_into().unwrap())
                 .collect();
@@ -146,17 +141,6 @@ pub(crate) fn evaluate_black_box<F: AcirField, Solver: BlackBoxFunctionSolver<F>
             memory.write(*result_address, result.into());
             Ok(())
         }
-        BlackBoxOp::SchnorrVerify { public_key_x, public_key_y, message, signature, result } => {
-            let public_key_x = *memory.read(*public_key_x).extract_field().unwrap();
-            let public_key_y = *memory.read(*public_key_y).extract_field().unwrap();
-            let message: Vec<u8> = to_u8_vec(read_heap_vector(memory, message));
-            let signature: [u8; 64] =
-                to_u8_vec(read_heap_vector(memory, signature)).try_into().unwrap();
-            let verified =
-                solver.schnorr_verify(&public_key_x, &public_key_y, &signature, &message)?;
-            memory.write(*result, verified.into());
-            Ok(())
-        }
         BlackBoxOp::MultiScalarMul { points, scalars, outputs: result } => {
             let points: Vec<F> = read_heap_vector(memory, points)
                 .iter()
@@ -227,41 +211,6 @@ pub(crate) fn evaluate_black_box<F: AcirField, Solver: BlackBoxFunctionSolver<F>
             );
             Ok(())
         }
-        BlackBoxOp::PedersenCommitment { inputs, domain_separator, output } => {
-            let inputs: Vec<F> = read_heap_vector(memory, inputs)
-                .iter()
-                .map(|x| *x.extract_field().unwrap())
-                .collect();
-            let domain_separator: u32 =
-                memory.read(*domain_separator).try_into().map_err(|_| {
-                    BlackBoxResolutionError::Failed(
-                        BlackBoxFunc::PedersenCommitment,
-                        "Invalid separator length".to_string(),
-                    )
-                })?;
-            let (x, y) = solver.pedersen_commitment(&inputs, domain_separator)?;
-            memory.write_slice(
-                memory.read_ref(output.pointer),
-                &[MemoryValue::new_field(x), MemoryValue::new_field(y)],
-            );
-            Ok(())
-        }
-        BlackBoxOp::PedersenHash { inputs, domain_separator, output } => {
-            let inputs: Vec<F> = read_heap_vector(memory, inputs)
-                .iter()
-                .map(|x| *x.extract_field().unwrap())
-                .collect();
-            let domain_separator: u32 =
-                memory.read(*domain_separator).try_into().map_err(|_| {
-                    BlackBoxResolutionError::Failed(
-                        BlackBoxFunc::PedersenCommitment,
-                        "Invalid separator length".to_string(),
-                    )
-                })?;
-            let hash = solver.pedersen_hash(&inputs, domain_separator)?;
-            memory.write(*output, MemoryValue::new_field(hash));
-            Ok(())
-        }
         BlackBoxOp::BigIntAdd { lhs, rhs, output } => {
             let lhs = memory.read(*lhs).try_into().unwrap();
             let rhs = memory.read(*rhs).try_into().unwrap();
@@ -333,7 +282,7 @@ pub(crate) fn evaluate_black_box<F: AcirField, Solver: BlackBoxFunctionSolver<F>
         }
         BlackBoxOp::Sha256Compression { input, hash_values, output } => {
             let mut message = [0; 16];
-            let inputs = read_heap_vector(memory, input);
+            let inputs = read_heap_array(memory, input);
             if inputs.len() != 16 {
                 return Err(BlackBoxResolutionError::Failed(
                     BlackBoxFunc::Sha256Compression,
@@ -344,7 +293,7 @@ pub(crate) fn evaluate_black_box<F: AcirField, Solver: BlackBoxFunctionSolver<F>
                 message[i] = input.try_into().unwrap();
             }
             let mut state = [0; 8];
-            let values = read_heap_vector(memory, hash_values);
+            let values = read_heap_array(memory, hash_values);
             if values.len() != 8 {
                 return Err(BlackBoxResolutionError::Failed(
                     BlackBoxFunc::Sha256Compression,
@@ -371,18 +320,18 @@ pub(crate) fn evaluate_black_box<F: AcirField, Solver: BlackBoxFunctionSolver<F>
             let mut input = BigUint::from_bytes_be(&input.to_be_bytes());
             let radix = BigUint::from_bytes_be(&radix.to_be_bytes());
 
-            let mut limbs: Vec<MemoryValue<F>> = Vec::with_capacity(output.size);
+            let mut limbs: Vec<MemoryValue<F>> = vec![MemoryValue::default(); output.size];
 
-            for _ in 0..output.size {
+            for i in (0..output.size).rev() {
                 let limb = &input % &radix;
                 if *output_bits {
-                    limbs.push(MemoryValue::new_integer(
+                    limbs[i] = MemoryValue::new_integer(
                         if limb.is_zero() { 0 } else { 1 },
                         IntegerBitSize::U1,
-                    ));
+                    );
                 } else {
                     let limb: u8 = limb.try_into().unwrap();
-                    limbs.push(MemoryValue::new_integer(limb as u128, IntegerBitSize::U8));
+                    limbs[i] = MemoryValue::new_integer(limb as u128, IntegerBitSize::U8);
                 };
                 input /= &radix;
             }
@@ -394,64 +343,14 @@ pub(crate) fn evaluate_black_box<F: AcirField, Solver: BlackBoxFunctionSolver<F>
     }
 }
 
-/// Wrapper over the generic bigint solver to automatically assign bigint ids in brillig
-#[derive(Default, Debug, Clone, PartialEq, Eq)]
-pub(crate) struct BrilligBigintSolver {
-    bigint_solver: BigIntSolver,
-    last_id: u32,
-}
-
-impl BrilligBigintSolver {
-    pub(crate) fn create_bigint_id(&mut self) -> u32 {
-        let output = self.last_id;
-        self.last_id += 1;
-        output
-    }
-
-    pub(crate) fn bigint_from_bytes(
-        &mut self,
-        inputs: &[u8],
-        modulus: &[u8],
-    ) -> Result<u32, BlackBoxResolutionError> {
-        let id = self.create_bigint_id();
-        self.bigint_solver.bigint_from_bytes(inputs, modulus, id)?;
-        Ok(id)
-    }
-
-    pub(crate) fn bigint_to_bytes(&self, input: u32) -> Result<Vec<u8>, BlackBoxResolutionError> {
-        self.bigint_solver.bigint_to_bytes(input)
-    }
-
-    pub(crate) fn bigint_op(
-        &mut self,
-        lhs: u32,
-        rhs: u32,
-        func: BlackBoxFunc,
-    ) -> Result<u32, BlackBoxResolutionError> {
-        let modulus_lhs = self.bigint_solver.get_modulus(lhs, func)?;
-        let modulus_rhs = self.bigint_solver.get_modulus(rhs, func)?;
-        if modulus_lhs != modulus_rhs {
-            return Err(BlackBoxResolutionError::Failed(
-                func,
-                "moduli should be identical in BigInt operation".to_string(),
-            ));
-        }
-        let id = self.create_bigint_id();
-        self.bigint_solver.bigint_op(lhs, rhs, id, func)?;
-        Ok(id)
-    }
-}
-
 fn black_box_function_from_op(op: &BlackBoxOp) -> BlackBoxFunc {
     match op {
         BlackBoxOp::AES128Encrypt { .. } => BlackBoxFunc::AES128Encrypt,
         BlackBoxOp::Blake2s { .. } => BlackBoxFunc::Blake2s,
         BlackBoxOp::Blake3 { .. } => BlackBoxFunc::Blake3,
-        BlackBoxOp::Keccak256 { .. } => BlackBoxFunc::Keccak256,
         BlackBoxOp::Keccakf1600 { .. } => BlackBoxFunc::Keccakf1600,
         BlackBoxOp::EcdsaSecp256k1 { .. } => BlackBoxFunc::EcdsaSecp256k1,
         BlackBoxOp::EcdsaSecp256r1 { .. } => BlackBoxFunc::EcdsaSecp256r1,
-        BlackBoxOp::SchnorrVerify { .. } => BlackBoxFunc::SchnorrVerify,
         BlackBoxOp::MultiScalarMul { .. } => BlackBoxFunc::MultiScalarMul,
         BlackBoxOp::EmbeddedCurveAdd { .. } => BlackBoxFunc::EmbeddedCurveAdd,
         BlackBoxOp::BigIntAdd { .. } => BlackBoxFunc::BigIntAdd,
@@ -463,7 +362,5 @@ fn black_box_function_from_op(op: &BlackBoxOp) -> BlackBoxFunc {
         BlackBoxOp::Poseidon2Permutation { .. } => BlackBoxFunc::Poseidon2Permutation,
         BlackBoxOp::Sha256Compression { .. } => BlackBoxFunc::Sha256Compression,
         BlackBoxOp::ToRadix { .. } => unreachable!("ToRadix is not an ACIR BlackBoxFunc"),
-        BlackBoxOp::PedersenCommitment { .. } => BlackBoxFunc::PedersenCommitment,
-        BlackBoxOp::PedersenHash { .. } => BlackBoxFunc::PedersenHash,
     }
 }
diff --git a/acvm-repo/brillig_vm/src/lib.rs b/acvm-repo/brillig_vm/src/lib.rs
index 07d0ea02ad4..5b3688339b5 100644
--- a/acvm-repo/brillig_vm/src/lib.rs
+++ b/acvm-repo/brillig_vm/src/lib.rs
@@ -6,7 +6,6 @@
 //! The Brillig VM is a specialized VM which allows the [ACVM][acvm] to perform custom non-determinism.
 //!
 //! Brillig bytecode is distinct from regular [ACIR][acir] in that it does not generate constraints.
-//! This is a generalization over the fixed directives that exists within in the ACVM.
 //!
 //! [acir]: https://crates.io/crates/acir
 //! [acvm]: https://crates.io/crates/acvm
@@ -18,7 +17,7 @@ use acir::brillig::{
 use acir::AcirField;
 use acvm_blackbox_solver::BlackBoxFunctionSolver;
 use arithmetic::{evaluate_binary_field_op, evaluate_binary_int_op, BrilligArithmeticError};
-use black_box::{evaluate_black_box, BrilligBigintSolver};
+use black_box::{evaluate_black_box, BrilligBigIntSolver};
 
 // Re-export `brillig`.
 pub use acir::brillig;
@@ -63,6 +62,15 @@ pub enum VMStatus<F> {
     },
 }
 
+// A sample for each opcode that was executed.
+pub type BrilligProfilingSamples = Vec<BrilligProfilingSample>;
+
+#[derive(Debug, PartialEq, Eq, Clone)]
+pub struct BrilligProfilingSample {
+    // The call stack when processing a given opcode.
+    pub call_stack: Vec<usize>,
+}
+
 #[derive(Debug, PartialEq, Eq, Clone)]
 /// VM encapsulates the state of the Brillig VM during execution.
 pub struct VM<'a, F, B: BlackBoxFunctionSolver<F>> {
@@ -87,7 +95,11 @@ pub struct VM<'a, F, B: BlackBoxFunctionSolver<F>> {
     /// The solver for blackbox functions
     black_box_solver: &'a B,
     // The solver for big integers
-    bigint_solver: BrilligBigintSolver,
+    bigint_solver: BrilligBigIntSolver,
+    // Flag that determines whether we want to profile VM.
+    profiling_active: bool,
+    // Samples for profiling the VM execution.
+    profiling_samples: BrilligProfilingSamples,
 }
 
 impl<'a, F: AcirField, B: BlackBoxFunctionSolver<F>> VM<'a, F, B> {
@@ -97,6 +109,7 @@ impl<'a, F: AcirField, B: BlackBoxFunctionSolver<F>> VM<'a, F, B> {
         bytecode: &'a [Opcode<F>],
         foreign_call_results: Vec<ForeignCallResult<F>>,
         black_box_solver: &'a B,
+        profiling_active: bool,
     ) -> Self {
         Self {
             calldata,
@@ -109,9 +122,19 @@ impl<'a, F: AcirField, B: BlackBoxFunctionSolver<F>> VM<'a, F, B> {
             call_stack: Vec::new(),
             black_box_solver,
             bigint_solver: Default::default(),
+            profiling_active,
+            profiling_samples: Vec::with_capacity(bytecode.len()),
         }
     }
 
+    pub fn is_profiling_active(&self) -> bool {
+        self.profiling_active
+    }
+
+    pub fn take_profiling_samples(&mut self) -> BrilligProfilingSamples {
+        std::mem::take(&mut self.profiling_samples)
+    }
+
     /// Updates the current status of the VM.
     /// Returns the given status.
     fn status(&mut self, status: VMStatus<F>) -> VMStatus<F> {
@@ -185,7 +208,7 @@ impl<'a, F: AcirField, B: BlackBoxFunctionSolver<F>> VM<'a, F, B> {
     }
 
     pub fn write_memory_at(&mut self, ptr: usize, value: MemoryValue<F>) {
-        self.memory.write(MemoryAddress(ptr), value);
+        self.memory.write(MemoryAddress::direct(ptr), value);
     }
 
     /// Returns the VM's current call stack, including the actual program
@@ -196,6 +219,15 @@ impl<'a, F: AcirField, B: BlackBoxFunctionSolver<F>> VM<'a, F, B> {
 
     /// Process a single opcode and modify the program counter.
     pub fn process_opcode(&mut self) -> VMStatus<F> {
+        if self.profiling_active {
+            let call_stack: Vec<usize> = self.get_call_stack();
+            self.profiling_samples.push(BrilligProfilingSample { call_stack });
+        }
+
+        self.process_opcode_internal()
+    }
+
+    fn process_opcode_internal(&mut self) -> VMStatus<F> {
         let opcode = &self.bytecode[self.program_counter];
         match opcode {
             Opcode::BinaryFieldOp { op, lhs, rhs, destination: result } => {
@@ -314,14 +346,26 @@ impl<'a, F: AcirField, B: BlackBoxFunctionSolver<F>> VM<'a, F, B> {
                 self.increment_program_counter()
             }
             Opcode::Trap { revert_data } => {
-                if revert_data.size > 0 {
-                    self.trap(self.memory.read_ref(revert_data.pointer).0, revert_data.size)
+                let revert_data_size = self.memory.read(revert_data.size).to_usize();
+                if revert_data_size > 0 {
+                    self.trap(
+                        self.memory.read_ref(revert_data.pointer).unwrap_direct(),
+                        revert_data_size,
+                    )
                 } else {
                     self.trap(0, 0)
                 }
             }
-            Opcode::Stop { return_data_offset, return_data_size } => {
-                self.finish(*return_data_offset, *return_data_size)
+            Opcode::Stop { return_data } => {
+                let return_data_size = self.memory.read(return_data.size).to_usize();
+                if return_data_size > 0 {
+                    self.finish(
+                        self.memory.read_ref(return_data.pointer).unwrap_direct(),
+                        return_data_size,
+                    )
+                } else {
+                    self.finish(0, 0)
+                }
             }
             Opcode::Load { destination: destination_address, source_pointer } => {
                 // Convert our source_pointer to an address
@@ -437,6 +481,7 @@ impl<'a, F: AcirField, B: BlackBoxFunctionSolver<F>> VM<'a, F, B> {
         size: usize,
         value_types: &[HeapValueType],
     ) -> Vec<MemoryValue<F>> {
+        assert!(!start.is_relative(), "read_slice_of_values_from_memory requires direct addresses");
         if HeapValueType::all_simple(value_types) {
             self.memory.read_slice(start, size).to_vec()
         } else {
@@ -449,20 +494,25 @@ impl<'a, F: AcirField, B: BlackBoxFunctionSolver<F>> VM<'a, F, B> {
             (0..size)
                 .zip(value_types.iter().cycle())
                 .flat_map(|(i, value_type)| {
-                    let value_address: MemoryAddress = (start.to_usize() + i).into();
+                    let value_address = start.offset(i);
                     match value_type {
                         HeapValueType::Simple(_) => {
                             vec![self.memory.read(value_address)]
                         }
                         HeapValueType::Array { value_types, size } => {
                             let array_address = self.memory.read_ref(value_address);
-                            let items_start = MemoryAddress(array_address.to_usize() + 1);
-                            self.read_slice_of_values_from_memory(items_start, *size, value_types)
+
+                            self.read_slice_of_values_from_memory(
+                                array_address.offset(1),
+                                *size,
+                                value_types,
+                            )
                         }
                         HeapValueType::Vector { value_types } => {
                             let vector_address = self.memory.read_ref(value_address);
-                            let size_address = MemoryAddress(vector_address.to_usize() + 1);
-                            let items_start = MemoryAddress(vector_address.to_usize() + 2);
+                            let size_address =
+                                MemoryAddress::direct(vector_address.unwrap_direct() + 1);
+                            let items_start = vector_address.offset(2);
                             let vector_size = self.memory.read(size_address).to_usize();
                             self.read_slice_of_values_from_memory(
                                 items_start,
@@ -630,13 +680,17 @@ impl<'a, F: AcirField, B: BlackBoxFunctionSolver<F>> VM<'a, F, B> {
         values: &Vec<F>,
         values_idx: &mut usize,
         value_type: &HeapValueType,
-    ) -> Result<MemoryAddress, String> {
+    ) -> Result<(), String> {
+        assert!(
+            !destination.is_relative(),
+            "write_slice_of_values_to_memory requires direct addresses"
+        );
         let mut current_pointer = destination;
         match value_type {
             HeapValueType::Simple(bit_size) => {
                 self.write_value_to_memory(destination, &values[*values_idx], *bit_size)?;
                 *values_idx += 1;
-                Ok(MemoryAddress(destination.to_usize() + 1))
+                Ok(())
             }
             HeapValueType::Array { value_types, size } => {
                 for _ in 0..*size {
@@ -649,18 +703,17 @@ impl<'a, F: AcirField, B: BlackBoxFunctionSolver<F>> VM<'a, F, B> {
                                     *len,
                                 )?;
                                 *values_idx += 1;
-                                current_pointer = MemoryAddress(current_pointer.to_usize() + 1);
+                                current_pointer = current_pointer.offset(1);
                             }
                             HeapValueType::Array { .. } => {
-                                let destination =
-                                    MemoryAddress(self.memory.read_ref(current_pointer).0 + 1);
+                                let destination = self.memory.read_ref(current_pointer).offset(1);
                                 self.write_slice_of_values_to_memory(
                                     destination,
                                     values,
                                     values_idx,
                                     typ,
                                 )?;
-                                current_pointer = MemoryAddress(current_pointer.to_usize() + 1);
+                                current_pointer = current_pointer.offset(1);
                             }
                             HeapValueType::Vector { .. } => {
                                 return Err(format!(
@@ -671,7 +724,7 @@ impl<'a, F: AcirField, B: BlackBoxFunctionSolver<F>> VM<'a, F, B> {
                         }
                     }
                 }
-                Ok(current_pointer)
+                Ok(())
             }
             HeapValueType::Vector { .. } => {
                 Err(format!("Unsupported returned type in foreign calls {:?}", value_type))
@@ -795,13 +848,13 @@ mod tests {
         let calldata = vec![];
 
         let opcodes = [Opcode::Const {
-            destination: MemoryAddress(0),
+            destination: MemoryAddress::direct(0),
             bit_size: BitSize::Integer(IntegerBitSize::U32),
             value: FieldElement::from(27u128),
         }];
 
         // Start VM
-        let mut vm = VM::new(calldata, &opcodes, vec![], &StubbedBlackBoxSolver);
+        let mut vm = VM::new(calldata, &opcodes, vec![], &StubbedBlackBoxSolver, false);
 
         let status = vm.process_opcode();
         assert_eq!(status, VMStatus::Finished { return_data_offset: 0, return_data_size: 0 });
@@ -809,7 +862,7 @@ mod tests {
         // The address at index `2` should have the value of 3 since we had an
         // add opcode
         let VM { memory, .. } = vm;
-        let output_value = memory.read(MemoryAddress::from(0));
+        let output_value = memory.read(MemoryAddress::direct(0));
 
         assert_eq!(output_value.to_field(), FieldElement::from(27u128));
     }
@@ -820,38 +873,38 @@ mod tests {
 
         let lhs = {
             calldata.push(2u128.into());
-            MemoryAddress::from(calldata.len() - 1)
+            MemoryAddress::direct(calldata.len() - 1)
         };
 
         let rhs = {
             calldata.push(2u128.into());
-            MemoryAddress::from(calldata.len() - 1)
+            MemoryAddress::direct(calldata.len() - 1)
         };
 
-        let destination = MemoryAddress::from(calldata.len());
+        let destination = MemoryAddress::direct(calldata.len());
 
         let opcodes = vec![
             Opcode::Const {
-                destination: MemoryAddress(0),
+                destination: MemoryAddress::direct(0),
                 bit_size: BitSize::Integer(IntegerBitSize::U32),
                 value: FieldElement::from(2u64),
             },
             Opcode::Const {
-                destination: MemoryAddress(1),
+                destination: MemoryAddress::direct(1),
                 bit_size: BitSize::Integer(IntegerBitSize::U32),
                 value: FieldElement::from(0u64),
             },
             Opcode::CalldataCopy {
-                destination_address: MemoryAddress(0),
-                size_address: MemoryAddress(0),
-                offset_address: MemoryAddress(1),
+                destination_address: MemoryAddress::direct(0),
+                size_address: MemoryAddress::direct(0),
+                offset_address: MemoryAddress::direct(1),
             },
             Opcode::BinaryFieldOp { destination, op: BinaryFieldOp::Equals, lhs, rhs },
             Opcode::Jump { location: 5 },
             Opcode::JumpIf { condition: destination, location: 6 },
         ];
 
-        let mut vm = VM::new(calldata, &opcodes, vec![], &StubbedBlackBoxSolver);
+        let mut vm = VM::new(calldata, &opcodes, vec![], &StubbedBlackBoxSolver, false);
 
         let status = vm.process_opcode();
         assert_eq!(status, VMStatus::InProgress);
@@ -878,38 +931,48 @@ mod tests {
 
         let opcodes = vec![
             Opcode::Const {
-                destination: MemoryAddress(0),
+                destination: MemoryAddress::direct(0),
                 bit_size: BitSize::Integer(IntegerBitSize::U32),
                 value: FieldElement::from(2u64),
             },
             Opcode::Const {
-                destination: MemoryAddress(1),
+                destination: MemoryAddress::direct(1),
                 bit_size: BitSize::Integer(IntegerBitSize::U32),
                 value: FieldElement::from(0u64),
             },
             Opcode::CalldataCopy {
-                destination_address: MemoryAddress(0),
-                size_address: MemoryAddress(0),
-                offset_address: MemoryAddress(1),
+                destination_address: MemoryAddress::direct(0),
+                size_address: MemoryAddress::direct(0),
+                offset_address: MemoryAddress::direct(1),
+            },
+            Opcode::Jump { location: 6 },
+            Opcode::Const {
+                destination: MemoryAddress::direct(0),
+                bit_size: BitSize::Integer(IntegerBitSize::U32),
+                value: FieldElement::from(0u64),
+            },
+            Opcode::Trap {
+                revert_data: HeapVector {
+                    pointer: MemoryAddress::direct(0),
+                    size: MemoryAddress::direct(0),
+                },
             },
-            Opcode::Jump { location: 5 },
-            Opcode::Trap { revert_data: HeapArray::default() },
             Opcode::BinaryFieldOp {
                 op: BinaryFieldOp::Equals,
-                lhs: MemoryAddress::from(0),
-                rhs: MemoryAddress::from(1),
-                destination: MemoryAddress::from(2),
+                lhs: MemoryAddress::direct(0),
+                rhs: MemoryAddress::direct(1),
+                destination: MemoryAddress::direct(2),
             },
-            Opcode::JumpIfNot { condition: MemoryAddress::from(2), location: 4 },
+            Opcode::JumpIfNot { condition: MemoryAddress::direct(2), location: 4 },
             Opcode::BinaryFieldOp {
                 op: BinaryFieldOp::Add,
-                lhs: MemoryAddress::from(0),
-                rhs: MemoryAddress::from(1),
-                destination: MemoryAddress::from(2),
+                lhs: MemoryAddress::direct(0),
+                rhs: MemoryAddress::direct(1),
+                destination: MemoryAddress::direct(2),
             },
         ];
 
-        let mut vm = VM::new(calldata, &opcodes, vec![], &StubbedBlackBoxSolver);
+        let mut vm = VM::new(calldata, &opcodes, vec![], &StubbedBlackBoxSolver, false);
 
         let status = vm.process_opcode();
         assert_eq!(status, VMStatus::InProgress);
@@ -921,8 +984,10 @@ mod tests {
         assert_eq!(status, VMStatus::InProgress);
         let status = vm.process_opcode();
         assert_eq!(status, VMStatus::InProgress);
+        let status = vm.process_opcode();
+        assert_eq!(status, VMStatus::InProgress);
 
-        let output_cmp_value = vm.memory.read(MemoryAddress::from(2));
+        let output_cmp_value = vm.memory.read(MemoryAddress::direct(2));
         assert_eq!(output_cmp_value.to_field(), false.into());
 
         let status = vm.process_opcode();
@@ -933,13 +998,13 @@ mod tests {
             status,
             VMStatus::Failure {
                 reason: FailureReason::Trap { revert_data_offset: 0, revert_data_size: 0 },
-                call_stack: vec![4]
+                call_stack: vec![5]
             }
         );
 
         // The address at index `2` should have not changed as we jumped over the add opcode
         let VM { memory, .. } = vm;
-        let output_value = memory.read(MemoryAddress::from(2));
+        let output_value = memory.read(MemoryAddress::direct(2));
         assert_eq!(output_value.to_field(), false.into());
     }
 
@@ -947,30 +1012,39 @@ mod tests {
     fn cast_opcode() {
         let calldata: Vec<FieldElement> = vec![((2_u128.pow(32)) - 1).into()];
 
+        let value_address = MemoryAddress::direct(1);
+        let one_usize = MemoryAddress::direct(2);
+        let zero_usize = MemoryAddress::direct(3);
+
         let opcodes = &[
             Opcode::Const {
-                destination: MemoryAddress(0),
+                destination: one_usize,
                 bit_size: BitSize::Integer(IntegerBitSize::U32),
                 value: FieldElement::from(1u64),
             },
             Opcode::Const {
-                destination: MemoryAddress(1),
+                destination: zero_usize,
                 bit_size: BitSize::Integer(IntegerBitSize::U32),
                 value: FieldElement::from(0u64),
             },
             Opcode::CalldataCopy {
-                destination_address: MemoryAddress(0),
-                size_address: MemoryAddress(0),
-                offset_address: MemoryAddress(1),
+                destination_address: value_address,
+                size_address: one_usize,
+                offset_address: zero_usize,
             },
             Opcode::Cast {
-                destination: MemoryAddress::from(1),
-                source: MemoryAddress::from(0),
+                destination: value_address,
+                source: value_address,
                 bit_size: BitSize::Integer(IntegerBitSize::U8),
             },
-            Opcode::Stop { return_data_offset: 1, return_data_size: 1 },
+            Opcode::Stop {
+                return_data: HeapVector {
+                    pointer: one_usize, // Since value_address is direct(1)
+                    size: one_usize,
+                },
+            },
         ];
-        let mut vm = VM::new(calldata, opcodes, vec![], &StubbedBlackBoxSolver);
+        let mut vm = VM::new(calldata, opcodes, vec![], &StubbedBlackBoxSolver, false);
 
         let status = vm.process_opcode();
         assert_eq!(status, VMStatus::InProgress);
@@ -985,7 +1059,7 @@ mod tests {
 
         let VM { memory, .. } = vm;
 
-        let casted_value = memory.read(MemoryAddress::from(1));
+        let casted_value = memory.read(MemoryAddress::direct(1));
         assert_eq!(casted_value.to_field(), (2_u128.pow(8) - 1).into());
     }
 
@@ -993,35 +1067,44 @@ mod tests {
     fn not_opcode() {
         let calldata: Vec<FieldElement> = vec![(1_usize).into()];
 
+        let value_address = MemoryAddress::direct(1);
+        let one_usize = MemoryAddress::direct(2);
+        let zero_usize = MemoryAddress::direct(3);
+
         let opcodes = &[
             Opcode::Const {
-                destination: MemoryAddress(0),
+                destination: one_usize,
                 bit_size: BitSize::Integer(IntegerBitSize::U32),
                 value: FieldElement::from(1u64),
             },
             Opcode::Const {
-                destination: MemoryAddress(1),
+                destination: zero_usize,
                 bit_size: BitSize::Integer(IntegerBitSize::U32),
                 value: FieldElement::from(0u64),
             },
             Opcode::CalldataCopy {
-                destination_address: MemoryAddress(0),
-                size_address: MemoryAddress(0),
-                offset_address: MemoryAddress(1),
+                destination_address: value_address,
+                size_address: one_usize,
+                offset_address: zero_usize,
             },
             Opcode::Cast {
-                destination: MemoryAddress::from(1),
-                source: MemoryAddress::from(0),
+                destination: value_address,
+                source: value_address,
                 bit_size: BitSize::Integer(IntegerBitSize::U128),
             },
             Opcode::Not {
-                destination: MemoryAddress::from(1),
-                source: MemoryAddress::from(1),
+                destination: value_address,
+                source: value_address,
                 bit_size: IntegerBitSize::U128,
             },
-            Opcode::Stop { return_data_offset: 1, return_data_size: 1 },
+            Opcode::Stop {
+                return_data: HeapVector {
+                    pointer: one_usize, // Since value_address is direct(1)
+                    size: one_usize,
+                },
+            },
         ];
-        let mut vm = VM::new(calldata, opcodes, vec![], &StubbedBlackBoxSolver);
+        let mut vm = VM::new(calldata, opcodes, vec![], &StubbedBlackBoxSolver, false);
 
         let status = vm.process_opcode();
         assert_eq!(status, VMStatus::InProgress);
@@ -1039,7 +1122,7 @@ mod tests {
         let VM { memory, .. } = vm;
 
         let (negated_value, _) = memory
-            .read(MemoryAddress::from(1))
+            .read(MemoryAddress::direct(1))
             .extract_integer()
             .expect("Expected integer as the output of Not");
         assert_eq!(negated_value, !1_u128);
@@ -1051,23 +1134,23 @@ mod tests {
 
         let opcodes = &[
             Opcode::Const {
-                destination: MemoryAddress(0),
+                destination: MemoryAddress::direct(0),
                 bit_size: BitSize::Integer(IntegerBitSize::U32),
                 value: FieldElement::from(3u64),
             },
             Opcode::Const {
-                destination: MemoryAddress(1),
+                destination: MemoryAddress::direct(1),
                 bit_size: BitSize::Integer(IntegerBitSize::U32),
                 value: FieldElement::from(0u64),
             },
             Opcode::CalldataCopy {
-                destination_address: MemoryAddress(0),
-                size_address: MemoryAddress(0),
-                offset_address: MemoryAddress(1),
+                destination_address: MemoryAddress::direct(0),
+                size_address: MemoryAddress::direct(0),
+                offset_address: MemoryAddress::direct(1),
             },
-            Opcode::Mov { destination: MemoryAddress::from(2), source: MemoryAddress::from(0) },
+            Opcode::Mov { destination: MemoryAddress::direct(2), source: MemoryAddress::direct(0) },
         ];
-        let mut vm = VM::new(calldata, opcodes, vec![], &StubbedBlackBoxSolver);
+        let mut vm = VM::new(calldata, opcodes, vec![], &StubbedBlackBoxSolver, false);
 
         let status = vm.process_opcode();
         assert_eq!(status, VMStatus::InProgress);
@@ -1081,10 +1164,10 @@ mod tests {
 
         let VM { memory, .. } = vm;
 
-        let destination_value = memory.read(MemoryAddress::from(2));
+        let destination_value = memory.read(MemoryAddress::direct(2));
         assert_eq!(destination_value.to_field(), (1u128).into());
 
-        let source_value = memory.read(MemoryAddress::from(0));
+        let source_value = memory.read(MemoryAddress::direct(0));
         assert_eq!(source_value.to_field(), (1u128).into());
     }
 
@@ -1095,44 +1178,44 @@ mod tests {
 
         let opcodes = &[
             Opcode::Const {
-                destination: MemoryAddress(0),
+                destination: MemoryAddress::direct(0),
                 bit_size: BitSize::Integer(IntegerBitSize::U32),
                 value: FieldElement::from(4u64),
             },
             Opcode::Const {
-                destination: MemoryAddress(1),
+                destination: MemoryAddress::direct(1),
                 bit_size: BitSize::Integer(IntegerBitSize::U32),
                 value: FieldElement::from(0u64),
             },
             Opcode::CalldataCopy {
-                destination_address: MemoryAddress(0),
-                size_address: MemoryAddress(0),
-                offset_address: MemoryAddress(1),
+                destination_address: MemoryAddress::direct(0),
+                size_address: MemoryAddress::direct(0),
+                offset_address: MemoryAddress::direct(1),
             },
             Opcode::Cast {
-                destination: MemoryAddress::from(0),
-                source: MemoryAddress::from(0),
+                destination: MemoryAddress::direct(0),
+                source: MemoryAddress::direct(0),
                 bit_size: BitSize::Integer(IntegerBitSize::U1),
             },
             Opcode::Cast {
-                destination: MemoryAddress::from(1),
-                source: MemoryAddress::from(1),
+                destination: MemoryAddress::direct(1),
+                source: MemoryAddress::direct(1),
                 bit_size: BitSize::Integer(IntegerBitSize::U1),
             },
             Opcode::ConditionalMov {
-                destination: MemoryAddress(4), // Sets 3_u128 to memory address 4
-                source_a: MemoryAddress(2),
-                source_b: MemoryAddress(3),
-                condition: MemoryAddress(0),
+                destination: MemoryAddress::direct(4), // Sets 3_u128 to memory address 4
+                source_a: MemoryAddress::direct(2),
+                source_b: MemoryAddress::direct(3),
+                condition: MemoryAddress::direct(0),
             },
             Opcode::ConditionalMov {
-                destination: MemoryAddress(5), // Sets 2_u128 to memory address 5
-                source_a: MemoryAddress(2),
-                source_b: MemoryAddress(3),
-                condition: MemoryAddress(1),
+                destination: MemoryAddress::direct(5), // Sets 2_u128 to memory address 5
+                source_a: MemoryAddress::direct(2),
+                source_b: MemoryAddress::direct(3),
+                condition: MemoryAddress::direct(1),
             },
         ];
-        let mut vm = VM::new(calldata, opcodes, vec![], &StubbedBlackBoxSolver);
+        let mut vm = VM::new(calldata, opcodes, vec![], &StubbedBlackBoxSolver, false);
 
         let status = vm.process_opcode();
         assert_eq!(status, VMStatus::InProgress);
@@ -1151,10 +1234,10 @@ mod tests {
 
         let VM { memory, .. } = vm;
 
-        let destination_value = memory.read(MemoryAddress::from(4));
+        let destination_value = memory.read(MemoryAddress::direct(4));
         assert_eq!(destination_value.to_field(), (3_u128).into());
 
-        let source_value = memory.read(MemoryAddress::from(5));
+        let source_value = memory.read(MemoryAddress::direct(5));
         assert_eq!(source_value.to_field(), (2_u128).into());
     }
 
@@ -1167,26 +1250,26 @@ mod tests {
 
         let calldata_copy_opcodes = vec![
             Opcode::Const {
-                destination: MemoryAddress(0),
+                destination: MemoryAddress::direct(0),
                 bit_size: BitSize::Integer(IntegerBitSize::U32),
                 value: FieldElement::from(5u64),
             },
             Opcode::Const {
-                destination: MemoryAddress(1),
+                destination: MemoryAddress::direct(1),
                 bit_size: BitSize::Integer(IntegerBitSize::U32),
                 value: FieldElement::from(0u64),
             },
             Opcode::CalldataCopy {
-                destination_address: MemoryAddress(0),
-                size_address: MemoryAddress(0),
-                offset_address: MemoryAddress(1),
+                destination_address: MemoryAddress::direct(0),
+                size_address: MemoryAddress::direct(0),
+                offset_address: MemoryAddress::direct(1),
             },
         ];
 
         let cast_opcodes: Vec<_> = (0..calldata_size)
             .map(|index| Opcode::Cast {
-                destination: MemoryAddress::from(index),
-                source: MemoryAddress::from(index),
+                destination: MemoryAddress::direct(index),
+                source: MemoryAddress::direct(index),
                 bit_size: BitSize::Integer(bit_size),
             })
             .collect();
@@ -1194,33 +1277,33 @@ mod tests {
         let equal_opcode = Opcode::BinaryIntOp {
             bit_size,
             op: BinaryIntOp::Equals,
-            lhs: MemoryAddress::from(0),
-            rhs: MemoryAddress::from(1),
-            destination: MemoryAddress::from(2),
+            lhs: MemoryAddress::direct(0),
+            rhs: MemoryAddress::direct(1),
+            destination: MemoryAddress::direct(2),
         };
 
         let not_equal_opcode = Opcode::BinaryIntOp {
             bit_size,
             op: BinaryIntOp::Equals,
-            lhs: MemoryAddress::from(0),
-            rhs: MemoryAddress::from(3),
-            destination: MemoryAddress::from(2),
+            lhs: MemoryAddress::direct(0),
+            rhs: MemoryAddress::direct(3),
+            destination: MemoryAddress::direct(2),
         };
 
         let less_than_opcode = Opcode::BinaryIntOp {
             bit_size,
             op: BinaryIntOp::LessThan,
-            lhs: MemoryAddress::from(3),
-            rhs: MemoryAddress::from(4),
-            destination: MemoryAddress::from(2),
+            lhs: MemoryAddress::direct(3),
+            rhs: MemoryAddress::direct(4),
+            destination: MemoryAddress::direct(2),
         };
 
         let less_than_equal_opcode = Opcode::BinaryIntOp {
             bit_size,
             op: BinaryIntOp::LessThanEquals,
-            lhs: MemoryAddress::from(3),
-            rhs: MemoryAddress::from(4),
-            destination: MemoryAddress::from(2),
+            lhs: MemoryAddress::direct(3),
+            rhs: MemoryAddress::direct(4),
+            destination: MemoryAddress::direct(2),
         };
 
         let opcodes: Vec<_> = calldata_copy_opcodes
@@ -1228,7 +1311,7 @@ mod tests {
             .chain(cast_opcodes)
             .chain([equal_opcode, not_equal_opcode, less_than_opcode, less_than_equal_opcode])
             .collect();
-        let mut vm = VM::new(calldata, &opcodes, vec![], &StubbedBlackBoxSolver);
+        let mut vm = VM::new(calldata, &opcodes, vec![], &StubbedBlackBoxSolver, false);
 
         // Calldata copy
         let status = vm.process_opcode();
@@ -1247,25 +1330,25 @@ mod tests {
         let status = vm.process_opcode();
         assert_eq!(status, VMStatus::InProgress);
 
-        let output_eq_value = vm.memory.read(MemoryAddress::from(2));
+        let output_eq_value = vm.memory.read(MemoryAddress::direct(2));
         assert_eq!(output_eq_value, true.into());
 
         let status = vm.process_opcode();
         assert_eq!(status, VMStatus::InProgress);
 
-        let output_neq_value = vm.memory.read(MemoryAddress::from(2));
+        let output_neq_value = vm.memory.read(MemoryAddress::direct(2));
         assert_eq!(output_neq_value, false.into());
 
         let status = vm.process_opcode();
         assert_eq!(status, VMStatus::InProgress);
 
-        let lt_value = vm.memory.read(MemoryAddress::from(2));
+        let lt_value = vm.memory.read(MemoryAddress::direct(2));
         assert_eq!(lt_value, true.into());
 
         let status = vm.process_opcode();
         assert_eq!(status, VMStatus::Finished { return_data_offset: 0, return_data_size: 0 });
 
-        let lte_value = vm.memory.read(MemoryAddress::from(2));
+        let lte_value = vm.memory.read(MemoryAddress::direct(2));
         assert_eq!(lte_value, true.into());
     }
 
@@ -1281,10 +1364,10 @@ mod tests {
         fn brillig_write_memory(item_count: usize) -> Vec<MemoryValue<FieldElement>> {
             let integer_bit_size = MEMORY_ADDRESSING_BIT_SIZE;
             let bit_size = BitSize::Integer(integer_bit_size);
-            let r_i = MemoryAddress::from(0);
-            let r_len = MemoryAddress::from(1);
-            let r_tmp = MemoryAddress::from(2);
-            let r_pointer = MemoryAddress::from(3);
+            let r_i = MemoryAddress::direct(0);
+            let r_len = MemoryAddress::direct(1);
+            let r_tmp = MemoryAddress::direct(2);
+            let r_pointer = MemoryAddress::direct(3);
 
             let start: [Opcode<FieldElement>; 3] = [
                 // i = 0
@@ -1346,17 +1429,17 @@ mod tests {
     fn iconst_opcode() {
         let opcodes = &[
             Opcode::Const {
-                destination: MemoryAddress(0),
+                destination: MemoryAddress::direct(0),
                 bit_size: BitSize::Integer(MEMORY_ADDRESSING_BIT_SIZE),
                 value: FieldElement::from(8_usize),
             },
             Opcode::IndirectConst {
-                destination_pointer: MemoryAddress(0),
+                destination_pointer: MemoryAddress::direct(0),
                 bit_size: BitSize::Integer(MEMORY_ADDRESSING_BIT_SIZE),
                 value: FieldElement::from(27_usize),
             },
         ];
-        let mut vm = VM::new(vec![], opcodes, vec![], &StubbedBlackBoxSolver);
+        let mut vm = VM::new(vec![], opcodes, vec![], &StubbedBlackBoxSolver, false);
 
         let status = vm.process_opcode();
         assert_eq!(status, VMStatus::InProgress);
@@ -1366,7 +1449,7 @@ mod tests {
 
         let VM { memory, .. } = vm;
 
-        let destination_value = memory.read(MemoryAddress::from(8));
+        let destination_value = memory.read(MemoryAddress::direct(8));
         assert_eq!(destination_value.to_field(), (27_usize).into());
     }
 
@@ -1382,11 +1465,11 @@ mod tests {
         ///     }
         fn brillig_sum_memory(memory: Vec<FieldElement>) -> FieldElement {
             let bit_size = IntegerBitSize::U32;
-            let r_i = MemoryAddress::from(0);
-            let r_len = MemoryAddress::from(1);
-            let r_sum = MemoryAddress::from(2);
-            let r_tmp = MemoryAddress::from(3);
-            let r_pointer = MemoryAddress::from(4);
+            let r_i = MemoryAddress::direct(0);
+            let r_len = MemoryAddress::direct(1);
+            let r_sum = MemoryAddress::direct(2);
+            let r_tmp = MemoryAddress::direct(3);
+            let r_pointer = MemoryAddress::direct(4);
 
             let start = [
                 // sum = 0
@@ -1410,19 +1493,19 @@ mod tests {
                     bit_size: BitSize::Integer(bit_size),
                 },
                 Opcode::Const {
-                    destination: MemoryAddress(100),
+                    destination: MemoryAddress::direct(100),
                     bit_size: BitSize::Integer(IntegerBitSize::U32),
                     value: FieldElement::from(memory.len() as u32),
                 },
                 Opcode::Const {
-                    destination: MemoryAddress(101),
+                    destination: MemoryAddress::direct(101),
                     bit_size: BitSize::Integer(IntegerBitSize::U32),
                     value: FieldElement::from(0u64),
                 },
                 Opcode::CalldataCopy {
-                    destination_address: MemoryAddress(5),
-                    size_address: MemoryAddress(100),
-                    offset_address: MemoryAddress(101),
+                    destination_address: MemoryAddress::direct(5),
+                    size_address: MemoryAddress::direct(100),
+                    offset_address: MemoryAddress::direct(101),
                 },
             ];
             let loop_body = [
@@ -1501,10 +1584,10 @@ mod tests {
         fn brillig_recursive_write_memory<F: AcirField>(size: usize) -> Vec<MemoryValue<F>> {
             let integer_bit_size = MEMORY_ADDRESSING_BIT_SIZE;
             let bit_size = BitSize::Integer(integer_bit_size);
-            let r_i = MemoryAddress::from(0);
-            let r_len = MemoryAddress::from(1);
-            let r_tmp = MemoryAddress::from(2);
-            let r_pointer = MemoryAddress::from(3);
+            let r_i = MemoryAddress::direct(0);
+            let r_len = MemoryAddress::direct(1);
+            let r_tmp = MemoryAddress::direct(2);
+            let r_pointer = MemoryAddress::direct(3);
 
             let start: [Opcode<F>; 5] = [
                 // i = 0
@@ -1580,7 +1663,7 @@ mod tests {
         calldata: Vec<F>,
         opcodes: &[Opcode<F>],
     ) -> VM<'_, F, StubbedBlackBoxSolver> {
-        let mut vm = VM::new(calldata, opcodes, vec![], &StubbedBlackBoxSolver);
+        let mut vm = VM::new(calldata, opcodes, vec![], &StubbedBlackBoxSolver, false);
         brillig_execute(&mut vm);
         assert_eq!(vm.call_stack, vec![]);
         vm
@@ -1598,8 +1681,8 @@ mod tests {
 
     #[test]
     fn foreign_call_opcode_simple_result() {
-        let r_input = MemoryAddress::from(0);
-        let r_result = MemoryAddress::from(1);
+        let r_input = MemoryAddress::direct(0);
+        let r_result = MemoryAddress::direct(1);
 
         let double_program = vec![
             // Load input address with value 5
@@ -1654,8 +1737,8 @@ mod tests {
 
     #[test]
     fn foreign_call_opcode_memory_result() {
-        let r_input = MemoryAddress::from(0);
-        let r_output = MemoryAddress::from(1);
+        let r_input = MemoryAddress::direct(0);
+        let r_output = MemoryAddress::direct(1);
 
         // Define a simple 2x2 matrix in memory
         let initial_matrix: Vec<FieldElement> =
@@ -1667,19 +1750,19 @@ mod tests {
 
         let invert_program = vec![
             Opcode::Const {
-                destination: MemoryAddress(0),
+                destination: MemoryAddress::direct(0),
                 bit_size: BitSize::Integer(IntegerBitSize::U32),
                 value: FieldElement::from(initial_matrix.len() as u32),
             },
             Opcode::Const {
-                destination: MemoryAddress(1),
+                destination: MemoryAddress::direct(1),
                 bit_size: BitSize::Integer(IntegerBitSize::U32),
                 value: FieldElement::from(0u64),
             },
             Opcode::CalldataCopy {
-                destination_address: MemoryAddress(2),
-                size_address: MemoryAddress(0),
-                offset_address: MemoryAddress(1),
+                destination_address: MemoryAddress::direct(2),
+                size_address: MemoryAddress::direct(0),
+                offset_address: MemoryAddress::direct(1),
             },
             // input = 0
             Opcode::Const {
@@ -1736,7 +1819,7 @@ mod tests {
         assert_eq!(vm.status, VMStatus::Finished { return_data_offset: 0, return_data_size: 0 });
 
         // Check result in memory
-        let result_values = vm.memory.read_slice(MemoryAddress(2), 4).to_vec();
+        let result_values = vm.memory.read_slice(MemoryAddress::direct(2), 4).to_vec();
         assert_eq!(
             result_values.into_iter().map(|mem_value| mem_value.to_field()).collect::<Vec<_>>(),
             expected_result
@@ -1749,11 +1832,11 @@ mod tests {
     /// Calling a simple foreign call function that takes any string input, concatenates it with itself, and reverses the concatenation
     #[test]
     fn foreign_call_opcode_vector_input_and_output() {
-        let r_input_pointer = MemoryAddress::from(0);
-        let r_input_size = MemoryAddress::from(1);
+        let r_input_pointer = MemoryAddress::direct(0);
+        let r_input_size = MemoryAddress::direct(1);
         // We need to pass a location of appropriate size
-        let r_output_pointer = MemoryAddress::from(2);
-        let r_output_size = MemoryAddress::from(3);
+        let r_output_pointer = MemoryAddress::direct(2);
+        let r_output_size = MemoryAddress::direct(3);
 
         // Our first string to use the identity function with
         let input_string: Vec<FieldElement> =
@@ -1767,19 +1850,19 @@ mod tests {
         // First call:
         let string_double_program = vec![
             Opcode::Const {
-                destination: MemoryAddress(100),
+                destination: MemoryAddress::direct(100),
                 bit_size: BitSize::Integer(IntegerBitSize::U32),
                 value: FieldElement::from(input_string.len() as u32),
             },
             Opcode::Const {
-                destination: MemoryAddress(101),
+                destination: MemoryAddress::direct(101),
                 bit_size: BitSize::Integer(IntegerBitSize::U32),
                 value: FieldElement::from(0u64),
             },
             Opcode::CalldataCopy {
-                destination_address: MemoryAddress(4),
-                size_address: MemoryAddress(100),
-                offset_address: MemoryAddress(101),
+                destination_address: MemoryAddress::direct(4),
+                size_address: MemoryAddress::direct(100),
+                offset_address: MemoryAddress::direct(101),
             },
             // input_pointer = 4
             Opcode::Const {
@@ -1850,7 +1933,7 @@ mod tests {
         // Check result in memory
         let result_values: Vec<_> = vm
             .memory
-            .read_slice(MemoryAddress(4 + input_string.len()), output_string.len())
+            .read_slice(MemoryAddress::direct(4 + input_string.len()), output_string.len())
             .iter()
             .map(|mem_val| mem_val.clone().to_field())
             .collect();
@@ -1862,8 +1945,8 @@ mod tests {
 
     #[test]
     fn foreign_call_opcode_memory_alloc_result() {
-        let r_input = MemoryAddress::from(0);
-        let r_output = MemoryAddress::from(1);
+        let r_input = MemoryAddress::direct(0);
+        let r_output = MemoryAddress::direct(1);
 
         // Define a simple 2x2 matrix in memory
         let initial_matrix: Vec<FieldElement> =
@@ -1875,19 +1958,19 @@ mod tests {
 
         let invert_program = vec![
             Opcode::Const {
-                destination: MemoryAddress(100),
+                destination: MemoryAddress::direct(100),
                 bit_size: BitSize::Integer(IntegerBitSize::U32),
                 value: FieldElement::from(initial_matrix.len() as u32),
             },
             Opcode::Const {
-                destination: MemoryAddress(101),
+                destination: MemoryAddress::direct(101),
                 bit_size: BitSize::Integer(IntegerBitSize::U32),
                 value: FieldElement::from(0u64),
             },
             Opcode::CalldataCopy {
-                destination_address: MemoryAddress(2),
-                size_address: MemoryAddress(100),
-                offset_address: MemoryAddress(101),
+                destination_address: MemoryAddress::direct(2),
+                size_address: MemoryAddress::direct(100),
+                offset_address: MemoryAddress::direct(101),
             },
             // input = 0
             Opcode::Const {
@@ -1946,7 +2029,7 @@ mod tests {
         // Check initial memory still in place
         let initial_values: Vec<_> = vm
             .memory
-            .read_slice(MemoryAddress(2), 4)
+            .read_slice(MemoryAddress::direct(2), 4)
             .iter()
             .map(|mem_val| mem_val.clone().to_field())
             .collect();
@@ -1955,7 +2038,7 @@ mod tests {
         // Check result in memory
         let result_values: Vec<_> = vm
             .memory
-            .read_slice(MemoryAddress(6), 4)
+            .read_slice(MemoryAddress::direct(6), 4)
             .iter()
             .map(|mem_val| mem_val.clone().to_field())
             .collect();
@@ -1967,9 +2050,9 @@ mod tests {
 
     #[test]
     fn foreign_call_opcode_multiple_array_inputs_result() {
-        let r_input_a = MemoryAddress::from(0);
-        let r_input_b = MemoryAddress::from(1);
-        let r_output = MemoryAddress::from(2);
+        let r_input_a = MemoryAddress::direct(0);
+        let r_input_b = MemoryAddress::direct(1);
+        let r_output = MemoryAddress::direct(2);
 
         // Define a simple 2x2 matrix in memory
         let matrix_a: Vec<FieldElement> =
@@ -1984,19 +2067,19 @@ mod tests {
 
         let matrix_mul_program = vec![
             Opcode::Const {
-                destination: MemoryAddress(100),
+                destination: MemoryAddress::direct(100),
                 bit_size: BitSize::Integer(IntegerBitSize::U32),
                 value: FieldElement::from(matrix_a.len() + matrix_b.len()),
             },
             Opcode::Const {
-                destination: MemoryAddress(101),
+                destination: MemoryAddress::direct(101),
                 bit_size: BitSize::Integer(IntegerBitSize::U32),
                 value: FieldElement::from(0u64),
             },
             Opcode::CalldataCopy {
-                destination_address: MemoryAddress(3),
-                size_address: MemoryAddress(100),
-                offset_address: MemoryAddress(101),
+                destination_address: MemoryAddress::direct(3),
+                size_address: MemoryAddress::direct(100),
+                offset_address: MemoryAddress::direct(101),
             },
             // input = 3
             Opcode::Const {
@@ -2068,7 +2151,7 @@ mod tests {
         // Check result in memory
         let result_values: Vec<_> = vm
             .memory
-            .read_slice(MemoryAddress(0), 4)
+            .read_slice(MemoryAddress::direct(0), 4)
             .iter()
             .map(|mem_val| mem_val.clone().to_field())
             .collect();
@@ -2135,30 +2218,30 @@ mod tests {
         // memory address of the end of the above data structures
         let r_ptr = memory.len();
 
-        let r_input = MemoryAddress::from(r_ptr);
-        let r_output = MemoryAddress::from(r_ptr + 1);
+        let r_input = MemoryAddress::direct(r_ptr);
+        let r_output = MemoryAddress::direct(r_ptr + 1);
 
         let program: Vec<_> = vec![
             Opcode::Const {
-                destination: MemoryAddress(100),
+                destination: MemoryAddress::direct(100),
                 bit_size: BitSize::Integer(IntegerBitSize::U32),
                 value: FieldElement::from(memory.len()),
             },
             Opcode::Const {
-                destination: MemoryAddress(101),
+                destination: MemoryAddress::direct(101),
                 bit_size: BitSize::Integer(IntegerBitSize::U32),
                 value: FieldElement::from(0u64),
             },
             Opcode::CalldataCopy {
-                destination_address: MemoryAddress(0),
-                size_address: MemoryAddress(100),
-                offset_address: MemoryAddress(101),
+                destination_address: MemoryAddress::direct(0),
+                size_address: MemoryAddress::direct(100),
+                offset_address: MemoryAddress::direct(101),
             },
         ]
         .into_iter()
         .chain(memory.iter().enumerate().map(|(index, mem_value)| Opcode::Cast {
-            destination: MemoryAddress(index),
-            source: MemoryAddress(index),
+            destination: MemoryAddress::direct(index),
+            source: MemoryAddress::direct(index),
             bit_size: mem_value.bit_size(),
         }))
         .chain(vec![
@@ -2227,4 +2310,49 @@ mod tests {
         // Ensure the foreign call counter has been incremented
         assert_eq!(vm.foreign_call_counter, 1);
     }
+
+    #[test]
+    fn relative_addressing() {
+        let calldata = vec![];
+        let bit_size = BitSize::Integer(IntegerBitSize::U32);
+        let value = FieldElement::from(3u128);
+
+        let opcodes = [
+            Opcode::Const {
+                destination: MemoryAddress::direct(0),
+                bit_size,
+                value: FieldElement::from(27u128),
+            },
+            Opcode::Const {
+                destination: MemoryAddress::relative(1), // Resolved address 28 value 3
+                bit_size,
+                value,
+            },
+            Opcode::Const {
+                destination: MemoryAddress::direct(1), // Address 1 value 3
+                bit_size,
+                value,
+            },
+            Opcode::BinaryIntOp {
+                destination: MemoryAddress::direct(1),
+                op: BinaryIntOp::Equals,
+                bit_size: IntegerBitSize::U32,
+                lhs: MemoryAddress::direct(1),
+                rhs: MemoryAddress::direct(28),
+            },
+        ];
+
+        let mut vm = VM::new(calldata, &opcodes, vec![], &StubbedBlackBoxSolver, false);
+
+        vm.process_opcode();
+        vm.process_opcode();
+        vm.process_opcode();
+        let status = vm.process_opcode();
+        assert_eq!(status, VMStatus::Finished { return_data_offset: 0, return_data_size: 0 });
+
+        let VM { memory, .. } = vm;
+        let output_value = memory.read(MemoryAddress::direct(1));
+
+        assert_eq!(output_value.to_field(), FieldElement::from(1u128));
+    }
 }
diff --git a/acvm-repo/brillig_vm/src/memory.rs b/acvm-repo/brillig_vm/src/memory.rs
index ef1e0301387..2bf45f77b54 100644
--- a/acvm-repo/brillig_vm/src/memory.rs
+++ b/acvm-repo/brillig_vm/src/memory.rs
@@ -136,7 +136,7 @@ impl<F: std::fmt::Display> std::fmt::Display for MemoryValue<F> {
 
 impl<F: AcirField> Default for MemoryValue<F> {
     fn default() -> Self {
-        MemoryValue::new_integer(0, IntegerBitSize::U0)
+        MemoryValue::new_field(F::zero())
     }
 }
 
@@ -233,13 +233,25 @@ pub struct Memory<F> {
 }
 
 impl<F: AcirField> Memory<F> {
-    /// Gets the value at pointer
-    pub fn read(&self, ptr: MemoryAddress) -> MemoryValue<F> {
-        self.inner.get(ptr.to_usize()).copied().unwrap_or_default()
+    fn get_stack_pointer(&self) -> usize {
+        self.read(MemoryAddress::Direct(0)).to_usize()
+    }
+
+    fn resolve(&self, address: MemoryAddress) -> usize {
+        match address {
+            MemoryAddress::Direct(address) => address,
+            MemoryAddress::Relative(offset) => self.get_stack_pointer() + offset,
+        }
+    }
+
+    /// Gets the value at address
+    pub fn read(&self, address: MemoryAddress) -> MemoryValue<F> {
+        let resolved_addr = self.resolve(address);
+        self.inner.get(resolved_addr).copied().unwrap_or_default()
     }
 
     pub fn read_ref(&self, ptr: MemoryAddress) -> MemoryAddress {
-        MemoryAddress(self.read(ptr).to_usize())
+        MemoryAddress::direct(self.read(ptr).to_usize())
     }
 
     pub fn read_slice(&self, addr: MemoryAddress, len: usize) -> &[MemoryValue<F>] {
@@ -249,13 +261,15 @@ impl<F: AcirField> Memory<F> {
         if len == 0 {
             return &[];
         }
-        &self.inner[addr.to_usize()..(addr.to_usize() + len)]
+        let resolved_addr = self.resolve(addr);
+        &self.inner[resolved_addr..(resolved_addr + len)]
     }
 
-    /// Sets the value at pointer `ptr` to `value`
-    pub fn write(&mut self, ptr: MemoryAddress, value: MemoryValue<F>) {
-        self.resize_to_fit(ptr.to_usize() + 1);
-        self.inner[ptr.to_usize()] = value;
+    /// Sets the value at `address` to `value`
+    pub fn write(&mut self, address: MemoryAddress, value: MemoryValue<F>) {
+        let resolved_ptr = self.resolve(address);
+        self.resize_to_fit(resolved_ptr + 1);
+        self.inner[resolved_ptr] = value;
     }
 
     fn resize_to_fit(&mut self, size: usize) {
@@ -265,10 +279,11 @@ impl<F: AcirField> Memory<F> {
         self.inner.resize(new_size, MemoryValue::default());
     }
 
-    /// Sets the values after pointer `ptr` to `values`
-    pub fn write_slice(&mut self, ptr: MemoryAddress, values: &[MemoryValue<F>]) {
-        self.resize_to_fit(ptr.to_usize() + values.len());
-        self.inner[ptr.to_usize()..(ptr.to_usize() + values.len())].copy_from_slice(values);
+    /// Sets the values after `address` to `values`
+    pub fn write_slice(&mut self, address: MemoryAddress, values: &[MemoryValue<F>]) {
+        let resolved_address = self.resolve(address);
+        self.resize_to_fit(resolved_address + values.len());
+        self.inner[resolved_address..(resolved_address + values.len())].copy_from_slice(values);
     }
 
     /// Returns the values of the memory
diff --git a/compiler/fm/src/file_map.rs b/compiler/fm/src/file_map.rs
index ba552fe5156..857c7460fb9 100644
--- a/compiler/fm/src/file_map.rs
+++ b/compiler/fm/src/file_map.rs
@@ -80,6 +80,19 @@ impl FileMap {
     pub fn all_file_ids(&self) -> impl Iterator<Item = &FileId> {
         self.name_to_id.values()
     }
+
+    pub fn get_name(&self, file_id: FileId) -> Result<PathString, Error> {
+        let name = self.files.get(file_id.as_usize())?.name().clone();
+
+        // See if we can make the file name a bit shorter/easier to read if it starts with the current directory
+        if let Some(current_dir) = &self.current_dir {
+            if let Ok(name_without_prefix) = name.0.strip_prefix(current_dir) {
+                return Ok(PathString::from_path(name_without_prefix.to_path_buf()));
+            }
+        }
+
+        Ok(name)
+    }
 }
 impl Default for FileMap {
     fn default() -> Self {
@@ -97,16 +110,7 @@ impl<'a> Files<'a> for FileMap {
     type Source = &'a str;
 
     fn name(&self, file_id: Self::FileId) -> Result<Self::Name, Error> {
-        let name = self.files.get(file_id.as_usize())?.name().clone();
-
-        // See if we can make the file name a bit shorter/easier to read if it starts with the current directory
-        if let Some(current_dir) = &self.current_dir {
-            if let Ok(name_without_prefix) = name.0.strip_prefix(current_dir) {
-                return Ok(PathString::from_path(name_without_prefix.to_path_buf()));
-            }
-        }
-
-        Ok(name)
+        self.get_name(file_id)
     }
 
     fn source(&'a self, file_id: Self::FileId) -> Result<Self::Source, Error> {
diff --git a/compiler/fm/src/lib.rs b/compiler/fm/src/lib.rs
index 37da29fc982..fad2634bab4 100644
--- a/compiler/fm/src/lib.rs
+++ b/compiler/fm/src/lib.rs
@@ -100,6 +100,11 @@ impl FileManager {
         self.id_to_path.get(&file_id).map(|path| path.as_path())
     }
 
+    pub fn has_file(&self, file_name: &Path) -> bool {
+        let file_name = self.root.join(file_name);
+        self.name_to_id(file_name).is_some()
+    }
+
     // TODO: This should accept a &Path instead of a PathBuf
     pub fn name_to_id(&self, file_name: PathBuf) -> Option<FileId> {
         self.file_map.get_file_id(&PathString::from_path(file_name))
diff --git a/compiler/integration-tests/package.json b/compiler/integration-tests/package.json
index 64a638539d5..bfaa1cabd16 100644
--- a/compiler/integration-tests/package.json
+++ b/compiler/integration-tests/package.json
@@ -1,34 +1,34 @@
 {
-    "name": "integration-tests",
-    "license": "(MIT OR Apache-2.0)",
-    "main": "index.js",
-    "private": true,
-    "scripts": {
-        "build": "echo Integration Test build step",
-        "test": "yarn test:browser && yarn test:node",
-        "test:node": "bash ./scripts/setup.sh && hardhat test test/node/prove_and_verify.test.ts && hardhat test test/node/smart_contract_verifier.test.ts && hardhat test test/node/onchain_recursive_verification.test.ts",
-        "test:browser": "web-test-runner",
-        "test:integration:browser": "web-test-runner test/browser/**/*.test.ts",
-        "test:integration:browser:watch": "web-test-runner test/browser/**/*.test.ts --watch",
-        "lint": "NODE_NO_WARNINGS=1 eslint . --ext .ts --ignore-path ./.eslintignore  --max-warnings 0"
-    },
-    "dependencies": {
-        "@noir-lang/backend_barretenberg": "workspace:*",
-        "@noir-lang/noir_js": "workspace:*",
-        "@noir-lang/noir_wasm": "workspace:*",
-        "@nomicfoundation/hardhat-chai-matchers": "^2.0.0",
-        "@nomicfoundation/hardhat-ethers": "^3.0.0",
-        "@web/dev-server-esbuild": "^0.3.6",
-        "@web/dev-server-import-maps": "^0.2.0",
-        "@web/test-runner": "^0.18.1",
-        "@web/test-runner-playwright": "^0.11.0",
-        "eslint": "^8.57.0",
-        "eslint-plugin-prettier": "^5.1.3",
-        "ethers": "^6.7.1",
-        "hardhat": "^2.22.6",
-        "prettier": "3.2.5",
-        "smol-toml": "^1.1.2",
-        "toml": "^3.0.0",
-        "tslog": "^4.9.2"
-    }
+  "name": "integration-tests",
+  "license": "(MIT OR Apache-2.0)",
+  "main": "index.js",
+  "private": true,
+  "scripts": {
+    "build": "echo Integration Test build step",
+    "test": "yarn test:browser && yarn test:node",
+    "test:node": "bash ./scripts/setup.sh && hardhat test test/node/prove_and_verify.test.ts && hardhat test test/node/smart_contract_verifier.test.ts && hardhat test test/node/onchain_recursive_verification.test.ts",
+    "test:browser": "web-test-runner",
+    "test:integration:browser": "web-test-runner test/browser/**/*.test.ts",
+    "test:integration:browser:watch": "web-test-runner test/browser/**/*.test.ts --watch",
+    "lint": "NODE_NO_WARNINGS=1 eslint . --ext .ts --ignore-path ./.eslintignore  --max-warnings 0"
+  },
+  "dependencies": {
+    "@aztec/bb.js": "0.66.0",
+    "@noir-lang/noir_js": "workspace:*",
+    "@noir-lang/noir_wasm": "workspace:*",
+    "@nomicfoundation/hardhat-chai-matchers": "^2.0.0",
+    "@nomicfoundation/hardhat-ethers": "^3.0.0",
+    "@web/dev-server-esbuild": "^0.3.6",
+    "@web/dev-server-import-maps": "^0.2.0",
+    "@web/test-runner": "^0.18.1",
+    "@web/test-runner-playwright": "^0.11.0",
+    "eslint": "^8.57.0",
+    "eslint-plugin-prettier": "^5.1.3",
+    "ethers": "^6.7.1",
+    "hardhat": "^2.22.6",
+    "prettier": "3.2.5",
+    "smol-toml": "^1.1.2",
+    "toml": "^3.0.0",
+    "tslog": "^4.9.2"
+  }
 }
diff --git a/compiler/integration-tests/scripts/codegen-verifiers.sh b/compiler/integration-tests/scripts/codegen-verifiers.sh
index bec59eb6889..de1f71a4cc0 100755
--- a/compiler/integration-tests/scripts/codegen-verifiers.sh
+++ b/compiler/integration-tests/scripts/codegen-verifiers.sh
@@ -17,8 +17,8 @@ KEYS=$(mktemp -d)
 # Codegen verifier contract for 1_mul
 mul_dir=$repo_root/test_programs/execution_success/1_mul
 nargo --program-dir $mul_dir compile
-$NARGO_BACKEND_PATH write_vk -b $mul_dir/target/1_mul.json -o $KEYS/1_mul 
-$NARGO_BACKEND_PATH contract -k $KEYS/1_mul -o $contracts_dir/1_mul.sol 
+$NARGO_BACKEND_PATH write_vk -b $mul_dir/target/1_mul.json -o $KEYS/1_mul
+$NARGO_BACKEND_PATH contract -k $KEYS/1_mul -o $contracts_dir/1_mul.sol
 
 # Codegen verifier contract for assert_statement
 assert_statement_dir=$repo_root/test_programs/execution_success/assert_statement
diff --git a/compiler/integration-tests/test/browser/compile_prove_verify.test.ts b/compiler/integration-tests/test/browser/compile_prove_verify.test.ts
index f18ceb85276..8d24b27ac25 100644
--- a/compiler/integration-tests/test/browser/compile_prove_verify.test.ts
+++ b/compiler/integration-tests/test/browser/compile_prove_verify.test.ts
@@ -4,7 +4,7 @@ import * as TOML from 'smol-toml';
 import { compile, createFileManager } from '@noir-lang/noir_wasm';
 import { Noir } from '@noir-lang/noir_js';
 import { InputMap } from '@noir-lang/noirc_abi';
-import { BarretenbergBackend } from '@noir-lang/backend_barretenberg';
+import { UltraPlonkBackend } from '@aztec/bb.js';
 
 import { getFile } from './utils.js';
 
@@ -59,7 +59,7 @@ test_cases.forEach((testInfo) => {
     const program = new Noir(noir_program);
     const { witness } = await program.execute(inputs);
 
-    const backend = new BarretenbergBackend(noir_program);
+    const backend = new UltraPlonkBackend(noir_program.bytecode);
     const proof = await backend.generateProof(witness);
 
     // JS verification
diff --git a/compiler/integration-tests/test/browser/recursion.test.ts b/compiler/integration-tests/test/browser/recursion.test.ts
index abbee7b96ad..71d6697f843 100644
--- a/compiler/integration-tests/test/browser/recursion.test.ts
+++ b/compiler/integration-tests/test/browser/recursion.test.ts
@@ -5,7 +5,7 @@ import { Logger } from 'tslog';
 import { acvm, abi, Noir } from '@noir-lang/noir_js';
 
 import * as TOML from 'smol-toml';
-import { BarretenbergBackend } from '@noir-lang/backend_barretenberg';
+import { UltraPlonkBackend } from '@aztec/bb.js';
 import { getFile } from './utils.js';
 import { Field, InputMap } from '@noir-lang/noirc_abi';
 import { createFileManager, compile } from '@noir-lang/noir_wasm';
@@ -19,7 +19,7 @@ await newABICoder();
 await initACVM();
 
 const base_relative_path = '../../../../..';
-const circuit_main = 'test_programs/execution_success/assert_statement_recursive';
+const circuit_main = 'test_programs/execution_success/assert_statement';
 const circuit_recursion = 'compiler/integration-tests/circuits/recursion';
 
 async function getCircuit(projectPath: string) {
@@ -45,7 +45,7 @@ describe('It compiles noir program code, receiving circuit bytes and abi object.
     const main_program = await getCircuit(`${base_relative_path}/${circuit_main}`);
     const main_inputs: InputMap = TOML.parse(circuit_main_toml) as InputMap;
 
-    const main_backend = new BarretenbergBackend(main_program);
+    const main_backend = new UltraPlonkBackend(main_program.bytecode, {}, { recursive: true });
 
     const { witness: main_witnessUint8Array } = await new Noir(main_program).execute(main_inputs);
 
@@ -73,7 +73,7 @@ describe('It compiles noir program code, receiving circuit bytes and abi object.
 
     const recursion_program = await getCircuit(`${base_relative_path}/${circuit_recursion}`);
 
-    const recursion_backend = new BarretenbergBackend(recursion_program);
+    const recursion_backend = new UltraPlonkBackend(recursion_program.bytecode, {}, { recursive: false });
 
     const { witness: recursion_witnessUint8Array } = await new Noir(recursion_program).execute(recursion_inputs);
 
diff --git a/compiler/integration-tests/test/node/onchain_recursive_verification.test.ts b/compiler/integration-tests/test/node/onchain_recursive_verification.test.ts
index f4647c478f1..1694da28805 100644
--- a/compiler/integration-tests/test/node/onchain_recursive_verification.test.ts
+++ b/compiler/integration-tests/test/node/onchain_recursive_verification.test.ts
@@ -6,7 +6,7 @@ import { resolve, join } from 'path';
 import toml from 'toml';
 
 import { Noir } from '@noir-lang/noir_js';
-import { BarretenbergBackend } from '@noir-lang/backend_barretenberg';
+import { UltraPlonkBackend } from '@aztec/bb.js';
 import { Field, InputMap } from '@noir-lang/noirc_abi';
 
 import { compile, createFileManager } from '@noir-lang/noir_wasm';
@@ -17,7 +17,7 @@ it.skip(`smart contract can verify a recursive proof`, async () => {
   const fm = createFileManager(basePath);
   const innerCompilationResult = await compile(
     fm,
-    join(basePath, './test_programs/execution_success/assert_statement_recursive'),
+    join(basePath, './test_programs/execution_success/assert_statement'),
   );
   if (!('program' in innerCompilationResult)) {
     throw new Error('Compilation failed');
@@ -35,11 +35,11 @@ it.skip(`smart contract can verify a recursive proof`, async () => {
 
   // Intermediate proof
 
-  const inner_backend = new BarretenbergBackend(innerProgram);
+  const inner_backend = new UltraPlonkBackend(innerProgram.bytecode, {}, { recursive: true });
   const inner = new Noir(innerProgram);
 
   const inner_prover_toml = readFileSync(
-    join(basePath, `./test_programs/execution_success/assert_statement_recursive/Prover.toml`),
+    join(basePath, `./test_programs/execution_success/assert_statement/Prover.toml`),
   ).toString();
 
   const inner_inputs = toml.parse(inner_prover_toml);
@@ -67,7 +67,7 @@ it.skip(`smart contract can verify a recursive proof`, async () => {
 
   const { witness: recursionWitness } = await recursion.execute(recursion_inputs);
 
-  const recursion_backend = new BarretenbergBackend(recursionProgram);
+  const recursion_backend = new UltraPlonkBackend(recursionProgram.bytecode, {}, { recursive: false });
   const recursion_proof = await recursion_backend.generateProof(recursionWitness);
   expect(await recursion_backend.verifyProof(recursion_proof)).to.be.true;
 
diff --git a/compiler/integration-tests/test/node/prove_and_verify.test.ts b/compiler/integration-tests/test/node/prove_and_verify.test.ts
index babc8ca5bb8..4353bccd90d 100644
--- a/compiler/integration-tests/test/node/prove_and_verify.test.ts
+++ b/compiler/integration-tests/test/node/prove_and_verify.test.ts
@@ -2,18 +2,13 @@ import { expect } from 'chai';
 import assert_lt_json from '../../circuits/assert_lt/target/assert_lt.json' assert { type: 'json' };
 import fold_fibonacci_json from '../../circuits/fold_fibonacci/target/fold_fibonacci.json' assert { type: 'json' };
 import { Noir } from '@noir-lang/noir_js';
-import {
-  BarretenbergBackend as Backend,
-  BarretenbergVerifier as Verifier,
-  UltraHonkBackend,
-  UltraHonkVerifier,
-} from '@noir-lang/backend_barretenberg';
+import { BarretenbergVerifier, UltraPlonkBackend, UltraHonkBackend } from '@aztec/bb.js';
 import { CompiledCircuit } from '@noir-lang/types';
 
 const assert_lt_program = assert_lt_json as CompiledCircuit;
 const fold_fibonacci_program = fold_fibonacci_json as CompiledCircuit;
 
-const backend = new Backend(assert_lt_program);
+const backend = new UltraPlonkBackend(assert_lt_program.bytecode);
 
 it('end-to-end proof creation and verification (outer)', async () => {
   // Noir.Js part
@@ -53,8 +48,8 @@ it('end-to-end proof creation and verification (outer) -- Verifier API', async (
   const verificationKey = await backend.getVerificationKey();
 
   // Proof verification
-  const verifier = new Verifier();
-  const isValid = await verifier.verifyProof(proof, verificationKey);
+  const verifier = new BarretenbergVerifier();
+  const isValid = await verifier.verifyUltraPlonkProof(proof, verificationKey);
   expect(isValid).to.be.true;
 });
 
@@ -94,7 +89,7 @@ it('end-to-end proving and verification with different instances', async () => {
   // bb.js part
   const proof = await backend.generateProof(witness);
 
-  const verifier = new Backend(assert_lt_program);
+  const verifier = new UltraPlonkBackend(assert_lt_program.bytecode);
   const proof_is_valid = await verifier.verifyProof(proof);
   expect(proof_is_valid).to.be.true;
 });
@@ -148,7 +143,7 @@ it('end-to-end proof creation and verification for multiple ACIR circuits (inner
   // bb.js part
   //
   // Proof creation
-  const backend = new Backend(fold_fibonacci_program);
+  const backend = new UltraPlonkBackend(fold_fibonacci_program.bytecode);
   const proof = await backend.generateProof(witness);
 
   // Proof verification
@@ -156,7 +151,7 @@ it('end-to-end proof creation and verification for multiple ACIR circuits (inner
   expect(isValid).to.be.true;
 });
 
-const honkBackend = new UltraHonkBackend(assert_lt_program);
+const honkBackend = new UltraHonkBackend(assert_lt_program.bytecode);
 
 it('UltraHonk end-to-end proof creation and verification (outer)', async () => {
   // Noir.Js part
@@ -196,8 +191,8 @@ it('UltraHonk end-to-end proof creation and verification (outer) -- Verifier API
   const verificationKey = await honkBackend.getVerificationKey();
 
   // Proof verification
-  const verifier = new UltraHonkVerifier();
-  const isValid = await verifier.verifyProof(proof, verificationKey);
+  const verifier = new BarretenbergVerifier();
+  const isValid = await verifier.verifyUltraHonkProof(proof, verificationKey);
   expect(isValid).to.be.true;
 });
 
@@ -236,7 +231,7 @@ it('UltraHonk end-to-end proving and verification with different instances', asy
   // bb.js part
   const proof = await honkBackend.generateProof(witness);
 
-  const verifier = new UltraHonkBackend(assert_lt_program);
+  const verifier = new UltraHonkBackend(assert_lt_program.bytecode);
   const proof_is_valid = await verifier.verifyProof(proof);
   expect(proof_is_valid).to.be.true;
 });
@@ -283,7 +278,7 @@ it('UltraHonk end-to-end proof creation and verification for multiple ACIR circu
   // bb.js part
   //
   // Proof creation
-  const honkBackend = new UltraHonkBackend(fold_fibonacci_program);
+  const honkBackend = new UltraHonkBackend(fold_fibonacci_program.bytecode);
   const proof = await honkBackend.generateProof(witness);
 
   // Proof verification
diff --git a/compiler/integration-tests/test/node/smart_contract_verifier.test.ts b/compiler/integration-tests/test/node/smart_contract_verifier.test.ts
index e109cbcab6a..74a36262829 100644
--- a/compiler/integration-tests/test/node/smart_contract_verifier.test.ts
+++ b/compiler/integration-tests/test/node/smart_contract_verifier.test.ts
@@ -6,7 +6,7 @@ import { resolve } from 'path';
 import toml from 'toml';
 
 import { Noir } from '@noir-lang/noir_js';
-import { BarretenbergBackend } from '@noir-lang/backend_barretenberg';
+import { UltraPlonkBackend } from '@aztec/bb.js';
 
 import { compile, createFileManager } from '@noir-lang/noir_wasm';
 
@@ -46,7 +46,7 @@ test_cases.forEach((testInfo) => {
     const inputs = toml.parse(prover_toml);
     const { witness } = await program.execute(inputs);
 
-    const backend = new BarretenbergBackend(noir_program);
+    const backend = new UltraPlonkBackend(noir_program.bytecode, {}, { recursive: false });
     const proofData = await backend.generateProof(witness);
 
     // JS verification
diff --git a/compiler/noirc_driver/src/abi_gen.rs b/compiler/noirc_driver/src/abi_gen.rs
index be89b24fee5..625a35c8d15 100644
--- a/compiler/noirc_driver/src/abi_gen.rs
+++ b/compiler/noirc_driver/src/abi_gen.rs
@@ -6,14 +6,20 @@ use iter_extended::vecmap;
 use noirc_abi::{
     Abi, AbiErrorType, AbiParameter, AbiReturnType, AbiType, AbiValue, AbiVisibility, Sign,
 };
+use noirc_errors::Span;
+use noirc_evaluator::ErrorType;
 use noirc_frontend::ast::{Signedness, Visibility};
+use noirc_frontend::TypeBinding;
 use noirc_frontend::{
     hir::Context,
-    hir_def::{expr::HirArrayLiteral, function::Param, stmt::HirPattern, types::Type},
-    macros_api::{HirExpression, HirLiteral},
+    hir_def::{
+        expr::{HirArrayLiteral, HirExpression, HirLiteral},
+        function::Param,
+        stmt::HirPattern,
+        types::Type,
+    },
     node_interner::{FuncId, NodeInterner},
 };
-use noirc_frontend::{TypeBinding, TypeVariableKind};
 
 /// Arranges a function signature and a generated circuit's return witnesses into a
 /// `noirc_abi::Abi`.
@@ -21,7 +27,7 @@ pub(super) fn gen_abi(
     context: &Context,
     func_id: &FuncId,
     return_visibility: Visibility,
-    error_types: BTreeMap<ErrorSelector, Type>,
+    error_types: BTreeMap<ErrorSelector, ErrorType>,
 ) -> Abi {
     let (parameters, return_type) = compute_function_abi(context, func_id);
     let return_type = return_type.map(|typ| AbiReturnType {
@@ -30,23 +36,37 @@ pub(super) fn gen_abi(
     });
     let error_types = error_types
         .into_iter()
-        .map(|(selector, typ)| (selector, build_abi_error_type(context, &typ)))
+        .map(|(selector, typ)| (selector, build_abi_error_type(context, typ)))
         .collect();
     Abi { parameters, return_type, error_types }
 }
 
-fn build_abi_error_type(context: &Context, typ: &Type) -> AbiErrorType {
+// Get the Span of the root crate's main function, or else a dummy span if that fails
+fn get_main_function_span(context: &Context) -> Span {
+    if let Some(func_id) = context.get_main_function(context.root_crate_id()) {
+        context.function_meta(&func_id).location.span
+    } else {
+        Span::default()
+    }
+}
+
+fn build_abi_error_type(context: &Context, typ: ErrorType) -> AbiErrorType {
     match typ {
-        Type::FmtString(len, item_types) => {
-            let length = len.evaluate_to_u32().expect("Cannot evaluate fmt length");
-            let Type::Tuple(item_types) = item_types.as_ref() else {
-                unreachable!("FmtString items must be a tuple")
-            };
-            let item_types =
-                item_types.iter().map(|typ| abi_type_from_hir_type(context, typ)).collect();
-            AbiErrorType::FmtString { length, item_types }
+        ErrorType::Dynamic(typ) => {
+            if let Type::FmtString(len, item_types) = typ {
+                let span = get_main_function_span(context);
+                let length = len.evaluate_to_u32(span).expect("Cannot evaluate fmt length");
+                let Type::Tuple(item_types) = item_types.as_ref() else {
+                    unreachable!("FmtString items must be a tuple")
+                };
+                let item_types =
+                    item_types.iter().map(|typ| abi_type_from_hir_type(context, typ)).collect();
+                AbiErrorType::FmtString { length, item_types }
+            } else {
+                AbiErrorType::Custom(abi_type_from_hir_type(context, &typ))
+            }
         }
-        _ => AbiErrorType::Custom(abi_type_from_hir_type(context, typ)),
+        ErrorType::String(string) => AbiErrorType::String { string },
     }
 }
 
@@ -54,8 +74,9 @@ pub(super) fn abi_type_from_hir_type(context: &Context, typ: &Type) -> AbiType {
     match typ {
         Type::FieldElement => AbiType::Field,
         Type::Array(size, typ) => {
+            let span = get_main_function_span(context);
             let length = size
-                .evaluate_to_u32()
+                .evaluate_to_u32(span)
                 .expect("Cannot have variable sized arrays as a parameter to main");
             let typ = typ.as_ref();
             AbiType::Array { length, typ: Box::new(abi_type_from_hir_type(context, typ)) }
@@ -68,17 +89,23 @@ pub(super) fn abi_type_from_hir_type(context: &Context, typ: &Type) -> AbiType {
 
             AbiType::Integer { sign, width: (*bit_width).into() }
         }
-        Type::TypeVariable(binding, TypeVariableKind::IntegerOrField)
-        | Type::TypeVariable(binding, TypeVariableKind::Integer) => match &*binding.borrow() {
-            TypeBinding::Bound(typ) => abi_type_from_hir_type(context, typ),
-            TypeBinding::Unbound(_) => {
-                abi_type_from_hir_type(context, &Type::default_int_or_field_type())
+        Type::TypeVariable(binding) => {
+            if binding.is_integer() || binding.is_integer_or_field() {
+                match &*binding.borrow() {
+                    TypeBinding::Bound(typ) => abi_type_from_hir_type(context, typ),
+                    TypeBinding::Unbound(_id, _kind) => {
+                        abi_type_from_hir_type(context, &Type::default_int_or_field_type())
+                    }
+                }
+            } else {
+                unreachable!("{typ} cannot be used in the abi")
             }
-        },
+        }
         Type::Bool => AbiType::Boolean,
         Type::String(size) => {
+            let span = get_main_function_span(context);
             let size = size
-                .evaluate_to_u32()
+                .evaluate_to_u32(span)
                 .expect("Cannot have variable sized strings as a parameter to main");
             AbiType::String { length: size }
         }
@@ -93,6 +120,7 @@ pub(super) fn abi_type_from_hir_type(context: &Context, typ: &Type) -> AbiType {
             AbiType::Struct { fields, path }
         }
         Type::Alias(def, args) => abi_type_from_hir_type(context, &def.borrow().get_type(args)),
+        Type::CheckedCast { to, .. } => abi_type_from_hir_type(context, to),
         Type::Tuple(fields) => {
             let fields = vecmap(fields, |typ| abi_type_from_hir_type(context, typ));
             AbiType::Tuple { fields }
@@ -102,7 +130,6 @@ pub(super) fn abi_type_from_hir_type(context: &Context, typ: &Type) -> AbiType {
         | Type::Constant(..)
         | Type::InfixExpr(..)
         | Type::TraitAsType(..)
-        | Type::TypeVariable(_, _)
         | Type::NamedGeneric(..)
         | Type::Forall(..)
         | Type::Quoted(_)
diff --git a/compiler/noirc_driver/src/debug.rs b/compiler/noirc_driver/src/debug.rs
index f5eaede89b2..6044e6c0e65 100644
--- a/compiler/noirc_driver/src/debug.rs
+++ b/compiler/noirc_driver/src/debug.rs
@@ -8,7 +8,7 @@ use std::{
 
 /// For a given file, we store the source code and the path to the file
 /// so consumers of the debug artifact can reconstruct the original source code structure.
-#[derive(Clone, Debug, Serialize, Deserialize)]
+#[derive(Clone, Debug, Serialize, Deserialize, Hash)]
 pub struct DebugFile {
     pub source: String,
     pub path: PathBuf,
diff --git a/compiler/noirc_driver/src/lib.rs b/compiler/noirc_driver/src/lib.rs
index 1d69e435738..9318e4d2b5c 100644
--- a/compiler/noirc_driver/src/lib.rs
+++ b/compiler/noirc_driver/src/lib.rs
@@ -5,14 +5,15 @@
 
 use abi_gen::{abi_type_from_hir_type, value_from_hir_expression};
 use acvm::acir::circuit::ExpressionWidth;
+use acvm::compiler::MIN_EXPRESSION_WIDTH;
 use clap::Args;
 use fm::{FileId, FileManager};
 use iter_extended::vecmap;
 use noirc_abi::{AbiParameter, AbiType, AbiValue};
-use noirc_errors::{CustomDiagnostic, FileDiagnostic};
+use noirc_errors::{CustomDiagnostic, DiagnosticKind, FileDiagnostic};
 use noirc_evaluator::create_program;
 use noirc_evaluator::errors::RuntimeError;
-use noirc_evaluator::ssa::SsaProgramArtifact;
+use noirc_evaluator::ssa::{SsaLogging, SsaProgramArtifact};
 use noirc_frontend::debug::build_debug_crate_file;
 use noirc_frontend::hir::def_map::{Contract, CrateDefMap};
 use noirc_frontend::hir::Context;
@@ -69,6 +70,11 @@ pub struct CompileOptions {
     #[arg(long, hide = true)]
     pub show_ssa: bool,
 
+    /// Only show SSA passes whose name contains the provided string.
+    /// This setting takes precedence over `show_ssa` if it's not empty.
+    #[arg(long, hide = true)]
+    pub show_ssa_pass_name: Option<String>,
+
     /// Emit the unoptimized SSA IR to file.
     /// The IR will be dumped into the workspace target directory,
     /// under `[compiled-package].ssa.json`.
@@ -124,6 +130,26 @@ pub struct CompileOptions {
     /// This check should always be run on production code.
     #[arg(long)]
     pub skip_underconstrained_check: bool,
+
+    /// Flag to turn off the compiler check for missing Brillig call constrains.
+    /// Warning: This can improve compilation speed but can also lead to correctness errors.
+    /// This check should always be run on production code.
+    #[arg(long)]
+    pub skip_brillig_constraints_check: bool,
+
+    /// Setting to decide on an inlining strategy for Brillig functions.
+    /// A more aggressive inliner should generate larger programs but more optimized
+    /// A less aggressive inliner should generate smaller programs
+    #[arg(long, hide = true, allow_hyphen_values = true, default_value_t = i64::MAX)]
+    pub inliner_aggressiveness: i64,
+
+    /// Setting the maximum acceptable increase in Brillig bytecode size due to
+    /// unrolling small loops. When left empty, any change is accepted as long
+    /// as it required fewer SSA instructions.
+    /// A higher value results in fewer jumps but a larger program.
+    /// A lower value keeps the original program if it was smaller, even if it has more jumps.
+    #[arg(long, hide = true, allow_hyphen_values = true)]
+    pub max_bytecode_increase_percent: Option<i32>,
 }
 
 pub fn parse_expression_width(input: &str) -> Result<ExpressionWidth, std::io::Error> {
@@ -134,7 +160,11 @@ pub fn parse_expression_width(input: &str) -> Result<ExpressionWidth, std::io::E
 
     match width {
         0 => Ok(ExpressionWidth::Unbounded),
-        _ => Ok(ExpressionWidth::Bounded { width }),
+        w if w >= MIN_EXPRESSION_WIDTH => Ok(ExpressionWidth::Bounded { width }),
+        _ => Err(Error::new(
+            ErrorKind::InvalidInput,
+            format!("has to be 0 or at least {MIN_EXPRESSION_WIDTH}"),
+        )),
     }
 }
 
@@ -271,13 +301,12 @@ pub fn add_dep(
 ///
 /// This returns a (possibly empty) vector of any warnings found on success.
 /// On error, this returns a non-empty vector of warnings and error messages, with at least one error.
-#[tracing::instrument(level = "trace", skip(context))]
+#[tracing::instrument(level = "trace", skip_all)]
 pub fn check_crate(
     context: &mut Context,
     crate_id: CrateId,
     options: &CompileOptions,
 ) -> CompilationResult<()> {
-    let mut errors = vec![];
     let error_on_unused_imports = true;
     let diagnostics = CrateDefMap::collect_defs(
         crate_id,
@@ -285,15 +314,22 @@ pub fn check_crate(
         options.debug_comptime_in_file.as_deref(),
         error_on_unused_imports,
     );
-    errors.extend(diagnostics.into_iter().map(|(error, file_id)| {
-        let diagnostic = CustomDiagnostic::from(&error);
-        diagnostic.in_file(file_id)
-    }));
+    let warnings_and_errors: Vec<FileDiagnostic> = diagnostics
+        .into_iter()
+        .map(|(error, file_id)| {
+            let diagnostic = CustomDiagnostic::from(&error);
+            diagnostic.in_file(file_id)
+        })
+        .filter(|diagnostic| {
+            // We filter out any warnings if they're going to be ignored later on to free up memory.
+            !options.silence_warnings || diagnostic.diagnostic.kind != DiagnosticKind::Warning
+        })
+        .collect();
 
-    if has_errors(&errors, options.deny_warnings) {
-        Err(errors)
+    if has_errors(&warnings_and_errors, options.deny_warnings) {
+        Err(warnings_and_errors)
     } else {
-        Ok(((), errors))
+        Ok(((), warnings_and_errors))
     }
 }
 
@@ -310,6 +346,8 @@ pub fn compute_function_abi(
 ///
 /// On success this returns the compiled program alongside any warnings that were found.
 /// On error this returns the non-empty list of warnings and errors.
+///
+/// See [compile_no_check] for further information about the use of `cached_program`.
 pub fn compile_main(
     context: &mut Context,
     crate_id: CrateId,
@@ -444,14 +482,11 @@ fn compile_contract_inner(
             .attributes
             .secondary
             .iter()
-            .filter_map(|attr| {
-                if let SecondaryAttribute::Custom(attribute) = attr {
-                    Some(&attribute.contents)
-                } else {
-                    None
-                }
+            .filter_map(|attr| match attr {
+                SecondaryAttribute::Tag(attribute) => Some(attribute.contents.clone()),
+                SecondaryAttribute::Meta(attribute) => Some(attribute.to_string()),
+                _ => None,
             })
-            .cloned()
             .collect();
 
         functions.push(ContractFunction {
@@ -534,6 +569,15 @@ pub const DEFAULT_EXPRESSION_WIDTH: ExpressionWidth = ExpressionWidth::Bounded {
 /// Compile the current crate using `main_function` as the entrypoint.
 ///
 /// This function assumes [`check_crate`] is called beforehand.
+///
+/// If the program is not returned from cache, it is backend-agnostic and must go through a transformation
+/// pass before usage in proof generation; if it's returned from cache these transformations might have
+/// already been applied.
+///
+/// The transformations are _not_ covered by the check that decides whether we can use the cached artifact.
+/// That comparison is based on on [CompiledProgram::hash] which is a persisted version of the hash of the input
+/// [`ast::Program`][noirc_frontend::monomorphization::ast::Program], whereas the output [`circuit::Program`][acir::circuit::Program]
+/// contains the final optimized ACIR opcodes, including the transformation done after this compilation.
 #[tracing::instrument(level = "trace", skip_all, fields(function_name = context.function_name(&main_function)))]
 pub fn compile_no_check(
     context: &mut Context,
@@ -548,8 +592,6 @@ pub fn compile_no_check(
         monomorphize(main_function, &mut context.def_interner)?
     };
 
-    let hash = fxhash::hash64(&program);
-    let hashes_match = cached_program.as_ref().map_or(false, |program| program.hash == hash);
     if options.show_monomorphized {
         println!("{program}");
     }
@@ -563,13 +605,28 @@ pub fn compile_no_check(
         || options.show_ssa
         || options.emit_ssa;
 
-    if !force_compile && hashes_match {
-        info!("Program matches existing artifact, returning early");
-        return Ok(cached_program.expect("cache must exist for hashes to match"));
+    // Hash the AST program, which is going to be used to fingerprint the compilation artifact.
+    let hash = fxhash::hash64(&program);
+
+    if let Some(cached_program) = cached_program {
+        if !force_compile && cached_program.hash == hash {
+            info!("Program matches existing artifact, returning early");
+            return Ok(cached_program);
+        }
     }
+
     let return_visibility = program.return_visibility;
     let ssa_evaluator_options = noirc_evaluator::ssa::SsaEvaluatorOptions {
-        enable_ssa_logging: options.show_ssa,
+        ssa_logging: match &options.show_ssa_pass_name {
+            Some(string) => SsaLogging::Contains(string.clone()),
+            None => {
+                if options.show_ssa {
+                    SsaLogging::All
+                } else {
+                    SsaLogging::None
+                }
+            }
+        },
         enable_brillig_logging: options.show_brillig,
         force_brillig_output: options.force_brillig,
         print_codegen_timings: options.benchmark_codegen,
@@ -580,6 +637,9 @@ pub fn compile_no_check(
         },
         emit_ssa: if options.emit_ssa { Some(context.package_build_path.clone()) } else { None },
         skip_underconstrained_check: options.skip_underconstrained_check,
+        skip_brillig_constraints_check: options.skip_brillig_constraints_check,
+        inliner_aggressiveness: options.inliner_aggressiveness,
+        max_bytecode_increase_percent: options.max_bytecode_increase_percent,
     };
 
     let SsaProgramArtifact { program, debug, warnings, names, brillig_names, error_types, .. } =
diff --git a/compiler/noirc_driver/src/program.rs b/compiler/noirc_driver/src/program.rs
index 88460482928..4b4d6662e8e 100644
--- a/compiler/noirc_driver/src/program.rs
+++ b/compiler/noirc_driver/src/program.rs
@@ -9,7 +9,7 @@ use serde::{Deserialize, Serialize};
 
 use super::debug::DebugFile;
 
-#[derive(Debug, Serialize, Deserialize, Clone)]
+#[derive(Debug, Serialize, Deserialize, Clone, Hash)]
 pub struct CompiledProgram {
     pub noir_version: String,
     /// Hash of the [`Program`][noirc_frontend::monomorphization::ast::Program] from which this [`CompiledProgram`]
diff --git a/compiler/noirc_errors/Cargo.toml b/compiler/noirc_errors/Cargo.toml
index 61b274c605f..a6927eb647a 100644
--- a/compiler/noirc_errors/Cargo.toml
+++ b/compiler/noirc_errors/Cargo.toml
@@ -16,7 +16,6 @@ acvm.workspace = true
 codespan-reporting.workspace = true
 codespan.workspace = true
 fm.workspace = true
-chumsky.workspace = true
 noirc_printable_type.workspace = true
 serde.workspace = true
 serde_with = "3.2.0"
diff --git a/compiler/noirc_errors/src/debug_info.rs b/compiler/noirc_errors/src/debug_info.rs
index b480d20fde4..a5e12b37712 100644
--- a/compiler/noirc_errors/src/debug_info.rs
+++ b/compiler/noirc_errors/src/debug_info.rs
@@ -12,7 +12,6 @@ use serde::Serializer;
 use serde_with::serde_as;
 use serde_with::DisplayFromStr;
 use std::collections::BTreeMap;
-use std::collections::HashMap;
 use std::io::Read;
 use std::io::Write;
 use std::mem;
@@ -48,6 +47,9 @@ pub type DebugVariables = BTreeMap<DebugVarId, DebugVariable>;
 pub type DebugFunctions = BTreeMap<DebugFnId, DebugFunction>;
 pub type DebugTypes = BTreeMap<DebugTypeId, PrintableType>;
 
+#[derive(Debug, Clone, Copy, Hash, PartialEq, Eq, PartialOrd, Ord, Deserialize, Serialize)]
+pub struct ProcedureDebugId(pub u32);
+
 #[derive(Default, Debug, Clone, Deserialize, Serialize)]
 pub struct ProgramDebugInfo {
     pub debug_infos: Vec<DebugInfo>,
@@ -92,7 +94,7 @@ impl ProgramDebugInfo {
 }
 
 #[serde_as]
-#[derive(Default, Debug, Clone, Deserialize, Serialize)]
+#[derive(Default, Debug, Clone, Deserialize, Serialize, Hash)]
 pub struct DebugInfo {
     /// Map opcode index of an ACIR circuit into the source code location
     /// Serde does not support mapping keys being enums for json, so we indicate
@@ -104,14 +106,9 @@ pub struct DebugInfo {
     pub variables: DebugVariables,
     pub functions: DebugFunctions,
     pub types: DebugTypes,
-}
-
-/// Holds OpCodes Counts for Acir and Brillig Opcodes
-/// To be printed with `nargo info --profile-info`
-#[derive(Default, Debug, Serialize, Deserialize, Clone)]
-pub struct OpCodesCount {
-    pub acir_size: usize,
-    pub brillig_size: usize,
+    /// This a map per brillig function representing the range of opcodes where a procedure is activated.
+    pub brillig_procedure_locs:
+        BTreeMap<BrilligFunctionId, BTreeMap<ProcedureDebugId, (usize, usize)>>,
 }
 
 impl DebugInfo {
@@ -124,8 +121,12 @@ impl DebugInfo {
         variables: DebugVariables,
         functions: DebugFunctions,
         types: DebugTypes,
+        brillig_procedure_locs: BTreeMap<
+            BrilligFunctionId,
+            BTreeMap<ProcedureDebugId, (usize, usize)>,
+        >,
     ) -> Self {
-        Self { locations, brillig_locations, variables, functions, types }
+        Self { locations, brillig_locations, variables, functions, types, brillig_procedure_locs }
     }
 
     /// Updates the locations map when the [`Circuit`][acvm::acir::circuit::Circuit] is modified.
@@ -147,38 +148,4 @@ impl DebugInfo {
     pub fn opcode_location(&self, loc: &OpcodeLocation) -> Option<Vec<Location>> {
         self.locations.get(loc).cloned()
     }
-
-    pub fn count_span_opcodes(&self) -> HashMap<Location, OpCodesCount> {
-        let mut accumulator: HashMap<Location, Vec<&OpcodeLocation>> = HashMap::new();
-
-        for (opcode_location, locations) in self.locations.iter() {
-            for location in locations.iter() {
-                let opcodes = accumulator.entry(*location).or_default();
-                opcodes.push(opcode_location);
-            }
-        }
-
-        let counted_opcodes = accumulator
-            .iter()
-            .map(|(location, opcodes)| {
-                let acir_opcodes: Vec<_> = opcodes
-                    .iter()
-                    .filter(|opcode_location| matches!(opcode_location, OpcodeLocation::Acir(_)))
-                    .collect();
-                let brillig_opcodes: Vec<_> = opcodes
-                    .iter()
-                    .filter(|opcode_location| {
-                        matches!(opcode_location, OpcodeLocation::Brillig { .. })
-                    })
-                    .collect();
-                let opcodes_count = OpCodesCount {
-                    acir_size: acir_opcodes.len(),
-                    brillig_size: brillig_opcodes.len(),
-                };
-                (*location, opcodes_count)
-            })
-            .collect();
-
-        counted_opcodes
-    }
 }
diff --git a/compiler/noirc_errors/src/position.rs b/compiler/noirc_errors/src/position.rs
index 9b031f56ae2..c7a64c4f422 100644
--- a/compiler/noirc_errors/src/position.rs
+++ b/compiler/noirc_errors/src/position.rs
@@ -8,7 +8,7 @@ use std::{
 
 pub type Position = u32;
 
-#[derive(PartialOrd, Eq, Ord, Debug, Clone)]
+#[derive(PartialOrd, Eq, Ord, Debug, Clone, Default)]
 pub struct Spanned<T> {
     pub contents: T,
     span: Span,
@@ -94,8 +94,10 @@ impl Span {
         self.start() <= other.start() && self.end() >= other.end()
     }
 
+    /// Returns `true` if any point of `self` intersects a point of `other`.
+    /// Adjacent spans are considered to intersect (so, for example, `0..1` intersects `1..3`).
     pub fn intersects(&self, other: &Span) -> bool {
-        self.end() > other.start() && self.start() < other.end()
+        self.end() >= other.start() && self.start() <= other.end()
     }
 
     pub fn is_smaller(&self, other: &Span) -> bool {
@@ -121,26 +123,6 @@ impl From<Range<u32>> for Span {
     }
 }
 
-impl chumsky::Span for Span {
-    type Context = ();
-
-    type Offset = u32;
-
-    fn new(_context: Self::Context, range: Range<Self::Offset>) -> Self {
-        Span(ByteSpan::from(range))
-    }
-
-    fn context(&self) -> Self::Context {}
-
-    fn start(&self) -> Self::Offset {
-        self.start()
-    }
-
-    fn end(&self) -> Self::Offset {
-        self.end()
-    }
-}
-
 #[derive(Debug, Copy, Clone, PartialEq, Eq, Hash, Deserialize, Serialize)]
 pub struct Location {
     pub span: Span,
@@ -160,3 +142,37 @@ impl Location {
         self.file == other.file && self.span.contains(&other.span)
     }
 }
+
+#[cfg(test)]
+mod tests {
+    use crate::Span;
+
+    #[test]
+    fn test_intersects() {
+        assert!(Span::from(5..10).intersects(&Span::from(5..10)));
+
+        assert!(Span::from(5..10).intersects(&Span::from(5..5)));
+        assert!(Span::from(5..5).intersects(&Span::from(5..10)));
+
+        assert!(Span::from(10..10).intersects(&Span::from(5..10)));
+        assert!(Span::from(5..10).intersects(&Span::from(10..10)));
+
+        assert!(Span::from(5..10).intersects(&Span::from(6..9)));
+        assert!(Span::from(6..9).intersects(&Span::from(5..10)));
+
+        assert!(Span::from(5..10).intersects(&Span::from(4..11)));
+        assert!(Span::from(4..11).intersects(&Span::from(5..10)));
+
+        assert!(Span::from(5..10).intersects(&Span::from(4..6)));
+        assert!(Span::from(4..6).intersects(&Span::from(5..10)));
+
+        assert!(Span::from(5..10).intersects(&Span::from(9..11)));
+        assert!(Span::from(9..11).intersects(&Span::from(5..10)));
+
+        assert!(!Span::from(5..10).intersects(&Span::from(3..4)));
+        assert!(!Span::from(3..4).intersects(&Span::from(5..10)));
+
+        assert!(!Span::from(5..10).intersects(&Span::from(11..12)));
+        assert!(!Span::from(11..12).intersects(&Span::from(5..10)));
+    }
+}
diff --git a/compiler/noirc_errors/src/reporter.rs b/compiler/noirc_errors/src/reporter.rs
index 76e308969b4..e57775d9a7f 100644
--- a/compiler/noirc_errors/src/reporter.rs
+++ b/compiler/noirc_errors/src/reporter.rs
@@ -10,7 +10,7 @@ use codespan_reporting::term::termcolor::{ColorChoice, StandardStream};
 pub struct CustomDiagnostic {
     pub message: String,
     pub secondaries: Vec<CustomLabel>,
-    notes: Vec<String>,
+    pub notes: Vec<String>,
     pub kind: DiagnosticKind,
     pub deprecated: bool,
     pub unnecessary: bool,
@@ -272,7 +272,7 @@ fn convert_diagnostic(
     diagnostic.with_message(&cd.message).with_labels(secondary_labels).with_notes(notes)
 }
 
-fn stack_trace<'files>(
+pub fn stack_trace<'files>(
     files: &'files impl Files<'files, FileId = fm::FileId>,
     call_stack: &[Location],
 ) -> String {
diff --git a/compiler/noirc_evaluator/Cargo.toml b/compiler/noirc_evaluator/Cargo.toml
index 1db6af2ae85..72fba8aadc2 100644
--- a/compiler/noirc_evaluator/Cargo.toml
+++ b/compiler/noirc_evaluator/Cargo.toml
@@ -31,7 +31,11 @@ cfg-if.workspace = true
 
 [dev-dependencies]
 proptest.workspace = true
+similar-asserts.workspace = true
+tracing-test = "0.2.5"
+num-traits.workspace = true
+test-case.workspace = true
 
 [features]
 bn254 = ["noirc_frontend/bn254"]
-bls12_381= []
+bls12_381 = []
diff --git a/compiler/noirc_evaluator/src/ssa/acir_gen/acir_ir/acir_variable.rs b/compiler/noirc_evaluator/src/acir/acir_variable.rs
similarity index 95%
rename from compiler/noirc_evaluator/src/ssa/acir_gen/acir_ir/acir_variable.rs
rename to compiler/noirc_evaluator/src/acir/acir_variable.rs
index b0f283eeaeb..9f2c649ee3e 100644
--- a/compiler/noirc_evaluator/src/ssa/acir_gen/acir_ir/acir_variable.rs
+++ b/compiler/noirc_evaluator/src/acir/acir_variable.rs
@@ -1,24 +1,18 @@
-use super::big_int::BigIntContext;
-use super::generated_acir::{BrilligStdlibFunc, GeneratedAcir, PLACEHOLDER_BRILLIG_INDEX};
-use crate::brillig::brillig_gen::brillig_directive;
-use crate::brillig::brillig_ir::artifact::GeneratedBrillig;
-use crate::errors::{InternalBug, InternalError, RuntimeError, SsaReport};
-use crate::ssa::acir_gen::{AcirDynamicArray, AcirValue};
-use crate::ssa::ir::dfg::CallStack;
-use crate::ssa::ir::types::Type as SsaType;
-use crate::ssa::ir::{instruction::Endian, types::NumericType};
-use acvm::acir::circuit::brillig::{BrilligFunctionId, BrilligInputs, BrilligOutputs};
-use acvm::acir::circuit::opcodes::{AcirFunctionId, BlockId, BlockType, MemOp};
-use acvm::acir::circuit::{AssertionPayload, ExpressionOrMemory, ExpressionWidth, Opcode};
-use acvm::brillig_vm::{MemoryValue, VMStatus, VM};
 use acvm::{
-    acir::AcirField,
     acir::{
         brillig::Opcode as BrilligOpcode,
-        circuit::opcodes::FunctionInput,
+        circuit::{
+            brillig::{BrilligFunctionId, BrilligInputs, BrilligOutputs},
+            opcodes::{
+                AcirFunctionId, BlockId, BlockType, ConstantOrWitnessEnum, FunctionInput, MemOp,
+            },
+            AssertionPayload, ExpressionOrMemory, ExpressionWidth, Opcode,
+        },
         native_types::{Expression, Witness},
-        BlackBoxFunc,
+        AcirField, BlackBoxFunc,
     },
+    brillig_vm::{MemoryValue, VMStatus, VM},
+    BlackBoxFunctionSolver,
 };
 use fxhash::FxHashMap as HashMap;
 use iter_extended::{try_vecmap, vecmap};
@@ -26,6 +20,16 @@ use num_bigint::BigUint;
 use std::cmp::Ordering;
 use std::{borrow::Cow, hash::Hash};
 
+use crate::brillig::brillig_ir::artifact::GeneratedBrillig;
+use crate::errors::{InternalBug, InternalError, RuntimeError, SsaReport};
+use crate::ssa::ir::{
+    dfg::CallStack, instruction::Endian, types::NumericType, types::Type as SsaType,
+};
+
+use super::big_int::BigIntContext;
+use super::generated_acir::{BrilligStdlibFunc, GeneratedAcir, PLACEHOLDER_BRILLIG_INDEX};
+use super::{brillig_directive, AcirDynamicArray, AcirValue};
+
 #[derive(Clone, Debug, PartialEq, Eq, Hash)]
 /// High level Type descriptor for Variables.
 ///
@@ -88,7 +92,7 @@ impl<'a> From<&'a SsaType> for AcirType {
             SsaType::Numeric(numeric_type) => AcirType::NumericType(*numeric_type),
             SsaType::Array(elements, size) => {
                 let elements = elements.iter().map(|e| e.into()).collect();
-                AcirType::Array(elements, *size)
+                AcirType::Array(elements, *size as usize)
             }
             _ => unreachable!("The type {value} cannot be represented in ACIR"),
         }
@@ -105,7 +109,9 @@ impl From<NumericType> for AcirType {
 /// Context object which holds the relationship between
 /// `Variables`(AcirVar) and types such as `Expression` and `Witness`
 /// which are placed into ACIR.
-pub(crate) struct AcirContext<F: AcirField> {
+pub(crate) struct AcirContext<F: AcirField, B: BlackBoxFunctionSolver<F>> {
+    blackbox_solver: B,
+
     /// Two-way map that links `AcirVar` to `AcirVarData`.
     ///
     /// The vars object is an instance of the `TwoWayMap`, which provides a bidirectional mapping between `AcirVar` and `AcirVarData`.
@@ -130,7 +136,7 @@ pub(crate) struct AcirContext<F: AcirField> {
     pub(crate) warnings: Vec<SsaReport>,
 }
 
-impl<F: AcirField> AcirContext<F> {
+impl<F: AcirField, B: BlackBoxFunctionSolver<F>> AcirContext<F, B> {
     pub(crate) fn set_expression_width(&mut self, expression_width: ExpressionWidth) {
         self.expression_width = expression_width;
     }
@@ -572,7 +578,7 @@ impl<F: AcirField> AcirContext<F> {
         let numeric_type = match typ {
             AcirType::NumericType(numeric_type) => numeric_type,
             AcirType::Array(_, _) => {
-                todo!("cannot divide arrays. This should have been caught by the frontend")
+                unreachable!("cannot divide arrays. This should have been caught by the frontend")
             }
         };
         match numeric_type {
@@ -1078,11 +1084,22 @@ impl<F: AcirField> AcirContext<F> {
         &mut self,
         lhs: AcirVar,
         rhs: AcirVar,
+        typ: AcirType,
         bit_size: u32,
         predicate: AcirVar,
     ) -> Result<AcirVar, RuntimeError> {
-        let (_, remainder) = self.euclidean_division_var(lhs, rhs, bit_size, predicate)?;
-        Ok(remainder)
+        let numeric_type = match typ {
+            AcirType::NumericType(numeric_type) => numeric_type,
+            AcirType::Array(_, _) => {
+                unreachable!("cannot modulo arrays. This should have been caught by the frontend")
+            }
+        };
+
+        let (_, remainder_var) = match numeric_type {
+            NumericType::Signed { bit_size } => self.signed_division_var(lhs, rhs, bit_size)?,
+            _ => self.euclidean_division_var(lhs, rhs, bit_size, predicate)?,
+        };
+        Ok(remainder_var)
     }
 
     /// Constrains the `AcirVar` variable to be of type `NumericType`.
@@ -1106,10 +1123,10 @@ impl<F: AcirField> AcirContext<F> {
                 let witness = self.var_to_witness(witness_var)?;
                 self.acir_ir.range_constraint(witness, *bit_size)?;
                 if let Some(message) = message {
-                    self.acir_ir.assertion_payloads.insert(
-                        self.acir_ir.last_acir_opcode_location(),
-                        AssertionPayload::StaticString(message.clone()),
-                    );
+                    let payload = self.generate_assertion_message_payload(message.clone());
+                    self.acir_ir
+                        .assertion_payloads
+                        .insert(self.acir_ir.last_acir_opcode_location(), payload);
                 }
             }
             NumericType::NativeField => {
@@ -1284,31 +1301,6 @@ impl<F: AcirField> AcirContext<F> {
     ) -> Result<Vec<AcirVar>, RuntimeError> {
         // Separate out any arguments that should be constants
         let (constant_inputs, constant_outputs) = match name {
-            BlackBoxFunc::PedersenCommitment | BlackBoxFunc::PedersenHash => {
-                // The last argument of pedersen is the domain separator, which must be a constant
-                let domain_var = match inputs.pop() {
-                    Some(domain_var) => domain_var.into_var()?,
-                    None => {
-                        return Err(RuntimeError::InternalError(InternalError::MissingArg {
-                            name: "pedersen call".to_string(),
-                            arg: "domain separator".to_string(),
-                            call_stack: self.get_call_stack(),
-                        }))
-                    }
-                };
-
-                let domain_constant = match self.vars[&domain_var].as_constant() {
-                    Some(domain_constant) => domain_constant,
-                    None => {
-                        return Err(RuntimeError::InternalError(InternalError::NotAConstant {
-                            name: "domain separator".to_string(),
-                            call_stack: self.get_call_stack(),
-                        }))
-                    }
-                };
-
-                (vec![*domain_constant], Vec::new())
-            }
             BlackBoxFunc::Poseidon2Permutation => {
                 // The last argument is the state length, which must be a constant
                 let state_len = match inputs.pop() {
@@ -1459,22 +1451,7 @@ impl<F: AcirField> AcirContext<F> {
             }
             _ => (vec![], vec![]),
         };
-        // Allow constant inputs for most blackbox
-        // EmbeddedCurveAdd needs to be fixed first in bb
-        // Poseidon2Permutation requires witness input
-        let allow_constant_inputs = matches!(
-            name,
-            BlackBoxFunc::MultiScalarMul
-                | BlackBoxFunc::Keccakf1600
-                | BlackBoxFunc::Blake2s
-                | BlackBoxFunc::Blake3
-                | BlackBoxFunc::AND
-                | BlackBoxFunc::XOR
-                | BlackBoxFunc::AES128Encrypt
-                | BlackBoxFunc::EmbeddedCurveAdd
-        );
-        // Convert `AcirVar` to `FunctionInput`
-        let inputs = self.prepare_inputs_for_black_box_func_call(inputs, allow_constant_inputs)?;
+        let inputs = self.prepare_inputs_for_black_box_func(inputs, name)?;
         // Call Black box with `FunctionInput`
         let mut results = vecmap(&constant_outputs, |c| self.add_constant(*c));
         let outputs = self.acir_ir.call_black_box(
@@ -1496,6 +1473,34 @@ impl<F: AcirField> AcirContext<F> {
         Ok(results)
     }
 
+    fn prepare_inputs_for_black_box_func(
+        &mut self,
+        inputs: Vec<AcirValue>,
+        name: BlackBoxFunc,
+    ) -> Result<Vec<Vec<FunctionInput<F>>>, RuntimeError> {
+        // Allow constant inputs for most blackbox, but:
+        // - EmbeddedCurveAdd requires all-or-nothing constant inputs
+        // - Poseidon2Permutation requires witness input
+        let allow_constant_inputs = matches!(
+            name,
+            BlackBoxFunc::MultiScalarMul
+                | BlackBoxFunc::Keccakf1600
+                | BlackBoxFunc::Blake2s
+                | BlackBoxFunc::Blake3
+                | BlackBoxFunc::AND
+                | BlackBoxFunc::XOR
+                | BlackBoxFunc::AES128Encrypt
+                | BlackBoxFunc::EmbeddedCurveAdd
+        );
+        // Convert `AcirVar` to `FunctionInput`
+        let mut inputs =
+            self.prepare_inputs_for_black_box_func_call(inputs, allow_constant_inputs)?;
+        if name == BlackBoxFunc::EmbeddedCurveAdd {
+            inputs = self.all_or_nothing_for_ec_add(inputs)?;
+        }
+        Ok(inputs)
+    }
+
     /// Black box function calls expect their inputs to be in a specific data structure (FunctionInput).
     ///
     /// This function will convert `AcirVar` into `FunctionInput` for a blackbox function call.
@@ -1536,6 +1541,41 @@ impl<F: AcirField> AcirContext<F> {
         Ok(witnesses)
     }
 
+    /// EcAdd has 6 inputs representing the two points to add
+    /// Each point must be either all constant, or all witnesses
+    fn all_or_nothing_for_ec_add(
+        &mut self,
+        inputs: Vec<Vec<FunctionInput<F>>>,
+    ) -> Result<Vec<Vec<FunctionInput<F>>>, RuntimeError> {
+        let mut has_constant = false;
+        let mut has_witness = false;
+        let mut result = inputs.clone();
+        for (i, input) in inputs.iter().enumerate() {
+            if input[0].is_constant() {
+                has_constant = true;
+            } else {
+                has_witness = true;
+            }
+            if i % 3 == 2 {
+                if has_constant && has_witness {
+                    // Convert the constants to witness if mixed constant and witness,
+                    for j in i - 2..i + 1 {
+                        if let ConstantOrWitnessEnum::Constant(constant) = inputs[j][0].input() {
+                            let constant = self.add_constant(constant);
+                            let witness_var = self.get_or_create_witness_var(constant)?;
+                            let witness = self.var_to_witness(witness_var)?;
+                            result[j] =
+                                vec![FunctionInput::witness(witness, inputs[j][0].num_bits())];
+                        }
+                    }
+                }
+                has_constant = false;
+                has_witness = false;
+            }
+        }
+        Ok(result)
+    }
+
     /// Returns a vector of `AcirVar`s constrained to be the decomposition of the given input
     /// over given radix.
     ///
@@ -1733,8 +1773,8 @@ impl<F: AcirField> AcirContext<F> {
             brillig_stdlib_func,
         );
 
-        fn range_constraint_value<G: AcirField>(
-            context: &mut AcirContext<G>,
+        fn range_constraint_value<G: AcirField, C: BlackBoxFunctionSolver<G>>(
+            context: &mut AcirContext<G, C>,
             value: &AcirValue,
         ) -> Result<(), RuntimeError> {
             match value {
@@ -1853,7 +1893,7 @@ impl<F: AcirField> AcirContext<F> {
         inputs: &[BrilligInputs<F>],
         outputs_types: &[AcirType],
     ) -> Option<Vec<AcirValue>> {
-        let mut memory = (execute_brillig(code, inputs)?).into_iter();
+        let mut memory = (execute_brillig(code, &self.blackbox_solver, inputs)?).into_iter();
 
         let outputs_var = vecmap(outputs_types.iter(), |output| match output {
             AcirType::NumericType(_) => {
@@ -2043,6 +2083,13 @@ impl<F: AcirField> AcirContext<F> {
         self.acir_ir.push_opcode(Opcode::Call { id, inputs, outputs, predicate });
         Ok(results)
     }
+
+    pub(crate) fn generate_assertion_message_payload(
+        &mut self,
+        message: String,
+    ) -> AssertionPayload<F> {
+        self.acir_ir.generate_assertion_message_payload(message)
+    }
 }
 
 /// Enum representing the possible values that a
@@ -2139,8 +2186,9 @@ pub(crate) struct AcirVar(usize);
 /// Returns the finished state of the Brillig VM if execution can complete.
 ///
 /// Returns `None` if complete execution of the Brillig bytecode is not possible.
-fn execute_brillig<F: AcirField>(
+fn execute_brillig<F: AcirField, B: BlackBoxFunctionSolver<F>>(
     code: &[BrilligOpcode<F>],
+    blackbox_solver: &B,
     inputs: &[BrilligInputs<F>],
 ) -> Option<Vec<MemoryValue<F>>> {
     // Set input values
@@ -2166,11 +2214,8 @@ fn execute_brillig<F: AcirField>(
     }
 
     // Instantiate a Brillig VM given the solved input registers and memory, along with the Brillig bytecode.
-    //
-    // We pass a stubbed solver here as a concrete solver implies a field choice which conflicts with this function
-    // being generic.
-    let solver = acvm::blackbox_solver::StubbedBlackBoxSolver;
-    let mut vm = VM::new(calldata, code, Vec::new(), &solver);
+    let profiling_active = false;
+    let mut vm = VM::new(calldata, code, Vec::new(), blackbox_solver, profiling_active);
 
     // Run the Brillig VM on these inputs, bytecode, etc!
     let vm_status = vm.process_opcodes();
diff --git a/compiler/noirc_evaluator/src/ssa/acir_gen/acir_ir/big_int.rs b/compiler/noirc_evaluator/src/acir/big_int.rs
similarity index 100%
rename from compiler/noirc_evaluator/src/ssa/acir_gen/acir_ir/big_int.rs
rename to compiler/noirc_evaluator/src/acir/big_int.rs
diff --git a/compiler/noirc_evaluator/src/acir/brillig_directive.rs b/compiler/noirc_evaluator/src/acir/brillig_directive.rs
new file mode 100644
index 00000000000..89fc7f1eda5
--- /dev/null
+++ b/compiler/noirc_evaluator/src/acir/brillig_directive.rs
@@ -0,0 +1,276 @@
+use acvm::acir::{
+    brillig::{
+        BinaryFieldOp, BinaryIntOp, BitSize, HeapVector, IntegerBitSize, MemoryAddress,
+        Opcode as BrilligOpcode,
+    },
+    AcirField,
+};
+
+use crate::brillig::brillig_ir::artifact::GeneratedBrillig;
+
+/// Generates brillig bytecode which computes the inverse of its input if not null, and zero else.
+pub(crate) fn directive_invert<F: AcirField>() -> GeneratedBrillig<F> {
+    //  We generate the following code:
+    // fn invert(x : Field) -> Field {
+    //    1/ x
+    // }
+
+    // The input argument, ie the value that will be inverted.
+    // We store the result in this register too.
+    let input = MemoryAddress::direct(0);
+    let one_const = MemoryAddress::direct(1);
+    let zero_const = MemoryAddress::direct(2);
+    let input_is_zero = MemoryAddress::direct(3);
+    let zero_usize = MemoryAddress::direct(20);
+    let one_usize = MemoryAddress::direct(21);
+    // Location of the stop opcode
+    let stop_location = 8;
+
+    GeneratedBrillig {
+        byte_code: vec![
+            BrilligOpcode::Const {
+                destination: one_usize,
+                bit_size: BitSize::Integer(IntegerBitSize::U32),
+                value: F::from(1_usize),
+            },
+            BrilligOpcode::Const {
+                destination: zero_usize,
+                bit_size: BitSize::Integer(IntegerBitSize::U32),
+                value: F::from(0_usize),
+            },
+            BrilligOpcode::CalldataCopy {
+                destination_address: input,
+                size_address: one_usize,
+                offset_address: zero_usize,
+            },
+            // Put value zero in register (2)
+            BrilligOpcode::Const {
+                destination: zero_const,
+                value: F::from(0_usize),
+                bit_size: BitSize::Field,
+            },
+            BrilligOpcode::BinaryFieldOp {
+                op: BinaryFieldOp::Equals,
+                lhs: input,
+                rhs: zero_const,
+                destination: input_is_zero,
+            },
+            // If the input is zero, then we jump to the stop opcode
+            BrilligOpcode::JumpIf { condition: input_is_zero, location: stop_location },
+            // Put value one in register (1)
+            BrilligOpcode::Const {
+                destination: one_const,
+                value: F::one(),
+                bit_size: BitSize::Field,
+            },
+            // Divide 1 by the input, and set the result of the division into register (0)
+            BrilligOpcode::BinaryFieldOp {
+                op: BinaryFieldOp::Div,
+                lhs: one_const,
+                rhs: input,
+                destination: input,
+            },
+            BrilligOpcode::Stop {
+                return_data: HeapVector { pointer: zero_usize, size: one_usize },
+            },
+        ],
+        name: "directive_invert".to_string(),
+        ..Default::default()
+    }
+}
+
+/// Generates brillig bytecode which computes `a / b` and returns the quotient and remainder.
+///
+/// This is equivalent to the Noir (pseudo)code
+///
+/// ```text
+/// fn quotient<T>(a: T, b: T) -> (T,T) {
+///    (a/b, a-a/b*b)
+/// }
+/// ```
+pub(crate) fn directive_quotient<F: AcirField>() -> GeneratedBrillig<F> {
+    // `a` is (0) (i.e register index 0)
+    // `b` is (1)
+
+    GeneratedBrillig {
+        byte_code: vec![
+            BrilligOpcode::Const {
+                destination: MemoryAddress::direct(10),
+                bit_size: BitSize::Integer(IntegerBitSize::U32),
+                value: F::from(2_usize),
+            },
+            BrilligOpcode::Const {
+                destination: MemoryAddress::direct(11),
+                bit_size: BitSize::Integer(IntegerBitSize::U32),
+                value: F::from(0_usize),
+            },
+            BrilligOpcode::CalldataCopy {
+                destination_address: MemoryAddress::direct(0),
+                size_address: MemoryAddress::direct(10),
+                offset_address: MemoryAddress::direct(11),
+            },
+            // No cast, since calldata is typed as field by default
+            //q = a/b is set into register (2)
+            BrilligOpcode::BinaryFieldOp {
+                op: BinaryFieldOp::IntegerDiv, // We want integer division, not field division!
+                lhs: MemoryAddress::direct(0),
+                rhs: MemoryAddress::direct(1),
+                destination: MemoryAddress::direct(2),
+            },
+            //(1)= q*b
+            BrilligOpcode::BinaryFieldOp {
+                op: BinaryFieldOp::Mul,
+                lhs: MemoryAddress::direct(2),
+                rhs: MemoryAddress::direct(1),
+                destination: MemoryAddress::direct(1),
+            },
+            //(1) = a-q*b
+            BrilligOpcode::BinaryFieldOp {
+                op: BinaryFieldOp::Sub,
+                lhs: MemoryAddress::direct(0),
+                rhs: MemoryAddress::direct(1),
+                destination: MemoryAddress::direct(1),
+            },
+            //(0) = q
+            BrilligOpcode::Mov {
+                destination: MemoryAddress::direct(0),
+                source: MemoryAddress::direct(2),
+            },
+            BrilligOpcode::Stop {
+                return_data: HeapVector {
+                    pointer: MemoryAddress::direct(11),
+                    size: MemoryAddress::direct(10),
+                },
+            },
+        ],
+        name: "directive_integer_quotient".to_string(),
+        ..Default::default()
+    }
+}
+
+/// Generates brillig bytecode which performs a radix-base decomposition of `a`
+/// The brillig inputs are 'a', the numbers of limbs and the radix
+pub(crate) fn directive_to_radix<F: AcirField>() -> GeneratedBrillig<F> {
+    let memory_adr_int_size = IntegerBitSize::U32;
+    let memory_adr_size = BitSize::Integer(memory_adr_int_size);
+
+    // (0) is the input field `a` to decompose
+    // (1) contains the number of limbs (second input)
+    let limbs_nb = MemoryAddress::direct(1);
+    // (2) contains the radix (third input)
+    let radix = MemoryAddress::direct(2);
+    // (3) and (4) are intermediate registers
+    // (5,6,7) are constants: 0,1,3
+    let zero = MemoryAddress::direct(5);
+    let one = MemoryAddress::direct(6);
+    let three = MemoryAddress::direct(7);
+    // (7) is the iteration bound, it is the same register as three because the latter is only used at the start
+    let bound = MemoryAddress::direct(7);
+    // (8) is the register for storing the loop condition
+    let cond = MemoryAddress::direct(8);
+    // (9) is the pointer to the result array
+    let result_pointer = MemoryAddress::direct(9);
+    // address of the result array
+    let result_base_adr = 10_usize;
+
+    let result_vector = HeapVector { pointer: result_pointer, size: limbs_nb };
+
+    let byte_code = vec![
+        // Initialize registers
+        // Constants
+        // Zero
+        BrilligOpcode::Const { destination: zero, bit_size: memory_adr_size, value: F::zero() },
+        // One
+        BrilligOpcode::Const {
+            destination: one,
+            bit_size: memory_adr_size,
+            value: F::from(1_usize),
+        },
+        // Three
+        BrilligOpcode::Const {
+            destination: three,
+            bit_size: memory_adr_size,
+            value: F::from(3_usize),
+        },
+        // Brillig Inputs
+        BrilligOpcode::CalldataCopy {
+            destination_address: MemoryAddress::direct(0),
+            size_address: three,
+            offset_address: zero,
+        },
+        // The number of limbs needs to be an integer
+        BrilligOpcode::Cast { destination: limbs_nb, source: limbs_nb, bit_size: memory_adr_size },
+        // Result_pointer starts at the base address
+        BrilligOpcode::Const {
+            destination: result_pointer,
+            bit_size: memory_adr_size,
+            value: F::from(result_base_adr),
+        },
+        // Loop bound
+        BrilligOpcode::BinaryIntOp {
+            destination: bound,
+            op: BinaryIntOp::Add,
+            bit_size: memory_adr_int_size,
+            lhs: result_pointer,
+            rhs: limbs_nb,
+        },
+        // loop label: (3) = a / radix (integer division)
+        BrilligOpcode::BinaryFieldOp {
+            op: BinaryFieldOp::IntegerDiv,
+            lhs: MemoryAddress::direct(0),
+            rhs: radix,
+            destination: MemoryAddress::direct(3),
+        },
+        //(4) = (3)*256
+        BrilligOpcode::BinaryFieldOp {
+            op: BinaryFieldOp::Mul,
+            lhs: MemoryAddress::direct(3),
+            rhs: radix,
+            destination: MemoryAddress::direct(4),
+        },
+        //(4) = a-(3)*256 (remainder)
+        BrilligOpcode::BinaryFieldOp {
+            op: BinaryFieldOp::Sub,
+            lhs: MemoryAddress::direct(0),
+            rhs: MemoryAddress::direct(4),
+            destination: MemoryAddress::direct(4),
+        },
+        // Store the remainder in the result array
+        BrilligOpcode::Store {
+            destination_pointer: result_pointer,
+            source: MemoryAddress::direct(4),
+        },
+        // Increment the result pointer
+        BrilligOpcode::BinaryIntOp {
+            op: BinaryIntOp::Add,
+            lhs: result_pointer,
+            rhs: one,
+            destination: result_pointer,
+            bit_size: memory_adr_int_size,
+        },
+        //a := quotient
+        BrilligOpcode::Mov {
+            destination: MemoryAddress::direct(0),
+            source: MemoryAddress::direct(3),
+        },
+        // loop condition
+        BrilligOpcode::BinaryIntOp {
+            op: BinaryIntOp::LessThan,
+            lhs: result_pointer,
+            rhs: bound,
+            destination: cond,
+            bit_size: memory_adr_int_size,
+        },
+        // loop back
+        BrilligOpcode::JumpIf { condition: cond, location: 7 },
+        // reset result pointer to the start of the array
+        BrilligOpcode::Const {
+            destination: result_pointer,
+            bit_size: memory_adr_size,
+            value: F::from(result_base_adr),
+        },
+        BrilligOpcode::Stop { return_data: result_vector },
+    ];
+
+    GeneratedBrillig { byte_code, name: "directive_to_radix".to_string(), ..Default::default() }
+}
diff --git a/compiler/noirc_evaluator/src/ssa/acir_gen/acir_ir/generated_acir.rs b/compiler/noirc_evaluator/src/acir/generated_acir.rs
similarity index 88%
rename from compiler/noirc_evaluator/src/ssa/acir_gen/acir_ir/generated_acir.rs
rename to compiler/noirc_evaluator/src/acir/generated_acir.rs
index 21d4dfb60b8..3b29c0319ab 100644
--- a/compiler/noirc_evaluator/src/ssa/acir_gen/acir_ir/generated_acir.rs
+++ b/compiler/noirc_evaluator/src/acir/generated_acir.rs
@@ -1,26 +1,27 @@
 //! `GeneratedAcir` is constructed as part of the `acir_gen` pass to accumulate all of the ACIR
 //! program as it is being converted from SSA form.
-use std::{collections::BTreeMap, u32};
+use std::collections::BTreeMap;
 
-use crate::{
-    brillig::{brillig_gen::brillig_directive, brillig_ir::artifact::GeneratedBrillig},
-    errors::{InternalError, RuntimeError, SsaReport},
-    ssa::ir::dfg::CallStack,
-};
 use acvm::acir::{
     circuit::{
         brillig::{BrilligFunctionId, BrilligInputs, BrilligOutputs},
         opcodes::{BlackBoxFuncCall, FunctionInput, Opcode as AcirOpcode},
-        AssertionPayload, BrilligOpcodeLocation, OpcodeLocation,
+        AssertionPayload, BrilligOpcodeLocation, ErrorSelector, OpcodeLocation,
     },
-    native_types::Witness,
-    BlackBoxFunc,
+    native_types::{Expression, Witness},
+    AcirField, BlackBoxFunc,
 };
-use acvm::{
-    acir::AcirField,
-    acir::{circuit::directives::Directive, native_types::Expression},
+
+use super::brillig_directive;
+use crate::{
+    brillig::brillig_ir::artifact::GeneratedBrillig,
+    errors::{InternalError, RuntimeError, SsaReport},
+    ssa::ir::dfg::CallStack,
+    ErrorType,
 };
+
 use iter_extended::vecmap;
+use noirc_errors::debug_info::ProcedureDebugId;
 use num_bigint::BigUint;
 
 /// Brillig calls such as for the Brillig std lib are resolved only after code generation is finished.
@@ -62,6 +63,9 @@ pub(crate) struct GeneratedAcir<F: AcirField> {
     /// Correspondence between an opcode index and the error message associated with it.
     pub(crate) assertion_payloads: BTreeMap<OpcodeLocation, AssertionPayload<F>>,
 
+    /// Correspondence between error selectors and types associated with them.
+    pub(crate) error_types: BTreeMap<ErrorSelector, ErrorType>,
+
     pub(crate) warnings: Vec<SsaReport>,
 
     /// Name for the corresponding entry point represented by this Acir-gen output.
@@ -72,6 +76,11 @@ pub(crate) struct GeneratedAcir<F: AcirField> {
     /// As to avoid passing the ACIR gen shared context into each individual ACIR
     /// we can instead keep this map and resolve the Brillig calls at the end of code generation.
     pub(crate) brillig_stdlib_func_locations: BTreeMap<OpcodeLocation, BrilligStdlibFunc>,
+
+    /// Brillig function id -> Brillig procedure locations map
+    /// This maps allows a profiler to determine which Brillig opcodes
+    /// originated from a reusable procedure.
+    pub(crate) brillig_procedure_locs: BTreeMap<BrilligFunctionId, BrilligProcedureRangeMap>,
 }
 
 /// Correspondence between an opcode index (in opcodes) and the source code call stack which generated it
@@ -79,10 +88,13 @@ pub(crate) type OpcodeToLocationsMap = BTreeMap<OpcodeLocation, CallStack>;
 
 pub(crate) type BrilligOpcodeToLocationsMap = BTreeMap<BrilligOpcodeLocation, CallStack>;
 
+pub(crate) type BrilligProcedureRangeMap = BTreeMap<ProcedureDebugId, (usize, usize)>;
+
 #[derive(Debug, Clone, Copy, Hash, PartialEq, Eq)]
 pub(crate) enum BrilligStdlibFunc {
     Inverse,
     Quotient,
+    ToLeBytes,
 }
 
 impl BrilligStdlibFunc {
@@ -90,6 +102,7 @@ impl BrilligStdlibFunc {
         match self {
             BrilligStdlibFunc::Inverse => brillig_directive::directive_invert(),
             BrilligStdlibFunc::Quotient => brillig_directive::directive_quotient(),
+            BrilligStdlibFunc::ToLeBytes => brillig_directive::directive_to_radix(),
         }
     }
 }
@@ -144,7 +157,7 @@ impl<F: AcirField> GeneratedAcir<F> {
     /// This means you cannot multiply an infinite amount of `Expression`s together.
     /// Once the `Expression` goes over degree-2, then it needs to be reduced to a `Witness`
     /// which has degree-1 in order to be able to continue the multiplication chain.
-    pub(crate) fn create_witness_for_expression(&mut self, expression: &Expression<F>) -> Witness {
+    fn create_witness_for_expression(&mut self, expression: &Expression<F>) -> Witness {
         let fresh_witness = self.next_witness_index();
 
         // Create a constraint that sets them to be equal to each other
@@ -212,29 +225,6 @@ impl<F: AcirField> GeneratedAcir<F> {
                 inputs: inputs[0].clone(),
                 outputs: outputs.try_into().expect("Compiler should generate correct size outputs"),
             },
-            BlackBoxFunc::SchnorrVerify => {
-                BlackBoxFuncCall::SchnorrVerify {
-                    public_key_x: inputs[0][0],
-                    public_key_y: inputs[1][0],
-                    // Schnorr signature is an r & s, 32 bytes each
-                    signature: inputs[2]
-                        .clone()
-                        .try_into()
-                        .expect("Compiler should generate correct size inputs"),
-                    message: inputs[3].clone(),
-                    output: outputs[0],
-                }
-            }
-            BlackBoxFunc::PedersenCommitment => BlackBoxFuncCall::PedersenCommitment {
-                inputs: inputs[0].clone(),
-                outputs: (outputs[0], outputs[1]),
-                domain_separator: constant_inputs[0].to_u128() as u32,
-            },
-            BlackBoxFunc::PedersenHash => BlackBoxFuncCall::PedersenHash {
-                inputs: inputs[0].clone(),
-                output: outputs[0],
-                domain_separator: constant_inputs[0].to_u128() as u32,
-            },
             BlackBoxFunc::EcdsaSecp256k1 => {
                 BlackBoxFuncCall::EcdsaSecp256k1 {
                     // 32 bytes for each public key co-ordinate
@@ -294,9 +284,6 @@ impl<F: AcirField> GeneratedAcir<F> {
                 input2: Box::new([inputs[3][0], inputs[4][0], inputs[5][0]]),
                 outputs: (outputs[0], outputs[1], outputs[2]),
             },
-            BlackBoxFunc::Keccak256 => {
-                unreachable!("unexpected BlackBox {}", func_name.to_string())
-            }
             BlackBoxFunc::Keccakf1600 => BlackBoxFuncCall::Keccakf1600 {
                 inputs: inputs[0]
                     .clone()
@@ -381,12 +368,7 @@ impl<F: AcirField> GeneratedAcir<F> {
             "ICE: Radix must be a power of 2"
         );
 
-        let limb_witnesses = vecmap(0..limb_count, |_| self.next_witness_index());
-        self.push_opcode(AcirOpcode::Directive(Directive::ToLeRadix {
-            a: input_expr.clone(),
-            b: limb_witnesses.clone(),
-            radix,
-        }));
+        let limb_witnesses = self.brillig_to_radix(input_expr, radix, limb_count);
 
         let mut composed_limbs = Expression::default();
 
@@ -407,6 +389,54 @@ impl<F: AcirField> GeneratedAcir<F> {
         Ok(limb_witnesses)
     }
 
+    /// Adds brillig opcode for to_radix
+    ///
+    /// This code will decompose `expr` in a radix-base
+    /// and return  `Witnesses` which may (or not, because it does not apply constraints)
+    /// be limbs resulting from the decomposition.
+    ///
+    /// Safety: It is the callers responsibility to ensure that the
+    /// resulting `Witnesses` are properly constrained.
+    pub(crate) fn brillig_to_radix(
+        &mut self,
+        expr: &Expression<F>,
+        radix: u32,
+        limb_count: u32,
+    ) -> Vec<Witness> {
+        // Create the witness for the result
+        let limb_witnesses = vecmap(0..limb_count, |_| self.next_witness_index());
+
+        // Get the decomposition brillig code
+        let le_bytes_code = brillig_directive::directive_to_radix();
+        // Prepare the inputs/outputs
+        let limbs_nb = Expression {
+            mul_terms: Vec::new(),
+            linear_combinations: Vec::new(),
+            q_c: F::from(limb_count as u128),
+        };
+        let radix_expr = Expression {
+            mul_terms: Vec::new(),
+            linear_combinations: Vec::new(),
+            q_c: F::from(radix as u128),
+        };
+        let inputs = vec![
+            BrilligInputs::Single(expr.clone()),
+            BrilligInputs::Single(limbs_nb),
+            BrilligInputs::Single(radix_expr),
+        ];
+        let outputs = vec![BrilligOutputs::Array(limb_witnesses.clone())];
+
+        self.brillig_call(
+            None,
+            &le_bytes_code,
+            inputs,
+            outputs,
+            PLACEHOLDER_BRILLIG_INDEX,
+            Some(BrilligStdlibFunc::ToLeBytes),
+        );
+        limb_witnesses
+    }
+
     /// Adds an inversion brillig opcode.
     ///
     /// This code will invert `expr` without applying constraints
@@ -475,7 +505,7 @@ impl<F: AcirField> GeneratedAcir<F> {
     ///
     /// This equation however falls short when `t != 0` because then `t`
     /// may not be `1`. If `t` is non-zero, then `y` is also non-zero due to
-    /// `y == 1 - t` and the equation `y * t == 0` fails.  
+    /// `y == 1 - t` and the equation `y * t == 0` fails.
     ///
     /// To fix, we introduce another free variable called `z` and apply the following
     /// constraint instead: `y == 1 - t * z`.
@@ -485,7 +515,7 @@ impl<F: AcirField> GeneratedAcir<F> {
     ///
     /// We now arrive at the conclusion that when `t == 0`, `y` is `1` and when
     /// `t != 0`, then `y` is `0`.
-    ///  
+    ///
     /// Bringing it all together, We introduce two variables `y` and `z`,
     /// With the following equations:
     /// - `y == 1 - tz` (`z` is a value that is chosen to be the inverse of `t` by the prover)
@@ -589,21 +619,22 @@ impl<F: AcirField> GeneratedAcir<F> {
             return;
         }
 
-        // TODO(https://github.com/noir-lang/noir/issues/5792)
-        for (brillig_index, message) in generated_brillig.assert_messages.iter() {
-            self.assertion_payloads.insert(
-                OpcodeLocation::Brillig {
-                    acir_index: self.opcodes.len() - 1,
-                    brillig_index: *brillig_index,
-                },
-                AssertionPayload::StaticString(message.clone()),
-            );
+        for (error_selector, error_type) in generated_brillig.error_types.iter() {
+            self.record_error_type(*error_selector, error_type.clone());
         }
 
         if inserted_func_before {
             return;
         }
 
+        for (procedure_id, (start_index, end_index)) in generated_brillig.procedure_locations.iter()
+        {
+            self.brillig_procedure_locs
+                .entry(brillig_function_index)
+                .or_default()
+                .insert(procedure_id.to_debug_id(), (*start_index, *end_index));
+        }
+
         for (brillig_index, call_stack) in generated_brillig.locations.iter() {
             self.brillig_locations
                 .entry(brillig_function_index)
@@ -632,6 +663,20 @@ impl<F: AcirField> GeneratedAcir<F> {
     pub(crate) fn last_acir_opcode_location(&self) -> OpcodeLocation {
         OpcodeLocation::Acir(self.opcodes.len() - 1)
     }
+
+    pub(crate) fn record_error_type(&mut self, selector: ErrorSelector, typ: ErrorType) {
+        self.error_types.insert(selector, typ);
+    }
+
+    pub(crate) fn generate_assertion_message_payload(
+        &mut self,
+        message: String,
+    ) -> AssertionPayload<F> {
+        let error_type = ErrorType::String(message);
+        let error_selector = error_type.selector();
+        self.record_error_type(error_selector, error_type);
+        AssertionPayload { error_selector: error_selector.as_u64(), payload: Vec::new() }
+    }
 }
 
 /// This function will return the number of inputs that a blackbox function
@@ -643,12 +688,7 @@ fn black_box_func_expected_input_size(name: BlackBoxFunc) -> Option<usize> {
 
         // All of the hash/cipher methods will take in a
         // variable number of inputs.
-        BlackBoxFunc::AES128Encrypt
-        | BlackBoxFunc::Keccak256
-        | BlackBoxFunc::Blake2s
-        | BlackBoxFunc::Blake3
-        | BlackBoxFunc::PedersenCommitment
-        | BlackBoxFunc::PedersenHash => None,
+        BlackBoxFunc::AES128Encrypt | BlackBoxFunc::Blake2s | BlackBoxFunc::Blake3 => None,
 
         BlackBoxFunc::Keccakf1600 => Some(25),
         // The permutation takes a fixed number of inputs, but the inputs length depends on the proving system implementation.
@@ -662,9 +702,7 @@ fn black_box_func_expected_input_size(name: BlackBoxFunc) -> Option<usize> {
 
         // Signature verification algorithms will take in a variable
         // number of inputs, since the message/hashed-message can vary in size.
-        BlackBoxFunc::SchnorrVerify
-        | BlackBoxFunc::EcdsaSecp256k1
-        | BlackBoxFunc::EcdsaSecp256r1 => None,
+        BlackBoxFunc::EcdsaSecp256k1 | BlackBoxFunc::EcdsaSecp256r1 => None,
 
         // Inputs for multi scalar multiplication is an arbitrary number of [point, scalar] pairs.
         BlackBoxFunc::MultiScalarMul => None,
@@ -696,7 +734,7 @@ fn black_box_expected_output_size(name: BlackBoxFunc) -> Option<usize> {
         BlackBoxFunc::AND | BlackBoxFunc::XOR => Some(1),
 
         // 32 byte hash algorithms
-        BlackBoxFunc::Keccak256 | BlackBoxFunc::Blake2s | BlackBoxFunc::Blake3 => Some(32),
+        BlackBoxFunc::Blake2s | BlackBoxFunc::Blake3 => Some(32),
 
         BlackBoxFunc::Keccakf1600 => Some(25),
         // The permutation returns a fixed number of outputs, equals to the inputs length which depends on the proving system implementation.
@@ -704,20 +742,12 @@ fn black_box_expected_output_size(name: BlackBoxFunc) -> Option<usize> {
 
         BlackBoxFunc::Sha256Compression => Some(8),
 
-        // Pedersen commitment returns a point
-        BlackBoxFunc::PedersenCommitment => Some(2),
-
-        // Pedersen hash returns a field
-        BlackBoxFunc::PedersenHash => Some(1),
-
         // Can only apply a range constraint to one
         // witness at a time.
         BlackBoxFunc::RANGE => Some(0),
 
         // Signature verification algorithms will return a boolean
-        BlackBoxFunc::SchnorrVerify
-        | BlackBoxFunc::EcdsaSecp256k1
-        | BlackBoxFunc::EcdsaSecp256r1 => Some(1),
+        BlackBoxFunc::EcdsaSecp256k1 | BlackBoxFunc::EcdsaSecp256r1 => Some(1),
 
         // Output of operations over the embedded curve
         // will be 2 field elements representing the point.
diff --git a/compiler/noirc_evaluator/src/ssa/acir_gen/mod.rs b/compiler/noirc_evaluator/src/acir/mod.rs
similarity index 95%
rename from compiler/noirc_evaluator/src/ssa/acir_gen/mod.rs
rename to compiler/noirc_evaluator/src/acir/mod.rs
index 15d72c2ae74..769d0d80cc4 100644
--- a/compiler/noirc_evaluator/src/ssa/acir_gen/mod.rs
+++ b/compiler/noirc_evaluator/src/acir/mod.rs
@@ -1,45 +1,57 @@
 //! This file holds the pass to convert from Noir's SSA IR to ACIR.
-mod acir_ir;
 
+use fxhash::FxHashMap as HashMap;
+use im::Vector;
 use std::collections::{BTreeMap, HashSet};
 use std::fmt::Debug;
 
-use self::acir_ir::acir_variable::{AcirContext, AcirType, AcirVar};
-use self::acir_ir::generated_acir::BrilligStdlibFunc;
-use super::function_builder::data_bus::DataBus;
-use super::ir::dfg::CallStack;
-use super::ir::function::FunctionId;
-use super::ir::instruction::{ConstrainError, ErrorType};
-use super::ir::printer::try_to_extract_string_from_error_payload;
-use super::{
+use acvm::acir::{
+    circuit::{
+        brillig::{BrilligBytecode, BrilligFunctionId},
+        opcodes::{AcirFunctionId, BlockType},
+        AssertionPayload, ErrorSelector, ExpressionWidth, OpcodeLocation,
+    },
+    native_types::Witness,
+    BlackBoxFunc,
+};
+use acvm::{acir::circuit::opcodes::BlockId, acir::AcirField, FieldElement};
+use bn254_blackbox_solver::Bn254BlackBoxSolver;
+use iter_extended::{try_vecmap, vecmap};
+use noirc_frontend::monomorphization::ast::InlineType;
+
+mod acir_variable;
+mod big_int;
+mod brillig_directive;
+mod generated_acir;
+
+use crate::brillig::brillig_gen::gen_brillig_for;
+use crate::brillig::{
+    brillig_gen::brillig_fn::FunctionContext as BrilligFunctionContext,
+    brillig_ir::artifact::{BrilligParameter, GeneratedBrillig},
+    Brillig,
+};
+use crate::errors::{InternalError, InternalWarning, RuntimeError, SsaReport};
+use crate::ssa::ir::instruction::Hint;
+use crate::ssa::{
+    function_builder::data_bus::DataBus,
     ir::{
-        dfg::DataFlowGraph,
-        function::{Function, RuntimeType},
+        dfg::{CallStack, DataFlowGraph},
+        function::{Function, FunctionId, RuntimeType},
         instruction::{
-            Binary, BinaryOp, Instruction, InstructionId, Intrinsic, TerminatorInstruction,
+            Binary, BinaryOp, ConstrainError, Instruction, InstructionId, Intrinsic,
+            TerminatorInstruction,
         },
         map::Id,
+        printer::try_to_extract_string_from_error_payload,
         types::{NumericType, Type},
         value::{Value, ValueId},
     },
     ssa_gen::Ssa,
 };
-use crate::brillig::brillig_ir::artifact::{BrilligParameter, GeneratedBrillig};
-use crate::brillig::brillig_ir::BrilligContext;
-use crate::brillig::{brillig_gen::brillig_fn::FunctionContext as BrilligFunctionContext, Brillig};
-use crate::errors::{InternalError, InternalWarning, RuntimeError, SsaReport};
-pub(crate) use acir_ir::generated_acir::GeneratedAcir;
-use acvm::acir::circuit::opcodes::{AcirFunctionId, BlockType};
-use noirc_frontend::monomorphization::ast::InlineType;
-
-use acvm::acir::circuit::brillig::{BrilligBytecode, BrilligFunctionId};
-use acvm::acir::circuit::{AssertionPayload, ErrorSelector, ExpressionWidth, OpcodeLocation};
-use acvm::acir::native_types::Witness;
-use acvm::acir::BlackBoxFunc;
-use acvm::{acir::circuit::opcodes::BlockId, acir::AcirField, FieldElement};
-use fxhash::FxHashMap as HashMap;
-use im::Vector;
-use iter_extended::{try_vecmap, vecmap};
+use acir_variable::{AcirContext, AcirType, AcirVar};
+use generated_acir::BrilligStdlibFunc;
+pub(crate) use generated_acir::GeneratedAcir;
+use noirc_frontend::hir_def::types::Type as HirType;
 
 #[derive(Default)]
 struct SharedContext<F> {
@@ -156,7 +168,7 @@ struct Context<'a> {
     current_side_effects_enabled_var: AcirVar,
 
     /// Manages and builds the `AcirVar`s to which the converted SSA values refer.
-    acir_context: AcirContext<FieldElement>,
+    acir_context: AcirContext<FieldElement, Bn254BlackBoxSolver>,
 
     /// Track initialized acir dynamic arrays
     ///
@@ -283,7 +295,7 @@ pub(crate) type Artifacts = (
     Vec<GeneratedAcir<FieldElement>>,
     Vec<BrilligBytecode<FieldElement>>,
     Vec<String>,
-    BTreeMap<ErrorSelector, ErrorType>,
+    BTreeMap<ErrorSelector, HirType>,
 );
 
 impl Ssa {
@@ -296,6 +308,7 @@ impl Ssa {
         let mut acirs = Vec::new();
         // TODO: can we parallelize this?
         let mut shared_context = SharedContext::default();
+
         for function in self.functions.values() {
             let context = Context::new(&mut shared_context, expression_width);
             if let Some(mut generated_acir) =
@@ -377,7 +390,7 @@ impl<'a> Context<'a> {
         match function.runtime() {
             RuntimeType::Acir(inline_type) => {
                 match inline_type {
-                    InlineType::Inline => {
+                    InlineType::Inline | InlineType::InlineAlways => {
                         if function.id() != ssa.main_id {
                             panic!("ACIR function should have been inlined earlier if not marked otherwise");
                         }
@@ -390,7 +403,7 @@ impl<'a> Context<'a> {
                 // We only want to convert entry point functions. This being `main` and those marked with `InlineType::Fold`
                 Ok(Some(self.convert_acir_main(function, ssa, brillig)?))
             }
-            RuntimeType::Brillig => {
+            RuntimeType::Brillig(_) => {
                 if function.id() == ssa.main_id {
                     Ok(Some(self.convert_brillig_main(function, brillig)?))
                 } else {
@@ -504,7 +517,7 @@ impl<'a> Context<'a> {
         let outputs: Vec<AcirType> =
             vecmap(main_func.returns(), |result_id| dfg.type_of_value(*result_id).into());
 
-        let code = self.gen_brillig_for(main_func, arguments.clone(), brillig)?;
+        let code = gen_brillig_for(main_func, arguments.clone(), brillig)?;
 
         // We specifically do not attempt execution of the brillig code being generated as this can result in it being
         // replaced with constraints on witnesses to the program outputs.
@@ -559,7 +572,7 @@ impl<'a> Context<'a> {
                 AcirValue::Array(_) => {
                     let block_id = self.block_id(param_id);
                     let len = if matches!(typ, Type::Array(_, _)) {
-                        typ.flattened_size()
+                        typ.flattened_size() as usize
                     } else {
                         return Err(InternalError::Unexpected {
                             expected: "Block params should be an array".to_owned(),
@@ -675,16 +688,19 @@ impl<'a> Context<'a> {
 
                 let assert_payload = if let Some(error) = assert_message {
                     match error {
-                        ConstrainError::StaticString(string) => {
-                            Some(AssertionPayload::StaticString(string.clone()))
-                        }
-                        ConstrainError::Dynamic(error_selector, values) => {
+                        ConstrainError::StaticString(string) => Some(
+                            self.acir_context.generate_assertion_message_payload(string.clone()),
+                        ),
+                        ConstrainError::Dynamic(error_selector, is_string_type, values) => {
                             if let Some(constant_string) = try_to_extract_string_from_error_payload(
-                                *error_selector,
+                                *is_string_type,
                                 values,
                                 dfg,
                             ) {
-                                Some(AssertionPayload::StaticString(constant_string))
+                                Some(
+                                    self.acir_context
+                                        .generate_assertion_message_payload(constant_string),
+                                )
                             } else {
                                 let acir_vars: Vec<_> = values
                                     .iter()
@@ -694,10 +710,10 @@ impl<'a> Context<'a> {
                                 let expressions_or_memory =
                                     self.acir_context.vars_to_expressions_or_memory(&acir_vars)?;
 
-                                Some(AssertionPayload::Dynamic(
-                                    error_selector.as_u64(),
-                                    expressions_or_memory,
-                                ))
+                                Some(AssertionPayload {
+                                    error_selector: error_selector.as_u64(),
+                                    payload: expressions_or_memory,
+                                })
                             }
                         }
                     }
@@ -766,6 +782,12 @@ impl<'a> Context<'a> {
             Instruction::IfElse { .. } => {
                 unreachable!("IfElse instruction remaining in acir-gen")
             }
+            Instruction::MakeArray { elements, typ: _ } => {
+                let elements = elements.iter().map(|element| self.convert_value(*element, dfg));
+                let value = AcirValue::Array(elements.collect());
+                let result = dfg.instruction_results(instruction_id)[0];
+                self.ssa_values.insert(result, value);
+            }
         }
 
         self.acir_context.set_call_stack(CallStack::new());
@@ -795,17 +817,17 @@ impl<'a> Context<'a> {
                                 let inputs = vecmap(arguments, |arg| self.convert_value(*arg, dfg));
                                 let output_count = result_ids
                                     .iter()
-                                    .map(|result_id| dfg.type_of_value(*result_id).flattened_size())
+                                    .map(|result_id| {
+                                        dfg.type_of_value(*result_id).flattened_size() as usize
+                                    })
                                     .sum();
 
-                                let Some(acir_function_id) =
-                                    ssa.entry_point_to_generated_index.get(id)
-                                else {
+                                let Some(acir_function_id) = ssa.get_entry_point_index(id) else {
                                     unreachable!("Expected an associated final index for call to acir function {id} with args {arguments:?}");
                                 };
 
                                 let output_vars = self.acir_context.call_acir_function(
-                                    AcirFunctionId(*acir_function_id),
+                                    AcirFunctionId(acir_function_id),
                                     inputs,
                                     output_count,
                                     self.current_side_effects_enabled_var,
@@ -816,7 +838,7 @@ impl<'a> Context<'a> {
 
                                 self.handle_ssa_call_outputs(result_ids, output_values, dfg)?;
                             }
-                            RuntimeType::Brillig => {
+                            RuntimeType::Brillig(_) => {
                                 // Check that we are not attempting to return a slice from
                                 // an unconstrained runtime to a constrained runtime
                                 for result_id in result_ids {
@@ -855,8 +877,7 @@ impl<'a> Context<'a> {
                                         None,
                                     )?
                                 } else {
-                                    let code =
-                                        self.gen_brillig_for(func, arguments.clone(), brillig)?;
+                                    let code = gen_brillig_for(func, arguments.clone(), brillig)?;
                                     let generated_pointer =
                                         self.shared_context.new_generated_pointer();
                                     let output_values = self.acir_context.brillig_call(
@@ -928,7 +949,7 @@ impl<'a> Context<'a> {
                 let block_id = self.block_id(&array_id);
                 let array_typ = dfg.type_of_value(array_id);
                 let len = if matches!(array_typ, Type::Array(_, _)) {
-                    array_typ.flattened_size()
+                    array_typ.flattened_size() as usize
                 } else {
                     Self::flattened_value_size(&output)
                 };
@@ -976,38 +997,6 @@ impl<'a> Context<'a> {
             .collect()
     }
 
-    fn gen_brillig_for(
-        &self,
-        func: &Function,
-        arguments: Vec<BrilligParameter>,
-        brillig: &Brillig,
-    ) -> Result<GeneratedBrillig<FieldElement>, InternalError> {
-        // Create the entry point artifact
-        let mut entry_point = BrilligContext::new_entry_point_artifact(
-            arguments,
-            BrilligFunctionContext::return_values(func),
-            func.id(),
-        );
-        entry_point.name = func.name().to_string();
-
-        // Link the entry point with all dependencies
-        while let Some(unresolved_fn_label) = entry_point.first_unresolved_function_call() {
-            let artifact = &brillig.find_by_label(unresolved_fn_label);
-            let artifact = match artifact {
-                Some(artifact) => artifact,
-                None => {
-                    return Err(InternalError::General {
-                        message: format!("Cannot find linked fn {unresolved_fn_label}"),
-                        call_stack: CallStack::new(),
-                    })
-                }
-            };
-            entry_point.link_with(artifact);
-        }
-        // Generate the final bytecode
-        Ok(entry_point.finish())
-    }
-
     /// Handles an ArrayGet or ArraySet instruction.
     /// To set an index of the array (and create a new array in doing so), pass Some(value) for
     /// store_value. To just retrieve an index of the array, pass None for store_value.
@@ -1303,6 +1292,29 @@ impl<'a> Context<'a> {
         }
     }
 
+    /// Returns the acir value at the provided databus offset
+    fn get_from_call_data(
+        &mut self,
+        offset: &mut AcirVar,
+        call_data_block: BlockId,
+        typ: &Type,
+    ) -> Result<AcirValue, RuntimeError> {
+        match typ {
+            Type::Numeric(_) => self.array_get_value(&Type::field(), call_data_block, offset),
+            Type::Array(arc, len) => {
+                let mut result = Vector::new();
+                for _i in 0..*len {
+                    for sub_type in arc.iter() {
+                        let element = self.get_from_call_data(offset, call_data_block, sub_type)?;
+                        result.push_back(element);
+                    }
+                }
+                Ok(AcirValue::Array(result))
+            }
+            _ => unimplemented!("Unsupported type in databus"),
+        }
+    }
+
     /// Generates a read opcode for the array
     /// `index_side_effect == false` means that we ensured `var_index` will have a type matching the value in the array
     fn array_get(
@@ -1316,27 +1328,19 @@ impl<'a> Context<'a> {
         let block_id = self.ensure_array_is_initialized(array, dfg)?;
         let results = dfg.instruction_results(instruction);
         let res_typ = dfg.type_of_value(results[0]);
-
         // Get operations to call-data parameters are replaced by a get to the call-data-bus array
-        if let Some(call_data) =
-            self.data_bus.call_data.iter().find(|cd| cd.index_map.contains_key(&array))
-        {
-            let type_size = res_typ.flattened_size();
-            let type_size = self.acir_context.add_constant(FieldElement::from(type_size as i128));
-            let offset = self.acir_context.mul_var(var_index, type_size)?;
+        let call_data =
+            self.data_bus.call_data.iter().find(|cd| cd.index_map.contains_key(&array)).cloned();
+        if let Some(call_data) = call_data {
+            let call_data_block = self.ensure_array_is_initialized(call_data.array_id, dfg)?;
             let bus_index = self
                 .acir_context
                 .add_constant(FieldElement::from(call_data.index_map[&array] as i128));
-            let new_index = self.acir_context.add_var(offset, bus_index)?;
-            return self.array_get(
-                instruction,
-                call_data.array_id,
-                new_index,
-                dfg,
-                index_side_effect,
-            );
+            let mut current_index = self.acir_context.add_var(bus_index, var_index)?;
+            let result = self.get_from_call_data(&mut current_index, call_data_block, &res_typ)?;
+            self.define_result(dfg, instruction, result.clone());
+            return Ok(result);
         }
-
         // Compiler sanity check
         assert!(
             !res_typ.contains_slice_element(),
@@ -1441,7 +1445,7 @@ impl<'a> Context<'a> {
         // a separate SSA value and restrictions on slice indices should be generated elsewhere in the SSA.
         let array_typ = dfg.type_of_value(array);
         let array_len = if !array_typ.contains_slice_element() {
-            array_typ.flattened_size()
+            array_typ.flattened_size() as usize
         } else {
             self.flattened_slice_size(array, dfg)
         };
@@ -1532,11 +1536,11 @@ impl<'a> Context<'a> {
         if !already_initialized {
             let value = &dfg[array];
             match value {
-                Value::Array { .. } | Value::Instruction { .. } => {
+                Value::Instruction { .. } => {
                     let value = self.convert_value(array, dfg);
                     let array_typ = dfg.type_of_value(array);
                     let len = if !array_typ.contains_slice_element() {
-                        array_typ.flattened_size()
+                        array_typ.flattened_size() as usize
                     } else {
                         self.flattened_slice_size(array, dfg)
                     };
@@ -1575,13 +1579,6 @@ impl<'a> Context<'a> {
         match array_typ {
             Type::Array(_, _) | Type::Slice(_) => {
                 match &dfg[array_id] {
-                    Value::Array { array, .. } => {
-                        for (i, value) in array.iter().enumerate() {
-                            flat_elem_type_sizes.push(
-                                self.flattened_slice_size(*value, dfg) + flat_elem_type_sizes[i],
-                            );
-                        }
-                    }
                     Value::Instruction { .. } | Value::Param { .. } => {
                         // An instruction representing the slice means it has been processed previously during ACIR gen.
                         // Use the previously defined result of an array operation to fetch the internal type information.
@@ -1714,13 +1711,6 @@ impl<'a> Context<'a> {
     fn flattened_slice_size(&mut self, array_id: ValueId, dfg: &DataFlowGraph) -> usize {
         let mut size = 0;
         match &dfg[array_id] {
-            Value::Array { array, .. } => {
-                // The array is going to be the flattened outer array
-                // Flattened slice size from SSA value does not need to be multiplied by the len
-                for value in array {
-                    size += self.flattened_slice_size(*value, dfg);
-                }
-            }
             Value::NumericConstant { .. } => {
                 size += 1;
             }
@@ -1821,7 +1811,7 @@ impl<'a> Context<'a> {
 
         return_values
             .iter()
-            .fold(0, |acc, value_id| acc + dfg.type_of_value(*value_id).flattened_size())
+            .fold(0, |acc, value_id| acc + dfg.type_of_value(*value_id).flattened_size() as usize)
     }
 
     /// Converts an SSA terminator's return values into their ACIR representations
@@ -1882,18 +1872,15 @@ impl<'a> Context<'a> {
 
         let acir_value = match value {
             Value::NumericConstant { constant, typ } => {
-                AcirValue::Var(self.acir_context.add_constant(*constant), typ.into())
-            }
-            Value::Array { array, .. } => {
-                let elements = array.iter().map(|element| self.convert_value(*element, dfg));
-                AcirValue::Array(elements.collect())
+                let typ = AcirType::from(Type::Numeric(*typ));
+                AcirValue::Var(self.acir_context.add_constant(*constant), typ)
             }
             Value::Intrinsic(..) => todo!(),
             Value::Function(function_id) => {
                 // This conversion is for debugging support only, to allow the
                 // debugging instrumentation code to work. Taking the reference
                 // of a function in ACIR is useless.
-                let id = self.acir_context.add_constant(function_id.to_usize());
+                let id = self.acir_context.add_constant(function_id.to_u32());
                 AcirValue::Var(id, AcirType::field())
             }
             Value::ForeignFunction(_) => unimplemented!(
@@ -1983,6 +1970,7 @@ impl<'a> Context<'a> {
             BinaryOp::Mod => self.acir_context.modulo_var(
                 lhs,
                 rhs,
+                binary_type.clone(),
                 bit_count,
                 self.current_side_effects_enabled_var,
             ),
@@ -2145,6 +2133,15 @@ impl<'a> Context<'a> {
         result_ids: &[ValueId],
     ) -> Result<Vec<AcirValue>, RuntimeError> {
         match intrinsic {
+            Intrinsic::Hint(Hint::BlackBox) => {
+                // Identity function; at the ACIR level this is a no-op, it only affects the SSA.
+                assert_eq!(
+                    arguments.len(),
+                    result_ids.len(),
+                    "ICE: BlackBox input and output lengths should match."
+                );
+                Ok(arguments.iter().map(|v| self.convert_value(*v, dfg)).collect())
+            }
             Intrinsic::BlackBox(black_box) => {
                 // Slices are represented as a tuple of (length, slice contents).
                 // We must check the inputs to determine if there are slices
@@ -2170,7 +2167,7 @@ impl<'a> Context<'a> {
                 let inputs = vecmap(&arguments_no_slice_len, |arg| self.convert_value(*arg, dfg));
 
                 let output_count = result_ids.iter().fold(0usize, |sum, result_id| {
-                    sum + dfg.try_get_array_length(*result_id).unwrap_or(1)
+                    sum + dfg.try_get_array_length(*result_id).unwrap_or(1) as usize
                 });
 
                 let vars = self.acir_context.black_box_function(black_box, inputs, output_count)?;
@@ -2194,7 +2191,7 @@ impl<'a> Context<'a> {
                         endian,
                         field,
                         radix,
-                        array_length as u32,
+                        array_length,
                         result_type[0].clone().into(),
                     )
                     .map(|array| vec![array])
@@ -2208,12 +2205,7 @@ impl<'a> Context<'a> {
                 };
 
                 self.acir_context
-                    .bit_decompose(
-                        endian,
-                        field,
-                        array_length as u32,
-                        result_type[0].clone().into(),
-                    )
+                    .bit_decompose(endian, field, array_length, result_type[0].clone().into())
                     .map(|array| vec![array])
             }
             Intrinsic::ArrayLen => {
@@ -2234,7 +2226,7 @@ impl<'a> Context<'a> {
                 let acir_value = self.convert_value(slice_contents, dfg);
 
                 let array_len = if !slice_typ.contains_slice_element() {
-                    slice_typ.flattened_size()
+                    slice_typ.flattened_size() as usize
                 } else {
                     self.flattened_slice_size(slice_contents, dfg)
                 };
@@ -2774,6 +2766,16 @@ impl<'a> Context<'a> {
             Intrinsic::DerivePedersenGenerators => {
                 unreachable!("DerivePedersenGenerators can only be called with constants")
             }
+            Intrinsic::FieldLessThan => {
+                unreachable!("FieldLessThan can only be called in unconstrained")
+            }
+            Intrinsic::ArrayRefCount | Intrinsic::SliceRefCount => {
+                let zero = self.acir_context.add_constant(FieldElement::zero());
+                Ok(vec![AcirValue::Var(
+                    zero,
+                    AcirType::NumericType(NumericType::Unsigned { bit_size: 32 }),
+                )])
+            }
         }
     }
 
@@ -2807,22 +2809,6 @@ impl<'a> Context<'a> {
         Ok(())
     }
 
-    /// Given an array value, return the numerical type of its element.
-    /// Panics if the given value is not an array or has a non-numeric element type.
-    fn array_element_type(dfg: &DataFlowGraph, value: ValueId) -> AcirType {
-        match dfg.type_of_value(value) {
-            Type::Array(elements, _) => {
-                assert_eq!(elements.len(), 1);
-                (&elements[0]).into()
-            }
-            Type::Slice(elements) => {
-                assert_eq!(elements.len(), 1);
-                (&elements[0]).into()
-            }
-            _ => unreachable!("Expected array type"),
-        }
-    }
-
     /// Convert a Vec<AcirVar> into a Vec<AcirValue> using the given result ids.
     /// If the type of a result id is an array, several acir vars are collected into
     /// a single AcirValue::Array of the same length.
@@ -2907,25 +2893,30 @@ mod test {
         },
         FieldElement,
     };
-    use im::vector;
     use noirc_errors::Location;
     use noirc_frontend::monomorphization::ast::InlineType;
     use std::collections::BTreeMap;
 
     use crate::{
+        acir::BrilligStdlibFunc,
         brillig::Brillig,
         ssa::{
-            acir_gen::acir_ir::generated_acir::BrilligStdlibFunc,
             function_builder::FunctionBuilder,
-            ir::{function::FunctionId, instruction::BinaryOp, map::Id, types::Type},
+            ir::{
+                dfg::CallStack,
+                function::FunctionId,
+                instruction::BinaryOp,
+                map::Id,
+                types::{NumericType, Type},
+            },
         },
     };
 
     fn build_basic_foo_with_return(
         builder: &mut FunctionBuilder,
         foo_id: FunctionId,
-        // `InlineType` can only exist on ACIR functions, so if the option is `None` we should generate a Brillig function
-        inline_type: Option<InlineType>,
+        brillig: bool,
+        inline_type: InlineType,
     ) {
         // fn foo f1 {
         // b0(v0: Field, v1: Field):
@@ -2933,19 +2924,21 @@ mod test {
         //     constrain v2 == u1 0
         //     return v0
         // }
-        if let Some(inline_type) = inline_type {
-            builder.new_function("foo".into(), foo_id, inline_type);
+        if brillig {
+            builder.new_brillig_function("foo".into(), foo_id, inline_type);
         } else {
-            builder.new_brillig_function("foo".into(), foo_id);
+            builder.new_function("foo".into(), foo_id, inline_type);
         }
         // Set a call stack for testing whether `brillig_locations` in the `GeneratedAcir` was accurately set.
-        builder.set_call_stack(vector![Location::dummy(), Location::dummy()]);
+        let mut stack = CallStack::unit(Location::dummy());
+        stack.push_back(Location::dummy());
+        builder.set_call_stack(stack);
 
         let foo_v0 = builder.add_parameter(Type::field());
         let foo_v1 = builder.add_parameter(Type::field());
 
         let foo_equality_check = builder.insert_binary(foo_v0, BinaryOp::Eq, foo_v1);
-        let zero = builder.numeric_constant(0u128, Type::unsigned(1));
+        let zero = builder.numeric_constant(0u128, NumericType::unsigned(1));
         builder.insert_constrain(foo_equality_check, zero, None);
         builder.terminate_with_return(vec![foo_v0]);
     }
@@ -3000,9 +2993,9 @@ mod test {
         builder.insert_constrain(main_call1_results[0], main_call2_results[0], None);
         builder.terminate_with_return(vec![]);
 
-        build_basic_foo_with_return(&mut builder, foo_id, Some(inline_type));
+        build_basic_foo_with_return(&mut builder, foo_id, false, inline_type);
 
-        let ssa = builder.finish();
+        let ssa = builder.finish().generate_entry_point_index();
 
         let (acir_functions, _, _, _) = ssa
             .into_acir(&Brillig::default(), ExpressionWidth::default())
@@ -3105,11 +3098,12 @@ mod test {
         builder.insert_constrain(main_call1_results[0], main_call2_results[0], None);
         builder.terminate_with_return(vec![]);
 
-        build_basic_foo_with_return(&mut builder, foo_id, Some(inline_type));
+        build_basic_foo_with_return(&mut builder, foo_id, false, inline_type);
 
         let ssa = builder.finish();
 
         let (acir_functions, _, _, _) = ssa
+            .generate_entry_point_index()
             .into_acir(&Brillig::default(), ExpressionWidth::default())
             .expect("Should compile manually written SSA into ACIR");
         // The expected result should look very similar to the above test expect that the input witnesses of the `Call`
@@ -3205,9 +3199,9 @@ mod test {
             .to_vec();
         builder.terminate_with_return(vec![foo_call[0]]);
 
-        build_basic_foo_with_return(&mut builder, foo_id, Some(inline_type));
+        build_basic_foo_with_return(&mut builder, foo_id, false, inline_type);
 
-        let ssa = builder.finish();
+        let ssa = builder.finish().generate_entry_point_index();
 
         let (acir_functions, _, _, _) = ssa
             .into_acir(&Brillig::default(), ExpressionWidth::default())
@@ -3327,13 +3321,14 @@ mod test {
         builder.insert_call(bar, vec![main_v0, main_v1], vec![Type::field()]).to_vec();
         builder.terminate_with_return(vec![]);
 
-        build_basic_foo_with_return(&mut builder, foo_id, None);
-        build_basic_foo_with_return(&mut builder, bar_id, None);
+        build_basic_foo_with_return(&mut builder, foo_id, true, InlineType::default());
+        build_basic_foo_with_return(&mut builder, bar_id, true, InlineType::default());
 
         let ssa = builder.finish();
         let brillig = ssa.to_brillig(false);
 
         let (acir_functions, brillig_functions, _, _) = ssa
+            .generate_entry_point_index()
             .into_acir(&brillig, ExpressionWidth::default())
             .expect("Should compile manually written SSA into ACIR");
 
@@ -3387,7 +3382,7 @@ mod test {
 
         // Call the same primitive operation again
         let v1_div_v2 = builder.insert_binary(main_v1, BinaryOp::Div, main_v2);
-        let one = builder.numeric_constant(1u128, Type::unsigned(32));
+        let one = builder.numeric_constant(1u128, NumericType::unsigned(32));
         builder.insert_constrain(v1_div_v2, one, None);
 
         builder.terminate_with_return(vec![]);
@@ -3398,6 +3393,7 @@ mod test {
         // The Brillig bytecode we insert for the stdlib is hardcoded so we do not need to provide any
         // Brillig artifacts to the ACIR gen pass.
         let (acir_functions, brillig_functions, _, _) = ssa
+            .generate_entry_point_index()
             .into_acir(&Brillig::default(), ExpressionWidth::default())
             .expect("Should compile manually written SSA into ACIR");
 
@@ -3459,12 +3455,12 @@ mod test {
 
         // Call the same primitive operation again
         let v1_div_v2 = builder.insert_binary(main_v1, BinaryOp::Div, main_v2);
-        let one = builder.numeric_constant(1u128, Type::unsigned(32));
+        let one = builder.numeric_constant(1u128, NumericType::unsigned(32));
         builder.insert_constrain(v1_div_v2, one, None);
 
         builder.terminate_with_return(vec![]);
 
-        build_basic_foo_with_return(&mut builder, foo_id, None);
+        build_basic_foo_with_return(&mut builder, foo_id, true, InlineType::default());
 
         let ssa = builder.finish();
         // We need to generate  Brillig artifacts for the regular Brillig function and pass them to the ACIR generation pass.
@@ -3472,6 +3468,7 @@ mod test {
         println!("{}", ssa);
 
         let (acir_functions, brillig_functions, _, _) = ssa
+            .generate_entry_point_index()
             .into_acir(&brillig, ExpressionWidth::default())
             .expect("Should compile manually written SSA into ACIR");
 
@@ -3544,15 +3541,15 @@ mod test {
 
         // Call the same primitive operation again
         let v1_div_v2 = builder.insert_binary(main_v1, BinaryOp::Div, main_v2);
-        let one = builder.numeric_constant(1u128, Type::unsigned(32));
+        let one = builder.numeric_constant(1u128, NumericType::unsigned(32));
         builder.insert_constrain(v1_div_v2, one, None);
 
         builder.terminate_with_return(vec![]);
 
         // Build a Brillig function
-        build_basic_foo_with_return(&mut builder, foo_id, None);
+        build_basic_foo_with_return(&mut builder, foo_id, true, InlineType::default());
         // Build an ACIR function which has the same logic as the Brillig function above
-        build_basic_foo_with_return(&mut builder, bar_id, Some(InlineType::Fold));
+        build_basic_foo_with_return(&mut builder, bar_id, false, InlineType::Fold);
 
         let ssa = builder.finish();
         // We need to generate  Brillig artifacts for the regular Brillig function and pass them to the ACIR generation pass.
@@ -3560,6 +3557,7 @@ mod test {
         println!("{}", ssa);
 
         let (acir_functions, brillig_functions, _, _) = ssa
+            .generate_entry_point_index()
             .into_acir(&brillig, ExpressionWidth::default())
             .expect("Should compile manually written SSA into ACIR");
 
diff --git a/compiler/noirc_evaluator/src/brillig/brillig_gen.rs b/compiler/noirc_evaluator/src/brillig/brillig_gen.rs
index 628ec9657f2..ca4e783aa93 100644
--- a/compiler/noirc_evaluator/src/brillig/brillig_gen.rs
+++ b/compiler/noirc_evaluator/src/brillig/brillig_gen.rs
@@ -1,7 +1,6 @@
 pub(crate) mod brillig_black_box;
 pub(crate) mod brillig_block;
 pub(crate) mod brillig_block_variables;
-pub(crate) mod brillig_directive;
 pub(crate) mod brillig_fn;
 pub(crate) mod brillig_slice_ops;
 mod constant_allocation;
@@ -10,11 +9,17 @@ mod variable_liveness;
 use acvm::FieldElement;
 
 use self::{brillig_block::BrilligBlock, brillig_fn::FunctionContext};
-use super::brillig_ir::{
-    artifact::{BrilligArtifact, Label},
-    BrilligContext,
+use super::{
+    brillig_ir::{
+        artifact::{BrilligArtifact, BrilligParameter, GeneratedBrillig, Label},
+        BrilligContext,
+    },
+    Brillig,
+};
+use crate::{
+    errors::InternalError,
+    ssa::ir::{dfg::CallStack, function::Function},
 };
-use crate::ssa::ir::function::Function;
 
 /// Converting an SSA function into Brillig bytecode.
 pub(crate) fn convert_ssa_function(
@@ -27,6 +32,8 @@ pub(crate) fn convert_ssa_function(
 
     brillig_context.enter_context(Label::function(func.id()));
 
+    brillig_context.call_check_max_stack_depth_procedure();
+
     for block in function_context.blocks.clone() {
         BrilligBlock::compile(&mut function_context, &mut brillig_context, block, &func.dfg);
     }
@@ -35,3 +42,43 @@ pub(crate) fn convert_ssa_function(
     artifact.name = func.name().to_string();
     artifact
 }
+
+pub(crate) fn gen_brillig_for(
+    func: &Function,
+    arguments: Vec<BrilligParameter>,
+    brillig: &Brillig,
+) -> Result<GeneratedBrillig<FieldElement>, InternalError> {
+    // Create the entry point artifact
+    let mut entry_point = BrilligContext::new_entry_point_artifact(
+        arguments,
+        FunctionContext::return_values(func),
+        func.id(),
+    );
+    entry_point.name = func.name().to_string();
+
+    // Link the entry point with all dependencies
+    while let Some(unresolved_fn_label) = entry_point.first_unresolved_function_call() {
+        let artifact = &brillig.find_by_label(unresolved_fn_label.clone());
+        let artifact = match artifact {
+            Some(artifact) => artifact,
+            None => {
+                return Err(InternalError::General {
+                    message: format!("Cannot find linked fn {unresolved_fn_label}"),
+                    call_stack: CallStack::new(),
+                })
+            }
+        };
+        entry_point.link_with(artifact);
+        // Insert the range of opcode locations occupied by a procedure
+        if let Some(procedure_id) = &artifact.procedure {
+            let num_opcodes = entry_point.byte_code.len();
+            let previous_num_opcodes = entry_point.byte_code.len() - artifact.byte_code.len();
+            // We subtract one as to keep the range inclusive on both ends
+            entry_point
+                .procedure_locations
+                .insert(procedure_id.clone(), (previous_num_opcodes, num_opcodes - 1));
+        }
+    }
+    // Generate the final bytecode
+    Ok(entry_point.finish())
+}
diff --git a/compiler/noirc_evaluator/src/brillig/brillig_gen/brillig_black_box.rs b/compiler/noirc_evaluator/src/brillig/brillig_gen/brillig_black_box.rs
index 889af07fbef..2ddcea26570 100644
--- a/compiler/noirc_evaluator/src/brillig/brillig_gen/brillig_black_box.rs
+++ b/compiler/noirc_evaluator/src/brillig/brillig_gen/brillig_black_box.rs
@@ -7,10 +7,8 @@ use acvm::{
 };
 
 use crate::brillig::brillig_ir::{
-    brillig_variable::{BrilligVariable, SingleAddrVariable},
-    debug_show::DebugToString,
-    registers::RegisterAllocator,
-    BrilligBinaryOp, BrilligContext,
+    brillig_variable::BrilligVariable, debug_show::DebugToString, registers::RegisterAllocator,
+    BrilligContext,
 };
 
 /// Transforms SSA's black box function calls into the corresponding brillig instructions
@@ -61,47 +59,23 @@ pub(crate) fn convert_black_box_call<F: AcirField + DebugToString, Registers: Re
                 unreachable!("ICE: Blake3 expects one array argument and one array result")
             }
         }
-        BlackBoxFunc::Keccak256 => {
+        BlackBoxFunc::Keccakf1600 => {
             if let (
-                [message, BrilligVariable::SingleAddr(message_size)],
+                [BrilligVariable::BrilligArray(input_array)],
                 [BrilligVariable::BrilligArray(result_array)],
             ) = (function_arguments, function_results)
             {
-                let message_vector = convert_array_or_vector(brillig_context, *message, bb_func);
-                let output_heap_array =
-                    brillig_context.codegen_brillig_array_to_heap_array(*result_array);
-
-                // Message_size is not usize
-                brillig_context.cast_instruction(
-                    SingleAddrVariable::new_usize(message_vector.size),
-                    *message_size,
-                );
-
-                brillig_context.black_box_op_instruction(BlackBoxOp::Keccak256 {
-                    message: message_vector,
-                    output: output_heap_array,
-                });
-
-                brillig_context.deallocate_heap_vector(message_vector);
-                brillig_context.deallocate_heap_array(output_heap_array);
-            } else {
-                unreachable!("ICE: Keccak256 expects message, message size and result array")
-            }
-        }
-        BlackBoxFunc::Keccakf1600 => {
-            if let ([message], [BrilligVariable::BrilligArray(result_array)]) =
-                (function_arguments, function_results)
-            {
-                let message_vector = convert_array_or_vector(brillig_context, *message, bb_func);
+                let input_heap_array =
+                    brillig_context.codegen_brillig_array_to_heap_array(*input_array);
                 let output_heap_array =
                     brillig_context.codegen_brillig_array_to_heap_array(*result_array);
 
                 brillig_context.black_box_op_instruction(BlackBoxOp::Keccakf1600 {
-                    message: message_vector,
+                    input: input_heap_array,
                     output: output_heap_array,
                 });
 
-                brillig_context.deallocate_heap_vector(message_vector);
+                brillig_context.deallocate_heap_array(input_heap_array);
                 brillig_context.deallocate_heap_array(output_heap_array);
             } else {
                 unreachable!("ICE: Keccakf1600 expects one array argument and one array result")
@@ -170,63 +144,6 @@ pub(crate) fn convert_black_box_call<F: AcirField + DebugToString, Registers: Re
             }
         }
 
-        BlackBoxFunc::PedersenCommitment => {
-            if let (
-                [message, BrilligVariable::SingleAddr(domain_separator)],
-                [BrilligVariable::BrilligArray(result_array)],
-            ) = (function_arguments, function_results)
-            {
-                let inputs = convert_array_or_vector(brillig_context, *message, bb_func);
-                let output = brillig_context.codegen_brillig_array_to_heap_array(*result_array);
-                brillig_context.black_box_op_instruction(BlackBoxOp::PedersenCommitment {
-                    inputs,
-                    domain_separator: domain_separator.address,
-                    output,
-                });
-                brillig_context.deallocate_heap_vector(inputs);
-                brillig_context.deallocate_heap_array(output);
-            } else {
-                unreachable!("ICE: Pedersen expects one array argument, a register for the domain separator, and one array result")
-            }
-        }
-        BlackBoxFunc::PedersenHash => {
-            if let (
-                [message, BrilligVariable::SingleAddr(domain_separator)],
-                [BrilligVariable::SingleAddr(result)],
-            ) = (function_arguments, function_results)
-            {
-                let inputs = convert_array_or_vector(brillig_context, *message, bb_func);
-                brillig_context.black_box_op_instruction(BlackBoxOp::PedersenHash {
-                    inputs,
-                    domain_separator: domain_separator.address,
-                    output: result.address,
-                });
-                brillig_context.deallocate_heap_vector(inputs);
-            } else {
-                unreachable!("ICE: Pedersen hash expects one array argument, a register for the domain separator, and one register result")
-            }
-        }
-        BlackBoxFunc::SchnorrVerify => {
-            if let (
-                [BrilligVariable::SingleAddr(public_key_x), BrilligVariable::SingleAddr(public_key_y), signature, message],
-                [BrilligVariable::SingleAddr(result_register)],
-            ) = (function_arguments, function_results)
-            {
-                let message = convert_array_or_vector(brillig_context, *message, bb_func);
-                let signature = convert_array_or_vector(brillig_context, *signature, bb_func);
-                brillig_context.black_box_op_instruction(BlackBoxOp::SchnorrVerify {
-                    public_key_x: public_key_x.address,
-                    public_key_y: public_key_y.address,
-                    message,
-                    signature,
-                    result: result_register.address,
-                });
-                brillig_context.deallocate_heap_vector(message);
-                brillig_context.deallocate_heap_vector(signature);
-            } else {
-                unreachable!("ICE: Schnorr verify expects two registers for the public key, an array for signature, an array for the message hash and one result register")
-            }
-        }
         BlackBoxFunc::MultiScalarMul => {
             if let ([points, scalars], [BrilligVariable::BrilligArray(outputs)]) =
                 (function_arguments, function_results)
@@ -413,21 +330,23 @@ pub(crate) fn convert_black_box_call<F: AcirField + DebugToString, Registers: Re
             }
         }
         BlackBoxFunc::Sha256Compression => {
-            if let ([message, hash_values], [BrilligVariable::BrilligArray(result_array)]) =
-                (function_arguments, function_results)
+            if let (
+                [BrilligVariable::BrilligArray(input_array), BrilligVariable::BrilligArray(hash_values)],
+                [BrilligVariable::BrilligArray(result_array)],
+            ) = (function_arguments, function_results)
             {
-                let message_vector = convert_array_or_vector(brillig_context, *message, bb_func);
-                let hash_values = convert_array_or_vector(brillig_context, *hash_values, bb_func);
+                let input = brillig_context.codegen_brillig_array_to_heap_array(*input_array);
+                let hash_values = brillig_context.codegen_brillig_array_to_heap_array(*hash_values);
                 let output = brillig_context.codegen_brillig_array_to_heap_array(*result_array);
 
                 brillig_context.black_box_op_instruction(BlackBoxOp::Sha256Compression {
-                    input: message_vector,
+                    input,
                     hash_values,
                     output,
                 });
 
-                brillig_context.deallocate_heap_vector(message_vector);
-                brillig_context.deallocate_heap_vector(hash_values);
+                brillig_context.deallocate_heap_array(input);
+                brillig_context.deallocate_heap_array(hash_values);
                 brillig_context.deallocate_heap_array(output);
             } else {
                 unreachable!("ICE: Sha256Compression expects two array argument, one array result")
@@ -455,19 +374,8 @@ pub(crate) fn convert_black_box_call<F: AcirField + DebugToString, Registers: Re
 
                 brillig_context.mov_instruction(out_len.address, outputs_vector.size);
                 // Returns slice, so we need to allocate memory for it after the fact
-                brillig_context.codegen_usize_op_in_place(
-                    outputs_vector.size,
-                    BrilligBinaryOp::Add,
-                    2_usize,
-                );
-                brillig_context.increase_free_memory_pointer_instruction(outputs_vector.size);
-                // We also need to write the size of the vector to the memory
-                brillig_context.codegen_usize_op_in_place(
-                    outputs_vector.pointer,
-                    BrilligBinaryOp::Sub,
-                    1_usize,
-                );
-                brillig_context.store_instruction(outputs_vector.pointer, out_len.address);
+
+                brillig_context.initialize_externally_returned_vector(*outputs, outputs_vector);
 
                 brillig_context.deallocate_heap_vector(inputs);
                 brillig_context.deallocate_heap_vector(outputs_vector);
diff --git a/compiler/noirc_evaluator/src/brillig/brillig_gen/brillig_block.rs b/compiler/noirc_evaluator/src/brillig/brillig_gen/brillig_block.rs
index e764c81b023..d2bf7e5bdca 100644
--- a/compiler/noirc_evaluator/src/brillig/brillig_gen/brillig_block.rs
+++ b/compiler/noirc_evaluator/src/brillig/brillig_gen/brillig_block.rs
@@ -2,12 +2,13 @@ use crate::brillig::brillig_ir::artifact::Label;
 use crate::brillig::brillig_ir::brillig_variable::{
     type_to_heap_value_type, BrilligArray, BrilligVariable, SingleAddrVariable,
 };
+
 use crate::brillig::brillig_ir::registers::Stack;
 use crate::brillig::brillig_ir::{
     BrilligBinaryOp, BrilligContext, ReservedRegisters, BRILLIG_MEMORY_ADDRESSING_BIT_SIZE,
 };
 use crate::ssa::ir::dfg::CallStack;
-use crate::ssa::ir::instruction::ConstrainError;
+use crate::ssa::ir::instruction::{ConstrainError, Hint};
 use crate::ssa::ir::{
     basic_block::BasicBlockId,
     dfg::DataFlowGraph,
@@ -159,13 +160,9 @@ impl<'block> BrilligBlock<'block> {
                 );
             }
             TerminatorInstruction::Return { return_values, .. } => {
-                let return_registers: Vec<_> = return_values
-                    .iter()
-                    .map(|value_id| {
-                        let return_variable = self.convert_ssa_value(*value_id, dfg);
-                        return_variable.extract_register()
-                    })
-                    .collect();
+                let return_registers = vecmap(return_values, |value_id| {
+                    self.convert_ssa_value(*value_id, dfg).extract_register()
+                });
                 self.brillig_context.codegen_return(&return_registers);
             }
         }
@@ -229,16 +226,14 @@ impl<'block> BrilligBlock<'block> {
                     dfg.get_numeric_constant_with_type(*rhs),
                 ) {
                     // If the constraint is of the form `x == u1 1` then we can simply constrain `x` directly
-                    (
-                        Some((constant, Type::Numeric(NumericType::Unsigned { bit_size: 1 }))),
-                        None,
-                    ) if constant == FieldElement::one() => {
+                    (Some((constant, NumericType::Unsigned { bit_size: 1 })), None)
+                        if constant == FieldElement::one() =>
+                    {
                         (self.convert_ssa_single_addr_value(*rhs, dfg), false)
                     }
-                    (
-                        None,
-                        Some((constant, Type::Numeric(NumericType::Unsigned { bit_size: 1 }))),
-                    ) if constant == FieldElement::one() => {
+                    (None, Some((constant, NumericType::Unsigned { bit_size: 1 })))
+                        if constant == FieldElement::one() =>
+                    {
                         (self.convert_ssa_single_addr_value(*lhs, dfg), false)
                     }
 
@@ -259,7 +254,7 @@ impl<'block> BrilligBlock<'block> {
                 };
 
                 match assert_message {
-                    Some(ConstrainError::Dynamic(selector, values)) => {
+                    Some(ConstrainError::Dynamic(selector, _, values)) => {
                         let payload_values =
                             vecmap(values, |value| self.convert_ssa_value(*value, dfg));
                         let payload_as_params = vecmap(values, |value| {
@@ -270,7 +265,7 @@ impl<'block> BrilligBlock<'block> {
                             condition,
                             payload_values,
                             payload_as_params,
-                            selector.as_u64(),
+                            *selector,
                         );
                     }
                     Some(ConstrainError::StaticString(message)) => {
@@ -374,34 +369,10 @@ impl<'block> BrilligBlock<'block> {
                         match output_register {
                             // Returned vectors need to emit some bytecode to format the result as a BrilligVector
                             ValueOrArray::HeapVector(heap_vector) => {
-                                // Update the stack pointer so that we do not overwrite
-                                // dynamic memory returned from other external calls
-                                // Single values and allocation of fixed sized arrays has already been handled
-                                // inside of `allocate_external_call_result`
-                                let total_size = self.brillig_context.allocate_register();
-                                self.brillig_context.codegen_usize_op(
-                                    heap_vector.size,
-                                    total_size,
-                                    BrilligBinaryOp::Add,
-                                    2, // RC and Length
+                                self.brillig_context.initialize_externally_returned_vector(
+                                    output_variable.extract_vector(),
+                                    *heap_vector,
                                 );
-
-                                self.brillig_context
-                                    .increase_free_memory_pointer_instruction(total_size);
-                                let brillig_vector = output_variable.extract_vector();
-                                let size_pointer = self.brillig_context.allocate_register();
-
-                                self.brillig_context.codegen_usize_op(
-                                    brillig_vector.pointer,
-                                    size_pointer,
-                                    BrilligBinaryOp::Add,
-                                    1_usize, // Slices are [RC, Size, ...items]
-                                );
-                                self.brillig_context
-                                    .store_instruction(size_pointer, heap_vector.size);
-                                self.brillig_context.deallocate_register(size_pointer);
-                                self.brillig_context.deallocate_register(total_size);
-
                                 // Update the dynamic slice length maintained in SSA
                                 if let ValueOrArray::MemoryAddress(len_index) = output_values[i - 1]
                                 {
@@ -429,183 +400,255 @@ impl<'block> BrilligBlock<'block> {
                     let result_ids = dfg.instruction_results(instruction_id);
                     self.convert_ssa_function_call(*func_id, arguments, dfg, result_ids);
                 }
-                Value::Intrinsic(Intrinsic::BlackBox(bb_func)) => {
-                    // Slices are represented as a tuple of (length, slice contents).
-                    // We must check the inputs to determine if there are slices
-                    // and make sure that we pass the correct inputs to the black box function call.
-                    // The loop below only keeps the slice contents, so that
-                    // setting up a black box function with slice inputs matches the expected
-                    // number of arguments specified in the function signature.
-                    let mut arguments_no_slice_len = Vec::new();
-                    for (i, arg) in arguments.iter().enumerate() {
-                        if matches!(dfg.type_of_value(*arg), Type::Numeric(_)) {
-                            if i < arguments.len() - 1 {
-                                if !matches!(dfg.type_of_value(arguments[i + 1]), Type::Slice(_)) {
-                                    arguments_no_slice_len.push(*arg);
-                                }
+                Value::Intrinsic(intrinsic) => {
+                    // This match could be combined with the above but without it rust analyzer
+                    // can't automatically insert any missing cases
+                    match intrinsic {
+                        Intrinsic::ArrayLen => {
+                            let result_variable = self.variables.define_single_addr_variable(
+                                self.function_context,
+                                self.brillig_context,
+                                dfg.instruction_results(instruction_id)[0],
+                                dfg,
+                            );
+                            let param_id = arguments[0];
+                            // Slices are represented as a tuple in the form: (length, slice contents).
+                            // Thus, we can expect the first argument to a field in the case of a slice
+                            // or an array in the case of an array.
+                            if let Type::Numeric(_) = dfg.type_of_value(param_id) {
+                                let len_variable = self.convert_ssa_value(arguments[0], dfg);
+                                let length = len_variable.extract_single_addr();
+                                self.brillig_context
+                                    .mov_instruction(result_variable.address, length.address);
                             } else {
-                                arguments_no_slice_len.push(*arg);
+                                self.convert_ssa_array_len(
+                                    arguments[0],
+                                    result_variable.address,
+                                    dfg,
+                                );
                             }
-                        } else {
-                            arguments_no_slice_len.push(*arg);
                         }
-                    }
-
-                    let function_arguments =
-                        vecmap(&arguments_no_slice_len, |arg| self.convert_ssa_value(*arg, dfg));
-                    let function_results = dfg.instruction_results(instruction_id);
-                    let function_results = vecmap(function_results, |result| {
-                        self.allocate_external_call_result(*result, dfg)
-                    });
-                    convert_black_box_call(
-                        self.brillig_context,
-                        bb_func,
-                        &function_arguments,
-                        &function_results,
-                    );
-                }
-                Value::Intrinsic(Intrinsic::ArrayLen) => {
-                    let result_variable = self.variables.define_single_addr_variable(
-                        self.function_context,
-                        self.brillig_context,
-                        dfg.instruction_results(instruction_id)[0],
-                        dfg,
-                    );
-                    let param_id = arguments[0];
-                    // Slices are represented as a tuple in the form: (length, slice contents).
-                    // Thus, we can expect the first argument to a field in the case of a slice
-                    // or an array in the case of an array.
-                    if let Type::Numeric(_) = dfg.type_of_value(param_id) {
-                        let len_variable = self.convert_ssa_value(arguments[0], dfg);
-                        let length = len_variable.extract_single_addr();
-                        self.brillig_context
-                            .mov_instruction(result_variable.address, length.address);
-                    } else {
-                        self.convert_ssa_array_len(arguments[0], result_variable.address, dfg);
-                    }
-                }
-                Value::Intrinsic(Intrinsic::AsSlice) => {
-                    let source_variable = self.convert_ssa_value(arguments[0], dfg);
-                    let result_ids = dfg.instruction_results(instruction_id);
-                    let destination_len_variable = self.variables.define_single_addr_variable(
-                        self.function_context,
-                        self.brillig_context,
-                        result_ids[0],
-                        dfg,
-                    );
-                    let destination_variable = self.variables.define_variable(
-                        self.function_context,
-                        self.brillig_context,
-                        result_ids[1],
-                        dfg,
-                    );
-                    let destination_vector = destination_variable.extract_vector();
-                    let source_array = source_variable.extract_array();
-                    let element_size = dfg.type_of_value(arguments[0]).element_size();
-
-                    let source_size_register = self
-                        .brillig_context
-                        .make_usize_constant_instruction(source_array.size.into());
-
-                    // we need to explicitly set the destination_len_variable
-                    self.brillig_context.codegen_usize_op(
-                        source_size_register.address,
-                        destination_len_variable.address,
-                        BrilligBinaryOp::UnsignedDiv,
-                        element_size,
-                    );
+                        Intrinsic::AsSlice => {
+                            let source_variable = self.convert_ssa_value(arguments[0], dfg);
+                            let result_ids = dfg.instruction_results(instruction_id);
+                            let destination_len_variable =
+                                self.variables.define_single_addr_variable(
+                                    self.function_context,
+                                    self.brillig_context,
+                                    result_ids[0],
+                                    dfg,
+                                );
+                            let destination_variable = self.variables.define_variable(
+                                self.function_context,
+                                self.brillig_context,
+                                result_ids[1],
+                                dfg,
+                            );
+                            let destination_vector = destination_variable.extract_vector();
+                            let source_array = source_variable.extract_array();
+                            let element_size = dfg.type_of_value(arguments[0]).element_size();
 
-                    self.brillig_context
-                        .codegen_initialize_vector(destination_vector, source_size_register);
-
-                    // Items
-                    let vector_items_pointer =
-                        self.brillig_context.codegen_make_vector_items_pointer(destination_vector);
-                    let array_items_pointer =
-                        self.brillig_context.codegen_make_array_items_pointer(source_array);
-
-                    self.brillig_context.codegen_mem_copy(
-                        array_items_pointer,
-                        vector_items_pointer,
-                        source_size_register,
-                    );
+                            let source_size_register = self
+                                .brillig_context
+                                .make_usize_constant_instruction(source_array.size.into());
+
+                            // we need to explicitly set the destination_len_variable
+                            self.brillig_context.codegen_usize_op(
+                                source_size_register.address,
+                                destination_len_variable.address,
+                                BrilligBinaryOp::UnsignedDiv,
+                                element_size,
+                            );
 
-                    self.brillig_context.deallocate_single_addr(source_size_register);
-                    self.brillig_context.deallocate_register(vector_items_pointer);
-                    self.brillig_context.deallocate_register(array_items_pointer);
-                }
-                Value::Intrinsic(
-                    Intrinsic::SlicePushBack
-                    | Intrinsic::SlicePopBack
-                    | Intrinsic::SlicePushFront
-                    | Intrinsic::SlicePopFront
-                    | Intrinsic::SliceInsert
-                    | Intrinsic::SliceRemove,
-                ) => {
-                    self.convert_ssa_slice_intrinsic_call(
-                        dfg,
-                        &dfg[dfg.resolve(*func)],
-                        instruction_id,
-                        arguments,
-                    );
-                }
-                Value::Intrinsic(Intrinsic::ToRadix(endianness)) => {
-                    let results = dfg.instruction_results(instruction_id);
-
-                    let source = self.convert_ssa_single_addr_value(arguments[0], dfg);
-                    let radix = self.convert_ssa_single_addr_value(arguments[1], dfg);
-
-                    let target_array = self
-                        .variables
-                        .define_variable(
-                            self.function_context,
-                            self.brillig_context,
-                            results[0],
-                            dfg,
-                        )
-                        .extract_array();
-
-                    self.brillig_context.codegen_to_radix(
-                        source,
-                        target_array,
-                        radix,
-                        matches!(endianness, Endian::Big),
-                        false,
-                    );
-                }
-                Value::Intrinsic(Intrinsic::ToBits(endianness)) => {
-                    let results = dfg.instruction_results(instruction_id);
+                            self.brillig_context.codegen_initialize_vector(
+                                destination_vector,
+                                source_size_register,
+                                None,
+                            );
 
-                    let source = self.convert_ssa_single_addr_value(arguments[0], dfg);
+                            // Items
+                            let vector_items_pointer = self
+                                .brillig_context
+                                .codegen_make_vector_items_pointer(destination_vector);
+                            let array_items_pointer =
+                                self.brillig_context.codegen_make_array_items_pointer(source_array);
+
+                            self.brillig_context.codegen_mem_copy(
+                                array_items_pointer,
+                                vector_items_pointer,
+                                source_size_register,
+                            );
 
-                    let target_array = self
-                        .variables
-                        .define_variable(
-                            self.function_context,
-                            self.brillig_context,
-                            results[0],
-                            dfg,
-                        )
-                        .extract_array();
+                            self.brillig_context.deallocate_single_addr(source_size_register);
+                            self.brillig_context.deallocate_register(vector_items_pointer);
+                            self.brillig_context.deallocate_register(array_items_pointer);
+                        }
+                        Intrinsic::SlicePushBack
+                        | Intrinsic::SlicePopBack
+                        | Intrinsic::SlicePushFront
+                        | Intrinsic::SlicePopFront
+                        | Intrinsic::SliceInsert
+                        | Intrinsic::SliceRemove => {
+                            self.convert_ssa_slice_intrinsic_call(
+                                dfg,
+                                &dfg[dfg.resolve(*func)],
+                                instruction_id,
+                                arguments,
+                            );
+                        }
+                        Intrinsic::ToBits(endianness) => {
+                            let results = dfg.instruction_results(instruction_id);
+
+                            let source = self.convert_ssa_single_addr_value(arguments[0], dfg);
+
+                            let target_array = self
+                                .variables
+                                .define_variable(
+                                    self.function_context,
+                                    self.brillig_context,
+                                    results[0],
+                                    dfg,
+                                )
+                                .extract_array();
+
+                            let two = self
+                                .brillig_context
+                                .make_usize_constant_instruction(2_usize.into());
+
+                            self.brillig_context.codegen_to_radix(
+                                source,
+                                target_array,
+                                two,
+                                matches!(endianness, Endian::Little),
+                                true,
+                            );
 
-                    let two = self.brillig_context.make_usize_constant_instruction(2_usize.into());
+                            self.brillig_context.deallocate_single_addr(two);
+                        }
 
-                    self.brillig_context.codegen_to_radix(
-                        source,
-                        target_array,
-                        two,
-                        matches!(endianness, Endian::Big),
-                        true,
-                    );
+                        Intrinsic::ToRadix(endianness) => {
+                            let results = dfg.instruction_results(instruction_id);
+
+                            let source = self.convert_ssa_single_addr_value(arguments[0], dfg);
+                            let radix = self.convert_ssa_single_addr_value(arguments[1], dfg);
+
+                            let target_array = self
+                                .variables
+                                .define_variable(
+                                    self.function_context,
+                                    self.brillig_context,
+                                    results[0],
+                                    dfg,
+                                )
+                                .extract_array();
+
+                            self.brillig_context.codegen_to_radix(
+                                source,
+                                target_array,
+                                radix,
+                                matches!(endianness, Endian::Little),
+                                false,
+                            );
+                        }
+                        Intrinsic::Hint(Hint::BlackBox) => {
+                            let result_ids = dfg.instruction_results(instruction_id);
+                            self.convert_ssa_identity_call(arguments, dfg, result_ids);
+                        }
+                        Intrinsic::BlackBox(bb_func) => {
+                            // Slices are represented as a tuple of (length, slice contents).
+                            // We must check the inputs to determine if there are slices
+                            // and make sure that we pass the correct inputs to the black box function call.
+                            // The loop below only keeps the slice contents, so that
+                            // setting up a black box function with slice inputs matches the expected
+                            // number of arguments specified in the function signature.
+                            let mut arguments_no_slice_len = Vec::new();
+                            for (i, arg) in arguments.iter().enumerate() {
+                                if matches!(dfg.type_of_value(*arg), Type::Numeric(_)) {
+                                    if i < arguments.len() - 1 {
+                                        if !matches!(
+                                            dfg.type_of_value(arguments[i + 1]),
+                                            Type::Slice(_)
+                                        ) {
+                                            arguments_no_slice_len.push(*arg);
+                                        }
+                                    } else {
+                                        arguments_no_slice_len.push(*arg);
+                                    }
+                                } else {
+                                    arguments_no_slice_len.push(*arg);
+                                }
+                            }
 
-                    self.brillig_context.deallocate_single_addr(two);
+                            let function_arguments = vecmap(&arguments_no_slice_len, |arg| {
+                                self.convert_ssa_value(*arg, dfg)
+                            });
+                            let function_results = dfg.instruction_results(instruction_id);
+                            let function_results = vecmap(function_results, |result| {
+                                self.allocate_external_call_result(*result, dfg)
+                            });
+                            convert_black_box_call(
+                                self.brillig_context,
+                                bb_func,
+                                &function_arguments,
+                                &function_results,
+                            );
+                        }
+                        // `Intrinsic::AsWitness` is used to provide hints to acir-gen on optimal expression splitting.
+                        // It is then useless in the brillig runtime and so we can ignore it
+                        Intrinsic::AsWitness => (),
+                        Intrinsic::FieldLessThan => {
+                            let lhs = self.convert_ssa_single_addr_value(arguments[0], dfg);
+                            assert!(lhs.bit_size == FieldElement::max_num_bits());
+                            let rhs = self.convert_ssa_single_addr_value(arguments[1], dfg);
+                            assert!(rhs.bit_size == FieldElement::max_num_bits());
+
+                            let results = dfg.instruction_results(instruction_id);
+                            let destination = self
+                                .variables
+                                .define_variable(
+                                    self.function_context,
+                                    self.brillig_context,
+                                    results[0],
+                                    dfg,
+                                )
+                                .extract_single_addr();
+                            assert!(destination.bit_size == 1);
+
+                            self.brillig_context.binary_instruction(
+                                lhs,
+                                rhs,
+                                destination,
+                                BrilligBinaryOp::LessThan,
+                            );
+                        }
+                        Intrinsic::ArrayRefCount | Intrinsic::SliceRefCount => {
+                            let array = self.convert_ssa_value(arguments[0], dfg);
+                            let result = dfg.instruction_results(instruction_id)[0];
+
+                            let destination = self.variables.define_variable(
+                                self.function_context,
+                                self.brillig_context,
+                                result,
+                                dfg,
+                            );
+                            let destination = destination.extract_register();
+                            let array = array.extract_register();
+                            self.brillig_context.load_instruction(destination, array);
+                        }
+                        Intrinsic::FromField
+                        | Intrinsic::AsField
+                        | Intrinsic::IsUnconstrained
+                        | Intrinsic::DerivePedersenGenerators
+                        | Intrinsic::ApplyRangeConstraint
+                        | Intrinsic::StrAsBytes
+                        | Intrinsic::AssertConstant
+                        | Intrinsic::StaticAssert
+                        | Intrinsic::ArrayAsStrUnchecked => {
+                            unreachable!("unsupported function call type {:?}", dfg[*func])
+                        }
+                    }
                 }
-
-                // `Intrinsic::AsWitness` is used to provide hints to acir-gen on optimal expression splitting.
-                // It is then useless in the brillig runtime and so we can ignore it
-                Value::Intrinsic(Intrinsic::AsWitness) => (),
-
-                _ => {
+                Value::Instruction { .. } | Value::Param { .. } | Value::NumericConstant { .. } => {
                     unreachable!("unsupported function call type {:?}", dfg[*func])
                 }
             },
@@ -759,6 +802,43 @@ impl<'block> BrilligBlock<'block> {
             Instruction::IfElse { .. } => {
                 unreachable!("IfElse instructions should not be possible in brillig")
             }
+            Instruction::MakeArray { elements: array, typ } => {
+                let value_id = dfg.instruction_results(instruction_id)[0];
+                if !self.variables.is_allocated(&value_id) {
+                    let new_variable = self.variables.define_variable(
+                        self.function_context,
+                        self.brillig_context,
+                        value_id,
+                        dfg,
+                    );
+
+                    // Initialize the variable
+                    match new_variable {
+                        BrilligVariable::BrilligArray(brillig_array) => {
+                            self.brillig_context.codegen_initialize_array(brillig_array);
+                        }
+                        BrilligVariable::BrilligVector(vector) => {
+                            let size = self
+                                .brillig_context
+                                .make_usize_constant_instruction(array.len().into());
+                            self.brillig_context.codegen_initialize_vector(vector, size, None);
+                            self.brillig_context.deallocate_single_addr(size);
+                        }
+                        _ => unreachable!(
+                            "ICE: Cannot initialize array value created as {new_variable:?}"
+                        ),
+                    };
+
+                    // Write the items
+                    let items_pointer = self
+                        .brillig_context
+                        .codegen_make_array_or_vector_items_pointer(new_variable);
+
+                    self.initialize_constant_array(array, typ, dfg, items_pointer);
+
+                    self.brillig_context.deallocate_register(items_pointer);
+                }
+            }
         };
 
         let dead_variables = self
@@ -783,26 +863,9 @@ impl<'block> BrilligBlock<'block> {
         dfg: &DataFlowGraph,
         result_ids: &[ValueId],
     ) {
-        // Convert the arguments to registers casting those to the types of the receiving function
-        let argument_registers: Vec<MemoryAddress> = arguments
-            .iter()
-            .map(|argument_id| self.convert_ssa_value(*argument_id, dfg).extract_register())
-            .collect();
-
-        let variables_to_save = self.variables.get_available_variables(self.function_context);
-
-        let saved_registers = self
-            .brillig_context
-            .codegen_pre_call_save_registers_prep_args(&argument_registers, &variables_to_save);
-
-        // Call instruction, which will interpret above registers 0..num args
-        self.brillig_context.add_external_call_instruction(func_id);
-
-        // Important: resolve after pre_call_save_registers_prep_args
-        // This ensures we don't save the results to registers unnecessarily.
-
-        // Allocate the registers for the variables where we are assigning the returns
-        let variables_assigned_to = vecmap(result_ids, |result_id| {
+        let argument_variables =
+            vecmap(arguments, |argument_id| self.convert_ssa_value(*argument_id, dfg));
+        let return_variables = vecmap(result_ids, |result_id| {
             self.variables.define_variable(
                 self.function_context,
                 self.brillig_context,
@@ -810,26 +873,31 @@ impl<'block> BrilligBlock<'block> {
                 dfg,
             )
         });
+        self.brillig_context.codegen_call(func_id, &argument_variables, &return_variables);
+    }
 
-        // Collect the registers that should have been returned
-        let returned_registers: Vec<MemoryAddress> = variables_assigned_to
-            .iter()
-            .map(|returned_variable| returned_variable.extract_register())
-            .collect();
-
-        assert!(
-            !saved_registers.iter().any(|x| returned_registers.contains(x)),
-            "should not save registers used as function results"
-        );
+    /// Copy the input arguments to the results.
+    fn convert_ssa_identity_call(
+        &mut self,
+        arguments: &[ValueId],
+        dfg: &DataFlowGraph,
+        result_ids: &[ValueId],
+    ) {
+        let argument_variables =
+            vecmap(arguments, |argument_id| self.convert_ssa_value(*argument_id, dfg));
 
-        // puts the returns into the returned_registers and restores saved_registers
-        self.brillig_context
-            .codegen_post_call_prep_returns_load_registers(&returned_registers, &saved_registers);
+        let return_variables = vecmap(result_ids, |result_id| {
+            self.variables.define_variable(
+                self.function_context,
+                self.brillig_context,
+                *result_id,
+                dfg,
+            )
+        });
 
-        // Reset the register state to the one needed to hold the current available variables
-        let variables = self.variables.get_available_variables(self.function_context);
-        let registers = variables.into_iter().map(|variable| variable.extract_register()).collect();
-        self.brillig_context.set_allocated_registers(registers);
+        for (src, dst) in argument_variables.into_iter().zip(return_variables) {
+            self.brillig_context.mov_instruction(dst.extract_register(), src.extract_register());
+        }
     }
 
     fn validate_array_index(
@@ -1215,8 +1283,8 @@ impl<'block> BrilligBlock<'block> {
         result_variable: SingleAddrVariable,
     ) {
         let binary_type = type_of_binary_operation(
-            dfg[binary.lhs].get_type(),
-            dfg[binary.rhs].get_type(),
+            dfg[binary.lhs].get_type().as_ref(),
+            dfg[binary.rhs].get_type().as_ref(),
             binary.operator,
         );
 
@@ -1235,7 +1303,7 @@ impl<'block> BrilligBlock<'block> {
         let brillig_binary_op = match binary.operator {
             BinaryOp::Div => {
                 if is_signed {
-                    self.convert_signed_division(left, right, result_variable);
+                    self.brillig_context.convert_signed_division(left, right, result_variable);
                     return;
                 } else if is_field {
                     BrilligBinaryOp::FieldDiv
@@ -1267,7 +1335,14 @@ impl<'block> BrilligBlock<'block> {
             BinaryOp::Or => BrilligBinaryOp::Or,
             BinaryOp::Xor => BrilligBinaryOp::Xor,
             BinaryOp::Shl => BrilligBinaryOp::Shl,
-            BinaryOp::Shr => BrilligBinaryOp::Shr,
+            BinaryOp::Shr => {
+                if is_signed {
+                    self.convert_signed_shr(left, right, result_variable);
+                    return;
+                } else {
+                    BrilligBinaryOp::Shr
+                }
+            }
         };
 
         self.brillig_context.binary_instruction(left, right, result_variable, brillig_binary_op);
@@ -1283,97 +1358,6 @@ impl<'block> BrilligBlock<'block> {
         );
     }
 
-    /// Splits a two's complement signed integer in the sign bit and the absolute value.
-    /// For example, -6 i8 (11111010) is split to 00000110 (6, absolute value) and 1 (is_negative).
-    fn absolute_value(
-        &mut self,
-        num: SingleAddrVariable,
-        absolute_value: SingleAddrVariable,
-        result_is_negative: SingleAddrVariable,
-    ) {
-        let max_positive = self
-            .brillig_context
-            .make_constant_instruction(((1_u128 << (num.bit_size - 1)) - 1).into(), num.bit_size);
-
-        // Compute if num is negative
-        self.brillig_context.binary_instruction(
-            max_positive,
-            num,
-            result_is_negative,
-            BrilligBinaryOp::LessThan,
-        );
-
-        // Two's complement of num
-        let zero = self.brillig_context.make_constant_instruction(0_usize.into(), num.bit_size);
-        let twos_complement =
-            SingleAddrVariable::new(self.brillig_context.allocate_register(), num.bit_size);
-        self.brillig_context.binary_instruction(zero, num, twos_complement, BrilligBinaryOp::Sub);
-
-        // absolute_value = result_is_negative ? twos_complement : num
-        self.brillig_context.conditional_mov_instruction(
-            absolute_value.address,
-            result_is_negative.address,
-            twos_complement.address,
-            num.address,
-        );
-
-        self.brillig_context.deallocate_single_addr(zero);
-        self.brillig_context.deallocate_single_addr(max_positive);
-        self.brillig_context.deallocate_single_addr(twos_complement);
-    }
-
-    fn convert_signed_division(
-        &mut self,
-        left: SingleAddrVariable,
-        right: SingleAddrVariable,
-        result: SingleAddrVariable,
-    ) {
-        let left_is_negative = SingleAddrVariable::new(self.brillig_context.allocate_register(), 1);
-        let left_abs_value =
-            SingleAddrVariable::new(self.brillig_context.allocate_register(), left.bit_size);
-
-        let right_is_negative =
-            SingleAddrVariable::new(self.brillig_context.allocate_register(), 1);
-        let right_abs_value =
-            SingleAddrVariable::new(self.brillig_context.allocate_register(), right.bit_size);
-
-        let result_is_negative =
-            SingleAddrVariable::new(self.brillig_context.allocate_register(), 1);
-
-        // Compute both absolute values
-        self.absolute_value(left, left_abs_value, left_is_negative);
-        self.absolute_value(right, right_abs_value, right_is_negative);
-
-        // Perform the division on the absolute values
-        self.brillig_context.binary_instruction(
-            left_abs_value,
-            right_abs_value,
-            result,
-            BrilligBinaryOp::UnsignedDiv,
-        );
-
-        // Compute result sign
-        self.brillig_context.binary_instruction(
-            left_is_negative,
-            right_is_negative,
-            result_is_negative,
-            BrilligBinaryOp::Xor,
-        );
-
-        // If result has to be negative, perform two's complement
-        self.brillig_context.codegen_if(result_is_negative.address, |ctx| {
-            let zero = ctx.make_constant_instruction(0_usize.into(), result.bit_size);
-            ctx.binary_instruction(zero, result, result, BrilligBinaryOp::Sub);
-            ctx.deallocate_single_addr(zero);
-        });
-
-        self.brillig_context.deallocate_single_addr(left_is_negative);
-        self.brillig_context.deallocate_single_addr(left_abs_value);
-        self.brillig_context.deallocate_single_addr(right_is_negative);
-        self.brillig_context.deallocate_single_addr(right_abs_value);
-        self.brillig_context.deallocate_single_addr(result_is_negative);
-    }
-
     fn convert_signed_modulo(
         &mut self,
         left: SingleAddrVariable,
@@ -1386,7 +1370,7 @@ impl<'block> BrilligBlock<'block> {
             SingleAddrVariable::new(self.brillig_context.allocate_register(), left.bit_size);
 
         // i = left / right
-        self.convert_signed_division(left, right, scratch_var_i);
+        self.brillig_context.convert_signed_division(left, right, scratch_var_i);
 
         // j = i * right
         self.brillig_context.binary_instruction(
@@ -1433,6 +1417,56 @@ impl<'block> BrilligBlock<'block> {
         self.brillig_context.deallocate_single_addr(bias);
     }
 
+    fn convert_signed_shr(
+        &mut self,
+        left: SingleAddrVariable,
+        right: SingleAddrVariable,
+        result: SingleAddrVariable,
+    ) {
+        // Check if left is negative
+        let left_is_negative = SingleAddrVariable::new(self.brillig_context.allocate_register(), 1);
+        let max_positive = self
+            .brillig_context
+            .make_constant_instruction(((1_u128 << (left.bit_size - 1)) - 1).into(), left.bit_size);
+        self.brillig_context.binary_instruction(
+            max_positive,
+            left,
+            left_is_negative,
+            BrilligBinaryOp::LessThan,
+        );
+
+        self.brillig_context.codegen_branch(left_is_negative.address, |ctx, is_negative| {
+            if is_negative {
+                let one = ctx.make_constant_instruction(1_u128.into(), left.bit_size);
+
+                // computes 2^right
+                let two = ctx.make_constant_instruction(2_u128.into(), left.bit_size);
+                let two_pow = ctx.make_constant_instruction(1_u128.into(), left.bit_size);
+                let right_u32 = SingleAddrVariable::new(ctx.allocate_register(), 32);
+                ctx.cast(right_u32, right);
+                let pow_body = |ctx: &mut BrilligContext<_, _>, _: SingleAddrVariable| {
+                    ctx.binary_instruction(two_pow, two, two_pow, BrilligBinaryOp::Mul);
+                };
+                ctx.codegen_for_loop(None, right_u32.address, None, pow_body);
+
+                // Right shift using division on 1-complement
+                ctx.binary_instruction(left, one, result, BrilligBinaryOp::Add);
+                ctx.convert_signed_division(result, two_pow, result);
+                ctx.binary_instruction(result, one, result, BrilligBinaryOp::Sub);
+
+                // Clean-up
+                ctx.deallocate_single_addr(one);
+                ctx.deallocate_single_addr(two);
+                ctx.deallocate_single_addr(two_pow);
+                ctx.deallocate_single_addr(right_u32);
+            } else {
+                ctx.binary_instruction(left, right, result, BrilligBinaryOp::Shr);
+            }
+        });
+
+        self.brillig_context.deallocate_single_addr(left_is_negative);
+    }
+
     #[allow(clippy::too_many_arguments)]
     fn add_overflow_check(
         &mut self,
@@ -1566,46 +1600,6 @@ impl<'block> BrilligBlock<'block> {
                     new_variable
                 }
             }
-            Value::Array { array, typ } => {
-                if self.variables.is_allocated(&value_id) {
-                    self.variables.get_allocation(self.function_context, value_id, dfg)
-                } else {
-                    let new_variable = self.variables.define_variable(
-                        self.function_context,
-                        self.brillig_context,
-                        value_id,
-                        dfg,
-                    );
-
-                    // Initialize the variable
-                    match new_variable {
-                        BrilligVariable::BrilligArray(brillig_array) => {
-                            self.brillig_context.codegen_initialize_array(brillig_array);
-                        }
-                        BrilligVariable::BrilligVector(vector) => {
-                            let size = self
-                                .brillig_context
-                                .make_usize_constant_instruction(array.len().into());
-                            self.brillig_context.codegen_initialize_vector(vector, size);
-                            self.brillig_context.deallocate_single_addr(size);
-                        }
-                        _ => unreachable!(
-                            "ICE: Cannot initialize array value created as {new_variable:?}"
-                        ),
-                    };
-
-                    // Write the items
-                    let items_pointer = self
-                        .brillig_context
-                        .codegen_make_array_or_vector_items_pointer(new_variable);
-
-                    self.initialize_constant_array(array, typ, dfg, items_pointer);
-
-                    self.brillig_context.deallocate_register(items_pointer);
-
-                    new_variable
-                }
-            }
             Value::Function(_) => {
                 // For the debugger instrumentation we want to allow passing
                 // around values representing function pointers, even though
@@ -1620,7 +1614,7 @@ impl<'block> BrilligBlock<'block> {
 
                 self.brillig_context.const_instruction(
                     new_variable.extract_single_addr(),
-                    value_id.to_usize().into(),
+                    value_id.to_u32().into(),
                 );
                 new_variable
             }
@@ -1799,7 +1793,7 @@ impl<'block> BrilligBlock<'block> {
         dfg: &DataFlowGraph,
     ) -> BrilligVariable {
         let typ = dfg[result].get_type();
-        match typ {
+        match typ.as_ref() {
             Type::Numeric(_) => self.variables.define_variable(
                 self.function_context,
                 self.brillig_context,
@@ -1815,7 +1809,7 @@ impl<'block> BrilligBlock<'block> {
                     dfg,
                 );
                 let array = variable.extract_array();
-                self.allocate_foreign_call_result_array(typ, array);
+                self.allocate_foreign_call_result_array(typ.as_ref(), array);
 
                 variable
             }
@@ -1832,11 +1826,6 @@ impl<'block> BrilligBlock<'block> {
                 // The stack pointer will then be updated by the caller of this method
                 // once the external call is resolved and the array size is known
                 self.brillig_context.load_free_memory_pointer_instruction(vector.pointer);
-                self.brillig_context.indirect_const_instruction(
-                    vector.pointer,
-                    BRILLIG_MEMORY_ADDRESSING_BIT_SIZE,
-                    1_usize.into(),
-                );
 
                 variable
             }
@@ -1860,7 +1849,7 @@ impl<'block> BrilligBlock<'block> {
                     Type::Array(_, nested_size) => {
                         let inner_array = BrilligArray {
                             pointer: self.brillig_context.allocate_register(),
-                            size: *nested_size,
+                            size: *nested_size as usize,
                         };
                         self.allocate_foreign_call_result_array(element_type, inner_array);
 
diff --git a/compiler/noirc_evaluator/src/brillig/brillig_gen/brillig_block_variables.rs b/compiler/noirc_evaluator/src/brillig/brillig_gen/brillig_block_variables.rs
index 393d4c967c2..bf0a1bc7347 100644
--- a/compiler/noirc_evaluator/src/brillig/brillig_gen/brillig_block_variables.rs
+++ b/compiler/noirc_evaluator/src/brillig/brillig_gen/brillig_block_variables.rs
@@ -142,7 +142,7 @@ pub(crate) fn allocate_value<F, Registers: RegisterAllocator>(
         }
         Type::Array(item_typ, elem_count) => BrilligVariable::BrilligArray(BrilligArray {
             pointer: brillig_context.allocate_register(),
-            size: compute_array_length(&item_typ, elem_count),
+            size: compute_array_length(&item_typ, elem_count as usize),
         }),
         Type::Slice(_) => BrilligVariable::BrilligVector(BrilligVector {
             pointer: brillig_context.allocate_register(),
diff --git a/compiler/noirc_evaluator/src/brillig/brillig_gen/brillig_directive.rs b/compiler/noirc_evaluator/src/brillig/brillig_gen/brillig_directive.rs
deleted file mode 100644
index faf4242a9ca..00000000000
--- a/compiler/noirc_evaluator/src/brillig/brillig_gen/brillig_directive.rs
+++ /dev/null
@@ -1,139 +0,0 @@
-use acvm::acir::{
-    brillig::{BinaryFieldOp, BitSize, IntegerBitSize, MemoryAddress, Opcode as BrilligOpcode},
-    AcirField,
-};
-
-use crate::brillig::brillig_ir::artifact::GeneratedBrillig;
-
-/// Generates brillig bytecode which computes the inverse of its input if not null, and zero else.
-pub(crate) fn directive_invert<F: AcirField>() -> GeneratedBrillig<F> {
-    //  We generate the following code:
-    // fn invert(x : Field) -> Field {
-    //    1/ x
-    // }
-
-    // The input argument, ie the value that will be inverted.
-    // We store the result in this register too.
-    let input = MemoryAddress::from(0);
-    let one_const = MemoryAddress::from(1);
-    let zero_const = MemoryAddress::from(2);
-    let input_is_zero = MemoryAddress::from(3);
-    // Location of the stop opcode
-    let stop_location = 8;
-
-    GeneratedBrillig {
-        byte_code: vec![
-            BrilligOpcode::Const {
-                destination: MemoryAddress(20),
-                bit_size: BitSize::Integer(IntegerBitSize::U32),
-                value: F::from(1_usize),
-            },
-            BrilligOpcode::Const {
-                destination: MemoryAddress::from(21),
-                bit_size: BitSize::Integer(IntegerBitSize::U32),
-                value: F::from(0_usize),
-            },
-            BrilligOpcode::CalldataCopy {
-                destination_address: input,
-                size_address: MemoryAddress::from(20),
-                offset_address: MemoryAddress::from(21),
-            },
-            // Put value zero in register (2)
-            BrilligOpcode::Const {
-                destination: zero_const,
-                value: F::from(0_usize),
-                bit_size: BitSize::Field,
-            },
-            BrilligOpcode::BinaryFieldOp {
-                op: BinaryFieldOp::Equals,
-                lhs: input,
-                rhs: zero_const,
-                destination: input_is_zero,
-            },
-            // If the input is zero, then we jump to the stop opcode
-            BrilligOpcode::JumpIf { condition: input_is_zero, location: stop_location },
-            // Put value one in register (1)
-            BrilligOpcode::Const {
-                destination: one_const,
-                value: F::one(),
-                bit_size: BitSize::Field,
-            },
-            // Divide 1 by the input, and set the result of the division into register (0)
-            BrilligOpcode::BinaryFieldOp {
-                op: BinaryFieldOp::Div,
-                lhs: one_const,
-                rhs: input,
-                destination: input,
-            },
-            BrilligOpcode::Stop { return_data_offset: 0, return_data_size: 1 },
-        ],
-        assert_messages: Default::default(),
-        locations: Default::default(),
-        name: "directive_invert".to_string(),
-    }
-}
-
-/// Generates brillig bytecode which computes `a / b` and returns the quotient and remainder.
-///
-/// This is equivalent to the Noir (pseudo)code
-///
-/// ```text
-/// fn quotient<T>(a: T, b: T) -> (T,T) {
-///    (a/b, a-a/b*b)
-/// }
-/// ```
-pub(crate) fn directive_quotient<F: AcirField>() -> GeneratedBrillig<F> {
-    // `a` is (0) (i.e register index 0)
-    // `b` is (1)
-
-    GeneratedBrillig {
-        byte_code: vec![
-            BrilligOpcode::Const {
-                destination: MemoryAddress::from(10),
-                bit_size: BitSize::Integer(IntegerBitSize::U32),
-                value: F::from(2_usize),
-            },
-            BrilligOpcode::Const {
-                destination: MemoryAddress::from(11),
-                bit_size: BitSize::Integer(IntegerBitSize::U32),
-                value: F::from(0_usize),
-            },
-            BrilligOpcode::CalldataCopy {
-                destination_address: MemoryAddress::from(0),
-                size_address: MemoryAddress::from(10),
-                offset_address: MemoryAddress::from(11),
-            },
-            // No cast, since calldata is typed as field by default
-            //q = a/b is set into register (2)
-            BrilligOpcode::BinaryFieldOp {
-                op: BinaryFieldOp::IntegerDiv, // We want integer division, not field division!
-                lhs: MemoryAddress::from(0),
-                rhs: MemoryAddress::from(1),
-                destination: MemoryAddress::from(2),
-            },
-            //(1)= q*b
-            BrilligOpcode::BinaryFieldOp {
-                op: BinaryFieldOp::Mul,
-                lhs: MemoryAddress::from(2),
-                rhs: MemoryAddress::from(1),
-                destination: MemoryAddress::from(1),
-            },
-            //(1) = a-q*b
-            BrilligOpcode::BinaryFieldOp {
-                op: BinaryFieldOp::Sub,
-                lhs: MemoryAddress::from(0),
-                rhs: MemoryAddress::from(1),
-                destination: MemoryAddress::from(1),
-            },
-            //(0) = q
-            BrilligOpcode::Mov {
-                destination: MemoryAddress::from(0),
-                source: MemoryAddress::from(2),
-            },
-            BrilligOpcode::Stop { return_data_offset: 0, return_data_size: 2 },
-        ],
-        assert_messages: Default::default(),
-        locations: Default::default(),
-        name: "directive_integer_quotient".to_string(),
-    }
-}
diff --git a/compiler/noirc_evaluator/src/brillig/brillig_gen/brillig_fn.rs b/compiler/noirc_evaluator/src/brillig/brillig_gen/brillig_fn.rs
index 2779be103cd..3dea7b3e7f5 100644
--- a/compiler/noirc_evaluator/src/brillig/brillig_gen/brillig_fn.rs
+++ b/compiler/noirc_evaluator/src/brillig/brillig_gen/brillig_fn.rs
@@ -59,7 +59,7 @@ impl FunctionContext {
                 vecmap(item_type.iter(), |item_typ| {
                     FunctionContext::ssa_type_to_parameter(item_typ)
                 }),
-                *size,
+                *size as usize,
             ),
             Type::Slice(_) => {
                 panic!("ICE: Slice parameters cannot be derived from type information")
diff --git a/compiler/noirc_evaluator/src/brillig/brillig_gen/brillig_slice_ops.rs b/compiler/noirc_evaluator/src/brillig/brillig_gen/brillig_slice_ops.rs
index 85db1bd8b96..26c7151bf07 100644
--- a/compiler/noirc_evaluator/src/brillig/brillig_gen/brillig_slice_ops.rs
+++ b/compiler/noirc_evaluator/src/brillig/brillig_gen/brillig_slice_ops.rs
@@ -79,17 +79,15 @@ impl<'block> BrilligBlock<'block> {
         source_vector: BrilligVector,
         removed_items: &[BrilligVariable],
     ) {
-        let read_pointer = self.brillig_context.allocate_register();
-        self.brillig_context.call_vector_pop_procedure(
+        let read_pointer = self.brillig_context.codegen_make_vector_items_pointer(source_vector);
+        self.read_variables(read_pointer, removed_items);
+        self.brillig_context.deallocate_register(read_pointer);
+
+        self.brillig_context.call_vector_pop_front_procedure(
             source_vector,
             target_vector,
-            read_pointer,
             removed_items.len(),
-            false,
         );
-
-        self.read_variables(read_pointer, removed_items);
-        self.brillig_context.deallocate_register(read_pointer);
     }
 
     pub(crate) fn slice_pop_back_operation(
@@ -99,12 +97,11 @@ impl<'block> BrilligBlock<'block> {
         removed_items: &[BrilligVariable],
     ) {
         let read_pointer = self.brillig_context.allocate_register();
-        self.brillig_context.call_vector_pop_procedure(
+        self.brillig_context.call_vector_pop_back_procedure(
             source_vector,
             target_vector,
             read_pointer,
             removed_items.len(),
-            true,
         );
 
         self.read_variables(read_pointer, removed_items);
@@ -162,6 +159,7 @@ mod tests {
     use std::vec;
 
     use acvm::FieldElement;
+    use noirc_frontend::monomorphization::ast::InlineType;
 
     use crate::brillig::brillig_gen::brillig_block::BrilligBlock;
     use crate::brillig::brillig_gen::brillig_block_variables::BlockVariables;
@@ -182,7 +180,7 @@ mod tests {
 
     fn create_test_environment() -> (Ssa, FunctionContext, BrilligContext<FieldElement, Stack>) {
         let mut builder = FunctionBuilder::new("main".to_string(), Id::test_new(0));
-        builder.set_runtime(RuntimeType::Brillig);
+        builder.set_runtime(RuntimeType::Brillig(InlineType::default()));
 
         let ssa = builder.finish();
         let mut brillig_context = create_context(ssa.main_id);
@@ -212,7 +210,7 @@ mod tests {
             push_back: bool,
             array: Vec<FieldElement>,
             item_to_push: FieldElement,
-            mut expected_return: Vec<FieldElement>,
+            expected_return: Vec<FieldElement>,
         ) {
             let arguments = vec![
                 BrilligParameter::Slice(
@@ -222,11 +220,15 @@ mod tests {
                 BrilligParameter::SingleAddr(BRILLIG_MEMORY_ADDRESSING_BIT_SIZE),
             ];
             let result_length = array.len() + 1;
+            assert_eq!(result_length, expected_return.len());
+            let result_length_with_metadata = result_length + 2; // Leading length and capacity
+
+            // Entry points don't support returning slices, so we implicitly cast the vector to an array
+            // With the metadata at the start.
             let returns = vec![BrilligParameter::Array(
                 vec![BrilligParameter::SingleAddr(BRILLIG_MEMORY_ADDRESSING_BIT_SIZE)],
-                result_length + 1, // Leading length since the we return a vector
+                result_length_with_metadata,
             )];
-            expected_return.insert(0, FieldElement::from(result_length));
 
             let (_, mut function_context, mut context) = create_test_environment();
 
@@ -261,14 +263,17 @@ mod tests {
             let bytecode = create_entry_point_bytecode(context, arguments, returns).byte_code;
             let (vm, return_data_offset, return_data_size) =
                 create_and_run_vm(array.into_iter().chain(vec![item_to_push]).collect(), &bytecode);
-            assert_eq!(return_data_size, expected_return.len());
-            assert_eq!(
-                vm.get_memory()[return_data_offset..(return_data_offset + expected_return.len())]
-                    .iter()
-                    .map(|mem_val| mem_val.to_field())
-                    .collect::<Vec<_>>(),
-                expected_return
-            );
+            assert_eq!(return_data_size, result_length_with_metadata);
+            let mut returned_vector: Vec<FieldElement> = vm.get_memory()
+                [return_data_offset..(return_data_offset + result_length_with_metadata)]
+                .iter()
+                .map(|mem_val| mem_val.to_field())
+                .collect();
+            let returned_size = returned_vector.remove(0);
+            assert_eq!(returned_size, result_length.into());
+            let _returned_capacity = returned_vector.remove(0);
+
+            assert_eq!(returned_vector, expected_return);
         }
 
         test_case_push(
@@ -320,7 +325,7 @@ mod tests {
         fn test_case_pop(
             pop_back: bool,
             array: Vec<FieldElement>,
-            mut expected_return_array: Vec<FieldElement>,
+            expected_return_array: Vec<FieldElement>,
             expected_return_item: FieldElement,
         ) {
             let arguments = vec![BrilligParameter::Slice(
@@ -328,15 +333,18 @@ mod tests {
                 array.len(),
             )];
             let result_length = array.len() - 1;
+            assert_eq!(result_length, expected_return_array.len());
+            let result_length_with_metadata = result_length + 2; // Leading length and capacity
 
+            // Entry points don't support returning slices, so we implicitly cast the vector to an array
+            // With the metadata at the start.
             let returns = vec![
+                BrilligParameter::SingleAddr(BRILLIG_MEMORY_ADDRESSING_BIT_SIZE),
                 BrilligParameter::Array(
                     vec![BrilligParameter::SingleAddr(BRILLIG_MEMORY_ADDRESSING_BIT_SIZE)],
-                    result_length + 1,
+                    result_length_with_metadata,
                 ),
-                BrilligParameter::SingleAddr(BRILLIG_MEMORY_ADDRESSING_BIT_SIZE),
             ];
-            expected_return_array.insert(0, FieldElement::from(result_length));
 
             let (_, mut function_context, mut context) = create_test_environment();
 
@@ -366,22 +374,28 @@ mod tests {
                 );
             }
 
-            context.codegen_return(&[target_vector.pointer, removed_item.address]);
+            context.codegen_return(&[removed_item.address, target_vector.pointer]);
 
             let bytecode = create_entry_point_bytecode(context, arguments, returns).byte_code;
-            let expected_return: Vec<_> =
-                expected_return_array.into_iter().chain(vec![expected_return_item]).collect();
+
             let (vm, return_data_offset, return_data_size) =
                 create_and_run_vm(array.clone(), &bytecode);
-            assert_eq!(return_data_size, expected_return.len());
-
-            assert_eq!(
-                vm.get_memory()[return_data_offset..(return_data_offset + expected_return.len())]
-                    .iter()
-                    .map(|mem_val| mem_val.to_field())
-                    .collect::<Vec<_>>(),
-                expected_return
-            );
+            // vector + removed item
+            assert_eq!(return_data_size, result_length_with_metadata + 1);
+
+            let mut return_data: Vec<FieldElement> = vm.get_memory()
+                [return_data_offset..(return_data_offset + return_data_size)]
+                .iter()
+                .map(|mem_val| mem_val.to_field())
+                .collect();
+            let returned_item = return_data.remove(0);
+            assert_eq!(returned_item, expected_return_item);
+
+            let returned_size = return_data.remove(0);
+            assert_eq!(returned_size, result_length.into());
+            let _returned_capacity = return_data.remove(0);
+
+            assert_eq!(return_data, expected_return_array);
         }
 
         test_case_pop(
@@ -413,7 +427,7 @@ mod tests {
             array: Vec<FieldElement>,
             item: FieldElement,
             index: FieldElement,
-            mut expected_return: Vec<FieldElement>,
+            expected_return: Vec<FieldElement>,
         ) {
             let arguments = vec![
                 BrilligParameter::Slice(
@@ -424,11 +438,15 @@ mod tests {
                 BrilligParameter::SingleAddr(BRILLIG_MEMORY_ADDRESSING_BIT_SIZE),
             ];
             let result_length = array.len() + 1;
+            assert_eq!(result_length, expected_return.len());
+            let result_length_with_metadata = result_length + 2; // Leading length and capacity
+
+            // Entry points don't support returning slices, so we implicitly cast the vector to an array
+            // With the metadata at the start.
             let returns = vec![BrilligParameter::Array(
                 vec![BrilligParameter::SingleAddr(BRILLIG_MEMORY_ADDRESSING_BIT_SIZE)],
-                result_length + 1,
+                result_length_with_metadata,
             )];
-            expected_return.insert(0, FieldElement::from(result_length));
 
             let (_, mut function_context, mut context) = create_test_environment();
 
@@ -460,15 +478,18 @@ mod tests {
 
             let bytecode = create_entry_point_bytecode(context, arguments, returns).byte_code;
             let (vm, return_data_offset, return_data_size) = create_and_run_vm(calldata, &bytecode);
-            assert_eq!(return_data_size, expected_return.len());
-
-            assert_eq!(
-                vm.get_memory()[return_data_offset..(return_data_offset + expected_return.len())]
-                    .iter()
-                    .map(|mem_val| mem_val.to_field())
-                    .collect::<Vec<_>>(),
-                expected_return
-            );
+            assert_eq!(return_data_size, result_length_with_metadata);
+
+            let mut returned_vector: Vec<FieldElement> = vm.get_memory()
+                [return_data_offset..(return_data_offset + result_length_with_metadata)]
+                .iter()
+                .map(|mem_val| mem_val.to_field())
+                .collect();
+            let returned_size = returned_vector.remove(0);
+            assert_eq!(returned_size, result_length.into());
+            let _returned_capacity = returned_vector.remove(0);
+
+            assert_eq!(returned_vector, expected_return);
         }
 
         test_case_insert(
@@ -545,7 +566,7 @@ mod tests {
         fn test_case_remove(
             array: Vec<FieldElement>,
             index: FieldElement,
-            mut expected_array: Vec<FieldElement>,
+            expected_array: Vec<FieldElement>,
             expected_removed_item: FieldElement,
         ) {
             let arguments = vec![
@@ -556,15 +577,16 @@ mod tests {
                 BrilligParameter::SingleAddr(BRILLIG_MEMORY_ADDRESSING_BIT_SIZE),
             ];
             let result_length = array.len() - 1;
+            assert_eq!(result_length, expected_array.len());
+            let result_length_with_metadata = result_length + 2; // Leading length and capacity
 
             let returns = vec![
+                BrilligParameter::SingleAddr(BRILLIG_MEMORY_ADDRESSING_BIT_SIZE),
                 BrilligParameter::Array(
                     vec![BrilligParameter::SingleAddr(BRILLIG_MEMORY_ADDRESSING_BIT_SIZE)],
-                    result_length + 1,
+                    result_length_with_metadata,
                 ),
-                BrilligParameter::SingleAddr(BRILLIG_MEMORY_ADDRESSING_BIT_SIZE),
             ];
-            expected_array.insert(0, FieldElement::from(result_length));
 
             let (_, mut function_context, mut context) = create_test_environment();
 
@@ -591,24 +613,29 @@ mod tests {
                 &[BrilligVariable::SingleAddr(removed_item)],
             );
 
-            context.codegen_return(&[target_vector.pointer, removed_item.address]);
+            context.codegen_return(&[removed_item.address, target_vector.pointer]);
 
             let calldata: Vec<_> = array.into_iter().chain(vec![index]).collect();
 
             let bytecode = create_entry_point_bytecode(context, arguments, returns).byte_code;
             let (vm, return_data_offset, return_data_size) = create_and_run_vm(calldata, &bytecode);
 
-            let expected_return: Vec<_> =
-                expected_array.into_iter().chain(vec![expected_removed_item]).collect();
-            assert_eq!(return_data_size, expected_return.len());
+            // vector + removed item
+            assert_eq!(return_data_size, result_length_with_metadata + 1);
 
-            assert_eq!(
-                vm.get_memory()[return_data_offset..(return_data_offset + expected_return.len())]
-                    .iter()
-                    .map(|mem_val| mem_val.to_field())
-                    .collect::<Vec<_>>(),
-                expected_return
-            );
+            let mut return_data: Vec<FieldElement> = vm.get_memory()
+                [return_data_offset..(return_data_offset + return_data_size)]
+                .iter()
+                .map(|mem_val| mem_val.to_field())
+                .collect();
+            let returned_item = return_data.remove(0);
+            assert_eq!(returned_item, expected_removed_item);
+
+            let returned_size = return_data.remove(0);
+            assert_eq!(returned_size, result_length.into());
+            let _returned_capacity = return_data.remove(0);
+
+            assert_eq!(return_data, expected_array);
         }
 
         test_case_remove(
diff --git a/compiler/noirc_evaluator/src/brillig/brillig_gen/constant_allocation.rs b/compiler/noirc_evaluator/src/brillig/brillig_gen/constant_allocation.rs
index f9ded224b33..61ca20be2f5 100644
--- a/compiler/noirc_evaluator/src/brillig/brillig_gen/constant_allocation.rs
+++ b/compiler/noirc_evaluator/src/brillig/brillig_gen/constant_allocation.rs
@@ -89,8 +89,7 @@ impl ConstantAllocation {
             }
             if let Some(terminator_instruction) = block.terminator() {
                 terminator_instruction.for_each_value(|value_id| {
-                    let variables = collect_variables_of_value(value_id, &func.dfg);
-                    for variable in variables {
+                    if let Some(variable) = collect_variables_of_value(value_id, &func.dfg) {
                         record_if_constant(block_id, variable, InstructionLocation::Terminator);
                     }
                 });
@@ -166,7 +165,7 @@ impl ConstantAllocation {
 }
 
 pub(crate) fn is_constant_value(id: ValueId, dfg: &DataFlowGraph) -> bool {
-    matches!(&dfg[dfg.resolve(id)], Value::NumericConstant { .. } | Value::Array { .. })
+    matches!(&dfg[dfg.resolve(id)], Value::NumericConstant { .. })
 }
 
 /// For a given function, finds all the blocks that are within loops
diff --git a/compiler/noirc_evaluator/src/brillig/brillig_gen/variable_liveness.rs b/compiler/noirc_evaluator/src/brillig/brillig_gen/variable_liveness.rs
index 92595292bf0..d6851a9ecf9 100644
--- a/compiler/noirc_evaluator/src/brillig/brillig_gen/variable_liveness.rs
+++ b/compiler/noirc_evaluator/src/brillig/brillig_gen/variable_liveness.rs
@@ -45,32 +45,19 @@ fn find_back_edges(
 }
 
 /// Collects the underlying variables inside a value id. It might be more than one, for example in constant arrays that are constructed with multiple vars.
-pub(crate) fn collect_variables_of_value(value_id: ValueId, dfg: &DataFlowGraph) -> Vec<ValueId> {
+pub(crate) fn collect_variables_of_value(
+    value_id: ValueId,
+    dfg: &DataFlowGraph,
+) -> Option<ValueId> {
     let value_id = dfg.resolve(value_id);
     let value = &dfg[value_id];
 
     match value {
-        Value::Instruction { .. } | Value::Param { .. } => {
-            vec![value_id]
-        }
-        // Literal arrays are constants, but might use variable values to initialize.
-        Value::Array { array, .. } => {
-            let mut value_ids = vec![value_id];
-
-            array.iter().for_each(|item_id| {
-                let underlying_ids = collect_variables_of_value(*item_id, dfg);
-                value_ids.extend(underlying_ids);
-            });
-
-            value_ids
-        }
-        Value::NumericConstant { .. } => {
-            vec![value_id]
+        Value::Instruction { .. } | Value::Param { .. } | Value::NumericConstant { .. } => {
+            Some(value_id)
         }
         // Functions are not variables in a defunctionalized SSA. Only constant function values should appear.
-        Value::ForeignFunction(_) | Value::Function(_) | Value::Intrinsic(..) => {
-            vec![]
-        }
+        Value::ForeignFunction(_) | Value::Function(_) | Value::Intrinsic(..) => None,
     }
 }
 
@@ -341,6 +328,7 @@ impl VariableLiveness {
 #[cfg(test)]
 mod test {
     use fxhash::FxHashSet;
+    use noirc_frontend::monomorphization::ast::InlineType;
 
     use crate::brillig::brillig_gen::constant_allocation::ConstantAllocation;
     use crate::brillig::brillig_gen::variable_liveness::VariableLiveness;
@@ -373,7 +361,7 @@ mod test {
 
         let main_id = Id::test_new(1);
         let mut builder = FunctionBuilder::new("main".into(), main_id);
-        builder.set_runtime(RuntimeType::Brillig);
+        builder.set_runtime(RuntimeType::Brillig(InlineType::default()));
 
         let b1 = builder.insert_block();
         let b2 = builder.insert_block();
@@ -384,7 +372,7 @@ mod test {
 
         let v3 = builder.insert_allocate(Type::field());
 
-        let zero = builder.numeric_constant(0u128, Type::field());
+        let zero = builder.field_constant(0u128);
         builder.insert_store(v3, zero);
 
         let v4 = builder.insert_binary(v0, BinaryOp::Eq, zero);
@@ -393,7 +381,7 @@ mod test {
 
         builder.switch_to_block(b2);
 
-        let twenty_seven = builder.numeric_constant(27u128, Type::field());
+        let twenty_seven = builder.field_constant(27u128);
         let v7 = builder.insert_binary(v0, BinaryOp::Add, twenty_seven);
         builder.insert_store(v3, v7);
 
@@ -483,7 +471,7 @@ mod test {
 
         let main_id = Id::test_new(1);
         let mut builder = FunctionBuilder::new("main".into(), main_id);
-        builder.set_runtime(RuntimeType::Brillig);
+        builder.set_runtime(RuntimeType::Brillig(InlineType::default()));
 
         let b1 = builder.insert_block();
         let b2 = builder.insert_block();
@@ -499,7 +487,7 @@ mod test {
 
         let v3 = builder.insert_allocate(Type::field());
 
-        let zero = builder.numeric_constant(0u128, Type::field());
+        let zero = builder.field_constant(0u128);
         builder.insert_store(v3, zero);
 
         builder.terminate_with_jmp(b1, vec![zero]);
@@ -527,7 +515,7 @@ mod test {
 
         builder.switch_to_block(b5);
 
-        let twenty_seven = builder.numeric_constant(27u128, Type::field());
+        let twenty_seven = builder.field_constant(27u128);
         let v10 = builder.insert_binary(v7, BinaryOp::Eq, twenty_seven);
 
         let v11 = builder.insert_not(v10);
@@ -546,7 +534,7 @@ mod test {
 
         builder.switch_to_block(b8);
 
-        let one = builder.numeric_constant(1u128, Type::field());
+        let one = builder.field_constant(1u128);
         let v15 = builder.insert_binary(v7, BinaryOp::Add, one);
 
         builder.terminate_with_jmp(b4, vec![v15]);
@@ -622,7 +610,7 @@ mod test {
 
         let main_id = Id::test_new(1);
         let mut builder = FunctionBuilder::new("main".into(), main_id);
-        builder.set_runtime(RuntimeType::Brillig);
+        builder.set_runtime(RuntimeType::Brillig(InlineType::default()));
 
         let v0 = builder.add_parameter(Type::bool());
 
diff --git a/compiler/noirc_evaluator/src/brillig/brillig_ir.rs b/compiler/noirc_evaluator/src/brillig/brillig_ir.rs
index d8065294b0c..8d5f14cee94 100644
--- a/compiler/noirc_evaluator/src/brillig/brillig_ir.rs
+++ b/compiler/noirc_evaluator/src/brillig/brillig_ir.rs
@@ -25,6 +25,7 @@ mod entry_point;
 mod instructions;
 
 use artifact::Label;
+use brillig_variable::SingleAddrVariable;
 pub(crate) use instructions::BrilligBinaryOp;
 use registers::{RegisterAllocator, ScratchSpace};
 
@@ -36,6 +37,8 @@ use acvm::{
 };
 use debug_show::DebugShow;
 
+use super::ProcedureId;
+
 /// The Brillig VM does not apply a limit to the memory address space,
 /// As a convention, we take use 32 bits. This means that we assume that
 /// memory has 2^32 memory slots.
@@ -43,19 +46,17 @@ pub(crate) const BRILLIG_MEMORY_ADDRESSING_BIT_SIZE: u32 = 32;
 
 // Registers reserved in runtime for special purposes.
 pub(crate) enum ReservedRegisters {
+    /// This register stores the stack pointer. All relative memory addresses are relative to this pointer.
+    StackPointer = 0,
     /// This register stores the free memory pointer. Allocations must be done after this pointer.
-    FreeMemoryPointer = 0,
-    /// This register stores the previous stack pointer. The registers of the caller are stored here.
-    PreviousStackPointer = 1,
+    FreeMemoryPointer = 1,
     /// This register stores a 1_usize constant.
     UsizeOne = 2,
 }
 
 impl ReservedRegisters {
-    /// The number of reserved registers.
-    ///
-    /// This is used to offset the general registers
-    /// which should not overwrite the special register
+    /// The number of reserved registers. These are allocated in the first memory positions.
+    /// The stack should start after the reserved registers.
     const NUM_RESERVED_REGISTERS: usize = 3;
 
     /// Returns the length of the reserved registers
@@ -63,19 +64,16 @@ impl ReservedRegisters {
         Self::NUM_RESERVED_REGISTERS
     }
 
-    /// Returns the free memory pointer register. This will get used to allocate memory in runtime.
-    pub(crate) fn free_memory_pointer() -> MemoryAddress {
-        MemoryAddress::from(ReservedRegisters::FreeMemoryPointer as usize)
+    pub(crate) fn stack_pointer() -> MemoryAddress {
+        MemoryAddress::direct(ReservedRegisters::StackPointer as usize)
     }
 
-    /// Returns the previous stack pointer register. This will be used to restore the registers after a fn call.
-    pub(crate) fn previous_stack_pointer() -> MemoryAddress {
-        MemoryAddress::from(ReservedRegisters::PreviousStackPointer as usize)
+    pub(crate) fn free_memory_pointer() -> MemoryAddress {
+        MemoryAddress::direct(ReservedRegisters::FreeMemoryPointer as usize)
     }
 
-    /// Returns the usize one register. This will be used to perform arithmetic operations.
     pub(crate) fn usize_one() -> MemoryAddress {
-        MemoryAddress::from(ReservedRegisters::UsizeOne as usize)
+        MemoryAddress::direct(ReservedRegisters::UsizeOne as usize)
     }
 }
 
@@ -112,13 +110,99 @@ impl<F: AcirField + DebugToString> BrilligContext<F, Stack> {
             can_call_procedures: true,
         }
     }
+
+    /// Splits a two's complement signed integer in the sign bit and the absolute value.
+    /// For example, -6 i8 (11111010) is split to 00000110 (6, absolute value) and 1 (is_negative).
+    pub(crate) fn absolute_value(
+        &mut self,
+        num: SingleAddrVariable,
+        absolute_value: SingleAddrVariable,
+        result_is_negative: SingleAddrVariable,
+    ) {
+        let max_positive = self
+            .make_constant_instruction(((1_u128 << (num.bit_size - 1)) - 1).into(), num.bit_size);
+
+        // Compute if num is negative
+        self.binary_instruction(max_positive, num, result_is_negative, BrilligBinaryOp::LessThan);
+
+        // Two's complement of num
+        let zero = self.make_constant_instruction(0_usize.into(), num.bit_size);
+        let twos_complement = SingleAddrVariable::new(self.allocate_register(), num.bit_size);
+        self.binary_instruction(zero, num, twos_complement, BrilligBinaryOp::Sub);
+
+        // absolute_value = result_is_negative ? twos_complement : num
+        self.codegen_branch(result_is_negative.address, |ctx, is_negative| {
+            if is_negative {
+                ctx.mov_instruction(absolute_value.address, twos_complement.address);
+            } else {
+                ctx.mov_instruction(absolute_value.address, num.address);
+            }
+        });
+
+        self.deallocate_single_addr(zero);
+        self.deallocate_single_addr(max_positive);
+        self.deallocate_single_addr(twos_complement);
+    }
+
+    pub(crate) fn convert_signed_division(
+        &mut self,
+        left: SingleAddrVariable,
+        right: SingleAddrVariable,
+        result: SingleAddrVariable,
+    ) {
+        let left_is_negative = SingleAddrVariable::new(self.allocate_register(), 1);
+        let left_abs_value = SingleAddrVariable::new(self.allocate_register(), left.bit_size);
+
+        let right_is_negative = SingleAddrVariable::new(self.allocate_register(), 1);
+        let right_abs_value = SingleAddrVariable::new(self.allocate_register(), right.bit_size);
+
+        let result_is_negative = SingleAddrVariable::new(self.allocate_register(), 1);
+
+        // Compute both absolute values
+        self.absolute_value(left, left_abs_value, left_is_negative);
+        self.absolute_value(right, right_abs_value, right_is_negative);
+
+        // Perform the division on the absolute values
+        self.binary_instruction(
+            left_abs_value,
+            right_abs_value,
+            result,
+            BrilligBinaryOp::UnsignedDiv,
+        );
+
+        // Compute result sign
+        self.binary_instruction(
+            left_is_negative,
+            right_is_negative,
+            result_is_negative,
+            BrilligBinaryOp::Xor,
+        );
+
+        // If result has to be negative, perform two's complement
+        self.codegen_if(result_is_negative.address, |ctx| {
+            let zero = ctx.make_constant_instruction(0_usize.into(), result.bit_size);
+            ctx.binary_instruction(zero, result, result, BrilligBinaryOp::Sub);
+            ctx.deallocate_single_addr(zero);
+        });
+
+        self.deallocate_single_addr(left_is_negative);
+        self.deallocate_single_addr(left_abs_value);
+        self.deallocate_single_addr(right_is_negative);
+        self.deallocate_single_addr(right_abs_value);
+        self.deallocate_single_addr(result_is_negative);
+    }
 }
 
 /// Special brillig context to codegen compiler intrinsic shared procedures
 impl<F: AcirField + DebugToString> BrilligContext<F, ScratchSpace> {
-    pub(crate) fn new_for_procedure(enable_debug_trace: bool) -> BrilligContext<F, ScratchSpace> {
+    pub(crate) fn new_for_procedure(
+        enable_debug_trace: bool,
+        procedure_id: ProcedureId,
+    ) -> BrilligContext<F, ScratchSpace> {
+        let mut obj = BrilligArtifact::default();
+        obj.procedure = Some(procedure_id);
         BrilligContext {
-            obj: BrilligArtifact::default(),
+            obj,
             registers: ScratchSpace::new(),
             context_label: Label::entrypoint(),
             current_section: 0,
@@ -151,8 +235,8 @@ pub(crate) mod tests {
     use std::vec;
 
     use acvm::acir::brillig::{
-        BitSize, ForeignCallParam, ForeignCallResult, HeapArray, HeapVector, IntegerBitSize,
-        MemoryAddress, ValueOrArray,
+        BitSize, ForeignCallParam, ForeignCallResult, HeapVector, IntegerBitSize, MemoryAddress,
+        ValueOrArray,
     };
     use acvm::brillig_vm::brillig::HeapValueType;
     use acvm::brillig_vm::{VMStatus, VM};
@@ -169,29 +253,6 @@ pub(crate) mod tests {
     pub(crate) struct DummyBlackBoxSolver;
 
     impl BlackBoxFunctionSolver<FieldElement> for DummyBlackBoxSolver {
-        fn schnorr_verify(
-            &self,
-            _public_key_x: &FieldElement,
-            _public_key_y: &FieldElement,
-            _signature: &[u8; 64],
-            _message: &[u8],
-        ) -> Result<bool, BlackBoxResolutionError> {
-            Ok(true)
-        }
-        fn pedersen_commitment(
-            &self,
-            _inputs: &[FieldElement],
-            _domain_separator: u32,
-        ) -> Result<(FieldElement, FieldElement), BlackBoxResolutionError> {
-            Ok((2_u128.into(), 3_u128.into()))
-        }
-        fn pedersen_hash(
-            &self,
-            _inputs: &[FieldElement],
-            _domain_separator: u32,
-        ) -> Result<FieldElement, BlackBoxResolutionError> {
-            Ok(6_u128.into())
-        }
         fn multi_scalar_mul(
             &self,
             _points: &[FieldElement],
@@ -252,7 +313,8 @@ pub(crate) mod tests {
         calldata: Vec<FieldElement>,
         bytecode: &[BrilligOpcode<FieldElement>],
     ) -> (VM<'_, FieldElement, DummyBlackBoxSolver>, usize, usize) {
-        let mut vm = VM::new(calldata, bytecode, vec![], &DummyBlackBoxSolver);
+        let profiling_active = false;
+        let mut vm = VM::new(calldata, bytecode, vec![], &DummyBlackBoxSolver, profiling_active);
 
         let status = vm.process_opcodes();
         if let VMStatus::Finished { return_data_offset, return_data_size } = status {
@@ -279,10 +341,10 @@ pub(crate) mod tests {
         let r_stack = ReservedRegisters::free_memory_pointer();
         // Start stack pointer at 0
         context.usize_const_instruction(r_stack, FieldElement::from(ReservedRegisters::len() + 3));
-        let r_input_size = MemoryAddress::from(ReservedRegisters::len());
-        let r_array_ptr = MemoryAddress::from(ReservedRegisters::len() + 1);
-        let r_output_size = MemoryAddress::from(ReservedRegisters::len() + 2);
-        let r_equality = MemoryAddress::from(ReservedRegisters::len() + 3);
+        let r_input_size = MemoryAddress::direct(ReservedRegisters::len());
+        let r_array_ptr = MemoryAddress::direct(ReservedRegisters::len() + 1);
+        let r_output_size = MemoryAddress::direct(ReservedRegisters::len() + 2);
+        let r_equality = MemoryAddress::direct(ReservedRegisters::len() + 3);
         context.usize_const_instruction(r_input_size, FieldElement::from(12_usize));
         // copy our stack frame to r_array_ptr
         context.mov_instruction(r_array_ptr, r_stack);
@@ -307,10 +369,23 @@ pub(crate) mod tests {
         // We push a JumpIf and Trap opcode directly as the constrain instruction
         // uses unresolved jumps which requires a block to be constructed in SSA and
         // we don't need this for Brillig IR tests
-        context.push_opcode(BrilligOpcode::JumpIf { condition: r_equality, location: 8 });
-        context.push_opcode(BrilligOpcode::Trap { revert_data: HeapArray::default() });
+        context.push_opcode(BrilligOpcode::Const {
+            destination: MemoryAddress::direct(0),
+            bit_size: BitSize::Integer(IntegerBitSize::U32),
+            value: FieldElement::from(0u64),
+        });
+        context.push_opcode(BrilligOpcode::JumpIf { condition: r_equality, location: 9 });
+        context.push_opcode(BrilligOpcode::Trap {
+            revert_data: HeapVector {
+                pointer: MemoryAddress::direct(0),
+                size: MemoryAddress::direct(0),
+            },
+        });
 
-        context.stop_instruction();
+        context.stop_instruction(HeapVector {
+            pointer: MemoryAddress::direct(0),
+            size: MemoryAddress::direct(0),
+        });
 
         let bytecode: Vec<BrilligOpcode<FieldElement>> = context.artifact().finish().byte_code;
         let number_sequence: Vec<FieldElement> =
@@ -320,6 +395,7 @@ pub(crate) mod tests {
             &bytecode,
             vec![ForeignCallResult { values: vec![ForeignCallParam::Array(number_sequence)] }],
             &DummyBlackBoxSolver,
+            false,
         );
         let status = vm.process_opcodes();
         assert_eq!(status, VMStatus::Finished { return_data_offset: 0, return_data_size: 0 });
diff --git a/compiler/noirc_evaluator/src/brillig/brillig_ir/artifact.rs b/compiler/noirc_evaluator/src/brillig/brillig_ir/artifact.rs
index d0bd91e185c..0e5b72c0b85 100644
--- a/compiler/noirc_evaluator/src/brillig/brillig_ir/artifact.rs
+++ b/compiler/noirc_evaluator/src/brillig/brillig_ir/artifact.rs
@@ -1,8 +1,11 @@
 use acvm::acir::brillig::Opcode as BrilligOpcode;
+use acvm::acir::circuit::ErrorSelector;
 use std::collections::{BTreeMap, HashMap};
 
-use crate::brillig::brillig_ir::procedures::ProcedureId;
 use crate::ssa::ir::{basic_block::BasicBlockId, dfg::CallStack, function::FunctionId};
+use crate::ErrorType;
+
+use super::procedures::ProcedureId;
 
 /// Represents a parameter or a return value of an entry point function.
 #[derive(Debug, Clone, Eq, PartialEq, Hash, PartialOrd, Ord)]
@@ -22,8 +25,9 @@ pub(crate) enum BrilligParameter {
 pub(crate) struct GeneratedBrillig<F> {
     pub(crate) byte_code: Vec<BrilligOpcode<F>>,
     pub(crate) locations: BTreeMap<OpcodeLocation, CallStack>,
-    pub(crate) assert_messages: BTreeMap<OpcodeLocation, String>,
+    pub(crate) error_types: BTreeMap<ErrorSelector, ErrorType>,
     pub(crate) name: String,
+    pub(crate) procedure_locations: HashMap<ProcedureId, (OpcodeLocation, OpcodeLocation)>,
 }
 
 #[derive(Default, Debug, Clone)]
@@ -31,10 +35,7 @@ pub(crate) struct GeneratedBrillig<F> {
 /// It includes the bytecode of the function and all the metadata that allows linking with other functions.
 pub(crate) struct BrilligArtifact<F> {
     pub(crate) byte_code: Vec<BrilligOpcode<F>>,
-    /// A map of bytecode positions to assertion messages.
-    /// Some error messages (compiler intrinsics) are not emitted via revert data,
-    /// instead, they are handled externally so they don't add size to user programs.
-    pub(crate) assert_messages: BTreeMap<OpcodeLocation, String>,
+    pub(crate) error_types: BTreeMap<ErrorSelector, ErrorType>,
     /// The set of jumps that need to have their locations
     /// resolved.
     unresolved_jumps: Vec<(JumpInstructionPosition, UnresolvedJumpLocation)>,
@@ -53,12 +54,20 @@ pub(crate) struct BrilligArtifact<F> {
     call_stack: CallStack,
     /// Name of the function, only used for debugging purposes.
     pub(crate) name: String,
+
+    /// This field contains the given procedure id if this artifact originates from as procedure
+    pub(crate) procedure: Option<ProcedureId>,
+    /// Procedure ID mapped to the range of its opcode locations
+    /// This is created as artifacts are linked together and allows us to determine
+    /// which opcodes originate from reusable procedures.s
+    /// The range is inclusive for both start and end opcode locations.
+    pub(crate) procedure_locations: HashMap<ProcedureId, (OpcodeLocation, OpcodeLocation)>,
 }
 
 /// A pointer to a location in the opcode.
 pub(crate) type OpcodeLocation = usize;
 
-#[derive(Debug, Clone, Copy, Eq, PartialEq, Hash)]
+#[derive(Debug, Clone, Eq, PartialEq, Hash)]
 pub(crate) enum LabelType {
     /// Labels for the entry point bytecode
     Entrypoint,
@@ -88,7 +97,7 @@ impl std::fmt::Display for LabelType {
 ///
 /// It is assumed that an entity will keep a map
 /// of labels to Opcode locations.
-#[derive(Debug, Clone, Copy, Eq, PartialEq, Hash)]
+#[derive(Debug, Clone, Eq, PartialEq, Hash)]
 pub(crate) struct Label {
     pub(crate) label_type: LabelType,
     pub(crate) section: Option<usize>,
@@ -96,7 +105,7 @@ pub(crate) struct Label {
 
 impl Label {
     pub(crate) fn add_section(&self, section: usize) -> Self {
-        Label { label_type: self.label_type, section: Some(section) }
+        Label { label_type: self.label_type.clone(), section: Some(section) }
     }
 
     pub(crate) fn function(func_id: FunctionId) -> Self {
@@ -147,14 +156,15 @@ impl<F: Clone + std::fmt::Debug> BrilligArtifact<F> {
         GeneratedBrillig {
             byte_code: self.byte_code,
             locations: self.locations,
-            assert_messages: self.assert_messages,
+            error_types: self.error_types,
             name: self.name,
+            procedure_locations: self.procedure_locations,
         }
     }
 
     /// Gets the first unresolved function call of this artifact.
     pub(crate) fn first_unresolved_function_call(&self) -> Option<Label> {
-        self.unresolved_external_call_labels.first().map(|(_, label)| *label)
+        self.unresolved_external_call_labels.first().map(|(_, label)| label.clone())
     }
 
     /// Link with an external brillig artifact called from this artifact.
@@ -166,17 +176,11 @@ impl<F: Clone + std::fmt::Debug> BrilligArtifact<F> {
         // Add the unresolved jumps of the linked function to this artifact.
         self.add_unresolved_jumps_and_calls(obj);
 
-        let mut byte_code = obj.byte_code.clone();
-
-        // Replace STOP with RETURN because this is not the end of the program now.
-        let stop_position = byte_code
-            .iter()
-            .position(|opcode| matches!(opcode, BrilligOpcode::Stop { .. }))
-            .expect("Trying to link with a function that does not have a stop opcode");
-
-        byte_code[stop_position] = BrilligOpcode::Return;
+        for (error_selector, error_type) in &obj.error_types {
+            self.error_types.insert(*error_selector, error_type.clone());
+        }
 
-        self.byte_code.append(&mut byte_code);
+        self.byte_code.append(&mut obj.byte_code.clone());
 
         // Remove all resolved external calls and transform them to jumps
         let is_resolved = |label: &Label| self.labels.contains_key(label);
@@ -199,20 +203,17 @@ impl<F: Clone + std::fmt::Debug> BrilligArtifact<F> {
     fn add_unresolved_jumps_and_calls(&mut self, obj: &BrilligArtifact<F>) {
         let offset = self.index_of_next_opcode();
         for (jump_label, jump_location) in &obj.unresolved_jumps {
-            self.unresolved_jumps.push((jump_label + offset, *jump_location));
+            self.unresolved_jumps.push((jump_label + offset, jump_location.clone()));
         }
 
         for (label_id, position_in_bytecode) in &obj.labels {
-            let old_value = self.labels.insert(*label_id, position_in_bytecode + offset);
+            let old_value = self.labels.insert(label_id.clone(), position_in_bytecode + offset);
             assert!(old_value.is_none(), "overwriting label {label_id} {old_value:?}");
         }
 
         for (position_in_bytecode, label_id) in &obj.unresolved_external_call_labels {
-            self.unresolved_external_call_labels.push((position_in_bytecode + offset, *label_id));
-        }
-
-        for (position_in_bytecode, message) in &obj.assert_messages {
-            self.assert_messages.insert(position_in_bytecode + offset, message.clone());
+            self.unresolved_external_call_labels
+                .push((position_in_bytecode + offset, label_id.clone()));
         }
 
         for (position_in_bytecode, call_stack) in obj.locations.iter() {
@@ -267,7 +268,7 @@ impl<F: Clone + std::fmt::Debug> BrilligArtifact<F> {
     /// Adds a label in the bytecode to specify where this block's
     /// opcodes will start.
     pub(crate) fn add_label_at_position(&mut self, label: Label, position: OpcodeLocation) {
-        let old_value = self.labels.insert(label, position);
+        let old_value = self.labels.insert(label.clone(), position);
         assert!(
             old_value.is_none(),
             "overwriting label {label}. old_value = {old_value:?}, new_value = {position}"
@@ -326,9 +327,4 @@ impl<F: Clone + std::fmt::Debug> BrilligArtifact<F> {
     pub(crate) fn set_call_stack(&mut self, call_stack: CallStack) {
         self.call_stack = call_stack;
     }
-
-    pub(crate) fn add_assert_message_to_last_opcode(&mut self, message: String) {
-        let position = self.index_of_next_opcode() - 1;
-        self.assert_messages.insert(position, message);
-    }
 }
diff --git a/compiler/noirc_evaluator/src/brillig/brillig_ir/brillig_variable.rs b/compiler/noirc_evaluator/src/brillig/brillig_ir/brillig_variable.rs
index 81d61e05cc4..0bb18448670 100644
--- a/compiler/noirc_evaluator/src/brillig/brillig_ir/brillig_variable.rs
+++ b/compiler/noirc_evaluator/src/brillig/brillig_ir/brillig_variable.rs
@@ -88,7 +88,7 @@ pub(crate) fn type_to_heap_value_type(typ: &Type) -> HeapValueType {
         ),
         Type::Array(elem_type, size) => HeapValueType::Array {
             value_types: elem_type.as_ref().iter().map(type_to_heap_value_type).collect(),
-            size: typ.element_size() * size,
+            size: typ.element_size() * *size as usize,
         },
         Type::Slice(elem_type) => HeapValueType::Vector {
             value_types: elem_type.as_ref().iter().map(type_to_heap_value_type).collect(),
diff --git a/compiler/noirc_evaluator/src/brillig/brillig_ir/codegen_calls.rs b/compiler/noirc_evaluator/src/brillig/brillig_ir/codegen_calls.rs
index 185a6a08a04..da310873cff 100644
--- a/compiler/noirc_evaluator/src/brillig/brillig_ir/codegen_calls.rs
+++ b/compiler/noirc_evaluator/src/brillig/brillig_ir/codegen_calls.rs
@@ -1,105 +1,78 @@
 use acvm::{acir::brillig::MemoryAddress, AcirField};
 
+use crate::ssa::ir::function::FunctionId;
+
 use super::{
-    brillig_variable::BrilligVariable, debug_show::DebugToString, registers::RegisterAllocator,
+    brillig_variable::{BrilligVariable, SingleAddrVariable},
+    debug_show::DebugToString,
+    registers::{RegisterAllocator, Stack},
     BrilligBinaryOp, BrilligContext, ReservedRegisters,
 };
 
-impl<F: AcirField + DebugToString, Registers: RegisterAllocator> BrilligContext<F, Registers> {
-    /// Saves all of the registers that have been used up until this point.
-    fn codegen_save_registers_of_vars(&mut self, vars: &[BrilligVariable]) -> Vec<MemoryAddress> {
-        // Save all of the used registers at this point in memory
-        // because the function call will/may overwrite them.
-        //
-        // Note that here it is important that the stack pointer register is at register 0,
-        // as after the first register save we add to the pointer.
-        let mut used_registers: Vec<_> = vars.iter().map(|var| var.extract_register()).collect();
-
-        // Also dump the previous stack pointer
-        used_registers.push(ReservedRegisters::previous_stack_pointer());
-        for register in used_registers.iter() {
-            self.store_instruction(ReservedRegisters::free_memory_pointer(), *register);
-            // Add one to our stack pointer
-            self.codegen_usize_op_in_place(
-                ReservedRegisters::free_memory_pointer(),
-                BrilligBinaryOp::Add,
-                1,
+impl<F: AcirField + DebugToString> BrilligContext<F, Stack> {
+    pub(crate) fn codegen_call(
+        &mut self,
+        func_id: FunctionId,
+        arguments: &[BrilligVariable],
+        returns: &[BrilligVariable],
+    ) {
+        let stack_size_register = SingleAddrVariable::new_usize(self.allocate_register());
+        let previous_stack_pointer = self.registers.empty_stack_start();
+        let stack_size = previous_stack_pointer.unwrap_relative();
+        // Write the stack size
+        self.const_instruction(stack_size_register, stack_size.into());
+        // Pass the previous stack pointer
+        self.mov_instruction(previous_stack_pointer, ReservedRegisters::stack_pointer());
+        // Pass the arguments
+        let mut current_argument_location = stack_size + 1;
+        for item in arguments {
+            self.mov_instruction(
+                MemoryAddress::relative(current_argument_location),
+                item.extract_register(),
             );
+            current_argument_location += 1;
         }
-
-        // Store the location of our registers in the previous stack pointer
-        self.mov_instruction(
-            ReservedRegisters::previous_stack_pointer(),
-            ReservedRegisters::free_memory_pointer(),
+        // Increment the stack pointer
+        self.memory_op_instruction(
+            ReservedRegisters::stack_pointer(),
+            stack_size_register.address,
+            ReservedRegisters::stack_pointer(),
+            BrilligBinaryOp::Add,
         );
-        used_registers
-    }
 
-    /// Loads all of the registers that have been save by save_all_used_registers.
-    fn codegen_load_all_saved_registers(&mut self, used_registers: &[MemoryAddress]) {
-        // Load all of the used registers that we saved.
-        // We do all the reverse operations of save_all_used_registers.
-        // Iterate our registers in reverse
-        let iterator_register = self.allocate_register();
-        self.mov_instruction(iterator_register, ReservedRegisters::previous_stack_pointer());
+        self.add_external_call_instruction(func_id);
+
+        // Restore the stack pointer
+        self.mov_instruction(ReservedRegisters::stack_pointer(), MemoryAddress::relative(0));
 
-        for register in used_registers.iter().rev() {
-            // Subtract one from our stack pointer
-            self.codegen_usize_op_in_place(iterator_register, BrilligBinaryOp::Sub, 1);
-            self.load_instruction(*register, iterator_register);
+        // Move the return values back
+        let mut current_return_location = stack_size + 1;
+        for item in returns {
+            self.mov_instruction(
+                item.extract_register(),
+                MemoryAddress::relative(current_return_location),
+            );
+            current_return_location += 1;
         }
+        self.deallocate_single_addr(stack_size_register);
     }
 
-    // Used before a call instruction.
-    // Save all the registers we have used to the stack.
-    // Move argument values to the front of the register indices.
-    pub(crate) fn codegen_pre_call_save_registers_prep_args(
-        &mut self,
-        arguments: &[MemoryAddress],
-        variables_to_save: &[BrilligVariable],
-    ) -> Vec<MemoryAddress> {
-        // Save all the registers we have used to the stack.
-        let saved_registers = self.codegen_save_registers_of_vars(variables_to_save);
+    /// Codegens a return from the current function.
+    pub(crate) fn codegen_return(&mut self, return_registers: &[MemoryAddress]) {
+        let mut sources = Vec::with_capacity(return_registers.len());
+        let mut destinations = Vec::with_capacity(return_registers.len());
 
-        // Move argument values to the front of the registers
-        //
-        // This means that the arguments will be in the first `n` registers after
-        // the number of reserved registers.
-        let (sources, destinations): (Vec<_>, Vec<_>) = arguments
-            .iter()
-            .enumerate()
-            .map(|(i, argument)| (*argument, self.stack_register(i)))
-            .unzip();
+        for (destination_index, return_register) in return_registers.iter().enumerate() {
+            // In case we have fewer return registers than indices to write to, ensure we've allocated this register
+            let destination_register = MemoryAddress::relative(Stack::start() + destination_index);
+            self.registers.ensure_register_is_allocated(destination_register);
+            sources.push(*return_register);
+            destinations.push(destination_register);
+        }
         destinations
             .iter()
             .for_each(|destination| self.registers.ensure_register_is_allocated(*destination));
         self.codegen_mov_registers_to_registers(sources, destinations);
-        saved_registers
-    }
-
-    // Used after a call instruction.
-    // Move return values to the front of the register indices.
-    // Load all the registers we have previous saved in save_registers_prep_args.
-    pub(crate) fn codegen_post_call_prep_returns_load_registers(
-        &mut self,
-        result_registers: &[MemoryAddress],
-        saved_registers: &[MemoryAddress],
-    ) {
-        // Allocate our result registers and write into them
-        // We assume the return values of our call are held in 0..num results register indices
-        let (sources, destinations): (Vec<_>, Vec<_>) = result_registers
-            .iter()
-            .enumerate()
-            .map(|(i, result_register)| (self.stack_register(i), *result_register))
-            .unzip();
-        sources.iter().for_each(|source| self.registers.ensure_register_is_allocated(*source));
-        self.codegen_mov_registers_to_registers(sources, destinations);
-
-        // Restore all the same registers we have, in exact reverse order.
-        // Note that we have allocated some registers above, which we will not be handling here,
-        // only restoring registers that were used prior to the call finishing.
-        // After the call instruction, the stack frame pointer should be back to where we left off,
-        // so we do our instructions in reverse order.
-        self.codegen_load_all_saved_registers(saved_registers);
+        self.return_instruction();
     }
 }
diff --git a/compiler/noirc_evaluator/src/brillig/brillig_ir/codegen_control_flow.rs b/compiler/noirc_evaluator/src/brillig/brillig_ir/codegen_control_flow.rs
index e5b57293d1e..9512a60e699 100644
--- a/compiler/noirc_evaluator/src/brillig/brillig_ir/codegen_control_flow.rs
+++ b/compiler/noirc_evaluator/src/brillig/brillig_ir/codegen_control_flow.rs
@@ -1,17 +1,57 @@
 use acvm::{
-    acir::brillig::{HeapArray, MemoryAddress},
+    acir::{
+        brillig::{HeapVector, MemoryAddress},
+        circuit::ErrorSelector,
+    },
     AcirField,
 };
 
+use crate::ssa::ir::instruction::ErrorType;
+
 use super::{
     artifact::BrilligParameter,
     brillig_variable::{BrilligArray, BrilligVariable, SingleAddrVariable},
     debug_show::DebugToString,
-    registers::{RegisterAllocator, Stack},
+    registers::RegisterAllocator,
     BrilligBinaryOp, BrilligContext, ReservedRegisters,
 };
 
 impl<F: AcirField + DebugToString, Registers: RegisterAllocator> BrilligContext<F, Registers> {
+    pub(crate) fn codegen_generic_iteration<T>(
+        &mut self,
+        make_iterator: impl FnOnce(&mut BrilligContext<F, Registers>) -> T,
+        update_iterator: impl FnOnce(&mut BrilligContext<F, Registers>, &T),
+        make_finish_condition: impl FnOnce(&mut BrilligContext<F, Registers>, &T) -> SingleAddrVariable,
+        on_iteration: impl FnOnce(&mut BrilligContext<F, Registers>, &T),
+        clean_iterator: impl FnOnce(&mut BrilligContext<F, Registers>, T),
+    ) {
+        let iterator = make_iterator(self);
+
+        let (loop_section, loop_label) = self.reserve_next_section_label();
+        self.enter_section(loop_section);
+
+        // Loop body
+        let should_end = make_finish_condition(self, &iterator);
+
+        let (exit_loop_section, exit_loop_label) = self.reserve_next_section_label();
+
+        self.jump_if_instruction(should_end.address, exit_loop_label);
+
+        // Call the on iteration function
+        on_iteration(self, &iterator);
+
+        // Update iterator
+        update_iterator(self, &iterator);
+        self.jump_instruction(loop_label);
+
+        // Exit the loop
+        self.enter_section(exit_loop_section);
+
+        // Deallocate our temporary registers
+        self.deallocate_single_addr(should_end);
+        clean_iterator(self, iterator);
+    }
+
     /// This codegen will issue a loop for (let iterator_register = loop_start; i < loop_bound; i += step)
     /// The body of the loop should be issued by the caller in the on_iteration closure.
     pub(crate) fn codegen_for_loop(
@@ -103,7 +143,7 @@ impl<F: AcirField + DebugToString, Registers: RegisterAllocator> BrilligContext<
 
         self.enter_section(then_section);
         f(self, true);
-        self.jump_instruction(end_label);
+        self.jump_instruction(end_label.clone());
 
         self.enter_section(otherwise_section);
         f(self, false);
@@ -152,24 +192,24 @@ impl<F: AcirField + DebugToString, Registers: RegisterAllocator> BrilligContext<
         condition: SingleAddrVariable,
         revert_data_items: Vec<BrilligVariable>,
         revert_data_types: Vec<BrilligParameter>,
-        error_selector: u64,
+        error_selector: ErrorSelector,
     ) {
         assert!(condition.bit_size == 1);
 
         self.codegen_if_not(condition.address, |ctx| {
-            let revert_data = HeapArray {
-                pointer: ctx.allocate_register(),
-                // + 1 due to the revert data id being the first item returned
-                size: Self::flattened_tuple_size(&revert_data_types) + 1,
-            };
-            ctx.codegen_allocate_immediate_mem(revert_data.pointer, revert_data.size);
+            // + 1 due to the revert data id being the first item returned
+            let revert_data_size = Self::flattened_tuple_size(&revert_data_types) + 1;
+            let revert_data_size_var = ctx.make_usize_constant_instruction(revert_data_size.into());
+            let revert_data =
+                HeapVector { pointer: ctx.allocate_register(), size: revert_data_size_var.address };
+            ctx.codegen_allocate_immediate_mem(revert_data.pointer, revert_data_size);
 
             let current_revert_data_pointer = ctx.allocate_register();
             ctx.mov_instruction(current_revert_data_pointer, revert_data.pointer);
             ctx.indirect_const_instruction(
                 current_revert_data_pointer,
                 64,
-                (error_selector as u128).into(),
+                (error_selector.as_u64() as u128).into(),
             );
 
             ctx.codegen_usize_op_in_place(current_revert_data_pointer, BrilligBinaryOp::Add, 1);
@@ -208,6 +248,7 @@ impl<F: AcirField + DebugToString, Registers: RegisterAllocator> BrilligContext<
                 );
             }
             ctx.trap_instruction(revert_data);
+            ctx.deallocate_single_addr(revert_data_size_var);
             ctx.deallocate_register(revert_data.pointer);
             ctx.deallocate_register(current_revert_data_pointer);
         });
@@ -223,13 +264,38 @@ impl<F: AcirField + DebugToString, Registers: RegisterAllocator> BrilligContext<
         assert!(condition.bit_size == 1);
 
         self.codegen_if_not(condition.address, |ctx| {
-            ctx.trap_instruction(HeapArray::default());
             if let Some(assert_message) = assert_message {
-                ctx.obj.add_assert_message_to_last_opcode(assert_message);
-            }
+                ctx.revert_with_string(assert_message);
+            } else {
+                let revert_data = HeapVector {
+                    pointer: ReservedRegisters::free_memory_pointer(),
+                    size: ctx.make_usize_constant_instruction(0_usize.into()).address,
+                };
+                ctx.trap_instruction(revert_data);
+                ctx.deallocate_register(revert_data.size);
+            };
         });
     }
 
+    pub(super) fn revert_with_string(&mut self, revert_string: String) {
+        if self.can_call_procedures {
+            self.call_revert_with_string_procedure(revert_string);
+        } else {
+            let error_type = ErrorType::String(revert_string);
+            let error_selector = error_type.selector();
+            self.obj.error_types.insert(error_selector, error_type);
+            self.indirect_const_instruction(
+                ReservedRegisters::free_memory_pointer(),
+                64,
+                (error_selector.as_u64() as u128).into(),
+            );
+            self.trap_instruction(HeapVector {
+                pointer: ReservedRegisters::free_memory_pointer(),
+                size: ReservedRegisters::usize_one(),
+            });
+        }
+    }
+
     /// Computes the size of a parameter if it was flattened
     pub(super) fn flattened_size(param: &BrilligParameter) -> usize {
         match param {
@@ -349,32 +415,3 @@ impl<F: AcirField + DebugToString, Registers: RegisterAllocator> BrilligContext<
         }
     }
 }
-
-impl<F: AcirField + DebugToString> BrilligContext<F, Stack> {
-    /// Codegens a return from the current function.
-    ///
-    /// For Brillig, the return is implicit, since there is no explicit return instruction.
-    /// The caller will take `N` values from the Register starting at register index 0.
-    /// `N` indicates the number of return values expected.
-    ///
-    /// Brillig does not have an explicit return instruction, so this
-    /// method will move all register values to the first `N` values in
-    /// the VM.
-    pub(crate) fn codegen_return(&mut self, return_registers: &[MemoryAddress]) {
-        let mut sources = Vec::with_capacity(return_registers.len());
-        let mut destinations = Vec::with_capacity(return_registers.len());
-
-        for (destination_index, return_register) in return_registers.iter().enumerate() {
-            // In case we have fewer return registers than indices to write to, ensure we've allocated this register
-            let destination_register = MemoryAddress(Stack::start() + destination_index);
-            self.registers.ensure_register_is_allocated(destination_register);
-            sources.push(*return_register);
-            destinations.push(destination_register);
-        }
-        destinations
-            .iter()
-            .for_each(|destination| self.registers.ensure_register_is_allocated(*destination));
-        self.codegen_mov_registers_to_registers(sources, destinations);
-        self.stop_instruction();
-    }
-}
diff --git a/compiler/noirc_evaluator/src/brillig/brillig_ir/codegen_intrinsic.rs b/compiler/noirc_evaluator/src/brillig/brillig_ir/codegen_intrinsic.rs
index 5f4781788f5..ba89823ef13 100644
--- a/compiler/noirc_evaluator/src/brillig/brillig_ir/codegen_intrinsic.rs
+++ b/compiler/noirc_evaluator/src/brillig/brillig_ir/codegen_intrinsic.rs
@@ -69,7 +69,7 @@ impl<F: AcirField + DebugToString, Registers: RegisterAllocator> BrilligContext<
         source_field: SingleAddrVariable,
         target_array: BrilligArray,
         radix: SingleAddrVariable,
-        big_endian: bool,
+        little_endian: bool,
         output_bits: bool, // If true will generate bit limbs, if false will generate byte limbs
     ) {
         assert!(source_field.bit_size == F::max_num_bits());
@@ -79,6 +79,7 @@ impl<F: AcirField + DebugToString, Registers: RegisterAllocator> BrilligContext<
 
         let heap_array = self.codegen_brillig_array_to_heap_array(target_array);
 
+        // Perform big-endian ToRadix
         self.black_box_op_instruction(BlackBoxOp::ToRadix {
             input: source_field.address,
             radix: radix.address,
@@ -86,7 +87,7 @@ impl<F: AcirField + DebugToString, Registers: RegisterAllocator> BrilligContext<
             output_bits,
         });
 
-        if big_endian {
+        if little_endian {
             let items_len = self.make_usize_constant_instruction(target_array.size.into());
             self.codegen_array_reverse(heap_array.pointer, items_len.address);
             self.deallocate_single_addr(items_len);
diff --git a/compiler/noirc_evaluator/src/brillig/brillig_ir/codegen_memory.rs b/compiler/noirc_evaluator/src/brillig/brillig_ir/codegen_memory.rs
index 0199d9537a6..a34034bb550 100644
--- a/compiler/noirc_evaluator/src/brillig/brillig_ir/codegen_memory.rs
+++ b/compiler/noirc_evaluator/src/brillig/brillig_ir/codegen_memory.rs
@@ -93,16 +93,125 @@ impl<F: AcirField + DebugToString, Registers: RegisterAllocator> BrilligContext<
             );
         } else {
             let value_register = self.allocate_register();
+            let end_source_pointer = self.allocate_register();
+            self.memory_op_instruction(
+                source_pointer,
+                num_elements_variable.address,
+                end_source_pointer,
+                BrilligBinaryOp::Add,
+            );
 
-            self.codegen_loop(num_elements_variable.address, |ctx, iterator| {
-                ctx.codegen_load_with_offset(source_pointer, iterator, value_register);
-                ctx.codegen_store_with_offset(destination_pointer, iterator, value_register);
-            });
-
+            self.codegen_generic_iteration(
+                |brillig_context| {
+                    let source_iterator = brillig_context.allocate_register();
+                    let target_iterator = brillig_context.allocate_register();
+
+                    brillig_context.mov_instruction(source_iterator, source_pointer);
+                    brillig_context.mov_instruction(target_iterator, destination_pointer);
+
+                    (source_iterator, target_iterator)
+                },
+                |brillig_context, &(source_iterator, target_iterator)| {
+                    brillig_context.codegen_usize_op_in_place(
+                        source_iterator,
+                        BrilligBinaryOp::Add,
+                        1,
+                    );
+                    brillig_context.codegen_usize_op_in_place(
+                        target_iterator,
+                        BrilligBinaryOp::Add,
+                        1,
+                    );
+                },
+                |brillig_context, &(source_iterator, _)| {
+                    // We have finished when the source/target pointer is less than the source/target start
+                    let finish_condition =
+                        SingleAddrVariable::new(brillig_context.allocate_register(), 1);
+                    brillig_context.memory_op_instruction(
+                        source_iterator,
+                        end_source_pointer,
+                        finish_condition.address,
+                        BrilligBinaryOp::Equals,
+                    );
+                    finish_condition
+                },
+                |brillig_context, &(source_iterator, target_iterator)| {
+                    brillig_context.load_instruction(value_register, source_iterator);
+                    brillig_context.store_instruction(target_iterator, value_register);
+                },
+                |brillig_context, (source_iterator, target_iterator)| {
+                    brillig_context.deallocate_register(source_iterator);
+                    brillig_context.deallocate_register(target_iterator);
+                },
+            );
             self.deallocate_register(value_register);
+            self.deallocate_register(end_source_pointer);
         }
     }
 
+    /// Copies num_elements_variable from the source pointer to the target pointer, starting from the end
+    pub(crate) fn codegen_mem_copy_from_the_end(
+        &mut self,
+        source_start: MemoryAddress,
+        target_start: MemoryAddress,
+        num_elements_variable: SingleAddrVariable,
+    ) {
+        self.codegen_generic_iteration(
+            |brillig_context| {
+                // Create the pointer to the last item for both source and target
+                let num_items_minus_one = brillig_context.allocate_register();
+                brillig_context.codegen_usize_op(
+                    num_elements_variable.address,
+                    num_items_minus_one,
+                    BrilligBinaryOp::Sub,
+                    1,
+                );
+                let target_pointer = brillig_context.allocate_register();
+                brillig_context.memory_op_instruction(
+                    target_start,
+                    num_items_minus_one,
+                    target_pointer,
+                    BrilligBinaryOp::Add,
+                );
+                let source_pointer = brillig_context.allocate_register();
+                brillig_context.memory_op_instruction(
+                    source_start,
+                    num_items_minus_one,
+                    source_pointer,
+                    BrilligBinaryOp::Add,
+                );
+                brillig_context.deallocate_register(num_items_minus_one);
+                (source_pointer, target_pointer)
+            },
+            |brillig_context, &(source_pointer, target_pointer)| {
+                brillig_context.codegen_usize_op_in_place(source_pointer, BrilligBinaryOp::Sub, 1);
+                brillig_context.codegen_usize_op_in_place(target_pointer, BrilligBinaryOp::Sub, 1);
+            },
+            |brillig_context, &(source_pointer, _)| {
+                // We have finished when the source/target pointer is less than the source/target start
+                let finish_condition =
+                    SingleAddrVariable::new(brillig_context.allocate_register(), 1);
+                brillig_context.memory_op_instruction(
+                    source_pointer,
+                    source_start,
+                    finish_condition.address,
+                    BrilligBinaryOp::LessThan,
+                );
+                finish_condition
+            },
+            |brillig_context, &(source_pointer, target_pointer)| {
+                let value_register = brillig_context.allocate_register();
+                brillig_context.load_instruction(value_register, source_pointer);
+                brillig_context.store_instruction(target_pointer, value_register);
+                brillig_context.deallocate_register(value_register);
+            },
+            |brillig_context, (source_pointer, target_pointer)| {
+                brillig_context.deallocate_register(source_pointer);
+                brillig_context.deallocate_register(target_pointer);
+            },
+        );
+    }
+
     /// This instruction will reverse the order of the `size` elements pointed by `pointer`.
     pub(crate) fn codegen_array_reverse(
         &mut self,
@@ -170,7 +279,7 @@ impl<F: AcirField + DebugToString, Registers: RegisterAllocator> BrilligContext<
         self.codegen_usize_op(vector.pointer, current_pointer, BrilligBinaryOp::Add, 1);
         self.load_instruction(heap_vector.size, current_pointer);
         // Now prepare the pointer to the items
-        self.codegen_usize_op(current_pointer, heap_vector.pointer, BrilligBinaryOp::Add, 1);
+        self.codegen_usize_op(current_pointer, heap_vector.pointer, BrilligBinaryOp::Add, 2);
 
         self.deallocate_register(current_pointer);
         heap_vector
@@ -201,16 +310,73 @@ impl<F: AcirField + DebugToString, Registers: RegisterAllocator> BrilligContext<
         result
     }
 
+    pub(crate) fn codegen_update_vector_length(
+        &mut self,
+        vector: BrilligVector,
+        new_length: SingleAddrVariable,
+    ) {
+        let write_pointer = self.allocate_register();
+        self.codegen_usize_op(vector.pointer, write_pointer, BrilligBinaryOp::Add, 1);
+        self.store_instruction(write_pointer, new_length.address);
+        self.deallocate_register(write_pointer);
+    }
+
+    /// Returns a variable holding the capacity of a given vector
+    pub(crate) fn codegen_make_vector_capacity(
+        &mut self,
+        vector: BrilligVector,
+    ) -> SingleAddrVariable {
+        let result = SingleAddrVariable::new_usize(self.allocate_register());
+        self.codegen_usize_op(vector.pointer, result.address, BrilligBinaryOp::Add, 2);
+        self.load_instruction(result.address, result.address);
+        result
+    }
+
+    /// Writes a pointer to the items of a given vector
+    pub(crate) fn codegen_vector_items_pointer(
+        &mut self,
+        vector: BrilligVector,
+        result: MemoryAddress,
+    ) {
+        self.codegen_usize_op(vector.pointer, result, BrilligBinaryOp::Add, 3);
+    }
+
     /// Returns a pointer to the items of a given vector
     pub(crate) fn codegen_make_vector_items_pointer(
         &mut self,
         vector: BrilligVector,
     ) -> MemoryAddress {
         let result = self.allocate_register();
-        self.codegen_usize_op(vector.pointer, result, BrilligBinaryOp::Add, 2);
+        self.codegen_vector_items_pointer(vector, result);
         result
     }
 
+    /// Reads the metadata of a vector and stores it in the given variables
+    pub(crate) fn codegen_read_vector_metadata(
+        &mut self,
+        vector: BrilligVector,
+        rc: SingleAddrVariable,
+        size: SingleAddrVariable,
+        capacity: SingleAddrVariable,
+        items_pointer: SingleAddrVariable,
+    ) {
+        assert!(rc.bit_size == BRILLIG_MEMORY_ADDRESSING_BIT_SIZE);
+        assert!(size.bit_size == BRILLIG_MEMORY_ADDRESSING_BIT_SIZE);
+        assert!(capacity.bit_size == BRILLIG_MEMORY_ADDRESSING_BIT_SIZE);
+        assert!(items_pointer.bit_size == BRILLIG_MEMORY_ADDRESSING_BIT_SIZE);
+
+        self.load_instruction(rc.address, vector.pointer);
+
+        let read_pointer = self.allocate_register();
+        self.codegen_usize_op(vector.pointer, read_pointer, BrilligBinaryOp::Add, 1);
+        self.load_instruction(size.address, read_pointer);
+        self.codegen_usize_op_in_place(read_pointer, BrilligBinaryOp::Add, 1);
+        self.load_instruction(capacity.address, read_pointer);
+        self.codegen_usize_op(read_pointer, items_pointer.address, BrilligBinaryOp::Add, 1);
+
+        self.deallocate_register(read_pointer);
+    }
+
     /// Returns a variable holding the length of a given array
     pub(crate) fn codegen_make_array_length(&mut self, array: BrilligArray) -> SingleAddrVariable {
         let result = SingleAddrVariable::new_usize(self.allocate_register());
@@ -262,28 +428,88 @@ impl<F: AcirField + DebugToString, Registers: RegisterAllocator> BrilligContext<
         );
     }
 
-    /// Initializes a vector, allocating memory to store its representation and initializing the reference counter and size.
+    pub(crate) fn codegen_initialize_vector_metadata(
+        &mut self,
+        vector: BrilligVector,
+        size: SingleAddrVariable,
+        capacity: Option<SingleAddrVariable>,
+    ) {
+        // Write RC
+        self.indirect_const_instruction(
+            vector.pointer,
+            BRILLIG_MEMORY_ADDRESSING_BIT_SIZE,
+            1_usize.into(),
+        );
+
+        // Write size
+        let write_pointer = self.allocate_register();
+        self.codegen_usize_op(vector.pointer, write_pointer, BrilligBinaryOp::Add, 1);
+        self.store_instruction(write_pointer, size.address);
+
+        // Write capacity
+        self.codegen_usize_op_in_place(write_pointer, BrilligBinaryOp::Add, 1);
+        self.store_instruction(write_pointer, capacity.unwrap_or(size).address);
+
+        self.deallocate_register(write_pointer);
+    }
+
+    /// Initializes a vector, allocating memory to store its representation and initializing the reference counter, size and capacity
     pub(crate) fn codegen_initialize_vector(
         &mut self,
         vector: BrilligVector,
         size: SingleAddrVariable,
+        capacity: Option<SingleAddrVariable>, // Defaults to size if None
     ) {
         let allocation_size = self.allocate_register();
-        self.codegen_usize_op(size.address, allocation_size, BrilligBinaryOp::Add, 2);
+        // Allocation size = capacity + 3 (rc, size, capacity)
+        self.codegen_usize_op(
+            capacity.unwrap_or(size).address,
+            allocation_size,
+            BrilligBinaryOp::Add,
+            3,
+        );
         self.codegen_allocate_mem(vector.pointer, allocation_size);
         self.deallocate_register(allocation_size);
 
-        // Write RC
+        self.codegen_initialize_vector_metadata(vector, size, capacity);
+    }
+
+    /// We don't know the length of a vector returned externally before the call
+    /// so we pass the free memory pointer and then use this function to allocate
+    /// after the fact when we know the length.
+    pub(crate) fn initialize_externally_returned_vector(
+        &mut self,
+        vector: BrilligVector,
+        resulting_heap_vector: HeapVector,
+    ) {
+        let total_size = self.allocate_register();
+        self.codegen_usize_op(
+            resulting_heap_vector.size,
+            total_size,
+            BrilligBinaryOp::Add,
+            3, // Rc, length and capacity
+        );
+
+        self.increase_free_memory_pointer_instruction(total_size);
+        let write_pointer = self.allocate_register();
+
+        // Vectors are [RC, Size, Capacity, ...items]
+        // Initialize RC
         self.indirect_const_instruction(
             vector.pointer,
             BRILLIG_MEMORY_ADDRESSING_BIT_SIZE,
             1_usize.into(),
         );
 
-        // Write size
-        let len_write_pointer = self.allocate_register();
-        self.codegen_usize_op(vector.pointer, len_write_pointer, BrilligBinaryOp::Add, 1);
-        self.store_instruction(len_write_pointer, size.address);
-        self.deallocate_register(len_write_pointer);
+        // Initialize size
+        self.codegen_usize_op(vector.pointer, write_pointer, BrilligBinaryOp::Add, 1_usize);
+        self.store_instruction(write_pointer, resulting_heap_vector.size);
+
+        // Initialize capacity
+        self.codegen_usize_op_in_place(write_pointer, BrilligBinaryOp::Add, 1_usize);
+        self.store_instruction(write_pointer, resulting_heap_vector.size);
+
+        self.deallocate_register(write_pointer);
+        self.deallocate_register(total_size);
     }
 }
diff --git a/compiler/noirc_evaluator/src/brillig/brillig_ir/codegen_stack.rs b/compiler/noirc_evaluator/src/brillig/brillig_ir/codegen_stack.rs
index b7b25c6db49..599c05fc0e8 100644
--- a/compiler/noirc_evaluator/src/brillig/brillig_ir/codegen_stack.rs
+++ b/compiler/noirc_evaluator/src/brillig/brillig_ir/codegen_stack.rs
@@ -47,6 +47,7 @@ impl<F: AcirField + DebugToString, Registers: RegisterAllocator> BrilligContext<
             let destinations_of_temp = movements_map.remove(first_source).unwrap();
             movements_map.insert(temp_register, destinations_of_temp);
         }
+
         // After removing loops we should have an DAG with each node having only one ancestor (but could have multiple successors)
         // Now we should be able to move the registers just by performing a DFS on the movements map
         let heads: Vec<_> = movements_map
@@ -54,6 +55,7 @@ impl<F: AcirField + DebugToString, Registers: RegisterAllocator> BrilligContext<
             .filter(|source| !destinations_set.contains(source))
             .copied()
             .collect();
+
         for head in heads {
             self.perform_movements(&movements_map, head);
         }
@@ -140,7 +142,9 @@ mod tests {
         movements: Vec<(usize, usize)>,
     ) -> HashMap<MemoryAddress, HashSet<MemoryAddress>> {
         movements.into_iter().fold(HashMap::default(), |mut map, (source, destination)| {
-            map.entry(MemoryAddress(source)).or_default().insert(MemoryAddress(destination));
+            map.entry(MemoryAddress::relative(source))
+                .or_default()
+                .insert(MemoryAddress::relative(destination));
             map
         })
     }
@@ -190,9 +194,12 @@ mod tests {
     fn movements_to_source_and_destinations(
         movements: Vec<(usize, usize)>,
     ) -> (Vec<MemoryAddress>, Vec<MemoryAddress>) {
-        let sources = movements.iter().map(|(source, _)| MemoryAddress::from(*source)).collect();
-        let destinations =
-            movements.iter().map(|(_, destination)| MemoryAddress::from(*destination)).collect();
+        let sources =
+            movements.iter().map(|(source, _)| MemoryAddress::relative(*source)).collect();
+        let destinations = movements
+            .iter()
+            .map(|(_, destination)| MemoryAddress::relative(*destination))
+            .collect();
         (sources, destinations)
     }
 
@@ -223,10 +230,22 @@ mod tests {
         assert_eq!(
             opcodes,
             vec![
-                Opcode::Mov { destination: MemoryAddress(14), source: MemoryAddress(13) },
-                Opcode::Mov { destination: MemoryAddress(13), source: MemoryAddress(12) },
-                Opcode::Mov { destination: MemoryAddress(12), source: MemoryAddress(11) },
-                Opcode::Mov { destination: MemoryAddress(11), source: MemoryAddress(10) },
+                Opcode::Mov {
+                    destination: MemoryAddress::relative(14),
+                    source: MemoryAddress::relative(13)
+                },
+                Opcode::Mov {
+                    destination: MemoryAddress::relative(13),
+                    source: MemoryAddress::relative(12)
+                },
+                Opcode::Mov {
+                    destination: MemoryAddress::relative(12),
+                    source: MemoryAddress::relative(11)
+                },
+                Opcode::Mov {
+                    destination: MemoryAddress::relative(11),
+                    source: MemoryAddress::relative(10)
+                },
             ]
         );
     }
@@ -241,8 +260,14 @@ mod tests {
         assert_eq!(
             opcodes,
             vec![
-                Opcode::Mov { destination: MemoryAddress(12), source: MemoryAddress(11) },
-                Opcode::Mov { destination: MemoryAddress(11), source: MemoryAddress(10) },
+                Opcode::Mov {
+                    destination: MemoryAddress::relative(12),
+                    source: MemoryAddress::relative(11)
+                },
+                Opcode::Mov {
+                    destination: MemoryAddress::relative(11),
+                    source: MemoryAddress::relative(10)
+                },
             ]
         );
     }
@@ -258,11 +283,26 @@ mod tests {
         assert_eq!(
             opcodes,
             vec![
-                Opcode::Mov { destination: MemoryAddress(3), source: MemoryAddress(10) },
-                Opcode::Mov { destination: MemoryAddress(10), source: MemoryAddress(13) },
-                Opcode::Mov { destination: MemoryAddress(13), source: MemoryAddress(12) },
-                Opcode::Mov { destination: MemoryAddress(12), source: MemoryAddress(11) },
-                Opcode::Mov { destination: MemoryAddress(11), source: MemoryAddress(3) }
+                Opcode::Mov {
+                    destination: MemoryAddress::relative(1),
+                    source: MemoryAddress::relative(10)
+                },
+                Opcode::Mov {
+                    destination: MemoryAddress::relative(10),
+                    source: MemoryAddress::relative(13)
+                },
+                Opcode::Mov {
+                    destination: MemoryAddress::relative(13),
+                    source: MemoryAddress::relative(12)
+                },
+                Opcode::Mov {
+                    destination: MemoryAddress::relative(12),
+                    source: MemoryAddress::relative(11)
+                },
+                Opcode::Mov {
+                    destination: MemoryAddress::relative(11),
+                    source: MemoryAddress::relative(1)
+                }
             ]
         );
     }
@@ -278,12 +318,30 @@ mod tests {
         assert_eq!(
             opcodes,
             vec![
-                Opcode::Mov { destination: MemoryAddress(3), source: MemoryAddress(10) }, // Temporary
-                Opcode::Mov { destination: MemoryAddress(14), source: MemoryAddress(13) }, // Branch
-                Opcode::Mov { destination: MemoryAddress(10), source: MemoryAddress(12) }, // Loop
-                Opcode::Mov { destination: MemoryAddress(12), source: MemoryAddress(11) }, // Loop
-                Opcode::Mov { destination: MemoryAddress(13), source: MemoryAddress(3) }, // Finish branch
-                Opcode::Mov { destination: MemoryAddress(11), source: MemoryAddress(3) } // Finish loop
+                Opcode::Mov {
+                    destination: MemoryAddress::relative(1),
+                    source: MemoryAddress::relative(10)
+                }, // Temporary
+                Opcode::Mov {
+                    destination: MemoryAddress::relative(10),
+                    source: MemoryAddress::relative(12)
+                }, // Branch
+                Opcode::Mov {
+                    destination: MemoryAddress::relative(12),
+                    source: MemoryAddress::relative(11)
+                }, // Loop
+                Opcode::Mov {
+                    destination: MemoryAddress::relative(14),
+                    source: MemoryAddress::relative(13)
+                }, // Loop
+                Opcode::Mov {
+                    destination: MemoryAddress::relative(11),
+                    source: MemoryAddress::relative(1)
+                }, // Finish branch
+                Opcode::Mov {
+                    destination: MemoryAddress::relative(13),
+                    source: MemoryAddress::relative(1)
+                } // Finish loop
             ]
         );
     }
diff --git a/compiler/noirc_evaluator/src/brillig/brillig_ir/debug_show.rs b/compiler/noirc_evaluator/src/brillig/brillig_ir/debug_show.rs
index 08e6c18182b..ef1b5432128 100644
--- a/compiler/noirc_evaluator/src/brillig/brillig_ir/debug_show.rs
+++ b/compiler/noirc_evaluator/src/brillig/brillig_ir/debug_show.rs
@@ -28,10 +28,13 @@ impl DebugToString for MemoryAddress {
     fn debug_to_string(&self) -> String {
         if *self == ReservedRegisters::free_memory_pointer() {
             "FreeMem".into()
-        } else if *self == ReservedRegisters::previous_stack_pointer() {
-            "PrevStack".into()
+        } else if *self == ReservedRegisters::stack_pointer() {
+            "StackPointer".into()
         } else {
-            format!("R{}", self.to_usize())
+            match self {
+                MemoryAddress::Direct(address) => format!("M{}", address),
+                MemoryAddress::Relative(offset) => format!("S{}", offset),
+            }
         }
     }
 }
@@ -114,7 +117,7 @@ impl DebugShow {
     }
 
     /// Emits a `trap` instruction.
-    pub(crate) fn trap_instruction(&self, revert_data: HeapArray) {
+    pub(crate) fn trap_instruction(&self, revert_data: HeapVector) {
         debug_println!(self.enable_debug_trace, "  TRAP {}", revert_data);
     }
 
@@ -123,24 +126,6 @@ impl DebugShow {
         debug_println!(self.enable_debug_trace, "  MOV {}, {}", destination, source);
     }
 
-    /// Emits a conditional `mov` instruction.
-    pub(crate) fn conditional_mov_instruction(
-        &self,
-        destination: MemoryAddress,
-        condition: MemoryAddress,
-        source_a: MemoryAddress,
-        source_b: MemoryAddress,
-    ) {
-        debug_println!(
-            self.enable_debug_trace,
-            "  CMOV {} = {}? {} : {}",
-            destination,
-            condition,
-            source_a,
-            source_b
-        );
-    }
-
     /// Emits a `cast` instruction.
     pub(crate) fn cast_instruction(
         &self,
@@ -226,23 +211,14 @@ impl DebugShow {
         debug_println!(self.enable_debug_trace, "  STORE *{} = {}", destination_pointer, source);
     }
 
-    /// Emits a stop instruction
-    pub(crate) fn stop_instruction(&self) {
-        debug_println!(self.enable_debug_trace, "  STOP");
+    /// Emits a return instruction
+    pub(crate) fn return_instruction(&self) {
+        debug_println!(self.enable_debug_trace, "  RETURN");
     }
 
-    /// Emits a external stop instruction (returns data)
-    pub(crate) fn external_stop_instruction(
-        &self,
-        return_data_offset: usize,
-        return_data_size: usize,
-    ) {
-        debug_println!(
-            self.enable_debug_trace,
-            "  EXT_STOP {}..{}",
-            return_data_offset,
-            return_data_offset + return_data_size
-        );
+    /// Emits a stop instruction
+    pub(crate) fn stop_instruction(&self, return_data: HeapVector) {
+        debug_println!(self.enable_debug_trace, "  STOP {}", return_data);
     }
 
     /// Debug function for enter_context
@@ -285,11 +261,8 @@ impl DebugShow {
                     outputs
                 );
             }
-            BlackBoxOp::Keccak256 { message, output } => {
-                debug_println!(self.enable_debug_trace, "  KECCAK256 {} -> {}", message, output);
-            }
-            BlackBoxOp::Keccakf1600 { message, output } => {
-                debug_println!(self.enable_debug_trace, "  KECCAKF1600 {} -> {}", message, output);
+            BlackBoxOp::Keccakf1600 { input, output } => {
+                debug_println!(self.enable_debug_trace, "  KECCAKF1600 {} -> {}", input, output);
             }
             BlackBoxOp::Blake2s { message, output } => {
                 debug_println!(self.enable_debug_trace, "  BLAKE2S {} -> {}", message, output);
@@ -353,41 +326,6 @@ impl DebugShow {
                     result
                 );
             }
-            BlackBoxOp::PedersenCommitment { inputs, domain_separator, output } => {
-                debug_println!(
-                    self.enable_debug_trace,
-                    "  PEDERSEN {} {} -> {}",
-                    inputs,
-                    domain_separator,
-                    output
-                );
-            }
-            BlackBoxOp::PedersenHash { inputs, domain_separator, output } => {
-                debug_println!(
-                    self.enable_debug_trace,
-                    "  PEDERSEN_HASH {} {} -> {}",
-                    inputs,
-                    domain_separator,
-                    output
-                );
-            }
-            BlackBoxOp::SchnorrVerify {
-                public_key_x,
-                public_key_y,
-                message,
-                signature,
-                result,
-            } => {
-                debug_println!(
-                    self.enable_debug_trace,
-                    "  SCHNORR_VERIFY {} {} {} {} -> {}",
-                    public_key_x,
-                    public_key_y,
-                    message,
-                    signature,
-                    result
-                );
-            }
             BlackBoxOp::BigIntAdd { lhs, rhs, output } => {
                 debug_println!(
                     self.enable_debug_trace,
diff --git a/compiler/noirc_evaluator/src/brillig/brillig_ir/entry_point.rs b/compiler/noirc_evaluator/src/brillig/brillig_ir/entry_point.rs
index ff9b5ea67eb..2dbee48b277 100644
--- a/compiler/noirc_evaluator/src/brillig/brillig_ir/entry_point.rs
+++ b/compiler/noirc_evaluator/src/brillig/brillig_ir/entry_point.rs
@@ -7,9 +7,13 @@ use super::{
     registers::Stack,
     BrilligBinaryOp, BrilligContext, ReservedRegisters,
 };
-use acvm::acir::{brillig::MemoryAddress, AcirField};
+use acvm::acir::{
+    brillig::{HeapVector, MemoryAddress},
+    AcirField,
+};
 
-pub(crate) const MAX_STACK_SIZE: usize = 2048;
+pub(crate) const MAX_STACK_SIZE: usize = 16 * MAX_STACK_FRAME_SIZE;
+pub(crate) const MAX_STACK_FRAME_SIZE: usize = 2048;
 pub(crate) const MAX_SCRATCH_SPACE: usize = 64;
 
 impl<F: AcirField + DebugToString> BrilligContext<F, Stack> {
@@ -57,12 +61,18 @@ impl<F: AcirField + DebugToString> BrilligContext<F, Stack> {
             1_usize.into(),
         );
 
-        // Set initial value of stack pointer: calldata_start_offset + calldata_size + return_data_size
+        // Set initial value of free memory pointer: calldata_start_offset + calldata_size + return_data_size
         self.const_instruction(
             SingleAddrVariable::new_usize(ReservedRegisters::free_memory_pointer()),
             (Self::calldata_start_offset() + calldata_size + return_data_size).into(),
         );
 
+        // Set initial value of stack pointer: ReservedRegisters.len()
+        self.const_instruction(
+            SingleAddrVariable::new_usize(ReservedRegisters::stack_pointer()),
+            ReservedRegisters::len().into(),
+        );
+
         // Copy calldata
         self.copy_and_cast_calldata(arguments);
 
@@ -74,7 +84,7 @@ impl<F: AcirField + DebugToString> BrilligContext<F, Stack> {
                 (BrilligVariable::SingleAddr(single_address), BrilligParameter::SingleAddr(_)) => {
                     self.mov_instruction(
                         single_address.address,
-                        MemoryAddress(current_calldata_pointer),
+                        MemoryAddress::direct(current_calldata_pointer),
                     );
                     current_calldata_pointer += 1;
                 }
@@ -142,7 +152,7 @@ impl<F: AcirField + DebugToString> BrilligContext<F, Stack> {
     fn copy_and_cast_calldata(&mut self, arguments: &[BrilligParameter]) {
         let calldata_size = Self::flattened_tuple_size(arguments);
         self.calldata_copy_instruction(
-            MemoryAddress(Self::calldata_start_offset()),
+            MemoryAddress::direct(Self::calldata_start_offset()),
             calldata_size,
             0,
         );
@@ -162,10 +172,12 @@ impl<F: AcirField + DebugToString> BrilligContext<F, Stack> {
             if bit_size < F::max_num_bits() {
                 self.cast_instruction(
                     SingleAddrVariable::new(
-                        MemoryAddress(Self::calldata_start_offset() + i),
+                        MemoryAddress::direct(Self::calldata_start_offset() + i),
                         bit_size,
                     ),
-                    SingleAddrVariable::new_field(MemoryAddress(Self::calldata_start_offset() + i)),
+                    SingleAddrVariable::new_field(MemoryAddress::direct(
+                        Self::calldata_start_offset() + i,
+                    )),
                 );
             }
         }
@@ -187,7 +199,7 @@ impl<F: AcirField + DebugToString> BrilligContext<F, Stack> {
         let deflattened_items_pointer = if is_vector {
             let vector = BrilligVector { pointer: deflattened_array_pointer };
 
-            self.codegen_initialize_vector(vector, deflattened_size_variable);
+            self.codegen_initialize_vector(vector, deflattened_size_variable, None);
 
             self.codegen_make_vector_items_pointer(vector)
         } else {
@@ -325,7 +337,7 @@ impl<F: AcirField + DebugToString> BrilligContext<F, Stack> {
             match return_param {
                 BrilligParameter::SingleAddr(_) => {
                     self.mov_instruction(
-                        MemoryAddress(return_data_index),
+                        MemoryAddress::direct(return_data_index),
                         returned_variable.extract_single_addr().address,
                     );
                     return_data_index += 1;
@@ -354,7 +366,12 @@ impl<F: AcirField + DebugToString> BrilligContext<F, Stack> {
             }
         }
 
-        self.external_stop_instruction(return_data_offset, return_data_size);
+        let return_data = HeapVector {
+            pointer: self.make_usize_constant_instruction(return_data_offset.into()).address,
+            size: self.make_usize_constant_instruction(return_data_size.into()).address,
+        };
+
+        self.stop_instruction(return_data);
     }
 }
 
diff --git a/compiler/noirc_evaluator/src/brillig/brillig_ir/instructions.rs b/compiler/noirc_evaluator/src/brillig/brillig_ir/instructions.rs
index f196552b768..2bf5364414c 100644
--- a/compiler/noirc_evaluator/src/brillig/brillig_ir/instructions.rs
+++ b/compiler/noirc_evaluator/src/brillig/brillig_ir/instructions.rs
@@ -1,7 +1,7 @@
 use acvm::{
     acir::{
         brillig::{
-            BinaryFieldOp, BinaryIntOp, BitSize, BlackBoxOp, HeapArray, HeapValueType,
+            BinaryFieldOp, BinaryIntOp, BitSize, BlackBoxOp, HeapValueType, HeapVector,
             MemoryAddress, Opcode as BrilligOpcode, ValueOrArray,
         },
         AcirField,
@@ -224,7 +224,7 @@ impl<F: AcirField + DebugToString, Registers: RegisterAllocator> BrilligContext<
     /// Adds a label to the next opcode
     pub(crate) fn enter_context(&mut self, label: Label) {
         self.debug_show.enter_context(label.to_string());
-        self.context_label = label;
+        self.context_label = label.clone();
         self.current_section = 0;
         // Add a context label to the next opcode
         self.obj.add_label_at_position(label, self.obj.index_of_next_opcode());
@@ -257,20 +257,16 @@ impl<F: AcirField + DebugToString, Registers: RegisterAllocator> BrilligContext<
         self.compute_section_label(self.current_section)
     }
 
-    /// Emits a stop instruction
-    pub(crate) fn stop_instruction(&mut self) {
-        self.debug_show.stop_instruction();
-        self.push_opcode(BrilligOpcode::Stop { return_data_offset: 0, return_data_size: 0 });
+    /// Emits a return instruction
+    pub(crate) fn return_instruction(&mut self) {
+        self.debug_show.return_instruction();
+        self.push_opcode(BrilligOpcode::Return);
     }
 
-    /// Emits a external stop instruction (returns data)
-    pub(crate) fn external_stop_instruction(
-        &mut self,
-        return_data_offset: usize,
-        return_data_size: usize,
-    ) {
-        self.debug_show.external_stop_instruction(return_data_offset, return_data_size);
-        self.push_opcode(BrilligOpcode::Stop { return_data_offset, return_data_size });
+    /// Emits a stop instruction with return data
+    pub(crate) fn stop_instruction(&mut self, return_data: HeapVector) {
+        self.debug_show.stop_instruction(return_data);
+        self.push_opcode(BrilligOpcode::Stop { return_data });
     }
 
     /// Issues a blackbox operation.
@@ -327,25 +323,6 @@ impl<F: AcirField + DebugToString, Registers: RegisterAllocator> BrilligContext<
         self.push_opcode(BrilligOpcode::Mov { destination, source });
     }
 
-    /// Emits a conditional `mov` instruction.
-    ///
-    /// Copies the value at `source` into `destination`
-    pub(crate) fn conditional_mov_instruction(
-        &mut self,
-        destination: MemoryAddress,
-        condition: MemoryAddress,
-        source_a: MemoryAddress,
-        source_b: MemoryAddress,
-    ) {
-        self.debug_show.conditional_mov_instruction(destination, condition, source_a, source_b);
-        self.push_opcode(BrilligOpcode::ConditionalMov {
-            destination,
-            source_a,
-            source_b,
-            condition,
-        });
-    }
-
     /// Cast truncates the value to the given bit size and converts the type of the value in memory to that bit size.
     pub(crate) fn cast_instruction(
         &mut self,
@@ -444,7 +421,7 @@ impl<F: AcirField + DebugToString, Registers: RegisterAllocator> BrilligContext<
         self.deallocate_single_addr(offset_var);
     }
 
-    pub(super) fn trap_instruction(&mut self, revert_data: HeapArray) {
+    pub(super) fn trap_instruction(&mut self, revert_data: HeapVector) {
         self.debug_show.trap_instruction(revert_data);
 
         self.push_opcode(BrilligOpcode::Trap { revert_data });
diff --git a/compiler/noirc_evaluator/src/brillig/brillig_ir/procedures/array_copy.rs b/compiler/noirc_evaluator/src/brillig/brillig_ir/procedures/array_copy.rs
index 5b97bbc8f7a..0a6e8824223 100644
--- a/compiler/noirc_evaluator/src/brillig/brillig_ir/procedures/array_copy.rs
+++ b/compiler/noirc_evaluator/src/brillig/brillig_ir/procedures/array_copy.rs
@@ -18,9 +18,9 @@ impl<F: AcirField + DebugToString, Registers: RegisterAllocator> BrilligContext<
         source_array: BrilligArray,
         destination_array: BrilligArray,
     ) {
-        let source_array_pointer_arg = MemoryAddress::from(ScratchSpace::start());
-        let source_array_memory_size_arg = MemoryAddress::from(ScratchSpace::start() + 1);
-        let new_array_pointer_return = MemoryAddress::from(ScratchSpace::start() + 2);
+        let source_array_pointer_arg = MemoryAddress::direct(ScratchSpace::start());
+        let source_array_memory_size_arg = MemoryAddress::direct(ScratchSpace::start() + 1);
+        let new_array_pointer_return = MemoryAddress::direct(ScratchSpace::start() + 2);
 
         self.mov_instruction(source_array_pointer_arg, source_array.pointer);
         self.usize_const_instruction(source_array_memory_size_arg, (source_array.size + 1).into());
@@ -34,9 +34,9 @@ impl<F: AcirField + DebugToString, Registers: RegisterAllocator> BrilligContext<
 pub(super) fn compile_array_copy_procedure<F: AcirField + DebugToString>(
     brillig_context: &mut BrilligContext<F, ScratchSpace>,
 ) {
-    let source_array_pointer_arg = MemoryAddress::from(ScratchSpace::start());
-    let source_array_memory_size_arg = MemoryAddress::from(ScratchSpace::start() + 1);
-    let new_array_pointer_return = MemoryAddress::from(ScratchSpace::start() + 2);
+    let source_array_pointer_arg = MemoryAddress::direct(ScratchSpace::start());
+    let source_array_memory_size_arg = MemoryAddress::direct(ScratchSpace::start() + 1);
+    let new_array_pointer_return = MemoryAddress::direct(ScratchSpace::start() + 2);
 
     brillig_context.set_allocated_registers(vec![
         source_array_pointer_arg,
@@ -69,6 +69,8 @@ pub(super) fn compile_array_copy_procedure<F: AcirField + DebugToString>(
                 BRILLIG_MEMORY_ADDRESSING_BIT_SIZE,
                 1_usize.into(),
             );
+            // Decrease the original ref count now that this copy is no longer pointing to it
+            ctx.codegen_usize_op(rc.address, rc.address, BrilligBinaryOp::Sub, 1);
         }
     });
 }
diff --git a/compiler/noirc_evaluator/src/brillig/brillig_ir/procedures/array_reverse.rs b/compiler/noirc_evaluator/src/brillig/brillig_ir/procedures/array_reverse.rs
index 0d98599bf96..a5a11d61bef 100644
--- a/compiler/noirc_evaluator/src/brillig/brillig_ir/procedures/array_reverse.rs
+++ b/compiler/noirc_evaluator/src/brillig/brillig_ir/procedures/array_reverse.rs
@@ -15,8 +15,8 @@ impl<F: AcirField + DebugToString, Registers: RegisterAllocator> BrilligContext<
         pointer: MemoryAddress,
         size: MemoryAddress,
     ) {
-        let source_pointer = MemoryAddress::from(ScratchSpace::start());
-        let size_register = MemoryAddress::from(ScratchSpace::start() + 1);
+        let source_pointer = MemoryAddress::direct(ScratchSpace::start());
+        let size_register = MemoryAddress::direct(ScratchSpace::start() + 1);
 
         self.mov_instruction(source_pointer, pointer);
         self.mov_instruction(size_register, size);
@@ -28,8 +28,8 @@ impl<F: AcirField + DebugToString, Registers: RegisterAllocator> BrilligContext<
 pub(super) fn compile_array_reverse_procedure<F: AcirField + DebugToString>(
     brillig_context: &mut BrilligContext<F, ScratchSpace>,
 ) {
-    let source_pointer = MemoryAddress::from(ScratchSpace::start());
-    let size_register = MemoryAddress::from(ScratchSpace::start() + 1);
+    let source_pointer = MemoryAddress::direct(ScratchSpace::start());
+    let size_register = MemoryAddress::direct(ScratchSpace::start() + 1);
 
     brillig_context.set_allocated_registers(vec![source_pointer, size_register]);
 
diff --git a/compiler/noirc_evaluator/src/brillig/brillig_ir/procedures/check_max_stack_depth.rs b/compiler/noirc_evaluator/src/brillig/brillig_ir/procedures/check_max_stack_depth.rs
new file mode 100644
index 00000000000..4d5abe93420
--- /dev/null
+++ b/compiler/noirc_evaluator/src/brillig/brillig_ir/procedures/check_max_stack_depth.rs
@@ -0,0 +1,30 @@
+use acvm::AcirField;
+
+use super::ProcedureId;
+use crate::brillig::brillig_ir::{
+    brillig_variable::SingleAddrVariable,
+    debug_show::DebugToString,
+    entry_point::{MAX_STACK_FRAME_SIZE, MAX_STACK_SIZE},
+    registers::{RegisterAllocator, ScratchSpace},
+    BrilligBinaryOp, BrilligContext, ReservedRegisters,
+};
+
+impl<F: AcirField + DebugToString, Registers: RegisterAllocator> BrilligContext<F, Registers> {
+    pub(crate) fn call_check_max_stack_depth_procedure(&mut self) {
+        self.add_procedure_call_instruction(ProcedureId::CheckMaxStackDepth);
+    }
+}
+
+pub(super) fn compile_check_max_stack_depth_procedure<F: AcirField + DebugToString>(
+    brillig_context: &mut BrilligContext<F, ScratchSpace>,
+) {
+    let in_range = SingleAddrVariable::new(brillig_context.allocate_register(), 1);
+    brillig_context.codegen_usize_op(
+        ReservedRegisters::stack_pointer(),
+        in_range.address,
+        BrilligBinaryOp::LessThan,
+        MAX_STACK_SIZE - MAX_STACK_FRAME_SIZE,
+    );
+    brillig_context.codegen_constrain(in_range, Some("Stack too deep".to_string()));
+    brillig_context.deallocate_single_addr(in_range);
+}
diff --git a/compiler/noirc_evaluator/src/brillig/brillig_ir/procedures/mem_copy.rs b/compiler/noirc_evaluator/src/brillig/brillig_ir/procedures/mem_copy.rs
index b4e1d37af38..cdd99542483 100644
--- a/compiler/noirc_evaluator/src/brillig/brillig_ir/procedures/mem_copy.rs
+++ b/compiler/noirc_evaluator/src/brillig/brillig_ir/procedures/mem_copy.rs
@@ -17,9 +17,12 @@ impl<F: AcirField + DebugToString, Registers: RegisterAllocator> BrilligContext<
         destination_pointer: MemoryAddress,
         num_elements_variable: MemoryAddress,
     ) {
-        self.mov_instruction(MemoryAddress::from(ScratchSpace::start()), source_pointer);
-        self.mov_instruction(MemoryAddress::from(ScratchSpace::start() + 1), destination_pointer);
-        self.mov_instruction(MemoryAddress::from(ScratchSpace::start() + 2), num_elements_variable);
+        self.mov_instruction(MemoryAddress::direct(ScratchSpace::start()), source_pointer);
+        self.mov_instruction(MemoryAddress::direct(ScratchSpace::start() + 1), destination_pointer);
+        self.mov_instruction(
+            MemoryAddress::direct(ScratchSpace::start() + 2),
+            num_elements_variable,
+        );
         self.add_procedure_call_instruction(ProcedureId::MemCopy);
     }
 }
@@ -27,9 +30,9 @@ impl<F: AcirField + DebugToString, Registers: RegisterAllocator> BrilligContext<
 pub(super) fn compile_mem_copy_procedure<F: AcirField + DebugToString>(
     brillig_context: &mut BrilligContext<F, ScratchSpace>,
 ) {
-    let source_pointer = MemoryAddress::from(ScratchSpace::start());
-    let destination_pointer = MemoryAddress::from(ScratchSpace::start() + 1);
-    let num_elements_variable = MemoryAddress::from(ScratchSpace::start() + 2);
+    let source_pointer = MemoryAddress::direct(ScratchSpace::start());
+    let destination_pointer = MemoryAddress::direct(ScratchSpace::start() + 1);
+    let num_elements_variable = MemoryAddress::direct(ScratchSpace::start() + 2);
 
     brillig_context.set_allocated_registers(vec![
         source_pointer,
diff --git a/compiler/noirc_evaluator/src/brillig/brillig_ir/procedures/mod.rs b/compiler/noirc_evaluator/src/brillig/brillig_ir/procedures/mod.rs
index 32fe6725e56..0955142e414 100644
--- a/compiler/noirc_evaluator/src/brillig/brillig_ir/procedures/mod.rs
+++ b/compiler/noirc_evaluator/src/brillig/brillig_ir/procedures/mod.rs
@@ -1,19 +1,28 @@
+use noirc_errors::debug_info::ProcedureDebugId;
+use serde::{Deserialize, Serialize};
+
 mod array_copy;
 mod array_reverse;
+mod check_max_stack_depth;
 mod mem_copy;
 mod prepare_vector_insert;
 mod prepare_vector_push;
+mod revert_with_string;
 mod vector_copy;
-mod vector_pop;
+mod vector_pop_back;
+mod vector_pop_front;
 mod vector_remove;
 
 use array_copy::compile_array_copy_procedure;
 use array_reverse::compile_array_reverse_procedure;
+use check_max_stack_depth::compile_check_max_stack_depth_procedure;
 use mem_copy::compile_mem_copy_procedure;
 use prepare_vector_insert::compile_prepare_vector_insert_procedure;
 use prepare_vector_push::compile_prepare_vector_push_procedure;
+use revert_with_string::compile_revert_with_string_procedure;
 use vector_copy::compile_vector_copy_procedure;
-use vector_pop::compile_vector_pop_procedure;
+use vector_pop_back::compile_vector_pop_back_procedure;
+use vector_pop_front::compile_vector_pop_front_procedure;
 use vector_remove::compile_vector_remove_procedure;
 
 use crate::brillig::brillig_ir::AcirField;
@@ -27,23 +36,83 @@ use super::{
 /// Procedures are a set of complex operations that are common in the noir language.
 /// Extracting them to reusable procedures allows us to reduce the size of the generated Brillig.
 /// Procedures receive their arguments on scratch space to avoid stack dumping&restoring.
-#[derive(Debug, Clone, Copy, Eq, PartialEq, Hash)]
-pub(crate) enum ProcedureId {
+#[derive(Debug, Clone, Eq, PartialEq, Hash, PartialOrd, Ord, Deserialize, Serialize)]
+pub enum ProcedureId {
     ArrayCopy,
     ArrayReverse,
     VectorCopy,
     MemCopy,
     PrepareVectorPush(bool),
-    VectorPop(bool),
+    VectorPopFront,
+    VectorPopBack,
     PrepareVectorInsert,
     VectorRemove,
+    CheckMaxStackDepth,
+    RevertWithString(String),
+}
+
+impl ProcedureId {
+    pub(crate) fn to_debug_id(&self) -> ProcedureDebugId {
+        ProcedureDebugId(match self {
+            ProcedureId::ArrayCopy => 0,
+            ProcedureId::ArrayReverse => 1,
+            ProcedureId::VectorCopy => 2,
+            ProcedureId::MemCopy => 3,
+            ProcedureId::PrepareVectorPush(true) => 4,
+            ProcedureId::PrepareVectorPush(false) => 5,
+            ProcedureId::VectorPopFront => 6,
+            ProcedureId::VectorPopBack => 7,
+            ProcedureId::PrepareVectorInsert => 8,
+            ProcedureId::VectorRemove => 9,
+            ProcedureId::CheckMaxStackDepth => 10,
+            ProcedureId::RevertWithString(_) => 11,
+        })
+    }
+
+    pub fn from_debug_id(debug_id: ProcedureDebugId) -> Self {
+        let inner = debug_id.0;
+        match inner {
+            0 => ProcedureId::ArrayCopy,
+            1 => ProcedureId::ArrayReverse,
+            2 => ProcedureId::VectorCopy,
+            3 => ProcedureId::MemCopy,
+            4 => ProcedureId::PrepareVectorPush(true),
+            5 => ProcedureId::PrepareVectorPush(false),
+            6 => ProcedureId::VectorPopFront,
+            7 => ProcedureId::VectorPopBack,
+            8 => ProcedureId::PrepareVectorInsert,
+            9 => ProcedureId::VectorRemove,
+            10 => ProcedureId::CheckMaxStackDepth,
+            // TODO: what to do here?
+            11 => ProcedureId::RevertWithString("".to_string()),
+            _ => panic!("Unsupported procedure debug ID of {inner} was supplied"),
+        }
+    }
+}
+
+impl std::fmt::Display for ProcedureId {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        match self {
+            ProcedureId::ArrayCopy => write!(f, "ArrayCopy"),
+            ProcedureId::ArrayReverse => write!(f, "ArrayReverse"),
+            ProcedureId::VectorCopy => write!(f, "VectorCopy"),
+            ProcedureId::MemCopy => write!(f, "MemCopy"),
+            ProcedureId::PrepareVectorPush(flag) => write!(f, "PrepareVectorPush({flag})"),
+            ProcedureId::VectorPopFront => write!(f, "VectorPopFront"),
+            ProcedureId::VectorPopBack => write!(f, "VectorPopBack"),
+            ProcedureId::PrepareVectorInsert => write!(f, "PrepareVectorInsert"),
+            ProcedureId::VectorRemove => write!(f, "VectorRemove"),
+            ProcedureId::CheckMaxStackDepth => write!(f, "CheckMaxStackDepth"),
+            ProcedureId::RevertWithString(_) => write!(f, "RevertWithString"),
+        }
+    }
 }
 
 pub(crate) fn compile_procedure<F: AcirField + DebugToString>(
     procedure_id: ProcedureId,
 ) -> BrilligArtifact<F> {
-    let mut brillig_context = BrilligContext::new_for_procedure(false);
-    brillig_context.enter_context(Label::procedure(procedure_id));
+    let mut brillig_context = BrilligContext::new_for_procedure(false, procedure_id.clone());
+    brillig_context.enter_context(Label::procedure(procedure_id.clone()));
 
     match procedure_id {
         ProcedureId::MemCopy => compile_mem_copy_procedure(&mut brillig_context),
@@ -53,16 +122,25 @@ pub(crate) fn compile_procedure<F: AcirField + DebugToString>(
         ProcedureId::PrepareVectorPush(push_back) => {
             compile_prepare_vector_push_procedure(&mut brillig_context, push_back);
         }
-        ProcedureId::VectorPop(pop_back) => {
-            compile_vector_pop_procedure(&mut brillig_context, pop_back);
+        ProcedureId::VectorPopFront => {
+            compile_vector_pop_front_procedure(&mut brillig_context);
+        }
+        ProcedureId::VectorPopBack => {
+            compile_vector_pop_back_procedure(&mut brillig_context);
         }
         ProcedureId::PrepareVectorInsert => {
             compile_prepare_vector_insert_procedure(&mut brillig_context);
         }
         ProcedureId::VectorRemove => compile_vector_remove_procedure(&mut brillig_context),
+        ProcedureId::CheckMaxStackDepth => {
+            compile_check_max_stack_depth_procedure(&mut brillig_context);
+        }
+        ProcedureId::RevertWithString(revert_string) => {
+            compile_revert_with_string_procedure(&mut brillig_context, revert_string);
+        }
     };
 
-    brillig_context.stop_instruction();
+    brillig_context.return_instruction();
 
     brillig_context.artifact()
 }
diff --git a/compiler/noirc_evaluator/src/brillig/brillig_ir/procedures/prepare_vector_insert.rs b/compiler/noirc_evaluator/src/brillig/brillig_ir/procedures/prepare_vector_insert.rs
index d3a6855fa0f..1c1a738509c 100644
--- a/compiler/noirc_evaluator/src/brillig/brillig_ir/procedures/prepare_vector_insert.rs
+++ b/compiler/noirc_evaluator/src/brillig/brillig_ir/procedures/prepare_vector_insert.rs
@@ -2,7 +2,7 @@ use std::vec;
 
 use acvm::{acir::brillig::MemoryAddress, AcirField};
 
-use super::ProcedureId;
+use super::{prepare_vector_push::reallocate_vector_for_insertion, ProcedureId};
 use crate::brillig::brillig_ir::{
     brillig_variable::{BrilligVector, SingleAddrVariable},
     debug_show::DebugToString,
@@ -20,11 +20,11 @@ impl<F: AcirField + DebugToString, Registers: RegisterAllocator> BrilligContext<
         write_pointer: MemoryAddress,
         item_count: usize,
     ) {
-        let source_vector_pointer_arg = MemoryAddress::from(ScratchSpace::start());
-        let index_arg = MemoryAddress::from(ScratchSpace::start() + 1);
-        let item_count_arg = MemoryAddress::from(ScratchSpace::start() + 2);
-        let new_vector_pointer_return = MemoryAddress::from(ScratchSpace::start() + 3);
-        let write_pointer_return = MemoryAddress::from(ScratchSpace::start() + 4);
+        let source_vector_pointer_arg = MemoryAddress::direct(ScratchSpace::start());
+        let index_arg = MemoryAddress::direct(ScratchSpace::start() + 1);
+        let item_count_arg = MemoryAddress::direct(ScratchSpace::start() + 2);
+        let new_vector_pointer_return = MemoryAddress::direct(ScratchSpace::start() + 3);
+        let write_pointer_return = MemoryAddress::direct(ScratchSpace::start() + 4);
 
         self.mov_instruction(source_vector_pointer_arg, source_vector.pointer);
         self.mov_instruction(index_arg, index.address);
@@ -40,11 +40,11 @@ impl<F: AcirField + DebugToString, Registers: RegisterAllocator> BrilligContext<
 pub(super) fn compile_prepare_vector_insert_procedure<F: AcirField + DebugToString>(
     brillig_context: &mut BrilligContext<F, ScratchSpace>,
 ) {
-    let source_vector_pointer_arg = MemoryAddress::from(ScratchSpace::start());
-    let index_arg = MemoryAddress::from(ScratchSpace::start() + 1);
-    let item_count_arg = MemoryAddress::from(ScratchSpace::start() + 2);
-    let new_vector_pointer_return = MemoryAddress::from(ScratchSpace::start() + 3);
-    let write_pointer_return = MemoryAddress::from(ScratchSpace::start() + 4);
+    let source_vector_pointer_arg = MemoryAddress::direct(ScratchSpace::start());
+    let index_arg = MemoryAddress::direct(ScratchSpace::start() + 1);
+    let item_count_arg = MemoryAddress::direct(ScratchSpace::start() + 2);
+    let new_vector_pointer_return = MemoryAddress::direct(ScratchSpace::start() + 3);
+    let write_pointer_return = MemoryAddress::direct(ScratchSpace::start() + 4);
 
     brillig_context.set_allocated_registers(vec![
         source_vector_pointer_arg,
@@ -58,9 +58,19 @@ pub(super) fn compile_prepare_vector_insert_procedure<F: AcirField + DebugToStri
     let target_vector = BrilligVector { pointer: new_vector_pointer_return };
     let index = SingleAddrVariable::new_usize(index_arg);
 
-    // First we need to allocate the target vector incrementing the size by items.len()
-    let source_size = brillig_context.codegen_make_vector_length(source_vector);
+    let source_rc = SingleAddrVariable::new_usize(brillig_context.allocate_register());
+    let source_size = SingleAddrVariable::new_usize(brillig_context.allocate_register());
+    let source_capacity = SingleAddrVariable::new_usize(brillig_context.allocate_register());
+    let source_items_pointer = SingleAddrVariable::new_usize(brillig_context.allocate_register());
+    brillig_context.codegen_read_vector_metadata(
+        source_vector,
+        source_rc,
+        source_size,
+        source_capacity,
+        source_items_pointer,
+    );
 
+    // Target size is source size + item_count
     let target_size = SingleAddrVariable::new_usize(brillig_context.allocate_register());
     brillig_context.memory_op_instruction(
         source_size.address,
@@ -69,24 +79,40 @@ pub(super) fn compile_prepare_vector_insert_procedure<F: AcirField + DebugToStri
         BrilligBinaryOp::Add,
     );
 
-    brillig_context.codegen_initialize_vector(target_vector, target_size);
+    // Reallocate the target vector if necessary
+    reallocate_vector_for_insertion(
+        brillig_context,
+        source_vector,
+        source_rc,
+        source_capacity,
+        target_vector,
+        target_size,
+    );
 
-    // Copy the elements to the left of the index
-    let source_vector_items_pointer =
-        brillig_context.codegen_make_vector_items_pointer(source_vector);
     let target_vector_items_pointer =
         brillig_context.codegen_make_vector_items_pointer(target_vector);
 
-    brillig_context.codegen_mem_copy(
-        source_vector_items_pointer,
-        target_vector_items_pointer,
-        index,
+    let was_reused = SingleAddrVariable::new(brillig_context.allocate_register(), 1);
+    brillig_context.memory_op_instruction(
+        source_vector.pointer,
+        target_vector.pointer,
+        was_reused.address,
+        BrilligBinaryOp::Equals,
     );
 
+    brillig_context.codegen_if_not(was_reused.address, |brillig_context| {
+        // Copy the elements to the left of the index
+        brillig_context.codegen_mem_copy(
+            source_items_pointer.address,
+            target_vector_items_pointer,
+            index,
+        );
+    });
+
     // Compute the source pointer just at the index
     let source_pointer_at_index = brillig_context.allocate_register();
     brillig_context.memory_op_instruction(
-        source_vector_items_pointer,
+        source_items_pointer.address,
         index_arg,
         source_pointer_at_index,
         BrilligBinaryOp::Add,
@@ -108,27 +134,30 @@ pub(super) fn compile_prepare_vector_insert_procedure<F: AcirField + DebugToStri
         BrilligBinaryOp::Add,
     );
 
-    // Compute the number of elements to the right of the index
-    let item_count = brillig_context.allocate_register();
+    // Compute the number of elements to the right of the insertion index
+    let element_count_to_the_right = brillig_context.allocate_register();
     brillig_context.memory_op_instruction(
         source_size.address,
         index.address,
-        item_count,
+        element_count_to_the_right,
         BrilligBinaryOp::Sub,
     );
 
     // Copy the elements to the right of the index
-    brillig_context.codegen_mem_copy(
+    brillig_context.codegen_mem_copy_from_the_end(
         source_pointer_at_index,
         target_pointer_after_index,
-        SingleAddrVariable::new_usize(item_count),
+        SingleAddrVariable::new_usize(element_count_to_the_right),
     );
 
-    brillig_context.deallocate_register(source_pointer_at_index);
-    brillig_context.deallocate_register(target_pointer_after_index);
-    brillig_context.deallocate_register(item_count);
+    brillig_context.deallocate_single_addr(source_rc);
     brillig_context.deallocate_single_addr(source_size);
+    brillig_context.deallocate_single_addr(source_capacity);
+    brillig_context.deallocate_single_addr(source_items_pointer);
     brillig_context.deallocate_single_addr(target_size);
-    brillig_context.deallocate_register(source_vector_items_pointer);
     brillig_context.deallocate_register(target_vector_items_pointer);
+    brillig_context.deallocate_single_addr(was_reused);
+    brillig_context.deallocate_register(source_pointer_at_index);
+    brillig_context.deallocate_register(target_pointer_after_index);
+    brillig_context.deallocate_register(element_count_to_the_right);
 }
diff --git a/compiler/noirc_evaluator/src/brillig/brillig_ir/procedures/prepare_vector_push.rs b/compiler/noirc_evaluator/src/brillig/brillig_ir/procedures/prepare_vector_push.rs
index 8af75712374..798cf2385e5 100644
--- a/compiler/noirc_evaluator/src/brillig/brillig_ir/procedures/prepare_vector_push.rs
+++ b/compiler/noirc_evaluator/src/brillig/brillig_ir/procedures/prepare_vector_push.rs
@@ -21,10 +21,10 @@ impl<F: AcirField + DebugToString, Registers: RegisterAllocator> BrilligContext<
         item_push_count: usize,
         back: bool,
     ) {
-        let source_vector_pointer_arg = MemoryAddress::from(ScratchSpace::start());
-        let item_push_count_arg = MemoryAddress::from(ScratchSpace::start() + 1);
-        let new_vector_pointer_return = MemoryAddress::from(ScratchSpace::start() + 2);
-        let write_pointer_return = MemoryAddress::from(ScratchSpace::start() + 3);
+        let source_vector_pointer_arg = MemoryAddress::direct(ScratchSpace::start());
+        let item_push_count_arg = MemoryAddress::direct(ScratchSpace::start() + 1);
+        let new_vector_pointer_return = MemoryAddress::direct(ScratchSpace::start() + 2);
+        let write_pointer_return = MemoryAddress::direct(ScratchSpace::start() + 3);
 
         self.mov_instruction(source_vector_pointer_arg, source_vector.pointer);
         self.usize_const_instruction(item_push_count_arg, item_push_count.into());
@@ -40,10 +40,10 @@ pub(super) fn compile_prepare_vector_push_procedure<F: AcirField + DebugToString
     brillig_context: &mut BrilligContext<F, ScratchSpace>,
     push_back: bool,
 ) {
-    let source_vector_pointer_arg = MemoryAddress::from(ScratchSpace::start());
-    let item_push_count_arg = MemoryAddress::from(ScratchSpace::start() + 1);
-    let new_vector_pointer_return = MemoryAddress::from(ScratchSpace::start() + 2);
-    let write_pointer_return = MemoryAddress::from(ScratchSpace::start() + 3);
+    let source_vector_pointer_arg = MemoryAddress::direct(ScratchSpace::start());
+    let item_push_count_arg = MemoryAddress::direct(ScratchSpace::start() + 1);
+    let new_vector_pointer_return = MemoryAddress::direct(ScratchSpace::start() + 2);
+    let write_pointer_return = MemoryAddress::direct(ScratchSpace::start() + 3);
 
     brillig_context.set_allocated_registers(vec![
         source_vector_pointer_arg,
@@ -55,8 +55,17 @@ pub(super) fn compile_prepare_vector_push_procedure<F: AcirField + DebugToString
     let source_vector = BrilligVector { pointer: source_vector_pointer_arg };
     let target_vector = BrilligVector { pointer: new_vector_pointer_return };
 
-    // First we need to allocate the target vector incrementing the size by item_push_count_arg
-    let source_size = brillig_context.codegen_make_vector_length(source_vector);
+    let source_rc = SingleAddrVariable::new_usize(brillig_context.allocate_register());
+    let source_size = SingleAddrVariable::new_usize(brillig_context.allocate_register());
+    let source_capacity = SingleAddrVariable::new_usize(brillig_context.allocate_register());
+    let source_items_pointer = SingleAddrVariable::new_usize(brillig_context.allocate_register());
+    brillig_context.codegen_read_vector_metadata(
+        source_vector,
+        source_rc,
+        source_size,
+        source_capacity,
+        source_items_pointer,
+    );
 
     let target_size = SingleAddrVariable::new_usize(brillig_context.allocate_register());
     brillig_context.memory_op_instruction(
@@ -66,46 +75,138 @@ pub(super) fn compile_prepare_vector_push_procedure<F: AcirField + DebugToString
         BrilligBinaryOp::Add,
     );
 
-    brillig_context.codegen_initialize_vector(target_vector, target_size);
+    // The strategy is to reallocate first and then depending if it's push back or not, copy the items or not.
+    reallocate_vector_for_insertion(
+        brillig_context,
+        source_vector,
+        source_rc,
+        source_capacity,
+        target_vector,
+        target_size,
+    );
 
-    // Now we copy the source vector into the target vector
-    let source_vector_items_pointer =
-        brillig_context.codegen_make_vector_items_pointer(source_vector);
     let target_vector_items_pointer =
         brillig_context.codegen_make_vector_items_pointer(target_vector);
 
     if push_back {
-        brillig_context.codegen_mem_copy(
-            source_vector_items_pointer,
-            target_vector_items_pointer,
-            source_size,
+        let was_reused = SingleAddrVariable::new(brillig_context.allocate_register(), 1);
+        brillig_context.memory_op_instruction(
+            source_vector.pointer,
+            target_vector.pointer,
+            was_reused.address,
+            BrilligBinaryOp::Equals,
         );
 
+        brillig_context.codegen_if_not(was_reused.address, |brillig_context| {
+            brillig_context.codegen_mem_copy(
+                source_items_pointer.address,
+                target_vector_items_pointer,
+                source_size,
+            );
+        });
+        // Target vector is ready for push back at this point
         brillig_context.memory_op_instruction(
             target_vector_items_pointer,
             source_size.address,
             write_pointer_return,
             BrilligBinaryOp::Add,
         );
-    } else {
-        brillig_context.mov_instruction(write_pointer_return, target_vector_items_pointer);
 
+        brillig_context.deallocate_single_addr(was_reused);
+    } else {
+        // If push front we need to shift the items independently of it being reused or not
+        let target_start = brillig_context.allocate_register();
         brillig_context.memory_op_instruction(
             target_vector_items_pointer,
             item_push_count_arg,
-            target_vector_items_pointer,
+            target_start,
             BrilligBinaryOp::Add,
         );
-
-        brillig_context.codegen_mem_copy(
-            source_vector_items_pointer,
-            target_vector_items_pointer,
+        brillig_context.codegen_mem_copy_from_the_end(
+            source_items_pointer.address,
+            target_start,
             source_size,
         );
+        brillig_context.deallocate_register(target_start);
+        brillig_context.mov_instruction(write_pointer_return, target_vector_items_pointer);
     }
 
+    brillig_context.deallocate_single_addr(source_rc);
     brillig_context.deallocate_single_addr(source_size);
+    brillig_context.deallocate_single_addr(source_capacity);
+    brillig_context.deallocate_single_addr(source_items_pointer);
     brillig_context.deallocate_single_addr(target_size);
-    brillig_context.deallocate_register(source_vector_items_pointer);
     brillig_context.deallocate_register(target_vector_items_pointer);
 }
+
+/// Reallocates the target vector for insertion, skipping reallocation if the source vector can be reused.
+/// If it doesn't fit capacity we will reallocate the vector to double the capacity.
+/// Does not copy the items, only reallocates the vector.
+pub(crate) fn reallocate_vector_for_insertion<
+    F: AcirField + DebugToString,
+    Registers: RegisterAllocator,
+>(
+    brillig_context: &mut BrilligContext<F, Registers>,
+    source_vector: BrilligVector,
+    source_rc: SingleAddrVariable,
+    source_capacity: SingleAddrVariable,
+    target_vector: BrilligVector,
+    target_size: SingleAddrVariable,
+) {
+    let does_capacity_fit = SingleAddrVariable::new(brillig_context.allocate_register(), 1);
+    brillig_context.memory_op_instruction(
+        target_size.address,
+        source_capacity.address,
+        does_capacity_fit.address,
+        BrilligBinaryOp::LessThanEquals,
+    );
+
+    let is_rc_one = SingleAddrVariable::new(brillig_context.allocate_register(), 1);
+    brillig_context.codegen_usize_op(
+        source_rc.address,
+        is_rc_one.address,
+        BrilligBinaryOp::Equals,
+        1,
+    );
+
+    // Reallocate target vector for insertion
+    brillig_context.codegen_branch(
+        does_capacity_fit.address,
+        |brillig_context, does_capacity_fit| {
+            if does_capacity_fit {
+                brillig_context.codegen_branch(is_rc_one.address, |brillig_context, is_rc_one| {
+                    if is_rc_one {
+                        // We can insert in place, so we can just move the source pointer to the destination pointer and update the length
+                        brillig_context
+                            .mov_instruction(target_vector.pointer, source_vector.pointer);
+                        brillig_context.codegen_update_vector_length(target_vector, target_size);
+                    } else {
+                        brillig_context.codegen_initialize_vector(
+                            target_vector,
+                            target_size,
+                            Some(source_capacity),
+                        );
+                    }
+                });
+            } else {
+                let double_size =
+                    SingleAddrVariable::new_usize(brillig_context.allocate_register());
+                brillig_context.codegen_usize_op(
+                    target_size.address,
+                    double_size.address,
+                    BrilligBinaryOp::Mul,
+                    2_usize,
+                );
+                brillig_context.codegen_initialize_vector(
+                    target_vector,
+                    target_size,
+                    Some(double_size),
+                );
+                brillig_context.deallocate_single_addr(double_size);
+            }
+        },
+    );
+
+    brillig_context.deallocate_single_addr(is_rc_one);
+    brillig_context.deallocate_single_addr(does_capacity_fit);
+}
diff --git a/compiler/noirc_evaluator/src/brillig/brillig_ir/procedures/revert_with_string.rs b/compiler/noirc_evaluator/src/brillig/brillig_ir/procedures/revert_with_string.rs
new file mode 100644
index 00000000000..83d7dfc618d
--- /dev/null
+++ b/compiler/noirc_evaluator/src/brillig/brillig_ir/procedures/revert_with_string.rs
@@ -0,0 +1,23 @@
+use acvm::AcirField;
+
+use super::ProcedureId;
+use crate::brillig::brillig_ir::{
+    debug_show::DebugToString,
+    registers::{RegisterAllocator, ScratchSpace},
+    BrilligContext,
+};
+
+impl<F: AcirField + DebugToString, Registers: RegisterAllocator> BrilligContext<F, Registers> {
+    /// Reverts with the error selector of the given string
+    /// This procedure is useful to deduplicate generating code for the same selector.
+    pub(crate) fn call_revert_with_string_procedure(&mut self, revert_string: String) {
+        self.add_procedure_call_instruction(ProcedureId::RevertWithString(revert_string));
+    }
+}
+
+pub(super) fn compile_revert_with_string_procedure<F: AcirField + DebugToString>(
+    brillig_context: &mut BrilligContext<F, ScratchSpace>,
+    revert_string: String,
+) {
+    brillig_context.revert_with_string(revert_string);
+}
diff --git a/compiler/noirc_evaluator/src/brillig/brillig_ir/procedures/vector_copy.rs b/compiler/noirc_evaluator/src/brillig/brillig_ir/procedures/vector_copy.rs
index 87895a975f8..6d2f9c4afb4 100644
--- a/compiler/noirc_evaluator/src/brillig/brillig_ir/procedures/vector_copy.rs
+++ b/compiler/noirc_evaluator/src/brillig/brillig_ir/procedures/vector_copy.rs
@@ -18,8 +18,8 @@ impl<F: AcirField + DebugToString, Registers: RegisterAllocator> BrilligContext<
         source_vector: BrilligVector,
         destination_vector: BrilligVector,
     ) {
-        let source_vector_pointer_arg = MemoryAddress::from(ScratchSpace::start());
-        let new_vector_pointer_return = MemoryAddress::from(ScratchSpace::start() + 1);
+        let source_vector_pointer_arg = MemoryAddress::direct(ScratchSpace::start());
+        let new_vector_pointer_return = MemoryAddress::direct(ScratchSpace::start() + 1);
 
         self.mov_instruction(source_vector_pointer_arg, source_vector.pointer);
 
@@ -32,8 +32,8 @@ impl<F: AcirField + DebugToString, Registers: RegisterAllocator> BrilligContext<
 pub(super) fn compile_vector_copy_procedure<F: AcirField + DebugToString>(
     brillig_context: &mut BrilligContext<F, ScratchSpace>,
 ) {
-    let source_vector_pointer_arg = MemoryAddress::from(ScratchSpace::start());
-    let new_vector_pointer_return = MemoryAddress::from(ScratchSpace::start() + 1);
+    let source_vector_pointer_arg = MemoryAddress::direct(ScratchSpace::start());
+    let new_vector_pointer_return = MemoryAddress::direct(ScratchSpace::start() + 1);
 
     brillig_context
         .set_allocated_registers(vec![source_vector_pointer_arg, new_vector_pointer_return]);
@@ -53,8 +53,8 @@ pub(super) fn compile_vector_copy_procedure<F: AcirField + DebugToString>(
             let result_vector = BrilligVector { pointer: new_vector_pointer_return };
 
             // Allocate the memory for the new vec
-            let allocation_size = ctx.codegen_make_vector_length(source_vector);
-            ctx.codegen_usize_op_in_place(allocation_size.address, BrilligBinaryOp::Add, 2_usize);
+            let allocation_size = ctx.codegen_make_vector_capacity(source_vector);
+            ctx.codegen_usize_op_in_place(allocation_size.address, BrilligBinaryOp::Add, 3_usize); // Capacity plus 3 (rc, len, cap)
             ctx.codegen_allocate_mem(result_vector.pointer, allocation_size.address);
 
             ctx.codegen_mem_copy(source_vector.pointer, result_vector.pointer, allocation_size);
diff --git a/compiler/noirc_evaluator/src/brillig/brillig_ir/procedures/vector_pop.rs b/compiler/noirc_evaluator/src/brillig/brillig_ir/procedures/vector_pop.rs
deleted file mode 100644
index bb14ffac6be..00000000000
--- a/compiler/noirc_evaluator/src/brillig/brillig_ir/procedures/vector_pop.rs
+++ /dev/null
@@ -1,113 +0,0 @@
-use std::vec;
-
-use acvm::{acir::brillig::MemoryAddress, AcirField};
-
-use super::ProcedureId;
-use crate::brillig::brillig_ir::{
-    brillig_variable::{BrilligVector, SingleAddrVariable},
-    debug_show::DebugToString,
-    registers::{RegisterAllocator, ScratchSpace},
-    BrilligBinaryOp, BrilligContext,
-};
-
-impl<F: AcirField + DebugToString, Registers: RegisterAllocator> BrilligContext<F, Registers> {
-    /// Pops items from the vector, returning the new vector and the pointer to the popped items in read_pointer.
-    pub(crate) fn call_vector_pop_procedure(
-        &mut self,
-        source_vector: BrilligVector,
-        destination_vector: BrilligVector,
-        read_pointer: MemoryAddress,
-        item_pop_count: usize,
-        back: bool,
-    ) {
-        let source_vector_pointer_arg = MemoryAddress::from(ScratchSpace::start());
-        let item_pop_count_arg = MemoryAddress::from(ScratchSpace::start() + 1);
-        let new_vector_pointer_return = MemoryAddress::from(ScratchSpace::start() + 2);
-        let read_pointer_return = MemoryAddress::from(ScratchSpace::start() + 3);
-
-        self.mov_instruction(source_vector_pointer_arg, source_vector.pointer);
-        self.usize_const_instruction(item_pop_count_arg, item_pop_count.into());
-
-        self.add_procedure_call_instruction(ProcedureId::VectorPop(back));
-
-        self.mov_instruction(destination_vector.pointer, new_vector_pointer_return);
-        self.mov_instruction(read_pointer, read_pointer_return);
-    }
-}
-
-pub(super) fn compile_vector_pop_procedure<F: AcirField + DebugToString>(
-    brillig_context: &mut BrilligContext<F, ScratchSpace>,
-    pop_back: bool,
-) {
-    let source_vector_pointer_arg = MemoryAddress::from(ScratchSpace::start());
-    let item_pop_count_arg = MemoryAddress::from(ScratchSpace::start() + 1);
-    let new_vector_pointer_return = MemoryAddress::from(ScratchSpace::start() + 2);
-    let read_pointer_return = MemoryAddress::from(ScratchSpace::start() + 3);
-
-    brillig_context.set_allocated_registers(vec![
-        source_vector_pointer_arg,
-        item_pop_count_arg,
-        new_vector_pointer_return,
-        read_pointer_return,
-    ]);
-
-    let source_vector = BrilligVector { pointer: source_vector_pointer_arg };
-    let target_vector = BrilligVector { pointer: new_vector_pointer_return };
-
-    // First we need to allocate the target vector decrementing the size by removed_items.len()
-    let source_size = brillig_context.codegen_make_vector_length(source_vector);
-
-    let target_size = SingleAddrVariable::new_usize(brillig_context.allocate_register());
-    brillig_context.memory_op_instruction(
-        source_size.address,
-        item_pop_count_arg,
-        target_size.address,
-        BrilligBinaryOp::Sub,
-    );
-
-    brillig_context.codegen_initialize_vector(target_vector, target_size);
-
-    // Now we offset the source pointer by removed_items.len()
-    let source_vector_items_pointer =
-        brillig_context.codegen_make_vector_items_pointer(source_vector);
-    let target_vector_items_pointer =
-        brillig_context.codegen_make_vector_items_pointer(target_vector);
-
-    if pop_back {
-        // Now we copy the source vector starting at index 0 into the target vector
-        brillig_context.codegen_mem_copy(
-            source_vector_items_pointer,
-            target_vector_items_pointer,
-            target_size,
-        );
-        brillig_context.memory_op_instruction(
-            source_vector_items_pointer,
-            target_size.address,
-            read_pointer_return,
-            BrilligBinaryOp::Add,
-        );
-    } else {
-        let source_copy_pointer = brillig_context.allocate_register();
-        brillig_context.memory_op_instruction(
-            source_vector_items_pointer,
-            item_pop_count_arg,
-            source_copy_pointer,
-            BrilligBinaryOp::Add,
-        );
-
-        // Now we copy the source vector starting at index removed_items.len() into the target vector
-        brillig_context.codegen_mem_copy(
-            source_copy_pointer,
-            target_vector_items_pointer,
-            target_size,
-        );
-        brillig_context.mov_instruction(read_pointer_return, source_vector_items_pointer);
-
-        brillig_context.deallocate_register(source_copy_pointer);
-    }
-
-    brillig_context.deallocate_single_addr(source_size);
-    brillig_context.deallocate_single_addr(target_size);
-    brillig_context.deallocate_register(source_vector_items_pointer);
-    brillig_context.deallocate_register(target_vector_items_pointer);
-}
diff --git a/compiler/noirc_evaluator/src/brillig/brillig_ir/procedures/vector_pop_back.rs b/compiler/noirc_evaluator/src/brillig/brillig_ir/procedures/vector_pop_back.rs
new file mode 100644
index 00000000000..bfc9d512852
--- /dev/null
+++ b/compiler/noirc_evaluator/src/brillig/brillig_ir/procedures/vector_pop_back.rs
@@ -0,0 +1,109 @@
+use std::vec;
+
+use acvm::{acir::brillig::MemoryAddress, AcirField};
+
+use super::ProcedureId;
+use crate::brillig::brillig_ir::{
+    brillig_variable::{BrilligVector, SingleAddrVariable},
+    debug_show::DebugToString,
+    registers::{RegisterAllocator, ScratchSpace},
+    BrilligBinaryOp, BrilligContext,
+};
+
+impl<F: AcirField + DebugToString, Registers: RegisterAllocator> BrilligContext<F, Registers> {
+    /// Pops items from the back of a vector, returning the new vector and the pointer to the popped items in read_pointer.
+    pub(crate) fn call_vector_pop_back_procedure(
+        &mut self,
+        source_vector: BrilligVector,
+        destination_vector: BrilligVector,
+        read_pointer: MemoryAddress,
+        item_pop_count: usize,
+    ) {
+        let source_vector_pointer_arg = MemoryAddress::direct(ScratchSpace::start());
+        let item_pop_count_arg = MemoryAddress::direct(ScratchSpace::start() + 1);
+        let new_vector_pointer_return = MemoryAddress::direct(ScratchSpace::start() + 2);
+        let read_pointer_return = MemoryAddress::direct(ScratchSpace::start() + 3);
+
+        self.mov_instruction(source_vector_pointer_arg, source_vector.pointer);
+        self.usize_const_instruction(item_pop_count_arg, item_pop_count.into());
+
+        self.add_procedure_call_instruction(ProcedureId::VectorPopBack);
+
+        self.mov_instruction(destination_vector.pointer, new_vector_pointer_return);
+        self.mov_instruction(read_pointer, read_pointer_return);
+    }
+}
+
+pub(super) fn compile_vector_pop_back_procedure<F: AcirField + DebugToString>(
+    brillig_context: &mut BrilligContext<F, ScratchSpace>,
+) {
+    let source_vector_pointer_arg = MemoryAddress::direct(ScratchSpace::start());
+    let item_pop_count_arg = MemoryAddress::direct(ScratchSpace::start() + 1);
+    let new_vector_pointer_return = MemoryAddress::direct(ScratchSpace::start() + 2);
+    let read_pointer_return = MemoryAddress::direct(ScratchSpace::start() + 3);
+
+    brillig_context.set_allocated_registers(vec![
+        source_vector_pointer_arg,
+        item_pop_count_arg,
+        new_vector_pointer_return,
+        read_pointer_return,
+    ]);
+
+    let source_vector = BrilligVector { pointer: source_vector_pointer_arg };
+    let target_vector = BrilligVector { pointer: new_vector_pointer_return };
+
+    // First we need to allocate the target vector decrementing the size by removed_items.len()
+    let source_size = brillig_context.codegen_make_vector_length(source_vector);
+
+    let target_size = SingleAddrVariable::new_usize(brillig_context.allocate_register());
+    brillig_context.memory_op_instruction(
+        source_size.address,
+        item_pop_count_arg,
+        target_size.address,
+        BrilligBinaryOp::Sub,
+    );
+
+    let rc = brillig_context.allocate_register();
+    brillig_context.load_instruction(rc, source_vector.pointer);
+    let is_rc_one = brillig_context.allocate_register();
+    brillig_context.codegen_usize_op(rc, is_rc_one, BrilligBinaryOp::Equals, 1_usize);
+
+    let source_vector_items_pointer =
+        brillig_context.codegen_make_vector_items_pointer(source_vector);
+
+    brillig_context.codegen_branch(is_rc_one, |brillig_context, is_rc_one| {
+        if is_rc_one {
+            // We can reuse the source vector updating its length
+            brillig_context.mov_instruction(target_vector.pointer, source_vector.pointer);
+            brillig_context.codegen_update_vector_length(target_vector, target_size);
+        } else {
+            // We need to clone the source vector
+            brillig_context.codegen_initialize_vector(target_vector, target_size, None);
+
+            let target_vector_items_pointer =
+                brillig_context.codegen_make_vector_items_pointer(target_vector);
+
+            // Now we copy the source vector starting at index 0 into the target vector but with the reduced length
+            brillig_context.codegen_mem_copy(
+                source_vector_items_pointer,
+                target_vector_items_pointer,
+                target_size,
+            );
+            brillig_context.deallocate_register(target_vector_items_pointer);
+        }
+    });
+
+    brillig_context.memory_op_instruction(
+        source_vector_items_pointer,
+        target_size.address,
+        read_pointer_return,
+        BrilligBinaryOp::Add,
+    );
+
+    brillig_context.deallocate_register(rc);
+    brillig_context.deallocate_register(is_rc_one);
+    brillig_context.deallocate_register(source_vector_items_pointer);
+
+    brillig_context.deallocate_single_addr(source_size);
+    brillig_context.deallocate_single_addr(target_size);
+}
diff --git a/compiler/noirc_evaluator/src/brillig/brillig_ir/procedures/vector_pop_front.rs b/compiler/noirc_evaluator/src/brillig/brillig_ir/procedures/vector_pop_front.rs
new file mode 100644
index 00000000000..49123ca2f50
--- /dev/null
+++ b/compiler/noirc_evaluator/src/brillig/brillig_ir/procedures/vector_pop_front.rs
@@ -0,0 +1,130 @@
+use std::vec;
+
+use acvm::{acir::brillig::MemoryAddress, AcirField};
+
+use super::ProcedureId;
+use crate::brillig::brillig_ir::{
+    brillig_variable::{BrilligVector, SingleAddrVariable},
+    debug_show::DebugToString,
+    registers::{RegisterAllocator, ScratchSpace},
+    BrilligBinaryOp, BrilligContext,
+};
+
+impl<F: AcirField + DebugToString, Registers: RegisterAllocator> BrilligContext<F, Registers> {
+    /// Pops items from the front of a vector, returning the new vector
+    pub(crate) fn call_vector_pop_front_procedure(
+        &mut self,
+        source_vector: BrilligVector,
+        destination_vector: BrilligVector,
+        item_pop_count: usize,
+    ) {
+        let source_vector_pointer_arg = MemoryAddress::direct(ScratchSpace::start());
+        let item_pop_count_arg = MemoryAddress::direct(ScratchSpace::start() + 1);
+        let new_vector_pointer_return = MemoryAddress::direct(ScratchSpace::start() + 2);
+
+        self.mov_instruction(source_vector_pointer_arg, source_vector.pointer);
+        self.usize_const_instruction(item_pop_count_arg, item_pop_count.into());
+
+        self.add_procedure_call_instruction(ProcedureId::VectorPopFront);
+
+        self.mov_instruction(destination_vector.pointer, new_vector_pointer_return);
+    }
+}
+
+pub(super) fn compile_vector_pop_front_procedure<F: AcirField + DebugToString>(
+    brillig_context: &mut BrilligContext<F, ScratchSpace>,
+) {
+    let source_vector_pointer_arg = MemoryAddress::direct(ScratchSpace::start());
+    let item_pop_count_arg = MemoryAddress::direct(ScratchSpace::start() + 1);
+    let new_vector_pointer_return = MemoryAddress::direct(ScratchSpace::start() + 2);
+
+    brillig_context.set_allocated_registers(vec![
+        source_vector_pointer_arg,
+        item_pop_count_arg,
+        new_vector_pointer_return,
+    ]);
+
+    let source_vector = BrilligVector { pointer: source_vector_pointer_arg };
+    let target_vector = BrilligVector { pointer: new_vector_pointer_return };
+
+    let source_rc = SingleAddrVariable::new_usize(brillig_context.allocate_register());
+    let source_size = SingleAddrVariable::new_usize(brillig_context.allocate_register());
+    let source_capacity = SingleAddrVariable::new_usize(brillig_context.allocate_register());
+    let source_items_pointer = SingleAddrVariable::new_usize(brillig_context.allocate_register());
+    brillig_context.codegen_read_vector_metadata(
+        source_vector,
+        source_rc,
+        source_size,
+        source_capacity,
+        source_items_pointer,
+    );
+
+    // target_size = source_size - item_pop_count
+    let target_size = SingleAddrVariable::new_usize(brillig_context.allocate_register());
+    brillig_context.memory_op_instruction(
+        source_size.address,
+        item_pop_count_arg,
+        target_size.address,
+        BrilligBinaryOp::Sub,
+    );
+
+    let is_rc_one = brillig_context.allocate_register();
+    brillig_context.codegen_usize_op(
+        source_rc.address,
+        is_rc_one,
+        BrilligBinaryOp::Equals,
+        1_usize,
+    );
+
+    brillig_context.codegen_branch(is_rc_one, |brillig_context, is_rc_one| {
+        if is_rc_one {
+            // We reuse the source vector, moving the metadata to the right (decreasing capacity)
+            brillig_context.memory_op_instruction(
+                source_vector.pointer,
+                item_pop_count_arg,
+                target_vector.pointer,
+                BrilligBinaryOp::Add,
+            );
+            brillig_context.memory_op_instruction(
+                source_capacity.address,
+                item_pop_count_arg,
+                source_capacity.address,
+                BrilligBinaryOp::Sub,
+            );
+            brillig_context.codegen_initialize_vector_metadata(
+                target_vector,
+                target_size,
+                Some(source_capacity),
+            );
+        } else {
+            brillig_context.codegen_initialize_vector(target_vector, target_size, None);
+
+            let target_vector_items_pointer =
+                brillig_context.codegen_make_vector_items_pointer(target_vector);
+
+            let source_copy_pointer = brillig_context.allocate_register();
+            brillig_context.memory_op_instruction(
+                source_items_pointer.address,
+                item_pop_count_arg,
+                source_copy_pointer,
+                BrilligBinaryOp::Add,
+            );
+            // Now we copy the source vector starting at index removed_items.len() into the target vector
+            brillig_context.codegen_mem_copy(
+                source_copy_pointer,
+                target_vector_items_pointer,
+                target_size,
+            );
+
+            brillig_context.deallocate_register(source_copy_pointer);
+            brillig_context.deallocate_register(target_vector_items_pointer);
+        }
+    });
+
+    brillig_context.deallocate_register(is_rc_one);
+    brillig_context.deallocate_single_addr(target_size);
+    brillig_context.deallocate_single_addr(source_rc);
+    brillig_context.deallocate_single_addr(source_size);
+    brillig_context.deallocate_single_addr(source_capacity);
+    brillig_context.deallocate_single_addr(source_items_pointer);
+}
diff --git a/compiler/noirc_evaluator/src/brillig/brillig_ir/procedures/vector_remove.rs b/compiler/noirc_evaluator/src/brillig/brillig_ir/procedures/vector_remove.rs
index d4a7217677f..7abc43286ee 100644
--- a/compiler/noirc_evaluator/src/brillig/brillig_ir/procedures/vector_remove.rs
+++ b/compiler/noirc_evaluator/src/brillig/brillig_ir/procedures/vector_remove.rs
@@ -19,10 +19,10 @@ impl<F: AcirField + DebugToString, Registers: RegisterAllocator> BrilligContext<
         index: SingleAddrVariable,
         item_count: usize,
     ) {
-        let source_vector_pointer_arg = MemoryAddress::from(ScratchSpace::start());
-        let index_arg = MemoryAddress::from(ScratchSpace::start() + 1);
-        let item_count_arg = MemoryAddress::from(ScratchSpace::start() + 2);
-        let new_vector_pointer_return = MemoryAddress::from(ScratchSpace::start() + 3);
+        let source_vector_pointer_arg = MemoryAddress::direct(ScratchSpace::start());
+        let index_arg = MemoryAddress::direct(ScratchSpace::start() + 1);
+        let item_count_arg = MemoryAddress::direct(ScratchSpace::start() + 2);
+        let new_vector_pointer_return = MemoryAddress::direct(ScratchSpace::start() + 3);
 
         self.mov_instruction(source_vector_pointer_arg, source_vector.pointer);
         self.mov_instruction(index_arg, index.address);
@@ -37,10 +37,10 @@ impl<F: AcirField + DebugToString, Registers: RegisterAllocator> BrilligContext<
 pub(super) fn compile_vector_remove_procedure<F: AcirField + DebugToString>(
     brillig_context: &mut BrilligContext<F, ScratchSpace>,
 ) {
-    let source_vector_pointer_arg = MemoryAddress::from(ScratchSpace::start());
-    let index_arg = MemoryAddress::from(ScratchSpace::start() + 1);
-    let item_count_arg = MemoryAddress::from(ScratchSpace::start() + 2);
-    let new_vector_pointer_return = MemoryAddress::from(ScratchSpace::start() + 3);
+    let source_vector_pointer_arg = MemoryAddress::direct(ScratchSpace::start());
+    let index_arg = MemoryAddress::direct(ScratchSpace::start() + 1);
+    let item_count_arg = MemoryAddress::direct(ScratchSpace::start() + 2);
+    let new_vector_pointer_return = MemoryAddress::direct(ScratchSpace::start() + 3);
 
     brillig_context.set_allocated_registers(vec![
         source_vector_pointer_arg,
@@ -53,7 +53,7 @@ pub(super) fn compile_vector_remove_procedure<F: AcirField + DebugToString>(
     let target_vector = BrilligVector { pointer: new_vector_pointer_return };
     let index = SingleAddrVariable::new_usize(index_arg);
 
-    // First we need to allocate the target vector decrementing the size by removed_items.len()
+    // Reallocate if necessary
     let source_size = brillig_context.codegen_make_vector_length(source_vector);
 
     let target_size = SingleAddrVariable::new_usize(brillig_context.allocate_register());
@@ -64,19 +64,36 @@ pub(super) fn compile_vector_remove_procedure<F: AcirField + DebugToString>(
         BrilligBinaryOp::Sub,
     );
 
-    brillig_context.codegen_initialize_vector(target_vector, target_size);
+    let rc = brillig_context.allocate_register();
+    brillig_context.load_instruction(rc, source_vector.pointer);
+    let is_rc_one = brillig_context.allocate_register();
+    brillig_context.codegen_usize_op(rc, is_rc_one, BrilligBinaryOp::Equals, 1_usize);
 
-    // Copy the elements to the left of the index
     let source_vector_items_pointer =
         brillig_context.codegen_make_vector_items_pointer(source_vector);
-    let target_vector_items_pointer =
-        brillig_context.codegen_make_vector_items_pointer(target_vector);
 
-    brillig_context.codegen_mem_copy(
-        source_vector_items_pointer,
-        target_vector_items_pointer,
-        index,
-    );
+    let target_vector_items_pointer = brillig_context.allocate_register();
+
+    brillig_context.codegen_branch(is_rc_one, |brillig_context, is_rc_one| {
+        if is_rc_one {
+            brillig_context.mov_instruction(target_vector.pointer, source_vector.pointer);
+            brillig_context.codegen_update_vector_length(target_vector, target_size);
+            brillig_context
+                .codegen_vector_items_pointer(target_vector, target_vector_items_pointer);
+        } else {
+            brillig_context.codegen_initialize_vector(target_vector, target_size, None);
+
+            // Copy the elements to the left of the index
+            brillig_context
+                .codegen_vector_items_pointer(target_vector, target_vector_items_pointer);
+
+            brillig_context.codegen_mem_copy(
+                source_vector_items_pointer,
+                target_vector_items_pointer,
+                index,
+            );
+        }
+    });
 
     // Compute the source pointer after the removed items
     let source_pointer_after_index = brillig_context.allocate_register();
@@ -124,6 +141,8 @@ pub(super) fn compile_vector_remove_procedure<F: AcirField + DebugToString>(
         SingleAddrVariable::new_usize(item_count),
     );
 
+    brillig_context.deallocate_register(rc);
+    brillig_context.deallocate_register(is_rc_one);
     brillig_context.deallocate_register(source_pointer_after_index);
     brillig_context.deallocate_register(target_pointer_at_index);
     brillig_context.deallocate_register(item_count);
diff --git a/compiler/noirc_evaluator/src/brillig/brillig_ir/registers.rs b/compiler/noirc_evaluator/src/brillig/brillig_ir/registers.rs
index 75fb60fc9f2..dd7766f40aa 100644
--- a/compiler/noirc_evaluator/src/brillig/brillig_ir/registers.rs
+++ b/compiler/noirc_evaluator/src/brillig/brillig_ir/registers.rs
@@ -1,10 +1,14 @@
+use std::collections::BTreeSet;
+
 use acvm::acir::brillig::{HeapArray, HeapVector, MemoryAddress};
+use iter_extended::vecmap;
 
 use crate::brillig::brillig_ir::entry_point::MAX_STACK_SIZE;
 
 use super::{
-    brillig_variable::SingleAddrVariable, entry_point::MAX_SCRATCH_SPACE, BrilligContext,
-    ReservedRegisters,
+    brillig_variable::SingleAddrVariable,
+    entry_point::{MAX_SCRATCH_SPACE, MAX_STACK_FRAME_SIZE},
+    BrilligContext, ReservedRegisters,
 };
 
 pub(crate) trait RegisterAllocator {
@@ -34,33 +38,37 @@ impl Stack {
     }
 
     fn is_within_bounds(register: MemoryAddress) -> bool {
-        let index = register.to_usize();
-        index >= Self::start() && index < Self::end()
+        let offset = register.unwrap_relative();
+        offset >= Self::start() && offset < Self::end()
+    }
+
+    pub(crate) fn empty_stack_start(&self) -> MemoryAddress {
+        MemoryAddress::relative(self.storage.empty_registers_start(Self::start()))
     }
 }
 
 impl RegisterAllocator for Stack {
     fn start() -> usize {
-        ReservedRegisters::len()
+        1 // Previous stack pointer is the first stack item
     }
 
     fn end() -> usize {
-        ReservedRegisters::len() + MAX_STACK_SIZE
+        MAX_STACK_FRAME_SIZE
     }
 
     fn ensure_register_is_allocated(&mut self, register: MemoryAddress) {
         assert!(Self::is_within_bounds(register), "Register out of stack bounds");
-        self.storage.ensure_register_is_allocated(register);
+        self.storage.ensure_register_is_allocated(register.unwrap_relative());
     }
 
     fn allocate_register(&mut self) -> MemoryAddress {
-        let allocated = self.storage.allocate_register();
-        assert!(Self::is_within_bounds(allocated), "Stack too deep");
+        let allocated = MemoryAddress::relative(self.storage.allocate_register());
+        assert!(Self::is_within_bounds(allocated), "Stack frame too deep");
         allocated
     }
 
     fn deallocate_register(&mut self, register_index: MemoryAddress) {
-        self.storage.deallocate_register(register_index);
+        self.storage.deallocate_register(register_index.unwrap_relative());
     }
 
     fn from_preallocated_registers(preallocated_registers: Vec<MemoryAddress>) -> Self {
@@ -71,7 +79,7 @@ impl RegisterAllocator for Stack {
         Self {
             storage: DeallocationListAllocator::from_preallocated_registers(
                 Self::start(),
-                preallocated_registers,
+                vecmap(preallocated_registers, |r| r.unwrap_relative()),
             ),
         }
     }
@@ -90,7 +98,7 @@ impl ScratchSpace {
     }
 
     fn is_within_bounds(register: MemoryAddress) -> bool {
-        let index = register.to_usize();
+        let index = register.unwrap_direct();
         index >= Self::start() && index < Self::end()
     }
 }
@@ -106,17 +114,17 @@ impl RegisterAllocator for ScratchSpace {
 
     fn ensure_register_is_allocated(&mut self, register: MemoryAddress) {
         assert!(Self::is_within_bounds(register), "Register out of scratch space bounds");
-        self.storage.ensure_register_is_allocated(register);
+        self.storage.ensure_register_is_allocated(register.unwrap_direct());
     }
 
     fn allocate_register(&mut self) -> MemoryAddress {
-        let allocated = self.storage.allocate_register();
+        let allocated = MemoryAddress::direct(self.storage.allocate_register());
         assert!(Self::is_within_bounds(allocated), "Scratch space too deep");
         allocated
     }
 
     fn deallocate_register(&mut self, register_index: MemoryAddress) {
-        self.storage.deallocate_register(register_index);
+        self.storage.deallocate_register(register_index.unwrap_direct());
     }
 
     fn from_preallocated_registers(preallocated_registers: Vec<MemoryAddress>) -> Self {
@@ -127,7 +135,7 @@ impl RegisterAllocator for ScratchSpace {
         Self {
             storage: DeallocationListAllocator::from_preallocated_registers(
                 Self::start(),
-                preallocated_registers,
+                vecmap(preallocated_registers, |r| r.unwrap_direct()),
             ),
         }
     }
@@ -135,75 +143,77 @@ impl RegisterAllocator for ScratchSpace {
 
 struct DeallocationListAllocator {
     /// A free-list of registers that have been deallocated and can be used again.
-    deallocated_registers: Vec<MemoryAddress>,
+    deallocated_registers: BTreeSet<usize>,
     /// A usize indicating the next un-used register.
     next_free_register_index: usize,
 }
 
 impl DeallocationListAllocator {
     fn new(start: usize) -> Self {
-        Self { deallocated_registers: Vec::new(), next_free_register_index: start }
+        Self { deallocated_registers: BTreeSet::new(), next_free_register_index: start }
     }
 
-    fn ensure_register_is_allocated(&mut self, register: MemoryAddress) {
-        let index = register.to_usize();
+    fn ensure_register_is_allocated(&mut self, index: usize) {
         if index < self.next_free_register_index {
             // If it could be allocated, check if it's in the deallocated list and remove it from there
-            self.deallocated_registers.retain(|&r| r != register);
+            self.deallocated_registers.retain(|&r| r != index);
         } else {
             // If it couldn't yet be, expand the register space.
             self.next_free_register_index = index + 1;
         }
     }
 
-    fn allocate_register(&mut self) -> MemoryAddress {
+    fn allocate_register(&mut self) -> usize {
         // If we have a register in our free list of deallocated registers,
         // consume it first. This prioritizes reuse.
-        if let Some(register) = self.deallocated_registers.pop() {
+        if let Some(register) = self.deallocated_registers.pop_first() {
             return register;
         }
         // Otherwise, move to our latest register.
-        let register = MemoryAddress::from(self.next_free_register_index);
+        let register = self.next_free_register_index;
         self.next_free_register_index += 1;
         register
     }
 
-    fn deallocate_register(&mut self, register_index: MemoryAddress) {
+    fn deallocate_register(&mut self, register_index: usize) {
         assert!(!self.deallocated_registers.contains(&register_index));
-        self.deallocated_registers.push(register_index);
+        self.deallocated_registers.insert(register_index);
     }
 
-    fn from_preallocated_registers(
-        start: usize,
-        preallocated_registers: Vec<MemoryAddress>,
-    ) -> Self {
+    fn from_preallocated_registers(start: usize, preallocated_registers: Vec<usize>) -> Self {
         let next_free_register_index = preallocated_registers.iter().fold(
             start,
-            |free_register_index, preallocated_register| {
-                if preallocated_register.to_usize() < free_register_index {
+            |free_register_index, &preallocated_register| {
+                if preallocated_register < free_register_index {
                     free_register_index
                 } else {
-                    preallocated_register.to_usize() + 1
+                    preallocated_register + 1
                 }
             },
         );
-        let mut deallocated_registers = Vec::new();
+        let mut deallocated_registers = BTreeSet::new();
         for i in start..next_free_register_index {
-            if !preallocated_registers.contains(&MemoryAddress::from(i)) {
-                deallocated_registers.push(MemoryAddress::from(i));
+            if !preallocated_registers.contains(&i) {
+                deallocated_registers.insert(i);
             }
         }
 
         Self { deallocated_registers, next_free_register_index }
     }
-}
 
-impl<F, Registers: RegisterAllocator> BrilligContext<F, Registers> {
-    /// Returns the i'th register after the reserved ones
-    pub(crate) fn stack_register(&self, i: usize) -> MemoryAddress {
-        MemoryAddress::from(ReservedRegisters::NUM_RESERVED_REGISTERS + i)
+    fn empty_registers_start(&self, start: usize) -> usize {
+        let mut first_free = self.next_free_register_index;
+        while first_free > start {
+            if !self.deallocated_registers.contains(&(first_free - 1)) {
+                break;
+            }
+            first_free -= 1;
+        }
+        first_free
     }
+}
 
+impl<F, Registers: RegisterAllocator> BrilligContext<F, Registers> {
     /// Allocates an unused register.
     pub(crate) fn allocate_register(&mut self) -> MemoryAddress {
         self.registers.allocate_register()
@@ -232,3 +242,22 @@ impl<F, Registers: RegisterAllocator> BrilligContext<F, Registers> {
         self.deallocate_register(vec.size);
     }
 }
+
+#[cfg(test)]
+mod tests {
+    use crate::brillig::brillig_ir::registers::{RegisterAllocator, Stack};
+
+    #[test]
+    fn stack_should_prioritize_returning_low_registers() {
+        let mut stack = Stack::new();
+        let one = stack.allocate_register();
+        let _two = stack.allocate_register();
+        let three = stack.allocate_register();
+
+        stack.deallocate_register(three);
+        stack.deallocate_register(one);
+
+        let one_again = stack.allocate_register();
+        assert_eq!(one, one_again);
+    }
+}
diff --git a/compiler/noirc_evaluator/src/brillig/mod.rs b/compiler/noirc_evaluator/src/brillig/mod.rs
index 45b84f5311e..cb8c35cd8e0 100644
--- a/compiler/noirc_evaluator/src/brillig/mod.rs
+++ b/compiler/noirc_evaluator/src/brillig/mod.rs
@@ -12,12 +12,14 @@ use self::{
     },
 };
 use crate::ssa::{
-    ir::function::{Function, FunctionId, RuntimeType},
+    ir::function::{Function, FunctionId},
     ssa_gen::Ssa,
 };
 use fxhash::FxHashMap as HashMap;
 use std::{borrow::Cow, collections::BTreeSet};
 
+pub use self::brillig_ir::procedures::ProcedureId;
+
 /// Context structure for the brillig pass.
 /// It stores brillig-related data required for brillig generation.
 #[derive(Default)]
@@ -57,7 +59,7 @@ impl std::ops::Index<FunctionId> for Brillig {
 }
 
 impl Ssa {
-    /// Compile to brillig brillig functions and ACIR functions reachable from them
+    /// Compile Brillig functions and ACIR functions reachable from them
     #[tracing::instrument(level = "trace", skip_all)]
     pub(crate) fn to_brillig(&self, enable_debug_trace: bool) -> Brillig {
         // Collect all the function ids that are reachable from brillig
@@ -65,7 +67,7 @@ impl Ssa {
         let brillig_reachable_function_ids = self
             .functions
             .iter()
-            .filter_map(|(id, func)| (func.runtime() == RuntimeType::Brillig).then_some(*id))
+            .filter_map(|(id, func)| func.runtime().is_brillig().then_some(*id))
             .collect::<BTreeSet<_>>();
 
         let mut brillig = Brillig::default();
diff --git a/compiler/noirc_evaluator/src/errors.rs b/compiler/noirc_evaluator/src/errors.rs
index 994e97eabb8..bb224617994 100644
--- a/compiler/noirc_evaluator/src/errors.rs
+++ b/compiler/noirc_evaluator/src/errors.rs
@@ -63,7 +63,7 @@ pub enum RuntimeError {
     UnknownReference { call_stack: CallStack },
 }
 
-#[derive(Debug, Clone, Serialize, Deserialize)]
+#[derive(Debug, Clone, Serialize, Deserialize, Hash)]
 pub enum SsaReport {
     Warning(InternalWarning),
     Bug(InternalBug),
@@ -93,7 +93,10 @@ impl From<SsaReport> for FileDiagnostic {
                 let message = bug.to_string();
                 let (secondary_message, call_stack) = match bug {
                     InternalBug::IndependentSubgraph { call_stack } => {
-                        ("There is no path from the output of this brillig call to either return values or inputs of the circuit, which creates an independent subgraph. This is quite likely a soundness vulnerability".to_string(),call_stack)
+                        ("There is no path from the output of this Brillig call to either return values or inputs of the circuit, which creates an independent subgraph. This is quite likely a soundness vulnerability".to_string(), call_stack)
+                    }
+                    InternalBug::UncheckedBrilligCall { call_stack } => {
+                        ("This Brillig call's inputs and its return values haven't been sufficiently constrained. This should be done to prevent potential soundness vulnerabilities".to_string(), call_stack)
                     }
                     InternalBug::AssertFailed { call_stack } => ("As a result, the compiled circuit is ensured to fail. Other assertions may also fail during execution".to_string(), call_stack)
                 };
@@ -107,7 +110,7 @@ impl From<SsaReport> for FileDiagnostic {
     }
 }
 
-#[derive(Debug, PartialEq, Eq, Clone, Error, Serialize, Deserialize)]
+#[derive(Debug, PartialEq, Eq, Clone, Error, Serialize, Deserialize, Hash)]
 pub enum InternalWarning {
     #[error("Return variable contains a constant value")]
     ReturnConstant { call_stack: CallStack },
@@ -115,10 +118,12 @@ pub enum InternalWarning {
     VerifyProof { call_stack: CallStack },
 }
 
-#[derive(Debug, PartialEq, Eq, Clone, Error, Serialize, Deserialize)]
+#[derive(Debug, PartialEq, Eq, Clone, Error, Serialize, Deserialize, Hash)]
 pub enum InternalBug {
-    #[error("Input to brillig function is in a separate subgraph to output")]
+    #[error("Input to Brillig function is in a separate subgraph to output")]
     IndependentSubgraph { call_stack: CallStack },
+    #[error("Brillig function call isn't properly covered by a manual constraint")]
+    UncheckedBrilligCall { call_stack: CallStack },
     #[error("Assertion is always false")]
     AssertFailed { call_stack: CallStack },
 }
diff --git a/compiler/noirc_evaluator/src/lib.rs b/compiler/noirc_evaluator/src/lib.rs
index 54376963338..75ea557d3de 100644
--- a/compiler/noirc_evaluator/src/lib.rs
+++ b/compiler/noirc_evaluator/src/lib.rs
@@ -5,10 +5,44 @@
 
 pub mod errors;
 
-// SSA code to create the SSA based IR
-// for functions and execute different optimizations.
-pub mod ssa;
-
+mod acir;
 pub mod brillig;
+pub mod ssa;
 
 pub use ssa::create_program;
+pub use ssa::ir::instruction::ErrorType;
+
+/// Trims leading whitespace from each line of the input string
+#[cfg(test)]
+pub(crate) fn trim_leading_whitespace_from_lines(src: &str) -> String {
+    let mut lines = src.trim_end().lines();
+    let mut first_line = lines.next().unwrap();
+    while first_line.is_empty() {
+        first_line = lines.next().unwrap();
+    }
+    let mut result = first_line.trim_start().to_string();
+    for line in lines {
+        result.push('\n');
+        result.push_str(line.trim_start());
+    }
+    result
+}
+
+/// Trim comments from the lines, ie. content starting with `//`.
+#[cfg(test)]
+pub(crate) fn trim_comments_from_lines(src: &str) -> String {
+    let mut result = String::new();
+    let mut first = true;
+    for line in src.lines() {
+        if !first {
+            result.push('\n');
+        }
+        if let Some(comment) = line.find("//") {
+            result.push_str(line[..comment].trim_end());
+        } else {
+            result.push_str(line);
+        }
+        first = false;
+    }
+    result
+}
diff --git a/compiler/noirc_evaluator/src/ssa.rs b/compiler/noirc_evaluator/src/ssa.rs
index 6ad20b75999..dd3a13d6fb4 100644
--- a/compiler/noirc_evaluator/src/ssa.rs
+++ b/compiler/noirc_evaluator/src/ssa.rs
@@ -26,30 +26,34 @@ use acvm::{
     FieldElement,
 };
 
+use ir::instruction::ErrorType;
 use noirc_errors::debug_info::{DebugFunctions, DebugInfo, DebugTypes, DebugVariables};
 
 use noirc_frontend::ast::Visibility;
-use noirc_frontend::{
-    hir_def::{function::FunctionSignature, types::Type as HirType},
-    monomorphization::ast::Program,
-};
+use noirc_frontend::{hir_def::function::FunctionSignature, monomorphization::ast::Program};
+use ssa_gen::Ssa;
 use tracing::{span, Level};
 
-use self::{
-    acir_gen::{Artifacts, GeneratedAcir},
-    ssa_gen::Ssa,
-};
+use crate::acir::{Artifacts, GeneratedAcir};
 
-mod acir_gen;
 mod checks;
 pub(super) mod function_builder;
 pub mod ir;
 mod opt;
+#[cfg(test)]
+pub(crate) mod parser;
 pub mod ssa_gen;
 
+#[derive(Debug, Clone)]
+pub enum SsaLogging {
+    None,
+    All,
+    Contains(String),
+}
+
 pub struct SsaEvaluatorOptions {
     /// Emit debug information for the intermediate SSA IR
-    pub enable_ssa_logging: bool,
+    pub ssa_logging: SsaLogging,
 
     pub enable_brillig_logging: bool,
 
@@ -67,6 +71,17 @@ pub struct SsaEvaluatorOptions {
 
     /// Skip the check for under constrained values
     pub skip_underconstrained_check: bool,
+
+    /// Skip the missing Brillig call constraints check
+    pub skip_brillig_constraints_check: bool,
+
+    /// The higher the value, the more inlined Brillig functions will be.
+    pub inliner_aggressiveness: i64,
+
+    /// Maximum accepted percentage increase in the Brillig bytecode size after unrolling loops.
+    /// When `None` the size increase check is skipped altogether and any decrease in the SSA
+    /// instruction count is accepted.
+    pub max_bytecode_increase_percent: Option<i32>,
 }
 
 pub(crate) struct ArtifactsAndWarnings(Artifacts, Vec<SsaReport>);
@@ -82,55 +97,32 @@ pub(crate) fn optimize_into_acir(
 ) -> Result<ArtifactsAndWarnings, RuntimeError> {
     let ssa_gen_span = span!(Level::TRACE, "ssa_generation");
     let ssa_gen_span_guard = ssa_gen_span.enter();
-
-    let mut ssa = SsaBuilder::new(
+    let builder = SsaBuilder::new(
         program,
-        options.enable_ssa_logging,
+        options.ssa_logging.clone(),
         options.force_brillig_output,
         options.print_codegen_timings,
         &options.emit_ssa,
-    )?
-    .run_pass(Ssa::defunctionalize, "After Defunctionalization:")
-    .run_pass(Ssa::remove_paired_rc, "After Removing Paired rc_inc & rc_decs:")
-    .run_pass(Ssa::separate_runtime, "After Runtime Separation:")
-    .run_pass(Ssa::resolve_is_unconstrained, "After Resolving IsUnconstrained:")
-    .run_pass(Ssa::inline_functions, "After Inlining:")
-    // Run mem2reg with the CFG separated into blocks
-    .run_pass(Ssa::mem2reg, "After Mem2Reg:")
-    .run_pass(Ssa::as_slice_optimization, "After `as_slice` optimization")
-    .try_run_pass(
-        Ssa::evaluate_static_assert_and_assert_constant,
-        "After `static_assert` and `assert_constant`:",
-    )?
-    .try_run_pass(Ssa::unroll_loops_iteratively, "After Unrolling:")?
-    .run_pass(Ssa::simplify_cfg, "After Simplifying:")
-    .run_pass(Ssa::flatten_cfg, "After Flattening:")
-    .run_pass(Ssa::remove_bit_shifts, "After Removing Bit Shifts:")
-    // Run mem2reg once more with the flattened CFG to catch any remaining loads/stores
-    .run_pass(Ssa::mem2reg, "After Mem2Reg:")
-    // Run the inlining pass again to handle functions with `InlineType::NoPredicates`.
-    // Before flattening is run, we treat functions marked with the `InlineType::NoPredicates` as an entry point.
-    // This pass must come immediately following `mem2reg` as the succeeding passes
-    // may create an SSA which inlining fails to handle.
-    .run_pass(Ssa::inline_functions_with_no_predicates, "After Inlining:")
-    .run_pass(
-        Ssa::array_get_from_if_else_result_optimization,
-        "After Array Get From If Else Result Optimizations:",
-    )
-    .run_pass(Ssa::remove_if_else, "After Remove IfElse:")
-    .run_pass(Ssa::fold_constants, "After Constant Folding:")
-    .run_pass(Ssa::remove_enable_side_effects, "After EnableSideEffectsIf removal:")
-    .run_pass(Ssa::fold_constants_using_constraints, "After Constraint Folding:")
-    .run_pass(Ssa::dead_instruction_elimination, "After Dead Instruction Elimination:")
-    .run_pass(Ssa::array_set_optimization, "After Array Set Optimizations:")
-    .finish();
+    )?;
 
-    let ssa_level_warnings = if options.skip_underconstrained_check {
-        vec![]
-    } else {
-        time("After Check for Underconstrained Values", options.print_codegen_timings, || {
-            ssa.check_for_underconstrained_values()
-        })
+    let mut ssa = optimize_all(builder, options)?;
+
+    let mut ssa_level_warnings = vec![];
+
+    if !options.skip_underconstrained_check {
+        ssa_level_warnings.extend(time(
+            "After Check for Underconstrained Values",
+            options.print_codegen_timings,
+            || ssa.check_for_underconstrained_values(),
+        ));
+    }
+
+    if !options.skip_brillig_constraints_check {
+        ssa_level_warnings.extend(time(
+            "After Check for Missing Brillig Call Constraints",
+            options.print_codegen_timings,
+            || ssa.check_for_missing_brillig_constraints(),
+        ));
     };
 
     drop(ssa_gen_span_guard);
@@ -139,12 +131,75 @@ pub(crate) fn optimize_into_acir(
         ssa.to_brillig(options.enable_brillig_logging)
     });
 
+    let ssa_gen_span = span!(Level::TRACE, "ssa_generation");
+    let ssa_gen_span_guard = ssa_gen_span.enter();
+
+    let ssa = SsaBuilder {
+        ssa,
+        ssa_logging: options.ssa_logging.clone(),
+        print_codegen_timings: options.print_codegen_timings,
+    }
+    .run_pass(|ssa| ssa.fold_constants_with_brillig(&brillig), "Inlining Brillig Calls Inlining")
+    .run_pass(Ssa::dead_instruction_elimination, "Dead Instruction Elimination (2nd)")
+    .finish();
+
+    drop(ssa_gen_span_guard);
+
     let artifacts = time("SSA to ACIR", options.print_codegen_timings, || {
         ssa.into_acir(&brillig, options.expression_width)
     })?;
+
     Ok(ArtifactsAndWarnings(artifacts, ssa_level_warnings))
 }
 
+/// Run all SSA passes.
+fn optimize_all(builder: SsaBuilder, options: &SsaEvaluatorOptions) -> Result<Ssa, RuntimeError> {
+    Ok(builder
+        .run_pass(Ssa::defunctionalize, "Defunctionalization")
+        .run_pass(Ssa::remove_paired_rc, "Removing Paired rc_inc & rc_decs")
+        .run_pass(Ssa::separate_runtime, "Runtime Separation")
+        .run_pass(Ssa::resolve_is_unconstrained, "Resolving IsUnconstrained")
+        .run_pass(|ssa| ssa.inline_functions(options.inliner_aggressiveness), "Inlining (1st)")
+        // Run mem2reg with the CFG separated into blocks
+        .run_pass(Ssa::mem2reg, "Mem2Reg (1st)")
+        .run_pass(Ssa::simplify_cfg, "Simplifying (1st)")
+        .run_pass(Ssa::as_slice_optimization, "`as_slice` optimization")
+        .try_run_pass(
+            Ssa::evaluate_static_assert_and_assert_constant,
+            "`static_assert` and `assert_constant`",
+        )?
+        .run_pass(Ssa::loop_invariant_code_motion, "Loop Invariant Code Motion")
+        .try_run_pass(
+            |ssa| ssa.unroll_loops_iteratively(options.max_bytecode_increase_percent),
+            "Unrolling",
+        )?
+        .run_pass(Ssa::simplify_cfg, "Simplifying (2nd)")
+        .run_pass(Ssa::flatten_cfg, "Flattening")
+        .run_pass(Ssa::remove_bit_shifts, "After Removing Bit Shifts")
+        // Run mem2reg once more with the flattened CFG to catch any remaining loads/stores
+        .run_pass(Ssa::mem2reg, "Mem2Reg (2nd)")
+        // Run the inlining pass again to handle functions with `InlineType::NoPredicates`.
+        // Before flattening is run, we treat functions marked with the `InlineType::NoPredicates` as an entry point.
+        // This pass must come immediately following `mem2reg` as the succeeding passes
+        // may create an SSA which inlining fails to handle.
+        .run_pass(
+            |ssa| ssa.inline_functions_with_no_predicates(options.inliner_aggressiveness),
+            "Inlining (2nd)",
+        )
+        .run_pass(
+            Ssa::array_get_from_if_else_result_optimization,
+            "After Array Get From If Else Result Optimizations:",
+        )
+        .run_pass(Ssa::remove_if_else, "Remove IfElse")
+        .run_pass(Ssa::fold_constants, "Constant Folding")
+        .run_pass(Ssa::remove_enable_side_effects, "EnableSideEffectsIf removal")
+        .run_pass(Ssa::fold_constants_using_constraints, "Constraint Folding")
+        .run_pass(Ssa::dead_instruction_elimination, "Dead Instruction Elimination (1st)")
+        .run_pass(Ssa::simplify_cfg, "Simplifying:")
+        .run_pass(Ssa::array_set_optimization, "Array Set Optimizations")
+        .finish())
+}
+
 // Helper to time SSA passes
 fn time<T>(name: &str, print_timings: bool, f: impl FnOnce() -> T) -> T {
     let start_time = chrono::Utc::now().time();
@@ -167,13 +222,13 @@ pub struct SsaProgramArtifact {
     pub main_return_witnesses: Vec<Witness>,
     pub names: Vec<String>,
     pub brillig_names: Vec<String>,
-    pub error_types: BTreeMap<ErrorSelector, HirType>,
+    pub error_types: BTreeMap<ErrorSelector, ErrorType>,
 }
 
 impl SsaProgramArtifact {
     fn new(
         unconstrained_functions: Vec<BrilligBytecode<FieldElement>>,
-        error_types: BTreeMap<ErrorSelector, HirType>,
+        error_types: BTreeMap<ErrorSelector, ErrorType>,
     ) -> Self {
         let program = AcirProgram { functions: Vec::default(), unconstrained_functions };
         Self {
@@ -197,6 +252,9 @@ impl SsaProgramArtifact {
             self.main_return_witnesses = circuit_artifact.return_witnesses;
         }
         self.names.push(circuit_artifact.name);
+        // Acir and brillig both generate new error types, so we need to merge them
+        // With the ones found during ssa generation.
+        self.error_types.extend(circuit_artifact.error_types);
     }
 
     fn add_warnings(&mut self, mut warnings: Vec<SsaReport>) {
@@ -204,7 +262,7 @@ impl SsaProgramArtifact {
     }
 }
 
-/// Compiles the [`Program`] into [`ACIR``][acvm::acir::circuit::Program].
+/// Compiles the [`Program`] into [`ACIR`][acvm::acir::circuit::Program].
 ///
 /// The output ACIR is backend-agnostic and so must go through a transformation pass before usage in proof generation.
 #[tracing::instrument(level = "trace", skip_all)]
@@ -218,7 +276,6 @@ pub fn create_program(
 
     let func_sigs = program.function_signatures.clone();
 
-    let recursive = program.recursive;
     let ArtifactsAndWarnings(
         (generated_acirs, generated_brillig, brillig_function_names, error_types),
         ssa_level_warnings,
@@ -236,6 +293,12 @@ pub fn create_program(
             "The generated ACIRs should match the supplied function signatures"
         );
     }
+
+    let error_types = error_types
+        .into_iter()
+        .map(|(selector, hir_type)| (selector, ErrorType::Dynamic(hir_type)))
+        .collect();
+
     let mut program_artifact = SsaProgramArtifact::new(generated_brillig, error_types);
 
     // Add warnings collected at the Ssa stage
@@ -246,7 +309,6 @@ pub fn create_program(
         let circuit_artifact = convert_generated_acir_into_circuit(
             acir,
             func_sig,
-            recursive,
             // TODO: get rid of these clones
             debug_variables.clone(),
             debug_functions.clone(),
@@ -267,12 +329,12 @@ pub struct SsaCircuitArtifact {
     warnings: Vec<SsaReport>,
     input_witnesses: Vec<Witness>,
     return_witnesses: Vec<Witness>,
+    error_types: BTreeMap<ErrorSelector, ErrorType>,
 }
 
 fn convert_generated_acir_into_circuit(
     mut generated_acir: GeneratedAcir<FieldElement>,
     func_sig: FunctionSignature,
-    recursive: bool,
     debug_variables: DebugVariables,
     debug_functions: DebugFunctions,
     debug_types: DebugTypes,
@@ -287,6 +349,7 @@ fn convert_generated_acir_into_circuit(
         assertion_payloads: assert_messages,
         warnings,
         name,
+        brillig_procedure_locs,
         ..
     } = generated_acir;
 
@@ -304,7 +367,6 @@ fn convert_generated_acir_into_circuit(
         public_parameters,
         return_values,
         assert_messages: assert_messages.into_iter().collect(),
-        recursive,
     };
 
     // This converts each im::Vector in the BTreeMap to a Vec
@@ -324,8 +386,14 @@ fn convert_generated_acir_into_circuit(
         })
         .collect();
 
-    let mut debug_info =
-        DebugInfo::new(locations, brillig_locations, debug_variables, debug_functions, debug_types);
+    let mut debug_info = DebugInfo::new(
+        locations,
+        brillig_locations,
+        debug_variables,
+        debug_functions,
+        debug_types,
+        brillig_procedure_locs,
+    );
 
     // Perform any ACIR-level optimizations
     let (optimized_circuit, transformation_map) = acvm::compiler::optimize(circuit);
@@ -338,6 +406,7 @@ fn convert_generated_acir_into_circuit(
         warnings,
         input_witnesses,
         return_witnesses,
+        error_types: generated_acir.error_types,
     }
 }
 
@@ -354,8 +423,8 @@ fn split_public_and_private_inputs(
     func_sig
         .0
         .iter()
-        .map(|(_, typ, visibility)| {
-            let num_field_elements_needed = typ.field_count() as usize;
+        .map(|(pattern, typ, visibility)| {
+            let num_field_elements_needed = typ.field_count(&pattern.location()) as usize;
             let witnesses = input_witnesses[idx..idx + num_field_elements_needed].to_vec();
             idx += num_field_elements_needed;
             (visibility, witnesses)
@@ -378,14 +447,14 @@ fn split_public_and_private_inputs(
 // This is just a convenience object to bundle the ssa with `print_ssa_passes` for debug printing.
 struct SsaBuilder {
     ssa: Ssa,
-    print_ssa_passes: bool,
+    ssa_logging: SsaLogging,
     print_codegen_timings: bool,
 }
 
 impl SsaBuilder {
     fn new(
         program: Program,
-        print_ssa_passes: bool,
+        ssa_logging: SsaLogging,
         force_brillig_runtime: bool,
         print_codegen_timings: bool,
         emit_ssa: &Option<PathBuf>,
@@ -400,33 +469,45 @@ impl SsaBuilder {
             let ssa_path = emit_ssa.with_extension("ssa.json");
             write_to_file(&serde_json::to_vec(&ssa).unwrap(), &ssa_path);
         }
-        Ok(SsaBuilder { print_ssa_passes, print_codegen_timings, ssa }.print("Initial SSA:"))
+        Ok(SsaBuilder { ssa_logging, print_codegen_timings, ssa }.print("Initial SSA:"))
     }
 
     fn finish(self) -> Ssa {
-        self.ssa
+        self.ssa.generate_entry_point_index()
     }
 
     /// Runs the given SSA pass and prints the SSA afterward if `print_ssa_passes` is true.
-    fn run_pass(mut self, pass: fn(Ssa) -> Ssa, msg: &str) -> Self {
+    fn run_pass<F>(mut self, pass: F, msg: &str) -> Self
+    where
+        F: FnOnce(Ssa) -> Ssa,
+    {
         self.ssa = time(msg, self.print_codegen_timings, || pass(self.ssa));
         self.print(msg)
     }
 
     /// The same as `run_pass` but for passes that may fail
-    fn try_run_pass(
-        mut self,
-        pass: fn(Ssa) -> Result<Ssa, RuntimeError>,
-        msg: &str,
-    ) -> Result<Self, RuntimeError> {
+    fn try_run_pass<F>(mut self, pass: F, msg: &str) -> Result<Self, RuntimeError>
+    where
+        F: FnOnce(Ssa) -> Result<Ssa, RuntimeError>,
+    {
         self.ssa = time(msg, self.print_codegen_timings, || pass(self.ssa))?;
         Ok(self.print(msg))
     }
 
     fn print(mut self, msg: &str) -> Self {
-        if self.print_ssa_passes {
+        let print_ssa_pass = match &self.ssa_logging {
+            SsaLogging::None => false,
+            SsaLogging::All => true,
+            SsaLogging::Contains(string) => {
+                let string = string.to_lowercase();
+                let string = string.strip_prefix("after ").unwrap_or(&string);
+                let string = string.strip_suffix(':').unwrap_or(string);
+                msg.to_lowercase().contains(string)
+            }
+        };
+        if print_ssa_pass {
             self.ssa.normalize_ids();
-            println!("{msg}\n{}", self.ssa);
+            println!("After {msg}:\n{}", self.ssa);
         }
         self
     }
diff --git a/compiler/noirc_evaluator/src/ssa/acir_gen/acir_ir.rs b/compiler/noirc_evaluator/src/ssa/acir_gen/acir_ir.rs
deleted file mode 100644
index 090d5bb0a83..00000000000
--- a/compiler/noirc_evaluator/src/ssa/acir_gen/acir_ir.rs
+++ /dev/null
@@ -1,3 +0,0 @@
-pub(crate) mod acir_variable;
-pub(crate) mod big_int;
-pub(crate) mod generated_acir;
diff --git a/compiler/noirc_evaluator/src/ssa/checks/check_for_underconstrained_values.rs b/compiler/noirc_evaluator/src/ssa/checks/check_for_underconstrained_values.rs
index aa5f4c8df95..f092f63cd07 100644
--- a/compiler/noirc_evaluator/src/ssa/checks/check_for_underconstrained_values.rs
+++ b/compiler/noirc_evaluator/src/ssa/checks/check_for_underconstrained_values.rs
@@ -1,33 +1,62 @@
-//! This module defines an SSA pass that detects if the final function has any subgraphs independent from inputs and outputs.
-//! If this is the case, then part of the final circuit can be completely replaced by any other passing circuit, since there are no constraints ensuring connections.
-//! So the compiler informs the developer of this as a bug
+//! This module defines security SSA passes detecting constraint problems leading to possible
+//! soundness vulnerabilities.
+//! The compiler informs the developer of these as bugs.
 use crate::errors::{InternalBug, SsaReport};
 use crate::ssa::ir::basic_block::BasicBlockId;
 use crate::ssa::ir::function::RuntimeType;
 use crate::ssa::ir::function::{Function, FunctionId};
-use crate::ssa::ir::instruction::{Instruction, InstructionId, Intrinsic};
+use crate::ssa::ir::instruction::{Hint, Instruction, InstructionId, Intrinsic};
 use crate::ssa::ir::value::{Value, ValueId};
 use crate::ssa::ssa_gen::Ssa;
 use im::HashMap;
 use rayon::prelude::*;
 use std::collections::{BTreeMap, HashSet};
+use tracing::trace;
 
 impl Ssa {
-    /// Go through each top-level non-brillig function and detect if it has independent subgraphs
+    /// This function provides an SSA pass that detects if the final function has any subgraphs independent from inputs and outputs.
+    /// If this is the case, then part of the final circuit can be completely replaced by any other passing circuit, since there are no constraints ensuring connections.
+    /// Go through each top-level non-Brillig function and detect if it has independent subgraphs
     #[tracing::instrument(level = "trace", skip(self))]
     pub(crate) fn check_for_underconstrained_values(&mut self) -> Vec<SsaReport> {
-        let functions_id = self.functions.values().map(|f| f.id().to_usize()).collect::<Vec<_>>();
-        functions_id
-            .iter()
+        self.functions
+            .values()
+            .map(|f| f.id())
             .par_bridge()
             .flat_map(|fid| {
-                let function_to_process = &self.functions[&FunctionId::new(*fid)];
+                let function_to_process = &self.functions[&fid];
                 match function_to_process.runtime() {
                     RuntimeType::Acir { .. } => check_for_underconstrained_values_within_function(
                         function_to_process,
                         &self.functions,
                     ),
-                    RuntimeType::Brillig => Vec::new(),
+                    RuntimeType::Brillig(_) => Vec::new(),
+                }
+            })
+            .collect()
+    }
+
+    /// Detect Brillig calls left unconstrained with manual asserts
+    /// and return a vector of bug reports if any have been found
+    pub(crate) fn check_for_missing_brillig_constraints(&mut self) -> Vec<SsaReport> {
+        // Skip the check if there are no Brillig functions involved
+        if !self.functions.values().any(|func| func.runtime().is_brillig()) {
+            return vec![];
+        };
+
+        self.functions
+            .values()
+            .map(|f| f.id())
+            .par_bridge()
+            .flat_map(|fid| {
+                let function_to_process = &self.functions[&fid];
+                match function_to_process.runtime() {
+                    RuntimeType::Acir { .. } => {
+                        let mut context = DependencyContext::default();
+                        context.build(function_to_process, &self.functions);
+                        context.collect_warnings(function_to_process)
+                    }
+                    RuntimeType::Brillig(_) => Vec::new(),
                 }
             })
             .collect()
@@ -63,6 +92,345 @@ fn check_for_underconstrained_values_within_function(
     }
     warnings
 }
+
+#[derive(Default)]
+struct DependencyContext {
+    visited_blocks: HashSet<BasicBlockId>,
+    block_queue: Vec<BasicBlockId>,
+    // Map keeping track of values stored at memory locations
+    memory_slots: HashMap<ValueId, ValueId>,
+    // Map of values resulting from array get instructions
+    // to the actual array values
+    array_elements: HashMap<ValueId, ValueId>,
+    // Map of brillig call ids to sets of the value ids descending
+    // from their arguments and results
+    tainted: HashMap<InstructionId, BrilligTaintedIds>,
+}
+
+/// Structure keeping track of value ids descending from Brillig calls'
+/// arguments and results, also storing information on results
+/// already properly constrained
+#[derive(Clone, Debug)]
+struct BrilligTaintedIds {
+    // Argument descendant value ids
+    arguments: HashSet<ValueId>,
+    // Results status
+    results: Vec<ResultStatus>,
+    // Initial result value ids
+    root_results: HashSet<ValueId>,
+}
+
+#[derive(Clone, Debug)]
+enum ResultStatus {
+    // Keep track of descendants until found constrained
+    Unconstrained { descendants: HashSet<ValueId> },
+    Constrained,
+}
+
+impl BrilligTaintedIds {
+    fn new(arguments: &[ValueId], results: &[ValueId]) -> Self {
+        BrilligTaintedIds {
+            arguments: HashSet::from_iter(arguments.iter().copied()),
+            results: results
+                .iter()
+                .map(|result| ResultStatus::Unconstrained { descendants: HashSet::from([*result]) })
+                .collect(),
+            root_results: HashSet::from_iter(results.iter().copied()),
+        }
+    }
+
+    /// Add children of a given parent to the tainted value set
+    /// (for arguments one set is enough, for results we keep them
+    /// separate as the forthcoming check considers the call covered
+    /// if all the results were properly covered)
+    fn update_children(&mut self, parents: &HashSet<ValueId>, children: &[ValueId]) {
+        if self.arguments.intersection(parents).next().is_some() {
+            self.arguments.extend(children);
+        }
+        for result_status in &mut self.results.iter_mut() {
+            match result_status {
+                // Skip updating results already found covered
+                ResultStatus::Constrained => {
+                    continue;
+                }
+                ResultStatus::Unconstrained { descendants } => {
+                    if descendants.intersection(parents).next().is_some() {
+                        descendants.extend(children);
+                    }
+                }
+            }
+        }
+    }
+
+    /// If Brillig call is properly constrained by the given ids, return true
+    fn check_constrained(&self) -> bool {
+        // If every result has now been constrained,
+        // consider the call properly constrained
+        self.results.iter().all(|result| matches!(result, ResultStatus::Constrained))
+    }
+
+    /// Remember partial constraints (involving some of the results and an argument)
+    /// along the way to take them into final consideration
+    /// Generally, a valid partial constraint should link up a result descendant
+    /// and an argument descendant, although there are also edge cases mentioned below.
+    fn store_partial_constraints(&mut self, constrained_values: &HashSet<ValueId>) {
+        let mut results_involved: Vec<usize> = vec![];
+
+        // For a valid partial constraint, a value descending from
+        // one of the results should be constrained
+        for (i, result_status) in self.results.iter().enumerate() {
+            match result_status {
+                // Skip checking already covered results
+                ResultStatus::Constrained => {
+                    continue;
+                }
+                ResultStatus::Unconstrained { descendants } => {
+                    if descendants.intersection(constrained_values).next().is_some() {
+                        results_involved.push(i);
+                    }
+                }
+            }
+        }
+
+        // Along with it, one of the argument descendants should be constrained
+        // (skipped if there were no arguments, or if an actual result and not a
+        // descendant has been constrained _alone_, e.g. against a constant)
+        if !results_involved.is_empty()
+            && (self.arguments.is_empty()
+                || (constrained_values.len() == 1
+                    && self.root_results.intersection(constrained_values).next().is_some())
+                || self.arguments.intersection(constrained_values).next().is_some())
+        {
+            // Remember the partial constraint, clearing the sets
+            results_involved.iter().for_each(|i| self.results[*i] = ResultStatus::Constrained);
+        }
+    }
+}
+
+impl DependencyContext {
+    /// Build the dependency context of variable ValueIds, storing
+    /// information on value ids involved in unchecked Brillig calls
+    fn build(&mut self, function: &Function, all_functions: &BTreeMap<FunctionId, Function>) {
+        self.block_queue.push(function.entry_block());
+        while let Some(block) = self.block_queue.pop() {
+            if self.visited_blocks.contains(&block) {
+                continue;
+            }
+            self.visited_blocks.insert(block);
+            self.process_instructions(block, function, all_functions);
+        }
+    }
+
+    /// Go over the given block tracking Brillig calls and checking them against
+    /// following constraints
+    fn process_instructions(
+        &mut self,
+        block: BasicBlockId,
+        function: &Function,
+        all_functions: &BTreeMap<FunctionId, Function>,
+    ) {
+        trace!("processing instructions of block {} of function {}", block, function.id());
+
+        for instruction in function.dfg[block].instructions() {
+            let mut arguments = Vec::new();
+            let mut results = Vec::new();
+
+            // Collect non-constant instruction arguments
+            function.dfg[*instruction].for_each_value(|value_id| {
+                if function.dfg.get_numeric_constant(value_id).is_none() {
+                    arguments.push(function.dfg.resolve(value_id));
+                }
+            });
+
+            // Collect non-constant instruction results
+            for value_id in function.dfg.instruction_results(*instruction).iter() {
+                if function.dfg.get_numeric_constant(*value_id).is_none() {
+                    results.push(function.dfg.resolve(*value_id));
+                }
+            }
+
+            // Process instructions
+            match &function.dfg[*instruction] {
+                // For memory operations, we have to link up the stored value as a parent
+                // of one loaded from the same memory slot
+                Instruction::Store { address, value } => {
+                    self.memory_slots.insert(*address, function.dfg.resolve(*value));
+                }
+                Instruction::Load { address } => {
+                    // Recall the value stored at address as parent for the results
+                    if let Some(value_id) = self.memory_slots.get(address) {
+                        self.update_children(&[*value_id], &results);
+                    } else {
+                        panic!("load instruction {} has attempted to access previously unused memory location",
+                            instruction);
+                    }
+                }
+                // Check the constrain instruction arguments against those
+                // involved in Brillig calls, remove covered calls
+                Instruction::Constrain(value_id1, value_id2, _) => {
+                    self.clear_constrained(
+                        &[function.dfg.resolve(*value_id1), function.dfg.resolve(*value_id2)],
+                        function,
+                    );
+                }
+                // Consider range check to also be constraining
+                Instruction::RangeCheck { value, .. } => {
+                    self.clear_constrained(&[function.dfg.resolve(*value)], function);
+                }
+                Instruction::Call { func: func_id, .. } => {
+                    // For functions, we remove the first element of arguments,
+                    // as .for_each_value() used previously also includes func_id
+                    arguments.remove(0);
+
+                    match &function.dfg[*func_id] {
+                        Value::Intrinsic(intrinsic) => match intrinsic {
+                            Intrinsic::ApplyRangeConstraint | Intrinsic::AssertConstant => {
+                                // Consider these intrinsic arguments constrained
+                                self.clear_constrained(&arguments, function);
+                            }
+                            Intrinsic::AsWitness | Intrinsic::IsUnconstrained => {
+                                // These intrinsics won't affect the dependency graph
+                            }
+                            Intrinsic::ArrayLen
+                            | Intrinsic::ArrayRefCount
+                            | Intrinsic::ArrayAsStrUnchecked
+                            | Intrinsic::AsField
+                            | Intrinsic::AsSlice
+                            | Intrinsic::BlackBox(..)
+                            | Intrinsic::DerivePedersenGenerators
+                            | Intrinsic::FromField
+                            | Intrinsic::Hint(..)
+                            | Intrinsic::SlicePushBack
+                            | Intrinsic::SlicePushFront
+                            | Intrinsic::SlicePopBack
+                            | Intrinsic::SlicePopFront
+                            | Intrinsic::SliceRefCount
+                            | Intrinsic::SliceInsert
+                            | Intrinsic::SliceRemove
+                            | Intrinsic::StaticAssert
+                            | Intrinsic::StrAsBytes
+                            | Intrinsic::ToBits(..)
+                            | Intrinsic::ToRadix(..)
+                            | Intrinsic::FieldLessThan => {
+                                // Record all the function arguments as parents of the results
+                                self.update_children(&arguments, &results);
+                            }
+                        },
+                        Value::Function(callee) => match all_functions[&callee].runtime() {
+                            RuntimeType::Brillig(_) => {
+                                // Record arguments/results for each Brillig call for the check
+                                self.tainted.insert(
+                                    *instruction,
+                                    BrilligTaintedIds::new(&arguments, &results),
+                                );
+                            }
+                            RuntimeType::Acir(..) => {
+                                // Record all the function arguments as parents of the results
+                                self.update_children(&arguments, &results);
+                            }
+                        },
+                        Value::ForeignFunction(..) => {
+                            panic!("should not be able to reach foreign function from non-Brillig functions, {func_id} in function {}", function.name());
+                        }
+                        Value::Instruction { .. }
+                        | Value::NumericConstant { .. }
+                        | Value::Param { .. } => {
+                            panic!(
+                                "calling non-function value with ID {func_id} in function {}",
+                                function.name()
+                            );
+                        }
+                    }
+                }
+                // For array get operations, we link the resulting values to
+                // the corresponding array value ids
+                // (this is required later because for now we consider array elements
+                // being constrained as valid as the whole arrays being constrained)
+                Instruction::ArrayGet { array, .. } => {
+                    for result in &results {
+                        self.array_elements.insert(*result, function.dfg.resolve(*array));
+                    }
+                    // Record all the used arguments as parents of the results
+                    self.update_children(&arguments, &results);
+                }
+                Instruction::ArraySet { .. }
+                | Instruction::Binary(..)
+                | Instruction::Cast(..)
+                | Instruction::IfElse { .. }
+                | Instruction::Not(..)
+                | Instruction::Truncate { .. } => {
+                    // Record all the used arguments as parents of the results
+                    self.update_children(&arguments, &results);
+                }
+                // These instructions won't affect the dependency graph
+                Instruction::Allocate { .. }
+                | Instruction::DecrementRc { .. }
+                | Instruction::EnableSideEffectsIf { .. }
+                | Instruction::IncrementRc { .. }
+                | Instruction::MakeArray { .. } => {}
+            }
+        }
+
+        trace!("Number tainted Brillig calls: {}", self.tainted.len());
+    }
+
+    /// Every Brillig call not properly constrained should remain in the tainted set
+    /// at this point. For each, emit a corresponding warning.
+    fn collect_warnings(&mut self, function: &Function) -> Vec<SsaReport> {
+        let warnings: Vec<SsaReport> = self
+            .tainted
+            .keys()
+            .map(|brillig_call| {
+                SsaReport::Bug(InternalBug::UncheckedBrilligCall {
+                    call_stack: function.dfg.get_call_stack(*brillig_call),
+                })
+            })
+            .collect();
+
+        trace!(
+            "making {} under constrained reports for function {}",
+            warnings.len(),
+            function.name()
+        );
+        warnings
+    }
+
+    /// Update sets of value ids that can be traced back to the Brillig calls being tracked
+    fn update_children(&mut self, parents: &[ValueId], children: &[ValueId]) {
+        let parents: HashSet<_> = HashSet::from_iter(parents.iter().copied());
+        for (_, tainted_ids) in self.tainted.iter_mut() {
+            tainted_ids.update_children(&parents, children);
+        }
+    }
+
+    /// Check if any of the recorded Brillig calls have been properly constrained
+    /// by given values after recording partial constraints, if so stop tracking them
+    fn clear_constrained(&mut self, constrained_values: &[ValueId], function: &Function) {
+        // Remove numeric constants
+        let constrained_values =
+            constrained_values.iter().filter(|v| function.dfg.get_numeric_constant(**v).is_none());
+
+        // For now, consider array element constraints to be array constraints
+        // TODO(https://github.com/noir-lang/noir/issues/6698):
+        // This probably has to be further looked into, to ensure _every_ element
+        // of an array result of a Brillig call has been constrained
+        let constrained_values: HashSet<_> = constrained_values
+            .map(|v| {
+                if let Some(parent_array) = self.array_elements.get(v) {
+                    *parent_array
+                } else {
+                    *v
+                }
+            })
+            .collect();
+
+        self.tainted.iter_mut().for_each(|(_, tainted_ids)| {
+            tainted_ids.store_partial_constraints(&constrained_values);
+        });
+        self.tainted.retain(|_, tainted_ids| !tainted_ids.check_constrained());
+    }
+}
+
 #[derive(Default)]
 struct Context {
     visited_blocks: HashSet<BasicBlockId>,
@@ -75,7 +443,7 @@ struct Context {
 impl Context {
     /// Compute sets of variable ValueIds that are connected with constraints
     ///
-    /// Additionally, store information about brillig calls in the context
+    /// Additionally, store information about Brillig calls in the context
     fn compute_sets_of_connected_value_ids(
         &mut self,
         function: &Function,
@@ -122,7 +490,7 @@ impl Context {
         connected_sets_indices
     }
 
-    /// Find which brillig calls separate this set from others and return bug warnings about them
+    /// Find which Brillig calls separate this set from others and return bug warnings about them
     fn find_disconnecting_brillig_calls_with_results_in_set(
         &self,
         current_set: &HashSet<ValueId>,
@@ -133,7 +501,7 @@ impl Context {
         // Find brillig-generated values in the set
         let intersection = all_brillig_generated_values.intersection(current_set).copied();
 
-        // Go through all brillig outputs in the set
+        // Go through all Brillig outputs in the set
         for brillig_output_in_set in intersection {
             // Get the inputs that correspond to the output
             let inputs: HashSet<ValueId> =
@@ -155,7 +523,7 @@ impl Context {
     }
     /// Go through each instruction in the block and add a set of ValueIds connected through that instruction
     ///
-    /// Additionally, this function adds mappings of brillig return values to call arguments and instruction ids from calls to brillig functions in the block
+    /// Additionally, this function adds mappings of Brillig return values to call arguments and instruction ids from calls to Brillig functions in the block
     fn connect_value_ids_in_block(
         &mut self,
         function: &Function,
@@ -191,7 +559,8 @@ impl Context {
                 | Instruction::Load { .. }
                 | Instruction::Not(..)
                 | Instruction::Store { .. }
-                | Instruction::Truncate { .. } => {
+                | Instruction::Truncate { .. }
+                | Instruction::MakeArray { .. } => {
                     self.value_sets.push(instruction_arguments_and_results);
                 }
 
@@ -204,27 +573,31 @@ impl Context {
                             | Intrinsic::IsUnconstrained => {}
                             Intrinsic::ArrayLen
                             | Intrinsic::ArrayAsStrUnchecked
+                            | Intrinsic::ArrayRefCount
                             | Intrinsic::AsField
                             | Intrinsic::AsSlice
                             | Intrinsic::BlackBox(..)
+                            | Intrinsic::Hint(Hint::BlackBox)
                             | Intrinsic::DerivePedersenGenerators
                             | Intrinsic::FromField
+                            | Intrinsic::SliceInsert
                             | Intrinsic::SlicePushBack
                             | Intrinsic::SlicePushFront
                             | Intrinsic::SlicePopBack
                             | Intrinsic::SlicePopFront
-                            | Intrinsic::SliceInsert
+                            | Intrinsic::SliceRefCount
                             | Intrinsic::SliceRemove
                             | Intrinsic::StaticAssert
                             | Intrinsic::StrAsBytes
                             | Intrinsic::ToBits(..)
-                            | Intrinsic::ToRadix(..) => {
+                            | Intrinsic::ToRadix(..)
+                            | Intrinsic::FieldLessThan => {
                                 self.value_sets.push(instruction_arguments_and_results);
                             }
                         },
                         Value::Function(callee) => match all_functions[&callee].runtime() {
-                            RuntimeType::Brillig => {
-                                // For calls to brillig functions we memorize the mapping of results to argument ValueId's and InstructionId's
+                            RuntimeType::Brillig(_) => {
+                                // For calls to Brillig functions we memorize the mapping of results to argument ValueId's and InstructionId's
                                 // The latter are needed to produce the callstack later
                                 for result in
                                     function.dfg.instruction_results(*instruction).iter().filter(
@@ -244,10 +617,9 @@ impl Context {
                             }
                         },
                         Value::ForeignFunction(..) => {
-                            panic!("Should not be able to reach foreign function from non-brillig functions, {func_id} in function {}", function.name());
+                            panic!("Should not be able to reach foreign function from non-Brillig functions, {func_id} in function {}", function.name());
                         }
-                        Value::Array { .. }
-                        | Value::Instruction { .. }
+                        Value::Instruction { .. }
                         | Value::NumericConstant { .. }
                         | Value::Param { .. } => {
                             panic!("At the point we are running disconnect there shouldn't be any other values as arguments")
@@ -351,81 +723,297 @@ impl Context {
 }
 #[cfg(test)]
 mod test {
-    use crate::ssa::{
-        function_builder::FunctionBuilder,
-        ir::{instruction::BinaryOp, map::Id, types::Type},
-    };
+    use crate::ssa::Ssa;
+    use tracing_test::traced_test;
 
     #[test]
+    #[traced_test]
     /// Test that a connected function raises no warnings
     fn test_simple_connected_function() {
-        // fn main {
-        //   b0(v0: Field, v1: Field):
-        //      v2 = add v0, 1
-        //      v3 = mul v1, 2
-        //      v4 = eq v2, v3
-        //      return v2
-        // }
-        let main_id = Id::test_new(0);
-        let mut builder = FunctionBuilder::new("main".into(), main_id);
-        let v0 = builder.add_parameter(Type::field());
-        let v1 = builder.add_parameter(Type::field());
-
-        let one = builder.field_constant(1u128);
-        let two = builder.field_constant(2u128);
-
-        let v2 = builder.insert_binary(v0, BinaryOp::Add, one);
-        let v3 = builder.insert_binary(v1, BinaryOp::Mul, two);
-        let _v4 = builder.insert_binary(v2, BinaryOp::Eq, v3);
-        builder.terminate_with_return(vec![v2]);
-
-        let mut ssa = builder.finish();
+        let program = r#"
+        acir(inline) fn main f0 {
+            b0(v0: Field, v1: Field):
+                v2 = add v0, Field 1
+                v3 = mul v1, Field 2
+                v4 = eq v2, v3
+                return v2
+        }
+        "#;
+
+        let mut ssa = Ssa::from_str(program).unwrap();
         let ssa_level_warnings = ssa.check_for_underconstrained_values();
         assert_eq!(ssa_level_warnings.len(), 0);
     }
 
     #[test]
-    /// Test where the results of a call to a brillig function are not connected to main function inputs or outputs
+    #[traced_test]
+    /// Test where the results of a call to a Brillig function are not connected to main function inputs or outputs
     /// This should be detected.
     fn test_simple_function_with_disconnected_part() {
-        //  unconstrained fn br(v0: Field, v1: Field){
-        //      v2 = add v0, v1
-        //      return v2
-        //  }
-        //
-        //  fn main {
-        //   b0(v0: Field, v1: Field):
-        //      v2 = add v0, 1
-        //      v3 = mul v1, 2
-        //      v4 = call br(v2, v3)
-        //      v5 = add v4, 2
-        //      return
-        // }
-        let main_id = Id::test_new(0);
-        let mut builder = FunctionBuilder::new("main".into(), main_id);
-        let v0 = builder.add_parameter(Type::field());
-        let v1 = builder.add_parameter(Type::field());
-
-        let one = builder.field_constant(1u128);
-        let two = builder.field_constant(2u128);
-
-        let v2 = builder.insert_binary(v0, BinaryOp::Add, one);
-        let v3 = builder.insert_binary(v1, BinaryOp::Mul, two);
-
-        let br_function_id = Id::test_new(1);
-        let br_function = builder.import_function(br_function_id);
-        let v4 = builder.insert_call(br_function, vec![v2, v3], vec![Type::field()])[0];
-        let v5 = builder.insert_binary(v4, BinaryOp::Add, two);
-        builder.insert_constrain(v5, one, None);
-        builder.terminate_with_return(vec![]);
-
-        builder.new_brillig_function("br".into(), br_function_id);
-        let v0 = builder.add_parameter(Type::field());
-        let v1 = builder.add_parameter(Type::field());
-        let v2 = builder.insert_binary(v0, BinaryOp::Add, v1);
-        builder.terminate_with_return(vec![v2]);
-        let mut ssa = builder.finish();
+        let program = r#"
+        acir(inline) fn main f0 {
+            b0(v0: Field, v1: Field):
+                v2 = add v0, Field 1
+                v3 = mul v1, Field 2
+                v4 = call f1(v2, v3) -> Field
+                v5 = add v4, Field 2
+                return
+        }
+        
+        brillig(inline) fn br f1 {
+          b0(v0: Field, v1: Field):
+            v2 = add v0, v1
+            return v2
+        }
+        "#;
+
+        let mut ssa = Ssa::from_str(program).unwrap();
         let ssa_level_warnings = ssa.check_for_underconstrained_values();
         assert_eq!(ssa_level_warnings.len(), 1);
     }
+
+    #[test]
+    #[traced_test]
+    /// Test where a call to a Brillig function is left unchecked with a later assert,
+    /// by example of the program illustrating issue #5425 (simplified variant).
+    fn test_underconstrained_value_detector_5425() {
+        /*
+        unconstrained fn maximum_price(options: [u32; 2]) -> u32 {
+            let mut maximum_option = options[0];
+            if (options[1] > options[0]) {
+                maximum_option = options[1];
+            }
+            maximum_option
+        }
+
+        fn main(sandwiches: pub [u32; 2], drinks: pub [u32; 2], best_value: u32) {
+            let most_expensive_sandwich = maximum_price(sandwiches);
+            let mut sandwich_exists = false;
+            sandwich_exists |= (sandwiches[0] == most_expensive_sandwich);
+            sandwich_exists |= (sandwiches[1] == most_expensive_sandwich);
+            assert(sandwich_exists);
+
+            let most_expensive_drink = maximum_price(drinks);
+            assert(
+                best_value
+                == (most_expensive_sandwich + most_expensive_drink)
+            );
+        }
+        */
+
+        // The Brillig function is fake, for simplicity's sake
+
+        let program = r#"
+        acir(inline) fn main f0 {
+          b0(v4: [u32; 2], v5: [u32; 2], v6: u32):
+            inc_rc v4
+            inc_rc v5
+            v8 = call f1(v4) -> u32
+            v9 = allocate -> &mut u32
+            store u1 0 at v9
+            v10 = load v9 -> u1
+            v11 = array_get v4, index u32 0 -> u32
+            v12 = eq v11, v8
+            v13 = or v10, v12
+            store v13 at v9
+            v14 = load v9 -> u1
+            v15 = array_get v4, index u32 1 -> u32
+            v16 = eq v15, v8
+            v17 = or v14, v16
+            store v17 at v9
+            v18 = load v9 -> u1
+            constrain v18 == u1 1
+            v19 = call f1(v5) -> u32
+            v20 = add v8, v19
+            constrain v6 == v20
+            dec_rc v4
+            dec_rc v5
+            return
+        }
+
+        brillig(inline) fn maximum_price f1 {
+          b0(v0: [u32; 2]):
+            v2 = array_get v0, index u32 0 -> u32
+            return v2
+        }
+        "#;
+
+        let mut ssa = Ssa::from_str(program).unwrap();
+        let ssa_level_warnings = ssa.check_for_missing_brillig_constraints();
+        assert_eq!(ssa_level_warnings.len(), 1);
+    }
+
+    #[test]
+    #[traced_test]
+    /// Test where a call to a Brillig function returning multiple result values
+    /// is left unchecked with a later assert involving all the results
+    fn test_unchecked_multiple_results_brillig() {
+        // First call is constrained properly, involving both results
+        // Second call is insufficiently constrained, involving only one of the results
+        // The Brillig function is fake, for simplicity's sake
+        let program = r#"
+        acir(inline) fn main f0 {
+          b0(v0: u32):
+            v2, v3 = call f1(v0) -> (u32, u32)
+            v4 = mul v2, v3
+            constrain v4 == v0
+            v5, v6 = call f1(v0) -> (u32, u32)
+            v7 = mul v5, v5
+            constrain v7 == v0
+            return
+        }
+
+        brillig(inline) fn factor f1 {
+          b0(v0: u32):
+            return u32 0, u32 0
+        }
+        "#;
+
+        let mut ssa = Ssa::from_str(program).unwrap();
+        let ssa_level_warnings = ssa.check_for_missing_brillig_constraints();
+        assert_eq!(ssa_level_warnings.len(), 1);
+    }
+
+    #[test]
+    #[traced_test]
+    /// Test where a Brillig function is called with a constant argument
+    /// (should _not_ lead to a false positive failed check
+    /// if all the results are constrained)
+    fn test_checked_brillig_with_constant_arguments() {
+        // The call is constrained properly, involving both results
+        // (but the argument to the Brillig is a constant)
+        // The Brillig function is fake, for simplicity's sake
+
+        let program = r#"
+        acir(inline) fn main f0 {
+          b0(v0: u32):
+            v3, v4 = call f1(Field 7) -> (u32, u32)
+            v5 = mul v3, v4
+            constrain v5 == v0
+            return
+        }
+
+        brillig(inline) fn factor f1 {
+          b0(v0: Field):
+            return u32 0, u32 0
+        }
+        "#;
+
+        let mut ssa = Ssa::from_str(program).unwrap();
+        let ssa_level_warnings = ssa.check_for_missing_brillig_constraints();
+        assert_eq!(ssa_level_warnings.len(), 0);
+    }
+
+    #[test]
+    #[traced_test]
+    /// Test where a Brillig function call is constrained with a range check
+    /// (should _not_ lead to a false positive failed check)
+    fn test_range_checked_brillig() {
+        // The call is constrained properly with a range check, involving
+        // both Brillig call argument and result
+        // The Brillig function is fake, for simplicity's sake
+
+        let program = r#"
+        acir(inline) fn main f0 {
+          b0(v0: u32):
+            v2 = call f1(v0) -> u32
+            v3 = add v2, v0
+            range_check v3 to 32 bits
+            return
+        }
+
+        brillig(inline) fn dummy f1 {
+          b0(v0: u32):
+            return u32 0
+        }
+        "#;
+
+        let mut ssa = Ssa::from_str(program).unwrap();
+        let ssa_level_warnings = ssa.check_for_missing_brillig_constraints();
+        assert_eq!(ssa_level_warnings.len(), 0);
+    }
+
+    #[test]
+    #[traced_test]
+    /// Test where a Brillig nested type result is insufficiently constrained
+    /// (with a field constraint missing)
+    fn test_nested_type_result_brillig() {
+        /*
+        struct Animal {
+            legs: Field,
+            eyes: u8,
+            tag: Tag,
+        }
+
+        struct Tag {
+            no: Field,
+        }
+
+        unconstrained fn foo(bar: Field) -> Animal {
+            Animal {
+                legs: 4,
+                eyes: 2,
+                tag: Tag { no: bar }
+            }
+        }
+
+        fn main(x: Field) -> pub Animal {
+            let dog = foo(x);
+            assert(dog.legs == 4);
+            assert(dog.tag.no == x);
+
+            dog
+        }
+        */
+
+        let program = r#"
+        acir(inline) fn main f0 {
+          b0(v0: Field):
+            v2, v3, v4 = call f1(v0) -> (Field, u8, Field)
+            v6 = eq v2, Field 4
+            constrain v2 == Field 4
+            v10 = eq v4, v0
+            constrain v4 == v0
+            return v2, v3, v4
+        }
+
+        brillig(inline) fn foo f1 {
+          b0(v0: Field):
+            return Field 4, u8 2, v0
+        }
+        "#;
+
+        let mut ssa = Ssa::from_str(program).unwrap();
+        let ssa_level_warnings = ssa.check_for_missing_brillig_constraints();
+        assert_eq!(ssa_level_warnings.len(), 1);
+    }
+
+    #[test]
+    #[traced_test]
+    /// Test where Brillig calls' root result values are constrained against
+    /// each other (covers a false negative edge case)
+    /// (https://github.com/noir-lang/noir/pull/6658#pullrequestreview-2482170066)
+    fn test_root_result_intersection_false_negative() {
+        let program = r#"
+        acir(inline) fn main f0 {
+          b0(v0: Field, v1: Field):
+            v3 = call f1(v0, v1) -> Field
+            v5 = call f1(v0, v1) -> Field
+            v6 = eq v3, v5
+            constrain v3 == v5
+            v8 = add v3, v5
+            return v8
+        }
+
+        brillig(inline) fn foo f1 {
+          b0(v0: Field, v1: Field):
+            v2 = add v0, v1
+            return v2
+        }
+        "#;
+
+        let mut ssa = Ssa::from_str(program).unwrap();
+        let ssa_level_warnings = ssa.check_for_missing_brillig_constraints();
+        assert_eq!(ssa_level_warnings.len(), 2);
+    }
 }
diff --git a/compiler/noirc_evaluator/src/ssa/function_builder/data_bus.rs b/compiler/noirc_evaluator/src/ssa/function_builder/data_bus.rs
index 38895bb977e..1d18683ee9e 100644
--- a/compiler/noirc_evaluator/src/ssa/function_builder/data_bus.rs
+++ b/compiler/noirc_evaluator/src/ssa/function_builder/data_bus.rs
@@ -1,6 +1,10 @@
 use std::{collections::BTreeMap, sync::Arc};
 
-use crate::ssa::ir::{types::Type, value::ValueId};
+use crate::ssa::ir::{
+    function::RuntimeType,
+    types::{NumericType, Type},
+    value::ValueId,
+};
 use acvm::FieldElement;
 use fxhash::FxHashMap as HashMap;
 use noirc_frontend::ast;
@@ -9,7 +13,7 @@ use serde::{Deserialize, Serialize};
 
 use super::FunctionBuilder;
 
-#[derive(Clone, Debug, Eq, PartialEq)]
+#[derive(Clone, Copy, Debug, Eq, PartialEq)]
 pub(crate) enum DatabusVisibility {
     None,
     CallData(u32),
@@ -48,7 +52,7 @@ impl DataBusBuilder {
                 ast::Visibility::CallData(id) => DatabusVisibility::CallData(id),
                 ast::Visibility::ReturnData => DatabusVisibility::ReturnData,
             };
-            let len = param.1.field_count() as usize;
+            let len = param.1.field_count(&param.0.location()) as usize;
             params_is_databus.extend(vec![is_databus; len]);
         }
         params_is_databus
@@ -100,7 +104,8 @@ impl DataBus {
     ) -> DataBus {
         let mut call_data_args = Vec::new();
         for call_data_item in call_data {
-            let array_id = call_data_item.databus.expect("Call data should have an array id");
+            // databus can be None if `main` is a brillig function
+            let Some(array_id) = call_data_item.databus else { continue };
             let call_data_id =
                 call_data_item.call_data_id.expect("Call data should have a user id");
             call_data_args.push(CallData { array_id, call_data_id, index_map: call_data_item.map });
@@ -114,23 +119,31 @@ impl FunctionBuilder {
     /// Insert a value into a data bus builder
     fn add_to_data_bus(&mut self, value: ValueId, databus: &mut DataBusBuilder) {
         assert!(databus.databus.is_none(), "initializing finalized call data");
-        let typ = self.current_function.dfg[value].get_type().clone();
+        let typ = self.current_function.dfg[value].get_type().into_owned();
         match typ {
             Type::Numeric(_) => {
                 databus.values.push_back(value);
                 databus.index += 1;
             }
             Type::Array(typ, len) => {
-                assert!(typ.len() == 1, "unsupported composite type");
                 databus.map.insert(value, databus.index);
-                for i in 0..len {
-                    // load each element of the array
-                    let index = self
-                        .current_function
-                        .dfg
-                        .make_constant(FieldElement::from(i as i128), Type::length_type());
-                    let element = self.insert_array_get(value, index, typ[0].clone());
-                    self.add_to_data_bus(element, databus);
+
+                let mut index = 0;
+                for _i in 0..len {
+                    for subitem_typ in typ.iter() {
+                        // load each element of the array, and add it to the databus
+                        let length_type = NumericType::length_type();
+                        let index_var = FieldElement::from(index as i128);
+                        let index_var =
+                            self.current_function.dfg.make_constant(index_var, length_type);
+                        let element = self.insert_array_get(value, index_var, subitem_typ.clone());
+                        index += match subitem_typ {
+                            Type::Array(_, _) | Type::Slice(_) => subitem_typ.element_size(),
+                            Type::Numeric(_) => 1,
+                            _ => unreachable!("Unsupported type for databus"),
+                        };
+                        self.add_to_data_bus(element, databus);
+                    }
                 }
             }
             Type::Reference(_) => {
@@ -151,15 +164,13 @@ impl FunctionBuilder {
         for value in values {
             self.add_to_data_bus(*value, &mut databus);
         }
-        let len = databus.values.len();
+        let len = databus.values.len() as u32;
 
-        let array = if len > 0 {
-            let array = self
-                .array_constant(databus.values, Type::Array(Arc::new(vec![Type::field()]), len));
-            Some(array)
-        } else {
-            None
-        };
+        let array = (len > 0 && matches!(self.current_function.runtime(), RuntimeType::Acir(_)))
+            .then(|| {
+                let array_type = Type::Array(Arc::new(vec![Type::field()]), len);
+                self.insert_make_array(databus.values, array_type)
+            });
 
         DataBusBuilder {
             index: 0,
@@ -214,34 +225,29 @@ impl FunctionBuilder {
     fn deflatten_databus_visibilities(
         &self,
         ssa_params: &[ValueId],
-        flattened_params_databus_visibility: Vec<DatabusVisibility>,
+        mut flattened_params_databus_visibility: Vec<DatabusVisibility>,
     ) -> Vec<DatabusVisibility> {
-        // To do so, create a vec the size of the flattened arguments where the items are the ssa param index they correspond to
-        let ssa_param_indices: Vec<_> = ssa_params
+        let ssa_param_sizes: Vec<usize> = ssa_params
             .iter()
-            .enumerate()
-            .flat_map(|(ssa_param_index, ssa_param)| {
-                let flattened_size =
-                    self.current_function.dfg[*ssa_param].get_type().flattened_size();
-                std::iter::repeat(ssa_param_index).take(flattened_size)
+            .map(|ssa_param| {
+                self.current_function.dfg[*ssa_param].get_type().flattened_size() as usize
             })
             .collect();
 
         let mut is_ssa_params_databus = Vec::with_capacity(ssa_params.len());
-        assert!(flattened_params_databus_visibility.len() == ssa_param_indices.len());
-        for (databus_visibility, ssa_index) in
-            flattened_params_databus_visibility.into_iter().zip(ssa_param_indices)
-        {
-            if let Some(previous_databus_visibility) = is_ssa_params_databus.get(ssa_index) {
-                assert!(
-                    *previous_databus_visibility == databus_visibility,
-                    "inconsistent databus visibility for ssa param"
-                );
-            } else {
-                assert!(ssa_index == is_ssa_params_databus.len());
-                is_ssa_params_databus.push(databus_visibility);
-            }
+        for size in ssa_param_sizes {
+            let visibilities: Vec<DatabusVisibility> =
+                flattened_params_databus_visibility.drain(0..size).collect();
+            let visibility = visibilities.get(0).copied().unwrap_or(DatabusVisibility::None);
+            assert!(
+                visibilities.iter().all(|v| *v == visibility),
+                "inconsistent databus visibility for ssa param"
+            );
+            is_ssa_params_databus.push(visibility);
         }
+
+        assert_eq!(is_ssa_params_databus.len(), ssa_params.len());
+
         is_ssa_params_databus
     }
 }
diff --git a/compiler/noirc_evaluator/src/ssa/function_builder/mod.rs b/compiler/noirc_evaluator/src/ssa/function_builder/mod.rs
index 04d4e893bf8..fe654912ad3 100644
--- a/compiler/noirc_evaluator/src/ssa/function_builder/mod.rs
+++ b/compiler/noirc_evaluator/src/ssa/function_builder/mod.rs
@@ -4,6 +4,7 @@ use std::{borrow::Cow, collections::BTreeMap, sync::Arc};
 
 use acvm::{acir::circuit::ErrorSelector, FieldElement};
 use noirc_errors::Location;
+use noirc_frontend::hir_def::types::Type as HirType;
 use noirc_frontend::monomorphization::ast::InlineType;
 
 use crate::ssa::ir::{
@@ -19,7 +20,8 @@ use super::{
         basic_block::BasicBlock,
         dfg::{CallStack, InsertInstructionResult},
         function::RuntimeType,
-        instruction::{ConstrainError, ErrorType, InstructionId, Intrinsic},
+        instruction::{ConstrainError, InstructionId, Intrinsic},
+        types::NumericType,
     },
     ssa_gen::Ssa,
 };
@@ -36,7 +38,7 @@ pub(crate) struct FunctionBuilder {
     current_block: BasicBlockId,
     finished_functions: Vec<Function>,
     call_stack: CallStack,
-    error_types: BTreeMap<ErrorSelector, ErrorType>,
+    error_types: BTreeMap<ErrorSelector, HirType>,
 }
 
 impl FunctionBuilder {
@@ -95,8 +97,13 @@ impl FunctionBuilder {
     }
 
     /// Finish the current function and create a new unconstrained function.
-    pub(crate) fn new_brillig_function(&mut self, name: String, function_id: FunctionId) {
-        self.new_function_with_type(name, function_id, RuntimeType::Brillig);
+    pub(crate) fn new_brillig_function(
+        &mut self,
+        name: String,
+        function_id: FunctionId,
+        inline_type: InlineType,
+    ) {
+        self.new_function_with_type(name, function_id, RuntimeType::Brillig(inline_type));
     }
 
     /// Consume the FunctionBuilder returning all the functions it has generated.
@@ -116,24 +123,19 @@ impl FunctionBuilder {
     pub(crate) fn numeric_constant(
         &mut self,
         value: impl Into<FieldElement>,
-        typ: Type,
+        typ: NumericType,
     ) -> ValueId {
         self.current_function.dfg.make_constant(value.into(), typ)
     }
 
     /// Insert a numeric constant into the current function of type Field
     pub(crate) fn field_constant(&mut self, value: impl Into<FieldElement>) -> ValueId {
-        self.numeric_constant(value.into(), Type::field())
+        self.numeric_constant(value.into(), NumericType::NativeField)
     }
 
     /// Insert a numeric constant into the current function of type Type::length_type()
     pub(crate) fn length_constant(&mut self, value: impl Into<FieldElement>) -> ValueId {
-        self.numeric_constant(value.into(), Type::length_type())
-    }
-
-    /// Insert an array constant into the current function with the given element values.
-    pub(crate) fn array_constant(&mut self, elements: im::Vector<ValueId>, typ: Type) -> ValueId {
-        self.current_function.dfg.make_array(elements, typ)
+        self.numeric_constant(value.into(), NumericType::length_type())
     }
 
     /// Returns the type of the given value.
@@ -194,7 +196,7 @@ impl FunctionBuilder {
     }
 
     pub(crate) fn set_location(&mut self, location: Location) -> &mut FunctionBuilder {
-        self.call_stack = im::Vector::unit(location);
+        self.call_stack = CallStack::unit(location);
         self
     }
 
@@ -250,7 +252,7 @@ impl FunctionBuilder {
 
     /// Insert a cast instruction at the end of the current block.
     /// Returns the result of the cast instruction.
-    pub(crate) fn insert_cast(&mut self, value: ValueId, typ: Type) -> ValueId {
+    pub(crate) fn insert_cast(&mut self, value: ValueId, typ: NumericType) -> ValueId {
         self.insert_instruction(Instruction::Cast(value, typ), None).first()
     }
 
@@ -322,6 +324,16 @@ impl FunctionBuilder {
             .first()
     }
 
+    pub(crate) fn insert_mutable_array_set(
+        &mut self,
+        array: ValueId,
+        index: ValueId,
+        value: ValueId,
+    ) -> ValueId {
+        self.insert_instruction(Instruction::ArraySet { array, index, value, mutable: true }, None)
+            .first()
+    }
+
     /// Insert an instruction to increment an array's reference count. This only has an effect
     /// in unconstrained code where arrays are reference counted and copy on write.
     pub(crate) fn insert_inc_rc(&mut self, value: ValueId) {
@@ -340,6 +352,17 @@ impl FunctionBuilder {
         self.insert_instruction(Instruction::EnableSideEffectsIf { condition }, None);
     }
 
+    /// Insert a `make_array` instruction to create a new array or slice.
+    /// Returns the new array value. Expects `typ` to be an array or slice type.
+    pub(crate) fn insert_make_array(
+        &mut self,
+        elements: im::Vector<ValueId>,
+        typ: Type,
+    ) -> ValueId {
+        assert!(matches!(typ, Type::Array(..) | Type::Slice(_)));
+        self.insert_instruction(Instruction::MakeArray { elements, typ }, None).first()
+    }
+
     /// Terminates the current block with the given terminator instruction
     /// if the current block does not already have a terminator instruction.
     fn terminate_block_with(&mut self, terminator: TerminatorInstruction) {
@@ -419,29 +442,38 @@ impl FunctionBuilder {
     /// Insert instructions to increment the reference count of any array(s) stored
     /// within the given value. If the given value is not an array and does not contain
     /// any arrays, this does nothing.
-    pub(crate) fn increment_array_reference_count(&mut self, value: ValueId) {
-        self.update_array_reference_count(value, true);
+    ///
+    /// Returns whether a reference count instruction was issued.
+    pub(crate) fn increment_array_reference_count(&mut self, value: ValueId) -> bool {
+        self.update_array_reference_count(value, true)
     }
 
     /// Insert instructions to decrement the reference count of any array(s) stored
     /// within the given value. If the given value is not an array and does not contain
     /// any arrays, this does nothing.
-    pub(crate) fn decrement_array_reference_count(&mut self, value: ValueId) {
-        self.update_array_reference_count(value, false);
+    ///
+    /// Returns whether a reference count instruction was issued.
+    pub(crate) fn decrement_array_reference_count(&mut self, value: ValueId) -> bool {
+        self.update_array_reference_count(value, false)
     }
 
     /// Increment or decrement the given value's reference count if it is an array.
     /// If it is not an array, this does nothing. Note that inc_rc and dec_rc instructions
     /// are ignored outside of unconstrained code.
-    fn update_array_reference_count(&mut self, value: ValueId, increment: bool) {
+    ///
+    /// Returns whether a reference count instruction was issued.
+    fn update_array_reference_count(&mut self, value: ValueId, increment: bool) -> bool {
         match self.type_of_value(value) {
-            Type::Numeric(_) => (),
-            Type::Function => (),
+            Type::Numeric(_) => false,
+            Type::Function => false,
             Type::Reference(element) => {
                 if element.contains_an_array() {
                     let reference = value;
                     let value = self.insert_load(reference, element.as_ref().clone());
                     self.update_array_reference_count(value, increment);
+                    true
+                } else {
+                    false
                 }
             }
             Type::Array(..) | Type::Slice(..) => {
@@ -452,11 +484,12 @@ impl FunctionBuilder {
                 } else {
                     self.insert_dec_rc(value);
                 }
+                true
             }
         }
     }
 
-    pub(crate) fn record_error_type(&mut self, selector: ErrorSelector, typ: ErrorType) {
+    pub(crate) fn record_error_type(&mut self, selector: ErrorSelector, typ: HirType) {
         self.error_types.insert(selector, typ);
     }
 }
@@ -494,8 +527,7 @@ mod tests {
     use crate::ssa::ir::{
         instruction::{Endian, Intrinsic},
         map::Id,
-        types::Type,
-        value::Value,
+        types::{NumericType, Type},
     };
 
     use super::FunctionBuilder;
@@ -507,20 +539,17 @@ mod tests {
         // let bits: [u1; 8] = x.to_le_bits();
         let func_id = Id::test_new(0);
         let mut builder = FunctionBuilder::new("func".into(), func_id);
-        let one = builder.numeric_constant(FieldElement::one(), Type::bool());
-        let zero = builder.numeric_constant(FieldElement::zero(), Type::bool());
+        let one = builder.numeric_constant(FieldElement::one(), NumericType::bool());
+        let zero = builder.numeric_constant(FieldElement::zero(), NumericType::bool());
 
         let to_bits_id = builder.import_intrinsic_id(Intrinsic::ToBits(Endian::Little));
-        let input = builder.numeric_constant(FieldElement::from(7_u128), Type::field());
-        let length = builder.numeric_constant(FieldElement::from(8_u128), Type::field());
+        let input = builder.field_constant(FieldElement::from(7_u128));
+        let length = builder.field_constant(FieldElement::from(8_u128));
         let result_types = vec![Type::Array(Arc::new(vec![Type::bool()]), 8)];
         let call_results =
             builder.insert_call(to_bits_id, vec![input, length], result_types).into_owned();
 
-        let slice = match &builder.current_function.dfg[call_results[0]] {
-            Value::Array { array, .. } => array,
-            _ => panic!(),
-        };
+        let slice = builder.current_function.dfg.get_array_constant(call_results[0]).unwrap().0;
         assert_eq!(slice[0], one);
         assert_eq!(slice[1], one);
         assert_eq!(slice[2], one);
diff --git a/compiler/noirc_evaluator/src/ssa/ir/cfg.rs b/compiler/noirc_evaluator/src/ssa/ir/cfg.rs
index b9166bf1d56..2268e6b2191 100644
--- a/compiler/noirc_evaluator/src/ssa/ir/cfg.rs
+++ b/compiler/noirc_evaluator/src/ssa/ir/cfg.rs
@@ -59,7 +59,7 @@ impl ControlFlowGraph {
 
     /// Clears out a given block's successors. This also removes the given block from
     /// being a predecessor of any of its previous successors.
-    fn invalidate_block_successors(&mut self, basic_block_id: BasicBlockId) {
+    pub(crate) fn invalidate_block_successors(&mut self, basic_block_id: BasicBlockId) {
         let node = self
             .data
             .get_mut(&basic_block_id)
@@ -231,7 +231,7 @@ mod tests {
         func.dfg[block2_id].set_terminator(TerminatorInstruction::Jmp {
             destination: ret_block_id,
             arguments: vec![],
-            call_stack: im::Vector::new(),
+            call_stack: CallStack::new(),
         });
         func.dfg[block0_id].set_terminator(TerminatorInstruction::JmpIf {
             condition: cond,
diff --git a/compiler/noirc_evaluator/src/ssa/ir/dfg.rs b/compiler/noirc_evaluator/src/ssa/ir/dfg.rs
index d79916a9e11..7546cba19d8 100644
--- a/compiler/noirc_evaluator/src/ssa/ir/dfg.rs
+++ b/compiler/noirc_evaluator/src/ssa/ir/dfg.rs
@@ -9,7 +9,7 @@ use super::{
         Instruction, InstructionId, InstructionResultType, Intrinsic, TerminatorInstruction,
     },
     map::DenseMap,
-    types::Type,
+    types::{NumericType, Type},
     value::{Value, ValueId},
 };
 
@@ -50,7 +50,7 @@ pub(crate) struct DataFlowGraph {
     /// Each constant is unique, attempting to insert the same constant
     /// twice will return the same ValueId.
     #[serde(skip)]
-    constants: HashMap<(FieldElement, Type), ValueId>,
+    constants: HashMap<(FieldElement, NumericType), ValueId>,
 
     /// Contains each function that has been imported into the current function.
     /// A unique `ValueId` for each function's [`Value::Function`] is stored so any given FunctionId
@@ -74,8 +74,9 @@ pub(crate) struct DataFlowGraph {
     blocks: DenseMap<BasicBlock>,
 
     /// Debugging information about which `ValueId`s have had their underlying `Value` substituted
-    /// for that of another. This information is purely used for printing the SSA, and has no
-    /// material effect on the SSA itself.
+    /// for that of another. In theory this information is purely used for printing the SSA,
+    /// and has no material effect on the SSA itself, however in practice the IDs can get out of
+    /// sync and may need this resolution before they can be compared.
     #[serde(skip)]
     replaced_value_ids: HashMap<ValueId, ValueId>,
 
@@ -96,7 +97,7 @@ pub(crate) struct DataFlowGraph {
     pub(crate) data_bus: DataBus,
 }
 
-pub(crate) type CallStack = im::Vector<Location>;
+pub(crate) type CallStack = super::list::List<Location>;
 
 impl DataFlowGraph {
     /// Creates a new basic block with no parameters.
@@ -118,7 +119,7 @@ impl DataFlowGraph {
         let parameters = self.blocks[block].parameters();
 
         let parameters = vecmap(parameters.iter().enumerate(), |(position, param)| {
-            let typ = self.values[*param].get_type().clone();
+            let typ = self.values[*param].get_type().into_owned();
             self.values.insert(Value::Param { block: new_block, position, typ })
         });
 
@@ -232,11 +233,12 @@ impl DataFlowGraph {
     pub(crate) fn set_type_of_value(&mut self, value_id: ValueId, target_type: Type) {
         let value = &mut self.values[value_id];
         match value {
-            Value::Instruction { typ, .. }
-            | Value::Param { typ, .. }
-            | Value::NumericConstant { typ, .. } => {
+            Value::Instruction { typ, .. } | Value::Param { typ, .. } => {
                 *typ = target_type;
             }
+            Value::NumericConstant { typ, .. } => {
+                *typ = target_type.unwrap_numeric();
+            }
             _ => {
                 unreachable!("ICE: Cannot set type of {:?}", value);
             }
@@ -256,21 +258,15 @@ impl DataFlowGraph {
 
     /// Creates a new constant value, or returns the Id to an existing one if
     /// one already exists.
-    pub(crate) fn make_constant(&mut self, constant: FieldElement, typ: Type) -> ValueId {
-        if let Some(id) = self.constants.get(&(constant, typ.clone())) {
+    pub(crate) fn make_constant(&mut self, constant: FieldElement, typ: NumericType) -> ValueId {
+        if let Some(id) = self.constants.get(&(constant, typ)) {
             return *id;
         }
-        let id = self.values.insert(Value::NumericConstant { constant, typ: typ.clone() });
+        let id = self.values.insert(Value::NumericConstant { constant, typ });
         self.constants.insert((constant, typ), id);
         id
     }
 
-    /// Create a new constant array value from the given elements
-    pub(crate) fn make_array(&mut self, array: im::Vector<ValueId>, typ: Type) -> ValueId {
-        assert!(matches!(typ, Type::Array(..) | Type::Slice(_)));
-        self.make_value(Value::Array { array, typ })
-    }
-
     /// Gets or creates a ValueId for the given FunctionId.
     pub(crate) fn import_function(&mut self, function: FunctionId) -> ValueId {
         if let Some(existing) = self.functions.get(&function) {
@@ -312,13 +308,13 @@ impl DataFlowGraph {
         instruction_id: InstructionId,
         ctrl_typevars: Option<Vec<Type>>,
     ) {
-        self.results.insert(instruction_id, Default::default());
+        let result_types = self.instruction_result_types(instruction_id, ctrl_typevars);
+        let results = vecmap(result_types.into_iter().enumerate(), |(position, typ)| {
+            let instruction = instruction_id;
+            self.values.insert(Value::Instruction { typ, position, instruction })
+        });
 
-        // Get all of the types that this instruction produces
-        // and append them as results.
-        for typ in self.instruction_result_types(instruction_id, ctrl_typevars) {
-            self.append_result(instruction_id, typ);
-        }
+        self.results.insert(instruction_id, results);
     }
 
     /// Return the result types of this instruction.
@@ -347,7 +343,7 @@ impl DataFlowGraph {
 
     /// Returns the type of a given value
     pub(crate) fn type_of_value(&self, value: ValueId) -> Type {
-        self.values[value].get_type().clone()
+        self.values[value].get_type().into_owned()
     }
 
     /// Returns the maximum possible number of bits that `value` can potentially be.
@@ -372,23 +368,7 @@ impl DataFlowGraph {
     /// True if the type of this value is Type::Reference.
     /// Using this method over type_of_value avoids cloning the value's type.
     pub(crate) fn value_is_reference(&self, value: ValueId) -> bool {
-        matches!(self.values[value].get_type(), Type::Reference(_))
-    }
-
-    /// Appends a result type to the instruction.
-    pub(crate) fn append_result(&mut self, instruction_id: InstructionId, typ: Type) -> ValueId {
-        let results = self.results.get_mut(&instruction_id).unwrap();
-        let expected_res_position = results.len();
-
-        let value_id = self.values.insert(Value::Instruction {
-            typ,
-            position: expected_res_position,
-            instruction: instruction_id,
-        });
-
-        // Add value to the list of results for this instruction
-        results.push(value_id);
-        value_id
+        matches!(self.values[value].get_type().as_ref(), Type::Reference(_))
     }
 
     /// Replaces an instruction result with a fresh id.
@@ -446,9 +426,9 @@ impl DataFlowGraph {
     pub(crate) fn get_numeric_constant_with_type(
         &self,
         value: ValueId,
-    ) -> Option<(FieldElement, Type)> {
+    ) -> Option<(FieldElement, NumericType)> {
         match &self.values[self.resolve(value)] {
-            Value::NumericConstant { constant, typ } => Some((*constant, typ.clone())),
+            Value::NumericConstant { constant, typ } => Some((*constant, *typ)),
             _ => None,
         }
     }
@@ -457,15 +437,18 @@ impl DataFlowGraph {
     /// Otherwise, this returns None.
     pub(crate) fn get_array_constant(&self, value: ValueId) -> Option<(im::Vector<ValueId>, Type)> {
         match &self.values[self.resolve(value)] {
+            Value::Instruction { instruction, .. } => match &self.instructions[*instruction] {
+                Instruction::MakeArray { elements, typ } => Some((elements.clone(), typ.clone())),
+                _ => None,
+            },
             // Arrays are shared, so cloning them is cheap
-            Value::Array { array, typ } => Some((array.clone(), typ.clone())),
             _ => None,
         }
     }
 
     /// If this value is an array, return the length of the array as indicated by its type.
     /// Otherwise, return None.
-    pub(crate) fn try_get_array_length(&self, value: ValueId) -> Option<usize> {
+    pub(crate) fn try_get_array_length(&self, value: ValueId) -> Option<u32> {
         match self.type_of_value(value) {
             Type::Array(_, length) => Some(length),
             _ => None,
@@ -514,15 +497,20 @@ impl DataFlowGraph {
     pub(crate) fn get_value_call_stack(&self, value: ValueId) -> CallStack {
         match &self.values[self.resolve(value)] {
             Value::Instruction { instruction, .. } => self.get_call_stack(*instruction),
-            _ => im::Vector::new(),
+            _ => CallStack::new(),
         }
     }
 
     /// True if the given ValueId refers to a (recursively) constant value
     pub(crate) fn is_constant(&self, argument: ValueId) -> bool {
         match &self[self.resolve(argument)] {
-            Value::Instruction { .. } | Value::Param { .. } => false,
-            Value::Array { array, .. } => array.iter().all(|element| self.is_constant(*element)),
+            Value::Param { .. } => false,
+            Value::Instruction { instruction, .. } => match &self[*instruction] {
+                Instruction::MakeArray { elements, .. } => {
+                    elements.iter().all(|element| self.is_constant(*element))
+                }
+                _ => false,
+            },
             _ => true,
         }
     }
@@ -574,6 +562,7 @@ impl std::ops::IndexMut<BasicBlockId> for DataFlowGraph {
 // The result of calling DataFlowGraph::insert_instruction can
 // be a list of results or a single ValueId if the instruction was simplified
 // to an existing value.
+#[derive(Debug)]
 pub(crate) enum InsertInstructionResult<'dfg> {
     /// Results is the standard case containing the instruction id and the results of that instruction.
     Results(InstructionId, &'dfg [ValueId]),
diff --git a/compiler/noirc_evaluator/src/ssa/ir/dom.rs b/compiler/noirc_evaluator/src/ssa/ir/dom.rs
index 94f7a405c05..504eecf4801 100644
--- a/compiler/noirc_evaluator/src/ssa/ir/dom.rs
+++ b/compiler/noirc_evaluator/src/ssa/ir/dom.rs
@@ -86,7 +86,7 @@ impl DominatorTree {
     ///
     /// This function panics if either of the blocks are unreachable.
     ///
-    /// An instruction is considered to dominate itself.
+    /// A block is considered to dominate itself.
     pub(crate) fn dominates(&mut self, block_a_id: BasicBlockId, block_b_id: BasicBlockId) -> bool {
         if let Some(res) = self.cache.get(&(block_a_id, block_b_id)) {
             return *res;
@@ -119,6 +119,29 @@ impl DominatorTree {
         }
     }
 
+    /// Walk up the dominator tree until we find a block for which `f` returns `Some` value.
+    /// Otherwise return `None` when we reach the top.
+    ///
+    /// Similar to `Iterator::filter_map` but only returns the first hit.
+    pub(crate) fn find_map_dominator<T>(
+        &self,
+        mut block_id: BasicBlockId,
+        f: impl Fn(BasicBlockId) -> Option<T>,
+    ) -> Option<T> {
+        if !self.is_reachable(block_id) {
+            return None;
+        }
+        loop {
+            if let Some(value) = f(block_id) {
+                return Some(value);
+            }
+            block_id = match self.immediate_dominator(block_id) {
+                Some(immediate_dominator) => immediate_dominator,
+                None => return None,
+            }
+        }
+    }
+
     /// Allocate and compute a dominator tree from a pre-computed control flow graph and
     /// post-order counterpart.
     pub(crate) fn with_cfg_and_post_order(cfg: &ControlFlowGraph, post_order: &PostOrder) -> Self {
@@ -448,4 +471,22 @@ mod tests {
         assert!(dt.dominates(block2_id, block1_id));
         assert!(dt.dominates(block2_id, block2_id));
     }
+
+    #[test]
+    fn test_find_map_dominator() {
+        let (dt, b0, b1, b2, _b3) = unreachable_node_setup();
+
+        assert_eq!(
+            dt.find_map_dominator(b2, |b| if b == b0 { Some("root") } else { None }),
+            Some("root")
+        );
+        assert_eq!(
+            dt.find_map_dominator(b1, |b| if b == b0 { Some("unreachable") } else { None }),
+            None
+        );
+        assert_eq!(
+            dt.find_map_dominator(b1, |b| if b == b1 { Some("not part of tree") } else { None }),
+            None
+        );
+    }
 }
diff --git a/compiler/noirc_evaluator/src/ssa/ir/function.rs b/compiler/noirc_evaluator/src/ssa/ir/function.rs
index 1466f2e5d44..6413107c04a 100644
--- a/compiler/noirc_evaluator/src/ssa/ir/function.rs
+++ b/compiler/noirc_evaluator/src/ssa/ir/function.rs
@@ -16,7 +16,7 @@ pub(crate) enum RuntimeType {
     // A noir function, to be compiled in ACIR and executed by ACVM
     Acir(InlineType),
     // Unconstrained function, to be compiled to brillig and executed by the Brillig VM
-    Brillig,
+    Brillig(InlineType),
 }
 
 impl RuntimeType {
@@ -27,9 +27,33 @@ impl RuntimeType {
     pub(crate) fn is_entry_point(&self) -> bool {
         match self {
             RuntimeType::Acir(inline_type) => inline_type.is_entry_point(),
-            RuntimeType::Brillig => true,
+            RuntimeType::Brillig(_) => true,
         }
     }
+
+    pub(crate) fn is_inline_always(&self) -> bool {
+        matches!(
+            self,
+            RuntimeType::Acir(InlineType::InlineAlways)
+                | RuntimeType::Brillig(InlineType::InlineAlways)
+        )
+    }
+
+    pub(crate) fn is_no_predicates(&self) -> bool {
+        matches!(
+            self,
+            RuntimeType::Acir(InlineType::NoPredicates)
+                | RuntimeType::Brillig(InlineType::NoPredicates)
+        )
+    }
+
+    pub(crate) fn is_brillig(&self) -> bool {
+        matches!(self, RuntimeType::Brillig(_))
+    }
+
+    pub(crate) fn is_acir(&self) -> bool {
+        matches!(self, RuntimeType::Acir(_))
+    }
 }
 
 /// A function holds a list of instructions.
@@ -103,7 +127,7 @@ impl Function {
     pub(crate) fn is_no_predicates(&self) -> bool {
         match self.runtime() {
             RuntimeType::Acir(inline_type) => matches!(inline_type, InlineType::NoPredicates),
-            RuntimeType::Brillig => false,
+            RuntimeType::Brillig(_) => false,
         }
     }
 
@@ -173,11 +197,17 @@ impl Function {
     }
 }
 
+impl Clone for Function {
+    fn clone(&self) -> Self {
+        Function::clone_with_id(self.id(), self)
+    }
+}
+
 impl std::fmt::Display for RuntimeType {
     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
         match self {
             RuntimeType::Acir(inline_type) => write!(f, "acir({inline_type})"),
-            RuntimeType::Brillig => write!(f, "brillig"),
+            RuntimeType::Brillig(inline_type) => write!(f, "brillig({inline_type})"),
         }
     }
 }
diff --git a/compiler/noirc_evaluator/src/ssa/ir/function_inserter.rs b/compiler/noirc_evaluator/src/ssa/ir/function_inserter.rs
index 991ff22c902..6ebd2aa1105 100644
--- a/compiler/noirc_evaluator/src/ssa/ir/function_inserter.rs
+++ b/compiler/noirc_evaluator/src/ssa/ir/function_inserter.rs
@@ -18,15 +18,26 @@ pub(crate) struct FunctionInserter<'f> {
     pub(crate) function: &'f mut Function,
 
     values: HashMap<ValueId, ValueId>,
+
     /// Map containing repeat array constants so that we do not initialize a new
     /// array unnecessarily. An extra tuple field is included as part of the key to
     /// distinguish between array/slice types.
-    const_arrays: HashMap<(im::Vector<ValueId>, Type), ValueId>,
+    ///
+    /// This is optional since caching arrays relies on the inserter inserting strictly
+    /// in control-flow order. Otherwise, if arrays later in the program are cached first,
+    /// they may be referred to by instructions earlier in the program.
+    array_cache: Option<ArrayCache>,
+
+    /// If this pass is loop unrolling, store the block before the loop to optionally
+    /// hoist any make_array instructions up to after they are retrieved from the `array_cache`.
+    pre_loop: Option<BasicBlockId>,
 }
 
+pub(crate) type ArrayCache = HashMap<im::Vector<ValueId>, HashMap<Type, ValueId>>;
+
 impl<'f> FunctionInserter<'f> {
     pub(crate) fn new(function: &'f mut Function) -> FunctionInserter<'f> {
-        Self { function, values: HashMap::default(), const_arrays: HashMap::default() }
+        Self { function, values: HashMap::default(), array_cache: None, pre_loop: None }
     }
 
     /// Resolves a ValueId to its new, updated value.
@@ -36,27 +47,7 @@ impl<'f> FunctionInserter<'f> {
         value = self.function.dfg.resolve(value);
         match self.values.get(&value) {
             Some(value) => self.resolve(*value),
-            None => match &self.function.dfg[value] {
-                super::value::Value::Array { array, typ } => {
-                    let array = array.clone();
-                    let typ = typ.clone();
-                    let new_array: im::Vector<ValueId> =
-                        array.iter().map(|id| self.resolve(*id)).collect();
-
-                    if let Some(fetched_value) =
-                        self.const_arrays.get(&(new_array.clone(), typ.clone()))
-                    {
-                        return *fetched_value;
-                    };
-
-                    let new_array_clone = new_array.clone();
-                    let new_id = self.function.dfg.make_array(new_array, typ.clone());
-                    self.values.insert(value, new_id);
-                    self.const_arrays.insert((new_array_clone, typ), new_id);
-                    new_id
-                }
-                _ => value,
-            },
+            None => value,
         }
     }
 
@@ -80,6 +71,7 @@ impl<'f> FunctionInserter<'f> {
         }
     }
 
+    /// Get an instruction and make sure all the values in it are freshly resolved.
     pub(crate) fn map_instruction(&mut self, id: InstructionId) -> (Instruction, CallStack) {
         (
             self.function.dfg[id].clone().map_values(|id| self.resolve(id)),
@@ -122,7 +114,7 @@ impl<'f> FunctionInserter<'f> {
         &mut self,
         instruction: Instruction,
         id: InstructionId,
-        block: BasicBlockId,
+        mut block: BasicBlockId,
         call_stack: CallStack,
     ) -> InsertInstructionResult {
         let results = self.function.dfg.instruction_results(id);
@@ -132,6 +124,30 @@ impl<'f> FunctionInserter<'f> {
             .requires_ctrl_typevars()
             .then(|| vecmap(&results, |result| self.function.dfg.type_of_value(*result)));
 
+        // Large arrays can lead to OOM panics if duplicated from being unrolled in loops.
+        // To prevent this, try to reuse the same ID for identical arrays instead of inserting
+        // another MakeArray instruction. Note that this assumes the function inserter is inserting
+        // in control-flow order. Otherwise we could refer to ValueIds defined later in the program.
+        let make_array = if let Instruction::MakeArray { elements, typ } = &instruction {
+            if self.array_is_constant(elements) && self.function.runtime().is_acir() {
+                if let Some(fetched_value) = self.get_cached_array(elements, typ) {
+                    assert_eq!(results.len(), 1);
+                    self.values.insert(results[0], fetched_value);
+                    return InsertInstructionResult::SimplifiedTo(fetched_value);
+                }
+
+                // Hoist constant arrays out of the loop and cache their value
+                if let Some(pre_loop) = self.pre_loop {
+                    block = pre_loop;
+                }
+                Some((elements.clone(), typ.clone()))
+            } else {
+                None
+            }
+        } else {
+            None
+        };
+
         let new_results = self.function.dfg.insert_instruction_and_results(
             instruction,
             block,
@@ -139,10 +155,54 @@ impl<'f> FunctionInserter<'f> {
             call_stack,
         );
 
+        // Cache an array in the fresh_array_cache if array caching is enabled.
+        // The fresh cache isn't used for deduplication until an external pass confirms we
+        // pass a sequence point and all blocks that may be before the current insertion point
+        // are finished.
+        if let Some((elements, typ)) = make_array {
+            Self::cache_array(&mut self.array_cache, elements, typ, new_results.first());
+        }
+
         Self::insert_new_instruction_results(&mut self.values, &results, &new_results);
         new_results
     }
 
+    fn get_cached_array(&self, elements: &im::Vector<ValueId>, typ: &Type) -> Option<ValueId> {
+        self.array_cache.as_ref()?.get(elements)?.get(typ).copied()
+    }
+
+    fn cache_array(
+        arrays: &mut Option<ArrayCache>,
+        elements: im::Vector<ValueId>,
+        typ: Type,
+        result_id: ValueId,
+    ) {
+        if let Some(arrays) = arrays {
+            arrays.entry(elements).or_default().insert(typ, result_id);
+        }
+    }
+
+    fn array_is_constant(&self, elements: &im::Vector<ValueId>) -> bool {
+        elements.iter().all(|element| self.function.dfg.is_constant(*element))
+    }
+
+    pub(crate) fn set_array_cache(
+        &mut self,
+        new_cache: Option<ArrayCache>,
+        pre_loop: BasicBlockId,
+    ) {
+        self.array_cache = new_cache;
+        self.pre_loop = Some(pre_loop);
+    }
+
+    /// Finish this inserter, returning its array cache merged with the fresh array cache.
+    /// Since this consumes the inserter this assumes we're at a sequence point where all
+    /// predecessor blocks to the current block are finished. Since this is true, the fresh
+    /// array cache can be merged with the existing array cache.
+    pub(crate) fn into_array_cache(self) -> Option<ArrayCache> {
+        self.array_cache
+    }
+
     /// Modify the values HashMap to remember the mapping between an instruction result's previous
     /// ValueId (from the source_function) and its new ValueId in the destination function.
     pub(crate) fn insert_new_instruction_results(
diff --git a/compiler/noirc_evaluator/src/ssa/ir/instruction.rs b/compiler/noirc_evaluator/src/ssa/ir/instruction.rs
index e30707effed..fb35978d906 100644
--- a/compiler/noirc_evaluator/src/ssa/ir/instruction.rs
+++ b/compiler/noirc_evaluator/src/ssa/ir/instruction.rs
@@ -1,24 +1,21 @@
-use noirc_errors::Location;
 use serde::{Deserialize, Serialize};
 use std::hash::{Hash, Hasher};
 
 use acvm::{
     acir::AcirField,
-    acir::{
-        circuit::{ErrorSelector, STRING_ERROR_SELECTOR},
-        BlackBoxFunc,
-    },
+    acir::{circuit::ErrorSelector, BlackBoxFunc},
     FieldElement,
 };
-use fxhash::FxHasher;
+use fxhash::FxHasher64;
 use iter_extended::vecmap;
 use noirc_frontend::hir_def::types::Type as HirType;
 
-use crate::ssa::opt::flatten_cfg::value_merger::ValueMerger;
+use crate::ssa::{ir::function::RuntimeType, opt::flatten_cfg::value_merger::ValueMerger};
 
 use super::{
     basic_block::BasicBlockId,
     dfg::{CallStack, DataFlowGraph},
+    function::Function,
     map::Id,
     types::{NumericType, Type},
     value::{Value, ValueId},
@@ -47,8 +44,7 @@ pub(crate) type InstructionId = Id<Instruction>;
 /// - Opcodes which the IR knows the target machine has
 /// special support for. (LowLevel)
 /// - Opcodes which have no function definition in the
-/// source code and must be processed by the IR. An example
-/// of this is println.
+/// source code and must be processed by the IR.
 #[derive(Debug, Copy, Clone, PartialEq, Eq, Hash, Serialize, Deserialize)]
 pub(crate) enum Intrinsic {
     ArrayLen,
@@ -67,11 +63,15 @@ pub(crate) enum Intrinsic {
     ToBits(Endian),
     ToRadix(Endian),
     BlackBox(BlackBoxFunc),
+    Hint(Hint),
     FromField,
     AsField,
     AsWitness,
     IsUnconstrained,
     DerivePedersenGenerators,
+    FieldLessThan,
+    ArrayRefCount,
+    SliceRefCount,
 }
 
 impl std::fmt::Display for Intrinsic {
@@ -95,11 +95,15 @@ impl std::fmt::Display for Intrinsic {
             Intrinsic::ToRadix(Endian::Big) => write!(f, "to_be_radix"),
             Intrinsic::ToRadix(Endian::Little) => write!(f, "to_le_radix"),
             Intrinsic::BlackBox(function) => write!(f, "{function}"),
+            Intrinsic::Hint(Hint::BlackBox) => write!(f, "black_box"),
             Intrinsic::FromField => write!(f, "from_field"),
             Intrinsic::AsField => write!(f, "as_field"),
             Intrinsic::AsWitness => write!(f, "as_witness"),
             Intrinsic::IsUnconstrained => write!(f, "is_unconstrained"),
             Intrinsic::DerivePedersenGenerators => write!(f, "derive_pedersen_generators"),
+            Intrinsic::FieldLessThan => write!(f, "field_less_than"),
+            Intrinsic::ArrayRefCount => write!(f, "array_refcount"),
+            Intrinsic::SliceRefCount => write!(f, "slice_refcount"),
         }
     }
 }
@@ -108,30 +112,41 @@ impl Intrinsic {
     /// Returns whether the `Intrinsic` has side effects.
     ///
     /// If there are no side effects then the `Intrinsic` can be removed if the result is unused.
+    ///
+    /// An example of a side effect is increasing the reference count of an array, but functions
+    /// which can fail due to implicit constraints are also considered to have a side effect.
     pub(crate) fn has_side_effects(&self) -> bool {
         match self {
             Intrinsic::AssertConstant
             | Intrinsic::StaticAssert
             | Intrinsic::ApplyRangeConstraint
+            // Array & slice ref counts are treated as having side effects since they operate
+            // on hidden variables on otherwise identical array values.
+            | Intrinsic::ArrayRefCount
+            | Intrinsic::SliceRefCount
             | Intrinsic::AsWitness => true,
 
             // These apply a constraint that the input must fit into a specified number of limbs.
             Intrinsic::ToBits(_) | Intrinsic::ToRadix(_) => true,
 
+            // These imply a check that the slice is non-empty and should fail otherwise.
+            Intrinsic::SlicePopBack | Intrinsic::SlicePopFront | Intrinsic::SliceRemove => true,
+
             Intrinsic::ArrayLen
             | Intrinsic::ArrayAsStrUnchecked
             | Intrinsic::AsSlice
             | Intrinsic::SlicePushBack
             | Intrinsic::SlicePushFront
-            | Intrinsic::SlicePopBack
-            | Intrinsic::SlicePopFront
             | Intrinsic::SliceInsert
-            | Intrinsic::SliceRemove
             | Intrinsic::StrAsBytes
             | Intrinsic::FromField
             | Intrinsic::AsField
             | Intrinsic::IsUnconstrained
-            | Intrinsic::DerivePedersenGenerators => false,
+            | Intrinsic::DerivePedersenGenerators
+            | Intrinsic::FieldLessThan => false,
+
+            // Treat the black_box hint as-if it could potentially have side effects.
+            Intrinsic::Hint(Hint::BlackBox) => true,
 
             // Some black box functions have side-effects
             Intrinsic::BlackBox(func) => matches!(
@@ -143,6 +158,39 @@ impl Intrinsic {
         }
     }
 
+    /// Intrinsics which only have a side effect due to the chance that
+    /// they can fail a constraint can be deduplicated.
+    pub(crate) fn can_be_deduplicated(&self, deduplicate_with_predicate: bool) -> bool {
+        match self {
+            // These apply a constraint in the form of ACIR opcodes, but they can be deduplicated
+            // if the inputs are the same. If they depend on a side effect variable (e.g. because
+            // they were in an if-then-else) then `handle_instruction_side_effects` in `flatten_cfg`
+            // will have attached the condition variable to their inputs directly, so they don't
+            // directly depend on the corresponding `enable_side_effect` instruction any more.
+            // However, to conform with the expectations of `Instruction::can_be_deduplicated` and
+            // `constant_folding` we only use this information if the caller shows interest in it.
+            Intrinsic::ToBits(_)
+            | Intrinsic::ToRadix(_)
+            | Intrinsic::BlackBox(
+                BlackBoxFunc::MultiScalarMul
+                | BlackBoxFunc::EmbeddedCurveAdd
+                | BlackBoxFunc::RecursiveAggregation,
+            ) => deduplicate_with_predicate,
+
+            // Operations that remove items from a slice don't modify the slice, they just assert it's non-empty.
+            Intrinsic::SlicePopBack | Intrinsic::SlicePopFront | Intrinsic::SliceRemove => {
+                deduplicate_with_predicate
+            }
+
+            Intrinsic::AssertConstant
+            | Intrinsic::StaticAssert
+            | Intrinsic::ApplyRangeConstraint
+            | Intrinsic::AsWitness => deduplicate_with_predicate,
+
+            _ => !self.has_side_effects(),
+        }
+    }
+
     /// Lookup an Intrinsic by name and return it if found.
     /// If there is no such intrinsic by that name, None is returned.
     pub(crate) fn lookup(name: &str) -> Option<Intrinsic> {
@@ -169,6 +217,11 @@ impl Intrinsic {
             "as_witness" => Some(Intrinsic::AsWitness),
             "is_unconstrained" => Some(Intrinsic::IsUnconstrained),
             "derive_pedersen_generators" => Some(Intrinsic::DerivePedersenGenerators),
+            "field_less_than" => Some(Intrinsic::FieldLessThan),
+            "black_box" => Some(Intrinsic::Hint(Hint::BlackBox)),
+            "array_refcount" => Some(Intrinsic::ArrayRefCount),
+            "slice_refcount" => Some(Intrinsic::SliceRefCount),
+
             other => BlackBoxFunc::lookup(other).map(Intrinsic::BlackBox),
         }
     }
@@ -181,6 +234,16 @@ pub(crate) enum Endian {
     Little,
 }
 
+/// Compiler hints.
+#[derive(Clone, Copy, Debug, Hash, PartialEq, Eq, Serialize, Deserialize)]
+pub(crate) enum Hint {
+    /// Hint to the compiler to treat the call as having potential side effects,
+    /// so that the value passed to it can survive SSA passes without being
+    /// simplified out completely. This facilitates testing and reproducing
+    /// runtime behavior with constants.
+    BlackBox,
+}
+
 #[derive(Debug, PartialEq, Eq, Hash, Clone, Serialize, Deserialize)]
 /// Instructions are used to perform tasks.
 /// The instructions that the IR is able to specify are listed below.
@@ -188,8 +251,8 @@ pub(crate) enum Instruction {
     /// Binary Operations like +, -, *, /, ==, !=
     Binary(Binary),
 
-    /// Converts `Value` into Typ
-    Cast(ValueId, Type),
+    /// Converts `Value` into the given NumericType
+    Cast(ValueId, NumericType),
 
     /// Computes a bit wise not
     Not(ValueId),
@@ -232,7 +295,7 @@ pub(crate) enum Instruction {
     /// - `code1` will have side effects iff `condition1` evaluates to `true`
     ///
     /// This instruction is only emitted after the cfg flattening pass, and is used to annotate
-    /// instruction regions with an condition that corresponds to their position in the CFG's
+    /// instruction regions with a condition that corresponds to their position in the CFG's
     /// if-branching structure.
     EnableSideEffectsIf { condition: ValueId },
 
@@ -267,15 +330,18 @@ pub(crate) enum Instruction {
     ///     else_value
     /// }
     /// ```
-    ///
-    /// Where we save the result of !then_condition so that we have the same
-    /// ValueId for it each time.
     IfElse {
         then_condition: ValueId,
         then_value: ValueId,
         else_condition: ValueId,
         else_value: ValueId,
     },
+
+    /// Creates a new array or slice.
+    ///
+    /// `typ` should be an array or slice type with an element type
+    /// matching each of the `elements` values' types.
+    MakeArray { elements: im::Vector<ValueId>, typ: Type },
 }
 
 impl Instruction {
@@ -288,7 +354,8 @@ impl Instruction {
     pub(crate) fn result_type(&self) -> InstructionResultType {
         match self {
             Instruction::Binary(binary) => binary.result_type(),
-            Instruction::Cast(_, typ) => InstructionResultType::Known(typ.clone()),
+            Instruction::Cast(_, typ) => InstructionResultType::Known(Type::Numeric(*typ)),
+            Instruction::MakeArray { typ, .. } => InstructionResultType::Known(typ.clone()),
             Instruction::Not(value)
             | Instruction::Truncate { value, .. }
             | Instruction::ArraySet { array: value, .. }
@@ -314,13 +381,69 @@ impl Instruction {
         matches!(self.result_type(), InstructionResultType::Unknown)
     }
 
+    /// Indicates if the instruction has a side effect, ie. it can fail, or it interacts with memory.
+    ///
+    /// This is similar to `can_be_deduplicated`, but it doesn't depend on whether the caller takes
+    /// constraints into account, because it might not use it to isolate the side effects across branches.
+    pub(crate) fn has_side_effects(&self, dfg: &DataFlowGraph) -> bool {
+        use Instruction::*;
+
+        match self {
+            // These either have side-effects or interact with memory
+            EnableSideEffectsIf { .. }
+            | Allocate
+            | Load { .. }
+            | Store { .. }
+            | IncrementRc { .. }
+            | DecrementRc { .. } => true,
+
+            Call { func, .. } => match dfg[*func] {
+                Value::Intrinsic(intrinsic) => intrinsic.has_side_effects(),
+                _ => true, // Be conservative and assume other functions can have side effects.
+            },
+
+            // These can fail.
+            Constrain(..) | RangeCheck { .. } => true,
+
+            // This should never be side-effectful
+            MakeArray { .. } => false,
+
+            // Some binary math can overflow or underflow
+            Binary(binary) => match binary.operator {
+                BinaryOp::Add | BinaryOp::Sub | BinaryOp::Mul | BinaryOp::Div | BinaryOp::Mod => {
+                    true
+                }
+                BinaryOp::Eq
+                | BinaryOp::Lt
+                | BinaryOp::And
+                | BinaryOp::Or
+                | BinaryOp::Xor
+                | BinaryOp::Shl
+                | BinaryOp::Shr => false,
+            },
+
+            // These can have different behavior depending on the EnableSideEffectsIf context.
+            Cast(_, _)
+            | Not(_)
+            | Truncate { .. }
+            | IfElse { .. }
+            | ArrayGet { .. }
+            | ArraySet { .. } => self.requires_acir_gen_predicate(dfg),
+        }
+    }
+
     /// Indicates if the instruction can be safely replaced with the results of another instruction with the same inputs.
     /// If `deduplicate_with_predicate` is set, we assume we're deduplicating with the instruction
     /// and its predicate, rather than just the instruction. Setting this means instructions that
     /// rely on predicates can be deduplicated as well.
+    ///
+    /// Some instructions get the predicate attached to their inputs by `handle_instruction_side_effects` in `flatten_cfg`.
+    /// These can be deduplicated because they implicitly depend on the predicate, not only when the caller uses the
+    /// predicate variable as a key to cache results. However, to avoid tight coupling between passes, we make the deduplication
+    /// conditional on whether the caller wants the predicate to be taken into account or not.
     pub(crate) fn can_be_deduplicated(
         &self,
-        dfg: &DataFlowGraph,
+        function: &Function,
         deduplicate_with_predicate: bool,
     ) -> bool {
         use Instruction::*;
@@ -334,14 +457,22 @@ impl Instruction {
             | IncrementRc { .. }
             | DecrementRc { .. } => false,
 
-            Call { func, .. } => match dfg[*func] {
-                Value::Intrinsic(intrinsic) => !intrinsic.has_side_effects(),
+            Call { func, .. } => match function.dfg[*func] {
+                Value::Intrinsic(intrinsic) => {
+                    intrinsic.can_be_deduplicated(deduplicate_with_predicate)
+                }
                 _ => false,
             },
 
             // We can deduplicate these instructions if we know the predicate is also the same.
             Constrain(..) | RangeCheck { .. } => deduplicate_with_predicate,
 
+            // Arrays can be mutated in unconstrained code so code that handles this case must
+            // take care to track whether the array was possibly mutated or not before
+            // deduplicating. Since we don't know if the containing pass checks for this, we
+            // can only assume these are safe to deduplicate in constrained code.
+            MakeArray { .. } => function.runtime().is_acir(),
+
             // These can have different behavior depending on the EnableSideEffectsIf context.
             // Replacing them with a similar instruction potentially enables replacing an instruction
             // with one that was disabled. See
@@ -353,17 +484,17 @@ impl Instruction {
             | IfElse { .. }
             | ArrayGet { .. }
             | ArraySet { .. } => {
-                deduplicate_with_predicate || !self.requires_acir_gen_predicate(dfg)
+                deduplicate_with_predicate || !self.requires_acir_gen_predicate(&function.dfg)
             }
         }
     }
 
-    pub(crate) fn can_eliminate_if_unused(&self, dfg: &DataFlowGraph) -> bool {
+    pub(crate) fn can_eliminate_if_unused(&self, function: &Function) -> bool {
         use Instruction::*;
         match self {
             Binary(binary) => {
                 if matches!(binary.operator, BinaryOp::Div | BinaryOp::Mod) {
-                    if let Some(rhs) = dfg.get_numeric_constant(binary.rhs) {
+                    if let Some(rhs) = function.dfg.get_numeric_constant(binary.rhs) {
                         rhs != FieldElement::zero()
                     } else {
                         false
@@ -379,20 +510,33 @@ impl Instruction {
             | Load { .. }
             | ArrayGet { .. }
             | IfElse { .. }
-            | ArraySet { .. } => true,
+            | ArraySet { .. }
+            | MakeArray { .. } => true,
+
+            // Store instructions must be removed by DIE in acir code, any load
+            // instructions should already be unused by that point.
+            //
+            // Note that this check assumes that it is being performed after the flattening
+            // pass and after the last mem2reg pass. This is currently the case for the DIE
+            // pass where this check is done, but does mean that we cannot perform mem2reg
+            // after the DIE pass.
+            Store { .. } => {
+                matches!(function.runtime(), RuntimeType::Acir(_))
+                    && function.reachable_blocks().len() == 1
+            }
 
             Constrain(..)
-            | Store { .. }
             | EnableSideEffectsIf { .. }
             | IncrementRc { .. }
             | DecrementRc { .. }
             | RangeCheck { .. } => false,
 
             // Some `Intrinsic`s have side effects so we must check what kind of `Call` this is.
-            Call { func, .. } => match dfg[*func] {
+            Call { func, .. } => match function.dfg[*func] {
                 // Explicitly allows removal of unused ec operations, even if they can fail
                 Value::Intrinsic(Intrinsic::BlackBox(BlackBoxFunc::MultiScalarMul))
                 | Value::Intrinsic(Intrinsic::BlackBox(BlackBoxFunc::EmbeddedCurveAdd)) => true,
+
                 Value::Intrinsic(intrinsic) => !intrinsic.has_side_effects(),
 
                 // All foreign functions are treated as having side effects.
@@ -408,7 +552,7 @@ impl Instruction {
         }
     }
 
-    /// If true the instruction will depends on enable_side_effects context during acir-gen
+    /// If true the instruction will depend on `enable_side_effects` context during acir-gen.
     pub(crate) fn requires_acir_gen_predicate(&self, dfg: &DataFlowGraph) -> bool {
         match self {
             Instruction::Binary(binary)
@@ -442,7 +586,8 @@ impl Instruction {
             | Instruction::Store { .. }
             | Instruction::IfElse { .. }
             | Instruction::IncrementRc { .. }
-            | Instruction::DecrementRc { .. } => false,
+            | Instruction::DecrementRc { .. }
+            | Instruction::MakeArray { .. } => false,
         }
     }
 
@@ -456,7 +601,7 @@ impl Instruction {
                 rhs: f(binary.rhs),
                 operator: binary.operator,
             }),
-            Instruction::Cast(value, typ) => Instruction::Cast(f(*value), typ.clone()),
+            Instruction::Cast(value, typ) => Instruction::Cast(f(*value), *typ),
             Instruction::Not(value) => Instruction::Not(f(*value)),
             Instruction::Truncate { value, bit_size, max_bit_size } => Instruction::Truncate {
                 value: f(*value),
@@ -468,10 +613,13 @@ impl Instruction {
                 let lhs = f(*lhs);
                 let rhs = f(*rhs);
                 let assert_message = assert_message.as_ref().map(|error| match error {
-                    ConstrainError::Dynamic(selector, payload_values) => ConstrainError::Dynamic(
-                        *selector,
-                        payload_values.iter().map(|&value| f(value)).collect(),
-                    ),
+                    ConstrainError::Dynamic(selector, is_string, payload_values) => {
+                        ConstrainError::Dynamic(
+                            *selector,
+                            *is_string,
+                            payload_values.iter().map(|&value| f(value)).collect(),
+                        )
+                    }
                     _ => error.clone(),
                 });
                 Instruction::Constrain(lhs, rhs, assert_message)
@@ -514,6 +662,10 @@ impl Instruction {
                     else_value: f(*else_value),
                 }
             }
+            Instruction::MakeArray { elements, typ } => Instruction::MakeArray {
+                elements: elements.iter().copied().map(f).collect(),
+                typ: typ.clone(),
+            },
         }
     }
 
@@ -539,7 +691,7 @@ impl Instruction {
             Instruction::Constrain(lhs, rhs, assert_error) => {
                 f(*lhs);
                 f(*rhs);
-                if let Some(ConstrainError::Dynamic(_, values)) = assert_error.as_ref() {
+                if let Some(ConstrainError::Dynamic(_, _, values)) = assert_error.as_ref() {
                     values.iter().for_each(|&val| {
                         f(val);
                     });
@@ -574,6 +726,11 @@ impl Instruction {
                 f(*else_condition);
                 f(*else_value);
             }
+            Instruction::MakeArray { elements, typ: _ } => {
+                for element in elements {
+                    f(*element);
+                }
+            }
         }
     }
 
@@ -592,7 +749,7 @@ impl Instruction {
         use SimplifyResult::*;
         match self {
             Instruction::Binary(binary) => binary.simplify(dfg),
-            Instruction::Cast(value, typ) => simplify_cast(*value, typ, dfg),
+            Instruction::Cast(value, typ) => simplify_cast(*value, *typ, dfg),
             Instruction::Not(value) => {
                 match &dfg[dfg.resolve(*value)] {
                     // Limit optimizing ! on constants to only booleans. If we tried it on fields,
@@ -601,7 +758,7 @@ impl Instruction {
                     Value::NumericConstant { constant, typ } if typ.is_unsigned() => {
                         // As we're casting to a `u128`, we need to clear out any upper bits that the NOT fills.
                         let value = !constant.to_u128() % (1 << typ.bit_size());
-                        SimplifiedTo(dfg.make_constant(value.into(), typ.clone()))
+                        SimplifiedTo(dfg.make_constant(value.into(), *typ))
                     }
                     Value::Instruction { instruction, .. } => {
                         // !!v => v
@@ -629,19 +786,28 @@ impl Instruction {
                     None
                 }
             }
-            Instruction::ArraySet { array, index, value, .. } => {
-                let array = dfg.get_array_constant(*array);
-                let index = dfg.get_numeric_constant(*index);
-                if let (Some((array, element_type)), Some(index)) = (array, index) {
+            Instruction::ArraySet { array: array_id, index: index_id, value, .. } => {
+                let array = dfg.get_array_constant(*array_id);
+                let index = dfg.get_numeric_constant(*index_id);
+                if let (Some((array, _element_type)), Some(index)) = (array, index) {
                     let index =
                         index.try_to_u32().expect("Expected array index to fit in u32") as usize;
 
                     if index < array.len() {
-                        let new_array = dfg.make_array(array.update(index, *value), element_type);
-                        return SimplifiedTo(new_array);
+                        let elements = array.update(index, *value);
+                        let typ = dfg.type_of_value(*array_id);
+                        let instruction = Instruction::MakeArray { elements, typ };
+                        let new_array = dfg.insert_instruction_and_results(
+                            instruction,
+                            block,
+                            Option::None,
+                            call_stack.clone(),
+                        );
+                        return SimplifiedTo(new_array.first());
                     }
                 }
-                None
+
+                try_optimize_array_set_from_previous_get(dfg, *array_id, *index_id, *value)
             }
             Instruction::Truncate { value, bit_size, max_bit_size } => {
                 if bit_size == max_bit_size {
@@ -754,6 +920,7 @@ impl Instruction {
                     None
                 }
             }
+            Instruction::MakeArray { .. } => None,
         }
     }
 }
@@ -797,13 +964,13 @@ fn try_optimize_array_get_from_previous_set(
                             return SimplifyResult::None;
                         }
                     }
+                    Instruction::MakeArray { elements: array, typ: _ } => {
+                        elements = Some(array.clone());
+                        break;
+                    }
                     _ => return SimplifyResult::None,
                 }
             }
-            Value::Array { array, typ: _ } => {
-                elements = Some(array.clone());
-                break;
-            }
             _ => return SimplifyResult::None,
         }
     }
@@ -817,19 +984,111 @@ fn try_optimize_array_get_from_previous_set(
     SimplifyResult::None
 }
 
-pub(crate) type ErrorType = HirType;
-
-pub(crate) fn error_selector_from_type(typ: &ErrorType) -> ErrorSelector {
-    match typ {
-        ErrorType::String(_) => STRING_ERROR_SELECTOR,
-        _ => {
-            let mut hasher = FxHasher::default();
-            typ.hash(&mut hasher);
-            let hash = hasher.finish();
-            assert!(hash != 0, "ICE: Error type {} collides with the string error type", typ);
-            ErrorSelector::new(hash)
+/// If we have an array set whose value is from an array get on the same array at the same index,
+/// we can simplify that array set to the array we were looking to perform an array set upon.
+///
+/// Simple case:
+/// v3 = array_get v1, index v2
+/// v5 = array_set v1, index v2, value v3
+///
+/// If we could not immediately simplify the array set from its value, we can try to follow
+/// the array set backwards in the case we have constant indices:
+///
+/// v3 = array_get v1, index 1
+/// v5 = array_set v1, index 2, value [Field 100, Field 101, Field 102]
+/// v7 = array_set mut v5, index 1, value v3
+///
+/// We want to optimize `v7` to `v5`. We see that `v3` comes from an array get to `v1`. We follow `v5` backwards and see an array set
+/// to `v1` and see that the previous array set occurs to a different constant index.
+///
+/// For each array_set:
+/// - If the index is non-constant we fail the optimization since any index may be changed.
+/// - If the index is constant and is our target index, we conservatively fail the optimization.
+/// - Otherwise, we check the array value of the `array_set`. We will refer to this array as array'.
+///   In the case above, array' is `v1` from `v5 = array set ...`
+///   - If the original `array_set` value comes from an `array_get`, check the array in that `array_get` against array'.
+///   - If the two values are equal we can simplify.
+///     - Continuing the example above, as we have `v3 = array_get v1, index 1`, `v1` is
+///       what we want to check against array'. We now know we can simplify `v7` to `v5` as it is unchanged.
+///   - If they are not equal, recur marking the current `array_set` array as the new array id to use in the checks
+fn try_optimize_array_set_from_previous_get(
+    dfg: &DataFlowGraph,
+    mut array_id: ValueId,
+    target_index: ValueId,
+    target_value: ValueId,
+) -> SimplifyResult {
+    let array_from_get = match &dfg[target_value] {
+        Value::Instruction { instruction, .. } => match &dfg[*instruction] {
+            Instruction::ArrayGet { array, index } => {
+                if *array == array_id && *index == target_index {
+                    // If array and index match from the value, we can immediately simplify
+                    return SimplifyResult::SimplifiedTo(array_id);
+                } else if *index == target_index {
+                    *array
+                } else {
+                    return SimplifyResult::None;
+                }
+            }
+            _ => return SimplifyResult::None,
+        },
+        _ => return SimplifyResult::None,
+    };
+
+    // At this point we have determined that the value we are writing in the `array_set` instruction
+    // comes from an `array_get` from the same index at which we want to write it at.
+    // It's possible that we're acting on the same array where other indices have been mutated in between
+    // the `array_get` and `array_set` (resulting in the `array_id` not matching).
+    //
+    // We then inspect the set of `array_set`s which which led to the current array the `array_set` is acting on.
+    // If we can work back to the array on which the `array_get` was reading from without having another `array_set`
+    // act on the same index then we can be sure that the new `array_set` can be removed without affecting the final result.
+    let Some(target_index) = dfg.get_numeric_constant(target_index) else {
+        return SimplifyResult::None;
+    };
+
+    let original_array_id = array_id;
+    // Arbitrary number of maximum tries just to prevent this optimization from taking too long.
+    let max_tries = 5;
+    for _ in 0..max_tries {
+        match &dfg[array_id] {
+            Value::Instruction { instruction, .. } => match &dfg[*instruction] {
+                Instruction::ArraySet { array, index, .. } => {
+                    let Some(index) = dfg.get_numeric_constant(*index) else {
+                        return SimplifyResult::None;
+                    };
+
+                    if index == target_index {
+                        return SimplifyResult::None;
+                    }
+
+                    if *array == array_from_get {
+                        return SimplifyResult::SimplifiedTo(original_array_id);
+                    }
+
+                    array_id = *array; // recur
+                }
+                _ => return SimplifyResult::None,
+            },
+            _ => return SimplifyResult::None,
         }
     }
+
+    SimplifyResult::None
+}
+
+#[derive(Debug, PartialEq, Eq, Hash, Clone)]
+pub enum ErrorType {
+    String(String),
+    Dynamic(HirType),
+}
+
+impl ErrorType {
+    pub fn selector(&self) -> ErrorSelector {
+        let mut hasher = FxHasher64::default();
+        self.hash(&mut hasher);
+        let hash = hasher.finish();
+        ErrorSelector::new(hash)
+    }
 }
 
 #[derive(Debug, PartialEq, Eq, Hash, Clone, Serialize, Deserialize)]
@@ -837,7 +1096,8 @@ pub(crate) enum ConstrainError {
     // Static string errors are not handled inside the program as data for efficiency reasons.
     StaticString(String),
     // These errors are handled by the program as data.
-    Dynamic(ErrorSelector, Vec<ValueId>),
+    // We use a boolean to indicate if the error is a string for printing purposes.
+    Dynamic(ErrorSelector, /* is_string */ bool, Vec<ValueId>),
 }
 
 impl From<String> for ConstrainError {
@@ -987,7 +1247,7 @@ impl TerminatorInstruction {
         }
     }
 
-    pub(crate) fn call_stack(&self) -> im::Vector<Location> {
+    pub(crate) fn call_stack(&self) -> CallStack {
         match self {
             TerminatorInstruction::JmpIf { call_stack, .. }
             | TerminatorInstruction::Jmp { call_stack, .. }
diff --git a/compiler/noirc_evaluator/src/ssa/ir/instruction/binary.rs b/compiler/noirc_evaluator/src/ssa/ir/instruction/binary.rs
index 03262be0a06..81f2f3b1e01 100644
--- a/compiler/noirc_evaluator/src/ssa/ir/instruction/binary.rs
+++ b/compiler/noirc_evaluator/src/ssa/ir/instruction/binary.rs
@@ -88,7 +88,7 @@ impl Binary {
     pub(super) fn simplify(&self, dfg: &mut DataFlowGraph) -> SimplifyResult {
         let lhs = dfg.get_numeric_constant(self.lhs);
         let rhs = dfg.get_numeric_constant(self.rhs);
-        let operand_type = dfg.type_of_value(self.lhs);
+        let operand_type = dfg.type_of_value(self.lhs).unwrap_numeric();
 
         if let (Some(lhs), Some(rhs)) = (lhs, rhs) {
             return match eval_constant_binary_op(lhs, rhs, self.operator, operand_type) {
@@ -168,11 +168,11 @@ impl Binary {
             }
             BinaryOp::Eq => {
                 if dfg.resolve(self.lhs) == dfg.resolve(self.rhs) {
-                    let one = dfg.make_constant(FieldElement::one(), Type::bool());
+                    let one = dfg.make_constant(FieldElement::one(), NumericType::bool());
                     return SimplifyResult::SimplifiedTo(one);
                 }
 
-                if operand_type == Type::bool() {
+                if operand_type == NumericType::bool() {
                     // Simplify forms of `(boolean == true)` into `boolean`
                     if lhs_is_one {
                         return SimplifyResult::SimplifiedTo(self.rhs);
@@ -191,13 +191,13 @@ impl Binary {
             }
             BinaryOp::Lt => {
                 if dfg.resolve(self.lhs) == dfg.resolve(self.rhs) {
-                    let zero = dfg.make_constant(FieldElement::zero(), Type::bool());
+                    let zero = dfg.make_constant(FieldElement::zero(), NumericType::bool());
                     return SimplifyResult::SimplifiedTo(zero);
                 }
                 if operand_type.is_unsigned() {
                     if rhs_is_zero {
                         // Unsigned values cannot be less than zero.
-                        let zero = dfg.make_constant(FieldElement::zero(), Type::bool());
+                        let zero = dfg.make_constant(FieldElement::zero(), NumericType::bool());
                         return SimplifyResult::SimplifiedTo(zero);
                     } else if rhs_is_one {
                         let zero = dfg.make_constant(FieldElement::zero(), operand_type);
@@ -217,7 +217,7 @@ impl Binary {
                 if dfg.resolve(self.lhs) == dfg.resolve(self.rhs) {
                     return SimplifyResult::SimplifiedTo(self.lhs);
                 }
-                if operand_type == Type::bool() {
+                if operand_type == NumericType::bool() {
                     // Boolean AND is equivalent to multiplication, which is a cheaper operation.
                     let instruction = Instruction::binary(BinaryOp::Mul, self.lhs, self.rhs);
                     return SimplifyResult::SimplifiedToInstruction(instruction);
@@ -256,6 +256,10 @@ impl Binary {
                 if rhs_is_zero {
                     return SimplifyResult::SimplifiedTo(self.lhs);
                 }
+                if operand_type == NumericType::bool() && (lhs_is_one || rhs_is_one) {
+                    let one = dfg.make_constant(FieldElement::one(), operand_type);
+                    return SimplifyResult::SimplifiedTo(one);
+                }
                 if dfg.resolve(self.lhs) == dfg.resolve(self.rhs) {
                     return SimplifyResult::SimplifiedTo(self.lhs);
                 }
@@ -281,15 +285,7 @@ impl Binary {
                         let zero = dfg.make_constant(FieldElement::zero(), operand_type);
                         return SimplifyResult::SimplifiedTo(zero);
                     }
-
-                    // `two_pow_rhs` is limited to be at most `2 ^ {operand_bitsize - 1}` so it fits in `operand_type`.
-                    let two_pow_rhs = FieldElement::from(2u128).pow(&rhs_const);
-                    let two_pow_rhs = dfg.make_constant(two_pow_rhs, operand_type);
-                    return SimplifyResult::SimplifiedToInstruction(Instruction::binary(
-                        BinaryOp::Div,
-                        self.lhs,
-                        two_pow_rhs,
-                    ));
+                    return SimplifyResult::None;
                 }
             }
         };
@@ -302,10 +298,10 @@ fn eval_constant_binary_op(
     lhs: FieldElement,
     rhs: FieldElement,
     operator: BinaryOp,
-    mut operand_type: Type,
-) -> Option<(FieldElement, Type)> {
-    let value = match &operand_type {
-        Type::Numeric(NumericType::NativeField) => {
+    mut operand_type: NumericType,
+) -> Option<(FieldElement, NumericType)> {
+    let value = match operand_type {
+        NumericType::NativeField => {
             // If the rhs of a division is zero, attempting to evaluate the division will cause a compiler panic.
             // Thus, we do not evaluate the division in this method, as we want to avoid triggering a panic,
             // and the operation should be handled by ACIR generation.
@@ -314,11 +310,11 @@ fn eval_constant_binary_op(
             }
             operator.get_field_function()?(lhs, rhs)
         }
-        Type::Numeric(NumericType::Unsigned { bit_size }) => {
+        NumericType::Unsigned { bit_size } => {
             let function = operator.get_u128_function();
 
-            let lhs = truncate(lhs.try_into_u128()?, *bit_size);
-            let rhs = truncate(rhs.try_into_u128()?, *bit_size);
+            let lhs = truncate(lhs.try_into_u128()?, bit_size);
+            let rhs = truncate(rhs.try_into_u128()?, bit_size);
 
             // The divisor is being truncated into the type of the operand, which can potentially
             // lead to the rhs being zero.
@@ -330,16 +326,16 @@ fn eval_constant_binary_op(
             }
             let result = function(lhs, rhs)?;
             // Check for overflow
-            if result >= 1 << *bit_size {
+            if result >= 1 << bit_size {
                 return None;
             }
             result.into()
         }
-        Type::Numeric(NumericType::Signed { bit_size }) => {
+        NumericType::Signed { bit_size } => {
             let function = operator.get_i128_function();
 
-            let lhs = try_convert_field_element_to_signed_integer(lhs, *bit_size)?;
-            let rhs = try_convert_field_element_to_signed_integer(rhs, *bit_size)?;
+            let lhs = try_convert_field_element_to_signed_integer(lhs, bit_size)?;
+            let rhs = try_convert_field_element_to_signed_integer(rhs, bit_size)?;
             // The divisor is being truncated into the type of the operand, which can potentially
             // lead to the rhs being zero.
             // If the rhs of a division is zero, attempting to evaluate the division will cause a compiler panic.
@@ -351,17 +347,16 @@ fn eval_constant_binary_op(
 
             let result = function(lhs, rhs)?;
             // Check for overflow
-            let two_pow_bit_size_minus_one = 1i128 << (*bit_size - 1);
+            let two_pow_bit_size_minus_one = 1i128 << (bit_size - 1);
             if result >= two_pow_bit_size_minus_one || result < -two_pow_bit_size_minus_one {
                 return None;
             }
-            convert_signed_integer_to_field_element(result, *bit_size)
+            convert_signed_integer_to_field_element(result, bit_size)
         }
-        _ => return None,
     };
 
     if matches!(operator, BinaryOp::Eq | BinaryOp::Lt) {
-        operand_type = Type::bool();
+        operand_type = NumericType::bool();
     }
 
     Some((value, operand_type))
diff --git a/compiler/noirc_evaluator/src/ssa/ir/instruction/call.rs b/compiler/noirc_evaluator/src/ssa/ir/instruction/call.rs
index 3068f2b5c37..02be0910a13 100644
--- a/compiler/noirc_evaluator/src/ssa/ir/instruction/call.rs
+++ b/compiler/noirc_evaluator/src/ssa/ir/instruction/call.rs
@@ -15,13 +15,13 @@ use crate::ssa::{
         dfg::{CallStack, DataFlowGraph},
         instruction::Intrinsic,
         map::Id,
-        types::Type,
+        types::{NumericType, Type},
         value::{Value, ValueId},
     },
     opt::flatten_cfg::value_merger::ValueMerger,
 };
 
-use super::{Binary, BinaryOp, Endian, Instruction, SimplifyResult};
+use super::{Binary, BinaryOp, Endian, Hint, Instruction, SimplifyResult};
 
 mod blackbox;
 
@@ -45,44 +45,53 @@ pub(super) fn simplify_call(
         _ => return SimplifyResult::None,
     };
 
+    let return_type = ctrl_typevars.and_then(|return_types| return_types.first().cloned());
+
     let constant_args: Option<Vec<_>> =
         arguments.iter().map(|value_id| dfg.get_numeric_constant(*value_id)).collect();
 
-    match intrinsic {
+    let simplified_result = match intrinsic {
         Intrinsic::ToBits(endian) => {
             // TODO: simplify to a range constraint if `limb_count == 1`
-            if let (Some(constant_args), Some(return_type)) =
-                (constant_args, ctrl_typevars.map(|return_types| return_types.first().cloned()))
-            {
+            if let (Some(constant_args), Some(return_type)) = (constant_args, return_type.clone()) {
                 let field = constant_args[0];
-                let limb_count = if let Some(Type::Array(_, array_len)) = return_type {
-                    array_len as u32
+                let limb_count = if let Type::Array(_, array_len) = return_type {
+                    array_len
                 } else {
                     unreachable!("ICE: Intrinsic::ToRadix return type must be array")
                 };
-                let result_array = constant_to_radix(endian, field, 2, limb_count, dfg);
-
-                SimplifyResult::SimplifiedTo(result_array)
+                constant_to_radix(endian, field, 2, limb_count, |values| {
+                    make_constant_array(
+                        dfg,
+                        values.into_iter(),
+                        NumericType::bool(),
+                        block,
+                        call_stack,
+                    )
+                })
             } else {
                 SimplifyResult::None
             }
         }
         Intrinsic::ToRadix(endian) => {
             // TODO: simplify to a range constraint if `limb_count == 1`
-            if let (Some(constant_args), Some(return_type)) =
-                (constant_args, ctrl_typevars.map(|return_types| return_types.first().cloned()))
-            {
+            if let (Some(constant_args), Some(return_type)) = (constant_args, return_type.clone()) {
                 let field = constant_args[0];
                 let radix = constant_args[1].to_u128() as u32;
-                let limb_count = if let Some(Type::Array(_, array_len)) = return_type {
-                    array_len as u32
+                let limb_count = if let Type::Array(_, array_len) = return_type {
+                    array_len
                 } else {
                     unreachable!("ICE: Intrinsic::ToRadix return type must be array")
                 };
-
-                let result_array = constant_to_radix(endian, field, radix, limb_count, dfg);
-
-                SimplifyResult::SimplifiedTo(result_array)
+                constant_to_radix(endian, field, radix, limb_count, |values| {
+                    make_constant_array(
+                        dfg,
+                        values.into_iter(),
+                        NumericType::Unsigned { bit_size: 8 },
+                        block,
+                        call_stack,
+                    )
+                })
             } else {
                 SimplifyResult::None
             }
@@ -90,7 +99,7 @@ pub(super) fn simplify_call(
         Intrinsic::ArrayLen => {
             if let Some(length) = dfg.try_get_array_length(arguments[0]) {
                 let length = FieldElement::from(length as u128);
-                SimplifyResult::SimplifiedTo(dfg.make_constant(length, Type::length_type()))
+                SimplifyResult::SimplifiedTo(dfg.make_constant(length, NumericType::length_type()))
             } else if matches!(dfg.type_of_value(arguments[1]), Type::Slice(_)) {
                 SimplifyResult::SimplifiedTo(arguments[0])
             } else {
@@ -113,8 +122,9 @@ pub(super) fn simplify_call(
                 );
                 let slice_length_value = array.len() / elements_size;
                 let slice_length =
-                    dfg.make_constant(slice_length_value.into(), Type::length_type());
-                let new_slice = dfg.make_array(array, Type::Slice(inner_element_types));
+                    dfg.make_constant(slice_length_value.into(), NumericType::length_type());
+                let new_slice =
+                    make_array(dfg, array, Type::Slice(inner_element_types), block, call_stack);
                 SimplifyResult::SimplifiedToMultiple(vec![slice_length, new_slice])
             } else {
                 SimplifyResult::None
@@ -134,7 +144,7 @@ pub(super) fn simplify_call(
                     let new_slice_length =
                         update_slice_length(arguments[0], dfg, BinaryOp::Add, block);
 
-                    let new_slice = dfg.make_array(slice, element_type);
+                    let new_slice = make_array(dfg, slice, element_type, block, call_stack);
                     return SimplifyResult::SimplifiedToMultiple(vec![new_slice_length, new_slice]);
                 }
 
@@ -159,13 +169,20 @@ pub(super) fn simplify_call(
 
                 let new_slice_length = update_slice_length(arguments[0], dfg, BinaryOp::Add, block);
 
-                let new_slice = dfg.make_array(slice, element_type);
+                let new_slice = make_array(dfg, slice, element_type, block, call_stack);
                 SimplifyResult::SimplifiedToMultiple(vec![new_slice_length, new_slice])
             } else {
                 SimplifyResult::None
             }
         }
         Intrinsic::SlicePopBack => {
+            let length = dfg.get_numeric_constant(arguments[0]);
+            if length.map_or(true, |length| length.is_zero()) {
+                // If the length is zero then we're trying to pop the last element from an empty slice.
+                // Defer the error to acir_gen.
+                return SimplifyResult::None;
+            }
+
             let slice = dfg.get_array_constant(arguments[1]);
             if let Some((_, typ)) = slice {
                 simplify_slice_pop_back(typ, arguments, dfg, block, call_stack.clone())
@@ -174,6 +191,13 @@ pub(super) fn simplify_call(
             }
         }
         Intrinsic::SlicePopFront => {
+            let length = dfg.get_numeric_constant(arguments[0]);
+            if length.map_or(true, |length| length.is_zero()) {
+                // If the length is zero then we're trying to pop the first element from an empty slice.
+                // Defer the error to acir_gen.
+                return SimplifyResult::None;
+            }
+
             let slice = dfg.get_array_constant(arguments[1]);
             if let Some((mut slice, typ)) = slice {
                 let element_count = typ.element_size();
@@ -187,7 +211,7 @@ pub(super) fn simplify_call(
 
                 results.push(new_slice_length);
 
-                let new_slice = dfg.make_array(slice, typ);
+                let new_slice = make_array(dfg, slice, typ, block, call_stack);
 
                 // The slice is the last item returned for pop_front
                 results.push(new_slice);
@@ -218,13 +242,20 @@ pub(super) fn simplify_call(
 
                 let new_slice_length = update_slice_length(arguments[0], dfg, BinaryOp::Add, block);
 
-                let new_slice = dfg.make_array(slice, typ);
+                let new_slice = make_array(dfg, slice, typ, block, call_stack);
                 SimplifyResult::SimplifiedToMultiple(vec![new_slice_length, new_slice])
             } else {
                 SimplifyResult::None
             }
         }
         Intrinsic::SliceRemove => {
+            let length = dfg.get_numeric_constant(arguments[0]);
+            if length.map_or(true, |length| length.is_zero()) {
+                // If the length is zero then we're trying to remove an element from an empty slice.
+                // Defer the error to acir_gen.
+                return SimplifyResult::None;
+            }
+
             let slice = dfg.get_array_constant(arguments[1]);
             let index = dfg.get_numeric_constant(arguments[2]);
             if let (Some((mut slice, typ)), Some(index)) = (slice, index) {
@@ -244,7 +275,7 @@ pub(super) fn simplify_call(
                     results.push(slice.remove(index));
                 }
 
-                let new_slice = dfg.make_array(slice, typ);
+                let new_slice = make_array(dfg, slice, typ, block, call_stack);
                 results.insert(0, new_slice);
 
                 let new_slice_length = update_slice_length(arguments[0], dfg, BinaryOp::Sub, block);
@@ -301,17 +332,17 @@ pub(super) fn simplify_call(
                 SimplifyResult::None
             }
         }
-        Intrinsic::BlackBox(bb_func) => simplify_black_box_func(bb_func, arguments, dfg),
+        Intrinsic::Hint(Hint::BlackBox) => SimplifyResult::None,
+        Intrinsic::BlackBox(bb_func) => {
+            simplify_black_box_func(bb_func, arguments, dfg, block, call_stack)
+        }
         Intrinsic::AsField => {
-            let instruction = Instruction::Cast(
-                arguments[0],
-                Type::Numeric(crate::ssa::ir::types::NumericType::NativeField),
-            );
+            let instruction = Instruction::Cast(arguments[0], NumericType::NativeField);
             SimplifyResult::SimplifiedToInstruction(instruction)
         }
         Intrinsic::FromField => {
             let incoming_type = Type::field();
-            let target_type = ctrl_typevars.unwrap().remove(0);
+            let target_type = return_type.clone().unwrap();
 
             let truncate = Instruction::Truncate {
                 value: arguments[0],
@@ -327,19 +358,43 @@ pub(super) fn simplify_call(
                 )
                 .first();
 
-            let instruction = Instruction::Cast(truncated_value, target_type);
+            let instruction = Instruction::Cast(truncated_value, target_type.unwrap_numeric());
             SimplifyResult::SimplifiedToInstruction(instruction)
         }
         Intrinsic::AsWitness => SimplifyResult::None,
         Intrinsic::IsUnconstrained => SimplifyResult::None,
         Intrinsic::DerivePedersenGenerators => {
-            if let Some(Type::Array(_, len)) = ctrl_typevars.unwrap().first() {
-                simplify_derive_generators(dfg, arguments, *len as u32)
+            if let Some(Type::Array(_, len)) = return_type.clone() {
+                simplify_derive_generators(dfg, arguments, len, block, call_stack)
             } else {
                 unreachable!("Derive Pedersen Generators must return an array");
             }
         }
+        Intrinsic::FieldLessThan => {
+            if let Some(constants) = constant_args {
+                let lhs = constants[0];
+                let rhs = constants[1];
+                let result = dfg.make_constant((lhs < rhs).into(), NumericType::bool());
+                SimplifyResult::SimplifiedTo(result)
+            } else {
+                SimplifyResult::None
+            }
+        }
+        Intrinsic::ArrayRefCount => SimplifyResult::None,
+        Intrinsic::SliceRefCount => SimplifyResult::None,
+    };
+
+    if let (Some(expected_types), SimplifyResult::SimplifiedTo(result)) =
+        (return_type, &simplified_result)
+    {
+        assert_eq!(
+            dfg.type_of_value(*result),
+            expected_types,
+            "Simplification should not alter return type"
+        );
     }
+
+    simplified_result
 }
 
 /// Slices have a tuple structure (slice length, slice contents) to enable logic
@@ -355,7 +410,7 @@ fn update_slice_length(
     operator: BinaryOp,
     block: BasicBlockId,
 ) -> ValueId {
-    let one = dfg.make_constant(FieldElement::one(), Type::length_type());
+    let one = dfg.make_constant(FieldElement::one(), NumericType::length_type());
     let instruction = Instruction::Binary(Binary { lhs: slice_len, operator, rhs: one });
     let call_stack = dfg.get_value_call_stack(slice_len);
     dfg.insert_instruction_and_results(instruction, block, None, call_stack).first()
@@ -370,7 +425,7 @@ fn simplify_slice_push_back(
     call_stack: CallStack,
 ) -> SimplifyResult {
     // The capacity must be an integer so that we can compare it against the slice length
-    let capacity = dfg.make_constant((slice.len() as u128).into(), Type::length_type());
+    let capacity = dfg.make_constant((slice.len() as u128).into(), NumericType::length_type());
     let len_equals_capacity_instr =
         Instruction::Binary(Binary { lhs: arguments[0], operator: BinaryOp::Eq, rhs: capacity });
     let len_equals_capacity = dfg
@@ -391,9 +446,9 @@ fn simplify_slice_push_back(
     for elem in &arguments[2..] {
         slice.push_back(*elem);
     }
-    let slice_size = slice.len();
-    let element_size = element_type.element_size();
-    let new_slice = dfg.make_array(slice, element_type);
+    let slice_size = slice.len() as u32;
+    let element_size = element_type.element_size() as u32;
+    let new_slice = make_array(dfg, slice, element_type, block, &call_stack);
 
     let set_last_slice_value_instr = Instruction::ArraySet {
         array: new_slice,
@@ -425,25 +480,20 @@ fn simplify_slice_push_back(
 }
 
 fn simplify_slice_pop_back(
-    element_type: Type,
+    slice_type: Type,
     arguments: &[ValueId],
     dfg: &mut DataFlowGraph,
     block: BasicBlockId,
     call_stack: CallStack,
 ) -> SimplifyResult {
-    let element_types = match element_type.clone() {
-        Type::Slice(element_types) | Type::Array(element_types, _) => element_types,
-        _ => {
-            unreachable!("ICE: Expected slice or array, but got {element_type}");
-        }
-    };
-
-    let element_count = element_type.element_size();
+    let element_types = slice_type.element_types();
+    let element_count = element_types.len();
     let mut results = VecDeque::with_capacity(element_count + 1);
 
     let new_slice_length = update_slice_length(arguments[0], dfg, BinaryOp::Sub, block);
 
-    let element_size = dfg.make_constant((element_count as u128).into(), Type::length_type());
+    let element_size =
+        dfg.make_constant((element_count as u128).into(), NumericType::length_type());
     let flattened_len_instr = Instruction::binary(BinaryOp::Mul, arguments[0], element_size);
     let mut flattened_len = dfg
         .insert_instruction_and_results(flattened_len_instr, block, None, call_stack.clone())
@@ -451,14 +501,17 @@ fn simplify_slice_pop_back(
     flattened_len = update_slice_length(flattened_len, dfg, BinaryOp::Sub, block);
 
     // We must pop multiple elements in the case of a slice of tuples
-    for _ in 0..element_count {
+    // Iterating through element types in reverse here since we're popping from the end
+    for element_type in element_types.iter().rev() {
         let get_last_elem_instr =
             Instruction::ArrayGet { array: arguments[1], index: flattened_len };
+
+        let element_type = Some(vec![element_type.clone()]);
         let get_last_elem = dfg
             .insert_instruction_and_results(
                 get_last_elem_instr,
                 block,
-                Some(element_types.to_vec()),
+                element_type,
                 call_stack.clone(),
             )
             .first();
@@ -479,6 +532,8 @@ fn simplify_black_box_func(
     bb_func: BlackBoxFunc,
     arguments: &[ValueId],
     dfg: &mut DataFlowGraph,
+    block: BasicBlockId,
+    call_stack: &CallStack,
 ) -> SimplifyResult {
     cfg_if::cfg_if! {
         if #[cfg(feature = "bn254")] {
@@ -488,8 +543,12 @@ fn simplify_black_box_func(
         }
     };
     match bb_func {
-        BlackBoxFunc::Blake2s => simplify_hash(dfg, arguments, acvm::blackbox_solver::blake2s),
-        BlackBoxFunc::Blake3 => simplify_hash(dfg, arguments, acvm::blackbox_solver::blake3),
+        BlackBoxFunc::Blake2s => {
+            simplify_hash(dfg, arguments, acvm::blackbox_solver::blake2s, block, call_stack)
+        }
+        BlackBoxFunc::Blake3 => {
+            simplify_hash(dfg, arguments, acvm::blackbox_solver::blake3, block, call_stack)
+        }
         BlackBoxFunc::Keccakf1600 => {
             if let Some((array_input, _)) = dfg.get_array_constant(arguments[0]) {
                 if array_is_constant(dfg, &array_input) {
@@ -507,8 +566,14 @@ fn simplify_black_box_func(
                         const_input.try_into().expect("Keccakf1600 input should have length of 25"),
                     )
                     .expect("Rust solvable black box function should not fail");
-                    let state_values = vecmap(state, |x| FieldElement::from(x as u128));
-                    let result_array = make_constant_array(dfg, state_values, Type::unsigned(64));
+                    let state_values = state.iter().map(|x| FieldElement::from(*x as u128));
+                    let result_array = make_constant_array(
+                        dfg,
+                        state_values,
+                        NumericType::Unsigned { bit_size: 64 },
+                        block,
+                        call_stack,
+                    );
                     SimplifyResult::SimplifiedTo(result_array)
                 } else {
                     SimplifyResult::None
@@ -517,11 +582,8 @@ fn simplify_black_box_func(
                 SimplifyResult::None
             }
         }
-        BlackBoxFunc::Keccak256 => {
-            unreachable!("Keccak256 should have been replaced by calls to Keccakf1600")
-        }
         BlackBoxFunc::Poseidon2Permutation => {
-            blackbox::simplify_poseidon2_permutation(dfg, solver, arguments)
+            blackbox::simplify_poseidon2_permutation(dfg, solver, arguments, block, call_stack)
         }
         BlackBoxFunc::EcdsaSecp256k1 => blackbox::simplify_signature(
             dfg,
@@ -534,11 +596,12 @@ fn simplify_black_box_func(
             acvm::blackbox_solver::ecdsa_secp256r1_verify,
         ),
 
-        BlackBoxFunc::PedersenCommitment
-        | BlackBoxFunc::PedersenHash
-        | BlackBoxFunc::MultiScalarMul => SimplifyResult::None,
-        BlackBoxFunc::EmbeddedCurveAdd => blackbox::simplify_ec_add(dfg, solver, arguments),
-        BlackBoxFunc::SchnorrVerify => blackbox::simplify_schnorr_verify(dfg, solver, arguments),
+        BlackBoxFunc::MultiScalarMul => {
+            blackbox::simplify_msm(dfg, solver, arguments, block, call_stack)
+        }
+        BlackBoxFunc::EmbeddedCurveAdd => {
+            blackbox::simplify_ec_add(dfg, solver, arguments, block, call_stack)
+        }
 
         BlackBoxFunc::BigIntAdd
         | BlackBoxFunc::BigIntSub
@@ -564,23 +627,30 @@ fn simplify_black_box_func(
     }
 }
 
-fn make_constant_array(dfg: &mut DataFlowGraph, results: Vec<FieldElement>, typ: Type) -> ValueId {
-    let result_constants = vecmap(results, |element| dfg.make_constant(element, typ.clone()));
+fn make_constant_array(
+    dfg: &mut DataFlowGraph,
+    results: impl Iterator<Item = FieldElement>,
+    typ: NumericType,
+    block: BasicBlockId,
+    call_stack: &CallStack,
+) -> ValueId {
+    let result_constants: im::Vector<_> =
+        results.map(|element| dfg.make_constant(element, typ)).collect();
 
-    let typ = Type::Array(Arc::new(vec![typ]), result_constants.len());
-    dfg.make_array(result_constants.into(), typ)
+    let typ = Type::Array(Arc::new(vec![Type::Numeric(typ)]), result_constants.len() as u32);
+    make_array(dfg, result_constants, typ, block, call_stack)
 }
 
-fn make_constant_slice(
+fn make_array(
     dfg: &mut DataFlowGraph,
-    results: Vec<FieldElement>,
+    elements: im::Vector<ValueId>,
     typ: Type,
-) -> (ValueId, ValueId) {
-    let result_constants = vecmap(results, |element| dfg.make_constant(element, typ.clone()));
-
-    let typ = Type::Slice(Arc::new(vec![typ]));
-    let length = FieldElement::from(result_constants.len() as u128);
-    (dfg.make_constant(length, Type::length_type()), dfg.make_array(result_constants.into(), typ))
+    block: BasicBlockId,
+    call_stack: &CallStack,
+) -> ValueId {
+    let instruction = Instruction::MakeArray { elements, typ };
+    let call_stack = call_stack.clone();
+    dfg.insert_instruction_and_results(instruction, block, None, call_stack).first()
 }
 
 /// Returns a slice (represented by a tuple (len, slice)) of constants corresponding to the limbs of the radix decomposition.
@@ -589,8 +659,8 @@ fn constant_to_radix(
     field: FieldElement,
     radix: u32,
     limb_count: u32,
-    dfg: &mut DataFlowGraph,
-) -> ValueId {
+    mut make_array: impl FnMut(Vec<FieldElement>) -> ValueId,
+) -> SimplifyResult {
     let bit_size = u32::BITS - (radix - 1).leading_zeros();
     let radix_big = BigUint::from(radix);
     assert_eq!(BigUint::from(2u128).pow(bit_size), radix_big, "ICE: Radix must be a power of 2");
@@ -598,14 +668,21 @@ fn constant_to_radix(
 
     // Decompose the integer into its radix digits in little endian form.
     let decomposed_integer = big_integer.to_radix_le(radix);
-    let mut limbs = vecmap(0..limb_count, |i| match decomposed_integer.get(i as usize) {
-        Some(digit) => FieldElement::from_be_bytes_reduce(&[*digit]),
-        None => FieldElement::zero(),
-    });
-    if endian == Endian::Big {
-        limbs.reverse();
+    if limb_count < decomposed_integer.len() as u32 {
+        // `field` cannot be represented as `limb_count` bits.
+        // defer error to acir_gen.
+        SimplifyResult::None
+    } else {
+        let mut limbs = vecmap(0..limb_count, |i| match decomposed_integer.get(i as usize) {
+            Some(digit) => FieldElement::from_be_bytes_reduce(&[*digit]),
+            None => FieldElement::zero(),
+        });
+        if endian == Endian::Big {
+            limbs.reverse();
+        }
+        let result_array = make_array(limbs);
+        SimplifyResult::SimplifiedTo(result_array)
     }
-    make_constant_array(dfg, limbs, Type::unsigned(bit_size))
 }
 
 fn to_u8_vec(dfg: &DataFlowGraph, values: im::Vector<Id<Value>>) -> Vec<u8> {
@@ -628,6 +705,8 @@ fn simplify_hash(
     dfg: &mut DataFlowGraph,
     arguments: &[ValueId],
     hash_function: fn(&[u8]) -> Result<[u8; 32], BlackBoxResolutionError>,
+    block: BasicBlockId,
+    call_stack: &CallStack,
 ) -> SimplifyResult {
     match dfg.get_array_constant(arguments[0]) {
         Some((input, _)) if array_is_constant(dfg, &input) => {
@@ -636,9 +715,10 @@ fn simplify_hash(
             let hash = hash_function(&input_bytes)
                 .expect("Rust solvable black box function should not fail");
 
-            let hash_values = vecmap(hash, |byte| FieldElement::from_be_bytes_reduce(&[byte]));
+            let hash_values = hash.iter().map(|byte| FieldElement::from_be_bytes_reduce(&[*byte]));
 
-            let result_array = make_constant_array(dfg, hash_values, Type::unsigned(8));
+            let u8_type = NumericType::Unsigned { bit_size: 8 };
+            let result_array = make_constant_array(dfg, hash_values, u8_type, block, call_stack);
             SimplifyResult::SimplifiedTo(result_array)
         }
         _ => SimplifyResult::None,
@@ -686,7 +766,7 @@ fn simplify_signature(
                 signature_verifier(&hashed_message, &public_key_x, &public_key_y, &signature)
                     .expect("Rust solvable black box function should not fail");
 
-            let valid_signature = dfg.make_constant(valid_signature.into(), Type::bool());
+            let valid_signature = dfg.make_constant(valid_signature.into(), NumericType::bool());
             SimplifyResult::SimplifiedTo(valid_signature)
         }
         _ => SimplifyResult::None,
@@ -697,6 +777,8 @@ fn simplify_derive_generators(
     dfg: &mut DataFlowGraph,
     arguments: &[ValueId],
     num_generators: u32,
+    block: BasicBlockId,
+    call_stack: &CallStack,
 ) -> SimplifyResult {
     if arguments.len() == 2 {
         let domain_separator_string = dfg.get_array_constant(arguments[0]);
@@ -714,20 +796,21 @@ fn simplify_derive_generators(
                 num_generators,
                 starting_index.try_to_u32().expect("argument is declared as u32"),
             );
-            let is_infinite = dfg.make_constant(FieldElement::zero(), Type::bool());
+            let is_infinite = dfg.make_constant(FieldElement::zero(), NumericType::bool());
             let mut results = Vec::new();
             for gen in generators {
                 let x_big: BigUint = gen.x.into();
                 let x = FieldElement::from_be_bytes_reduce(&x_big.to_bytes_be());
                 let y_big: BigUint = gen.y.into();
                 let y = FieldElement::from_be_bytes_reduce(&y_big.to_bytes_be());
-                results.push(dfg.make_constant(x, Type::field()));
-                results.push(dfg.make_constant(y, Type::field()));
+                results.push(dfg.make_constant(x, NumericType::NativeField));
+                results.push(dfg.make_constant(y, NumericType::NativeField));
                 results.push(is_infinite);
             }
-            let len = results.len();
-            let result =
-                dfg.make_array(results.into(), Type::Array(vec![Type::field()].into(), len));
+            let len = results.len() as u32;
+            let typ =
+                Type::Array(vec![Type::field(), Type::field(), Type::unsigned(1)].into(), len / 3);
+            let result = make_array(dfg, results.into(), typ, block, call_stack);
             SimplifyResult::SimplifiedTo(result)
         } else {
             SimplifyResult::None
@@ -736,3 +819,34 @@ fn simplify_derive_generators(
         unreachable!("Unexpected number of arguments to derive_generators");
     }
 }
+
+#[cfg(test)]
+mod tests {
+    use crate::ssa::{opt::assert_normalized_ssa_equals, Ssa};
+
+    #[test]
+    fn simplify_derive_generators_has_correct_type() {
+        let src = r#"
+            brillig(inline) fn main f0 {
+              b0():
+                v0 = make_array b"DEFAULT_DOMAIN_SEPARATOR"
+
+                // This call was previously incorrectly simplified to something that returned `[Field; 3]`
+                v2 = call derive_pedersen_generators(v0, u32 0) -> [(Field, Field, u1); 1]
+
+                return v2
+            }
+            "#;
+        let ssa = Ssa::from_str(src).unwrap();
+
+        let expected = r#"
+            brillig(inline) fn main f0 {
+              b0():
+                v15 = make_array b"DEFAULT_DOMAIN_SEPARATOR"
+                v19 = make_array [Field 3728882899078719075161482178784387565366481897740339799480980287259621149274, Field -9903063709032878667290627648209915537972247634463802596148419711785767431332, u1 0] : [(Field, Field, u1); 1]
+                return v19
+            }
+            "#;
+        assert_normalized_ssa_equals(ssa, expected);
+    }
+}
diff --git a/compiler/noirc_evaluator/src/ssa/ir/instruction/call/blackbox.rs b/compiler/noirc_evaluator/src/ssa/ir/instruction/call/blackbox.rs
index 7789b212e58..a5de98cec7f 100644
--- a/compiler/noirc_evaluator/src/ssa/ir/instruction/call/blackbox.rs
+++ b/compiler/noirc_evaluator/src/ssa/ir/instruction/call/blackbox.rs
@@ -1,10 +1,15 @@
 use std::sync::Arc;
 
 use acvm::{acir::AcirField, BlackBoxFunctionSolver, BlackBoxResolutionError, FieldElement};
-use iter_extended::vecmap;
 
+use crate::ssa::ir::instruction::BlackBoxFunc;
+use crate::ssa::ir::types::NumericType;
 use crate::ssa::ir::{
-    dfg::DataFlowGraph, instruction::SimplifyResult, types::Type, value::ValueId,
+    basic_block::BasicBlockId,
+    dfg::{CallStack, DataFlowGraph},
+    instruction::{Instruction, Intrinsic, SimplifyResult},
+    types::Type,
+    value::ValueId,
 };
 
 use super::{array_is_constant, make_constant_array, to_u8_vec};
@@ -13,6 +18,8 @@ pub(super) fn simplify_ec_add(
     dfg: &mut DataFlowGraph,
     solver: impl BlackBoxFunctionSolver<FieldElement>,
     arguments: &[ValueId],
+    block: BasicBlockId,
+    call_stack: &CallStack,
 ) -> SimplifyResult {
     match (
         dfg.get_numeric_constant(arguments[0]),
@@ -41,79 +48,190 @@ pub(super) fn simplify_ec_add(
                 return SimplifyResult::None;
             };
 
-            let result_x = dfg.make_constant(result_x, Type::field());
-            let result_y = dfg.make_constant(result_y, Type::field());
-            let result_is_infinity = dfg.make_constant(result_is_infinity, Type::bool());
+            let result_x = dfg.make_constant(result_x, NumericType::NativeField);
+            let result_y = dfg.make_constant(result_y, NumericType::NativeField);
+            let result_is_infinity =
+                dfg.make_constant(result_is_infinity, NumericType::NativeField);
 
             let typ = Type::Array(Arc::new(vec![Type::field()]), 3);
+
+            let elements = im::vector![result_x, result_y, result_is_infinity];
+            let instruction = Instruction::MakeArray { elements, typ };
             let result_array =
-                dfg.make_array(im::vector![result_x, result_y, result_is_infinity], typ);
+                dfg.insert_instruction_and_results(instruction, block, None, call_stack.clone());
 
-            SimplifyResult::SimplifiedTo(result_array)
+            SimplifyResult::SimplifiedTo(result_array.first())
         }
         _ => SimplifyResult::None,
     }
 }
 
-pub(super) fn simplify_poseidon2_permutation(
+pub(super) fn simplify_msm(
     dfg: &mut DataFlowGraph,
     solver: impl BlackBoxFunctionSolver<FieldElement>,
     arguments: &[ValueId],
+    block: BasicBlockId,
+    call_stack: &CallStack,
 ) -> SimplifyResult {
-    match (dfg.get_array_constant(arguments[0]), dfg.get_numeric_constant(arguments[1])) {
-        (Some((state, _)), Some(state_length)) if array_is_constant(dfg, &state) => {
-            let state: Vec<FieldElement> = state
-                .iter()
-                .map(|id| {
-                    dfg.get_numeric_constant(*id)
-                        .expect("value id from array should point at constant")
-                })
-                .collect();
+    let mut is_constant;
 
-            let Some(state_length) = state_length.try_to_u32() else {
+    match (dfg.get_array_constant(arguments[0]), dfg.get_array_constant(arguments[1])) {
+        (Some((points, _)), Some((scalars, _))) => {
+            // We decompose points and scalars into constant and non-constant parts in order to simplify MSMs where a subset of the terms are constant.
+            let mut constant_points = vec![];
+            let mut constant_scalars_lo = vec![];
+            let mut constant_scalars_hi = vec![];
+            let mut var_points = vec![];
+            let mut var_scalars = vec![];
+            let len = scalars.len() / 2;
+            for i in 0..len {
+                match (
+                    dfg.get_numeric_constant(scalars[2 * i]),
+                    dfg.get_numeric_constant(scalars[2 * i + 1]),
+                    dfg.get_numeric_constant(points[3 * i]),
+                    dfg.get_numeric_constant(points[3 * i + 1]),
+                    dfg.get_numeric_constant(points[3 * i + 2]),
+                ) {
+                    (Some(lo), Some(hi), _, _, _) if lo.is_zero() && hi.is_zero() => {
+                        is_constant = true;
+                        constant_scalars_lo.push(lo);
+                        constant_scalars_hi.push(hi);
+                        constant_points.push(FieldElement::zero());
+                        constant_points.push(FieldElement::zero());
+                        constant_points.push(FieldElement::one());
+                    }
+                    (_, _, _, _, Some(infinity)) if infinity.is_one() => {
+                        is_constant = true;
+                        constant_scalars_lo.push(FieldElement::zero());
+                        constant_scalars_hi.push(FieldElement::zero());
+                        constant_points.push(FieldElement::zero());
+                        constant_points.push(FieldElement::zero());
+                        constant_points.push(FieldElement::one());
+                    }
+                    (Some(lo), Some(hi), Some(x), Some(y), Some(infinity)) => {
+                        is_constant = true;
+                        constant_scalars_lo.push(lo);
+                        constant_scalars_hi.push(hi);
+                        constant_points.push(x);
+                        constant_points.push(y);
+                        constant_points.push(infinity);
+                    }
+                    _ => {
+                        is_constant = false;
+                    }
+                }
+
+                if !is_constant {
+                    var_points.push(points[3 * i]);
+                    var_points.push(points[3 * i + 1]);
+                    var_points.push(points[3 * i + 2]);
+                    var_scalars.push(scalars[2 * i]);
+                    var_scalars.push(scalars[2 * i + 1]);
+                }
+            }
+
+            // If there are no constant terms, we can't simplify
+            if constant_scalars_lo.is_empty() {
+                return SimplifyResult::None;
+            }
+            let Ok((result_x, result_y, result_is_infinity)) = solver.multi_scalar_mul(
+                &constant_points,
+                &constant_scalars_lo,
+                &constant_scalars_hi,
+            ) else {
                 return SimplifyResult::None;
             };
 
-            let Ok(new_state) = solver.poseidon2_permutation(&state, state_length) else {
+            // If there are no variable term, we can directly return the constant result
+            if var_scalars.is_empty() {
+                let result_x = dfg.make_constant(result_x, NumericType::NativeField);
+                let result_y = dfg.make_constant(result_y, NumericType::NativeField);
+                let result_is_infinity =
+                    dfg.make_constant(result_is_infinity, NumericType::NativeField);
+
+                let elements = im::vector![result_x, result_y, result_is_infinity];
+                let typ = Type::Array(Arc::new(vec![Type::field()]), 3);
+                let instruction = Instruction::MakeArray { elements, typ };
+                let result_array = dfg.insert_instruction_and_results(
+                    instruction,
+                    block,
+                    None,
+                    call_stack.clone(),
+                );
+
+                return SimplifyResult::SimplifiedTo(result_array.first());
+            }
+            // If there is only one non-null constant term, we cannot simplify
+            if constant_scalars_lo.len() == 1 && result_is_infinity != FieldElement::one() {
                 return SimplifyResult::None;
-            };
+            }
+            // Add the constant part back to the non-constant part, if it is not null
+            let one = dfg.make_constant(FieldElement::one(), NumericType::NativeField);
+            let zero = dfg.make_constant(FieldElement::zero(), NumericType::NativeField);
+            if result_is_infinity.is_zero() {
+                var_scalars.push(one);
+                var_scalars.push(zero);
+                let result_x = dfg.make_constant(result_x, NumericType::NativeField);
+                let result_y = dfg.make_constant(result_y, NumericType::NativeField);
 
-            let result_array = make_constant_array(dfg, new_state, Type::field());
+                // Pushing a bool here is intentional, multi_scalar_mul takes two arguments:
+                // `points: [(Field, Field, bool); N]` and `scalars: [(Field, Field); N]`.
+                let result_is_infinity = dfg.make_constant(result_is_infinity, NumericType::bool());
 
-            SimplifyResult::SimplifiedTo(result_array)
+                var_points.push(result_x);
+                var_points.push(result_y);
+                var_points.push(result_is_infinity);
+            }
+            // Construct the simplified MSM expression
+            let typ = Type::Array(Arc::new(vec![Type::field()]), var_scalars.len() as u32);
+            let scalars = Instruction::MakeArray { elements: var_scalars.into(), typ };
+            let scalars = dfg
+                .insert_instruction_and_results(scalars, block, None, call_stack.clone())
+                .first();
+            let typ = Type::Array(Arc::new(vec![Type::field()]), var_points.len() as u32);
+            let points = Instruction::MakeArray { elements: var_points.into(), typ };
+            let points =
+                dfg.insert_instruction_and_results(points, block, None, call_stack.clone()).first();
+            let msm = dfg.import_intrinsic(Intrinsic::BlackBox(BlackBoxFunc::MultiScalarMul));
+            SimplifyResult::SimplifiedToInstruction(Instruction::Call {
+                func: msm,
+                arguments: vec![points, scalars],
+            })
         }
         _ => SimplifyResult::None,
     }
 }
 
-pub(super) fn simplify_schnorr_verify(
+pub(super) fn simplify_poseidon2_permutation(
     dfg: &mut DataFlowGraph,
     solver: impl BlackBoxFunctionSolver<FieldElement>,
     arguments: &[ValueId],
+    block: BasicBlockId,
+    call_stack: &CallStack,
 ) -> SimplifyResult {
-    match (
-        dfg.get_numeric_constant(arguments[0]),
-        dfg.get_numeric_constant(arguments[1]),
-        dfg.get_array_constant(arguments[2]),
-        dfg.get_array_constant(arguments[3]),
-    ) {
-        (Some(public_key_x), Some(public_key_y), Some((signature, _)), Some((message, _)))
-            if array_is_constant(dfg, &signature) && array_is_constant(dfg, &message) =>
-        {
-            let signature = to_u8_vec(dfg, signature);
-            let signature: [u8; 64] =
-                signature.try_into().expect("Compiler should produce correctly sized signature");
+    match (dfg.get_array_constant(arguments[0]), dfg.get_numeric_constant(arguments[1])) {
+        (Some((state, _)), Some(state_length)) if array_is_constant(dfg, &state) => {
+            let state: Vec<FieldElement> = state
+                .iter()
+                .map(|id| {
+                    dfg.get_numeric_constant(*id)
+                        .expect("value id from array should point at constant")
+                })
+                .collect();
 
-            let message = to_u8_vec(dfg, message);
+            let Some(state_length) = state_length.try_to_u32() else {
+                return SimplifyResult::None;
+            };
 
-            let Ok(valid_signature) =
-                solver.schnorr_verify(&public_key_x, &public_key_y, &signature, &message)
-            else {
+            let Ok(new_state) = solver.poseidon2_permutation(&state, state_length) else {
                 return SimplifyResult::None;
             };
 
-            let valid_signature = dfg.make_constant(valid_signature.into(), Type::bool());
-            SimplifyResult::SimplifiedTo(valid_signature)
+            let new_state = new_state.into_iter();
+            let typ = NumericType::NativeField;
+            let result_array = make_constant_array(dfg, new_state, typ, block, call_stack);
+
+            SimplifyResult::SimplifiedTo(result_array)
         }
         _ => SimplifyResult::None,
     }
@@ -123,6 +241,8 @@ pub(super) fn simplify_hash(
     dfg: &mut DataFlowGraph,
     arguments: &[ValueId],
     hash_function: fn(&[u8]) -> Result<[u8; 32], BlackBoxResolutionError>,
+    block: BasicBlockId,
+    call_stack: &CallStack,
 ) -> SimplifyResult {
     match dfg.get_array_constant(arguments[0]) {
         Some((input, _)) if array_is_constant(dfg, &input) => {
@@ -131,9 +251,10 @@ pub(super) fn simplify_hash(
             let hash = hash_function(&input_bytes)
                 .expect("Rust solvable black box function should not fail");
 
-            let hash_values = vecmap(hash, |byte| FieldElement::from_be_bytes_reduce(&[byte]));
+            let hash_values = hash.iter().map(|byte| FieldElement::from_be_bytes_reduce(&[*byte]));
 
-            let result_array = make_constant_array(dfg, hash_values, Type::unsigned(8));
+            let u8_type = NumericType::Unsigned { bit_size: 8 };
+            let result_array = make_constant_array(dfg, hash_values, u8_type, block, call_stack);
             SimplifyResult::SimplifiedTo(result_array)
         }
         _ => SimplifyResult::None,
@@ -182,9 +303,99 @@ pub(super) fn simplify_signature(
                 signature_verifier(&hashed_message, &public_key_x, &public_key_y, &signature)
                     .expect("Rust solvable black box function should not fail");
 
-            let valid_signature = dfg.make_constant(valid_signature.into(), Type::bool());
+            let valid_signature = dfg.make_constant(valid_signature.into(), NumericType::bool());
             SimplifyResult::SimplifiedTo(valid_signature)
         }
         _ => SimplifyResult::None,
     }
 }
+
+#[cfg(feature = "bn254")]
+#[cfg(test)]
+mod test {
+    use crate::ssa::opt::assert_normalized_ssa_equals;
+    use crate::ssa::Ssa;
+
+    #[cfg(feature = "bn254")]
+    #[test]
+    fn full_constant_folding() {
+        let src = r#"
+            acir(inline) fn main f0 {
+            b0():
+                v0 = make_array [Field 2, Field 3, Field 5, Field 5] : [Field; 4]
+                v1 = make_array [Field 1, Field 17631683881184975370165255887551781615748388533673675138860, Field 0, Field 1, Field 17631683881184975370165255887551781615748388533673675138860, Field 0] : [Field; 6]
+                v2 = call multi_scalar_mul (v1, v0) -> [Field; 3]
+                return v2
+            }"#;
+        let ssa = Ssa::from_str(src).unwrap();
+
+        let expected_src = r#"
+            acir(inline) fn main f0 {
+            b0():
+                v3 = make_array [Field 2, Field 3, Field 5, Field 5] : [Field; 4]
+                v7 = make_array [Field 1, Field 17631683881184975370165255887551781615748388533673675138860, Field 0, Field 1, Field 17631683881184975370165255887551781615748388533673675138860, Field 0] : [Field; 6]
+                v10 = make_array [Field 1478523918288173385110236399861791147958001875200066088686689589556927843200, Field 700144278551281040379388961242974992655630750193306467120985766322057145630, Field 0] : [Field; 3]
+                return v10
+            }
+            "#;
+        assert_normalized_ssa_equals(ssa, expected_src);
+    }
+
+    #[cfg(feature = "bn254")]
+    #[test]
+    fn simplify_zero() {
+        let src = r#"
+            acir(inline) fn main f0 {
+            b0(v0: Field, v1: Field):
+                v2 = make_array [v0, Field 0, Field 0, Field 0, v0, Field 0] : [Field; 6]
+                v3 = make_array [
+                Field 0, Field 0, Field 1, v0, v1, Field 0, Field 1, v0, Field 0] : [Field; 9]
+                v4 = call multi_scalar_mul (v3, v2) -> [Field; 3]
+
+                return v4
+            
+            }"#;
+        let ssa = Ssa::from_str(src).unwrap();
+        //First point is zero, second scalar is zero, so we should be left with the scalar mul of the last point.
+        let expected_src = r#"
+            acir(inline) fn main f0 {
+            b0(v0: Field, v1: Field):
+                v3 = make_array [v0, Field 0, Field 0, Field 0, v0, Field 0] : [Field; 6]
+                v5 = make_array [Field 0, Field 0, Field 1, v0, v1, Field 0, Field 1, v0, Field 0] : [Field; 9]
+                v6 = make_array [v0, Field 0] : [Field; 2]
+                v7 = make_array [Field 1, v0, Field 0] : [Field; 3]
+                v9 = call multi_scalar_mul(v7, v6) -> [Field; 3]
+                return v9
+            }
+            "#;
+        assert_normalized_ssa_equals(ssa, expected_src);
+    }
+
+    #[cfg(feature = "bn254")]
+    #[test]
+    fn partial_constant_folding() {
+        let src = r#"
+            acir(inline) fn main f0 {
+            b0(v0: Field, v1: Field):
+                v2 = make_array [Field 1, Field 0, v0, Field 0, Field 2, Field 0] : [Field; 6]
+                v3 = make_array [
+                Field 1, Field 17631683881184975370165255887551781615748388533673675138860, Field 0, v0, v1, Field 0, Field 1, Field 17631683881184975370165255887551781615748388533673675138860, Field 0] : [Field; 9]
+                v4 = call multi_scalar_mul (v3, v2) -> [Field; 3]
+                return v4
+            }"#;
+        let ssa = Ssa::from_str(src).unwrap();
+        //First and last scalar/point are constant, so we should be left with the msm of the middle point and the folded constant point
+        let expected_src = r#"
+            acir(inline) fn main f0 {
+            b0(v0: Field, v1: Field):
+                v5 = make_array [Field 1, Field 0, v0, Field 0, Field 2, Field 0] : [Field; 6]
+                v7 = make_array [Field 1, Field 17631683881184975370165255887551781615748388533673675138860, Field 0, v0, v1, Field 0, Field 1, Field 17631683881184975370165255887551781615748388533673675138860, Field 0] : [Field; 9]
+                v8 = make_array [v0, Field 0, Field 1, Field 0] : [Field; 4]
+                v12 = make_array [v0, v1, Field 0, Field -3227352362257037263902424173275354266044964400219754872043023745437788450996, Field 8902249110305491597038405103722863701255802573786510474664632793109847672620, u1 0] : [Field; 6]
+                v14 = call multi_scalar_mul(v12, v8) -> [Field; 3]
+                return v14
+            }
+            "#;
+        assert_normalized_ssa_equals(ssa, expected_src);
+    }
+}
diff --git a/compiler/noirc_evaluator/src/ssa/ir/instruction/cast.rs b/compiler/noirc_evaluator/src/ssa/ir/instruction/cast.rs
index ed588def1d7..ee2ab43aa5d 100644
--- a/compiler/noirc_evaluator/src/ssa/ir/instruction/cast.rs
+++ b/compiler/noirc_evaluator/src/ssa/ir/instruction/cast.rs
@@ -7,7 +7,7 @@ use super::{DataFlowGraph, Instruction, NumericType, SimplifyResult, Type, Value
 /// that value is returned. Otherwise None is returned.
 pub(super) fn simplify_cast(
     value: ValueId,
-    dst_typ: &Type,
+    dst_typ: NumericType,
     dfg: &mut DataFlowGraph,
 ) -> SimplifyResult {
     use SimplifyResult::*;
@@ -15,60 +15,55 @@ pub(super) fn simplify_cast(
 
     if let Value::Instruction { instruction, .. } = &dfg[value] {
         if let Instruction::Cast(original_value, _) = &dfg[*instruction] {
-            return SimplifiedToInstruction(Instruction::Cast(*original_value, dst_typ.clone()));
+            return SimplifiedToInstruction(Instruction::Cast(*original_value, dst_typ));
         }
     }
 
     if let Some(constant) = dfg.get_numeric_constant(value) {
-        let src_typ = dfg.type_of_value(value);
+        let src_typ = dfg.type_of_value(value).unwrap_numeric();
         match (src_typ, dst_typ) {
-            (Type::Numeric(NumericType::NativeField), Type::Numeric(NumericType::NativeField)) => {
+            (NumericType::NativeField, NumericType::NativeField) => {
                 // Field -> Field: use src value
                 SimplifiedTo(value)
             }
             (
-                Type::Numeric(NumericType::Unsigned { .. } | NumericType::Signed { .. }),
-                Type::Numeric(NumericType::NativeField),
+                NumericType::Unsigned { .. } | NumericType::Signed { .. },
+                NumericType::NativeField,
             ) => {
                 // Unsigned/Signed -> Field: redefine same constant as Field
-                SimplifiedTo(dfg.make_constant(constant, dst_typ.clone()))
+                SimplifiedTo(dfg.make_constant(constant, dst_typ))
             }
             (
-                Type::Numeric(
-                    NumericType::NativeField
-                    | NumericType::Unsigned { .. }
-                    | NumericType::Signed { .. },
-                ),
-                Type::Numeric(NumericType::Unsigned { bit_size }),
+                NumericType::NativeField
+                | NumericType::Unsigned { .. }
+                | NumericType::Signed { .. },
+                NumericType::Unsigned { bit_size },
             ) => {
                 // Field/Unsigned -> unsigned: truncate
-                let integer_modulus = BigUint::from(2u128).pow(*bit_size);
+                let integer_modulus = BigUint::from(2u128).pow(bit_size);
                 let constant: BigUint = BigUint::from_bytes_be(&constant.to_be_bytes());
                 let truncated = constant % integer_modulus;
                 let truncated = FieldElement::from_be_bytes_reduce(&truncated.to_bytes_be());
-                SimplifiedTo(dfg.make_constant(truncated, dst_typ.clone()))
+                SimplifiedTo(dfg.make_constant(truncated, dst_typ))
             }
             (
-                Type::Numeric(
-                    NumericType::NativeField
-                    | NumericType::Unsigned { .. }
-                    | NumericType::Signed { .. },
-                ),
-                Type::Numeric(NumericType::Signed { bit_size }),
+                NumericType::NativeField
+                | NumericType::Unsigned { .. }
+                | NumericType::Signed { .. },
+                NumericType::Signed { bit_size },
             ) => {
                 // Field/Unsigned -> signed
                 // We only simplify to signed when we are below the maximum signed integer of the destination type.
-                let integer_modulus = BigUint::from(2u128).pow(*bit_size - 1);
+                let integer_modulus = BigUint::from(2u128).pow(bit_size - 1);
                 let constant_uint: BigUint = BigUint::from_bytes_be(&constant.to_be_bytes());
                 if constant_uint < integer_modulus {
-                    SimplifiedTo(dfg.make_constant(constant, dst_typ.clone()))
+                    SimplifiedTo(dfg.make_constant(constant, dst_typ))
                 } else {
                     None
                 }
             }
-            _ => None,
         }
-    } else if *dst_typ == dfg.type_of_value(value) {
+    } else if Type::Numeric(dst_typ) == dfg.type_of_value(value) {
         SimplifiedTo(value)
     } else {
         None
diff --git a/compiler/noirc_evaluator/src/ssa/ir/instruction/constrain.rs b/compiler/noirc_evaluator/src/ssa/ir/instruction/constrain.rs
index 66f50440d64..5ae6a642a57 100644
--- a/compiler/noirc_evaluator/src/ssa/ir/instruction/constrain.rs
+++ b/compiler/noirc_evaluator/src/ssa/ir/instruction/constrain.rs
@@ -1,5 +1,7 @@
 use acvm::{acir::AcirField, FieldElement};
 
+use crate::ssa::ir::types::NumericType;
+
 use super::{Binary, BinaryOp, ConstrainError, DataFlowGraph, Instruction, Type, Value, ValueId};
 
 /// Try to decompose this constrain instruction. This constraint will be broken down such that it instead constrains
@@ -20,7 +22,7 @@ pub(super) fn decompose_constrain(
         match (&dfg[lhs], &dfg[rhs]) {
             (Value::NumericConstant { constant, typ }, Value::Instruction { instruction, .. })
             | (Value::Instruction { instruction, .. }, Value::NumericConstant { constant, typ })
-                if *typ == Type::bool() =>
+                if *typ == NumericType::bool() =>
             {
                 match dfg[*instruction] {
                     Instruction::Binary(Binary { lhs, rhs, operator: BinaryOp::Eq })
@@ -61,7 +63,7 @@ pub(super) fn decompose_constrain(
                         // Note that this doesn't remove the value `v2` as it may be used in other instructions, but it
                         // will likely be removed through dead instruction elimination.
                         let one = FieldElement::one();
-                        let one = dfg.make_constant(one, Type::bool());
+                        let one = dfg.make_constant(one, NumericType::bool());
 
                         [
                             decompose_constrain(lhs, one, msg, dfg),
@@ -89,7 +91,7 @@ pub(super) fn decompose_constrain(
                         // Note that this doesn't remove the value `v2` as it may be used in other instructions, but it
                         // will likely be removed through dead instruction elimination.
                         let zero = FieldElement::zero();
-                        let zero = dfg.make_constant(zero, dfg.type_of_value(lhs));
+                        let zero = dfg.make_constant(zero, dfg.type_of_value(lhs).unwrap_numeric());
 
                         [
                             decompose_constrain(lhs, zero, msg, dfg),
@@ -112,7 +114,8 @@ pub(super) fn decompose_constrain(
                         // Note that this doesn't remove the value `v1` as it may be used in other instructions, but it
                         // will likely be removed through dead instruction elimination.
                         let reversed_constant = FieldElement::from(!constant.is_one());
-                        let reversed_constant = dfg.make_constant(reversed_constant, Type::bool());
+                        let reversed_constant =
+                            dfg.make_constant(reversed_constant, NumericType::bool());
                         decompose_constrain(value, reversed_constant, msg, dfg)
                     }
 
diff --git a/compiler/noirc_evaluator/src/ssa/ir/list.rs b/compiler/noirc_evaluator/src/ssa/ir/list.rs
new file mode 100644
index 00000000000..9a84d304444
--- /dev/null
+++ b/compiler/noirc_evaluator/src/ssa/ir/list.rs
@@ -0,0 +1,187 @@
+use serde::{Deserialize, Serialize};
+use std::sync::Arc;
+
+/// A shared linked list type intended to be cloned
+#[derive(Clone, PartialEq, Eq, Hash, Serialize, Deserialize)]
+pub struct List<T> {
+    head: Arc<Node<T>>,
+    len: usize,
+}
+
+#[derive(Default, Clone, PartialEq, Eq, Hash, Serialize, Deserialize)]
+enum Node<T> {
+    #[default]
+    Nil,
+    Cons(T, Arc<Node<T>>),
+}
+
+impl<T> Default for List<T> {
+    fn default() -> Self {
+        List { head: Arc::new(Node::Nil), len: 0 }
+    }
+}
+
+impl<T> List<T> {
+    pub fn new() -> Self {
+        Self::default()
+    }
+
+    /// This is actually a push_front since we just create a new head for the
+    /// list. This is done so that the tail of the list can still be shared.
+    /// In the case of call stacks, the last node will be main, while the top
+    /// of the call stack will be the head of this list.
+    pub fn push_back(&mut self, value: T) {
+        self.len += 1;
+        self.head = Arc::new(Node::Cons(value, self.head.clone()));
+    }
+
+    /// It is more efficient to iterate from the head of the list towards the tail.
+    /// For callstacks this means from the top of the call stack towards main.
+    fn iter_rev(&self) -> IterRev<T> {
+        IterRev { head: &self.head, len: self.len }
+    }
+
+    pub fn clear(&mut self) {
+        *self = Self::default();
+    }
+
+    pub fn append(&mut self, other: Self)
+    where
+        T: Copy + std::fmt::Debug,
+    {
+        let other = other.into_iter().collect::<Vec<_>>();
+
+        for item in other {
+            self.push_back(item);
+        }
+    }
+
+    pub fn len(&self) -> usize {
+        self.len
+    }
+
+    pub fn is_empty(&self) -> bool {
+        self.len == 0
+    }
+
+    fn pop_front(&mut self) -> Option<T>
+    where
+        T: Copy,
+    {
+        match self.head.as_ref() {
+            Node::Nil => None,
+            Node::Cons(value, rest) => {
+                let value = *value;
+                self.head = rest.clone();
+                self.len -= 1;
+                Some(value)
+            }
+        }
+    }
+
+    pub fn truncate(&mut self, len: usize)
+    where
+        T: Copy,
+    {
+        if self.len > len {
+            for _ in 0..self.len - len {
+                self.pop_front();
+            }
+        }
+    }
+
+    pub fn unit(item: T) -> Self {
+        let mut this = Self::default();
+        this.push_back(item);
+        this
+    }
+
+    pub fn back(&self) -> Option<&T> {
+        match self.head.as_ref() {
+            Node::Nil => None,
+            Node::Cons(item, _) => Some(item),
+        }
+    }
+}
+
+pub struct IterRev<'a, T> {
+    head: &'a Node<T>,
+    len: usize,
+}
+
+impl<T> IntoIterator for List<T>
+where
+    T: Copy + std::fmt::Debug,
+{
+    type Item = T;
+
+    type IntoIter = std::iter::Rev<std::vec::IntoIter<T>>;
+
+    fn into_iter(self) -> Self::IntoIter {
+        let items: Vec<_> = self.iter_rev().copied().collect();
+        items.into_iter().rev()
+    }
+}
+
+impl<'a, T> IntoIterator for &'a List<T> {
+    type Item = &'a T;
+
+    type IntoIter = std::iter::Rev<<Vec<&'a T> as IntoIterator>::IntoIter>;
+
+    fn into_iter(self) -> Self::IntoIter {
+        let items: Vec<_> = self.iter_rev().collect();
+        items.into_iter().rev()
+    }
+}
+
+impl<'a, T> Iterator for IterRev<'a, T> {
+    type Item = &'a T;
+
+    fn next(&mut self) -> Option<Self::Item> {
+        match self.head {
+            Node::Nil => None,
+            Node::Cons(value, rest) => {
+                self.head = rest;
+                Some(value)
+            }
+        }
+    }
+
+    fn size_hint(&self) -> (usize, Option<usize>) {
+        (0, Some(self.len))
+    }
+}
+
+impl<'a, T> ExactSizeIterator for IterRev<'a, T> {}
+
+impl<T> std::fmt::Debug for List<T>
+where
+    T: std::fmt::Debug,
+{
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        write!(f, "[")?;
+        for (i, item) in self.iter_rev().enumerate() {
+            if i != 0 {
+                write!(f, ", ")?;
+            }
+            write!(f, "{item:?}")?;
+        }
+        write!(f, "]")
+    }
+}
+
+impl<T> std::fmt::Display for List<T>
+where
+    T: std::fmt::Display,
+{
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        write!(f, "[")?;
+        for (i, item) in self.iter_rev().enumerate() {
+            if i != 0 {
+                write!(f, ", ")?;
+            }
+            write!(f, "{item}")?;
+        }
+        write!(f, "]")
+    }
+}
diff --git a/compiler/noirc_evaluator/src/ssa/ir/map.rs b/compiler/noirc_evaluator/src/ssa/ir/map.rs
index 23f5380f030..0fb02f19b14 100644
--- a/compiler/noirc_evaluator/src/ssa/ir/map.rs
+++ b/compiler/noirc_evaluator/src/ssa/ir/map.rs
@@ -4,7 +4,7 @@ use std::{
     collections::BTreeMap,
     hash::Hash,
     str::FromStr,
-    sync::atomic::{AtomicUsize, Ordering},
+    sync::atomic::{AtomicU32, Ordering},
 };
 use thiserror::Error;
 
@@ -18,7 +18,7 @@ use thiserror::Error;
 /// another map where it will likely be invalid.
 #[derive(Serialize, Deserialize)]
 pub(crate) struct Id<T> {
-    index: usize,
+    index: u32,
     // If we do not skip this field it will simply serialize as `"_marker":null` which is useless extra data
     #[serde(skip)]
     _marker: std::marker::PhantomData<T>,
@@ -26,14 +26,15 @@ pub(crate) struct Id<T> {
 
 impl<T> Id<T> {
     /// Constructs a new Id for the given index.
-    /// This constructor is deliberately private to prevent
-    /// constructing invalid IDs.
-    pub(crate) fn new(index: usize) -> Self {
+    ///
+    /// This is private so that we can guarantee ids created from this function
+    /// point to valid T values in their external maps.
+    fn new(index: u32) -> Self {
         Self { index, _marker: std::marker::PhantomData }
     }
 
     /// Returns the underlying index of this Id.
-    pub(crate) fn to_usize(self) -> usize {
+    pub(crate) fn to_u32(self) -> u32 {
         self.index
     }
 
@@ -43,7 +44,7 @@ impl<T> Id<T> {
     /// as unlike DenseMap::push and SparseMap::push, the Ids created
     /// here are likely invalid for any particularly map.
     #[cfg(test)]
-    pub(crate) fn test_new(index: usize) -> Self {
+    pub(crate) fn test_new(index: u32) -> Self {
         Self::new(index)
     }
 }
@@ -187,7 +188,7 @@ impl<T> DenseMap<T> {
     /// Adds an element to the map.
     /// Returns the identifier/reference to that element.
     pub(crate) fn insert(&mut self, element: T) -> Id<T> {
-        let id = Id::new(self.storage.len());
+        let id = Id::new(self.storage.len().try_into().unwrap());
         self.storage.push(element);
         id
     }
@@ -195,7 +196,7 @@ impl<T> DenseMap<T> {
     /// Given the Id of the element being created, adds the element
     /// returned by the given function to the map
     pub(crate) fn insert_with_id(&mut self, f: impl FnOnce(Id<T>) -> T) -> Id<T> {
-        let id = Id::new(self.storage.len());
+        let id = Id::new(self.storage.len().try_into().unwrap());
         self.storage.push(f(id));
         id
     }
@@ -204,7 +205,7 @@ impl<T> DenseMap<T> {
     ///
     /// The id-element pairs are ordered by the numeric values of the ids.
     pub(crate) fn iter(&self) -> impl ExactSizeIterator<Item = (Id<T>, &T)> {
-        let ids_iter = (0..self.storage.len()).map(|idx| Id::new(idx));
+        let ids_iter = (0..self.storage.len() as u32).map(|idx| Id::new(idx));
         ids_iter.zip(self.storage.iter())
     }
 }
@@ -219,13 +220,13 @@ impl<T> std::ops::Index<Id<T>> for DenseMap<T> {
     type Output = T;
 
     fn index(&self, id: Id<T>) -> &Self::Output {
-        &self.storage[id.index]
+        &self.storage[id.index as usize]
     }
 }
 
 impl<T> std::ops::IndexMut<Id<T>> for DenseMap<T> {
     fn index_mut(&mut self, id: Id<T>) -> &mut Self::Output {
-        &mut self.storage[id.index]
+        &mut self.storage[id.index as usize]
     }
 }
 
@@ -253,7 +254,7 @@ impl<T> SparseMap<T> {
     /// Adds an element to the map.
     /// Returns the identifier/reference to that element.
     pub(crate) fn insert(&mut self, element: T) -> Id<T> {
-        let id = Id::new(self.storage.len());
+        let id = Id::new(self.storage.len().try_into().unwrap());
         self.storage.insert(id, element);
         id
     }
@@ -261,7 +262,7 @@ impl<T> SparseMap<T> {
     /// Given the Id of the element being created, adds the element
     /// returned by the given function to the map
     pub(crate) fn insert_with_id(&mut self, f: impl FnOnce(Id<T>) -> T) -> Id<T> {
-        let id = Id::new(self.storage.len());
+        let id = Id::new(self.storage.len().try_into().unwrap());
         self.storage.insert(id, f(id));
         id
     }
@@ -365,7 +366,7 @@ impl<K: Eq + Hash, V> std::ops::Index<&K> for TwoWayMap<K, V> {
 /// This type wraps an AtomicUsize so it can safely be used across threads.
 #[derive(Debug, Serialize, Deserialize)]
 pub(crate) struct AtomicCounter<T> {
-    next: AtomicUsize,
+    next: AtomicU32,
     _marker: std::marker::PhantomData<T>,
 }
 
@@ -373,7 +374,7 @@ impl<T> AtomicCounter<T> {
     /// Create a new counter starting after the given Id.
     /// Use AtomicCounter::default() to start at zero.
     pub(crate) fn starting_after(id: Id<T>) -> Self {
-        Self { next: AtomicUsize::new(id.index + 1), _marker: Default::default() }
+        Self { next: AtomicU32::new(id.index + 1), _marker: Default::default() }
     }
 
     /// Return the next fresh id
diff --git a/compiler/noirc_evaluator/src/ssa/ir.rs b/compiler/noirc_evaluator/src/ssa/ir/mod.rs
similarity index 95%
rename from compiler/noirc_evaluator/src/ssa/ir.rs
rename to compiler/noirc_evaluator/src/ssa/ir/mod.rs
index 3ef680dda0f..89ba22e8b79 100644
--- a/compiler/noirc_evaluator/src/ssa/ir.rs
+++ b/compiler/noirc_evaluator/src/ssa/ir/mod.rs
@@ -5,6 +5,7 @@ pub(crate) mod dom;
 pub(crate) mod function;
 pub(crate) mod function_inserter;
 pub(crate) mod instruction;
+pub mod list;
 pub(crate) mod map;
 pub(crate) mod post_order;
 pub(crate) mod printer;
diff --git a/compiler/noirc_evaluator/src/ssa/ir/post_order.rs b/compiler/noirc_evaluator/src/ssa/ir/post_order.rs
index 94ff96ba1d7..398ce887b96 100644
--- a/compiler/noirc_evaluator/src/ssa/ir/post_order.rs
+++ b/compiler/noirc_evaluator/src/ssa/ir/post_order.rs
@@ -22,7 +22,7 @@ impl PostOrder {
 }
 
 impl PostOrder {
-    /// Allocate and compute a function's block post-order. Pos
+    /// Allocate and compute a function's block post-order.
     pub(crate) fn with_function(func: &Function) -> Self {
         PostOrder(Self::compute_post_order(func))
     }
diff --git a/compiler/noirc_evaluator/src/ssa/ir/printer.rs b/compiler/noirc_evaluator/src/ssa/ir/printer.rs
index 2b564c14aa7..29e79728303 100644
--- a/compiler/noirc_evaluator/src/ssa/ir/printer.rs
+++ b/compiler/noirc_evaluator/src/ssa/ir/printer.rs
@@ -1,13 +1,12 @@
 //! This file is for pretty-printing the SSA IR in a human-readable form for debugging.
-use std::{
-    collections::HashSet,
-    fmt::{Formatter, Result},
-};
+use std::fmt::{Formatter, Result};
 
-use acvm::acir::circuit::{ErrorSelector, STRING_ERROR_SELECTOR};
 use acvm::acir::AcirField;
+use im::Vector;
 use iter_extended::vecmap;
 
+use crate::ssa::ir::types::{NumericType, Type};
+
 use super::{
     basic_block::BasicBlockId,
     dfg::DataFlowGraph,
@@ -19,28 +18,10 @@ use super::{
 /// Helper function for Function's Display impl to pretty-print the function with the given formatter.
 pub(crate) fn display_function(function: &Function, f: &mut Formatter) -> Result {
     writeln!(f, "{} fn {} {} {{", function.runtime(), function.name(), function.id())?;
-    display_block_with_successors(function, function.entry_block(), &mut HashSet::new(), f)?;
-    write!(f, "}}")
-}
-
-/// Displays a block followed by all of its successors recursively.
-/// This uses a HashSet to keep track of the visited blocks. Otherwise
-/// there would be infinite recursion for any loops in the IR.
-pub(crate) fn display_block_with_successors(
-    function: &Function,
-    block_id: BasicBlockId,
-    visited: &mut HashSet<BasicBlockId>,
-    f: &mut Formatter,
-) -> Result {
-    display_block(function, block_id, f)?;
-    visited.insert(block_id);
-
-    for successor in function.dfg[block_id].successors() {
-        if !visited.contains(&successor) {
-            display_block_with_successors(function, successor, visited, f)?;
-        }
+    for block_id in function.reachable_blocks() {
+        display_block(function, block_id, f)?;
     }
-    Ok(())
+    write!(f, "}}")
 }
 
 /// Display a single block. This will not display the block's successors.
@@ -70,10 +51,6 @@ fn value(function: &Function, id: ValueId) -> String {
         }
         Value::Function(id) => id.to_string(),
         Value::Intrinsic(intrinsic) => intrinsic.to_string(),
-        Value::Array { array, .. } => {
-            let elements = vecmap(array, |element| value(function, *element));
-            format!("[{}]", elements.join(", "))
-        }
         Value::Param { .. } | Value::Instruction { .. } | Value::ForeignFunction(_) => {
             id.to_string()
         }
@@ -120,7 +97,11 @@ pub(crate) fn display_terminator(
             )
         }
         Some(TerminatorInstruction::Return { return_values, .. }) => {
-            writeln!(f, "    return {}", value_list(function, return_values))
+            if return_values.is_empty() {
+                writeln!(f, "    return")
+            } else {
+                writeln!(f, "    return {}", value_list(function, return_values))
+            }
         }
         None => writeln!(f, "    (no terminator instruction)"),
     }
@@ -140,12 +121,13 @@ pub(crate) fn display_instruction(
         write!(f, "{} = ", value_list(function, results))?;
     }
 
-    display_instruction_inner(function, &function.dfg[instruction], f)
+    display_instruction_inner(function, &function.dfg[instruction], results, f)
 }
 
 fn display_instruction_inner(
     function: &Function,
     instruction: &Instruction,
+    results: &[ValueId],
     f: &mut Formatter,
 ) -> Result {
     let show = |id| value(function, id);
@@ -169,10 +151,15 @@ fn display_instruction_inner(
             }
         }
         Instruction::Call { func, arguments } => {
-            writeln!(f, "call {}({})", show(*func), value_list(function, arguments))
+            let arguments = value_list(function, arguments);
+            writeln!(f, "call {}({}){}", show(*func), arguments, result_types(function, results))
+        }
+        Instruction::Allocate => {
+            writeln!(f, "allocate{}", result_types(function, results))
+        }
+        Instruction::Load { address } => {
+            writeln!(f, "load {}{}", show(*address), result_types(function, results))
         }
-        Instruction::Allocate => writeln!(f, "allocate"),
-        Instruction::Load { address } => writeln!(f, "load {}", show(*address)),
         Instruction::Store { address, value } => {
             writeln!(f, "store {} at {}", show(*value), show(*address))
         }
@@ -180,7 +167,13 @@ fn display_instruction_inner(
             writeln!(f, "enable_side_effects {}", show(*condition))
         }
         Instruction::ArrayGet { array, index } => {
-            writeln!(f, "array_get {}, index {}", show(*array), show(*index))
+            writeln!(
+                f,
+                "array_get {}, index {}{}",
+                show(*array),
+                show(*index),
+                result_types(function, results)
+            )
         }
         Instruction::ArraySet { array, index, value, mutable } => {
             let array = show(*array);
@@ -205,28 +198,88 @@ fn display_instruction_inner(
             let else_value = show(*else_value);
             writeln!(
                 f,
-                "if {then_condition} then {then_value} else if {else_condition} then {else_value}"
+                "if {then_condition} then {then_value} else (if {else_condition}) {else_value}"
             )
         }
+        Instruction::MakeArray { elements, typ } => {
+            // If the array is a byte array, we check if all the bytes are printable ascii characters
+            // and, if so, we print the array as a string literal (easier to understand).
+            // It could happen that the byte array is a random byte sequence that happens to be printable
+            // (it didn't come from a string literal) but this still reduces the noise in the output
+            // and actually represents the same value.
+            let (element_types, is_slice) = match typ {
+                Type::Array(types, _) => (types, false),
+                Type::Slice(types) => (types, true),
+                _ => panic!("Expected array or slice type for MakeArray"),
+            };
+            if element_types.len() == 1
+                && element_types[0] == Type::Numeric(NumericType::Unsigned { bit_size: 8 })
+            {
+                if let Some(string) = try_byte_array_to_string(elements, function) {
+                    if is_slice {
+                        return writeln!(f, "make_array &b{:?}", string);
+                    } else {
+                        return writeln!(f, "make_array b{:?}", string);
+                    }
+                }
+            }
+
+            write!(f, "make_array [")?;
+
+            for (i, element) in elements.iter().enumerate() {
+                if i != 0 {
+                    write!(f, ", ")?;
+                }
+                write!(f, "{}", show(*element))?;
+            }
+
+            writeln!(f, "] : {typ}")
+        }
+    }
+}
+
+fn try_byte_array_to_string(elements: &Vector<ValueId>, function: &Function) -> Option<String> {
+    let mut string = String::new();
+    for element in elements {
+        let element = function.dfg.get_numeric_constant(*element)?;
+        let element = element.try_to_u32()?;
+        if element > 0xFF {
+            return None;
+        }
+        let byte = element as u8;
+        if byte.is_ascii_alphanumeric() || byte.is_ascii_punctuation() || byte.is_ascii_whitespace()
+        {
+            string.push(byte as char);
+        } else {
+            return None;
+        }
+    }
+    Some(string)
+}
+
+fn result_types(function: &Function, results: &[ValueId]) -> String {
+    let types = vecmap(results, |result| function.dfg.type_of_value(*result).to_string());
+    if types.is_empty() {
+        String::new()
+    } else if types.len() == 1 {
+        format!(" -> {}", types[0])
+    } else {
+        format!(" -> ({})", types.join(", "))
     }
 }
 
 /// Tries to extract a constant string from an error payload.
 pub(crate) fn try_to_extract_string_from_error_payload(
-    error_selector: ErrorSelector,
+    is_string_type: bool,
     values: &[ValueId],
     dfg: &DataFlowGraph,
 ) -> Option<String> {
-    ((error_selector == STRING_ERROR_SELECTOR) && (values.len() == 1))
+    (is_string_type && (values.len() == 1))
         .then_some(())
         .and_then(|()| {
-            let Value::Array { array: values, .. } = &dfg[values[0]] else {
-                return None;
-            };
-            let fields: Option<Vec<_>> =
-                values.iter().map(|value_id| dfg.get_numeric_constant(*value_id)).collect();
-
-            fields
+            let (values, _) = &dfg.get_array_constant(values[0])?;
+            let values = values.iter().map(|value_id| dfg.get_numeric_constant(*value_id));
+            values.collect::<Option<Vec<_>>>()
         })
         .map(|fields| {
             fields
@@ -246,13 +299,13 @@ fn display_constrain_error(
 ) -> Result {
     match error {
         ConstrainError::StaticString(assert_message_string) => {
-            writeln!(f, " '{assert_message_string:?}'")
+            writeln!(f, ", {assert_message_string:?}")
         }
-        ConstrainError::Dynamic(selector, values) => {
+        ConstrainError::Dynamic(_, is_string, values) => {
             if let Some(constant_string) =
-                try_to_extract_string_from_error_payload(*selector, values, &function.dfg)
+                try_to_extract_string_from_error_payload(*is_string, values, &function.dfg)
             {
-                writeln!(f, " '{}'", constant_string)
+                writeln!(f, ", {constant_string:?}")
             } else {
                 writeln!(f, ", data {}", value_list(function, values))
             }
diff --git a/compiler/noirc_evaluator/src/ssa/ir/types.rs b/compiler/noirc_evaluator/src/ssa/ir/types.rs
index b7ee37ba17a..0dd7fd92ee5 100644
--- a/compiler/noirc_evaluator/src/ssa/ir/types.rs
+++ b/compiler/noirc_evaluator/src/ssa/ir/types.rs
@@ -30,6 +30,31 @@ impl NumericType {
         }
     }
 
+    /// Creates a NumericType::Signed type
+    pub(crate) fn signed(bit_size: u32) -> NumericType {
+        NumericType::Signed { bit_size }
+    }
+
+    /// Creates a NumericType::Unsigned type
+    pub(crate) fn unsigned(bit_size: u32) -> NumericType {
+        NumericType::Unsigned { bit_size }
+    }
+
+    /// Creates the u1 type
+    pub(crate) fn bool() -> NumericType {
+        NumericType::Unsigned { bit_size: 1 }
+    }
+
+    /// Creates the char type, represented as u8.
+    pub(crate) fn char() -> NumericType {
+        NumericType::Unsigned { bit_size: 8 }
+    }
+
+    /// Creates the type of an array's length.
+    pub(crate) fn length_type() -> NumericType {
+        NumericType::Unsigned { bit_size: SSA_WORD_SIZE }
+    }
+
     /// Returns None if the given Field value is within the numeric limits
     /// for the current NumericType. Otherwise returns a string describing
     /// the limits, as a range.
@@ -63,6 +88,10 @@ impl NumericType {
             NumericType::NativeField => None,
         }
     }
+
+    pub(crate) fn is_unsigned(&self) -> bool {
+        matches!(self, NumericType::Unsigned { .. })
+    }
 }
 
 /// All types representable in the IR.
@@ -75,7 +104,7 @@ pub(crate) enum Type {
     Reference(Arc<Type>),
 
     /// An immutable array value with the given element type and length
-    Array(Arc<CompositeType>, usize),
+    Array(Arc<CompositeType>, u32),
 
     /// An immutable slice value with a given element type
     Slice(Arc<CompositeType>),
@@ -111,7 +140,7 @@ impl Type {
     }
 
     /// Creates the str<N> type, of the given length N
-    pub(crate) fn str(length: usize) -> Type {
+    pub(crate) fn str(length: u32) -> Type {
         Type::Array(Arc::new(vec![Type::char()]), length)
     }
 
@@ -125,6 +154,14 @@ impl Type {
         Type::unsigned(SSA_WORD_SIZE)
     }
 
+    /// Returns the inner NumericType if this is one, or panics otherwise
+    pub(crate) fn unwrap_numeric(&self) -> NumericType {
+        match self {
+            Type::Numeric(numeric) => *numeric,
+            other => panic!("Expected NumericType, found {other}"),
+        }
+    }
+
     /// Returns the bit size of the provided numeric type.
     ///
     /// # Panics
@@ -161,7 +198,7 @@ impl Type {
     }
 
     /// Returns the flattened size of a Type
-    pub(crate) fn flattened_size(&self) -> usize {
+    pub(crate) fn flattened_size(&self) -> u32 {
         match self {
             Type::Array(elements, len) => {
                 elements.iter().fold(0, |sum, elem| sum + (elem.flattened_size() * len))
@@ -190,6 +227,15 @@ impl Type {
         }
     }
 
+    /// Retrieves the array or slice type within this type, or panics if there is none.
+    pub(crate) fn get_contained_array(&self) -> &Type {
+        match self {
+            Type::Numeric(_) | Type::Function => panic!("Expected an array type"),
+            Type::Array(_, _) | Type::Slice(_) => self,
+            Type::Reference(element) => element.get_contained_array(),
+        }
+    }
+
     pub(crate) fn element_types(self) -> Arc<Vec<Type>> {
         match self {
             Type::Array(element_types, _) | Type::Slice(element_types) => element_types,
@@ -204,6 +250,17 @@ impl Type {
             Type::Slice(element_types) | Type::Array(element_types, _) => element_types[0].first(),
         }
     }
+
+    /// True if this is a reference type or if it is a composite type which contains a reference.
+    pub(crate) fn contains_reference(&self) -> bool {
+        match self {
+            Type::Reference(_) => true,
+            Type::Numeric(_) | Type::Function => false,
+            Type::Array(elements, _) | Type::Slice(elements) => {
+                elements.iter().any(|elem| elem.contains_reference())
+            }
+        }
+    }
 }
 
 /// Composite Types are essentially flattened struct or tuple types.
@@ -218,7 +275,11 @@ impl std::fmt::Display for Type {
             Type::Reference(element) => write!(f, "&mut {element}"),
             Type::Array(element, length) => {
                 let elements = vecmap(element.iter(), |element| element.to_string());
-                write!(f, "[{}; {length}]", elements.join(", "))
+                if elements.len() == 1 {
+                    write!(f, "[{}; {length}]", elements.join(", "))
+                } else {
+                    write!(f, "[({}); {length}]", elements.join(", "))
+                }
             }
             Type::Slice(element) => {
                 let elements = vecmap(element.iter(), |element| element.to_string());
diff --git a/compiler/noirc_evaluator/src/ssa/ir/value.rs b/compiler/noirc_evaluator/src/ssa/ir/value.rs
index 795d45c75e9..ec7a8e25246 100644
--- a/compiler/noirc_evaluator/src/ssa/ir/value.rs
+++ b/compiler/noirc_evaluator/src/ssa/ir/value.rs
@@ -1,3 +1,5 @@
+use std::borrow::Cow;
+
 use acvm::FieldElement;
 use serde::{Deserialize, Serialize};
 
@@ -7,7 +9,7 @@ use super::{
     function::FunctionId,
     instruction::{InstructionId, Intrinsic},
     map::Id,
-    types::Type,
+    types::{NumericType, Type},
 };
 
 pub(crate) type ValueId = Id<Value>;
@@ -34,10 +36,7 @@ pub(crate) enum Value {
     Param { block: BasicBlockId, position: usize, typ: Type },
 
     /// This Value originates from a numeric constant
-    NumericConstant { constant: FieldElement, typ: Type },
-
-    /// Represents a constant array value
-    Array { array: im::Vector<ValueId>, typ: Type },
+    NumericConstant { constant: FieldElement, typ: NumericType },
 
     /// This Value refers to a function in the IR.
     /// Functions always have the type Type::Function.
@@ -58,15 +57,13 @@ pub(crate) enum Value {
 
 impl Value {
     /// Retrieves the type of this Value
-    pub(crate) fn get_type(&self) -> &Type {
+    pub(crate) fn get_type(&self) -> Cow<Type> {
         match self {
-            Value::Instruction { typ, .. } => typ,
-            Value::Param { typ, .. } => typ,
-            Value::NumericConstant { typ, .. } => typ,
-            Value::Array { typ, .. } => typ,
-            Value::Function { .. } => &Type::Function,
-            Value::Intrinsic { .. } => &Type::Function,
-            Value::ForeignFunction { .. } => &Type::Function,
+            Value::Instruction { typ, .. } | Value::Param { typ, .. } => Cow::Borrowed(typ),
+            Value::NumericConstant { typ, .. } => Cow::Owned(Type::Numeric(*typ)),
+            Value::Function { .. } | Value::Intrinsic { .. } | Value::ForeignFunction { .. } => {
+                Cow::Owned(Type::Function)
+            }
         }
     }
 }
diff --git a/compiler/noirc_evaluator/src/ssa/opt/array_set.rs b/compiler/noirc_evaluator/src/ssa/opt/array_set.rs
index 6d48b8c0d67..09339cf0797 100644
--- a/compiler/noirc_evaluator/src/ssa/opt/array_set.rs
+++ b/compiler/noirc_evaluator/src/ssa/opt/array_set.rs
@@ -1,7 +1,10 @@
+use std::mem;
+
 use crate::ssa::{
     ir::{
         basic_block::BasicBlockId,
         dfg::DataFlowGraph,
+        function::{Function, RuntimeType},
         instruction::{Instruction, InstructionId, TerminatorInstruction},
         types::Type::{Array, Slice},
         value::ValueId,
@@ -17,94 +20,138 @@ impl Ssa {
     #[tracing::instrument(level = "trace", skip(self))]
     pub(crate) fn array_set_optimization(mut self) -> Self {
         for func in self.functions.values_mut() {
-            let reachable_blocks = func.reachable_blocks();
+            func.array_set_optimization();
+        }
+        self
+    }
+}
 
-            if !func.runtime().is_entry_point() {
-                assert_eq!(reachable_blocks.len(), 1, "Expected there to be 1 block remaining in Acir function for array_set optimization");
-            }
-            let mut array_to_last_use = HashMap::default();
-            let mut instructions_to_update = HashSet::default();
-            let mut arrays_from_load = HashSet::default();
+impl Function {
+    pub(crate) fn array_set_optimization(&mut self) {
+        if matches!(self.runtime(), RuntimeType::Brillig(_)) {
+            // Brillig is supposed to use refcounting to decide whether to mutate an array;
+            // array mutation was only meant for ACIR. We could use it with Brillig as well,
+            // but then some of the optimizations that we can do in ACIR around shared
+            // references have to be skipped, which makes it more cumbersome.
+            return;
+        }
 
-            for block in reachable_blocks.iter() {
-                analyze_last_uses(
-                    &func.dfg,
-                    *block,
-                    &mut array_to_last_use,
-                    &mut instructions_to_update,
-                    &mut arrays_from_load,
-                );
-            }
-            for block in reachable_blocks {
-                make_mutable(&mut func.dfg, block, &instructions_to_update);
-            }
+        let reachable_blocks = self.reachable_blocks();
+
+        if !self.runtime().is_entry_point() {
+            assert_eq!(reachable_blocks.len(), 1, "Expected there to be 1 block remaining in Acir function for array_set optimization");
+        }
+
+        let mut context = Context::new(&self.dfg);
+
+        for block in reachable_blocks.iter() {
+            context.analyze_last_uses(*block);
+        }
+
+        let instructions_to_update = mem::take(&mut context.instructions_that_can_be_made_mutable);
+        for block in reachable_blocks {
+            make_mutable(&mut self.dfg, block, &instructions_to_update);
         }
-        self
     }
 }
 
-/// Builds the set of ArraySet instructions that can be made mutable
-/// because their input value is unused elsewhere afterward.
-fn analyze_last_uses(
-    dfg: &DataFlowGraph,
-    block_id: BasicBlockId,
-    array_to_last_use: &mut HashMap<ValueId, InstructionId>,
-    instructions_that_can_be_made_mutable: &mut HashSet<InstructionId>,
-    arrays_from_load: &mut HashSet<ValueId>,
-) {
-    let block = &dfg[block_id];
+struct Context<'f> {
+    dfg: &'f DataFlowGraph,
+    array_to_last_use: HashMap<ValueId, InstructionId>,
+    instructions_that_can_be_made_mutable: HashSet<InstructionId>,
+    // Mapping of an array that comes from a load and whether the address
+    // it was loaded from is a reference parameter passed to the block.
+    arrays_from_load: HashMap<ValueId, bool>,
+    inner_nested_arrays: HashMap<ValueId, InstructionId>,
+}
 
-    for instruction_id in block.instructions() {
-        match &dfg[*instruction_id] {
-            Instruction::ArrayGet { array, .. } => {
-                let array = dfg.resolve(*array);
+impl<'f> Context<'f> {
+    fn new(dfg: &'f DataFlowGraph) -> Self {
+        Context {
+            dfg,
+            array_to_last_use: HashMap::default(),
+            instructions_that_can_be_made_mutable: HashSet::default(),
+            arrays_from_load: HashMap::default(),
+            inner_nested_arrays: HashMap::default(),
+        }
+    }
 
-                if let Some(existing) = array_to_last_use.insert(array, *instruction_id) {
-                    instructions_that_can_be_made_mutable.remove(&existing);
-                }
-            }
-            Instruction::ArraySet { array, .. } => {
-                let array = dfg.resolve(*array);
+    /// Builds the set of ArraySet instructions that can be made mutable
+    /// because their input value is unused elsewhere afterward.
+    fn analyze_last_uses(&mut self, block_id: BasicBlockId) {
+        let block = &self.dfg[block_id];
 
-                if let Some(existing) = array_to_last_use.insert(array, *instruction_id) {
-                    instructions_that_can_be_made_mutable.remove(&existing);
-                }
-                // If the array we are setting does not come from a load we can safely mark it mutable.
-                // If the array comes from a load we may potentially being mutating an array at a reference
-                // that is loaded from by other values.
-                let terminator = dfg[block_id].unwrap_terminator();
-                // If we are in a return block we are not concerned about the array potentially being mutated again.
-                let is_return_block = matches!(terminator, TerminatorInstruction::Return { .. });
-                // We also want to check that the array is not part of the terminator arguments, as this means it is used again.
-                let mut array_in_terminator = false;
-                terminator.for_each_value(|value| {
-                    if value == array {
-                        array_in_terminator = true;
+        for instruction_id in block.instructions() {
+            match &self.dfg[*instruction_id] {
+                Instruction::ArrayGet { array, .. } => {
+                    let array = self.dfg.resolve(*array);
+
+                    if let Some(existing) = self.array_to_last_use.insert(array, *instruction_id) {
+                        self.instructions_that_can_be_made_mutable.remove(&existing);
                     }
-                });
-                if (!arrays_from_load.contains(&array) || is_return_block) && !array_in_terminator {
-                    instructions_that_can_be_made_mutable.insert(*instruction_id);
                 }
-            }
-            Instruction::Call { arguments, .. } => {
-                for argument in arguments {
-                    if matches!(dfg.type_of_value(*argument), Array { .. } | Slice { .. }) {
-                        let argument = dfg.resolve(*argument);
+                Instruction::ArraySet { array, .. } => {
+                    let array = self.dfg.resolve(*array);
 
-                        if let Some(existing) = array_to_last_use.insert(argument, *instruction_id)
+                    if let Some(existing) = self.array_to_last_use.insert(array, *instruction_id) {
+                        self.instructions_that_can_be_made_mutable.remove(&existing);
+                    }
+
+                    // If the array we are setting does not come from a load we can safely mark it mutable.
+                    // If the array comes from a load we may potentially being mutating an array at a reference
+                    // that is loaded from by other values.
+                    let terminator = self.dfg[block_id].unwrap_terminator();
+
+                    // If we are in a return block we are not concerned about the array potentially being mutated again.
+                    let is_return_block =
+                        matches!(terminator, TerminatorInstruction::Return { .. });
+
+                    // We also want to check that the array is not part of the terminator arguments, as this means it is used again.
+                    let mut is_array_in_terminator = false;
+                    terminator.for_each_value(|value| {
+                        // The terminator can contain original IDs, while the SSA has replaced the array value IDs; we need to resolve to compare.
+                        if !is_array_in_terminator && self.dfg.resolve(value) == array {
+                            is_array_in_terminator = true;
+                        }
+                    });
+
+                    let can_mutate = if let Some(is_from_param) = self.arrays_from_load.get(&array)
+                    {
+                        // If the array was loaded from a reference parameter, we cannot
+                        // safely mark that array mutable as it may be shared by another value.
+                        !is_from_param && is_return_block
+                    } else {
+                        !is_array_in_terminator
+                    };
+
+                    if can_mutate {
+                        self.instructions_that_can_be_made_mutable.insert(*instruction_id);
+                    }
+                }
+                Instruction::Call { arguments, .. } => {
+                    for argument in arguments {
+                        if matches!(self.dfg.type_of_value(*argument), Array { .. } | Slice { .. })
                         {
-                            instructions_that_can_be_made_mutable.remove(&existing);
+                            let argument = self.dfg.resolve(*argument);
+
+                            if let Some(existing) =
+                                self.array_to_last_use.insert(argument, *instruction_id)
+                            {
+                                self.instructions_that_can_be_made_mutable.remove(&existing);
+                            }
                         }
                     }
                 }
-            }
-            Instruction::Load { .. } => {
-                let result = dfg.instruction_results(*instruction_id)[0];
-                if matches!(dfg.type_of_value(result), Array { .. } | Slice { .. }) {
-                    arrays_from_load.insert(result);
+                Instruction::Load { address } => {
+                    let result = self.dfg.instruction_results(*instruction_id)[0];
+                    if matches!(self.dfg.type_of_value(result), Array { .. } | Slice { .. }) {
+                        let is_reference_param =
+                            self.dfg.block_parameters(block_id).contains(address);
+                        self.arrays_from_load.insert(result, is_reference_param);
+                    }
                 }
+                _ => (),
             }
-            _ => (),
         }
     }
 }
@@ -142,126 +189,49 @@ fn make_mutable(
 
 #[cfg(test)]
 mod tests {
-    use std::sync::Arc;
-
-    use im::vector;
-
-    use crate::ssa::{
-        function_builder::FunctionBuilder,
-        ir::{
-            function::RuntimeType,
-            instruction::{BinaryOp, Instruction},
-            map::Id,
-            types::Type,
-        },
-    };
+    use crate::ssa::{opt::assert_normalized_ssa_equals, Ssa};
 
     #[test]
     fn array_set_in_loop_with_conditional_clone() {
         // We want to make sure that we do not mark a single array set mutable which is loaded
         // from and cloned in a loop. If the array is inadvertently marked mutable, and is cloned in a previous iteration
         // of the loop, its clone will also be altered.
-        //
-        // acir(inline) fn main f0 {
-        //     b0():
-        //       v2 = allocate
-        //       store [Field 0, Field 0, Field 0, Field 0, Field 0] at v2
-        //       v3 = allocate
-        //       store [Field 0, Field 0, Field 0, Field 0, Field 0] at v3
-        //       jmp b1(u32 0)
-        //     b1(v5: u32):
-        //       v7 = lt v5, u32 5
-        //       jmpif v7 then: b3, else: b2
-        //     b3():
-        //       v8 = eq v5, u32 5
-        //       jmpif v8 then: b4, else: b5
-        //     b4():
-        //       v9 = load v2
-        //       store v9 at v3
-        //       jmp b5()
-        //     b5():
-        //       v10 = load v2
-        //       v12 = array_set v10, index v5, value Field 20
-        //       store v12 at v2
-        //       v14 = add v5, u32 1
-        //       jmp b1(v14)
-        //     b2():
-        //       return
-        //   }
-        let main_id = Id::test_new(0);
-        let mut builder = FunctionBuilder::new("main".into(), main_id);
-        builder.set_runtime(RuntimeType::Brillig);
-
-        let array_type = Type::Array(Arc::new(vec![Type::field()]), 5);
-        let zero = builder.field_constant(0u128);
-        let array_constant =
-            builder.array_constant(vector![zero, zero, zero, zero, zero], array_type.clone());
-
-        let v2 = builder.insert_allocate(array_type.clone());
-
-        builder.insert_store(v2, array_constant);
-
-        let v3 = builder.insert_allocate(array_type.clone());
-        builder.insert_store(v3, array_constant);
-
-        let b1 = builder.insert_block();
-        let zero_u32 = builder.numeric_constant(0u128, Type::unsigned(32));
-        builder.terminate_with_jmp(b1, vec![zero_u32]);
-
-        // Loop header
-        builder.switch_to_block(b1);
-        let v5 = builder.add_block_parameter(b1, Type::unsigned(32));
-        let five = builder.numeric_constant(5u128, Type::unsigned(32));
-        let v7 = builder.insert_binary(v5, BinaryOp::Lt, five);
-
-        let b2 = builder.insert_block();
-        let b3 = builder.insert_block();
-        let b4 = builder.insert_block();
-        let b5 = builder.insert_block();
-        builder.terminate_with_jmpif(v7, b3, b2);
-
-        // Loop body
-        // b3 is the if statement conditional
-        builder.switch_to_block(b3);
-        let two = builder.numeric_constant(5u128, Type::unsigned(32));
-        let v8 = builder.insert_binary(v5, BinaryOp::Eq, two);
-        builder.terminate_with_jmpif(v8, b4, b5);
-
-        // b4 is the rest of the loop after the if statement
-        builder.switch_to_block(b4);
-        let v9 = builder.insert_load(v2, array_type.clone());
-        builder.insert_store(v3, v9);
-        builder.terminate_with_jmp(b5, vec![]);
-
-        builder.switch_to_block(b5);
-        let v10 = builder.insert_load(v2, array_type.clone());
-        let twenty = builder.field_constant(20u128);
-        let v12 = builder.insert_array_set(v10, v5, twenty);
-        builder.insert_store(v2, v12);
-        let one = builder.numeric_constant(1u128, Type::unsigned(32));
-        let v14 = builder.insert_binary(v5, BinaryOp::Add, one);
-        builder.terminate_with_jmp(b1, vec![v14]);
-
-        builder.switch_to_block(b2);
-        builder.terminate_with_return(vec![]);
+        let src = "
+            brillig(inline) fn main f0 {
+              b0():
+                v2 = make_array [Field 0, Field 0, Field 0, Field 0, Field 0] : [Field; 5]
+                v3 = make_array [v2, v2] : [[Field; 5]; 2]
+                v4 = allocate -> &mut [Field; 5]
+                store v3 at v4
+                v5 = allocate -> &mut [Field; 5]
+                store v3 at v5
+                jmp b1(u32 0)
+              b1(v0: u32):
+                v8 = lt v0, u32 5
+                jmpif v8 then: b3, else: b2
+              b2():
+                return
+              b3():
+                v9 = eq v0, u32 5
+                jmpif v9 then: b4, else: b5
+              b4():
+                v10 = load v4 -> [[Field; 5]; 2]
+                store v10 at v5
+                jmp b5()
+              b5():
+                v11 = load v4 -> [[Field; 5]; 2]
+                v12 = array_get v11, index Field 0 -> [Field; 5]
+                v14 = array_set v12, index v0, value Field 20
+                v15 = array_set v11, index v0, value v14
+                store v15 at v4
+                v17 = add v0, u32 1
+                jmp b1(v17)
+            }
+            ";
+        let ssa = Ssa::from_str(src).unwrap();
 
-        let ssa = builder.finish();
         // We expect the same result as above
         let ssa = ssa.array_set_optimization();
-
-        let main = ssa.main();
-        assert_eq!(main.reachable_blocks().len(), 6);
-
-        let array_set_instructions = main.dfg[b5]
-            .instructions()
-            .iter()
-            .filter(|instruction| matches!(&main.dfg[**instruction], Instruction::ArraySet { .. }))
-            .collect::<Vec<_>>();
-
-        assert_eq!(array_set_instructions.len(), 1);
-        if let Instruction::ArraySet { mutable, .. } = &main.dfg[*array_set_instructions[0]] {
-            // The single array set should not be marked mutable
-            assert!(!mutable);
-        }
+        assert_normalized_ssa_equals(ssa, src);
     }
 }
diff --git a/compiler/noirc_evaluator/src/ssa/opt/as_slice_length.rs b/compiler/noirc_evaluator/src/ssa/opt/as_slice_length.rs
index 69eab1da0ed..c6cdffd3bc3 100644
--- a/compiler/noirc_evaluator/src/ssa/opt/as_slice_length.rs
+++ b/compiler/noirc_evaluator/src/ssa/opt/as_slice_length.rs
@@ -2,7 +2,7 @@ use crate::ssa::{
     ir::{
         function::Function,
         instruction::{Instruction, InstructionId, Intrinsic},
-        types::Type,
+        types::{NumericType, Type},
         value::Value,
     },
     ssa_gen::Ssa,
@@ -20,14 +20,20 @@ impl Ssa {
     #[tracing::instrument(level = "trace", skip(self))]
     pub(crate) fn as_slice_optimization(mut self) -> Self {
         for func in self.functions.values_mut() {
-            let known_slice_lengths = known_slice_lengths(func);
-            replace_known_slice_lengths(func, known_slice_lengths);
+            func.as_slice_optimization();
         }
         self
     }
 }
 
-fn known_slice_lengths(func: &Function) -> HashMap<InstructionId, usize> {
+impl Function {
+    pub(crate) fn as_slice_optimization(&mut self) {
+        let known_slice_lengths = known_slice_lengths(self);
+        replace_known_slice_lengths(self, known_slice_lengths);
+    }
+}
+
+fn known_slice_lengths(func: &Function) -> HashMap<InstructionId, u32> {
     let mut known_slice_lengths = HashMap::default();
     for block_id in func.reachable_blocks() {
         let block = &func.dfg[block_id];
@@ -55,7 +61,7 @@ fn known_slice_lengths(func: &Function) -> HashMap<InstructionId, usize> {
 
 fn replace_known_slice_lengths(
     func: &mut Function,
-    known_slice_lengths: HashMap<InstructionId, usize>,
+    known_slice_lengths: HashMap<InstructionId, u32>,
 ) {
     known_slice_lengths.into_iter().for_each(|(instruction_id, known_length)| {
         let call_returns = func.dfg.instruction_results(instruction_id);
@@ -65,7 +71,38 @@ fn replace_known_slice_lengths(
         // This isn't strictly necessary as a new result will be defined the next time for which the instruction
         // is reinserted but this avoids leaving the program in an invalid state.
         func.dfg.replace_result(instruction_id, original_slice_length);
-        let known_length = func.dfg.make_constant(known_length.into(), Type::length_type());
+        let known_length = func.dfg.make_constant(known_length.into(), NumericType::length_type());
         func.dfg.set_value_from_id(original_slice_length, known_length);
     });
 }
+
+#[cfg(test)]
+mod test {
+    use crate::ssa::opt::assert_normalized_ssa_equals;
+
+    use super::Ssa;
+
+    #[test]
+    fn as_slice_length_optimization() {
+        // In this code we expect `return v2` to be replaced with `return u32 3` because
+        // that's the length of the v0 array.
+        let src = "
+            acir(inline) fn main f0 {
+              b0(v0: [Field; 3]):
+                v2, v3 = call as_slice(v0) -> (u32, [Field])
+                return v2
+            }
+            ";
+        let ssa = Ssa::from_str(src).unwrap();
+
+        let expected = "
+            acir(inline) fn main f0 {
+              b0(v0: [Field; 3]):
+                v2, v3 = call as_slice(v0) -> (u32, [Field])
+                return u32 3
+            }
+            ";
+        let ssa = ssa.as_slice_optimization();
+        assert_normalized_ssa_equals(ssa, expected);
+    }
+}
diff --git a/compiler/noirc_evaluator/src/ssa/opt/assert_constant.rs b/compiler/noirc_evaluator/src/ssa/opt/assert_constant.rs
index ae0681a55ff..348c78683a0 100644
--- a/compiler/noirc_evaluator/src/ssa/opt/assert_constant.rs
+++ b/compiler/noirc_evaluator/src/ssa/opt/assert_constant.rs
@@ -26,22 +26,31 @@ impl Ssa {
         mut self,
     ) -> Result<Ssa, RuntimeError> {
         for function in self.functions.values_mut() {
-            for block in function.reachable_blocks() {
-                // Unfortunately we can't just use instructions.retain(...) here since
-                // check_instruction can also return an error
-                let instructions = function.dfg[block].take_instructions();
-                let mut filtered_instructions = Vec::with_capacity(instructions.len());
+            function.evaluate_static_assert_and_assert_constant()?;
+        }
+        Ok(self)
+    }
+}
 
-                for instruction in instructions {
-                    if check_instruction(function, instruction)? {
-                        filtered_instructions.push(instruction);
-                    }
-                }
+impl Function {
+    pub(crate) fn evaluate_static_assert_and_assert_constant(
+        &mut self,
+    ) -> Result<(), RuntimeError> {
+        for block in self.reachable_blocks() {
+            // Unfortunately we can't just use instructions.retain(...) here since
+            // check_instruction can also return an error
+            let instructions = self.dfg[block].take_instructions();
+            let mut filtered_instructions = Vec::with_capacity(instructions.len());
 
-                *function.dfg[block].instructions_mut() = filtered_instructions;
+            for instruction in instructions {
+                if check_instruction(self, instruction)? {
+                    filtered_instructions.push(instruction);
+                }
             }
+
+            *self.dfg[block].instructions_mut() = filtered_instructions;
         }
-        Ok(self)
+        Ok(())
     }
 }
 
diff --git a/compiler/noirc_evaluator/src/ssa/opt/constant_folding.rs b/compiler/noirc_evaluator/src/ssa/opt/constant_folding.rs
index ff9a63c8d79..e2379043541 100644
--- a/compiler/noirc_evaluator/src/ssa/opt/constant_folding.rs
+++ b/compiler/noirc_evaluator/src/ssa/opt/constant_folding.rs
@@ -6,7 +6,7 @@
 //!   by the [`DataFlowGraph`] automatically as new instructions are pushed.
 //! - Check whether any input values have been constrained to be equal to a value of a simpler form
 //!   by a [constrain instruction][Instruction::Constrain]. If so, replace the input value with the simpler form.
-//! - Check whether the instruction [can_be_replaced][Instruction::can_be_replaced()]
+//! - Check whether the instruction [can_be_deduplicated][Instruction::can_be_deduplicated()]
 //!   by duplicate instruction earlier in the same block.
 //!
 //! These operations are done in parallel so that they can each benefit from each other
@@ -19,32 +19,49 @@
 //!
 //! This is the only pass which removes duplicated pure [`Instruction`]s however and so is needed when
 //! different blocks are merged, i.e. after the [`flatten_cfg`][super::flatten_cfg] pass.
-use std::collections::HashSet;
+use std::collections::{BTreeMap, HashSet, VecDeque};
 
-use acvm::{acir::AcirField, FieldElement};
+use acvm::{
+    acir::AcirField,
+    brillig_vm::{MemoryValue, VMStatus, VM},
+    FieldElement,
+};
+use bn254_blackbox_solver::Bn254BlackBoxSolver;
+use im::Vector;
 use iter_extended::vecmap;
 
-use crate::ssa::{
-    ir::{
-        basic_block::BasicBlockId,
-        dfg::{DataFlowGraph, InsertInstructionResult},
-        function::Function,
-        instruction::{Instruction, InstructionId},
-        types::Type,
-        value::{Value, ValueId},
+use crate::{
+    brillig::{
+        brillig_gen::gen_brillig_for,
+        brillig_ir::{artifact::BrilligParameter, brillig_variable::get_bit_size_from_ssa_type},
+        Brillig,
+    },
+    ssa::{
+        ir::{
+            basic_block::BasicBlockId,
+            dfg::{DataFlowGraph, InsertInstructionResult},
+            dom::DominatorTree,
+            function::{Function, FunctionId, RuntimeType},
+            instruction::{Instruction, InstructionId},
+            types::{NumericType, Type},
+            value::{Value, ValueId},
+        },
+        ssa_gen::Ssa,
     },
-    ssa_gen::Ssa,
 };
 use fxhash::FxHashMap as HashMap;
 
 impl Ssa {
     /// Performs constant folding on each instruction.
     ///
+    /// It will not look at constraints to inform simplifications
+    /// based on the stated equivalence of two instructions.
+    ///
     /// See [`constant_folding`][self] module for more information.
     #[tracing::instrument(level = "trace", skip(self))]
     pub(crate) fn fold_constants(mut self) -> Ssa {
         for function in self.functions.values_mut() {
-            constant_fold(function, false);
+            function.constant_fold(false, None);
         }
         self
     }
@@ -57,66 +74,216 @@ impl Ssa {
     #[tracing::instrument(level = "trace", skip(self))]
     pub(crate) fn fold_constants_using_constraints(mut self) -> Ssa {
         for function in self.functions.values_mut() {
-            constant_fold(function, true);
+            function.constant_fold(true, None);
         }
         self
     }
-}
 
-/// The structure of this pass is simple:
-/// Go through each block and re-insert all instructions.
-fn constant_fold(function: &mut Function, use_constraint_info: bool) {
-    let mut context = Context { use_constraint_info, ..Default::default() };
-    context.block_queue.push(function.entry_block());
+    /// Performs constant folding on each instruction while also replacing calls to brillig functions
+    /// with all constant arguments by trying to evaluate those calls.
+    #[tracing::instrument(level = "trace", skip(self, brillig))]
+    pub(crate) fn fold_constants_with_brillig(mut self, brillig: &Brillig) -> Ssa {
+        // Collect all brillig functions so that later we can find them when processing a call instruction
+        let mut brillig_functions: BTreeMap<FunctionId, Function> = BTreeMap::new();
+        for (func_id, func) in &self.functions {
+            if let RuntimeType::Brillig(..) = func.runtime() {
+                let cloned_function = Function::clone_with_id(*func_id, func);
+                brillig_functions.insert(*func_id, cloned_function);
+            };
+        }
+
+        let brillig_info = Some(BrilligInfo { brillig, brillig_functions: &brillig_functions });
+
+        for function in self.functions.values_mut() {
+            function.constant_fold(false, brillig_info);
+        }
+
+        // It could happen that we inlined all calls to a given brillig function.
+        // In that case it's unused so we can remove it. This is what we check next.
+        self.remove_unused_brillig_functions(brillig_functions)
+    }
+
+    fn remove_unused_brillig_functions(
+        mut self,
+        mut brillig_functions: BTreeMap<FunctionId, Function>,
+    ) -> Ssa {
+        // Remove from the above map functions that are called
+        for function in self.functions.values() {
+            for block_id in function.reachable_blocks() {
+                for instruction_id in function.dfg[block_id].instructions() {
+                    let instruction = &function.dfg[*instruction_id];
+                    let Instruction::Call { func: func_id, arguments: _ } = instruction else {
+                        continue;
+                    };
+
+                    let func_value = &function.dfg[*func_id];
+                    let Value::Function(func_id) = func_value else { continue };
+
+                    brillig_functions.remove(func_id);
+                }
+            }
+        }
+
+        // The ones that remain are never called: let's remove them.
+        for (func_id, func) in &brillig_functions {
+            // We never want to remove the main function (it could be `unconstrained` or it
+            // could have been turned into brillig if `--force-brillig` was given).
+            // We also don't want to remove entry points.
+            let runtime = func.runtime();
+            if self.main_id == *func_id
+                || (runtime.is_entry_point() && matches!(runtime, RuntimeType::Acir(_)))
+            {
+                continue;
+            }
 
-    while let Some(block) = context.block_queue.pop() {
-        if context.visited_blocks.contains(&block) {
-            continue;
+            self.functions.remove(func_id);
         }
 
-        context.visited_blocks.insert(block);
-        context.fold_constants_in_block(function, block);
+        self
     }
 }
 
-#[derive(Default)]
-struct Context {
+impl Function {
+    /// The structure of this pass is simple:
+    /// Go through each block and re-insert all instructions.
+    pub(crate) fn constant_fold(
+        &mut self,
+        use_constraint_info: bool,
+        brillig_info: Option<BrilligInfo>,
+    ) {
+        let mut context = Context::new(use_constraint_info, brillig_info);
+        let mut dom = DominatorTree::with_function(self);
+        context.block_queue.push_back(self.entry_block());
+
+        while let Some(block) = context.block_queue.pop_front() {
+            if context.visited_blocks.contains(&block) {
+                continue;
+            }
+
+            context.visited_blocks.insert(block);
+            context.fold_constants_in_block(self, &mut dom, block);
+        }
+    }
+}
+
+struct Context<'a> {
     use_constraint_info: bool,
+    brillig_info: Option<BrilligInfo<'a>>,
     /// Maps pre-folded ValueIds to the new ValueIds obtained by re-inserting the instruction.
     visited_blocks: HashSet<BasicBlockId>,
-    block_queue: Vec<BasicBlockId>,
+    block_queue: VecDeque<BasicBlockId>,
+
+    /// Contains sets of values which are constrained to be equivalent to each other.
+    ///
+    /// The mapping's structure is `side_effects_enabled_var => (constrained_value => simplified_value)`.
+    ///
+    /// We partition the maps of constrained values according to the side-effects flag at the point
+    /// at which the values are constrained. This prevents constraints which are only sometimes enforced
+    /// being used to modify the rest of the program.
+    constraint_simplification_mappings: ConstraintSimplificationCache,
+
+    // Cache of instructions without any side-effects along with their outputs.
+    cached_instruction_results: InstructionResultCache,
+}
+
+#[derive(Copy, Clone)]
+pub(crate) struct BrilligInfo<'a> {
+    brillig: &'a Brillig,
+    brillig_functions: &'a BTreeMap<FunctionId, Function>,
 }
 
-/// HashMap from (Instruction, side_effects_enabled_var) to the results of the instruction.
+/// Records a simplified equivalents of an [`Instruction`] in the blocks
+/// where the constraint that advised the simplification has been encountered.
+///
+/// For more information see [`ConstraintSimplificationCache`].
+#[derive(Default)]
+struct SimplificationCache {
+    /// Simplified expressions where we found them.
+    ///
+    /// It will always have at least one value because `add` is called
+    /// after the default is constructed.
+    simplifications: HashMap<BasicBlockId, ValueId>,
+}
+
+impl SimplificationCache {
+    /// Called with a newly encountered simplification.
+    fn add(&mut self, dfg: &DataFlowGraph, simple: ValueId, block: BasicBlockId) {
+        self.simplifications
+            .entry(block)
+            .and_modify(|existing| {
+                // `SimplificationCache` may already hold a simplification in this block
+                // so we check whether `simple` is a better simplification than the current one.
+                if let Some((_, simpler)) = simplify(dfg, *existing, simple) {
+                    *existing = simpler;
+                };
+            })
+            .or_insert(simple);
+    }
+
+    /// Try to find a simplification in a visible block.
+    fn get(&self, block: BasicBlockId, dom: &DominatorTree) -> Option<ValueId> {
+        // Deterministically walk up the dominator chain until we encounter a block that contains a simplification.
+        dom.find_map_dominator(block, |b| self.simplifications.get(&b).cloned())
+    }
+}
+
+/// HashMap from `(side_effects_enabled_var, Instruction)` to a simplified expression that it can
+/// be replaced with based on constraints that testify to their equivalence, stored together
+/// with the set of blocks at which this constraint has been observed.
+///
+/// Only blocks dominated by one in the cache should have access to this information, otherwise
+/// we create a sort of time paradox where we replace an instruction with a constant we believe
+/// it _should_ equal to, without ever actually producing and asserting the value.
+type ConstraintSimplificationCache = HashMap<ValueId, HashMap<ValueId, SimplificationCache>>;
+
+/// HashMap from `(Instruction, side_effects_enabled_var)` to the results of the instruction.
 /// Stored as a two-level map to avoid cloning Instructions during the `.get` call.
-type InstructionResultCache = HashMap<Instruction, HashMap<Option<ValueId>, Vec<ValueId>>>;
+///
+/// The `side_effects_enabled_var` is optional because we only use them when `Instruction::requires_acir_gen_predicate`
+/// is true _and_ the constraint information is also taken into account.
+///
+/// In addition to each result, the original BasicBlockId is stored as well. This allows us
+/// to deduplicate instructions across blocks as long as the new block dominates the original.
+type InstructionResultCache = HashMap<Instruction, HashMap<Option<ValueId>, ResultCache>>;
+
+/// Records the results of all duplicate [`Instruction`]s along with the blocks in which they sit.
+///
+/// For more information see [`InstructionResultCache`].
+#[derive(Default)]
+struct ResultCache {
+    result: Option<(BasicBlockId, Vec<ValueId>)>,
+}
 
-impl Context {
-    fn fold_constants_in_block(&mut self, function: &mut Function, block: BasicBlockId) {
-        let instructions = function.dfg[block].take_instructions();
+impl<'brillig> Context<'brillig> {
+    fn new(use_constraint_info: bool, brillig_info: Option<BrilligInfo<'brillig>>) -> Self {
+        Self {
+            use_constraint_info,
+            brillig_info,
+            visited_blocks: Default::default(),
+            block_queue: Default::default(),
+            constraint_simplification_mappings: Default::default(),
+            cached_instruction_results: Default::default(),
+        }
+    }
 
-        // Cache of instructions without any side-effects along with their outputs.
-        let mut cached_instruction_results = HashMap::default();
+    fn fold_constants_in_block(
+        &mut self,
+        function: &mut Function,
+        dom: &mut DominatorTree,
+        block: BasicBlockId,
+    ) {
+        let instructions = function.dfg[block].take_instructions();
 
-        // Contains sets of values which are constrained to be equivalent to each other.
-        //
-        // The mapping's structure is `side_effects_enabled_var => (constrained_value => simplified_value)`.
-        //
-        // We partition the maps of constrained values according to the side-effects flag at the point
-        // at which the values are constrained. This prevents constraints which are only sometimes enforced
-        // being used to modify the rest of the program.
-        let mut constraint_simplification_mappings: HashMap<ValueId, HashMap<ValueId, ValueId>> =
-            HashMap::default();
+        // Default side effect condition variable with an enabled state.
         let mut side_effects_enabled_var =
-            function.dfg.make_constant(FieldElement::one(), Type::bool());
+            function.dfg.make_constant(FieldElement::one(), NumericType::bool());
 
         for instruction_id in instructions {
             self.fold_constants_into_instruction(
-                &mut function.dfg,
+                function,
+                dom,
                 block,
                 instruction_id,
-                &mut cached_instruction_results,
-                &mut constraint_simplification_mappings,
                 &mut side_effects_enabled_var,
             );
         }
@@ -124,39 +291,70 @@ impl Context {
     }
 
     fn fold_constants_into_instruction(
-        &self,
-        dfg: &mut DataFlowGraph,
-        block: BasicBlockId,
+        &mut self,
+        function: &mut Function,
+        dom: &mut DominatorTree,
+        mut block: BasicBlockId,
         id: InstructionId,
-        instruction_result_cache: &mut InstructionResultCache,
-        constraint_simplification_mappings: &mut HashMap<ValueId, HashMap<ValueId, ValueId>>,
         side_effects_enabled_var: &mut ValueId,
     ) {
-        let constraint_simplification_mapping =
-            constraint_simplification_mappings.entry(*side_effects_enabled_var).or_default();
-        let instruction = Self::resolve_instruction(id, dfg, constraint_simplification_mapping);
+        let constraint_simplification_mapping = self.get_constraint_map(*side_effects_enabled_var);
+        let dfg = &mut function.dfg;
+
+        let instruction =
+            Self::resolve_instruction(id, block, dfg, dom, constraint_simplification_mapping);
+
         let old_results = dfg.instruction_results(id).to_vec();
 
         // If a copy of this instruction exists earlier in the block, then reuse the previous results.
-        if let Some(cached_results) =
-            Self::get_cached(dfg, instruction_result_cache, &instruction, *side_effects_enabled_var)
+        if let Some(cache_result) =
+            self.get_cached(dfg, dom, &instruction, *side_effects_enabled_var, block)
         {
-            Self::replace_result_ids(dfg, &old_results, cached_results);
-            return;
-        }
+            match cache_result {
+                CacheResult::Cached(cached) => {
+                    // We track whether we may mutate MakeArray instructions before we deduplicate
+                    // them but we still need to issue an extra inc_rc in case they're mutated afterward.
+                    if matches!(instruction, Instruction::MakeArray { .. }) {
+                        let value = *cached.last().unwrap();
+                        let inc_rc = Instruction::IncrementRc { value };
+                        let call_stack = dfg.get_call_stack(id);
+                        dfg.insert_instruction_and_results(inc_rc, block, None, call_stack);
+                    }
 
+                    Self::replace_result_ids(dfg, &old_results, cached);
+                    return;
+                }
+                CacheResult::NeedToHoistToCommonBlock(dominator) => {
+                    // Just change the block to insert in the common dominator instead.
+                    // This will only move the current instance of the instruction right now.
+                    // When constant folding is run a second time later on, it'll catch
+                    // that the previous instance can be deduplicated to this instance.
+                    block = dominator;
+                }
+            }
+        };
+
+        // First try to inline a call to a brillig function with all constant arguments.
+        let new_results = Self::try_inline_brillig_call_with_all_constants(
+            &instruction,
+            &old_results,
+            block,
+            dfg,
+            self.brillig_info,
+        )
         // Otherwise, try inserting the instruction again to apply any optimizations using the newly resolved inputs.
-        let new_results = Self::push_instruction(id, instruction.clone(), &old_results, block, dfg);
+        .unwrap_or_else(|| {
+            Self::push_instruction(id, instruction.clone(), &old_results, block, dfg)
+        });
 
         Self::replace_result_ids(dfg, &old_results, &new_results);
 
         self.cache_instruction(
             instruction.clone(),
             new_results,
-            dfg,
-            instruction_result_cache,
-            constraint_simplification_mapping,
+            function,
             *side_effects_enabled_var,
+            block,
         );
 
         // If we just inserted an `Instruction::EnableSideEffectsIf`, we need to update `side_effects_enabled_var`
@@ -169,8 +367,10 @@ impl Context {
     /// Fetches an [`Instruction`] by its [`InstructionId`] and fully resolves its inputs.
     fn resolve_instruction(
         instruction_id: InstructionId,
+        block: BasicBlockId,
         dfg: &DataFlowGraph,
-        constraint_simplification_mapping: &HashMap<ValueId, ValueId>,
+        dom: &mut DominatorTree,
+        constraint_simplification_mapping: &HashMap<ValueId, SimplificationCache>,
     ) -> Instruction {
         let instruction = dfg[instruction_id].clone();
 
@@ -180,20 +380,29 @@ impl Context {
         // This allows us to reach a stable final `ValueId` for each instruction input as we add more
         // constraints to the cache.
         fn resolve_cache(
+            block: BasicBlockId,
             dfg: &DataFlowGraph,
-            cache: &HashMap<ValueId, ValueId>,
+            dom: &mut DominatorTree,
+            cache: &HashMap<ValueId, SimplificationCache>,
             value_id: ValueId,
         ) -> ValueId {
             let resolved_id = dfg.resolve(value_id);
             match cache.get(&resolved_id) {
-                Some(cached_value) => resolve_cache(dfg, cache, *cached_value),
+                Some(simplification_cache) => {
+                    if let Some(simplified) = simplification_cache.get(block, dom) {
+                        resolve_cache(block, dfg, dom, cache, simplified)
+                    } else {
+                        resolved_id
+                    }
+                }
                 None => resolved_id,
             }
         }
 
         // Resolve any inputs to ensure that we're comparing like-for-like instructions.
-        instruction
-            .map_values(|value_id| resolve_cache(dfg, constraint_simplification_mapping, value_id))
+        instruction.map_values(|value_id| {
+            resolve_cache(block, dfg, dom, constraint_simplification_mapping, value_id)
+        })
     }
 
     /// Pushes a new [`Instruction`] into the [`DataFlowGraph`] which applies any optimizations
@@ -227,57 +436,85 @@ impl Context {
     }
 
     fn cache_instruction(
-        &self,
+        &mut self,
         instruction: Instruction,
         instruction_results: Vec<ValueId>,
-        dfg: &DataFlowGraph,
-        instruction_result_cache: &mut InstructionResultCache,
-        constraint_simplification_mapping: &mut HashMap<ValueId, ValueId>,
+        function: &Function,
         side_effects_enabled_var: ValueId,
+        block: BasicBlockId,
     ) {
         if self.use_constraint_info {
             // If the instruction was a constraint, then create a link between the two `ValueId`s
             // to map from the more complex to the simpler value.
             if let Instruction::Constrain(lhs, rhs, _) = instruction {
                 // These `ValueId`s should be fully resolved now.
-                match (&dfg[lhs], &dfg[rhs]) {
-                    // Ignore trivial constraints
-                    (Value::NumericConstant { .. }, Value::NumericConstant { .. }) => (),
-
-                    // Prefer replacing with constants where possible.
-                    (Value::NumericConstant { .. }, _) => {
-                        constraint_simplification_mapping.insert(rhs, lhs);
-                    }
-                    (_, Value::NumericConstant { .. }) => {
-                        constraint_simplification_mapping.insert(lhs, rhs);
-                    }
-                    // Otherwise prefer block parameters over instruction results.
-                    // This is as block parameters are more likely to be a single witness rather than a full expression.
-                    (Value::Param { .. }, Value::Instruction { .. }) => {
-                        constraint_simplification_mapping.insert(rhs, lhs);
-                    }
-                    (Value::Instruction { .. }, Value::Param { .. }) => {
-                        constraint_simplification_mapping.insert(lhs, rhs);
-                    }
-                    (_, _) => (),
+                if let Some((complex, simple)) = simplify(&function.dfg, lhs, rhs) {
+                    self.get_constraint_map(side_effects_enabled_var)
+                        .entry(complex)
+                        .or_default()
+                        .add(&function.dfg, simple, block);
                 }
             }
         }
 
+        // If we have an array get whose value is from an array set on the same array at the same index,
+        // we can simplify that array get to the value of the previous array set.
+        //
+        // For example:
+        // v3 = array_set v0, index v1, value v2
+        // v4 = array_get v3, index v1 -> Field
+        //
+        // We know that `v4` can be simplified to `v2`.
+        // Thus, even if the index is dynamic (meaning the array get would have side effects),
+        // we can simplify the operation when we take into account the predicate.
+        if let Instruction::ArraySet { index, value, .. } = &instruction {
+            let use_predicate =
+                self.use_constraint_info && instruction.requires_acir_gen_predicate(&function.dfg);
+            let predicate = use_predicate.then_some(side_effects_enabled_var);
+
+            let array_get = Instruction::ArrayGet { array: instruction_results[0], index: *index };
+
+            self.cached_instruction_results
+                .entry(array_get)
+                .or_default()
+                .entry(predicate)
+                .or_default()
+                .cache(block, vec![*value]);
+        }
+
+        self.remove_possibly_mutated_cached_make_arrays(&instruction, function);
+
         // If the instruction doesn't have side-effects and if it won't interact with enable_side_effects during acir_gen,
         // we cache the results so we can reuse them if the same instruction appears again later in the block.
-        if instruction.can_be_deduplicated(dfg, self.use_constraint_info) {
+        // Others have side effects representing failure, which are implicit in the ACIR code and can also be deduplicated.
+        let can_be_deduplicated =
+            instruction.can_be_deduplicated(function, self.use_constraint_info);
+
+        // We also allow deduplicating MakeArray instructions that we have tracked which haven't
+        // been mutated.
+        if can_be_deduplicated || matches!(instruction, Instruction::MakeArray { .. }) {
             let use_predicate =
-                self.use_constraint_info && instruction.requires_acir_gen_predicate(dfg);
+                self.use_constraint_info && instruction.requires_acir_gen_predicate(&function.dfg);
             let predicate = use_predicate.then_some(side_effects_enabled_var);
 
-            instruction_result_cache
+            self.cached_instruction_results
                 .entry(instruction)
                 .or_default()
-                .insert(predicate, instruction_results);
+                .entry(predicate)
+                .or_default()
+                .cache(block, instruction_results);
         }
     }
 
+    /// Get the simplification mapping from complex to simpler instructions,
+    /// which all depend on the same side effect condition variable.
+    fn get_constraint_map(
+        &mut self,
+        side_effects_enabled_var: ValueId,
+    ) -> &mut HashMap<ValueId, SimplificationCache> {
+        self.constraint_simplification_mappings.entry(side_effects_enabled_var).or_default()
+    }
+
     /// Replaces a set of [`ValueId`]s inside the [`DataFlowGraph`] with another.
     fn replace_result_ids(
         dfg: &mut DataFlowGraph,
@@ -289,23 +526,302 @@ impl Context {
         }
     }
 
-    fn get_cached<'a>(
+    /// Get a cached result if it can be used in this context.
+    fn get_cached(
+        &self,
         dfg: &DataFlowGraph,
-        instruction_result_cache: &'a mut InstructionResultCache,
+        dom: &mut DominatorTree,
         instruction: &Instruction,
         side_effects_enabled_var: ValueId,
-    ) -> Option<&'a Vec<ValueId>> {
-        let results_for_instruction = instruction_result_cache.get(instruction);
+        block: BasicBlockId,
+    ) -> Option<CacheResult> {
+        let results_for_instruction = self.cached_instruction_results.get(instruction)?;
+        let predicate = self.use_constraint_info && instruction.requires_acir_gen_predicate(dfg);
+        let predicate = predicate.then_some(side_effects_enabled_var);
 
-        // See if there's a cached version with no predicate first
-        if let Some(results) = results_for_instruction.and_then(|map| map.get(&None)) {
-            return Some(results);
+        results_for_instruction.get(&predicate)?.get(block, dom, instruction.has_side_effects(dfg))
+    }
+
+    /// Checks if the given instruction is a call to a brillig function with all constant arguments.
+    /// If so, we can try to evaluate that function and replace the results with the evaluation results.
+    fn try_inline_brillig_call_with_all_constants(
+        instruction: &Instruction,
+        old_results: &[ValueId],
+        block: BasicBlockId,
+        dfg: &mut DataFlowGraph,
+        brillig_info: Option<BrilligInfo>,
+    ) -> Option<Vec<ValueId>> {
+        let evaluation_result = Self::evaluate_const_brillig_call(
+            instruction,
+            brillig_info?.brillig,
+            brillig_info?.brillig_functions,
+            dfg,
+        );
+
+        match evaluation_result {
+            EvaluationResult::NotABrilligCall | EvaluationResult::CannotEvaluate(_) => None,
+            EvaluationResult::Evaluated(memory_values) => {
+                let mut memory_index = 0;
+                let new_results = vecmap(old_results, |old_result| {
+                    let typ = dfg.type_of_value(*old_result);
+                    Self::new_value_for_type_and_memory_values(
+                        typ,
+                        block,
+                        &memory_values,
+                        &mut memory_index,
+                        dfg,
+                    )
+                });
+                Some(new_results)
+            }
         }
+    }
 
-        let predicate =
-            instruction.requires_acir_gen_predicate(dfg).then_some(side_effects_enabled_var);
+    /// Tries to evaluate an instruction if it's a call that points to a brillig function,
+    /// and all its arguments are constant.
+    /// We do this by directly executing the function with a brillig VM.
+    fn evaluate_const_brillig_call(
+        instruction: &Instruction,
+        brillig: &Brillig,
+        brillig_functions: &BTreeMap<FunctionId, Function>,
+        dfg: &mut DataFlowGraph,
+    ) -> EvaluationResult {
+        let Instruction::Call { func: func_id, arguments } = instruction else {
+            return EvaluationResult::NotABrilligCall;
+        };
+
+        let func_value = &dfg[*func_id];
+        let Value::Function(func_id) = func_value else {
+            return EvaluationResult::NotABrilligCall;
+        };
 
-        results_for_instruction.and_then(|map| map.get(&predicate))
+        let Some(func) = brillig_functions.get(func_id) else {
+            return EvaluationResult::NotABrilligCall;
+        };
+
+        if !arguments.iter().all(|argument| dfg.is_constant(*argument)) {
+            return EvaluationResult::CannotEvaluate(*func_id);
+        }
+
+        let mut brillig_arguments = Vec::new();
+        for argument in arguments {
+            let typ = dfg.type_of_value(*argument);
+            let Some(parameter) = type_to_brillig_parameter(&typ) else {
+                return EvaluationResult::CannotEvaluate(*func_id);
+            };
+            brillig_arguments.push(parameter);
+        }
+
+        // Check that return value types are supported by brillig
+        for return_id in func.returns().iter() {
+            let typ = func.dfg.type_of_value(*return_id);
+            if type_to_brillig_parameter(&typ).is_none() {
+                return EvaluationResult::CannotEvaluate(*func_id);
+            }
+        }
+
+        let Ok(generated_brillig) = gen_brillig_for(func, brillig_arguments, brillig) else {
+            return EvaluationResult::CannotEvaluate(*func_id);
+        };
+
+        let mut calldata = Vec::new();
+        for argument in arguments {
+            value_id_to_calldata(*argument, dfg, &mut calldata);
+        }
+
+        let bytecode = &generated_brillig.byte_code;
+        let foreign_call_results = Vec::new();
+        let black_box_solver = Bn254BlackBoxSolver;
+        let profiling_active = false;
+        let mut vm =
+            VM::new(calldata, bytecode, foreign_call_results, &black_box_solver, profiling_active);
+        let vm_status: VMStatus<_> = vm.process_opcodes();
+        let VMStatus::Finished { return_data_offset, return_data_size } = vm_status else {
+            return EvaluationResult::CannotEvaluate(*func_id);
+        };
+
+        let memory =
+            vm.get_memory()[return_data_offset..(return_data_offset + return_data_size)].to_vec();
+
+        EvaluationResult::Evaluated(memory)
+    }
+
+    /// Creates a new value inside this function by reading it from `memory_values` starting at
+    /// `memory_index` depending on the given Type: if it's an array multiple values will be read
+    /// and a new `make_array` instruction will be created.
+    fn new_value_for_type_and_memory_values(
+        typ: Type,
+        block_id: BasicBlockId,
+        memory_values: &[MemoryValue<FieldElement>],
+        memory_index: &mut usize,
+        dfg: &mut DataFlowGraph,
+    ) -> ValueId {
+        match typ {
+            Type::Numeric(typ) => {
+                let memory = memory_values[*memory_index];
+                *memory_index += 1;
+
+                let field_value = match memory {
+                    MemoryValue::Field(field_value) => field_value,
+                    MemoryValue::Integer(u128_value, _) => u128_value.into(),
+                };
+                dfg.make_constant(field_value, typ)
+            }
+            Type::Array(types, length) => {
+                let mut new_array_values = Vector::new();
+                for _ in 0..length {
+                    for typ in types.iter() {
+                        let new_value = Self::new_value_for_type_and_memory_values(
+                            typ.clone(),
+                            block_id,
+                            memory_values,
+                            memory_index,
+                            dfg,
+                        );
+                        new_array_values.push_back(new_value);
+                    }
+                }
+
+                let instruction = Instruction::MakeArray {
+                    elements: new_array_values,
+                    typ: Type::Array(types, length),
+                };
+                let instruction_id = dfg.make_instruction(instruction, None);
+                dfg[block_id].instructions_mut().push(instruction_id);
+                *dfg.instruction_results(instruction_id).first().unwrap()
+            }
+            Type::Reference(_) => {
+                panic!("Unexpected reference type in brillig function result")
+            }
+            Type::Slice(_) => {
+                panic!("Unexpected slice type in brillig function result")
+            }
+            Type::Function => {
+                panic!("Unexpected function type in brillig function result")
+            }
+        }
+    }
+
+    fn remove_possibly_mutated_cached_make_arrays(
+        &mut self,
+        instruction: &Instruction,
+        function: &Function,
+    ) {
+        use Instruction::{ArraySet, Store};
+
+        // Should we consider calls to slice_push_back and similar to be mutating operations as well?
+        if let Store { value: array, .. } | ArraySet { array, .. } = instruction {
+            let instruction = match &function.dfg[*array] {
+                Value::Instruction { instruction, .. } => &function.dfg[*instruction],
+                _ => return,
+            };
+
+            if matches!(instruction, Instruction::MakeArray { .. }) {
+                self.cached_instruction_results.remove(instruction);
+            }
+        }
+    }
+}
+
+impl ResultCache {
+    /// Records that an `Instruction` in block `block` produced the result values `results`.
+    fn cache(&mut self, block: BasicBlockId, results: Vec<ValueId>) {
+        if self.result.is_none() {
+            self.result = Some((block, results));
+        }
+    }
+
+    /// Returns a set of [`ValueId`]s produced from a copy of this [`Instruction`] which sits
+    /// within a block which dominates `block`.
+    ///
+    /// We require that the cached instruction's block dominates `block` in order to avoid
+    /// cycles causing issues (e.g. two instructions being replaced with the results of each other
+    /// such that neither instruction exists anymore.)
+    fn get(
+        &self,
+        block: BasicBlockId,
+        dom: &mut DominatorTree,
+        has_side_effects: bool,
+    ) -> Option<CacheResult> {
+        self.result.as_ref().and_then(|(origin_block, results)| {
+            if dom.dominates(*origin_block, block) {
+                Some(CacheResult::Cached(results))
+            } else if !has_side_effects {
+                // Insert a copy of this instruction in the common dominator
+                let dominator = dom.common_dominator(*origin_block, block);
+                Some(CacheResult::NeedToHoistToCommonBlock(dominator))
+            } else {
+                None
+            }
+        })
+    }
+}
+
+enum CacheResult<'a> {
+    Cached(&'a [ValueId]),
+    NeedToHoistToCommonBlock(BasicBlockId),
+}
+
+/// Result of trying to evaluate an instruction (any instruction) in this pass.
+enum EvaluationResult {
+    /// Nothing was done because the instruction wasn't a call to a brillig function,
+    /// or some arguments to it were not constants.
+    NotABrilligCall,
+    /// The instruction was a call to a brillig function, but we couldn't evaluate it.
+    /// This can occur in the situation where the brillig function reaches a "trap" or a foreign call opcode.
+    CannotEvaluate(FunctionId),
+    /// The instruction was a call to a brillig function and we were able to evaluate it,
+    /// returning evaluation memory values.
+    Evaluated(Vec<MemoryValue<FieldElement>>),
+}
+
+/// Similar to FunctionContext::ssa_type_to_parameter but never panics and disallows reference types.
+pub(crate) fn type_to_brillig_parameter(typ: &Type) -> Option<BrilligParameter> {
+    match typ {
+        Type::Numeric(_) => Some(BrilligParameter::SingleAddr(get_bit_size_from_ssa_type(typ))),
+        Type::Array(item_type, size) => {
+            let mut parameters = Vec::with_capacity(item_type.len());
+            for item_typ in item_type.iter() {
+                parameters.push(type_to_brillig_parameter(item_typ)?);
+            }
+            Some(BrilligParameter::Array(parameters, *size as usize))
+        }
+        _ => None,
+    }
+}
+
+fn value_id_to_calldata(value_id: ValueId, dfg: &DataFlowGraph, calldata: &mut Vec<FieldElement>) {
+    if let Some(value) = dfg.get_numeric_constant(value_id) {
+        calldata.push(value);
+        return;
+    }
+
+    if let Some((values, _type)) = dfg.get_array_constant(value_id) {
+        for value in values {
+            value_id_to_calldata(value, dfg, calldata);
+        }
+        return;
+    }
+
+    panic!("Expected ValueId to be numeric constant or array constant");
+}
+
+/// Check if one expression is simpler than the other.
+/// Returns `Some((complex, simple))` if a simplification was found, otherwise `None`.
+/// Expects the `ValueId`s to be fully resolved.
+fn simplify(dfg: &DataFlowGraph, lhs: ValueId, rhs: ValueId) -> Option<(ValueId, ValueId)> {
+    match (&dfg[lhs], &dfg[rhs]) {
+        // Ignore trivial constraints
+        (Value::NumericConstant { .. }, Value::NumericConstant { .. }) => None,
+
+        // Prefer replacing with constants where possible.
+        (Value::NumericConstant { .. }, _) => Some((rhs, lhs)),
+        (_, Value::NumericConstant { .. }) => Some((lhs, rhs)),
+        // Otherwise prefer block parameters over instruction results.
+        // This is as block parameters are more likely to be a single witness rather than a full expression.
+        (Value::Param { .. }, Value::Instruction { .. }) => Some((rhs, lhs)),
+        (Value::Instruction { .. }, Value::Param { .. }) => Some((lhs, rhs)),
+        (_, _) => None,
     }
 }
 
@@ -316,325 +832,360 @@ mod test {
     use crate::ssa::{
         function_builder::FunctionBuilder,
         ir::{
-            instruction::{Binary, BinaryOp, Instruction, TerminatorInstruction},
             map::Id,
-            types::Type,
-            value::{Value, ValueId},
+            types::{NumericType, Type},
         },
+        opt::assert_normalized_ssa_equals,
+        Ssa,
     };
-    use acvm::{acir::AcirField, FieldElement};
 
     #[test]
     fn simple_constant_fold() {
-        // fn main f0 {
-        //   b0(v0: Field):
-        //     v1 = add v0, Field 1
-        //     v2 = mul v1, Field 3
-        //     return v2
-        // }
-        //
         // After constructing this IR, we set the value of v0 to 2.
         // The expected return afterwards should be 9.
-        let main_id = Id::test_new(0);
-
-        // Compiling main
-        let mut builder = FunctionBuilder::new("main".into(), main_id);
-        let v0 = builder.add_parameter(Type::field());
-
-        let one = builder.field_constant(1u128);
-        let two = builder.field_constant(2u128);
-        let three = builder.field_constant(3u128);
-
-        let v1 = builder.insert_binary(v0, BinaryOp::Add, one);
-        let v2 = builder.insert_binary(v1, BinaryOp::Mul, three);
-        builder.terminate_with_return(vec![v2]);
-
-        let mut ssa = builder.finish();
+        let src = "
+            acir(inline) fn main f0 {
+              b0(v0: Field):
+                v1 = add v0, Field 1
+                v2 = mul v1, Field 3
+                return v2
+            }
+            ";
+        let mut ssa = Ssa::from_str(src).unwrap();
         let main = ssa.main_mut();
+
         let instructions = main.dfg[main.entry_block()].instructions();
         assert_eq!(instructions.len(), 2); // The final return is not counted
 
-        // Expected output:
-        //
-        // fn main f0 {
-        //   b0(Field 2: Field):
-        //     return Field 9
-        // }
+        let v0 = main.parameters()[0];
+        let two = main.dfg.make_constant(2_u128.into(), NumericType::NativeField);
+
         main.dfg.set_value_from_id(v0, two);
 
+        let expected = "
+            acir(inline) fn main f0 {
+              b0(v0: Field):
+                return Field 9
+            }
+            ";
         let ssa = ssa.fold_constants();
-        let main = ssa.main();
-        let block = &main.dfg[main.entry_block()];
-        assert_eq!(block.instructions().len(), 0);
-
-        match block.terminator() {
-            Some(TerminatorInstruction::Return { return_values, .. }) => {
-                let value = main
-                    .dfg
-                    .get_numeric_constant(return_values[0])
-                    .expect("Expected constant 9")
-                    .to_u128();
-                assert_eq!(value, 9);
-            }
-            _ => unreachable!("b0 should have a return terminator"),
-        }
+        assert_normalized_ssa_equals(ssa, expected);
     }
 
     #[test]
     fn redundant_truncation() {
-        // fn main f0 {
-        //   b0(v0: u16, v1: u16):
-        //     v2 = div v0, v1
-        //     v3 = truncate v2 to 8 bits, max_bit_size: 16
-        //     return v3
-        // }
-        //
         // After constructing this IR, we set the value of v1 to 2^8.
         // The expected return afterwards should be v2.
-        let main_id = Id::test_new(0);
-
-        // Compiling main
-        let mut builder = FunctionBuilder::new("main".into(), main_id);
-        let v0 = builder.add_parameter(Type::unsigned(16));
-        let v1 = builder.add_parameter(Type::unsigned(16));
-
-        // Note that this constant guarantees that `v0/constant < 2^8`. We then do not need to truncate the result.
-        let constant = 2_u128.pow(8);
-        let constant = builder.numeric_constant(constant, Type::field());
-
-        let v2 = builder.insert_binary(v0, BinaryOp::Div, v1);
-        let v3 = builder.insert_truncate(v2, 8, 16);
-        builder.terminate_with_return(vec![v3]);
-
-        let mut ssa = builder.finish();
+        let src = "
+            acir(inline) fn main f0 {
+              b0(v0: u16, v1: u16):
+                v2 = div v0, v1
+                v3 = truncate v2 to 8 bits, max_bit_size: 16
+                return v3
+            }
+            ";
+        let mut ssa = Ssa::from_str(src).unwrap();
         let main = ssa.main_mut();
+
         let instructions = main.dfg[main.entry_block()].instructions();
         assert_eq!(instructions.len(), 2); // The final return is not counted
 
-        // Expected output:
-        //
-        // fn main f0 {
-        //   b0(Field 2: Field):
-        //     return Field 9
-        // }
-        main.dfg.set_value_from_id(v1, constant);
+        let v1 = main.parameters()[1];
 
-        let ssa = ssa.fold_constants();
-        let main = ssa.main();
+        // Note that this constant guarantees that `v0/constant < 2^8`. We then do not need to truncate the result.
+        let constant = 2_u128.pow(8);
+        let constant = main.dfg.make_constant(constant.into(), NumericType::unsigned(16));
 
-        println!("{ssa}");
+        main.dfg.set_value_from_id(v1, constant);
 
-        let instructions = main.dfg[main.entry_block()].instructions();
-        assert_eq!(instructions.len(), 1);
-        let instruction = &main.dfg[instructions[0]];
+        let expected = "
+            acir(inline) fn main f0 {
+              b0(v0: u16, v1: u16):
+                v3 = div v0, u16 256
+                return v3
+            }
+            ";
 
-        assert_eq!(
-            instruction,
-            &Instruction::Binary(Binary { lhs: v0, operator: BinaryOp::Div, rhs: constant })
-        );
+        let ssa = ssa.fold_constants();
+        assert_normalized_ssa_equals(ssa, expected);
     }
 
     #[test]
     fn non_redundant_truncation() {
-        // fn main f0 {
-        //   b0(v0: u16, v1: u16):
-        //     v2 = div v0, v1
-        //     v3 = truncate v2 to 8 bits, max_bit_size: 16
-        //     return v3
-        // }
-        //
         // After constructing this IR, we set the value of v1 to 2^8 - 1.
         // This should not result in the truncation being removed.
-        let main_id = Id::test_new(0);
+        let src = "
+            acir(inline) fn main f0 {
+              b0(v0: u16, v1: u16):
+                v2 = div v0, v1
+                v3 = truncate v2 to 8 bits, max_bit_size: 16
+                return v3
+            }
+            ";
+        let mut ssa = Ssa::from_str(src).unwrap();
+        let main = ssa.main_mut();
 
-        // Compiling main
-        let mut builder = FunctionBuilder::new("main".into(), main_id);
-        let v0 = builder.add_parameter(Type::unsigned(16));
-        let v1 = builder.add_parameter(Type::unsigned(16));
+        let instructions = main.dfg[main.entry_block()].instructions();
+        assert_eq!(instructions.len(), 2); // The final return is not counted
+
+        let v1 = main.parameters()[1];
 
         // Note that this constant does not guarantee that `v0/constant < 2^8`. We must then truncate the result.
         let constant = 2_u128.pow(8) - 1;
-        let constant = builder.numeric_constant(constant, Type::field());
-
-        let v2 = builder.insert_binary(v0, BinaryOp::Div, v1);
-        let v3 = builder.insert_truncate(v2, 8, 16);
-        builder.terminate_with_return(vec![v3]);
-
-        let mut ssa = builder.finish();
-        let main = ssa.main_mut();
-        let instructions = main.dfg[main.entry_block()].instructions();
-        assert_eq!(instructions.len(), 2); // The final return is not counted
+        let constant = main.dfg.make_constant(constant.into(), NumericType::unsigned(16));
 
-        // Expected output:
-        //
-        // fn main f0 {
-        //   b0(v0: u16, Field 255: Field):
-        //      v6 = div v0, Field 255
-        //      v7 = truncate v6 to 8 bits, max_bit_size: 16
-        //      return v7
-        // }
         main.dfg.set_value_from_id(v1, constant);
 
-        let ssa = ssa.fold_constants();
-        let main = ssa.main();
-
-        let instructions = main.dfg[main.entry_block()].instructions();
-        assert_eq!(instructions.len(), 2);
+        let expected = "
+            acir(inline) fn main f0 {
+              b0(v0: u16, v1: u16):
+                v3 = div v0, u16 255
+                v4 = truncate v3 to 8 bits, max_bit_size: 16
+                return v4
+            }
+            ";
 
-        assert_eq!(
-            &main.dfg[instructions[0]],
-            &Instruction::Binary(Binary { lhs: v0, operator: BinaryOp::Div, rhs: constant })
-        );
-        assert_eq!(
-            &main.dfg[instructions[1]],
-            &Instruction::Truncate { value: ValueId::test_new(6), bit_size: 8, max_bit_size: 16 }
-        );
+        let ssa = ssa.fold_constants();
+        assert_normalized_ssa_equals(ssa, expected);
     }
 
     #[test]
     fn arrays_elements_are_updated() {
-        // fn main f0 {
-        //   b0(v0: Field):
-        //     v1 = add v0, Field 1
-        //     return [v1]
-        // }
-        //
         // After constructing this IR, we run constant folding with no expected benefit, but to
         // ensure that all new values ids are correctly propagated.
-        let main_id = Id::test_new(0);
-
-        // Compiling main
-        let mut builder = FunctionBuilder::new("main".into(), main_id);
-        let v0 = builder.add_parameter(Type::field());
-        let one = builder.field_constant(1u128);
-        let v1 = builder.insert_binary(v0, BinaryOp::Add, one);
-
-        let array_type = Type::Array(Arc::new(vec![Type::field()]), 1);
-        let arr = builder.current_function.dfg.make_array(vec![v1].into(), array_type);
-        builder.terminate_with_return(vec![arr]);
-
-        let ssa = builder.finish().fold_constants();
-        let main = ssa.main();
-        let entry_block_id = main.entry_block();
-        let entry_block = &main.dfg[entry_block_id];
-        assert_eq!(entry_block.instructions().len(), 1);
-        let new_add_instr = entry_block.instructions().first().unwrap();
-        let new_add_instr_result = main.dfg.instruction_results(*new_add_instr)[0];
-        assert_ne!(new_add_instr_result, v1);
-
-        let return_value_id = match entry_block.unwrap_terminator() {
-            TerminatorInstruction::Return { return_values, .. } => return_values[0],
-            _ => unreachable!("Should have terminator instruction"),
-        };
-        let return_element = match &main.dfg[return_value_id] {
-            Value::Array { array, .. } => array[0],
-            _ => unreachable!("Return type should be array"),
-        };
-        // The return element is expected to refer to the new add instruction result.
-        assert_eq!(main.dfg.resolve(new_add_instr_result), main.dfg.resolve(return_element));
+        let src = "
+            acir(inline) fn main f0 {
+              b0(v0: Field):
+                v2 = add v0, Field 1
+                v3 = make_array [v2] : [Field; 1]
+                return v3
+            }
+            ";
+        let ssa = Ssa::from_str(src).unwrap();
+        let ssa = ssa.fold_constants();
+        assert_normalized_ssa_equals(ssa, src);
     }
 
     #[test]
     fn instruction_deduplication() {
-        // fn main f0 {
-        //   b0(v0: u16):
-        //     v1 = cast v0 as u32
-        //     v2 = cast v0 as u32
-        //     constrain v1 v2
-        // }
-        //
         // After constructing this IR, we run constant folding which should replace the second cast
         // with a reference to the results to the first. This then allows us to optimize away
         // the constrain instruction as both inputs are known to be equal.
         //
         // The first cast instruction is retained and will be removed in the dead instruction elimination pass.
-        let main_id = Id::test_new(0);
-
-        // Compiling main
-        let mut builder = FunctionBuilder::new("main".into(), main_id);
-        let v0 = builder.add_parameter(Type::unsigned(16));
+        let src = "
+            acir(inline) fn main f0 {
+              b0(v0: u16):
+                v1 = cast v0 as u32
+                v2 = cast v0 as u32
+                constrain v1 == v2
+                return
+            }
+            ";
+        let expected = "
+            acir(inline) fn main f0 {
+              b0(v0: u16):
+                v1 = cast v0 as u32
+                return
+            }
+            ";
+        let ssa = Ssa::from_str(src).unwrap();
+        let ssa = ssa.fold_constants();
+        assert_normalized_ssa_equals(ssa, expected);
+    }
 
-        let v1 = builder.insert_cast(v0, Type::unsigned(32));
-        let v2 = builder.insert_cast(v0, Type::unsigned(32));
-        builder.insert_constrain(v1, v2, None);
+    #[test]
+    fn constant_index_array_access_deduplication() {
+        // After constructing this IR, we run constant folding which should replace the second constant-index array get
+        // with a reference to the results to the first. This then allows us to optimize away
+        // the constrain instruction as both inputs are known to be equal.
+        let src = "
+            acir(inline) fn main f0 {
+              b0(v0: [Field; 4], v1: u32, v2: bool, v3: bool):
+                enable_side_effects v2
+                v4 = array_get v0, index u32 0 -> Field
+                v5 = array_get v0, index v1 -> Field
+                enable_side_effects v3
+                v6 = array_get v0, index u32 0 -> Field
+                v7 = array_get v0, index v1 -> Field
+                constrain v4 == v6
+                return
+            }
+            ";
+        let expected = "
+            acir(inline) fn main f0 {
+              b0(v0: [Field; 4], v1: u32, v2: u1, v3: u1):
+                enable_side_effects v2
+                v5 = array_get v0, index u32 0 -> Field
+                v6 = array_get v0, index v1 -> Field
+                enable_side_effects v3
+                v7 = array_get v0, index v1 -> Field
+                return
+            }
+            ";
 
-        let mut ssa = builder.finish();
-        let main = ssa.main_mut();
-        let instructions = main.dfg[main.entry_block()].instructions();
-        assert_eq!(instructions.len(), 3);
+        let ssa = Ssa::from_str(src).unwrap();
+        let ssa = ssa.fold_constants();
+        assert_normalized_ssa_equals(ssa, expected);
+    }
 
-        // Expected output:
+    #[test]
+    fn constraint_decomposition() {
+        // When constructing this IR, we should automatically decompose the constraint to be in terms of `v0`, `v1` and `v2`.
         //
-        // fn main f0 {
-        //   b0(v0: u16):
-        //     v1 = cast v0 as u32
-        // }
+        // The mul instructions are retained and will be removed in the dead instruction elimination pass.
+        let src = "
+            acir(inline) fn main f0 {
+              b0(v0: u1, v1: u1, v2: u1):
+                v3 = mul v0, v1
+                v4 = not v2
+                v5 = mul v3, v4
+                constrain v5 == u1 1
+                return
+            }
+            ";
+        let ssa = Ssa::from_str(src).unwrap();
+
+        let expected = "
+            acir(inline) fn main f0 {
+              b0(v0: u1, v1: u1, v2: u1):
+                v3 = mul v0, v1
+                v4 = not v2
+                v5 = mul v3, v4
+                constrain v0 == u1 1
+                constrain v1 == u1 1
+                constrain v2 == u1 0
+                return
+            }
+            ";
+        assert_normalized_ssa_equals(ssa, expected);
+    }
+
+    // Regression for #4600
+    #[test]
+    fn array_get_regression() {
+        // We want to make sure after constant folding both array_gets remain since they are
+        // under different enable_side_effects_if contexts and thus one may be disabled while
+        // the other is not. If one is removed, it is possible e.g. v4 is replaced with v2 which
+        // is disabled (only gets from index 0) and thus returns the wrong result.
+        let src = "
+        acir(inline) fn main f0 {
+          b0(v0: u1, v1: u64):
+            enable_side_effects v0
+            v4 = make_array [Field 0, Field 1] : [Field; 2]
+            v5 = array_get v4, index v1 -> Field
+            v6 = not v0
+            enable_side_effects v6
+            v7 = array_get v4, index v1 -> Field
+            return
+        }
+        ";
+        let ssa = Ssa::from_str(src).unwrap();
+
+        // Expected output is unchanged
         let ssa = ssa.fold_constants();
+        assert_normalized_ssa_equals(ssa, src);
+    }
+
+    #[test]
+    fn deduplicate_instructions_with_predicates() {
+        let src = "
+            acir(inline) fn main f0 {
+              b0(v0: u1, v1: u1, v2: [Field; 2]):
+                enable_side_effects v0
+                v6 = array_get v2, index u32 0 -> u32
+                v7 = array_set v2, index u32 1, value u32 2
+                v8 = array_get v7, index u32 0 -> u32
+                constrain v6 == v8
+                enable_side_effects v1
+                v9 = array_get v2, index u32 0 -> u32
+                v10 = array_set v2, index u32 1, value u32 2
+                v11 = array_get v10, index u32 0 -> u32
+                constrain v9 == v11
+                enable_side_effects v0
+                v12 = array_get v2, index u32 0 -> u32
+                v13 = array_set v2, index u32 1, value u32 2
+                v14 = array_get v13, index u32 0 -> u32
+                constrain v12 == v14
+                return
+            }
+            ";
+        let ssa = Ssa::from_str(src).unwrap();
+
         let main = ssa.main();
         let instructions = main.dfg[main.entry_block()].instructions();
+        assert_eq!(instructions.len(), 15);
 
-        assert_eq!(instructions.len(), 1);
-        let instruction = &main.dfg[instructions[0]];
+        let expected = "
+            acir(inline) fn main f0 {
+              b0(v0: u1, v1: u1, v2: [Field; 2]):
+                enable_side_effects v0
+                v4 = array_get v2, index u32 0 -> u32
+                v7 = array_set v2, index u32 1, value u32 2
+                v8 = array_get v7, index u32 0 -> u32
+                constrain v4 == v8
+                enable_side_effects v1
+                v9 = array_set v2, index u32 1, value u32 2
+                v10 = array_get v9, index u32 0 -> u32
+                constrain v4 == v10
+                enable_side_effects v0
+                return
+            }
+            ";
 
-        assert_eq!(instruction, &Instruction::Cast(v0, Type::unsigned(32)));
+        let ssa = ssa.fold_constants_using_constraints();
+        assert_normalized_ssa_equals(ssa, expected);
     }
 
     #[test]
-    fn constant_index_array_access_deduplication() {
+    fn constant_array_deduplication() {
         // fn main f0 {
-        //   b0(v0: [Field; 4], v1: u32, v2: bool, v3: bool):
-        //     enable_side_effects v2
-        //     v4 = array_get v0 u32 0
-        //     v5 = array_get v0 v1
-        //     enable_side_effects v3
-        //     v6 = array_get v0 u32 0
-        //     v7 = array_get v0 v1
-        //     constrain v4 v6
+        //   b0(v0: u64):
+        //     v1 = make_array [v0, u64 0, u64 0, u64 0, u64 0, u64 0, u64 0, u64 0, u64 0, u64 0, u64 0, u64 0, u64 0, u64 0, u64 0, u64 0, u64 0, u64 0, u64 0, u64 0, u64 0, u64 0, u64 0, u64 0, u64 0]
+        //     v2 = make_array [v0, u64 0, u64 0, u64 0, u64 0, u64 0, u64 0, u64 0, u64 0, u64 0, u64 0, u64 0, u64 0, u64 0, u64 0, u64 0, u64 0, u64 0, u64 0, u64 0, u64 0, u64 0, u64 0, u64 0, u64 0]
+        //     v5 = call keccakf1600(v1)
+        //     v6 = call keccakf1600(v2)
         // }
-        //
-        // After constructing this IR, we run constant folding which should replace the second constant-index array get
-        // with a reference to the results to the first. This then allows us to optimize away
-        // the constrain instruction as both inputs are known to be equal.
-        //
+        // Here we're checking a situation where two identical arrays are being initialized twice and being assigned separate `ValueId`s.
+        // This would result in otherwise identical instructions not being deduplicated.
         let main_id = Id::test_new(0);
 
         // Compiling main
         let mut builder = FunctionBuilder::new("main".into(), main_id);
+        let v0 = builder.add_parameter(Type::unsigned(64));
+        let zero = builder.numeric_constant(0u128, NumericType::unsigned(64));
+        let typ = Type::Array(Arc::new(vec![Type::unsigned(64)]), 25);
 
-        let v0 = builder.add_parameter(Type::Array(Arc::new(vec![Type::field()]), 4));
-        let v1 = builder.add_parameter(Type::unsigned(32));
-        let v2 = builder.add_parameter(Type::unsigned(1));
-        let v3 = builder.add_parameter(Type::unsigned(1));
+        let array_contents = im::vector![
+            v0, zero, zero, zero, zero, zero, zero, zero, zero, zero, zero, zero, zero, zero, zero,
+            zero, zero, zero, zero, zero, zero, zero, zero, zero, zero,
+        ];
+        let array1 = builder.insert_make_array(array_contents.clone(), typ.clone());
+        let array2 = builder.insert_make_array(array_contents, typ.clone());
 
-        let zero = builder.numeric_constant(FieldElement::zero(), Type::length_type());
+        assert_ne!(array1, array2, "arrays were not assigned different value ids");
 
-        builder.insert_enable_side_effects_if(v2);
-        let v4 = builder.insert_array_get(v0, zero, Type::field());
-        let _v5 = builder.insert_array_get(v0, v1, Type::field());
+        let keccakf1600 =
+            builder.import_intrinsic("keccakf1600").expect("keccakf1600 intrinsic should exist");
+        let _v10 = builder.insert_call(keccakf1600, vec![array1], vec![typ.clone()]);
+        let _v11 = builder.insert_call(keccakf1600, vec![array2], vec![typ.clone()]);
+        builder.terminate_with_return(Vec::new());
 
-        builder.insert_enable_side_effects_if(v3);
-        let v6 = builder.insert_array_get(v0, zero, Type::field());
-        let _v7 = builder.insert_array_get(v0, v1, Type::field());
-
-        builder.insert_constrain(v4, v6, None);
-
-        let ssa = builder.finish();
+        let mut ssa = builder.finish();
+        ssa.normalize_ids();
 
         println!("{ssa}");
 
         let main = ssa.main();
         let instructions = main.dfg[main.entry_block()].instructions();
-        assert_eq!(instructions.len(), 7);
+        let starting_instruction_count = instructions.len();
+        assert_eq!(starting_instruction_count, 4);
 
-        // Expected output:
-        //
         // fn main f0 {
-        //   b0(v0: [Field; 4], v1: u32, v2: bool, v3: bool):
-        //     enable_side_effects v2
-        //     v10 = array_get v0 u32 0
-        //     v11 = array_get v0 v1
-        //     enable_side_effects v3
-        //     v12 = array_get v0 v1
+        //   b0(v0: u64):
+        //     v1 = make_array [v0, u64 0, u64 0, u64 0, u64 0, u64 0, u64 0, u64 0, u64 0, u64 0, u64 0, u64 0, u64 0, u64 0, u64 0, u64 0, u64 0, u64 0, u64 0, u64 0, u64 0, u64 0, u64 0, u64 0, u64 0]
+        //     inc_rc v1
+        //     v5 = call keccakf1600(v1)
         // }
         let ssa = ssa.fold_constants();
 
@@ -642,203 +1193,439 @@ mod test {
 
         let main = ssa.main();
         let instructions = main.dfg[main.entry_block()].instructions();
-
-        assert_eq!(instructions.len(), 5);
+        let ending_instruction_count = instructions.len();
+        assert_eq!(ending_instruction_count, 3);
     }
 
     #[test]
-    fn constraint_decomposition() {
+    fn deduplicate_across_blocks() {
         // fn main f0 {
-        //   b0(v0: u1, v1: u1, v2: u1):
-        //     v3 = mul v0 v1
-        //     v4 = not v2
-        //     v5 = mul v3 v4
-        //     constrain v4 u1 1
+        //   b0(v0: u1):
+        //     v1 = not v0
+        //     jmp b1()
+        //   b1():
+        //     v2 = not v0
+        //     return v2
         // }
-        //
-        // When constructing this IR, we should automatically decompose the constraint to be in terms of `v0`, `v1` and `v2`.
-        //
-        // The mul instructions are retained and will be removed in the dead instruction elimination pass.
         let main_id = Id::test_new(0);
 
         // Compiling main
         let mut builder = FunctionBuilder::new("main".into(), main_id);
-        let v0 = builder.add_parameter(Type::bool());
-        let v1 = builder.add_parameter(Type::bool());
-        let v2 = builder.add_parameter(Type::bool());
+        let b1 = builder.insert_block();
 
-        let v3 = builder.insert_binary(v0, BinaryOp::Mul, v1);
-        let v4 = builder.insert_not(v2);
-        let v5 = builder.insert_binary(v3, BinaryOp::Mul, v4);
+        let v0 = builder.add_parameter(Type::bool());
+        let _v1 = builder.insert_not(v0);
+        builder.terminate_with_jmp(b1, Vec::new());
 
-        // This constraint is automatically decomposed when it is inserted.
-        let v_true = builder.numeric_constant(true, Type::bool());
-        builder.insert_constrain(v5, v_true, None);
+        builder.switch_to_block(b1);
+        let v2 = builder.insert_not(v0);
+        builder.terminate_with_return(vec![v2]);
 
-        let v_false = builder.numeric_constant(false, Type::bool());
+        let ssa = builder.finish();
+        let main = ssa.main();
+        assert_eq!(main.dfg[main.entry_block()].instructions().len(), 1);
+        assert_eq!(main.dfg[b1].instructions().len(), 1);
 
         // Expected output:
         //
         // fn main f0 {
-        //   b0(v0: u1, v1: u1, v2: u1):
-        //     v3 = mul v0 v1
-        //     v4 = not v2
-        //     v5 = mul v3 v4
-        //     constrain v0 u1 1
-        //     constrain v1 u1 1
-        //     constrain v2 u1 0
+        //   b0(v0: u1):
+        //     v1 = not v0
+        //     jmp b1()
+        //   b1():
+        //     return v1
         // }
-
-        let ssa = builder.finish();
+        let ssa = ssa.fold_constants_using_constraints();
         let main = ssa.main();
-        let instructions = main.dfg[main.entry_block()].instructions();
+        assert_eq!(main.dfg[main.entry_block()].instructions().len(), 1);
+        assert_eq!(main.dfg[b1].instructions().len(), 0);
+    }
 
-        assert_eq!(instructions.len(), 6);
+    #[test]
+    fn deduplicate_across_non_dominated_blocks() {
+        let src = "
+            brillig(inline) fn main f0 {
+              b0(v0: u32):
+                v2 = lt u32 1000, v0
+                jmpif v2 then: b1, else: b2
+              b1():
+                v4 = shl v0, u32 1
+                v5 = lt v0, v4
+                constrain v5 == u1 1
+                jmp b2()
+              b2():
+                v7 = lt u32 1000, v0
+                jmpif v7 then: b3, else: b4
+              b3():
+                v8 = shl v0, u32 1
+                v9 = lt v0, v8
+                constrain v9 == u1 1
+                jmp b4()
+              b4():
+                return
+            }
+        ";
+        let ssa = Ssa::from_str(src).unwrap();
+
+        // v4 has been hoisted, although:
+        // - v5 has not yet been removed since it was encountered earlier in the program
+        // - v8 hasn't been recognized as a duplicate of v6 yet since they still reference v4 and
+        //   v5 respectively
+        let expected = "
+            brillig(inline) fn main f0 {
+              b0(v0: u32):
+                v2 = lt u32 1000, v0
+                v4 = shl v0, u32 1
+                jmpif v2 then: b1, else: b2
+              b1():
+                v5 = shl v0, u32 1
+                v6 = lt v0, v5
+                constrain v6 == u1 1
+                jmp b2()
+              b2():
+                jmpif v2 then: b3, else: b4
+              b3():
+                v8 = lt v0, v4
+                constrain v8 == u1 1
+                jmp b4()
+              b4():
+                return
+            }
+        ";
 
-        assert_eq!(
-            main.dfg[instructions[0]],
-            Instruction::Binary(Binary { lhs: v0, operator: BinaryOp::Mul, rhs: v1 })
-        );
-        assert_eq!(main.dfg[instructions[1]], Instruction::Not(v2));
-        assert_eq!(
-            main.dfg[instructions[2]],
-            Instruction::Binary(Binary { lhs: v3, operator: BinaryOp::Mul, rhs: v4 })
-        );
-        assert_eq!(main.dfg[instructions[3]], Instruction::Constrain(v0, v_true, None));
-        assert_eq!(main.dfg[instructions[4]], Instruction::Constrain(v1, v_true, None));
-        assert_eq!(main.dfg[instructions[5]], Instruction::Constrain(v2, v_false, None));
+        let ssa = ssa.fold_constants_using_constraints();
+        assert_normalized_ssa_equals(ssa, expected);
     }
 
-    // Regression for #4600
     #[test]
-    fn array_get_regression() {
-        // fn main f0 {
-        //   b0(v0: u1, v1: u64):
-        //     enable_side_effects_if v0
-        //     v2 = array_get [Field 0, Field 1], index v1
-        //     v3 = not v0
-        //     enable_side_effects_if v3
-        //     v4 = array_get [Field 0, Field 1], index v1
-        // }
-        //
-        // We want to make sure after constant folding both array_gets remain since they are
-        // under different enable_side_effects_if contexts and thus one may be disabled while
-        // the other is not. If one is removed, it is possible e.g. v4 is replaced with v2 which
-        // is disabled (only gets from index 0) and thus returns the wrong result.
-        let main_id = Id::test_new(0);
+    fn inlines_brillig_call_without_arguments() {
+        let src = "
+            acir(inline) fn main f0 {
+              b0():
+                v0 = call f1() -> Field
+                return v0
+            }
 
-        // Compiling main
-        let mut builder = FunctionBuilder::new("main".into(), main_id);
-        let v0 = builder.add_parameter(Type::bool());
-        let v1 = builder.add_parameter(Type::unsigned(64));
+            brillig(inline) fn one f1 {
+              b0():
+                v0 = add Field 2, Field 3
+                return v0
+            }
+            ";
+        let ssa = Ssa::from_str(src).unwrap();
+        let brillig = ssa.to_brillig(false);
+
+        let expected = "
+            acir(inline) fn main f0 {
+              b0():
+                return Field 5
+            }
+            ";
+        let ssa = ssa.fold_constants_with_brillig(&brillig);
+        assert_normalized_ssa_equals(ssa, expected);
+    }
 
-        builder.insert_enable_side_effects_if(v0);
+    #[test]
+    fn inlines_brillig_call_with_two_field_arguments() {
+        let src = "
+            acir(inline) fn main f0 {
+              b0():
+                v0 = call f1(Field 2, Field 3) -> Field
+                return v0
+            }
 
-        let zero = builder.field_constant(0u128);
-        let one = builder.field_constant(1u128);
+            brillig(inline) fn one f1 {
+              b0(v0: Field, v1: Field):
+                v2 = add v0, v1
+                return v2
+            }
+            ";
+        let ssa = Ssa::from_str(src).unwrap();
+        let brillig = ssa.to_brillig(false);
+
+        let expected = "
+            acir(inline) fn main f0 {
+              b0():
+                return Field 5
+            }
+            ";
+        let ssa = ssa.fold_constants_with_brillig(&brillig);
+        assert_normalized_ssa_equals(ssa, expected);
+    }
 
-        let typ = Type::Array(Arc::new(vec![Type::field()]), 2);
-        let array = builder.array_constant(vec![zero, one].into(), typ);
+    #[test]
+    fn inlines_brillig_call_with_two_i32_arguments() {
+        let src = "
+            acir(inline) fn main f0 {
+              b0():
+                v0 = call f1(i32 2, i32 3) -> i32
+                return v0
+            }
 
-        let _v2 = builder.insert_array_get(array, v1, Type::field());
-        let v3 = builder.insert_not(v0);
+            brillig(inline) fn one f1 {
+              b0(v0: i32, v1: i32):
+                v2 = add v0, v1
+                return v2
+            }
+            ";
+        let ssa = Ssa::from_str(src).unwrap();
+        let brillig = ssa.to_brillig(false);
+
+        let expected = "
+            acir(inline) fn main f0 {
+              b0():
+                return i32 5
+            }
+            ";
+        let ssa = ssa.fold_constants_with_brillig(&brillig);
+        assert_normalized_ssa_equals(ssa, expected);
+    }
 
-        builder.insert_enable_side_effects_if(v3);
-        let _v4 = builder.insert_array_get(array, v1, Type::field());
+    #[test]
+    fn inlines_brillig_call_with_array_return() {
+        let src = "
+            acir(inline) fn main f0 {
+              b0():
+                v0 = call f1(Field 2, Field 3, Field 4) -> [Field; 3]
+                return v0
+            }
 
-        // Expected output is unchanged
-        let ssa = builder.finish();
-        let main = ssa.main();
-        let instructions = main.dfg[main.entry_block()].instructions();
-        let starting_instruction_count = instructions.len();
-        assert_eq!(starting_instruction_count, 5);
+            brillig(inline) fn one f1 {
+              b0(v0: Field, v1: Field, v2: Field):
+                v3 = make_array [v0, v1, v2] : [Field; 3]
+                return v3
+            }
+            ";
+        let ssa = Ssa::from_str(src).unwrap();
+        let brillig = ssa.to_brillig(false);
+
+        let expected = "
+            acir(inline) fn main f0 {
+              b0():
+                v3 = make_array [Field 2, Field 3, Field 4] : [Field; 3]
+                return v3
+            }
+            ";
+        let ssa = ssa.fold_constants_with_brillig(&brillig);
+        assert_normalized_ssa_equals(ssa, expected);
+    }
 
-        let ssa = ssa.fold_constants();
-        let main = ssa.main();
-        let instructions = main.dfg[main.entry_block()].instructions();
-        let ending_instruction_count = instructions.len();
-        assert_eq!(starting_instruction_count, ending_instruction_count);
+    #[test]
+    fn inlines_brillig_call_with_composite_array_return() {
+        let src = "
+            acir(inline) fn main f0 {
+              b0():
+                v0 = call f1(Field 2, i32 3, Field 4, i32 5) -> [(Field, i32); 2]
+                return v0
+            }
+
+            brillig(inline) fn one f1 {
+              b0(v0: Field, v1: i32, v2: i32, v3: Field):
+                v4 = make_array [v0, v1, v2, v3] : [(Field, i32); 2]
+                return v4
+            }
+            ";
+        let ssa = Ssa::from_str(src).unwrap();
+        let brillig = ssa.to_brillig(false);
+
+        let expected = "
+            acir(inline) fn main f0 {
+              b0():
+                v4 = make_array [Field 2, i32 3, Field 4, i32 5] : [(Field, i32); 2]
+                return v4
+            }
+            ";
+        let ssa = ssa.fold_constants_with_brillig(&brillig);
+        assert_normalized_ssa_equals(ssa, expected);
     }
 
     #[test]
-    fn deduplicate_instructions_with_predicates() {
-        // fn main f0 {
-        //   b0(v0: bool, v1: bool, v2: [u32; 2]):
-        //     enable_side_effects v0
-        //     v3 = array_get v2, index u32 0
-        //     v4 = array_set v2, index u32 1, value: u32 2
-        //     v5 = array_get v4, index u32 0
-        //     constrain_eq v3, v5
-        //     enable_side_effects v1
-        //     v6 = array_get v2, index u32 0
-        //     v7 = array_set v2, index u32 1, value: u32 2
-        //     v8 = array_get v7, index u32 0
-        //     constrain_eq v6, v8
-        //     enable_side_effects v0
-        //     v9 = array_get v2, index u32 0
-        //     v10 = array_set v2, index u32 1, value: u32 2
-        //     v11 = array_get v10, index u32 0
-        //     constrain_eq v9, v11
-        // }
-        let main_id = Id::test_new(0);
+    fn inlines_brillig_call_with_array_arguments() {
+        let src = "
+            acir(inline) fn main f0 {
+              b0():
+                v0 = make_array [Field 2, Field 3] : [Field; 2]
+                v1 = call f1(v0) -> Field
+                return v1
+            }
 
-        // Compiling main
-        let mut builder = FunctionBuilder::new("main".into(), main_id);
+            brillig(inline) fn one f1 {
+              b0(v0: [Field; 2]):
+                inc_rc v0
+                v2 = array_get v0, index u32 0 -> Field
+                v4 = array_get v0, index u32 1 -> Field
+                v5 = add v2, v4
+                dec_rc v0
+                return v5
+            }
+            ";
+        let ssa = Ssa::from_str(src).unwrap();
+        let brillig = ssa.to_brillig(false);
+
+        let expected = "
+            acir(inline) fn main f0 {
+              b0():
+                v2 = make_array [Field 2, Field 3] : [Field; 2]
+                return Field 5
+            }
+            ";
+        let ssa = ssa.fold_constants_with_brillig(&brillig);
+        assert_normalized_ssa_equals(ssa, expected);
+    }
 
-        let v0 = builder.add_parameter(Type::bool());
-        let v1 = builder.add_parameter(Type::bool());
-        let v2 = builder.add_parameter(Type::Array(Arc::new(vec![Type::field()]), 2));
-
-        let zero = builder.numeric_constant(0u128, Type::length_type());
-        let one = builder.numeric_constant(1u128, Type::length_type());
-        let two = builder.numeric_constant(2u128, Type::length_type());
-
-        builder.insert_enable_side_effects_if(v0);
-        let v3 = builder.insert_array_get(v2, zero, Type::length_type());
-        let v4 = builder.insert_array_set(v2, one, two);
-        let v5 = builder.insert_array_get(v4, zero, Type::length_type());
-        builder.insert_constrain(v3, v5, None);
-
-        builder.insert_enable_side_effects_if(v1);
-        let v6 = builder.insert_array_get(v2, zero, Type::length_type());
-        let v7 = builder.insert_array_set(v2, one, two);
-        let v8 = builder.insert_array_get(v7, zero, Type::length_type());
-        builder.insert_constrain(v6, v8, None);
-
-        // We expect all these instructions after the 'enable side effects' instruction to be removed.
-        builder.insert_enable_side_effects_if(v0);
-        let v9 = builder.insert_array_get(v2, zero, Type::length_type());
-        let v10 = builder.insert_array_set(v2, one, two);
-        let v11 = builder.insert_array_get(v10, zero, Type::length_type());
-        builder.insert_constrain(v9, v11, None);
+    #[test]
+    fn does_not_use_cached_constrain_in_block_that_is_not_dominated() {
+        let src = "
+            brillig(inline) fn main f0 {
+              b0(v0: Field, v1: Field):
+                v3 = eq v0, Field 0
+                jmpif v3 then: b1, else: b2
+              b1():
+                v5 = eq v1, Field 1
+                constrain v1 == Field 1
+                jmp b2()
+              b2():
+                v6 = eq v1, Field 0
+                constrain v1 == Field 0
+                return
+            }
+            ";
+        let ssa = Ssa::from_str(src).unwrap();
+        let ssa = ssa.fold_constants_using_constraints();
+        assert_normalized_ssa_equals(ssa, src);
+    }
 
-        let ssa = builder.finish();
-        println!("{ssa}");
+    #[test]
+    fn does_not_hoist_constrain_to_common_ancestor() {
+        let src = "
+            brillig(inline) fn main f0 {
+              b0(v0: Field, v1: Field):
+                v3 = eq v0, Field 0
+                jmpif v3 then: b1, else: b2
+              b1():
+                constrain v1 == Field 1
+                jmp b2()
+              b2():
+                jmpif v0 then: b3, else: b4
+              b3():
+                constrain v1 == Field 1 // This was incorrectly hoisted to b0 but this condition is not valid when going b0 -> b2 -> b4
+                jmp b4()
+              b4():
+                return
+            }
+            ";
+        let ssa = Ssa::from_str(src).unwrap();
+        let ssa = ssa.fold_constants_using_constraints();
+        assert_normalized_ssa_equals(ssa, src);
+    }
 
-        let main = ssa.main();
-        let instructions = main.dfg[main.entry_block()].instructions();
-        assert_eq!(instructions.len(), 15);
+    #[test]
+    fn does_not_hoist_sub_to_common_ancestor() {
+        let src = "
+            acir(inline) fn main f0 {
+              b0(v0: u32):
+                v2 = eq v0, u32 0
+                jmpif v2 then: b4, else: b1
+              b1():
+                jmpif v0 then: b3, else: b2
+              b2():
+                jmp b5()
+              b3():
+                v4 = sub v0, u32 1 // We can't hoist this because v0 is zero here and it will lead to an underflow
+                jmp b5()
+              b4():
+                v5 = sub v0, u32 1
+                jmp b5()
+              b5():
+                return
+            }
+            ";
+        let ssa = Ssa::from_str(src).unwrap();
+        let ssa = ssa.fold_constants_using_constraints();
+        assert_normalized_ssa_equals(ssa, src);
+    }
 
-        // Expected output:
-        //
-        // fn main f0 {
-        //   b0(v0: bool, v1: bool, v2: [Field; 2]):
-        //     enable_side_effects v0
-        //     v3 = array_get v2, index Field 0
-        //     v4 = array_set v2, index Field 1, value: Field 2
-        //     v5 = array_get v4, index Field 0
-        //     constrain_eq v3, v5
-        //     enable_side_effects v1
-        //     v7 = array_set v2, index Field 1, value: Field 2
-        //     v8 = array_get v7, index Field 0
-        //     constrain_eq v3, v8
-        //     enable_side_effects v0
-        // }
+    #[test]
+    fn deduplicates_side_effecting_intrinsics() {
+        let src = "
+        // After EnableSideEffectsIf removal:
+        acir(inline) fn main f0 {
+          b0(v0: Field, v1: Field, v2: u1):
+            v4 = call is_unconstrained() -> u1
+            v7 = call to_be_radix(v0, u32 256) -> [u8; 1]    // `a.to_be_radix(256)`;
+            inc_rc v7
+            v8 = call to_be_radix(v0, u32 256) -> [u8; 1]    // duplicate load of `a`
+            inc_rc v8
+            v9 = cast v2 as Field                            // `if c { a.to_be_radix(256) }`
+            v10 = mul v0, v9                                 // attaching `c` to `a`
+            v11 = call to_be_radix(v10, u32 256) -> [u8; 1]  // calling `to_radix(c * a)`
+            inc_rc v11
+            enable_side_effects v2                           // side effect var for `c` shifted down by removal
+            return
+        }
+        ";
+        let ssa = Ssa::from_str(src).unwrap();
+        let expected = "
+        acir(inline) fn main f0 {
+          b0(v0: Field, v1: Field, v2: u1):
+            v4 = call is_unconstrained() -> u1
+            v7 = call to_be_radix(v0, u32 256) -> [u8; 1]
+            inc_rc v7
+            inc_rc v7
+            v8 = cast v2 as Field
+            v9 = mul v0, v8
+            v10 = call to_be_radix(v9, u32 256) -> [u8; 1]
+            inc_rc v10
+            enable_side_effects v2
+            return
+        }
+        ";
         let ssa = ssa.fold_constants_using_constraints();
-        println!("{ssa}");
+        assert_normalized_ssa_equals(ssa, expected);
+    }
 
-        let main = ssa.main();
-        let instructions = main.dfg[main.entry_block()].instructions();
-        assert_eq!(instructions.len(), 10);
+    #[test]
+    fn array_get_from_array_set_with_different_predicates() {
+        let src = "
+        acir(inline) fn main f0 {
+          b0(v0: [Field; 3], v1: u32, v2: Field):
+            enable_side_effects u1 0
+            v4 = array_set v0, index v1, value v2
+            enable_side_effects u1 1
+            v6 = array_get v4, index v1 -> Field
+            return v6
+        }
+        ";
+
+        let ssa = Ssa::from_str(src).unwrap();
+
+        let ssa = ssa.fold_constants_using_constraints();
+        // We expect the code to be unchanged
+        assert_normalized_ssa_equals(ssa, src);
+    }
+
+    #[test]
+    fn array_get_from_array_set_same_predicates() {
+        let src = "
+        acir(inline) fn main f0 {
+          b0(v0: [Field; 3], v1: u32, v2: Field):
+            enable_side_effects u1 1
+            v4 = array_set v0, index v1, value v2
+            v6 = array_get v4, index v1 -> Field
+            return v6
+        }
+        ";
+        let ssa = Ssa::from_str(src).unwrap();
+
+        let expected = "
+        acir(inline) fn main f0 {
+          b0(v0: [Field; 3], v1: u32, v2: Field):
+            enable_side_effects u1 1
+            v4 = array_set v0, index v1, value v2
+            return v2
+        }
+        ";
+        let ssa = ssa.fold_constants_using_constraints();
+        assert_normalized_ssa_equals(ssa, expected);
     }
 }
diff --git a/compiler/noirc_evaluator/src/ssa/opt/defunctionalize.rs b/compiler/noirc_evaluator/src/ssa/opt/defunctionalize.rs
index cfeb8751f25..7d7798fd30a 100644
--- a/compiler/noirc_evaluator/src/ssa/opt/defunctionalize.rs
+++ b/compiler/noirc_evaluator/src/ssa/opt/defunctionalize.rs
@@ -130,13 +130,14 @@ impl DefunctionalizationContext {
         // Change the type of all the values that are not call targets to NativeField
         let value_ids = vecmap(func.dfg.values_iter(), |(id, _)| id);
         for value_id in value_ids {
-            if let Type::Function = &func.dfg[value_id].get_type() {
+            if let Type::Function = func.dfg[value_id].get_type().as_ref() {
                 match &func.dfg[value_id] {
                     // If the value is a static function, transform it to the function id
                     Value::Function(id) => {
                         if !call_target_values.contains(&value_id) {
+                            let field = NumericType::NativeField;
                             let new_value =
-                                func.dfg.make_constant(function_id_to_field(*id), Type::field());
+                                func.dfg.make_constant(function_id_to_field(*id), field);
                             func.dfg.set_value_from_id(value_id, new_value);
                         }
                     }
@@ -267,7 +268,7 @@ fn create_apply_functions(
 }
 
 fn function_id_to_field(function_id: FunctionId) -> FieldElement {
-    (function_id.to_usize() as u128).into()
+    (function_id.to_u32() as u128).into()
 }
 
 /// Creates an apply function for the given signature and variants
@@ -287,10 +288,8 @@ fn create_apply_function(
             let is_last = index == function_ids.len() - 1;
             let mut next_function_block = None;
 
-            let function_id_constant = function_builder.numeric_constant(
-                function_id_to_field(*function_id),
-                Type::Numeric(NumericType::NativeField),
-            );
+            let function_id_constant = function_builder
+                .numeric_constant(function_id_to_field(*function_id), NumericType::NativeField);
 
             // If it's not the last function to dispatch, create an if statement
             if !is_last {
diff --git a/compiler/noirc_evaluator/src/ssa/opt/die.rs b/compiler/noirc_evaluator/src/ssa/opt/die.rs
index ae55f85d897..675d7fd854e 100644
--- a/compiler/noirc_evaluator/src/ssa/opt/die.rs
+++ b/compiler/noirc_evaluator/src/ssa/opt/die.rs
@@ -1,20 +1,19 @@
 //! Dead Instruction Elimination (DIE) pass: Removes any instruction without side-effects for
 //! which the results are unused.
 use fxhash::{FxHashMap as HashMap, FxHashSet as HashSet};
-use im::Vector;
-use noirc_errors::Location;
+use rayon::iter::{IntoParallelRefMutIterator, ParallelIterator};
 
 use crate::ssa::{
     ir::{
         basic_block::{BasicBlock, BasicBlockId},
-        dfg::DataFlowGraph,
+        dfg::{CallStack, DataFlowGraph},
         function::Function,
         instruction::{BinaryOp, Instruction, InstructionId, Intrinsic},
         post_order::PostOrder,
-        types::Type,
+        types::{NumericType, Type},
         value::{Value, ValueId},
     },
-    ssa_gen::{Ssa, SSA_WORD_SIZE},
+    ssa_gen::Ssa,
 };
 
 use super::rc::{pop_rc_for, RcInstruction};
@@ -24,45 +23,46 @@ impl Ssa {
     /// unused results.
     #[tracing::instrument(level = "trace", skip(self))]
     pub(crate) fn dead_instruction_elimination(mut self) -> Ssa {
-        for function in self.functions.values_mut() {
-            dead_instruction_elimination(function, true);
-        }
+        self.functions.par_iter_mut().for_each(|(_, func)| func.dead_instruction_elimination(true));
+
         self
     }
 }
 
-/// Removes any unused instructions in the reachable blocks of the given function.
-///
-/// The blocks of the function are iterated in post order, such that any blocks containing
-/// instructions that reference results from an instruction in another block are evaluated first.
-/// If we did not iterate blocks in this order we could not safely say whether or not the results
-/// of its instructions are needed elsewhere.
-fn dead_instruction_elimination(function: &mut Function, insert_out_of_bounds_checks: bool) {
-    let mut context = Context::default();
-    for call_data in &function.dfg.data_bus.call_data {
-        context.mark_used_instruction_results(&function.dfg, call_data.array_id);
-    }
+impl Function {
+    /// Removes any unused instructions in the reachable blocks of the given function.
+    ///
+    /// The blocks of the function are iterated in post order, such that any blocks containing
+    /// instructions that reference results from an instruction in another block are evaluated first.
+    /// If we did not iterate blocks in this order we could not safely say whether or not the results
+    /// of its instructions are needed elsewhere.
+    pub(crate) fn dead_instruction_elimination(&mut self, insert_out_of_bounds_checks: bool) {
+        let mut context = Context::default();
+        for call_data in &self.dfg.data_bus.call_data {
+            context.mark_used_instruction_results(&self.dfg, call_data.array_id);
+        }
 
-    let mut inserted_out_of_bounds_checks = false;
+        let mut inserted_out_of_bounds_checks = false;
 
-    let blocks = PostOrder::with_function(function);
-    for block in blocks.as_slice() {
-        inserted_out_of_bounds_checks |= context.remove_unused_instructions_in_block(
-            function,
-            *block,
-            insert_out_of_bounds_checks,
-        );
-    }
+        let blocks = PostOrder::with_function(self);
+        for block in blocks.as_slice() {
+            inserted_out_of_bounds_checks |= context.remove_unused_instructions_in_block(
+                self,
+                *block,
+                insert_out_of_bounds_checks,
+            );
+        }
 
-    // If we inserted out of bounds check, let's run the pass again with those new
-    // instructions (we don't want to remove those checks, or instructions that are
-    // dependencies of those checks)
-    if inserted_out_of_bounds_checks {
-        dead_instruction_elimination(function, false);
-        return;
-    }
+        // If we inserted out of bounds check, let's run the pass again with those new
+        // instructions (we don't want to remove those checks, or instructions that are
+        // dependencies of those checks)
+        if inserted_out_of_bounds_checks {
+            self.dead_instruction_elimination(false);
+            return;
+        }
 
-    context.remove_rc_instructions(&mut function.dfg);
+        context.remove_rc_instructions(&mut self.dfg);
+    }
 }
 
 /// Per function context for tracking unused values and which instructions to remove.
@@ -106,19 +106,7 @@ impl Context {
 
         let instructions_len = block.instructions().len();
 
-        // We can track IncrementRc instructions per block to determine whether they are useless.
-        // IncrementRc and DecrementRc instructions are normally side effectual instructions, but we remove
-        // them if their value is not used anywhere in the function. However, even when their value is used, their existence
-        // is pointless logic if there is no array set between the increment and the decrement of the reference counter.
-        // We track per block whether an IncrementRc instruction has a paired DecrementRc instruction
-        // with the same value but no array set in between.
-        // If we see an inc/dec RC pair within a block we can safely remove both instructions.
-        let mut rcs_with_possible_pairs: HashMap<Type, Vec<RcInstruction>> = HashMap::default();
-        let mut rc_pairs_to_remove = HashSet::default();
-        // We also separately track all IncrementRc instructions and all arrays which have been mutably borrowed.
-        // If an array has not been mutably borrowed we can then safely remove all IncrementRc instructions on that array.
-        let mut inc_rcs: HashMap<ValueId, HashSet<InstructionId>> = HashMap::default();
-        let mut borrowed_arrays: HashSet<ValueId> = HashSet::default();
+        let mut rc_tracker = RcTracker::default();
 
         // Indexes of instructions that might be out of bounds.
         // We'll remove those, but before that we'll insert bounds checks for them.
@@ -137,8 +125,9 @@ impl Context {
                         .push(instructions_len - instruction_index - 1);
                 }
             } else {
-                use Instruction::*;
-                if matches!(instruction, IncrementRc { .. } | DecrementRc { .. }) {
+                // We can't remove rc instructions if they're loaded from a reference
+                // since we'd have no way of knowing whether the reference is still used.
+                if Self::is_inc_dec_instruction_on_known_array(instruction, &function.dfg) {
                     self.rc_instructions.push((*instruction_id, block_id));
                 } else {
                     instruction.for_each_value(|value| {
@@ -147,32 +136,11 @@ impl Context {
                 }
             }
 
-            self.track_inc_rcs_to_remove(
-                *instruction_id,
-                function,
-                &mut rcs_with_possible_pairs,
-                &mut rc_pairs_to_remove,
-                &mut inc_rcs,
-                &mut borrowed_arrays,
-            );
+            rc_tracker.track_inc_rcs_to_remove(*instruction_id, function);
         }
 
-        let non_mutated_arrays =
-            inc_rcs
-                .keys()
-                .filter_map(|value| {
-                    if !borrowed_arrays.contains(value) {
-                        Some(&inc_rcs[value])
-                    } else {
-                        None
-                    }
-                })
-                .flatten()
-                .copied()
-                .collect::<Vec<_>>();
-
-        self.instructions_to_remove.extend(non_mutated_arrays);
-        self.instructions_to_remove.extend(rc_pairs_to_remove);
+        self.instructions_to_remove.extend(rc_tracker.get_non_mutated_arrays(&function.dfg));
+        self.instructions_to_remove.extend(rc_tracker.rc_pairs_to_remove);
 
         // If there are some instructions that might trigger an out of bounds error,
         // first add constrain checks. Then run the DIE pass again, which will remove those
@@ -196,59 +164,6 @@ impl Context {
         false
     }
 
-    fn track_inc_rcs_to_remove(
-        &self,
-        instruction_id: InstructionId,
-        function: &Function,
-        rcs_with_possible_pairs: &mut HashMap<Type, Vec<RcInstruction>>,
-        inc_rcs_to_remove: &mut HashSet<InstructionId>,
-        inc_rcs: &mut HashMap<ValueId, HashSet<InstructionId>>,
-        borrowed_arrays: &mut HashSet<ValueId>,
-    ) {
-        let instruction = &function.dfg[instruction_id];
-        // DIE loops over a block in reverse order, so we insert an RC instruction for possible removal
-        // when we see a DecrementRc and check whether it was possibly mutated when we see an IncrementRc.
-        match instruction {
-            Instruction::IncrementRc { value } => {
-                if let Some(inc_rc) = pop_rc_for(*value, function, rcs_with_possible_pairs) {
-                    if !inc_rc.possibly_mutated {
-                        inc_rcs_to_remove.insert(inc_rc.id);
-                        inc_rcs_to_remove.insert(instruction_id);
-                    }
-                }
-
-                inc_rcs.entry(*value).or_default().insert(instruction_id);
-            }
-            Instruction::DecrementRc { value } => {
-                let typ = function.dfg.type_of_value(*value);
-
-                // We assume arrays aren't mutated until we find an array_set
-                let dec_rc =
-                    RcInstruction { id: instruction_id, array: *value, possibly_mutated: false };
-                rcs_with_possible_pairs.entry(typ).or_default().push(dec_rc);
-            }
-            Instruction::ArraySet { array, .. } => {
-                let typ = function.dfg.type_of_value(*array);
-                if let Some(dec_rcs) = rcs_with_possible_pairs.get_mut(&typ) {
-                    for dec_rc in dec_rcs {
-                        dec_rc.possibly_mutated = true;
-                    }
-                }
-
-                borrowed_arrays.insert(*array);
-            }
-            Instruction::Store { value, .. } => {
-                // We are very conservative and say that any store of an array value means it has the potential
-                // to be mutated. This is done due to the tracking of mutable borrows still being per block.
-                let typ = function.dfg.type_of_value(*value);
-                if matches!(&typ, Type::Array(..) | Type::Slice(..)) {
-                    borrowed_arrays.insert(*value);
-                }
-            }
-            _ => {}
-        }
-    }
-
     /// Returns true if an instruction can be removed.
     ///
     /// An instruction can be removed as long as it has no side-effects, and none of its result
@@ -256,7 +171,7 @@ impl Context {
     fn is_unused(&self, instruction_id: InstructionId, function: &Function) -> bool {
         let instruction = &function.dfg[instruction_id];
 
-        if instruction.can_eliminate_if_unused(&function.dfg) {
+        if instruction.can_eliminate_if_unused(function) {
             let results = function.dfg.instruction_results(instruction_id);
             results.iter().all(|result| !self.used_values.contains(result))
         } else if let Instruction::Call { func, arguments } = instruction {
@@ -276,46 +191,37 @@ impl Context {
         });
     }
 
-    /// Inspects a value recursively (as it could be an array) and marks all comprised instruction
-    /// results as used.
+    /// Inspects a value and marks all instruction results as used.
     fn mark_used_instruction_results(&mut self, dfg: &DataFlowGraph, value_id: ValueId) {
         let value_id = dfg.resolve(value_id);
-        match &dfg[value_id] {
-            Value::Instruction { .. } => {
-                self.used_values.insert(value_id);
-            }
-            Value::Array { array, .. } => {
-                self.used_values.insert(value_id);
-                for elem in array {
-                    self.mark_used_instruction_results(dfg, *elem);
-                }
-            }
-            Value::Param { .. } => {
-                self.used_values.insert(value_id);
-            }
-            Value::NumericConstant { .. } => {
-                self.used_values.insert(value_id);
-            }
-            _ => {
-                // Does not comprise of any instruction results
-            }
+        if matches!(&dfg[value_id], Value::Instruction { .. } | Value::Param { .. }) {
+            self.used_values.insert(value_id);
         }
     }
 
     fn remove_rc_instructions(self, dfg: &mut DataFlowGraph) {
-        for (rc, block) in self.rc_instructions {
-            let value = match &dfg[rc] {
-                Instruction::IncrementRc { value } => *value,
-                Instruction::DecrementRc { value } => *value,
-                other => {
-                    unreachable!("Expected IncrementRc or DecrementRc instruction, found {other:?}")
+        let unused_rc_values_by_block: HashMap<BasicBlockId, HashSet<InstructionId>> =
+            self.rc_instructions.into_iter().fold(HashMap::default(), |mut acc, (rc, block)| {
+                let value = match &dfg[rc] {
+                    Instruction::IncrementRc { value } => *value,
+                    Instruction::DecrementRc { value } => *value,
+                    other => {
+                        unreachable!(
+                            "Expected IncrementRc or DecrementRc instruction, found {other:?}"
+                        )
+                    }
+                };
+
+                if !self.used_values.contains(&value) {
+                    acc.entry(block).or_default().insert(rc);
                 }
-            };
+                acc
+            });
 
-            // This could be more efficient if we have to remove multiple instructions in a single block
-            if !self.used_values.contains(&value) {
-                dfg[block].instructions_mut().retain(|instruction| *instruction != rc);
-            }
+        for (block, instructions_to_remove) in unused_rc_values_by_block {
+            dfg[block]
+                .instructions_mut()
+                .retain(|instruction| !instructions_to_remove.contains(instruction));
         }
     }
 
@@ -386,25 +292,25 @@ impl Context {
 
             let (lhs, rhs) = if function.dfg.get_numeric_constant(*index).is_some() {
                 // If we are here it means the index is known but out of bounds. That's always an error!
-                let false_const = function.dfg.make_constant(false.into(), Type::bool());
-                let true_const = function.dfg.make_constant(true.into(), Type::bool());
+                let false_const = function.dfg.make_constant(false.into(), NumericType::bool());
+                let true_const = function.dfg.make_constant(true.into(), NumericType::bool());
                 (false_const, true_const)
             } else {
                 // `index` will be relative to the flattened array length, so we need to take that into account
                 let array_length = function.dfg.type_of_value(*array).flattened_size();
 
                 // If we are here it means the index is dynamic, so let's add a check that it's less than length
+                let length_type = NumericType::length_type();
                 let index = function.dfg.insert_instruction_and_results(
-                    Instruction::Cast(*index, Type::unsigned(SSA_WORD_SIZE)),
+                    Instruction::Cast(*index, length_type),
                     block_id,
                     None,
                     call_stack.clone(),
                 );
                 let index = index.first();
 
-                let array_typ = Type::unsigned(SSA_WORD_SIZE);
                 let array_length =
-                    function.dfg.make_constant((array_length as u128).into(), array_typ);
+                    function.dfg.make_constant((array_length as u128).into(), length_type);
                 let is_index_out_of_bounds = function.dfg.insert_instruction_and_results(
                     Instruction::binary(BinaryOp::Lt, index, array_length),
                     block_id,
@@ -412,7 +318,7 @@ impl Context {
                     call_stack.clone(),
                 );
                 let is_index_out_of_bounds = is_index_out_of_bounds.first();
-                let true_const = function.dfg.make_constant(true.into(), Type::bool());
+                let true_const = function.dfg.make_constant(true.into(), NumericType::bool());
                 (is_index_out_of_bounds, true_const)
             };
 
@@ -439,6 +345,28 @@ impl Context {
 
         inserted_check
     }
+
+    /// True if this is a `Instruction::IncrementRc` or `Instruction::DecrementRc`
+    /// operating on an array directly from a `Instruction::MakeArray` or an
+    /// intrinsic known to return a fresh array.
+    fn is_inc_dec_instruction_on_known_array(
+        instruction: &Instruction,
+        dfg: &DataFlowGraph,
+    ) -> bool {
+        use Instruction::*;
+        if let IncrementRc { value } | DecrementRc { value } = instruction {
+            if let Value::Instruction { instruction, .. } = &dfg[*value] {
+                return match &dfg[*instruction] {
+                    MakeArray { .. } => true,
+                    Call { func, .. } => {
+                        matches!(&dfg[*func], Value::Intrinsic(_) | Value::ForeignFunction(_))
+                    }
+                    _ => false,
+                };
+            }
+        }
+        false
+    }
 }
 
 fn instruction_might_result_in_out_of_bounds(
@@ -563,7 +491,7 @@ fn apply_side_effects(
     rhs: ValueId,
     function: &mut Function,
     block_id: BasicBlockId,
-    call_stack: Vector<Location>,
+    call_stack: CallStack,
 ) -> (ValueId, ValueId) {
     // See if there's an active "enable side effects" condition
     let Some(condition) = side_effects_condition else {
@@ -574,12 +502,9 @@ fn apply_side_effects(
 
     // Condition needs to be cast to argument type in order to multiply them together.
     // In our case, lhs is always a boolean.
-    let casted_condition = dfg.insert_instruction_and_results(
-        Instruction::Cast(condition, Type::bool()),
-        block_id,
-        None,
-        call_stack.clone(),
-    );
+    let cast = Instruction::Cast(condition, NumericType::bool());
+    let casted_condition =
+        dfg.insert_instruction_and_results(cast, block_id, None, call_stack.clone());
     let casted_condition = casted_condition.first();
 
     let lhs = dfg.insert_instruction_and_results(
@@ -601,6 +526,112 @@ fn apply_side_effects(
     (lhs, rhs)
 }
 
+#[derive(Default)]
+struct RcTracker {
+    // We can track IncrementRc instructions per block to determine whether they are useless.
+    // IncrementRc and DecrementRc instructions are normally side effectual instructions, but we remove
+    // them if their value is not used anywhere in the function. However, even when their value is used, their existence
+    // is pointless logic if there is no array set between the increment and the decrement of the reference counter.
+    // We track per block whether an IncrementRc instruction has a paired DecrementRc instruction
+    // with the same value but no array set in between.
+    // If we see an inc/dec RC pair within a block we can safely remove both instructions.
+    rcs_with_possible_pairs: HashMap<Type, Vec<RcInstruction>>,
+    rc_pairs_to_remove: HashSet<InstructionId>,
+    // We also separately track all IncrementRc instructions and all array types which have been mutably borrowed.
+    // If an array is the same type as one of those non-mutated array types, we can safely remove all IncrementRc instructions on that array.
+    inc_rcs: HashMap<ValueId, HashSet<InstructionId>>,
+    mutated_array_types: HashSet<Type>,
+    // The SSA often creates patterns where after simplifications we end up with repeat
+    // IncrementRc instructions on the same value. We track whether the previous instruction was an IncrementRc,
+    // and if the current instruction is also an IncrementRc on the same value we remove the current instruction.
+    // `None` if the previous instruction was anything other than an IncrementRc
+    previous_inc_rc: Option<ValueId>,
+}
+
+impl RcTracker {
+    fn track_inc_rcs_to_remove(&mut self, instruction_id: InstructionId, function: &Function) {
+        let instruction = &function.dfg[instruction_id];
+
+        if let Instruction::IncrementRc { value } = instruction {
+            if let Some(previous_value) = self.previous_inc_rc {
+                if previous_value == *value {
+                    self.rc_pairs_to_remove.insert(instruction_id);
+                }
+            }
+            self.previous_inc_rc = Some(*value);
+        } else {
+            self.previous_inc_rc = None;
+        }
+
+        // DIE loops over a block in reverse order, so we insert an RC instruction for possible removal
+        // when we see a DecrementRc and check whether it was possibly mutated when we see an IncrementRc.
+        match instruction {
+            Instruction::IncrementRc { value } => {
+                if let Some(inc_rc) =
+                    pop_rc_for(*value, function, &mut self.rcs_with_possible_pairs)
+                {
+                    if !inc_rc.possibly_mutated {
+                        self.rc_pairs_to_remove.insert(inc_rc.id);
+                        self.rc_pairs_to_remove.insert(instruction_id);
+                    }
+                }
+
+                self.inc_rcs.entry(*value).or_default().insert(instruction_id);
+            }
+            Instruction::DecrementRc { value } => {
+                let typ = function.dfg.type_of_value(*value);
+
+                // We assume arrays aren't mutated until we find an array_set
+                let dec_rc =
+                    RcInstruction { id: instruction_id, array: *value, possibly_mutated: false };
+                self.rcs_with_possible_pairs.entry(typ).or_default().push(dec_rc);
+            }
+            Instruction::ArraySet { array, .. } => {
+                let typ = function.dfg.type_of_value(*array);
+                if let Some(dec_rcs) = self.rcs_with_possible_pairs.get_mut(&typ) {
+                    for dec_rc in dec_rcs {
+                        dec_rc.possibly_mutated = true;
+                    }
+                }
+
+                self.mutated_array_types.insert(typ);
+            }
+            Instruction::Store { value, .. } => {
+                // We are very conservative and say that any store of an array type means it has the potential to be mutated.
+                let typ = function.dfg.type_of_value(*value);
+                if matches!(&typ, Type::Array(..) | Type::Slice(..)) {
+                    self.mutated_array_types.insert(typ);
+                }
+            }
+            Instruction::Call { arguments, .. } => {
+                for arg in arguments {
+                    let typ = function.dfg.type_of_value(*arg);
+                    if matches!(&typ, Type::Array(..) | Type::Slice(..)) {
+                        self.mutated_array_types.insert(typ);
+                    }
+                }
+            }
+            _ => {}
+        }
+    }
+
+    fn get_non_mutated_arrays(&self, dfg: &DataFlowGraph) -> HashSet<InstructionId> {
+        self.inc_rcs
+            .keys()
+            .filter_map(|value| {
+                let typ = dfg.type_of_value(*value);
+                if !self.mutated_array_types.contains(&typ) {
+                    Some(&self.inc_rcs[value])
+                } else {
+                    None
+                }
+            })
+            .flatten()
+            .copied()
+            .collect()
+    }
+}
+
 #[cfg(test)]
 mod test {
     use std::sync::Arc;
@@ -610,219 +641,131 @@ mod test {
     use crate::ssa::{
         function_builder::FunctionBuilder,
         ir::{
-            instruction::{BinaryOp, Instruction, Intrinsic},
             map::Id,
-            types::Type,
+            types::{NumericType, Type},
         },
+        opt::assert_normalized_ssa_equals,
+        Ssa,
     };
 
     #[test]
     fn dead_instruction_elimination() {
-        // fn main f0 {
-        //   b0(v0: Field):
-        //     v1 = add v0, Field 1
-        //     v2 = add v0, Field 2
-        //     jmp b1(v2)
-        //   b1(v3: Field):
-        //     v4 = allocate 1 field
-        //     v5 = load v4
-        //     v6 = allocate 1 field
-        //     store Field 1 in v6
-        //     v7 = load v6
-        //     v8 = add v7, Field 1
-        //     v9 = add v7, Field 2
-        //     v10 = add v7, Field 3
-        //     v11 = add v10, v10
-        //     call assert_constant(v8)
-        //     return v9
-        // }
-        let main_id = Id::test_new(0);
-
-        // Compiling main
-        let mut builder = FunctionBuilder::new("main".into(), main_id);
-        let v0 = builder.add_parameter(Type::field());
-        let b1 = builder.insert_block();
-
-        let one = builder.field_constant(1u128);
-        let two = builder.field_constant(2u128);
-        let three = builder.field_constant(3u128);
-
-        let _v1 = builder.insert_binary(v0, BinaryOp::Add, one);
-        let v2 = builder.insert_binary(v0, BinaryOp::Add, two);
-        builder.terminate_with_jmp(b1, vec![v2]);
-
-        builder.switch_to_block(b1);
-        let _v3 = builder.add_block_parameter(b1, Type::field());
-
-        let v4 = builder.insert_allocate(Type::field());
-        let _v5 = builder.insert_load(v4, Type::field());
-
-        let v6 = builder.insert_allocate(Type::field());
-        builder.insert_store(v6, one);
-        let v7 = builder.insert_load(v6, Type::field());
-        let v8 = builder.insert_binary(v7, BinaryOp::Add, one);
-        let v9 = builder.insert_binary(v7, BinaryOp::Add, two);
-        let v10 = builder.insert_binary(v7, BinaryOp::Add, three);
-        let _v11 = builder.insert_binary(v10, BinaryOp::Add, v10);
-
-        let assert_constant_id = builder.import_intrinsic_id(Intrinsic::AssertConstant);
-        builder.insert_call(assert_constant_id, vec![v8], vec![]);
-        builder.terminate_with_return(vec![v9]);
-
-        let ssa = builder.finish();
-        let main = ssa.main();
-
-        // The instruction count never includes the terminator instruction
-        assert_eq!(main.dfg[main.entry_block()].instructions().len(), 2);
-        assert_eq!(main.dfg[b1].instructions().len(), 10);
-
-        // Expected output:
-        //
-        // fn main f0 {
-        //   b0(v0: Field):
-        //     v2 = add v0, Field 2
-        //     jmp b1(v2)
-        //   b1(v3: Field):
-        //     v6 = allocate 1 field
-        //     store Field 1 in v6
-        //     v7 = load v6
-        //     v8 = add v7, Field 1
-        //     v9 = add v7, Field 2
-        //     call assert_constant(v8)
-        //     return v9
-        // }
+        let src = "
+            acir(inline) fn main f0 {
+              b0(v0: Field):
+                v3 = add v0, Field 1
+                v5 = add v0, Field 2
+                jmp b1(v5)
+              b1(v1: Field):
+                v6 = allocate -> &mut Field
+                v7 = load v6 -> Field
+                v8 = allocate -> &mut Field
+                store Field 1 at v8
+                v9 = load v8 -> Field
+                v10 = add v9, Field 1
+                v11 = add v9, Field 2
+                v13 = add v9, Field 3
+                v14 = add v13, v13
+                call assert_constant(v10)
+                return v11
+            }
+            ";
+        let ssa = Ssa::from_str(src).unwrap();
+
+        let expected = "
+            acir(inline) fn main f0 {
+              b0(v0: Field):
+                v3 = add v0, Field 2
+                jmp b1(v3)
+              b1(v1: Field):
+                v4 = allocate -> &mut Field
+                store Field 1 at v4
+                v6 = load v4 -> Field
+                v7 = add v6, Field 1
+                v8 = add v6, Field 2
+                call assert_constant(v7)
+                return v8
+            }
+            ";
         let ssa = ssa.dead_instruction_elimination();
-        let main = ssa.main();
-
-        assert_eq!(main.dfg[main.entry_block()].instructions().len(), 1);
-        assert_eq!(main.dfg[b1].instructions().len(), 6);
+        assert_normalized_ssa_equals(ssa, expected);
     }
 
     #[test]
     fn as_witness_die() {
-        // fn main f0 {
-        //   b0(v0: Field):
-        //     v1 = add v0, Field 1
-        //     v2 = add v0, Field 2
-        //     call as_witness(v2)
-        //     return v1
-        // }
-        let main_id = Id::test_new(0);
-
-        // Compiling main
-        let mut builder = FunctionBuilder::new("main".into(), main_id);
-        let v0 = builder.add_parameter(Type::field());
-
-        let one = builder.field_constant(1u128);
-        let two = builder.field_constant(2u128);
-
-        let v1 = builder.insert_binary(v0, BinaryOp::Add, one);
-        let v2 = builder.insert_binary(v0, BinaryOp::Add, two);
-        let as_witness = builder.import_intrinsic("as_witness").unwrap();
-        builder.insert_call(as_witness, vec![v2], Vec::new());
-        builder.terminate_with_return(vec![v1]);
-
-        let ssa = builder.finish();
-        let main = ssa.main();
-
-        // The instruction count never includes the terminator instruction
-        assert_eq!(main.dfg[main.entry_block()].instructions().len(), 3);
-
-        // Expected output:
-        //
-        // acir(inline) fn main f0 {
-        //    b0(v0: Field):
-        //      v3 = add v0, Field 1
-        //      return v3
-        //  }
+        let src = "
+            acir(inline) fn main f0 {
+              b0(v0: Field):
+                v2 = add v0, Field 1
+                v4 = add v0, Field 2
+                call as_witness(v4)
+                return v2
+            }
+            ";
+        let ssa = Ssa::from_str(src).unwrap();
+
+        let expected = "
+            acir(inline) fn main f0 {
+              b0(v0: Field):
+                v2 = add v0, Field 1
+                return v2
+            }
+            ";
         let ssa = ssa.dead_instruction_elimination();
-        let main = ssa.main();
-
-        assert_eq!(main.dfg[main.entry_block()].instructions().len(), 1);
+        assert_normalized_ssa_equals(ssa, expected);
     }
 
     #[test]
     fn remove_useless_paired_rcs_even_when_used() {
-        // acir(inline) fn main f0 {
-        //     b0(v0: [Field; 2]):
-        //       inc_rc v0
-        //       v2 = array_get v0, index u32 0
-        //       dec_rc v0
-        //       return v2
-        //   }
-        let main_id = Id::test_new(0);
-
-        // Compiling main
-        let mut builder = FunctionBuilder::new("main".into(), main_id);
-        let v0 = builder.add_parameter(Type::Array(Arc::new(vec![Type::field()]), 2));
-        builder.increment_array_reference_count(v0);
-        let zero = builder.numeric_constant(0u128, Type::unsigned(32));
-        let v1 = builder.insert_array_get(v0, zero, Type::field());
-        builder.decrement_array_reference_count(v0);
-        builder.terminate_with_return(vec![v1]);
-
-        let ssa = builder.finish();
-        let main = ssa.main();
-
-        // The instruction count never includes the terminator instruction
-        assert_eq!(main.dfg[main.entry_block()].instructions().len(), 3);
-
-        // Expected output:
-        //
-        // acir(inline) fn main f0 {
-        //     b0(v0: [Field; 2]):
-        //       v2 = array_get v0, index u32 0
-        //       return v2
-        //   }
+        let src = "
+            acir(inline) fn main f0 {
+              b0(v0: [Field; 2]):
+                inc_rc v0
+                v2 = array_get v0, index u32 0 -> Field
+                dec_rc v0
+                return v2
+            }
+            ";
+        let ssa = Ssa::from_str(src).unwrap();
+
+        let expected = "
+            acir(inline) fn main f0 {
+              b0(v0: [Field; 2]):
+                v2 = array_get v0, index u32 0 -> Field
+                return v2
+            }
+            ";
         let ssa = ssa.dead_instruction_elimination();
-        let main = ssa.main();
-
-        let instructions = main.dfg[main.entry_block()].instructions();
-        assert_eq!(instructions.len(), 1);
-        assert!(matches!(&main.dfg[instructions[0]], Instruction::ArrayGet { .. }));
+        assert_normalized_ssa_equals(ssa, expected);
     }
 
     #[test]
     fn keep_paired_rcs_with_array_set() {
-        // acir(inline) fn main f0 {
-        //     b0(v0: [Field; 2]):
-        //       inc_rc v0
-        //       v2 = array_set v0, index u32 0, value u32 0
-        //       dec_rc v0
-        //       return v2
-        //   }
-        let main_id = Id::test_new(0);
-
-        // Compiling main
-        let mut builder = FunctionBuilder::new("main".into(), main_id);
-        let v0 = builder.add_parameter(Type::Array(Arc::new(vec![Type::field()]), 2));
-        builder.increment_array_reference_count(v0);
-        let zero = builder.numeric_constant(0u128, Type::unsigned(32));
-        let v1 = builder.insert_array_set(v0, zero, zero);
-        builder.decrement_array_reference_count(v0);
-        builder.terminate_with_return(vec![v1]);
-
-        let ssa = builder.finish();
-        let main = ssa.main();
-
-        // The instruction count never includes the terminator instruction
-        assert_eq!(main.dfg[main.entry_block()].instructions().len(), 3);
+        let src = "
+            acir(inline) fn main f0 {
+              b0(v0: [Field; 2]):
+                inc_rc v0
+                v2 = array_set v0, index u32 0, value u32 0
+                dec_rc v0
+                return v2
+            }
+            ";
+        let ssa = Ssa::from_str(src).unwrap();
 
         // We expect the output to be unchanged
         let ssa = ssa.dead_instruction_elimination();
-        let main = ssa.main();
-
-        assert_eq!(main.dfg[main.entry_block()].instructions().len(), 3);
+        assert_normalized_ssa_equals(ssa, src);
     }
 
     #[test]
     fn keep_inc_rc_on_borrowed_array_store() {
         // acir(inline) fn main f0 {
         //     b0():
+        //       v1 = make_array [u32 0, u32 0]
         //       v2 = allocate
-        //       inc_rc [u32 0, u32 0]
-        //       store [u32 0, u32 0] at v2
-        //       inc_rc [u32 0, u32 0]
+        //       inc_rc v1
+        //       store v1 at v2
+        //       inc_rc v1
         //       jmp b1()
         //     b1():
         //       v3 = load v2
@@ -833,20 +776,20 @@ mod test {
 
         // Compiling main
         let mut builder = FunctionBuilder::new("main".into(), main_id);
-        let zero = builder.numeric_constant(0u128, Type::unsigned(32));
+        let zero = builder.numeric_constant(0u128, NumericType::unsigned(32));
         let array_type = Type::Array(Arc::new(vec![Type::unsigned(32)]), 2);
-        let array = builder.array_constant(vector![zero, zero], array_type.clone());
+        let v1 = builder.insert_make_array(vector![zero, zero], array_type.clone());
         let v2 = builder.insert_allocate(array_type.clone());
-        builder.increment_array_reference_count(array);
-        builder.insert_store(v2, array);
-        builder.increment_array_reference_count(array);
+        builder.increment_array_reference_count(v1);
+        builder.insert_store(v2, v1);
+        builder.increment_array_reference_count(v1);
 
         let b1 = builder.insert_block();
         builder.terminate_with_jmp(b1, vec![]);
         builder.switch_to_block(b1);
 
         let v3 = builder.insert_load(v2, array_type);
-        let one = builder.numeric_constant(1u128, Type::unsigned(32));
+        let one = builder.numeric_constant(1u128, NumericType::unsigned(32));
         let v5 = builder.insert_array_set(v3, zero, one);
         builder.terminate_with_return(vec![v5]);
 
@@ -854,14 +797,14 @@ mod test {
         let main = ssa.main();
 
         // The instruction count never includes the terminator instruction
-        assert_eq!(main.dfg[main.entry_block()].instructions().len(), 4);
+        assert_eq!(main.dfg[main.entry_block()].instructions().len(), 5);
         assert_eq!(main.dfg[b1].instructions().len(), 2);
 
         // We expect the output to be unchanged
         let ssa = ssa.dead_instruction_elimination();
         let main = ssa.main();
 
-        assert_eq!(main.dfg[main.entry_block()].instructions().len(), 4);
+        assert_eq!(main.dfg[main.entry_block()].instructions().len(), 5);
         assert_eq!(main.dfg[b1].instructions().len(), 2);
     }
 
@@ -877,80 +820,120 @@ mod test {
         //       v4 = array_get v3, index u32 1
         //       return v4
         //   }
-        let main_id = Id::test_new(0);
-
-        // Compiling main
-        let mut builder = FunctionBuilder::new("main".into(), main_id);
-        let array_type = Type::Array(Arc::new(vec![Type::unsigned(32)]), 2);
-        let v0 = builder.add_parameter(array_type.clone());
-        builder.increment_array_reference_count(v0);
-        let zero = builder.numeric_constant(0u128, Type::unsigned(32));
-        let one = builder.numeric_constant(1u128, Type::unsigned(32));
-        let v3 = builder.insert_array_set(v0, zero, one);
-        builder.increment_array_reference_count(v0);
-        builder.increment_array_reference_count(v0);
-        builder.increment_array_reference_count(v0);
-
-        let v4 = builder.insert_array_get(v3, one, Type::unsigned(32));
-
-        builder.terminate_with_return(vec![v4]);
-
-        let ssa = builder.finish();
-        let main = ssa.main();
-
-        // The instruction count never includes the terminator instruction
-        assert_eq!(main.dfg[main.entry_block()].instructions().len(), 6);
+        let src = "
+        acir(inline) fn main f0 {
+          b0(v0: [u32; 2]):
+            inc_rc v0
+            v3 = array_set v0, index u32 0, value u32 1
+            inc_rc v0
+            inc_rc v0
+            inc_rc v0
+            v4 = array_get v3, index u32 1 -> u32
+            return v4
+        }
+        ";
+        let ssa = Ssa::from_str(src).unwrap();
 
         // We expect the output to be unchanged
+        // Except for the repeated inc_rc instructions
+        let expected = "
+        acir(inline) fn main f0 {
+          b0(v0: [u32; 2]):
+            inc_rc v0
+            v3 = array_set v0, index u32 0, value u32 1
+            inc_rc v0
+            v4 = array_get v3, index u32 1 -> u32
+            return v4
+        }
+        ";
+
         let ssa = ssa.dead_instruction_elimination();
-        let main = ssa.main();
+        assert_normalized_ssa_equals(ssa, expected);
+    }
 
-        assert_eq!(main.dfg[main.entry_block()].instructions().len(), 6);
+    #[test]
+    fn does_not_remove_inc_or_dec_rc_of_if_they_are_loaded_from_a_reference() {
+        let src = "
+            brillig(inline) fn borrow_mut f0 {
+              b0(v0: &mut [Field; 3]):
+                v1 = load v0 -> [Field; 3]
+                inc_rc v1 // this one shouldn't be removed
+                v2 = load v0 -> [Field; 3]
+                inc_rc v2 // this one shouldn't be removed
+                v3 = load v0 -> [Field; 3]
+                v6 = array_set v3, index u32 0, value Field 5
+                store v6 at v0
+                dec_rc v6
+                return
+            }
+            ";
+        let ssa = Ssa::from_str(src).unwrap();
+        let ssa = ssa.dead_instruction_elimination();
+        assert_normalized_ssa_equals(ssa, src);
     }
 
     #[test]
     fn remove_inc_rcs_that_are_never_mutably_borrowed() {
-        // acir(inline) fn main f0 {
-        //     b0(v0: [Field; 2]):
-        //       inc_rc v0
-        //       inc_rc v0
-        //       inc_rc v0
-        //       v2 = array_get v0, index u32 0
-        //       inc_rc v0
-        //       return v2
-        //   }
-        let main_id = Id::test_new(0);
-
-        // Compiling main
-        let mut builder = FunctionBuilder::new("main".into(), main_id);
-        let v0 = builder.add_parameter(Type::Array(Arc::new(vec![Type::field()]), 2));
-        builder.increment_array_reference_count(v0);
-        builder.increment_array_reference_count(v0);
-        builder.increment_array_reference_count(v0);
-
-        let zero = builder.numeric_constant(0u128, Type::unsigned(32));
-        let v2 = builder.insert_array_get(v0, zero, Type::field());
-        builder.increment_array_reference_count(v0);
-        builder.terminate_with_return(vec![v2]);
+        let src = "
+        acir(inline) fn main f0 {
+          b0(v0: [Field; 2]):
+            inc_rc v0
+            inc_rc v0
+            inc_rc v0
+            v2 = array_get v0, index u32 0 -> Field
+            inc_rc v0
+            return v2
+        }
+        ";
 
-        let ssa = builder.finish();
+        let ssa = Ssa::from_str(src).unwrap();
         let main = ssa.main();
 
         // The instruction count never includes the terminator instruction
         assert_eq!(main.dfg[main.entry_block()].instructions().len(), 5);
 
-        // Expected output:
-        //
-        // acir(inline) fn main f0 {
-        //     b0(v0: [Field; 2]):
-        //       v2 = array_get v0, index u32 0
-        //       return v2
-        //   }
+        let expected = "
+        acir(inline) fn main f0 {
+          b0(v0: [Field; 2]):
+            v2 = array_get v0, index u32 0 -> Field
+            return v2
+        }
+        ";
+
         let ssa = ssa.dead_instruction_elimination();
-        let main = ssa.main();
+        assert_normalized_ssa_equals(ssa, expected);
+    }
 
-        let instructions = main.dfg[main.entry_block()].instructions();
-        assert_eq!(instructions.len(), 1);
-        assert!(matches!(&main.dfg[instructions[0]], Instruction::ArrayGet { .. }));
+    #[test]
+    fn do_not_remove_inc_rc_if_used_as_call_arg() {
+        // We do not want to remove inc_rc instructions on values
+        // that are passed as call arguments.
+        //
+        // We could have previously inlined a function which does the following:
+        // - Accepts a mutable array as an argument
+        // - Writes to that array
+        // - Passes the new array to another call
+        //
+        // It is possible then that the mutation gets simplified out after inlining.
+        // If we then remove the inc_rc as we see no mutations to that array in the block,
+        // we may end up with an the incorrect reference count.
+        let src = "
+        brillig(inline) fn main f0 {
+          b0(v0: Field):
+            v4 = make_array [Field 0, Field 1, Field 2] : [Field; 3]
+            inc_rc v4
+            v6 = call f1(v4) -> Field
+            constrain v0 == v6
+            return
+        }
+        brillig(inline) fn foo f1 {
+          b0(v0: [Field; 3]):
+            return u32 1
+        }
+        ";
+
+        let ssa = Ssa::from_str(src).unwrap();
+        let ssa = ssa.dead_instruction_elimination();
+        assert_normalized_ssa_equals(ssa, src);
     }
 }
diff --git a/compiler/noirc_evaluator/src/ssa/opt/flatten_cfg.rs b/compiler/noirc_evaluator/src/ssa/opt/flatten_cfg.rs
index cb455507985..9c3fd72f281 100644
--- a/compiler/noirc_evaluator/src/ssa/opt/flatten_cfg.rs
+++ b/compiler/noirc_evaluator/src/ssa/opt/flatten_cfg.rs
@@ -131,8 +131,7 @@
 //!   v11 = mul v4, Field 12
 //!   v12 = add v10, v11
 //!   store v12 at v5         (new store)
-use fxhash::FxHashMap as HashMap;
-use std::collections::{BTreeMap, HashSet};
+use fxhash::{FxHashMap as HashMap, FxHashSet as HashSet};
 
 use acvm::{acir::AcirField, acir::BlackBoxFunc, FieldElement};
 use iter_extended::vecmap;
@@ -142,10 +141,10 @@ use crate::ssa::{
         basic_block::BasicBlockId,
         cfg::ControlFlowGraph,
         dfg::{CallStack, InsertInstructionResult},
-        function::{Function, FunctionId},
+        function::{Function, FunctionId, RuntimeType},
         function_inserter::FunctionInserter,
         instruction::{BinaryOp, Instruction, InstructionId, Intrinsic, TerminatorInstruction},
-        types::Type,
+        types::{NumericType, Type},
         value::{Value, ValueId},
     },
     ssa_gen::Ssa,
@@ -186,18 +185,6 @@ struct Context<'f> {
     /// Maps start of branch -> end of branch
     branch_ends: HashMap<BasicBlockId, BasicBlockId>,
 
-    /// Maps an address to the old and new value of the element at that address
-    /// These only hold stores for one block at a time and is cleared
-    /// between inlining of branches.
-    store_values: HashMap<ValueId, Store>,
-
-    /// Stores all allocations local to the current branch.
-    /// Since these branches are local to the current branch (ie. only defined within one branch of
-    /// an if expression), they should not be merged with their previous value or stored value in
-    /// the other branch since there is no such value. The ValueId here is that which is returned
-    /// by the allocate instruction.
-    local_allocations: HashSet<ValueId>,
-
     /// A stack of each jmpif condition that was taken to reach a particular point in the program.
     /// When two branches are merged back into one, this constitutes a join point, and is analogous
     /// to the rest of the program after an if statement. When such a join point / end block is
@@ -214,13 +201,15 @@ struct Context<'f> {
     /// When processing a block, we pop this stack to get its arguments
     /// and at the end we push the arguments for his successor
     arguments_stack: Vec<Vec<ValueId>>,
-}
 
-#[derive(Clone)]
-pub(crate) struct Store {
-    old_value: ValueId,
-    new_value: ValueId,
-    call_stack: CallStack,
+    /// Stores all allocations local to the current branch.
+    ///
+    /// Since these branches are local to the current branch (i.e. only defined within one branch of
+    /// an if expression), they should not be merged with their previous value or stored value in
+    /// the other branch since there is no such value.
+    ///
+    /// The `ValueId` here is that which is returned by the allocate instruction.
+    local_allocations: HashSet<ValueId>,
 }
 
 #[derive(Clone)]
@@ -231,8 +220,6 @@ struct ConditionalBranch {
     old_condition: ValueId,
     // The condition of the branch
     condition: ValueId,
-    // The store values accumulated when processing the branch
-    store_values: HashMap<ValueId, Store>,
     // The allocations accumulated when processing the branch
     local_allocations: HashSet<ValueId>,
 }
@@ -254,7 +241,7 @@ fn flatten_function_cfg(function: &mut Function, no_predicates: &HashMap<Functio
     // This pass may run forever on a brillig function.
     // Analyze will check if the predecessors have been processed and push the block to the back of
     // the queue. This loops forever if there are still any loops present in the program.
-    if let crate::ssa::ir::function::RuntimeType::Brillig = function.runtime() {
+    if matches!(function.runtime(), RuntimeType::Brillig(_)) {
         return;
     }
     let cfg = ControlFlowGraph::with_function(function);
@@ -263,12 +250,11 @@ fn flatten_function_cfg(function: &mut Function, no_predicates: &HashMap<Functio
     let mut context = Context {
         inserter: FunctionInserter::new(function),
         cfg,
-        store_values: HashMap::default(),
-        local_allocations: HashSet::new(),
         branch_ends,
         slice_sizes: HashMap::default(),
         condition_stack: Vec::new(),
         arguments_stack: Vec::new(),
+        local_allocations: HashSet::default(),
     };
     context.flatten(no_predicates);
 }
@@ -346,15 +332,12 @@ impl<'f> Context<'f> {
         for instruction in instructions.iter() {
             if self.is_no_predicate(no_predicates, instruction) {
                 // disable side effect for no_predicate functions
-                let one = self
-                    .inserter
-                    .function
-                    .dfg
-                    .make_constant(FieldElement::one(), Type::unsigned(1));
+                let bool_type = NumericType::bool();
+                let one = self.inserter.function.dfg.make_constant(FieldElement::one(), bool_type);
                 self.insert_instruction_with_typevars(
                     Instruction::EnableSideEffectsIf { condition: one },
                     None,
-                    im::Vector::new(),
+                    CallStack::new(),
                 );
                 self.push_instruction(*instruction);
                 self.insert_current_side_effects_enabled();
@@ -429,14 +412,12 @@ impl<'f> Context<'f> {
         let old_condition = *condition;
         let then_condition = self.inserter.resolve(old_condition);
 
-        let old_stores = std::mem::take(&mut self.store_values);
         let old_allocations = std::mem::take(&mut self.local_allocations);
         let branch = ConditionalBranch {
             old_condition,
             condition: self.link_condition(then_condition),
-            store_values: old_stores,
-            local_allocations: old_allocations,
             last_block: *then_destination,
+            local_allocations: old_allocations,
         };
         let cond_context = ConditionalContext {
             condition: then_condition,
@@ -447,6 +428,16 @@ impl<'f> Context<'f> {
         };
         self.condition_stack.push(cond_context);
         self.insert_current_side_effects_enabled();
+
+        // We disallow this case as it results in the `else_destination` block
+        // being inlined before the `then_destination` block due to block deduplication in the work queue.
+        //
+        // The `else_destination` block then gets treated as if it were the `then_destination` block
+        // and has the incorrect condition applied to it.
+        assert_ne!(
+            self.branch_ends[if_entry], *then_destination,
+            "ICE: branches merge inside of `then` branch"
+        );
         vec![self.branch_ends[if_entry], *else_destination, *then_destination]
     }
 
@@ -463,19 +454,12 @@ impl<'f> Context<'f> {
         );
         let else_condition = self.link_condition(else_condition);
 
-        // Make sure the else branch sees the previous values of each store
-        // rather than any values created in the 'then' branch.
-        let old_stores = std::mem::take(&mut cond_context.then_branch.store_values);
-        cond_context.then_branch.store_values = std::mem::take(&mut self.store_values);
-        self.undo_stores_in_then_branch(&cond_context.then_branch.store_values);
-
         let old_allocations = std::mem::take(&mut self.local_allocations);
         let else_branch = ConditionalBranch {
             old_condition: cond_context.then_branch.old_condition,
             condition: else_condition,
-            store_values: old_stores,
-            local_allocations: old_allocations,
             last_block: *block,
+            local_allocations: old_allocations,
         };
         cond_context.then_branch.local_allocations.clear();
         cond_context.else_branch = Some(else_branch);
@@ -499,10 +483,8 @@ impl<'f> Context<'f> {
         }
 
         let mut else_branch = cond_context.else_branch.unwrap();
-        let stores_in_branch = std::mem::replace(&mut self.store_values, else_branch.store_values);
         self.local_allocations = std::mem::take(&mut else_branch.local_allocations);
         else_branch.last_block = *block;
-        else_branch.store_values = stores_in_branch;
         cond_context.else_branch = Some(else_branch);
 
         // We must remember to reset whether side effects are enabled when both branches
@@ -552,7 +534,11 @@ impl<'f> Context<'f> {
         let args = vecmap(then_args.iter().zip(else_args), |(then_arg, else_arg)| {
             (self.inserter.resolve(*then_arg), self.inserter.resolve(else_arg))
         });
-
+        let else_condition = if let Some(branch) = cond_context.else_branch {
+            branch.condition
+        } else {
+            self.inserter.function.dfg.make_constant(FieldElement::zero(), NumericType::bool())
+        };
         let block = self.inserter.function.entry_block();
 
         // Cannot include this in the previous vecmap since it requires exclusive access to self
@@ -560,7 +546,7 @@ impl<'f> Context<'f> {
             let instruction = Instruction::IfElse {
                 then_condition: cond_context.then_branch.condition,
                 then_value: then_arg,
-                else_condition: cond_context.else_branch.as_ref().unwrap().condition,
+                else_condition,
                 else_value: else_arg,
             };
             let call_stack = cond_context.call_stack.clone();
@@ -571,8 +557,6 @@ impl<'f> Context<'f> {
                 .first()
         });
 
-        let call_stack = cond_context.call_stack;
-        self.merge_stores(cond_context.then_branch, cond_context.else_branch, call_stack);
         self.arguments_stack.pop();
         self.arguments_stack.pop();
         self.arguments_stack.push(args);
@@ -619,7 +603,7 @@ impl<'f> Context<'f> {
         let condition = match self.get_last_condition() {
             Some(cond) => cond,
             None => {
-                self.inserter.function.dfg.make_constant(FieldElement::one(), Type::unsigned(1))
+                self.inserter.function.dfg.make_constant(FieldElement::one(), NumericType::bool())
             }
         };
         let enable_side_effects = Instruction::EnableSideEffectsIf { condition };
@@ -627,122 +611,29 @@ impl<'f> Context<'f> {
         self.insert_instruction_with_typevars(enable_side_effects, None, call_stack);
     }
 
-    /// Merge any store instructions found in each branch.
-    ///
-    /// This function relies on the 'then' branch being merged before the 'else' branch of a jmpif
-    /// instruction. If this ordering is changed, the ordering that store values are merged within
-    /// this function also needs to be changed to reflect that.
-    fn merge_stores(
-        &mut self,
-        then_branch: ConditionalBranch,
-        else_branch: Option<ConditionalBranch>,
-        call_stack: CallStack,
-    ) {
-        // Address -> (then_value, else_value, value_before_the_if)
-        let mut new_map = BTreeMap::new();
-
-        for (address, store) in then_branch.store_values {
-            new_map.insert(address, (store.new_value, store.old_value, store.old_value));
-        }
-
-        if else_branch.is_some() {
-            for (address, store) in else_branch.clone().unwrap().store_values {
-                if let Some(entry) = new_map.get_mut(&address) {
-                    entry.1 = store.new_value;
-                } else {
-                    new_map.insert(address, (store.old_value, store.new_value, store.old_value));
-                }
-            }
-        }
-
-        let then_condition = then_branch.condition;
-        let else_condition = if let Some(branch) = else_branch {
-            branch.condition
-        } else {
-            self.inserter.function.dfg.make_constant(FieldElement::zero(), Type::bool())
-        };
-        let block = self.inserter.function.entry_block();
-
-        // Merging must occur in a separate loop as we cannot borrow `self` as mutable while `value_merger` does
-        let mut new_values = HashMap::default();
-        for (address, (then_case, else_case, _)) in &new_map {
-            let instruction = Instruction::IfElse {
-                then_condition,
-                then_value: *then_case,
-                else_condition,
-                else_value: *else_case,
-            };
-            let dfg = &mut self.inserter.function.dfg;
-            let value = dfg
-                .insert_instruction_and_results(instruction, block, None, call_stack.clone())
-                .first();
-
-            new_values.insert(address, value);
-        }
-
-        // Replace stores with new merged values
-        for (address, (_, _, old_value)) in &new_map {
-            let value = new_values[address];
-            let address = *address;
-            self.insert_instruction_with_typevars(
-                Instruction::Store { address, value },
-                None,
-                call_stack.clone(),
-            );
-
-            if let Some(store) = self.store_values.get_mut(&address) {
-                store.new_value = value;
-            } else {
-                self.store_values.insert(
-                    address,
-                    Store {
-                        old_value: *old_value,
-                        new_value: value,
-                        call_stack: call_stack.clone(),
-                    },
-                );
-            }
-        }
-    }
-
-    fn remember_store(&mut self, address: ValueId, new_value: ValueId, call_stack: CallStack) {
-        if !self.local_allocations.contains(&address) {
-            if let Some(store_value) = self.store_values.get_mut(&address) {
-                store_value.new_value = new_value;
-            } else {
-                let load = Instruction::Load { address };
-
-                let load_type = Some(vec![self.inserter.function.dfg.type_of_value(new_value)]);
-                let old_value = self
-                    .insert_instruction_with_typevars(load.clone(), load_type, call_stack.clone())
-                    .first();
-
-                self.store_values.insert(address, Store { old_value, new_value, call_stack });
-            }
-        }
-    }
-
     /// Push the given instruction to the end of the entry block of the current function.
     ///
     /// Note that each ValueId of the instruction will be mapped via self.inserter.resolve.
     /// As a result, the instruction that will be pushed will actually be a new instruction
     /// with a different InstructionId from the original. The results of the given instruction
     /// will also be mapped to the results of the new instruction.
-    fn push_instruction(&mut self, id: InstructionId) -> Vec<ValueId> {
+    ///
+    /// `previous_allocate_result` should only be set to the result of an allocate instruction
+    /// if that instruction was the instruction immediately previous to this one - if there are
+    /// any instructions in between it should be None.
+    fn push_instruction(&mut self, id: InstructionId) {
         let (instruction, call_stack) = self.inserter.map_instruction(id);
         let instruction = self.handle_instruction_side_effects(instruction, call_stack.clone());
-        let is_allocate = matches!(instruction, Instruction::Allocate);
 
+        let instruction_is_allocate = matches!(&instruction, Instruction::Allocate);
         let entry = self.inserter.function.entry_block();
         let results = self.inserter.push_instruction_value(instruction, id, entry, call_stack);
 
         // Remember an allocate was created local to this branch so that we do not try to merge store
         // values across branches for it later.
-        if is_allocate {
+        if instruction_is_allocate {
             self.local_allocations.insert(results.first());
         }
-
-        results.results().into_owned()
     }
 
     /// If we are currently in a branch, we need to modify constrain instructions
@@ -759,13 +650,9 @@ impl<'f> Context<'f> {
 
                     // Condition needs to be cast to argument type in order to multiply them together.
                     let argument_type = self.inserter.function.dfg.type_of_value(lhs);
-                    // Sanity check that we're not constraining non-primitive types
-                    assert!(matches!(argument_type, Type::Numeric(_)));
 
-                    let casted_condition = self.insert_instruction(
-                        Instruction::Cast(condition, argument_type),
-                        call_stack.clone(),
-                    );
+                    let cast = Instruction::Cast(condition, argument_type.unwrap_numeric());
+                    let casted_condition = self.insert_instruction(cast, call_stack.clone());
 
                     let lhs = self.insert_instruction(
                         Instruction::binary(BinaryOp::Mul, lhs, casted_condition),
@@ -779,18 +666,43 @@ impl<'f> Context<'f> {
                     Instruction::Constrain(lhs, rhs, message)
                 }
                 Instruction::Store { address, value } => {
-                    self.remember_store(address, value, call_stack);
-                    Instruction::Store { address, value }
+                    // If this instruction immediately follows an allocate, and stores to that
+                    // address there is no previous value to load and we don't need a merge anyway.
+                    if self.local_allocations.contains(&address) {
+                        Instruction::Store { address, value }
+                    } else {
+                        // Instead of storing `value`, store `if condition { value } else { previous_value }`
+                        let typ = self.inserter.function.dfg.type_of_value(value);
+                        let load = Instruction::Load { address };
+                        let previous_value = self
+                            .insert_instruction_with_typevars(
+                                load,
+                                Some(vec![typ]),
+                                call_stack.clone(),
+                            )
+                            .first();
+
+                        let else_condition = self
+                            .insert_instruction(Instruction::Not(condition), call_stack.clone());
+
+                        let instruction = Instruction::IfElse {
+                            then_condition: condition,
+                            then_value: value,
+                            else_condition,
+                            else_value: previous_value,
+                        };
+
+                        let updated_value = self.insert_instruction(instruction, call_stack);
+                        Instruction::Store { address, value: updated_value }
+                    }
                 }
                 Instruction::RangeCheck { value, max_bit_size, assert_message } => {
                     // Replace value with `value * predicate` to zero out value when predicate is inactive.
 
                     // Condition needs to be cast to argument type in order to multiply them together.
                     let argument_type = self.inserter.function.dfg.type_of_value(value);
-                    let casted_condition = self.insert_instruction(
-                        Instruction::Cast(condition, argument_type),
-                        call_stack.clone(),
-                    );
+                    let cast = Instruction::Cast(condition, argument_type.unwrap_numeric());
+                    let casted_condition = self.insert_instruction(cast, call_stack.clone());
 
                     let value = self.insert_instruction(
                         Instruction::binary(BinaryOp::Mul, value, casted_condition),
@@ -804,10 +716,8 @@ impl<'f> Context<'f> {
                         let field = arguments[0];
                         let argument_type = self.inserter.function.dfg.type_of_value(field);
 
-                        let casted_condition = self.insert_instruction(
-                            Instruction::Cast(condition, argument_type),
-                            call_stack.clone(),
-                        );
+                        let cast = Instruction::Cast(condition, argument_type.unwrap_numeric());
+                        let casted_condition = self.insert_instruction(cast, call_stack.clone());
                         let field = self.insert_instruction(
                             Instruction::binary(BinaryOp::Mul, field, casted_condition),
                             call_stack.clone(),
@@ -826,8 +736,8 @@ impl<'f> Context<'f> {
                     }
                     Value::Intrinsic(Intrinsic::BlackBox(BlackBoxFunc::MultiScalarMul)) => {
                         let points_array_idx = if matches!(
-                            self.inserter.function.dfg[arguments[0]],
-                            Value::Array { .. }
+                            self.inserter.function.dfg.type_of_value(arguments[0]),
+                            Type::Array { .. }
                         ) {
                             0
                         } else {
@@ -835,15 +745,15 @@ impl<'f> Context<'f> {
                             // which means the array is the second argument
                             1
                         };
-                        let (array_with_predicate, array_typ) = self
-                            .apply_predicate_to_msm_argument(
-                                arguments[points_array_idx],
-                                condition,
-                                call_stack.clone(),
-                            );
+                        let (elements, typ) = self.apply_predicate_to_msm_argument(
+                            arguments[points_array_idx],
+                            condition,
+                            call_stack.clone(),
+                        );
 
-                        arguments[points_array_idx] =
-                            self.inserter.function.dfg.make_array(array_with_predicate, array_typ);
+                        let instruction = Instruction::MakeArray { elements, typ };
+                        let array = self.insert_instruction(instruction, call_stack);
+                        arguments[points_array_idx] = array;
                         Instruction::Call { func, arguments }
                     }
                     _ => Instruction::Call { func, arguments },
@@ -866,7 +776,7 @@ impl<'f> Context<'f> {
     ) -> (im::Vector<ValueId>, Type) {
         let array_typ;
         let mut array_with_predicate = im::Vector::new();
-        if let Value::Array { array, typ } = &self.inserter.function.dfg[argument] {
+        if let Some((array, typ)) = &self.inserter.function.dfg.get_array_constant(argument) {
             array_typ = typ.clone();
             for (i, value) in array.clone().iter().enumerate() {
                 if i % 3 == 2 {
@@ -902,22 +812,10 @@ impl<'f> Context<'f> {
             call_stack,
         )
     }
-
-    fn undo_stores_in_then_branch(&mut self, store_values: &HashMap<ValueId, Store>) {
-        for (address, store) in store_values {
-            let address = *address;
-            let value = store.old_value;
-            let instruction = Instruction::Store { address, value };
-            // Considering the location of undoing a store to be the same as the original store.
-            self.insert_instruction_with_typevars(instruction, None, store.call_stack.clone());
-        }
-    }
 }
 
 #[cfg(test)]
 mod test {
-    use std::sync::Arc;
-
     use acvm::acir::AcirField;
 
     use crate::ssa::{
@@ -930,237 +828,159 @@ mod test {
             types::Type,
             value::{Value, ValueId},
         },
+        opt::assert_normalized_ssa_equals,
+        Ssa,
     };
 
     #[test]
     fn basic_jmpif() {
-        // fn main f0 {
-        //   b0(v0: b1):
-        //     jmpif v0, then: b1, else: b2
-        //   b1():
-        //     jmp b3(Field 3)
-        //   b2():
-        //     jmp b3(Field 4)
-        //   b3(v1: Field):
-        //     return v1
-        // }
-        let main_id = Id::test_new(0);
-        let mut builder = FunctionBuilder::new("main".into(), main_id);
-
-        let b1 = builder.insert_block();
-        let b2 = builder.insert_block();
-        let b3 = builder.insert_block();
-
-        let v0 = builder.add_parameter(Type::bool());
-        let v1 = builder.add_block_parameter(b3, Type::field());
-
-        let three = builder.field_constant(3u128);
-        let four = builder.field_constant(4u128);
-
-        builder.terminate_with_jmpif(v0, b1, b2);
-
-        builder.switch_to_block(b1);
-        builder.terminate_with_jmp(b3, vec![three]);
-
-        builder.switch_to_block(b2);
-        builder.terminate_with_jmp(b3, vec![four]);
-
-        builder.switch_to_block(b3);
-        builder.terminate_with_return(vec![v1]);
-
-        let ssa = builder.finish();
+        let src = "
+            acir(inline) fn main f0 {
+              b0(v0: u1):
+                jmpif v0 then: b1, else: b2
+              b1():
+                jmp b3(Field 3)
+              b3(v1: Field):
+                return v1
+              b2():
+                jmp b3(Field 4)
+            }
+            ";
+        let ssa = Ssa::from_str(src).unwrap();
         assert_eq!(ssa.main().reachable_blocks().len(), 4);
 
-        // Expected output:
-        // fn main f0 {
-        //   b0(v0: u1):
-        //     enable_side_effects v0
-        //     v5 = not v0
-        //     enable_side_effects v5
-        //     enable_side_effects u1 1
-        //     v7 = mul v0, Field 3
-        //     v8 = mul v5, Field 4
-        //     v9 = add v7, v8
-        //     return v9
-        // }
+        let expected = "
+            acir(inline) fn main f0 {
+              b0(v0: u1):
+                enable_side_effects v0
+                v1 = not v0
+                enable_side_effects u1 1
+                v3 = cast v0 as Field
+                v4 = cast v1 as Field
+                v6 = mul v3, Field 3
+                v8 = mul v4, Field 4
+                v9 = add v6, v8
+                return v9
+            }
+            ";
+
         let ssa = ssa.flatten_cfg();
-        assert_eq!(ssa.main().reachable_blocks().len(), 1);
+        assert_normalized_ssa_equals(ssa, expected);
     }
 
     #[test]
     fn modify_constrain() {
-        // fn main f0 {
-        //   b0(v0: u1, v1: u1):
-        //     jmpif v0, then: b1, else: b2
-        //   b1():
-        //     constrain v1
-        //     jmp b2()
-        //   b2():
-        //     return
-        // }
-        let main_id = Id::test_new(0);
-        let mut builder = FunctionBuilder::new("main".into(), main_id);
-
-        let b1 = builder.insert_block();
-        let b2 = builder.insert_block();
-
-        let v0 = builder.add_parameter(Type::bool());
-        let v1 = builder.add_parameter(Type::bool());
-        let v_true = builder.numeric_constant(true, Type::bool());
-
-        builder.terminate_with_jmpif(v0, b1, b2);
-
-        builder.switch_to_block(b1);
-        builder.insert_constrain(v1, v_true, None);
-        builder.terminate_with_jmp(b2, vec![]);
-
-        builder.switch_to_block(b2);
-        builder.terminate_with_return(vec![]);
-
-        let ssa = builder.finish();
+        let src = "
+            acir(inline) fn main f0 {
+              b0(v0: u1, v1: u1):
+                jmpif v0 then: b1, else: b2
+              b1():
+                constrain v1 == u1 1
+                jmp b2()
+              b2():
+                return
+            }
+            ";
+        let ssa = Ssa::from_str(src).unwrap();
         assert_eq!(ssa.main().reachable_blocks().len(), 3);
 
-        // Expected output:
-        // fn main f0 {
-        //   b0(v0: u1, v1: u1):
-        //     enable_side_effects v0
-        //     v3 = mul v1, v0
-        //     v4 = eq v3, v0
-        //     constrain v4
-        //     v5 = not v0
-        //     enable_side_effects v5
-        //     enable_side_effects u1 1
-        //     return
-        // }
+        let expected = "
+            acir(inline) fn main f0 {
+              b0(v0: u1, v1: u1):
+                enable_side_effects v0
+                v2 = mul v1, v0
+                constrain v2 == v0
+                v3 = not v0
+                enable_side_effects u1 1
+                return
+            }
+            ";
         let ssa = ssa.flatten_cfg();
         assert_eq!(ssa.main().reachable_blocks().len(), 1);
+        assert_normalized_ssa_equals(ssa, expected);
     }
 
     #[test]
     fn merge_stores() {
-        // fn main f0 {
-        //   b0(v0: u1, v1: &mut Field):
-        //     jmpif v0, then: b1, else: b2
-        //   b1():
-        //     store v1, Field 5
-        //     jmp b2()
-        //   b2():
-        //     return
-        // }
-        let main_id = Id::test_new(0);
-        let mut builder = FunctionBuilder::new("main".into(), main_id);
-
-        let b1 = builder.insert_block();
-        let b2 = builder.insert_block();
-
-        let v0 = builder.add_parameter(Type::bool());
-        let v1 = builder.add_parameter(Type::Reference(Arc::new(Type::field())));
-
-        builder.terminate_with_jmpif(v0, b1, b2);
-
-        builder.switch_to_block(b1);
-        let five = builder.field_constant(5u128);
-        builder.insert_store(v1, five);
-        builder.terminate_with_jmp(b2, vec![]);
-
-        builder.switch_to_block(b2);
-        builder.terminate_with_return(vec![]);
-
-        let ssa = builder.finish();
-
-        // Expected output:
-        // fn main f0 {
-        //   b0(v0: u1, v1: reference):
-        //     enable_side_effects v0
-        //     v4 = load v1
-        //     store Field 5 at v1
-        //     v5 = not v0
-        //     store v4 at v1
-        //     enable_side_effects u1 1
-        //     v6 = cast v0 as Field
-        //     v7 = cast v5 as Field
-        //     v8 = mul v6, Field 5
-        //     v9 = mul v7, v4
-        //     v10 = add v8, v9
-        //     store v10 at v1
-        //     return
-        // }
+        let src = "
+            acir(inline) fn main f0 {
+              b0(v0: u1, v1: &mut Field):
+                jmpif v0 then: b1, else: b2
+              b1():
+                store Field 5 at v1
+                jmp b2()
+              b2():
+                return
+            }
+            ";
+        let ssa = Ssa::from_str(src).unwrap();
+
+        let expected = "
+            acir(inline) fn main f0 {
+              b0(v0: u1, v1: &mut Field):
+                enable_side_effects v0
+                v2 = load v1 -> Field
+                v3 = not v0
+                v4 = cast v0 as Field
+                v5 = cast v3 as Field
+                v7 = mul v4, Field 5
+                v8 = mul v5, v2
+                v9 = add v7, v8
+                store v9 at v1
+                v10 = not v0
+                enable_side_effects u1 1
+                return
+            }
+            ";
         let ssa = ssa.flatten_cfg();
-        let main = ssa.main();
-
-        assert_eq!(main.reachable_blocks().len(), 1);
-
-        let store_count = count_instruction(main, |ins| matches!(ins, Instruction::Store { .. }));
-        assert_eq!(store_count, 3);
+        assert_normalized_ssa_equals(ssa, expected);
     }
 
     #[test]
     fn merge_stores_with_else_block() {
-        // fn main f0 {
-        //   b0(v0: u1, v1: ref):
-        //     jmpif v0, then: b1, else: b2
-        //   b1():
-        //     store Field 5 in v1
-        //     jmp b3()
-        //   b2():
-        //     store Field 6 in v1
-        //     jmp b3()
-        //   b3():
-        //     return
-        // }
-        let main_id = Id::test_new(0);
-        let mut builder = FunctionBuilder::new("main".into(), main_id);
-
-        let b1 = builder.insert_block();
-        let b2 = builder.insert_block();
-        let b3 = builder.insert_block();
-
-        let v0 = builder.add_parameter(Type::bool());
-        let v1 = builder.add_parameter(Type::Reference(Arc::new(Type::field())));
-
-        builder.terminate_with_jmpif(v0, b1, b2);
-
-        builder.switch_to_block(b1);
-        let five = builder.field_constant(5u128);
-        builder.insert_store(v1, five);
-        builder.terminate_with_jmp(b3, vec![]);
-
-        builder.switch_to_block(b2);
-        let six = builder.field_constant(6u128);
-        builder.insert_store(v1, six);
-        builder.terminate_with_jmp(b3, vec![]);
-
-        builder.switch_to_block(b3);
-        builder.terminate_with_return(vec![]);
-
-        let ssa = builder.finish();
-
-        // Expected output:
-        // fn main f0 {
-        //   b0(v0: u1, v1: reference):
-        //     enable_side_effects v0
-        //     v5 = load v1
-        //     store Field 5 at v1
-        //     v6 = not v0
-        //     store v5 at v1
-        //     enable_side_effects v6
-        //     v8 = load v1
-        //     store Field 6 at v1
-        //     enable_side_effects u1 1
-        //     v9 = cast v0 as Field
-        //     v10 = cast v6 as Field
-        //     v11 = mul v9, Field 5
-        //     v12 = mul v10, Field 6
-        //     v13 = add v11, v12
-        //     store v13 at v1
-        //     return
-        // }
+        let src = "
+            acir(inline) fn main f0 {
+              b0(v0: u1, v1: &mut Field):
+                jmpif v0 then: b1, else: b2
+              b1():
+                store Field 5 at v1
+                jmp b3()
+              b2():
+                store Field 6 at v1
+                jmp b3()
+              b3():
+                return
+            }
+            ";
+        let ssa = Ssa::from_str(src).unwrap();
+
+        let expected = "
+            acir(inline) fn main f0 {
+              b0(v0: u1, v1: &mut Field):
+                enable_side_effects v0
+                v2 = load v1 -> Field
+                v3 = not v0
+                v4 = cast v0 as Field
+                v5 = cast v3 as Field
+                v7 = mul v4, Field 5
+                v8 = mul v5, v2
+                v9 = add v7, v8
+                store v9 at v1
+                v10 = not v0
+                enable_side_effects v10
+                v11 = load v1 -> Field
+                v12 = cast v10 as Field
+                v13 = cast v0 as Field
+                v15 = mul v12, Field 6
+                v16 = mul v13, v11
+                v17 = add v15, v16
+                store v17 at v1
+                enable_side_effects u1 1
+                return
+            }
+            ";
         let ssa = ssa.flatten_cfg();
-        let main = ssa.main();
-        assert_eq!(main.reachable_blocks().len(), 1);
-
-        let store_count = count_instruction(main, |ins| matches!(ins, Instruction::Store { .. }));
-        assert_eq!(store_count, 4);
+        assert_normalized_ssa_equals(ssa, expected);
     }
 
     fn count_instruction(function: &Function, f: impl Fn(&Instruction) -> bool) -> usize {
@@ -1198,123 +1018,101 @@ mod test {
         //    b7      b8
         //      ↘   ↙
         //       b9
-        let main_id = Id::test_new(0);
-        let mut builder = FunctionBuilder::new("main".into(), main_id);
-
-        let b1 = builder.insert_block();
-        let b2 = builder.insert_block();
-        let b3 = builder.insert_block();
-        let b4 = builder.insert_block();
-        let b5 = builder.insert_block();
-        let b6 = builder.insert_block();
-        let b7 = builder.insert_block();
-        let b8 = builder.insert_block();
-        let b9 = builder.insert_block();
-
-        let c1 = builder.add_parameter(Type::bool());
-        let c4 = builder.add_parameter(Type::bool());
-
-        let r1 = builder.insert_allocate(Type::field());
-
-        let store_value = |builder: &mut FunctionBuilder, value: u128| {
-            let value = builder.field_constant(value);
-            builder.insert_store(r1, value);
-        };
-
-        let test_function = Id::test_new(1);
-
-        let call_test_function = |builder: &mut FunctionBuilder, block: u128| {
-            let block = builder.field_constant(block);
-            let load = builder.insert_load(r1, Type::field());
-            builder.insert_call(test_function, vec![block, load], Vec::new());
-        };
-
-        let switch_store_and_test_function =
-            |builder: &mut FunctionBuilder, block, block_number: u128| {
-                builder.switch_to_block(block);
-                store_value(builder, block_number);
-                call_test_function(builder, block_number);
-            };
-
-        let switch_and_test_function =
-            |builder: &mut FunctionBuilder, block, block_number: u128| {
-                builder.switch_to_block(block);
-                call_test_function(builder, block_number);
-            };
-
-        store_value(&mut builder, 0);
-        call_test_function(&mut builder, 0);
-        builder.terminate_with_jmp(b1, vec![]);
-
-        switch_store_and_test_function(&mut builder, b1, 1);
-        builder.terminate_with_jmpif(c1, b2, b3);
-
-        switch_store_and_test_function(&mut builder, b2, 2);
-        builder.terminate_with_jmp(b4, vec![]);
-
-        switch_store_and_test_function(&mut builder, b3, 3);
-        builder.terminate_with_jmp(b8, vec![]);
-
-        switch_and_test_function(&mut builder, b4, 4);
-        builder.terminate_with_jmpif(c4, b5, b6);
-
-        switch_store_and_test_function(&mut builder, b5, 5);
-        builder.terminate_with_jmp(b7, vec![]);
-
-        switch_store_and_test_function(&mut builder, b6, 6);
-        builder.terminate_with_jmp(b7, vec![]);
 
-        switch_and_test_function(&mut builder, b7, 7);
-        builder.terminate_with_jmp(b9, vec![]);
-
-        switch_and_test_function(&mut builder, b8, 8);
-        builder.terminate_with_jmp(b9, vec![]);
-
-        switch_and_test_function(&mut builder, b9, 9);
-        let load = builder.insert_load(r1, Type::field());
-        builder.terminate_with_return(vec![load]);
-
-        let ssa = builder.finish().flatten_cfg().mem2reg();
-
-        // Expected results after mem2reg removes the allocation and each load and store:
-        //
-        // fn main f0 {
-        //   b0(v0: u1, v1: u1):
-        //     call test_function(Field 0, Field 0)
-        //     call test_function(Field 1, Field 1)
-        //     enable_side_effects v0
-        //     call test_function(Field 2, Field 2)
-        //     call test_function(Field 4, Field 2)
-        //     v29 = and v0, v1
-        //     enable_side_effects v29
-        //     call test_function(Field 5, Field 5)
-        //     v32 = not v1
-        //     v33 = and v0, v32
-        //     enable_side_effects v33
-        //     call test_function(Field 6, Field 6)
-        //     enable_side_effects v0
-        //     v36 = mul v1, Field 5
-        //     v37 = mul v32, Field 2
-        //     v38 = add v36, v37
-        //     v39 = mul v1, Field 5
-        //     v40 = mul v32, Field 6
-        //     v41 = add v39, v40
-        //     call test_function(Field 7, v42)
-        //     v43 = not v0
-        //     enable_side_effects v43
-        //     store Field 3 at v2
-        //     call test_function(Field 3, Field 3)
-        //     call test_function(Field 8, Field 3)
-        //     enable_side_effects Field 1
-        //     v47 = mul v0, v41
-        //     v48 = mul v43, Field 1
-        //     v49 = add v47, v48
-        //     v50 = mul v0, v44
-        //     v51 = mul v43, Field 3
-        //     v52 = add v50, v51
-        //     call test_function(Field 9, v53)
-        //     return v54
-        // }
+        let src = "
+        acir(inline) fn main f0 {
+          b0(v0: u1, v1: u1):
+            v2 = allocate -> &mut Field
+            store Field 0 at v2
+            v4 = load v2 -> Field
+            // call v1(Field 0, v4)
+            jmp b1()
+          b1():
+            store Field 1 at v2
+            v6 = load v2 -> Field
+            // call v1(Field 1, v6)
+            jmpif v0 then: b2, else: b3
+          b2():
+            store Field 2 at v2
+            v8 = load v2 -> Field
+            // call v1(Field 2, v8)
+            jmp b4()
+          b4():
+            v12 = load v2 -> Field
+            // call v1(Field 4, v12)
+            jmpif v1 then: b5, else: b6
+          b5():
+            store Field 5 at v2
+            v14 = load v2 -> Field
+            // call v1(Field 5, v14)
+            jmp b7()
+          b7():
+            v18 = load v2 -> Field
+            // call v1(Field 7, v18)
+            jmp b9()
+          b9():
+            v22 = load v2 -> Field
+            // call v1(Field 9, v22)
+            v23 = load v2 -> Field
+            return v23
+          b6():
+            store Field 6 at v2
+            v16 = load v2 -> Field
+            // call v1(Field 6, v16)
+            jmp b7()
+          b3():
+            store Field 3 at v2
+            v10 = load v2 -> Field
+            // call v1(Field 3, v10)
+            jmp b8()
+          b8():
+            v20 = load v2 -> Field
+            // call v1(Field 8, v20)
+            jmp b9()
+        }";
+
+        let ssa = Ssa::from_str(src).unwrap();
+
+        let ssa = ssa.flatten_cfg().mem2reg();
+
+        let expected = "
+        acir(inline) fn main f0 {
+          b0(v0: u1, v1: u1):
+            v2 = allocate -> &mut Field
+            enable_side_effects v0
+            v3 = not v0
+            v4 = cast v0 as Field
+            v5 = cast v3 as Field
+            v7 = mul v4, Field 2
+            v8 = add v7, v5
+            v9 = mul v0, v1
+            enable_side_effects v9
+            v10 = not v9
+            v11 = cast v9 as Field
+            v12 = cast v10 as Field
+            v14 = mul v11, Field 5
+            v15 = mul v12, v8
+            v16 = add v14, v15
+            v17 = not v1
+            v18 = mul v0, v17
+            enable_side_effects v18
+            v19 = not v18
+            v20 = cast v18 as Field
+            v21 = cast v19 as Field
+            v23 = mul v20, Field 6
+            v24 = mul v21, v16
+            v25 = add v23, v24
+            enable_side_effects v0
+            v26 = not v0
+            enable_side_effects v26
+            v27 = cast v26 as Field
+            v28 = cast v0 as Field
+            v30 = mul v27, Field 3
+            v31 = mul v28, v25
+            v32 = add v30, v31
+            enable_side_effects u1 1
+            return v32
+        }";
 
         let main = ssa.main();
         let ret = match main.dfg[main.entry_block()].terminator() {
@@ -1323,7 +1121,9 @@ mod test {
         };
 
         let merged_values = get_all_constants_reachable_from_instruction(&main.dfg, ret);
-        assert_eq!(merged_values, vec![3, 5, 6]);
+        assert_eq!(merged_values, vec![2, 3, 5, 6]);
+
+        assert_normalized_ssa_equals(ssa, expected);
     }
 
     #[test]
@@ -1340,56 +1140,41 @@ mod test {
         //     };
         // }
         //
-        // // Translates to the following before the flattening pass:
-        // fn main f2 {
-        //   b0(v0: u1):
-        //     jmpif v0 then: b1, else: b2
-        //   b1():
-        //     v2 = allocate
-        //     store Field 0 at v2
-        //     v4 = load v2
-        //     jmp b2()
-        //   b2():
-        //     return
-        // }
+        // Translates to the following before the flattening pass:
+        let src = "
+        acir(inline) fn main f0 {
+          b0(v0: u1):
+            jmpif v0 then: b1, else: b2
+          b1():
+            v1 = allocate -> &mut Field
+            store Field 0 at v1
+            v3 = load v1 -> Field
+            jmp b2()
+          b2():
+            return
+        }";
         // The bug is that the flattening pass previously inserted a load
         // before the first store to allocate, which loaded an uninitialized value.
         // In this test we assert the ordering is strictly Allocate then Store then Load.
-        let main_id = Id::test_new(0);
-        let mut builder = FunctionBuilder::new("main".into(), main_id);
-
-        let b1 = builder.insert_block();
-        let b2 = builder.insert_block();
-
-        let v0 = builder.add_parameter(Type::bool());
-        builder.terminate_with_jmpif(v0, b1, b2);
-
-        builder.switch_to_block(b1);
-        let v2 = builder.insert_allocate(Type::field());
-        let zero = builder.field_constant(0u128);
-        builder.insert_store(v2, zero);
-        let _v4 = builder.insert_load(v2, Type::field());
-        builder.terminate_with_jmp(b2, vec![]);
-
-        builder.switch_to_block(b2);
-        builder.terminate_with_return(vec![]);
-
-        let ssa = builder.finish().flatten_cfg();
-        let main = ssa.main();
+        let ssa = Ssa::from_str(src).unwrap();
+        let flattened_ssa = ssa.flatten_cfg();
 
         // Now assert that there is not a load between the allocate and its first store
         // The Expected IR is:
-        //
-        // fn main f2 {
-        //   b0(v0: u1):
-        //     enable_side_effects v0
-        //     v6 = allocate
-        //     store Field 0 at v6
-        //     v7 = load v6
-        //     v8 = not v0
-        //     enable_side_effects u1 1
-        //     return
-        // }
+        let expected = "
+        acir(inline) fn main f0 {
+          b0(v0: u1):
+            enable_side_effects v0
+            v1 = allocate -> &mut Field
+            store Field 0 at v1
+            v3 = load v1 -> Field
+            v4 = not v0
+            enable_side_effects u1 1
+            return
+        }
+        ";
+
+        let main = flattened_ssa.main();
         let instructions = main.dfg[main.entry_block()].instructions();
 
         let find_instruction = |predicate: fn(&Instruction) -> bool| {
@@ -1402,6 +1187,8 @@ mod test {
 
         assert!(allocate_index < store_index);
         assert!(store_index < load_index);
+
+        assert_normalized_ssa_equals(flattened_ssa, expected);
     }
 
     /// Work backwards from an instruction to find all the constant values
@@ -1445,111 +1232,97 @@ mod test {
         // Very simplified derived regression test for #1792
         // Tests that it does not simplify to a true constraint an always-false constraint
         // The original function is replaced by the following:
-        // fn main f1 {
-        //   b0():
-        //     jmpif u1 0 then: b1, else: b2
-        //   b1():
-        //     jmp b2()
-        //   b2():
-        //     constrain u1 0 // was incorrectly removed
-        //     return
-        // }
-        let main_id = Id::test_new(1);
-        let mut builder = FunctionBuilder::new("main".into(), main_id);
-
-        builder.insert_block(); // entry
-
-        let b1 = builder.insert_block();
-        let b2 = builder.insert_block();
-        let v_true = builder.numeric_constant(true, Type::bool());
-        let v_false = builder.numeric_constant(false, Type::bool());
-        builder.terminate_with_jmpif(v_false, b1, b2);
-
-        builder.switch_to_block(b1);
-        builder.terminate_with_jmp(b2, vec![]);
-
-        builder.switch_to_block(b2);
-        builder.insert_constrain(v_false, v_true, None); // should not be removed
-        builder.terminate_with_return(vec![]);
-
-        let ssa = builder.finish().flatten_cfg();
-        let main = ssa.main();
-
-        // Assert we have not incorrectly removed a constraint:
-        use Instruction::Constrain;
-        let constrain_count = count_instruction(main, |ins| matches!(ins, Constrain(..)));
-        assert_eq!(constrain_count, 1);
+        let src = "
+            acir(inline) fn main f1 {
+              b0():
+                jmpif u1 0 then: b1, else: b2
+              b1():
+                jmp b2()
+              b2():
+                constrain u1 0 == u1 1 // was incorrectly removed
+                return
+            }
+            ";
+        let ssa = Ssa::from_str(src).unwrap();
+
+        let expected = "
+            acir(inline) fn main f0 {
+              b0():
+                enable_side_effects u1 1
+                constrain u1 0 == u1 1
+                return
+            }
+            ";
+        let ssa = ssa.flatten_cfg();
+        assert_normalized_ssa_equals(ssa, expected);
     }
 
     #[test]
     fn should_not_merge_incorrectly_to_false() {
         // Regression test for #1792
         // Tests that it does not simplify a true constraint an always-false constraint
-        // acir(inline) fn main f1 {
-        //     b0(v0: [u8; 2]):
-        //       v5 = array_get v0, index u8 0
-        //       v6 = cast v5 as u32
-        //       v8 = truncate v6 to 1 bits, max_bit_size: 32
-        //       v9 = cast v8 as u1
-        //       v10 = allocate
-        //       store u8 0 at v10
-        //       jmpif v9 then: b2, else: b3
-        //     b2():
-        //       v12 = cast v5 as Field
-        //       v13 = add v12, Field 1
-        //       store v13 at v10
-        //       jmp b4()
-        //     b4():
-        //       constrain v9 == u1 1
-        //       return
-        //     b3():
-        //       store u8 0 at v10
-        //       jmp b4()
-        //   }
-        let main_id = Id::test_new(1);
-        let mut builder = FunctionBuilder::new("main".into(), main_id);
-
-        builder.insert_block(); // b0
-        let b1 = builder.insert_block();
-        let b2 = builder.insert_block();
-        let b3 = builder.insert_block();
 
-        let element_type = Arc::new(vec![Type::unsigned(8)]);
-        let array_type = Type::Array(element_type.clone(), 2);
-        let array = builder.add_parameter(array_type);
-
-        let zero = builder.numeric_constant(0_u128, Type::unsigned(8));
-
-        let v5 = builder.insert_array_get(array, zero, Type::unsigned(8));
-        let v6 = builder.insert_cast(v5, Type::unsigned(32));
-        let i_two = builder.numeric_constant(2_u128, Type::unsigned(32));
-        let v8 = builder.insert_binary(v6, BinaryOp::Mod, i_two);
-        let v9 = builder.insert_cast(v8, Type::bool());
-
-        let v10 = builder.insert_allocate(Type::field());
-        builder.insert_store(v10, zero);
-
-        builder.terminate_with_jmpif(v9, b1, b2);
-
-        builder.switch_to_block(b1);
-        let one = builder.field_constant(1_u128);
-        let v5b = builder.insert_cast(v5, Type::field());
-        let v13: Id<Value> = builder.insert_binary(v5b, BinaryOp::Add, one);
-        let v14 = builder.insert_cast(v13, Type::unsigned(8));
-        builder.insert_store(v10, v14);
-        builder.terminate_with_jmp(b3, vec![]);
-
-        builder.switch_to_block(b2);
-        builder.insert_store(v10, zero);
-        builder.terminate_with_jmp(b3, vec![]);
-
-        builder.switch_to_block(b3);
-        let v_true = builder.numeric_constant(true, Type::bool());
-        let v12 = builder.insert_binary(v9, BinaryOp::Eq, v_true);
-        builder.insert_constrain(v12, v_true, None);
-        builder.terminate_with_return(vec![]);
+        let src = "
+        acir(inline) fn main f0 {
+          b0(v0: [u8; 2]):
+            v2 = array_get v0, index u8 0 -> u8
+            v3 = cast v2 as u32
+            v4 = truncate v3 to 1 bits, max_bit_size: 32
+            v5 = cast v4 as u1
+            v6 = allocate -> &mut Field
+            store u8 0 at v6
+            jmpif v5 then: b2, else: b1
+          b2():
+            v7 = cast v2 as Field
+            v9 = add v7, Field 1
+            v10 = cast v9 as u8
+            store v10 at v6
+            jmp b3()
+          b3():
+            constrain v5 == u1 1
+            return
+          b1():
+            store u8 0 at v6
+            jmp b3()
+        }
+        ";
+
+        let ssa = Ssa::from_str(src).unwrap();
+
+        let expected = "
+        acir(inline) fn main f0 {
+          b0(v0: [u8; 2]):
+            v2 = array_get v0, index u8 0 -> u8
+            v3 = cast v2 as u32
+            v4 = truncate v3 to 1 bits, max_bit_size: 32
+            v5 = cast v4 as u1
+            v6 = allocate -> &mut Field
+            store u8 0 at v6
+            enable_side_effects v5
+            v7 = cast v2 as Field
+            v9 = add v7, Field 1
+            v10 = cast v9 as u8
+            v11 = load v6 -> u8
+            v12 = not v5
+            v13 = cast v4 as u8
+            v14 = cast v12 as u8
+            v15 = mul v13, v10
+            v16 = mul v14, v11
+            v17 = add v15, v16
+            store v17 at v6
+            v18 = not v5
+            enable_side_effects v18
+            v19 = load v6 -> u8
+            v20 = cast v18 as u8
+            v21 = cast v4 as u8
+            v22 = mul v21, v19
+            store v22 at v6
+            enable_side_effects u1 1
+            constrain v5 == u1 1
+            return
+        }
+        ";
 
-        let ssa = builder.finish();
         let flattened_ssa = ssa.flatten_cfg();
         let main = flattened_ssa.main();
 
@@ -1566,6 +1339,8 @@ mod test {
             }
         }
         assert_eq!(constrain_count, 1);
+
+        assert_normalized_ssa_equals(flattened_ssa, expected);
     }
 
     #[test]
@@ -1688,4 +1463,23 @@ mod test {
             _ => unreachable!("Should have terminator instruction"),
         }
     }
+
+    #[test]
+    #[should_panic = "ICE: branches merge inside of `then` branch"]
+    fn panics_if_branches_merge_within_then_branch() {
+        //! This is a regression test for https://github.com/noir-lang/noir/issues/6620
+
+        let src = "
+        acir(inline) fn main f0 {
+          b0(v0: u1):
+            jmpif v0 then: b2, else: b1
+          b2():
+            return
+          b1():
+            jmp b2()           
+        }
+        ";
+        let merged_ssa = Ssa::from_str(src).unwrap();
+        let _ = merged_ssa.flatten_cfg();
+    }
 }
diff --git a/compiler/noirc_evaluator/src/ssa/opt/flatten_cfg/capacity_tracker.rs b/compiler/noirc_evaluator/src/ssa/opt/flatten_cfg/capacity_tracker.rs
index 836c812843e..a01be691778 100644
--- a/compiler/noirc_evaluator/src/ssa/opt/flatten_cfg/capacity_tracker.rs
+++ b/compiler/noirc_evaluator/src/ssa/opt/flatten_cfg/capacity_tracker.rs
@@ -21,30 +21,28 @@ impl<'a> SliceCapacityTracker<'a> {
     pub(crate) fn collect_slice_information(
         &self,
         instruction: &Instruction,
-        slice_sizes: &mut HashMap<ValueId, usize>,
+        slice_sizes: &mut HashMap<ValueId, u32>,
         results: &[ValueId],
     ) {
         match instruction {
             Instruction::ArrayGet { array, .. } => {
-                let array_typ = self.dfg.type_of_value(*array);
-                let array_value = &self.dfg[*array];
-                if matches!(array_value, Value::Array { .. }) && array_typ.contains_slice_element()
-                {
-                    // Initial insertion into the slice sizes map
-                    // Any other insertions should only occur if the value is already
-                    // a part of the map.
-                    self.compute_slice_capacity(*array, slice_sizes);
+                if let Some((_, array_type)) = self.dfg.get_array_constant(*array) {
+                    if array_type.contains_slice_element() {
+                        // Initial insertion into the slice sizes map
+                        // Any other insertions should only occur if the value is already
+                        // a part of the map.
+                        self.compute_slice_capacity(*array, slice_sizes);
+                    }
                 }
             }
             Instruction::ArraySet { array, value, .. } => {
-                let array_typ = self.dfg.type_of_value(*array);
-                let array_value = &self.dfg[*array];
-                if matches!(array_value, Value::Array { .. }) && array_typ.contains_slice_element()
-                {
-                    // Initial insertion into the slice sizes map
-                    // Any other insertions should only occur if the value is already
-                    // a part of the map.
-                    self.compute_slice_capacity(*array, slice_sizes);
+                if let Some((_, array_type)) = self.dfg.get_array_constant(*array) {
+                    if array_type.contains_slice_element() {
+                        // Initial insertion into the slice sizes map
+                        // Any other insertions should only occur if the value is already
+                        // a part of the map.
+                        self.compute_slice_capacity(*array, slice_sizes);
+                    }
                 }
 
                 let value_typ = self.dfg.type_of_value(*value);
@@ -99,20 +97,21 @@ impl<'a> SliceCapacityTracker<'a> {
                             let slice_contents = arguments[argument_index];
 
                             if let Some(contents_capacity) = slice_sizes.get(&slice_contents) {
-                                let new_capacity = *contents_capacity - 1;
+                                // We use a saturating sub here as calling `pop_front` or `pop_back`
+                                // on a zero-length slice would otherwise underflow.
+                                let new_capacity = contents_capacity.saturating_sub(1);
                                 slice_sizes.insert(result_slice, new_capacity);
                             }
                         }
                         Intrinsic::ToBits(_) => {
                             // Compiler sanity check
                             assert!(matches!(self.dfg.type_of_value(result_slice), Type::Slice(_)));
-                            slice_sizes.insert(result_slice, FieldElement::max_num_bits() as usize);
+                            slice_sizes.insert(result_slice, FieldElement::max_num_bits());
                         }
                         Intrinsic::ToRadix(_) => {
                             // Compiler sanity check
                             assert!(matches!(self.dfg.type_of_value(result_slice), Type::Slice(_)));
-                            slice_sizes
-                                .insert(result_slice, FieldElement::max_num_bytes() as usize);
+                            slice_sizes.insert(result_slice, FieldElement::max_num_bytes());
                         }
                         Intrinsic::AsSlice => {
                             let array_size = self
@@ -157,15 +156,15 @@ impl<'a> SliceCapacityTracker<'a> {
     pub(crate) fn compute_slice_capacity(
         &self,
         array_id: ValueId,
-        slice_sizes: &mut HashMap<ValueId, usize>,
+        slice_sizes: &mut HashMap<ValueId, u32>,
     ) {
-        if let Value::Array { array, typ } = &self.dfg[array_id] {
+        if let Some((array, typ)) = self.dfg.get_array_constant(array_id) {
             // Compiler sanity check
             assert!(!typ.is_nested_slice(), "ICE: Nested slices are not allowed and should not have reached the flattening pass of SSA");
             if let Type::Slice(_) = typ {
                 let element_size = typ.element_size();
                 let len = array.len() / element_size;
-                slice_sizes.insert(array_id, len);
+                slice_sizes.insert(array_id, len as u32);
             }
         }
     }
diff --git a/compiler/noirc_evaluator/src/ssa/opt/flatten_cfg/value_merger.rs b/compiler/noirc_evaluator/src/ssa/opt/flatten_cfg/value_merger.rs
index 75ee57dd4fa..c2b071a9c9a 100644
--- a/compiler/noirc_evaluator/src/ssa/opt/flatten_cfg/value_merger.rs
+++ b/compiler/noirc_evaluator/src/ssa/opt/flatten_cfg/value_merger.rs
@@ -5,7 +5,7 @@ use crate::ssa::ir::{
     basic_block::BasicBlockId,
     dfg::{CallStack, DataFlowGraph, InsertInstructionResult},
     instruction::{BinaryOp, Instruction},
-    types::Type,
+    types::{NumericType, Type},
     value::{Value, ValueId},
 };
 
@@ -17,7 +17,7 @@ pub(crate) struct ValueMerger<'a> {
 
     // Maps SSA array values with a slice type to their size.
     // This must be computed before merging values.
-    slice_sizes: &'a mut HashMap<ValueId, usize>,
+    slice_sizes: &'a mut HashMap<ValueId, u32>,
 
     array_set_conditionals: &'a mut HashMap<ValueId, ValueId>,
 
@@ -28,7 +28,7 @@ impl<'a> ValueMerger<'a> {
     pub(crate) fn new(
         dfg: &'a mut DataFlowGraph,
         block: BasicBlockId,
-        slice_sizes: &'a mut HashMap<ValueId, usize>,
+        slice_sizes: &'a mut HashMap<ValueId, u32>,
         array_set_conditionals: &'a mut HashMap<ValueId, ValueId>,
         current_condition: Option<ValueId>,
         call_stack: CallStack,
@@ -45,7 +45,7 @@ impl<'a> ValueMerger<'a> {
 
     /// Merge two values a and b from separate basic blocks to a single value.
     /// If these two values are numeric, the result will be
-    /// `then_condition * then_value + else_condition * else_value`.
+    /// `then_condition * (then_value - else_value) + else_value`.
     /// Otherwise, if the values being merged are arrays, a new array will be made
     /// recursively from combining each element of both input arrays.
     ///
@@ -95,8 +95,8 @@ impl<'a> ValueMerger<'a> {
         then_value: ValueId,
         else_value: ValueId,
     ) -> ValueId {
-        let then_type = dfg.type_of_value(then_value);
-        let else_type = dfg.type_of_value(else_value);
+        let then_type = dfg.type_of_value(then_value).unwrap_numeric();
+        let else_type = dfg.type_of_value(else_value).unwrap_numeric();
         assert_eq!(
             then_type, else_type,
             "Expected values merged to be of the same type but found {then_type} and {else_type}"
@@ -112,22 +112,13 @@ impl<'a> ValueMerger<'a> {
         let call_stack = if then_call_stack.is_empty() { else_call_stack } else { then_call_stack };
 
         // We must cast the bool conditions to the actual numeric type used by each value.
-        let then_condition = dfg
-            .insert_instruction_and_results(
-                Instruction::Cast(then_condition, then_type),
-                block,
-                None,
-                call_stack.clone(),
-            )
-            .first();
-        let else_condition = dfg
-            .insert_instruction_and_results(
-                Instruction::Cast(else_condition, else_type),
-                block,
-                None,
-                call_stack.clone(),
-            )
-            .first();
+        let cast = Instruction::Cast(then_condition, then_type);
+        let then_condition =
+            dfg.insert_instruction_and_results(cast, block, None, call_stack.clone()).first();
+
+        let cast = Instruction::Cast(else_condition, else_type);
+        let else_condition =
+            dfg.insert_instruction_and_results(cast, block, None, call_stack.clone()).first();
 
         let mul = Instruction::binary(BinaryOp::Mul, then_condition, then_value);
         let then_value =
@@ -159,7 +150,7 @@ impl<'a> ValueMerger<'a> {
             _ => panic!("Expected array type"),
         };
 
-        let actual_length = len * element_types.len();
+        let actual_length = len * element_types.len() as u32;
 
         if let Some(result) = self.try_merge_only_changed_indices(
             then_condition,
@@ -173,8 +164,9 @@ impl<'a> ValueMerger<'a> {
 
         for i in 0..len {
             for (element_index, element_type) in element_types.iter().enumerate() {
-                let index = ((i * element_types.len() + element_index) as u128).into();
-                let index = self.dfg.make_constant(index, Type::field());
+                let index =
+                    ((i * element_types.len() as u32 + element_index as u32) as u128).into();
+                let index = self.dfg.make_constant(index, NumericType::NativeField);
 
                 let typevars = Some(vec![element_type.clone()]);
 
@@ -202,7 +194,9 @@ impl<'a> ValueMerger<'a> {
             }
         }
 
-        self.dfg.make_array(merged, typ)
+        let instruction = Instruction::MakeArray { elements: merged, typ };
+        let call_stack = self.call_stack.clone();
+        self.dfg.insert_instruction_and_results(instruction, self.block, None, call_stack).first()
     }
 
     fn merge_slice_values(
@@ -224,30 +218,30 @@ impl<'a> ValueMerger<'a> {
             let (slice, typ) = self.dfg.get_array_constant(then_value_id).unwrap_or_else(|| {
                 panic!("ICE: Merging values during flattening encountered slice {then_value_id} without a preset size");
             });
-            slice.len() / typ.element_types().len()
+            (slice.len() / typ.element_types().len()) as u32
         });
 
         let else_len = self.slice_sizes.get(&else_value_id).copied().unwrap_or_else(|| {
             let (slice, typ) = self.dfg.get_array_constant(else_value_id).unwrap_or_else(|| {
                 panic!("ICE: Merging values during flattening encountered slice {else_value_id} without a preset size");
             });
-            slice.len() / typ.element_types().len()
+            (slice.len() / typ.element_types().len()) as u32
         });
 
         let len = then_len.max(else_len);
 
         for i in 0..len {
             for (element_index, element_type) in element_types.iter().enumerate() {
-                let index_usize = i * element_types.len() + element_index;
-                let index_value = (index_usize as u128).into();
-                let index = self.dfg.make_constant(index_value, Type::field());
+                let index_u32 = i * element_types.len() as u32 + element_index as u32;
+                let index_value = (index_u32 as u128).into();
+                let index = self.dfg.make_constant(index_value, NumericType::NativeField);
 
                 let typevars = Some(vec![element_type.clone()]);
 
                 let mut get_element = |array, typevars, len| {
                     // The smaller slice is filled with placeholder data. Codegen for slice accesses must
                     // include checks against the dynamic slice length so that this placeholder data is not incorrectly accessed.
-                    if len <= index_usize {
+                    if len <= index_u32 {
                         self.make_slice_dummy_data(element_type)
                     } else {
                         let get = Instruction::ArrayGet { array, index };
@@ -262,10 +256,13 @@ impl<'a> ValueMerger<'a> {
                     }
                 };
 
-                let then_element =
-                    get_element(then_value_id, typevars.clone(), then_len * element_types.len());
+                let then_element = get_element(
+                    then_value_id,
+                    typevars.clone(),
+                    then_len * element_types.len() as u32,
+                );
                 let else_element =
-                    get_element(else_value_id, typevars, else_len * element_types.len());
+                    get_element(else_value_id, typevars, else_len * element_types.len() as u32);
 
                 merged.push_back(self.merge_values(
                     then_condition,
@@ -276,7 +273,9 @@ impl<'a> ValueMerger<'a> {
             }
         }
 
-        self.dfg.make_array(merged, typ)
+        let instruction = Instruction::MakeArray { elements: merged, typ };
+        let call_stack = self.call_stack.clone();
+        self.dfg.insert_instruction_and_results(instruction, self.block, None, call_stack).first()
     }
 
     /// Construct a dummy value to be attached to the smaller of two slices being merged.
@@ -287,7 +286,7 @@ impl<'a> ValueMerger<'a> {
         match typ {
             Type::Numeric(numeric_type) => {
                 let zero = FieldElement::zero();
-                self.dfg.make_constant(zero, Type::Numeric(*numeric_type))
+                self.dfg.make_constant(zero, *numeric_type)
             }
             Type::Array(element_types, len) => {
                 let mut array = im::Vector::new();
@@ -296,7 +295,11 @@ impl<'a> ValueMerger<'a> {
                         array.push_back(self.make_slice_dummy_data(typ));
                     }
                 }
-                self.dfg.make_array(array, typ.clone())
+                let instruction = Instruction::MakeArray { elements: array, typ: typ.clone() };
+                let call_stack = self.call_stack.clone();
+                self.dfg
+                    .insert_instruction_and_results(instruction, self.block, None, call_stack)
+                    .first()
             }
             Type::Slice(_) => {
                 // TODO(#3188): Need to update flattening to use true user facing length of slices
@@ -318,7 +321,7 @@ impl<'a> ValueMerger<'a> {
         else_condition: ValueId,
         then_value: ValueId,
         else_value: ValueId,
-        array_length: usize,
+        array_length: u32,
     ) -> Option<ValueId> {
         let mut found = false;
         let current_condition = self.current_condition?;
@@ -372,7 +375,7 @@ impl<'a> ValueMerger<'a> {
             .chain(seen_else.into_iter().map(|(_, index, typ, condition)| (index, typ, condition)))
             .collect();
 
-        if !found || changed_indices.len() >= array_length {
+        if !found || changed_indices.len() as u32 >= array_length {
             return None;
         }
 
diff --git a/compiler/noirc_evaluator/src/ssa/opt/hint.rs b/compiler/noirc_evaluator/src/ssa/opt/hint.rs
new file mode 100644
index 00000000000..567a0795edc
--- /dev/null
+++ b/compiler/noirc_evaluator/src/ssa/opt/hint.rs
@@ -0,0 +1,105 @@
+#[cfg(test)]
+mod tests {
+    use acvm::acir::circuit::ExpressionWidth;
+
+    use crate::{
+        errors::RuntimeError,
+        ssa::{
+            opt::assert_normalized_ssa_equals, optimize_all, Ssa, SsaBuilder, SsaEvaluatorOptions,
+            SsaLogging,
+        },
+    };
+
+    fn run_all_passes(ssa: Ssa) -> Result<Ssa, RuntimeError> {
+        let options = &SsaEvaluatorOptions {
+            ssa_logging: SsaLogging::None,
+            enable_brillig_logging: false,
+            force_brillig_output: false,
+            print_codegen_timings: false,
+            expression_width: ExpressionWidth::default(),
+            emit_ssa: None,
+            skip_underconstrained_check: true,
+            skip_brillig_constraints_check: true,
+            inliner_aggressiveness: 0,
+            max_bytecode_increase_percent: None,
+        };
+
+        let builder = SsaBuilder {
+            ssa,
+            ssa_logging: options.ssa_logging.clone(),
+            print_codegen_timings: false,
+        };
+
+        optimize_all(builder, options)
+    }
+
+    /// Test that the `std::hint::black_box` function prevents some of the optimizations.
+    #[test]
+    fn test_black_box_hint() {
+        // fn main(sum: u32) {
+        //     // This version simplifies into a single `constraint 50 == sum`
+        //     assert_eq(loop(5, 10), sum);
+        //     // This should preserve additions because `k` is opaque, as if it came from an input.
+        //     assert_eq(loop(5, std::hint::black_box(10)), sum);
+        // }
+        // fn loop(n: u32, k: u32) -> u32 {
+        //     let mut sum = 0;
+        //     for _ in 0..n {
+        //         sum = sum + k;
+        //     }
+        //     sum
+        // }
+
+        // Initial SSA:
+        let src = "
+          acir(inline) fn main f0 {
+            b0(v0: u32):
+              v4 = call f1(u32 5, u32 10) -> u32
+              v5 = eq v4, v0
+              constrain v4 == v0
+              v7 = call black_box(u32 10) -> u32
+              v9 = call f1(u32 5, v7) -> u32
+              v10 = eq v9, v0
+              constrain v9 == v0
+              return
+          }
+          acir(inline) fn loop f1 {
+            b0(v0: u32, v1: u32):
+              v3 = allocate -> &mut u32
+              store u32 0 at v3
+              jmp b1(u32 0)
+            b1(v2: u32):
+              v5 = lt v2, v0
+              jmpif v5 then: b3, else: b2
+            b3():
+              v7 = load v3 -> u32
+              v8 = add v7, v1
+              store v8 at v3
+              v10 = add v2, u32 1
+              jmp b1(v10)
+            b2():
+              v6 = load v3 -> u32
+              return v6
+          }
+        ";
+
+        // After Array Set Optimizations:
+        let expected = "
+          acir(inline) fn main f0 {
+            b0(v0: u32):
+              constrain u32 50 == v0
+              v4 = call black_box(u32 10) -> u32
+              v5 = add v4, v4
+              v6 = add v5, v4
+              v7 = add v6, v4
+              v8 = add v7, v4
+              constrain v8 == u32 50
+              return
+          }
+        ";
+
+        let ssa = Ssa::from_str(src).unwrap();
+        let ssa = run_all_passes(ssa).unwrap();
+        assert_normalized_ssa_equals(ssa, expected);
+    }
+}
diff --git a/compiler/noirc_evaluator/src/ssa/opt/inlining.rs b/compiler/noirc_evaluator/src/ssa/opt/inlining.rs
index 7843c55da65..37659ec7c98 100644
--- a/compiler/noirc_evaluator/src/ssa/opt/inlining.rs
+++ b/compiler/noirc_evaluator/src/ssa/opt/inlining.rs
@@ -44,30 +44,32 @@ impl Ssa {
     ///
     /// This step should run after runtime separation, since it relies on the runtime of the called functions being final.
     #[tracing::instrument(level = "trace", skip(self))]
-    pub(crate) fn inline_functions(self) -> Ssa {
-        Self::inline_functions_inner(self, false)
+    pub(crate) fn inline_functions(self, aggressiveness: i64) -> Ssa {
+        Self::inline_functions_inner(self, aggressiveness, false)
     }
 
     // Run the inlining pass where functions marked with `InlineType::NoPredicates` as not entry points
-    pub(crate) fn inline_functions_with_no_predicates(self) -> Ssa {
-        Self::inline_functions_inner(self, true)
-    }
-
-    fn inline_functions_inner(mut self, inline_no_predicates_functions: bool) -> Ssa {
-        let recursive_functions = find_all_recursive_functions(&self);
-        self.functions = btree_map(
-            get_functions_to_inline_into(&self, inline_no_predicates_functions),
-            |entry_point| {
-                let new_function = InlineContext::new(
-                    &self,
-                    entry_point,
-                    inline_no_predicates_functions,
-                    recursive_functions.clone(),
-                )
-                .inline_all(&self);
-                (entry_point, new_function)
-            },
-        );
+    pub(crate) fn inline_functions_with_no_predicates(self, aggressiveness: i64) -> Ssa {
+        Self::inline_functions_inner(self, aggressiveness, true)
+    }
+
+    fn inline_functions_inner(
+        mut self,
+        aggressiveness: i64,
+        inline_no_predicates_functions: bool,
+    ) -> Ssa {
+        let inline_sources =
+            get_functions_to_inline_into(&self, inline_no_predicates_functions, aggressiveness);
+        self.functions = btree_map(&inline_sources, |entry_point| {
+            let new_function = InlineContext::new(
+                &self,
+                *entry_point,
+                inline_no_predicates_functions,
+                inline_sources.clone(),
+            )
+            .inline_all(&self);
+            (*entry_point, new_function)
+        });
         self
     }
 }
@@ -93,8 +95,8 @@ struct InlineContext {
     /// the control flow graph has been flattened.
     inline_no_predicates_functions: bool,
 
-    // We keep track of the recursive functions in the SSA to avoid inlining them in a brillig context.
-    recursive_functions: BTreeSet<FunctionId>,
+    // These are the functions of the program that we shouldn't inline.
+    functions_not_to_inline: BTreeSet<FunctionId>,
 }
 
 /// The per-function inlining context contains information that is only valid for one function.
@@ -129,8 +131,8 @@ struct PerFunctionContext<'function> {
 }
 
 /// Utility function to find out the direct calls of a function.
-fn called_functions(func: &Function) -> BTreeSet<FunctionId> {
-    let mut called_function_ids = BTreeSet::default();
+fn called_functions_vec(func: &Function) -> Vec<FunctionId> {
+    let mut called_function_ids = Vec::new();
     for block_id in func.reachable_blocks() {
         for instruction_id in func.dfg[block_id].instructions() {
             let Instruction::Call { func: called_value_id, .. } = &func.dfg[*instruction_id] else {
@@ -138,7 +140,7 @@ fn called_functions(func: &Function) -> BTreeSet<FunctionId> {
             };
 
             if let Value::Function(function_id) = func.dfg[*called_value_id] {
-                called_function_ids.insert(function_id);
+                called_function_ids.push(function_id);
             }
         }
     }
@@ -146,52 +148,32 @@ fn called_functions(func: &Function) -> BTreeSet<FunctionId> {
     called_function_ids
 }
 
-// Recursively explore the SSA to find the functions that end up calling themselves
-fn find_recursive_functions(
-    ssa: &Ssa,
-    current_function: FunctionId,
-    mut explored_functions: im::HashSet<FunctionId>,
-    recursive_functions: &mut BTreeSet<FunctionId>,
-) {
-    if explored_functions.contains(&current_function) {
-        recursive_functions.insert(current_function);
-        return;
-    }
-
-    let called_functions = called_functions(&ssa.functions[&current_function]);
-
-    explored_functions.insert(current_function);
-
-    for called_function in called_functions {
-        find_recursive_functions(
-            ssa,
-            called_function,
-            explored_functions.clone(),
-            recursive_functions,
-        );
-    }
-}
-
-fn find_all_recursive_functions(ssa: &Ssa) -> BTreeSet<FunctionId> {
-    let mut recursive_functions = BTreeSet::default();
-    find_recursive_functions(ssa, ssa.main_id, im::HashSet::default(), &mut recursive_functions);
-    recursive_functions
+/// Utility function to find out the deduplicated direct calls of a function.
+fn called_functions(func: &Function) -> BTreeSet<FunctionId> {
+    called_functions_vec(func).into_iter().collect()
 }
 
 /// The functions we should inline into (and that should be left in the final program) are:
 ///  - main
 ///  - Any Brillig function called from Acir
-///  - Any Brillig recursive function (Acir recursive functions will be inlined into the main function)
+///  - Some Brillig functions depending on aggressiveness and some metrics
 ///  - Any Acir functions with a [fold inline type][InlineType::Fold],
 fn get_functions_to_inline_into(
     ssa: &Ssa,
     inline_no_predicates_functions: bool,
+    aggressiveness: i64,
 ) -> BTreeSet<FunctionId> {
     let mut brillig_entry_points = BTreeSet::default();
     let mut acir_entry_points = BTreeSet::default();
 
+    if matches!(ssa.main().runtime(), RuntimeType::Brillig(_)) {
+        brillig_entry_points.insert(ssa.main_id);
+    } else {
+        acir_entry_points.insert(ssa.main_id);
+    }
+
     for (func_id, function) in ssa.functions.iter() {
-        if function.runtime() == RuntimeType::Brillig {
+        if matches!(function.runtime(), RuntimeType::Brillig(_)) {
             continue;
         }
 
@@ -203,27 +185,167 @@ fn get_functions_to_inline_into(
         }
 
         for called_function_id in called_functions(function) {
-            if ssa.functions[&called_function_id].runtime() == RuntimeType::Brillig {
+            if matches!(ssa.functions[&called_function_id].runtime(), RuntimeType::Brillig(_)) {
                 brillig_entry_points.insert(called_function_id);
             }
         }
     }
 
-    let brillig_recursive_functions: BTreeSet<_> = find_all_recursive_functions(ssa)
+    let times_called = compute_times_called(ssa);
+
+    let brillig_functions_to_retain: BTreeSet<_> = compute_functions_to_retain(
+        ssa,
+        &brillig_entry_points,
+        &times_called,
+        inline_no_predicates_functions,
+        aggressiveness,
+    );
+
+    acir_entry_points
         .into_iter()
-        .filter(|recursive_function_id| {
-            let function = &ssa.functions[&recursive_function_id];
-            function.runtime() == RuntimeType::Brillig
+        .chain(brillig_entry_points)
+        .chain(brillig_functions_to_retain)
+        .collect()
+}
+
+fn compute_times_called(ssa: &Ssa) -> HashMap<FunctionId, usize> {
+    ssa.functions
+        .iter()
+        .flat_map(|(_caller_id, function)| {
+            let called_functions_vec = called_functions_vec(function);
+            called_functions_vec.into_iter()
+        })
+        .chain(std::iter::once(ssa.main_id))
+        .fold(HashMap::default(), |mut map, func_id| {
+            *map.entry(func_id).or_insert(0) += 1;
+            map
         })
-        .collect();
+}
 
-    std::iter::once(ssa.main_id)
-        .chain(acir_entry_points)
-        .chain(brillig_entry_points)
-        .chain(brillig_recursive_functions)
+fn should_retain_recursive(
+    ssa: &Ssa,
+    func: FunctionId,
+    times_called: &HashMap<FunctionId, usize>,
+    should_retain_function: &mut HashMap<FunctionId, (bool, i64)>,
+    mut explored_functions: im::HashSet<FunctionId>,
+    inline_no_predicates_functions: bool,
+    aggressiveness: i64,
+) {
+    // We have already decided on this function
+    if should_retain_function.get(&func).is_some() {
+        return;
+    }
+    // Recursive, this function won't be inlined
+    if explored_functions.contains(&func) {
+        should_retain_function.insert(func, (true, 0));
+        return;
+    }
+    explored_functions.insert(func);
+
+    // Decide on dependencies first
+    let called_functions = called_functions(&ssa.functions[&func]);
+    for function in called_functions.iter() {
+        should_retain_recursive(
+            ssa,
+            *function,
+            times_called,
+            should_retain_function,
+            explored_functions.clone(),
+            inline_no_predicates_functions,
+            aggressiveness,
+        );
+    }
+    // We could have decided on this function while deciding on dependencies
+    // If the function is recursive
+    if should_retain_function.get(&func).is_some() {
+        return;
+    }
+
+    // We'll use some heuristics to decide whether to inline or not.
+    // We compute the weight (roughly the number of instructions) of the function after inlining
+    // And the interface cost of the function (the inherent cost at the callsite, roughly the number of args and returns)
+    // We then can compute an approximation of the cost of inlining vs the cost of retaining the function
+    // We do this computation using saturating i64s to avoid overflows
+    let inlined_function_weights: i64 = called_functions.iter().fold(0, |acc, called_function| {
+        let (should_retain, weight) = should_retain_function[called_function];
+        if should_retain {
+            acc
+        } else {
+            acc.saturating_add(weight)
+        }
+    });
+
+    let this_function_weight = inlined_function_weights
+        .saturating_add(compute_function_own_weight(&ssa.functions[&func]) as i64);
+
+    let interface_cost = compute_function_interface_cost(&ssa.functions[&func]) as i64;
+
+    let times_called = times_called[&func] as i64;
+
+    let inline_cost = times_called.saturating_mul(this_function_weight);
+    let retain_cost = times_called.saturating_mul(interface_cost) + this_function_weight;
+
+    let runtime = ssa.functions[&func].runtime();
+    // We inline if the aggressiveness is higher than inline cost minus the retain cost
+    // If aggressiveness is infinite, we'll always inline
+    // If aggressiveness is 0, we'll inline when the inline cost is lower than the retain cost
+    // If aggressiveness is minus infinity, we'll never inline (other than in the mandatory cases)
+    let should_inline = ((inline_cost.saturating_sub(retain_cost)) < aggressiveness)
+        || runtime.is_inline_always()
+        || (runtime.is_no_predicates() && inline_no_predicates_functions);
+
+    should_retain_function.insert(func, (!should_inline, this_function_weight));
+}
+
+fn compute_functions_to_retain(
+    ssa: &Ssa,
+    entry_points: &BTreeSet<FunctionId>,
+    times_called: &HashMap<FunctionId, usize>,
+    inline_no_predicates_functions: bool,
+    aggressiveness: i64,
+) -> BTreeSet<FunctionId> {
+    let mut should_retain_function = HashMap::default();
+
+    for entry_point in entry_points.iter() {
+        should_retain_recursive(
+            ssa,
+            *entry_point,
+            times_called,
+            &mut should_retain_function,
+            im::HashSet::default(),
+            inline_no_predicates_functions,
+            aggressiveness,
+        );
+    }
+
+    should_retain_function
+        .into_iter()
+        .filter_map(
+            |(func_id, (should_retain, _))| {
+                if should_retain {
+                    Some(func_id)
+                } else {
+                    None
+                }
+            },
+        )
         .collect()
 }
 
+fn compute_function_own_weight(func: &Function) -> usize {
+    let mut weight = 0;
+    for block_id in func.reachable_blocks() {
+        weight += func.dfg[block_id].instructions().len() + 1; // We add one for the terminator
+    }
+    // We use an approximation of the average increase in instruction ratio from SSA to Brillig
+    // In order to get the actual weight we'd need to codegen this function to brillig.
+    weight
+}
+
+fn compute_function_interface_cost(func: &Function) -> usize {
+    func.parameters().len() + func.returns().len()
+}
+
 impl InlineContext {
     /// Create a new context object for the function inlining pass.
     /// This starts off with an empty mapping of instructions for main's parameters.
@@ -234,7 +356,7 @@ impl InlineContext {
         ssa: &Ssa,
         entry_point: FunctionId,
         inline_no_predicates_functions: bool,
-        recursive_functions: BTreeSet<FunctionId>,
+        functions_not_to_inline: BTreeSet<FunctionId>,
     ) -> InlineContext {
         let source = &ssa.functions[&entry_point];
         let mut builder = FunctionBuilder::new(source.name().to_owned(), entry_point);
@@ -245,7 +367,7 @@ impl InlineContext {
             entry_point,
             call_stack: CallStack::new(),
             inline_no_predicates_functions,
-            recursive_functions,
+            functions_not_to_inline,
         }
     }
 
@@ -291,13 +413,14 @@ impl InlineContext {
     ) -> Vec<ValueId> {
         self.recursion_level += 1;
 
+        let source_function = &ssa.functions[&id];
+
         if self.recursion_level > RECURSION_LIMIT {
             panic!(
-                "Attempted to recur more than {RECURSION_LIMIT} times during function inlining."
+                "Attempted to recur more than {RECURSION_LIMIT} times during inlining function '{}': {}", source_function.name(), source_function
             );
         }
 
-        let source_function = &ssa.functions[&id];
         let mut context = PerFunctionContext::new(self, source_function);
 
         let parameters = source_function.parameters();
@@ -346,17 +469,13 @@ impl<'function> PerFunctionContext<'function> {
                 unreachable!("All Value::Params should already be known from previous calls to translate_block. Unknown value {id} = {value:?}")
             }
             Value::NumericConstant { constant, typ } => {
-                self.context.builder.numeric_constant(*constant, typ.clone())
+                self.context.builder.numeric_constant(*constant, *typ)
             }
             Value::Function(function) => self.context.builder.import_function(*function),
             Value::Intrinsic(intrinsic) => self.context.builder.import_intrinsic_id(*intrinsic),
             Value::ForeignFunction(function) => {
                 self.context.builder.import_foreign_function(function)
             }
-            Value::Array { array, typ } => {
-                let elements = array.iter().map(|value| self.translate_value(*value)).collect();
-                self.context.builder.array_constant(elements, typ.clone())
-            }
         };
 
         self.values.insert(id, new_value);
@@ -525,8 +644,8 @@ impl<'function> PerFunctionContext<'function> {
             !inline_type.is_entry_point() && !preserve_function
         } else {
             // If the called function is brillig, we inline only if it's into brillig and the function is not recursive
-            ssa.functions[&self.context.entry_point].runtime() == RuntimeType::Brillig
-                && !self.context.recursive_functions.contains(&called_func_id)
+            matches!(ssa.functions[&self.context.entry_point].runtime(), RuntimeType::Brillig(_))
+                && !self.context.functions_not_to_inline.contains(&called_func_id)
         }
     }
 
@@ -695,9 +814,10 @@ mod test {
         function_builder::FunctionBuilder,
         ir::{
             basic_block::BasicBlockId,
+            function::RuntimeType,
             instruction::{BinaryOp, Intrinsic, TerminatorInstruction},
             map::Id,
-            types::Type,
+            types::{NumericType, Type},
         },
     };
 
@@ -728,7 +848,7 @@ mod test {
         let ssa = builder.finish();
         assert_eq!(ssa.functions.len(), 2);
 
-        let inlined = ssa.inline_functions();
+        let inlined = ssa.inline_functions(i64::MAX);
         assert_eq!(inlined.functions.len(), 1);
     }
 
@@ -794,7 +914,7 @@ mod test {
         let ssa = builder.finish();
         assert_eq!(ssa.functions.len(), 4);
 
-        let inlined = ssa.inline_functions();
+        let inlined = ssa.inline_functions(i64::MAX);
         assert_eq!(inlined.functions.len(), 1);
     }
 
@@ -868,7 +988,7 @@ mod test {
         //   b6():
         //     return Field 120
         // }
-        let inlined = ssa.inline_functions();
+        let inlined = ssa.inline_functions(i64::MAX);
         assert_eq!(inlined.functions.len(), 1);
 
         let main = inlined.main();
@@ -942,16 +1062,16 @@ mod test {
         let join_block = builder.insert_block();
         builder.terminate_with_jmpif(inner2_cond, then_block, else_block);
         builder.switch_to_block(then_block);
-        let one = builder.numeric_constant(FieldElement::one(), Type::field());
+        let one = builder.field_constant(FieldElement::one());
         builder.terminate_with_jmp(join_block, vec![one]);
         builder.switch_to_block(else_block);
-        let two = builder.numeric_constant(FieldElement::from(2_u128), Type::field());
+        let two = builder.field_constant(FieldElement::from(2_u128));
         builder.terminate_with_jmp(join_block, vec![two]);
         let join_param = builder.add_block_parameter(join_block, Type::field());
         builder.switch_to_block(join_block);
         builder.terminate_with_return(vec![join_param]);
 
-        let ssa = builder.finish().inline_functions();
+        let ssa = builder.finish().inline_functions(i64::MAX);
         // Expected result:
         // fn main f3 {
         //   b0(v0: u1):
@@ -967,4 +1087,116 @@ mod test {
         let main = ssa.main();
         assert_eq!(main.reachable_blocks().len(), 4);
     }
+
+    #[test]
+    #[should_panic(
+        expected = "Attempted to recur more than 1000 times during inlining function 'main': acir(inline) fn main f0 {"
+    )]
+    fn unconditional_recursion() {
+        // fn main f1 {
+        //   b0():
+        //     call f1()
+        //     return
+        // }
+        let main_id = Id::test_new(0);
+        let mut builder = FunctionBuilder::new("main".into(), main_id);
+
+        let main = builder.import_function(main_id);
+        let results = builder.insert_call(main, Vec::new(), vec![]).to_vec();
+        builder.terminate_with_return(results);
+
+        let ssa = builder.finish();
+        assert_eq!(ssa.functions.len(), 1);
+
+        let inlined = ssa.inline_functions(i64::MAX);
+        assert_eq!(inlined.functions.len(), 0);
+    }
+
+    #[test]
+    fn inliner_disabled() {
+        // brillig fn foo {
+        //   b0():
+        //     v0 = call bar()
+        //     return v0
+        // }
+        // brillig fn bar {
+        //   b0():
+        //     return 72
+        // }
+        let foo_id = Id::test_new(0);
+        let mut builder = FunctionBuilder::new("foo".into(), foo_id);
+        builder.set_runtime(RuntimeType::Brillig(InlineType::default()));
+
+        let bar_id = Id::test_new(1);
+        let bar = builder.import_function(bar_id);
+        let results = builder.insert_call(bar, Vec::new(), vec![Type::field()]).to_vec();
+        builder.terminate_with_return(results);
+
+        builder.new_brillig_function("bar".into(), bar_id, InlineType::default());
+        let expected_return = 72u128;
+        let seventy_two = builder.field_constant(expected_return);
+        builder.terminate_with_return(vec![seventy_two]);
+
+        let ssa = builder.finish();
+        assert_eq!(ssa.functions.len(), 2);
+
+        let inlined = ssa.inline_functions(i64::MIN);
+        // No inlining has happened
+        assert_eq!(inlined.functions.len(), 2);
+    }
+
+    #[test]
+    fn conditional_inlining() {
+        // In this example we call a larger brillig function 3 times so the inliner refuses to inline the function.
+        // brillig fn foo {
+        //   b0():
+        //     v0 = call bar()
+        //     v1 = call bar()
+        //     v2 = call bar()
+        //     return v0
+        // }
+        // brillig fn bar {
+        //   b0():
+        //     jmpif 1 then: b1, else: b2
+        //   b1():
+        //     jmp b3(Field 1)
+        //   b3(v3: Field):
+        //     return v3
+        //   b2():
+        //     jmp b3(Field 2)
+        // }
+        let foo_id = Id::test_new(0);
+        let mut builder = FunctionBuilder::new("foo".into(), foo_id);
+        builder.set_runtime(RuntimeType::Brillig(InlineType::default()));
+
+        let bar_id = Id::test_new(1);
+        let bar = builder.import_function(bar_id);
+        let v0 = builder.insert_call(bar, Vec::new(), vec![Type::field()]).to_vec();
+        let _v1 = builder.insert_call(bar, Vec::new(), vec![Type::field()]).to_vec();
+        let _v2 = builder.insert_call(bar, Vec::new(), vec![Type::field()]).to_vec();
+        builder.terminate_with_return(v0);
+
+        builder.new_brillig_function("bar".into(), bar_id, InlineType::default());
+        let bar_v0 = builder.numeric_constant(1_usize, NumericType::bool());
+        let then_block = builder.insert_block();
+        let else_block = builder.insert_block();
+        let join_block = builder.insert_block();
+        builder.terminate_with_jmpif(bar_v0, then_block, else_block);
+        builder.switch_to_block(then_block);
+        let one = builder.field_constant(FieldElement::one());
+        builder.terminate_with_jmp(join_block, vec![one]);
+        builder.switch_to_block(else_block);
+        let two = builder.field_constant(FieldElement::from(2_u128));
+        builder.terminate_with_jmp(join_block, vec![two]);
+        let join_param = builder.add_block_parameter(join_block, Type::field());
+        builder.switch_to_block(join_block);
+        builder.terminate_with_return(vec![join_param]);
+
+        let ssa = builder.finish();
+        assert_eq!(ssa.functions.len(), 2);
+
+        let inlined = ssa.inline_functions(0);
+        // No inlining has happened
+        assert_eq!(inlined.functions.len(), 2);
+    }
 }
diff --git a/compiler/noirc_evaluator/src/ssa/opt/loop_invariant.rs b/compiler/noirc_evaluator/src/ssa/opt/loop_invariant.rs
new file mode 100644
index 00000000000..7e4546083b8
--- /dev/null
+++ b/compiler/noirc_evaluator/src/ssa/opt/loop_invariant.rs
@@ -0,0 +1,665 @@
+//! The loop invariant code motion pass moves code from inside a loop to before the loop
+//! if that code will always have the same result on every iteration of the loop.
+//!
+//! To identify a loop invariant, check whether all of an instruction's values are:
+//! - Outside of the loop
+//! - Constant
+//! - Already marked as loop invariants
+//!
+//! We also check that we are not hoisting instructions with side effects.
+use acvm::{acir::AcirField, FieldElement};
+use fxhash::{FxHashMap as HashMap, FxHashSet as HashSet};
+
+use crate::ssa::{
+    ir::{
+        basic_block::BasicBlockId,
+        function::Function,
+        function_inserter::FunctionInserter,
+        instruction::{Instruction, InstructionId},
+        types::Type,
+        value::ValueId,
+    },
+    Ssa,
+};
+
+use super::unrolling::{Loop, Loops};
+
+impl Ssa {
+    #[tracing::instrument(level = "trace", skip(self))]
+    pub(crate) fn loop_invariant_code_motion(mut self) -> Ssa {
+        for function in self.functions.values_mut() {
+            function.loop_invariant_code_motion();
+        }
+
+        self
+    }
+}
+
+impl Function {
+    fn loop_invariant_code_motion(&mut self) {
+        Loops::find_all(self).hoist_loop_invariants(self);
+    }
+}
+
+impl Loops {
+    fn hoist_loop_invariants(mut self, function: &mut Function) {
+        let mut context = LoopInvariantContext::new(function);
+
+        // The loops should be sorted by the number of blocks.
+        // We want to access outer nested loops first, which we do by popping
+        // from the top of the list.
+        while let Some(loop_) = self.yet_to_unroll.pop() {
+            let Ok(pre_header) = loop_.get_pre_header(context.inserter.function, &self.cfg) else {
+                // If the loop does not have a preheader we skip hoisting loop invariants for this loop
+                continue;
+            };
+
+            context.hoist_loop_invariants(&loop_, pre_header);
+        }
+
+        context.map_dependent_instructions();
+        context.inserter.map_data_bus_in_place();
+    }
+}
+
+impl Loop {
+    /// Find the value that controls whether to perform a loop iteration.
+    /// This is going to be the block parameter of the loop header.
+    ///
+    /// Consider the following example of a `for i in 0..4` loop:
+    /// ```text
+    /// brillig(inline) fn main f0 {
+    ///   b0(v0: u32):
+    ///     ...
+    ///     jmp b1(u32 0)
+    ///   b1(v1: u32):                  // Loop header
+    ///     v5 = lt v1, u32 4           // Upper bound
+    ///     jmpif v5 then: b3, else: b2
+    /// ```
+    /// In the example above, `v1` is the induction variable
+    fn get_induction_variable(&self, function: &Function) -> ValueId {
+        function.dfg.block_parameters(self.header)[0]
+    }
+}
+
+struct LoopInvariantContext<'f> {
+    inserter: FunctionInserter<'f>,
+    defined_in_loop: HashSet<ValueId>,
+    loop_invariants: HashSet<ValueId>,
+    // Maps induction variable -> fixed upper loop bound
+    outer_induction_variables: HashMap<ValueId, FieldElement>,
+}
+
+impl<'f> LoopInvariantContext<'f> {
+    fn new(function: &'f mut Function) -> Self {
+        Self {
+            inserter: FunctionInserter::new(function),
+            defined_in_loop: HashSet::default(),
+            loop_invariants: HashSet::default(),
+            outer_induction_variables: HashMap::default(),
+        }
+    }
+
+    fn hoist_loop_invariants(&mut self, loop_: &Loop, pre_header: BasicBlockId) {
+        self.set_values_defined_in_loop(loop_);
+
+        for block in loop_.blocks.iter() {
+            for instruction_id in self.inserter.function.dfg[*block].take_instructions() {
+                let hoist_invariant = self.can_hoist_invariant(instruction_id);
+
+                if hoist_invariant {
+                    self.inserter.push_instruction(instruction_id, pre_header);
+
+                    // If we are hoisting a MakeArray instruction,
+                    // we need to issue an extra inc_rc in case they are mutated afterward.
+                    if matches!(
+                        self.inserter.function.dfg[instruction_id],
+                        Instruction::MakeArray { .. }
+                    ) {
+                        let result =
+                            self.inserter.function.dfg.instruction_results(instruction_id)[0];
+                        let inc_rc = Instruction::IncrementRc { value: result };
+                        let call_stack = self.inserter.function.dfg.get_call_stack(instruction_id);
+                        self.inserter
+                            .function
+                            .dfg
+                            .insert_instruction_and_results(inc_rc, *block, None, call_stack);
+                    }
+                } else {
+                    self.inserter.push_instruction(instruction_id, *block);
+                }
+
+                self.extend_values_defined_in_loop_and_invariants(instruction_id, hoist_invariant);
+            }
+        }
+
+        // Keep track of a loop induction variable and respective upper bound.
+        // This will be used by later loops to determine whether they have operations
+        // reliant upon the maximum induction variable.
+        let upper_bound = loop_.get_const_upper_bound(self.inserter.function);
+        if let Some(upper_bound) = upper_bound {
+            let induction_variable = loop_.get_induction_variable(self.inserter.function);
+            let induction_variable = self.inserter.resolve(induction_variable);
+            self.outer_induction_variables.insert(induction_variable, upper_bound);
+        }
+    }
+
+    /// Gather the variables declared within the loop
+    fn set_values_defined_in_loop(&mut self, loop_: &Loop) {
+        // Clear any values that may be defined in previous loops, as the context is per function.
+        self.defined_in_loop.clear();
+        // These are safe to keep per function, but we want to be clear that these values
+        // are used per loop.
+        self.loop_invariants.clear();
+
+        for block in loop_.blocks.iter() {
+            let params = self.inserter.function.dfg.block_parameters(*block);
+            self.defined_in_loop.extend(params);
+            for instruction_id in self.inserter.function.dfg[*block].instructions() {
+                let results = self.inserter.function.dfg.instruction_results(*instruction_id);
+                self.defined_in_loop.extend(results);
+            }
+        }
+    }
+
+    /// Update any values defined in the loop and loop invariants after a
+    /// analyzing and re-inserting a loop's instruction.
+    fn extend_values_defined_in_loop_and_invariants(
+        &mut self,
+        instruction_id: InstructionId,
+        hoist_invariant: bool,
+    ) {
+        let results = self.inserter.function.dfg.instruction_results(instruction_id).to_vec();
+        // We will have new IDs after pushing instructions.
+        // We should mark the resolved result IDs as also being defined within the loop.
+        let results =
+            results.into_iter().map(|value| self.inserter.resolve(value)).collect::<Vec<_>>();
+        self.defined_in_loop.extend(results.iter());
+
+        // We also want the update result IDs when we are marking loop invariants as we may not
+        // be going through the blocks of the loop in execution order
+        if hoist_invariant {
+            // Track already found loop invariants
+            self.loop_invariants.extend(results.iter());
+        }
+    }
+
+    fn can_hoist_invariant(&mut self, instruction_id: InstructionId) -> bool {
+        let mut is_loop_invariant = true;
+        // The list of blocks for a nested loop contain any inner loops as well.
+        // We may have already re-inserted new instructions if two loops share blocks
+        // so we need to map all the values in the instruction which we want to check.
+        let (instruction, _) = self.inserter.map_instruction(instruction_id);
+        instruction.for_each_value(|value| {
+            // If an instruction value is defined in the loop and not already a loop invariant
+            // the instruction results are not loop invariants.
+            //
+            // We are implicitly checking whether the values are constant as well.
+            // The set of values defined in the loop only contains instruction results and block parameters
+            // which cannot be constants.
+            is_loop_invariant &=
+                !self.defined_in_loop.contains(&value) || self.loop_invariants.contains(&value);
+        });
+
+        let can_be_deduplicated = instruction.can_be_deduplicated(self.inserter.function, false)
+            || matches!(instruction, Instruction::MakeArray { .. })
+            || self.can_be_deduplicated_from_upper_bound(&instruction);
+
+        is_loop_invariant && can_be_deduplicated
+    }
+
+    /// Certain instructions can take advantage of that our induction variable has a fixed maximum.
+    ///
+    /// For example, an array access can usually only be safely deduplicated when we have a constant
+    /// index that is below the length of the array.
+    /// Checking an array get where the index is the loop's induction variable on its own
+    /// would determine that the instruction is not safe for hoisting.
+    /// However, if we know that the induction variable's upper bound will always be in bounds of the array
+    /// we can safely hoist the array access.
+    fn can_be_deduplicated_from_upper_bound(&self, instruction: &Instruction) -> bool {
+        match instruction {
+            Instruction::ArrayGet { array, index } => {
+                let array_typ = self.inserter.function.dfg.type_of_value(*array);
+                let upper_bound = self.outer_induction_variables.get(index);
+                if let (Type::Array(_, len), Some(upper_bound)) = (array_typ, upper_bound) {
+                    upper_bound.to_u128() <= len.into()
+                } else {
+                    false
+                }
+            }
+            _ => false,
+        }
+    }
+
+    /// Loop invariant hoisting only operates over loop instructions.
+    /// The `FunctionInserter` is used for mapping old values to new values after
+    /// re-inserting loop invariant instructions.
+    /// However, there may be instructions which are not within loops that are
+    /// still reliant upon the instruction results altered during the pass.
+    /// This method re-inserts all instructions so that all instructions have
+    /// correct new value IDs based upon the `FunctionInserter` internal map.
+    /// Leaving out this mapping could lead to instructions with values that do not exist.
+    fn map_dependent_instructions(&mut self) {
+        let blocks = self.inserter.function.reachable_blocks();
+        for block in blocks {
+            for instruction_id in self.inserter.function.dfg[block].take_instructions() {
+                self.inserter.push_instruction(instruction_id, block);
+            }
+            self.inserter.map_terminator_in_place(block);
+        }
+    }
+}
+
+#[cfg(test)]
+mod test {
+    use crate::ssa::opt::assert_normalized_ssa_equals;
+    use crate::ssa::Ssa;
+
+    #[test]
+    fn simple_loop_invariant_code_motion() {
+        let src = "
+        brillig(inline) fn main f0 {
+          b0(v0: u32, v1: u32):
+              jmp b1(u32 0)
+          b1(v2: u32):
+              v5 = lt v2, u32 4
+              jmpif v5 then: b3, else: b2
+          b2():
+              return
+          b3():
+              v6 = mul v0, v1
+              constrain v6 == u32 6
+              v8 = add v2, u32 1
+              jmp b1(v8)
+        }
+        ";
+
+        let mut ssa = Ssa::from_str(src).unwrap();
+        let main = ssa.main_mut();
+
+        let instructions = main.dfg[main.entry_block()].instructions();
+        assert_eq!(instructions.len(), 0); // The final return is not counted
+
+        // `v6 = mul v0, v1` in b3 should now be `v3 = mul v0, v1` in b0
+        let expected = "
+        brillig(inline) fn main f0 {
+          b0(v0: u32, v1: u32):
+            v3 = mul v0, v1
+            jmp b1(u32 0)
+          b1(v2: u32):
+            v6 = lt v2, u32 4
+            jmpif v6 then: b3, else: b2
+          b2():
+            return
+          b3():
+            constrain v3 == u32 6
+            v9 = add v2, u32 1
+            jmp b1(v9)
+        }
+        ";
+
+        let ssa = ssa.loop_invariant_code_motion();
+        assert_normalized_ssa_equals(ssa, expected);
+    }
+
+    #[test]
+    fn nested_loop_invariant_code_motion() {
+        // Check that a loop invariant in the inner loop of a nested loop
+        // is hoisted to the parent loop's pre-header block.
+        let src = "
+        brillig(inline) fn main f0 {
+          b0(v0: u32, v1: u32):
+            jmp b1(u32 0)
+          b1(v2: u32):
+            v6 = lt v2, u32 4
+            jmpif v6 then: b3, else: b2
+          b2():
+            return
+          b3():
+            jmp b4(u32 0)
+          b4(v3: u32):
+            v7 = lt v3, u32 4
+            jmpif v7 then: b6, else: b5
+          b5():
+            v9 = add v2, u32 1
+            jmp b1(v9)
+          b6():
+            v10 = mul v0, v1
+            constrain v10 == u32 6
+            v12 = add v3, u32 1
+            jmp b4(v12)
+        }
+        ";
+
+        let mut ssa = Ssa::from_str(src).unwrap();
+        let main = ssa.main_mut();
+
+        let instructions = main.dfg[main.entry_block()].instructions();
+        assert_eq!(instructions.len(), 0); // The final return is not counted
+
+        // `v10 = mul v0, v1` in b6 should now be `v4 = mul v0, v1` in b0
+        let expected = "
+        brillig(inline) fn main f0 {
+          b0(v0: u32, v1: u32):
+            v4 = mul v0, v1
+            jmp b1(u32 0)
+          b1(v2: u32):
+            v7 = lt v2, u32 4
+            jmpif v7 then: b3, else: b2
+          b2():
+            return
+          b3():
+            jmp b4(u32 0)
+          b4(v3: u32):
+            v8 = lt v3, u32 4
+            jmpif v8 then: b6, else: b5
+          b5():
+            v10 = add v2, u32 1
+            jmp b1(v10)
+          b6():
+            constrain v4 == u32 6
+            v12 = add v3, u32 1
+            jmp b4(v12)
+        }
+        ";
+
+        let ssa = ssa.loop_invariant_code_motion();
+        assert_normalized_ssa_equals(ssa, expected);
+    }
+
+    #[test]
+    fn hoist_invariant_with_invariant_as_argument() {
+        // Check that an instruction which has arguments defined in the loop
+        // but which are already marked loop invariants is still hoisted to the preheader.
+        //
+        // For example, in b3 we have the following instructions:
+        // ```text
+        // v6 = mul v0, v1
+        // v7 = mul v6, v0
+        // ```
+        // `v6` should be marked a loop invariants as `v0` and `v1` are both declared outside of the loop.
+        // As we will be hoisting `v6 = mul v0, v1` to the loop preheader we know that we can also
+        // hoist `v7 = mul v6, v0`.
+        let src = "
+        brillig(inline) fn main f0 {
+          b0(v0: u32, v1: u32):
+            jmp b1(u32 0)
+          b1(v2: u32):
+            v5 = lt v2, u32 4
+            jmpif v5 then: b3, else: b2
+          b2():
+            return
+          b3():
+            v6 = mul v0, v1
+            v7 = mul v6, v0
+            v8 = eq v7, u32 12
+            constrain v7 == u32 12
+            v9 = add v2, u32 1
+            jmp b1(v9)
+        }
+        ";
+
+        let mut ssa = Ssa::from_str(src).unwrap();
+        let main = ssa.main_mut();
+
+        let instructions = main.dfg[main.entry_block()].instructions();
+        assert_eq!(instructions.len(), 0); // The final return is not counted
+
+        let expected = "
+        brillig(inline) fn main f0 {
+          b0(v0: u32, v1: u32):
+            v3 = mul v0, v1
+            v4 = mul v3, v0
+            v6 = eq v4, u32 12
+            jmp b1(u32 0)
+          b1(v2: u32):
+            v9 = lt v2, u32 4
+            jmpif v9 then: b3, else: b2
+          b2():
+            return
+          b3():
+            constrain v4 == u32 12
+            v11 = add v2, u32 1
+            jmp b1(v11)
+        }
+        ";
+
+        let ssa = ssa.loop_invariant_code_motion();
+        assert_normalized_ssa_equals(ssa, expected);
+    }
+
+    #[test]
+    fn do_not_hoist_instructions_with_side_effects() {
+        // In `v12 = load v5` in `b3`, `v5` is defined outside the loop.
+        // However, as the instruction has side effects, we want to make sure
+        // we do not hoist the instruction to the loop preheader.
+        let src = "
+        brillig(inline) fn main f0 {
+          b0(v0: u32, v1: u32):
+            v4 = make_array [u32 0, u32 0, u32 0, u32 0, u32 0] : [u32; 5]
+            inc_rc v4
+            v5 = allocate -> &mut [u32; 5]
+            store v4 at v5
+            jmp b1(u32 0)
+          b1(v2: u32):
+            v7 = lt v2, u32 4
+            jmpif v7 then: b3, else: b2
+          b2():
+            v8 = load v5 -> [u32; 5]
+            v10 = array_get v8, index u32 2 -> u32
+            constrain v10 == u32 3
+            return
+          b3():
+            v12 = load v5 -> [u32; 5]
+            v13 = array_set v12, index v0, value v1
+            store v13 at v5
+            v15 = add v2, u32 1
+            jmp b1(v15)
+        }
+        ";
+
+        let mut ssa = Ssa::from_str(src).unwrap();
+        let main = ssa.main_mut();
+
+        let instructions = main.dfg[main.entry_block()].instructions();
+        assert_eq!(instructions.len(), 4); // The final return is not counted
+
+        let ssa = ssa.loop_invariant_code_motion();
+        // The code should be unchanged
+        assert_normalized_ssa_equals(ssa, src);
+    }
+
+    #[test]
+    fn hoist_array_gets_using_induction_variable_with_const_bound() {
+        // SSA for the following program:
+        //
+        // fn triple_loop(x: u32) {
+        //   let arr = [2; 5];
+        //   for i in 0..4 {
+        //       for j in 0..4 {
+        //           for _ in 0..4 {
+        //               assert_eq(arr[i], x);
+        //               assert_eq(arr[j], x);
+        //           }
+        //       }
+        //   }
+        // }
+        //
+        // `arr[i]` and `arr[j]` are safe to hoist as we know the maximum possible index
+        // to be used for both array accesses.
+        // We want to make sure `arr[i]` is hoisted to the outermost loop body and that
+        // `arr[j]` is hoisted to the second outermost loop body.
+        let src = "
+        brillig(inline) fn main f0 {
+          b0(v0: u32, v1: u32):
+            v6 = make_array [u32 2, u32 2, u32 2, u32 2, u32 2] : [u32; 5]
+            inc_rc v6
+            jmp b1(u32 0)
+          b1(v2: u32):
+            v9 = lt v2, u32 4
+            jmpif v9 then: b3, else: b2
+          b2():
+            return
+          b3():
+            jmp b4(u32 0)
+          b4(v3: u32):
+            v10 = lt v3, u32 4
+            jmpif v10 then: b6, else: b5
+          b5():
+            v12 = add v2, u32 1
+            jmp b1(v12)
+          b6():
+            jmp b7(u32 0)
+          b7(v4: u32):
+            v13 = lt v4, u32 4
+            jmpif v13 then: b9, else: b8
+          b8():
+            v14 = add v3, u32 1
+            jmp b4(v14)
+          b9():
+            v15 = array_get v6, index v2 -> u32
+            v16 = eq v15, v0
+            constrain v15 == v0
+            v17 = array_get v6, index v3 -> u32
+            v18 = eq v17, v0
+            constrain v17 == v0
+            v19 = add v4, u32 1
+            jmp b7(v19)
+        }
+        ";
+
+        let ssa = Ssa::from_str(src).unwrap();
+
+        let expected = "
+        brillig(inline) fn main f0 {
+          b0(v0: u32, v1: u32):
+            v6 = make_array [u32 2, u32 2, u32 2, u32 2, u32 2] : [u32; 5]
+            inc_rc v6
+            jmp b1(u32 0)
+          b1(v2: u32):
+            v9 = lt v2, u32 4
+            jmpif v9 then: b3, else: b2
+          b2():
+            return
+          b3():
+            v10 = array_get v6, index v2 -> u32
+            v11 = eq v10, v0
+            jmp b4(u32 0)
+          b4(v3: u32):
+            v12 = lt v3, u32 4
+            jmpif v12 then: b6, else: b5
+          b5():
+            v14 = add v2, u32 1
+            jmp b1(v14)
+          b6():
+            v15 = array_get v6, index v3 -> u32
+            v16 = eq v15, v0
+            jmp b7(u32 0)
+          b7(v4: u32):
+            v17 = lt v4, u32 4
+            jmpif v17 then: b9, else: b8
+          b8():
+            v18 = add v3, u32 1
+            jmp b4(v18)
+          b9():
+            constrain v10 == v0
+            constrain v15 == v0
+            v19 = add v4, u32 1
+            jmp b7(v19)
+        }
+        ";
+
+        let ssa = ssa.loop_invariant_code_motion();
+        assert_normalized_ssa_equals(ssa, expected);
+    }
+
+    #[test]
+    fn insert_inc_rc_when_moving_make_array() {
+        // SSA for the following program:
+        //
+        // unconstrained fn main(x: u32, y: u32) {
+        //   let mut a1 = [1, 2, 3, 4, 5];
+        //   a1[x] = 64;
+        //   for i in 0 .. 5 {
+        //       let mut a2 = [1, 2, 3, 4, 5];
+        //       a2[y + i] = 128;
+        //       foo(a2);
+        //   }
+        //   foo(a1);
+        // }
+        //
+        // We want to make sure move a loop invariant make_array instruction,
+        // to account for whether that array has been marked as mutable.
+        // To do so, we increment the reference counter on the array we are moving.
+        // In the SSA below, we want to move `v42` out of the loop.
+        let src = "
+        brillig(inline) fn main f0 {
+          b0(v0: u32, v1: u32):
+            v8 = make_array [Field 1, Field 2, Field 3, Field 4, Field 5] : [Field; 5]
+            v9 = allocate -> &mut [Field; 5]
+            v11 = array_set v8, index v0, value Field 64
+            v13 = add v0, u32 1
+            store v11 at v9
+            jmp b1(u32 0)
+          b1(v2: u32):
+            v16 = lt v2, u32 5
+            jmpif v16 then: b3, else: b2
+          b2():
+            v17 = load v9 -> [Field; 5]
+            call f1(v17)
+            return
+          b3():
+            v19 = make_array [Field 1, Field 2, Field 3, Field 4, Field 5] : [Field; 5]
+            v20 = allocate -> &mut [Field; 5]
+            v21 = add v1, v2
+            v23 = array_set v19, index v21, value Field 128
+            call f1(v23)
+            v25 = add v2, u32 1
+            jmp b1(v25)
+        }
+        brillig(inline) fn foo f1 {
+          b0(v0: [Field; 5]):
+            return
+        }
+        ";
+
+        let ssa = Ssa::from_str(src).unwrap();
+
+        // We expect the `make_array` at the top of `b3` to be replaced with an `inc_rc`
+        // of the newly hoisted `make_array` at the end of `b0`.
+        let expected = "
+        brillig(inline) fn main f0 {
+          b0(v0: u32, v1: u32):
+            v8 = make_array [Field 1, Field 2, Field 3, Field 4, Field 5] : [Field; 5]
+            v9 = allocate -> &mut [Field; 5]
+            v11 = array_set v8, index v0, value Field 64
+            v13 = add v0, u32 1
+            store v11 at v9
+            v14 = make_array [Field 1, Field 2, Field 3, Field 4, Field 5] : [Field; 5]
+            jmp b1(u32 0)
+          b1(v2: u32):
+            v17 = lt v2, u32 5
+            jmpif v17 then: b3, else: b2
+          b2():
+            v18 = load v9 -> [Field; 5]
+            call f1(v18)
+            return
+          b3():
+            inc_rc v14
+            v20 = allocate -> &mut [Field; 5]
+            v21 = add v1, v2
+            v23 = array_set v14, index v21, value Field 128
+            call f1(v23)
+            v25 = add v2, u32 1
+            jmp b1(v25)
+        }
+        brillig(inline) fn foo f1 {
+          b0(v0: [Field; 5]):
+            return
+        }
+        ";
+
+        let ssa = ssa.loop_invariant_code_motion();
+        assert_normalized_ssa_equals(ssa, expected);
+    }
+}
diff --git a/compiler/noirc_evaluator/src/ssa/opt/mem2reg.rs b/compiler/noirc_evaluator/src/ssa/opt/mem2reg.rs
index 68c04e3b4b4..77ad53df9cf 100644
--- a/compiler/noirc_evaluator/src/ssa/opt/mem2reg.rs
+++ b/compiler/noirc_evaluator/src/ssa/opt/mem2reg.rs
@@ -18,6 +18,7 @@
 //!   - A reference with 0 aliases means we were unable to find which reference this reference
 //!     refers to. If such a reference is stored to, we must conservatively invalidate every
 //!     reference in the current block.
+//! - We also track the last load instruction to each address per block.
 //!
 //! From there, to figure out the value of each reference at the end of block, iterate each instruction:
 //! - On `Instruction::Allocate`:
@@ -28,6 +29,13 @@
 //!   - Furthermore, if the result of the load is a reference, mark the result as an alias
 //!     of the reference it dereferences to (if known).
 //!     - If which reference it dereferences to is not known, this load result has no aliases.
+//!   - We also track the last instance of a load instruction to each address in a block.
+//!     If we see that the last load instruction was from the same address as the current load instruction,
+//!     we move to replace the result of the current load with the result of the previous load.
+//!     This removal requires a couple conditions:
+//!     - No store occurs to that address before the next load,
+//!     - The address is not used as an argument to a call
+//!     This optimization helps us remove repeated loads for which there are not known values.
 //! - On `Instruction::Store { address, value }`:
 //!   - If the address of the store is known:
 //!     - If the address has exactly 1 alias:
@@ -40,11 +48,13 @@
 //!     - Conservatively mark every alias in the block to `Unknown`.
 //!   - Additionally, if there were no Loads to any alias of the address between this Store and
 //!     the previous Store to the same address, the previous store can be removed.
+//!   - Remove the instance of the last load instruction to the address and its aliases
 //! - On `Instruction::Call { arguments }`:
 //!   - If any argument of the call is a reference, set the value of each alias of that
 //!     reference to `Unknown`
 //!   - Any builtin functions that may return aliases if their input also contains a
 //!     reference should be tracked. Examples: `slice_push_back`, `slice_insert`, `slice_remove`, etc.
+//!   - Remove the instance of the last load instruction for any reference arguments and their aliases
 //!
 //! On a terminator instruction:
 //! - If the terminator is a `Jmp`:
@@ -61,38 +71,6 @@
 //! SSA optimization pipeline, although it will be more successful the simpler the program's CFG is.
 //! This pass is currently performed several times to enable other passes - most notably being
 //! performed before loop unrolling to try to allow for mutable variables used for loop indices.
-//!
-//! As stated above, the algorithm above can sometimes miss known references.
-//! This most commonly occurs in the case of loops, where we may have allocations preceding a loop that are known,
-//! but the loop body's blocks are predecessors to the loop header block, causing those known allocations to be marked unknown.
-//! In certain cases we may be able to remove these allocations that precede a loop.
-//! For example, if a reference is not stored to again in the loop we should be able to remove that store which precedes the loop.
-//!
-//! To handle cases such as the one laid out above, we maintain some extra state per function,
-//! that we will analyze after the initial run through all of the blocks.
-//! We refer to this as the "function cleanup" and it requires having already iterated through all blocks.
-//!
-//! The state contains the following:
-//! - For each load address we store the number of loads from a given address,
-//!   the last load instruction from a given address across all blocks, and the respective block id of that instruction.
-//! - A mapping of each load result to its number of uses, the load instruction that produced the given result, and the respective block id of that instruction.
-//! - A set of the references and their aliases passed as an argument to a call.
-//! - Maps the references which have been aliased to the instructions that aliased that reference.
-//! - As we go through each instruction, if a load result has been used we increment its usage counter.
-//!   Upon removing an instruction, we decrement the load result counter.
-//! After analyzing all of a function's blocks we can analyze the per function state:
-//! - If we find that a load result's usage counter equals zero, we can remove that load.
-//! - We can then remove a store if the following conditions are met:
-//!   - All loads to a given address have been removed
-//!   - None of the aliases of a reference are used in any of the following:
-//!     - Block parameters, function parameters, call arguments, terminator arguments
-//!   - The store address is not aliased.
-//! - If a store is in a return block, we can have special handling that only checks if there is a load after
-//!   that store in the return block. In the case of a return block, even if there are other loads
-//!   in preceding blocks we can safely remove those stores.
-//! - To further catch any stores to references which are never loaded, we can count the number of stores
-//!   that were removed in the previous step. If there is only a single store leftover, we can safely map
-//!   the value of this final store to any loads of that store.
 mod alias_set;
 mod block;
 
@@ -123,16 +101,21 @@ impl Ssa {
     #[tracing::instrument(level = "trace", skip(self))]
     pub(crate) fn mem2reg(mut self) -> Ssa {
         for function in self.functions.values_mut() {
-            let mut context = PerFunctionContext::new(function);
-            context.mem2reg();
-            context.remove_instructions();
-            context.update_data_bus();
+            function.mem2reg();
         }
-
         self
     }
 }
 
+impl Function {
+    pub(crate) fn mem2reg(&mut self) {
+        let mut context = PerFunctionContext::new(self);
+        context.mem2reg();
+        context.remove_instructions();
+        context.update_data_bus();
+    }
+}
+
 struct PerFunctionContext<'f> {
     cfg: ControlFlowGraph,
     post_order: PostOrder,
@@ -149,10 +132,7 @@ struct PerFunctionContext<'f> {
 
     /// Track a value's last load across all blocks.
     /// If a value is not used in anymore loads we can remove the last store to that value.
-    last_loads: HashMap<ValueId, PerFuncLastLoadContext>,
-
-    /// Track whether a load result was used across all blocks.
-    load_results: HashMap<ValueId, PerFuncLoadResultContext>,
+    last_loads: HashMap<ValueId, (InstructionId, BasicBlockId)>,
 
     /// Track whether a reference was passed into another entry point
     /// This is needed to determine whether we can remove a store.
@@ -162,41 +142,6 @@ struct PerFunctionContext<'f> {
     /// instruction that aliased that reference.
     /// If that store has been set for removal, we can also remove this instruction.
     aliased_references: HashMap<ValueId, HashSet<InstructionId>>,
-
-    // The index of the last load instruction in a given block
-    return_block_load_locations: HashMap<(ValueId, BasicBlockId), usize>,
-}
-
-#[derive(Debug, Clone)]
-struct PerFuncLastLoadContext {
-    /// Reference counter that keeps track of how many times we loaded from a given address
-    num_loads: u32,
-    /// Last load instruction from a given address
-    load_instruction: InstructionId,
-    /// Block of the last load instruction
-    block_id: BasicBlockId,
-}
-
-impl PerFuncLastLoadContext {
-    fn new(load_instruction: InstructionId, block_id: BasicBlockId, num_loads: u32) -> Self {
-        Self { num_loads, load_instruction, block_id }
-    }
-}
-
-#[derive(Debug, Clone)]
-struct PerFuncLoadResultContext {
-    /// Reference counter that keeps track of how many times a load was used in other instructions
-    uses: u32,
-    /// Load instruction that produced a given load result
-    load_instruction: InstructionId,
-    /// Block of the load instruction that produced a given result
-    block_id: BasicBlockId,
-}
-
-impl PerFuncLoadResultContext {
-    fn new(load_instruction: InstructionId, block_id: BasicBlockId) -> Self {
-        Self { uses: 0, load_instruction, block_id }
-    }
 }
 
 impl<'f> PerFunctionContext<'f> {
@@ -211,10 +156,8 @@ impl<'f> PerFunctionContext<'f> {
             blocks: BTreeMap::new(),
             instructions_to_remove: HashSet::default(),
             last_loads: HashMap::default(),
-            load_results: HashMap::default(),
             calls_reference_input: HashSet::default(),
             aliased_references: HashMap::default(),
-            return_block_load_locations: HashMap::default(),
         }
     }
 
@@ -232,7 +175,105 @@ impl<'f> PerFunctionContext<'f> {
             self.analyze_block(block, references);
         }
 
-        self.cleanup_function();
+        let mut all_terminator_values = HashSet::default();
+        let mut per_func_block_params: HashSet<ValueId> = HashSet::default();
+        for (block_id, _) in self.blocks.iter() {
+            let block_params = self.inserter.function.dfg.block_parameters(*block_id);
+            per_func_block_params.extend(block_params.iter());
+            let terminator = self.inserter.function.dfg[*block_id].unwrap_terminator();
+            terminator.for_each_value(|value| all_terminator_values.insert(value));
+        }
+
+        // If we never load from an address within a function we can remove all stores to that address.
+        // This rule does not apply to reference parameters, which we must also check for before removing these stores.
+        for (_, block) in self.blocks.iter() {
+            for (store_address, store_instruction) in block.last_stores.iter() {
+                let store_alias_used = self.is_store_alias_used(
+                    store_address,
+                    block,
+                    &all_terminator_values,
+                    &per_func_block_params,
+                );
+
+                let is_dereference = block
+                    .expressions
+                    .get(store_address)
+                    .map_or(false, |expression| matches!(expression, Expression::Dereference(_)));
+
+                if self.last_loads.get(store_address).is_none()
+                    && !store_alias_used
+                    && !is_dereference
+                {
+                    self.instructions_to_remove.insert(*store_instruction);
+                }
+            }
+        }
+    }
+
+    // Extra checks on where a reference can be used aside a load instruction.
+    // Even if all loads to a reference have been removed we need to make sure that
+    // an allocation did not come from an entry point or was passed to an entry point.
+    fn is_store_alias_used(
+        &self,
+        store_address: &ValueId,
+        block: &Block,
+        all_terminator_values: &HashSet<ValueId>,
+        per_func_block_params: &HashSet<ValueId>,
+    ) -> bool {
+        let reference_parameters = self.reference_parameters();
+
+        if let Some(expression) = block.expressions.get(store_address) {
+            if let Some(aliases) = block.aliases.get(expression) {
+                let allocation_aliases_parameter =
+                    aliases.any(|alias| reference_parameters.contains(&alias));
+                if allocation_aliases_parameter == Some(true) {
+                    return true;
+                }
+
+                let allocation_aliases_parameter =
+                    aliases.any(|alias| per_func_block_params.contains(&alias));
+                if allocation_aliases_parameter == Some(true) {
+                    return true;
+                }
+
+                let allocation_aliases_parameter =
+                    aliases.any(|alias| self.calls_reference_input.contains(&alias));
+                if allocation_aliases_parameter == Some(true) {
+                    return true;
+                }
+
+                let allocation_aliases_parameter =
+                    aliases.any(|alias| all_terminator_values.contains(&alias));
+                if allocation_aliases_parameter == Some(true) {
+                    return true;
+                }
+
+                let allocation_aliases_parameter = aliases.any(|alias| {
+                    if let Some(alias_instructions) = self.aliased_references.get(&alias) {
+                        self.instructions_to_remove.is_disjoint(alias_instructions)
+                    } else {
+                        false
+                    }
+                });
+                if allocation_aliases_parameter == Some(true) {
+                    return true;
+                }
+            }
+        }
+
+        false
+    }
+
+    /// Collect the input parameters of the function which are of reference type.
+    /// All references are mutable, so these inputs are shared with the function caller
+    /// and thus stores should not be eliminated, even if the blocks in this function
+    /// don't use them anywhere.
+    fn reference_parameters(&self) -> BTreeSet<ValueId> {
+        let parameters = self.inserter.function.parameters().iter();
+        parameters
+            .filter(|param| self.inserter.function.dfg.value_is_reference(**param))
+            .copied()
+            .collect()
     }
 
     /// The value of each reference at the start of the given block is the unification
@@ -243,6 +284,9 @@ impl<'f> PerFunctionContext<'f> {
         if let Some(first_predecessor) = predecessors.next() {
             let mut first = self.blocks.get(&first_predecessor).cloned().unwrap_or_default();
             first.last_stores.clear();
+            // Last loads are tracked per block. During unification we are creating a new block from the current one,
+            // so we must clear the last loads of the current block before we return the new block.
+            first.last_loads.clear();
 
             // Note that we have to start folding with the first block as the accumulator.
             // If we started with an empty block, an empty block union'd with any other block
@@ -264,6 +308,12 @@ impl<'f> PerFunctionContext<'f> {
     fn analyze_block(&mut self, block: BasicBlockId, mut references: Block) {
         let instructions = self.inserter.function.dfg[block].take_instructions();
 
+        // If this is the entry block, take all the block parameters and assume they may
+        // be aliased to each other
+        if block == self.inserter.function.entry_block() {
+            self.add_aliases_for_reference_parameters(block, &mut references);
+        }
+
         for instruction in instructions {
             self.analyze_instruction(block, &mut references, instruction);
         }
@@ -280,16 +330,52 @@ impl<'f> PerFunctionContext<'f> {
         self.blocks.insert(block, references);
     }
 
+    /// Go through each parameter and register that all reference parameters of the same type are
+    /// possibly aliased to each other. If there are parameters with nested references (arrays of
+    /// references or references containing other references) we give up and assume all parameter
+    /// references are `AliasSet::unknown()`.
+    fn add_aliases_for_reference_parameters(&self, block: BasicBlockId, references: &mut Block) {
+        let dfg = &self.inserter.function.dfg;
+        let params = dfg.block_parameters(block);
+
+        let mut aliases: HashMap<Type, AliasSet> = HashMap::default();
+
+        for param in params {
+            match dfg.type_of_value(*param) {
+                // If the type indirectly contains a reference we have to assume all references
+                // are unknown since we don't have any ValueIds to use.
+                Type::Reference(element) if element.contains_reference() => return,
+                Type::Reference(element) => {
+                    let empty_aliases = AliasSet::known_empty();
+                    let alias_set =
+                        aliases.entry(element.as_ref().clone()).or_insert(empty_aliases);
+                    alias_set.insert(*param);
+                }
+                typ if typ.contains_reference() => return,
+                _ => continue,
+            }
+        }
+
+        for aliases in aliases.into_values() {
+            let first = aliases.first();
+            let first = first.expect("All parameters alias at least themselves or we early return");
+
+            let expression = Expression::Other(first);
+            let previous = references.aliases.insert(expression.clone(), aliases.clone());
+            assert!(previous.is_none());
+
+            aliases.for_each(|alias| {
+                let previous = references.expressions.insert(alias, expression.clone());
+                assert!(previous.is_none());
+            });
+        }
+    }
+
     /// Add all instructions in `last_stores` to `self.instructions_to_remove` which do not
     /// possibly alias any parameters of the given function.
     fn remove_stores_that_do_not_alias_parameters(&mut self, references: &Block) {
-        let parameters = self.inserter.function.parameters().iter();
-        let reference_parameters = parameters
-            .filter(|param| self.inserter.function.dfg.value_is_reference(**param))
-            .collect::<BTreeSet<_>>();
+        let reference_parameters = self.reference_parameters();
 
-        // Must collect here as we are immutably borrowing `self` to fetch the reference parameters
-        let mut values_to_reduce_counts = Vec::new();
         for (allocation, instruction) in &references.last_stores {
             if let Some(expression) = references.expressions.get(allocation) {
                 if let Some(aliases) = references.aliases.get(expression) {
@@ -299,27 +385,10 @@ impl<'f> PerFunctionContext<'f> {
                     // If `allocation_aliases_parameter` is known to be false
                     if allocation_aliases_parameter == Some(false) {
                         self.instructions_to_remove.insert(*instruction);
-                        values_to_reduce_counts.push(*allocation);
                     }
                 }
             }
         }
-
-        for value in values_to_reduce_counts {
-            self.reduce_load_result_count(value);
-        }
-    }
-
-    fn increase_load_ref_counts(&mut self, value: ValueId) {
-        if let Some(context) = self.load_results.get_mut(&value) {
-            context.uses += 1;
-        }
-        let array_const = self.inserter.function.dfg.get_array_constant(value);
-        if let Some((values, _)) = array_const {
-            for array_value in values {
-                self.increase_load_ref_counts(array_value);
-            }
-        }
     }
 
     fn analyze_instruction(
@@ -337,16 +406,6 @@ impl<'f> PerFunctionContext<'f> {
             return;
         }
 
-        let mut collect_values = Vec::new();
-        // Track whether any load results were used in the instruction
-        self.inserter.function.dfg[instruction].for_each_value(|value| {
-            collect_values.push(value);
-        });
-
-        for value in collect_values {
-            self.increase_load_ref_counts(value);
-        }
-
         match &self.inserter.function.dfg[instruction] {
             Instruction::Load { address } => {
                 let address = self.inserter.function.dfg.resolve(*address);
@@ -356,76 +415,45 @@ impl<'f> PerFunctionContext<'f> {
 
                 // If the load is known, replace it with the known value and remove the load
                 if let Some(value) = references.get_known_value(address) {
+                    let result = self.inserter.function.dfg.instruction_results(instruction)[0];
                     self.inserter.map_value(result, value);
                     self.instructions_to_remove.insert(instruction);
                 } else {
                     references.mark_value_used(address, self.inserter.function);
 
-                    let expression =
-                        references.expressions.entry(result).or_insert(Expression::Other(result));
-                    // Make sure this load result is marked an alias to itself
-                    if let Some(aliases) = references.aliases.get_mut(expression) {
-                        // If we have an alias set, add to the set
-                        aliases.insert(result);
-                    } else {
-                        // Otherwise, create a new alias set containing just the load result
-                        references
-                            .aliases
-                            .insert(Expression::Other(result), AliasSet::known(result));
-                    }
-                    // Mark that we know a load result is equivalent to the address of a load.
-                    references.set_known_value(result, address);
-
-                    self.load_results
-                        .insert(result, PerFuncLoadResultContext::new(instruction, block_id));
-
-                    let num_loads =
-                        self.last_loads.get(&address).map_or(1, |context| context.num_loads + 1);
-                    let last_load = PerFuncLastLoadContext::new(instruction, block_id, num_loads);
-                    self.last_loads.insert(address, last_load);
-
-                    // If we are in a return block we want to save the last location of a load
-                    let terminator = self.inserter.function.dfg[block_id].unwrap_terminator();
-                    let is_return = matches!(terminator, TerminatorInstruction::Return { .. });
-                    if is_return {
-                        let instruction_index =
-                            self.inserter.function.dfg[block_id].instructions().len();
-                        self.return_block_load_locations
-                            .insert((address, block_id), instruction_index);
+                    self.last_loads.insert(address, (instruction, block_id));
+                }
+
+                // Check whether the block has a repeat load from the same address (w/ no calls or stores in between the loads).
+                // If we do have a repeat load, we can remove the current load and map its result to the previous load's result.
+                if let Some(last_load) = references.last_loads.get(&address) {
+                    let Instruction::Load { address: previous_address } =
+                        &self.inserter.function.dfg[*last_load]
+                    else {
+                        panic!("Expected a Load instruction here");
+                    };
+                    let result = self.inserter.function.dfg.instruction_results(instruction)[0];
+                    let previous_result =
+                        self.inserter.function.dfg.instruction_results(*last_load)[0];
+                    if *previous_address == address {
+                        self.inserter.map_value(result, previous_result);
+                        self.instructions_to_remove.insert(instruction);
                     }
                 }
+                // We want to set the load for every load even if the address has a known value
+                // and the previous load instruction was removed.
+                // We are safe to still remove a repeat load in this case as we are mapping from the current load's
+                // result to the previous load, which if it was removed should already have a mapping to the known value.
+                references.set_last_load(address, instruction);
             }
             Instruction::Store { address, value } => {
                 let address = self.inserter.function.dfg.resolve(*address);
                 let value = self.inserter.function.dfg.resolve(*value);
 
-                self.check_array_aliasing(references, value);
-
-                // If there was another store to this address without any (unremoved) loads or
+                // If there was another store to this instruction without any (unremoved) loads or
                 // function calls in-between, we can remove the previous store.
                 if let Some(last_store) = references.last_stores.get(&address) {
                     self.instructions_to_remove.insert(*last_store);
-                    let Instruction::Store { address, value } =
-                        self.inserter.function.dfg[*last_store]
-                    else {
-                        panic!("Should have a store instruction here");
-                    };
-                    self.reduce_load_result_count(address);
-                    self.reduce_load_result_count(value);
-                }
-
-                let known_value = references.get_known_value(value);
-                if let Some(known_value) = known_value {
-                    let known_value_is_address = known_value == address;
-                    if known_value_is_address {
-                        self.instructions_to_remove.insert(instruction);
-                        self.reduce_load_result_count(address);
-                        self.reduce_load_result_count(value);
-                    } else {
-                        references.last_stores.insert(address, instruction);
-                    }
-                } else {
-                    references.last_stores.insert(address, instruction);
                 }
 
                 if self.inserter.function.dfg.value_is_reference(value) {
@@ -442,6 +470,9 @@ impl<'f> PerFunctionContext<'f> {
                 }
 
                 references.set_known_value(address, value);
+                // If we see a store to an address, the last load to that address needs to remain.
+                references.keep_last_load_for(address, self.inserter.function);
+                references.last_stores.insert(address, instruction);
             }
             Instruction::Allocate => {
                 // Register the new reference
@@ -505,22 +536,22 @@ impl<'f> PerFunctionContext<'f> {
                 }
                 self.mark_all_unknown(arguments, references);
             }
-            _ => (),
-        }
-    }
-
-    fn check_array_aliasing(&self, references: &mut Block, array: ValueId) {
-        if let Some((elements, typ)) = self.inserter.function.dfg.get_array_constant(array) {
-            if Self::contains_references(&typ) {
-                // TODO: Check if type directly holds references or holds arrays that hold references
-                let expr = Expression::ArrayElement(Box::new(Expression::Other(array)));
-                references.expressions.insert(array, expr.clone());
-                let aliases = references.aliases.entry(expr).or_default();
-
-                for element in elements {
-                    aliases.insert(element);
+            Instruction::MakeArray { elements, typ } => {
+                // If `array` is an array constant that contains reference types, then insert each element
+                // as a potential alias to the array itself.
+                if Self::contains_references(typ) {
+                    let array = self.inserter.function.dfg.instruction_results(instruction)[0];
+
+                    let expr = Expression::ArrayElement(Box::new(Expression::Other(array)));
+                    references.expressions.insert(array, expr.clone());
+                    let aliases = references.aliases.entry(expr).or_default();
+
+                    for element in elements {
+                        aliases.insert(*element);
+                    }
                 }
             }
+            _ => (),
         }
     }
 
@@ -548,6 +579,9 @@ impl<'f> PerFunctionContext<'f> {
                 let value = self.inserter.function.dfg.resolve(*value);
                 references.set_unknown(value);
                 references.mark_value_used(value, self.inserter.function);
+
+                // If a reference is an argument to a call, the last load to that address and its aliases needs to remain.
+                references.keep_last_load_for(value, self.inserter.function);
             }
         }
     }
@@ -565,31 +599,25 @@ impl<'f> PerFunctionContext<'f> {
     }
 
     fn update_data_bus(&mut self) {
-        self.inserter.map_data_bus_in_place();
+        let databus = self.inserter.function.dfg.data_bus.clone();
+        self.inserter.function.dfg.data_bus = databus.map_values(|t| self.inserter.resolve(t));
     }
 
     fn handle_terminator(&mut self, block: BasicBlockId, references: &mut Block) {
         self.inserter.map_terminator_in_place(block);
 
-        let terminator: &TerminatorInstruction =
-            self.inserter.function.dfg[block].unwrap_terminator();
-
-        let mut collect_values = Vec::new();
-        terminator.for_each_value(|value| {
-            collect_values.push(value);
-        });
-
-        let terminator = terminator.clone();
-        for value in collect_values.iter() {
-            self.increase_load_ref_counts(*value);
-        }
-
-        match &terminator {
+        match self.inserter.function.dfg[block].unwrap_terminator() {
             TerminatorInstruction::JmpIf { .. } => (), // Nothing to do
             TerminatorInstruction::Jmp { destination, arguments, .. } => {
                 let destination_parameters = self.inserter.function.dfg[*destination].parameters();
                 assert_eq!(destination_parameters.len(), arguments.len());
 
+                // If we have multiple parameters that alias that same argument value,
+                // then those parameters also alias each other.
+                // We save parameters with repeat arguments to later mark those
+                // parameters as aliasing one another.
+                let mut arg_set: HashMap<ValueId, BTreeSet<ValueId>> = HashMap::default();
+
                 // Add an alias for each reference parameter
                 for (parameter, argument) in destination_parameters.iter().zip(arguments) {
                     if self.inserter.function.dfg.value_is_reference(*parameter) {
@@ -599,10 +627,27 @@ impl<'f> PerFunctionContext<'f> {
                             if let Some(aliases) = references.aliases.get_mut(expression) {
                                 // The argument reference is possibly aliased by this block parameter
                                 aliases.insert(*parameter);
+
+                                // Check if we have seen the same argument
+                                let seen_parameters = arg_set.entry(argument).or_default();
+                                // Add the current parameter to the parameters we have seen for this argument.
+                                // The previous parameters and the current one alias one another.
+                                seen_parameters.insert(*parameter);
                             }
                         }
                     }
                 }
+
+                // Set the aliases of the parameters
+                for (_, aliased_params) in arg_set {
+                    for param in aliased_params.iter() {
+                        self.set_aliases(
+                            references,
+                            *param,
+                            AliasSet::known_multiple(aliased_params.clone()),
+                        );
+                    }
+                }
             }
             TerminatorInstruction::Return { return_values, .. } => {
                 // Removing all `last_stores` for each returned reference is more important here
@@ -612,311 +657,6 @@ impl<'f> PerFunctionContext<'f> {
             }
         }
     }
-
-    fn reduce_load_result_count(&mut self, value: ValueId) {
-        if let Some(context) = self.load_results.get_mut(&value) {
-            // TODO this was saturating https://github.com/noir-lang/noir/issues/6124
-            context.uses = context.uses.wrapping_sub(1);
-        }
-    }
-
-    fn recursively_add_values(&self, value: ValueId, set: &mut HashSet<ValueId>) {
-        set.insert(value);
-        if let Some((elements, _)) = self.inserter.function.dfg.get_array_constant(value) {
-            for array_element in elements {
-                self.recursively_add_values(array_element, set);
-            }
-        }
-    }
-
-    /// The mem2reg pass is sometimes unable to determine certain known values
-    /// when iterating over a function's block in reverse post order.
-    /// We collect state about any final loads and stores to a given address during the initial mem2reg pass.
-    /// We can then utilize this state to clean up any loads and stores that may have been missed.
-    fn cleanup_function(&mut self) {
-        // Removing remaining unused loads during mem2reg can help expose removable stores that the initial
-        // mem2reg pass deemed we could not remove due to the existence of those unused loads.
-        let removed_loads = self.remove_unused_loads();
-        let remaining_last_stores = self.remove_unloaded_last_stores(&removed_loads);
-        let stores_were_removed =
-            self.remove_remaining_last_stores(&removed_loads, &remaining_last_stores);
-
-        // When removing some last loads with the last stores we will map the load result to the store value.
-        // We need to then map all the instructions again as we do not know which instructions are reliant on the load result.
-        if stores_were_removed {
-            let mut block_order = PostOrder::with_function(self.inserter.function).into_vec();
-            block_order.reverse();
-            for block in block_order {
-                let instructions = self.inserter.function.dfg[block].take_instructions();
-                for instruction in instructions {
-                    if !self.instructions_to_remove.contains(&instruction) {
-                        self.inserter.push_instruction(instruction, block);
-                    }
-                }
-                self.inserter.map_terminator_in_place(block);
-            }
-        }
-    }
-
-    /// Cleanup remaining loads across the entire function
-    /// Remove any loads whose reference counter is zero.
-    /// Returns a map of the removed load address to the number of load instructions removed for that address
-    fn remove_unused_loads(&mut self) -> HashMap<ValueId, u32> {
-        let mut removed_loads = HashMap::default();
-        for (_, PerFuncLoadResultContext { uses, load_instruction, block_id, .. }) in
-            self.load_results.iter()
-        {
-            let Instruction::Load { address } = self.inserter.function.dfg[*load_instruction]
-            else {
-                unreachable!("Should only have a load instruction here");
-            };
-            // If the load result's counter is equal to zero we can safely remove that load instruction.
-            if *uses == 0 {
-                self.return_block_load_locations.remove(&(address, *block_id));
-
-                removed_loads.entry(address).and_modify(|counter| *counter += 1).or_insert(1);
-                self.instructions_to_remove.insert(*load_instruction);
-            }
-        }
-        removed_loads
-    }
-
-    fn recursively_check_address_in_terminator(
-        &self,
-        return_value: ValueId,
-        store_address: ValueId,
-        is_return_value: &mut bool,
-    ) {
-        *is_return_value = return_value == store_address || *is_return_value;
-        let array_const = self.inserter.function.dfg.get_array_constant(return_value);
-        if let Some((values, _)) = array_const {
-            for array_value in values {
-                self.recursively_check_address_in_terminator(
-                    array_value,
-                    store_address,
-                    is_return_value,
-                );
-            }
-        }
-    }
-
-    /// Cleanup remaining stores across the entire function.
-    /// If we never load from an address within a function we can remove all stores to that address.
-    /// This rule does not apply to reference parameters, which we must also check for before removing these stores.
-    /// Returns a map of any remaining stores which may still have loads in use.
-    fn remove_unloaded_last_stores(
-        &mut self,
-        removed_loads: &HashMap<ValueId, u32>,
-    ) -> HashMap<ValueId, (InstructionId, u32)> {
-        let mut all_terminator_values = HashSet::default();
-        let mut per_func_block_params: HashSet<ValueId> = HashSet::default();
-        for (block_id, _) in self.blocks.iter() {
-            let block_params = self.inserter.function.dfg.block_parameters(*block_id);
-            per_func_block_params.extend(block_params.iter());
-
-            let terminator = self.inserter.function.dfg[*block_id].unwrap_terminator();
-            terminator.for_each_value(|value| {
-                self.recursively_add_values(value, &mut all_terminator_values);
-            });
-        }
-
-        let mut remaining_last_stores: HashMap<ValueId, (InstructionId, u32)> = HashMap::default();
-        for (block_id, block) in self.blocks.iter() {
-            for (store_address, store_instruction) in block.last_stores.iter() {
-                if self.instructions_to_remove.contains(store_instruction) {
-                    continue;
-                }
-
-                let all_loads_removed = self.all_loads_removed_for_address(
-                    store_address,
-                    *store_instruction,
-                    *block_id,
-                    removed_loads,
-                );
-
-                let store_alias_used = self.is_store_alias_used(
-                    store_address,
-                    block,
-                    &all_terminator_values,
-                    &per_func_block_params,
-                );
-
-                if all_loads_removed && !store_alias_used {
-                    self.instructions_to_remove.insert(*store_instruction);
-                    if let Some((_, counter)) = remaining_last_stores.get_mut(store_address) {
-                        // TODO this was saturating https://github.com/noir-lang/noir/issues/6124
-                        *counter = counter.wrapping_sub(1);
-                    }
-                } else if let Some((_, counter)) = remaining_last_stores.get_mut(store_address) {
-                    *counter += 1;
-                } else {
-                    remaining_last_stores.insert(*store_address, (*store_instruction, 1));
-                }
-            }
-        }
-        remaining_last_stores
-    }
-
-    fn all_loads_removed_for_address(
-        &self,
-        store_address: &ValueId,
-        store_instruction: InstructionId,
-        block_id: BasicBlockId,
-        removed_loads: &HashMap<ValueId, u32>,
-    ) -> bool {
-        let terminator = self.inserter.function.dfg[block_id].unwrap_terminator();
-        let is_return = matches!(terminator, TerminatorInstruction::Return { .. });
-        // Determine whether any loads that reference this store address
-        // have been removed while cleaning up unused loads.
-        if is_return {
-            // If we are in a return terminator, and the last loads of a reference
-            // come before a store to that reference, we can safely remove that store.
-            let store_after_load = if let Some(max_load_index) =
-                self.return_block_load_locations.get(&(*store_address, block_id))
-            {
-                let store_index = self.inserter.function.dfg[block_id]
-                    .instructions()
-                    .iter()
-                    .position(|id| *id == store_instruction)
-                    .expect("Store instruction should exist in the return block");
-                store_index > *max_load_index
-            } else {
-                // Otherwise there is no load in this block
-                true
-            };
-            store_after_load
-        } else if let (Some(context), Some(loads_removed_counter)) =
-            (self.last_loads.get(store_address), removed_loads.get(store_address))
-        {
-            // `last_loads` contains the total number of loads for a given load address
-            // If the number of removed loads for a given address is equal to the total number of loads for that address,
-            // we know we can safely remove any stores to that load address.
-            context.num_loads == *loads_removed_counter
-        } else {
-            self.last_loads.get(store_address).is_none()
-        }
-    }
-
-    // Extra checks on where a reference can be used aside a load instruction.
-    // Even if all loads to a reference have been removed we need to make sure that
-    // an allocation did not come from an entry point or was passed to an entry point.
-    fn is_store_alias_used(
-        &self,
-        store_address: &ValueId,
-        block: &Block,
-        all_terminator_values: &HashSet<ValueId>,
-        per_func_block_params: &HashSet<ValueId>,
-    ) -> bool {
-        let func_params = self.inserter.function.parameters();
-        let reference_parameters = func_params
-            .iter()
-            .filter(|param| self.inserter.function.dfg.value_is_reference(**param))
-            .collect::<BTreeSet<_>>();
-
-        let mut store_alias_used = false;
-        if let Some(expression) = block.expressions.get(store_address) {
-            if let Some(aliases) = block.aliases.get(expression) {
-                let allocation_aliases_parameter =
-                    aliases.any(|alias| reference_parameters.contains(&alias));
-                if allocation_aliases_parameter == Some(true) {
-                    store_alias_used = true;
-                }
-
-                let allocation_aliases_parameter =
-                    aliases.any(|alias| per_func_block_params.contains(&alias));
-                if allocation_aliases_parameter == Some(true) {
-                    store_alias_used = true;
-                }
-
-                let allocation_aliases_parameter =
-                    aliases.any(|alias| self.calls_reference_input.contains(&alias));
-                if allocation_aliases_parameter == Some(true) {
-                    store_alias_used = true;
-                }
-
-                let allocation_aliases_parameter =
-                    aliases.any(|alias| all_terminator_values.contains(&alias));
-                if allocation_aliases_parameter == Some(true) {
-                    store_alias_used = true;
-                }
-
-                let allocation_aliases_parameter = aliases.any(|alias| {
-                    if let Some(alias_instructions) = self.aliased_references.get(&alias) {
-                        self.instructions_to_remove.is_disjoint(alias_instructions)
-                    } else {
-                        false
-                    }
-                });
-                if allocation_aliases_parameter == Some(true) {
-                    store_alias_used = true;
-                }
-            }
-        }
-
-        store_alias_used
-    }
-
-    /// Check if any remaining last stores are only used in a single load
-    /// Returns true if any stores were removed.
-    fn remove_remaining_last_stores(
-        &mut self,
-        removed_loads: &HashMap<ValueId, u32>,
-        remaining_last_stores: &HashMap<ValueId, (InstructionId, u32)>,
-    ) -> bool {
-        let mut stores_were_removed = false;
-        // Filter out any still in use load results and any load results that do not contain addresses from the remaining last stores
-        self.load_results.retain(|_, PerFuncLoadResultContext { load_instruction, uses, .. }| {
-            let Instruction::Load { address } = self.inserter.function.dfg[*load_instruction]
-            else {
-                unreachable!("Should only have a load instruction here");
-            };
-            remaining_last_stores.contains_key(&address) && *uses > 0
-        });
-
-        for (store_address, (store_instruction, store_counter)) in remaining_last_stores {
-            let Instruction::Store { value, .. } = self.inserter.function.dfg[*store_instruction]
-            else {
-                unreachable!("Should only have a store instruction");
-            };
-
-            if let (Some(context), Some(loads_removed_counter)) =
-                (self.last_loads.get(store_address), removed_loads.get(store_address))
-            {
-                assert!(
-                    context.num_loads >= *loads_removed_counter,
-                    "The number of loads removed should not be more than all loads"
-                );
-            }
-
-            // We only want to remove last stores referencing a single address.
-            if *store_counter != 0 {
-                continue;
-            }
-
-            self.instructions_to_remove.insert(*store_instruction);
-
-            // Map any remaining load results to the value from the removed store
-            for (result, context) in self.load_results.iter() {
-                let Instruction::Load { address } =
-                    self.inserter.function.dfg[context.load_instruction]
-                else {
-                    unreachable!("Should only have a load instruction here");
-                };
-                if address != *store_address {
-                    continue;
-                }
-
-                // Map the load result to its respective store value
-                // We will have to map all instructions following this method
-                // as we do not know what instructions depend upon this result
-                self.inserter.map_value(*result, value);
-                self.instructions_to_remove.insert(context.load_instruction);
-
-                stores_were_removed = true;
-            }
-        }
-        stores_were_removed
-    }
 }
 
 #[cfg(test)]
@@ -935,6 +675,8 @@ mod tests {
             map::Id,
             types::Type,
         },
+        opt::assert_normalized_ssa_equals,
+        Ssa,
     };
 
     #[test]
@@ -942,10 +684,11 @@ mod tests {
         // fn func() {
         //   b0():
         //     v0 = allocate
-        //     store [Field 1, Field 2] in v0
-        //     v1 = load v0
-        //     v2 = array_get v1, index 1
-        //     return v2
+        //     v1 = make_array [Field 1, Field 2]
+        //     store v1 in v0
+        //     v2 = load v0
+        //     v3 = array_get v2, index 1
+        //     return v3
         // }
 
         let func_id = Id::test_new(0);
@@ -956,12 +699,12 @@ mod tests {
 
         let element_type = Arc::new(vec![Type::field()]);
         let array_type = Type::Array(element_type, 2);
-        let array = builder.array_constant(vector![one, two], array_type.clone());
+        let v1 = builder.insert_make_array(vector![one, two], array_type.clone());
 
-        builder.insert_store(v0, array);
-        let v1 = builder.insert_load(v0, array_type);
-        let v2 = builder.insert_array_get(v1, one, Type::field());
-        builder.terminate_with_return(vec![v2]);
+        builder.insert_store(v0, v1);
+        let v2 = builder.insert_load(v0, array_type);
+        let v3 = builder.insert_array_get(v2, one, Type::field());
+        builder.terminate_with_return(vec![v3]);
 
         let ssa = builder.finish().mem2reg().fold_constants();
 
@@ -1144,241 +887,53 @@ mod tests {
     // is later stored in a successor block
     #[test]
     fn load_aliases_in_predecessor_block() {
-        // fn main {
-        //     b0():
-        //       v0 = allocate
-        //       store Field 0 at v0
-        //       v2 = allocate
-        //       store v0 at v2
-        //       v3 = load v2
-        //       v4 = load v2
-        //       jmp b1()
-        //     b1():
-        //       store Field 1 at v3
-        //       store Field 2 at v4
-        //       v7 = load v3
-        //       v8 = eq v7, Field 2
-        //       return
-        // }
-        let main_id = Id::test_new(0);
-        let mut builder = FunctionBuilder::new("main".into(), main_id);
-
-        let v0 = builder.insert_allocate(Type::field());
-
-        let zero = builder.field_constant(0u128);
-        builder.insert_store(v0, zero);
-
-        let v2 = builder.insert_allocate(Type::Reference(Arc::new(Type::field())));
-        builder.insert_store(v2, v0);
-
-        let v3 = builder.insert_load(v2, Type::field());
-        let v4 = builder.insert_load(v2, Type::field());
-        let b1 = builder.insert_block();
-        builder.terminate_with_jmp(b1, vec![]);
-
-        builder.switch_to_block(b1);
-
-        let one = builder.field_constant(1u128);
-        builder.insert_store(v3, one);
-
-        let two = builder.field_constant(2u128);
-        builder.insert_store(v4, two);
-
-        let v8 = builder.insert_load(v3, Type::field());
-        let _ = builder.insert_binary(v8, BinaryOp::Eq, two);
-
-        builder.terminate_with_return(vec![]);
+        let src = "
+        acir(inline) fn main f0 {
+          b0():
+            v0 = allocate -> &mut Field
+            store Field 0 at v0
+            v2 = allocate -> &mut &mut Field
+            store v0 at v2
+            v3 = load v2 -> &mut Field
+            v4 = load v2 -> &mut Field
+            jmp b1()
+          b1():
+            store Field 1 at v3
+            store Field 2 at v4
+            v7 = load v3 -> Field
+            v8 = eq v7, Field 2
+            return
+        }
+        ";
 
-        let ssa = builder.finish();
-        assert_eq!(ssa.main().reachable_blocks().len(), 2);
+        let mut ssa = Ssa::from_str(src).unwrap();
+        let main = ssa.main_mut();
 
-        // Expected result:
-        // acir fn main f0 {
-        //   b0():
-        //     v9 = allocate
-        //     v10 = allocate
-        //     jmp b1()
-        //   b1():
-        //     return
-        // }
-        let ssa = ssa.mem2reg();
-        println!("{}", ssa);
-        let main = ssa.main();
-        assert_eq!(main.reachable_blocks().len(), 2);
+        let instructions = main.dfg[main.entry_block()].instructions();
+        assert_eq!(instructions.len(), 6); // The final return is not counted
 
         // All loads should be removed
-        assert_eq!(count_loads(main.entry_block(), &main.dfg), 0);
-        assert_eq!(count_loads(b1, &main.dfg), 0);
-
-        // All stores should be removed.
+        // The first store is not removed as it is used as a nested reference in another store.
+        // We would need to track whether the store where `v0` is the store value gets removed to know whether
+        // to remove it.
         // The first store in b1 is removed since there is another store to the same reference
         // in the same block, and the store is not needed before the later store.
         // The rest of the stores are also removed as no loads are done within any blocks
         // to the stored values.
-        assert_eq!(count_stores(main.entry_block(), &main.dfg), 0);
-        assert_eq!(count_stores(b1, &main.dfg), 0);
-
-        let b1_instructions = main.dfg[b1].instructions();
-
-        // We expect the last eq to be optimized out
-        assert_eq!(b1_instructions.len(), 0);
-    }
-
-    #[test]
-    fn remove_unused_loads_and_stores() {
-        // acir(inline) fn main f0 {
-        //     b0():
-        //       v0 = allocate
-        //       store Field 1 at v0
-        //       v2 = allocate
-        //       store Field 1 at v2
-        //       v4 = allocate
-        //       store u1 0 at v4
-        //       v5 = allocate
-        //       store u1 0 at v5
-        //       v6 = allocate
-        //       store u1 0 at v6
-        //       jmp b1(u1 0)
-        //     b1(v7: u32):
-        //       v9 = eq v7, u32 0
-        //       jmpif v9 then: b3, else: b2
-        //     b3():
-        //       v20 = load v0
-        //       v21 = load v2
-        //       v22 = load v4
-        //       v23 = load v5
-        //       v24 = load v6
-        //       constrain v20 == Field 1
-        //       v25 = eq v21, Field 1
-        //       constrain v21 == Field 1
-        //       v26 = eq v7, u32 0
-        //       jmp b1(v26)
-        //     b2():
-        //       v10 = load v0
-        //       v11 = load v2
-        //       v12 = load v4
-        //       v13 = load v5
-        //       v14 = load v6
-        //       store Field 1 at v0
-        //       store Field 1 at v2
-        //       store v12 at v4
-        //       store v13 at v5
-        //       store v14 at v6
-        //       v15 = load v0
-        //       v16 = load v2
-        //       v17 = load v4
-        //       v18 = load v5
-        //       v19 = load v6
-        //       constrain v15 == Field 1
-        //       return v16
-        //   }
-        let main_id = Id::test_new(0);
-        let mut builder = FunctionBuilder::new("main".into(), main_id);
-
-        let v0 = builder.insert_allocate(Type::field());
-        let one = builder.numeric_constant(1u128, Type::field());
-        builder.insert_store(v0, one);
-
-        let v2 = builder.insert_allocate(Type::field());
-        builder.insert_store(v2, one);
-
-        let zero_bool = builder.numeric_constant(0u128, Type::bool());
-        let v4 = builder.insert_allocate(Type::bool());
-        builder.insert_store(v4, zero_bool);
-
-        let v6 = builder.insert_allocate(Type::bool());
-        builder.insert_store(v6, zero_bool);
-
-        let v8 = builder.insert_allocate(Type::bool());
-        builder.insert_store(v8, zero_bool);
-
-        let b1 = builder.insert_block();
-        builder.terminate_with_jmp(b1, vec![zero_bool]);
-
-        builder.switch_to_block(b1);
-
-        let v7 = builder.add_block_parameter(b1, Type::unsigned(32));
-        let zero_u32 = builder.numeric_constant(0u128, Type::unsigned(32));
-        let is_zero = builder.insert_binary(v7, BinaryOp::Eq, zero_u32);
-
-        let b2 = builder.insert_block();
-        let b3 = builder.insert_block();
-        builder.terminate_with_jmpif(is_zero, b3, b2);
-
-        builder.switch_to_block(b2);
-
-        let _ = builder.insert_load(v0, Type::field());
-        let _ = builder.insert_load(v2, Type::field());
-        let v12 = builder.insert_load(v4, Type::bool());
-        let v13 = builder.insert_load(v6, Type::bool());
-        let v14 = builder.insert_load(v8, Type::bool());
-
-        builder.insert_store(v0, one);
-        builder.insert_store(v2, one);
-        builder.insert_store(v4, v12);
-        builder.insert_store(v6, v13);
-        builder.insert_store(v8, v14);
-
-        let v15 = builder.insert_load(v0, Type::field());
-        // Insert unused loads
-        let v16 = builder.insert_load(v2, Type::field());
-        let _ = builder.insert_load(v4, Type::bool());
-        let _ = builder.insert_load(v6, Type::bool());
-        let _ = builder.insert_load(v8, Type::bool());
-
-        builder.insert_constrain(v15, one, None);
-        builder.terminate_with_return(vec![v16]);
-
-        builder.switch_to_block(b3);
-
-        let v26 = builder.insert_load(v0, Type::field());
-        // Insert unused loads
-        let v27 = builder.insert_load(v2, Type::field());
-        let _ = builder.insert_load(v4, Type::bool());
-        let _ = builder.insert_load(v6, Type::bool());
-        let _ = builder.insert_load(v8, Type::bool());
-
-        builder.insert_constrain(v26, one, None);
-        let _ = builder.insert_binary(v27, BinaryOp::Eq, one);
-        builder.insert_constrain(v27, one, None);
-        let one_u32 = builder.numeric_constant(0u128, Type::unsigned(32));
-        let plus_one = builder.insert_binary(v7, BinaryOp::Eq, one_u32);
-        builder.terminate_with_jmp(b1, vec![plus_one]);
-
-        let ssa = builder.finish();
+        let expected = "
+        acir(inline) fn main f0 {
+          b0():
+            v0 = allocate -> &mut Field
+            store Field 0 at v0
+            v2 = allocate -> &mut &mut Field
+            jmp b1()
+          b1():
+            return
+        }
+        ";
 
-        // Expected result:
-        // acir(inline) fn main f0 {
-        //     b0():
-        //       v27 = allocate
-        //       v28 = allocate
-        //       v29 = allocate
-        //       v30 = allocate
-        //       v31 = allocate
-        //       jmp b1(u1 0)
-        //     b1(v7: u32):
-        //       v32 = eq v7, u32 0
-        //       jmpif v32 then: b3, else: b2
-        //     b3():
-        //       v49 = eq v7, u32 0
-        //       jmp b1(v49)
-        //     b2():
-        //       return Field 1
-        //   }
         let ssa = ssa.mem2reg();
-
-        let main = ssa.main();
-        assert_eq!(main.reachable_blocks().len(), 4);
-
-        // All loads should be removed
-        assert_eq!(count_loads(b2, &main.dfg), 0);
-        assert_eq!(count_loads(b3, &main.dfg), 0);
-
-        // All stores should be removed
-        assert_eq!(count_stores(main.entry_block(), &main.dfg), 0);
-        assert_eq!(count_stores(b2, &main.dfg), 0);
-        // Should only have one instruction in b3
-        assert_eq!(main.dfg[b3].instructions().len(), 1);
+        assert_normalized_ssa_equals(ssa, expected);
     }
 
     #[test]
@@ -1408,7 +963,7 @@ mod tests {
         //       v10 = eq v9, Field 2
         //       constrain v9 == Field 2
         //       v11 = load v2
-        //       v12 = load v10
+        //       v12 = load v11
         //       v13 = eq v12, Field 2
         //       constrain v11 == Field 2
         //       return
@@ -1417,7 +972,7 @@ mod tests {
         let mut builder = FunctionBuilder::new("main".into(), main_id);
 
         let v0 = builder.insert_allocate(Type::field());
-        let zero = builder.numeric_constant(0u128, Type::field());
+        let zero = builder.field_constant(0u128);
         builder.insert_store(v0, zero);
 
         let v2 = builder.insert_allocate(Type::field());
@@ -1441,9 +996,9 @@ mod tests {
         // Loop body
         builder.switch_to_block(b2);
         let v5 = builder.insert_load(v2, v2_type.clone());
-        let two = builder.numeric_constant(2u128, Type::field());
+        let two = builder.field_constant(2u128);
         builder.insert_store(v5, two);
-        let one = builder.numeric_constant(1u128, Type::field());
+        let one = builder.field_constant(1u128);
         let v3_plus_one = builder.insert_binary(v3, BinaryOp::Add, one);
         builder.terminate_with_jmp(b1, vec![v3_plus_one]);
 
@@ -1467,7 +1022,7 @@ mod tests {
         let main = ssa.main();
         assert_eq!(main.reachable_blocks().len(), 4);
 
-        // The store from the original SSA should remain
+        // The stores from the original SSA should remain
         assert_eq!(count_stores(main.entry_block(), &main.dfg), 2);
         assert_eq!(count_stores(b2, &main.dfg), 1);
 
@@ -1476,238 +1031,198 @@ mod tests {
     }
 
     #[test]
-    fn accurate_tracking_of_load_results() {
-        // acir(inline) fn main f0 {
-        //     b0():
-        //       v0 = allocate
-        //       store Field 5 at v0
-        //       v2 = allocate
-        //       store u32 10 at v2
-        //       v4 = load v0
-        //       v5 = load v2
-        //       v6 = allocate
-        //       store v4 at v6
-        //       v7 = allocate
-        //       store v5 at v7
-        //       v8 = load v6
-        //       v9 = load v7
-        //       v10 = load v6
-        //       v11 = load v7
-        //       v12 = allocate
-        //       store Field 0 at v12
-        //       v15 = eq v11, u32 0
-        //       jmpif v15 then: b1, else: b2
-        //     b1():
-        //       v16 = load v12
-        //       v17 = add v16, v8
-        //       store v17 at v12
-        //       jmp b2()
-        //     b2():
-        //       v18 = load v12
-        //       return [v18]
-        //   }
+    fn parameter_alias() {
+        // Do not assume parameters are not aliased to each other.
+        // The load below shouldn't be removed since `v0` could
+        // be aliased to `v1`.
+        //
+        // fn main f0 {
+        //   b0(v0: &mut Field, v1: &mut Field):
+        //     store Field 0 at v0
+        //     store Field 1 at v1
+        //     v4 = load v0
+        //     constrain v4 == Field 1
+        //     return
+        // }
         let main_id = Id::test_new(0);
         let mut builder = FunctionBuilder::new("main".into(), main_id);
 
-        let v0 = builder.insert_allocate(Type::field());
-        let five = builder.numeric_constant(5u128, Type::field());
-        builder.insert_store(v0, five);
+        let field_ref = Type::Reference(Arc::new(Type::field()));
+        let v0 = builder.add_parameter(field_ref.clone());
+        let v1 = builder.add_parameter(field_ref.clone());
 
-        let v2 = builder.insert_allocate(Type::unsigned(32));
-        let ten = builder.numeric_constant(10u128, Type::unsigned(32));
-        builder.insert_store(v2, ten);
+        let zero = builder.field_constant(0u128);
+        let one = builder.field_constant(0u128);
+        builder.insert_store(v0, zero);
+        builder.insert_store(v1, one);
 
         let v4 = builder.insert_load(v0, Type::field());
-        let v5 = builder.insert_load(v2, Type::unsigned(32));
-        let v4_type = builder.current_function.dfg.type_of_value(v4);
-        let v5_type = builder.current_function.dfg.type_of_value(v5);
-
-        let v6 = builder.insert_allocate(Type::field());
-        builder.insert_store(v6, v4);
-        let v7 = builder.insert_allocate(Type::unsigned(32));
-        builder.insert_store(v7, v5);
-
-        let v8 = builder.insert_load(v6, v4_type.clone());
-        let _v9 = builder.insert_load(v7, v5_type.clone());
-
-        let _v10 = builder.insert_load(v6, v4_type);
-        let v11 = builder.insert_load(v7, v5_type);
-
-        let v12 = builder.insert_allocate(Type::field());
-        let zero = builder.numeric_constant(0u128, Type::field());
-        builder.insert_store(v12, zero);
-
-        let zero_u32 = builder.numeric_constant(0u128, Type::unsigned(32));
-        let v15 = builder.insert_binary(v11, BinaryOp::Eq, zero_u32);
-
-        let b1 = builder.insert_block();
-        let b2 = builder.insert_block();
-        builder.terminate_with_jmpif(v15, b1, b2);
-
-        builder.switch_to_block(b1);
-
-        let v16 = builder.insert_load(v12, Type::field());
-        let v17 = builder.insert_binary(v16, BinaryOp::Add, v8);
-        builder.insert_store(v12, v17);
-
-        builder.terminate_with_jmp(b2, vec![]);
-
-        builder.switch_to_block(b2);
-        let v18 = builder.insert_load(v12, Type::field());
-
-        // Include the load result as part of an array constant to check that we are accounting for arrays
-        // when updating the reference counts of load results.
-        //
-        // If we were not accounting for arrays appropriately, the load of v18 would be removed.
-        // If v18 is the last load of a reference and is inadvertently removed,
-        // any stores to v12 will then be potentially removed as well and the program will be broken.
-        let return_array =
-            builder.array_constant(vector![v18], Type::Array(Arc::new(vec![Type::field()]), 1));
-        builder.terminate_with_return(vec![return_array]);
+        builder.insert_constrain(v4, one, None);
+        builder.terminate_with_return(Vec::new());
 
         let ssa = builder.finish();
+        let main = ssa.main();
+        assert_eq!(count_loads(main.entry_block(), &main.dfg), 1);
 
-        // Expected result:
-        // acir(inline) fn main f0 {
-        //     b0():
-        //       v20 = allocate
-        //       v21 = allocate
-        //       v24 = allocate
-        //       v25 = allocate
-        //       v30 = allocate
-        //       store Field 0 at v30
-        //       jmpif u1 0 then: b1, else: b2
-        //     b1():
-        //       store Field 5 at v30
-        //       jmp b2()
-        //     b2():
-        //       v33 = load v30
-        //       return [v33]
-        //   }
+        // No change expected
         let ssa = ssa.mem2reg();
-
         let main = ssa.main();
-        assert_eq!(main.reachable_blocks().len(), 3);
-
-        // A single store from the entry block should remain.
-        // If we are not appropriately handling unused stores across a function,
-        // we would expect all five stores from the original SSA to remain.
-        assert_eq!(count_stores(main.entry_block(), &main.dfg), 1);
-        // The store from the conditional block should remain,
-        // as it is loaded from in a successor block and used in the return terminator.
-        assert_eq!(count_stores(b1, &main.dfg), 1);
-
-        assert_eq!(count_loads(main.entry_block(), &main.dfg), 0);
-        assert_eq!(count_loads(b1, &main.dfg), 0);
-        assert_eq!(count_loads(b2, &main.dfg), 1);
+        assert_eq!(count_loads(main.entry_block(), &main.dfg), 1);
     }
 
     #[test]
-    fn keep_unused_store_only_used_as_an_alias_across_blocks() {
-        // acir(inline) fn main f0 {
-        //     b0(v0: u32):
-        //       v1 = allocate
-        //       store u32 0 at v1
-        //       v3 = allocate
-        //       store v1 at v3
-        //       v4 = allocate
-        //       store v0 at v4
-        //       v5 = allocate
-        //       store v4 at v5
-        //       jmp b1(u32 0)
-        //     b1(v6: u32):
-        //       v7 = eq v6, u32 0
-        //       jmpif v7 then: b2, else: b3
-        //     b2():
-        //       v8 = load v5
-        //       store v8 at u2 2
-        //       v11 = add v6, u32 1
-        //       jmp b1(v11)
-        //     b3():
-        //       v12 = load v4
-        //       constrain v12 == u2 2
-        //       v13 = load v5
-        //       v14 = load v13
-        //       constrain v14 == u2 2
-        //       v15 = load v3
-        //       v16 = load v15
-        //       v18 = lt v16, u32 4
-        //       constrain v18 == u32 1
-        //       return
-        //   }
-        let main_id = Id::test_new(0);
-        let mut builder = FunctionBuilder::new("main".into(), main_id);
-
-        let v0 = builder.add_parameter(Type::unsigned(32));
-
-        let v1 = builder.insert_allocate(Type::unsigned(32));
-        let zero = builder.numeric_constant(0u128, Type::unsigned(32));
-        builder.insert_store(v1, zero);
-
-        let v1_type = builder.type_of_value(v1);
-        let v3 = builder.insert_allocate(v1_type.clone());
-        builder.insert_store(v3, v1);
-
-        let v4 = builder.insert_allocate(Type::unsigned(32));
-        builder.insert_store(v4, v0);
-
-        let v5 = builder.insert_allocate(Type::Reference(Arc::new(Type::unsigned(32))));
-        builder.insert_store(v5, v4);
-
-        let b1 = builder.insert_block();
-        builder.terminate_with_jmp(b1, vec![zero]);
-        builder.switch_to_block(b1);
+    fn remove_repeat_loads() {
+        // This tests starts with two loads from the same unknown load.
+        // Specifically you should look for `load v2` in `b3`.
+        // We should be able to remove the second repeated load.
+        let src = "
+        acir(inline) fn main f0 {
+          b0():
+            v0 = allocate -> &mut Field
+            store Field 0 at v0
+            v2 = allocate -> &mut &mut Field
+            store v0 at v2
+            jmp b1(Field 0)
+          b1(v3: Field):
+            v4 = eq v3, Field 0
+            jmpif v4 then: b2, else: b3
+          b2():
+            v5 = load v2 -> &mut Field
+            store Field 2 at v5
+            v8 = add v3, Field 1
+            jmp b1(v8)
+          b3():
+            v9 = load v0 -> Field
+            v10 = eq v9, Field 2
+            constrain v9 == Field 2
+            v11 = load v2 -> &mut Field
+            v12 = load v2 -> &mut Field
+            v13 = load v12 -> Field
+            v14 = eq v13, Field 2
+            constrain v13 == Field 2
+            return
+        }
+        ";
 
-        let v6 = builder.add_block_parameter(b1, Type::unsigned(32));
-        let is_zero = builder.insert_binary(v6, BinaryOp::Eq, zero);
+        let ssa = Ssa::from_str(src).unwrap();
 
-        let b2 = builder.insert_block();
-        let b3 = builder.insert_block();
-        builder.terminate_with_jmpif(is_zero, b2, b3);
+        // The repeated load from v3 should be removed
+        // b3 should only have three loads now rather than four previously
+        //
+        // All stores are expected to remain.
+        let expected = "
+        acir(inline) fn main f0 {
+          b0():
+            v1 = allocate -> &mut Field
+            store Field 0 at v1
+            v3 = allocate -> &mut &mut Field
+            store v1 at v3
+            jmp b1(Field 0)
+          b1(v0: Field):
+            v4 = eq v0, Field 0
+            jmpif v4 then: b3, else: b2
+          b2():
+            v5 = load v1 -> Field
+            v7 = eq v5, Field 2
+            constrain v5 == Field 2
+            v8 = load v3 -> &mut Field
+            v9 = load v8 -> Field
+            v10 = eq v9, Field 2
+            constrain v9 == Field 2
+            return
+          b3():
+            v11 = load v3 -> &mut Field
+            store Field 2 at v11
+            v13 = add v0, Field 1
+            jmp b1(v13)
+        }
+        ";
 
-        builder.switch_to_block(b2);
-        let v4_type = builder.type_of_value(v4);
-        // let v0_type = builder.type_of_value(v4);
-        let v8 = builder.insert_load(v5, v4_type);
-        let two = builder.numeric_constant(2u128, Type::unsigned(2));
-        builder.insert_store(v8, two);
-        let one = builder.numeric_constant(1u128, Type::unsigned(32));
-        let v11 = builder.insert_binary(v6, BinaryOp::Add, one);
-        builder.terminate_with_jmp(b1, vec![v11]);
+        let ssa = ssa.mem2reg();
+        assert_normalized_ssa_equals(ssa, expected);
+    }
 
-        builder.switch_to_block(b3);
+    #[test]
+    fn keep_repeat_loads_passed_to_a_call() {
+        // The test is the exact same as `remove_repeat_loads` above except with the call
+        // to `f1` between the repeated loads.
+        let src = "
+        acir(inline) fn main f0 {
+          b0():
+            v1 = allocate -> &mut Field
+            store Field 0 at v1
+            v3 = allocate -> &mut &mut Field
+            store v1 at v3
+            jmp b1(Field 0)
+          b1(v0: Field):
+            v4 = eq v0, Field 0
+            jmpif v4 then: b3, else: b2
+          b2():
+            v5 = load v1 -> Field
+            v7 = eq v5, Field 2
+            constrain v5 == Field 2
+            v8 = load v3 -> &mut Field
+            call f1(v3)
+            v10 = load v3 -> &mut Field
+            v11 = load v10 -> Field
+            v12 = eq v11, Field 2
+            constrain v11 == Field 2
+            return
+          b3():
+            v13 = load v3 -> &mut Field
+            store Field 2 at v13
+            v15 = add v0, Field 1
+            jmp b1(v15)
+        }
+        acir(inline) fn foo f1 {
+          b0(v0: &mut Field):
+            return
+        }  
+        ";
 
-        let v12 = builder.insert_load(v4, Type::unsigned(32));
-        builder.insert_constrain(v12, two, None);
+        let ssa = Ssa::from_str(src).unwrap();
 
-        let v3_type = builder.type_of_value(v3);
-        let v13 = builder.insert_load(v5, v3_type);
-        let v14 = builder.insert_load(v13, Type::unsigned(32));
-        builder.insert_constrain(v14, two, None);
+        let ssa = ssa.mem2reg();
+        // We expect the program to be unchanged
+        assert_normalized_ssa_equals(ssa, src);
+    }
 
-        let v15 = builder.insert_load(v3, v1_type);
-        let v16 = builder.insert_load(v15, Type::unsigned(32));
-        let four = builder.numeric_constant(4u128, Type::unsigned(32));
-        let less_than_four = builder.insert_binary(v16, BinaryOp::Lt, four);
-        builder.insert_constrain(less_than_four, one, None);
+    #[test]
+    fn keep_repeat_loads_with_alias_store() {
+        // v7, v8, and v9 alias one another. We want to make sure that a repeat load to v7 with a store
+        // to its aliases in between the repeat loads does not remove those loads.
+        let src = "
+        acir(inline) fn main f0 {
+          b0(v0: u1):
+            jmpif v0 then: b2, else: b1
+          b1():
+            v4 = allocate -> &mut Field
+            store Field 1 at v4
+            jmp b3(v4, v4, v4)
+          b2():
+            v6 = allocate -> &mut Field
+            store Field 0 at v6
+            jmp b3(v6, v6, v6)
+          b3(v1: &mut Field, v2: &mut Field, v3: &mut Field):
+            v8 = load v1 -> Field
+            store Field 2 at v2
+            v10 = load v1 -> Field
+            store Field 1 at v3
+            v11 = load v1 -> Field
+            store Field 3 at v3
+            v13 = load v1 -> Field
+            constrain v8 == Field 0
+            constrain v10 == Field 2
+            constrain v11 == Field 1
+            constrain v13 == Field 3
+            return
+        }
+        ";
 
-        builder.terminate_with_return(vec![]);
-        let ssa = builder.finish();
+        let ssa = Ssa::from_str(src).unwrap();
 
-        // We expect the same result as above.
         let ssa = ssa.mem2reg();
-        let main = ssa.main();
-
-        // We expect all the stores to remain.
-        // The references in b0 are aliased and those are aliases may never be stored to again,
-        // but they are loaded from and used in later instructions.
-        // We need to make sure that the store of the address being aliased, is not removed from the program.
-        assert_eq!(count_stores(main.entry_block(), &main.dfg), 4);
-        // The store inside of the loop should remain
-        assert_eq!(count_stores(b2, &main.dfg), 1);
-
-        // We expect the loads to remain the same
-        assert_eq!(count_loads(b2, &main.dfg), 1);
-        assert_eq!(count_loads(b3, &main.dfg), 5);
+        // We expect the program to be unchanged
+        assert_normalized_ssa_equals(ssa, src);
     }
 }
diff --git a/compiler/noirc_evaluator/src/ssa/opt/mem2reg/alias_set.rs b/compiler/noirc_evaluator/src/ssa/opt/mem2reg/alias_set.rs
index 5477025e429..e32eaa70186 100644
--- a/compiler/noirc_evaluator/src/ssa/opt/mem2reg/alias_set.rs
+++ b/compiler/noirc_evaluator/src/ssa/opt/mem2reg/alias_set.rs
@@ -24,6 +24,10 @@ impl AliasSet {
         Self { aliases: Some(aliases) }
     }
 
+    pub(super) fn known_multiple(values: BTreeSet<ValueId>) -> AliasSet {
+        Self { aliases: Some(values) }
+    }
+
     /// In rare cases, such as when creating an empty array of references, the set of aliases for a
     /// particular value will be known to be zero, which is distinct from being unknown and
     /// possibly referring to any alias.
@@ -73,4 +77,11 @@ impl AliasSet {
             }
         }
     }
+
+    /// Return the first ValueId in the alias set as long as there is at least one.
+    /// The ordering is arbitrary (by lowest ValueId) so this method should only be
+    /// used when you need an arbitrary ValueId from the alias set.
+    pub(super) fn first(&self) -> Option<ValueId> {
+        self.aliases.as_ref().and_then(|aliases| aliases.first().copied())
+    }
 }
diff --git a/compiler/noirc_evaluator/src/ssa/opt/mem2reg/block.rs b/compiler/noirc_evaluator/src/ssa/opt/mem2reg/block.rs
index 532785d2928..f4265b2466d 100644
--- a/compiler/noirc_evaluator/src/ssa/opt/mem2reg/block.rs
+++ b/compiler/noirc_evaluator/src/ssa/opt/mem2reg/block.rs
@@ -34,6 +34,9 @@ pub(super) struct Block {
 
     /// The last instance of a `Store` instruction to each address in this block
     pub(super) last_stores: im::OrdMap<ValueId, InstructionId>,
+
+    // The last instance of a `Load` instruction to each address in this block
+    pub(super) last_loads: im::OrdMap<ValueId, InstructionId>,
 }
 
 /// An `Expression` here is used to represent a canonical key
@@ -237,4 +240,14 @@ impl Block {
 
         Cow::Owned(AliasSet::unknown())
     }
+
+    pub(super) fn set_last_load(&mut self, address: ValueId, instruction: InstructionId) {
+        self.last_loads.insert(address, instruction);
+    }
+
+    pub(super) fn keep_last_load_for(&mut self, address: ValueId, function: &Function) {
+        let address = function.dfg.resolve(address);
+        self.last_loads.remove(&address);
+        self.for_each_alias_of(address, |block, alias| block.last_loads.remove(&alias));
+    }
 }
diff --git a/compiler/noirc_evaluator/src/ssa/opt/mod.rs b/compiler/noirc_evaluator/src/ssa/opt/mod.rs
index e570323cb26..285342c18c7 100644
--- a/compiler/noirc_evaluator/src/ssa/opt/mod.rs
+++ b/compiler/noirc_evaluator/src/ssa/opt/mod.rs
@@ -11,7 +11,9 @@ mod constant_folding;
 mod defunctionalize;
 mod die;
 pub(crate) mod flatten_cfg;
+mod hint;
 mod inlining;
+mod loop_invariant;
 mod mem2reg;
 mod normalize_value_ids;
 mod rc;
@@ -22,3 +24,30 @@ mod resolve_is_unconstrained;
 mod runtime_separation;
 mod simplify_cfg;
 mod unrolling;
+
+/// Asserts that the given SSA, after normalizing its IDs and printing it,
+/// is equal to the expected strings. Normalization is done so the IDs don't
+/// shift depending on whether temporary intermediate values were created.
+#[cfg(test)]
+pub(crate) fn assert_normalized_ssa_equals(mut ssa: super::Ssa, expected: &str) {
+    // First check if `expected` is valid SSA by parsing it, otherwise
+    // the comparison will always fail but it won't be clear that it's because
+    // expected is not valid.
+    if let Err(err) = Ssa::from_str(expected) {
+        panic!("`expected` argument of `assert_ssa_equals` is not valid SSA:\n{:?}", err);
+    }
+
+    use crate::{ssa::Ssa, trim_comments_from_lines, trim_leading_whitespace_from_lines};
+
+    ssa.normalize_ids();
+
+    let ssa = ssa.to_string();
+    let ssa = trim_leading_whitespace_from_lines(&ssa);
+    let expected = trim_leading_whitespace_from_lines(expected);
+    let expected = trim_comments_from_lines(&expected);
+
+    if ssa != expected {
+        println!("Expected:\n~~~\n{expected}\n~~~\nGot:\n~~~\n{ssa}\n~~~");
+        similar_asserts::assert_eq!(expected, ssa);
+    }
+}
diff --git a/compiler/noirc_evaluator/src/ssa/opt/normalize_value_ids.rs b/compiler/noirc_evaluator/src/ssa/opt/normalize_value_ids.rs
index f11b310494b..f5e96224260 100644
--- a/compiler/noirc_evaluator/src/ssa/opt/normalize_value_ids.rs
+++ b/compiler/noirc_evaluator/src/ssa/opt/normalize_value_ids.rs
@@ -115,6 +115,11 @@ impl Context {
             terminator.mutate_blocks(|old_block| self.new_ids.blocks[&old_block]);
             new_function.dfg.set_block_terminator(new_block_id, terminator);
         }
+
+        // Also map the values in the databus
+        let old_databus = &old_function.dfg.data_bus;
+        new_function.dfg.data_bus = old_databus
+            .map_values(|old_value| self.new_ids.map_value(new_function, old_function, old_value));
     }
 }
 
@@ -172,20 +177,7 @@ impl IdMaps {
             }
 
             Value::NumericConstant { constant, typ } => {
-                new_function.dfg.make_constant(*constant, typ.clone())
-            }
-            Value::Array { array, typ } => {
-                if let Some(value) = self.values.get(&old_value) {
-                    return *value;
-                }
-
-                let array = array
-                    .iter()
-                    .map(|value| self.map_value(new_function, old_function, *value))
-                    .collect();
-                let new_value = new_function.dfg.make_array(array, typ.clone());
-                self.values.insert(old_value, new_value);
-                new_value
+                new_function.dfg.make_constant(*constant, *typ)
             }
             Value::Intrinsic(intrinsic) => new_function.dfg.import_intrinsic(*intrinsic),
             Value::ForeignFunction(name) => new_function.dfg.import_foreign_function(name),
diff --git a/compiler/noirc_evaluator/src/ssa/opt/rc.rs b/compiler/noirc_evaluator/src/ssa/opt/rc.rs
index 06025fd9e8b..64f6e2ddfea 100644
--- a/compiler/noirc_evaluator/src/ssa/opt/rc.rs
+++ b/compiler/noirc_evaluator/src/ssa/opt/rc.rs
@@ -22,7 +22,7 @@ impl Ssa {
     #[tracing::instrument(level = "trace", skip(self))]
     pub(crate) fn remove_paired_rc(mut self) -> Ssa {
         for function in self.functions.values_mut() {
-            remove_paired_rc(function);
+            function.remove_paired_rc();
         }
         self
     }
@@ -44,26 +44,28 @@ pub(crate) struct RcInstruction {
     pub(crate) possibly_mutated: bool,
 }
 
-/// This function is very simplistic for now. It takes advantage of the fact that dec_rc
-/// instructions are currently issued only at the end of a function for parameters and will
-/// only check the first and last block for inc & dec rc instructions to be removed. The rest
-/// of the function is still checked for array_set instructions.
-///
-/// This restriction lets this function largely ignore merging intermediate results from other
-/// blocks and handling loops.
-fn remove_paired_rc(function: &mut Function) {
-    // `dec_rc` is only issued for parameters currently so we can speed things
-    // up a bit by skipping any functions without them.
-    if !contains_array_parameter(function) {
-        return;
-    }
+impl Function {
+    /// This function is very simplistic for now. It takes advantage of the fact that dec_rc
+    /// instructions are currently issued only at the end of a function for parameters and will
+    /// only check the first and last block for inc & dec rc instructions to be removed. The rest
+    /// of the function is still checked for array_set instructions.
+    ///
+    /// This restriction lets this function largely ignore merging intermediate results from other
+    /// blocks and handling loops.
+    pub(crate) fn remove_paired_rc(&mut self) {
+        // `dec_rc` is only issued for parameters currently so we can speed things
+        // up a bit by skipping any functions without them.
+        if !contains_array_parameter(self) {
+            return;
+        }
 
-    let mut context = Context::default();
+        let mut context = Context::default();
 
-    context.find_rcs_in_entry_block(function);
-    context.scan_for_array_sets(function);
-    let to_remove = context.find_rcs_to_remove(function);
-    remove_instructions(to_remove, function);
+        context.find_rcs_in_entry_block(self);
+        context.scan_for_array_sets(self);
+        let to_remove = context.find_rcs_to_remove(self);
+        remove_instructions(to_remove, self);
+    }
 }
 
 fn contains_array_parameter(function: &mut Function) -> bool {
@@ -153,11 +155,17 @@ fn remove_instructions(to_remove: HashSet<InstructionId>, function: &mut Functio
 mod test {
     use std::sync::Arc;
 
+    use noirc_frontend::monomorphization::ast::InlineType;
+
     use crate::ssa::{
         function_builder::FunctionBuilder,
         ir::{
-            basic_block::BasicBlockId, dfg::DataFlowGraph, function::RuntimeType,
-            instruction::Instruction, map::Id, types::Type,
+            basic_block::BasicBlockId,
+            dfg::DataFlowGraph,
+            function::RuntimeType,
+            instruction::Instruction,
+            map::Id,
+            types::{NumericType, Type},
         },
     };
 
@@ -193,11 +201,12 @@ mod test {
         //     inc_rc v0
         //     inc_rc v0
         //     dec_rc v0
-        //     return [v0]
+        //     v1 = make_array [v0]
+        //     return v1
         // }
         let main_id = Id::test_new(0);
         let mut builder = FunctionBuilder::new("foo".into(), main_id);
-        builder.set_runtime(RuntimeType::Brillig);
+        builder.set_runtime(RuntimeType::Brillig(InlineType::default()));
 
         let inner_array_type = Type::Array(Arc::new(vec![Type::field()]), 2);
         let v0 = builder.add_parameter(inner_array_type.clone());
@@ -207,8 +216,8 @@ mod test {
         builder.insert_dec_rc(v0);
 
         let outer_array_type = Type::Array(Arc::new(vec![inner_array_type]), 1);
-        let array = builder.array_constant(vec![v0].into(), outer_array_type);
-        builder.terminate_with_return(vec![array]);
+        let v1 = builder.insert_make_array(vec![v0].into(), outer_array_type);
+        builder.terminate_with_return(vec![v1]);
 
         let ssa = builder.finish().remove_paired_rc();
         let main = ssa.main();
@@ -246,7 +255,7 @@ mod test {
         builder.insert_inc_rc(v0);
         let v2 = builder.insert_load(v1, array_type);
 
-        let zero = builder.numeric_constant(0u128, Type::unsigned(64));
+        let zero = builder.numeric_constant(0u128, NumericType::unsigned(64));
         let five = builder.field_constant(5u128);
         let v7 = builder.insert_array_set(v2, zero, five);
 
@@ -297,7 +306,7 @@ mod test {
         builder.insert_store(v0, v1);
 
         let v2 = builder.insert_load(v1, array_type.clone());
-        let zero = builder.numeric_constant(0u128, Type::unsigned(64));
+        let zero = builder.numeric_constant(0u128, NumericType::unsigned(64));
         let five = builder.field_constant(5u128);
         let v7 = builder.insert_array_set(v2, zero, five);
 
diff --git a/compiler/noirc_evaluator/src/ssa/opt/remove_bit_shifts.rs b/compiler/noirc_evaluator/src/ssa/opt/remove_bit_shifts.rs
index 984c0de04ca..872c7920a77 100644
--- a/compiler/noirc_evaluator/src/ssa/opt/remove_bit_shifts.rs
+++ b/compiler/noirc_evaluator/src/ssa/opt/remove_bit_shifts.rs
@@ -21,24 +21,30 @@ impl Ssa {
     #[tracing::instrument(level = "trace", skip(self))]
     pub(crate) fn remove_bit_shifts(mut self) -> Ssa {
         for function in self.functions.values_mut() {
-            remove_bit_shifts(function);
+            function.remove_bit_shifts();
         }
         self
     }
 }
 
-/// The structure of this pass is simple:
-/// Go through each block and re-insert all instructions.
-fn remove_bit_shifts(function: &mut Function) {
-    if let RuntimeType::Brillig = function.runtime() {
-        return;
-    }
+impl Function {
+    /// The structure of this pass is simple:
+    /// Go through each block and re-insert all instructions.
+    pub(crate) fn remove_bit_shifts(&mut self) {
+        if matches!(self.runtime(), RuntimeType::Brillig(_)) {
+            return;
+        }
 
-    let block = function.entry_block();
-    let mut context =
-        Context { function, new_instructions: Vec::new(), block, call_stack: CallStack::default() };
+        let block = self.entry_block();
+        let mut context = Context {
+            function: self,
+            new_instructions: Vec::new(),
+            block,
+            call_stack: CallStack::default(),
+        };
 
-    context.remove_bit_shifts();
+        context.remove_bit_shifts();
+    }
 }
 
 struct Context<'f> {
@@ -94,7 +100,7 @@ impl Context<'_> {
         bit_size: u32,
     ) -> ValueId {
         let base = self.field_constant(FieldElement::from(2_u128));
-        let typ = self.function.dfg.type_of_value(lhs);
+        let typ = self.function.dfg.type_of_value(lhs).unwrap_numeric();
         let (max_bit, pow) = if let Some(rhs_constant) = self.function.dfg.get_numeric_constant(rhs)
         {
             // Happy case is that we know precisely by how many bits the integer will
@@ -109,29 +115,29 @@ impl Context<'_> {
                     return InsertInstructionResult::SimplifiedTo(zero).first();
                 }
             }
-            let pow = self.numeric_constant(FieldElement::from(rhs_bit_size_pow_2), typ.clone());
+            let pow = self.numeric_constant(FieldElement::from(rhs_bit_size_pow_2), typ);
 
             let max_lhs_bits = self.function.dfg.get_value_max_num_bits(lhs);
 
             (max_lhs_bits + bit_shift_size, pow)
         } else {
             // we use a predicate to nullify the result in case of overflow
-            let bit_size_var =
-                self.numeric_constant(FieldElement::from(bit_size as u128), Type::unsigned(8));
+            let u8_type = NumericType::unsigned(8);
+            let bit_size_var = self.numeric_constant(FieldElement::from(bit_size as u128), u8_type);
             let overflow = self.insert_binary(rhs, BinaryOp::Lt, bit_size_var);
-            let predicate = self.insert_cast(overflow, typ.clone());
+            let predicate = self.insert_cast(overflow, typ);
             // we can safely cast to unsigned because overflow_checks prevent bit-shift with a negative value
-            let rhs_unsigned = self.insert_cast(rhs, Type::unsigned(bit_size));
+            let rhs_unsigned = self.insert_cast(rhs, NumericType::unsigned(bit_size));
             let pow = self.pow(base, rhs_unsigned);
-            let pow = self.insert_cast(pow, typ.clone());
+            let pow = self.insert_cast(pow, typ);
             (FieldElement::max_num_bits(), self.insert_binary(predicate, BinaryOp::Mul, pow))
         };
 
         if max_bit <= bit_size {
             self.insert_binary(lhs, BinaryOp::Mul, pow)
         } else {
-            let lhs_field = self.insert_cast(lhs, Type::field());
-            let pow_field = self.insert_cast(pow, Type::field());
+            let lhs_field = self.insert_cast(lhs, NumericType::NativeField);
+            let pow_field = self.insert_cast(pow, NumericType::NativeField);
             let result = self.insert_binary(lhs_field, BinaryOp::Mul, pow_field);
             let result = self.insert_truncate(result, bit_size, max_bit);
             self.insert_cast(result, typ)
@@ -139,24 +145,37 @@ impl Context<'_> {
     }
 
     /// Insert ssa instructions which computes lhs >> rhs by doing lhs/2^rhs
+    /// For negative signed integers, we do the division on the 1-complement representation of lhs,
+    /// before converting back the result to the 2-complement representation.
     pub(crate) fn insert_shift_right(
         &mut self,
         lhs: ValueId,
         rhs: ValueId,
         bit_size: u32,
     ) -> ValueId {
-        let lhs_typ = self.function.dfg.type_of_value(lhs);
+        let lhs_typ = self.function.dfg.type_of_value(lhs).unwrap_numeric();
         let base = self.field_constant(FieldElement::from(2_u128));
-        // we can safely cast to unsigned because overflow_checks prevent bit-shift with a negative value
-        let rhs_unsigned = self.insert_cast(rhs, Type::unsigned(bit_size));
-        let pow = self.pow(base, rhs_unsigned);
-        // We need at least one more bit for the case where rhs == bit_size
-        let div_type = Type::unsigned(bit_size + 1);
-        let casted_lhs = self.insert_cast(lhs, div_type.clone());
-        let casted_pow = self.insert_cast(pow, div_type);
-        let div_result = self.insert_binary(casted_lhs, BinaryOp::Div, casted_pow);
-        // We have to cast back to the original type
-        self.insert_cast(div_result, lhs_typ)
+        let pow = self.pow(base, rhs);
+        if lhs_typ.is_unsigned() {
+            // unsigned right bit shift is just a normal division
+            self.insert_binary(lhs, BinaryOp::Div, pow)
+        } else {
+            // Get the sign of the operand; positive signed operand will just do a division as well
+            let zero = self.numeric_constant(FieldElement::zero(), NumericType::signed(bit_size));
+            let lhs_sign = self.insert_binary(lhs, BinaryOp::Lt, zero);
+            let lhs_sign_as_field = self.insert_cast(lhs_sign, NumericType::NativeField);
+            let lhs_as_field = self.insert_cast(lhs, NumericType::NativeField);
+            // For negative numbers, convert to 1-complement using wrapping addition of a + 1
+            let one_complement = self.insert_binary(lhs_sign_as_field, BinaryOp::Add, lhs_as_field);
+            let one_complement = self.insert_truncate(one_complement, bit_size, bit_size + 1);
+            let one_complement = self.insert_cast(one_complement, NumericType::signed(bit_size));
+            // Performs the division on the 1-complement (or the operand if positive)
+            let shifted_complement = self.insert_binary(one_complement, BinaryOp::Div, pow);
+            // Convert back to 2-complement representation if operand is negative
+            let lhs_sign_as_int = self.insert_cast(lhs_sign, lhs_typ);
+            let shifted = self.insert_binary(shifted_complement, BinaryOp::Sub, lhs_sign_as_int);
+            self.insert_truncate(shifted, bit_size, bit_size + 1)
+        }
     }
 
     /// Computes lhs^rhs via square&multiply, using the bits decomposition of rhs
@@ -172,7 +191,7 @@ impl Context<'_> {
         let typ = self.function.dfg.type_of_value(rhs);
         if let Type::Numeric(NumericType::Unsigned { bit_size }) = typ {
             let to_bits = self.function.dfg.import_intrinsic(Intrinsic::ToBits(Endian::Little));
-            let result_types = vec![Type::Array(Arc::new(vec![Type::bool()]), bit_size as usize)];
+            let result_types = vec![Type::Array(Arc::new(vec![Type::bool()]), bit_size)];
             let rhs_bits = self.insert_call(to_bits, vec![rhs], result_types);
 
             let rhs_bits = rhs_bits[0];
@@ -184,8 +203,8 @@ impl Context<'_> {
                 let idx = self.field_constant(FieldElement::from((bit_size - i) as i128));
                 let b = self.insert_array_get(rhs_bits, idx, Type::bool());
                 let not_b = self.insert_not(b);
-                let b = self.insert_cast(b, Type::field());
-                let not_b = self.insert_cast(not_b, Type::field());
+                let b = self.insert_cast(b, NumericType::NativeField);
+                let not_b = self.insert_cast(not_b, NumericType::NativeField);
                 let r1 = self.insert_binary(a, BinaryOp::Mul, b);
                 let r2 = self.insert_binary(r_squared, BinaryOp::Mul, not_b);
                 r = self.insert_binary(r1, BinaryOp::Add, r2);
@@ -197,14 +216,14 @@ impl Context<'_> {
     }
 
     pub(crate) fn field_constant(&mut self, constant: FieldElement) -> ValueId {
-        self.function.dfg.make_constant(constant, Type::field())
+        self.function.dfg.make_constant(constant, NumericType::NativeField)
     }
 
     /// Insert a numeric constant into the current function
     pub(crate) fn numeric_constant(
         &mut self,
         value: impl Into<FieldElement>,
-        typ: Type,
+        typ: NumericType,
     ) -> ValueId {
         self.function.dfg.make_constant(value.into(), typ)
     }
@@ -241,7 +260,7 @@ impl Context<'_> {
 
     /// Insert a cast instruction at the end of the current block.
     /// Returns the result of the cast instruction.
-    pub(crate) fn insert_cast(&mut self, value: ValueId, typ: Type) -> ValueId {
+    pub(crate) fn insert_cast(&mut self, value: ValueId, typ: NumericType) -> ValueId {
         self.insert_instruction(Instruction::Cast(value, typ), None).first()
     }
 
diff --git a/compiler/noirc_evaluator/src/ssa/opt/remove_enable_side_effects.rs b/compiler/noirc_evaluator/src/ssa/opt/remove_enable_side_effects.rs
index a56786b2603..e85e2c4a441 100644
--- a/compiler/noirc_evaluator/src/ssa/opt/remove_enable_side_effects.rs
+++ b/compiler/noirc_evaluator/src/ssa/opt/remove_enable_side_effects.rs
@@ -16,9 +16,9 @@ use crate::ssa::{
     ir::{
         basic_block::BasicBlockId,
         dfg::DataFlowGraph,
-        function::Function,
-        instruction::{BinaryOp, Instruction, Intrinsic},
-        types::Type,
+        function::{Function, RuntimeType},
+        instruction::{BinaryOp, Hint, Instruction, Intrinsic},
+        types::NumericType,
         value::Value,
     },
     ssa_gen::Ssa,
@@ -29,23 +29,30 @@ impl Ssa {
     #[tracing::instrument(level = "trace", skip(self))]
     pub(crate) fn remove_enable_side_effects(mut self) -> Ssa {
         for function in self.functions.values_mut() {
-            remove_enable_side_effects(function);
+            function.remove_enable_side_effects();
         }
         self
     }
 }
 
-fn remove_enable_side_effects(function: &mut Function) {
-    let mut context = Context::default();
-    context.block_queue.push(function.entry_block());
-
-    while let Some(block) = context.block_queue.pop() {
-        if context.visited_blocks.contains(&block) {
-            continue;
+impl Function {
+    pub(crate) fn remove_enable_side_effects(&mut self) {
+        if matches!(self.runtime(), RuntimeType::Brillig(_)) {
+            // Brillig functions do not make use of the `EnableSideEffects` instruction so are unaffected by this pass.
+            return;
         }
 
-        context.visited_blocks.insert(block);
-        context.remove_enable_side_effects_in_block(function, block);
+        let mut context = Context::default();
+        context.block_queue.push(self.entry_block());
+
+        while let Some(block) = context.block_queue.pop() {
+            if context.visited_blocks.contains(&block) {
+                continue;
+            }
+
+            context.visited_blocks.insert(block);
+            context.remove_enable_side_effects_in_block(self, block);
+        }
     }
 }
 
@@ -63,7 +70,8 @@ impl Context {
     ) {
         let instructions = function.dfg[block].take_instructions();
 
-        let mut active_condition = function.dfg.make_constant(FieldElement::one(), Type::bool());
+        let one = FieldElement::one();
+        let mut active_condition = function.dfg.make_constant(one, NumericType::bool());
         let mut last_side_effects_enabled_instruction = None;
 
         let mut new_instructions = Vec::with_capacity(instructions.len());
@@ -138,7 +146,8 @@ impl Context {
             | RangeCheck { .. }
             | IfElse { .. }
             | IncrementRc { .. }
-            | DecrementRc { .. } => false,
+            | DecrementRc { .. }
+            | MakeArray { .. } => false,
 
             EnableSideEffectsIf { .. }
             | ArrayGet { .. }
@@ -166,12 +175,16 @@ impl Context {
                     | Intrinsic::ToBits(_)
                     | Intrinsic::ToRadix(_)
                     | Intrinsic::BlackBox(_)
+                    | Intrinsic::Hint(Hint::BlackBox)
                     | Intrinsic::FromField
                     | Intrinsic::AsField
                     | Intrinsic::AsSlice
                     | Intrinsic::AsWitness
                     | Intrinsic::IsUnconstrained
-                    | Intrinsic::DerivePedersenGenerators => false,
+                    | Intrinsic::DerivePedersenGenerators
+                    | Intrinsic::ArrayRefCount
+                    | Intrinsic::SliceRefCount
+                    | Intrinsic::FieldLessThan => false,
                 },
 
                 // We must assume that functions contain a side effect as we cannot inspect more deeply.
@@ -191,7 +204,7 @@ mod test {
         ir::{
             instruction::{BinaryOp, Instruction},
             map::Id,
-            types::Type,
+            types::{NumericType, Type},
         },
     };
 
@@ -222,9 +235,9 @@ mod test {
         let mut builder = FunctionBuilder::new("main".into(), main_id);
         let v0 = builder.add_parameter(Type::field());
 
-        let two = builder.numeric_constant(2u128, Type::field());
+        let two = builder.field_constant(2u128);
 
-        let one = builder.numeric_constant(1u128, Type::bool());
+        let one = builder.numeric_constant(1u128, NumericType::bool());
 
         builder.insert_enable_side_effects_if(one);
         builder.insert_binary(v0, BinaryOp::Mul, two);
diff --git a/compiler/noirc_evaluator/src/ssa/opt/remove_if_else.rs b/compiler/noirc_evaluator/src/ssa/opt/remove_if_else.rs
index 8d6225afabf..45b7f9072d8 100644
--- a/compiler/noirc_evaluator/src/ssa/opt/remove_if_else.rs
+++ b/compiler/noirc_evaluator/src/ssa/opt/remove_if_else.rs
@@ -3,6 +3,9 @@ use std::collections::hash_map::Entry;
 use acvm::{acir::AcirField, FieldElement};
 use fxhash::FxHashMap as HashMap;
 
+use crate::ssa::ir::function::RuntimeType;
+use crate::ssa::ir::instruction::Hint;
+use crate::ssa::ir::types::NumericType;
 use crate::ssa::ir::value::ValueId;
 use crate::ssa::{
     ir::{
@@ -28,20 +31,26 @@ impl Ssa {
     #[tracing::instrument(level = "trace", skip(self))]
     pub(crate) fn remove_if_else(mut self) -> Ssa {
         for function in self.functions.values_mut() {
-            // This should match the check in flatten_cfg
-            if let crate::ssa::ir::function::RuntimeType::Brillig = function.runtime() {
-                continue;
-            }
-
-            Context::default().remove_if_else(function);
+            function.remove_if_else();
         }
         self
     }
 }
 
+impl Function {
+    pub(crate) fn remove_if_else(&mut self) {
+        // This should match the check in flatten_cfg
+        if matches!(self.runtime(), RuntimeType::Brillig(_)) {
+            // skip
+        } else {
+            Context::default().remove_if_else(self);
+        }
+    }
+}
+
 #[derive(Default)]
 struct Context {
-    slice_sizes: HashMap<ValueId, usize>,
+    slice_sizes: HashMap<ValueId, u32>,
 
     // Maps array_set result -> element that was overwritten by that instruction.
     // Used to undo array_sets while merging values
@@ -55,14 +64,15 @@ impl Context {
     fn remove_if_else(&mut self, function: &mut Function) {
         let block = function.entry_block();
         let instructions = function.dfg[block].take_instructions();
-        let mut current_conditional = function.dfg.make_constant(FieldElement::one(), Type::bool());
+        let one = FieldElement::one();
+        let mut current_conditional = function.dfg.make_constant(one, NumericType::bool());
 
         for instruction in instructions {
             match &function.dfg[instruction] {
                 Instruction::IfElse { then_condition, then_value, else_condition, else_value } => {
                     let then_condition = *then_condition;
-                    let then_value = *then_value;
                     let else_condition = *else_condition;
+                    let then_value = *then_value;
                     let else_value = *else_value;
 
                     let typ = function.dfg.type_of_value(then_value);
@@ -112,7 +122,9 @@ impl Context {
                             }
                             SizeChange::Dec { old, new } => {
                                 let old_capacity = self.get_or_find_capacity(&function.dfg, old);
-                                self.slice_sizes.insert(new, old_capacity - 1);
+                                // We use a saturating sub here as calling `pop_front` or `pop_back` on a zero-length slice
+                                // would otherwise underflow.
+                                self.slice_sizes.insert(new, old_capacity.saturating_sub(1));
                             }
                         }
                     }
@@ -139,13 +151,13 @@ impl Context {
         }
     }
 
-    fn get_or_find_capacity(&mut self, dfg: &DataFlowGraph, value: ValueId) -> usize {
+    fn get_or_find_capacity(&mut self, dfg: &DataFlowGraph, value: ValueId) -> u32 {
         match self.slice_sizes.entry(value) {
             Entry::Occupied(entry) => return *entry.get(),
             Entry::Vacant(entry) => {
                 if let Some((array, typ)) = dfg.get_array_constant(value) {
                     let length = array.len() / typ.element_types().len();
-                    return *entry.insert(length);
+                    return *entry.insert(length as u32);
                 }
 
                 if let Type::Array(_, length) = dfg.type_of_value(value) {
@@ -161,7 +173,7 @@ impl Context {
 
 enum SizeChange {
     None,
-    SetTo(ValueId, usize),
+    SetTo(ValueId, u32),
 
     // These two variants store the old and new slice ids
     // not their lengths which should be old_len = new_len +/- 1
@@ -222,12 +234,16 @@ fn slice_capacity_change(
         | Intrinsic::ArrayAsStrUnchecked
         | Intrinsic::StrAsBytes
         | Intrinsic::BlackBox(_)
+        | Intrinsic::Hint(Hint::BlackBox)
         | Intrinsic::FromField
         | Intrinsic::AsField
         | Intrinsic::AsWitness
         | Intrinsic::IsUnconstrained
         | Intrinsic::DerivePedersenGenerators
         | Intrinsic::ToBits(_)
-        | Intrinsic::ToRadix(_) => SizeChange::None,
+        | Intrinsic::ToRadix(_)
+        | Intrinsic::ArrayRefCount
+        | Intrinsic::SliceRefCount
+        | Intrinsic::FieldLessThan => SizeChange::None,
     }
 }
diff --git a/compiler/noirc_evaluator/src/ssa/opt/resolve_is_unconstrained.rs b/compiler/noirc_evaluator/src/ssa/opt/resolve_is_unconstrained.rs
index 2c9e33ae528..87e680932c6 100644
--- a/compiler/noirc_evaluator/src/ssa/opt/resolve_is_unconstrained.rs
+++ b/compiler/noirc_evaluator/src/ssa/opt/resolve_is_unconstrained.rs
@@ -2,12 +2,11 @@ use crate::ssa::{
     ir::{
         function::{Function, RuntimeType},
         instruction::{Instruction, Intrinsic},
-        types::Type,
+        types::NumericType,
         value::Value,
     },
     ssa_gen::Ssa,
 };
-use acvm::FieldElement;
 use fxhash::FxHashSet as HashSet;
 
 impl Ssa {
@@ -17,40 +16,41 @@ impl Ssa {
     #[tracing::instrument(level = "trace", skip(self))]
     pub(crate) fn resolve_is_unconstrained(mut self) -> Self {
         for func in self.functions.values_mut() {
-            replace_is_unconstrained_result(func);
+            func.replace_is_unconstrained_result();
         }
         self
     }
 }
 
-fn replace_is_unconstrained_result(func: &mut Function) {
-    let mut is_unconstrained_calls = HashSet::default();
-    // Collect all calls to is_unconstrained
-    for block_id in func.reachable_blocks() {
-        for &instruction_id in func.dfg[block_id].instructions() {
-            let target_func = match &func.dfg[instruction_id] {
-                Instruction::Call { func, .. } => *func,
-                _ => continue,
-            };
+impl Function {
+    pub(crate) fn replace_is_unconstrained_result(&mut self) {
+        let mut is_unconstrained_calls = HashSet::default();
+        // Collect all calls to is_unconstrained
+        for block_id in self.reachable_blocks() {
+            for &instruction_id in self.dfg[block_id].instructions() {
+                let target_func = match &self.dfg[instruction_id] {
+                    Instruction::Call { func, .. } => *func,
+                    _ => continue,
+                };
 
-            if let Value::Intrinsic(Intrinsic::IsUnconstrained) = &func.dfg[target_func] {
-                is_unconstrained_calls.insert(instruction_id);
+                if let Value::Intrinsic(Intrinsic::IsUnconstrained) = &self.dfg[target_func] {
+                    is_unconstrained_calls.insert(instruction_id);
+                }
             }
         }
-    }
 
-    for instruction_id in is_unconstrained_calls {
-        let call_returns = func.dfg.instruction_results(instruction_id);
-        let original_return_id = call_returns[0];
+        for instruction_id in is_unconstrained_calls {
+            let call_returns = self.dfg.instruction_results(instruction_id);
+            let original_return_id = call_returns[0];
 
-        // We replace the result with a fresh id. This will be unused, so the DIE pass will remove the leftover intrinsic call.
-        func.dfg.replace_result(instruction_id, original_return_id);
+            // We replace the result with a fresh id. This will be unused, so the DIE pass will remove the leftover intrinsic call.
+            self.dfg.replace_result(instruction_id, original_return_id);
 
-        let is_within_unconstrained = func.dfg.make_constant(
-            FieldElement::from(matches!(func.runtime(), RuntimeType::Brillig)),
-            Type::bool(),
-        );
-        // Replace all uses of the original return value with the constant
-        func.dfg.set_value_from_id(original_return_id, is_within_unconstrained);
+            let is_unconstrained = matches!(self.runtime(), RuntimeType::Brillig(_)).into();
+            let is_within_unconstrained =
+                self.dfg.make_constant(is_unconstrained, NumericType::bool());
+            // Replace all uses of the original return value with the constant
+            self.dfg.set_value_from_id(original_return_id, is_within_unconstrained);
+        }
     }
 }
diff --git a/compiler/noirc_evaluator/src/ssa/opt/runtime_separation.rs b/compiler/noirc_evaluator/src/ssa/opt/runtime_separation.rs
index c0c9c0a1372..5628e12b9ae 100644
--- a/compiler/noirc_evaluator/src/ssa/opt/runtime_separation.rs
+++ b/compiler/noirc_evaluator/src/ssa/opt/runtime_separation.rs
@@ -70,7 +70,7 @@ impl RuntimeSeparatorContext {
         processed_functions.insert((within_brillig, current_func_id));
 
         let func = &ssa.functions[&current_func_id];
-        if func.runtime() == RuntimeType::Brillig {
+        if matches!(func.runtime(), RuntimeType::Brillig(_)) {
             within_brillig = true;
         }
 
@@ -97,17 +97,20 @@ impl RuntimeSeparatorContext {
 
     fn convert_acir_functions_called_from_brillig_to_brillig(&mut self, ssa: &mut Ssa) {
         for acir_func_id in self.acir_functions_called_from_brillig.iter() {
+            let RuntimeType::Acir(inline_type) = ssa.functions[acir_func_id].runtime() else {
+                unreachable!("Function to transform to brillig should be ACIR")
+            };
             let cloned_id = ssa.clone_fn(*acir_func_id);
             let new_func =
                 ssa.functions.get_mut(&cloned_id).expect("Cloned function should exist in SSA");
-            new_func.set_runtime(RuntimeType::Brillig);
+            new_func.set_runtime(RuntimeType::Brillig(inline_type));
             self.mapped_functions.insert(*acir_func_id, cloned_id);
         }
     }
 
     fn replace_calls_to_mapped_functions(&self, ssa: &mut Ssa) {
         for (_function_id, func) in ssa.functions.iter_mut() {
-            if func.runtime() == RuntimeType::Brillig {
+            if matches!(func.runtime(), RuntimeType::Brillig(_)) {
                 for called_func_value_id in called_functions_values(func).iter() {
                     let Value::Function(called_func_id) = &func.dfg[*called_func_value_id] else {
                         unreachable!("Value should be a function")
@@ -207,7 +210,7 @@ mod test {
         // }
         let foo_id = Id::test_new(0);
         let mut builder = FunctionBuilder::new("foo".into(), foo_id);
-        builder.current_function.set_runtime(RuntimeType::Brillig);
+        builder.current_function.set_runtime(RuntimeType::Brillig(InlineType::default()));
 
         let bar_id = Id::test_new(1);
         let bar = builder.import_function(bar_id);
@@ -239,7 +242,7 @@ mod test {
 
         // All functions should be brillig now
         for func in separated.functions.values() {
-            assert_eq!(func.runtime(), RuntimeType::Brillig);
+            assert_eq!(func.runtime(), RuntimeType::Brillig(InlineType::default()));
         }
     }
 
@@ -289,7 +292,7 @@ mod test {
         let v1 = builder.insert_call(baz, Vec::new(), vec![Type::field()]).to_vec();
         builder.terminate_with_return(vec![v0[0], v1[0]]);
 
-        builder.new_brillig_function("bar".into(), bar_id);
+        builder.new_brillig_function("bar".into(), bar_id, InlineType::default());
         let baz = builder.import_function(baz_id);
         let v0 = builder.insert_call(baz, Vec::new(), vec![Type::field()]).to_vec();
         builder.terminate_with_return(v0);
@@ -337,12 +340,12 @@ mod test {
         let baz_acir = find_func_by_name(&separated, &main_calls, "baz");
 
         assert_eq!(baz_acir.runtime(), RuntimeType::Acir(InlineType::Inline));
-        assert_eq!(bar.runtime(), RuntimeType::Brillig);
+        assert_eq!(bar.runtime(), RuntimeType::Brillig(InlineType::default()));
 
         let bar_calls = called_functions(bar);
         assert_eq!(bar_calls.len(), 1);
 
         let baz_brillig = find_func_by_name(&separated, &bar_calls, "baz");
-        assert_eq!(baz_brillig.runtime(), RuntimeType::Brillig);
+        assert_eq!(baz_brillig.runtime(), RuntimeType::Brillig(InlineType::default()));
     }
 }
diff --git a/compiler/noirc_evaluator/src/ssa/opt/simplify_cfg.rs b/compiler/noirc_evaluator/src/ssa/opt/simplify_cfg.rs
index 6887873dbc3..e7f8d227d28 100644
--- a/compiler/noirc_evaluator/src/ssa/opt/simplify_cfg.rs
+++ b/compiler/noirc_evaluator/src/ssa/opt/simplify_cfg.rs
@@ -18,7 +18,8 @@ use crate::ssa::{
         basic_block::BasicBlockId,
         cfg::ControlFlowGraph,
         function::{Function, RuntimeType},
-        instruction::TerminatorInstruction,
+        instruction::{Instruction, TerminatorInstruction},
+        value::Value,
     },
     ssa_gen::Ssa,
 };
@@ -31,53 +32,58 @@ impl Ssa {
     /// 4. Removing any blocks which have no instructions other than a single terminating jmp.
     /// 5. Replacing any jmpifs with constant conditions with jmps. If this causes the block to have
     ///    only 1 successor then (2) also will be applied.
+    /// 6. Replacing any jmpifs with a negated condition with a jmpif with a un-negated condition and reversed branches.
     ///
     /// Currently, 1 is unimplemented.
     #[tracing::instrument(level = "trace", skip(self))]
     pub(crate) fn simplify_cfg(mut self) -> Self {
         for function in self.functions.values_mut() {
-            simplify_function(function);
+            function.simplify_function();
         }
         self
     }
 }
 
-/// Simplify a function's cfg by going through each block to check for any simple blocks that can
-/// be inlined into their predecessor.
-fn simplify_function(function: &mut Function) {
-    let mut cfg = ControlFlowGraph::with_function(function);
-    let mut stack = vec![function.entry_block()];
-    let mut visited = HashSet::new();
-
-    while let Some(block) = stack.pop() {
-        if visited.insert(block) {
-            stack.extend(function.dfg[block].successors().filter(|block| !visited.contains(block)));
-        }
+impl Function {
+    /// Simplify a function's cfg by going through each block to check for any simple blocks that can
+    /// be inlined into their predecessor.
+    pub(crate) fn simplify_function(&mut self) {
+        let mut cfg = ControlFlowGraph::with_function(self);
+        let mut stack = vec![self.entry_block()];
+        let mut visited = HashSet::new();
+
+        while let Some(block) = stack.pop() {
+            if visited.insert(block) {
+                stack.extend(self.dfg[block].successors().filter(|block| !visited.contains(block)));
+            }
 
-        // This call is before try_inline_into_predecessor so that if it succeeds in changing a
-        // jmpif into a jmp, the block may then be inlined entirely into its predecessor in try_inline_into_predecessor.
-        check_for_constant_jmpif(function, block, &mut cfg);
+            check_for_negated_jmpif_condition(self, block, &mut cfg);
 
-        let mut predecessors = cfg.predecessors(block);
+            // This call is before try_inline_into_predecessor so that if it succeeds in changing a
+            // jmpif into a jmp, the block may then be inlined entirely into its predecessor in try_inline_into_predecessor.
+            check_for_constant_jmpif(self, block, &mut cfg);
 
-        if predecessors.len() == 1 {
-            let predecessor = predecessors.next().expect("Already checked length of predecessors");
-            drop(predecessors);
+            let mut predecessors = cfg.predecessors(block);
+            if predecessors.len() == 1 {
+                let predecessor =
+                    predecessors.next().expect("Already checked length of predecessors");
+                drop(predecessors);
 
-            // If the block has only 1 predecessor, we can safely remove its block parameters
-            remove_block_parameters(function, block, predecessor);
+                // If the block has only 1 predecessor, we can safely remove its block parameters
+                remove_block_parameters(self, block, predecessor);
 
-            // Note: this function relies on `remove_block_parameters` being called first.
-            // Otherwise the inlined block will refer to parameters that no longer exist.
-            //
-            // If successful, `block` will be empty and unreachable after this call, so any
-            // optimizations performed after this point on the same block should check if
-            // the inlining here was successful before continuing.
-            try_inline_into_predecessor(function, &mut cfg, block, predecessor);
-        } else {
-            drop(predecessors);
+                // Note: this function relies on `remove_block_parameters` being called first.
+                // Otherwise the inlined block will refer to parameters that no longer exist.
+                //
+                // If successful, `block` will be empty and unreachable after this call, so any
+                // optimizations performed after this point on the same block should check if
+                // the inlining here was successful before continuing.
+                try_inline_into_predecessor(self, &mut cfg, block, predecessor);
+            } else {
+                drop(predecessors);
 
-            check_for_double_jmp(function, block, &mut cfg);
+                check_for_double_jmp(self, block, &mut cfg);
+            }
         }
     }
 }
@@ -96,14 +102,23 @@ fn check_for_constant_jmpif(
     }) = function.dfg[block].terminator()
     {
         if let Some(constant) = function.dfg.get_numeric_constant(*condition) {
-            let destination =
-                if constant.is_zero() { *else_destination } else { *then_destination };
+            let (destination, unchosen_destination) = if constant.is_zero() {
+                (*else_destination, *then_destination)
+            } else {
+                (*then_destination, *else_destination)
+            };
 
             let arguments = Vec::new();
             let call_stack = call_stack.clone();
             let jmp = TerminatorInstruction::Jmp { destination, arguments, call_stack };
             function.dfg[block].set_terminator(jmp);
             cfg.recompute_block(function, block);
+
+            // If `block` was the only predecessor to `unchosen_destination` then it's no long reachable through the CFG,
+            // we can then invalidate it successors as it's an invalid predecessor.
+            if cfg.predecessors(unchosen_destination).len() == 0 {
+                cfg.invalidate_block_successors(unchosen_destination);
+            }
         }
     }
 }
@@ -173,6 +188,55 @@ fn check_for_double_jmp(function: &mut Function, block: BasicBlockId, cfg: &mut
     cfg.recompute_block(function, block);
 }
 
+/// Optimize a jmpif on a negated condition by swapping the branches.
+fn check_for_negated_jmpif_condition(
+    function: &mut Function,
+    block: BasicBlockId,
+    cfg: &mut ControlFlowGraph,
+) {
+    if matches!(function.runtime(), RuntimeType::Acir(_)) {
+        // Swapping the `then` and `else` branches of a `JmpIf` within an ACIR function
+        // can result in the situation where the branches merge together again in the `then` block, e.g.
+        //
+        // acir(inline) fn main f0 {
+        //   b0(v0: u1):
+        //     jmpif v0 then: b2, else: b1
+        //   b2():
+        //     return
+        //   b1():
+        //     jmp b2()
+        // }
+        //
+        // This breaks the `flatten_cfg` pass as it assumes that merges only happen in
+        // the `else` block or a 3rd block.
+        //
+        // See: https://github.com/noir-lang/noir/pull/5891#issuecomment-2500219428
+        return;
+    }
+
+    if let Some(TerminatorInstruction::JmpIf {
+        condition,
+        then_destination,
+        else_destination,
+        call_stack,
+    }) = function.dfg[block].terminator()
+    {
+        if let Value::Instruction { instruction, .. } = function.dfg[*condition] {
+            if let Instruction::Not(negated_condition) = function.dfg[instruction] {
+                let call_stack = call_stack.clone();
+                let jmpif = TerminatorInstruction::JmpIf {
+                    condition: negated_condition,
+                    then_destination: *else_destination,
+                    else_destination: *then_destination,
+                    call_stack,
+                };
+                function.dfg[block].set_terminator(jmpif);
+                cfg.recompute_block(function, block);
+            }
+        }
+    }
+}
+
 /// If the given block has block parameters, replace them with the jump arguments from the predecessor.
 ///
 /// Currently, if this function is needed, `try_inline_into_predecessor` will also always apply,
@@ -235,6 +299,8 @@ mod test {
             map::Id,
             types::Type,
         },
+        opt::assert_normalized_ssa_equals,
+        Ssa,
     };
     use acvm::acir::AcirField;
 
@@ -348,4 +414,59 @@ mod test {
             other => panic!("Unexpected terminator {other:?}"),
         }
     }
+
+    #[test]
+    fn swap_negated_jmpif_branches_in_brillig() {
+        let src = "
+        brillig(inline) fn main f0 {
+          b0(v0: u1):
+            v1 = allocate -> &mut Field
+            store Field 0 at v1
+            v3 = not v0
+            jmpif v3 then: b1, else: b2
+          b1():
+            store Field 2 at v1
+            jmp b2()
+          b2():
+            v5 = load v1 -> Field
+            v6 = eq v5, Field 2
+            constrain v5 == Field 2
+            return
+        }";
+        let ssa = Ssa::from_str(src).unwrap();
+
+        let expected = "
+        brillig(inline) fn main f0 {
+          b0(v0: u1):
+            v1 = allocate -> &mut Field
+            store Field 0 at v1
+            v3 = not v0
+            jmpif v0 then: b2, else: b1
+          b1():
+            store Field 2 at v1
+            jmp b2()
+          b2():
+            v5 = load v1 -> Field
+            v6 = eq v5, Field 2
+            constrain v5 == Field 2
+            return
+        }";
+        assert_normalized_ssa_equals(ssa.simplify_cfg(), expected);
+    }
+
+    #[test]
+    fn does_not_swap_negated_jmpif_branches_in_acir() {
+        let src = "
+        acir(inline) fn main f0 {
+          b0(v0: u1):
+            v1 = not v0
+            jmpif v1 then: b1, else: b2
+          b1():
+            jmp b2()
+          b2():
+            return
+        }";
+        let ssa = Ssa::from_str(src).unwrap();
+        assert_normalized_ssa_equals(ssa.simplify_cfg(), src);
+    }
 }
diff --git a/compiler/noirc_evaluator/src/ssa/opt/unrolling.rs b/compiler/noirc_evaluator/src/ssa/opt/unrolling.rs
index f3e11e04e3a..7ef793a350b 100644
--- a/compiler/noirc_evaluator/src/ssa/opt/unrolling.rs
+++ b/compiler/noirc_evaluator/src/ssa/opt/unrolling.rs
@@ -7,18 +7,22 @@
 //!    b. If we have previously modified any of the blocks in the loop,
 //!       restart from step 1 to refresh the context.
 //!    c. If not, try to unroll the loop. If successful, remember the modified
-//!       blocks. If unsuccessfully either error if the abort_on_error flag is set,
+//!       blocks. If unsuccessful either error if the abort_on_error flag is set,
 //!       or otherwise remember that the loop failed to unroll and leave it unmodified.
 //!
 //! Note that this pass also often creates superfluous jmp instructions in the
-//! program that will need to be removed by a later simplify cfg pass.
-//! Note also that unrolling is skipped for Brillig runtime and as a result
-//! we remove reference count instructions because they are only used by Brillig bytecode
-use std::collections::HashSet;
-
-use acvm::acir::AcirField;
+//! program that will need to be removed by a later simplify CFG pass.
+//!
+//! Note also that unrolling is skipped for Brillig runtime, unless the loops are deemed
+//! sufficiently small that inlining can be done without increasing the bytecode.
+//!
+//! When unrolling ACIR code, we remove reference count instructions because they are
+//! only used by Brillig bytecode.
+use acvm::{acir::AcirField, FieldElement};
+use im::HashSet;
 
 use crate::{
+    brillig::brillig_gen::convert_ssa_function,
     errors::RuntimeError,
     ssa::{
         ir::{
@@ -26,9 +30,9 @@ use crate::{
             cfg::ControlFlowGraph,
             dfg::{CallStack, DataFlowGraph},
             dom::DominatorTree,
-            function::{Function, RuntimeType},
-            function_inserter::FunctionInserter,
-            instruction::{Instruction, TerminatorInstruction},
+            function::Function,
+            function_inserter::{ArrayCache, FunctionInserter},
+            instruction::{Binary, BinaryOp, Instruction, InstructionId, TerminatorInstruction},
             post_order::PostOrder,
             value::ValueId,
         },
@@ -40,131 +44,180 @@ use fxhash::FxHashMap as HashMap;
 impl Ssa {
     /// Loop unrolling can return errors, since ACIR functions need to be fully unrolled.
     /// This meta-pass will keep trying to unroll loops and simplifying the SSA until no more errors are found.
-    pub(crate) fn unroll_loops_iteratively(mut ssa: Ssa) -> Result<Ssa, RuntimeError> {
-        // Try to unroll loops first:
-        let mut unroll_errors;
-        (ssa, unroll_errors) = ssa.try_to_unroll_loops();
-
-        // Keep unrolling until no more errors are found
-        while !unroll_errors.is_empty() {
-            let prev_unroll_err_count = unroll_errors.len();
-
-            // Simplify the SSA before retrying
-
-            // Do a mem2reg after the last unroll to aid simplify_cfg
-            ssa = ssa.mem2reg();
-            ssa = ssa.simplify_cfg();
-            // Do another mem2reg after simplify_cfg to aid the next unroll
-            ssa = ssa.mem2reg();
-
-            // Unroll again
-            (ssa, unroll_errors) = ssa.try_to_unroll_loops();
-            // If we didn't manage to unroll any more loops, exit
-            if unroll_errors.len() >= prev_unroll_err_count {
-                return Err(unroll_errors.swap_remove(0));
-            }
-        }
-        Ok(ssa)
-    }
-
-    /// Tries to unroll all loops in each SSA function.
-    /// If any loop cannot be unrolled, it is left as-is or in a partially unrolled state.
-    /// Returns the ssa along with all unrolling errors encountered
+    ///
+    /// The `max_bytecode_incr_pct`, when given, is used to limit the growth of the Brillig bytecode size
+    /// after unrolling small loops to some percentage of the original loop. For example a value of 150 would
+    /// mean the new loop can be 150% (ie. 2.5 times) larger than the original loop. It will still contain
+    /// fewer SSA instructions, but that can still result in more Brillig opcodes.
     #[tracing::instrument(level = "trace", skip(self))]
-    pub(crate) fn try_to_unroll_loops(mut self) -> (Ssa, Vec<RuntimeError>) {
-        let mut errors = vec![];
-        for function in self.functions.values_mut() {
-            // Loop unrolling in brillig can lead to a code explosion currently. This can
-            // also be true for ACIR, but we have no alternative to unrolling in ACIR.
-            // Brillig also generally prefers smaller code rather than faster code.
-            if function.runtime() == RuntimeType::Brillig {
-                continue;
+    pub(crate) fn unroll_loops_iteratively(
+        mut self: Ssa,
+        max_bytecode_increase_percent: Option<i32>,
+    ) -> Result<Ssa, RuntimeError> {
+        for (_, function) in self.functions.iter_mut() {
+            // Take a snapshot of the function to compare byte size increase,
+            // but only if the setting indicates we have to, otherwise skip it.
+            let orig_func_and_max_incr_pct = max_bytecode_increase_percent
+                .filter(|_| function.runtime().is_brillig())
+                .map(|max_incr_pct| (function.clone(), max_incr_pct));
+
+            // Try to unroll loops first:
+            let (mut has_unrolled, mut unroll_errors) = function.try_unroll_loops();
+
+            // Keep unrolling until no more errors are found
+            while !unroll_errors.is_empty() {
+                let prev_unroll_err_count = unroll_errors.len();
+
+                // Simplify the SSA before retrying
+                simplify_between_unrolls(function);
+
+                // Unroll again
+                let (new_unrolled, new_errors) = function.try_unroll_loops();
+                unroll_errors = new_errors;
+                has_unrolled |= new_unrolled;
+
+                // If we didn't manage to unroll any more loops, exit
+                if unroll_errors.len() >= prev_unroll_err_count {
+                    return Err(unroll_errors.swap_remove(0));
+                }
             }
 
-            errors.extend(find_all_loops(function).unroll_each_loop(function));
+            if has_unrolled {
+                if let Some((orig_function, max_incr_pct)) = orig_func_and_max_incr_pct {
+                    let new_size = brillig_bytecode_size(function);
+                    let orig_size = brillig_bytecode_size(&orig_function);
+                    if !is_new_size_ok(orig_size, new_size, max_incr_pct) {
+                        *function = orig_function;
+                    }
+                }
+            }
         }
-        (self, errors)
+        Ok(self)
+    }
+}
+
+impl Function {
+    // Loop unrolling in brillig can lead to a code explosion currently.
+    // This can also be true for ACIR, but we have no alternative to unrolling in ACIR.
+    // Brillig also generally prefers smaller code rather than faster code,
+    // so we only attempt to unroll small loops, which we decide on a case-by-case basis.
+    fn try_unroll_loops(&mut self) -> (bool, Vec<RuntimeError>) {
+        Loops::find_all(self).unroll_each(self)
     }
 }
 
-struct Loop {
+pub(super) struct Loop {
     /// The header block of a loop is the block which dominates all the
     /// other blocks in the loop.
-    header: BasicBlockId,
+    pub(super) header: BasicBlockId,
 
     /// The start of the back_edge n -> d is the block n at the end of
     /// the loop that jumps back to the header block d which restarts the loop.
     back_edge_start: BasicBlockId,
 
     /// All the blocks contained within the loop, including `header` and `back_edge_start`.
-    pub(crate) blocks: HashSet<BasicBlockId>,
+    pub(super) blocks: HashSet<BasicBlockId>,
 }
 
-struct Loops {
+pub(super) struct Loops {
     /// The loops that failed to be unrolled so that we do not try to unroll them again.
     /// Each loop is identified by its header block id.
     failed_to_unroll: HashSet<BasicBlockId>,
 
-    yet_to_unroll: Vec<Loop>,
+    pub(super) yet_to_unroll: Vec<Loop>,
     modified_blocks: HashSet<BasicBlockId>,
-    cfg: ControlFlowGraph,
+    pub(super) cfg: ControlFlowGraph,
 }
 
-/// Find a loop in the program by finding a node that dominates any predecessor node.
-/// The edge where this happens will be the back-edge of the loop.
-fn find_all_loops(function: &Function) -> Loops {
-    let cfg = ControlFlowGraph::with_function(function);
-    let post_order = PostOrder::with_function(function);
-    let mut dom_tree = DominatorTree::with_cfg_and_post_order(&cfg, &post_order);
-
-    let mut loops = vec![];
-
-    for (block, _) in function.dfg.basic_blocks_iter() {
-        // These reachable checks wouldn't be needed if we only iterated over reachable blocks
-        if dom_tree.is_reachable(block) {
-            for predecessor in cfg.predecessors(block) {
-                if dom_tree.is_reachable(predecessor) && dom_tree.dominates(block, predecessor) {
-                    // predecessor -> block is the back-edge of a loop
-                    loops.push(find_blocks_in_loop(block, predecessor, &cfg));
+impl Loops {
+    /// Find a loop in the program by finding a node that dominates any predecessor node.
+    /// The edge where this happens will be the back-edge of the loop.
+    ///
+    /// For example consider the following SSA of a basic loop:
+    /// ```text
+    /// main():
+    ///   v0 = ... start ...
+    ///   v1 = ... end ...
+    ///   jmp loop_entry(v0)
+    /// loop_entry(i: Field):
+    ///   v2 = lt i v1
+    ///   jmpif v2, then: loop_body, else: loop_end
+    /// loop_body():
+    ///   v3 = ... body ...
+    ///   v4 = add 1, i
+    ///   jmp loop_entry(v4)
+    /// loop_end():
+    /// ```
+    ///
+    /// The CFG will look something like this:
+    /// ```text
+    /// main
+    ///   ↓
+    /// loop_entry ←---↰
+    ///   ↓        ↘   |
+    /// loop_end    loop_body
+    /// ```
+    /// `loop_entry` has two predecessors: `main` and `loop_body`, and it dominates `loop_body`.
+    pub(super) fn find_all(function: &Function) -> Self {
+        let cfg = ControlFlowGraph::with_function(function);
+        let post_order = PostOrder::with_function(function);
+        let mut dom_tree = DominatorTree::with_cfg_and_post_order(&cfg, &post_order);
+
+        let mut loops = vec![];
+
+        for (block, _) in function.dfg.basic_blocks_iter() {
+            // These reachable checks wouldn't be needed if we only iterated over reachable blocks
+            if dom_tree.is_reachable(block) {
+                for predecessor in cfg.predecessors(block) {
+                    // In the above example, we're looking for when `block` is `loop_entry` and `predecessor` is `loop_body`.
+                    if dom_tree.is_reachable(predecessor) && dom_tree.dominates(block, predecessor)
+                    {
+                        // predecessor -> block is the back-edge of a loop
+                        loops.push(Loop::find_blocks_in_loop(block, predecessor, &cfg));
+                    }
                 }
             }
         }
-    }
 
-    // Sort loops by block size so that we unroll the larger, outer loops of nested loops first.
-    // This is needed because inner loops may use the induction variable from their outer loops in
-    // their loop range.
-    loops.sort_by_key(|loop_| loop_.blocks.len());
+        // Sort loops by block size so that we unroll the larger, outer loops of nested loops first.
+        // This is needed because inner loops may use the induction variable from their outer loops in
+        // their loop range. We will start popping loops from the back.
+        loops.sort_by_key(|loop_| loop_.blocks.len());
 
-    Loops {
-        failed_to_unroll: HashSet::new(),
-        yet_to_unroll: loops,
-        modified_blocks: HashSet::new(),
-        cfg,
+        Self {
+            failed_to_unroll: HashSet::default(),
+            yet_to_unroll: loops,
+            modified_blocks: HashSet::default(),
+            cfg,
+        }
     }
-}
 
-impl Loops {
     /// Unroll all loops within a given function.
     /// Any loops which fail to be unrolled (due to using non-constant indices) will be unmodified.
-    fn unroll_each_loop(mut self, function: &mut Function) -> Vec<RuntimeError> {
+    /// Returns whether any blocks have been modified
+    fn unroll_each(mut self, function: &mut Function) -> (bool, Vec<RuntimeError>) {
         let mut unroll_errors = vec![];
+        let mut has_unrolled = false;
         while let Some(next_loop) = self.yet_to_unroll.pop() {
+            if function.runtime().is_brillig() && !next_loop.is_small_loop(function, &self.cfg) {
+                continue;
+            }
             // If we've previously modified a block in this loop we need to refresh the context.
             // This happens any time we have nested loops.
             if next_loop.blocks.iter().any(|block| self.modified_blocks.contains(block)) {
-                let mut new_context = find_all_loops(function);
-                new_context.failed_to_unroll = self.failed_to_unroll;
-                return unroll_errors
-                    .into_iter()
-                    .chain(new_context.unroll_each_loop(function))
-                    .collect();
+                let mut new_loops = Self::find_all(function);
+                new_loops.failed_to_unroll = self.failed_to_unroll;
+                let (new_unrolled, new_errors) = new_loops.unroll_each(function);
+                return (has_unrolled || new_unrolled, [unroll_errors, new_errors].concat());
             }
 
             // Don't try to unroll the loop again if it is known to fail
             if !self.failed_to_unroll.contains(&next_loop.header) {
-                match unroll_loop(function, &self.cfg, &next_loop) {
-                    Ok(_) => self.modified_blocks.extend(next_loop.blocks),
+                match next_loop.unroll(function, &self.cfg) {
+                    Ok(_) => {
+                        has_unrolled = true;
+                        self.modified_blocks.extend(next_loop.blocks);
+                    }
                     Err(call_stack) => {
                         self.failed_to_unroll.insert(next_loop.header);
                         unroll_errors.push(RuntimeError::UnknownLoopBound { call_stack });
@@ -172,77 +225,515 @@ impl Loops {
                 }
             }
         }
-        unroll_errors
+        (has_unrolled, unroll_errors)
     }
 }
 
-/// Return each block that is in a loop starting in the given header block.
-/// Expects back_edge_start -> header to be the back edge of the loop.
-fn find_blocks_in_loop(
-    header: BasicBlockId,
-    back_edge_start: BasicBlockId,
-    cfg: &ControlFlowGraph,
-) -> Loop {
-    let mut blocks = HashSet::new();
-    blocks.insert(header);
-
-    let mut insert = |block, stack: &mut Vec<BasicBlockId>| {
-        if !blocks.contains(&block) {
-            blocks.insert(block);
-            stack.push(block);
+impl Loop {
+    /// Return each block that is in a loop starting in the given header block.
+    /// Expects back_edge_start -> header to be the back edge of the loop.
+    fn find_blocks_in_loop(
+        header: BasicBlockId,
+        back_edge_start: BasicBlockId,
+        cfg: &ControlFlowGraph,
+    ) -> Self {
+        let mut blocks = HashSet::default();
+        blocks.insert(header);
+
+        let mut insert = |block, stack: &mut Vec<BasicBlockId>| {
+            if !blocks.contains(&block) {
+                blocks.insert(block);
+                stack.push(block);
+            }
+        };
+
+        // Starting from the back edge of the loop, each predecessor of this block until
+        // the header is within the loop.
+        let mut stack = vec![];
+        insert(back_edge_start, &mut stack);
+
+        while let Some(block) = stack.pop() {
+            for predecessor in cfg.predecessors(block) {
+                insert(predecessor, &mut stack);
+            }
+        }
+
+        Self { header, back_edge_start, blocks }
+    }
+
+    /// Find the lower bound of the loop in the pre-header and return it
+    /// if it's a numeric constant, which it will be if the previous SSA
+    /// steps managed to inline it.
+    ///
+    /// Consider the following example of a `for i in 0..4` loop:
+    /// ```text
+    /// brillig(inline) fn main f0 {
+    ///   b0(v0: u32):                  // Pre-header
+    ///     ...
+    ///     jmp b1(u32 0)               // Lower-bound
+    ///   b1(v1: u32):                  // Induction variable
+    ///     v5 = lt v1, u32 4
+    ///     jmpif v5 then: b3, else: b2
+    /// ```
+    fn get_const_lower_bound(
+        &self,
+        function: &Function,
+        cfg: &ControlFlowGraph,
+    ) -> Option<FieldElement> {
+        let pre_header = self.get_pre_header(function, cfg).ok()?;
+        let jump_value = get_induction_variable(function, pre_header).ok()?;
+        function.dfg.get_numeric_constant(jump_value)
+    }
+
+    /// Find the upper bound of the loop in the loop header and return it
+    /// if it's a numeric constant, which it will be if the previous SSA
+    /// steps managed to inline it.
+    ///
+    /// Consider the following example of a `for i in 0..4` loop:
+    /// ```text
+    /// brillig(inline) fn main f0 {
+    ///   b0(v0: u32):
+    ///     ...
+    ///     jmp b1(u32 0)
+    ///   b1(v1: u32):                  // Loop header
+    ///     v5 = lt v1, u32 4           // Upper bound
+    ///     jmpif v5 then: b3, else: b2
+    /// ```
+    pub(super) fn get_const_upper_bound(&self, function: &Function) -> Option<FieldElement> {
+        let block = &function.dfg[self.header];
+        let instructions = block.instructions();
+        if instructions.is_empty() {
+            // If the loop condition is constant time, the loop header will be
+            // simplified to a simple jump.
+            return None;
+        }
+        assert_eq!(
+            instructions.len(),
+            1,
+            "The header should just compare the induction variable and jump"
+        );
+        match &function.dfg[instructions[0]] {
+            Instruction::Binary(Binary { lhs: _, operator: BinaryOp::Lt, rhs }) => {
+                function.dfg.get_numeric_constant(*rhs)
+            }
+            Instruction::Binary(Binary { lhs: _, operator: BinaryOp::Eq, rhs }) => {
+                // `for i in 0..1` is turned into:
+                // b1(v0: u32):
+                //   v12 = eq v0, u32 0
+                //   jmpif v12 then: b3, else: b2
+                function.dfg.get_numeric_constant(*rhs).map(|c| c + FieldElement::one())
+            }
+            other => panic!("Unexpected instruction in header: {other:?}"),
         }
-    };
+    }
 
-    // Starting from the back edge of the loop, each predecessor of this block until
-    // the header is within the loop.
-    let mut stack = vec![];
-    insert(back_edge_start, &mut stack);
+    /// Get the lower and upper bounds of the loop if both are constant numeric values.
+    fn get_const_bounds(
+        &self,
+        function: &Function,
+        cfg: &ControlFlowGraph,
+    ) -> Option<(FieldElement, FieldElement)> {
+        let lower = self.get_const_lower_bound(function, cfg)?;
+        let upper = self.get_const_upper_bound(function)?;
+        Some((lower, upper))
+    }
 
-    while let Some(block) = stack.pop() {
-        for predecessor in cfg.predecessors(block) {
-            insert(predecessor, &mut stack);
+    /// Unroll a single loop in the function.
+    /// Returns Ok(()) if it succeeded, Err(callstack) if it failed,
+    /// where the callstack indicates the location of the instruction
+    /// that could not be processed, or empty if such information was
+    /// not available.
+    ///
+    /// Consider this example:
+    /// ```text
+    /// main():
+    ///   v0 = 0
+    ///   v1 = 2
+    ///   jmp loop_entry(v0)
+    /// loop_entry(i: Field):
+    ///   v2 = lt i v1
+    ///   jmpif v2, then: loop_body, else: loop_end
+    /// ```
+    ///
+    /// The first step is to unroll the header by recognizing that jump condition
+    /// is a constant, which means it will go to `loop_body`:
+    /// ```text
+    /// main():
+    ///   v0 = 0
+    ///   v1 = 2
+    ///   v2 = lt v0 v1
+    ///   // jmpif v2, then: loop_body, else: loop_end
+    ///   jmp dest: loop_body
+    /// ```
+    ///
+    /// Following that we unroll the loop body, which is the next source, replace
+    /// the induction variable with the new value created in the body, and have
+    /// another go at the header.
+    /// ```text
+    /// main():
+    ///   v0 = 0
+    ///   v1 = 2
+    ///   v2 = lt v0 v1
+    ///   v3 = ... body ...
+    ///   v4 = add 1, 0
+    ///   jmp loop_entry(v4)
+    /// ```
+    ///
+    /// At the end we reach a point where the condition evaluates to 0 and we jump to the end.
+    /// ```text
+    /// main():
+    ///   v0 = 0
+    ///   v1 = 2
+    ///   v2 = lt 0
+    ///   v3 = ... body ...
+    ///   v4 = add 1, v0
+    ///   v5 = lt v4 v1
+    ///   v6 = ... body ...
+    ///   v7 = add v4, 1
+    ///   v8 = lt v5 v1
+    ///   jmp loop_end
+    /// ```
+    ///
+    /// When e.g. `v8 = lt v5 v1` cannot be evaluated to a constant, the loop signals by returning `Err`
+    /// that a few SSA passes are required to evaluate and simplify these values.
+    fn unroll(&self, function: &mut Function, cfg: &ControlFlowGraph) -> Result<(), CallStack> {
+        let mut unroll_into = self.get_pre_header(function, cfg)?;
+        let mut jump_value = get_induction_variable(function, unroll_into)?;
+        let mut array_cache = Some(ArrayCache::default());
+
+        while let Some(mut context) = self.unroll_header(function, unroll_into, jump_value)? {
+            // The inserter's array cache must be explicitly enabled. This is to
+            // confirm that we're inserting in insertion order. This is true here since:
+            // 1. We have a fresh inserter for each loop
+            // 2. Each loop is unrolled in iteration order
+            //
+            // Within a loop we do not insert in insertion order. This is fine however since the
+            // array cache is buffered with a separate fresh_array_cache which collects arrays
+            // but does not deduplicate. When we later call `into_array_cache`, that will merge
+            // the fresh cache in with the old one so that each iteration of the loop can cache
+            // from previous iterations but not the current iteration.
+            context.inserter.set_array_cache(array_cache, unroll_into);
+            (unroll_into, jump_value, array_cache) = context.unroll_loop_iteration();
         }
+
+        Ok(())
     }
 
-    Loop { header, back_edge_start, blocks }
-}
+    /// The loop pre-header is the block that comes before the loop begins. Generally a header block
+    /// is expected to have 2 predecessors: the pre-header and the final block of the loop which jumps
+    /// back to the beginning. Other predecessors can come from `break` or `continue`.
+    pub(super) fn get_pre_header(
+        &self,
+        function: &Function,
+        cfg: &ControlFlowGraph,
+    ) -> Result<BasicBlockId, CallStack> {
+        let mut pre_header = cfg
+            .predecessors(self.header)
+            .filter(|predecessor| *predecessor != self.back_edge_start)
+            .collect::<Vec<_>>();
+
+        if function.runtime().is_acir() {
+            assert_eq!(pre_header.len(), 1);
+            Ok(pre_header.remove(0))
+        } else if pre_header.len() == 1 {
+            Ok(pre_header.remove(0))
+        } else {
+            // We can come back into the header from multiple blocks, so we can't unroll this.
+            Err(CallStack::new())
+        }
+    }
 
-/// Unroll a single loop in the function.
-/// Returns Err(()) if it failed to unroll and Ok(()) otherwise.
-fn unroll_loop(
-    function: &mut Function,
-    cfg: &ControlFlowGraph,
-    loop_: &Loop,
-) -> Result<(), CallStack> {
-    let mut unroll_into = get_pre_header(cfg, loop_);
-    let mut jump_value = get_induction_variable(function, unroll_into)?;
+    /// Unrolls the header block of the loop. This is the block that dominates all other blocks in the
+    /// loop and contains the jmpif instruction that lets us know if we should continue looping.
+    /// Returns Some(iteration context) if we should perform another iteration.
+    fn unroll_header<'a>(
+        &'a self,
+        function: &'a mut Function,
+        unroll_into: BasicBlockId,
+        induction_value: ValueId,
+    ) -> Result<Option<LoopIteration<'a>>, CallStack> {
+        // We insert into a fresh block first and move instructions into the unroll_into block later
+        // only once we verify the jmpif instruction has a constant condition. If it does not, we can
+        // just discard this fresh block and leave the loop unmodified.
+        let fresh_block = function.dfg.make_block();
+
+        let mut context = LoopIteration::new(function, self, fresh_block, self.header);
+        let source_block = &context.dfg()[context.source_block];
+        assert_eq!(source_block.parameters().len(), 1, "Expected only 1 argument in loop header");
+
+        // Insert the current value of the loop induction variable into our context.
+        let first_param = source_block.parameters()[0];
+        context.inserter.try_map_value(first_param, induction_value);
+        // Copy over all instructions and a fresh terminator.
+        context.inline_instructions_from_block();
+        // Mutate the terminator if possible so that it points at the iteration block.
+        match context.dfg()[fresh_block].unwrap_terminator() {
+            TerminatorInstruction::JmpIf { condition, then_destination, else_destination, call_stack } => {
+                let condition = *condition;
+                let next_blocks = context.handle_jmpif(condition, *then_destination, *else_destination, call_stack.clone());
+
+                // If there is only 1 next block the jmpif evaluated to a single known block.
+                // This is the expected case and lets us know if we should loop again or not.
+                if next_blocks.len() == 1 {
+                    context.dfg_mut().inline_block(fresh_block, unroll_into);
+
+                    // The fresh block is gone now so we're committing to insert into the original
+                    // unroll_into block from now on.
+                    context.insert_block = unroll_into;
+
+                    // In the last iteration, `handle_jmpif` will have replaced `context.source_block`
+                    // with the `else_destination`, that is, the `loop_end`, which signals that we
+                    // have no more loops to unroll, because that block was not part of the loop itself,
+                    // ie. it wasn't between `loop_header` and `loop_body`. Otherwise we have the `loop_body`
+                    // in `source_block` and can unroll that into the destination.
+                    Ok(self.blocks.contains(&context.source_block).then_some(context))
+                } else {
+                    // If this case is reached the loop either uses non-constant indices or we need
+                    // another pass, such as mem2reg to resolve them to constants.
+                    Err(context.inserter.function.dfg.get_value_call_stack(condition))
+                }
+            }
+            other => unreachable!("Expected loop header to terminate in a JmpIf to the loop body, but found {other:?} instead"),
+        }
+    }
 
-    while let Some(context) = unroll_loop_header(function, loop_, unroll_into, jump_value)? {
-        let (last_block, last_value) = context.unroll_loop_iteration();
-        unroll_into = last_block;
-        jump_value = last_value;
+    /// Find all reference values which were allocated before the pre-header.
+    ///
+    /// These are accessible inside the loop body, and they can be involved
+    /// in load/store operations that could be eliminated if we unrolled the
+    /// body into the pre-header.
+    ///
+    /// Consider this loop:
+    /// ```text
+    /// let mut sum = 0;
+    /// let mut arr = &[];
+    /// for i in 0..3 {
+    ///     sum = sum + i;
+    ///     arr.push_back(sum)
+    /// }
+    /// sum
+    /// ```
+    ///
+    /// The SSA has a load+store for the `sum` and a load+push for the `arr`:
+    /// ```text
+    /// b0(v0: u32):
+    ///   v2 = allocate -> &mut u32     // reference allocated for `sum`
+    ///   store u32 0 at v2             // initial value for `sum`
+    ///   v4 = allocate -> &mut u32     // reference allocated for the length of `arr`
+    ///   store u32 0 at v4             // initial length of `arr`
+    ///   inc_rc [] of u32              // storage for `arr`
+    ///   v6 = allocate -> &mut [u32]   // reference allocated to point at the storage of `arr`
+    ///   store [] of u32 at v6         // initial value for the storage of `arr`
+    ///   jmp b1(u32 0)                 // start looping from 0
+    /// b1(v1: u32):                    // `i` induction variable
+    ///   v8 = lt v1, u32 3             // loop until 3
+    ///   jmpif v8 then: b3, else: b2
+    /// b3():
+    ///   v11 = load v2 -> u32          // load `sum`
+    ///   v12 = add v11, v1             // add `i` to `sum`
+    ///   store v12 at v2               // store updated `sum`
+    ///   v13 = load v4 -> u32          // load length of `arr`
+    ///   v14 = load v6 -> [u32]        // load storage of `arr`
+    ///   v16, v17 = call slice_push_back(v13, v14, v12) -> (u32, [u32]) // builtin to push, will store to storage and length references
+    ///   v19 = add v1, u32 1           // increase `arr`
+    ///   jmp b1(v19)                   // back-edge of the loop
+    /// b2():                           // after the loop
+    ///   v9 = load v2 -> u32           // read final value of `sum`
+    /// ```
+    ///
+    /// We won't always find load _and_ store ops (e.g. the push above doesn't come with a store),
+    /// but it's likely that mem2reg could eliminate a lot of the loads we can find, so we can
+    /// use this as an approximation of the gains we would see.
+    fn find_pre_header_reference_values(
+        &self,
+        function: &Function,
+        cfg: &ControlFlowGraph,
+    ) -> Option<HashSet<ValueId>> {
+        // We need to traverse blocks from the pre-header up to the block entry point.
+        let pre_header = self.get_pre_header(function, cfg).ok()?;
+        let function_entry = function.entry_block();
+
+        // The algorithm in `find_blocks_in_loop` expects to collect the blocks between the header and the back-edge of the loop,
+        // but technically works the same if we go from the pre-header up to the function entry as well.
+        let blocks = Self::find_blocks_in_loop(function_entry, pre_header, cfg).blocks;
+
+        // Collect allocations in all blocks above the header.
+        let allocations = blocks.iter().flat_map(|block| {
+            let instructions = function.dfg[*block].instructions().iter();
+            instructions
+                .filter(|i| matches!(&function.dfg[**i], Instruction::Allocate))
+                // Get the value into which the allocation was stored.
+                .map(|i| function.dfg.instruction_results(*i)[0])
+        });
+
+        // Collect reference parameters of the function itself.
+        let params =
+            function.parameters().iter().filter(|p| function.dfg.value_is_reference(**p)).copied();
+
+        Some(params.chain(allocations).collect())
+    }
+
+    /// Count the number of load and store instructions of specific variables in the loop.
+    ///
+    /// Returns `(loads, stores)` in case we want to differentiate in the estimates.
+    fn count_loads_and_stores(
+        &self,
+        function: &Function,
+        refs: &HashSet<ValueId>,
+    ) -> (usize, usize) {
+        let mut loads = 0;
+        let mut stores = 0;
+        for block in &self.blocks {
+            for instruction in function.dfg[*block].instructions() {
+                match &function.dfg[*instruction] {
+                    Instruction::Load { address } if refs.contains(address) => {
+                        loads += 1;
+                    }
+                    Instruction::Store { address, .. } if refs.contains(address) => {
+                        stores += 1;
+                    }
+                    _ => {}
+                }
+            }
+        }
+        (loads, stores)
     }
 
-    Ok(())
+    /// Count the number of instructions in the loop, including the terminating jumps.
+    fn count_all_instructions(&self, function: &Function) -> usize {
+        let iter = self.blocks.iter().map(|block| {
+            let block = &function.dfg[*block];
+            block.instructions().len() + block.terminator().is_some() as usize
+        });
+        iter.sum()
+    }
+
+    /// Count the number of increments to the induction variable.
+    /// It should be one, but it can be duplicated.
+    /// The increment should be in the block where the back-edge was found.
+    fn count_induction_increments(&self, function: &Function) -> usize {
+        let back = &function.dfg[self.back_edge_start];
+        let header = &function.dfg[self.header];
+        let induction_var = header.parameters()[0];
+
+        back.instructions().iter().filter(|instruction|  {
+            let instruction = &function.dfg[**instruction];
+            matches!(instruction, Instruction::Binary(Binary { lhs, operator: BinaryOp::Add, rhs: _ }) if *lhs == induction_var)
+        }).count()
+    }
+
+    /// Decide if this loop is small enough that it can be inlined in a way that the number
+    /// of unrolled instructions times the number of iterations would result in smaller bytecode
+    /// than if we keep the loops with their overheads.
+    fn is_small_loop(&self, function: &Function, cfg: &ControlFlowGraph) -> bool {
+        self.boilerplate_stats(function, cfg).map(|s| s.is_small()).unwrap_or_default()
+    }
+
+    /// Collect boilerplate stats if we can figure out the upper and lower bounds of the loop,
+    /// and the loop doesn't have multiple back-edges from breaks and continues.
+    fn boilerplate_stats(
+        &self,
+        function: &Function,
+        cfg: &ControlFlowGraph,
+    ) -> Option<BoilerplateStats> {
+        let (lower, upper) = self.get_const_bounds(function, cfg)?;
+        let lower = lower.try_to_u64()?;
+        let upper = upper.try_to_u64()?;
+        let refs = self.find_pre_header_reference_values(function, cfg)?;
+
+        let (loads, stores) = self.count_loads_and_stores(function, &refs);
+        let increments = self.count_induction_increments(function);
+        let all_instructions = self.count_all_instructions(function);
+
+        Some(BoilerplateStats {
+            iterations: (upper - lower) as usize,
+            loads,
+            stores,
+            increments,
+            all_instructions,
+        })
+    }
 }
 
-/// The loop pre-header is the block that comes before the loop begins. Generally a header block
-/// is expected to have 2 predecessors: the pre-header and the final block of the loop which jumps
-/// back to the beginning.
-fn get_pre_header(cfg: &ControlFlowGraph, loop_: &Loop) -> BasicBlockId {
-    let mut pre_header = cfg
-        .predecessors(loop_.header)
-        .filter(|predecessor| *predecessor != loop_.back_edge_start)
-        .collect::<Vec<_>>();
-
-    assert_eq!(pre_header.len(), 1);
-    pre_header.remove(0)
+/// All the instructions in the following example are boilerplate:
+/// ```text
+/// brillig(inline) fn main f0 {
+///   b0(v0: u32):
+///     ...
+///     jmp b1(u32 0)
+///   b1(v1: u32):
+///     v5 = lt v1, u32 4
+///     jmpif v5 then: b3, else: b2
+///   b3():
+///     ...
+///     v11 = add v1, u32 1
+///     jmp b1(v11)
+///   b2():
+///     ...
+/// }
+/// ```
+#[derive(Debug)]
+struct BoilerplateStats {
+    /// Number of iterations in the loop.
+    iterations: usize,
+    /// Number of loads  pre-header references in the loop.
+    loads: usize,
+    /// Number of stores into pre-header references in the loop.
+    stores: usize,
+    /// Number of increments to the induction variable (might be duplicated).
+    increments: usize,
+    /// Number of instructions in the loop, including boilerplate,
+    /// but excluding the boilerplate which is outside the loop.
+    all_instructions: usize,
+}
+
+impl BoilerplateStats {
+    /// Instruction count if we leave the loop as-is.
+    /// It's the instructions in the loop, plus the one to kick it off in the pre-header.
+    fn baseline_instructions(&self) -> usize {
+        self.all_instructions + 1
+    }
+
+    /// Estimated number of _useful_ instructions, which is the ones in the loop
+    /// minus all in-loop boilerplate.
+    fn useful_instructions(&self) -> usize {
+        // Two jumps + plus the comparison with the upper bound
+        let boilerplate = 3;
+        // Be conservative and only assume that mem2reg gets rid of load followed by store.
+        // NB we have not checked that these are actual pairs.
+        let load_and_store = self.loads.min(self.stores) * 2;
+        self.all_instructions - self.increments - load_and_store - boilerplate
+    }
+
+    /// Estimated number of instructions if we unroll the loop.
+    fn unrolled_instructions(&self) -> usize {
+        self.useful_instructions() * self.iterations
+    }
+
+    /// A small loop is where if we unroll it into the pre-header then considering the
+    /// number of iterations we still end up with a smaller bytecode than if we leave
+    /// the blocks in tact with all the boilerplate involved in jumping, and the extra
+    /// reference access instructions.
+    fn is_small(&self) -> bool {
+        self.unrolled_instructions() < self.baseline_instructions()
+    }
 }
 
 /// Return the induction value of the current iteration of the loop, from the given block's jmp arguments.
 ///
 /// Expects the current block to terminate in `jmp h(N)` where h is the loop header and N is
-/// a Field value.
+/// a Field value. Returns an `Err` if this isn't the case.
+///
+/// Consider the following example:
+/// ```text
+/// main():
+///   v0 = ... start ...
+///   v1 = ... end ...
+///   jmp loop_entry(v0)
+/// loop_entry(i: Field):
+///   ...
+/// ```
+/// We're looking for the terminating jump of the `main` predecessor of `loop_entry`.
 fn get_induction_variable(function: &Function, block: BasicBlockId) -> Result<ValueId, CallStack> {
     match function.dfg[block].terminator() {
         Some(TerminatorInstruction::Jmp { arguments, call_stack: location, .. }) => {
@@ -263,54 +754,6 @@ fn get_induction_variable(function: &Function, block: BasicBlockId) -> Result<Va
     }
 }
 
-/// Unrolls the header block of the loop. This is the block that dominates all other blocks in the
-/// loop and contains the jmpif instruction that lets us know if we should continue looping.
-/// Returns Some(iteration context) if we should perform another iteration.
-fn unroll_loop_header<'a>(
-    function: &'a mut Function,
-    loop_: &'a Loop,
-    unroll_into: BasicBlockId,
-    induction_value: ValueId,
-) -> Result<Option<LoopIteration<'a>>, CallStack> {
-    // We insert into a fresh block first and move instructions into the unroll_into block later
-    // only once we verify the jmpif instruction has a constant condition. If it does not, we can
-    // just discard this fresh block and leave the loop unmodified.
-    let fresh_block = function.dfg.make_block();
-
-    let mut context = LoopIteration::new(function, loop_, fresh_block, loop_.header);
-    let source_block = &context.dfg()[context.source_block];
-    assert_eq!(source_block.parameters().len(), 1, "Expected only 1 argument in loop header");
-
-    // Insert the current value of the loop induction variable into our context.
-    let first_param = source_block.parameters()[0];
-    context.inserter.try_map_value(first_param, induction_value);
-    context.inline_instructions_from_block();
-
-    match context.dfg()[fresh_block].unwrap_terminator() {
-        TerminatorInstruction::JmpIf { condition, then_destination, else_destination, call_stack } => {
-            let condition = *condition;
-            let next_blocks = context.handle_jmpif(condition, *then_destination, *else_destination, call_stack.clone());
-
-            // If there is only 1 next block the jmpif evaluated to a single known block.
-            // This is the expected case and lets us know if we should loop again or not.
-            if next_blocks.len() == 1 {
-                context.dfg_mut().inline_block(fresh_block, unroll_into);
-
-                // The fresh block is gone now so we're committing to insert into the original
-                // unroll_into block from now on.
-                context.insert_block = unroll_into;
-
-                Ok(loop_.blocks.contains(&context.source_block).then_some(context))
-            } else {
-                // If this case is reached the loop either uses non-constant indices or we need
-                // another pass, such as mem2reg to resolve them to constants.
-                Err(context.inserter.function.dfg.get_value_call_stack(condition))
-            }
-        }
-        other => unreachable!("Expected loop header to terminate in a JmpIf to the loop body, but found {other:?} instead"),
-    }
-}
-
 /// The context object for each loop iteration.
 /// Notably each loop iteration maps each loop block to a fresh, unrolled block.
 struct LoopIteration<'f> {
@@ -360,7 +803,7 @@ impl<'f> LoopIteration<'f> {
     /// It is expected the terminator instructions are set up to branch into an empty block
     /// for further unrolling. When the loop is finished this will need to be mutated to
     /// jump to the end of the loop instead.
-    fn unroll_loop_iteration(mut self) -> (BasicBlockId, ValueId) {
+    fn unroll_loop_iteration(mut self) -> (BasicBlockId, ValueId, Option<ArrayCache>) {
         let mut next_blocks = self.unroll_loop_block();
 
         while let Some(block) = next_blocks.pop() {
@@ -372,14 +815,20 @@ impl<'f> LoopIteration<'f> {
                 next_blocks.append(&mut blocks);
             }
         }
+        // After having unrolled all blocks in the loop body, we must know how to get back to the header;
+        // this is also the block into which we have to unroll into next.
+        let (end_block, induction_value) = self
+            .induction_value
+            .expect("Expected to find the induction variable by end of loop iteration");
 
-        self.induction_value
-            .expect("Expected to find the induction variable by end of loop iteration")
+        (end_block, induction_value, self.inserter.into_array_cache())
     }
 
     /// Unroll a single block in the current iteration of the loop
     fn unroll_loop_block(&mut self) -> Vec<BasicBlockId> {
         let mut next_blocks = self.unroll_loop_block_helper();
+        // Guarantee that the next blocks we set up to be unrolled, are actually part of the loop,
+        // which we recorded while inlining the instructions of the blocks already processed.
         next_blocks.retain(|block| {
             let b = self.get_original_block(*block);
             self.loop_.blocks.contains(&b)
@@ -389,6 +838,7 @@ impl<'f> LoopIteration<'f> {
 
     /// Unroll a single block in the current iteration of the loop
     fn unroll_loop_block_helper(&mut self) -> Vec<BasicBlockId> {
+        // Copy instructions from the loop body to the unroll destination, replacing the terminator.
         self.inline_instructions_from_block();
         self.visited_blocks.insert(self.source_block);
 
@@ -406,6 +856,7 @@ impl<'f> LoopIteration<'f> {
             ),
             TerminatorInstruction::Jmp { destination, arguments, call_stack: _ } => {
                 if self.get_original_block(*destination) == self.loop_.header {
+                    // We found the back-edge of the loop.
                     assert_eq!(arguments.len(), 1);
                     self.induction_value = Some((self.insert_block, arguments[0]));
                 }
@@ -417,7 +868,10 @@ impl<'f> LoopIteration<'f> {
 
     /// Find the next branch(es) to take from a jmpif terminator and return them.
     /// If only one block is returned, it means the jmpif condition evaluated to a known
-    /// constant and we can safely take only the given branch.
+    /// constant and we can safely take only the given branch. In this case the method
+    /// also replaces the terminator of the insert block (a.k.a fresh block) to be a `Jmp`,
+    /// and changes the source block in the context for the next iteration to be the
+    /// destination indicated by the constant condition (ie. the `then` or the `else`).
     fn handle_jmpif(
         &mut self,
         condition: ValueId,
@@ -463,10 +917,13 @@ impl<'f> LoopIteration<'f> {
         }
     }
 
+    /// Find the original ID of a block that replaced it.
     fn get_original_block(&self, block: BasicBlockId) -> BasicBlockId {
         self.original_blocks.get(&block).copied().unwrap_or(block)
     }
 
+    /// Copy over instructions from the source into the insert block,
+    /// while simplifying instructions and keeping track of original block IDs.
     fn inline_instructions_from_block(&mut self) {
         let source_block = &self.dfg()[self.source_block];
         let instructions = source_block.instructions().to_vec();
@@ -475,23 +932,31 @@ impl<'f> LoopIteration<'f> {
         // instances of the induction variable or any values that were changed as a result
         // of the new induction variable value.
         for instruction in instructions {
-            // Skip reference count instructions since they are only used for brillig, and brillig code is not unrolled
-            if !matches!(
-                self.dfg()[instruction],
-                Instruction::IncrementRc { .. } | Instruction::DecrementRc { .. }
-            ) {
-                self.inserter.push_instruction(instruction, self.insert_block);
+            // Reference counting is only used by Brillig, ACIR doesn't need them.
+            if self.inserter.function.runtime().is_acir() && self.is_refcount(instruction) {
+                continue;
             }
+            self.inserter.push_instruction(instruction, self.insert_block);
         }
         let mut terminator = self.dfg()[self.source_block]
             .unwrap_terminator()
             .clone()
             .map_values(|value| self.inserter.resolve(value));
 
+        // Replace the blocks in the terminator with fresh one with the same parameters,
+        // while remembering which were the original block IDs.
         terminator.mutate_blocks(|block| self.get_or_insert_block(block));
         self.inserter.function.dfg.set_block_terminator(self.insert_block, terminator);
     }
 
+    /// Is the instruction an `Rc`?
+    fn is_refcount(&self, instruction: InstructionId) -> bool {
+        matches!(
+            self.dfg()[instruction],
+            Instruction::IncrementRc { .. } | Instruction::DecrementRc { .. }
+        )
+    }
+
     fn dfg(&self) -> &DataFlowGraph {
         &self.inserter.function.dfg
     }
@@ -501,12 +966,62 @@ impl<'f> LoopIteration<'f> {
     }
 }
 
+/// Unrolling leaves some duplicate instructions which can potentially be removed.
+fn simplify_between_unrolls(function: &mut Function) {
+    // Do a mem2reg after the last unroll to aid simplify_cfg
+    function.mem2reg();
+    function.simplify_function();
+    // Do another mem2reg after simplify_cfg to aid the next unroll
+    function.mem2reg();
+}
+
+/// Convert the function to Brillig bytecode and return the resulting size.
+fn brillig_bytecode_size(function: &Function) -> usize {
+    // We need to do some SSA passes in order for the conversion to be able to go ahead,
+    // otherwise we can hit `unreachable!()` instructions in `convert_ssa_instruction`.
+    // Creating a clone so as not to modify the originals.
+    let mut temp = function.clone();
+
+    // Might as well give it the best chance.
+    simplify_between_unrolls(&mut temp);
+
+    // This is to try to prevent hitting ICE.
+    temp.dead_instruction_elimination(false);
+
+    convert_ssa_function(&temp, false).byte_code.len()
+}
+
+/// Decide if the new bytecode size is acceptable, compared to the original.
+///
+/// The maximum increase can be expressed as a negative value if we demand a decrease.
+/// (Values -100 and under mean the new size should be 0).
+fn is_new_size_ok(orig_size: usize, new_size: usize, max_incr_pct: i32) -> bool {
+    let max_size_pct = 100i32.saturating_add(max_incr_pct).max(0) as usize;
+    let max_size = orig_size.saturating_mul(max_size_pct);
+    new_size.saturating_mul(100) <= max_size
+}
+
 #[cfg(test)]
 mod tests {
-    use crate::ssa::{
-        function_builder::FunctionBuilder,
-        ir::{instruction::BinaryOp, map::Id, types::Type},
-    };
+    use acvm::FieldElement;
+    use test_case::test_case;
+
+    use crate::errors::RuntimeError;
+    use crate::ssa::{ir::value::ValueId, opt::assert_normalized_ssa_equals, Ssa};
+
+    use super::{is_new_size_ok, BoilerplateStats, Loops};
+
+    /// Tries to unroll all loops in each SSA function once, calling the `Function` directly,
+    /// bypassing the iterative loop done by the SSA which does further optimisations.
+    ///
+    /// If any loop cannot be unrolled, it is left as-is or in a partially unrolled state.
+    fn try_unroll_loops(mut ssa: Ssa) -> (Ssa, Vec<RuntimeError>) {
+        let mut errors = vec![];
+        for function in ssa.functions.values_mut() {
+            errors.extend(function.try_unroll_loops().1);
+        }
+        (ssa, errors)
+    }
 
     #[test]
     fn unroll_nested_loops() {
@@ -517,166 +1032,432 @@ mod tests {
         //         }
         //     }
         // }
-        //
-        // fn main f0 {
-        //   b0():
-        //     jmp b1(Field 0)
-        //   b1(v0: Field):  // header of outer loop
-        //     v1 = lt v0, Field 3
-        //     jmpif v1, then: b2, else: b3
-        //   b2():
-        //     jmp b4(Field 0)
-        //   b4(v2: Field):  // header of inner loop
-        //     v3 = lt v2, Field 4
-        //     jmpif v3, then: b5, else: b6
-        //   b5():
-        //     v4 = add v0, v2
-        //     v5 = lt Field 10, v4
-        //     constrain v5
-        //     v6 = add v2, Field 1
-        //     jmp b4(v6)
-        //   b6(): // end of inner loop
-        //     v7 = add v0, Field 1
-        //     jmp b1(v7)
-        //   b3(): // end of outer loop
-        //     return Field 0
-        // }
-        let main_id = Id::test_new(0);
-
-        // Compiling main
-        let mut builder = FunctionBuilder::new("main".into(), main_id);
-
-        let b1 = builder.insert_block();
-        let b2 = builder.insert_block();
-        let b3 = builder.insert_block();
-        let b4 = builder.insert_block();
-        let b5 = builder.insert_block();
-        let b6 = builder.insert_block();
-
-        let v0 = builder.add_block_parameter(b1, Type::field());
-        let v2 = builder.add_block_parameter(b4, Type::field());
-
-        let zero = builder.field_constant(0u128);
-        let one = builder.field_constant(1u128);
-        let three = builder.field_constant(3u128);
-        let four = builder.field_constant(4u128);
-        let ten = builder.field_constant(10u128);
-
-        builder.terminate_with_jmp(b1, vec![zero]);
-
-        // b1
-        builder.switch_to_block(b1);
-        let v1 = builder.insert_binary(v0, BinaryOp::Lt, three);
-        builder.terminate_with_jmpif(v1, b2, b3);
-
-        // b2
-        builder.switch_to_block(b2);
-        builder.terminate_with_jmp(b4, vec![zero]);
-
-        // b3
-        builder.switch_to_block(b3);
-        builder.terminate_with_return(vec![zero]);
-
-        // b4
-        builder.switch_to_block(b4);
-        let v3 = builder.insert_binary(v2, BinaryOp::Lt, four);
-        builder.terminate_with_jmpif(v3, b5, b6);
-
-        // b5
-        builder.switch_to_block(b5);
-        let v4 = builder.insert_binary(v0, BinaryOp::Add, v2);
-        let v5 = builder.insert_binary(ten, BinaryOp::Lt, v4);
-        builder.insert_constrain(v5, one, None);
-        let v6 = builder.insert_binary(v2, BinaryOp::Add, one);
-        builder.terminate_with_jmp(b4, vec![v6]);
-
-        // b6
-        builder.switch_to_block(b6);
-        let v7 = builder.insert_binary(v0, BinaryOp::Add, one);
-        builder.terminate_with_jmp(b1, vec![v7]);
-
-        let ssa = builder.finish();
-        assert_eq!(ssa.main().reachable_blocks().len(), 7);
-
-        // Expected output:
-        //
-        // fn main f0 {
-        //   b0():
-        //     constrain Field 0
-        //     constrain Field 0
-        //     constrain Field 0
-        //     constrain Field 0
-        //     jmp b23()
-        //   b23():
-        //     constrain Field 0
-        //     constrain Field 0
-        //     constrain Field 0
-        //     constrain Field 0
-        //     jmp b27()
-        //   b27():
-        //     constrain Field 0
-        //     constrain Field 0
-        //     constrain Field 0
-        //     constrain Field 0
-        //     jmp b31()
-        //   b31():
-        //     jmp b3()
-        //   b3():
-        //     return Field 0
-        // }
+        let src = "
+            acir(inline) fn main f0 {
+                b0():
+                    jmp b1(Field 0)
+                b1(v0: Field):  // header of outer loop
+                    v1 = lt v0, Field 3
+                    jmpif v1 then: b2, else: b3
+                b2():
+                    jmp b4(Field 0)
+                b4(v2: Field):  // header of inner loop
+                    v3 = lt v2, Field 4
+                    jmpif v3 then: b5, else: b6
+                b5():
+                    v4 = add v0, v2
+                    v5 = lt Field 10, v4
+                    constrain v5 == Field 1
+                    v6 = add v2, Field 1
+                    jmp b4(v6)
+                b6(): // end of inner loop
+                    v7 = add v0, Field 1
+                    jmp b1(v7)
+                b3(): // end of outer loop
+                    return Field 0
+            }
+        ";
+        let ssa = Ssa::from_str(src).unwrap();
+
+        let expected = "
+            acir(inline) fn main f0 {
+              b0():
+                constrain u1 0 == Field 1
+                constrain u1 0 == Field 1
+                constrain u1 0 == Field 1
+                constrain u1 0 == Field 1
+                jmp b1()
+              b1():
+                constrain u1 0 == Field 1
+                constrain u1 0 == Field 1
+                constrain u1 0 == Field 1
+                constrain u1 0 == Field 1
+                jmp b2()
+              b2():
+                constrain u1 0 == Field 1
+                constrain u1 0 == Field 1
+                constrain u1 0 == Field 1
+                constrain u1 0 == Field 1
+                jmp b3()
+              b3():
+                jmp b4()
+              b4():
+                return Field 0
+            }
+        ";
+
         // The final block count is not 1 because unrolling creates some unnecessary jmps.
         // If a simplify cfg pass is ran afterward, the expected block count will be 1.
-        let (ssa, errors) = ssa.try_to_unroll_loops();
+        let (ssa, errors) = try_unroll_loops(ssa);
         assert_eq!(errors.len(), 0, "All loops should be unrolled");
         assert_eq!(ssa.main().reachable_blocks().len(), 5);
+
+        assert_normalized_ssa_equals(ssa, expected);
     }
 
     // Test that the pass can still be run on loops which fail to unroll properly
     #[test]
     fn fail_to_unroll_loop() {
-        // fn main f0 {
-        //   b0(v0: Field):
-        //     jmp b1(v0)
-        //   b1(v1: Field):
-        //     v2 = lt v1, 5
-        //     jmpif v2, then: b2, else: b3
-        //   b2():
-        //     v3 = add v1, Field 1
-        //     jmp b1(v3)
-        //   b3():
-        //     return Field 0
-        // }
-        let main_id = Id::test_new(0);
-        let mut builder = FunctionBuilder::new("main".into(), main_id);
+        let src = "
+        acir(inline) fn main f0 {
+          b0(v0: Field):
+            jmp b1(v0)
+          b1(v1: Field):
+            v2 = lt v1, Field 5
+            jmpif v2 then: b2, else: b3
+          b2():
+            v3 = add v1, Field 1
+            jmp b1(v3)
+          b3():
+            return Field 0
+        }
+        ";
+        let ssa = Ssa::from_str(src).unwrap();
 
-        let b1 = builder.insert_block();
-        let b2 = builder.insert_block();
-        let b3 = builder.insert_block();
+        // Sanity check
+        assert_eq!(ssa.main().reachable_blocks().len(), 4);
 
-        let v0 = builder.add_parameter(Type::field());
-        let v1 = builder.add_block_parameter(b1, Type::field());
+        // Expected that we failed to unroll the loop
+        let (_, errors) = try_unroll_loops(ssa);
+        assert_eq!(errors.len(), 1, "Expected to fail to unroll loop");
+    }
 
-        builder.terminate_with_jmp(b1, vec![v0]);
+    #[test]
+    fn test_get_const_bounds() {
+        let ssa = brillig_unroll_test_case();
+        let function = ssa.main();
+        let loops = Loops::find_all(function);
+        assert_eq!(loops.yet_to_unroll.len(), 1);
+
+        let (lower, upper) = loops.yet_to_unroll[0]
+            .get_const_bounds(function, &loops.cfg)
+            .expect("bounds are numeric const");
+
+        assert_eq!(lower, FieldElement::from(0u32));
+        assert_eq!(upper, FieldElement::from(4u32));
+    }
 
-        builder.switch_to_block(b1);
-        let five = builder.field_constant(5u128);
-        let v2 = builder.insert_binary(v1, BinaryOp::Lt, five);
-        builder.terminate_with_jmpif(v2, b2, b3);
+    #[test]
+    fn test_find_pre_header_reference_values() {
+        let ssa = brillig_unroll_test_case();
+        let function = ssa.main();
+        let mut loops = Loops::find_all(function);
+        let loop0 = loops.yet_to_unroll.pop().unwrap();
+
+        let refs = loop0.find_pre_header_reference_values(function, &loops.cfg).unwrap();
+        assert_eq!(refs.len(), 1);
+        assert!(refs.contains(&ValueId::test_new(2)));
+
+        let (loads, stores) = loop0.count_loads_and_stores(function, &refs);
+        assert_eq!(loads, 1);
+        assert_eq!(stores, 1);
+
+        let all = loop0.count_all_instructions(function);
+        assert_eq!(all, 7);
+    }
 
-        builder.switch_to_block(b2);
-        let one = builder.field_constant(1u128);
-        let v3 = builder.insert_binary(v1, BinaryOp::Add, one);
-        builder.terminate_with_jmp(b1, vec![v3]);
+    #[test]
+    fn test_boilerplate_stats() {
+        let ssa = brillig_unroll_test_case();
+        let stats = loop0_stats(&ssa);
+        assert_eq!(stats.iterations, 4);
+        assert_eq!(stats.all_instructions, 2 + 5); // Instructions in b1 and b3
+        assert_eq!(stats.increments, 1);
+        assert_eq!(stats.loads, 1);
+        assert_eq!(stats.stores, 1);
+        assert_eq!(stats.useful_instructions(), 1); // Adding to sum
+        assert_eq!(stats.baseline_instructions(), 8);
+        assert!(stats.is_small());
+    }
 
-        builder.switch_to_block(b3);
-        let zero = builder.field_constant(0u128);
-        builder.terminate_with_return(vec![zero]);
+    #[test]
+    fn test_boilerplate_stats_6470() {
+        let ssa = brillig_unroll_test_case_6470(3);
+        let stats = loop0_stats(&ssa);
+        assert_eq!(stats.iterations, 3);
+        assert_eq!(stats.all_instructions, 2 + 8); // Instructions in b1 and b3
+        assert_eq!(stats.increments, 2);
+        assert_eq!(stats.loads, 1);
+        assert_eq!(stats.stores, 1);
+        assert_eq!(stats.useful_instructions(), 3); // array get, add, array set
+        assert_eq!(stats.baseline_instructions(), 11);
+        assert!(stats.is_small());
+    }
 
-        let ssa = builder.finish();
-        assert_eq!(ssa.main().reachable_blocks().len(), 4);
+    /// Test that we can unroll a small loop.
+    #[test]
+    fn test_brillig_unroll_small_loop() {
+        let ssa = brillig_unroll_test_case();
+
+        // Expectation taken by compiling the Noir program as ACIR,
+        // ie. by removing the `unconstrained` from `main`.
+        let expected = "
+        brillig(inline) fn main f0 {
+          b0(v0: u32):
+            v1 = allocate -> &mut u32
+            store u32 0 at v1
+            v3 = load v1 -> u32
+            store v3 at v1
+            v4 = load v1 -> u32
+            v6 = add v4, u32 1
+            store v6 at v1
+            v7 = load v1 -> u32
+            v9 = add v7, u32 2
+            store v9 at v1
+            v10 = load v1 -> u32
+            v12 = add v10, u32 3
+            store v12 at v1
+            jmp b1()
+          b1():
+            v13 = load v1 -> u32
+            v14 = eq v13, v0
+            constrain v13 == v0
+            return
+        }
+        ";
 
-        // Expected that we failed to unroll the loop
-        let (_, errors) = ssa.try_to_unroll_loops();
-        assert_eq!(errors.len(), 1, "Expected to fail to unroll loop");
+        let (ssa, errors) = try_unroll_loops(ssa);
+        assert_eq!(errors.len(), 0, "Unroll should have no errors");
+        assert_eq!(ssa.main().reachable_blocks().len(), 2, "The loop should be unrolled");
+
+        assert_normalized_ssa_equals(ssa, expected);
+    }
+
+    /// Test that we can unroll the loop in the ticket if we don't have too many iterations.
+    #[test]
+    fn test_brillig_unroll_6470_small() {
+        // Few enough iterations so that we can perform the unroll.
+        let ssa = brillig_unroll_test_case_6470(3);
+        let (ssa, errors) = try_unroll_loops(ssa);
+        assert_eq!(errors.len(), 0, "Unroll should have no errors");
+        assert_eq!(ssa.main().reachable_blocks().len(), 2, "The loop should be unrolled");
+
+        // The IDs are shifted by one compared to what the ACIR version printed.
+        let expected = "
+        brillig(inline) fn main f0 {
+          b0(v0: [u64; 6]):
+            inc_rc v0
+            v2 = make_array [u64 0, u64 0, u64 0, u64 0, u64 0, u64 0] : [u64; 6]
+            inc_rc v2
+            v3 = allocate -> &mut [u64; 6]
+            store v2 at v3
+            v4 = load v3 -> [u64; 6]
+            v6 = array_get v0, index u32 0 -> u64
+            v8 = add v6, u64 1
+            v9 = array_set v4, index u32 0, value v8
+            store v9 at v3
+            v10 = load v3 -> [u64; 6]
+            v12 = array_get v0, index u32 1 -> u64
+            v13 = add v12, u64 1
+            v14 = array_set v10, index u32 1, value v13
+            store v14 at v3
+            v15 = load v3 -> [u64; 6]
+            v17 = array_get v0, index u32 2 -> u64
+            v18 = add v17, u64 1
+            v19 = array_set v15, index u32 2, value v18
+            store v19 at v3
+            jmp b1()
+          b1():
+            v20 = load v3 -> [u64; 6]
+            dec_rc v0
+            return v20
+        }
+        ";
+        assert_normalized_ssa_equals(ssa, expected);
+    }
+
+    /// Test that with more iterations it's not unrolled.
+    #[test]
+    fn test_brillig_unroll_6470_large() {
+        // More iterations than it can unroll
+        let parse_ssa = || brillig_unroll_test_case_6470(6);
+        let ssa = parse_ssa();
+        let stats = loop0_stats(&ssa);
+        assert!(!stats.is_small(), "the loop should be considered large");
+
+        let (ssa, errors) = try_unroll_loops(ssa);
+        assert_eq!(errors.len(), 0, "Unroll should have no errors");
+        // Check that it's still the original
+        assert_normalized_ssa_equals(ssa, parse_ssa().to_string().as_str());
+    }
+
+    #[test]
+    fn test_brillig_unroll_iteratively_respects_max_increase() {
+        let ssa = brillig_unroll_test_case();
+        let ssa = ssa.unroll_loops_iteratively(Some(-90)).unwrap();
+        // Check that it's still the original
+        assert_normalized_ssa_equals(ssa, brillig_unroll_test_case().to_string().as_str());
+    }
+
+    #[test]
+    fn test_brillig_unroll_iteratively_with_large_max_increase() {
+        let ssa = brillig_unroll_test_case();
+        let ssa = ssa.unroll_loops_iteratively(Some(50)).unwrap();
+        // Check that it did the unroll
+        assert_eq!(ssa.main().reachable_blocks().len(), 2, "The loop should be unrolled");
+    }
+
+    /// Test that `break` and `continue` stop unrolling without any panic.
+    #[test]
+    fn test_brillig_unroll_break_and_continue() {
+        // unconstrained fn main() {
+        //     let mut count = 0;
+        //     for i in 0..10 {
+        //         if i == 2 {
+        //             continue;
+        //         }
+        //         if i == 5 {
+        //             break;
+        //         }
+        //         count += 1;
+        //     }
+        //     assert(count == 4);
+        // }
+        let src = "
+        brillig(inline) fn main f0 {
+          b0():
+            v1 = allocate -> &mut Field
+            store Field 0 at v1
+            jmp b1(u32 0)
+          b1(v0: u32):
+            v5 = lt v0, u32 10
+            jmpif v5 then: b2, else: b6
+          b2():
+            v7 = eq v0, u32 2
+            jmpif v7 then: b7, else: b3
+          b3():
+            v9 = eq v0, u32 5
+            jmpif v9 then: b5, else: b4
+          b4():
+            v10 = load v1 -> Field
+            v12 = add v10, Field 1
+            store v12 at v1
+            v14 = add v0, u32 1
+            jmp b1(v14)
+          b5():
+            jmp b6()
+          b6():
+            v15 = load v1 -> Field
+            v17 = eq v15, Field 4
+            constrain v15 == Field 4
+            return
+          b7():
+            v18 = add v0, u32 1
+            jmp b1(v18)
+        }
+        ";
+        let ssa = Ssa::from_str(src).unwrap();
+        let (ssa, errors) = try_unroll_loops(ssa);
+        assert_eq!(errors.len(), 0, "Unroll should have no errors");
+        assert_normalized_ssa_equals(ssa, src);
+    }
+
+    /// Simple test loop:
+    /// ```text
+    /// unconstrained fn main(sum: u32) {
+    ///     assert(loop(0, 4) == sum);
+    /// }
+    ///
+    /// fn loop(from: u32, to: u32) -> u32 {
+    ///      let mut sum = 0;
+    ///      for i in from..to {
+    ///          sum = sum + i;
+    ///      }
+    ///      sum
+    ///  }
+    /// ```
+    /// We can check what the ACIR unrolling behavior would be by
+    /// removing the `unconstrained` from the `main` function and
+    /// compiling the program with `nargo --test-program . compile --show-ssa`.
+    fn brillig_unroll_test_case() -> Ssa {
+        let src = "
+        // After `static_assert` and `assert_constant`:
+        brillig(inline) fn main f0 {
+          b0(v0: u32):
+            v2 = allocate -> &mut u32
+            store u32 0 at v2
+            jmp b1(u32 0)
+          b1(v1: u32):
+            v5 = lt v1, u32 4
+            jmpif v5 then: b3, else: b2
+          b3():
+            v8 = load v2 -> u32
+            v9 = add v8, v1
+            store v9 at v2
+            v11 = add v1, u32 1
+            jmp b1(v11)
+          b2():
+            v6 = load v2 -> u32
+            v7 = eq v6, v0
+            constrain v6 == v0
+            return
+        }
+        ";
+        Ssa::from_str(src).unwrap()
+    }
+
+    /// Test case from #6470:
+    /// ```text
+    /// unconstrained fn __validate_gt_remainder(a_u60: [u64; 6]) -> [u64; 6] {
+    ///     let mut result_u60: [u64; 6] = [0; 6];
+    ///
+    ///     for i in 0..6 {
+    ///         result_u60[i] = a_u60[i] + 1;
+    ///     }
+    ///
+    ///     result_u60
+    /// }
+    /// ```
+    /// The `num_iterations` parameter can be used to make it more costly to inline.
+    fn brillig_unroll_test_case_6470(num_iterations: usize) -> Ssa {
+        let src = format!(
+            "
+        // After `static_assert` and `assert_constant`:
+        brillig(inline) fn main f0 {{
+          b0(v0: [u64; 6]):
+            inc_rc v0
+            v3 = make_array [u64 0, u64 0, u64 0, u64 0, u64 0, u64 0] : [u64; 6]
+            inc_rc v3
+            v4 = allocate -> &mut [u64; 6]
+            store v3 at v4
+            jmp b1(u32 0)
+          b1(v1: u32):
+            v7 = lt v1, u32 {num_iterations}
+            jmpif v7 then: b3, else: b2
+          b3():
+            v9 = load v4 -> [u64; 6]
+            v10 = array_get v0, index v1 -> u64
+            v12 = add v10, u64 1
+            v13 = array_set v9, index v1, value v12
+            v15 = add v1, u32 1
+            store v13 at v4
+            v16 = add v1, u32 1 // duplicate
+            jmp b1(v16)
+          b2():
+            v8 = load v4 -> [u64; 6]
+            dec_rc v0
+            return v8
+        }}
+        "
+        );
+        Ssa::from_str(&src).unwrap()
+    }
+
+    // Boilerplate stats of the first loop in the SSA.
+    fn loop0_stats(ssa: &Ssa) -> BoilerplateStats {
+        let function = ssa.main();
+        let mut loops = Loops::find_all(function);
+        let loop0 = loops.yet_to_unroll.pop().expect("there should be a loop");
+        loop0.boilerplate_stats(function, &loops.cfg).expect("there should be stats")
+    }
+
+    #[test_case(1000, 700, 50, true; "size decreased")]
+    #[test_case(1000, 1500, 50, true; "size increased just by the max")]
+    #[test_case(1000, 1501, 50, false; "size increased over the max")]
+    #[test_case(1000, 700, -50, false; "size decreased but not enough")]
+    #[test_case(1000, 250, -50, true; "size decreased over expectations")]
+    #[test_case(1000, 250, -1250, false; "demanding more than minus 100 is handled")]
+    fn test_is_new_size_ok(old: usize, new: usize, max: i32, ok: bool) {
+        assert_eq!(is_new_size_ok(old, new, max), ok);
     }
 }
diff --git a/compiler/noirc_evaluator/src/ssa/parser/ast.rs b/compiler/noirc_evaluator/src/ssa/parser/ast.rs
new file mode 100644
index 00000000000..6c7608a2f16
--- /dev/null
+++ b/compiler/noirc_evaluator/src/ssa/parser/ast.rs
@@ -0,0 +1,150 @@
+use std::fmt::{self, Display, Formatter};
+
+use acvm::FieldElement;
+use noirc_errors::Span;
+
+use crate::ssa::ir::{function::RuntimeType, instruction::BinaryOp, types::Type};
+
+#[derive(Debug)]
+pub(crate) struct ParsedSsa {
+    pub(crate) functions: Vec<ParsedFunction>,
+}
+
+#[derive(Debug)]
+pub(crate) struct ParsedFunction {
+    pub(crate) runtime_type: RuntimeType,
+    pub(crate) external_name: String,
+    pub(crate) internal_name: String,
+    pub(crate) blocks: Vec<ParsedBlock>,
+}
+
+#[derive(Debug)]
+pub(crate) struct ParsedBlock {
+    pub(crate) name: String,
+    pub(crate) parameters: Vec<ParsedParameter>,
+    pub(crate) instructions: Vec<ParsedInstruction>,
+    pub(crate) terminator: ParsedTerminator,
+}
+
+#[derive(Debug)]
+pub(crate) struct ParsedParameter {
+    pub(crate) identifier: Identifier,
+    pub(crate) typ: Type,
+}
+
+#[derive(Debug, Clone)]
+pub(crate) struct Identifier {
+    pub(crate) name: String,
+    pub(crate) span: Span,
+}
+
+impl Identifier {
+    pub(crate) fn new(name: String, span: Span) -> Self {
+        Self { name, span }
+    }
+}
+
+impl Display for Identifier {
+    fn fmt(&self, f: &mut Formatter<'_>) -> fmt::Result {
+        write!(f, "{}", self.name)
+    }
+}
+
+#[derive(Debug)]
+pub(crate) enum ParsedInstruction {
+    Allocate {
+        target: Identifier,
+        typ: Type,
+    },
+    ArrayGet {
+        target: Identifier,
+        element_type: Type,
+        array: ParsedValue,
+        index: ParsedValue,
+    },
+    ArraySet {
+        target: Identifier,
+        array: ParsedValue,
+        index: ParsedValue,
+        value: ParsedValue,
+        mutable: bool,
+    },
+    BinaryOp {
+        target: Identifier,
+        lhs: ParsedValue,
+        op: BinaryOp,
+        rhs: ParsedValue,
+    },
+    Call {
+        targets: Vec<Identifier>,
+        function: Identifier,
+        arguments: Vec<ParsedValue>,
+        types: Vec<Type>,
+    },
+    Cast {
+        target: Identifier,
+        lhs: ParsedValue,
+        typ: Type,
+    },
+    Constrain {
+        lhs: ParsedValue,
+        rhs: ParsedValue,
+        assert_message: Option<AssertMessage>,
+    },
+    DecrementRc {
+        value: ParsedValue,
+    },
+    EnableSideEffectsIf {
+        condition: ParsedValue,
+    },
+    IncrementRc {
+        value: ParsedValue,
+    },
+    Load {
+        target: Identifier,
+        value: ParsedValue,
+        typ: Type,
+    },
+    MakeArray {
+        target: Identifier,
+        elements: Vec<ParsedValue>,
+        typ: Type,
+    },
+    Not {
+        target: Identifier,
+        value: ParsedValue,
+    },
+    RangeCheck {
+        value: ParsedValue,
+        max_bit_size: u32,
+    },
+    Store {
+        value: ParsedValue,
+        address: ParsedValue,
+    },
+    Truncate {
+        target: Identifier,
+        value: ParsedValue,
+        bit_size: u32,
+        max_bit_size: u32,
+    },
+}
+
+#[derive(Debug)]
+pub(crate) enum AssertMessage {
+    Static(String),
+    Dynamic(Vec<ParsedValue>),
+}
+
+#[derive(Debug)]
+pub(crate) enum ParsedTerminator {
+    Jmp { destination: Identifier, arguments: Vec<ParsedValue> },
+    Jmpif { condition: ParsedValue, then_block: Identifier, else_block: Identifier },
+    Return(Vec<ParsedValue>),
+}
+
+#[derive(Debug, Clone)]
+pub(crate) enum ParsedValue {
+    NumericConstant { constant: FieldElement, typ: Type },
+    Variable(Identifier),
+}
diff --git a/compiler/noirc_evaluator/src/ssa/parser/into_ssa.rs b/compiler/noirc_evaluator/src/ssa/parser/into_ssa.rs
new file mode 100644
index 00000000000..7c7e977c6ce
--- /dev/null
+++ b/compiler/noirc_evaluator/src/ssa/parser/into_ssa.rs
@@ -0,0 +1,353 @@
+use std::collections::HashMap;
+
+use acvm::acir::circuit::ErrorSelector;
+
+use crate::ssa::{
+    function_builder::FunctionBuilder,
+    ir::{
+        basic_block::BasicBlockId, function::FunctionId, instruction::ConstrainError,
+        value::ValueId,
+    },
+};
+
+use super::{
+    ast::AssertMessage, Identifier, ParsedBlock, ParsedFunction, ParsedInstruction, ParsedSsa,
+    ParsedTerminator, ParsedValue, RuntimeType, Ssa, SsaError,
+};
+
+impl ParsedSsa {
+    pub(crate) fn into_ssa(self) -> Result<Ssa, SsaError> {
+        Translator::translate(self)
+    }
+}
+
+struct Translator {
+    builder: FunctionBuilder,
+
+    /// Maps function names to their IDs
+    functions: HashMap<String, FunctionId>,
+
+    /// Maps block names to their IDs
+    blocks: HashMap<FunctionId, HashMap<String, BasicBlockId>>,
+
+    /// Maps variable names to their IDs.
+    ///
+    /// This is necessary because the SSA we parse might have undergone some
+    /// passes already which replaced some of the original IDs. The translator
+    /// will recreate the SSA step by step, which can result in a new ID layout.
+    variables: HashMap<FunctionId, HashMap<String, ValueId>>,
+
+    error_selector_counter: u64,
+}
+
+impl Translator {
+    fn translate(mut parsed_ssa: ParsedSsa) -> Result<Ssa, SsaError> {
+        let mut translator = Self::new(&mut parsed_ssa)?;
+
+        // Note that the `new` call above removed the main function,
+        // so all we are left with are non-main functions.
+        for function in parsed_ssa.functions {
+            translator.translate_non_main_function(function)?;
+        }
+
+        Ok(translator.finish())
+    }
+
+    fn new(parsed_ssa: &mut ParsedSsa) -> Result<Self, SsaError> {
+        // A FunctionBuilder must be created with a main Function, so here wer remove it
+        // from the parsed SSA to avoid adding it twice later on.
+        let main_function = parsed_ssa.functions.remove(0);
+        let main_id = FunctionId::test_new(0);
+        let mut builder = FunctionBuilder::new(main_function.external_name.clone(), main_id);
+        builder.set_runtime(main_function.runtime_type);
+
+        // Map function names to their IDs so calls can be resolved
+        let mut function_id_counter = 1;
+        let mut functions = HashMap::new();
+        for function in &parsed_ssa.functions {
+            let function_id = FunctionId::test_new(function_id_counter);
+            function_id_counter += 1;
+
+            functions.insert(function.internal_name.clone(), function_id);
+        }
+
+        let mut translator = Self {
+            builder,
+            functions,
+            variables: HashMap::new(),
+            blocks: HashMap::new(),
+            error_selector_counter: 0,
+        };
+        translator.translate_function_body(main_function)?;
+
+        Ok(translator)
+    }
+
+    fn translate_non_main_function(&mut self, function: ParsedFunction) -> Result<(), SsaError> {
+        let function_id = self.functions[&function.internal_name];
+        let external_name = function.external_name.clone();
+
+        match function.runtime_type {
+            RuntimeType::Acir(inline_type) => {
+                self.builder.new_function(external_name, function_id, inline_type);
+            }
+            RuntimeType::Brillig(inline_type) => {
+                self.builder.new_brillig_function(external_name, function_id, inline_type);
+            }
+        }
+
+        self.translate_function_body(function)
+    }
+
+    fn translate_function_body(&mut self, function: ParsedFunction) -> Result<(), SsaError> {
+        // First define all blocks so that they are known (a block might jump to a block that comes next)
+        for (index, block) in function.blocks.iter().enumerate() {
+            // The first block is the entry block and it was automatically created by the builder
+            let block_id = if index == 0 {
+                self.builder.current_function.entry_block()
+            } else {
+                self.builder.insert_block()
+            };
+            let entry = self.blocks.entry(self.current_function_id()).or_default();
+            entry.insert(block.name.clone(), block_id);
+        }
+
+        for block in function.blocks {
+            self.translate_block(block)?;
+        }
+
+        Ok(())
+    }
+
+    fn translate_block(&mut self, block: ParsedBlock) -> Result<(), SsaError> {
+        let block_id = self.blocks[&self.current_function_id()][&block.name];
+        self.builder.switch_to_block(block_id);
+
+        for parameter in block.parameters {
+            let parameter_value_id = self.builder.add_block_parameter(block_id, parameter.typ);
+            self.define_variable(parameter.identifier, parameter_value_id)?;
+        }
+
+        for instruction in block.instructions {
+            self.translate_instruction(instruction)?;
+        }
+
+        match block.terminator {
+            ParsedTerminator::Jmp { destination, arguments } => {
+                let block_id = self.lookup_block(destination)?;
+                let arguments = self.translate_values(arguments)?;
+                self.builder.terminate_with_jmp(block_id, arguments);
+            }
+            ParsedTerminator::Jmpif { condition, then_block, else_block } => {
+                let condition = self.translate_value(condition)?;
+                let then_destination = self.lookup_block(then_block)?;
+                let else_destination = self.lookup_block(else_block)?;
+                self.builder.terminate_with_jmpif(condition, then_destination, else_destination);
+            }
+            ParsedTerminator::Return(values) => {
+                let return_values = self.translate_values(values)?;
+                self.builder.terminate_with_return(return_values);
+            }
+        }
+
+        Ok(())
+    }
+
+    fn translate_instruction(&mut self, instruction: ParsedInstruction) -> Result<(), SsaError> {
+        match instruction {
+            ParsedInstruction::Allocate { target, typ } => {
+                let value_id = self.builder.insert_allocate(typ);
+                self.define_variable(target, value_id)?;
+            }
+            ParsedInstruction::ArrayGet { target, element_type, array, index } => {
+                let array = self.translate_value(array)?;
+                let index = self.translate_value(index)?;
+                let value_id = self.builder.insert_array_get(array, index, element_type);
+                self.define_variable(target, value_id)?;
+            }
+            ParsedInstruction::ArraySet { target, array, index, value, mutable } => {
+                let array = self.translate_value(array)?;
+                let index = self.translate_value(index)?;
+                let value = self.translate_value(value)?;
+                let value_id = if mutable {
+                    self.builder.insert_mutable_array_set(array, index, value)
+                } else {
+                    self.builder.insert_array_set(array, index, value)
+                };
+                self.define_variable(target, value_id)?;
+            }
+            ParsedInstruction::BinaryOp { target, lhs, op, rhs } => {
+                let lhs = self.translate_value(lhs)?;
+                let rhs = self.translate_value(rhs)?;
+                let value_id = self.builder.insert_binary(lhs, op, rhs);
+                self.define_variable(target, value_id)?;
+            }
+            ParsedInstruction::Call { targets, function, arguments, types } => {
+                let function_id = if let Some(id) = self.builder.import_intrinsic(&function.name) {
+                    id
+                } else {
+                    let function_id = self.lookup_function(function)?;
+                    self.builder.import_function(function_id)
+                };
+
+                let arguments = self.translate_values(arguments)?;
+
+                let value_ids = self.builder.insert_call(function_id, arguments, types).to_vec();
+
+                if value_ids.len() != targets.len() {
+                    return Err(SsaError::MismatchedReturnValues {
+                        returns: targets,
+                        expected: value_ids.len(),
+                    });
+                }
+
+                for (target, value_id) in targets.into_iter().zip(value_ids.into_iter()) {
+                    self.define_variable(target, value_id)?;
+                }
+            }
+            ParsedInstruction::Cast { target, lhs, typ } => {
+                let lhs = self.translate_value(lhs)?;
+                let value_id = self.builder.insert_cast(lhs, typ.unwrap_numeric());
+                self.define_variable(target, value_id)?;
+            }
+            ParsedInstruction::Constrain { lhs, rhs, assert_message } => {
+                let lhs = self.translate_value(lhs)?;
+                let rhs = self.translate_value(rhs)?;
+                let assert_message = match assert_message {
+                    Some(AssertMessage::Static(string)) => {
+                        Some(ConstrainError::StaticString(string))
+                    }
+                    Some(AssertMessage::Dynamic(values)) => {
+                        let error_selector = ErrorSelector::new(self.error_selector_counter);
+                        self.error_selector_counter += 1;
+
+                        let is_string_type = false;
+                        let values = self.translate_values(values)?;
+
+                        Some(ConstrainError::Dynamic(error_selector, is_string_type, values))
+                    }
+                    None => None,
+                };
+                self.builder.insert_constrain(lhs, rhs, assert_message);
+            }
+            ParsedInstruction::DecrementRc { value } => {
+                let value = self.translate_value(value)?;
+                self.builder.decrement_array_reference_count(value);
+            }
+            ParsedInstruction::EnableSideEffectsIf { condition } => {
+                let condition = self.translate_value(condition)?;
+                self.builder.insert_enable_side_effects_if(condition);
+            }
+            ParsedInstruction::IncrementRc { value } => {
+                let value = self.translate_value(value)?;
+                self.builder.increment_array_reference_count(value);
+            }
+            ParsedInstruction::MakeArray { target, elements, typ } => {
+                let elements = elements
+                    .into_iter()
+                    .map(|element| self.translate_value(element))
+                    .collect::<Result<_, _>>()?;
+                let value_id = self.builder.insert_make_array(elements, typ);
+                self.define_variable(target, value_id)?;
+            }
+            ParsedInstruction::Load { target, value, typ } => {
+                let value = self.translate_value(value)?;
+                let value_id = self.builder.insert_load(value, typ);
+                self.define_variable(target, value_id)?;
+            }
+            ParsedInstruction::Not { target, value } => {
+                let value = self.translate_value(value)?;
+                let value_id = self.builder.insert_not(value);
+                self.define_variable(target, value_id)?;
+            }
+            ParsedInstruction::RangeCheck { value, max_bit_size } => {
+                let value = self.translate_value(value)?;
+                self.builder.insert_range_check(value, max_bit_size, None);
+            }
+            ParsedInstruction::Store { value, address } => {
+                let value = self.translate_value(value)?;
+                let address = self.translate_value(address)?;
+                self.builder.insert_store(address, value);
+            }
+            ParsedInstruction::Truncate { target, value, bit_size, max_bit_size } => {
+                let value = self.translate_value(value)?;
+                let value_id = self.builder.insert_truncate(value, bit_size, max_bit_size);
+                self.define_variable(target, value_id)?;
+            }
+        }
+
+        Ok(())
+    }
+
+    fn translate_values(&mut self, values: Vec<ParsedValue>) -> Result<Vec<ValueId>, SsaError> {
+        let mut translated_values = Vec::with_capacity(values.len());
+        for value in values {
+            translated_values.push(self.translate_value(value)?);
+        }
+        Ok(translated_values)
+    }
+
+    fn translate_value(&mut self, value: ParsedValue) -> Result<ValueId, SsaError> {
+        match value {
+            ParsedValue::NumericConstant { constant, typ } => {
+                Ok(self.builder.numeric_constant(constant, typ.unwrap_numeric()))
+            }
+            ParsedValue::Variable(identifier) => self.lookup_variable(identifier),
+        }
+    }
+
+    fn define_variable(
+        &mut self,
+        identifier: Identifier,
+        value_id: ValueId,
+    ) -> Result<(), SsaError> {
+        if let Some(vars) = self.variables.get(&self.current_function_id()) {
+            if vars.contains_key(&identifier.name) {
+                return Err(SsaError::VariableAlreadyDefined(identifier));
+            }
+        }
+
+        let entry = self.variables.entry(self.current_function_id()).or_default();
+        entry.insert(identifier.name, value_id);
+
+        Ok(())
+    }
+
+    fn lookup_variable(&mut self, identifier: Identifier) -> Result<ValueId, SsaError> {
+        if let Some(value_id) = self.variables[&self.current_function_id()].get(&identifier.name) {
+            Ok(*value_id)
+        } else {
+            Err(SsaError::UnknownVariable(identifier))
+        }
+    }
+
+    fn lookup_block(&mut self, identifier: Identifier) -> Result<BasicBlockId, SsaError> {
+        if let Some(block_id) = self.blocks[&self.current_function_id()].get(&identifier.name) {
+            Ok(*block_id)
+        } else {
+            Err(SsaError::UnknownBlock(identifier))
+        }
+    }
+
+    fn lookup_function(&mut self, identifier: Identifier) -> Result<FunctionId, SsaError> {
+        if let Some(function_id) = self.functions.get(&identifier.name) {
+            Ok(*function_id)
+        } else {
+            Err(SsaError::UnknownFunction(identifier))
+        }
+    }
+
+    fn finish(self) -> Ssa {
+        let mut ssa = self.builder.finish();
+        // Normalize the IDs so we have a better chance of matching the SSA we parsed
+        // after the step-by-step reconstruction done during translation. This assumes
+        // that the SSA we parsed was printed by the `SsaBuilder`, which normalizes
+        // before each print.
+        ssa.normalize_ids();
+        ssa
+    }
+
+    fn current_function_id(&self) -> FunctionId {
+        self.builder.current_function.id()
+    }
+}
diff --git a/compiler/noirc_evaluator/src/ssa/parser/lexer.rs b/compiler/noirc_evaluator/src/ssa/parser/lexer.rs
new file mode 100644
index 00000000000..5b66810c641
--- /dev/null
+++ b/compiler/noirc_evaluator/src/ssa/parser/lexer.rs
@@ -0,0 +1,316 @@
+use std::str::{CharIndices, FromStr};
+
+use acvm::{AcirField, FieldElement};
+use noirc_errors::{Position, Span};
+use noirc_frontend::token::IntType;
+use num_bigint::BigInt;
+use num_traits::{Num, One};
+use thiserror::Error;
+
+use super::token::{Keyword, SpannedToken, Token};
+
+pub(crate) struct Lexer<'a> {
+    chars: CharIndices<'a>,
+    position: Position,
+    done: bool,
+    max_integer: BigInt,
+}
+
+impl<'a> Lexer<'a> {
+    pub(crate) fn new(source: &'a str) -> Self {
+        Lexer {
+            chars: source.char_indices(),
+            position: 0,
+            done: false,
+            max_integer: BigInt::from_biguint(num_bigint::Sign::Plus, FieldElement::modulus())
+                - BigInt::one(),
+        }
+    }
+
+    pub(crate) fn next_token(&mut self) -> SpannedTokenResult {
+        match self.next_char() {
+            Some(char) if char.is_ascii_whitespace() => {
+                while let Some(char) = self.peek_char() {
+                    if char.is_ascii_whitespace() {
+                        self.next_char();
+                    } else {
+                        break;
+                    }
+                }
+                self.next_token()
+            }
+            Some('/') if self.peek_char() == Some('/') => {
+                while let Some(char) = self.next_char() {
+                    if char == '\n' {
+                        break;
+                    }
+                }
+                self.next_token()
+            }
+            Some('=') if self.peek_char() == Some('=') => self.double_char_token(Token::Equal),
+            Some('=') => self.single_char_token(Token::Assign),
+            Some(',') => self.single_char_token(Token::Comma),
+            Some(':') => self.single_char_token(Token::Colon),
+            Some(';') => self.single_char_token(Token::Semicolon),
+            Some('(') => self.single_char_token(Token::LeftParen),
+            Some(')') => self.single_char_token(Token::RightParen),
+            Some('{') => self.single_char_token(Token::LeftBrace),
+            Some('}') => self.single_char_token(Token::RightBrace),
+            Some('[') => self.single_char_token(Token::LeftBracket),
+            Some(']') => self.single_char_token(Token::RightBracket),
+            Some('&') => self.single_char_token(Token::Ampersand),
+            Some('-') if self.peek_char() == Some('>') => self.double_char_token(Token::Arrow),
+            Some('-') => self.single_char_token(Token::Dash),
+            Some('"') => self.eat_string_literal(),
+            Some('b') if self.peek_char() == Some('"') => self.eat_byte_string_literal(),
+            Some(ch) if ch.is_ascii_alphanumeric() || ch == '_' => self.eat_alpha_numeric(ch),
+            Some(char) => Err(LexerError::UnexpectedCharacter {
+                char,
+                span: Span::single_char(self.position),
+            }),
+            None => {
+                self.done = true;
+                Ok(Token::Eof.into_single_span(self.position))
+            }
+        }
+    }
+
+    fn eat_alpha_numeric(&mut self, initial_char: char) -> SpannedTokenResult {
+        match initial_char {
+            'A'..='Z' | 'a'..='z' | '_' => Ok(self.eat_word(initial_char)?),
+            '0'..='9' => self.eat_digit(initial_char),
+            _ => Err(LexerError::UnexpectedCharacter {
+                char: initial_char,
+                span: Span::single_char(self.position),
+            }),
+        }
+    }
+
+    fn eat_word(&mut self, initial_char: char) -> SpannedTokenResult {
+        let (start, word, end) = self.lex_word(initial_char);
+        self.lookup_word_token(word, start, end)
+    }
+
+    fn lex_word(&mut self, initial_char: char) -> (Position, String, Position) {
+        let start = self.position;
+        let word = self.eat_while(Some(initial_char), |ch| {
+            ch.is_ascii_alphabetic() || ch.is_numeric() || ch == '_'
+        });
+        (start, word, self.position)
+    }
+
+    fn lookup_word_token(
+        &self,
+        word: String,
+        start: Position,
+        end: Position,
+    ) -> SpannedTokenResult {
+        // Check if word either an identifier or a keyword
+        if let Some(keyword_token) = Keyword::lookup_keyword(&word) {
+            return Ok(keyword_token.into_span(start, end));
+        }
+
+        // Check if word an int type
+        // if no error occurred, then it is either a valid integer type or it is not an int type
+        let parsed_token = IntType::lookup_int_type(&word);
+
+        // Check if it is an int type
+        if let Some(int_type) = parsed_token {
+            return Ok(Token::IntType(int_type).into_span(start, end));
+        }
+
+        // Else it is just an identifier
+        let ident_token = Token::Ident(word);
+        Ok(ident_token.into_span(start, end))
+    }
+
+    fn eat_digit(&mut self, initial_char: char) -> SpannedTokenResult {
+        let start = self.position;
+
+        let integer_str = self.eat_while(Some(initial_char), |ch| {
+            ch.is_ascii_digit() | ch.is_ascii_hexdigit() | (ch == 'x') | (ch == '_')
+        });
+
+        let end = self.position;
+
+        // We want to enforce some simple rules about usage of underscores:
+        // 1. Underscores cannot appear at the end of a integer literal. e.g. 0x123_.
+        // 2. There cannot be more than one underscore consecutively, e.g. 0x5__5, 5__5.
+        //
+        // We're not concerned with an underscore at the beginning of a decimal literal
+        // such as `_5` as this would be lexed into an ident rather than an integer literal.
+        let invalid_underscore_location = integer_str.ends_with('_');
+        let consecutive_underscores = integer_str.contains("__");
+        if invalid_underscore_location || consecutive_underscores {
+            return Err(LexerError::InvalidIntegerLiteral {
+                span: Span::inclusive(start, end),
+                found: integer_str,
+            });
+        }
+
+        // Underscores needs to be stripped out before the literal can be converted to a `FieldElement.
+        let integer_str = integer_str.replace('_', "");
+
+        let bigint_result = match integer_str.strip_prefix("0x") {
+            Some(integer_str) => BigInt::from_str_radix(integer_str, 16),
+            None => BigInt::from_str(&integer_str),
+        };
+
+        let integer = match bigint_result {
+            Ok(bigint) => {
+                if bigint > self.max_integer {
+                    return Err(LexerError::IntegerLiteralTooLarge {
+                        span: Span::inclusive(start, end),
+                        limit: self.max_integer.to_string(),
+                    });
+                }
+                let big_uint = bigint.magnitude();
+                FieldElement::from_be_bytes_reduce(&big_uint.to_bytes_be())
+            }
+            Err(_) => {
+                return Err(LexerError::InvalidIntegerLiteral {
+                    span: Span::inclusive(start, end),
+                    found: integer_str,
+                })
+            }
+        };
+
+        let integer_token = Token::Int(integer);
+        Ok(integer_token.into_span(start, end))
+    }
+
+    fn eat_string_literal(&mut self) -> SpannedTokenResult {
+        let start = self.position;
+        let string = self.eat_string(start)?;
+        let str_literal_token = Token::Str(string);
+        let end = self.position;
+        Ok(str_literal_token.into_span(start, end))
+    }
+
+    fn eat_byte_string_literal(&mut self) -> SpannedTokenResult {
+        let start = self.position;
+        self.next_char(); // skip the b
+        let string = self.eat_string(start)?;
+        let str_literal_token = Token::ByteStr(string);
+        let end = self.position;
+        Ok(str_literal_token.into_span(start, end))
+    }
+
+    fn eat_string(&mut self, start: u32) -> Result<String, LexerError> {
+        let mut string = String::new();
+        while let Some(next) = self.next_char() {
+            let char = match next {
+                '"' => break,
+                '\\' => match self.next_char() {
+                    Some('r') => '\r',
+                    Some('n') => '\n',
+                    Some('t') => '\t',
+                    Some('0') => '\0',
+                    Some('"') => '"',
+                    Some('\\') => '\\',
+                    Some(escaped) => {
+                        let span = Span::inclusive(start, self.position);
+                        return Err(LexerError::InvalidEscape { escaped, span });
+                    }
+                    None => {
+                        let span = Span::inclusive(start, self.position);
+                        return Err(LexerError::UnterminatedStringLiteral { span });
+                    }
+                },
+                other => other,
+            };
+
+            string.push(char);
+        }
+        Ok(string)
+    }
+
+    fn eat_while<F: Fn(char) -> bool>(
+        &mut self,
+        initial_char: Option<char>,
+        predicate: F,
+    ) -> String {
+        // This function is only called when we want to continue consuming a character of the same type.
+        // For example, we see a digit and we want to consume the whole integer
+        // Therefore, the current character which triggered this function will need to be appended
+        let mut word = String::new();
+        if let Some(init_char) = initial_char {
+            word.push(init_char);
+        }
+
+        // Keep checking that we are not at the EOF
+        while let Some(peek_char) = self.peek_char() {
+            // Then check for the predicate, if predicate matches append char and increment the cursor
+            // If not, return word. The next character will be analyzed on the next iteration of next_token,
+            // Which will increment the cursor
+            if !predicate(peek_char) {
+                return word;
+            }
+            word.push(peek_char);
+
+            // If we arrive at this point, then the char has been added to the word and we should increment the cursor
+            self.next_char();
+        }
+
+        word
+    }
+
+    fn single_char_token(&self, token: Token) -> SpannedTokenResult {
+        Ok(token.into_single_span(self.position))
+    }
+
+    fn double_char_token(&mut self, token: Token) -> SpannedTokenResult {
+        let start_position = self.position;
+        self.next_char();
+        Ok(token.into_span(start_position, self.position))
+    }
+
+    fn next_char(&mut self) -> Option<char> {
+        let (position, ch) = self.chars.next()?;
+        self.position = position as u32;
+        Some(ch)
+    }
+
+    fn peek_char(&self) -> Option<char> {
+        self.chars.clone().next().map(|(_, ch)| ch)
+    }
+
+    fn is_code_whitespace(c: char) -> bool {
+        c.is_ascii_whitespace()
+    }
+
+    pub(crate) fn newline_follows(&self) -> bool {
+        let chars = self.chars.clone();
+        chars.take_while(|(_, char)| char.is_ascii_whitespace()).any(|(_, char)| char == '\n')
+    }
+}
+
+type SpannedTokenResult = Result<SpannedToken, LexerError>;
+
+#[derive(Debug, Error)]
+pub(crate) enum LexerError {
+    #[error("Unexpected character: {char:?}")]
+    UnexpectedCharacter { char: char, span: Span },
+    #[error("Invalid integer literal")]
+    InvalidIntegerLiteral { span: Span, found: String },
+    #[error("Integer literal too large")]
+    IntegerLiteralTooLarge { span: Span, limit: String },
+    #[error("Unterminated string literal")]
+    UnterminatedStringLiteral { span: Span },
+    #[error(
+        "'\\{escaped}' is not a valid escape sequence. Use '\\' for a literal backslash character."
+    )]
+    InvalidEscape { escaped: char, span: Span },
+}
+
+impl LexerError {
+    pub(crate) fn span(&self) -> Span {
+        match self {
+            LexerError::UnexpectedCharacter { span, .. }
+            | LexerError::InvalidIntegerLiteral { span, .. }
+            | LexerError::IntegerLiteralTooLarge { span, .. }
+            | LexerError::UnterminatedStringLiteral { span }
+            | LexerError::InvalidEscape { span, .. } => *span,
+        }
+    }
+}
diff --git a/compiler/noirc_evaluator/src/ssa/parser/mod.rs b/compiler/noirc_evaluator/src/ssa/parser/mod.rs
new file mode 100644
index 00000000000..24a5ff43071
--- /dev/null
+++ b/compiler/noirc_evaluator/src/ssa/parser/mod.rs
@@ -0,0 +1,993 @@
+use std::{
+    fmt::{self, Debug, Formatter},
+    sync::Arc,
+};
+
+use super::{
+    ir::{
+        instruction::BinaryOp,
+        types::{NumericType, Type},
+    },
+    Ssa,
+};
+
+use acvm::{AcirField, FieldElement};
+use ast::{
+    AssertMessage, Identifier, ParsedBlock, ParsedFunction, ParsedInstruction, ParsedParameter,
+    ParsedSsa, ParsedValue,
+};
+use lexer::{Lexer, LexerError};
+use noirc_errors::Span;
+use noirc_frontend::{monomorphization::ast::InlineType, token::IntType};
+use thiserror::Error;
+use token::{Keyword, SpannedToken, Token};
+
+use crate::ssa::{ir::function::RuntimeType, parser::ast::ParsedTerminator};
+
+mod ast;
+mod into_ssa;
+mod lexer;
+mod tests;
+mod token;
+
+impl Ssa {
+    /// Creates an Ssa object from the given string.
+    ///
+    /// Note that the resulting Ssa might not be exactly the same as the given string.
+    /// This is because, internally, the Ssa is built using a `FunctionBuilder`, so
+    /// some instructions might be simplified while they are inserted.
+    pub(crate) fn from_str(src: &str) -> Result<Ssa, SsaErrorWithSource> {
+        let mut parser =
+            Parser::new(src).map_err(|err| SsaErrorWithSource::parse_error(err, src))?;
+        let parsed_ssa =
+            parser.parse_ssa().map_err(|err| SsaErrorWithSource::parse_error(err, src))?;
+        parsed_ssa.into_ssa().map_err(|error| SsaErrorWithSource { src: src.to_string(), error })
+    }
+}
+
+pub(crate) struct SsaErrorWithSource {
+    src: String,
+    error: SsaError,
+}
+
+impl SsaErrorWithSource {
+    fn parse_error(error: ParserError, src: &str) -> Self {
+        Self { src: src.to_string(), error: SsaError::ParserError(error) }
+    }
+}
+
+impl Debug for SsaErrorWithSource {
+    fn fmt(&self, f: &mut Formatter<'_>) -> fmt::Result {
+        let span = self.error.span();
+
+        let mut byte: usize = 0;
+        for line in self.src.lines() {
+            let has_error =
+                byte <= span.start() as usize && span.end() as usize <= byte + line.len();
+            if has_error {
+                writeln!(f)?;
+            }
+
+            writeln!(f, "{}", line)?;
+
+            if has_error {
+                let offset = span.start() as usize - byte;
+                write!(f, "{}", " ".repeat(offset))?;
+                writeln!(f, "{}", "^".repeat((span.end() - span.start()) as usize))?;
+                write!(f, "{}", " ".repeat(offset))?;
+                writeln!(f, "{}", self.error)?;
+                writeln!(f)?;
+            }
+
+            byte += line.len() + 1; // "+ 1" for the newline
+        }
+        Ok(())
+    }
+}
+
+#[derive(Debug, Error)]
+pub(crate) enum SsaError {
+    #[error("{0}")]
+    ParserError(ParserError),
+    #[error("Unknown variable '{0}'")]
+    UnknownVariable(Identifier),
+    #[error("Unknown block '{0}'")]
+    UnknownBlock(Identifier),
+    #[error("Unknown function '{0}'")]
+    UnknownFunction(Identifier),
+    #[error("Mismatched return values")]
+    MismatchedReturnValues { returns: Vec<Identifier>, expected: usize },
+    #[error("Variable '{0}' already defined")]
+    VariableAlreadyDefined(Identifier),
+}
+
+impl SsaError {
+    fn span(&self) -> Span {
+        match self {
+            SsaError::ParserError(parser_error) => parser_error.span(),
+            SsaError::UnknownVariable(identifier)
+            | SsaError::UnknownBlock(identifier)
+            | SsaError::VariableAlreadyDefined(identifier)
+            | SsaError::UnknownFunction(identifier) => identifier.span,
+            SsaError::MismatchedReturnValues { returns, expected: _ } => returns[0].span,
+        }
+    }
+}
+
+type ParseResult<T> = Result<T, ParserError>;
+
+pub(crate) struct Parser<'a> {
+    lexer: Lexer<'a>,
+    token: SpannedToken,
+}
+
+impl<'a> Parser<'a> {
+    pub(crate) fn new(source: &'a str) -> ParseResult<Self> {
+        let lexer = Lexer::new(source);
+        let mut parser = Self { lexer, token: eof_spanned_token() };
+        parser.token = parser.read_token_internal()?;
+        Ok(parser)
+    }
+
+    pub(crate) fn parse_ssa(&mut self) -> ParseResult<ParsedSsa> {
+        let mut functions = Vec::new();
+        while !self.at(Token::Eof) {
+            let function = self.parse_function()?;
+            functions.push(function);
+        }
+        Ok(ParsedSsa { functions })
+    }
+
+    fn parse_function(&mut self) -> ParseResult<ParsedFunction> {
+        let runtime_type = self.parse_runtime_type()?;
+        self.eat_or_error(Token::Keyword(Keyword::Fn))?;
+
+        let external_name = self.eat_ident_or_error()?;
+        let internal_name = self.eat_ident_or_error()?;
+
+        self.eat_or_error(Token::LeftBrace)?;
+
+        let blocks = self.parse_blocks()?;
+
+        self.eat_or_error(Token::RightBrace)?;
+
+        Ok(ParsedFunction { runtime_type, external_name, internal_name, blocks })
+    }
+
+    fn parse_runtime_type(&mut self) -> ParseResult<RuntimeType> {
+        let acir = if self.eat_keyword(Keyword::Acir)? {
+            true
+        } else if self.eat_keyword(Keyword::Brillig)? {
+            false
+        } else {
+            return self.expected_one_of_tokens(&[
+                Token::Keyword(Keyword::Acir),
+                Token::Keyword(Keyword::Brillig),
+            ]);
+        };
+
+        self.eat_or_error(Token::LeftParen)?;
+        let inline_type = self.parse_inline_type()?;
+        self.eat_or_error(Token::RightParen)?;
+
+        if acir {
+            Ok(RuntimeType::Acir(inline_type))
+        } else {
+            Ok(RuntimeType::Brillig(inline_type))
+        }
+    }
+
+    fn parse_inline_type(&mut self) -> ParseResult<InlineType> {
+        if self.eat_keyword(Keyword::Inline)? {
+            Ok(InlineType::Inline)
+        } else if self.eat_keyword(Keyword::InlineAlways)? {
+            Ok(InlineType::InlineAlways)
+        } else if self.eat_keyword(Keyword::Fold)? {
+            Ok(InlineType::Fold)
+        } else if self.eat_keyword(Keyword::NoPredicates)? {
+            Ok(InlineType::NoPredicates)
+        } else {
+            self.expected_one_of_tokens(&[
+                Token::Keyword(Keyword::Inline),
+                Token::Keyword(Keyword::InlineAlways),
+                Token::Keyword(Keyword::Fold),
+                Token::Keyword(Keyword::NoPredicates),
+            ])
+        }
+    }
+
+    fn parse_blocks(&mut self) -> ParseResult<Vec<ParsedBlock>> {
+        let mut blocks = Vec::new();
+        while !self.at(Token::RightBrace) {
+            let block = self.parse_block()?;
+            blocks.push(block);
+        }
+        Ok(blocks)
+    }
+
+    fn parse_block(&mut self) -> ParseResult<ParsedBlock> {
+        let name = self.eat_ident_or_error()?;
+        self.eat_or_error(Token::LeftParen)?;
+
+        let mut parameters = Vec::new();
+        while !self.at(Token::RightParen) {
+            parameters.push(self.parse_parameter()?);
+            if !self.eat(Token::Comma)? {
+                break;
+            }
+        }
+
+        self.eat_or_error(Token::RightParen)?;
+        self.eat_or_error(Token::Colon)?;
+
+        let instructions = self.parse_instructions()?;
+        let terminator = self.parse_terminator()?;
+        Ok(ParsedBlock { name, parameters, instructions, terminator })
+    }
+
+    fn parse_parameter(&mut self) -> ParseResult<ParsedParameter> {
+        let identifier = self.eat_identifier_or_error()?;
+        self.eat_or_error(Token::Colon)?;
+        let typ = self.parse_type()?;
+        Ok(ParsedParameter { identifier, typ })
+    }
+
+    fn parse_instructions(&mut self) -> ParseResult<Vec<ParsedInstruction>> {
+        let mut instructions = Vec::new();
+        while let Some(instruction) = self.parse_instruction()? {
+            instructions.push(instruction);
+        }
+        Ok(instructions)
+    }
+
+    fn parse_instruction(&mut self) -> ParseResult<Option<ParsedInstruction>> {
+        if let Some(instruction) = self.parse_call()? {
+            return Ok(Some(instruction));
+        }
+
+        if let Some(instruction) = self.parse_constrain()? {
+            return Ok(Some(instruction));
+        }
+
+        if let Some(instruction) = self.parse_decrement_rc()? {
+            return Ok(Some(instruction));
+        }
+
+        if let Some(instruction) = self.parse_enable_side_effects()? {
+            return Ok(Some(instruction));
+        }
+
+        if let Some(instruction) = self.parse_increment_rc()? {
+            return Ok(Some(instruction));
+        }
+
+        if let Some(instruction) = self.parse_range_check()? {
+            return Ok(Some(instruction));
+        }
+
+        if let Some(instruction) = self.parse_store()? {
+            return Ok(Some(instruction));
+        }
+
+        if let Some(target) = self.eat_identifier()? {
+            return Ok(Some(self.parse_assignment(target)?));
+        }
+
+        Ok(None)
+    }
+
+    fn eat_binary_op(&mut self) -> ParseResult<Option<BinaryOp>> {
+        let op = match self.token.token() {
+            Token::Keyword(Keyword::Add) => BinaryOp::Add,
+            Token::Keyword(Keyword::Sub) => BinaryOp::Sub,
+            Token::Keyword(Keyword::Mul) => BinaryOp::Mul,
+            Token::Keyword(Keyword::Div) => BinaryOp::Div,
+            Token::Keyword(Keyword::Eq) => BinaryOp::Eq,
+            Token::Keyword(Keyword::Mod) => BinaryOp::Mod,
+            Token::Keyword(Keyword::Lt) => BinaryOp::Lt,
+            Token::Keyword(Keyword::And) => BinaryOp::And,
+            Token::Keyword(Keyword::Or) => BinaryOp::Or,
+            Token::Keyword(Keyword::Xor) => BinaryOp::Xor,
+            Token::Keyword(Keyword::Shl) => BinaryOp::Shl,
+            Token::Keyword(Keyword::Shr) => BinaryOp::Shr,
+            _ => return Ok(None),
+        };
+
+        self.bump()?;
+
+        Ok(Some(op))
+    }
+
+    fn parse_call(&mut self) -> ParseResult<Option<ParsedInstruction>> {
+        if !self.eat_keyword(Keyword::Call)? {
+            return Ok(None);
+        }
+
+        let function = self.eat_identifier_or_error()?;
+        let arguments = self.parse_arguments()?;
+        Ok(Some(ParsedInstruction::Call { targets: vec![], function, arguments, types: vec![] }))
+    }
+
+    fn parse_constrain(&mut self) -> ParseResult<Option<ParsedInstruction>> {
+        if !self.eat_keyword(Keyword::Constrain)? {
+            return Ok(None);
+        }
+
+        let lhs = self.parse_value_or_error()?;
+        self.eat_or_error(Token::Equal)?;
+        let rhs = self.parse_value_or_error()?;
+
+        let assert_message = if self.eat(Token::Comma)? {
+            if let Some(str) = self.eat_str()? {
+                Some(AssertMessage::Static(str))
+            } else if self.eat_keyword(Keyword::Data)? {
+                Some(AssertMessage::Dynamic(self.parse_comma_separated_values()?))
+            } else {
+                return self.expected_string_or_data();
+            }
+        } else {
+            None
+        };
+
+        Ok(Some(ParsedInstruction::Constrain { lhs, rhs, assert_message }))
+    }
+
+    fn parse_decrement_rc(&mut self) -> ParseResult<Option<ParsedInstruction>> {
+        if !self.eat_keyword(Keyword::DecRc)? {
+            return Ok(None);
+        }
+
+        let value = self.parse_value_or_error()?;
+        Ok(Some(ParsedInstruction::DecrementRc { value }))
+    }
+
+    fn parse_enable_side_effects(&mut self) -> ParseResult<Option<ParsedInstruction>> {
+        if !self.eat_keyword(Keyword::EnableSideEffects)? {
+            return Ok(None);
+        }
+
+        let condition = self.parse_value_or_error()?;
+        Ok(Some(ParsedInstruction::EnableSideEffectsIf { condition }))
+    }
+
+    fn parse_increment_rc(&mut self) -> ParseResult<Option<ParsedInstruction>> {
+        if !self.eat_keyword(Keyword::IncRc)? {
+            return Ok(None);
+        }
+
+        let value = self.parse_value_or_error()?;
+        Ok(Some(ParsedInstruction::IncrementRc { value }))
+    }
+
+    fn parse_range_check(&mut self) -> ParseResult<Option<ParsedInstruction>> {
+        if !self.eat_keyword(Keyword::RangeCheck)? {
+            return Ok(None);
+        }
+
+        let value = self.parse_value_or_error()?;
+        self.eat_or_error(Token::Keyword(Keyword::To))?;
+        let max_bit_size = self.eat_int_or_error()?.to_u128() as u32;
+        self.eat_or_error(Token::Keyword(Keyword::Bits))?;
+        Ok(Some(ParsedInstruction::RangeCheck { value, max_bit_size }))
+    }
+
+    fn parse_store(&mut self) -> ParseResult<Option<ParsedInstruction>> {
+        if !self.eat_keyword(Keyword::Store)? {
+            return Ok(None);
+        }
+
+        let value = self.parse_value_or_error()?;
+        self.eat_or_error(Token::Keyword(Keyword::At))?;
+        let address = self.parse_value_or_error()?;
+        Ok(Some(ParsedInstruction::Store { address, value }))
+    }
+
+    fn parse_assignment(&mut self, target: Identifier) -> ParseResult<ParsedInstruction> {
+        let mut targets = vec![target];
+
+        while self.eat(Token::Comma)? {
+            let target = self.eat_identifier_or_error()?;
+            targets.push(target);
+        }
+
+        self.eat_or_error(Token::Assign)?;
+
+        if self.eat_keyword(Keyword::Call)? {
+            let function = self.eat_identifier_or_error()?;
+            let arguments = self.parse_arguments()?;
+            self.eat_or_error(Token::Arrow)?;
+            let types = self.parse_types()?;
+            return Ok(ParsedInstruction::Call { targets, function, arguments, types });
+        }
+
+        if targets.len() > 1 {
+            return Err(ParserError::MultipleReturnValuesOnlyAllowedForCall {
+                second_target: targets[1].clone(),
+            });
+        }
+
+        let target = targets.remove(0);
+
+        if self.eat_keyword(Keyword::Allocate)? {
+            self.eat_or_error(Token::Arrow)?;
+            let typ = self.parse_mutable_reference_type_or_error()?;
+            return Ok(ParsedInstruction::Allocate { target, typ });
+        }
+
+        if self.eat_keyword(Keyword::ArrayGet)? {
+            let array = self.parse_value_or_error()?;
+            self.eat_or_error(Token::Comma)?;
+            self.eat_or_error(Token::Keyword(Keyword::Index))?;
+            let index = self.parse_value_or_error()?;
+            self.eat_or_error(Token::Arrow)?;
+            let element_type = self.parse_type()?;
+            return Ok(ParsedInstruction::ArrayGet { target, element_type, array, index });
+        }
+
+        if self.eat_keyword(Keyword::ArraySet)? {
+            let mutable = self.eat_keyword(Keyword::Mut)?;
+            let array = self.parse_value_or_error()?;
+            self.eat_or_error(Token::Comma)?;
+            self.eat_or_error(Token::Keyword(Keyword::Index))?;
+            let index = self.parse_value_or_error()?;
+            self.eat_or_error(Token::Comma)?;
+            self.eat_or_error(Token::Keyword(Keyword::Value))?;
+            let value = self.parse_value_or_error()?;
+            return Ok(ParsedInstruction::ArraySet { target, array, index, value, mutable });
+        }
+
+        if self.eat_keyword(Keyword::Cast)? {
+            let lhs = self.parse_value_or_error()?;
+            self.eat_or_error(Token::Keyword(Keyword::As))?;
+            let typ = self.parse_type()?;
+            return Ok(ParsedInstruction::Cast { target, lhs, typ });
+        }
+
+        if self.eat_keyword(Keyword::Load)? {
+            let value = self.parse_value_or_error()?;
+            self.eat_or_error(Token::Arrow)?;
+            let typ = self.parse_type()?;
+            return Ok(ParsedInstruction::Load { target, value, typ });
+        }
+
+        if self.eat_keyword(Keyword::MakeArray)? {
+            if self.eat(Token::Ampersand)? {
+                let Some(string) = self.eat_byte_str()? else {
+                    return self.expected_byte_string();
+                };
+                let u8 = Type::Numeric(NumericType::Unsigned { bit_size: 8 });
+                let typ = Type::Slice(Arc::new(vec![u8.clone()]));
+                let elements = string
+                    .bytes()
+                    .map(|byte| ParsedValue::NumericConstant {
+                        constant: FieldElement::from(byte as u128),
+                        typ: u8.clone(),
+                    })
+                    .collect();
+                return Ok(ParsedInstruction::MakeArray { target, elements, typ });
+            } else if let Some(string) = self.eat_byte_str()? {
+                let u8 = Type::Numeric(NumericType::Unsigned { bit_size: 8 });
+                let typ = Type::Array(Arc::new(vec![u8.clone()]), string.len() as u32);
+                let elements = string
+                    .bytes()
+                    .map(|byte| ParsedValue::NumericConstant {
+                        constant: FieldElement::from(byte as u128),
+                        typ: u8.clone(),
+                    })
+                    .collect();
+                return Ok(ParsedInstruction::MakeArray { target, elements, typ });
+            } else {
+                self.eat_or_error(Token::LeftBracket)?;
+                let elements = self.parse_comma_separated_values()?;
+                self.eat_or_error(Token::RightBracket)?;
+                self.eat_or_error(Token::Colon)?;
+                let typ = self.parse_type()?;
+                return Ok(ParsedInstruction::MakeArray { target, elements, typ });
+            }
+        }
+
+        if self.eat_keyword(Keyword::Not)? {
+            let value = self.parse_value_or_error()?;
+            return Ok(ParsedInstruction::Not { target, value });
+        }
+
+        if self.eat_keyword(Keyword::Truncate)? {
+            let value = self.parse_value_or_error()?;
+            self.eat_or_error(Token::Keyword(Keyword::To))?;
+            let bit_size = self.eat_int_or_error()?.to_u128() as u32;
+            self.eat_or_error(Token::Keyword(Keyword::Bits))?;
+            self.eat_or_error(Token::Comma)?;
+            self.eat_or_error(Token::Keyword(Keyword::MaxBitSize))?;
+            self.eat_or_error(Token::Colon)?;
+            let max_bit_size = self.eat_int_or_error()?.to_u128() as u32;
+            return Ok(ParsedInstruction::Truncate { target, value, bit_size, max_bit_size });
+        }
+
+        if let Some(op) = self.eat_binary_op()? {
+            let lhs = self.parse_value_or_error()?;
+            self.eat_or_error(Token::Comma)?;
+            let rhs = self.parse_value_or_error()?;
+            return Ok(ParsedInstruction::BinaryOp { target, lhs, op, rhs });
+        }
+
+        self.expected_instruction_or_terminator()
+    }
+
+    fn parse_terminator(&mut self) -> ParseResult<ParsedTerminator> {
+        if let Some(terminator) = self.parse_return()? {
+            return Ok(terminator);
+        }
+
+        if let Some(terminator) = self.parse_jmp()? {
+            return Ok(terminator);
+        }
+
+        if let Some(terminator) = self.parse_jmpif()? {
+            return Ok(terminator);
+        }
+
+        self.expected_instruction_or_terminator()
+    }
+
+    fn parse_return(&mut self) -> ParseResult<Option<ParsedTerminator>> {
+        // Before advancing to the next token (after a potential return keyword),
+        // we check if a newline follows. This is because if we have this:
+        //
+        //   return
+        // b1():
+        //   ...
+        //
+        // then unless we check for a newline we can't know if the return
+        // returns `b1` or not (we could check if a parentheses comes next, but
+        // that would require a look-ahead and, for the purpose of the SSA parser,
+        // it's just simpler to check if a newline follows)
+        let newline_follows = self.newline_follows();
+
+        if !self.eat_keyword(Keyword::Return)? {
+            return Ok(None);
+        }
+
+        let values =
+            if newline_follows { Vec::new() } else { self.parse_comma_separated_values()? };
+        Ok(Some(ParsedTerminator::Return(values)))
+    }
+
+    fn parse_jmp(&mut self) -> ParseResult<Option<ParsedTerminator>> {
+        if !self.eat_keyword(Keyword::Jmp)? {
+            return Ok(None);
+        }
+
+        let destination = self.eat_identifier_or_error()?;
+        let arguments = self.parse_arguments()?;
+        Ok(Some(ParsedTerminator::Jmp { destination, arguments }))
+    }
+
+    fn parse_jmpif(&mut self) -> ParseResult<Option<ParsedTerminator>> {
+        if !self.eat_keyword(Keyword::Jmpif)? {
+            return Ok(None);
+        }
+
+        let condition = self.parse_value_or_error()?;
+        self.eat_or_error(Token::Keyword(Keyword::Then))?;
+        self.eat_or_error(Token::Colon)?;
+        let then_block = self.eat_identifier_or_error()?;
+        self.eat_or_error(Token::Comma)?;
+        self.eat_or_error(Token::Keyword(Keyword::Else))?;
+        self.eat_or_error(Token::Colon)?;
+        let else_block = self.eat_identifier_or_error()?;
+
+        Ok(Some(ParsedTerminator::Jmpif { condition, then_block, else_block }))
+    }
+
+    fn parse_arguments(&mut self) -> ParseResult<Vec<ParsedValue>> {
+        self.eat_or_error(Token::LeftParen)?;
+        let arguments = self.parse_comma_separated_values()?;
+        self.eat_or_error(Token::RightParen)?;
+        Ok(arguments)
+    }
+
+    fn parse_comma_separated_values(&mut self) -> ParseResult<Vec<ParsedValue>> {
+        let mut values = Vec::new();
+        while let Some(value) = self.parse_value()? {
+            values.push(value);
+            if !self.eat(Token::Comma)? {
+                break;
+            }
+        }
+        Ok(values)
+    }
+
+    fn parse_value_or_error(&mut self) -> ParseResult<ParsedValue> {
+        if let Some(value) = self.parse_value()? {
+            Ok(value)
+        } else {
+            self.expected_value()
+        }
+    }
+
+    fn parse_value(&mut self) -> ParseResult<Option<ParsedValue>> {
+        if let Some(value) = self.parse_field_value()? {
+            return Ok(Some(value));
+        }
+
+        if let Some(value) = self.parse_int_value()? {
+            return Ok(Some(value));
+        }
+
+        if let Some(identifier) = self.eat_identifier()? {
+            return Ok(Some(ParsedValue::Variable(identifier)));
+        }
+
+        Ok(None)
+    }
+
+    fn parse_field_value(&mut self) -> ParseResult<Option<ParsedValue>> {
+        if self.eat_keyword(Keyword::Field)? {
+            let constant = self.eat_int_or_error()?;
+            Ok(Some(ParsedValue::NumericConstant { constant, typ: Type::field() }))
+        } else {
+            Ok(None)
+        }
+    }
+
+    fn parse_int_value(&mut self) -> ParseResult<Option<ParsedValue>> {
+        if let Some(int_type) = self.eat_int_type()? {
+            let constant = self.eat_int_or_error()?;
+            let typ = match int_type {
+                IntType::Unsigned(bit_size) => Type::unsigned(bit_size),
+                IntType::Signed(bit_size) => Type::signed(bit_size),
+            };
+            Ok(Some(ParsedValue::NumericConstant { constant, typ }))
+        } else {
+            Ok(None)
+        }
+    }
+
+    fn parse_types(&mut self) -> ParseResult<Vec<Type>> {
+        if self.eat(Token::LeftParen)? {
+            let types = self.parse_comma_separated_types()?;
+            self.eat_or_error(Token::RightParen)?;
+            Ok(types)
+        } else {
+            Ok(vec![self.parse_type()?])
+        }
+    }
+
+    fn parse_comma_separated_types(&mut self) -> ParseResult<Vec<Type>> {
+        let mut types = Vec::new();
+        loop {
+            let typ = self.parse_type()?;
+            types.push(typ);
+            if !self.eat(Token::Comma)? {
+                break;
+            }
+        }
+        Ok(types)
+    }
+
+    fn parse_type(&mut self) -> ParseResult<Type> {
+        if self.eat_keyword(Keyword::Bool)? {
+            return Ok(Type::bool());
+        }
+
+        if self.eat_keyword(Keyword::Field)? {
+            return Ok(Type::field());
+        }
+
+        if let Some(int_type) = self.eat_int_type()? {
+            return Ok(match int_type {
+                IntType::Unsigned(bit_size) => Type::unsigned(bit_size),
+                IntType::Signed(bit_size) => Type::signed(bit_size),
+            });
+        }
+
+        if self.eat(Token::LeftBracket)? {
+            let element_types = self.parse_types()?;
+            if self.eat(Token::Semicolon)? {
+                let length = self.eat_int_or_error()?;
+                self.eat_or_error(Token::RightBracket)?;
+                return Ok(Type::Array(Arc::new(element_types), length.to_u128() as u32));
+            } else {
+                self.eat_or_error(Token::RightBracket)?;
+                return Ok(Type::Slice(Arc::new(element_types)));
+            }
+        }
+
+        if let Some(typ) = self.parse_mutable_reference_type()? {
+            return Ok(Type::Reference(Arc::new(typ)));
+        }
+
+        if self.eat_keyword(Keyword::Function)? {
+            return Ok(Type::Function);
+        }
+
+        self.expected_type()
+    }
+
+    /// Parses `&mut Type`, returns `Type` if `&mut` was found, errors otherwise.
+    fn parse_mutable_reference_type_or_error(&mut self) -> ParseResult<Type> {
+        if let Some(typ) = self.parse_mutable_reference_type()? {
+            Ok(typ)
+        } else {
+            self.expected_token(Token::Ampersand)
+        }
+    }
+
+    /// Parses `&mut Type`, returns `Some(Type)` if `&mut` was found, `None` otherwise.
+    fn parse_mutable_reference_type(&mut self) -> ParseResult<Option<Type>> {
+        if !self.eat(Token::Ampersand)? {
+            return Ok(None);
+        }
+
+        self.eat_or_error(Token::Keyword(Keyword::Mut))?;
+        let typ = self.parse_type()?;
+        Ok(Some(typ))
+    }
+
+    fn eat_identifier_or_error(&mut self) -> ParseResult<Identifier> {
+        if let Some(identifier) = self.eat_identifier()? {
+            Ok(identifier)
+        } else {
+            self.expected_identifier()
+        }
+    }
+
+    fn eat_identifier(&mut self) -> ParseResult<Option<Identifier>> {
+        let span = self.token.to_span();
+        if let Some(name) = self.eat_ident()? {
+            Ok(Some(Identifier::new(name, span)))
+        } else {
+            Ok(None)
+        }
+    }
+
+    fn eat_keyword(&mut self, keyword: Keyword) -> ParseResult<bool> {
+        if let Token::Keyword(kw) = self.token.token() {
+            if *kw == keyword {
+                self.bump()?;
+                Ok(true)
+            } else {
+                Ok(false)
+            }
+        } else {
+            Ok(false)
+        }
+    }
+
+    fn eat_ident(&mut self) -> ParseResult<Option<String>> {
+        if !matches!(self.token.token(), Token::Ident(..)) {
+            return Ok(None);
+        }
+
+        let token = self.bump()?;
+        match token.into_token() {
+            Token::Ident(ident) => Ok(Some(ident)),
+            _ => unreachable!(),
+        }
+    }
+
+    fn eat_ident_or_error(&mut self) -> ParseResult<String> {
+        if let Some(ident) = self.eat_ident()? {
+            Ok(ident)
+        } else {
+            self.expected_identifier()
+        }
+    }
+
+    fn eat_int(&mut self) -> ParseResult<Option<FieldElement>> {
+        let negative = self.eat(Token::Dash)?;
+
+        if matches!(self.token.token(), Token::Int(..)) {
+            let token = self.bump()?;
+            match token.into_token() {
+                Token::Int(mut int) => {
+                    if negative {
+                        int = -int;
+                    }
+                    Ok(Some(int))
+                }
+                _ => unreachable!(),
+            }
+        } else {
+            Ok(None)
+        }
+    }
+
+    fn eat_int_or_error(&mut self) -> ParseResult<FieldElement> {
+        if let Some(int) = self.eat_int()? {
+            Ok(int)
+        } else {
+            self.expected_int()
+        }
+    }
+
+    fn eat_int_type(&mut self) -> ParseResult<Option<IntType>> {
+        let is_int_type = matches!(self.token.token(), Token::IntType(..));
+        if is_int_type {
+            let token = self.bump()?;
+            match token.into_token() {
+                Token::IntType(int_type) => Ok(Some(int_type)),
+                _ => unreachable!(),
+            }
+        } else {
+            Ok(None)
+        }
+    }
+
+    fn eat_str(&mut self) -> ParseResult<Option<String>> {
+        if matches!(self.token.token(), Token::Str(..)) {
+            let token = self.bump()?;
+            match token.into_token() {
+                Token::Str(string) => Ok(Some(string)),
+                _ => unreachable!(),
+            }
+        } else {
+            Ok(None)
+        }
+    }
+
+    fn eat_byte_str(&mut self) -> ParseResult<Option<String>> {
+        if matches!(self.token.token(), Token::ByteStr(..)) {
+            let token = self.bump()?;
+            match token.into_token() {
+                Token::ByteStr(string) => Ok(Some(string)),
+                _ => unreachable!(),
+            }
+        } else {
+            Ok(None)
+        }
+    }
+
+    fn eat(&mut self, token: Token) -> ParseResult<bool> {
+        if self.token.token() == &token {
+            self.bump()?;
+            Ok(true)
+        } else {
+            Ok(false)
+        }
+    }
+
+    fn eat_or_error(&mut self, token: Token) -> ParseResult<()> {
+        if self.eat(token.clone())? {
+            Ok(())
+        } else {
+            self.expected_token(token)
+        }
+    }
+
+    fn at(&self, token: Token) -> bool {
+        self.token.token() == &token
+    }
+
+    fn at_keyword(&self, keyword: Keyword) -> bool {
+        self.at(Token::Keyword(keyword))
+    }
+
+    fn newline_follows(&self) -> bool {
+        self.lexer.newline_follows()
+    }
+
+    fn bump(&mut self) -> ParseResult<SpannedToken> {
+        let token = self.read_token_internal()?;
+        Ok(std::mem::replace(&mut self.token, token))
+    }
+
+    fn read_token_internal(&mut self) -> ParseResult<SpannedToken> {
+        self.lexer.next_token().map_err(ParserError::LexerError)
+    }
+
+    fn expected_instruction_or_terminator<T>(&mut self) -> ParseResult<T> {
+        Err(ParserError::ExpectedInstructionOrTerminator {
+            found: self.token.token().clone(),
+            span: self.token.to_span(),
+        })
+    }
+
+    fn expected_string_or_data<T>(&mut self) -> ParseResult<T> {
+        Err(ParserError::ExpectedStringOrData {
+            found: self.token.token().clone(),
+            span: self.token.to_span(),
+        })
+    }
+
+    fn expected_byte_string<T>(&mut self) -> ParseResult<T> {
+        Err(ParserError::ExpectedByteString {
+            found: self.token.token().clone(),
+            span: self.token.to_span(),
+        })
+    }
+
+    fn expected_identifier<T>(&mut self) -> ParseResult<T> {
+        Err(ParserError::ExpectedIdentifier {
+            found: self.token.token().clone(),
+            span: self.token.to_span(),
+        })
+    }
+
+    fn expected_int<T>(&mut self) -> ParseResult<T> {
+        Err(ParserError::ExpectedInt {
+            found: self.token.token().clone(),
+            span: self.token.to_span(),
+        })
+    }
+
+    fn expected_type<T>(&mut self) -> ParseResult<T> {
+        Err(ParserError::ExpectedType {
+            found: self.token.token().clone(),
+            span: self.token.to_span(),
+        })
+    }
+
+    fn expected_value<T>(&mut self) -> ParseResult<T> {
+        Err(ParserError::ExpectedValue {
+            found: self.token.token().clone(),
+            span: self.token.to_span(),
+        })
+    }
+
+    fn expected_token<T>(&mut self, token: Token) -> ParseResult<T> {
+        Err(ParserError::ExpectedToken {
+            token,
+            found: self.token.token().clone(),
+            span: self.token.to_span(),
+        })
+    }
+
+    fn expected_one_of_tokens<T>(&mut self, tokens: &[Token]) -> ParseResult<T> {
+        Err(ParserError::ExpectedOneOfTokens {
+            tokens: tokens.to_vec(),
+            found: self.token.token().clone(),
+            span: self.token.to_span(),
+        })
+    }
+}
+
+#[derive(Debug, Error)]
+pub(crate) enum ParserError {
+    #[error("{0}")]
+    LexerError(LexerError),
+    #[error("Expected '{token}', found '{found}'")]
+    ExpectedToken { token: Token, found: Token, span: Span },
+    #[error("Expected one of {tokens:?}, found {found}")]
+    ExpectedOneOfTokens { tokens: Vec<Token>, found: Token, span: Span },
+    #[error("Expected an identifier, found '{found}'")]
+    ExpectedIdentifier { found: Token, span: Span },
+    #[error("Expected an int, found '{found}'")]
+    ExpectedInt { found: Token, span: Span },
+    #[error("Expected a type, found '{found}'")]
+    ExpectedType { found: Token, span: Span },
+    #[error("Expected an instruction or terminator, found '{found}'")]
+    ExpectedInstructionOrTerminator { found: Token, span: Span },
+    #[error("Expected a string literal or 'data', found '{found}'")]
+    ExpectedStringOrData { found: Token, span: Span },
+    #[error("Expected a byte string literal, found '{found}'")]
+    ExpectedByteString { found: Token, span: Span },
+    #[error("Expected a value, found '{found}'")]
+    ExpectedValue { found: Token, span: Span },
+    #[error("Multiple return values only allowed for call")]
+    MultipleReturnValuesOnlyAllowedForCall { second_target: Identifier },
+}
+
+impl ParserError {
+    fn span(&self) -> Span {
+        match self {
+            ParserError::LexerError(err) => err.span(),
+            ParserError::ExpectedToken { span, .. }
+            | ParserError::ExpectedOneOfTokens { span, .. }
+            | ParserError::ExpectedIdentifier { span, .. }
+            | ParserError::ExpectedInt { span, .. }
+            | ParserError::ExpectedType { span, .. }
+            | ParserError::ExpectedInstructionOrTerminator { span, .. }
+            | ParserError::ExpectedStringOrData { span, .. }
+            | ParserError::ExpectedByteString { span, .. }
+            | ParserError::ExpectedValue { span, .. } => *span,
+            ParserError::MultipleReturnValuesOnlyAllowedForCall { second_target, .. } => {
+                second_target.span
+            }
+        }
+    }
+}
+
+fn eof_spanned_token() -> SpannedToken {
+    SpannedToken::new(Token::Eof, Default::default())
+}
diff --git a/compiler/noirc_evaluator/src/ssa/parser/tests.rs b/compiler/noirc_evaluator/src/ssa/parser/tests.rs
new file mode 100644
index 00000000000..dab96dfa04f
--- /dev/null
+++ b/compiler/noirc_evaluator/src/ssa/parser/tests.rs
@@ -0,0 +1,504 @@
+#![cfg(test)]
+
+use crate::{
+    ssa::{opt::assert_normalized_ssa_equals, Ssa},
+    trim_leading_whitespace_from_lines,
+};
+
+fn assert_ssa_roundtrip(src: &str) {
+    let ssa = Ssa::from_str(src).unwrap();
+    let ssa = ssa.to_string();
+    let ssa = trim_leading_whitespace_from_lines(&ssa);
+    let src = trim_leading_whitespace_from_lines(src);
+    if ssa != src {
+        println!("Expected:\n~~~\n{}\n~~~\nGot:\n~~~\n{}\n~~~", src, ssa);
+        similar_asserts::assert_eq!(ssa, src);
+    }
+}
+
+#[test]
+fn test_empty_acir_function() {
+    let src = "
+        acir(inline) fn main f0 {
+          b0():
+            return
+        }
+        ";
+    assert_ssa_roundtrip(src);
+}
+
+#[test]
+fn test_empty_brillig_function() {
+    let src = "
+        brillig(inline) fn main f0 {
+          b0():
+            return
+        }
+        ";
+    assert_ssa_roundtrip(src);
+}
+
+#[test]
+fn test_return_integer() {
+    for typ in ["u1", "u8", "u16", "u32", "u64", "i1", "i8", "i16", "i32", "i64", "Field"] {
+        let src = format!(
+            "
+            acir(inline) fn main f0 {{
+              b0():
+                return {typ} 1
+            }}
+            "
+        );
+        assert_ssa_roundtrip(&src);
+    }
+}
+
+#[test]
+fn test_make_array() {
+    let src = "
+        acir(inline) fn main f0 {
+          b0():
+            v1 = make_array [Field 1] : [Field; 1]
+            return v1
+        }
+        ";
+    assert_ssa_roundtrip(src);
+}
+
+#[test]
+fn test_make_empty_array() {
+    let src = "
+        acir(inline) fn main f0 {
+          b0():
+            v0 = make_array [] : [Field; 0]
+            return v0
+        }
+        ";
+    assert_ssa_roundtrip(src);
+}
+
+#[test]
+fn test_make_composite_array() {
+    let src = "
+        acir(inline) fn main f0 {
+          b0():
+            v2 = make_array [Field 1, Field 2] : [(Field, Field); 1]
+            return v2
+        }
+        ";
+    assert_ssa_roundtrip(src);
+}
+
+#[test]
+fn test_make_byte_array_with_string_literal() {
+    let src = "
+        acir(inline) fn main f0 {
+          b0():
+            v9 = make_array b\"Hello world!\"
+            return v9
+        }
+        ";
+    assert_ssa_roundtrip(src);
+}
+
+#[test]
+fn test_make_byte_slice_with_string_literal() {
+    let src = "
+        acir(inline) fn main f0 {
+          b0():
+            v9 = make_array &b\"Hello world!\"
+            return v9
+        }
+        ";
+    assert_ssa_roundtrip(src);
+}
+
+#[test]
+fn test_block_parameters() {
+    let src = "
+        acir(inline) fn main f0 {
+          b0(v0: Field, v1: Field):
+            return v0, v1
+        }
+        ";
+    assert_ssa_roundtrip(src);
+}
+
+#[test]
+fn test_multiple_blocks_and_jmp() {
+    let src = "
+        acir(inline) fn main f0 {
+          b0():
+            jmp b1(Field 1)
+          b1(v0: Field):
+            return v0
+        }
+        ";
+    assert_ssa_roundtrip(src);
+}
+
+#[test]
+fn test_jmpif() {
+    let src = "
+        acir(inline) fn main f0 {
+          b0(v0: Field):
+            jmpif v0 then: b2, else: b1
+          b1():
+            return
+          b2():
+            return
+        }
+        ";
+    assert_ssa_roundtrip(src);
+}
+
+#[test]
+fn test_call() {
+    let src = "
+        acir(inline) fn main f0 {
+          b0(v0: Field):
+            v2 = call f1(v0) -> Field
+            return v2
+        }
+        acir(inline) fn foo f1 {
+          b0(v0: Field):
+            return v0
+        }
+        ";
+    assert_ssa_roundtrip(src);
+}
+
+#[test]
+fn test_call_multiple_return_values() {
+    let src = "
+        acir(inline) fn main f0 {
+          b0():
+            v1, v2 = call f1() -> ([Field; 3], [Field; 1])
+            return v1
+        }
+        acir(inline) fn foo f1 {
+          b0():
+            v3 = make_array [Field 1, Field 2, Field 3] : [Field; 3]
+            v5 = make_array [Field 4] : [Field; 1]
+            return v3, v5
+        }
+        ";
+    assert_ssa_roundtrip(src);
+}
+
+#[test]
+fn test_call_no_return_value() {
+    let src = "
+        acir(inline) fn main f0 {
+          b0(v0: Field):
+            call f1(v0)
+            return
+        }
+        acir(inline) fn foo f1 {
+          b0(v0: Field):
+            return
+        }
+        ";
+    assert_ssa_roundtrip(src);
+}
+
+#[test]
+fn test_call_intrinsic() {
+    let src = "
+        acir(inline) fn main f0 {
+          b0(v0: Field):
+            call assert_constant(v0)
+            return
+        }
+        ";
+    assert_ssa_roundtrip(src);
+}
+
+#[test]
+fn test_cast() {
+    let src = "
+        acir(inline) fn main f0 {
+          b0(v0: Field):
+            v1 = cast v0 as i32
+            return v1
+        }
+        ";
+    assert_ssa_roundtrip(src);
+}
+
+#[test]
+fn test_constrain() {
+    let src = "
+        acir(inline) fn main f0 {
+          b0(v0: Field):
+            constrain v0 == Field 1
+            return
+        }
+        ";
+    assert_ssa_roundtrip(src);
+}
+
+#[test]
+fn test_constrain_with_static_message() {
+    let src = r#"
+        acir(inline) fn main f0 {
+          b0(v0: Field):
+            constrain v0 == Field 1, "Oh no!"
+            return
+        }
+        "#;
+    assert_ssa_roundtrip(src);
+}
+
+#[test]
+fn test_constrain_with_dynamic_message() {
+    let src = r#"
+        acir(inline) fn main f0 {
+          b0(v0: Field, v1: Field):
+            v7 = make_array b"{x} {y}"
+            constrain v0 == Field 1, data v7, u32 2, v0, v1
+            return
+        }
+        "#;
+    assert_ssa_roundtrip(src);
+}
+
+#[test]
+fn test_enable_side_effects() {
+    let src = "
+        acir(inline) fn main f0 {
+          b0(v0: Field):
+            enable_side_effects v0
+            return
+        }
+        ";
+    assert_ssa_roundtrip(src);
+}
+
+#[test]
+fn test_array_get() {
+    let src = "
+        acir(inline) fn main f0 {
+          b0(v0: [Field; 3]):
+            v2 = array_get v0, index Field 0 -> Field
+            return
+        }
+        ";
+    assert_ssa_roundtrip(src);
+}
+
+#[test]
+fn test_array_set() {
+    let src = "
+        acir(inline) fn main f0 {
+          b0(v0: [Field; 3]):
+            v3 = array_set v0, index Field 0, value Field 1
+            return
+        }
+        ";
+    assert_ssa_roundtrip(src);
+}
+
+#[test]
+fn test_mutable_array_set() {
+    let src = "
+        acir(inline) fn main f0 {
+          b0(v0: [Field; 3]):
+            v3 = array_set mut v0, index Field 0, value Field 1
+            return
+        }
+        ";
+    assert_ssa_roundtrip(src);
+}
+
+#[test]
+fn test_array_get_set_bug() {
+    let src = "
+        acir(inline) fn main f0 {
+          b0(v0: [u32; 3]):
+            v3 = array_set v0, index u32 1, value u32 2
+            v5 = array_get v3, index u32 0 -> u32
+            return
+        }
+        ";
+    assert_ssa_roundtrip(src);
+}
+
+#[test]
+fn test_binary() {
+    for op in ["add", "sub", "mul", "div", "eq", "mod", "lt", "and", "or", "xor", "shl", "shr"] {
+        let src = format!(
+            "
+            acir(inline) fn main f0 {{
+              b0(v0: Field, v1: Field):
+                v2 = {op} v0, v1
+                return
+            }}
+            "
+        );
+        assert_ssa_roundtrip(&src);
+    }
+}
+
+#[test]
+fn test_truncate() {
+    let src = "
+        acir(inline) fn main f0 {
+          b0(v0: Field):
+            v1 = truncate v0 to 8 bits, max_bit_size: 16
+            return
+        }
+        ";
+    assert_ssa_roundtrip(src);
+}
+
+#[test]
+fn test_not() {
+    let src = "
+        acir(inline) fn main f0 {
+          b0(v0: Field):
+            v1 = not v0
+            return
+        }
+        ";
+    assert_ssa_roundtrip(src);
+}
+
+#[test]
+fn test_range_check() {
+    let src = "
+        acir(inline) fn main f0 {
+          b0(v0: Field):
+            range_check v0 to 8 bits
+            return
+        }
+        ";
+    assert_ssa_roundtrip(src);
+}
+
+#[test]
+fn test_allocate() {
+    let src = "
+        acir(inline) fn main f0 {
+          b0():
+            v0 = allocate -> &mut [Field; 3]
+            return
+        }
+        ";
+    assert_ssa_roundtrip(src);
+}
+
+#[test]
+fn test_load() {
+    let src = "
+        acir(inline) fn main f0 {
+          b0(v0: Field):
+            v1 = load v0 -> Field
+            return
+        }
+        ";
+    assert_ssa_roundtrip(src);
+}
+
+#[test]
+fn test_store() {
+    let src = "
+        acir(inline) fn main f0 {
+          b0(v0: Field):
+            store Field 1 at v0
+            return
+        }
+        ";
+    assert_ssa_roundtrip(src);
+}
+
+#[test]
+fn test_inc_rc() {
+    let src = "
+        acir(inline) fn main f0 {
+          b0(v0: [Field; 3]):
+            inc_rc v0
+            return
+        }
+        ";
+    assert_ssa_roundtrip(src);
+}
+
+#[test]
+fn test_dec_rc() {
+    let src = "
+        acir(inline) fn main f0 {
+          b0(v0: [Field; 3]):
+            dec_rc v0
+            return
+        }
+        ";
+    assert_ssa_roundtrip(src);
+}
+
+#[test]
+fn test_mutable_reference_type() {
+    let src = "
+        acir(inline) fn main f0 {
+          b0(v0: &mut Field):
+            return
+        }
+        ";
+    assert_ssa_roundtrip(src);
+}
+
+#[test]
+fn test_parses_with_comments() {
+    let src = "
+        // This is a comment
+        acir(inline) fn main f0 {
+          b0(v0: &mut Field): // This is a block
+            return // Returns nothing
+        }
+        ";
+
+    let expected = "
+        acir(inline) fn main f0 {
+          b0(v0: &mut Field):
+            return
+        }
+        ";
+
+    let ssa = Ssa::from_str(src).unwrap();
+    assert_normalized_ssa_equals(ssa, expected);
+}
+
+#[test]
+fn test_slice() {
+    let src = "
+        acir(inline) fn main f0 {
+          b0(v0: [Field; 3]):
+            v2, v3 = call as_slice(v0) -> (u32, [Field])
+            return
+        }
+        ";
+    assert_ssa_roundtrip(src);
+}
+
+#[test]
+fn test_negative() {
+    let src = "
+        acir(inline) fn main f0 {
+          b0():
+            return Field -1
+        }
+        ";
+    assert_ssa_roundtrip(src);
+}
+
+#[test]
+fn test_function_type() {
+    let src = "
+        acir(inline) fn main f0 {
+          b0():
+            v0 = allocate -> &mut function
+            return
+        }
+        ";
+    assert_ssa_roundtrip(src);
+}
diff --git a/compiler/noirc_evaluator/src/ssa/parser/token.rs b/compiler/noirc_evaluator/src/ssa/parser/token.rs
new file mode 100644
index 00000000000..83a2a1d1ed2
--- /dev/null
+++ b/compiler/noirc_evaluator/src/ssa/parser/token.rs
@@ -0,0 +1,285 @@
+use std::fmt::Display;
+
+use acvm::FieldElement;
+use noirc_errors::{Position, Span, Spanned};
+use noirc_frontend::token::IntType;
+
+#[derive(Debug)]
+pub(crate) struct SpannedToken(Spanned<Token>);
+
+impl SpannedToken {
+    pub(crate) fn new(token: Token, span: Span) -> SpannedToken {
+        SpannedToken(Spanned::from(span, token))
+    }
+
+    pub(crate) fn to_span(&self) -> Span {
+        self.0.span()
+    }
+
+    pub(crate) fn token(&self) -> &Token {
+        &self.0.contents
+    }
+
+    pub(crate) fn into_token(self) -> Token {
+        self.0.contents
+    }
+}
+
+#[derive(Clone, PartialEq, Eq, Hash, PartialOrd, Ord)]
+pub(crate) enum Token {
+    Ident(String),
+    Int(FieldElement),
+    Str(String),
+    ByteStr(String),
+    Keyword(Keyword),
+    IntType(IntType),
+    /// =
+    Assign,
+    /// (
+    LeftParen,
+    /// )
+    RightParen,
+    /// {
+    LeftBrace,
+    /// }
+    RightBrace,
+    /// [
+    LeftBracket,
+    /// ]
+    RightBracket,
+    /// ,
+    Comma,
+    /// :
+    Colon,
+    /// ;
+    Semicolon,
+    /// ->
+    Arrow,
+    /// ==
+    Equal,
+    /// &
+    Ampersand,
+    /// -
+    Dash,
+    Eof,
+}
+
+impl Token {
+    pub(super) fn into_single_span(self, position: Position) -> SpannedToken {
+        self.into_span(position, position)
+    }
+
+    pub(super) fn into_span(self, start: Position, end: Position) -> SpannedToken {
+        SpannedToken(Spanned::from_position(start, end, self))
+    }
+}
+
+impl Display for Token {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        match self {
+            Token::Ident(ident) => write!(f, "{}", ident),
+            Token::Int(int) => write!(f, "{}", int),
+            Token::Str(string) => write!(f, "{string:?}"),
+            Token::ByteStr(string) => write!(f, "{string:?}"),
+            Token::Keyword(keyword) => write!(f, "{}", keyword),
+            Token::IntType(int_type) => write!(f, "{}", int_type),
+            Token::Assign => write!(f, "="),
+            Token::LeftParen => write!(f, "("),
+            Token::RightParen => write!(f, ")"),
+            Token::LeftBrace => write!(f, "{{"),
+            Token::RightBrace => write!(f, "}}"),
+            Token::LeftBracket => write!(f, "["),
+            Token::RightBracket => write!(f, "]"),
+            Token::Comma => write!(f, ","),
+            Token::Colon => write!(f, ":"),
+            Token::Semicolon => write!(f, ";"),
+            Token::Arrow => write!(f, "->"),
+            Token::Equal => write!(f, "=="),
+            Token::Ampersand => write!(f, "&"),
+            Token::Dash => write!(f, "-"),
+            Token::Eof => write!(f, "(end of stream)"),
+        }
+    }
+}
+
+impl std::fmt::Debug for Token {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        write!(f, "{}", self)
+    }
+}
+
+#[derive(Clone, PartialEq, Eq, Hash, PartialOrd, Ord)]
+pub(crate) enum Keyword {
+    Acir,
+    Add,
+    Allocate,
+    And,
+    ArrayGet,
+    ArraySet,
+    As,
+    At,
+    Bits,
+    Bool,
+    Brillig,
+    Call,
+    Cast,
+    Constrain,
+    Data,
+    DecRc,
+    Div,
+    Inline,
+    InlineAlways,
+    Else,
+    EnableSideEffects,
+    Eq,
+    Field,
+    Fold,
+    Fn,
+    Function,
+    IncRc,
+    Index,
+    Jmp,
+    Jmpif,
+    Load,
+    Lt,
+    MakeArray,
+    MaxBitSize,
+    Mod,
+    Mul,
+    Mut,
+    NoPredicates,
+    Not,
+    Of,
+    Or,
+    RangeCheck,
+    Return,
+    Shl,
+    Shr,
+    Store,
+    Sub,
+    Then,
+    To,
+    Truncate,
+    Value,
+    Xor,
+}
+
+impl Keyword {
+    pub(crate) fn lookup_keyword(word: &str) -> Option<Token> {
+        let keyword = match word {
+            "acir" => Keyword::Acir,
+            "add" => Keyword::Add,
+            "allocate" => Keyword::Allocate,
+            "and" => Keyword::And,
+            "array_get" => Keyword::ArrayGet,
+            "array_set" => Keyword::ArraySet,
+            "as" => Keyword::As,
+            "at" => Keyword::At,
+            "bits" => Keyword::Bits,
+            "bool" => Keyword::Bool,
+            "brillig" => Keyword::Brillig,
+            "call" => Keyword::Call,
+            "cast" => Keyword::Cast,
+            "constrain" => Keyword::Constrain,
+            "data" => Keyword::Data,
+            "dec_rc" => Keyword::DecRc,
+            "div" => Keyword::Div,
+            "else" => Keyword::Else,
+            "enable_side_effects" => Keyword::EnableSideEffects,
+            "eq" => Keyword::Eq,
+            "inline" => Keyword::Inline,
+            "inline_always" => Keyword::InlineAlways,
+            "Field" => Keyword::Field,
+            "fold" => Keyword::Fold,
+            "fn" => Keyword::Fn,
+            "function" => Keyword::Function,
+            "inc_rc" => Keyword::IncRc,
+            "index" => Keyword::Index,
+            "jmp" => Keyword::Jmp,
+            "jmpif" => Keyword::Jmpif,
+            "load" => Keyword::Load,
+            "lt" => Keyword::Lt,
+            "make_array" => Keyword::MakeArray,
+            "max_bit_size" => Keyword::MaxBitSize,
+            "mod" => Keyword::Mod,
+            "mul" => Keyword::Mul,
+            "mut" => Keyword::Mut,
+            "no_predicates" => Keyword::NoPredicates,
+            "not" => Keyword::Not,
+            "of" => Keyword::Of,
+            "or" => Keyword::Or,
+            "range_check" => Keyword::RangeCheck,
+            "return" => Keyword::Return,
+            "shl" => Keyword::Shl,
+            "shr" => Keyword::Shr,
+            "store" => Keyword::Store,
+            "sub" => Keyword::Sub,
+            "then" => Keyword::Then,
+            "to" => Keyword::To,
+            "truncate" => Keyword::Truncate,
+            "value" => Keyword::Value,
+            "xor" => Keyword::Xor,
+            _ => return None,
+        };
+        Some(Token::Keyword(keyword))
+    }
+}
+
+impl Display for Keyword {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        match self {
+            Keyword::Acir => write!(f, "acir"),
+            Keyword::Add => write!(f, "add"),
+            Keyword::Allocate => write!(f, "allocate"),
+            Keyword::And => write!(f, "and"),
+            Keyword::ArrayGet => write!(f, "array_get"),
+            Keyword::ArraySet => write!(f, "array_set"),
+            Keyword::As => write!(f, "as"),
+            Keyword::At => write!(f, "at"),
+            Keyword::Bits => write!(f, "bits"),
+            Keyword::Bool => write!(f, "bool"),
+            Keyword::Brillig => write!(f, "brillig"),
+            Keyword::Call => write!(f, "call"),
+            Keyword::Cast => write!(f, "cast"),
+            Keyword::Constrain => write!(f, "constrain"),
+            Keyword::Data => write!(f, "data"),
+            Keyword::DecRc => write!(f, "dec_rc"),
+            Keyword::Div => write!(f, "div"),
+            Keyword::Else => write!(f, "else"),
+            Keyword::EnableSideEffects => write!(f, "enable_side_effects"),
+            Keyword::Eq => write!(f, "eq"),
+            Keyword::Field => write!(f, "Field"),
+            Keyword::Fold => write!(f, "fold"),
+            Keyword::Fn => write!(f, "fn"),
+            Keyword::Function => write!(f, "function"),
+            Keyword::IncRc => write!(f, "inc_rc"),
+            Keyword::Index => write!(f, "index"),
+            Keyword::Inline => write!(f, "inline"),
+            Keyword::InlineAlways => write!(f, "inline_always"),
+            Keyword::Jmp => write!(f, "jmp"),
+            Keyword::Jmpif => write!(f, "jmpif"),
+            Keyword::Load => write!(f, "load"),
+            Keyword::Lt => write!(f, "lt"),
+            Keyword::MakeArray => write!(f, "make_array"),
+            Keyword::MaxBitSize => write!(f, "max_bit_size"),
+            Keyword::Mod => write!(f, "mod"),
+            Keyword::Mul => write!(f, "mul"),
+            Keyword::Mut => write!(f, "mut"),
+            Keyword::NoPredicates => write!(f, "no_predicates"),
+            Keyword::Not => write!(f, "not"),
+            Keyword::Of => write!(f, "of"),
+            Keyword::Or => write!(f, "or"),
+            Keyword::RangeCheck => write!(f, "range_check"),
+            Keyword::Return => write!(f, "return"),
+            Keyword::Shl => write!(f, "shl"),
+            Keyword::Shr => write!(f, "shr"),
+            Keyword::Store => write!(f, "store"),
+            Keyword::Sub => write!(f, "sub"),
+            Keyword::Then => write!(f, "then"),
+            Keyword::To => write!(f, "to"),
+            Keyword::Truncate => write!(f, "truncate"),
+            Keyword::Value => write!(f, "value"),
+            Keyword::Xor => write!(f, "xor"),
+        }
+    }
+}
diff --git a/compiler/noirc_evaluator/src/ssa/ssa_gen/context.rs b/compiler/noirc_evaluator/src/ssa/ssa_gen/context.rs
index c71c3a33edf..7807658dabb 100644
--- a/compiler/noirc_evaluator/src/ssa/ssa_gen/context.rs
+++ b/compiler/noirc_evaluator/src/ssa/ssa_gen/context.rs
@@ -19,8 +19,7 @@ use crate::ssa::ir::types::{NumericType, Type};
 use crate::ssa::ir::value::ValueId;
 
 use super::value::{Tree, Value, Values};
-use super::SSA_WORD_SIZE;
-use fxhash::FxHashMap as HashMap;
+use fxhash::{FxHashMap as HashMap, FxHashSet as HashSet};
 
 /// The FunctionContext is the main context object for translating a
 /// function into SSA form during the SSA-gen pass.
@@ -128,7 +127,7 @@ impl<'a> FunctionContext<'a> {
     ) {
         self.definitions.clear();
         if func.unconstrained || (force_brillig_runtime && func.inline_type != InlineType::Inline) {
-            self.builder.new_brillig_function(func.name.clone(), id);
+            self.builder.new_brillig_function(func.name.clone(), id, func.inline_type);
         } else {
             self.builder.new_function(func.name.clone(), id, func.inline_type);
         }
@@ -159,7 +158,8 @@ impl<'a> FunctionContext<'a> {
         let parameter_value = Self::map_type(parameter_type, |typ| {
             let value = self.builder.add_parameter(typ);
             if mutable {
-                self.new_mutable_variable(value)
+                // This will wrap any `mut var: T` in a reference and increase the rc of an array if needed
+                self.new_mutable_variable(value, true)
             } else {
                 value.into()
             }
@@ -170,8 +170,17 @@ impl<'a> FunctionContext<'a> {
 
     /// Allocate a single slot of memory and store into it the given initial value of the variable.
     /// Always returns a Value::Mutable wrapping the allocate instruction.
-    pub(super) fn new_mutable_variable(&mut self, value_to_store: ValueId) -> Value {
+    pub(super) fn new_mutable_variable(
+        &mut self,
+        value_to_store: ValueId,
+        increment_array_rc: bool,
+    ) -> Value {
         let element_type = self.builder.current_function.dfg.type_of_value(value_to_store);
+
+        if increment_array_rc {
+            self.builder.increment_array_reference_count(value_to_store);
+        }
+
         let alloc = self.builder.insert_allocate(element_type);
         self.builder.insert_store(alloc, value_to_store);
         let typ = self.builder.type_of_value(value_to_store);
@@ -236,12 +245,12 @@ impl<'a> FunctionContext<'a> {
             ast::Type::Field => Type::field(),
             ast::Type::Array(len, element) => {
                 let element_types = Self::convert_type(element).flatten();
-                Type::Array(Arc::new(element_types), *len as usize)
+                Type::Array(Arc::new(element_types), *len)
             }
             ast::Type::Integer(Signedness::Signed, bits) => Type::signed((*bits).into()),
             ast::Type::Integer(Signedness::Unsigned, bits) => Type::unsigned((*bits).into()),
             ast::Type::Bool => Type::unsigned(1),
-            ast::Type::String(len) => Type::str(*len as usize),
+            ast::Type::String(len) => Type::str(*len),
             ast::Type::FmtString(_, _) => {
                 panic!("convert_non_tuple_type called on a fmt string: {typ}")
             }
@@ -271,37 +280,33 @@ impl<'a> FunctionContext<'a> {
         &mut self,
         value: impl Into<FieldElement>,
         negative: bool,
-        typ: Type,
+        numeric_type: NumericType,
     ) -> Result<ValueId, RuntimeError> {
         let value = value.into();
 
-        if let Type::Numeric(numeric_type) = typ {
-            if let Some(range) = numeric_type.value_is_outside_limits(value, negative) {
-                let call_stack = self.builder.get_call_stack();
-                return Err(RuntimeError::IntegerOutOfBounds {
-                    value: if negative { -value } else { value },
-                    typ: numeric_type,
-                    range,
-                    call_stack,
-                });
-            }
+        if let Some(range) = numeric_type.value_is_outside_limits(value, negative) {
+            let call_stack = self.builder.get_call_stack();
+            return Err(RuntimeError::IntegerOutOfBounds {
+                value: if negative { -value } else { value },
+                typ: numeric_type,
+                range,
+                call_stack,
+            });
+        }
 
-            let value = if negative {
-                match numeric_type {
-                    NumericType::NativeField => -value,
-                    NumericType::Signed { bit_size } | NumericType::Unsigned { bit_size } => {
-                        let base = 1_u128 << bit_size;
-                        FieldElement::from(base) - value
-                    }
+        let value = if negative {
+            match numeric_type {
+                NumericType::NativeField => -value,
+                NumericType::Signed { bit_size } | NumericType::Unsigned { bit_size } => {
+                    let base = 1_u128 << bit_size;
+                    FieldElement::from(base) - value
                 }
-            } else {
-                value
-            };
-
-            Ok(self.builder.numeric_constant(value, typ))
+            }
         } else {
-            panic!("Expected type for numeric constant to be a numeric type, found {typ}");
-        }
+            value
+        };
+
+        Ok(self.builder.numeric_constant(value, numeric_type))
     }
 
     /// helper function which add instructions to the block computing the absolute value of the
@@ -310,16 +315,16 @@ impl<'a> FunctionContext<'a> {
         assert_eq!(self.builder.type_of_value(sign), Type::bool());
 
         // We compute the absolute value of lhs
-        let bit_width =
-            self.builder.numeric_constant(FieldElement::from(2_i128.pow(bit_size)), Type::field());
+        let bit_width = FieldElement::from(2_i128.pow(bit_size));
+        let bit_width = self.builder.numeric_constant(bit_width, NumericType::NativeField);
         let sign_not = self.builder.insert_not(sign);
 
         // We use unsafe casts here, this is fine as we're casting to a `field` type.
-        let as_field = self.builder.insert_cast(input, Type::field());
-        let sign_field = self.builder.insert_cast(sign, Type::field());
+        let as_field = self.builder.insert_cast(input, NumericType::NativeField);
+        let sign_field = self.builder.insert_cast(sign, NumericType::NativeField);
         let positive_predicate = self.builder.insert_binary(sign_field, BinaryOp::Mul, as_field);
         let two_complement = self.builder.insert_binary(bit_width, BinaryOp::Sub, as_field);
-        let sign_not_field = self.builder.insert_cast(sign_not, Type::field());
+        let sign_not_field = self.builder.insert_cast(sign_not, NumericType::NativeField);
         let negative_predicate =
             self.builder.insert_binary(sign_not_field, BinaryOp::Mul, two_complement);
         self.builder.insert_binary(positive_predicate, BinaryOp::Add, negative_predicate)
@@ -344,15 +349,18 @@ impl<'a> FunctionContext<'a> {
         operator: BinaryOpKind,
         location: Location,
     ) -> ValueId {
-        let result_type = self.builder.current_function.dfg.type_of_value(result);
+        let result_type = self.builder.current_function.dfg.type_of_value(result).unwrap_numeric();
         match result_type {
-            Type::Numeric(NumericType::Signed { bit_size }) => {
+            NumericType::Signed { bit_size } => {
                 match operator {
                     BinaryOpKind::Add | BinaryOpKind::Subtract => {
                         // Result is computed modulo the bit size
                         let result = self.builder.insert_truncate(result, bit_size, bit_size + 1);
-                        let result =
-                            self.insert_safe_cast(result, Type::unsigned(bit_size), location);
+                        let result = self.insert_safe_cast(
+                            result,
+                            NumericType::unsigned(bit_size),
+                            location,
+                        );
 
                         self.check_signed_overflow(result, lhs, rhs, operator, bit_size, location);
                         self.insert_safe_cast(result, result_type, location)
@@ -360,7 +368,7 @@ impl<'a> FunctionContext<'a> {
                     BinaryOpKind::Multiply => {
                         // Result is computed modulo the bit size
                         let mut result =
-                            self.builder.insert_cast(result, Type::unsigned(2 * bit_size));
+                            self.builder.insert_cast(result, NumericType::unsigned(2 * bit_size));
                         result = self.builder.insert_truncate(result, bit_size, 2 * bit_size);
 
                         self.check_signed_overflow(result, lhs, rhs, operator, bit_size, location);
@@ -372,7 +380,7 @@ impl<'a> FunctionContext<'a> {
                     _ => unreachable!("operator {} should not overflow", operator),
                 }
             }
-            Type::Numeric(NumericType::Unsigned { bit_size }) => {
+            NumericType::Unsigned { bit_size } => {
                 let dfg = &self.builder.current_function.dfg;
                 let max_lhs_bits = dfg.get_value_max_num_bits(lhs);
 
@@ -400,7 +408,7 @@ impl<'a> FunctionContext<'a> {
 
                 result
             }
-            _ => result,
+            NumericType::NativeField => result,
         }
     }
 
@@ -415,11 +423,11 @@ impl<'a> FunctionContext<'a> {
         bit_size: u32,
         location: Location,
     ) -> ValueId {
-        let one = self.builder.numeric_constant(FieldElement::one(), Type::bool());
+        let one = self.builder.numeric_constant(FieldElement::one(), NumericType::bool());
         assert!(self.builder.current_function.dfg.type_of_value(rhs) == Type::unsigned(8));
 
-        let max =
-            self.builder.numeric_constant(FieldElement::from(bit_size as i128), Type::unsigned(8));
+        let bit_size_field = FieldElement::from(bit_size as i128);
+        let max = self.builder.numeric_constant(bit_size_field, NumericType::unsigned(8));
         let overflow = self.builder.insert_binary(rhs, BinaryOp::Lt, max);
         self.builder.set_location(location).insert_constrain(
             overflow,
@@ -453,11 +461,11 @@ impl<'a> FunctionContext<'a> {
         let is_sub = operator == BinaryOpKind::Subtract;
         let half_width = self.builder.numeric_constant(
             FieldElement::from(2_i128.pow(bit_size - 1)),
-            Type::unsigned(bit_size),
+            NumericType::unsigned(bit_size),
         );
         // We compute the sign of the operands. The overflow checks for signed integers depends on these signs
-        let lhs_as_unsigned = self.insert_safe_cast(lhs, Type::unsigned(bit_size), location);
-        let rhs_as_unsigned = self.insert_safe_cast(rhs, Type::unsigned(bit_size), location);
+        let lhs_as_unsigned = self.insert_safe_cast(lhs, NumericType::unsigned(bit_size), location);
+        let rhs_as_unsigned = self.insert_safe_cast(rhs, NumericType::unsigned(bit_size), location);
         let lhs_sign = self.builder.insert_binary(lhs_as_unsigned, BinaryOp::Lt, half_width);
         let mut rhs_sign = self.builder.insert_binary(rhs_as_unsigned, BinaryOp::Lt, half_width);
         let message = if is_sub {
@@ -495,18 +503,19 @@ impl<'a> FunctionContext<'a> {
                     bit_size,
                     Some("attempt to multiply with overflow".to_string()),
                 );
-                let product = self.builder.insert_cast(product_field, Type::unsigned(bit_size));
+                let product =
+                    self.builder.insert_cast(product_field, NumericType::unsigned(bit_size));
 
                 // Then we check the signed product fits in a signed integer of bit_size-bits
                 let not_same = self.builder.insert_not(same_sign);
                 let not_same_sign_field =
-                    self.insert_safe_cast(not_same, Type::unsigned(bit_size), location);
+                    self.insert_safe_cast(not_same, NumericType::unsigned(bit_size), location);
                 let positive_maximum_with_offset =
                     self.builder.insert_binary(half_width, BinaryOp::Add, not_same_sign_field);
                 let product_overflow_check =
                     self.builder.insert_binary(product, BinaryOp::Lt, positive_maximum_with_offset);
 
-                let one = self.builder.numeric_constant(FieldElement::one(), Type::bool());
+                let one = self.builder.numeric_constant(FieldElement::one(), NumericType::bool());
                 self.builder.set_location(location).insert_constrain(
                     product_overflow_check,
                     one,
@@ -585,7 +594,7 @@ impl<'a> FunctionContext<'a> {
     pub(super) fn insert_safe_cast(
         &mut self,
         mut value: ValueId,
-        typ: Type,
+        typ: NumericType,
         location: Location,
     ) -> ValueId {
         self.builder.set_location(location);
@@ -604,7 +613,8 @@ impl<'a> FunctionContext<'a> {
     /// Create a const offset of an address for an array load or store
     pub(super) fn make_offset(&mut self, mut address: ValueId, offset: u128) -> ValueId {
         if offset != 0 {
-            let offset = self.builder.numeric_constant(offset, self.builder.type_of_value(address));
+            let typ = self.builder.type_of_value(address).unwrap_numeric();
+            let offset = self.builder.numeric_constant(offset, typ);
             address = self.builder.insert_binary(address, BinaryOp::Add, offset);
         }
         address
@@ -612,7 +622,7 @@ impl<'a> FunctionContext<'a> {
 
     /// Array indexes are u32. This function casts values used as indexes to u32.
     pub(super) fn make_array_index(&mut self, index: ValueId) -> ValueId {
-        self.builder.insert_cast(index, Type::unsigned(SSA_WORD_SIZE))
+        self.builder.insert_cast(index, NumericType::length_type())
     }
 
     /// Define a local variable to be some Values that can later be retrieved
@@ -732,10 +742,6 @@ impl<'a> FunctionContext<'a> {
         let element_types = Self::convert_type(element_type);
         values.map_both(element_types, |value, element_type| {
             let reference = value.eval_reference();
-            // Reference counting in brillig relies on us incrementing reference
-            // counts when arrays/slices are constructed or indexed.
-            // Thus, if we dereference an lvalue which happens to be array/slice we should increment its reference counter.
-            self.builder.increment_array_reference_count(reference);
             self.builder.insert_load(reference, element_type).into()
         })
     }
@@ -864,12 +870,12 @@ impl<'a> FunctionContext<'a> {
     ) -> ValueId {
         let index = self.make_array_index(index);
         let element_size =
-            self.builder.numeric_constant(self.element_size(array), Type::unsigned(SSA_WORD_SIZE));
+            self.builder.numeric_constant(self.element_size(array), NumericType::length_type());
 
         // The actual base index is the user's index * the array element type's size
         let mut index =
             self.builder.set_location(location).insert_binary(index, BinaryOp::Mul, element_size);
-        let one = self.builder.numeric_constant(FieldElement::one(), Type::unsigned(SSA_WORD_SIZE));
+        let one = self.builder.numeric_constant(FieldElement::one(), NumericType::length_type());
 
         new_value.for_each(|value| {
             let value = value.eval(self);
@@ -907,33 +913,55 @@ impl<'a> FunctionContext<'a> {
         }
     }
 
-    /// Increments the reference count of all parameters. Returns the entry block of the function.
+    /// Increments the reference count of mutable reference array parameters.
+    /// Any mutable-value (`mut a: [T; N]` versus `a: &mut [T; N]`) are already incremented
+    /// by `FunctionBuilder::add_parameter_to_scope`.
+    /// Returns each array id that was incremented.
     ///
     /// This is done on parameters rather than call arguments so that we can optimize out
     /// paired inc/dec instructions within brillig functions more easily.
-    pub(crate) fn increment_parameter_rcs(&mut self) -> BasicBlockId {
+    pub(crate) fn increment_parameter_rcs(&mut self) -> HashSet<ValueId> {
         let entry = self.builder.current_function.entry_block();
         let parameters = self.builder.current_function.dfg.block_parameters(entry).to_vec();
 
+        let mut incremented = HashSet::default();
+        let mut seen_array_types = HashSet::default();
+
         for parameter in parameters {
-            self.builder.increment_array_reference_count(parameter);
+            // Avoid reference counts for immutable arrays that aren't behind references.
+            let typ = self.builder.current_function.dfg.type_of_value(parameter);
+
+            if let Type::Reference(element) = typ {
+                if element.contains_an_array() {
+                    // If we haven't already seen this array type, the value may be possibly
+                    // aliased, so issue an inc_rc for it.
+                    if !seen_array_types.insert(element.get_contained_array().clone())
+                        && self.builder.increment_array_reference_count(parameter)
+                    {
+                        incremented.insert(parameter);
+                    }
+                }
+            }
         }
 
-        entry
+        incremented
     }
 
     /// Ends a local scope of a function.
     /// This will issue DecrementRc instructions for any arrays in the given starting scope
     /// block's parameters. Arrays that are also used in terminator instructions for the scope are
     /// ignored.
-    pub(crate) fn end_scope(&mut self, scope: BasicBlockId, terminator_args: &[ValueId]) {
-        let mut dropped_parameters =
-            self.builder.current_function.dfg.block_parameters(scope).to_vec();
-
-        dropped_parameters.retain(|parameter| !terminator_args.contains(parameter));
+    pub(crate) fn end_scope(
+        &mut self,
+        mut incremented_params: HashSet<ValueId>,
+        terminator_args: &[ValueId],
+    ) {
+        incremented_params.retain(|parameter| !terminator_args.contains(parameter));
 
-        for parameter in dropped_parameters {
-            self.builder.decrement_array_reference_count(parameter);
+        for parameter in incremented_params {
+            if self.builder.current_function.dfg.value_is_reference(parameter) {
+                self.builder.decrement_array_reference_count(parameter);
+            }
         }
     }
 
diff --git a/compiler/noirc_evaluator/src/ssa/ssa_gen/mod.rs b/compiler/noirc_evaluator/src/ssa/ssa_gen/mod.rs
index 2318fea8960..536f2cdb477 100644
--- a/compiler/noirc_evaluator/src/ssa/ssa_gen/mod.rs
+++ b/compiler/noirc_evaluator/src/ssa/ssa_gen/mod.rs
@@ -2,6 +2,7 @@ pub(crate) mod context;
 mod program;
 mod value;
 
+use noirc_frontend::token::FmtStrFragment;
 pub(crate) use program::Ssa;
 
 use context::SharedContext;
@@ -21,7 +22,8 @@ use self::{
     value::{Tree, Values},
 };
 
-use super::ir::instruction::error_selector_from_type;
+use super::ir::instruction::ErrorType;
+use super::ir::types::NumericType;
 use super::{
     function_builder::data_bus::DataBus,
     ir::{
@@ -58,7 +60,7 @@ pub(crate) fn generate_ssa(
         main.name.clone(),
         &main.parameters,
         if force_brillig_runtime || main.unconstrained {
-            RuntimeType::Brillig
+            RuntimeType::Brillig(main.inline_type)
         } else {
             RuntimeType::Acir(main.inline_type)
         },
@@ -125,10 +127,10 @@ impl<'a> FunctionContext<'a> {
     /// Codegen a function's body and set its return value to that of its last parameter.
     /// For functions returning nothing, this will be an empty list.
     fn codegen_function_body(&mut self, body: &Expression) -> Result<(), RuntimeError> {
-        let entry_block = self.increment_parameter_rcs();
+        let incremented_params = self.increment_parameter_rcs();
         let return_value = self.codegen_expression(body)?;
         let results = return_value.into_value_list(self);
-        self.end_scope(entry_block, &results);
+        self.end_scope(incremented_params, &results);
 
         self.builder.terminate_with_return(results);
         Ok(())
@@ -195,8 +197,7 @@ impl<'a> FunctionContext<'a> {
     fn codegen_literal(&mut self, literal: &ast::Literal) -> Result<Values, RuntimeError> {
         match literal {
             ast::Literal::Array(array) => {
-                let elements =
-                    try_vecmap(&array.contents, |element| self.codegen_expression(element))?;
+                let elements = self.codegen_array_elements(&array.contents)?;
 
                 let typ = Self::convert_type(&array.typ).flatten();
                 Ok(match array.typ {
@@ -207,8 +208,7 @@ impl<'a> FunctionContext<'a> {
                 })
             }
             ast::Literal::Slice(array) => {
-                let elements =
-                    try_vecmap(&array.contents, |element| self.codegen_expression(element))?;
+                let elements = self.codegen_array_elements(&array.contents)?;
 
                 let typ = Self::convert_type(&array.typ).flatten();
                 Ok(match array.typ {
@@ -224,18 +224,34 @@ impl<'a> FunctionContext<'a> {
             }
             ast::Literal::Integer(value, negative, typ, location) => {
                 self.builder.set_location(*location);
-                let typ = Self::convert_non_tuple_type(typ);
+                let typ = Self::convert_non_tuple_type(typ).unwrap_numeric();
                 self.checked_numeric_constant(*value, *negative, typ).map(Into::into)
             }
             ast::Literal::Bool(value) => {
                 // Don't need to call checked_numeric_constant here since `value` can only be true or false
-                Ok(self.builder.numeric_constant(*value as u128, Type::bool()).into())
+                Ok(self.builder.numeric_constant(*value as u128, NumericType::bool()).into())
             }
             ast::Literal::Str(string) => Ok(self.codegen_string(string)),
-            ast::Literal::FmtStr(string, number_of_fields, fields) => {
+            ast::Literal::FmtStr(fragments, number_of_fields, fields) => {
+                let mut string = String::new();
+                for fragment in fragments {
+                    match fragment {
+                        FmtStrFragment::String(value) => {
+                            // Escape curly braces in non-interpolations
+                            let value = value.replace('{', "{{").replace('}', "}}");
+                            string.push_str(&value);
+                        }
+                        FmtStrFragment::Interpolation(value, _span) => {
+                            string.push('{');
+                            string.push_str(value);
+                            string.push('}');
+                        }
+                    }
+                }
+
                 // A caller needs multiple pieces of information to make use of a format string
                 // The message string, the number of fields to be formatted, and the fields themselves
-                let string = self.codegen_string(string);
+                let string = self.codegen_string(&string);
                 let field_count = self.builder.length_constant(*number_of_fields as u128);
                 let fields = self.codegen_expression(fields)?;
 
@@ -245,18 +261,33 @@ impl<'a> FunctionContext<'a> {
         }
     }
 
+    fn codegen_array_elements(
+        &mut self,
+        elements: &[Expression],
+    ) -> Result<Vec<(Values, bool)>, RuntimeError> {
+        try_vecmap(elements, |element| {
+            let value = self.codegen_expression(element)?;
+            Ok((value, element.is_array_or_slice_literal()))
+        })
+    }
+
     fn codegen_string(&mut self, string: &str) -> Values {
         let elements = vecmap(string.as_bytes(), |byte| {
-            self.builder.numeric_constant(*byte as u128, Type::unsigned(8)).into()
+            let char = self.builder.numeric_constant(*byte as u128, NumericType::char());
+            (char.into(), false)
         });
         let typ = Self::convert_non_tuple_type(&ast::Type::String(elements.len() as u32));
         self.codegen_array(elements, typ)
     }
 
     // Codegen an array but make sure that we do not have a nested slice
+    ///
+    /// The bool aspect of each array element indicates whether the element is an array constant
+    /// or not. If it is, we avoid incrementing the reference count because we consider the
+    /// constant to be moved into this larger array constant.
     fn codegen_array_checked(
         &mut self,
-        elements: Vec<Values>,
+        elements: Vec<(Values, bool)>,
         typ: Type,
     ) -> Result<Values, RuntimeError> {
         if typ.is_nested_slice() {
@@ -273,11 +304,15 @@ impl<'a> FunctionContext<'a> {
     /// stored next to the other fields in memory. So an array such as [(1, 2), (3, 4)] is
     /// stored the same as the array [1, 2, 3, 4].
     ///
+    /// The bool aspect of each array element indicates whether the element is an array constant
+    /// or not. If it is, we avoid incrementing the reference count because we consider the
+    /// constant to be moved into this larger array constant.
+    ///
     /// The value returned from this function is always that of the allocate instruction.
-    fn codegen_array(&mut self, elements: Vec<Values>, typ: Type) -> Values {
+    fn codegen_array(&mut self, elements: Vec<(Values, bool)>, typ: Type) -> Values {
         let mut array = im::Vector::new();
 
-        for element in elements {
+        for (element, is_array_constant) in elements {
             element.for_each(|element| {
                 let element = element.eval(self);
 
@@ -286,12 +321,15 @@ impl<'a> FunctionContext<'a> {
                 // pessimistic reference count (since some are likely moved rather than shared)
                 // which is important for Brillig's copy on write optimization. This has no
                 // effect in ACIR code.
-                self.builder.increment_array_reference_count(element);
+                if !is_array_constant {
+                    self.builder.increment_array_reference_count(element);
+                }
+
                 array.push_back(element);
             });
         }
 
-        self.builder.array_constant(array, typ).into()
+        self.builder.insert_make_array(array, typ).into()
     }
 
     fn codegen_block(&mut self, block: &[Expression]) -> Result<Values, RuntimeError> {
@@ -312,7 +350,7 @@ impl<'a> FunctionContext<'a> {
             UnaryOp::Minus => {
                 let rhs = self.codegen_expression(&unary.rhs)?;
                 let rhs = rhs.into_leaf().eval(self);
-                let typ = self.builder.type_of_value(rhs);
+                let typ = self.builder.type_of_value(rhs).unwrap_numeric();
                 let zero = self.builder.numeric_constant(0u128, typ);
                 Ok(self.insert_binary(
                     zero,
@@ -406,7 +444,7 @@ impl<'a> FunctionContext<'a> {
         let index = self.make_array_index(index);
         let type_size = Self::convert_type(element_type).size_of_type();
         let type_size =
-            self.builder.numeric_constant(type_size as u128, Type::unsigned(SSA_WORD_SIZE));
+            self.builder.numeric_constant(type_size as u128, NumericType::length_type());
         let base_index =
             self.builder.set_location(location).insert_binary(index, BinaryOp::Mul, type_size);
 
@@ -445,7 +483,7 @@ impl<'a> FunctionContext<'a> {
             .make_array_index(length.expect("ICE: a length must be supplied for indexing slices"));
 
         let is_offset_out_of_bounds = self.builder.insert_binary(index, BinaryOp::Lt, array_len);
-        let true_const = self.builder.numeric_constant(true, Type::bool());
+        let true_const = self.builder.numeric_constant(true, NumericType::bool());
 
         self.builder.insert_constrain(
             is_offset_out_of_bounds,
@@ -456,7 +494,7 @@ impl<'a> FunctionContext<'a> {
 
     fn codegen_cast(&mut self, cast: &ast::Cast) -> Result<Values, RuntimeError> {
         let lhs = self.codegen_non_tuple_expression(&cast.lhs)?;
-        let typ = Self::convert_non_tuple_type(&cast.r#type);
+        let typ = Self::convert_non_tuple_type(&cast.r#type).unwrap_numeric();
 
         Ok(self.insert_safe_cast(lhs, typ, cast.location).into())
     }
@@ -466,6 +504,7 @@ impl<'a> FunctionContext<'a> {
     ///
     /// For example, the loop `for i in start .. end { body }` is codegen'd as:
     ///
+    /// ```text
     ///   v0 = ... codegen start ...
     ///   v1 = ... codegen end ...
     ///   br loop_entry(v0)
@@ -478,6 +517,7 @@ impl<'a> FunctionContext<'a> {
     ///   br loop_entry(v4)
     /// loop_end():
     ///   ... This is the current insert point after codegen_for finishes ...
+    /// ```
     fn codegen_for(&mut self, for_expr: &ast::For) -> Result<Values, RuntimeError> {
         let loop_entry = self.builder.insert_block();
         let loop_body = self.builder.insert_block();
@@ -529,6 +569,7 @@ impl<'a> FunctionContext<'a> {
     ///
     /// For example, the expression `if cond { a } else { b }` is codegen'd as:
     ///
+    /// ```text
     ///   v0 = ... codegen cond ...
     ///   brif v0, then: then_block, else: else_block
     /// then_block():
@@ -539,16 +580,19 @@ impl<'a> FunctionContext<'a> {
     ///   br end_if(v2)
     /// end_if(v3: ?):  // Type of v3 matches the type of a and b
     ///   ... This is the current insert point after codegen_if finishes ...
+    /// ```
     ///
     /// As another example, the expression `if cond { a }` is codegen'd as:
     ///
+    /// ```text
     ///   v0 = ... codegen cond ...
-    ///   brif v0, then: then_block, else: end_block
+    ///   brif v0, then: then_block, else: end_if
     /// then_block:
     ///   v1 = ... codegen a ...
     ///   br end_if()
     /// end_if:  // No block parameter is needed. Without an else, the unit value is always returned.
     ///   ... This is the current insert point after codegen_if finishes ...
+    /// ```
     fn codegen_if(&mut self, if_expr: &ast::If) -> Result<Values, RuntimeError> {
         let condition = self.codegen_non_tuple_expression(&if_expr.condition)?;
 
@@ -656,15 +700,24 @@ impl<'a> FunctionContext<'a> {
     fn codegen_let(&mut self, let_expr: &ast::Let) -> Result<Values, RuntimeError> {
         let mut values = self.codegen_expression(&let_expr.expression)?;
 
+        // Don't mutate the reference count if we're assigning an array literal to a Let:
+        // `let mut foo = [1, 2, 3];`
+        // we consider the array to be moved, so we should have an initial rc of just 1.
+        //
+        // TODO: this exception breaks #6763
+        let should_inc_rc = true; // !let_expr.expression.is_array_or_slice_literal();
+
         values = values.map(|value| {
             let value = value.eval(self);
 
-            // Make sure to increment array reference counts on each let binding
-            self.builder.increment_array_reference_count(value);
-
             Tree::Leaf(if let_expr.mutable {
-                self.new_mutable_variable(value)
+                self.new_mutable_variable(value, should_inc_rc)
             } else {
+                // `new_mutable_variable` increments rcs internally so we have to
+                // handle it separately for the immutable case
+                if should_inc_rc {
+                    self.builder.increment_array_reference_count(value);
+                }
                 value::Value::Normal(value)
             })
         });
@@ -680,7 +733,7 @@ impl<'a> FunctionContext<'a> {
         assert_payload: &Option<Box<(Expression, HirType)>>,
     ) -> Result<Values, RuntimeError> {
         let expr = self.codegen_non_tuple_expression(expr)?;
-        let true_literal = self.builder.numeric_constant(true, Type::bool());
+        let true_literal = self.builder.numeric_constant(true, NumericType::bool());
 
         // Set the location here for any errors that may occur when we codegen the assert message
         self.builder.set_location(location);
@@ -701,33 +754,36 @@ impl<'a> FunctionContext<'a> {
         assert_message: &Option<Box<(Expression, HirType)>>,
     ) -> Result<Option<ConstrainError>, RuntimeError> {
         let Some(assert_message_payload) = assert_message else { return Ok(None) };
-
-        if let Expression::Literal(ast::Literal::Str(static_string)) = &assert_message_payload.0 {
-            return Ok(Some(ConstrainError::StaticString(static_string.clone())));
-        }
-
         let (assert_message_expression, assert_message_typ) = assert_message_payload.as_ref();
 
-        let values = self.codegen_expression(assert_message_expression)?.into_value_list(self);
-
-        let error_type_id = error_selector_from_type(assert_message_typ);
-        // Do not record string errors in the ABI
-        match assert_message_typ {
-            HirType::String(_) => {}
-            _ => {
-                self.builder.record_error_type(error_type_id, assert_message_typ.clone());
+        if let Expression::Literal(ast::Literal::Str(static_string)) = assert_message_expression {
+            Ok(Some(ConstrainError::StaticString(static_string.clone())))
+        } else {
+            let error_type = ErrorType::Dynamic(assert_message_typ.clone());
+            let selector = error_type.selector();
+            let values = self.codegen_expression(assert_message_expression)?.into_value_list(self);
+            let is_string_type = matches!(assert_message_typ, HirType::String(_));
+            // Record custom types in the builder, outside of SSA instructions
+            // This is made to avoid having Hir types in the SSA code.
+            if !is_string_type {
+                self.builder.record_error_type(selector, assert_message_typ.clone());
             }
-        };
-        Ok(Some(ConstrainError::Dynamic(error_type_id, values)))
+
+            Ok(Some(ConstrainError::Dynamic(selector, is_string_type, values)))
+        }
     }
 
     fn codegen_assign(&mut self, assign: &ast::Assign) -> Result<Values, RuntimeError> {
         let lhs = self.extract_current_value(&assign.lvalue)?;
         let rhs = self.codegen_expression(&assign.expression)?;
+        let should_inc_rc = !assign.expression.is_array_or_slice_literal();
 
         rhs.clone().for_each(|value| {
             let value = value.eval(self);
-            self.builder.increment_array_reference_count(value);
+
+            if should_inc_rc {
+                self.builder.increment_array_reference_count(value);
+            }
         });
 
         self.assign_new_value(lhs, rhs);
diff --git a/compiler/noirc_evaluator/src/ssa/ssa_gen/program.rs b/compiler/noirc_evaluator/src/ssa/ssa_gen/program.rs
index fe786da16ca..de01a4596ad 100644
--- a/compiler/noirc_evaluator/src/ssa/ssa_gen/program.rs
+++ b/compiler/noirc_evaluator/src/ssa/ssa_gen/program.rs
@@ -25,7 +25,7 @@ pub(crate) struct Ssa {
     /// This mapping is necessary to use the correct function pointer for an ACIR call,
     /// as the final program artifact will be a list of only entry point functions.
     #[serde(skip)]
-    pub(crate) entry_point_to_generated_index: BTreeMap<FunctionId, u32>,
+    entry_point_to_generated_index: BTreeMap<FunctionId, u32>,
     // We can skip serializing this field as the error selector types end up as part of the
     // ABI not the actual SSA IR.
     #[serde(skip)]
@@ -47,25 +47,11 @@ impl Ssa {
             (f.id(), f)
         });
 
-        let entry_point_to_generated_index = btree_map(
-            functions
-                .iter()
-                .filter(|(_, func)| {
-                    let runtime = func.runtime();
-                    match func.runtime() {
-                        RuntimeType::Acir(_) => runtime.is_entry_point() || func.id() == main_id,
-                        RuntimeType::Brillig => false,
-                    }
-                })
-                .enumerate(),
-            |(i, (id, _))| (*id, i as u32),
-        );
-
         Self {
             functions,
             main_id,
             next_id: AtomicCounter::starting_after(max_id),
-            entry_point_to_generated_index,
+            entry_point_to_generated_index: BTreeMap::new(),
             error_selector_to_type: error_types,
         }
     }
@@ -98,6 +84,33 @@ impl Ssa {
         self.functions.insert(new_id, function);
         new_id
     }
+    pub(crate) fn generate_entry_point_index(mut self) -> Self {
+        self.entry_point_to_generated_index = btree_map(
+            self.functions
+                .iter()
+                .filter(|(_, func)| {
+                    let runtime = func.runtime();
+                    match func.runtime() {
+                        RuntimeType::Acir(_) => {
+                            runtime.is_entry_point() || func.id() == self.main_id
+                        }
+                        RuntimeType::Brillig(_) => false,
+                    }
+                })
+                .enumerate(),
+            |(i, (id, _))| (*id, i as u32),
+        );
+        self
+    }
+
+    pub(crate) fn get_entry_point_index(&self, func_id: &FunctionId) -> Option<u32> {
+        // Ensure the map has been initialized
+        assert!(
+            !self.entry_point_to_generated_index.is_empty(),
+            "Trying to read uninitialized entry point index"
+        );
+        self.entry_point_to_generated_index.get(func_id).copied()
+    }
 }
 
 impl Display for Ssa {
diff --git a/compiler/noirc_frontend/Cargo.toml b/compiler/noirc_frontend/Cargo.toml
index 510cff08dec..5f8f02689c8 100644
--- a/compiler/noirc_frontend/Cargo.toml
+++ b/compiler/noirc_frontend/Cargo.toml
@@ -16,7 +16,6 @@ noirc_errors.workspace = true
 noirc_printable_type.workspace = true
 fm.workspace = true
 iter-extended.workspace = true
-chumsky.workspace = true
 thiserror.workspace = true
 smol_str.workspace = true
 im.workspace = true
@@ -26,17 +25,18 @@ num-bigint.workspace = true
 num-traits.workspace = true
 rustc-hash = "1.1.0"
 small-ord-set = "0.1.3"
-regex = "1.9.1"
 cfg-if.workspace = true
 tracing.workspace = true
 petgraph = "0.6"
 rangemap = "1.4.0"
-strum = "0.24"
-strum_macros = "0.24"
+strum.workspace = true
+strum_macros.workspace = true
 
 
 [dev-dependencies]
 base64.workspace = true
+proptest.workspace = true
+proptest-derive = "0.5.0"
 
 [features]
 experimental_parser = []
diff --git a/compiler/noirc_frontend/proptest-regressions/hir_def/types/arithmetic.txt b/compiler/noirc_frontend/proptest-regressions/hir_def/types/arithmetic.txt
new file mode 100644
index 00000000000..80f5c7f1ead
--- /dev/null
+++ b/compiler/noirc_frontend/proptest-regressions/hir_def/types/arithmetic.txt
@@ -0,0 +1,7 @@
+# Seeds for failure cases proptest has generated in the past. It is
+# automatically read and these particular cases re-run before any
+# novel cases are generated.
+#
+# It is recommended to check this file in to source control so that
+# everyone who runs the test benefits from these saved cases.
+cc fc27f4091dfa5f938973048209b5fcf22aefa1cfaffaaa3e349f30e9b1f93f49 # shrinks to infix_and_bindings = (((0: numeric bool) % (Numeric(Shared(RefCell { value: Unbound('2, Numeric(bool)) }): bool) + Numeric(Shared(RefCell { value: Unbound('0, Numeric(bool)) }): bool))), [('0, (0: numeric bool)), ('1, (0: numeric bool)), ('2, (0: numeric bool))])
diff --git a/compiler/noirc_frontend/proptest-regressions/tests/arithmetic_generics.txt b/compiler/noirc_frontend/proptest-regressions/tests/arithmetic_generics.txt
new file mode 100644
index 00000000000..80f5c7f1ead
--- /dev/null
+++ b/compiler/noirc_frontend/proptest-regressions/tests/arithmetic_generics.txt
@@ -0,0 +1,7 @@
+# Seeds for failure cases proptest has generated in the past. It is
+# automatically read and these particular cases re-run before any
+# novel cases are generated.
+#
+# It is recommended to check this file in to source control so that
+# everyone who runs the test benefits from these saved cases.
+cc fc27f4091dfa5f938973048209b5fcf22aefa1cfaffaaa3e349f30e9b1f93f49 # shrinks to infix_and_bindings = (((0: numeric bool) % (Numeric(Shared(RefCell { value: Unbound('2, Numeric(bool)) }): bool) + Numeric(Shared(RefCell { value: Unbound('0, Numeric(bool)) }): bool))), [('0, (0: numeric bool)), ('1, (0: numeric bool)), ('2, (0: numeric bool))])
diff --git a/compiler/noirc_frontend/src/ast/expression.rs b/compiler/noirc_frontend/src/ast/expression.rs
index 7b0a6d028de..ae622f46686 100644
--- a/compiler/noirc_frontend/src/ast/expression.rs
+++ b/compiler/noirc_frontend/src/ast/expression.rs
@@ -1,14 +1,16 @@
 use std::borrow::Cow;
 use std::fmt::Display;
 
+use thiserror::Error;
+
 use crate::ast::{
     Ident, ItemVisibility, Path, Pattern, Recoverable, Statement, StatementKind,
     UnresolvedTraitConstraint, UnresolvedType, UnresolvedTypeData, Visibility,
 };
-use crate::hir::def_collector::errors::DefCollectorErrorKind;
-use crate::macros_api::StructId;
-use crate::node_interner::{ExprId, InternedExpressionKind, InternedStatementKind, QuotedTypeId};
-use crate::token::{Attributes, FunctionAttribute, Token, Tokens};
+use crate::node_interner::{
+    ExprId, InternedExpressionKind, InternedStatementKind, QuotedTypeId, StructId,
+};
+use crate::token::{Attributes, FmtStrFragment, FunctionAttribute, Token, Tokens};
 use crate::{Kind, Type};
 use acvm::{acir::AcirField, FieldElement};
 use iter_extended::vecmap;
@@ -75,6 +77,13 @@ pub enum UnresolvedGeneric {
     Resolved(QuotedTypeId, Span),
 }
 
+#[derive(Error, PartialEq, Eq, Debug, Clone)]
+#[error("The only supported types of numeric generics are integers, fields, and booleans")]
+pub struct UnsupportedNumericGenericType {
+    pub ident: Ident,
+    pub typ: UnresolvedTypeData,
+}
+
 impl UnresolvedGeneric {
     pub fn span(&self) -> Span {
         match self {
@@ -84,12 +93,12 @@ impl UnresolvedGeneric {
         }
     }
 
-    pub fn kind(&self) -> Result<Kind, DefCollectorErrorKind> {
+    pub fn kind(&self) -> Result<Kind, UnsupportedNumericGenericType> {
         match self {
             UnresolvedGeneric::Variable(_) => Ok(Kind::Normal),
             UnresolvedGeneric::Numeric { typ, .. } => {
                 let typ = self.resolve_numeric_kind_type(typ)?;
-                Ok(Kind::Numeric(Box::new(typ)))
+                Ok(Kind::numeric(typ))
             }
             UnresolvedGeneric::Resolved(..) => {
                 panic!("Don't know the kind of a resolved generic here")
@@ -100,14 +109,14 @@ impl UnresolvedGeneric {
     fn resolve_numeric_kind_type(
         &self,
         typ: &UnresolvedType,
-    ) -> Result<Type, DefCollectorErrorKind> {
+    ) -> Result<Type, UnsupportedNumericGenericType> {
         use crate::ast::UnresolvedTypeData::{FieldElement, Integer};
 
         match typ.typ {
             FieldElement => Ok(Type::FieldElement),
             Integer(sign, bits) => Ok(Type::Integer(sign, bits)),
             // Only fields and integers are supported for numeric kinds
-            _ => Err(DefCollectorErrorKind::UnsupportedNumericGenericType {
+            _ => Err(UnsupportedNumericGenericType {
                 ident: self.ident().clone(),
                 typ: typ.typ.clone(),
             }),
@@ -201,8 +210,8 @@ impl ExpressionKind {
         ExpressionKind::Literal(Literal::RawStr(contents, hashes))
     }
 
-    pub fn format_string(contents: String) -> ExpressionKind {
-        ExpressionKind::Literal(Literal::FmtStr(contents))
+    pub fn format_string(fragments: Vec<FmtStrFragment>, length: u32) -> ExpressionKind {
+        ExpressionKind::Literal(Literal::FmtStr(fragments, length))
     }
 
     pub fn constructor(
@@ -300,6 +309,7 @@ impl Expression {
 pub type BinaryOp = Spanned<BinaryOpKind>;
 
 #[derive(PartialEq, PartialOrd, Eq, Ord, Hash, Debug, Copy, Clone)]
+#[cfg_attr(test, derive(strum_macros::EnumIter))]
 pub enum BinaryOpKind {
     Add,
     Subtract,
@@ -424,7 +434,7 @@ pub enum Literal {
     Integer(FieldElement, /*sign*/ bool), // false for positive integer and true for negative
     Str(String),
     RawStr(String, u8),
-    FmtStr(String),
+    FmtStr(Vec<FmtStrFragment>, u32 /* length */),
     Unit,
 }
 
@@ -494,7 +504,7 @@ impl FunctionDefinition {
     }
 
     pub fn is_test(&self) -> bool {
-        if let Some(attribute) = &self.attributes.function {
+        if let Some(attribute) = self.attributes.function() {
             matches!(attribute, FunctionAttribute::Test(..))
         } else {
             false
@@ -659,7 +669,13 @@ impl Display for Literal {
                     std::iter::once('#').cycle().take(*num_hashes as usize).collect();
                 write!(f, "r{hashes}\"{string}\"{hashes}")
             }
-            Literal::FmtStr(string) => write!(f, "f\"{string}\""),
+            Literal::FmtStr(fragments, _length) => {
+                write!(f, "f\"")?;
+                for fragment in fragments {
+                    fragment.fmt(f)?;
+                }
+                write!(f, "\"")
+            }
             Literal::Unit => write!(f, "()"),
         }
     }
@@ -792,8 +808,8 @@ impl Display for AsTraitPath {
 impl Display for TypePath {
     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
         write!(f, "{}::{}", self.typ, self.item)?;
-        if !self.turbofish.is_empty() {
-            write!(f, "::{}", self.turbofish)?;
+        if let Some(turbofish) = &self.turbofish {
+            write!(f, "::{}", turbofish)?;
         }
         Ok(())
     }
@@ -864,7 +880,7 @@ impl FunctionDefinition {
 impl Display for FunctionDefinition {
     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
         writeln!(f, "{:?}", self.attributes)?;
-        write!(f, "fn {} {}", self.signature(), self.body)
+        write!(f, "{} {}", self.signature(), self.body)
     }
 }
 
diff --git a/compiler/noirc_frontend/src/ast/function.rs b/compiler/noirc_frontend/src/ast/function.rs
index 4f55e4c2c76..99ae78c93ea 100644
--- a/compiler/noirc_frontend/src/ast/function.rs
+++ b/compiler/noirc_frontend/src/ast/function.rs
@@ -29,14 +29,13 @@ pub enum FunctionKind {
     Builtin,
     Normal,
     Oracle,
-    Recursive,
 }
 
 impl FunctionKind {
     pub fn can_ignore_return_type(self) -> bool {
         match self {
             FunctionKind::LowLevel | FunctionKind::Builtin | FunctionKind::Oracle => true,
-            FunctionKind::Normal | FunctionKind::Recursive => false,
+            FunctionKind::Normal => false,
         }
     }
 }
@@ -78,7 +77,7 @@ impl NoirFunction {
         &self.def.attributes
     }
     pub fn function_attribute(&self) -> Option<&FunctionAttribute> {
-        self.def.attributes.function.as_ref()
+        self.def.attributes.function()
     }
     pub fn secondary_attributes(&self) -> &[SecondaryAttribute] {
         self.def.attributes.secondary.as_ref()
@@ -109,14 +108,14 @@ impl NoirFunction {
 impl From<FunctionDefinition> for NoirFunction {
     fn from(fd: FunctionDefinition) -> Self {
         // The function type is determined by the existence of a function attribute
-        let kind = match fd.attributes.function {
+        let kind = match fd.attributes.function() {
             Some(FunctionAttribute::Builtin(_)) => FunctionKind::Builtin,
             Some(FunctionAttribute::Foreign(_)) => FunctionKind::LowLevel,
             Some(FunctionAttribute::Test { .. }) => FunctionKind::Normal,
             Some(FunctionAttribute::Oracle(_)) => FunctionKind::Oracle,
-            Some(FunctionAttribute::Recursive) => FunctionKind::Recursive,
             Some(FunctionAttribute::Fold) => FunctionKind::Normal,
             Some(FunctionAttribute::NoPredicates) => FunctionKind::Normal,
+            Some(FunctionAttribute::InlineAlways) => FunctionKind::Normal,
             None => FunctionKind::Normal,
         };
 
diff --git a/compiler/noirc_frontend/src/ast/mod.rs b/compiler/noirc_frontend/src/ast/mod.rs
index 94e81b19582..35e57cd4528 100644
--- a/compiler/noirc_frontend/src/ast/mod.rs
+++ b/compiler/noirc_frontend/src/ast/mod.rs
@@ -19,6 +19,10 @@ pub use visitor::Visitor;
 pub use expression::*;
 pub use function::*;
 
+#[cfg(test)]
+use proptest_derive::Arbitrary;
+
+use acvm::FieldElement;
 pub use docs::*;
 use noirc_errors::Span;
 use serde::{Deserialize, Serialize};
@@ -36,6 +40,7 @@ use crate::{
 use acvm::acir::AcirField;
 use iter_extended::vecmap;
 
+#[cfg_attr(test, derive(Arbitrary))]
 #[derive(Debug, PartialEq, Eq, Clone, Copy, Hash, Ord, PartialOrd)]
 pub enum IntegerBitSize {
     One,
@@ -172,6 +177,12 @@ pub enum GenericTypeArg {
     Named(Ident, UnresolvedType),
 }
 
+#[derive(Debug, PartialEq, Eq, Clone, Hash)]
+pub enum GenericTypeArgKind {
+    Ordered,
+    Named,
+}
+
 #[derive(Debug, Default, PartialEq, Eq, Clone, Hash)]
 pub struct GenericTypeArgs {
     /// Each ordered argument, e.g. `<A, B, C>`
@@ -180,12 +191,23 @@ pub struct GenericTypeArgs {
     /// All named arguments, e.g. `<A = B, C = D, E = F>`.
     /// Used for associated types.
     pub named_args: Vec<(Ident, UnresolvedType)>,
+
+    /// The kind of each argument, in order (in case traversing the generics in order is needed)
+    pub kinds: Vec<GenericTypeArgKind>,
 }
 
 impl GenericTypeArgs {
     pub fn is_empty(&self) -> bool {
         self.ordered_args.is_empty() && self.named_args.is_empty()
     }
+
+    fn contains_unspecified(&self) -> bool {
+        let ordered_args_contains_unspecified =
+            self.ordered_args.iter().any(|ordered_arg| ordered_arg.contains_unspecified());
+        let named_args_contains_unspecified =
+            self.named_args.iter().any(|(_name, named_arg)| named_arg.contains_unspecified());
+        ordered_args_contains_unspecified || named_args_contains_unspecified
+    }
 }
 
 impl From<Vec<GenericTypeArg>> for GenericTypeArgs {
@@ -219,7 +241,7 @@ pub struct UnaryRhsMethodCall {
 #[derive(Debug, PartialEq, Eq, Clone, Hash)]
 pub enum UnresolvedTypeExpression {
     Variable(Path),
-    Constant(u32, Span),
+    Constant(FieldElement, Span),
     BinaryOperation(
         Box<UnresolvedTypeExpression>,
         BinaryTypeOperator,
@@ -350,13 +372,21 @@ impl UnresolvedType {
         let last_segment = path.segments.last_mut().unwrap();
         let generics = last_segment.generics.take();
         let generic_type_args = if let Some(generics) = generics {
-            GenericTypeArgs { ordered_args: generics, named_args: Vec::new() }
+            let mut kinds = Vec::with_capacity(generics.len());
+            for _ in 0..generics.len() {
+                kinds.push(GenericTypeArgKind::Ordered);
+            }
+            GenericTypeArgs { ordered_args: generics, named_args: Vec::new(), kinds }
         } else {
             GenericTypeArgs::default()
         };
         let typ = UnresolvedTypeData::Named(path, generic_type_args, true);
         UnresolvedType { typ, span }
     }
+
+    pub(crate) fn contains_unspecified(&self) -> bool {
+        self.typ.contains_unspecified()
+    }
 }
 
 impl UnresolvedTypeData {
@@ -377,6 +407,47 @@ impl UnresolvedTypeData {
     pub fn with_span(&self, span: Span) -> UnresolvedType {
         UnresolvedType { typ: self.clone(), span }
     }
+
+    fn contains_unspecified(&self) -> bool {
+        match self {
+            UnresolvedTypeData::Array(typ, length) => {
+                typ.contains_unspecified() || length.contains_unspecified()
+            }
+            UnresolvedTypeData::Slice(typ) => typ.contains_unspecified(),
+            UnresolvedTypeData::Expression(expr) => expr.contains_unspecified(),
+            UnresolvedTypeData::String(length) => length.contains_unspecified(),
+            UnresolvedTypeData::FormatString(typ, length) => {
+                typ.contains_unspecified() || length.contains_unspecified()
+            }
+            UnresolvedTypeData::Parenthesized(typ) => typ.contains_unspecified(),
+            UnresolvedTypeData::Named(path, args, _is_synthesized) => {
+                // '_' is unspecified
+                let path_is_wildcard = path.is_wildcard();
+                let an_arg_is_unresolved = args.contains_unspecified();
+                path_is_wildcard || an_arg_is_unresolved
+            }
+            UnresolvedTypeData::TraitAsType(_path, args) => args.contains_unspecified(),
+            UnresolvedTypeData::MutableReference(typ) => typ.contains_unspecified(),
+            UnresolvedTypeData::Tuple(args) => args.iter().any(|arg| arg.contains_unspecified()),
+            UnresolvedTypeData::Function(args, ret, env, _unconstrained) => {
+                let args_contains_unspecified = args.iter().any(|arg| arg.contains_unspecified());
+                args_contains_unspecified
+                    || ret.contains_unspecified()
+                    || env.contains_unspecified()
+            }
+            UnresolvedTypeData::Unspecified => true,
+
+            UnresolvedTypeData::FieldElement
+            | UnresolvedTypeData::Integer(_, _)
+            | UnresolvedTypeData::Bool
+            | UnresolvedTypeData::Unit
+            | UnresolvedTypeData::Quoted(_)
+            | UnresolvedTypeData::AsTraitPath(_)
+            | UnresolvedTypeData::Resolved(_)
+            | UnresolvedTypeData::Interned(_)
+            | UnresolvedTypeData::Error => false,
+        }
+    }
 }
 
 #[derive(Debug, PartialEq, Eq, Copy, Clone, Hash, PartialOrd, Ord)]
@@ -421,12 +492,13 @@ impl UnresolvedTypeExpression {
     fn from_expr_helper(expr: Expression) -> Result<UnresolvedTypeExpression, Expression> {
         match expr.kind {
             ExpressionKind::Literal(Literal::Integer(int, _)) => match int.try_to_u32() {
-                Some(int) => Ok(UnresolvedTypeExpression::Constant(int, expr.span)),
+                Some(int) => Ok(UnresolvedTypeExpression::Constant(int.into(), expr.span)),
                 None => Err(expr),
             },
             ExpressionKind::Variable(path) => Ok(UnresolvedTypeExpression::Variable(path)),
             ExpressionKind::Prefix(prefix) if prefix.operator == UnaryOp::Minus => {
-                let lhs = Box::new(UnresolvedTypeExpression::Constant(0, expr.span));
+                let lhs =
+                    Box::new(UnresolvedTypeExpression::Constant(FieldElement::zero(), expr.span));
                 let rhs = Box::new(UnresolvedTypeExpression::from_expr_helper(prefix.rhs)?);
                 let op = BinaryTypeOperator::Subtraction;
                 Ok(UnresolvedTypeExpression::BinaryOperation(lhs, op, rhs, expr.span))
@@ -475,6 +547,19 @@ impl UnresolvedTypeExpression {
                 | BinaryOpKind::Modulo
         )
     }
+
+    fn contains_unspecified(&self) -> bool {
+        match self {
+            // '_' is unspecified
+            UnresolvedTypeExpression::Variable(path) => path.is_wildcard(),
+            UnresolvedTypeExpression::BinaryOperation(lhs, _op, rhs, _span) => {
+                lhs.contains_unspecified() || rhs.contains_unspecified()
+            }
+            UnresolvedTypeExpression::Constant(_, _) | UnresolvedTypeExpression::AsTraitPath(_) => {
+                false
+            }
+        }
+    }
 }
 
 #[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord)]
diff --git a/compiler/noirc_frontend/src/ast/statement.rs b/compiler/noirc_frontend/src/ast/statement.rs
index 4abea8cebb4..c77fe7513a1 100644
--- a/compiler/noirc_frontend/src/ast/statement.rs
+++ b/compiler/noirc_frontend/src/ast/statement.rs
@@ -7,15 +7,18 @@ use iter_extended::vecmap;
 use noirc_errors::{Span, Spanned};
 
 use super::{
-    BlockExpression, ConstructorExpression, Expression, ExpressionKind, GenericTypeArgs,
-    IndexExpression, ItemVisibility, MemberAccessExpression, MethodCallExpression, UnresolvedType,
+    BinaryOpKind, BlockExpression, ConstructorExpression, Expression, ExpressionKind,
+    GenericTypeArgs, IndexExpression, InfixExpression, ItemVisibility, MemberAccessExpression,
+    MethodCallExpression, UnresolvedType,
 };
+use crate::ast::UnresolvedTypeData;
 use crate::elaborator::types::SELF_TYPE_NAME;
 use crate::lexer::token::SpannedToken;
-use crate::macros_api::{NodeInterner, SecondaryAttribute, UnresolvedTypeData};
-use crate::node_interner::{InternedExpressionKind, InternedPattern, InternedStatementKind};
+use crate::node_interner::{
+    InternedExpressionKind, InternedPattern, InternedStatementKind, NodeInterner,
+};
 use crate::parser::{ParserError, ParserErrorReason};
-use crate::token::Token;
+use crate::token::{SecondaryAttribute, Token};
 
 /// This is used when an identifier fails to parse in the parser.
 /// Instead of failing the parse, we can often recover using this
@@ -24,6 +27,9 @@ use crate::token::Token;
 /// for an identifier that already failed to parse.
 pub const ERROR_IDENT: &str = "$error";
 
+/// This is used to represent an UnresolvedTypeData::Unspecified in a Path
+pub const WILDCARD_TYPE: &str = "_";
+
 #[derive(Debug, PartialEq, Eq, Clone)]
 pub struct Statement {
     pub kind: StatementKind,
@@ -177,7 +183,7 @@ impl StatementKind {
     }
 }
 
-#[derive(Eq, Debug, Clone)]
+#[derive(Eq, Debug, Clone, Default)]
 pub struct Ident(pub Spanned<String>);
 
 impl Ident {
@@ -324,18 +330,19 @@ pub enum PathKind {
 pub struct UseTree {
     pub prefix: Path,
     pub kind: UseTreeKind,
+    pub span: Span,
 }
 
 impl Display for UseTree {
     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
         write!(f, "{}", self.prefix)?;
 
+        if !self.prefix.segments.is_empty() {
+            write!(f, "::")?;
+        }
+
         match &self.kind {
             UseTreeKind::Path(name, alias) => {
-                if !(self.prefix.segments.is_empty() && self.prefix.kind == PathKind::Plain) {
-                    write!(f, "::")?;
-                }
-
                 write!(f, "{name}")?;
 
                 if let Some(alias) = alias {
@@ -345,7 +352,7 @@ impl Display for UseTree {
                 Ok(())
             }
             UseTreeKind::List(trees) => {
-                write!(f, "::{{")?;
+                write!(f, "{{")?;
                 let tree = vecmap(trees, ToString::to_string).join(", ");
                 write!(f, "{tree}}}")
             }
@@ -370,7 +377,9 @@ impl UseTree {
 
         match self.kind {
             UseTreeKind::Path(name, alias) => {
-                vec![ImportStatement { visibility, path: prefix.join(name), alias }]
+                // Desugar `use foo::{self}` to `use foo`
+                let path = if name.0.contents == "self" { prefix } else { prefix.join(name) };
+                vec![ImportStatement { visibility, path, alias }]
             }
             UseTreeKind::List(trees) => {
                 let trees = trees.into_iter();
@@ -402,7 +411,7 @@ pub struct AsTraitPath {
 pub struct TypePath {
     pub typ: UnresolvedType,
     pub item: Ident,
-    pub turbofish: GenericTypeArgs,
+    pub turbofish: Option<GenericTypeArgs>,
 }
 
 // Note: Path deliberately doesn't implement Recoverable.
@@ -439,11 +448,6 @@ impl Path {
         self.span
     }
 
-    pub fn first_segment(&self) -> PathSegment {
-        assert!(!self.segments.is_empty());
-        self.segments.first().unwrap().clone()
-    }
-
     pub fn last_segment(&self) -> PathSegment {
         assert!(!self.segments.is_empty());
         self.segments.last().unwrap().clone()
@@ -453,9 +457,8 @@ impl Path {
         self.last_segment().ident
     }
 
-    pub fn first_name(&self) -> &str {
-        assert!(!self.segments.is_empty());
-        &self.segments.first().unwrap().ident.0.contents
+    pub fn first_name(&self) -> Option<&str> {
+        self.segments.first().map(|segment| segment.ident.0.contents.as_str())
     }
 
     pub fn last_name(&self) -> &str {
@@ -464,7 +467,9 @@ impl Path {
     }
 
     pub fn is_ident(&self) -> bool {
-        self.segments.len() == 1 && self.kind == PathKind::Plain
+        self.kind == PathKind::Plain
+            && self.segments.len() == 1
+            && self.segments.first().unwrap().generics.is_none()
     }
 
     pub fn as_ident(&self) -> Option<&Ident> {
@@ -481,6 +486,14 @@ impl Path {
         self.segments.first().cloned().map(|segment| segment.ident)
     }
 
+    pub(crate) fn is_wildcard(&self) -> bool {
+        self.to_ident().map(|ident| ident.0.contents) == Some(WILDCARD_TYPE.to_string())
+    }
+
+    pub fn is_empty(&self) -> bool {
+        self.segments.is_empty() && self.kind == PathKind::Plain
+    }
+
     pub fn as_string(&self) -> String {
         let mut string = String::new();
 
@@ -647,14 +660,6 @@ impl Pattern {
         }
     }
 
-    pub(crate) fn into_ident(self) -> Ident {
-        match self {
-            Pattern::Identifier(ident) => ident,
-            Pattern::Mutable(pattern, _, _) => pattern.into_ident(),
-            other => panic!("Pattern::into_ident called on {other} pattern with no identifier"),
-        }
-    }
-
     pub(crate) fn try_as_expression(&self, interner: &NodeInterner) -> Option<Expression> {
         match self {
             Pattern::Identifier(ident) => Some(Expression {
@@ -723,37 +728,36 @@ impl LValue {
         Expression::new(kind, span)
     }
 
-    pub fn from_expression(expr: Expression) -> LValue {
+    pub fn from_expression(expr: Expression) -> Option<LValue> {
         LValue::from_expression_kind(expr.kind, expr.span)
     }
 
-    pub fn from_expression_kind(expr: ExpressionKind, span: Span) -> LValue {
+    pub fn from_expression_kind(expr: ExpressionKind, span: Span) -> Option<LValue> {
         match expr {
-            ExpressionKind::Variable(path) => LValue::Ident(path.as_ident().unwrap().clone()),
-            ExpressionKind::MemberAccess(member_access) => LValue::MemberAccess {
-                object: Box::new(LValue::from_expression(member_access.lhs)),
+            ExpressionKind::Variable(path) => Some(LValue::Ident(path.as_ident().unwrap().clone())),
+            ExpressionKind::MemberAccess(member_access) => Some(LValue::MemberAccess {
+                object: Box::new(LValue::from_expression(member_access.lhs)?),
                 field_name: member_access.rhs,
                 span,
-            },
-            ExpressionKind::Index(index) => LValue::Index {
-                array: Box::new(LValue::from_expression(index.collection)),
+            }),
+            ExpressionKind::Index(index) => Some(LValue::Index {
+                array: Box::new(LValue::from_expression(index.collection)?),
                 index: index.index,
                 span,
-            },
+            }),
             ExpressionKind::Prefix(prefix) => {
                 if matches!(
                     prefix.operator,
                     crate::ast::UnaryOp::Dereference { implicitly_added: false }
                 ) {
-                    LValue::Dereference(Box::new(LValue::from_expression(prefix.rhs)), span)
+                    Some(LValue::Dereference(Box::new(LValue::from_expression(prefix.rhs)?), span))
                 } else {
-                    panic!("Called LValue::from_expression with an invalid prefix operator")
+                    None
                 }
             }
-            ExpressionKind::Interned(id) => LValue::Interned(id, span),
-            _ => {
-                panic!("Called LValue::from_expression with an invalid expression")
-            }
+            ExpressionKind::Parenthesized(expr) => LValue::from_expression(*expr),
+            ExpressionKind::Interned(id) => Some(LValue::Interned(id, span)),
+            _ => None,
         }
     }
 
@@ -768,13 +772,57 @@ impl LValue {
     }
 }
 
+#[derive(Debug, PartialEq, Eq, Clone)]
+pub struct ForBounds {
+    pub start: Expression,
+    pub end: Expression,
+    pub inclusive: bool,
+}
+
+impl ForBounds {
+    /// Create a half-open range bounded inclusively below and exclusively above (`start..end`),  
+    /// desugaring `start..=end` into `start..end+1` if necessary.
+    ///
+    /// Returns the `start` and `end` expressions.
+    pub(crate) fn into_half_open(self) -> (Expression, Expression) {
+        let end = if self.inclusive {
+            let end_span = self.end.span;
+            let end = ExpressionKind::Infix(Box::new(InfixExpression {
+                lhs: self.end,
+                operator: Spanned::from(end_span, BinaryOpKind::Add),
+                rhs: Expression::new(ExpressionKind::integer(FieldElement::from(1u32)), end_span),
+            }));
+            Expression::new(end, end_span)
+        } else {
+            self.end
+        };
+
+        (self.start, end)
+    }
+}
+
 #[derive(Debug, PartialEq, Eq, Clone)]
 pub enum ForRange {
-    Range(/*start:*/ Expression, /*end:*/ Expression),
+    Range(ForBounds),
     Array(Expression),
 }
 
 impl ForRange {
+    /// Create a half-open range, bounded inclusively below and exclusively above.
+    pub fn range(start: Expression, end: Expression) -> Self {
+        Self::Range(ForBounds { start, end, inclusive: false })
+    }
+
+    /// Create a range bounded inclusively below and above.
+    pub fn range_inclusive(start: Expression, end: Expression) -> Self {
+        Self::Range(ForBounds { start, end, inclusive: true })
+    }
+
+    /// Create a range over some array.
+    pub fn array(value: Expression) -> Self {
+        Self::Array(value)
+    }
+
     /// Create a 'for' expression taking care of desugaring a 'for e in array' loop
     /// into the following if needed:
     ///
@@ -877,7 +925,7 @@ impl ForRange {
                 let for_loop = Statement {
                     kind: StatementKind::For(ForLoopStatement {
                         identifier: fresh_identifier,
-                        range: ForRange::Range(start_range, end_range),
+                        range: ForRange::range(start_range, end_range),
                         block: new_block,
                         span: for_loop_span,
                     }),
@@ -1007,7 +1055,14 @@ impl Display for Pattern {
 impl Display for ForLoopStatement {
     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
         let range = match &self.range {
-            ForRange::Range(start, end) => format!("{start}..{end}"),
+            ForRange::Range(bounds) => {
+                format!(
+                    "{}{}{}",
+                    bounds.start,
+                    if bounds.inclusive { "..=" } else { ".." },
+                    bounds.end
+                )
+            }
             ForRange::Array(expr) => expr.to_string(),
         };
 
diff --git a/compiler/noirc_frontend/src/ast/structure.rs b/compiler/noirc_frontend/src/ast/structure.rs
index 1675629ff14..8c8fe6e6387 100644
--- a/compiler/noirc_frontend/src/ast/structure.rs
+++ b/compiler/noirc_frontend/src/ast/structure.rs
@@ -19,8 +19,15 @@ pub struct NoirStruct {
     pub span: Span,
 }
 
+impl NoirStruct {
+    pub fn is_abi(&self) -> bool {
+        self.attributes.iter().any(|attr| attr.is_abi())
+    }
+}
+
 #[derive(Clone, Debug, PartialEq, Eq)]
 pub struct StructField {
+    pub visibility: ItemVisibility,
     pub name: Ident,
     pub typ: UnresolvedType,
 }
diff --git a/compiler/noirc_frontend/src/ast/traits.rs b/compiler/noirc_frontend/src/ast/traits.rs
index 3df9939dc70..475e3ff1be9 100644
--- a/compiler/noirc_frontend/src/ast/traits.rs
+++ b/compiler/noirc_frontend/src/ast/traits.rs
@@ -7,8 +7,8 @@ use crate::ast::{
     BlockExpression, Expression, FunctionReturnType, Ident, NoirFunction, Path, UnresolvedGenerics,
     UnresolvedType,
 };
-use crate::macros_api::SecondaryAttribute;
 use crate::node_interner::TraitId;
+use crate::token::SecondaryAttribute;
 
 use super::{Documented, GenericTypeArgs, ItemVisibility};
 
@@ -18,11 +18,13 @@ use super::{Documented, GenericTypeArgs, ItemVisibility};
 pub struct NoirTrait {
     pub name: Ident,
     pub generics: UnresolvedGenerics,
+    pub bounds: Vec<TraitBound>,
     pub where_clause: Vec<UnresolvedTraitConstraint>,
     pub span: Span,
     pub items: Vec<Documented<TraitItem>>,
     pub attributes: Vec<SecondaryAttribute>,
     pub visibility: ItemVisibility,
+    pub is_alias: bool,
 }
 
 /// Any declaration inside the body of a trait that a user is required to
@@ -76,6 +78,9 @@ pub struct NoirTraitImpl {
     pub where_clause: Vec<UnresolvedTraitConstraint>,
 
     pub items: Vec<Documented<TraitImplItem>>,
+
+    /// true if generated at compile-time, e.g. from a trait alias
+    pub is_synthetic: bool,
 }
 
 /// Represents a simple trait constraint such as `where Foo: TraitY<U, V>`
@@ -129,12 +134,24 @@ impl Display for TypeImpl {
     }
 }
 
+// TODO: display where clauses (follow-up issue)
 impl Display for NoirTrait {
     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
         let generics = vecmap(&self.generics, |generic| generic.to_string());
         let generics = if generics.is_empty() { "".into() } else { generics.join(", ") };
 
-        writeln!(f, "trait {}{} {{", self.name, generics)?;
+        write!(f, "trait {}{}", self.name, generics)?;
+
+        if self.is_alias {
+            let bounds = vecmap(&self.bounds, |bound| bound.to_string()).join(" + ");
+            return write!(f, " = {};", bounds);
+        }
+
+        if !self.bounds.is_empty() {
+            let bounds = vecmap(&self.bounds, |bound| bound.to_string()).join(" + ");
+            write!(f, ": {}", bounds)?;
+        }
+        writeln!(f, " {{")?;
 
         for item in self.items.iter() {
             let item = item.to_string();
@@ -216,7 +233,29 @@ impl Display for TraitBound {
 
 impl Display for NoirTraitImpl {
     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
-        writeln!(f, "impl {}{} for {} {{", self.trait_name, self.trait_generics, self.object_type)?;
+        // Synthetic NoirTraitImpl's don't get printed
+        if self.is_synthetic {
+            return Ok(());
+        }
+
+        write!(f, "impl")?;
+        if !self.impl_generics.is_empty() {
+            write!(
+                f,
+                "<{}>",
+                self.impl_generics.iter().map(ToString::to_string).collect::<Vec<_>>().join(", ")
+            )?;
+        }
+
+        write!(f, " {}{} for {}", self.trait_name, self.trait_generics, self.object_type)?;
+        if !self.where_clause.is_empty() {
+            write!(
+                f,
+                " where {}",
+                self.where_clause.iter().map(ToString::to_string).collect::<Vec<_>>().join(", ")
+            )?;
+        }
+        writeln!(f, "{{")?;
 
         for item in self.items.iter() {
             let item = item.to_string();
diff --git a/compiler/noirc_frontend/src/ast/visitor.rs b/compiler/noirc_frontend/src/ast/visitor.rs
index ed4d17cadd8..2f60532980a 100644
--- a/compiler/noirc_frontend/src/ast/visitor.rs
+++ b/compiler/noirc_frontend/src/ast/visitor.rs
@@ -16,14 +16,14 @@ use crate::{
         InternedUnresolvedTypeData, QuotedTypeId,
     },
     parser::{Item, ItemKind, ParsedSubModule},
-    token::{CustomAttribute, SecondaryAttribute, Tokens},
+    token::{FmtStrFragment, MetaAttribute, SecondaryAttribute, Tokens},
     ParsedModule, QuotedType,
 };
 
 use super::{
-    FunctionReturnType, GenericTypeArgs, IntegerBitSize, ItemVisibility, Pattern, Signedness,
-    TraitImplItemKind, TypePath, UnresolvedGenerics, UnresolvedTraitConstraint, UnresolvedType,
-    UnresolvedTypeData, UnresolvedTypeExpression,
+    ForBounds, FunctionReturnType, GenericTypeArgs, IntegerBitSize, ItemVisibility, Pattern,
+    Signedness, TraitBound, TraitImplItemKind, TypePath, UnresolvedGenerics,
+    UnresolvedTraitConstraint, UnresolvedType, UnresolvedTypeData, UnresolvedTypeExpression,
 };
 
 #[derive(Debug, Copy, Clone, PartialEq, Eq)]
@@ -172,7 +172,7 @@ pub trait Visitor {
 
     fn visit_literal_raw_str(&mut self, _: &str, _: u8) {}
 
-    fn visit_literal_fmt_str(&mut self, _: &str) {}
+    fn visit_literal_fmt_str(&mut self, _: &[FmtStrFragment], _length: u32) {}
 
     fn visit_literal_unit(&mut self) {}
 
@@ -438,6 +438,14 @@ pub trait Visitor {
         true
     }
 
+    fn visit_trait_bound(&mut self, _: &TraitBound) -> bool {
+        true
+    }
+
+    fn visit_unresolved_trait_constraint(&mut self, _: &UnresolvedTraitConstraint) -> bool {
+        true
+    }
+
     fn visit_pattern(&mut self, _: &Pattern) -> bool {
         true
     }
@@ -466,7 +474,9 @@ pub trait Visitor {
         true
     }
 
-    fn visit_custom_attribute(&mut self, _: &CustomAttribute, _target: AttributeTarget) {}
+    fn visit_meta_attribute(&mut self, _: &MetaAttribute, _target: AttributeTarget) -> bool {
+        true
+    }
 }
 
 impl ParsedModule {
@@ -555,6 +565,12 @@ impl NoirFunction {
             param.typ.accept(visitor);
         }
 
+        self.def.return_type.accept(visitor);
+
+        for constraint in &self.def.where_clause {
+            constraint.accept(visitor);
+        }
+
         self.def.body.accept(None, visitor);
     }
 }
@@ -645,6 +661,14 @@ impl NoirTrait {
             attribute.accept(AttributeTarget::Trait, visitor);
         }
 
+        for bound in &self.bounds {
+            bound.accept(visitor);
+        }
+
+        for constraint in &self.where_clause {
+            constraint.accept(visitor);
+        }
+
         for item in &self.items {
             item.item.accept(visitor);
         }
@@ -686,7 +710,7 @@ impl TraitItem {
                     return_type.accept(visitor);
 
                     for unresolved_trait_constraint in where_clause {
-                        unresolved_trait_constraint.typ.accept(visitor);
+                        unresolved_trait_constraint.accept(visitor);
                     }
 
                     if let Some(body) = body {
@@ -876,7 +900,7 @@ impl Literal {
             Literal::Integer(value, negative) => visitor.visit_literal_integer(*value, *negative),
             Literal::Str(str) => visitor.visit_literal_str(str),
             Literal::RawStr(str, length) => visitor.visit_literal_raw_str(str, *length),
-            Literal::FmtStr(str) => visitor.visit_literal_fmt_str(str),
+            Literal::FmtStr(fragments, length) => visitor.visit_literal_fmt_str(fragments, *length),
             Literal::Unit => visitor.visit_literal_unit(),
         }
     }
@@ -1192,7 +1216,7 @@ impl ForRange {
 
     pub fn accept_children(&self, visitor: &mut impl Visitor) {
         match self {
-            ForRange::Range(start, end) => {
+            ForRange::Range(ForBounds { start, end, inclusive: _ }) => {
                 start.accept(visitor);
                 end.accept(visitor);
             }
@@ -1223,7 +1247,9 @@ impl TypePath {
 
     pub fn accept_children(&self, visitor: &mut impl Visitor) {
         self.typ.accept(visitor);
-        self.turbofish.accept(visitor);
+        if let Some(turbofish) = &self.turbofish {
+            turbofish.accept(visitor);
+        }
     }
 }
 
@@ -1346,6 +1372,32 @@ impl FunctionReturnType {
     }
 }
 
+impl TraitBound {
+    pub fn accept(&self, visitor: &mut impl Visitor) {
+        if visitor.visit_trait_bound(self) {
+            self.accept_children(visitor);
+        }
+    }
+
+    pub fn accept_children(&self, visitor: &mut impl Visitor) {
+        self.trait_path.accept(visitor);
+        self.trait_generics.accept(visitor);
+    }
+}
+
+impl UnresolvedTraitConstraint {
+    pub fn accept(&self, visitor: &mut impl Visitor) {
+        if visitor.visit_unresolved_trait_constraint(self) {
+            self.accept_children(visitor);
+        }
+    }
+
+    pub fn accept_children(&self, visitor: &mut impl Visitor) {
+        self.typ.accept(visitor);
+        self.trait_bound.accept(visitor);
+    }
+}
+
 impl Pattern {
     pub fn accept(&self, visitor: &mut impl Visitor) {
         if visitor.visit_pattern(self) {
@@ -1391,15 +1443,22 @@ impl SecondaryAttribute {
     }
 
     pub fn accept_children(&self, target: AttributeTarget, visitor: &mut impl Visitor) {
-        if let SecondaryAttribute::Custom(custom) = self {
-            custom.accept(target, visitor);
+        if let SecondaryAttribute::Meta(meta_attribute) = self {
+            meta_attribute.accept(target, visitor);
         }
     }
 }
 
-impl CustomAttribute {
+impl MetaAttribute {
     pub fn accept(&self, target: AttributeTarget, visitor: &mut impl Visitor) {
-        visitor.visit_custom_attribute(self, target);
+        if visitor.visit_meta_attribute(self, target) {
+            self.accept_children(visitor);
+        }
+    }
+
+    pub fn accept_children(&self, visitor: &mut impl Visitor) {
+        self.name.accept(visitor);
+        visit_expressions(&self.arguments, visitor);
     }
 }
 
diff --git a/compiler/noirc_frontend/src/debug/mod.rs b/compiler/noirc_frontend/src/debug/mod.rs
index 66de265f869..f05fc721581 100644
--- a/compiler/noirc_frontend/src/debug/mod.rs
+++ b/compiler/noirc_frontend/src/debug/mod.rs
@@ -1,5 +1,6 @@
 use crate::ast::PathSegment;
-use crate::parser::{parse_program, ParsedModule};
+use crate::parse_program;
+use crate::parser::ParsedModule;
 use crate::{
     ast,
     ast::{Path, PathKind},
@@ -66,12 +67,16 @@ impl DebugInstrumenter {
         self.insert_state_set_oracle(module, 8);
     }
 
-    fn insert_var(&mut self, var_name: &str) -> SourceVarId {
+    fn insert_var(&mut self, var_name: &str) -> Option<SourceVarId> {
+        if var_name == "_" {
+            return None;
+        }
+
         let var_id = SourceVarId(self.next_var_id);
         self.next_var_id += 1;
         self.variables.insert(var_id, var_name.to_string());
         self.scope.last_mut().unwrap().insert(var_name.to_string(), var_id);
-        var_id
+        Some(var_id)
     }
 
     fn lookup_var(&self, var_name: &str) -> Option<SourceVarId> {
@@ -106,9 +111,9 @@ impl DebugInstrumenter {
             .flat_map(|param| {
                 pattern_vars(&param.pattern)
                     .iter()
-                    .map(|(id, _is_mut)| {
-                        let var_id = self.insert_var(&id.0.contents);
-                        build_assign_var_stmt(var_id, id_expr(id))
+                    .filter_map(|(id, _is_mut)| {
+                        let var_id = self.insert_var(&id.0.contents)?;
+                        Some(build_assign_var_stmt(var_id, id_expr(id)))
                     })
                     .collect::<Vec<_>>()
             })
@@ -224,13 +229,28 @@ impl DebugInstrumenter {
                 }
             })
             .collect();
-        let vars_exprs: Vec<ast::Expression> = vars.iter().map(|(id, _)| id_expr(id)).collect();
+        let vars_exprs: Vec<ast::Expression> = vars
+            .iter()
+            .map(|(id, _)| {
+                // We don't want to generate an expression to read from "_".
+                // And since this expression is going to be assigned to "_" so it doesn't matter
+                // what it is, we can use `()` for it.
+                if id.0.contents == "_" {
+                    ast::Expression {
+                        kind: ast::ExpressionKind::Literal(ast::Literal::Unit),
+                        span: id.span(),
+                    }
+                } else {
+                    id_expr(id)
+                }
+            })
+            .collect();
 
         let mut block_stmts =
             vec![ast::Statement { kind: ast::StatementKind::Let(let_stmt.clone()), span: *span }];
-        block_stmts.extend(vars.iter().map(|(id, _)| {
-            let var_id = self.insert_var(&id.0.contents);
-            build_assign_var_stmt(var_id, id_expr(id))
+        block_stmts.extend(vars.iter().filter_map(|(id, _)| {
+            let var_id = self.insert_var(&id.0.contents)?;
+            Some(build_assign_var_stmt(var_id, id_expr(id)))
         }));
         block_stmts.push(ast::Statement {
             kind: ast::StatementKind::Expression(ast::Expression {
@@ -421,21 +441,31 @@ impl DebugInstrumenter {
         let var_name = &for_stmt.identifier.0.contents;
         let var_id = self.insert_var(var_name);
 
-        let set_stmt = build_assign_var_stmt(var_id, id_expr(&for_stmt.identifier));
-        let drop_stmt = build_drop_var_stmt(var_id, Span::empty(for_stmt.span.end()));
+        let set_and_drop_stmt = var_id.map(|var_id| {
+            (
+                build_assign_var_stmt(var_id, id_expr(&for_stmt.identifier)),
+                build_drop_var_stmt(var_id, Span::empty(for_stmt.span.end())),
+            )
+        });
 
         self.walk_expr(&mut for_stmt.block);
+
+        let mut statements = Vec::new();
+        let block_statement = ast::Statement {
+            kind: ast::StatementKind::Semi(for_stmt.block.clone()),
+            span: for_stmt.block.span,
+        };
+
+        if let Some((set_stmt, drop_stmt)) = set_and_drop_stmt {
+            statements.push(set_stmt);
+            statements.push(block_statement);
+            statements.push(drop_stmt);
+        } else {
+            statements.push(block_statement);
+        }
+
         for_stmt.block = ast::Expression {
-            kind: ast::ExpressionKind::Block(ast::BlockExpression {
-                statements: vec![
-                    set_stmt,
-                    ast::Statement {
-                        kind: ast::StatementKind::Semi(for_stmt.block.clone()),
-                        span: for_stmt.block.span,
-                    },
-                    drop_stmt,
-                ],
-            }),
+            kind: ast::ExpressionKind::Block(ast::BlockExpression { statements }),
             span: for_stmt.span,
         };
     }
diff --git a/compiler/noirc_frontend/src/elaborator/comptime.rs b/compiler/noirc_frontend/src/elaborator/comptime.rs
index 560be895628..fe8c8338b32 100644
--- a/compiler/noirc_frontend/src/elaborator/comptime.rs
+++ b/compiler/noirc_frontend/src/elaborator/comptime.rs
@@ -1,12 +1,11 @@
 use std::{collections::BTreeMap, fmt::Display};
 
-use chumsky::Parser;
 use fm::FileId;
 use iter_extended::vecmap;
 use noirc_errors::{Location, Span};
 
 use crate::{
-    ast::Documented,
+    ast::{Documented, Expression, ExpressionKind},
     hir::{
         comptime::{Interpreter, InterpreterError, Value},
         def_collector::{
@@ -19,13 +18,10 @@ use crate::{
         def_map::{LocalModuleId, ModuleId},
         resolution::errors::ResolverError,
     },
-    hir_def::expr::HirIdent,
-    lexer::Lexer,
-    macros_api::{
-        Expression, ExpressionKind, HirExpression, NodeInterner, SecondaryAttribute, StructId,
-    },
-    node_interner::{DefinitionKind, DependencyId, FuncId, TraitId},
-    parser::{self, TopLevelStatement, TopLevelStatementKind},
+    hir_def::expr::{HirExpression, HirIdent},
+    node_interner::{DefinitionKind, DependencyId, FuncId, NodeInterner, StructId, TraitId},
+    parser::{Item, ItemKind},
+    token::{MetaAttribute, SecondaryAttribute},
     Type, TypeBindings, UnificationError,
 };
 
@@ -43,6 +39,8 @@ struct AttributeContext {
     attribute_module: LocalModuleId,
 }
 
+type CollectedAttributes = Vec<(FuncId, Value, Vec<Expression>, AttributeContext, Span)>;
+
 impl AttributeContext {
     fn new(file: FileId, module: LocalModuleId) -> Self {
         Self { file, module, attribute_file: file, attribute_module: module }
@@ -94,6 +92,7 @@ impl<'context> Elaborator<'context> {
         let mut elaborator = Elaborator::new(
             self.interner,
             self.def_maps,
+            self.usage_tracker,
             self.crate_id,
             self.debug_comptime_in_file,
             self.interpreter_call_stack.clone(),
@@ -134,42 +133,37 @@ impl<'context> Elaborator<'context> {
         }
     }
 
-    fn run_comptime_attributes_on_item(
+    fn collect_comptime_attributes_on_item(
         &mut self,
         attributes: &[SecondaryAttribute],
         item: Value,
-        span: Span,
         attribute_context: AttributeContext,
-        generated_items: &mut CollectedItems,
+        attributes_to_run: &mut CollectedAttributes,
     ) {
         for attribute in attributes {
-            self.run_comptime_attribute_on_item(
+            self.collect_comptime_attribute_on_item(
                 attribute,
                 &item,
-                span,
                 attribute_context,
-                generated_items,
+                attributes_to_run,
             );
         }
     }
 
-    fn run_comptime_attribute_on_item(
+    fn collect_comptime_attribute_on_item(
         &mut self,
         attribute: &SecondaryAttribute,
         item: &Value,
-        span: Span,
         attribute_context: AttributeContext,
-        generated_items: &mut CollectedItems,
+        attributes_to_run: &mut CollectedAttributes,
     ) {
-        if let SecondaryAttribute::Custom(attribute) = attribute {
+        if let SecondaryAttribute::Meta(attribute) = attribute {
             self.elaborate_in_comptime_context(|this| {
-                if let Err(error) = this.run_comptime_attribute_name_on_item(
-                    &attribute.contents,
+                if let Err(error) = this.collect_comptime_attribute_name_on_item(
+                    attribute,
                     item.clone(),
-                    span,
-                    attribute.contents_span,
                     attribute_context,
-                    generated_items,
+                    attributes_to_run,
                 ) {
                     this.errors.push(error);
                 }
@@ -177,45 +171,58 @@ impl<'context> Elaborator<'context> {
         }
     }
 
-    fn run_comptime_attribute_name_on_item(
+    /// Resolve an attribute to the function it refers to and add it to `attributes_to_run`
+    fn collect_comptime_attribute_name_on_item(
         &mut self,
-        attribute: &str,
+        attribute: &MetaAttribute,
         item: Value,
-        span: Span,
-        attribute_span: Span,
         attribute_context: AttributeContext,
-        generated_items: &mut CollectedItems,
+        attributes_to_run: &mut CollectedAttributes,
     ) -> Result<(), (CompilationError, FileId)> {
         self.file = attribute_context.attribute_file;
         self.local_module = attribute_context.attribute_module;
+        let span = attribute.span;
 
-        let location = Location::new(attribute_span, self.file);
-        let Some((function, arguments)) = Self::parse_attribute(attribute, location)? else {
-            // Do not issue an error if the attribute is unknown
-            return Ok(());
-        };
+        let function = Expression { kind: ExpressionKind::Variable(attribute.name.clone()), span };
+        let arguments = attribute.arguments.clone();
 
         // Elaborate the function, rolling back any errors generated in case it is unknown
         let error_count = self.errors.len();
+        let function_string = function.to_string();
         let function = self.elaborate_expression(function).0;
         self.errors.truncate(error_count);
 
         let definition_id = match self.interner.expression(&function) {
             HirExpression::Ident(ident, _) => ident.id,
-            _ => return Ok(()),
+            _ => {
+                let error =
+                    ResolverError::AttributeFunctionIsNotAPath { function: function_string, span };
+                return Err((error.into(), self.file));
+            }
         };
 
         let Some(definition) = self.interner.try_definition(definition_id) else {
-            // If there's no such function, don't return an error.
-            // This preserves backwards compatibility in allowing custom attributes that
-            // do not refer to comptime functions.
-            return Ok(());
+            let error = ResolverError::AttributeFunctionNotInScope { name: function_string, span };
+            return Err((error.into(), self.file));
         };
 
         let DefinitionKind::Function(function) = definition.kind else {
             return Err((ResolverError::NonFunctionInAnnotation { span }.into(), self.file));
         };
 
+        attributes_to_run.push((function, item, arguments, attribute_context, span));
+        Ok(())
+    }
+
+    fn run_attribute(
+        &mut self,
+        attribute_context: AttributeContext,
+        function: FuncId,
+        arguments: Vec<Expression>,
+        item: Value,
+        location: Location,
+        generated_items: &mut CollectedItems,
+    ) -> Result<(), (CompilationError, FileId)> {
         self.file = attribute_context.file;
         self.local_module = attribute_context.module;
 
@@ -227,10 +234,7 @@ impl<'context> Elaborator<'context> {
             arguments,
             location,
         )
-        .map_err(|error| {
-            let file = error.get_location().file;
-            (error.into(), file)
-        })?;
+        .map_err(|error| error.into_compilation_error_pair())?;
 
         arguments.insert(0, (item, location));
 
@@ -251,37 +255,6 @@ impl<'context> Elaborator<'context> {
         Ok(())
     }
 
-    /// Parses an attribute in the form of a function call (e.g. `#[foo(a b, c d)]`) into
-    /// the function and quoted arguments called (e.g. `("foo", vec![(a b, location), (c d, location)])`)
-    #[allow(clippy::type_complexity)]
-    pub(crate) fn parse_attribute(
-        annotation: &str,
-        location: Location,
-    ) -> Result<Option<(Expression, Vec<Expression>)>, (CompilationError, FileId)> {
-        let (tokens, mut lexing_errors) = Lexer::lex(annotation);
-        if !lexing_errors.is_empty() {
-            return Err((lexing_errors.swap_remove(0).into(), location.file));
-        }
-
-        let expression = parser::expression()
-            .parse(tokens)
-            .map_err(|mut errors| (errors.swap_remove(0).into(), location.file))?;
-
-        let (mut func, mut arguments) = match expression.kind {
-            ExpressionKind::Call(call) => (*call.func, call.arguments),
-            ExpressionKind::Variable(_) => (expression, Vec::new()),
-            _ => return Ok(None),
-        };
-
-        func.span = func.span.shift_by(location.span.start());
-
-        for argument in &mut arguments {
-            argument.span = argument.span.shift_by(location.span.start());
-        }
-
-        Ok(Some((func, arguments)))
-    }
-
     fn handle_attribute_arguments(
         interpreter: &mut Interpreter,
         item: &Value,
@@ -350,8 +323,6 @@ impl<'context> Elaborator<'context> {
                 push_arg(Value::TraitDefinition(trait_id));
             } else {
                 let (expr_id, expr_type) = interpreter.elaborator.elaborate_expression(arg);
-                push_arg(interpreter.evaluate(expr_id)?);
-
                 if let Err(UnificationError) = expr_type.unify(param_type) {
                     return Err(InterpreterError::TypeMismatch {
                         expected: param_type.clone(),
@@ -359,6 +330,7 @@ impl<'context> Elaborator<'context> {
                         location: arg_location,
                     });
                 }
+                push_arg(interpreter.evaluate(expr_id)?);
             };
         }
 
@@ -372,7 +344,7 @@ impl<'context> Elaborator<'context> {
 
     fn add_items(
         &mut self,
-        items: Vec<TopLevelStatement>,
+        items: Vec<Item>,
         generated_items: &mut CollectedItems,
         location: Location,
     ) {
@@ -383,17 +355,18 @@ impl<'context> Elaborator<'context> {
 
     pub(crate) fn add_item(
         &mut self,
-        item: TopLevelStatement,
+        item: Item,
         generated_items: &mut CollectedItems,
         location: Location,
     ) {
         match item.kind {
-            TopLevelStatementKind::Function(function) => {
+            ItemKind::Function(function) => {
                 let module_id = self.module_id();
 
                 if let Some(id) = dc_mod::collect_function(
                     self.interner,
                     self.def_maps.get_mut(&self.crate_id).unwrap(),
+                    self.usage_tracker,
                     &function,
                     module_id,
                     self.file,
@@ -409,7 +382,7 @@ impl<'context> Elaborator<'context> {
                     });
                 }
             }
-            TopLevelStatementKind::TraitImpl(mut trait_impl) => {
+            ItemKind::TraitImpl(mut trait_impl) => {
                 let (methods, associated_types, associated_constants) =
                     dc_mod::collect_trait_impl_items(
                         self.interner,
@@ -439,10 +412,11 @@ impl<'context> Elaborator<'context> {
                     resolved_trait_generics: Vec::new(),
                 });
             }
-            TopLevelStatementKind::Global(global, visibility) => {
+            ItemKind::Global(global, visibility) => {
                 let (global, error) = dc_mod::collect_global(
                     self.interner,
                     self.def_maps.get_mut(&self.crate_id).unwrap(),
+                    self.usage_tracker,
                     Documented::new(global, item.doc_comments),
                     visibility,
                     self.file,
@@ -455,10 +429,11 @@ impl<'context> Elaborator<'context> {
                     self.errors.push(error);
                 }
             }
-            TopLevelStatementKind::Struct(struct_def) => {
+            ItemKind::Struct(struct_def) => {
                 if let Some((type_id, the_struct)) = dc_mod::collect_struct(
                     self.interner,
                     self.def_maps.get_mut(&self.crate_id).unwrap(),
+                    self.usage_tracker,
                     Documented::new(struct_def, item.doc_comments),
                     self.file,
                     self.local_module,
@@ -468,20 +443,24 @@ impl<'context> Elaborator<'context> {
                     generated_items.types.insert(type_id, the_struct);
                 }
             }
-            TopLevelStatementKind::Impl(r#impl) => {
+            ItemKind::Impl(r#impl) => {
                 let module = self.module_id();
-                dc_mod::collect_impl(self.interner, generated_items, r#impl, self.file, module);
+                dc_mod::collect_impl(
+                    self.interner,
+                    generated_items,
+                    r#impl,
+                    self.file,
+                    module,
+                    &mut self.errors,
+                );
             }
 
-            // Assume that an error has already been issued
-            TopLevelStatementKind::Error => (),
-
-            TopLevelStatementKind::Module(_)
-            | TopLevelStatementKind::Import(..)
-            | TopLevelStatementKind::Trait(_)
-            | TopLevelStatementKind::TypeAlias(_)
-            | TopLevelStatementKind::SubModule(_)
-            | TopLevelStatementKind::InnerAttribute(_) => {
+            ItemKind::ModuleDecl(_)
+            | ItemKind::Import(..)
+            | ItemKind::Trait(_)
+            | ItemKind::TypeAlias(_)
+            | ItemKind::Submodules(_)
+            | ItemKind::InnerAttribute(_) => {
                 let item = item.kind.to_string();
                 let error = InterpreterError::UnsupportedTopLevelItemUnquote { item, location };
                 self.errors.push(error.into_compilation_error_pair());
@@ -511,65 +490,91 @@ impl<'context> Elaborator<'context> {
         }
     }
 
-    /// Run all the attributes on each item. The ordering is unspecified to users but currently
-    /// we run trait attributes first to (e.g.) register derive handlers before derive is
-    /// called on structs.
-    /// Returns any new items generated by attributes.
+    /// Run all the attributes on each item in the crate in source-order.
+    /// Source-order is defined as running all child modules before their parent modules are run.
+    /// Child modules of a parent are run in order of their `mod foo;` declarations in the parent.
     pub(super) fn run_attributes(
         &mut self,
         traits: &BTreeMap<TraitId, UnresolvedTrait>,
         types: &BTreeMap<StructId, UnresolvedStruct>,
         functions: &[UnresolvedFunctions],
         module_attributes: &[ModuleAttribute],
-    ) -> CollectedItems {
-        let mut generated_items = CollectedItems::default();
+    ) {
+        let mut attributes_to_run = Vec::new();
 
         for (trait_id, trait_) in traits {
             let attributes = &trait_.trait_def.attributes;
             let item = Value::TraitDefinition(*trait_id);
-            let span = trait_.trait_def.span;
             let context = AttributeContext::new(trait_.file_id, trait_.module_id);
-            self.run_comptime_attributes_on_item(
+            self.collect_comptime_attributes_on_item(
                 attributes,
                 item,
-                span,
                 context,
-                &mut generated_items,
+                &mut attributes_to_run,
             );
         }
 
         for (struct_id, struct_def) in types {
             let attributes = &struct_def.struct_def.attributes;
             let item = Value::StructDefinition(*struct_id);
-            let span = struct_def.struct_def.span;
             let context = AttributeContext::new(struct_def.file_id, struct_def.module_id);
-            self.run_comptime_attributes_on_item(
+            self.collect_comptime_attributes_on_item(
                 attributes,
                 item,
-                span,
                 context,
-                &mut generated_items,
+                &mut attributes_to_run,
             );
         }
 
-        self.run_attributes_on_functions(functions, &mut generated_items);
+        self.collect_attributes_on_functions(functions, &mut attributes_to_run);
+        self.collect_attributes_on_modules(module_attributes, &mut attributes_to_run);
+
+        self.sort_attributes_by_run_order(&mut attributes_to_run);
+
+        // run
+        for (attribute, item, args, context, span) in attributes_to_run {
+            let location = Location::new(span, context.attribute_file);
+
+            let mut generated_items = CollectedItems::default();
+            self.elaborate_in_comptime_context(|this| {
+                if let Err(error) = this.run_attribute(
+                    context,
+                    attribute,
+                    args,
+                    item,
+                    location,
+                    &mut generated_items,
+                ) {
+                    this.errors.push(error);
+                }
+            });
 
-        self.run_attributes_on_modules(module_attributes, &mut generated_items);
+            if !generated_items.is_empty() {
+                self.elaborate_items(generated_items);
+            }
+        }
+    }
+
+    fn sort_attributes_by_run_order(&self, attributes: &mut CollectedAttributes) {
+        let module_order = self.def_maps[&self.crate_id].get_module_topological_order();
 
-        generated_items
+        // Sort each attribute by (module, location in file) so that we can execute in
+        // the order they were defined in, running attributes in child modules first.
+        attributes.sort_by_key(|(_, _, _, ctx, span)| {
+            (module_order[&ctx.attribute_module], span.start())
+        });
     }
 
-    fn run_attributes_on_modules(
+    fn collect_attributes_on_modules(
         &mut self,
         module_attributes: &[ModuleAttribute],
-        generated_items: &mut CollectedItems,
+        attributes_to_run: &mut CollectedAttributes,
     ) {
         for module_attribute in module_attributes {
             let local_id = module_attribute.module_id;
             let module_id = ModuleId { krate: self.crate_id, local_id };
             let item = Value::ModuleDefinition(module_id);
             let attribute = &module_attribute.attribute;
-            let span = Span::default();
 
             let context = AttributeContext {
                 file: module_attribute.file_id,
@@ -578,14 +583,14 @@ impl<'context> Elaborator<'context> {
                 attribute_module: module_attribute.attribute_module_id,
             };
 
-            self.run_comptime_attribute_on_item(attribute, &item, span, context, generated_items);
+            self.collect_comptime_attribute_on_item(attribute, &item, context, attributes_to_run);
         }
     }
 
-    fn run_attributes_on_functions(
+    fn collect_attributes_on_functions(
         &mut self,
         function_sets: &[UnresolvedFunctions],
-        generated_items: &mut CollectedItems,
+        attributes_to_run: &mut CollectedAttributes,
     ) {
         for function_set in function_sets {
             self.self_type = function_set.self_type.clone();
@@ -594,13 +599,11 @@ impl<'context> Elaborator<'context> {
                 let context = AttributeContext::new(function_set.file_id, *local_module);
                 let attributes = function.secondary_attributes();
                 let item = Value::FunctionDefinition(*function_id);
-                let span = function.span();
-                self.run_comptime_attributes_on_item(
+                self.collect_comptime_attributes_on_item(
                     attributes,
                     item,
-                    span,
                     context,
-                    generated_items,
+                    attributes_to_run,
                 );
             }
         }
diff --git a/compiler/noirc_frontend/src/elaborator/expressions.rs b/compiler/noirc_frontend/src/elaborator/expressions.rs
index 46a22bb232f..b4ea06f1030 100644
--- a/compiler/noirc_frontend/src/elaborator/expressions.rs
+++ b/compiler/noirc_frontend/src/elaborator/expressions.rs
@@ -1,34 +1,34 @@
+use acvm::{AcirField, FieldElement};
 use iter_extended::vecmap;
 use noirc_errors::{Location, Span};
-use regex::Regex;
 use rustc_hash::FxHashSet as HashSet;
 
 use crate::{
     ast::{
-        ArrayLiteral, ConstructorExpression, IfExpression, InfixExpression, Lambda, UnaryOp,
-        UnresolvedTypeData, UnresolvedTypeExpression,
+        ArrayLiteral, BlockExpression, CallExpression, CastExpression, ConstructorExpression,
+        Expression, ExpressionKind, Ident, IfExpression, IndexExpression, InfixExpression,
+        ItemVisibility, Lambda, Literal, MemberAccessExpression, MethodCallExpression, Path,
+        PrefixExpression, StatementKind, UnaryOp, UnresolvedTypeData, UnresolvedTypeExpression,
     },
     hir::{
         comptime::{self, InterpreterError},
-        resolution::errors::ResolverError,
+        resolution::{
+            errors::ResolverError, import::PathResolutionError, visibility::method_call_is_visible,
+        },
         type_check::{generics::TraitGenerics, TypeCheckError},
     },
     hir_def::{
         expr::{
             HirArrayLiteral, HirBinaryOp, HirBlockExpression, HirCallExpression, HirCastExpression,
-            HirConstructorExpression, HirExpression, HirIfExpression, HirIndexExpression,
-            HirInfixExpression, HirLambda, HirMemberAccess, HirMethodCallExpression,
+            HirConstructorExpression, HirExpression, HirIdent, HirIfExpression, HirIndexExpression,
+            HirInfixExpression, HirLambda, HirLiteral, HirMemberAccess, HirMethodCallExpression,
             HirPrefixExpression,
         },
-        traits::TraitConstraint,
-    },
-    macros_api::{
-        BlockExpression, CallExpression, CastExpression, Expression, ExpressionKind, HirLiteral,
-        HirStatement, Ident, IndexExpression, Literal, MemberAccessExpression,
-        MethodCallExpression, PrefixExpression, StatementKind,
+        stmt::HirStatement,
+        traits::{ResolvedTraitBound, TraitConstraint},
     },
     node_interner::{DefinitionKind, ExprId, FuncId, InternedStatementKind, TraitMethodId},
-    token::Tokens,
+    token::{FmtStrFragment, Tokens},
     Kind, QuotedType, Shared, StructType, Type,
 };
 
@@ -163,10 +163,10 @@ impl<'context> Elaborator<'context> {
                 (Lit(int), self.polymorphic_integer_or_field())
             }
             Literal::Str(str) | Literal::RawStr(str, _) => {
-                let len = Type::Constant(str.len() as u32, Kind::u32());
+                let len = Type::Constant(str.len().into(), Kind::u32());
                 (Lit(HirLiteral::Str(str)), Type::String(Box::new(len)))
             }
-            Literal::FmtStr(str) => self.elaborate_fmt_string(str, span),
+            Literal::FmtStr(fragments, length) => self.elaborate_fmt_string(fragments, length),
             Literal::Array(array_literal) => {
                 self.elaborate_array_literal(array_literal, span, true)
             }
@@ -205,7 +205,7 @@ impl<'context> Elaborator<'context> {
                     elem_id
                 });
 
-                let length = Type::Constant(elements.len() as u32, Kind::u32());
+                let length = Type::Constant(elements.len().into(), Kind::u32());
                 (HirArrayLiteral::Standard(elements), first_elem_type, length)
             }
             ArrayLiteral::Repeated { repeated_element, length } => {
@@ -213,7 +213,7 @@ impl<'context> Elaborator<'context> {
                 let length =
                     UnresolvedTypeExpression::from_expr(*length, span).unwrap_or_else(|error| {
                         self.push_err(ResolverError::ParserError(Box::new(error)));
-                        UnresolvedTypeExpression::Constant(0, span)
+                        UnresolvedTypeExpression::Constant(FieldElement::zero(), span)
                     });
 
                 let length = self.convert_expression_type(length, &Kind::u32(), span);
@@ -233,45 +233,50 @@ impl<'context> Elaborator<'context> {
         (HirExpression::Literal(constructor(expr)), typ)
     }
 
-    fn elaborate_fmt_string(&mut self, str: String, call_expr_span: Span) -> (HirExpression, Type) {
-        let re = Regex::new(r"\{([a-zA-Z0-9_]+)\}")
-            .expect("ICE: an invalid regex pattern was used for checking format strings");
-
+    fn elaborate_fmt_string(
+        &mut self,
+        fragments: Vec<FmtStrFragment>,
+        length: u32,
+    ) -> (HirExpression, Type) {
         let mut fmt_str_idents = Vec::new();
         let mut capture_types = Vec::new();
 
-        for field in re.find_iter(&str) {
-            let matched_str = field.as_str();
-            let ident_name = &matched_str[1..(matched_str.len() - 1)];
-
-            let scope_tree = self.scopes.current_scope_tree();
-            let variable = scope_tree.find(ident_name);
-            if let Some((old_value, _)) = variable {
-                old_value.num_times_used += 1;
-                let ident = HirExpression::Ident(old_value.ident.clone(), None);
-                let expr_id = self.interner.push_expr(ident);
-                self.interner.push_expr_location(expr_id, call_expr_span, self.file);
-                let ident = old_value.ident.clone();
-                let typ = self.type_check_variable(ident, expr_id, None);
+        for fragment in &fragments {
+            if let FmtStrFragment::Interpolation(ident_name, string_span) = fragment {
+                let scope_tree = self.scopes.current_scope_tree();
+                let variable = scope_tree.find(ident_name);
+
+                let hir_ident = if let Some((old_value, _)) = variable {
+                    old_value.num_times_used += 1;
+                    old_value.ident.clone()
+                } else if let Ok((definition_id, _)) =
+                    self.lookup_global(Path::from_single(ident_name.to_string(), *string_span))
+                {
+                    HirIdent::non_trait_method(
+                        definition_id,
+                        Location::new(*string_span, self.file),
+                    )
+                } else {
+                    self.push_err(ResolverError::VariableNotDeclared {
+                        name: ident_name.to_owned(),
+                        span: *string_span,
+                    });
+                    continue;
+                };
+
+                let hir_expr = HirExpression::Ident(hir_ident.clone(), None);
+                let expr_id = self.interner.push_expr(hir_expr);
+                self.interner.push_expr_location(expr_id, *string_span, self.file);
+                let typ = self.type_check_variable(hir_ident, expr_id, None);
                 self.interner.push_expr_type(expr_id, typ.clone());
                 capture_types.push(typ);
                 fmt_str_idents.push(expr_id);
-            } else if ident_name.parse::<usize>().is_ok() {
-                self.push_err(ResolverError::NumericConstantInFormatString {
-                    name: ident_name.to_owned(),
-                    span: call_expr_span,
-                });
-            } else {
-                self.push_err(ResolverError::VariableNotDeclared {
-                    name: ident_name.to_owned(),
-                    span: call_expr_span,
-                });
             }
         }
 
-        let len = Type::Constant(str.len() as u32, Kind::u32());
+        let len = Type::Constant(length.into(), Kind::u32());
         let typ = Type::FmtString(Box::new(len), Box::new(Type::Tuple(capture_types)));
-        (HirExpression::Literal(HirLiteral::FmtStr(str, fmt_str_idents)), typ)
+        (HirExpression::Literal(HirLiteral::FmtStr(fragments, fmt_str_idents, length)), typ)
     }
 
     fn elaborate_prefix(&mut self, prefix: PrefixExpression, span: Span) -> (ExprId, Type) {
@@ -341,6 +346,10 @@ impl<'context> Elaborator<'context> {
             Type::Array(_, base_type) => *base_type,
             Type::Slice(base_type) => *base_type,
             Type::Error => Type::Error,
+            Type::TypeVariable(_) => {
+                self.push_err(TypeCheckError::TypeAnnotationsNeededForIndex { span: lhs_span });
+                Type::Error
+            }
             typ => {
                 self.push_err(TypeCheckError::TypeMismatch {
                     expected_typ: "Array".to_owned(),
@@ -450,6 +459,8 @@ impl<'context> Elaborator<'context> {
                 let method_call =
                     HirMethodCallExpression { method, object, arguments, location, generics };
 
+                self.check_method_call_visibility(func_id, &object_type, &method_call.method);
+
                 // Desugar the method call into a normal, resolved function call
                 // so that the backend doesn't need to worry about methods
                 // TODO: update object_type here?
@@ -488,6 +499,20 @@ impl<'context> Elaborator<'context> {
         }
     }
 
+    fn check_method_call_visibility(&mut self, func_id: FuncId, object_type: &Type, name: &Ident) {
+        if !method_call_is_visible(
+            object_type,
+            func_id,
+            self.module_id(),
+            self.interner,
+            self.def_maps,
+        ) {
+            self.push_err(ResolverError::PathResolutionError(PathResolutionError::Private(
+                name.clone(),
+            )));
+        }
+    }
+
     fn elaborate_constructor(
         &mut self,
         constructor: ConstructorExpression,
@@ -511,9 +536,6 @@ impl<'context> Elaborator<'context> {
             last_segment.generics = Some(generics.ordered_args);
         }
 
-        let exclude_last_segment = true;
-        self.check_unsupported_turbofish_usage(&path, exclude_last_segment);
-
         let last_segment = path.last_segment();
         let is_self_type = last_segment.ident.is_self_type_name();
 
@@ -550,7 +572,7 @@ impl<'context> Elaborator<'context> {
         let generics = struct_generics.clone();
 
         let fields = constructor.fields;
-        let field_types = r#type.borrow().get_fields(&struct_generics);
+        let field_types = r#type.borrow().get_fields_with_visibility(&struct_generics);
         let fields =
             self.resolve_constructor_expr_fields(struct_type.clone(), field_types, fields, span);
         let expr = HirExpression::Constructor(HirConstructorExpression {
@@ -569,7 +591,7 @@ impl<'context> Elaborator<'context> {
     pub(super) fn mark_struct_as_constructed(&mut self, struct_type: Shared<StructType>) {
         let struct_type = struct_type.borrow();
         let parent_module_id = struct_type.id.parent_module_id(self.def_maps);
-        self.interner.usage_tracker.mark_as_used(parent_module_id, &struct_type.name);
+        self.usage_tracker.mark_as_used(parent_module_id, &struct_type.name);
     }
 
     /// Resolve all the fields of a struct constructor expression.
@@ -578,7 +600,7 @@ impl<'context> Elaborator<'context> {
     fn resolve_constructor_expr_fields(
         &mut self,
         struct_type: Shared<StructType>,
-        field_types: Vec<(String, Type)>,
+        field_types: Vec<(String, ItemVisibility, Type)>,
         fields: Vec<(Ident, Expression)>,
         span: Span,
     ) -> Vec<(Ident, ExprId)> {
@@ -590,10 +612,11 @@ impl<'context> Elaborator<'context> {
             let expected_field_with_index = field_types
                 .iter()
                 .enumerate()
-                .find(|(_, (name, _))| name == &field_name.0.contents);
-            let expected_index = expected_field_with_index.map(|(index, _)| index);
+                .find(|(_, (name, _, _))| name == &field_name.0.contents);
+            let expected_index_and_visibility =
+                expected_field_with_index.map(|(index, (_, visibility, _))| (index, visibility));
             let expected_type =
-                expected_field_with_index.map(|(_, (_, typ))| typ).unwrap_or(&Type::Error);
+                expected_field_with_index.map(|(_, (_, _, typ))| typ).unwrap_or(&Type::Error);
 
             let field_span = field.span;
             let (resolved, field_type) = self.elaborate_expression(field);
@@ -620,11 +643,21 @@ impl<'context> Elaborator<'context> {
                 });
             }
 
-            if let Some(expected_index) = expected_index {
+            if let Some((index, visibility)) = expected_index_and_visibility {
+                let struct_type = struct_type.borrow();
+                let field_span = field_name.span();
+                let field_name = &field_name.0.contents;
+                self.check_struct_field_visibility(
+                    &struct_type,
+                    field_name,
+                    *visibility,
+                    field_span,
+                );
+
                 self.interner.add_struct_member_reference(
-                    struct_type.borrow().id,
-                    expected_index,
-                    Location::new(field_name.span(), self.file),
+                    struct_type.id,
+                    index,
+                    Location::new(field_span, self.file),
                 );
             }
 
@@ -667,7 +700,7 @@ impl<'context> Elaborator<'context> {
     fn elaborate_cast(&mut self, cast: CastExpression, span: Span) -> (HirExpression, Type) {
         let (lhs, lhs_type) = self.elaborate_expression(cast.lhs);
         let r#type = self.resolve_type(cast.r#type);
-        let result = self.check_cast(&lhs_type, &r#type, span);
+        let result = self.check_cast(&lhs, &lhs_type, &r#type, span);
         let expr = HirExpression::Cast(HirCastExpression { lhs, r#type });
         (expr, result)
     }
@@ -715,9 +748,11 @@ impl<'context> Elaborator<'context> {
                     // that implements the trait.
                     let constraint = TraitConstraint {
                         typ: operand_type.clone(),
-                        trait_id: trait_id.trait_id,
-                        trait_generics: TraitGenerics::default(),
-                        span,
+                        trait_bound: ResolvedTraitBound {
+                            trait_id: trait_id.trait_id,
+                            trait_generics: TraitGenerics::default(),
+                            span,
+                        },
                     };
                     self.push_trait_constraint(constraint, expr_id);
                     self.type_check_operator_method(expr_id, trait_id, operand_type, span);
@@ -872,7 +907,17 @@ impl<'context> Elaborator<'context> {
 
         let location = Location::new(span, self.file);
         match value.into_expression(self.interner, location) {
-            Ok(new_expr) => self.elaborate_expression(new_expr),
+            Ok(new_expr) => {
+                // At this point the Expression was already elaborated and we got a Value.
+                // We'll elaborate this value turned into Expression to inline it and get
+                // an ExprId and Type, but we don't want any visibility errors to happen
+                // here (they could if we have `Foo { inner: 5 }` and `inner` is not
+                // accessible from where this expression is being elaborated).
+                self.silence_field_visibility_errors += 1;
+                let value = self.elaborate_expression(new_expr);
+                self.silence_field_visibility_errors -= 1;
+                value
+            }
             Err(error) => make_error(self, error),
         }
     }
diff --git a/compiler/noirc_frontend/src/elaborator/lints.rs b/compiler/noirc_frontend/src/elaborator/lints.rs
index 8253921d305..d3b776bea24 100644
--- a/compiler/noirc_frontend/src/elaborator/lints.rs
+++ b/compiler/noirc_frontend/src/elaborator/lints.rs
@@ -1,15 +1,18 @@
 use crate::{
-    ast::{FunctionKind, Ident},
+    ast::{Ident, NoirFunction, Signedness, UnaryOp, Visibility},
     graph::CrateId,
     hir::{
         resolution::errors::{PubPosition, ResolverError},
         type_check::TypeCheckError,
     },
-    hir_def::{expr::HirIdent, function::FuncMeta},
-    macros_api::{
-        HirExpression, HirLiteral, NodeInterner, NoirFunction, Signedness, UnaryOp, Visibility,
+    hir_def::{
+        expr::{HirBlockExpression, HirExpression, HirIdent, HirLiteral},
+        function::FuncMeta,
+        stmt::HirStatement,
+    },
+    node_interner::{
+        DefinitionId, DefinitionKind, ExprId, FuncId, FunctionModifiers, NodeInterner,
     },
-    node_interner::{DefinitionKind, ExprId, FuncId, FunctionModifiers},
     Type,
 };
 
@@ -64,7 +67,7 @@ pub(super) fn low_level_function_outside_stdlib(
     crate_id: CrateId,
 ) -> Option<ResolverError> {
     let is_low_level_function =
-        modifiers.attributes.function.as_ref().map_or(false, |func| func.is_low_level());
+        modifiers.attributes.function().map_or(false, |func| func.is_low_level());
     if !crate_id.is_stdlib() && is_low_level_function {
         let ident = func_meta_name_ident(func, modifiers);
         Some(ResolverError::LowLevelFunctionOutsideOfStdlib { ident })
@@ -78,8 +81,7 @@ pub(super) fn oracle_not_marked_unconstrained(
     func: &FuncMeta,
     modifiers: &FunctionModifiers,
 ) -> Option<ResolverError> {
-    let is_oracle_function =
-        modifiers.attributes.function.as_ref().map_or(false, |func| func.is_oracle());
+    let is_oracle_function = modifiers.attributes.function().map_or(false, |func| func.is_oracle());
     if is_oracle_function && !modifiers.is_unconstrained {
         let ident = func_meta_name_ident(func, modifiers);
         Some(ResolverError::OracleMarkedAsConstrained { ident })
@@ -102,8 +104,7 @@ pub(super) fn oracle_called_from_constrained_function(
     }
 
     let function_attributes = interner.function_attributes(called_func);
-    let is_oracle_call =
-        function_attributes.function.as_ref().map_or(false, |func| func.is_oracle());
+    let is_oracle_call = function_attributes.function().map_or(false, |func| func.is_oracle());
     if is_oracle_call {
         Some(ResolverError::UnconstrainedOracleReturnToConstrained { span })
     } else {
@@ -124,19 +125,6 @@ pub(super) fn missing_pub(func: &FuncMeta, modifiers: &FunctionModifiers) -> Opt
     }
 }
 
-/// `#[recursive]` attribute is only allowed for entry point functions
-pub(super) fn recursive_non_entrypoint_function(
-    func: &FuncMeta,
-    modifiers: &FunctionModifiers,
-) -> Option<ResolverError> {
-    if !func.is_entry_point && func.kind == FunctionKind::Recursive {
-        let ident = func_meta_name_ident(func, modifiers);
-        Some(ResolverError::MisplacedRecursiveAttribute { ident })
-    } else {
-        None
-    }
-}
-
 /// Check that we are not passing a mutable reference from a constrained runtime to an unconstrained runtime.
 pub(super) fn unconstrained_function_args(
     function_args: &[(Type, ExprId, Span)],
@@ -263,3 +251,77 @@ pub(crate) fn overflowing_int(
 fn func_meta_name_ident(func: &FuncMeta, modifiers: &FunctionModifiers) -> Ident {
     Ident(Spanned::from(func.name.location.span, modifiers.name.clone()))
 }
+
+/// Check that a recursive function *can* return without endlessly calling itself.
+pub(crate) fn unbounded_recursion<'a>(
+    interner: &'a NodeInterner,
+    func_id: FuncId,
+    func_name: impl FnOnce() -> &'a str,
+    func_span: Span,
+    body_id: ExprId,
+) -> Option<ResolverError> {
+    if !can_return_without_recursing(interner, func_id, body_id) {
+        Some(ResolverError::UnconditionalRecursion {
+            name: func_name().to_string(),
+            span: func_span,
+        })
+    } else {
+        None
+    }
+}
+
+/// Check if an expression will end up calling a specific function.
+fn can_return_without_recursing(interner: &NodeInterner, func_id: FuncId, expr_id: ExprId) -> bool {
+    let check = |e| can_return_without_recursing(interner, func_id, e);
+
+    let check_block = |block: HirBlockExpression| {
+        block.statements.iter().all(|stmt_id| match interner.statement(stmt_id) {
+            HirStatement::Let(s) => check(s.expression),
+            HirStatement::Assign(s) => check(s.expression),
+            HirStatement::Expression(e) => check(e),
+            HirStatement::Semi(e) => check(e),
+            // Rust doesn't seem to check the for loop body (it's bounds might mean it's never called).
+            HirStatement::For(e) => check(e.start_range) && check(e.end_range),
+            HirStatement::Constrain(_)
+            | HirStatement::Comptime(_)
+            | HirStatement::Break
+            | HirStatement::Continue
+            | HirStatement::Error => true,
+        })
+    };
+
+    match interner.expression(&expr_id) {
+        HirExpression::Ident(ident, _) => {
+            if ident.id == DefinitionId::dummy_id() {
+                return true;
+            }
+            let definition = interner.definition(ident.id);
+            if let DefinitionKind::Function(id) = definition.kind {
+                func_id != id
+            } else {
+                true
+            }
+        }
+        HirExpression::Block(b) => check_block(b),
+        HirExpression::Prefix(e) => check(e.rhs),
+        HirExpression::Infix(e) => check(e.lhs) && check(e.rhs),
+        HirExpression::Index(e) => check(e.collection) && check(e.index),
+        HirExpression::MemberAccess(e) => check(e.lhs),
+        HirExpression::Call(e) => check(e.func) && e.arguments.iter().cloned().all(check),
+        HirExpression::MethodCall(e) => check(e.object) && e.arguments.iter().cloned().all(check),
+        HirExpression::Cast(e) => check(e.lhs),
+        HirExpression::If(e) => {
+            check(e.condition) && (check(e.consequence) || e.alternative.map(check).unwrap_or(true))
+        }
+        HirExpression::Tuple(e) => e.iter().cloned().all(check),
+        HirExpression::Unsafe(b) => check_block(b),
+        // Rust doesn't check the lambda body (it might not be called).
+        HirExpression::Lambda(_)
+        | HirExpression::Literal(_)
+        | HirExpression::Constructor(_)
+        | HirExpression::Quote(_)
+        | HirExpression::Unquote(_)
+        | HirExpression::Comptime(_)
+        | HirExpression::Error => true,
+    }
+}
diff --git a/compiler/noirc_frontend/src/elaborator/mod.rs b/compiler/noirc_frontend/src/elaborator/mod.rs
index c5e457c405b..fe1d1e38e1a 100644
--- a/compiler/noirc_frontend/src/elaborator/mod.rs
+++ b/compiler/noirc_frontend/src/elaborator/mod.rs
@@ -4,59 +4,48 @@ use std::{
 };
 
 use crate::{
-    ast::{FunctionKind, GenericTypeArgs, UnresolvedTraitConstraint},
+    ast::ItemVisibility, hir_def::traits::ResolvedTraitBound, usage_tracker::UsageTracker,
+    StructField, StructType, TypeBindings,
+};
+use crate::{
+    ast::{
+        BlockExpression, FunctionKind, GenericTypeArgs, Ident, NoirFunction, NoirStruct, Param,
+        Path, Pattern, TraitBound, UnresolvedGeneric, UnresolvedGenerics,
+        UnresolvedTraitConstraint, UnresolvedTypeData, UnsupportedNumericGenericType,
+    },
+    graph::CrateId,
     hir::{
         def_collector::dc_crate::{
-            filter_literal_globals, CompilationError, ImplMap, UnresolvedGlobal, UnresolvedStruct,
-            UnresolvedTypeAlias,
+            filter_literal_globals, CompilationError, ImplMap, UnresolvedFunctions,
+            UnresolvedGlobal, UnresolvedStruct, UnresolvedTraitImpl, UnresolvedTypeAlias,
         },
-        def_map::DefMaps,
+        def_collector::{dc_crate::CollectedItems, errors::DefCollectorErrorKind},
+        def_map::{DefMaps, ModuleData},
+        def_map::{LocalModuleId, ModuleId, MAIN_FUNCTION},
         resolution::errors::ResolverError,
         scope::ScopeForest as GenericScopeForest,
         type_check::{generics::TraitGenerics, TypeCheckError},
+        Context,
     },
+    hir_def::traits::TraitImpl,
     hir_def::{
         expr::{HirCapturedVar, HirIdent},
-        function::FunctionBody,
+        function::{FuncMeta, FunctionBody, HirFunction},
         traits::TraitConstraint,
         types::{Generics, Kind, ResolvedGeneric},
     },
-    macros_api::{
-        BlockExpression, Ident, NodeInterner, NoirFunction, NoirStruct, Pattern,
-        SecondaryAttribute, StructId,
-    },
     node_interner::{
-        DefinitionKind, DependencyId, ExprId, FuncId, FunctionModifiers, GlobalId, ReferenceId,
-        TraitId, TypeAliasId,
+        DefinitionKind, DependencyId, ExprId, FuncId, FunctionModifiers, GlobalId, NodeInterner,
+        ReferenceId, StructId, TraitId, TraitImplId, TypeAliasId,
     },
-    token::CustomAttribute,
+    token::SecondaryAttribute,
     Shared, Type, TypeVariable,
 };
-use crate::{
-    ast::{TraitBound, UnresolvedGeneric, UnresolvedGenerics},
-    graph::CrateId,
-    hir::{
-        def_collector::{dc_crate::CollectedItems, errors::DefCollectorErrorKind},
-        def_map::{LocalModuleId, ModuleDefId, ModuleId, MAIN_FUNCTION},
-        resolution::import::PathResolution,
-        Context,
-    },
-    hir_def::function::{FuncMeta, HirFunction},
-    macros_api::{Param, Path, UnresolvedTypeData},
-    node_interner::TraitImplId,
-};
-use crate::{
-    hir::{
-        def_collector::dc_crate::{UnresolvedFunctions, UnresolvedTraitImpl},
-        def_map::ModuleData,
-    },
-    hir_def::traits::TraitImpl,
-    macros_api::ItemVisibility,
-};
 
 mod comptime;
 mod expressions;
 mod lints;
+mod path_resolution;
 mod patterns;
 mod scope;
 mod statements;
@@ -67,7 +56,9 @@ mod unquote;
 
 use fm::FileId;
 use iter_extended::vecmap;
-use noirc_errors::{Location, Span};
+use noirc_errors::{Location, Span, Spanned};
+use path_resolution::{PathResolution, PathResolutionItem};
+use types::bind_ordered_generics;
 
 use self::traits::check_trait_impl_method_matches_declaration;
 
@@ -94,8 +85,8 @@ pub struct Elaborator<'context> {
     pub(crate) errors: Vec<(CompilationError, FileId)>,
 
     pub(crate) interner: &'context mut NodeInterner,
-
     pub(crate) def_maps: &'context mut DefMaps,
+    pub(crate) usage_tracker: &'context mut UsageTracker,
 
     pub(crate) file: FileId,
 
@@ -173,6 +164,12 @@ pub struct Elaborator<'context> {
     unresolved_globals: BTreeMap<GlobalId, UnresolvedGlobal>,
 
     pub(crate) interpreter_call_stack: im::Vector<Location>,
+
+    /// If greater than 0, field visibility errors won't be reported.
+    /// This is used when elaborating a comptime expression that is a struct constructor
+    /// like `Foo { inner: 5 }`: in that case we already elaborated the code that led to
+    /// that comptime value and any visibility errors were already reported.
+    silence_field_visibility_errors: usize,
 }
 
 #[derive(Default)]
@@ -193,6 +190,7 @@ impl<'context> Elaborator<'context> {
     pub fn new(
         interner: &'context mut NodeInterner,
         def_maps: &'context mut DefMaps,
+        usage_tracker: &'context mut UsageTracker,
         crate_id: CrateId,
         debug_comptime_in_file: Option<FileId>,
         interpreter_call_stack: im::Vector<Location>,
@@ -202,6 +200,7 @@ impl<'context> Elaborator<'context> {
             errors: Vec::new(),
             interner,
             def_maps,
+            usage_tracker,
             file: FileId::dummy(),
             in_unsafe_block: false,
             nested_loops: 0,
@@ -220,6 +219,7 @@ impl<'context> Elaborator<'context> {
             current_trait: None,
             interpreter_call_stack,
             in_comptime_context: false,
+            silence_field_visibility_errors: 0,
         }
     }
 
@@ -231,6 +231,7 @@ impl<'context> Elaborator<'context> {
         Self::new(
             &mut context.def_interner,
             &mut context.def_maps,
+            &mut context.usage_tracker,
             crate_id,
             debug_comptime_in_file,
             im::Vector::new(),
@@ -306,23 +307,13 @@ impl<'context> Elaborator<'context> {
 
         // We have to run any comptime attributes on functions before the function is elaborated
         // since the generated items are checked beforehand as well.
-        let generated_items = self.run_attributes(
+        self.run_attributes(
             &items.traits,
             &items.types,
             &items.functions,
             &items.module_attributes,
         );
 
-        // After everything is collected, we can elaborate our generated items.
-        // It may be better to inline these within `items` entirely since elaborating them
-        // all here means any globals will not see these. Inlining them completely within `items`
-        // means we must be more careful about missing any additional items that need to be already
-        // elaborated. E.g. if a new struct is created, we've already passed the code path to
-        // elaborate them.
-        if !generated_items.is_empty() {
-            self.elaborate_items(generated_items);
-        }
-
         for functions in items.functions {
             self.elaborate_functions(functions);
         }
@@ -359,8 +350,9 @@ impl<'context> Elaborator<'context> {
     fn introduce_generics_into_scope(&mut self, all_generics: Vec<ResolvedGeneric>) {
         // Introduce all numeric generics into scope
         for generic in &all_generics {
-            if let Kind::Numeric(typ) = &generic.kind {
-                let definition = DefinitionKind::GenericType(generic.type_var.clone());
+            if let Kind::Numeric(typ) = &generic.kind() {
+                let definition =
+                    DefinitionKind::NumericGeneric(generic.type_var.clone(), typ.clone());
                 let ident = Ident::new(generic.name.to_string(), generic.span);
                 let hir_ident = self.add_variable_decl(
                     ident, false, // mutable
@@ -410,13 +402,39 @@ impl<'context> Elaborator<'context> {
 
         self.run_function_lints(&func_meta, &modifiers);
 
+        // Check arg and return-value visibility of standalone functions.
+        if self.should_check_function_visibility(&func_meta, &modifiers) {
+            let name = Ident(Spanned::from(
+                func_meta.name.location.span,
+                self.interner.definition_name(func_meta.name.id).to_string(),
+            ));
+            for (_, typ, _) in func_meta.parameters.iter() {
+                self.check_type_is_not_more_private_then_item(
+                    &name,
+                    modifiers.visibility,
+                    typ,
+                    name.span(),
+                );
+            }
+            self.check_type_is_not_more_private_then_item(
+                &name,
+                modifiers.visibility,
+                func_meta.return_type(),
+                name.span(),
+            );
+        }
+
         self.introduce_generics_into_scope(func_meta.all_generics.clone());
 
         // The DefinitionIds for each parameter were already created in define_function_meta
         // so we need to reintroduce the same IDs into scope here.
         for parameter in &func_meta.parameter_idents {
             let name = self.interner.definition_name(parameter.id).to_owned();
-            self.add_existing_variable_to_scope(name, parameter.clone(), true);
+            if name == "_" {
+                continue;
+            }
+            let warn_if_unused = !(func_meta.trait_impl.is_some() && name == "self");
+            self.add_existing_variable_to_scope(name, parameter.clone(), warn_if_unused);
         }
 
         self.add_trait_constraints_to_scope(&func_meta);
@@ -425,7 +443,7 @@ impl<'context> Elaborator<'context> {
             FunctionKind::Builtin | FunctionKind::LowLevel | FunctionKind::Oracle => {
                 (HirFunction::empty(), Type::Error)
             }
-            FunctionKind::Normal | FunctionKind::Recursive => {
+            FunctionKind::Normal => {
                 let (block, body_type) = self.elaborate_block(body);
                 let expr_id = self.intern_expr(block, body_span);
                 self.interner.push_expr_type(expr_id, body_type.clone());
@@ -446,7 +464,8 @@ impl<'context> Elaborator<'context> {
 
         // Now remove all the `where` clause constraints we added
         for constraint in &func_meta.trait_constraints {
-            self.interner.remove_assumed_trait_implementations_for_trait(constraint.trait_id);
+            self.interner
+                .remove_assumed_trait_implementations_for_trait(constraint.trait_bound.trait_id);
         }
 
         let func_scope_tree = self.scopes.end_function();
@@ -456,6 +475,20 @@ impl<'context> Elaborator<'context> {
             self.check_for_unused_variables_in_scope_tree(func_scope_tree);
         }
 
+        // Check that the body can return without calling the function.
+        if let FunctionKind::Normal = kind {
+            self.run_lint(|elaborator| {
+                lints::unbounded_recursion(
+                    elaborator.interner,
+                    id,
+                    || elaborator.interner.definition_name(func_meta.name.id),
+                    func_meta.name.location.span,
+                    hir_func.as_expr(),
+                )
+                .map(Into::into)
+            });
+        }
+
         let meta = self
             .interner
             .func_meta
@@ -475,9 +508,9 @@ impl<'context> Elaborator<'context> {
         let context = self.function_context.pop().expect("Imbalanced function_context pushes");
 
         for typ in context.type_variables {
-            if let Type::TypeVariable(variable, kind) = typ.follow_bindings() {
+            if let Type::TypeVariable(variable) = typ.follow_bindings() {
                 let msg = "TypeChecker should only track defaultable type vars";
-                variable.bind(kind.default_type().expect(msg));
+                variable.bind(variable.kind().default_type().expect(msg));
             }
         }
 
@@ -492,9 +525,9 @@ impl<'context> Elaborator<'context> {
 
             self.verify_trait_constraint(
                 &constraint.typ,
-                constraint.trait_id,
-                &constraint.trait_generics.ordered,
-                &constraint.trait_generics.named,
+                constraint.trait_bound.trait_id,
+                &constraint.trait_bound.trait_generics.ordered,
+                &constraint.trait_bound.trait_generics.named,
                 expr_id,
                 span,
             );
@@ -515,14 +548,16 @@ impl<'context> Elaborator<'context> {
         trait_constraints: &mut Vec<TraitConstraint>,
     ) -> Type {
         let new_generic_id = self.interner.next_type_variable_id();
-        let new_generic = TypeVariable::unbound(new_generic_id);
+
+        let new_generic = TypeVariable::unbound(new_generic_id, Kind::Normal);
         generics.push(new_generic.clone());
 
         let name = format!("impl {trait_path}");
-        let generic_type = Type::NamedGeneric(new_generic, Rc::new(name), Kind::Normal);
+        let generic_type = Type::NamedGeneric(new_generic, Rc::new(name));
         let trait_bound = TraitBound { trait_path, trait_id: None, trait_generics };
 
-        if let Some(new_constraint) = self.resolve_trait_bound(&trait_bound, generic_type.clone()) {
+        if let Some(trait_bound) = self.resolve_trait_bound(&trait_bound) {
+            let new_constraint = TraitConstraint { typ: generic_type.clone(), trait_bound };
             trait_constraints.push(new_constraint);
         }
 
@@ -534,19 +569,20 @@ impl<'context> Elaborator<'context> {
     pub fn add_generics(&mut self, generics: &UnresolvedGenerics) -> Generics {
         vecmap(generics, |generic| {
             let mut is_error = false;
-            let (type_var, name, kind) = match self.resolve_generic(generic) {
+            let (type_var, name) = match self.resolve_generic(generic) {
                 Ok(values) => values,
                 Err(error) => {
                     self.push_err(error);
                     is_error = true;
                     let id = self.interner.next_type_variable_id();
-                    (TypeVariable::unbound(id), Rc::new("(error)".into()), Kind::Normal)
+                    let kind = self.resolve_generic_kind(generic);
+                    (TypeVariable::unbound(id, kind), Rc::new("(error)".into()))
                 }
             };
 
             let span = generic.span();
             let name_owned = name.as_ref().clone();
-            let resolved_generic = ResolvedGeneric { name, type_var, kind, span };
+            let resolved_generic = ResolvedGeneric { name, type_var, span };
 
             // Check for name collisions of this generic
             // Checking `is_error` here prevents DuplicateDefinition errors when
@@ -571,25 +607,22 @@ impl<'context> Elaborator<'context> {
     fn resolve_generic(
         &mut self,
         generic: &UnresolvedGeneric,
-    ) -> Result<(TypeVariable, Rc<String>, Kind), ResolverError> {
+    ) -> Result<(TypeVariable, Rc<String>), ResolverError> {
         // Map the generic to a fresh type variable
         match generic {
             UnresolvedGeneric::Variable(_) | UnresolvedGeneric::Numeric { .. } => {
                 let id = self.interner.next_type_variable_id();
-                let typevar = TypeVariable::unbound(id);
-                let ident = generic.ident();
-
                 let kind = self.resolve_generic_kind(generic);
+                let typevar = TypeVariable::unbound(id, kind);
+                let ident = generic.ident();
                 let name = Rc::new(ident.0.contents.clone());
-                Ok((typevar, name, kind))
+                Ok((typevar, name))
             }
             // An already-resolved generic is only possible if it is the result of a
             // previous macro call being inserted into a generics list.
             UnresolvedGeneric::Resolved(id, span) => {
                 match self.interner.get_quoted_type(*id).follow_bindings() {
-                    Type::NamedGeneric(type_variable, name, kind) => {
-                        Ok((type_variable, name, kind))
-                    }
+                    Type::NamedGeneric(type_variable, name) => Ok((type_variable.clone(), name)),
                     other => Err(ResolverError::MacroResultInGenericsListNotAGeneric {
                         span: *span,
                         typ: other.clone(),
@@ -604,20 +637,24 @@ impl<'context> Elaborator<'context> {
     /// sure only primitive numeric types are being used.
     pub(super) fn resolve_generic_kind(&mut self, generic: &UnresolvedGeneric) -> Kind {
         if let UnresolvedGeneric::Numeric { ident, typ } = generic {
-            let typ = typ.clone();
-            let typ = if typ.is_type_expression() {
-                self.resolve_type_inner(typ, &Kind::Numeric(Box::new(Type::default_int_type())))
+            let unresolved_typ = typ.clone();
+            let typ = if unresolved_typ.is_type_expression() {
+                self.resolve_type_inner(
+                    unresolved_typ.clone(),
+                    &Kind::numeric(Type::default_int_type()),
+                )
             } else {
-                self.resolve_type(typ.clone())
+                self.resolve_type(unresolved_typ.clone())
             };
             if !matches!(typ, Type::FieldElement | Type::Integer(_, _)) {
-                let unsupported_typ_err = ResolverError::UnsupportedNumericGenericType {
-                    ident: ident.clone(),
-                    typ: typ.clone(),
-                };
+                let unsupported_typ_err =
+                    ResolverError::UnsupportedNumericGenericType(UnsupportedNumericGenericType {
+                        ident: ident.clone(),
+                        typ: unresolved_typ.typ.clone(),
+                    });
                 self.push_err(unsupported_typ_err);
             }
-            Kind::Numeric(Box::new(typ))
+            Kind::numeric(typ)
         } else {
             Kind::Normal
         }
@@ -635,11 +672,11 @@ impl<'context> Elaborator<'context> {
 
     pub fn resolve_module_by_path(&mut self, path: Path) -> Option<ModuleId> {
         match self.resolve_path(path.clone()) {
-            Ok(PathResolution { module_def_id: ModuleDefId::ModuleId(module_id), error }) => {
-                if error.is_some() {
-                    None
-                } else {
+            Ok(PathResolution { item: PathResolutionItem::Module(module_id), errors }) => {
+                if errors.is_empty() {
                     Some(module_id)
+                } else {
+                    None
                 }
             }
             _ => None,
@@ -648,8 +685,8 @@ impl<'context> Elaborator<'context> {
 
     fn resolve_trait_by_path(&mut self, path: Path) -> Option<TraitId> {
         let error = match self.resolve_path(path.clone()) {
-            Ok(PathResolution { module_def_id: ModuleDefId::TraitId(trait_id), error }) => {
-                if let Some(error) = error {
+            Ok(PathResolution { item: PathResolutionItem::Trait(trait_id), errors }) => {
+                for error in errors {
                     self.push_err(error);
                 }
                 return Some(trait_id);
@@ -678,14 +715,11 @@ impl<'context> Elaborator<'context> {
         constraint: &UnresolvedTraitConstraint,
     ) -> Option<TraitConstraint> {
         let typ = self.resolve_type(constraint.typ.clone());
-        self.resolve_trait_bound(&constraint.trait_bound, typ)
+        let trait_bound = self.resolve_trait_bound(&constraint.trait_bound)?;
+        Some(TraitConstraint { typ, trait_bound })
     }
 
-    pub fn resolve_trait_bound(
-        &mut self,
-        bound: &TraitBound,
-        typ: Type,
-    ) -> Option<TraitConstraint> {
+    pub fn resolve_trait_bound(&mut self, bound: &TraitBound) -> Option<ResolvedTraitBound> {
         let the_trait = self.lookup_trait_or_error(bound.trait_path.clone())?;
         let trait_id = the_trait.id;
         let span = bound.trait_path.span;
@@ -693,7 +727,7 @@ impl<'context> Elaborator<'context> {
         let (ordered, named) = self.resolve_type_args(bound.trait_generics.clone(), trait_id, span);
 
         let trait_generics = TraitGenerics { ordered, named };
-        Some(TraitConstraint { typ, trait_id, trait_generics, span })
+        Some(ResolvedTraitBound { trait_id, trait_generics, span })
     }
 
     /// Extract metadata from a NoirFunction
@@ -749,6 +783,7 @@ impl<'context> Elaborator<'context> {
                 UnresolvedTypeData::TraitAsType(path, args) => {
                     self.desugar_impl_trait_arg(path, args, &mut generics, &mut trait_constraints)
                 }
+                // Function parameters have Kind::Normal
                 _ => self.resolve_type_inner(typ, &Kind::Normal),
             };
 
@@ -760,7 +795,7 @@ impl<'context> Elaborator<'context> {
             );
 
             if is_entry_point {
-                self.mark_parameter_type_as_used(&typ);
+                self.mark_type_as_used(&typ);
             }
 
             let pattern = self.elaborate_pattern_and_store_ids(
@@ -769,7 +804,6 @@ impl<'context> Elaborator<'context> {
                 DefinitionKind::Local(None),
                 &mut parameter_idents,
                 true, // warn_if_unused
-                None,
             );
 
             parameters.push((pattern, typ.clone(), visibility));
@@ -805,11 +839,6 @@ impl<'context> Elaborator<'context> {
             None
         };
 
-        let attributes = func.secondary_attributes().iter();
-        let attributes =
-            attributes.filter_map(|secondary_attribute| secondary_attribute.as_custom());
-        let attributes: Vec<CustomAttribute> = attributes.cloned().collect();
-
         let meta = FuncMeta {
             name: name_ident,
             kind: func.kind,
@@ -833,7 +862,6 @@ impl<'context> Elaborator<'context> {
             function_body: FunctionBody::Unresolved(func.kind, body, func.def.span),
             self_type: self.self_type.clone(),
             source_file: self.file,
-            custom_attributes: attributes,
         };
 
         self.interner.push_fn_meta(meta, func_id);
@@ -841,30 +869,37 @@ impl<'context> Elaborator<'context> {
         self.current_item = None;
     }
 
-    fn mark_parameter_type_as_used(&mut self, typ: &Type) {
+    fn mark_type_as_used(&mut self, typ: &Type) {
         match typ {
-            Type::Array(_n, typ) => self.mark_parameter_type_as_used(typ),
-            Type::Slice(typ) => self.mark_parameter_type_as_used(typ),
+            Type::Array(_n, typ) => self.mark_type_as_used(typ),
+            Type::Slice(typ) => self.mark_type_as_used(typ),
             Type::Tuple(types) => {
                 for typ in types {
-                    self.mark_parameter_type_as_used(typ);
+                    self.mark_type_as_used(typ);
                 }
             }
             Type::Struct(struct_type, generics) => {
                 self.mark_struct_as_constructed(struct_type.clone());
                 for generic in generics {
-                    self.mark_parameter_type_as_used(generic);
+                    self.mark_type_as_used(generic);
+                }
+                for (_, typ) in struct_type.borrow().get_fields(generics) {
+                    self.mark_type_as_used(&typ);
                 }
             }
             Type::Alias(alias_type, generics) => {
-                self.mark_parameter_type_as_used(&alias_type.borrow().get_type(generics));
+                self.mark_type_as_used(&alias_type.borrow().get_type(generics));
+            }
+            Type::CheckedCast { from, to } => {
+                self.mark_type_as_used(from);
+                self.mark_type_as_used(to);
             }
             Type::MutableReference(typ) => {
-                self.mark_parameter_type_as_used(typ);
+                self.mark_type_as_used(typ);
             }
             Type::InfixExpr(left, _op, right) => {
-                self.mark_parameter_type_as_used(left);
-                self.mark_parameter_type_as_used(right);
+                self.mark_type_as_used(left);
+                self.mark_type_as_used(right);
             }
             Type::FieldElement
             | Type::Integer(..)
@@ -881,15 +916,6 @@ impl<'context> Elaborator<'context> {
             | Type::Forall(..)
             | Type::Error => (),
         }
-
-        if let Type::Alias(alias_type, generics) = typ {
-            self.mark_parameter_type_as_used(&alias_type.borrow().get_type(generics));
-            return;
-        }
-
-        if let Type::Struct(struct_type, _generics) = typ {
-            self.mark_struct_as_constructed(struct_type.clone());
-        }
     }
 
     fn run_function_lints(&mut self, func: &FuncMeta, modifiers: &FunctionModifiers) {
@@ -904,9 +930,6 @@ impl<'context> Elaborator<'context> {
             lints::low_level_function_outside_stdlib(func, modifiers, elaborator.crate_id)
                 .map(Into::into)
         });
-        self.run_lint(|_| {
-            lints::recursive_non_entrypoint_function(func, modifiers).map(Into::into)
-        });
     }
 
     /// Only sized types are valid to be used as main's parameters or the parameters to a contract
@@ -957,21 +980,52 @@ impl<'context> Elaborator<'context> {
 
     fn add_trait_constraints_to_scope(&mut self, func_meta: &FuncMeta) {
         for constraint in &func_meta.trait_constraints {
-            let object = constraint.typ.clone();
-            let trait_id = constraint.trait_id;
-            let generics = constraint.trait_generics.clone();
-
-            if !self.interner.add_assumed_trait_implementation(object, trait_id, generics) {
-                if let Some(the_trait) = self.interner.try_get_trait(trait_id) {
-                    let trait_name = the_trait.name.to_string();
-                    let typ = constraint.typ.clone();
-                    let span = func_meta.location.span;
-                    self.push_err(TypeCheckError::UnneededTraitConstraint {
-                        trait_name,
-                        typ,
-                        span,
-                    });
+            self.add_trait_bound_to_scope(
+                func_meta,
+                &constraint.typ,
+                &constraint.trait_bound,
+                constraint.trait_bound.trait_id,
+            );
+        }
+    }
+
+    fn add_trait_bound_to_scope(
+        &mut self,
+        func_meta: &FuncMeta,
+        object: &Type,
+        trait_bound: &ResolvedTraitBound,
+        starting_trait_id: TraitId,
+    ) {
+        let trait_id = trait_bound.trait_id;
+        let generics = trait_bound.trait_generics.clone();
+
+        if !self.interner.add_assumed_trait_implementation(object.clone(), trait_id, generics) {
+            if let Some(the_trait) = self.interner.try_get_trait(trait_id) {
+                let trait_name = the_trait.name.to_string();
+                let typ = object.clone();
+                let span = func_meta.location.span;
+                self.push_err(TypeCheckError::UnneededTraitConstraint { trait_name, typ, span });
+            }
+        }
+
+        // Also add assumed implementations for the parent traits, if any
+        if let Some(trait_bounds) =
+            self.interner.try_get_trait(trait_id).map(|the_trait| the_trait.trait_bounds.clone())
+        {
+            for parent_trait_bound in trait_bounds {
+                // Avoid looping forever in case there are cycles
+                if parent_trait_bound.trait_id == starting_trait_id {
+                    continue;
                 }
+
+                let parent_trait_bound =
+                    self.instantiate_parent_trait_bound(trait_bound, &parent_trait_bound);
+                self.add_trait_bound_to_scope(
+                    func_meta,
+                    object,
+                    &parent_trait_bound,
+                    starting_trait_id,
+                );
             }
         }
     }
@@ -987,9 +1041,14 @@ impl<'context> Elaborator<'context> {
         self.file = trait_impl.file_id;
         self.local_module = trait_impl.module_id;
 
-        self.generics = trait_impl.resolved_generics;
+        self.generics = trait_impl.resolved_generics.clone();
         self.current_trait_impl = trait_impl.impl_id;
 
+        self.add_trait_impl_assumed_trait_implementations(trait_impl.impl_id);
+        self.check_trait_impl_where_clause_matches_trait_where_clause(&trait_impl);
+        self.check_parent_traits_are_implemented(&trait_impl);
+        self.remove_trait_impl_assumed_trait_implementations(trait_impl.impl_id);
+
         for (module, function, _) in &trait_impl.methods.functions {
             self.local_module = *module;
             let errors = check_trait_impl_method_matches_declaration(self.interner, *function);
@@ -1003,6 +1062,162 @@ impl<'context> Elaborator<'context> {
         self.generics.clear();
     }
 
+    fn add_trait_impl_assumed_trait_implementations(&mut self, impl_id: Option<TraitImplId>) {
+        if let Some(impl_id) = impl_id {
+            if let Some(trait_implementation) = self.interner.try_get_trait_implementation(impl_id)
+            {
+                for trait_constrain in &trait_implementation.borrow().where_clause {
+                    let trait_bound = &trait_constrain.trait_bound;
+                    self.interner.add_assumed_trait_implementation(
+                        trait_constrain.typ.clone(),
+                        trait_bound.trait_id,
+                        trait_bound.trait_generics.clone(),
+                    );
+                }
+            }
+        }
+    }
+
+    fn remove_trait_impl_assumed_trait_implementations(&mut self, impl_id: Option<TraitImplId>) {
+        if let Some(impl_id) = impl_id {
+            if let Some(trait_implementation) = self.interner.try_get_trait_implementation(impl_id)
+            {
+                for trait_constrain in &trait_implementation.borrow().where_clause {
+                    self.interner.remove_assumed_trait_implementations_for_trait(
+                        trait_constrain.trait_bound.trait_id,
+                    );
+                }
+            }
+        }
+    }
+
+    fn check_trait_impl_where_clause_matches_trait_where_clause(
+        &mut self,
+        trait_impl: &UnresolvedTraitImpl,
+    ) {
+        let Some(trait_id) = trait_impl.trait_id else {
+            return;
+        };
+
+        let Some(the_trait) = self.interner.try_get_trait(trait_id) else {
+            return;
+        };
+
+        if the_trait.where_clause.is_empty() {
+            return;
+        }
+
+        let impl_trait = the_trait.name.to_string();
+        let the_trait_file = the_trait.location.file;
+
+        let mut bindings = TypeBindings::new();
+        bind_ordered_generics(
+            &the_trait.generics,
+            &trait_impl.resolved_trait_generics,
+            &mut bindings,
+        );
+
+        // Check that each of the trait's where clause constraints is satisfied
+        for trait_constraint in the_trait.where_clause.clone() {
+            let Some(trait_constraint_trait) =
+                self.interner.try_get_trait(trait_constraint.trait_bound.trait_id)
+            else {
+                continue;
+            };
+
+            let trait_constraint_type = trait_constraint.typ.substitute(&bindings);
+            let trait_bound = &trait_constraint.trait_bound;
+
+            if self
+                .interner
+                .try_lookup_trait_implementation(
+                    &trait_constraint_type,
+                    trait_bound.trait_id,
+                    &trait_bound.trait_generics.ordered,
+                    &trait_bound.trait_generics.named,
+                )
+                .is_err()
+            {
+                let missing_trait =
+                    format!("{}{}", trait_constraint_trait.name, trait_bound.trait_generics);
+                self.push_err(ResolverError::TraitNotImplemented {
+                    impl_trait: impl_trait.clone(),
+                    missing_trait,
+                    type_missing_trait: trait_constraint_type.to_string(),
+                    span: trait_impl.object_type.span,
+                    missing_trait_location: Location::new(trait_bound.span, the_trait_file),
+                });
+            }
+        }
+    }
+
+    fn check_parent_traits_are_implemented(&mut self, trait_impl: &UnresolvedTraitImpl) {
+        let Some(trait_id) = trait_impl.trait_id else {
+            return;
+        };
+
+        let Some(object_type) = &trait_impl.resolved_object_type else {
+            return;
+        };
+
+        let Some(the_trait) = self.interner.try_get_trait(trait_id) else {
+            return;
+        };
+
+        if the_trait.trait_bounds.is_empty() {
+            return;
+        }
+
+        let impl_trait = the_trait.name.to_string();
+        let the_trait_file = the_trait.location.file;
+
+        let mut bindings = TypeBindings::new();
+        bind_ordered_generics(
+            &the_trait.generics,
+            &trait_impl.resolved_trait_generics,
+            &mut bindings,
+        );
+
+        // Note: we only check if the immediate parents are implemented, we don't check recursively.
+        // Why? If a parent isn't implemented, we get an error. If a parent is implemented, we'll
+        // do the same check for the parent, so this trait's parents parents will be checked, so the
+        // recursion is guaranteed.
+        for parent_trait_bound in the_trait.trait_bounds.clone() {
+            let Some(parent_trait) = self.interner.try_get_trait(parent_trait_bound.trait_id)
+            else {
+                continue;
+            };
+
+            let parent_trait_bound = ResolvedTraitBound {
+                trait_generics: parent_trait_bound
+                    .trait_generics
+                    .map(|typ| typ.substitute(&bindings)),
+                ..parent_trait_bound
+            };
+
+            if self
+                .interner
+                .try_lookup_trait_implementation(
+                    object_type,
+                    parent_trait_bound.trait_id,
+                    &parent_trait_bound.trait_generics.ordered,
+                    &parent_trait_bound.trait_generics.named,
+                )
+                .is_err()
+            {
+                let missing_trait =
+                    format!("{}{}", parent_trait.name, parent_trait_bound.trait_generics);
+                self.push_err(ResolverError::TraitNotImplemented {
+                    impl_trait: impl_trait.clone(),
+                    missing_trait,
+                    type_missing_trait: trait_impl.object_type.to_string(),
+                    span: trait_impl.object_type.span,
+                    missing_trait_location: Location::new(parent_trait_bound.span, the_trait_file),
+                });
+            }
+        }
+    }
+
     fn collect_impls(
         &mut self,
         module: LocalModuleId,
@@ -1059,7 +1274,7 @@ impl<'context> Elaborator<'context> {
                 trait_id,
                 trait_generics,
                 file: trait_impl.file_id,
-                where_clause: where_clause.clone(),
+                where_clause,
                 methods,
             });
 
@@ -1134,7 +1349,7 @@ impl<'context> Elaborator<'context> {
                 // object types in each method overlap or not. If they do, we issue an error.
                 // If not, that is specialization which is allowed.
                 let name = method.name_ident().clone();
-                if module.declare_function(name, ItemVisibility::Public, *method_id).is_err() {
+                if module.declare_function(name, method.def.visibility, *method_id).is_err() {
                     let existing = module.find_func_with_name(method.name_ident()).expect(
                         "declare_function should only error if there is an existing function",
                     );
@@ -1195,14 +1410,49 @@ impl<'context> Elaborator<'context> {
         let typ = self.resolve_type(alias.type_alias_def.typ);
 
         if visibility != ItemVisibility::Private {
-            self.check_aliased_type_is_not_more_private(name, visibility, &typ, span);
+            self.check_type_is_not_more_private_then_item(name, visibility, &typ, span);
         }
 
         self.interner.set_type_alias(alias_id, typ, generics);
         self.generics.clear();
     }
 
-    fn check_aliased_type_is_not_more_private(
+    /// Find the struct in the parent module so we can know its visibility
+    fn find_struct_visibility(&self, struct_type: &StructType) -> Option<ItemVisibility> {
+        let parent_module_id = struct_type.id.parent_module_id(self.def_maps);
+        let parent_module_data = self.get_module(parent_module_id);
+        let per_ns = parent_module_data.find_name(&struct_type.name);
+        per_ns.types.map(|(_, vis, _)| vis)
+    }
+
+    /// Check whether a functions return value and args should be checked for private type visibility.
+    fn should_check_function_visibility(
+        &self,
+        func_meta: &FuncMeta,
+        modifiers: &FunctionModifiers,
+    ) -> bool {
+        // Private functions don't leak anything.
+        if modifiers.visibility == ItemVisibility::Private {
+            return false;
+        }
+        // Implementing public traits on private types is okay, they can't be used unless the type itself is accessible.
+        if func_meta.trait_impl.is_some() {
+            return false;
+        }
+        // Public struct functions should not expose private types.
+        if let Some(struct_visibility) = func_meta.struct_id.and_then(|id| {
+            let struct_def = self.get_struct(id);
+            let struct_def = struct_def.borrow();
+            self.find_struct_visibility(&struct_def)
+        }) {
+            return struct_visibility != ItemVisibility::Private;
+        }
+        // Standalone functions should be checked
+        true
+    }
+
+    /// Check that an item such as a struct field or type alias is not more visible than the type it refers to.
+    fn check_type_is_not_more_private_then_item(
         &mut self,
         name: &Ident,
         visibility: ItemVisibility,
@@ -1218,11 +1468,7 @@ impl<'context> Elaborator<'context> {
                 // then it's either accessible (all good) or it's not, in which case a different
                 // error will happen somewhere else, but no need to error again here.
                 if struct_module_id.krate == self.crate_id {
-                    // Find the struct in the parent module so we can know its visibility
-                    let parent_module_id = struct_type.id.parent_module_id(self.def_maps);
-                    let parent_module_data = self.get_module(parent_module_id);
-                    let per_ns = parent_module_data.find_name(&struct_type.name);
-                    if let Some((_, aliased_visibility, _)) = per_ns.types {
+                    if let Some(aliased_visibility) = self.find_struct_visibility(&struct_type) {
                         if aliased_visibility < visibility {
                             self.push_err(ResolverError::TypeIsMorePrivateThenItem {
                                 typ: struct_type.name.to_string(),
@@ -1234,35 +1480,39 @@ impl<'context> Elaborator<'context> {
                 }
 
                 for generic in generics {
-                    self.check_aliased_type_is_not_more_private(name, visibility, generic, span);
+                    self.check_type_is_not_more_private_then_item(name, visibility, generic, span);
                 }
             }
             Type::Tuple(types) => {
                 for typ in types {
-                    self.check_aliased_type_is_not_more_private(name, visibility, typ, span);
+                    self.check_type_is_not_more_private_then_item(name, visibility, typ, span);
                 }
             }
             Type::Alias(alias_type, generics) => {
-                self.check_aliased_type_is_not_more_private(
+                self.check_type_is_not_more_private_then_item(
                     name,
                     visibility,
                     &alias_type.borrow().get_type(generics),
                     span,
                 );
             }
+            Type::CheckedCast { from, to } => {
+                self.check_type_is_not_more_private_then_item(name, visibility, from, span);
+                self.check_type_is_not_more_private_then_item(name, visibility, to, span);
+            }
             Type::Function(args, return_type, env, _) => {
                 for arg in args {
-                    self.check_aliased_type_is_not_more_private(name, visibility, arg, span);
+                    self.check_type_is_not_more_private_then_item(name, visibility, arg, span);
                 }
-                self.check_aliased_type_is_not_more_private(name, visibility, return_type, span);
-                self.check_aliased_type_is_not_more_private(name, visibility, env, span);
+                self.check_type_is_not_more_private_then_item(name, visibility, return_type, span);
+                self.check_type_is_not_more_private_then_item(name, visibility, env, span);
             }
             Type::MutableReference(typ) | Type::Array(_, typ) | Type::Slice(typ) => {
-                self.check_aliased_type_is_not_more_private(name, visibility, typ, span);
+                self.check_type_is_not_more_private_then_item(name, visibility, typ, span);
             }
             Type::InfixExpr(left, _op, right) => {
-                self.check_aliased_type_is_not_more_private(name, visibility, left, span);
-                self.check_aliased_type_is_not_more_private(name, visibility, right, span);
+                self.check_type_is_not_more_private_then_item(name, visibility, left, span);
+                self.check_type_is_not_more_private_then_item(name, visibility, right, span);
             }
             Type::FieldElement
             | Type::Integer(..)
@@ -1292,6 +1542,29 @@ impl<'context> Elaborator<'context> {
             self.local_module = typ.module_id;
 
             let fields = self.resolve_struct_fields(&typ.struct_def, *type_id);
+
+            if typ.struct_def.is_abi() {
+                for field in &fields {
+                    self.mark_type_as_used(&field.typ);
+                }
+            }
+
+            // Check that the a public struct doesn't have a private type as a public field.
+            if typ.struct_def.visibility != ItemVisibility::Private {
+                for field in &fields {
+                    let ident = Ident(Spanned::from(
+                        field.name.span(),
+                        format!("{}::{}", typ.struct_def.name, field.name),
+                    ));
+                    self.check_type_is_not_more_private_then_item(
+                        &ident,
+                        field.visibility,
+                        &field.typ,
+                        field.name.span(),
+                    );
+                }
+            }
+
             let fields_len = fields.len();
             self.interner.update_struct(*type_id, |struct_def| {
                 struct_def.set_fields(fields);
@@ -1330,7 +1603,7 @@ impl<'context> Elaborator<'context> {
         &mut self,
         unresolved: &NoirStruct,
         struct_id: StructId,
-    ) -> Vec<(Ident, Type)> {
+    ) -> Vec<StructField> {
         self.recover_generics(|this| {
             this.current_item = Some(DependencyId::Struct(struct_id));
 
@@ -1342,7 +1615,8 @@ impl<'context> Elaborator<'context> {
             let fields = vecmap(&unresolved.fields, |field| {
                 let ident = &field.item.name;
                 let typ = &field.item.typ;
-                (ident.clone(), this.resolve_type(typ.clone()))
+                let visibility = field.item.visibility;
+                StructField { visibility, name: ident.clone(), typ: this.resolve_type(typ.clone()) }
             });
 
             this.resolving_ids.remove(&struct_id);
@@ -1394,7 +1668,7 @@ impl<'context> Elaborator<'context> {
         }
 
         if let Some(name) = name {
-            self.interner.register_global(global_id, name, self.module_id());
+            self.interner.register_global(global_id, name, global.visibility, self.module_id());
         }
 
         self.local_module = old_module;
diff --git a/compiler/noirc_frontend/src/elaborator/path_resolution.rs b/compiler/noirc_frontend/src/elaborator/path_resolution.rs
new file mode 100644
index 00000000000..a68991becb7
--- /dev/null
+++ b/compiler/noirc_frontend/src/elaborator/path_resolution.rs
@@ -0,0 +1,347 @@
+use noirc_errors::{Location, Span};
+
+use crate::ast::{Path, PathKind, UnresolvedType};
+use crate::hir::def_map::{ModuleDefId, ModuleId};
+use crate::hir::resolution::import::{resolve_path_kind, PathResolutionError};
+
+use crate::hir::resolution::errors::ResolverError;
+use crate::hir::resolution::visibility::item_in_module_is_visible;
+
+use crate::locations::ReferencesTracker;
+use crate::node_interner::{FuncId, GlobalId, StructId, TraitId, TypeAliasId};
+use crate::Type;
+
+use super::types::SELF_TYPE_NAME;
+use super::Elaborator;
+
+#[derive(Debug)]
+pub(crate) struct PathResolution {
+    pub(crate) item: PathResolutionItem,
+    pub(crate) errors: Vec<PathResolutionError>,
+}
+
+/// All possible items that result from resolving a Path.
+/// Note that this item doesn't include the last turbofish in a Path,
+/// only intermediate ones, if any.
+#[derive(Debug, Clone)]
+pub enum PathResolutionItem {
+    Module(ModuleId),
+    Struct(StructId),
+    TypeAlias(TypeAliasId),
+    Trait(TraitId),
+    Global(GlobalId),
+    ModuleFunction(FuncId),
+    StructFunction(StructId, Option<Turbofish>, FuncId),
+    TypeAliasFunction(TypeAliasId, Option<Turbofish>, FuncId),
+    TraitFunction(TraitId, Option<Turbofish>, FuncId),
+}
+
+impl PathResolutionItem {
+    pub fn function_id(&self) -> Option<FuncId> {
+        match self {
+            PathResolutionItem::ModuleFunction(func_id)
+            | PathResolutionItem::StructFunction(_, _, func_id)
+            | PathResolutionItem::TypeAliasFunction(_, _, func_id)
+            | PathResolutionItem::TraitFunction(_, _, func_id) => Some(*func_id),
+            _ => None,
+        }
+    }
+
+    pub fn module_id(&self) -> Option<ModuleId> {
+        match self {
+            Self::Module(module_id) => Some(*module_id),
+            _ => None,
+        }
+    }
+
+    pub fn description(&self) -> &'static str {
+        match self {
+            PathResolutionItem::Module(..) => "module",
+            PathResolutionItem::Struct(..) => "type",
+            PathResolutionItem::TypeAlias(..) => "type alias",
+            PathResolutionItem::Trait(..) => "trait",
+            PathResolutionItem::Global(..) => "global",
+            PathResolutionItem::ModuleFunction(..)
+            | PathResolutionItem::StructFunction(..)
+            | PathResolutionItem::TypeAliasFunction(..)
+            | PathResolutionItem::TraitFunction(..) => "function",
+        }
+    }
+}
+
+#[derive(Debug, Clone)]
+pub struct Turbofish {
+    pub generics: Vec<UnresolvedType>,
+    pub span: Span,
+}
+
+/// Any item that can appear before the last segment in a path.
+#[derive(Debug)]
+enum IntermediatePathResolutionItem {
+    Module(ModuleId),
+    Struct(StructId, Option<Turbofish>),
+    TypeAlias(TypeAliasId, Option<Turbofish>),
+    Trait(TraitId, Option<Turbofish>),
+}
+
+pub(crate) type PathResolutionResult = Result<PathResolution, PathResolutionError>;
+
+impl<'context> Elaborator<'context> {
+    pub(super) fn resolve_path_or_error(
+        &mut self,
+        path: Path,
+    ) -> Result<PathResolutionItem, ResolverError> {
+        let path_resolution = self.resolve_path(path)?;
+
+        for error in path_resolution.errors {
+            self.push_err(error);
+        }
+
+        Ok(path_resolution.item)
+    }
+
+    /// Resolves a path in the current module.
+    /// If the referenced name can't be found, `Err` will be returned. If it can be found, `Ok`
+    /// will be returned with a potential list of errors if, for example, one of the segments
+    /// is not accessible from the current module (e.g. because it's private).
+    pub(super) fn resolve_path(&mut self, mut path: Path) -> PathResolutionResult {
+        let mut module_id = self.module_id();
+
+        if path.kind == PathKind::Plain && path.first_name() == Some(SELF_TYPE_NAME) {
+            if let Some(Type::Struct(struct_type, _)) = &self.self_type {
+                let struct_type = struct_type.borrow();
+                if path.segments.len() == 1 {
+                    return Ok(PathResolution {
+                        item: PathResolutionItem::Struct(struct_type.id),
+                        errors: Vec::new(),
+                    });
+                }
+
+                module_id = struct_type.id.module_id();
+                path.segments.remove(0);
+            }
+        }
+
+        self.resolve_path_in_module(path, module_id)
+    }
+
+    /// Resolves a path in `current_module`.
+    /// `importing_module` is the module where the lookup originally started.
+    fn resolve_path_in_module(
+        &mut self,
+        path: Path,
+        importing_module: ModuleId,
+    ) -> PathResolutionResult {
+        let references_tracker = if self.interner.is_in_lsp_mode() {
+            Some(ReferencesTracker::new(self.interner, self.file))
+        } else {
+            None
+        };
+        let (path, module_id, _) =
+            resolve_path_kind(path, importing_module, self.def_maps, references_tracker)?;
+        self.resolve_name_in_module(path, module_id, importing_module)
+    }
+
+    /// Resolves a Path assuming we are inside `starting_module`.
+    /// `importing_module` is the module where the lookup originally started.
+    fn resolve_name_in_module(
+        &mut self,
+        path: Path,
+        starting_module: ModuleId,
+        importing_module: ModuleId,
+    ) -> PathResolutionResult {
+        // There is a possibility that the import path is empty. In that case, early return.
+        if path.segments.is_empty() {
+            return Ok(PathResolution {
+                item: PathResolutionItem::Module(starting_module),
+                errors: Vec::new(),
+            });
+        }
+
+        let plain_or_crate = matches!(path.kind, PathKind::Plain | PathKind::Crate);
+
+        // The current module and module ID as we resolve path segments
+        let mut current_module_id = starting_module;
+        let mut current_module = self.get_module(starting_module);
+
+        let mut intermediate_item = IntermediatePathResolutionItem::Module(current_module_id);
+
+        let first_segment =
+            &path.segments.first().expect("ice: could not fetch first segment").ident;
+        let mut current_ns = current_module.find_name(first_segment);
+        if current_ns.is_none() {
+            return Err(PathResolutionError::Unresolved(first_segment.clone()));
+        }
+
+        self.usage_tracker.mark_as_referenced(current_module_id, first_segment);
+
+        let mut errors = Vec::new();
+        for (index, (last_segment, current_segment)) in
+            path.segments.iter().zip(path.segments.iter().skip(1)).enumerate()
+        {
+            let last_ident = &last_segment.ident;
+            let current_ident = &current_segment.ident;
+            let last_segment_generics = &last_segment.generics;
+
+            let (typ, visibility) = match current_ns.types {
+                None => return Err(PathResolutionError::Unresolved(last_ident.clone())),
+                Some((typ, visibility, _)) => (typ, visibility),
+            };
+
+            let location = Location::new(last_segment.span, self.file);
+            self.interner.add_module_def_id_reference(
+                typ,
+                location,
+                last_segment.ident.is_self_type_name(),
+            );
+
+            (current_module_id, intermediate_item) = match typ {
+                ModuleDefId::ModuleId(id) => {
+                    if last_segment_generics.is_some() {
+                        errors.push(PathResolutionError::TurbofishNotAllowedOnItem {
+                            item: format!("module `{last_ident}`"),
+                            span: last_segment.turbofish_span(),
+                        });
+                    }
+
+                    (id, IntermediatePathResolutionItem::Module(id))
+                }
+                ModuleDefId::TypeId(id) => (
+                    id.module_id(),
+                    IntermediatePathResolutionItem::Struct(
+                        id,
+                        last_segment_generics.as_ref().map(|generics| Turbofish {
+                            generics: generics.clone(),
+                            span: last_segment.turbofish_span(),
+                        }),
+                    ),
+                ),
+                ModuleDefId::TypeAliasId(id) => {
+                    let type_alias = self.interner.get_type_alias(id);
+                    let type_alias = type_alias.borrow();
+
+                    let module_id = match &type_alias.typ {
+                        Type::Struct(struct_id, _generics) => struct_id.borrow().id.module_id(),
+                        Type::Error => {
+                            return Err(PathResolutionError::Unresolved(last_ident.clone()));
+                        }
+                        _ => {
+                            // For now we only allow type aliases that point to structs.
+                            // The more general case is captured here: https://github.com/noir-lang/noir/issues/6398
+                            panic!("Type alias in path not pointing to struct not yet supported")
+                        }
+                    };
+
+                    (
+                        module_id,
+                        IntermediatePathResolutionItem::TypeAlias(
+                            id,
+                            last_segment_generics.as_ref().map(|generics| Turbofish {
+                                generics: generics.clone(),
+                                span: last_segment.turbofish_span(),
+                            }),
+                        ),
+                    )
+                }
+                ModuleDefId::TraitId(id) => (
+                    id.0,
+                    IntermediatePathResolutionItem::Trait(
+                        id,
+                        last_segment_generics.as_ref().map(|generics| Turbofish {
+                            generics: generics.clone(),
+                            span: last_segment.turbofish_span(),
+                        }),
+                    ),
+                ),
+                ModuleDefId::FunctionId(_) => panic!("functions cannot be in the type namespace"),
+                ModuleDefId::GlobalId(_) => panic!("globals cannot be in the type namespace"),
+            };
+
+            // If the path is plain or crate, the first segment will always refer to
+            // something that's visible from the current module.
+            if !((plain_or_crate && index == 0)
+                || item_in_module_is_visible(
+                    self.def_maps,
+                    importing_module,
+                    current_module_id,
+                    visibility,
+                ))
+            {
+                errors.push(PathResolutionError::Private(last_ident.clone()));
+            }
+
+            current_module = self.get_module(current_module_id);
+
+            // Check if namespace
+            let found_ns = current_module.find_name(current_ident);
+            if found_ns.is_none() {
+                return Err(PathResolutionError::Unresolved(current_ident.clone()));
+            }
+
+            self.usage_tracker.mark_as_referenced(current_module_id, current_ident);
+
+            current_ns = found_ns;
+        }
+
+        let (module_def_id, visibility, _) =
+            current_ns.values.or(current_ns.types).expect("Found empty namespace");
+
+        let name = path.last_ident();
+        let is_self_type = name.is_self_type_name();
+        let location = Location::new(name.span(), self.file);
+        self.interner.add_module_def_id_reference(module_def_id, location, is_self_type);
+
+        let item = merge_intermediate_path_resolution_item_with_module_def_id(
+            intermediate_item,
+            module_def_id,
+        );
+
+        if !(self.self_type_module_id() == Some(current_module_id)
+            || item_in_module_is_visible(
+                self.def_maps,
+                importing_module,
+                current_module_id,
+                visibility,
+            ))
+        {
+            errors.push(PathResolutionError::Private(name.clone()));
+        }
+
+        Ok(PathResolution { item, errors })
+    }
+
+    fn self_type_module_id(&self) -> Option<ModuleId> {
+        if let Some(Type::Struct(struct_type, _)) = &self.self_type {
+            Some(struct_type.borrow().id.module_id())
+        } else {
+            None
+        }
+    }
+}
+
+fn merge_intermediate_path_resolution_item_with_module_def_id(
+    intermediate_item: IntermediatePathResolutionItem,
+    module_def_id: ModuleDefId,
+) -> PathResolutionItem {
+    match module_def_id {
+        ModuleDefId::ModuleId(module_id) => PathResolutionItem::Module(module_id),
+        ModuleDefId::TypeId(struct_id) => PathResolutionItem::Struct(struct_id),
+        ModuleDefId::TypeAliasId(type_alias_id) => PathResolutionItem::TypeAlias(type_alias_id),
+        ModuleDefId::TraitId(trait_id) => PathResolutionItem::Trait(trait_id),
+        ModuleDefId::GlobalId(global_id) => PathResolutionItem::Global(global_id),
+        ModuleDefId::FunctionId(func_id) => match intermediate_item {
+            IntermediatePathResolutionItem::Module(_) => {
+                PathResolutionItem::ModuleFunction(func_id)
+            }
+            IntermediatePathResolutionItem::Struct(struct_id, generics) => {
+                PathResolutionItem::StructFunction(struct_id, generics, func_id)
+            }
+            IntermediatePathResolutionItem::TypeAlias(alias_id, generics) => {
+                PathResolutionItem::TypeAliasFunction(alias_id, generics, func_id)
+            }
+            IntermediatePathResolutionItem::Trait(trait_id, generics) => {
+                PathResolutionItem::TraitFunction(trait_id, generics, func_id)
+            }
+        },
+    }
+}
diff --git a/compiler/noirc_frontend/src/elaborator/patterns.rs b/compiler/noirc_frontend/src/elaborator/patterns.rs
index 6ed59a61e4e..3fbdadbbee8 100644
--- a/compiler/noirc_frontend/src/elaborator/patterns.rs
+++ b/compiler/noirc_frontend/src/elaborator/patterns.rs
@@ -3,22 +3,24 @@ use noirc_errors::{Location, Span};
 use rustc_hash::FxHashSet as HashSet;
 
 use crate::{
-    ast::{TypePath, UnresolvedType, ERROR_IDENT},
+    ast::{
+        Expression, ExpressionKind, Ident, ItemVisibility, Path, Pattern, TypePath, UnresolvedType,
+        ERROR_IDENT,
+    },
     hir::{
         def_collector::dc_crate::CompilationError,
         resolution::errors::ResolverError,
         type_check::{Source, TypeCheckError},
     },
     hir_def::{
-        expr::{HirIdent, HirMethodReference, ImplKind},
+        expr::{HirExpression, HirIdent, HirMethodReference, ImplKind, TraitMethod},
         stmt::HirPattern,
     },
-    macros_api::{Expression, ExpressionKind, HirExpression, Ident, Path, Pattern},
     node_interner::{DefinitionId, DefinitionKind, ExprId, FuncId, GlobalId, TraitImplKind},
-    ResolvedGeneric, Shared, StructType, Type, TypeBindings,
+    Kind, Shared, StructType, Type, TypeAlias, TypeBindings,
 };
 
-use super::{Elaborator, ResolverMeta};
+use super::{path_resolution::PathResolutionItem, Elaborator, ResolverMeta};
 
 impl<'context> Elaborator<'context> {
     pub(super) fn elaborate_pattern(
@@ -35,7 +37,6 @@ impl<'context> Elaborator<'context> {
             None,
             &mut Vec::new(),
             warn_if_unused,
-            None,
         )
     }
 
@@ -48,7 +49,6 @@ impl<'context> Elaborator<'context> {
         definition_kind: DefinitionKind,
         created_ids: &mut Vec<HirIdent>,
         warn_if_unused: bool,
-        global_id: Option<GlobalId>,
     ) -> HirPattern {
         self.elaborate_pattern_mut(
             pattern,
@@ -57,7 +57,6 @@ impl<'context> Elaborator<'context> {
             None,
             created_ids,
             warn_if_unused,
-            global_id,
         )
     }
 
@@ -70,7 +69,6 @@ impl<'context> Elaborator<'context> {
         mutable: Option<Span>,
         new_definitions: &mut Vec<HirIdent>,
         warn_if_unused: bool,
-        global_id: Option<GlobalId>,
     ) -> HirPattern {
         match pattern {
             Pattern::Identifier(name) => {
@@ -80,7 +78,7 @@ impl<'context> Elaborator<'context> {
                     (Some(_), DefinitionKind::Local(_)) => DefinitionKind::Local(None),
                     (_, other) => other,
                 };
-                let ident = if let Some(global_id) = global_id {
+                let ident = if let DefinitionKind::Global(global_id) = definition {
                     // Globals don't need to be added to scope, they're already in the def_maps
                     let id = self.interner.get_global(global_id).definition_id;
                     let location = Location::new(name.span(), self.file);
@@ -110,7 +108,6 @@ impl<'context> Elaborator<'context> {
                     Some(span),
                     new_definitions,
                     warn_if_unused,
-                    global_id,
                 );
                 let location = Location::new(span, self.file);
                 HirPattern::Mutable(Box::new(pattern), location)
@@ -142,7 +139,6 @@ impl<'context> Elaborator<'context> {
                         mutable,
                         new_definitions,
                         warn_if_unused,
-                        global_id,
                     )
                 });
                 let location = Location::new(span, self.file);
@@ -166,7 +162,6 @@ impl<'context> Elaborator<'context> {
                     mutable,
                     new_definitions,
                     warn_if_unused,
-                    global_id,
                 )
             }
         }
@@ -183,9 +178,6 @@ impl<'context> Elaborator<'context> {
         mutable: Option<Span>,
         new_definitions: &mut Vec<HirIdent>,
     ) -> HirPattern {
-        let exclude_last_segment = true;
-        self.check_unsupported_turbofish_usage(&name, exclude_last_segment);
-
         let last_segment = name.last_segment();
         let name_span = last_segment.ident.span();
         let is_self_type = last_segment.ident.is_self_type_name();
@@ -200,7 +192,7 @@ impl<'context> Elaborator<'context> {
         };
 
         let (struct_type, generics) = match self.lookup_type_or_error(name) {
-            Some(Type::Struct(struct_type, generics)) => (struct_type, generics),
+            Some(Type::Struct(struct_type, struct_generics)) => (struct_type, struct_generics),
             None => return error_identifier(self),
             Some(typ) => {
                 let typ = typ.to_string();
@@ -271,7 +263,9 @@ impl<'context> Elaborator<'context> {
         let mut unseen_fields = struct_type.borrow().field_names();
 
         for (field, pattern) in fields {
-            let field_type = expected_type.get_field_type(&field.0.contents).unwrap_or(Type::Error);
+            let (field_type, visibility) = expected_type
+                .get_field_type_and_visibility(&field.0.contents)
+                .unwrap_or((Type::Error, ItemVisibility::Public));
             let resolved = self.elaborate_pattern_mut(
                 pattern,
                 field_type,
@@ -279,12 +273,18 @@ impl<'context> Elaborator<'context> {
                 mutable,
                 new_definitions,
                 true, // warn_if_unused
-                None,
             );
 
             if unseen_fields.contains(&field) {
                 unseen_fields.remove(&field);
                 seen_fields.insert(field.clone());
+
+                self.check_struct_field_visibility(
+                    &struct_type.borrow(),
+                    &field.0.contents,
+                    visibility,
+                    field.span(),
+                );
             } else if seen_fields.contains(&field) {
                 // duplicate field
                 self.push_err(ResolverError::DuplicateField { field: field.clone() });
@@ -318,8 +318,8 @@ impl<'context> Elaborator<'context> {
         warn_if_unused: bool,
         definition: DefinitionKind,
     ) -> HirIdent {
-        if definition.is_global() {
-            return self.add_global_variable_decl(name, definition);
+        if let DefinitionKind::Global(global_id) = definition {
+            return self.add_global_variable_decl(name, global_id);
         }
 
         let location = Location::new(name.span(), self.file);
@@ -331,16 +331,18 @@ impl<'context> Elaborator<'context> {
         let resolver_meta =
             ResolverMeta { num_times_used: 0, ident: ident.clone(), warn_if_unused };
 
-        let scope = self.scopes.get_mut_scope();
-        let old_value = scope.add_key_value(name.clone(), resolver_meta);
-
-        if !allow_shadowing {
-            if let Some(old_value) = old_value {
-                self.push_err(ResolverError::DuplicateDefinition {
-                    name,
-                    first_span: old_value.ident.location.span,
-                    second_span: location.span,
-                });
+        if name != "_" {
+            let scope = self.scopes.get_mut_scope();
+            let old_value = scope.add_key_value(name.clone(), resolver_meta);
+
+            if !allow_shadowing {
+                if let Some(old_value) = old_value {
+                    self.push_err(ResolverError::DuplicateDefinition {
+                        name,
+                        first_span: old_value.ident.location.span,
+                        second_span: location.span,
+                    });
+                }
             }
         }
 
@@ -364,47 +366,19 @@ impl<'context> Elaborator<'context> {
         }
     }
 
-    pub fn add_global_variable_decl(
-        &mut self,
-        name: Ident,
-        definition: DefinitionKind,
-    ) -> HirIdent {
-        let comptime = self.in_comptime_context();
+    pub fn add_global_variable_decl(&mut self, name: Ident, global_id: GlobalId) -> HirIdent {
         let scope = self.scopes.get_mut_scope();
-
-        // This check is necessary to maintain the same definition ids in the interner. Currently, each function uses a new resolver that has its own ScopeForest and thus global scope.
-        // We must first check whether an existing definition ID has been inserted as otherwise there will be multiple definitions for the same global statement.
-        // This leads to an error in evaluation where the wrong definition ID is selected when evaluating a statement using the global. The check below prevents this error.
-        let mut global_id = None;
-        let global = self.interner.get_all_globals();
-        for global_info in global {
-            if global_info.local_id == self.local_module && global_info.ident == name {
-                global_id = Some(global_info.id);
-            }
-        }
-
-        let (ident, resolver_meta) = if let Some(id) = global_id {
-            let global = self.interner.get_global(id);
-            let hir_ident = HirIdent::non_trait_method(global.definition_id, global.location);
-            let ident = hir_ident.clone();
-            let resolver_meta = ResolverMeta { num_times_used: 0, ident, warn_if_unused: true };
-            (hir_ident, resolver_meta)
-        } else {
-            let location = Location::new(name.span(), self.file);
-            let name = name.0.contents.clone();
-            let id = self.interner.push_definition(name, false, comptime, definition, location);
-            let ident = HirIdent::non_trait_method(id, location);
-            let resolver_meta =
-                ResolverMeta { num_times_used: 0, ident: ident.clone(), warn_if_unused: true };
-            (ident, resolver_meta)
-        };
+        let global = self.interner.get_global(global_id);
+        let ident = HirIdent::non_trait_method(global.definition_id, global.location);
+        let resolver_meta =
+            ResolverMeta { num_times_used: 0, ident: ident.clone(), warn_if_unused: true };
 
         let old_global_value = scope.add_key_value(name.0.contents.clone(), resolver_meta);
         if let Some(old_global_value) = old_global_value {
             self.push_err(ResolverError::DuplicateDefinition {
-                name: name.0.contents.clone(),
-                first_span: old_global_value.ident.location.span,
                 second_span: name.span(),
+                name: name.0.contents,
+                first_span: old_global_value.ident.location.span,
             });
         }
         ident
@@ -441,19 +415,20 @@ impl<'context> Elaborator<'context> {
         unresolved_turbofish: Option<Vec<UnresolvedType>>,
         span: Span,
     ) -> Option<Vec<Type>> {
-        let direct_generics = self.interner.function_meta(func_id).direct_generics.clone();
+        let direct_generic_kinds =
+            vecmap(&self.interner.function_meta(func_id).direct_generics, |generic| generic.kind());
 
         unresolved_turbofish.map(|unresolved_turbofish| {
-            if unresolved_turbofish.len() != direct_generics.len() {
+            if unresolved_turbofish.len() != direct_generic_kinds.len() {
                 let type_check_err = TypeCheckError::IncorrectTurbofishGenericCount {
-                    expected_count: direct_generics.len(),
+                    expected_count: direct_generic_kinds.len(),
                     actual_count: unresolved_turbofish.len(),
                     span,
                 };
                 self.push_err(type_check_err);
             }
 
-            self.resolve_turbofish_generics(&direct_generics, unresolved_turbofish)
+            self.resolve_turbofish_generics(direct_generic_kinds, unresolved_turbofish)
         })
     }
 
@@ -463,6 +438,62 @@ impl<'context> Elaborator<'context> {
         generics: Vec<Type>,
         unresolved_turbofish: Option<Vec<UnresolvedType>>,
         span: Span,
+    ) -> Vec<Type> {
+        let kinds = vecmap(&struct_type.generics, |generic| generic.kind());
+        self.resolve_item_turbofish_generics(
+            "struct",
+            &struct_type.name.0.contents,
+            kinds,
+            generics,
+            unresolved_turbofish,
+            span,
+        )
+    }
+
+    pub(super) fn resolve_trait_turbofish_generics(
+        &mut self,
+        trait_name: &str,
+        trait_generic_kinds: Vec<Kind>,
+        generics: Vec<Type>,
+        unresolved_turbofish: Option<Vec<UnresolvedType>>,
+        span: Span,
+    ) -> Vec<Type> {
+        self.resolve_item_turbofish_generics(
+            "trait",
+            trait_name,
+            trait_generic_kinds,
+            generics,
+            unresolved_turbofish,
+            span,
+        )
+    }
+
+    pub(super) fn resolve_alias_turbofish_generics(
+        &mut self,
+        type_alias: &TypeAlias,
+        generics: Vec<Type>,
+        unresolved_turbofish: Option<Vec<UnresolvedType>>,
+        span: Span,
+    ) -> Vec<Type> {
+        let kinds = vecmap(&type_alias.generics, |generic| generic.kind());
+        self.resolve_item_turbofish_generics(
+            "alias",
+            &type_alias.name.0.contents,
+            kinds,
+            generics,
+            unresolved_turbofish,
+            span,
+        )
+    }
+
+    pub(super) fn resolve_item_turbofish_generics(
+        &mut self,
+        item_kind: &'static str,
+        item_name: &str,
+        item_generic_kinds: Vec<Kind>,
+        generics: Vec<Type>,
+        unresolved_turbofish: Option<Vec<UnresolvedType>>,
+        span: Span,
     ) -> Vec<Type> {
         let Some(turbofish_generics) = unresolved_turbofish else {
             return generics;
@@ -470,7 +501,7 @@ impl<'context> Elaborator<'context> {
 
         if turbofish_generics.len() != generics.len() {
             self.push_err(TypeCheckError::GenericCountMismatch {
-                item: format!("struct {}", struct_type.name),
+                item: format!("{item_kind} {item_name}"),
                 expected: generics.len(),
                 found: turbofish_generics.len(),
                 span,
@@ -478,65 +509,152 @@ impl<'context> Elaborator<'context> {
             return generics;
         }
 
-        self.resolve_turbofish_generics(&struct_type.generics, turbofish_generics)
+        self.resolve_turbofish_generics(item_generic_kinds, turbofish_generics)
     }
 
     pub(super) fn resolve_turbofish_generics(
         &mut self,
-        generics: &[ResolvedGeneric],
+        kinds: Vec<Kind>,
         turbofish_generics: Vec<UnresolvedType>,
     ) -> Vec<Type> {
-        let generics_with_types = generics.iter().zip(turbofish_generics);
-        vecmap(generics_with_types, |(generic, unresolved_type)| {
-            self.resolve_type_inner(unresolved_type, &generic.kind)
+        let kinds_with_types = kinds.into_iter().zip(turbofish_generics);
+        vecmap(kinds_with_types, |(kind, unresolved_type)| {
+            self.resolve_type_inner(unresolved_type, &kind)
         })
     }
 
     pub(super) fn elaborate_variable(&mut self, variable: Path) -> (ExprId, Type) {
-        let exclude_last_segment = true;
-        self.check_unsupported_turbofish_usage(&variable, exclude_last_segment);
-
         let unresolved_turbofish = variable.segments.last().unwrap().generics.clone();
 
         let span = variable.span;
-        let expr = self.resolve_variable(variable);
+        let (expr, item) = self.resolve_variable(variable);
         let definition_id = expr.id;
 
+        let type_generics = item.map(|item| self.resolve_item_turbofish(item)).unwrap_or_default();
+
         let definition_kind =
             self.interner.try_definition(definition_id).map(|definition| definition.kind.clone());
 
+        let mut bindings = TypeBindings::new();
+
         // Resolve any generics if we the variable we have resolved is a function
         // and if the turbofish operator was used.
-        let generics = definition_kind.and_then(|definition_kind| match &definition_kind {
-            DefinitionKind::Function(function) => {
-                self.resolve_function_turbofish_generics(function, unresolved_turbofish, span)
+        let generics = if let Some(DefinitionKind::Function(func_id)) = &definition_kind {
+            self.resolve_function_turbofish_generics(func_id, unresolved_turbofish, span)
+        } else {
+            None
+        };
+
+        // If this is a function call on a type that has generics, we need to bind those generic types.
+        if !type_generics.is_empty() {
+            if let Some(DefinitionKind::Function(func_id)) = &definition_kind {
+                // `all_generics` will always have the enclosing type generics first, so we need to bind those
+                let func_generics = &self.interner.function_meta(func_id).all_generics;
+                for (type_generic, func_generic) in type_generics.into_iter().zip(func_generics) {
+                    let type_var = &func_generic.type_var;
+                    bindings
+                        .insert(type_var.id(), (type_var.clone(), type_var.kind(), type_generic));
+                }
             }
-            _ => None,
-        });
+        }
 
         let id = self.interner.push_expr(HirExpression::Ident(expr.clone(), generics.clone()));
 
         self.interner.push_expr_location(id, span, self.file);
-        let typ = self.type_check_variable(expr, id, generics);
+        let typ = self.type_check_variable_with_bindings(expr, id, generics, bindings);
         self.interner.push_expr_type(id, typ.clone());
 
         (id, typ)
     }
 
-    fn resolve_variable(&mut self, path: Path) -> HirIdent {
-        if let Some((method, constraint, assumed)) = self.resolve_trait_generic_path(&path) {
-            HirIdent {
-                location: Location::new(path.span, self.file),
-                id: self.interner.trait_method_id(method),
-                impl_kind: ImplKind::TraitMethod(method, constraint, assumed),
+    /// Solve any generics that are part of the path before the function, for example:
+    ///
+    /// foo::Bar::<i32>::baz
+    ///           ^^^^^
+    ///         solve these
+    fn resolve_item_turbofish(&mut self, item: PathResolutionItem) -> Vec<Type> {
+        match item {
+            PathResolutionItem::StructFunction(struct_id, Some(generics), _func_id) => {
+                let struct_type = self.interner.get_struct(struct_id);
+                let struct_type = struct_type.borrow();
+                let struct_generics = struct_type.instantiate(self.interner);
+                self.resolve_struct_turbofish_generics(
+                    &struct_type,
+                    struct_generics,
+                    Some(generics.generics),
+                    generics.span,
+                )
             }
+            PathResolutionItem::TypeAliasFunction(type_alias_id, generics, _func_id) => {
+                let type_alias = self.interner.get_type_alias(type_alias_id);
+                let type_alias = type_alias.borrow();
+                let alias_generics = vecmap(&type_alias.generics, |generic| {
+                    self.interner.next_type_variable_with_kind(generic.kind())
+                });
+
+                // First solve the generics on the alias, if any
+                let generics = if let Some(generics) = generics {
+                    self.resolve_alias_turbofish_generics(
+                        &type_alias,
+                        alias_generics,
+                        Some(generics.generics),
+                        generics.span,
+                    )
+                } else {
+                    alias_generics
+                };
+
+                // Now instantiate the underlying struct with those generics, the struct might
+                // have more generics than those in the alias, like in this example:
+                //
+                // type Alias<T> = Struct<T, i32>;
+                let typ = type_alias.get_type(&generics);
+                let Type::Struct(_, generics) = typ else {
+                    // See https://github.com/noir-lang/noir/issues/6398
+                    panic!("Expected type alias to point to struct")
+                };
+
+                generics
+            }
+            PathResolutionItem::TraitFunction(trait_id, Some(generics), _func_id) => {
+                let trait_ = self.interner.get_trait(trait_id);
+                let kinds = vecmap(&trait_.generics, |generic| generic.kind());
+                let trait_generics =
+                    vecmap(&kinds, |kind| self.interner.next_type_variable_with_kind(kind.clone()));
+
+                self.resolve_trait_turbofish_generics(
+                    &trait_.name.to_string(),
+                    kinds,
+                    trait_generics,
+                    Some(generics.generics),
+                    generics.span,
+                )
+            }
+            _ => Vec::new(),
+        }
+    }
+
+    fn resolve_variable(&mut self, path: Path) -> (HirIdent, Option<PathResolutionItem>) {
+        if let Some(trait_path_resolution) = self.resolve_trait_generic_path(&path) {
+            for error in trait_path_resolution.errors {
+                self.push_err(error);
+            }
+
+            (
+                HirIdent {
+                    location: Location::new(path.span, self.file),
+                    id: self.interner.trait_method_id(trait_path_resolution.method.method_id),
+                    impl_kind: ImplKind::TraitMethod(trait_path_resolution.method),
+                },
+                trait_path_resolution.item,
+            )
         } else {
             // If the Path is being used as an Expression, then it is referring to a global from a separate module
             // Otherwise, then it is referring to an Identifier
             // This lookup allows support of such statements: let x = foo::bar::SOME_GLOBAL + 10;
             // If the expression is a singular indent, we search the resolver's current scope as normal.
             let span = path.span();
-            let (hir_ident, var_scope_index) = self.get_ident_from_path(path);
+            let ((hir_ident, var_scope_index), item) = self.get_ident_from_path(path);
 
             if hir_ident.id != DefinitionId::dummy_id() {
                 match self.interner.definition(hir_ident.id).kind {
@@ -557,13 +675,14 @@ impl<'context> Elaborator<'context> {
 
                         self.interner.add_global_reference(global_id, hir_ident.location);
                     }
-                    DefinitionKind::GenericType(_) => {
+                    DefinitionKind::NumericGeneric(_, ref numeric_typ) => {
                         // Initialize numeric generics to a polymorphic integer type in case
                         // they're used in expressions. We must do this here since type_check_variable
                         // does not check definition kinds and otherwise expects parameters to
                         // already be typed.
                         if self.interner.definition_type(hir_ident.id) == Type::Error {
-                            let typ = Type::polymorphic_integer_or_field(self.interner);
+                            let type_var_kind = Kind::Numeric(numeric_typ.clone());
+                            let typ = self.type_variable_with_kind(type_var_kind);
                             self.interner.push_definition_type(hir_ident.id, typ);
                         }
                     }
@@ -577,7 +696,7 @@ impl<'context> Elaborator<'context> {
                 }
             }
 
-            hir_ident
+            (hir_ident, item)
         }
     }
 
@@ -587,14 +706,27 @@ impl<'context> Elaborator<'context> {
         expr_id: ExprId,
         generics: Option<Vec<Type>>,
     ) -> Type {
-        let mut bindings = TypeBindings::new();
+        let bindings = TypeBindings::new();
+        self.type_check_variable_with_bindings(ident, expr_id, generics, bindings)
+    }
 
+    pub(super) fn type_check_variable_with_bindings(
+        &mut self,
+        ident: HirIdent,
+        expr_id: ExprId,
+        generics: Option<Vec<Type>>,
+        mut bindings: TypeBindings,
+    ) -> Type {
         // Add type bindings from any constraints that were used.
         // We need to do this first since otherwise instantiating the type below
         // will replace each trait generic with a fresh type variable, rather than
         // the type used in the trait constraint (if it exists). See #4088.
-        if let ImplKind::TraitMethod(_, constraint, assumed) = &ident.impl_kind {
-            self.bind_generics_from_trait_constraint(constraint, *assumed, &mut bindings);
+        if let ImplKind::TraitMethod(method) = &ident.impl_kind {
+            self.bind_generics_from_trait_constraint(
+                &method.constraint,
+                method.assumed,
+                &mut bindings,
+            );
         }
 
         // An identifiers type may be forall-quantified in the case of generic functions.
@@ -632,18 +764,18 @@ impl<'context> Elaborator<'context> {
             }
         }
 
-        if let ImplKind::TraitMethod(_, mut constraint, assumed) = ident.impl_kind {
-            constraint.apply_bindings(&bindings);
-            if assumed {
-                let trait_generics = constraint.trait_generics.clone();
-                let object_type = constraint.typ;
+        if let ImplKind::TraitMethod(mut method) = ident.impl_kind {
+            method.constraint.apply_bindings(&bindings);
+            if method.assumed {
+                let trait_generics = method.constraint.trait_bound.trait_generics.clone();
+                let object_type = method.constraint.typ;
                 let trait_impl = TraitImplKind::Assumed { object_type, trait_generics };
                 self.interner.select_impl_for_expression(expr_id, trait_impl);
             } else {
                 // Currently only one impl can be selected per expr_id, so this
                 // constraint needs to be pushed after any other constraints so
                 // that monomorphization can resolve this trait method to the correct impl.
-                self.push_trait_constraint(constraint, expr_id);
+                self.push_trait_constraint(method.constraint, expr_id);
             }
         }
 
@@ -684,24 +816,31 @@ impl<'context> Elaborator<'context> {
         }
     }
 
-    pub fn get_ident_from_path(&mut self, path: Path) -> (HirIdent, usize) {
+    pub fn get_ident_from_path(
+        &mut self,
+        path: Path,
+    ) -> ((HirIdent, usize), Option<PathResolutionItem>) {
         let location = Location::new(path.last_ident().span(), self.file);
 
         let error = match path.as_ident().map(|ident| self.use_variable(ident)) {
-            Some(Ok(found)) => return found,
+            Some(Ok(found)) => return (found, None),
             // Try to look it up as a global, but still issue the first error if we fail
             Some(Err(error)) => match self.lookup_global(path) {
-                Ok(id) => return (HirIdent::non_trait_method(id, location), 0),
+                Ok((id, item)) => {
+                    return ((HirIdent::non_trait_method(id, location), 0), Some(item))
+                }
                 Err(_) => error,
             },
             None => match self.lookup_global(path) {
-                Ok(id) => return (HirIdent::non_trait_method(id, location), 0),
+                Ok((id, item)) => {
+                    return ((HirIdent::non_trait_method(id, location), 0), Some(item))
+                }
                 Err(error) => error,
             },
         };
         self.push_err(error);
         let id = DefinitionId::dummy_id();
-        (HirIdent::non_trait_method(id, location), 0)
+        ((HirIdent::non_trait_method(id, location), 0), None)
     }
 
     pub(super) fn elaborate_type_path(&mut self, path: TypePath) -> (ExprId, Type) {
@@ -717,8 +856,8 @@ impl<'context> Elaborator<'context> {
             .func_id(self.interner)
             .expect("Expected trait function to be a DefinitionKind::Function");
 
-        let generics = self.resolve_type_args(path.turbofish, func_id, span).0;
-        let generics = (!generics.is_empty()).then_some(generics);
+        let generics =
+            path.turbofish.map(|turbofish| self.resolve_type_args(turbofish, func_id, span).0);
 
         let location = Location::new(span, self.file);
         let id = self.interner.function_definition_id(func_id);
@@ -728,8 +867,8 @@ impl<'context> Elaborator<'context> {
             HirMethodReference::TraitMethodId(method_id, generics) => {
                 let mut constraint =
                     self.interner.get_trait(method_id.trait_id).as_constraint(span);
-                constraint.trait_generics = generics;
-                ImplKind::TraitMethod(method_id, constraint, false)
+                constraint.trait_bound.trait_generics = generics;
+                ImplKind::TraitMethod(TraitMethod { method_id, constraint, assumed: false })
             }
         };
 
diff --git a/compiler/noirc_frontend/src/elaborator/scope.rs b/compiler/noirc_frontend/src/elaborator/scope.rs
index 8e746256142..fe01e3cb7f3 100644
--- a/compiler/noirc_frontend/src/elaborator/scope.rs
+++ b/compiler/noirc_frontend/src/elaborator/scope.rs
@@ -1,26 +1,21 @@
-use noirc_errors::{Location, Spanned};
+use noirc_errors::Spanned;
 
-use crate::ast::{PathKind, ERROR_IDENT};
+use crate::ast::{Ident, Path, ERROR_IDENT};
 use crate::hir::def_map::{LocalModuleId, ModuleId};
-use crate::hir::resolution::import::{PathResolution, PathResolutionResult};
-use crate::hir::resolution::path_resolver::{PathResolver, StandardPathResolver};
+
 use crate::hir::scope::{Scope as GenericScope, ScopeTree as GenericScopeTree};
-use crate::macros_api::Ident;
 use crate::{
-    hir::{
-        def_map::{ModuleDefId, TryFromModuleDefId},
-        resolution::errors::ResolverError,
-    },
+    hir::resolution::errors::ResolverError,
     hir_def::{
         expr::{HirCapturedVar, HirIdent},
         traits::Trait,
     },
-    macros_api::{Path, StructId},
-    node_interner::{DefinitionId, TraitId},
+    node_interner::{DefinitionId, StructId, TraitId},
     Shared, StructType,
 };
 use crate::{Type, TypeAlias};
 
+use super::path_resolution::PathResolutionItem;
 use super::types::SELF_TYPE_NAME;
 use super::{Elaborator, ResolverMeta};
 
@@ -28,16 +23,6 @@ type Scope = GenericScope<String, ResolverMeta>;
 type ScopeTree = GenericScopeTree<String, ResolverMeta>;
 
 impl<'context> Elaborator<'context> {
-    pub(super) fn lookup<T: TryFromModuleDefId>(&mut self, path: Path) -> Result<T, ResolverError> {
-        let span = path.span();
-        let id = self.resolve_path_or_error(path)?;
-        T::try_from(id).ok_or_else(|| ResolverError::Expected {
-            expected: T::description(),
-            got: id.as_str().to_owned(),
-            span,
-        })
-    }
-
     pub fn module_id(&self) -> ModuleId {
         assert_ne!(self.local_module, LocalModuleId::dummy_id(), "local_module is unset");
         ModuleId { krate: self.crate_id, local_id: self.local_module }
@@ -52,91 +37,6 @@ impl<'context> Elaborator<'context> {
         current_module
     }
 
-    pub(super) fn resolve_path_or_error(
-        &mut self,
-        path: Path,
-    ) -> Result<ModuleDefId, ResolverError> {
-        let path_resolution = self.resolve_path(path)?;
-
-        if let Some(error) = path_resolution.error {
-            self.push_err(error);
-        }
-
-        Ok(path_resolution.module_def_id)
-    }
-
-    pub(super) fn resolve_path(&mut self, path: Path) -> PathResolutionResult {
-        let mut module_id = self.module_id();
-        let mut path = path;
-
-        if path.kind == PathKind::Plain && path.first_name() == SELF_TYPE_NAME {
-            if let Some(Type::Struct(struct_type, _)) = &self.self_type {
-                let struct_type = struct_type.borrow();
-                if path.segments.len() == 1 {
-                    return Ok(PathResolution {
-                        module_def_id: ModuleDefId::TypeId(struct_type.id),
-                        error: None,
-                    });
-                }
-
-                module_id = struct_type.id.module_id();
-                path = Path {
-                    segments: path.segments[1..].to_vec(),
-                    kind: PathKind::Plain,
-                    span: path.span(),
-                };
-            }
-        }
-
-        self.resolve_path_in_module(path, module_id)
-    }
-
-    fn resolve_path_in_module(&mut self, path: Path, module_id: ModuleId) -> PathResolutionResult {
-        let resolver = StandardPathResolver::new(module_id);
-
-        if !self.interner.lsp_mode {
-            return resolver.resolve(
-                self.def_maps,
-                path,
-                &mut self.interner.usage_tracker,
-                &mut None,
-            );
-        }
-
-        let last_segment = path.last_ident();
-        let location = Location::new(last_segment.span(), self.file);
-        let is_self_type_name = last_segment.is_self_type_name();
-
-        let mut references: Vec<_> = Vec::new();
-        let path_resolution = resolver.resolve(
-            self.def_maps,
-            path.clone(),
-            &mut self.interner.usage_tracker,
-            &mut Some(&mut references),
-        );
-
-        for (referenced, segment) in references.iter().zip(path.segments) {
-            self.interner.add_reference(
-                *referenced,
-                Location::new(segment.ident.span(), self.file),
-                segment.ident.is_self_type_name(),
-            );
-        }
-
-        let path_resolution = match path_resolution {
-            Ok(path_resolution) => path_resolution,
-            Err(err) => return Err(err),
-        };
-
-        self.interner.add_module_def_id_reference(
-            path_resolution.module_def_id,
-            location,
-            is_self_type_name,
-        );
-
-        Ok(path_resolution)
-    }
-
     pub(super) fn get_struct(&self, type_id: StructId) -> Shared<StructType> {
         self.interner.get_struct(type_id)
     }
@@ -179,21 +79,24 @@ impl<'context> Elaborator<'context> {
         }
     }
 
-    pub(super) fn lookup_global(&mut self, path: Path) -> Result<DefinitionId, ResolverError> {
+    pub(super) fn lookup_global(
+        &mut self,
+        path: Path,
+    ) -> Result<(DefinitionId, PathResolutionItem), ResolverError> {
         let span = path.span();
-        let id = self.resolve_path_or_error(path)?;
+        let item = self.resolve_path_or_error(path)?;
 
-        if let Some(function) = TryFromModuleDefId::try_from(id) {
-            return Ok(self.interner.function_definition_id(function));
+        if let Some(function) = item.function_id() {
+            return Ok((self.interner.function_definition_id(function), item));
         }
 
-        if let Some(global) = TryFromModuleDefId::try_from(id) {
+        if let PathResolutionItem::Global(global) = item {
             let global = self.interner.get_global(global);
-            return Ok(global.definition_id);
+            return Ok((global.definition_id, item));
         }
 
-        let expected = "global variable".into();
-        let got = "local variable".into();
+        let expected = "global variable";
+        let got = "local variable";
         Err(ResolverError::Expected { span, expected, got })
     }
 
@@ -235,10 +138,22 @@ impl<'context> Elaborator<'context> {
 
     /// Lookup a given trait by name/path.
     pub fn lookup_trait_or_error(&mut self, path: Path) -> Option<&mut Trait> {
-        match self.lookup(path) {
-            Ok(trait_id) => Some(self.get_trait_mut(trait_id)),
-            Err(error) => {
-                self.push_err(error);
+        let span = path.span();
+        match self.resolve_path_or_error(path) {
+            Ok(item) => {
+                if let PathResolutionItem::Trait(trait_id) = item {
+                    Some(self.get_trait_mut(trait_id))
+                } else {
+                    self.push_err(ResolverError::Expected {
+                        expected: "trait",
+                        got: item.description(),
+                        span,
+                    });
+                    None
+                }
+            }
+            Err(err) => {
+                self.push_err(err);
                 None
             }
         }
@@ -246,10 +161,22 @@ impl<'context> Elaborator<'context> {
 
     /// Lookup a given struct type by name.
     pub fn lookup_struct_or_error(&mut self, path: Path) -> Option<Shared<StructType>> {
-        match self.lookup(path) {
-            Ok(struct_id) => Some(self.get_struct(struct_id)),
-            Err(error) => {
-                self.push_err(error);
+        let span = path.span();
+        match self.resolve_path_or_error(path) {
+            Ok(item) => {
+                if let PathResolutionItem::Struct(struct_id) = item {
+                    Some(self.get_struct(struct_id))
+                } else {
+                    self.push_err(ResolverError::Expected {
+                        expected: "type",
+                        got: item.description(),
+                        span,
+                    });
+                    None
+                }
+            }
+            Err(err) => {
+                self.push_err(err);
                 None
             }
         }
@@ -265,12 +192,26 @@ impl<'context> Elaborator<'context> {
             }
         }
 
-        match self.lookup(path) {
-            Ok(struct_id) => {
+        let span = path.span;
+        match self.resolve_path_or_error(path) {
+            Ok(PathResolutionItem::Struct(struct_id)) => {
                 let struct_type = self.get_struct(struct_id);
                 let generics = struct_type.borrow().instantiate(self.interner);
                 Some(Type::Struct(struct_type, generics))
             }
+            Ok(PathResolutionItem::TypeAlias(alias_id)) => {
+                let alias = self.interner.get_type_alias(alias_id);
+                let alias = alias.borrow();
+                Some(alias.instantiate(self.interner))
+            }
+            Ok(other) => {
+                self.push_err(ResolverError::Expected {
+                    expected: "type",
+                    got: other.description(),
+                    span,
+                });
+                None
+            }
             Err(error) => {
                 self.push_err(error);
                 None
@@ -279,6 +220,11 @@ impl<'context> Elaborator<'context> {
     }
 
     pub fn lookup_type_alias(&mut self, path: Path) -> Option<Shared<TypeAlias>> {
-        self.lookup(path).ok().map(|id| self.interner.get_type_alias(id))
+        match self.resolve_path_or_error(path) {
+            Ok(PathResolutionItem::TypeAlias(type_alias_id)) => {
+                Some(self.interner.get_type_alias(type_alias_id))
+            }
+            _ => None,
+        }
     }
 }
diff --git a/compiler/noirc_frontend/src/elaborator/statements.rs b/compiler/noirc_frontend/src/elaborator/statements.rs
index 55b641ca3d4..93009f49071 100644
--- a/compiler/noirc_frontend/src/elaborator/statements.rs
+++ b/compiler/noirc_frontend/src/elaborator/statements.rs
@@ -3,23 +3,25 @@ use noirc_errors::{Location, Span, Spanned};
 use crate::{
     ast::{
         AssignStatement, BinaryOpKind, ConstrainKind, ConstrainStatement, Expression,
-        ExpressionKind, InfixExpression, LValue,
+        ExpressionKind, ForLoopStatement, ForRange, Ident, InfixExpression, ItemVisibility, LValue,
+        LetStatement, Path, Statement, StatementKind,
     },
     hir::{
-        resolution::errors::ResolverError,
+        resolution::{
+            errors::ResolverError, import::PathResolutionError,
+            visibility::struct_member_is_visible,
+        },
         type_check::{Source, TypeCheckError},
     },
     hir_def::{
         expr::HirIdent,
         stmt::{
             HirAssignStatement, HirConstrainStatement, HirForStatement, HirLValue, HirLetStatement,
+            HirStatement,
         },
     },
-    macros_api::{
-        ForLoopStatement, ForRange, HirStatement, LetStatement, Path, Statement, StatementKind,
-    },
     node_interner::{DefinitionId, DefinitionKind, GlobalId, StmtId},
-    Type,
+    StructType, Type,
 };
 
 use super::{lints, Elaborator};
@@ -74,8 +76,17 @@ impl<'context> Elaborator<'context> {
     ) -> (HirStatement, Type) {
         let expr_span = let_stmt.expression.span;
         let (expression, expr_type) = self.elaborate_expression(let_stmt.expression);
+        let type_contains_unspecified = let_stmt.r#type.contains_unspecified();
         let annotated_type = self.resolve_inferred_type(let_stmt.r#type);
 
+        // Require the top-level of a global's type to be fully-specified
+        if type_contains_unspecified && global_id.is_some() {
+            let span = expr_span;
+            let expected_type = annotated_type.clone();
+            let error = ResolverError::UnspecifiedGlobalType { span, expected_type };
+            self.push_err(error);
+        }
+
         let definition = match global_id {
             None => DefinitionKind::Local(Some(expression)),
             Some(id) => DefinitionKind::Global(id),
@@ -108,7 +119,6 @@ impl<'context> Elaborator<'context> {
             definition,
             &mut Vec::new(),
             warn_if_unused,
-            global_id,
         );
 
         let attributes = let_stmt.attributes;
@@ -173,20 +183,20 @@ impl<'context> Elaborator<'context> {
     }
 
     pub(super) fn elaborate_assign(&mut self, assign: AssignStatement) -> (HirStatement, Type) {
-        let span = assign.expression.span;
+        let expr_span = assign.expression.span;
         let (expression, expr_type) = self.elaborate_expression(assign.expression);
-        let (lvalue, lvalue_type, mutable) = self.elaborate_lvalue(assign.lvalue, span);
+        let (lvalue, lvalue_type, mutable) = self.elaborate_lvalue(assign.lvalue);
 
         if !mutable {
             let (name, span) = self.get_lvalue_name_and_span(&lvalue);
             self.push_err(TypeCheckError::VariableMustBeMutable { name, span });
         }
 
-        self.unify_with_coercions(&expr_type, &lvalue_type, expression, span, || {
+        self.unify_with_coercions(&expr_type, &lvalue_type, expression, expr_span, || {
             TypeCheckError::TypeMismatchWithSource {
                 actual: expr_type.clone(),
                 expected: lvalue_type.clone(),
-                span,
+                span: expr_span,
                 source: Source::Assignment,
             }
         });
@@ -197,7 +207,7 @@ impl<'context> Elaborator<'context> {
 
     pub(super) fn elaborate_for(&mut self, for_loop: ForLoopStatement) -> (HirStatement, Type) {
         let (start, end) = match for_loop.range {
-            ForRange::Range(start, end) => (start, end),
+            ForRange::Range(bounds) => bounds.into_half_open(),
             ForRange::Array(_) => {
                 let for_stmt =
                     for_loop.range.into_for(for_loop.identifier, for_loop.block, for_loop.span);
@@ -286,13 +296,14 @@ impl<'context> Elaborator<'context> {
         }
     }
 
-    fn elaborate_lvalue(&mut self, lvalue: LValue, assign_span: Span) -> (HirLValue, Type, bool) {
+    fn elaborate_lvalue(&mut self, lvalue: LValue) -> (HirLValue, Type, bool) {
         match lvalue {
             LValue::Ident(ident) => {
                 let mut mutable = true;
                 let span = ident.span();
                 let path = Path::from_single(ident.0.contents, span);
-                let (ident, scope_index) = self.get_ident_from_path(path);
+                let ((ident, scope_index), _) = self.get_ident_from_path(path);
+
                 self.resolve_local_variable(ident.clone(), scope_index);
 
                 let typ = if ident.id == DefinitionId::dummy_id() {
@@ -319,7 +330,7 @@ impl<'context> Elaborator<'context> {
                 (HirLValue::Ident(ident.clone(), typ.clone()), typ, mutable)
             }
             LValue::MemberAccess { object, field_name, span } => {
-                let (object, lhs_type, mut mutable) = self.elaborate_lvalue(*object, assign_span);
+                let (object, lhs_type, mut mutable) = self.elaborate_lvalue(*object);
                 let mut object = Box::new(object);
                 let field_name = field_name.clone();
 
@@ -363,8 +374,7 @@ impl<'context> Elaborator<'context> {
                     expr_span,
                 });
 
-                let (mut lvalue, mut lvalue_type, mut mutable) =
-                    self.elaborate_lvalue(*array, assign_span);
+                let (mut lvalue, mut lvalue_type, mut mutable) = self.elaborate_lvalue(*array);
 
                 // Before we check that the lvalue is an array, try to dereference it as many times
                 // as needed to unwrap any &mut wrappers.
@@ -386,12 +396,15 @@ impl<'context> Elaborator<'context> {
                         self.push_err(TypeCheckError::StringIndexAssign { span: lvalue_span });
                         Type::Error
                     }
+                    Type::TypeVariable(_) => {
+                        self.push_err(TypeCheckError::TypeAnnotationsNeededForIndex { span });
+                        Type::Error
+                    }
                     other => {
-                        // TODO: Need a better span here
                         self.push_err(TypeCheckError::TypeMismatch {
                             expected_typ: "array".to_string(),
                             expr_typ: other.to_string(),
-                            expr_span: assign_span,
+                            expr_span: span,
                         });
                         Type::Error
                     }
@@ -402,7 +415,7 @@ impl<'context> Elaborator<'context> {
                 (HirLValue::Index { array, index, typ, location }, array_type, mutable)
             }
             LValue::Dereference(lvalue, span) => {
-                let (lvalue, reference_type, _) = self.elaborate_lvalue(*lvalue, assign_span);
+                let (lvalue, reference_type, _) = self.elaborate_lvalue(*lvalue);
                 let lvalue = Box::new(lvalue);
                 let location = Location::new(span, self.file);
 
@@ -412,7 +425,7 @@ impl<'context> Elaborator<'context> {
                 self.unify(&reference_type, &expected_type, || TypeCheckError::TypeMismatch {
                     expected_typ: expected_type.to_string(),
                     expr_typ: reference_type.to_string(),
-                    expr_span: assign_span,
+                    expr_span: span,
                 });
 
                 // Dereferences are always mutable since we already type checked against a &mut T
@@ -422,7 +435,7 @@ impl<'context> Elaborator<'context> {
             }
             LValue::Interned(id, span) => {
                 let lvalue = self.interner.get_lvalue(id, span).clone();
-                self.elaborate_lvalue(lvalue, assign_span)
+                self.elaborate_lvalue(lvalue)
             }
         }
     }
@@ -440,10 +453,12 @@ impl<'context> Elaborator<'context> {
         match &lhs_type {
             Type::Struct(s, args) => {
                 let s = s.borrow();
-                if let Some((field, index)) = s.get_field(field_name, args) {
+                if let Some((field, visibility, index)) = s.get_field(field_name, args) {
                     let reference_location = Location::new(span, self.file);
                     self.interner.add_struct_member_reference(s.id, index, reference_location);
 
+                    self.check_struct_field_visibility(&s, field_name, visibility, span);
+
                     return Some((field, index));
                 }
             }
@@ -498,6 +513,24 @@ impl<'context> Elaborator<'context> {
         None
     }
 
+    pub(super) fn check_struct_field_visibility(
+        &mut self,
+        struct_type: &StructType,
+        field_name: &str,
+        visibility: ItemVisibility,
+        span: Span,
+    ) {
+        if self.silence_field_visibility_errors > 0 {
+            return;
+        }
+
+        if !struct_member_is_visible(struct_type.id, visibility, self.module_id(), self.def_maps) {
+            self.push_err(ResolverError::PathResolutionError(PathResolutionError::Private(
+                Ident::new(field_name.to_string(), span),
+            )));
+        }
+    }
+
     fn elaborate_comptime_statement(&mut self, statement: Statement) -> (HirStatement, Type) {
         let span = statement.span;
         let (hir_statement, _typ) =
diff --git a/compiler/noirc_frontend/src/elaborator/trait_impls.rs b/compiler/noirc_frontend/src/elaborator/trait_impls.rs
index aa7e1cb89c5..20f048bed05 100644
--- a/compiler/noirc_frontend/src/elaborator/trait_impls.rs
+++ b/compiler/noirc_frontend/src/elaborator/trait_impls.rs
@@ -1,8 +1,7 @@
 use crate::{
-    ast::UnresolvedTypeExpression,
+    ast::{Ident, UnresolvedType, UnresolvedTypeData, UnresolvedTypeExpression},
     graph::CrateId,
     hir::def_collector::{dc_crate::UnresolvedTraitImpl, errors::DefCollectorErrorKind},
-    macros_api::{Ident, UnresolvedType, UnresolvedTypeData},
     node_interner::TraitImplId,
     ResolvedGeneric,
 };
@@ -154,22 +153,28 @@ impl<'context> Elaborator<'context> {
         // Substitute each generic on the trait function with the corresponding generic on the impl function
         for (
             ResolvedGeneric { type_var: trait_fn_generic, .. },
-            ResolvedGeneric { name, type_var: impl_fn_generic, kind, .. },
+            ResolvedGeneric { name, type_var: impl_fn_generic, .. },
         ) in method.direct_generics.iter().zip(&override_meta.direct_generics)
         {
-            let arg = Type::NamedGeneric(impl_fn_generic.clone(), name.clone(), kind.clone());
-            bindings.insert(trait_fn_generic.id(), (trait_fn_generic.clone(), arg));
+            let trait_fn_kind = trait_fn_generic.kind();
+            let arg = Type::NamedGeneric(impl_fn_generic.clone(), name.clone());
+            bindings.insert(
+                trait_fn_generic.id(),
+                (trait_fn_generic.clone(), trait_fn_kind.clone(), arg),
+            );
         }
 
         let mut substituted_method_ids = HashSet::default();
         for method_constraint in method.trait_constraints.iter() {
             let substituted_constraint_type = method_constraint.typ.substitute(&bindings);
-            let substituted_trait_generics =
-                method_constraint.trait_generics.map(|generic| generic.substitute(&bindings));
+            let substituted_trait_generics = method_constraint
+                .trait_bound
+                .trait_generics
+                .map(|generic| generic.substitute(&bindings));
 
             substituted_method_ids.insert((
                 substituted_constraint_type,
-                method_constraint.trait_id,
+                method_constraint.trait_bound.trait_id,
                 substituted_trait_generics,
             ));
         }
@@ -177,7 +182,8 @@ impl<'context> Elaborator<'context> {
         for override_trait_constraint in override_meta.trait_constraints.clone() {
             let override_constraint_is_from_impl =
                 trait_impl_where_clause.iter().any(|impl_constraint| {
-                    impl_constraint.trait_id == override_trait_constraint.trait_id
+                    impl_constraint.trait_bound.trait_id
+                        == override_trait_constraint.trait_bound.trait_id
                 });
             if override_constraint_is_from_impl {
                 continue;
@@ -185,15 +191,16 @@ impl<'context> Elaborator<'context> {
 
             if !substituted_method_ids.contains(&(
                 override_trait_constraint.typ.clone(),
-                override_trait_constraint.trait_id,
-                override_trait_constraint.trait_generics.clone(),
+                override_trait_constraint.trait_bound.trait_id,
+                override_trait_constraint.trait_bound.trait_generics.clone(),
             )) {
-                let the_trait = self.interner.get_trait(override_trait_constraint.trait_id);
+                let the_trait =
+                    self.interner.get_trait(override_trait_constraint.trait_bound.trait_id);
                 self.push_err(DefCollectorErrorKind::ImplIsStricterThanTrait {
                     constraint_typ: override_trait_constraint.typ,
                     constraint_name: the_trait.name.0.contents.clone(),
-                    constraint_generics: override_trait_constraint.trait_generics,
-                    constraint_span: override_trait_constraint.span,
+                    constraint_generics: override_trait_constraint.trait_bound.trait_generics,
+                    constraint_span: override_trait_constraint.trait_bound.span,
                     trait_method_name: method.name.0.contents.clone(),
                     trait_method_span: method.location.span,
                 });
diff --git a/compiler/noirc_frontend/src/elaborator/traits.rs b/compiler/noirc_frontend/src/elaborator/traits.rs
index d7c8769620d..e1be45927ca 100644
--- a/compiler/noirc_frontend/src/elaborator/traits.rs
+++ b/compiler/noirc_frontend/src/elaborator/traits.rs
@@ -5,16 +5,17 @@ use noirc_errors::{Location, Span};
 
 use crate::{
     ast::{
-        FunctionKind, TraitItem, UnresolvedGeneric, UnresolvedGenerics, UnresolvedTraitConstraint,
+        BlockExpression, FunctionDefinition, FunctionKind, FunctionReturnType, Ident,
+        ItemVisibility, NoirFunction, TraitItem, UnresolvedGeneric, UnresolvedGenerics,
+        UnresolvedTraitConstraint, UnresolvedType,
     },
     hir::{def_collector::dc_crate::UnresolvedTrait, type_check::TypeCheckError},
-    hir_def::{function::Parameters, traits::TraitFunction},
-    macros_api::{
-        BlockExpression, FunctionDefinition, FunctionReturnType, Ident, ItemVisibility,
-        NodeInterner, NoirFunction, UnresolvedType,
+    hir_def::{
+        function::Parameters,
+        traits::{ResolvedTraitBound, TraitFunction},
     },
-    node_interner::{FuncId, ReferenceId, TraitId},
-    Kind, ResolvedGeneric, Type, TypeBindings, TypeVariableKind,
+    node_interner::{DependencyId, FuncId, NodeInterner, ReferenceId, TraitId},
+    ResolvedGeneric, Type, TypeBindings,
 };
 
 use super::Elaborator;
@@ -22,6 +23,8 @@ use super::Elaborator;
 impl<'context> Elaborator<'context> {
     pub fn collect_traits(&mut self, traits: &BTreeMap<TraitId, UnresolvedTrait>) {
         for (trait_id, unresolved_trait) in traits {
+            self.local_module = unresolved_trait.module_id;
+
             self.recover_generics(|this| {
                 this.current_trait = Some(*trait_id);
 
@@ -31,15 +34,26 @@ impl<'context> Elaborator<'context> {
                     &resolved_generics,
                 );
 
+                let where_clause =
+                    this.resolve_trait_constraints(&unresolved_trait.trait_def.where_clause);
+
                 // Each associated type in this trait is also an implicit generic
                 for associated_type in &this.interner.get_trait(*trait_id).associated_types {
                     this.generics.push(associated_type.clone());
                 }
 
+                let resolved_trait_bounds = this.resolve_trait_bounds(unresolved_trait);
+                for bound in &resolved_trait_bounds {
+                    this.interner
+                        .add_trait_dependency(DependencyId::Trait(bound.trait_id), *trait_id);
+                }
+
                 let methods = this.resolve_trait_methods(*trait_id, unresolved_trait);
 
                 this.interner.update_trait(*trait_id, |trait_def| {
                     trait_def.set_methods(methods);
+                    trait_def.set_trait_bounds(resolved_trait_bounds);
+                    trait_def.set_where_clause(where_clause);
                 });
             });
 
@@ -55,6 +69,14 @@ impl<'context> Elaborator<'context> {
         self.current_trait = None;
     }
 
+    fn resolve_trait_bounds(
+        &mut self,
+        unresolved_trait: &UnresolvedTrait,
+    ) -> Vec<ResolvedTraitBound> {
+        let bounds = &unresolved_trait.trait_def.bounds;
+        bounds.iter().filter_map(|bound| self.resolve_trait_bound(bound)).collect()
+    }
+
     fn resolve_trait_methods(
         &mut self,
         trait_id: TraitId,
@@ -81,8 +103,7 @@ impl<'context> Elaborator<'context> {
                 self.recover_generics(|this| {
                     let the_trait = this.interner.get_trait(trait_id);
                     let self_typevar = the_trait.self_type_typevar.clone();
-                    let self_type =
-                        Type::TypeVariable(self_typevar.clone(), TypeVariableKind::Normal);
+                    let self_type = Type::TypeVariable(self_typevar.clone());
                     let name_span = the_trait.name.span();
 
                     this.add_existing_generic(
@@ -92,7 +113,6 @@ impl<'context> Elaborator<'context> {
                             name: Rc::new("Self".to_owned()),
                             type_var: self_typevar,
                             span: name_span,
-                            kind: Kind::Normal,
                         },
                     );
                     this.self_type = Some(self_type.clone());
@@ -281,11 +301,12 @@ pub(crate) fn check_trait_impl_method_matches_declaration(
         // Substitute each generic on the trait function with the corresponding generic on the impl function
         for (
             ResolvedGeneric { type_var: trait_fn_generic, .. },
-            ResolvedGeneric { name, type_var: impl_fn_generic, kind, .. },
+            ResolvedGeneric { name, type_var: impl_fn_generic, .. },
         ) in trait_fn_meta.direct_generics.iter().zip(&meta.direct_generics)
         {
-            let arg = Type::NamedGeneric(impl_fn_generic.clone(), name.clone(), kind.clone());
-            bindings.insert(trait_fn_generic.id(), (trait_fn_generic.clone(), arg));
+            let trait_fn_kind = trait_fn_generic.kind();
+            let arg = Type::NamedGeneric(impl_fn_generic.clone(), name.clone());
+            bindings.insert(trait_fn_generic.id(), (trait_fn_generic.clone(), trait_fn_kind, arg));
         }
 
         let (declaration_type, _) = trait_fn_meta.typ.instantiate_with_bindings(bindings, interner);
diff --git a/compiler/noirc_frontend/src/elaborator/types.rs b/compiler/noirc_frontend/src/elaborator/types.rs
index 264b83956f8..2e4809f3511 100644
--- a/compiler/noirc_frontend/src/elaborator/types.rs
+++ b/compiler/noirc_frontend/src/elaborator/types.rs
@@ -1,4 +1,4 @@
-use std::{borrow::Cow, collections::BTreeMap, rc::Rc};
+use std::{borrow::Cow, rc::Rc};
 
 use acvm::acir::AcirField;
 use iter_extended::vecmap;
@@ -7,14 +7,14 @@ use rustc_hash::FxHashMap as HashMap;
 
 use crate::{
     ast::{
-        AsTraitPath, BinaryOpKind, GenericTypeArgs, IntegerBitSize, UnresolvedGeneric,
-        UnresolvedGenerics, UnresolvedTypeExpression,
+        AsTraitPath, BinaryOpKind, GenericTypeArgs, Ident, IntegerBitSize, Path, PathKind,
+        Signedness, UnaryOp, UnresolvedGeneric, UnresolvedGenerics, UnresolvedType,
+        UnresolvedTypeData, UnresolvedTypeExpression, WILDCARD_TYPE,
     },
     hir::{
         comptime::{Interpreter, Value},
         def_collector::dc_crate::CompilationError,
-        def_map::ModuleDefId,
-        resolution::errors::ResolverError,
+        resolution::{errors::ResolverError, import::PathResolutionError},
         type_check::{
             generics::{Generic, TraitGenerics},
             NoMatchingImplFoundError, Source, TypeCheckError,
@@ -22,28 +22,30 @@ use crate::{
     },
     hir_def::{
         expr::{
-            HirBinaryOp, HirCallExpression, HirMemberAccess, HirMethodReference,
-            HirPrefixExpression,
+            HirBinaryOp, HirCallExpression, HirExpression, HirLiteral, HirMemberAccess,
+            HirMethodReference, HirPrefixExpression, TraitMethod,
         },
-        function::{FuncMeta, Parameters},
-        traits::{NamedType, TraitConstraint},
-    },
-    macros_api::{
-        HirExpression, HirLiteral, HirStatement, Ident, NodeInterner, Path, PathKind,
-        SecondaryAttribute, Signedness, UnaryOp, UnresolvedType, UnresolvedTypeData,
+        function::FuncMeta,
+        stmt::HirStatement,
+        traits::{NamedType, ResolvedTraitBound, Trait, TraitConstraint},
     },
     node_interner::{
-        DefinitionKind, DependencyId, ExprId, FuncId, GlobalId, ImplSearchErrorKind, TraitId,
+        DefinitionKind, DependencyId, ExprId, GlobalId, ImplSearchErrorKind, NodeInterner, TraitId,
         TraitImplKind, TraitMethodId,
     },
-    Generics, Kind, ResolvedGeneric, Type, TypeBinding, TypeBindings, TypeVariable,
-    TypeVariableKind, UnificationError,
+    token::SecondaryAttribute,
+    Generics, Kind, ResolvedGeneric, Type, TypeBinding, TypeBindings, UnificationError,
 };
 
-use super::{lints, Elaborator};
+use super::{lints, path_resolution::PathResolutionItem, Elaborator};
 
 pub const SELF_TYPE_NAME: &str = "Self";
-pub const WILDCARD_TYPE: &str = "_";
+
+pub(super) struct TraitPathResolution {
+    pub(super) method: TraitMethod,
+    pub(super) item: Option<PathResolutionItem>,
+    pub(super) errors: Vec<PathResolutionError>,
+}
 
 impl<'context> Elaborator<'context> {
     /// Translates an UnresolvedType to a Type with a `TypeKind::Normal`
@@ -126,7 +128,7 @@ impl<'context> Elaborator<'context> {
                 let env = Box::new(self.resolve_type_inner(*env, kind));
 
                 match *env {
-                    Type::Unit | Type::Tuple(_) | Type::NamedGeneric(_, _, _) => {
+                    Type::Unit | Type::Tuple(_) | Type::NamedGeneric(_, _) => {
                         Type::Function(args, ret, env, unconstrained)
                     }
                     _ => {
@@ -169,14 +171,10 @@ impl<'context> Elaborator<'context> {
             _ => (),
         }
 
-        if !kind.matches_opt(resolved_type.kind()) {
+        if !kind.unifies(&resolved_type.kind()) {
             let expected_typ_err = CompilationError::TypeError(TypeCheckError::TypeKindMismatch {
                 expected_kind: kind.to_string(),
-                expr_kind: resolved_type
-                    .kind()
-                    .as_ref()
-                    .map(Kind::to_string)
-                    .unwrap_or("unknown".to_string()),
+                expr_kind: resolved_type.kind().to_string(),
                 expr_span: span,
             });
             self.errors.push((expected_typ_err, self.file));
@@ -192,7 +190,7 @@ impl<'context> Elaborator<'context> {
 
     // Resolve Self::Foo to an associated type on the current trait or trait impl
     fn lookup_associated_type_on_self(&self, path: &Path) -> Option<Type> {
-        if path.segments.len() == 2 && path.first_name() == SELF_TYPE_NAME {
+        if path.segments.len() == 2 && path.first_name() == Some(SELF_TYPE_NAME) {
             if let Some(trait_id) = self.current_trait {
                 let the_trait = self.interner.get_trait(trait_id);
                 if let Some(typ) = the_trait.get_associated_type(path.last_name()) {
@@ -230,7 +228,7 @@ impl<'context> Elaborator<'context> {
                     return self_type;
                 }
             } else if name == WILDCARD_TYPE {
-                return self.interner.next_type_variable();
+                return self.interner.next_type_variable_with_kind(Kind::Any);
             }
         } else if let Some(typ) = self.lookup_associated_type_on_self(&path) {
             if !args.is_empty() {
@@ -333,7 +331,7 @@ impl<'context> Elaborator<'context> {
 
         let ordered_args = expected_kinds.iter().zip(args.ordered_args);
         let ordered =
-            vecmap(ordered_args, |(generic, typ)| self.resolve_type_inner(typ, &generic.kind));
+            vecmap(ordered_args, |(generic, typ)| self.resolve_type_inner(typ, &generic.kind()));
 
         let mut associated = Vec::new();
 
@@ -377,7 +375,7 @@ impl<'context> Elaborator<'context> {
             let expected = required_args.remove(index);
             seen_args.insert(name.0.contents.clone(), name.span());
 
-            let typ = self.resolve_type_inner(typ, &expected.kind);
+            let typ = self.resolve_type_inner(typ, &expected.kind());
             resolved.push(NamedType { name, typ });
         }
 
@@ -396,7 +394,7 @@ impl<'context> Elaborator<'context> {
             let name = path.last_name();
             if let Some(generic) = self.find_generic(name) {
                 let generic = generic.clone();
-                return Some(Type::NamedGeneric(generic.type_var, generic.name, generic.kind));
+                return Some(Type::NamedGeneric(generic.type_var, generic.name));
             }
         } else if let Some(typ) = self.lookup_associated_type_on_self(path) {
             return Some(typ);
@@ -404,7 +402,7 @@ impl<'context> Elaborator<'context> {
 
         // If we cannot find a local generic of the same name, try to look up a global
         match self.resolve_path_or_error(path.clone()) {
-            Ok(ModuleDefId::GlobalId(id)) => {
+            Ok(PathResolutionItem::Global(id)) => {
                 if let Some(current_item) = self.current_item {
                     self.interner.add_global_dependency(current_item, id);
                 }
@@ -414,10 +412,20 @@ impl<'context> Elaborator<'context> {
                 let kind = self
                     .interner
                     .get_global_let_statement(id)
-                    .map(|let_statement| Kind::Numeric(Box::new(let_statement.r#type)))
+                    .map(|let_statement| Kind::numeric(let_statement.r#type))
                     .unwrap_or(Kind::u32());
 
-                Some(Type::Constant(self.eval_global_as_array_length(id, path), kind))
+                // TODO(https://github.com/noir-lang/noir/issues/6238):
+                // support non-u32 generics here
+                if !kind.unifies(&Kind::u32()) {
+                    let error = TypeCheckError::EvaluatedGlobalIsntU32 {
+                        expected_kind: Kind::u32().to_string(),
+                        expr_kind: kind.to_string(),
+                        expr_span: path.span(),
+                    };
+                    self.push_err(error);
+                }
+                Some(Type::Constant(self.eval_global_as_array_length(id, path).into(), kind))
             }
             _ => None,
         }
@@ -452,14 +460,26 @@ impl<'context> Elaborator<'context> {
                             });
                             return Type::Error;
                         }
-                        if let Some(result) = op.function(lhs, rhs) {
-                            Type::Constant(result, lhs_kind)
-                        } else {
-                            self.push_err(ResolverError::OverflowInType { lhs, op, rhs, span });
-                            Type::Error
+                        match op.function(lhs, rhs, &lhs_kind, span) {
+                            Ok(result) => Type::Constant(result, lhs_kind),
+                            Err(err) => {
+                                let err = Box::new(err);
+                                self.push_err(ResolverError::BinaryOpError {
+                                    lhs,
+                                    op,
+                                    rhs,
+                                    err,
+                                    span,
+                                });
+                                Type::Error
+                            }
                         }
                     }
-                    (lhs, rhs) => Type::InfixExpr(Box::new(lhs), op, Box::new(rhs)).canonicalize(),
+                    (lhs, rhs) => {
+                        let infix = Type::InfixExpr(Box::new(lhs), op, Box::new(rhs));
+                        Type::CheckedCast { from: Box::new(infix.clone()), to: Box::new(infix) }
+                            .canonicalize()
+                    }
                 }
             }
             UnresolvedTypeExpression::AsTraitPath(path) => {
@@ -470,15 +490,13 @@ impl<'context> Elaborator<'context> {
     }
 
     fn check_kind(&mut self, typ: Type, expected_kind: &Kind, span: Span) -> Type {
-        if let Some(kind) = typ.kind() {
-            if !kind.unifies(expected_kind) {
-                self.push_err(TypeCheckError::TypeKindMismatch {
-                    expected_kind: expected_kind.to_string(),
-                    expr_kind: kind.to_string(),
-                    expr_span: span,
-                });
-                return Type::Error;
-            }
+        if !typ.kind().unifies(expected_kind) {
+            self.push_err(TypeCheckError::TypeKindMismatch {
+                expected_kind: expected_kind.to_string(),
+                expr_kind: typ.kind().to_string(),
+                expr_span: span,
+            });
+            return Type::Error;
         }
         typ
     }
@@ -529,10 +547,7 @@ impl<'context> Elaborator<'context> {
     //
     // Returns the trait method, trait constraint, and whether the impl is assumed to exist by a where clause or not
     // E.g. `t.method()` with `where T: Foo<Bar>` in scope will return `(Foo::method, T, vec![Bar])`
-    fn resolve_trait_static_method_by_self(
-        &mut self,
-        path: &Path,
-    ) -> Option<(TraitMethodId, TraitConstraint, bool)> {
+    fn resolve_trait_static_method_by_self(&mut self, path: &Path) -> Option<TraitPathResolution> {
         let trait_impl = self.current_trait_impl?;
         let trait_id = self.interner.try_get_trait_implementation(trait_impl)?.borrow().trait_id;
 
@@ -544,7 +559,11 @@ impl<'context> Elaborator<'context> {
                 let the_trait = self.interner.get_trait(trait_id);
                 let method = the_trait.find_method(method.0.contents.as_str())?;
                 let constraint = the_trait.as_constraint(path.span);
-                return Some((method, constraint, true));
+                return Some(TraitPathResolution {
+                    method: TraitMethod { method_id: method, constraint, assumed: true },
+                    item: None,
+                    errors: Vec::new(),
+                });
             }
         }
         None
@@ -554,16 +573,18 @@ impl<'context> Elaborator<'context> {
     //
     // Returns the trait method, trait constraint, and whether the impl is assumed to exist by a where clause or not
     // E.g. `t.method()` with `where T: Foo<Bar>` in scope will return `(Foo::method, T, vec![Bar])`
-    fn resolve_trait_static_method(
-        &mut self,
-        path: &Path,
-    ) -> Option<(TraitMethodId, TraitConstraint, bool)> {
-        let func_id: FuncId = self.lookup(path.clone()).ok()?;
-        let meta = self.interner.function_meta(&func_id);
+    fn resolve_trait_static_method(&mut self, path: &Path) -> Option<TraitPathResolution> {
+        let path_resolution = self.resolve_path(path.clone()).ok()?;
+        let func_id = path_resolution.item.function_id()?;
+        let meta = self.interner.try_function_meta(&func_id)?;
         let the_trait = self.interner.get_trait(meta.trait_id?);
         let method = the_trait.find_method(path.last_name())?;
         let constraint = the_trait.as_constraint(path.span);
-        Some((method, constraint, false))
+        Some(TraitPathResolution {
+            method: TraitMethod { method_id: method, constraint, assumed: false },
+            item: Some(path_resolution.item),
+            errors: path_resolution.errors,
+        })
     }
 
     // This resolves a static trait method T::trait_method by iterating over the where clause
@@ -574,21 +595,25 @@ impl<'context> Elaborator<'context> {
     fn resolve_trait_method_by_named_generic(
         &mut self,
         path: &Path,
-    ) -> Option<(TraitMethodId, TraitConstraint, bool)> {
+    ) -> Option<TraitPathResolution> {
         if path.segments.len() != 2 {
             return None;
         }
 
         for constraint in self.trait_bounds.clone() {
-            if let Type::NamedGeneric(_, name, _) = &constraint.typ {
+            if let Type::NamedGeneric(_, name) = &constraint.typ {
                 // if `path` is `T::method_name`, we're looking for constraint of the form `T: SomeTrait`
                 if path.segments[0].ident.0.contents != name.as_str() {
                     continue;
                 }
 
-                let the_trait = self.interner.get_trait(constraint.trait_id);
+                let the_trait = self.interner.get_trait(constraint.trait_bound.trait_id);
                 if let Some(method) = the_trait.find_method(path.last_name()) {
-                    return Some((method, constraint, true));
+                    return Some(TraitPathResolution {
+                        method: TraitMethod { method_id: method, constraint, assumed: true },
+                        item: None,
+                        errors: Vec::new(),
+                    });
                 }
             }
         }
@@ -602,7 +627,7 @@ impl<'context> Elaborator<'context> {
     pub(super) fn resolve_trait_generic_path(
         &mut self,
         path: &Path,
-    ) -> Option<(TraitMethodId, TraitConstraint, bool)> {
+    ) -> Option<TraitPathResolution> {
         self.resolve_trait_static_method_by_self(path)
             .or_else(|| self.resolve_trait_static_method(path))
             .or_else(|| self.resolve_trait_method_by_named_generic(path))
@@ -697,11 +722,21 @@ impl<'context> Elaborator<'context> {
         typ
     }
 
+    /// Return a fresh integer type variable and log it
+    /// in self.type_variables to default it later.
+    pub(super) fn type_variable_with_kind(&mut self, type_var_kind: Kind) -> Type {
+        let typ = Type::type_variable_with_kind(self.interner, type_var_kind);
+        self.push_type_variable(typ.clone());
+        typ
+    }
+
     /// Translates a (possibly Unspecified) UnresolvedType to a Type.
     /// Any UnresolvedType::Unspecified encountered are replaced with fresh type variables.
     pub(super) fn resolve_inferred_type(&mut self, typ: UnresolvedType) -> Type {
         match &typ.typ {
-            UnresolvedTypeData::Unspecified => self.interner.next_type_variable(),
+            UnresolvedTypeData::Unspecified => {
+                self.interner.next_type_variable_with_kind(Kind::Any)
+            }
             _ => self.resolve_type(typ),
         }
     }
@@ -790,7 +825,7 @@ impl<'context> Elaborator<'context> {
         // Could do a single unification for the entire function type, but matching beforehand
         // lets us issue a more precise error on the individual argument that fails to type check.
         match function {
-            Type::TypeVariable(binding, TypeVariableKind::Normal) => {
+            Type::TypeVariable(binding) if binding.kind() == Kind::Normal => {
                 if let TypeBinding::Bound(typ) = &*binding.borrow() {
                     return self.bind_function_type(typ.clone(), args, span);
                 }
@@ -801,7 +836,8 @@ impl<'context> Elaborator<'context> {
                 let expected =
                     Type::Function(args, Box::new(ret.clone()), Box::new(env_type), false);
 
-                if let Err(error) = binding.try_bind(expected, span) {
+                let expected_kind = expected.kind();
+                if let Err(error) = binding.try_bind(expected, &expected_kind, span) {
                     self.push_err(error);
                 }
                 ret
@@ -819,28 +855,60 @@ impl<'context> Elaborator<'context> {
         }
     }
 
-    pub(super) fn check_cast(&mut self, from: &Type, to: &Type, span: Span) -> Type {
-        match from.follow_bindings() {
-            Type::Integer(..)
-            | Type::FieldElement
-            | Type::TypeVariable(_, TypeVariableKind::IntegerOrField)
-            | Type::TypeVariable(_, TypeVariableKind::Integer)
-            | Type::Bool => (),
+    pub(super) fn check_cast(
+        &mut self,
+        from_expr_id: &ExprId,
+        from: &Type,
+        to: &Type,
+        span: Span,
+    ) -> Type {
+        let from_follow_bindings = from.follow_bindings();
+
+        let from_value_opt = match self.interner.expression(from_expr_id) {
+            HirExpression::Literal(HirLiteral::Integer(int, false)) => Some(int),
 
-            Type::TypeVariable(_, _) => {
+            // TODO(https://github.com/noir-lang/noir/issues/6247):
+            // handle negative literals
+            _ => None,
+        };
+
+        let from_is_polymorphic = match from_follow_bindings {
+            Type::Integer(..) | Type::FieldElement | Type::Bool => false,
+
+            Type::TypeVariable(ref var) if var.is_integer() || var.is_integer_or_field() => true,
+            Type::TypeVariable(_) => {
                 // NOTE: in reality the expected type can also include bool, but for the compiler's simplicity
                 // we only allow integer types. If a bool is in `from` it will need an explicit type annotation.
-                let expected = Type::polymorphic_integer_or_field(self.interner);
+                let expected = self.polymorphic_integer_or_field();
                 self.unify(from, &expected, || TypeCheckError::InvalidCast {
                     from: from.clone(),
                     span,
+                    reason: "casting from a non-integral type is unsupported".into(),
                 });
+                true
             }
             Type::Error => return Type::Error,
             from => {
-                self.push_err(TypeCheckError::InvalidCast { from, span });
+                let reason = "casting from this type is unsupported".into();
+                self.push_err(TypeCheckError::InvalidCast { from, span, reason });
                 return Type::Error;
             }
+        };
+
+        // TODO(https://github.com/noir-lang/noir/issues/6247):
+        // handle negative literals
+        // when casting a polymorphic value to a specifically sized type,
+        // check that it fits or throw a warning
+        if let (Some(from_value), Some(to_maximum_size)) =
+            (from_value_opt, to.integral_maximum_size())
+        {
+            if from_is_polymorphic && from_value > to_maximum_size {
+                let from = from.clone();
+                let to = to.clone();
+                let reason = format!("casting untyped value ({from_value}) to a type with a maximum size ({to_maximum_size}) that's smaller than it");
+                // we warn that the 'to' type is too small for the value
+                self.push_err(TypeCheckError::DownsizingCast { from, to, span, reason });
+            }
         }
 
         match to {
@@ -878,8 +946,8 @@ impl<'context> Elaborator<'context> {
 
             // Matches on TypeVariable must be first to follow any type
             // bindings.
-            (TypeVariable(var, _), other) | (other, TypeVariable(var, _)) => {
-                if let TypeBinding::Bound(binding) = &*var.borrow() {
+            (TypeVariable(var), other) | (other, TypeVariable(var)) => {
+                if let TypeBinding::Bound(ref binding) = &*var.borrow() {
                     return self.comparator_operand_type_rules(other, binding, op, span);
                 }
 
@@ -943,14 +1011,14 @@ impl<'context> Elaborator<'context> {
             span,
         });
 
-        let use_impl = !lhs_type.is_numeric();
+        let use_impl = !lhs_type.is_numeric_value();
 
         // If this operator isn't valid for fields we have to possibly narrow
-        // TypeVariableKind::IntegerOrField to TypeVariableKind::Integer.
+        // Kind::IntegerOrField to Kind::Integer.
         // Doing so also ensures a type error if Field is used.
         // The is_numeric check is to allow impls for custom types to bypass this.
-        if !op.kind.is_valid_for_field_type() && lhs_type.is_numeric() {
-            let target = Type::polymorphic_integer(self.interner);
+        if !op.kind.is_valid_for_field_type() && lhs_type.is_numeric_value() {
+            let target = self.polymorphic_integer();
 
             use crate::ast::BinaryOpKind::*;
             use TypeCheckError::*;
@@ -991,22 +1059,22 @@ impl<'context> Elaborator<'context> {
 
             // Matches on TypeVariable must be first so that we follow any type
             // bindings.
-            (TypeVariable(int, _), other) | (other, TypeVariable(int, _)) => {
+            (TypeVariable(int), other) | (other, TypeVariable(int)) => {
                 if op.kind == BinaryOpKind::ShiftLeft || op.kind == BinaryOpKind::ShiftRight {
                     self.unify(
                         rhs_type,
                         &Type::Integer(Signedness::Unsigned, IntegerBitSize::Eight),
                         || TypeCheckError::InvalidShiftSize { span },
                     );
-                    let use_impl = if lhs_type.is_numeric() {
-                        let integer_type = Type::polymorphic_integer(self.interner);
+                    let use_impl = if lhs_type.is_numeric_value() {
+                        let integer_type = self.polymorphic_integer();
                         self.bind_type_variables_for_infix(lhs_type, op, &integer_type, span)
                     } else {
                         true
                     };
                     return Ok((lhs_type.clone(), use_impl));
                 }
-                if let TypeBinding::Bound(binding) = &*int.borrow() {
+                if let TypeBinding::Bound(ref binding) = &*int.borrow() {
                     return self.infix_operand_type_rules(binding, op, other, span);
                 }
                 let use_impl = self.bind_type_variables_for_infix(lhs_type, op, rhs_type, span);
@@ -1091,21 +1159,21 @@ impl<'context> Elaborator<'context> {
 
                     // Matches on TypeVariable must be first so that we follow any type
                     // bindings.
-                    TypeVariable(int, _) => {
-                        if let TypeBinding::Bound(binding) = &*int.borrow() {
+                    TypeVariable(int) => {
+                        if let TypeBinding::Bound(ref binding) = &*int.borrow() {
                             return self.prefix_operand_type_rules(op, binding, span);
                         }
 
                         // The `!` prefix operator is not valid for Field, so if this is a numeric
                         // type we constrain it to just (non-Field) integer types.
-                        if matches!(op, crate::ast::UnaryOp::Not) && rhs_type.is_numeric() {
+                        if matches!(op, crate::ast::UnaryOp::Not) && rhs_type.is_numeric_value() {
                             let integer_type = Type::polymorphic_integer(self.interner);
                             self.unify(rhs_type, &integer_type, || {
                                 TypeCheckError::InvalidUnaryOp { kind: rhs_type.to_string(), span }
                             });
                         }
 
-                        Ok((rhs_type.clone(), !rhs_type.is_numeric()))
+                        Ok((rhs_type.clone(), !rhs_type.is_numeric_value()))
                     }
                     Integer(sign_x, bit_width_x) => {
                         if *op == UnaryOp::Minus && *sign_x == Signedness::Unsigned {
@@ -1187,7 +1255,11 @@ impl<'context> Elaborator<'context> {
             let object_type = object_type.substitute(&bindings);
             bindings.insert(
                 the_trait.self_type_typevar.id(),
-                (the_trait.self_type_typevar.clone(), object_type.clone()),
+                (
+                    the_trait.self_type_typevar.clone(),
+                    the_trait.self_type_typevar.kind(),
+                    object_type.clone(),
+                ),
             );
             self.interner.select_impl_for_expression(
                 expr_id,
@@ -1249,11 +1321,23 @@ impl<'context> Elaborator<'context> {
                 {
                     Some(method_id) => Some(HirMethodReference::FuncId(method_id)),
                     None => {
-                        self.push_err(TypeCheckError::UnresolvedMethodCall {
-                            method_name: method_name.to_string(),
-                            object_type: object_type.clone(),
-                            span,
-                        });
+                        let has_field_with_function_type =
+                            typ.borrow().get_fields_as_written().into_iter().any(|field| {
+                                field.name.0.contents == method_name && field.typ.is_function()
+                            });
+                        if has_field_with_function_type {
+                            self.push_err(TypeCheckError::CannotInvokeStructFieldFunctionType {
+                                method_name: method_name.to_string(),
+                                object_type: object_type.clone(),
+                                span,
+                            });
+                        } else {
+                            self.push_err(TypeCheckError::UnresolvedMethodCall {
+                                method_name: method_name.to_string(),
+                                object_type: object_type.clone(),
+                                span,
+                            });
+                        }
                         None
                     }
                 }
@@ -1268,7 +1352,7 @@ impl<'context> Elaborator<'context> {
                 });
                 None
             }
-            Type::NamedGeneric(_, _, _) => {
+            Type::NamedGeneric(_, _) => {
                 self.lookup_method_in_trait_constraints(object_type, method_name, span)
             }
             // Mutable references to another type should resolve to methods of their element type.
@@ -1284,7 +1368,7 @@ impl<'context> Elaborator<'context> {
             Type::Error => None,
 
             // The type variable must be unbound at this point since follow_bindings was called
-            Type::TypeVariable(_, TypeVariableKind::Normal) => {
+            Type::TypeVariable(var) if var.kind() == Kind::Normal => {
                 self.push_err(TypeCheckError::TypeAnnotationsNeededForMethodCall { span });
                 None
             }
@@ -1316,15 +1400,16 @@ impl<'context> Elaborator<'context> {
 
         for constraint in &func_meta.trait_constraints {
             if *object_type == constraint.typ {
-                if let Some(the_trait) = self.interner.try_get_trait(constraint.trait_id) {
-                    for (method_index, method) in the_trait.methods.iter().enumerate() {
-                        if method.name.0.contents == method_name {
-                            let trait_method =
-                                TraitMethodId { trait_id: constraint.trait_id, method_index };
-
-                            let generics = constraint.trait_generics.clone();
-                            return Some(HirMethodReference::TraitMethodId(trait_method, generics));
-                        }
+                if let Some(the_trait) =
+                    self.interner.try_get_trait(constraint.trait_bound.trait_id)
+                {
+                    if let Some(method) = self.lookup_method_in_trait(
+                        the_trait,
+                        method_name,
+                        &constraint.trait_bound,
+                        the_trait.id,
+                    ) {
+                        return Some(method);
                     }
                 }
             }
@@ -1339,6 +1424,44 @@ impl<'context> Elaborator<'context> {
         None
     }
 
+    fn lookup_method_in_trait(
+        &self,
+        the_trait: &Trait,
+        method_name: &str,
+        trait_bound: &ResolvedTraitBound,
+        starting_trait_id: TraitId,
+    ) -> Option<HirMethodReference> {
+        if let Some(trait_method) = the_trait.find_method(method_name) {
+            return Some(HirMethodReference::TraitMethodId(
+                trait_method,
+                trait_bound.trait_generics.clone(),
+            ));
+        }
+
+        // Search in the parent traits, if any
+        for parent_trait_bound in &the_trait.trait_bounds {
+            if let Some(the_trait) = self.interner.try_get_trait(parent_trait_bound.trait_id) {
+                // Avoid looping forever in case there are cycles
+                if the_trait.id == starting_trait_id {
+                    continue;
+                }
+
+                let parent_trait_bound =
+                    self.instantiate_parent_trait_bound(trait_bound, parent_trait_bound);
+                if let Some(method) = self.lookup_method_in_trait(
+                    the_trait,
+                    method_name,
+                    &parent_trait_bound,
+                    starting_trait_id,
+                ) {
+                    return Some(method);
+                }
+            }
+        }
+
+        None
+    }
+
     pub(super) fn type_check_call(
         &mut self,
         call: &HirCallExpression,
@@ -1612,105 +1735,6 @@ impl<'context> Elaborator<'context> {
         }
     }
 
-    pub fn find_numeric_generics(
-        parameters: &Parameters,
-        return_type: &Type,
-    ) -> Vec<(String, TypeVariable)> {
-        let mut found = BTreeMap::new();
-        for (_, parameter, _) in &parameters.0 {
-            Self::find_numeric_generics_in_type(parameter, &mut found);
-        }
-        Self::find_numeric_generics_in_type(return_type, &mut found);
-        found.into_iter().collect()
-    }
-
-    fn find_numeric_generics_in_type(typ: &Type, found: &mut BTreeMap<String, TypeVariable>) {
-        match typ {
-            Type::FieldElement
-            | Type::Integer(_, _)
-            | Type::Bool
-            | Type::Unit
-            | Type::Error
-            | Type::TypeVariable(_, _)
-            | Type::Constant(..)
-            | Type::NamedGeneric(_, _, _)
-            | Type::Quoted(_)
-            | Type::Forall(_, _) => (),
-
-            Type::TraitAsType(_, _, args) => {
-                for arg in &args.ordered {
-                    Self::find_numeric_generics_in_type(arg, found);
-                }
-                for arg in &args.named {
-                    Self::find_numeric_generics_in_type(&arg.typ, found);
-                }
-            }
-
-            Type::Array(length, element_type) => {
-                if let Type::NamedGeneric(type_variable, name, _) = length.as_ref() {
-                    found.insert(name.to_string(), type_variable.clone());
-                }
-                Self::find_numeric_generics_in_type(element_type, found);
-            }
-
-            Type::Slice(element_type) => {
-                Self::find_numeric_generics_in_type(element_type, found);
-            }
-
-            Type::Tuple(fields) => {
-                for field in fields {
-                    Self::find_numeric_generics_in_type(field, found);
-                }
-            }
-
-            Type::Function(parameters, return_type, _env, _unconstrained) => {
-                for parameter in parameters {
-                    Self::find_numeric_generics_in_type(parameter, found);
-                }
-                Self::find_numeric_generics_in_type(return_type, found);
-            }
-
-            Type::Struct(struct_type, generics) => {
-                for (i, generic) in generics.iter().enumerate() {
-                    if let Type::NamedGeneric(type_variable, name, _) = generic {
-                        if struct_type.borrow().generics[i].is_numeric() {
-                            found.insert(name.to_string(), type_variable.clone());
-                        }
-                    } else {
-                        Self::find_numeric_generics_in_type(generic, found);
-                    }
-                }
-            }
-            Type::Alias(alias, generics) => {
-                for (i, generic) in generics.iter().enumerate() {
-                    if let Type::NamedGeneric(type_variable, name, _) = generic {
-                        if alias.borrow().generics[i].is_numeric() {
-                            found.insert(name.to_string(), type_variable.clone());
-                        }
-                    } else {
-                        Self::find_numeric_generics_in_type(generic, found);
-                    }
-                }
-            }
-            Type::MutableReference(element) => Self::find_numeric_generics_in_type(element, found),
-            Type::String(length) => {
-                if let Type::NamedGeneric(type_variable, name, _) = length.as_ref() {
-                    found.insert(name.to_string(), type_variable.clone());
-                }
-            }
-            Type::FmtString(length, fields) => {
-                if let Type::NamedGeneric(type_variable, name, _) = length.as_ref() {
-                    found.insert(name.to_string(), type_variable.clone());
-                }
-                Self::find_numeric_generics_in_type(fields, found);
-            }
-            Type::InfixExpr(lhs, _op, rhs) => {
-                Self::find_numeric_generics_in_type(lhs, found);
-                Self::find_numeric_generics_in_type(rhs, found);
-            }
-        }
-    }
-
     /// Push a type variable into the current FunctionContext to be defaulted if needed
     /// at the end of the earlier of either the current function or the current comptime scope.
     fn push_type_variable(&mut self, typ: Type) {
@@ -1727,61 +1751,86 @@ impl<'context> Elaborator<'context> {
         context.trait_constraints.push((constraint, expr_id));
     }
 
-    pub fn check_unsupported_turbofish_usage(&mut self, path: &Path, exclude_last_segment: bool) {
-        for (index, segment) in path.segments.iter().enumerate() {
-            if exclude_last_segment && index == path.segments.len() - 1 {
-                continue;
-            }
-
-            if segment.generics.is_some() {
-                let span = segment.turbofish_span();
-                self.push_err(TypeCheckError::UnsupportedTurbofishUsage { span });
-            }
-        }
-    }
-
     pub fn bind_generics_from_trait_constraint(
-        &mut self,
+        &self,
         constraint: &TraitConstraint,
         assumed: bool,
         bindings: &mut TypeBindings,
     ) {
-        let the_trait = self.interner.get_trait(constraint.trait_id);
-        assert_eq!(the_trait.generics.len(), constraint.trait_generics.ordered.len());
+        self.bind_generics_from_trait_bound(&constraint.trait_bound, bindings);
 
-        for (param, arg) in the_trait.generics.iter().zip(&constraint.trait_generics.ordered) {
-            // Avoid binding t = t
-            if !arg.occurs(param.type_var.id()) {
-                bindings.insert(param.type_var.id(), (param.type_var.clone(), arg.clone()));
-            }
+        // If the trait impl is already assumed to exist we should add any type bindings for `Self`.
+        // Otherwise `self` will be replaced with a fresh type variable, which will require the user
+        // to specify a redundant type annotation.
+        if assumed {
+            let the_trait = self.interner.get_trait(constraint.trait_bound.trait_id);
+            let self_type = the_trait.self_type_typevar.clone();
+            let kind = the_trait.self_type_typevar.kind();
+            bindings.insert(self_type.id(), (self_type, kind, constraint.typ.clone()));
         }
+    }
 
-        let mut associated_types = the_trait.associated_types.clone();
-        assert_eq!(associated_types.len(), constraint.trait_generics.named.len());
+    pub fn bind_generics_from_trait_bound(
+        &self,
+        trait_bound: &ResolvedTraitBound,
+        bindings: &mut TypeBindings,
+    ) {
+        let the_trait = self.interner.get_trait(trait_bound.trait_id);
 
-        for arg in &constraint.trait_generics.named {
-            let i = associated_types
-                .iter()
-                .position(|typ| *typ.name == arg.name.0.contents)
-                .unwrap_or_else(|| {
-                    unreachable!("Expected to find associated type named {}", arg.name)
-                });
+        bind_ordered_generics(&the_trait.generics, &trait_bound.trait_generics.ordered, bindings);
 
-            let param = associated_types.swap_remove(i);
+        let associated_types = the_trait.associated_types.clone();
+        bind_named_generics(associated_types, &trait_bound.trait_generics.named, bindings);
+    }
 
-            // Avoid binding t = t
-            if !arg.typ.occurs(param.type_var.id()) {
-                bindings.insert(param.type_var.id(), (param.type_var.clone(), arg.typ.clone()));
-            }
+    pub fn instantiate_parent_trait_bound(
+        &self,
+        trait_bound: &ResolvedTraitBound,
+        parent_trait_bound: &ResolvedTraitBound,
+    ) -> ResolvedTraitBound {
+        let mut bindings = TypeBindings::new();
+        self.bind_generics_from_trait_bound(trait_bound, &mut bindings);
+        ResolvedTraitBound {
+            trait_generics: parent_trait_bound.trait_generics.map(|typ| typ.substitute(&bindings)),
+            ..*parent_trait_bound
         }
+    }
+}
 
-        // If the trait impl is already assumed to exist we should add any type bindings for `Self`.
-        // Otherwise `self` will be replaced with a fresh type variable, which will require the user
-        // to specify a redundant type annotation.
-        if assumed {
-            let self_type = the_trait.self_type_typevar.clone();
-            bindings.insert(self_type.id(), (self_type, constraint.typ.clone()));
-        }
+pub(crate) fn bind_ordered_generics(
+    params: &[ResolvedGeneric],
+    args: &[Type],
+    bindings: &mut TypeBindings,
+) {
+    assert_eq!(params.len(), args.len());
+
+    for (param, arg) in params.iter().zip(args) {
+        bind_generic(param, arg, bindings);
+    }
+}
+
+pub(crate) fn bind_named_generics(
+    mut params: Vec<ResolvedGeneric>,
+    args: &[NamedType],
+    bindings: &mut TypeBindings,
+) {
+    assert_eq!(params.len(), args.len());
+
+    for arg in args {
+        let i = params
+            .iter()
+            .position(|typ| *typ.name == arg.name.0.contents)
+            .unwrap_or_else(|| unreachable!("Expected to find associated type named {}", arg.name));
+
+        let param = params.swap_remove(i);
+        bind_generic(&param, &arg.typ, bindings);
+    }
+}
+
+fn bind_generic(param: &ResolvedGeneric, arg: &Type, bindings: &mut TypeBindings) {
+    // Avoid binding t = t
+    if !arg.occurs(param.type_var.id()) {
+        bindings.insert(param.type_var.id(), (param.type_var.clone(), param.kind(), arg.clone()));
     }
 }
 
diff --git a/compiler/noirc_frontend/src/elaborator/unquote.rs b/compiler/noirc_frontend/src/elaborator/unquote.rs
index fd7e02df905..982ad3d2e1f 100644
--- a/compiler/noirc_frontend/src/elaborator/unquote.rs
+++ b/compiler/noirc_frontend/src/elaborator/unquote.rs
@@ -1,5 +1,5 @@
 use crate::{
-    macros_api::Path,
+    ast::Path,
     token::{SpannedToken, Token, Tokens},
 };
 
diff --git a/compiler/noirc_frontend/src/hir/comptime/display.rs b/compiler/noirc_frontend/src/hir/comptime/display.rs
index 105f6e09395..29d1448f07e 100644
--- a/compiler/noirc_frontend/src/hir/comptime/display.rs
+++ b/compiler/noirc_frontend/src/hir/comptime/display.rs
@@ -7,14 +7,13 @@ use crate::{
     ast::{
         ArrayLiteral, AsTraitPath, AssignStatement, BlockExpression, CallExpression,
         CastExpression, ConstrainStatement, ConstructorExpression, Expression, ExpressionKind,
-        ForLoopStatement, ForRange, GenericTypeArgs, IfExpression, IndexExpression,
+        ForBounds, ForLoopStatement, ForRange, GenericTypeArgs, IfExpression, IndexExpression,
         InfixExpression, LValue, Lambda, LetStatement, Literal, MemberAccessExpression,
         MethodCallExpression, Pattern, PrefixExpression, Statement, StatementKind, UnresolvedType,
         UnresolvedTypeData,
     },
     hir_def::traits::TraitConstraint,
-    macros_api::NodeInterner,
-    node_interner::InternedStatementKind,
+    node_interner::{InternedStatementKind, NodeInterner},
     token::{Keyword, Token},
     Type,
 };
@@ -268,6 +267,7 @@ impl<'interner> TokenPrettyPrinter<'interner> {
             | Token::Dot
             | Token::DoubleColon
             | Token::DoubleDot
+            | Token::DoubleDotEqual
             | Token::Caret
             | Token::Pound
             | Token::Pipe
@@ -281,8 +281,7 @@ impl<'interner> TokenPrettyPrinter<'interner> {
             | Token::Whitespace(_)
             | Token::LineComment(..)
             | Token::BlockComment(..)
-            | Token::Attribute(..)
-            | Token::InnerAttribute(..)
+            | Token::AttributeStart { .. }
             | Token::Invalid(_) => {
                 if last_was_alphanumeric {
                     write!(f, " ")?;
@@ -509,8 +508,11 @@ impl<'token, 'interner> Display for TokenPrinter<'token, 'interner> {
 }
 
 fn display_trait_constraint(interner: &NodeInterner, trait_constraint: &TraitConstraint) -> String {
-    let trait_ = interner.get_trait(trait_constraint.trait_id);
-    format!("{}: {}{}", trait_constraint.typ, trait_.name, trait_constraint.trait_generics)
+    let trait_ = interner.get_trait(trait_constraint.trait_bound.trait_id);
+    format!(
+        "{}: {}{}",
+        trait_constraint.typ, trait_.name, trait_constraint.trait_bound.trait_generics
+    )
 }
 
 // Returns a new Expression where all Interned and Resolved expressions have been turned into non-interned ExpressionKind.
@@ -617,7 +619,9 @@ fn remove_interned_in_expression_kind(
         }
         ExpressionKind::TypePath(mut path) => {
             path.typ = remove_interned_in_unresolved_type(interner, path.typ);
-            path.turbofish = remove_interned_in_generic_type_args(interner, path.turbofish);
+            path.turbofish = path
+                .turbofish
+                .map(|turbofish| remove_interned_in_generic_type_args(interner, turbofish));
             ExpressionKind::TypePath(path)
         }
         ExpressionKind::Resolved(id) => {
@@ -657,7 +661,7 @@ fn remove_interned_in_literal(interner: &NodeInterner, literal: Literal) -> Lite
         | Literal::Integer(_, _)
         | Literal::Str(_)
         | Literal::RawStr(_, _)
-        | Literal::FmtStr(_)
+        | Literal::FmtStr(_, _)
         | Literal::Unit => literal,
     }
 }
@@ -714,10 +718,13 @@ fn remove_interned_in_statement_kind(
         }),
         StatementKind::For(for_loop) => StatementKind::For(ForLoopStatement {
             range: match for_loop.range {
-                ForRange::Range(from, to) => ForRange::Range(
-                    remove_interned_in_expression(interner, from),
-                    remove_interned_in_expression(interner, to),
-                ),
+                ForRange::Range(ForBounds { start, end, inclusive }) => {
+                    ForRange::Range(ForBounds {
+                        start: remove_interned_in_expression(interner, start),
+                        end: remove_interned_in_expression(interner, end),
+                        inclusive,
+                    })
+                }
                 ForRange::Array(expr) => {
                     ForRange::Array(remove_interned_in_expression(interner, expr))
                 }
@@ -854,6 +861,7 @@ fn remove_interned_in_generic_type_args(
         named_args: vecmap(args.named_args, |(name, typ)| {
             (name, remove_interned_in_unresolved_type(interner, typ))
         }),
+        kinds: args.kinds,
     }
 }
 
diff --git a/compiler/noirc_frontend/src/hir/comptime/errors.rs b/compiler/noirc_frontend/src/hir/comptime/errors.rs
index 5217bbd1e71..3df20b39209 100644
--- a/compiler/noirc_frontend/src/hir/comptime/errors.rs
+++ b/compiler/noirc_frontend/src/hir/comptime/errors.rs
@@ -3,7 +3,10 @@ use std::rc::Rc;
 
 use crate::{
     ast::TraitBound,
-    hir::{def_collector::dc_crate::CompilationError, type_check::NoMatchingImplFoundError},
+    hir::{
+        def_collector::dc_crate::CompilationError,
+        type_check::{NoMatchingImplFoundError, TypeCheckError},
+    },
     parser::ParserError,
     Type,
 };
@@ -87,6 +90,7 @@ pub enum InterpreterError {
     },
     NonIntegerArrayLength {
         typ: Type,
+        err: Option<Box<TypeCheckError>>,
         location: Location,
     },
     NonNumericCasted {
@@ -196,6 +200,11 @@ pub enum InterpreterError {
         item: String,
         location: Location,
     },
+    InvalidInComptimeContext {
+        item: String,
+        location: Location,
+        explanation: String,
+    },
     TypeAnnotationsNeededForMethodCall {
         location: Location,
     },
@@ -226,6 +235,14 @@ pub enum InterpreterError {
         location: Location,
         expression: String,
     },
+    UnknownArrayLength {
+        length: Type,
+        err: Box<TypeCheckError>,
+        location: Location,
+    },
+    CannotInterpretFormatStringWithErrors {
+        location: Location,
+    },
 
     // These cases are not errors, they are just used to prevent us from running more code
     // until the loop can be resumed properly. These cases will never be displayed to users.
@@ -282,6 +299,7 @@ impl InterpreterError {
             | InterpreterError::UnsupportedTopLevelItemUnquote { location, .. }
             | InterpreterError::ComptimeDependencyCycle { location, .. }
             | InterpreterError::Unimplemented { location, .. }
+            | InterpreterError::InvalidInComptimeContext { location, .. }
             | InterpreterError::NoImpl { location, .. }
             | InterpreterError::ImplMethodTypeMismatch { location, .. }
             | InterpreterError::DebugEvaluateComptime { location, .. }
@@ -299,7 +317,9 @@ impl InterpreterError {
             | InterpreterError::DuplicateGeneric { duplicate_location: location, .. }
             | InterpreterError::TypeAnnotationsNeededForMethodCall { location }
             | InterpreterError::CannotResolveExpression { location, .. }
-            | InterpreterError::CannotSetFunctionBody { location, .. } => *location,
+            | InterpreterError::CannotSetFunctionBody { location, .. }
+            | InterpreterError::UnknownArrayLength { location, .. }
+            | InterpreterError::CannotInterpretFormatStringWithErrors { location } => *location,
 
             InterpreterError::FailedToParseMacro { error, file, .. } => {
                 Location::new(error.span(), *file)
@@ -430,9 +450,13 @@ impl<'a> From<&'a InterpreterError> for CustomDiagnostic {
                 let secondary = "This is likely a bug".into();
                 CustomDiagnostic::simple_error(msg, secondary, location.span)
             }
-            InterpreterError::NonIntegerArrayLength { typ, location } => {
+            InterpreterError::NonIntegerArrayLength { typ, err, location } => {
                 let msg = format!("Non-integer array length: `{typ}`");
-                let secondary = "Array lengths must be integers".into();
+                let secondary = if let Some(err) = err {
+                    format!("Array lengths must be integers, but evaluating `{typ}` resulted in `{err}`")
+                } else {
+                    "Array lengths must be integers".to_string()
+                };
                 CustomDiagnostic::simple_error(msg, secondary, location.span)
             }
             InterpreterError::NonNumericCasted { typ, location } => {
@@ -526,6 +550,10 @@ impl<'a> From<&'a InterpreterError> for CustomDiagnostic {
                 let msg = format!("{item} is currently unimplemented");
                 CustomDiagnostic::simple_error(msg, String::new(), location.span)
             }
+            InterpreterError::InvalidInComptimeContext { item, location, explanation } => {
+                let msg = format!("{item} is invalid in comptime context");
+                CustomDiagnostic::simple_error(msg, explanation.clone(), location.span)
+            }
             InterpreterError::BreakNotInLoop { location } => {
                 let msg = "There is no loop to break out of!".into();
                 CustomDiagnostic::simple_error(msg, String::new(), location.span)
@@ -635,6 +663,17 @@ impl<'a> From<&'a InterpreterError> for CustomDiagnostic {
                 let msg = format!("`{expression}` is not a valid function body");
                 CustomDiagnostic::simple_error(msg, String::new(), location.span)
             }
+            InterpreterError::UnknownArrayLength { length, err, location } => {
+                let msg = format!("Could not determine array length `{length}`");
+                let secondary = format!("Evaluating the length failed with: `{err}`");
+                CustomDiagnostic::simple_error(msg, secondary, location.span)
+            }
+            InterpreterError::CannotInterpretFormatStringWithErrors { location } => {
+                let msg = "Cannot interpret format string with errors".to_string();
+                let secondary =
+                    "Some of the variables to interpolate could not be evaluated".to_string();
+                CustomDiagnostic::simple_error(msg, secondary, location.span)
+            }
         }
     }
 }
diff --git a/compiler/noirc_frontend/src/hir/comptime/hir_to_display_ast.rs b/compiler/noirc_frontend/src/hir/comptime/hir_to_display_ast.rs
index 4344d19829a..9338c0fc37f 100644
--- a/compiler/noirc_frontend/src/hir/comptime/hir_to_display_ast.rs
+++ b/compiler/noirc_frontend/src/hir/comptime/hir_to_display_ast.rs
@@ -9,10 +9,11 @@ use crate::ast::{
     UnresolvedType, UnresolvedTypeData, UnresolvedTypeExpression,
 };
 use crate::ast::{ConstrainStatement, Expression, Statement, StatementKind};
-use crate::hir_def::expr::{HirArrayLiteral, HirBlockExpression, HirExpression, HirIdent};
+use crate::hir_def::expr::{
+    HirArrayLiteral, HirBlockExpression, HirExpression, HirIdent, HirLiteral,
+};
 use crate::hir_def::stmt::{HirLValue, HirPattern, HirStatement};
 use crate::hir_def::types::{Type, TypeBinding};
-use crate::macros_api::HirLiteral;
 use crate::node_interner::{ExprId, NodeInterner, StmtId};
 
 // TODO:
@@ -51,7 +52,7 @@ impl HirStatement {
             }),
             HirStatement::For(for_stmt) => StatementKind::For(ForLoopStatement {
                 identifier: for_stmt.identifier.to_display_ast(interner),
-                range: ForRange::Range(
+                range: ForRange::range(
                     for_stmt.start_range.to_display_ast(interner),
                     for_stmt.end_range.to_display_ast(interner),
                 ),
@@ -120,9 +121,9 @@ impl HirExpression {
             HirExpression::Literal(HirLiteral::Str(string)) => {
                 ExpressionKind::Literal(Literal::Str(string.clone()))
             }
-            HirExpression::Literal(HirLiteral::FmtStr(string, _exprs)) => {
+            HirExpression::Literal(HirLiteral::FmtStr(fragments, _exprs, length)) => {
                 // TODO: Is throwing away the exprs here valid?
-                ExpressionKind::Literal(Literal::FmtStr(string.clone()))
+                ExpressionKind::Literal(Literal::FmtStr(fragments.clone(), *length))
             }
             HirExpression::Literal(HirLiteral::Unit) => ExpressionKind::Literal(Literal::Unit),
             HirExpression::Block(expr) => ExpressionKind::Block(expr.to_display_ast(interner)),
@@ -302,7 +303,8 @@ impl Type {
             Type::Struct(def, generics) => {
                 let struct_def = def.borrow();
                 let ordered_args = vecmap(generics, |generic| generic.to_display_ast());
-                let generics = GenericTypeArgs { ordered_args, named_args: Vec::new() };
+                let generics =
+                    GenericTypeArgs { ordered_args, named_args: Vec::new(), kinds: Vec::new() };
                 let name = Path::from_ident(struct_def.name.clone());
                 UnresolvedTypeData::Named(name, generics, false)
             }
@@ -311,14 +313,15 @@ impl Type {
                 // alias' definition was changed
                 let type_def = type_def.borrow();
                 let ordered_args = vecmap(generics, |generic| generic.to_display_ast());
-                let generics = GenericTypeArgs { ordered_args, named_args: Vec::new() };
+                let generics =
+                    GenericTypeArgs { ordered_args, named_args: Vec::new(), kinds: Vec::new() };
                 let name = Path::from_ident(type_def.name.clone());
                 UnresolvedTypeData::Named(name, generics, false)
             }
-            Type::TypeVariable(binding, kind) => match &*binding.borrow() {
+            Type::TypeVariable(binding) => match &*binding.borrow() {
                 TypeBinding::Bound(typ) => return typ.to_display_ast(),
-                TypeBinding::Unbound(id) => {
-                    let name = format!("var_{:?}_{}", kind, id);
+                TypeBinding::Unbound(id, type_var_kind) => {
+                    let name = format!("var_{:?}_{}", type_var_kind, id);
                     let path = Path::from_single(name, Span::empty(0));
                     let expression = UnresolvedTypeExpression::Variable(path);
                     UnresolvedTypeData::Expression(expression)
@@ -329,14 +332,15 @@ impl Type {
                 let named_args = vecmap(&generics.named, |named_type| {
                     (named_type.name.clone(), named_type.typ.to_display_ast())
                 });
-                let generics = GenericTypeArgs { ordered_args, named_args };
+                let generics = GenericTypeArgs { ordered_args, named_args, kinds: Vec::new() };
                 let name = Path::from_single(name.as_ref().clone(), Span::default());
                 UnresolvedTypeData::TraitAsType(name, generics)
             }
-            Type::NamedGeneric(_var, name, _kind) => {
+            Type::NamedGeneric(_var, name) => {
                 let name = Path::from_single(name.as_ref().clone(), Span::default());
                 UnresolvedTypeData::Named(name, GenericTypeArgs::default(), true)
             }
+            Type::CheckedCast { to, .. } => to.to_display_ast().typ,
             Type::Function(args, ret, env, unconstrained) => {
                 let args = vecmap(args, |arg| arg.to_display_ast());
                 let ret = Box::new(ret.to_display_ast());
@@ -373,7 +377,7 @@ impl Type {
 
         match self.follow_bindings() {
             Type::Constant(length, _kind) => UnresolvedTypeExpression::Constant(length, span),
-            Type::NamedGeneric(_var, name, _kind) => {
+            Type::NamedGeneric(_var, name) => {
                 let path = Path::from_single(name.as_ref().clone(), span);
                 UnresolvedTypeExpression::Variable(path)
             }
@@ -416,7 +420,7 @@ impl HirArrayLiteral {
                 let repeated_element = Box::new(repeated_element.to_display_ast(interner));
                 let length = match length {
                     Type::Constant(length, _kind) => {
-                        let literal = Literal::Integer((*length as u128).into(), false);
+                        let literal = Literal::Integer(*length, false);
                         let expr_kind = ExpressionKind::Literal(literal);
                         Box::new(Expression::new(expr_kind, span))
                     }
diff --git a/compiler/noirc_frontend/src/hir/comptime/interpreter.rs b/compiler/noirc_frontend/src/hir/comptime/interpreter.rs
index e920073b453..dfa55a9d79b 100644
--- a/compiler/noirc_frontend/src/hir/comptime/interpreter.rs
+++ b/compiler/noirc_frontend/src/hir/comptime/interpreter.rs
@@ -1,6 +1,7 @@
 use std::collections::VecDeque;
 use std::{collections::hash_map::Entry, rc::Rc};
 
+use acvm::blackbox_solver::BigIntSolverWithId;
 use acvm::{acir::AcirField, FieldElement};
 use fm::FileId;
 use im::Vector;
@@ -8,36 +9,35 @@ use iter_extended::try_vecmap;
 use noirc_errors::Location;
 use rustc_hash::FxHashMap as HashMap;
 
-use crate::ast::{BinaryOpKind, FunctionKind, IntegerBitSize, Signedness};
+use crate::ast::{BinaryOpKind, FunctionKind, IntegerBitSize, Signedness, UnaryOp};
 use crate::elaborator::Elaborator;
 use crate::graph::CrateId;
 use crate::hir::def_map::ModuleId;
 use crate::hir::type_check::TypeCheckError;
 use crate::hir_def::expr::ImplKind;
 use crate::hir_def::function::FunctionBody;
-use crate::macros_api::UnaryOp;
 use crate::monomorphization::{
     perform_impl_bindings, perform_instantiation_bindings, resolve_trait_method,
     undo_instantiation_bindings,
 };
-use crate::token::Tokens;
+use crate::token::{FmtStrFragment, Tokens};
 use crate::TypeVariable;
 use crate::{
     hir_def::{
         expr::{
             HirArrayLiteral, HirBlockExpression, HirCallExpression, HirCastExpression,
             HirConstructorExpression, HirExpression, HirIdent, HirIfExpression, HirIndexExpression,
-            HirInfixExpression, HirLambda, HirMemberAccess, HirMethodCallExpression,
+            HirInfixExpression, HirLambda, HirLiteral, HirMemberAccess, HirMethodCallExpression,
             HirPrefixExpression,
         },
         stmt::{
             HirAssignStatement, HirConstrainStatement, HirForStatement, HirLValue, HirLetStatement,
-            HirPattern,
+            HirPattern, HirStatement,
         },
+        types::Kind,
     },
-    macros_api::{HirLiteral, HirStatement, NodeInterner},
-    node_interner::{DefinitionId, DefinitionKind, ExprId, FuncId, StmtId},
-    Shared, Type, TypeBinding, TypeBindings, TypeVariableKind,
+    node_interner::{DefinitionId, DefinitionKind, ExprId, FuncId, NodeInterner, StmtId},
+    Shared, Type, TypeBinding, TypeBindings,
 };
 
 use super::errors::{IResult, InterpreterError};
@@ -62,7 +62,10 @@ pub struct Interpreter<'local, 'interner> {
     /// Since the interpreter monomorphizes as it interprets, we can bind over the same generic
     /// multiple times. Without this map, when one of these inner functions exits we would
     /// unbind the generic completely instead of resetting it to its previous binding.
-    bound_generics: Vec<HashMap<TypeVariable, Type>>,
+    bound_generics: Vec<HashMap<TypeVariable, (Type, Kind)>>,
+
+    /// Stateful bigint calculator.
+    bigint_solver: BigIntSolverWithId,
 }
 
 #[allow(unused)]
@@ -72,9 +75,14 @@ impl<'local, 'interner> Interpreter<'local, 'interner> {
         crate_id: CrateId,
         current_function: Option<FuncId>,
     ) -> Self {
-        let bound_generics = Vec::new();
-        let in_loop = false;
-        Self { elaborator, crate_id, current_function, bound_generics, in_loop }
+        Self {
+            elaborator,
+            crate_id,
+            current_function,
+            bound_generics: Vec::new(),
+            in_loop: false,
+            bigint_solver: BigIntSolverWithId::default(),
+        }
     }
 
     pub(crate) fn call_function(
@@ -89,7 +97,8 @@ impl<'local, 'interner> Interpreter<'local, 'interner> {
         // To match the monomorphizer, we need to call follow_bindings on each of
         // the instantiation bindings before we unbind the generics from the previous function.
         // This is because the instantiation bindings refer to variables from the call site.
-        for (_, binding) in instantiation_bindings.values_mut() {
+        for (_, kind, binding) in instantiation_bindings.values_mut() {
+            *kind = kind.follow_bindings();
             *binding = binding.follow_bindings();
         }
 
@@ -98,7 +107,8 @@ impl<'local, 'interner> Interpreter<'local, 'interner> {
         let mut impl_bindings =
             perform_impl_bindings(self.elaborator.interner, trait_method, function, location)?;
 
-        for (_, binding) in impl_bindings.values_mut() {
+        for (_, kind, binding) in impl_bindings.values_mut() {
+            *kind = kind.follow_bindings();
             *binding = binding.follow_bindings();
         }
 
@@ -222,15 +232,13 @@ impl<'local, 'interner> Interpreter<'local, 'interner> {
         location: Location,
     ) -> IResult<Value> {
         let attributes = self.elaborator.interner.function_attributes(&function);
-        let func_attrs = attributes.function.as_ref()
+        let func_attrs = attributes.function()
             .expect("all builtin functions must contain a function  attribute which contains the opcode which it links to");
 
         if let Some(builtin) = func_attrs.builtin() {
-            let builtin = builtin.clone();
-            self.call_builtin(&builtin, arguments, return_type, location)
+            self.call_builtin(builtin.clone().as_str(), arguments, return_type, location)
         } else if let Some(foreign) = func_attrs.foreign() {
-            let foreign = foreign.clone();
-            foreign::call_foreign(self.elaborator.interner, &foreign, arguments, location)
+            self.call_foreign(foreign.clone().as_str(), arguments, return_type, location)
         } else if let Some(oracle) = func_attrs.oracle() {
             if oracle == "print" {
                 self.print_oracle(arguments)
@@ -335,8 +343,8 @@ impl<'local, 'interner> Interpreter<'local, 'interner> {
 
     fn unbind_generics_from_previous_function(&mut self) {
         if let Some(bindings) = self.bound_generics.last() {
-            for var in bindings.keys() {
-                var.unbind(var.id());
+            for (var, (_, kind)) in bindings {
+                var.unbind(var.id(), kind.clone());
             }
         }
         // Push a new bindings list for the current function
@@ -348,7 +356,7 @@ impl<'local, 'interner> Interpreter<'local, 'interner> {
         self.bound_generics.pop();
 
         if let Some(bindings) = self.bound_generics.last() {
-            for (var, binding) in bindings {
+            for (var, (binding, _kind)) in bindings {
                 var.force_bind(binding.clone());
             }
         }
@@ -360,12 +368,12 @@ impl<'local, 'interner> Interpreter<'local, 'interner> {
             .last_mut()
             .expect("remember_bindings called with no bound_generics on the stack");
 
-        for (var, binding) in main_bindings.values() {
-            bound_generics.insert(var.clone(), binding.follow_bindings());
+        for (var, kind, binding) in main_bindings.values() {
+            bound_generics.insert(var.clone(), (binding.follow_bindings(), kind.clone()));
         }
 
-        for (var, binding) in impl_bindings.values() {
-            bound_generics.insert(var.clone(), binding.follow_bindings());
+        for (var, kind, binding) in impl_bindings.values() {
+            bound_generics.insert(var.clone(), (binding.follow_bindings(), kind.clone()));
         }
     }
 
@@ -543,8 +551,8 @@ impl<'local, 'interner> Interpreter<'local, 'interner> {
             InterpreterError::VariableNotInScope { location }
         })?;
 
-        if let ImplKind::TraitMethod(method, _, _) = ident.impl_kind {
-            let method_id = resolve_trait_method(self.elaborator.interner, method, id)?;
+        if let ImplKind::TraitMethod(method) = ident.impl_kind {
+            let method_id = resolve_trait_method(self.elaborator.interner, method.method_id, id)?;
             let typ = self.elaborator.interner.id_type(id).follow_bindings();
             let bindings = self.elaborator.interner.get_instantiation_bindings(id).clone();
             return Ok(Value::Function(method_id, typ, Rc::new(bindings)));
@@ -553,8 +561,8 @@ impl<'local, 'interner> Interpreter<'local, 'interner> {
         match &definition.kind {
             DefinitionKind::Function(function_id) => {
                 let typ = self.elaborator.interner.id_type(id).follow_bindings();
-                let bindings =
-                    Rc::new(self.elaborator.interner.get_instantiation_bindings(id).clone());
+                let bindings = self.elaborator.interner.try_get_instantiation_bindings(id);
+                let bindings = Rc::new(bindings.map_or(TypeBindings::default(), Clone::clone));
                 Ok(Value::Function(*function_id, typ, bindings))
             }
             DefinitionKind::Local(_) => self.lookup(&ident),
@@ -582,20 +590,27 @@ impl<'local, 'interner> Interpreter<'local, 'interner> {
                     Ok(value)
                 }
             }
-            DefinitionKind::GenericType(type_variable) => {
+            DefinitionKind::NumericGeneric(type_variable, numeric_typ) => {
                 let value = match &*type_variable.borrow() {
-                    TypeBinding::Unbound(_) => None,
-                    TypeBinding::Bound(binding) => binding.evaluate_to_u32(),
-                };
+                    TypeBinding::Unbound(_, _) => {
+                        let typ = self.elaborator.interner.id_type(id);
+                        let location = self.elaborator.interner.expr_location(&id);
+                        Err(InterpreterError::NonIntegerArrayLength { typ, err: None, location })
+                    }
+                    TypeBinding::Bound(binding) => {
+                        let span = self.elaborator.interner.id_location(id).span;
+                        binding
+                            .evaluate_to_field_element(&Kind::Numeric(numeric_typ.clone()), span)
+                            .map_err(|err| {
+                                let typ = Type::TypeVariable(type_variable.clone());
+                                let err = Some(Box::new(err));
+                                let location = self.elaborator.interner.expr_location(&id);
+                                InterpreterError::NonIntegerArrayLength { typ, err, location }
+                            })
+                    }
+                }?;
 
-                if let Some(value) = value {
-                    let typ = self.elaborator.interner.id_type(id);
-                    self.evaluate_integer((value as u128).into(), false, id)
-                } else {
-                    let location = self.elaborator.interner.expr_location(&id);
-                    let typ = Type::TypeVariable(type_variable.clone(), TypeVariableKind::Normal);
-                    Err(InterpreterError::NonIntegerArrayLength { typ, location })
-                }
+                self.evaluate_integer(value, false, id)
             }
         }
     }
@@ -608,8 +623,8 @@ impl<'local, 'interner> Interpreter<'local, 'interner> {
                 self.evaluate_integer(value, is_negative, id)
             }
             HirLiteral::Str(string) => Ok(Value::String(Rc::new(string))),
-            HirLiteral::FmtStr(string, captures) => {
-                self.evaluate_format_string(string, captures, id)
+            HirLiteral::FmtStr(fragments, captures, _length) => {
+                self.evaluate_format_string(fragments, captures, id)
             }
             HirLiteral::Array(array) => self.evaluate_array(array, id),
             HirLiteral::Slice(array) => self.evaluate_slice(array, id),
@@ -618,7 +633,7 @@ impl<'local, 'interner> Interpreter<'local, 'interner> {
 
     fn evaluate_format_string(
         &mut self,
-        string: String,
+        fragments: Vec<FmtStrFragment>,
         captures: Vec<ExprId>,
         id: ExprId,
     ) -> IResult<Value> {
@@ -629,13 +644,12 @@ impl<'local, 'interner> Interpreter<'local, 'interner> {
         let mut values: VecDeque<_> =
             captures.into_iter().map(|capture| self.evaluate(capture)).collect::<Result<_, _>>()?;
 
-        for character in string.chars() {
-            match character {
-                '\\' => escaped = true,
-                '{' if !escaped => consuming = true,
-                '}' if !escaped && consuming => {
-                    consuming = false;
-
+        for fragment in fragments {
+            match fragment {
+                FmtStrFragment::String(string) => {
+                    result.push_str(&string);
+                }
+                FmtStrFragment::Interpolation(_, span) => {
                     if let Some(value) = values.pop_front() {
                         // When interpolating a quoted value inside a format string, we don't include the
                         // surrounding `quote {` ... `}` as if we are unquoting the quoted value inside the string.
@@ -650,13 +664,15 @@ impl<'local, 'interner> Interpreter<'local, 'interner> {
                         } else {
                             result.push_str(&value.display(self.elaborator.interner).to_string());
                         }
+                    } else {
+                        // If we can't find a value for this fragment it means the interpolated value was not
+                        // found or it errored. In this case we error here as well.
+                        let location = self.elaborator.interner.expr_location(&id);
+                        return Err(InterpreterError::CannotInterpretFormatStringWithErrors {
+                            location,
+                        });
                     }
                 }
-                other if !consuming => {
-                    escaped = false;
-                    result.push(other);
-                }
-                _ => (),
             }
         }
 
@@ -752,14 +768,18 @@ impl<'local, 'interner> Interpreter<'local, 'interner> {
                     Ok(Value::I64(value))
                 }
             }
-        } else if let Type::TypeVariable(variable, TypeVariableKind::IntegerOrField) = &typ {
-            Ok(Value::Field(value))
-        } else if let Type::TypeVariable(variable, TypeVariableKind::Integer) = &typ {
-            let value: u64 = value
-                .try_to_u64()
-                .ok_or(InterpreterError::IntegerOutOfRangeForType { value, typ, location })?;
-            let value = if is_negative { 0u64.wrapping_sub(value) } else { value };
-            Ok(Value::U64(value))
+        } else if let Type::TypeVariable(variable) = &typ {
+            if variable.is_integer_or_field() {
+                Ok(Value::Field(value))
+            } else if variable.is_integer() {
+                let value: u64 = value
+                    .try_to_u64()
+                    .ok_or(InterpreterError::IntegerOutOfRangeForType { value, typ, location })?;
+                let value = if is_negative { 0u64.wrapping_sub(value) } else { value };
+                Ok(Value::U64(value))
+            } else {
+                Err(InterpreterError::NonIntegerIntegerLiteral { typ, location })
+            }
         } else {
             Err(InterpreterError::NonIntegerIntegerLiteral { typ, location })
         }
@@ -798,12 +818,17 @@ impl<'local, 'interner> Interpreter<'local, 'interner> {
             HirArrayLiteral::Repeated { repeated_element, length } => {
                 let element = self.evaluate(repeated_element)?;
 
-                if let Some(length) = length.evaluate_to_u32() {
-                    let elements = (0..length).map(|_| element.clone()).collect();
-                    Ok(Value::Array(elements, typ))
-                } else {
-                    let location = self.elaborator.interner.expr_location(&id);
-                    Err(InterpreterError::NonIntegerArrayLength { typ: length, location })
+                let span = self.elaborator.interner.id_location(id).span;
+                match length.evaluate_to_u32(span) {
+                    Ok(length) => {
+                        let elements = (0..length).map(|_| element.clone()).collect();
+                        Ok(Value::Array(elements, typ))
+                    }
+                    Err(err) => {
+                        let err = Some(Box::new(err));
+                        let location = self.elaborator.interner.expr_location(&id);
+                        Err(InterpreterError::NonIntegerArrayLength { typ: length, err, location })
+                    }
                 }
             }
         }
@@ -889,213 +914,202 @@ impl<'local, 'interner> Interpreter<'local, 'interner> {
         }
     }
 
+    #[allow(clippy::bool_comparison)]
     fn evaluate_infix(&mut self, infix: HirInfixExpression, id: ExprId) -> IResult<Value> {
-        let lhs = self.evaluate(infix.lhs)?;
-        let rhs = self.evaluate(infix.rhs)?;
+        let lhs_value = self.evaluate(infix.lhs)?;
+        let rhs_value = self.evaluate(infix.rhs)?;
 
         if self.elaborator.interner.get_selected_impl_for_expression(id).is_some() {
-            return self.evaluate_overloaded_infix(infix, lhs, rhs, id);
+            return self.evaluate_overloaded_infix(infix, lhs_value, rhs_value, id);
         }
 
-        let make_error = |this: &mut Self, lhs: Value, rhs: Value, operator| {
-            let location = this.elaborator.interner.expr_location(&id);
-            let lhs = lhs.get_type().into_owned();
-            let rhs = rhs.get_type().into_owned();
-            Err(InvalidValuesForBinary { lhs, rhs, location, operator })
+        let lhs_type = lhs_value.get_type().into_owned();
+        let rhs_type = rhs_value.get_type().into_owned();
+        let location = self.elaborator.interner.expr_location(&id);
+
+        let error = |operator| {
+            let lhs = lhs_type.clone();
+            let rhs = rhs_type.clone();
+            InterpreterError::InvalidValuesForBinary { lhs, rhs, location, operator }
         };
 
+        /// Generate matches that can promote the type of one side to the other if they are compatible.
+        macro_rules! match_values {
+            (($lhs_value:ident as $lhs:ident $op:literal $rhs_value:ident as $rhs:ident) {
+                $(
+                    ($lhs_var:ident, $rhs_var:ident) to $res_var:ident => $expr:expr
+                ),*
+                $(,)?
+             }
+            ) => {
+                match ($lhs_value, $rhs_value) {
+                    $(
+                    (Value::$lhs_var($lhs), Value::$rhs_var($rhs)) => {
+                        Ok(Value::$res_var(($expr).ok_or(error($op))?))
+                    },
+                    )*
+                    (lhs, rhs) => {
+                        Err(error($op))
+                    },
+                }
+            };
+        }
+
+        /// Generate matches for arithmetic operations on `Field` and integers.
+        macro_rules! match_arithmetic {
+            (($lhs_value:ident as $lhs:ident $op:literal $rhs_value:ident as $rhs:ident) { field: $field_expr:expr, int: $int_expr:expr, }) => {
+                match_values! {
+                    ($lhs_value as $lhs $op $rhs_value as $rhs) {
+                        (Field, Field) to Field => Some($field_expr),
+                        (I8,  I8)      to I8    => $int_expr,
+                        (I16, I16)     to I16   => $int_expr,
+                        (I32, I32)     to I32   => $int_expr,
+                        (I64, I64)     to I64   => $int_expr,
+                        (U8,  U8)      to U8    => $int_expr,
+                        (U16, U16)     to U16   => $int_expr,
+                        (U32, U32)     to U32   => $int_expr,
+                        (U64, U64)     to U64   => $int_expr,
+                    }
+                }
+            };
+        }
+
+        /// Generate matches for comparison operations on all types, returning `Bool`.
+        macro_rules! match_cmp {
+            (($lhs_value:ident as $lhs:ident $op:literal $rhs_value:ident as $rhs:ident) => $expr:expr) => {
+                match_values! {
+                    ($lhs_value as $lhs $op $rhs_value as $rhs) {
+                        (Field, Field) to Bool => Some($expr),
+                        (Bool, Bool)   to Bool => Some($expr),
+                        (I8,  I8)      to Bool => Some($expr),
+                        (I16, I16)     to Bool => Some($expr),
+                        (I32, I32)     to Bool => Some($expr),
+                        (I64, I64)     to Bool => Some($expr),
+                        (U8,  U8)      to Bool => Some($expr),
+                        (U16, U16)     to Bool => Some($expr),
+                        (U32, U32)     to Bool => Some($expr),
+                        (U64, U64)     to Bool => Some($expr),
+                    }
+                }
+            };
+        }
+
+        /// Generate matches for bitwise operations on `Bool` and integers.
+        macro_rules! match_bitwise {
+            (($lhs_value:ident as $lhs:ident $op:literal $rhs_value:ident as $rhs:ident) => $expr:expr) => {
+                match_values! {
+                    ($lhs_value as $lhs $op $rhs_value as $rhs) {
+                        (Bool, Bool)   to Bool => Some($expr),
+                        (I8,  I8)      to I8   => Some($expr),
+                        (I16, I16)     to I16  => Some($expr),
+                        (I32, I32)     to I32  => Some($expr),
+                        (I64, I64)     to I64  => Some($expr),
+                        (U8,  U8)      to U8   => Some($expr),
+                        (U16, U16)     to U16  => Some($expr),
+                        (U32, U32)     to U32  => Some($expr),
+                        (U64, U64)     to U64  => Some($expr),
+                    }
+                }
+            };
+        }
+
+        /// Generate matches for operations on just integer values.
+        macro_rules! match_integer {
+            (($lhs_value:ident as $lhs:ident $op:literal $rhs_value:ident as $rhs:ident) => $expr:expr) => {
+                match_values! {
+                    ($lhs_value as $lhs $op $rhs_value as $rhs) {
+                        (I8,  I8)      to I8   => $expr,
+                        (I16, I16)     to I16  => $expr,
+                        (I32, I32)     to I32  => $expr,
+                        (I64, I64)     to I64  => $expr,
+                        (U8,  U8)      to U8   => $expr,
+                        (U16, U16)     to U16  => $expr,
+                        (U32, U32)     to U32  => $expr,
+                        (U64, U64)     to U64  => $expr,
+                    }
+                }
+            };
+        }
+
+        /// Generate matches for bit shifting, which in Noir only accepts `u8` for RHS.
+        macro_rules! match_bitshift {
+            (($lhs_value:ident as $lhs:ident $op:literal $rhs_value:ident as $rhs:ident) => $expr:expr) => {
+                match_values! {
+                    ($lhs_value as $lhs $op $rhs_value as $rhs) {
+                        (I8,  U8)      to I8   => $expr,
+                        (I16, U8)      to I16  => $expr,
+                        (I32, U8)      to I32  => $expr,
+                        (I64, U8)      to I64  => $expr,
+                        (U8,  U8)      to U8   => $expr,
+                        (U16, U8)      to U16  => $expr,
+                        (U32, U8)      to U32  => $expr,
+                        (U64, U8)      to U64  => $expr,
+                    }
+                }
+            };
+        }
+
         use InterpreterError::InvalidValuesForBinary;
         match infix.operator.kind {
-            BinaryOpKind::Add => match (lhs, rhs) {
-                (Value::Field(lhs), Value::Field(rhs)) => Ok(Value::Field(lhs + rhs)),
-                (Value::I8(lhs), Value::I8(rhs)) => Ok(Value::I8(lhs + rhs)),
-                (Value::I16(lhs), Value::I16(rhs)) => Ok(Value::I16(lhs + rhs)),
-                (Value::I32(lhs), Value::I32(rhs)) => Ok(Value::I32(lhs + rhs)),
-                (Value::I64(lhs), Value::I64(rhs)) => Ok(Value::I64(lhs + rhs)),
-                (Value::U8(lhs), Value::U8(rhs)) => Ok(Value::U8(lhs + rhs)),
-                (Value::U16(lhs), Value::U16(rhs)) => Ok(Value::U16(lhs + rhs)),
-                (Value::U32(lhs), Value::U32(rhs)) => Ok(Value::U32(lhs + rhs)),
-                (Value::U64(lhs), Value::U64(rhs)) => Ok(Value::U64(lhs + rhs)),
-                (lhs, rhs) => make_error(self, lhs, rhs, "+"),
+            BinaryOpKind::Add => match_arithmetic! {
+                (lhs_value as lhs "+" rhs_value as rhs) {
+                    field: lhs + rhs,
+                    int: lhs.checked_add(rhs),
+                }
             },
-            BinaryOpKind::Subtract => match (lhs, rhs) {
-                (Value::Field(lhs), Value::Field(rhs)) => Ok(Value::Field(lhs - rhs)),
-                (Value::I8(lhs), Value::I8(rhs)) => Ok(Value::I8(lhs - rhs)),
-                (Value::I16(lhs), Value::I16(rhs)) => Ok(Value::I16(lhs - rhs)),
-                (Value::I32(lhs), Value::I32(rhs)) => Ok(Value::I32(lhs - rhs)),
-                (Value::I64(lhs), Value::I64(rhs)) => Ok(Value::I64(lhs - rhs)),
-                (Value::U8(lhs), Value::U8(rhs)) => Ok(Value::U8(lhs - rhs)),
-                (Value::U16(lhs), Value::U16(rhs)) => Ok(Value::U16(lhs - rhs)),
-                (Value::U32(lhs), Value::U32(rhs)) => Ok(Value::U32(lhs - rhs)),
-                (Value::U64(lhs), Value::U64(rhs)) => Ok(Value::U64(lhs - rhs)),
-                (lhs, rhs) => make_error(self, lhs, rhs, "-"),
+            BinaryOpKind::Subtract => match_arithmetic! {
+                (lhs_value as lhs "-" rhs_value as rhs) {
+                    field: lhs - rhs,
+                    int: lhs.checked_sub(rhs),
+                }
             },
-            BinaryOpKind::Multiply => match (lhs, rhs) {
-                (Value::Field(lhs), Value::Field(rhs)) => Ok(Value::Field(lhs * rhs)),
-                (Value::I8(lhs), Value::I8(rhs)) => Ok(Value::I8(lhs * rhs)),
-                (Value::I16(lhs), Value::I16(rhs)) => Ok(Value::I16(lhs * rhs)),
-                (Value::I32(lhs), Value::I32(rhs)) => Ok(Value::I32(lhs * rhs)),
-                (Value::I64(lhs), Value::I64(rhs)) => Ok(Value::I64(lhs * rhs)),
-                (Value::U8(lhs), Value::U8(rhs)) => Ok(Value::U8(lhs * rhs)),
-                (Value::U16(lhs), Value::U16(rhs)) => Ok(Value::U16(lhs * rhs)),
-                (Value::U32(lhs), Value::U32(rhs)) => Ok(Value::U32(lhs * rhs)),
-                (Value::U64(lhs), Value::U64(rhs)) => Ok(Value::U64(lhs * rhs)),
-                (lhs, rhs) => make_error(self, lhs, rhs, "*"),
+            BinaryOpKind::Multiply => match_arithmetic! {
+                (lhs_value as lhs "*" rhs_value as rhs) {
+                    field: lhs * rhs,
+                    int: lhs.checked_mul(rhs),
+                }
             },
-            BinaryOpKind::Divide => match (lhs, rhs) {
-                (Value::Field(lhs), Value::Field(rhs)) => Ok(Value::Field(lhs / rhs)),
-                (Value::I8(lhs), Value::I8(rhs)) => Ok(Value::I8(lhs / rhs)),
-                (Value::I16(lhs), Value::I16(rhs)) => Ok(Value::I16(lhs / rhs)),
-                (Value::I32(lhs), Value::I32(rhs)) => Ok(Value::I32(lhs / rhs)),
-                (Value::I64(lhs), Value::I64(rhs)) => Ok(Value::I64(lhs / rhs)),
-                (Value::U8(lhs), Value::U8(rhs)) => Ok(Value::U8(lhs / rhs)),
-                (Value::U16(lhs), Value::U16(rhs)) => Ok(Value::U16(lhs / rhs)),
-                (Value::U32(lhs), Value::U32(rhs)) => Ok(Value::U32(lhs / rhs)),
-                (Value::U64(lhs), Value::U64(rhs)) => Ok(Value::U64(lhs / rhs)),
-                (lhs, rhs) => make_error(self, lhs, rhs, "/"),
+            BinaryOpKind::Divide => match_arithmetic! {
+                (lhs_value as lhs "/" rhs_value as rhs) {
+                    field: lhs / rhs,
+                    int: lhs.checked_div(rhs),
+                }
             },
-            BinaryOpKind::Equal => match (lhs, rhs) {
-                (Value::Field(lhs), Value::Field(rhs)) => Ok(Value::Bool(lhs == rhs)),
-                (Value::I8(lhs), Value::I8(rhs)) => Ok(Value::Bool(lhs == rhs)),
-                (Value::I16(lhs), Value::I16(rhs)) => Ok(Value::Bool(lhs == rhs)),
-                (Value::I32(lhs), Value::I32(rhs)) => Ok(Value::Bool(lhs == rhs)),
-                (Value::I64(lhs), Value::I64(rhs)) => Ok(Value::Bool(lhs == rhs)),
-                (Value::U8(lhs), Value::U8(rhs)) => Ok(Value::Bool(lhs == rhs)),
-                (Value::U16(lhs), Value::U16(rhs)) => Ok(Value::Bool(lhs == rhs)),
-                (Value::U32(lhs), Value::U32(rhs)) => Ok(Value::Bool(lhs == rhs)),
-                (Value::U64(lhs), Value::U64(rhs)) => Ok(Value::Bool(lhs == rhs)),
-                (Value::Bool(lhs), Value::Bool(rhs)) => Ok(Value::Bool(lhs == rhs)),
-                (lhs, rhs) => make_error(self, lhs, rhs, "=="),
+            BinaryOpKind::Equal => match_cmp! {
+                (lhs_value as lhs "==" rhs_value as rhs) => lhs == rhs
             },
-            BinaryOpKind::NotEqual => match (lhs, rhs) {
-                (Value::Field(lhs), Value::Field(rhs)) => Ok(Value::Bool(lhs != rhs)),
-                (Value::I8(lhs), Value::I8(rhs)) => Ok(Value::Bool(lhs != rhs)),
-                (Value::I16(lhs), Value::I16(rhs)) => Ok(Value::Bool(lhs != rhs)),
-                (Value::I32(lhs), Value::I32(rhs)) => Ok(Value::Bool(lhs != rhs)),
-                (Value::I64(lhs), Value::I64(rhs)) => Ok(Value::Bool(lhs != rhs)),
-                (Value::U8(lhs), Value::U8(rhs)) => Ok(Value::Bool(lhs != rhs)),
-                (Value::U16(lhs), Value::U16(rhs)) => Ok(Value::Bool(lhs != rhs)),
-                (Value::U32(lhs), Value::U32(rhs)) => Ok(Value::Bool(lhs != rhs)),
-                (Value::U64(lhs), Value::U64(rhs)) => Ok(Value::Bool(lhs != rhs)),
-                (Value::Bool(lhs), Value::Bool(rhs)) => Ok(Value::Bool(lhs != rhs)),
-                (lhs, rhs) => make_error(self, lhs, rhs, "!="),
+            BinaryOpKind::NotEqual => match_cmp! {
+                (lhs_value as lhs "!=" rhs_value as rhs) => lhs != rhs
             },
-            BinaryOpKind::Less => match (lhs, rhs) {
-                (Value::Field(lhs), Value::Field(rhs)) => Ok(Value::Bool(lhs < rhs)),
-                (Value::I8(lhs), Value::I8(rhs)) => Ok(Value::Bool(lhs < rhs)),
-                (Value::I16(lhs), Value::I16(rhs)) => Ok(Value::Bool(lhs < rhs)),
-                (Value::I32(lhs), Value::I32(rhs)) => Ok(Value::Bool(lhs < rhs)),
-                (Value::I64(lhs), Value::I64(rhs)) => Ok(Value::Bool(lhs < rhs)),
-                (Value::U8(lhs), Value::U8(rhs)) => Ok(Value::Bool(lhs < rhs)),
-                (Value::U16(lhs), Value::U16(rhs)) => Ok(Value::Bool(lhs < rhs)),
-                (Value::U32(lhs), Value::U32(rhs)) => Ok(Value::Bool(lhs < rhs)),
-                (Value::U64(lhs), Value::U64(rhs)) => Ok(Value::Bool(lhs < rhs)),
-                (lhs, rhs) => make_error(self, lhs, rhs, "<"),
+            BinaryOpKind::Less => match_cmp! {
+                (lhs_value as lhs "<" rhs_value as rhs) => lhs < rhs
             },
-            BinaryOpKind::LessEqual => match (lhs, rhs) {
-                (Value::Field(lhs), Value::Field(rhs)) => Ok(Value::Bool(lhs <= rhs)),
-                (Value::I8(lhs), Value::I8(rhs)) => Ok(Value::Bool(lhs <= rhs)),
-                (Value::I16(lhs), Value::I16(rhs)) => Ok(Value::Bool(lhs <= rhs)),
-                (Value::I32(lhs), Value::I32(rhs)) => Ok(Value::Bool(lhs <= rhs)),
-                (Value::I64(lhs), Value::I64(rhs)) => Ok(Value::Bool(lhs <= rhs)),
-                (Value::U8(lhs), Value::U8(rhs)) => Ok(Value::Bool(lhs <= rhs)),
-                (Value::U16(lhs), Value::U16(rhs)) => Ok(Value::Bool(lhs <= rhs)),
-                (Value::U32(lhs), Value::U32(rhs)) => Ok(Value::Bool(lhs <= rhs)),
-                (Value::U64(lhs), Value::U64(rhs)) => Ok(Value::Bool(lhs <= rhs)),
-                (lhs, rhs) => make_error(self, lhs, rhs, "<="),
+            BinaryOpKind::LessEqual => match_cmp! {
+                (lhs_value as lhs "<=" rhs_value as rhs) => lhs <= rhs
             },
-            BinaryOpKind::Greater => match (lhs, rhs) {
-                (Value::Field(lhs), Value::Field(rhs)) => Ok(Value::Bool(lhs > rhs)),
-                (Value::I8(lhs), Value::I8(rhs)) => Ok(Value::Bool(lhs > rhs)),
-                (Value::I16(lhs), Value::I16(rhs)) => Ok(Value::Bool(lhs > rhs)),
-                (Value::I32(lhs), Value::I32(rhs)) => Ok(Value::Bool(lhs > rhs)),
-                (Value::I64(lhs), Value::I64(rhs)) => Ok(Value::Bool(lhs > rhs)),
-                (Value::U8(lhs), Value::U8(rhs)) => Ok(Value::Bool(lhs > rhs)),
-                (Value::U16(lhs), Value::U16(rhs)) => Ok(Value::Bool(lhs > rhs)),
-                (Value::U32(lhs), Value::U32(rhs)) => Ok(Value::Bool(lhs > rhs)),
-                (Value::U64(lhs), Value::U64(rhs)) => Ok(Value::Bool(lhs > rhs)),
-                (lhs, rhs) => make_error(self, lhs, rhs, ">"),
+            BinaryOpKind::Greater => match_cmp! {
+                (lhs_value as lhs ">" rhs_value as rhs) => lhs > rhs
             },
-            BinaryOpKind::GreaterEqual => match (lhs, rhs) {
-                (Value::Field(lhs), Value::Field(rhs)) => Ok(Value::Bool(lhs >= rhs)),
-                (Value::I8(lhs), Value::I8(rhs)) => Ok(Value::Bool(lhs >= rhs)),
-                (Value::I16(lhs), Value::I16(rhs)) => Ok(Value::Bool(lhs >= rhs)),
-                (Value::I32(lhs), Value::I32(rhs)) => Ok(Value::Bool(lhs >= rhs)),
-                (Value::I64(lhs), Value::I64(rhs)) => Ok(Value::Bool(lhs >= rhs)),
-                (Value::U8(lhs), Value::U8(rhs)) => Ok(Value::Bool(lhs >= rhs)),
-                (Value::U16(lhs), Value::U16(rhs)) => Ok(Value::Bool(lhs >= rhs)),
-                (Value::U32(lhs), Value::U32(rhs)) => Ok(Value::Bool(lhs >= rhs)),
-                (Value::U64(lhs), Value::U64(rhs)) => Ok(Value::Bool(lhs >= rhs)),
-                (lhs, rhs) => make_error(self, lhs, rhs, ">="),
+            BinaryOpKind::GreaterEqual => match_cmp! {
+                (lhs_value as lhs ">=" rhs_value as rhs) => lhs >= rhs
             },
-            BinaryOpKind::And => match (lhs, rhs) {
-                (Value::Bool(lhs), Value::Bool(rhs)) => Ok(Value::Bool(lhs & rhs)),
-                (Value::I8(lhs), Value::I8(rhs)) => Ok(Value::I8(lhs & rhs)),
-                (Value::I16(lhs), Value::I16(rhs)) => Ok(Value::I16(lhs & rhs)),
-                (Value::I32(lhs), Value::I32(rhs)) => Ok(Value::I32(lhs & rhs)),
-                (Value::I64(lhs), Value::I64(rhs)) => Ok(Value::I64(lhs & rhs)),
-                (Value::U8(lhs), Value::U8(rhs)) => Ok(Value::U8(lhs & rhs)),
-                (Value::U16(lhs), Value::U16(rhs)) => Ok(Value::U16(lhs & rhs)),
-                (Value::U32(lhs), Value::U32(rhs)) => Ok(Value::U32(lhs & rhs)),
-                (Value::U64(lhs), Value::U64(rhs)) => Ok(Value::U64(lhs & rhs)),
-                (lhs, rhs) => make_error(self, lhs, rhs, "&"),
+            BinaryOpKind::And => match_bitwise! {
+                (lhs_value as lhs "&" rhs_value as rhs) => lhs & rhs
             },
-            BinaryOpKind::Or => match (lhs, rhs) {
-                (Value::Bool(lhs), Value::Bool(rhs)) => Ok(Value::Bool(lhs | rhs)),
-                (Value::I8(lhs), Value::I8(rhs)) => Ok(Value::I8(lhs | rhs)),
-                (Value::I16(lhs), Value::I16(rhs)) => Ok(Value::I16(lhs | rhs)),
-                (Value::I32(lhs), Value::I32(rhs)) => Ok(Value::I32(lhs | rhs)),
-                (Value::I64(lhs), Value::I64(rhs)) => Ok(Value::I64(lhs | rhs)),
-                (Value::U8(lhs), Value::U8(rhs)) => Ok(Value::U8(lhs | rhs)),
-                (Value::U16(lhs), Value::U16(rhs)) => Ok(Value::U16(lhs | rhs)),
-                (Value::U32(lhs), Value::U32(rhs)) => Ok(Value::U32(lhs | rhs)),
-                (Value::U64(lhs), Value::U64(rhs)) => Ok(Value::U64(lhs | rhs)),
-                (lhs, rhs) => make_error(self, lhs, rhs, "|"),
+            BinaryOpKind::Or => match_bitwise! {
+                (lhs_value as lhs "|" rhs_value as rhs) => lhs | rhs
             },
-            BinaryOpKind::Xor => match (lhs, rhs) {
-                (Value::Bool(lhs), Value::Bool(rhs)) => Ok(Value::Bool(lhs ^ rhs)),
-                (Value::I8(lhs), Value::I8(rhs)) => Ok(Value::I8(lhs ^ rhs)),
-                (Value::I16(lhs), Value::I16(rhs)) => Ok(Value::I16(lhs ^ rhs)),
-                (Value::I32(lhs), Value::I32(rhs)) => Ok(Value::I32(lhs ^ rhs)),
-                (Value::I64(lhs), Value::I64(rhs)) => Ok(Value::I64(lhs ^ rhs)),
-                (Value::U8(lhs), Value::U8(rhs)) => Ok(Value::U8(lhs ^ rhs)),
-                (Value::U16(lhs), Value::U16(rhs)) => Ok(Value::U16(lhs ^ rhs)),
-                (Value::U32(lhs), Value::U32(rhs)) => Ok(Value::U32(lhs ^ rhs)),
-                (Value::U64(lhs), Value::U64(rhs)) => Ok(Value::U64(lhs ^ rhs)),
-                (lhs, rhs) => make_error(self, lhs, rhs, "^"),
+            BinaryOpKind::Xor => match_bitwise! {
+                (lhs_value as lhs "^" rhs_value as rhs) => lhs ^ rhs
             },
-            BinaryOpKind::ShiftRight => match (lhs, rhs) {
-                (Value::I8(lhs), Value::I8(rhs)) => Ok(Value::I8(lhs >> rhs)),
-                (Value::I16(lhs), Value::I16(rhs)) => Ok(Value::I16(lhs >> rhs)),
-                (Value::I32(lhs), Value::I32(rhs)) => Ok(Value::I32(lhs >> rhs)),
-                (Value::I64(lhs), Value::I64(rhs)) => Ok(Value::I64(lhs >> rhs)),
-                (Value::U8(lhs), Value::U8(rhs)) => Ok(Value::U8(lhs >> rhs)),
-                (Value::U16(lhs), Value::U16(rhs)) => Ok(Value::U16(lhs >> rhs)),
-                (Value::U32(lhs), Value::U32(rhs)) => Ok(Value::U32(lhs >> rhs)),
-                (Value::U64(lhs), Value::U64(rhs)) => Ok(Value::U64(lhs >> rhs)),
-                (lhs, rhs) => make_error(self, lhs, rhs, ">>"),
+            BinaryOpKind::ShiftRight => match_bitshift! {
+                (lhs_value as lhs ">>" rhs_value as rhs) => lhs.checked_shr(rhs.into())
             },
-            BinaryOpKind::ShiftLeft => match (lhs, rhs) {
-                (Value::I8(lhs), Value::I8(rhs)) => Ok(Value::I8(lhs << rhs)),
-                (Value::I16(lhs), Value::I16(rhs)) => Ok(Value::I16(lhs << rhs)),
-                (Value::I32(lhs), Value::I32(rhs)) => Ok(Value::I32(lhs << rhs)),
-                (Value::I64(lhs), Value::I64(rhs)) => Ok(Value::I64(lhs << rhs)),
-                (Value::U8(lhs), Value::U8(rhs)) => Ok(Value::U8(lhs << rhs)),
-                (Value::U16(lhs), Value::U16(rhs)) => Ok(Value::U16(lhs << rhs)),
-                (Value::U32(lhs), Value::U32(rhs)) => Ok(Value::U32(lhs << rhs)),
-                (Value::U64(lhs), Value::U64(rhs)) => Ok(Value::U64(lhs << rhs)),
-                (lhs, rhs) => make_error(self, lhs, rhs, "<<"),
+            BinaryOpKind::ShiftLeft => match_bitshift! {
+                (lhs_value as lhs "<<" rhs_value as rhs) => lhs.checked_shl(rhs.into())
             },
-            BinaryOpKind::Modulo => match (lhs, rhs) {
-                (Value::I8(lhs), Value::I8(rhs)) => Ok(Value::I8(lhs % rhs)),
-                (Value::I16(lhs), Value::I16(rhs)) => Ok(Value::I16(lhs % rhs)),
-                (Value::I32(lhs), Value::I32(rhs)) => Ok(Value::I32(lhs % rhs)),
-                (Value::I64(lhs), Value::I64(rhs)) => Ok(Value::I64(lhs % rhs)),
-                (Value::U8(lhs), Value::U8(rhs)) => Ok(Value::U8(lhs % rhs)),
-                (Value::U16(lhs), Value::U16(rhs)) => Ok(Value::U16(lhs % rhs)),
-                (Value::U32(lhs), Value::U32(rhs)) => Ok(Value::U32(lhs % rhs)),
-                (Value::U64(lhs), Value::U64(rhs)) => Ok(Value::U64(lhs % rhs)),
-                (lhs, rhs) => make_error(self, lhs, rhs, "%"),
+            BinaryOpKind::Modulo => match_integer! {
+                (lhs_value as lhs "%" rhs_value as rhs) => lhs.checked_rem(rhs)
             },
         }
     }
@@ -1633,7 +1647,7 @@ impl<'local, 'interner> Interpreter<'local, 'interner> {
                 Value::Pointer(elem, true) => Ok(elem.borrow().clone()),
                 other => Ok(other),
             },
-            HirLValue::Dereference { lvalue, element_type: _, location } => {
+            HirLValue::Dereference { lvalue, element_type, location } => {
                 match self.evaluate_lvalue(lvalue)? {
                     Value::Pointer(value, _) => Ok(value.borrow().clone()),
                     value => {
diff --git a/compiler/noirc_frontend/src/hir/comptime/interpreter/builtin.rs b/compiler/noirc_frontend/src/hir/comptime/interpreter/builtin.rs
index 9960486120e..3d8ccf78926 100644
--- a/compiler/noirc_frontend/src/hir/comptime/interpreter/builtin.rs
+++ b/compiler/noirc_frontend/src/hir/comptime/interpreter/builtin.rs
@@ -1,27 +1,27 @@
 use std::rc::Rc;
 
-use acvm::{AcirField, FieldElement};
+use acvm::{acir::BlackBoxFunc, AcirField, FieldElement};
 use builtin_helpers::{
-    block_expression_to_value, check_argument_count, check_function_not_yet_resolved,
-    check_one_argument, check_three_arguments, check_two_arguments, get_bool, get_expr, get_field,
-    get_format_string, get_function_def, get_module, get_quoted, get_slice, get_struct,
-    get_trait_constraint, get_trait_def, get_trait_impl, get_tuple, get_type, get_typed_expr,
-    get_u32, get_unresolved_type, has_named_attribute, hir_pattern_to_tokens,
-    mutate_func_meta_type, parse, quote_ident, replace_func_meta_parameters,
-    replace_func_meta_return_type,
+    block_expression_to_value, byte_array_type, check_argument_count,
+    check_function_not_yet_resolved, check_one_argument, check_three_arguments,
+    check_two_arguments, get_bool, get_expr, get_field, get_format_string, get_function_def,
+    get_module, get_quoted, get_slice, get_struct, get_trait_constraint, get_trait_def,
+    get_trait_impl, get_tuple, get_type, get_typed_expr, get_u32, get_unresolved_type,
+    has_named_attribute, hir_pattern_to_tokens, mutate_func_meta_type, parse, quote_ident,
+    replace_func_meta_parameters, replace_func_meta_return_type,
 };
-use chumsky::{chain::Chain, prelude::choice, primitive::just, Parser};
 use im::Vector;
 use iter_extended::{try_vecmap, vecmap};
-use noirc_errors::Location;
+use noirc_errors::{Location, Span};
 use num_bigint::BigUint;
 use rustc_hash::FxHashMap as HashMap;
 
 use crate::{
     ast::{
         ArrayLiteral, BlockExpression, ConstrainKind, Expression, ExpressionKind, ForRange,
-        FunctionKind, FunctionReturnType, IntegerBitSize, LValue, Literal, Pattern, Statement,
-        StatementKind, UnaryOp, UnresolvedType, UnresolvedTypeData, Visibility,
+        FunctionKind, FunctionReturnType, Ident, IntegerBitSize, ItemVisibility, LValue, Literal,
+        Pattern, Signedness, Statement, StatementKind, UnaryOp, UnresolvedType, UnresolvedTypeData,
+        Visibility,
     },
     hir::{
         comptime::{
@@ -30,12 +30,14 @@ use crate::{
             InterpreterError, Value,
         },
         def_collector::dc_crate::CollectedItems,
+        def_map::ModuleDefId,
     },
+    hir_def::expr::{HirExpression, HirLiteral},
     hir_def::function::FunctionBody,
-    macros_api::{HirExpression, HirLiteral, Ident, ModuleDefId, NodeInterner, Signedness},
-    node_interner::{DefinitionKind, TraitImplKind},
-    parser,
-    token::{Attribute, SecondaryAttribute, Token},
+    hir_def::{self},
+    node_interner::{DefinitionKind, NodeInterner, TraitImplKind},
+    parser::{Parser, StatementOrExpressionOrLValue},
+    token::{Attribute, Token},
     Kind, QuotedType, ResolvedGeneric, Shared, Type, TypeVariable,
 };
 
@@ -55,12 +57,19 @@ impl<'local, 'context> Interpreter<'local, 'context> {
         let interner = &mut self.elaborator.interner;
         let call_stack = &self.elaborator.interpreter_call_stack;
         match name {
+            "apply_range_constraint" => {
+                self.call_foreign("range", arguments, return_type, location)
+            }
             "array_as_str_unchecked" => array_as_str_unchecked(interner, arguments, location),
             "array_len" => array_len(interner, arguments, location),
+            "array_refcount" => Ok(Value::U32(0)),
             "assert_constant" => Ok(Value::Bool(true)),
             "as_slice" => as_slice(interner, arguments, location),
             "ctstring_eq" => ctstring_eq(arguments, location),
             "ctstring_hash" => ctstring_hash(arguments, location),
+            "derive_pedersen_generators" => {
+                derive_generators(interner, arguments, return_type, location)
+            }
             "expr_as_array" => expr_as_array(interner, arguments, return_type, location),
             "expr_as_assert" => expr_as_assert(interner, arguments, return_type, location),
             "expr_as_assert_eq" => expr_as_assert_eq(interner, arguments, return_type, location),
@@ -104,6 +113,7 @@ impl<'local, 'context> Interpreter<'local, 'context> {
             "expr_is_continue" => expr_is_continue(interner, arguments, location),
             "expr_resolve" => expr_resolve(self, arguments, location),
             "is_unconstrained" => Ok(Value::Bool(true)),
+            "field_less_than" => field_less_than(arguments, location),
             "fmtstr_as_ctstring" => fmtstr_as_ctstring(interner, arguments, location),
             "fmtstr_quoted_contents" => fmtstr_quoted_contents(interner, arguments, location),
             "fresh_type_variable" => fresh_type_variable(interner),
@@ -129,6 +139,9 @@ impl<'local, 'context> Interpreter<'local, 'context> {
             "function_def_set_return_public" => {
                 function_def_set_return_public(self, arguments, location)
             }
+            "function_def_set_return_data" => {
+                function_def_set_return_data(self, arguments, location)
+            }
             "function_def_set_unconstrained" => {
                 function_def_set_unconstrained(self, arguments, location)
             }
@@ -157,6 +170,7 @@ impl<'local, 'context> Interpreter<'local, 'context> {
             "slice_pop_front" => slice_pop_front(interner, arguments, location, call_stack),
             "slice_push_back" => slice_push_back(interner, arguments, location),
             "slice_push_front" => slice_push_front(interner, arguments, location),
+            "slice_refcount" => Ok(Value::U32(0)),
             "slice_remove" => slice_remove(interner, arguments, location, call_stack),
             "str_as_bytes" => str_as_bytes(interner, arguments, location),
             "str_as_ctstring" => str_as_ctstring(interner, arguments, location),
@@ -189,6 +203,9 @@ impl<'local, 'context> Interpreter<'local, 'context> {
             "type_as_array" => type_as_array(arguments, return_type, location),
             "type_as_constant" => type_as_constant(arguments, return_type, location),
             "type_as_integer" => type_as_integer(arguments, return_type, location),
+            "type_as_mutable_reference" => {
+                type_as_mutable_reference(arguments, return_type, location)
+            }
             "type_as_slice" => type_as_slice(arguments, return_type, location),
             "type_as_str" => type_as_str(arguments, return_type, location),
             "type_as_struct" => type_as_struct(arguments, return_type, location),
@@ -201,6 +218,7 @@ impl<'local, 'context> Interpreter<'local, 'context> {
             "type_implements" => type_implements(interner, arguments, location),
             "type_is_bool" => type_is_bool(arguments, location),
             "type_is_field" => type_is_field(arguments, location),
+            "type_is_unit" => type_is_unit(arguments, location),
             "type_of" => type_of(arguments, location),
             "typed_expr_as_function_definition" => {
                 typed_expr_as_function_definition(interner, arguments, return_type, location)
@@ -208,10 +226,21 @@ impl<'local, 'context> Interpreter<'local, 'context> {
             "typed_expr_get_type" => {
                 typed_expr_get_type(interner, arguments, return_type, location)
             }
+            "unresolved_type_as_mutable_reference" => {
+                unresolved_type_as_mutable_reference(interner, arguments, return_type, location)
+            }
+            "unresolved_type_as_slice" => {
+                unresolved_type_as_slice(interner, arguments, return_type, location)
+            }
+            "unresolved_type_is_bool" => unresolved_type_is_bool(interner, arguments, location),
             "unresolved_type_is_field" => unresolved_type_is_field(interner, arguments, location),
-            "zeroed" => zeroed(return_type),
+            "unresolved_type_is_unit" => unresolved_type_is_unit(interner, arguments, location),
+            "zeroed" => zeroed(return_type, location.span),
+            blackbox if BlackBoxFunc::is_valid_black_box_func_name(blackbox) => {
+                self.call_foreign(blackbox, arguments, return_type, location)
+            }
             _ => {
-                let item = format!("Comptime evaluation for builtin function {name}");
+                let item = format!("Comptime evaluation for builtin function '{name}'");
                 Err(InterpreterError::Unimplemented { item, location })
             }
         }
@@ -300,10 +329,7 @@ fn str_as_bytes(
     let string = get_str(interner, string)?;
 
     let bytes: im::Vector<Value> = string.bytes().map(Value::U8).collect();
-    let byte_array_type = Type::Array(
-        Box::new(Type::Constant(bytes.len() as u32, Kind::u32())),
-        Box::new(Type::Integer(Signedness::Unsigned, IntegerBitSize::Eight)),
-    );
+    let byte_array_type = byte_array_type(bytes.len());
     Ok(Value::Array(bytes, byte_array_type))
 }
 
@@ -327,24 +353,9 @@ fn struct_def_add_attribute(
     let (self_argument, attribute) = check_two_arguments(arguments, location)?;
     let attribute_location = attribute.1;
     let attribute = get_str(interner, attribute)?;
-
-    let mut tokens = lex(&format!("#[{}]", attribute));
-    if tokens.len() != 1 {
-        return Err(InterpreterError::InvalidAttribute {
-            attribute: attribute.to_string(),
-            location: attribute_location,
-        });
-    }
-
-    let token = tokens.remove(0);
-    let Token::Attribute(attribute) = token else {
-        return Err(InterpreterError::InvalidAttribute {
-            attribute: attribute.to_string(),
-            location: attribute_location,
-        });
-    };
-
-    let Attribute::Secondary(attribute) = attribute else {
+    let attribute = format!("#[{}]", attribute);
+    let mut parser = Parser::for_str(&attribute);
+    let Some((Attribute::Secondary(attribute), _span)) = parser.parse_attribute() else {
         return Err(InterpreterError::InvalidAttribute {
             attribute: attribute.to_string(),
             location: attribute_location,
@@ -353,7 +364,7 @@ fn struct_def_add_attribute(
 
     let struct_id = get_struct(self_argument)?;
     interner.update_struct_attributes(struct_id, |attributes| {
-        attributes.push(attribute.clone());
+        attributes.push(attribute);
     });
 
     Ok(Value::Unit)
@@ -400,11 +411,11 @@ fn struct_def_add_generic(
         }
     }
 
-    let type_var = TypeVariable::unbound(interner.next_type_variable_id());
+    let type_var_kind = Kind::Normal;
+    let type_var = TypeVariable::unbound(interner.next_type_variable_id(), type_var_kind);
     let span = generic_location.span;
-    let kind = Kind::Normal;
-    let typ = Type::NamedGeneric(type_var.clone(), name.clone(), kind.clone());
-    let new_generic = ResolvedGeneric { name, type_var, span, kind };
+    let typ = Type::NamedGeneric(type_var.clone(), name.clone());
+    let new_generic = ResolvedGeneric { name, type_var, span };
     the_struct.generics.push(new_generic);
 
     Ok(Value::Type(typ))
@@ -422,7 +433,7 @@ fn struct_def_as_type(
     let struct_def = struct_def_rc.borrow();
 
     let generics = vecmap(&struct_def.generics, |generic| {
-        Type::NamedGeneric(generic.type_var.clone(), generic.name.clone(), generic.kind.clone())
+        Type::NamedGeneric(generic.type_var.clone(), generic.name.clone())
     });
 
     drop(struct_def);
@@ -483,9 +494,9 @@ fn struct_def_fields(
 
     let mut fields = im::Vector::new();
 
-    for (name, typ) in struct_def.get_fields_as_written() {
-        let name = Value::Quoted(Rc::new(vec![Token::Ident(name)]));
-        let typ = Value::Type(typ);
+    for field in struct_def.get_fields_as_written() {
+        let name = Value::Quoted(Rc::new(vec![Token::Ident(field.name.to_string())]));
+        let typ = Value::Type(field.typ);
         fields.push_back(Value::Tuple(vec![name, typ]));
     }
 
@@ -552,7 +563,11 @@ fn struct_def_set_fields(
 
                 match name_tokens.first() {
                     Some(Token::Ident(name)) if name_tokens.len() == 1 => {
-                        Ok((Ident::new(name.clone(), field_location.span), typ))
+                        Ok(hir_def::types::StructField {
+                            visibility: ItemVisibility::Public,
+                            name: Ident::new(name.clone(), field_location.span),
+                            typ,
+                        })
                     }
                     _ => {
                         let value = name_value.display(interner).to_string();
@@ -671,15 +686,21 @@ fn quoted_as_expr(
 ) -> IResult<Value> {
     let argument = check_one_argument(arguments, location)?;
 
-    let expr_parser = parser::expression().map(|expr| Value::expression(expr.kind));
-    let statement_parser = parser::fresh_statement().map(Value::statement);
-    let lvalue_parser = parser::lvalue(parser::expression()).map(Value::lvalue);
-    let parser = choice((expr_parser, statement_parser, lvalue_parser));
-    let parser = parser.then_ignore(just(Token::Semicolon).or_not());
+    let result =
+        parse(interner, argument, Parser::parse_statement_or_expression_or_lvalue, "an expression");
 
-    let expr = parse(interner, argument, parser, "an expression").ok();
+    let value =
+        result.ok().map(
+            |statement_or_expression_or_lvalue| match statement_or_expression_or_lvalue {
+                StatementOrExpressionOrLValue::Expression(expr) => Value::expression(expr.kind),
+                StatementOrExpressionOrLValue::Statement(statement) => {
+                    Value::statement(statement.kind)
+                }
+                StatementOrExpressionOrLValue::LValue(lvalue) => Value::lvalue(lvalue),
+            },
+        );
 
-    option(return_type, expr)
+    option(return_type, value, location.span)
 }
 
 // fn as_module(quoted: Quoted) -> Option<Module>
@@ -691,9 +712,13 @@ fn quoted_as_module(
 ) -> IResult<Value> {
     let argument = check_one_argument(arguments, location)?;
 
-    let path =
-        parse(interpreter.elaborator.interner, argument, parser::path_no_turbofish(), "a path")
-            .ok();
+    let path = parse(
+        interpreter.elaborator.interner,
+        argument,
+        Parser::parse_path_no_turbofish_or_error,
+        "a path",
+    )
+    .ok();
     let option_value = path.and_then(|path| {
         let module = interpreter
             .elaborate_in_function(interpreter.current_function, |elaborator| {
@@ -702,7 +727,7 @@ fn quoted_as_module(
         module.map(Value::ModuleDefinition)
     });
 
-    option(return_type, option_value)
+    option(return_type, option_value, location.span)
 }
 
 // fn as_trait_constraint(quoted: Quoted) -> TraitConstraint
@@ -715,12 +740,12 @@ fn quoted_as_trait_constraint(
     let trait_bound = parse(
         interpreter.elaborator.interner,
         argument,
-        parser::trait_bound(),
+        Parser::parse_trait_bound_or_error,
         "a trait constraint",
     )?;
     let bound = interpreter
         .elaborate_in_function(interpreter.current_function, |elaborator| {
-            elaborator.resolve_trait_bound(&trait_bound, Type::Unit)
+            elaborator.resolve_trait_bound(&trait_bound)
         })
         .ok_or(InterpreterError::FailedToResolveTraitBound { trait_bound, location })?;
 
@@ -734,7 +759,8 @@ fn quoted_as_type(
     location: Location,
 ) -> IResult<Value> {
     let argument = check_one_argument(arguments, location)?;
-    let typ = parse(interpreter.elaborator.interner, argument, parser::parse_type(), "a type")?;
+    let typ =
+        parse(interpreter.elaborator.interner, argument, Parser::parse_type_or_error, "a type")?;
     let typ = interpreter
         .elaborate_in_function(interpreter.current_function, |elab| elab.resolve_type(typ));
     Ok(Value::Type(typ))
@@ -776,8 +802,12 @@ fn to_le_radix(
     let value = get_field(value)?;
     let radix = get_u32(radix)?;
     let limb_count = if let Type::Array(length, _) = return_type {
-        if let Type::Constant(limb_count, _kind) = *length {
-            limb_count
+        if let Type::Constant(limb_count, kind) = *length {
+            if kind.unifies(&Kind::u32()) {
+                limb_count
+            } else {
+                return Err(InterpreterError::TypeAnnotationsNeededForMethodCall { location });
+            }
         } else {
             return Err(InterpreterError::TypeAnnotationsNeededForMethodCall { location });
         }
@@ -787,14 +817,13 @@ fn to_le_radix(
 
     // Decompose the integer into its radix digits in little endian form.
     let decomposed_integer = compute_to_radix_le(value, radix);
-    let decomposed_integer = vecmap(0..limb_count as usize, |i| match decomposed_integer.get(i) {
-        Some(digit) => Value::U8(*digit),
-        None => Value::U8(0),
-    });
-    Ok(Value::Array(
-        decomposed_integer.into(),
-        Type::Integer(Signedness::Unsigned, IntegerBitSize::Eight),
-    ))
+    let decomposed_integer =
+        vecmap(0..limb_count.to_u128() as usize, |i| match decomposed_integer.get(i) {
+            Some(digit) => Value::U8(*digit),
+            None => Value::U8(0),
+        });
+    let result_type = byte_array_type(decomposed_integer.len());
+    Ok(Value::Array(decomposed_integer.into(), result_type))
 }
 
 fn compute_to_radix_le(field: FieldElement, radix: u32) -> Vec<u8> {
@@ -828,11 +857,22 @@ fn type_as_constant(
     return_type: Type,
     location: Location,
 ) -> IResult<Value> {
-    type_as(arguments, return_type, location, |typ| {
+    type_as_or_err(arguments, return_type, location, |typ| {
         // Prefer to use `evaluate_to_u32` over matching on `Type::Constant`
         // since arithmetic generics may be `Type::InfixExpr`s which evaluate to
         // constants but are not actually the `Type::Constant` variant.
-        typ.evaluate_to_u32().map(Value::U32)
+        match typ.evaluate_to_u32(location.span) {
+            Ok(constant) => Ok(Some(Value::U32(constant))),
+            Err(err) => {
+                // Evaluating to a non-constant returns 'None' in user code
+                if err.is_non_constant_evaluated() {
+                    Ok(None)
+                } else {
+                    let err = Some(Box::new(err));
+                    Err(InterpreterError::NonIntegerArrayLength { typ, err, location })
+                }
+            }
+        }
     })
 }
 
@@ -851,6 +891,21 @@ fn type_as_integer(
     })
 }
 
+// fn as_mutable_reference(self) -> Option<Type>
+fn type_as_mutable_reference(
+    arguments: Vec<(Value, Location)>,
+    return_type: Type,
+    location: Location,
+) -> IResult<Value> {
+    type_as(arguments, return_type, location, |typ| {
+        if let Type::MutableReference(typ) = typ {
+            Some(Value::Type(*typ))
+        } else {
+            None
+        }
+    })
+}
+
 // fn as_slice(self) -> Option<Type>
 fn type_as_slice(
     arguments: Vec<(Value, Location)>,
@@ -923,7 +978,6 @@ fn type_as_tuple(
     })
 }
 
-// Helper function for implementing the `type_as_...` functions.
 fn type_as<F>(
     arguments: Vec<(Value, Location)>,
     return_type: Type,
@@ -932,13 +986,26 @@ fn type_as<F>(
 ) -> IResult<Value>
 where
     F: FnOnce(Type) -> Option<Value>,
+{
+    type_as_or_err(arguments, return_type, location, |x| Ok(f(x)))
+}
+
+// Helper function for implementing the `type_as_...` functions.
+fn type_as_or_err<F>(
+    arguments: Vec<(Value, Location)>,
+    return_type: Type,
+    location: Location,
+    f: F,
+) -> IResult<Value>
+where
+    F: FnOnce(Type) -> IResult<Option<Value>>,
 {
     let value = check_one_argument(arguments, location)?;
     let typ = get_type(value)?.follow_bindings();
 
-    let option_value = f(typ);
+    let option_value = f(typ)?;
 
-    option(return_type, option_value)
+    option(return_type, option_value, location.span)
 }
 
 // fn type_eq(_first: Type, _second: Type) -> bool
@@ -973,7 +1040,7 @@ fn type_get_trait_impl(
         _ => None,
     };
 
-    option(return_type, option_value)
+    option(return_type, option_value, location.span)
 }
 
 // fn implements(self, constraint: TraitConstraint) -> bool
@@ -1009,6 +1076,14 @@ fn type_is_field(arguments: Vec<(Value, Location)>, location: Location) -> IResu
     Ok(Value::Bool(matches!(typ, Type::FieldElement)))
 }
 
+// fn is_unit(self) -> bool
+fn type_is_unit(arguments: Vec<(Value, Location)>, location: Location) -> IResult<Value> {
+    let value = check_one_argument(arguments, location)?;
+    let typ = get_type(value)?;
+
+    Ok(Value::Bool(matches!(typ, Type::Unit)))
+}
+
 // fn type_of<T>(x: T) -> Type
 fn type_of(arguments: Vec<(Value, Location)>, location: Location) -> IResult<Value> {
     let (value, _) = check_one_argument(arguments, location)?;
@@ -1086,7 +1161,7 @@ fn typed_expr_as_function_definition(
     } else {
         None
     };
-    option(return_type, option_value)
+    option(return_type, option_value, location.span)
 }
 
 // fn get_type(self) -> Option<Type>
@@ -1108,7 +1183,50 @@ fn typed_expr_get_type(
     } else {
         None
     };
-    option(return_type, option_value)
+    option(return_type, option_value, location.span)
+}
+
+// fn as_mutable_reference(self) -> Option<UnresolvedType>
+fn unresolved_type_as_mutable_reference(
+    interner: &NodeInterner,
+    arguments: Vec<(Value, Location)>,
+    return_type: Type,
+    location: Location,
+) -> IResult<Value> {
+    unresolved_type_as(interner, arguments, return_type, location, |typ| {
+        if let UnresolvedTypeData::MutableReference(typ) = typ {
+            Some(Value::UnresolvedType(typ.typ))
+        } else {
+            None
+        }
+    })
+}
+
+// fn as_slice(self) -> Option<UnresolvedType>
+fn unresolved_type_as_slice(
+    interner: &NodeInterner,
+    arguments: Vec<(Value, Location)>,
+    return_type: Type,
+    location: Location,
+) -> IResult<Value> {
+    unresolved_type_as(interner, arguments, return_type, location, |typ| {
+        if let UnresolvedTypeData::Slice(typ) = typ {
+            Some(Value::UnresolvedType(typ.typ))
+        } else {
+            None
+        }
+    })
+}
+
+// fn is_bool(self) -> bool
+fn unresolved_type_is_bool(
+    interner: &NodeInterner,
+    arguments: Vec<(Value, Location)>,
+    location: Location,
+) -> IResult<Value> {
+    let self_argument = check_one_argument(arguments, location)?;
+    let typ = get_unresolved_type(interner, self_argument)?;
+    Ok(Value::Bool(matches!(typ, UnresolvedTypeData::Bool)))
 }
 
 // fn is_field(self) -> bool
@@ -1122,13 +1240,43 @@ fn unresolved_type_is_field(
     Ok(Value::Bool(matches!(typ, UnresolvedTypeData::FieldElement)))
 }
 
+// fn is_unit(self) -> bool
+fn unresolved_type_is_unit(
+    interner: &NodeInterner,
+    arguments: Vec<(Value, Location)>,
+    location: Location,
+) -> IResult<Value> {
+    let self_argument = check_one_argument(arguments, location)?;
+    let typ = get_unresolved_type(interner, self_argument)?;
+    Ok(Value::Bool(matches!(typ, UnresolvedTypeData::Unit)))
+}
+
+// Helper function for implementing the `unresolved_type_as_...` functions.
+fn unresolved_type_as<F>(
+    interner: &NodeInterner,
+    arguments: Vec<(Value, Location)>,
+    return_type: Type,
+    location: Location,
+    f: F,
+) -> IResult<Value>
+where
+    F: FnOnce(UnresolvedTypeData) -> Option<Value>,
+{
+    let value = check_one_argument(arguments, location)?;
+    let typ = get_unresolved_type(interner, value)?;
+
+    let option_value = f(typ);
+
+    option(return_type, option_value, location.span)
+}
+
 // fn zeroed<T>() -> T
-fn zeroed(return_type: Type) -> IResult<Value> {
+fn zeroed(return_type: Type, span: Span) -> IResult<Value> {
     match return_type {
         Type::FieldElement => Ok(Value::Field(0u128.into())),
         Type::Array(length_type, elem) => {
-            if let Some(length) = length_type.evaluate_to_u32() {
-                let element = zeroed(elem.as_ref().clone())?;
+            if let Ok(length) = length_type.evaluate_to_u32(span) {
+                let element = zeroed(elem.as_ref().clone(), span)?;
                 let array = std::iter::repeat(element).take(length as usize).collect();
                 Ok(Value::Array(array, Type::Array(length_type, elem)))
             } else {
@@ -1151,7 +1299,7 @@ fn zeroed(return_type: Type) -> IResult<Value> {
         },
         Type::Bool => Ok(Value::Bool(false)),
         Type::String(length_type) => {
-            if let Some(length) = length_type.evaluate_to_u32() {
+            if let Ok(length) = length_type.evaluate_to_u32(span) {
                 Ok(Value::String(Rc::new("\0".repeat(length as usize))))
             } else {
                 // Assume we can resolve the length later
@@ -1159,9 +1307,9 @@ fn zeroed(return_type: Type) -> IResult<Value> {
             }
         }
         Type::FmtString(length_type, captures) => {
-            let length = length_type.evaluate_to_u32();
+            let length = length_type.evaluate_to_u32(span);
             let typ = Type::FmtString(length_type, captures);
-            if let Some(length) = length {
+            if let Ok(length) = length {
                 Ok(Value::FormatString(Rc::new("\0".repeat(length as usize)), typ))
             } else {
                 // Assume we can resolve the length later
@@ -1169,37 +1317,38 @@ fn zeroed(return_type: Type) -> IResult<Value> {
             }
         }
         Type::Unit => Ok(Value::Unit),
-        Type::Tuple(fields) => Ok(Value::Tuple(try_vecmap(fields, zeroed)?)),
+        Type::Tuple(fields) => Ok(Value::Tuple(try_vecmap(fields, |field| zeroed(field, span))?)),
         Type::Struct(struct_type, generics) => {
             let fields = struct_type.borrow().get_fields(&generics);
             let mut values = HashMap::default();
 
             for (field_name, field_type) in fields {
-                let field_value = zeroed(field_type)?;
+                let field_value = zeroed(field_type, span)?;
                 values.insert(Rc::new(field_name), field_value);
             }
 
             let typ = Type::Struct(struct_type, generics);
             Ok(Value::Struct(values, typ))
         }
-        Type::Alias(alias, generics) => zeroed(alias.borrow().get_type(&generics)),
+        Type::Alias(alias, generics) => zeroed(alias.borrow().get_type(&generics), span),
+        Type::CheckedCast { to, .. } => zeroed(*to, span),
         typ @ Type::Function(..) => {
             // Using Value::Zeroed here is probably safer than using FuncId::dummy_id() or similar
             Ok(Value::Zeroed(typ))
         }
         Type::MutableReference(element) => {
-            let element = zeroed(*element)?;
+            let element = zeroed(*element, span)?;
             Ok(Value::Pointer(Shared::new(element), false))
         }
         // Optimistically assume we can resolve this type later or that the value is unused
-        Type::TypeVariable(_, _)
+        Type::TypeVariable(_)
         | Type::Forall(_, _)
         | Type::Constant(..)
         | Type::InfixExpr(..)
         | Type::Quoted(_)
         | Type::Error
         | Type::TraitAsType(..)
-        | Type::NamedGeneric(_, _, _) => Ok(Value::Zeroed(return_type)),
+        | Type::NamedGeneric(_, _) => Ok(Value::Zeroed(return_type)),
     }
 }
 
@@ -1252,7 +1401,7 @@ fn expr_as_assert(
 
                 let option_type = tuple_types.pop().unwrap();
                 let message = message.map(|msg| Value::expression(msg.kind));
-                let message = option(option_type, message).ok()?;
+                let message = option(option_type, message, location.span).ok()?;
 
                 Some(Value::Tuple(vec![predicate, message]))
             } else {
@@ -1298,7 +1447,7 @@ fn expr_as_assert_eq(
 
                 let option_type = tuple_types.pop().unwrap();
                 let message = message.map(|message| Value::expression(message.kind));
-                let message = option(option_type, message).ok()?;
+                let message = option(option_type, message, location.span).ok()?;
 
                 Some(Value::Tuple(vec![lhs, rhs, message]))
             } else {
@@ -1474,7 +1623,7 @@ fn expr_as_constructor(
             None
         };
 
-    option(return_type, option_value)
+    option(return_type, option_value, location.span)
 }
 
 // fn as_for(self) -> Option<(Quoted, Expr, Expr)>
@@ -1510,7 +1659,8 @@ fn expr_as_for_range(
 ) -> IResult<Value> {
     expr_as(interner, arguments, return_type, location, |expr| {
         if let ExprValue::Statement(StatementKind::For(for_statement)) = expr {
-            if let ForRange::Range(from, to) = for_statement.range {
+            if let ForRange::Range(bounds) = for_statement.range {
+                let (from, to) = bounds.into_half_open();
                 let identifier =
                     Value::Quoted(Rc::new(vec![Token::Ident(for_statement.identifier.0.contents)]));
                 let from = Value::expression(from.kind);
@@ -1567,6 +1717,7 @@ fn expr_as_if(
             let alternative = option(
                 alternative_option_type,
                 if_expr.alternative.map(|e| Value::expression(e.kind)),
+                location.span,
             );
 
             Some(Value::Tuple(vec![
@@ -1655,7 +1806,7 @@ fn expr_as_lambda(
                     } else {
                         Some(Value::UnresolvedType(typ.typ))
                     };
-                    let typ = option(option_unresolved_type.clone(), typ).unwrap();
+                    let typ = option(option_unresolved_type.clone(), typ, location.span).unwrap();
                     Value::Tuple(vec![pattern, typ])
                 })
                 .collect();
@@ -1674,7 +1825,7 @@ fn expr_as_lambda(
                 Some(return_type)
             };
             let return_type = return_type.map(Value::UnresolvedType);
-            let return_type = option(option_unresolved_type, return_type).ok()?;
+            let return_type = option(option_unresolved_type, return_type, location.span).ok()?;
 
             let body = Value::expression(lambda.body.kind);
 
@@ -1708,7 +1859,7 @@ fn expr_as_let(
                 Some(Value::UnresolvedType(let_statement.r#type.typ))
             };
 
-            let typ = option(option_type, typ).ok()?;
+            let typ = option(option_type, typ, location.span).ok()?;
 
             Some(Value::Tuple(vec![
                 Value::pattern(let_statement.pattern),
@@ -1960,7 +2111,7 @@ where
     let expr_value = unwrap_expr_value(interner, expr_value);
 
     let option_value = f(expr_value);
-    option(return_type, option_value)
+    option(return_type, option_value, location.span)
 }
 
 // fn resolve(self, in_function: Option<FunctionDefinition>) -> TypedExpr
@@ -2075,7 +2226,7 @@ fn fmtstr_quoted_contents(
 
 // fn fresh_type_variable() -> Type
 fn fresh_type_variable(interner: &NodeInterner) -> IResult<Value> {
-    Ok(Value::Type(interner.next_type_variable()))
+    Ok(Value::Type(interner.next_type_variable_with_kind(Kind::Any)))
 }
 
 // fn add_attribute<let N: u32>(self, attribute: str<N>)
@@ -2087,17 +2238,9 @@ fn function_def_add_attribute(
     let (self_argument, attribute) = check_two_arguments(arguments, location)?;
     let attribute_location = attribute.1;
     let attribute = get_str(interpreter.elaborator.interner, attribute)?;
-
-    let mut tokens = lex(&format!("#[{}]", attribute));
-    if tokens.len() != 1 {
-        return Err(InterpreterError::InvalidAttribute {
-            attribute: attribute.to_string(),
-            location: attribute_location,
-        });
-    }
-
-    let token = tokens.remove(0);
-    let Token::Attribute(attribute) = token else {
+    let attribute = format!("#[{}]", attribute);
+    let mut parser = Parser::for_str(&attribute);
+    let Some((attribute, _span)) = parser.parse_attribute() else {
         return Err(InterpreterError::InvalidAttribute {
             attribute: attribute.to_string(),
             location: attribute_location,
@@ -2111,18 +2254,13 @@ fn function_def_add_attribute(
 
     match &attribute {
         Attribute::Function(attribute) => {
-            function_modifiers.attributes.function = Some(attribute.clone());
+            function_modifiers.attributes.set_function(attribute.clone());
         }
         Attribute::Secondary(attribute) => {
             function_modifiers.attributes.secondary.push(attribute.clone());
         }
     }
 
-    if let Attribute::Secondary(SecondaryAttribute::Custom(attribute)) = attribute {
-        let func_meta = interpreter.elaborator.interner.function_meta_mut(&func_id);
-        func_meta.custom_attributes.push(attribute);
-    }
-
     Ok(Value::Unit)
 }
 
@@ -2154,7 +2292,7 @@ fn function_def_has_named_attribute(
     let name = &*get_str(interner, name)?;
 
     let modifiers = interner.function_modifiers(&func_id);
-    if let Some(attribute) = &modifiers.attributes.function {
+    if let Some(attribute) = modifiers.attributes.function() {
         if name == attribute.name() {
             return Ok(Value::Bool(true));
         }
@@ -2320,7 +2458,7 @@ fn function_def_set_parameters(
         let parameter_pattern = parse(
             interpreter.elaborator.interner,
             (tuple.pop().unwrap(), parameters_argument_location),
-            parser::pattern(),
+            Parser::parse_pattern_or_error,
             "a pattern",
         )?;
 
@@ -2331,7 +2469,6 @@ fn function_def_set_parameters(
                 DefinitionKind::Local(None),
                 &mut parameter_idents,
                 true, // warn_if_unused
-                None,
             )
         });
 
@@ -2392,6 +2529,23 @@ fn function_def_set_return_public(
     Ok(Value::Unit)
 }
 
+// fn set_return_data(self)
+fn function_def_set_return_data(
+    interpreter: &mut Interpreter,
+    arguments: Vec<(Value, Location)>,
+    location: Location,
+) -> IResult<Value> {
+    let self_argument = check_one_argument(arguments, location)?;
+
+    let func_id = get_function_def(self_argument)?;
+    check_function_not_yet_resolved(interpreter, func_id, location)?;
+
+    let func_meta = interpreter.elaborator.interner.function_meta_mut(&func_id);
+    func_meta.return_visibility = Visibility::ReturnData;
+
+    Ok(Value::Unit)
+}
+
 // fn set_unconstrained(self, value: bool)
 fn function_def_set_unconstrained(
     interpreter: &mut Interpreter,
@@ -2421,7 +2575,7 @@ fn module_add_item(
     let module_id = get_module(self_argument)?;
     let module_data = interpreter.elaborator.get_module(module_id);
 
-    let parser = parser::top_level_items();
+    let parser = Parser::parse_top_level_items;
     let top_level_statements =
         parse(interpreter.elaborator.interner, item, parser, "a top-level item")?;
 
@@ -2602,17 +2756,17 @@ fn trait_def_as_trait_constraint(
     let trait_id = get_trait_def(argument)?;
     let constraint = interner.get_trait(trait_id).as_constraint(location.span);
 
-    Ok(Value::TraitConstraint(trait_id, constraint.trait_generics))
+    Ok(Value::TraitConstraint(trait_id, constraint.trait_bound.trait_generics))
 }
 
 /// Creates a value that holds an `Option`.
 /// `option_type` must be a Type referencing the `Option` type.
-pub(crate) fn option(option_type: Type, value: Option<Value>) -> IResult<Value> {
+pub(crate) fn option(option_type: Type, value: Option<Value>, span: Span) -> IResult<Value> {
     let t = extract_option_generic_type(option_type.clone());
 
     let (is_some, value) = match value {
         Some(value) => (Value::Bool(true), value),
-        None => (Value::Bool(false), zeroed(t)?),
+        None => (Value::Bool(false), zeroed(t, span)?),
     };
 
     let mut fields = HashMap::default();
@@ -2640,3 +2794,66 @@ fn ctstring_eq(arguments: Vec<(Value, Location)>, location: Location) -> IResult
 fn ctstring_hash(arguments: Vec<(Value, Location)>, location: Location) -> IResult<Value> {
     hash_item(arguments, location, get_ctstring)
 }
+
+fn derive_generators(
+    interner: &mut NodeInterner,
+    arguments: Vec<(Value, Location)>,
+    return_type: Type,
+    location: Location,
+) -> IResult<Value> {
+    let (domain_separator_string, starting_index) = check_two_arguments(arguments, location)?;
+
+    let domain_separator_location = domain_separator_string.1;
+    let (domain_separator_string, _) = get_array(interner, domain_separator_string)?;
+    let starting_index = get_u32(starting_index)?;
+
+    let domain_separator_string =
+        try_vecmap(domain_separator_string, |byte| get_u8((byte, domain_separator_location)))?;
+
+    let (size, elements) = match return_type.clone() {
+        Type::Array(size, elements) => (size, elements),
+        _ => panic!("ICE: Should only have an array return type"),
+    };
+
+    let num_generators = size.evaluate_to_u32(location.span).map_err(|err| {
+        let err = Box::new(err);
+        InterpreterError::UnknownArrayLength { length: *size, err, location }
+    })?;
+
+    let generators = bn254_blackbox_solver::derive_generators(
+        &domain_separator_string,
+        num_generators,
+        starting_index,
+    );
+
+    let is_infinite = FieldElement::zero();
+    let x_field_name: Rc<String> = Rc::new("x".to_owned());
+    let y_field_name: Rc<String> = Rc::new("y".to_owned());
+    let is_infinite_field_name: Rc<String> = Rc::new("is_infinite".to_owned());
+    let mut results = Vector::new();
+    for gen in generators {
+        let x_big: BigUint = gen.x.into();
+        let x = FieldElement::from_be_bytes_reduce(&x_big.to_bytes_be());
+        let y_big: BigUint = gen.y.into();
+        let y = FieldElement::from_be_bytes_reduce(&y_big.to_bytes_be());
+        let mut embedded_curve_point_fields = HashMap::default();
+        embedded_curve_point_fields.insert(x_field_name.clone(), Value::Field(x));
+        embedded_curve_point_fields.insert(y_field_name.clone(), Value::Field(y));
+        embedded_curve_point_fields
+            .insert(is_infinite_field_name.clone(), Value::Field(is_infinite));
+        let embedded_curve_point_struct =
+            Value::Struct(embedded_curve_point_fields, *elements.clone());
+        results.push_back(embedded_curve_point_struct);
+    }
+
+    Ok(Value::Array(results, return_type))
+}
+
+fn field_less_than(arguments: Vec<(Value, Location)>, location: Location) -> IResult<Value> {
+    let (lhs, rhs) = check_two_arguments(arguments, location)?;
+
+    let lhs = get_field(lhs)?;
+    let rhs = get_field(rhs)?;
+
+    Ok(Value::Bool(lhs < rhs))
+}
diff --git a/compiler/noirc_frontend/src/hir/comptime/interpreter/builtin/builtin_helpers.rs b/compiler/noirc_frontend/src/hir/comptime/interpreter/builtin/builtin_helpers.rs
index 20303e49e15..cf90aab32e0 100644
--- a/compiler/noirc_frontend/src/hir/comptime/interpreter/builtin/builtin_helpers.rs
+++ b/compiler/noirc_frontend/src/hir/comptime/interpreter/builtin/builtin_helpers.rs
@@ -2,10 +2,13 @@ use std::hash::Hash;
 use std::{hash::Hasher, rc::Rc};
 
 use acvm::FieldElement;
+use iter_extended::try_vecmap;
 use noirc_errors::Location;
 
 use crate::hir::comptime::display::tokens_to_string;
+use crate::hir::comptime::value::add_token_spans;
 use crate::lexer::Lexer;
+use crate::parser::Parser;
 use crate::{
     ast::{
         BlockExpression, ExpressionKind, Ident, IntegerBitSize, LValue, Pattern, Signedness,
@@ -14,7 +17,7 @@ use crate::{
     hir::{
         comptime::{
             errors::IResult,
-            value::{add_token_spans, ExprValue, TypedExpr},
+            value::{ExprValue, TypedExpr},
             Interpreter, InterpreterError, Value,
         },
         def_map::ModuleId,
@@ -24,12 +27,12 @@ use crate::{
         function::{FuncMeta, FunctionBody},
         stmt::HirPattern,
     },
-    macros_api::{NodeInterner, StructId},
-    node_interner::{FuncId, TraitId, TraitImplId},
-    parser::NoirParser,
+    node_interner::{FuncId, NodeInterner, StructId, TraitId, TraitImplId},
     token::{SecondaryAttribute, Token, Tokens},
     QuotedType, Type,
 };
+use crate::{Kind, Shared, StructType};
+use rustc_hash::FxHashMap as HashMap;
 
 pub(crate) fn check_argument_count(
     expected: usize,
@@ -45,38 +48,40 @@ pub(crate) fn check_argument_count(
 }
 
 pub(crate) fn check_one_argument(
-    mut arguments: Vec<(Value, Location)>,
+    arguments: Vec<(Value, Location)>,
     location: Location,
 ) -> IResult<(Value, Location)> {
-    check_argument_count(1, &arguments, location)?;
+    let [arg1] = check_arguments(arguments, location)?;
 
-    Ok(arguments.pop().unwrap())
+    Ok(arg1)
 }
 
 pub(crate) fn check_two_arguments(
-    mut arguments: Vec<(Value, Location)>,
+    arguments: Vec<(Value, Location)>,
     location: Location,
 ) -> IResult<((Value, Location), (Value, Location))> {
-    check_argument_count(2, &arguments, location)?;
+    let [arg1, arg2] = check_arguments(arguments, location)?;
 
-    let argument2 = arguments.pop().unwrap();
-    let argument1 = arguments.pop().unwrap();
-
-    Ok((argument1, argument2))
+    Ok((arg1, arg2))
 }
 
 #[allow(clippy::type_complexity)]
 pub(crate) fn check_three_arguments(
-    mut arguments: Vec<(Value, Location)>,
+    arguments: Vec<(Value, Location)>,
     location: Location,
 ) -> IResult<((Value, Location), (Value, Location), (Value, Location))> {
-    check_argument_count(3, &arguments, location)?;
+    let [arg1, arg2, arg3] = check_arguments(arguments, location)?;
 
-    let argument3 = arguments.pop().unwrap();
-    let argument2 = arguments.pop().unwrap();
-    let argument1 = arguments.pop().unwrap();
+    Ok((arg1, arg2, arg3))
+}
 
-    Ok((argument1, argument2, argument3))
+#[allow(clippy::type_complexity)]
+pub(crate) fn check_arguments<const N: usize>(
+    arguments: Vec<(Value, Location)>,
+    location: Location,
+) -> IResult<[(Value, Location); N]> {
+    check_argument_count(N, &arguments, location)?;
+    Ok(arguments.try_into().expect("checked arg count"))
 }
 
 pub(crate) fn get_array(
@@ -93,6 +98,47 @@ pub(crate) fn get_array(
     }
 }
 
+/// Get the fields if the value is a `Value::Struct`, otherwise report that a struct type
+/// with `name` is expected. Returns the `Type` but doesn't verify that it's called `name`.
+pub(crate) fn get_struct_fields(
+    name: &str,
+    (value, location): (Value, Location),
+) -> IResult<(HashMap<Rc<String>, Value>, Type)> {
+    match value {
+        Value::Struct(fields, typ) => Ok((fields, typ)),
+        _ => {
+            let expected = StructType::new(
+                StructId::dummy_id(),
+                Ident::new(name.to_string(), location.span),
+                location,
+                Vec::new(),
+                Vec::new(),
+            );
+            let expected = Type::Struct(Shared::new(expected), Vec::new());
+            type_mismatch(value, expected, location)
+        }
+    }
+}
+
+/// Get a specific field of a struct and apply a decoder function on it.
+pub(crate) fn get_struct_field<T>(
+    field_name: &str,
+    struct_fields: &HashMap<Rc<String>, Value>,
+    struct_type: &Type,
+    location: Location,
+    f: impl Fn((Value, Location)) -> IResult<T>,
+) -> IResult<T> {
+    let key = Rc::new(field_name.to_string());
+    let Some(value) = struct_fields.get(&key) else {
+        return Err(InterpreterError::ExpectedStructToHaveField {
+            typ: struct_type.clone(),
+            field_name: Rc::into_inner(key).unwrap(),
+            location,
+        });
+    };
+    f((value.clone(), location))
+}
+
 pub(crate) fn get_bool((value, location): (Value, Location)) -> IResult<bool> {
     match value {
         Value::Bool(value) => Ok(value),
@@ -114,6 +160,49 @@ pub(crate) fn get_slice(
     }
 }
 
+/// Interpret the input as a slice, then map each element.
+/// Returns the values in the slice and the original type.
+pub(crate) fn get_slice_map<T>(
+    interner: &NodeInterner,
+    (value, location): (Value, Location),
+    f: impl Fn((Value, Location)) -> IResult<T>,
+) -> IResult<(Vec<T>, Type)> {
+    let (values, typ) = get_slice(interner, (value, location))?;
+    let values = try_vecmap(values, |value| f((value, location)))?;
+    Ok((values, typ))
+}
+
+/// Interpret the input as an array, then map each element.
+/// Returns the values in the array and the original array type.
+pub(crate) fn get_array_map<T>(
+    interner: &NodeInterner,
+    (value, location): (Value, Location),
+    f: impl Fn((Value, Location)) -> IResult<T>,
+) -> IResult<(Vec<T>, Type)> {
+    let (values, typ) = get_array(interner, (value, location))?;
+    let values = try_vecmap(values, |value| f((value, location)))?;
+    Ok((values, typ))
+}
+
+/// Get an array and convert it to a fixed size.
+/// Returns the values in the array and the original array type.
+pub(crate) fn get_fixed_array_map<T, const N: usize>(
+    interner: &NodeInterner,
+    (value, location): (Value, Location),
+    f: impl Fn((Value, Location)) -> IResult<T>,
+) -> IResult<([T; N], Type)> {
+    let (values, typ) = get_array_map(interner, (value, location), f)?;
+
+    values.try_into().map(|v| (v, typ.clone())).map_err(|_| {
+        // Assuming that `values.len()` corresponds to `typ`.
+        let Type::Array(_, ref elem) = typ else {
+            unreachable!("get_array_map checked it was an array")
+        };
+        let expected = Type::Array(Box::new(Type::Constant(N.into(), Kind::u32())), elem.clone());
+        InterpreterError::TypeMismatch { expected, actual: typ, location }
+    })
+}
+
 pub(crate) fn get_str(
     interner: &NodeInterner,
     (value, location): (Value, Location),
@@ -403,27 +492,32 @@ pub(super) fn lex(input: &str) -> Vec<Token> {
     tokens
 }
 
-pub(super) fn parse<T>(
+pub(super) fn parse<'a, T, F>(
     interner: &NodeInterner,
     (value, location): (Value, Location),
-    parser: impl NoirParser<T>,
+    parser: F,
     rule: &'static str,
-) -> IResult<T> {
-    let parser = parser.then_ignore(chumsky::primitive::end());
+) -> IResult<T>
+where
+    F: FnOnce(&mut Parser<'a>) -> T,
+{
     let tokens = get_quoted((value, location))?;
     let quoted = add_token_spans(tokens.clone(), location.span);
     parse_tokens(tokens, quoted, interner, location, parser, rule)
 }
 
-pub(super) fn parse_tokens<T>(
+pub(super) fn parse_tokens<'a, T, F>(
     tokens: Rc<Vec<Token>>,
     quoted: Tokens,
     interner: &NodeInterner,
     location: Location,
-    parser: impl NoirParser<T>,
+    parsing_function: F,
     rule: &'static str,
-) -> IResult<T> {
-    parser.parse(quoted).map_err(|mut errors| {
+) -> IResult<T>
+where
+    F: FnOnce(&mut Parser<'a>) -> T,
+{
+    Parser::for_tokens(quoted).parse_result(parsing_function).map_err(|mut errors| {
         let error = errors.swap_remove(0);
         let tokens = tokens_to_string(tokens, interner);
         InterpreterError::FailedToParseMacro { error, tokens, rule, file: location.file }
@@ -515,3 +609,44 @@ pub(super) fn eq_item<T: Eq>(
     let other_arg = get_item(other_arg)?;
     Ok(Value::Bool(self_arg == other_arg))
 }
+
+/// Type to be used in `Value::Array(<values>, <array-type>)`.
+pub(crate) fn byte_array_type(len: usize) -> Type {
+    Type::Array(
+        Box::new(Type::Constant(len.into(), Kind::u32())),
+        Box::new(Type::Integer(Signedness::Unsigned, IntegerBitSize::Eight)),
+    )
+}
+
+/// Type to be used in `Value::Slice(<values>, <slice-type>)`.
+pub(crate) fn byte_slice_type() -> Type {
+    Type::Slice(Box::new(Type::Integer(Signedness::Unsigned, IntegerBitSize::Eight)))
+}
+
+/// Create a `Value::Array` from bytes.
+pub(crate) fn to_byte_array(values: &[u8]) -> Value {
+    Value::Array(values.iter().copied().map(Value::U8).collect(), byte_array_type(values.len()))
+}
+
+/// Create a `Value::Slice` from bytes.
+pub(crate) fn to_byte_slice(values: &[u8]) -> Value {
+    Value::Slice(values.iter().copied().map(Value::U8).collect(), byte_slice_type())
+}
+
+/// Create a `Value::Array` from fields.
+pub(crate) fn to_field_array(values: &[FieldElement]) -> Value {
+    let typ = Type::Array(
+        Box::new(Type::Constant(values.len().into(), Kind::u32())),
+        Box::new(Type::FieldElement),
+    );
+    Value::Array(values.iter().copied().map(Value::Field).collect(), typ)
+}
+
+/// Create a `Value::Struct` from fields and the expected return type.
+pub(crate) fn to_struct(
+    fields: impl IntoIterator<Item = (&'static str, Value)>,
+    typ: Type,
+) -> Value {
+    let fields = fields.into_iter().map(|(k, v)| (Rc::new(k.to_string()), v)).collect();
+    Value::Struct(fields, typ)
+}
diff --git a/compiler/noirc_frontend/src/hir/comptime/interpreter/foreign.rs b/compiler/noirc_frontend/src/hir/comptime/interpreter/foreign.rs
index 5ae60bb4d00..99cc11ecd2a 100644
--- a/compiler/noirc_frontend/src/hir/comptime/interpreter/foreign.rs
+++ b/compiler/noirc_frontend/src/hir/comptime/interpreter/foreign.rs
@@ -1,49 +1,329 @@
-use acvm::blackbox_solver::BlackBoxFunctionSolver;
-use bn254_blackbox_solver::Bn254BlackBoxSolver;
+use acvm::{
+    acir::BlackBoxFunc,
+    blackbox_solver::{BigIntSolverWithId, BlackBoxFunctionSolver},
+    AcirField, BlackBoxResolutionError, FieldElement,
+};
+use bn254_blackbox_solver::Bn254BlackBoxSolver; // Currently locked to only bn254!
 use im::Vector;
-use iter_extended::try_vecmap;
 use noirc_errors::Location;
 
 use crate::{
-    hir::comptime::{errors::IResult, InterpreterError, Value},
-    macros_api::NodeInterner,
+    hir::comptime::{
+        errors::IResult, interpreter::builtin::builtin_helpers::to_byte_array, InterpreterError,
+        Value,
+    },
+    node_interner::NodeInterner,
+    Type,
 };
 
-use super::builtin::builtin_helpers::{
-    check_one_argument, check_two_arguments, get_array, get_field, get_u32, get_u64,
+use super::{
+    builtin::builtin_helpers::{
+        check_arguments, check_one_argument, check_three_arguments, check_two_arguments,
+        get_array_map, get_bool, get_field, get_fixed_array_map, get_slice_map, get_struct_field,
+        get_struct_fields, get_u32, get_u64, get_u8, to_byte_slice, to_field_array, to_struct,
+    },
+    Interpreter,
 };
 
-pub(super) fn call_foreign(
+impl<'local, 'context> Interpreter<'local, 'context> {
+    pub(super) fn call_foreign(
+        &mut self,
+        name: &str,
+        arguments: Vec<(Value, Location)>,
+        return_type: Type,
+        location: Location,
+    ) -> IResult<Value> {
+        call_foreign(
+            self.elaborator.interner,
+            &mut self.bigint_solver,
+            name,
+            arguments,
+            return_type,
+            location,
+        )
+    }
+}
+
+// Similar to `evaluate_black_box` in `brillig_vm`.
+fn call_foreign(
     interner: &mut NodeInterner,
+    bigint_solver: &mut BigIntSolverWithId,
     name: &str,
-    arguments: Vec<(Value, Location)>,
+    args: Vec<(Value, Location)>,
+    return_type: Type,
     location: Location,
 ) -> IResult<Value> {
+    use BlackBoxFunc::*;
+
     match name {
-        "poseidon2_permutation" => poseidon2_permutation(interner, arguments, location),
-        "keccakf1600" => keccakf1600(interner, arguments, location),
+        "aes128_encrypt" => aes128_encrypt(interner, args, location),
+        "bigint_from_le_bytes" => {
+            bigint_from_le_bytes(interner, bigint_solver, args, return_type, location)
+        }
+        "bigint_to_le_bytes" => bigint_to_le_bytes(bigint_solver, args, location),
+        "bigint_add" => bigint_op(bigint_solver, BigIntAdd, args, return_type, location),
+        "bigint_sub" => bigint_op(bigint_solver, BigIntSub, args, return_type, location),
+        "bigint_mul" => bigint_op(bigint_solver, BigIntMul, args, return_type, location),
+        "bigint_div" => bigint_op(bigint_solver, BigIntDiv, args, return_type, location),
+        "blake2s" => blake_hash(interner, args, location, acvm::blackbox_solver::blake2s),
+        "blake3" => blake_hash(interner, args, location, acvm::blackbox_solver::blake3),
+        "ecdsa_secp256k1" => ecdsa_secp256_verify(
+            interner,
+            args,
+            location,
+            acvm::blackbox_solver::ecdsa_secp256k1_verify,
+        ),
+        "ecdsa_secp256r1" => ecdsa_secp256_verify(
+            interner,
+            args,
+            location,
+            acvm::blackbox_solver::ecdsa_secp256r1_verify,
+        ),
+        "embedded_curve_add" => embedded_curve_add(args, location),
+        "multi_scalar_mul" => multi_scalar_mul(interner, args, location),
+        "poseidon2_permutation" => poseidon2_permutation(interner, args, location),
+        "keccakf1600" => keccakf1600(interner, args, location),
+        "range" => apply_range_constraint(args, location),
+        "sha256_compression" => sha256_compression(interner, args, location),
         _ => {
-            let item = format!("Comptime evaluation for builtin function {name}");
-            Err(InterpreterError::Unimplemented { item, location })
+            let explanation = match name {
+                "and" | "xor" => "It should be turned into a binary operation.".into(),
+                "recursive_aggregation" => "A proof cannot be verified at comptime.".into(),
+                _ => {
+                    let item = format!("Comptime evaluation for foreign function '{name}'");
+                    return Err(InterpreterError::Unimplemented { item, location });
+                }
+            };
+
+            let item = format!("Attempting to evaluate foreign function '{name}'");
+            Err(InterpreterError::InvalidInComptimeContext { item, location, explanation })
         }
     }
 }
 
-// poseidon2_permutation<let N: u32>(_input: [Field; N], _state_length: u32) -> [Field; N]
+/// `pub fn aes128_encrypt<let N: u32>(input: [u8; N], iv: [u8; 16], key: [u8; 16]) -> [u8]`
+fn aes128_encrypt(
+    interner: &mut NodeInterner,
+    arguments: Vec<(Value, Location)>,
+    location: Location,
+) -> IResult<Value> {
+    let (inputs, iv, key) = check_three_arguments(arguments, location)?;
+
+    let (inputs, _) = get_array_map(interner, inputs, get_u8)?;
+    let (iv, _) = get_fixed_array_map(interner, iv, get_u8)?;
+    let (key, _) = get_fixed_array_map(interner, key, get_u8)?;
+
+    let output = acvm::blackbox_solver::aes128_encrypt(&inputs, iv, key)
+        .map_err(|e| InterpreterError::BlackBoxError(e, location))?;
+
+    Ok(to_byte_slice(&output))
+}
+
+fn apply_range_constraint(arguments: Vec<(Value, Location)>, location: Location) -> IResult<Value> {
+    let (value, num_bits) = check_two_arguments(arguments, location)?;
+
+    let input = get_field(value)?;
+    let num_bits = get_u32(num_bits)?;
+
+    if input.num_bits() < num_bits {
+        Ok(Value::Unit)
+    } else {
+        Err(InterpreterError::BlackBoxError(
+            BlackBoxResolutionError::Failed(
+                BlackBoxFunc::RANGE,
+                "value exceeds range check bounds".to_owned(),
+            ),
+            location,
+        ))
+    }
+}
+
+/// `fn from_le_bytes(bytes: [u8], modulus: [u8]) -> BigInt`
+///
+/// Returns the ID of the new bigint allocated by the solver.
+fn bigint_from_le_bytes(
+    interner: &mut NodeInterner,
+    solver: &mut BigIntSolverWithId,
+    arguments: Vec<(Value, Location)>,
+    return_type: Type,
+    location: Location,
+) -> IResult<Value> {
+    let (bytes, modulus) = check_two_arguments(arguments, location)?;
+
+    let (bytes, _) = get_slice_map(interner, bytes, get_u8)?;
+    let (modulus, _) = get_slice_map(interner, modulus, get_u8)?;
+
+    let id = solver
+        .bigint_from_bytes(&bytes, &modulus)
+        .map_err(|e| InterpreterError::BlackBoxError(e, location))?;
+
+    Ok(to_bigint(id, return_type))
+}
+
+/// `fn to_le_bytes(self) -> [u8; 32]`
+///
+/// Take the ID of a bigint and returned its content.
+fn bigint_to_le_bytes(
+    solver: &mut BigIntSolverWithId,
+    arguments: Vec<(Value, Location)>,
+    location: Location,
+) -> IResult<Value> {
+    let int = check_one_argument(arguments, location)?;
+    let id = get_bigint_id(int)?;
+
+    let mut bytes =
+        solver.bigint_to_bytes(id).map_err(|e| InterpreterError::BlackBoxError(e, location))?;
+
+    assert!(bytes.len() <= 32);
+    bytes.resize(32, 0);
+
+    Ok(to_byte_array(&bytes))
+}
+
+/// `fn bigint_add(self, other: BigInt) -> BigInt`
+///
+/// Takes two previous allocated IDs, gets the values from the solver,
+/// stores the result of the operation, returns the new ID.
+fn bigint_op(
+    solver: &mut BigIntSolverWithId,
+    func: BlackBoxFunc,
+    arguments: Vec<(Value, Location)>,
+    return_type: Type,
+    location: Location,
+) -> IResult<Value> {
+    let (lhs, rhs) = check_two_arguments(arguments, location)?;
+
+    let lhs = get_bigint_id(lhs)?;
+    let rhs = get_bigint_id(rhs)?;
+
+    let id = solver
+        .bigint_op(lhs, rhs, func)
+        .map_err(|e| InterpreterError::BlackBoxError(e, location))?;
+
+    Ok(to_bigint(id, return_type))
+}
+
+/// Run one of the Blake hash functions.
+/// ```text
+/// pub fn blake2s<let N: u32>(input: [u8; N]) -> [u8; 32]
+/// pub fn blake3<let N: u32>(input: [u8; N]) -> [u8; 32]
+/// ```
+fn blake_hash(
+    interner: &mut NodeInterner,
+    arguments: Vec<(Value, Location)>,
+    location: Location,
+    f: impl Fn(&[u8]) -> Result<[u8; 32], BlackBoxResolutionError>,
+) -> IResult<Value> {
+    let inputs = check_one_argument(arguments, location)?;
+
+    let (inputs, _) = get_array_map(interner, inputs, get_u8)?;
+    let output = f(&inputs).map_err(|e| InterpreterError::BlackBoxError(e, location))?;
+
+    Ok(to_byte_array(&output))
+}
+
+/// Run one of the Secp256 signature verifications.
+/// ```text
+/// pub fn verify_signature<let N: u32>(
+///   public_key_x: [u8; 32],
+///   public_key_y: [u8; 32],
+///   signature: [u8; 64],
+///   message_hash: [u8; N],
+/// ) -> bool
+
+/// pub fn verify_signature_slice(
+///   public_key_x: [u8; 32],
+///   public_key_y: [u8; 32],
+///   signature: [u8; 64],
+///   message_hash: [u8],
+/// ) -> bool
+/// ```
+fn ecdsa_secp256_verify(
+    interner: &mut NodeInterner,
+    arguments: Vec<(Value, Location)>,
+    location: Location,
+    f: impl Fn(&[u8], &[u8; 32], &[u8; 32], &[u8; 64]) -> Result<bool, BlackBoxResolutionError>,
+) -> IResult<Value> {
+    let [pub_key_x, pub_key_y, sig, msg_hash] = check_arguments(arguments, location)?;
+
+    let (pub_key_x, _) = get_fixed_array_map(interner, pub_key_x, get_u8)?;
+    let (pub_key_y, _) = get_fixed_array_map(interner, pub_key_y, get_u8)?;
+    let (sig, _) = get_fixed_array_map(interner, sig, get_u8)?;
+
+    // Hash can be an array or slice.
+    let (msg_hash, _) = if matches!(msg_hash.0.get_type().as_ref(), Type::Array(_, _)) {
+        get_array_map(interner, msg_hash.clone(), get_u8)?
+    } else {
+        get_slice_map(interner, msg_hash, get_u8)?
+    };
+
+    let is_valid = f(&msg_hash, &pub_key_x, &pub_key_y, &sig)
+        .map_err(|e| InterpreterError::BlackBoxError(e, location))?;
+
+    Ok(Value::Bool(is_valid))
+}
+
+/// ```text
+/// fn embedded_curve_add(
+///     point1: EmbeddedCurvePoint,
+///     point2: EmbeddedCurvePoint,
+/// ) -> [Field; 3]
+/// ```
+fn embedded_curve_add(arguments: Vec<(Value, Location)>, location: Location) -> IResult<Value> {
+    let (point1, point2) = check_two_arguments(arguments, location)?;
+
+    let (p1x, p1y, p1inf) = get_embedded_curve_point(point1)?;
+    let (p2x, p2y, p2inf) = get_embedded_curve_point(point2)?;
+
+    let (x, y, inf) = Bn254BlackBoxSolver
+        .ec_add(&p1x, &p1y, &p1inf.into(), &p2x, &p2y, &p2inf.into())
+        .map_err(|e| InterpreterError::BlackBoxError(e, location))?;
+
+    Ok(to_field_array(&[x, y, inf]))
+}
+
+/// ```text
+/// pub fn multi_scalar_mul<let N: u32>(
+///     points: [EmbeddedCurvePoint; N],
+///     scalars: [EmbeddedCurveScalar; N],
+/// ) -> [Field; 3]
+/// ```
+fn multi_scalar_mul(
+    interner: &mut NodeInterner,
+    arguments: Vec<(Value, Location)>,
+    location: Location,
+) -> IResult<Value> {
+    let (points, scalars) = check_two_arguments(arguments, location)?;
+
+    let (points, _) = get_array_map(interner, points, get_embedded_curve_point)?;
+    let (scalars, _) = get_array_map(interner, scalars, get_embedded_curve_scalar)?;
+
+    let points: Vec<_> = points.into_iter().flat_map(|(x, y, inf)| [x, y, inf.into()]).collect();
+    let mut scalars_lo = Vec::new();
+    let mut scalars_hi = Vec::new();
+    for (lo, hi) in scalars {
+        scalars_lo.push(lo);
+        scalars_hi.push(hi);
+    }
+
+    let (x, y, inf) = Bn254BlackBoxSolver
+        .multi_scalar_mul(&points, &scalars_lo, &scalars_hi)
+        .map_err(|e| InterpreterError::BlackBoxError(e, location))?;
+
+    Ok(to_field_array(&[x, y, inf]))
+}
+
+/// `poseidon2_permutation<let N: u32>(_input: [Field; N], _state_length: u32) -> [Field; N]`
 fn poseidon2_permutation(
     interner: &mut NodeInterner,
     arguments: Vec<(Value, Location)>,
     location: Location,
 ) -> IResult<Value> {
     let (input, state_length) = check_two_arguments(arguments, location)?;
-    let input_location = input.1;
 
-    let (input, typ) = get_array(interner, input)?;
+    let (input, typ) = get_array_map(interner, input, get_field)?;
     let state_length = get_u32(state_length)?;
 
-    let input = try_vecmap(input, |integer| get_field((integer, input_location)))?;
-
-    // Currently locked to only bn254!
     let fields = Bn254BlackBoxSolver
         .poseidon2_permutation(&input, state_length)
         .map_err(|error| InterpreterError::BlackBoxError(error, location))?;
@@ -52,25 +332,135 @@ fn poseidon2_permutation(
     Ok(Value::Array(array, typ))
 }
 
+/// `fn keccakf1600(input: [u64; 25]) -> [u64; 25] {}`
 fn keccakf1600(
     interner: &mut NodeInterner,
     arguments: Vec<(Value, Location)>,
     location: Location,
 ) -> IResult<Value> {
     let input = check_one_argument(arguments, location)?;
-    let input_location = input.1;
-
-    let (input, typ) = get_array(interner, input)?;
 
-    let input = try_vecmap(input, |integer| get_u64((integer, input_location)))?;
+    let (state, typ) = get_fixed_array_map(interner, input, get_u64)?;
 
-    let mut state = [0u64; 25];
-    for (it, input_value) in state.iter_mut().zip(input.iter()) {
-        *it = *input_value;
-    }
     let result_lanes = acvm::blackbox_solver::keccakf1600(state)
         .map_err(|error| InterpreterError::BlackBoxError(error, location))?;
 
     let array: Vector<Value> = result_lanes.into_iter().map(Value::U64).collect();
     Ok(Value::Array(array, typ))
 }
+
+/// `pub fn sha256_compression(input: [u32; 16], state: [u32; 8]) -> [u32; 8]`
+fn sha256_compression(
+    interner: &mut NodeInterner,
+    arguments: Vec<(Value, Location)>,
+    location: Location,
+) -> IResult<Value> {
+    let (input, state) = check_two_arguments(arguments, location)?;
+
+    let (input, _) = get_fixed_array_map(interner, input, get_u32)?;
+    let (mut state, typ) = get_fixed_array_map(interner, state, get_u32)?;
+
+    acvm::blackbox_solver::sha256_compression(&mut state, &input);
+
+    let state = state.into_iter().map(Value::U32).collect();
+    Ok(Value::Array(state, typ))
+}
+
+/// Decode a `BigInt` struct.
+///
+/// Returns the ID of the value in the solver.
+fn get_bigint_id((value, location): (Value, Location)) -> IResult<u32> {
+    let (fields, typ) = get_struct_fields("BigInt", (value, location))?;
+    let p = get_struct_field("pointer", &fields, &typ, location, get_u32)?;
+    let m = get_struct_field("modulus", &fields, &typ, location, get_u32)?;
+    assert_eq!(p, m, "`pointer` and `modulus` are expected to be the same");
+    Ok(p)
+}
+
+/// Decode an `EmbeddedCurvePoint` struct.
+///
+/// Returns `(x, y, is_infinite)`.
+fn get_embedded_curve_point(
+    (value, location): (Value, Location),
+) -> IResult<(FieldElement, FieldElement, bool)> {
+    let (fields, typ) = get_struct_fields("EmbeddedCurvePoint", (value, location))?;
+    let x = get_struct_field("x", &fields, &typ, location, get_field)?;
+    let y = get_struct_field("y", &fields, &typ, location, get_field)?;
+    let is_infinite = get_struct_field("is_infinite", &fields, &typ, location, get_bool)?;
+    Ok((x, y, is_infinite))
+}
+
+/// Decode an `EmbeddedCurveScalar` struct.
+///
+/// Returns `(lo, hi)`.
+fn get_embedded_curve_scalar(
+    (value, location): (Value, Location),
+) -> IResult<(FieldElement, FieldElement)> {
+    let (fields, typ) = get_struct_fields("EmbeddedCurveScalar", (value, location))?;
+    let lo = get_struct_field("lo", &fields, &typ, location, get_field)?;
+    let hi = get_struct_field("hi", &fields, &typ, location, get_field)?;
+    Ok((lo, hi))
+}
+
+fn to_bigint(id: u32, typ: Type) -> Value {
+    to_struct([("pointer", Value::U32(id)), ("modulus", Value::U32(id))], typ)
+}
+
+#[cfg(test)]
+mod tests {
+    use acvm::acir::BlackBoxFunc;
+    use noirc_errors::Location;
+    use strum::IntoEnumIterator;
+
+    use crate::hir::comptime::tests::with_interpreter;
+    use crate::hir::comptime::InterpreterError::{
+        ArgumentCountMismatch, InvalidInComptimeContext, Unimplemented,
+    };
+    use crate::Type;
+
+    use super::call_foreign;
+
+    /// Check that all `BlackBoxFunc` are covered by `call_foreign`.
+    #[test]
+    fn test_blackbox_implemented() {
+        let dummy = "
+        comptime fn main() -> pub u8 {
+            0
+        }
+        ";
+
+        let not_implemented = with_interpreter(dummy, |interpreter, _, _| {
+            let no_location = Location::dummy();
+            let mut not_implemented = Vec::new();
+
+            for blackbox in BlackBoxFunc::iter() {
+                let name = blackbox.name();
+                match call_foreign(
+                    interpreter.elaborator.interner,
+                    &mut interpreter.bigint_solver,
+                    name,
+                    Vec::new(),
+                    Type::Unit,
+                    no_location,
+                ) {
+                    Ok(_) => {
+                        // Exists and works with no args (unlikely)
+                    }
+                    Err(ArgumentCountMismatch { .. }) => {
+                        // Exists but doesn't work with no args (expected)
+                    }
+                    Err(InvalidInComptimeContext { .. }) => {}
+                    Err(Unimplemented { .. }) => not_implemented.push(name),
+                    Err(other) => panic!("unexpected error: {other:?}"),
+                };
+            }
+
+            not_implemented
+        });
+
+        assert!(
+            not_implemented.is_empty(),
+            "unimplemented blackbox functions: {not_implemented:?}"
+        );
+    }
+}
diff --git a/compiler/noirc_frontend/src/hir/comptime/tests.rs b/compiler/noirc_frontend/src/hir/comptime/tests.rs
index 5b03b27e0b2..2d3bf928917 100644
--- a/compiler/noirc_frontend/src/hir/comptime/tests.rs
+++ b/compiler/noirc_frontend/src/hir/comptime/tests.rs
@@ -9,14 +9,20 @@ use noirc_errors::Location;
 
 use super::errors::InterpreterError;
 use super::value::Value;
+use super::Interpreter;
 use crate::elaborator::Elaborator;
-use crate::hir::def_collector::dc_crate::DefCollector;
+use crate::hir::def_collector::dc_crate::{CompilationError, DefCollector};
 use crate::hir::def_collector::dc_mod::collect_defs;
 use crate::hir::def_map::{CrateDefMap, LocalModuleId, ModuleData};
 use crate::hir::{Context, ParsedFiles};
-use crate::parser::parse_program;
-
-fn interpret_helper(src: &str) -> Result<Value, InterpreterError> {
+use crate::node_interner::FuncId;
+use crate::parse_program;
+
+/// Create an interpreter for a code snippet and pass it to a test function.
+pub(crate) fn with_interpreter<T>(
+    src: &str,
+    f: impl FnOnce(&mut Interpreter, FuncId, &[(CompilationError, FileId)]) -> T,
+) -> T {
     let file = FileId::default();
 
     // Can't use Index::test_new here for some reason, even with #[cfg(test)].
@@ -28,7 +34,8 @@ fn interpret_helper(src: &str) -> Result<Value, InterpreterError> {
         location,
         Vec::new(),
         Vec::new(),
-        false,
+        false, // is contract
+        false, // is struct
     )));
     assert_eq!(root, module_id);
 
@@ -50,14 +57,24 @@ fn interpret_helper(src: &str) -> Result<Value, InterpreterError> {
     context.def_maps.insert(krate, collector.def_map);
 
     let main = context.get_main_function(&krate).expect("Expected 'main' function");
+
     let mut elaborator =
         Elaborator::elaborate_and_return_self(&mut context, krate, collector.items, None);
-    assert_eq!(elaborator.errors.len(), 0);
+
+    let errors = elaborator.errors.clone();
 
     let mut interpreter = elaborator.setup_interpreter();
 
-    let no_location = Location::dummy();
-    interpreter.call_function(main, Vec::new(), HashMap::new(), no_location)
+    f(&mut interpreter, main, &errors)
+}
+
+/// Evaluate a code snippet by calling the `main` function.
+fn interpret_helper(src: &str) -> Result<Value, InterpreterError> {
+    with_interpreter(src, |interpreter, main, errors| {
+        assert_eq!(errors.len(), 0);
+        let no_location = Location::dummy();
+        interpreter.call_function(main, Vec::new(), HashMap::new(), no_location)
+    })
 }
 
 fn interpret(src: &str) -> Value {
@@ -77,6 +94,23 @@ fn interpreter_works() {
     assert_eq!(result, Value::Field(3u128.into()));
 }
 
+#[test]
+fn interpreter_type_checking_works() {
+    let program = "comptime fn main() -> pub u8 { 3 }";
+    let result = interpret(program);
+    assert_eq!(result, Value::U8(3u8));
+}
+
+#[test]
+fn let_statement_works() {
+    let program = "comptime fn main() -> pub i8 {
+        let x = 4;
+        x
+    }";
+    let result = interpret(program);
+    assert_eq!(result, Value::I8(4));
+}
+
 #[test]
 fn mutation_works() {
     let program = "comptime fn main() -> pub i8 {
@@ -160,6 +194,19 @@ fn for_loop() {
     assert_eq!(result, Value::U8(15));
 }
 
+#[test]
+fn for_loop_inclusive() {
+    let program = "comptime fn main() -> pub u8 {
+        let mut x = 0;
+        for i in 0 ..= 6 {
+            x += i;
+        }
+        x
+    }";
+    let result = interpret(program);
+    assert_eq!(result, Value::U8(21));
+}
+
 #[test]
 fn for_loop_u16() {
     let program = "comptime fn main() -> pub u16 {
@@ -263,5 +310,5 @@ fn generic_functions() {
     }
     ";
     let result = interpret(program);
-    assert!(matches!(result, Value::U8(2)));
+    assert_eq!(result, Value::U8(2));
 }
diff --git a/compiler/noirc_frontend/src/hir/comptime/value.rs b/compiler/noirc_frontend/src/hir/comptime/value.rs
index f01e188e498..945fb45026d 100644
--- a/compiler/noirc_frontend/src/hir/comptime/value.rs
+++ b/compiler/noirc_frontend/src/hir/comptime/value.rs
@@ -1,7 +1,6 @@
 use std::{borrow::Cow, rc::Rc, vec};
 
 use acvm::{AcirField, FieldElement};
-use chumsky::Parser;
 use im::Vector;
 use iter_extended::{try_vecmap, vecmap};
 use noirc_errors::{Location, Span};
@@ -9,17 +8,17 @@ use strum_macros::Display;
 
 use crate::{
     ast::{
-        ArrayLiteral, BlockExpression, ConstructorExpression, Ident, IntegerBitSize, LValue,
-        Pattern, Signedness, Statement, StatementKind, UnresolvedType, UnresolvedTypeData,
+        ArrayLiteral, BlockExpression, ConstructorExpression, Expression, ExpressionKind, Ident,
+        IntegerBitSize, LValue, Literal, Path, Pattern, Signedness, Statement, StatementKind,
+        UnresolvedType, UnresolvedTypeData,
     },
     hir::{def_map::ModuleId, type_check::generics::TraitGenerics},
-    hir_def::expr::{HirArrayLiteral, HirConstructorExpression, HirIdent, HirLambda, ImplKind},
-    macros_api::{
-        Expression, ExpressionKind, HirExpression, HirLiteral, Literal, NodeInterner, Path,
-        StructId,
+    hir_def::expr::{
+        HirArrayLiteral, HirConstructorExpression, HirExpression, HirIdent, HirLambda, HirLiteral,
+        ImplKind,
     },
-    node_interner::{ExprId, FuncId, StmtId, TraitId, TraitImplId},
-    parser::{self, NoirParser, TopLevelStatement},
+    node_interner::{ExprId, FuncId, NodeInterner, StmtId, StructId, TraitId, TraitImplId},
+    parser::{Item, Parser},
     token::{SpannedToken, Token, Tokens},
     Kind, QuotedType, Shared, Type, TypeBindings,
 };
@@ -121,7 +120,7 @@ impl Value {
             Value::U32(_) => Type::Integer(Signedness::Unsigned, IntegerBitSize::ThirtyTwo),
             Value::U64(_) => Type::Integer(Signedness::Unsigned, IntegerBitSize::SixtyFour),
             Value::String(value) => {
-                let length = Type::Constant(value.len() as u32, Kind::u32());
+                let length = Type::Constant(value.len().into(), Kind::u32());
                 Type::String(Box::new(length))
             }
             Value::FormatString(_, typ) => return Cow::Borrowed(typ),
@@ -261,7 +260,8 @@ impl Value {
                 tokens_to_parse.0.insert(0, SpannedToken::new(Token::LeftBrace, location.span));
                 tokens_to_parse.0.push(SpannedToken::new(Token::RightBrace, location.span));
 
-                return match parser::expression().parse(tokens_to_parse) {
+                let parser = Parser::for_tokens(tokens_to_parse);
+                return match parser.parse_result(Parser::parse_expression_or_error) {
                     Ok(expr) => Ok(expr),
                     Err(mut errors) => {
                         let error = errors.swap_remove(0);
@@ -523,8 +523,8 @@ impl Value {
         self,
         location: Location,
         interner: &NodeInterner,
-    ) -> IResult<Vec<TopLevelStatement>> {
-        let parser = parser::top_level_items();
+    ) -> IResult<Vec<Item>> {
+        let parser = Parser::parse_top_level_items;
         match self {
             Value::Quoted(tokens) => {
                 parse_tokens(tokens, interner, parser, location, "top-level item")
@@ -543,15 +543,18 @@ pub(crate) fn unwrap_rc<T: Clone>(rc: Rc<T>) -> T {
     Rc::try_unwrap(rc).unwrap_or_else(|rc| (*rc).clone())
 }
 
-fn parse_tokens<T>(
+fn parse_tokens<'a, T, F>(
     tokens: Rc<Vec<Token>>,
     interner: &NodeInterner,
-    parser: impl NoirParser<T>,
+    parsing_function: F,
     location: Location,
     rule: &'static str,
-) -> IResult<T> {
-    let parser = parser.then_ignore(chumsky::primitive::end());
-    match parser.parse(add_token_spans(tokens.clone(), location.span)) {
+) -> IResult<T>
+where
+    F: FnOnce(&mut Parser<'a>) -> T,
+{
+    let parser = Parser::for_tokens(add_token_spans(tokens.clone(), location.span));
+    match parser.parse_result(parsing_function) {
         Ok(expr) => Ok(expr),
         Err(mut errors) => {
             let error = errors.swap_remove(0);
diff --git a/compiler/noirc_frontend/src/hir/def_collector/dc_crate.rs b/compiler/noirc_frontend/src/hir/def_collector/dc_crate.rs
index faf72e86fb4..33dab802b21 100644
--- a/compiler/noirc_frontend/src/hir/def_collector/dc_crate.rs
+++ b/compiler/noirc_frontend/src/hir/def_collector/dc_crate.rs
@@ -5,16 +5,16 @@ use crate::graph::CrateId;
 use crate::hir::comptime::InterpreterError;
 use crate::hir::def_map::{CrateDefMap, LocalModuleId, ModuleId};
 use crate::hir::resolution::errors::ResolverError;
-use crate::hir::resolution::path_resolver;
 use crate::hir::type_check::TypeCheckError;
+use crate::locations::ReferencesTracker;
 use crate::token::SecondaryAttribute;
 use crate::usage_tracker::UnusedItem;
 use crate::{Generics, Type};
 
-use crate::hir::resolution::import::{resolve_import, ImportDirective, PathResolution};
+use crate::hir::resolution::import::{resolve_import, ImportDirective};
 use crate::hir::Context;
 
-use crate::macros_api::Expression;
+use crate::ast::Expression;
 use crate::node_interner::{
     FuncId, GlobalId, ModuleAttributes, NodeInterner, ReferenceId, StructId, TraitId, TraitImplId,
     TypeAliasId,
@@ -23,7 +23,7 @@ use crate::node_interner::{
 use crate::ast::{
     ExpressionKind, GenericTypeArgs, Ident, ItemVisibility, LetStatement, Literal, NoirFunction,
     NoirStruct, NoirTrait, NoirTypeAlias, Path, PathKind, PathSegment, UnresolvedGenerics,
-    UnresolvedTraitConstraint, UnresolvedType,
+    UnresolvedTraitConstraint, UnresolvedType, UnsupportedNumericGenericType,
 };
 
 use crate::parser::{ParserError, SortedModule};
@@ -111,6 +111,7 @@ pub struct UnresolvedGlobal {
     pub module_id: LocalModuleId,
     pub global_id: GlobalId,
     pub stmt_def: LetStatement,
+    pub visibility: ItemVisibility,
 }
 
 pub struct ModuleAttribute {
@@ -118,9 +119,11 @@ pub struct ModuleAttribute {
     pub file_id: FileId,
     // The module this attribute is attached to
     pub module_id: LocalModuleId,
+
     // The file where the attribute exists (it could be the same as `file_id`
-    // or a different one if it's an inner attribute in a different file)
+    // or a different one if it is an outer attribute in the parent of the module it applies to)
     pub attribute_file_id: FileId,
+
     // The module where the attribute is defined (similar to `attribute_file_id`,
     // it could be different than `module_id` for inner attributes)
     pub attribute_module_id: LocalModuleId,
@@ -231,12 +234,19 @@ impl From<ResolverError> for CompilationError {
         CompilationError::ResolverError(value)
     }
 }
+
 impl From<TypeCheckError> for CompilationError {
     fn from(value: TypeCheckError) -> Self {
         CompilationError::TypeError(value)
     }
 }
 
+impl From<UnsupportedNumericGenericType> for CompilationError {
+    fn from(value: UnsupportedNumericGenericType) -> Self {
+        Self::ResolverError(value.into())
+    }
+}
+
 impl DefCollector {
     pub fn new(def_map: CrateDefMap) -> DefCollector {
         DefCollector {
@@ -295,7 +305,12 @@ impl DefCollector {
             def_map.extern_prelude.insert(dep.as_name(), module_id);
 
             let location = dep_def_map[dep_def_root].location;
-            let attributes = ModuleAttributes { name: dep.as_name(), location, parent: None };
+            let attributes = ModuleAttributes {
+                name: dep.as_name(),
+                location,
+                parent: None,
+                visibility: ItemVisibility::Public,
+            };
             context.def_interner.add_module_attributes(module_id, attributes);
         }
 
@@ -334,47 +349,26 @@ impl DefCollector {
 
         // Resolve unresolved imports collected from the crate, one by one.
         for collected_import in std::mem::take(&mut def_collector.imports) {
-            let module_id = collected_import.module_id;
-            let resolved_import = if context.def_interner.lsp_mode {
-                let mut references: Vec<ReferenceId> = Vec::new();
-                let resolved_import = resolve_import(
-                    crate_id,
-                    &collected_import,
-                    &context.def_maps,
-                    &mut context.def_interner.usage_tracker,
-                    &mut Some(&mut references),
-                );
-
-                let current_def_map = context.def_maps.get(&crate_id).unwrap();
-                let file_id = current_def_map.file_id(module_id);
-
-                for (referenced, segment) in references.iter().zip(&collected_import.path.segments)
-                {
-                    context.def_interner.add_reference(
-                        *referenced,
-                        Location::new(segment.ident.span(), file_id),
-                        false,
-                    );
-                }
+            let local_module_id = collected_import.module_id;
+            let module_id = ModuleId { krate: crate_id, local_id: local_module_id };
+            let current_def_map = context.def_maps.get(&crate_id).unwrap();
+            let file_id = current_def_map.file_id(local_module_id);
+
+            let resolved_import = resolve_import(
+                collected_import.path.clone(),
+                module_id,
+                &context.def_maps,
+                &mut context.usage_tracker,
+                Some(ReferencesTracker::new(&mut context.def_interner, file_id)),
+            );
 
-                resolved_import
-            } else {
-                resolve_import(
-                    crate_id,
-                    &collected_import,
-                    &context.def_maps,
-                    &mut context.def_interner.usage_tracker,
-                    &mut None,
-                )
-            };
             match resolved_import {
                 Ok(resolved_import) => {
                     let current_def_map = context.def_maps.get_mut(&crate_id).unwrap();
-                    let file_id = current_def_map.file_id(module_id);
-
-                    let has_path_resolution_error = resolved_import.error.is_some();
+                    let file_id = current_def_map.file_id(local_module_id);
 
-                    if let Some(error) = resolved_import.error {
+                    let has_path_resolution_error = !resolved_import.errors.is_empty();
+                    for error in resolved_import.errors {
                         errors.push((
                             DefCollectorErrorKind::PathResolutionError(error).into(),
                             file_id,
@@ -382,11 +376,11 @@ impl DefCollector {
                     }
 
                     // Populate module namespaces according to the imports used
-                    let name = resolved_import.name;
+                    let name = collected_import.name();
                     let visibility = collected_import.visibility;
-                    let is_prelude = resolved_import.is_prelude;
+                    let is_prelude = collected_import.is_prelude;
                     for (module_def_id, item_visibility, _) in
-                        resolved_import.resolved_namespace.iter_items()
+                        resolved_import.namespace.iter_items()
                     {
                         if item_visibility < visibility {
                             errors.push((
@@ -400,25 +394,26 @@ impl DefCollector {
                         }
                         let visibility = visibility.min(item_visibility);
 
-                        let result = current_def_map.modules[resolved_import.module_scope.0]
-                            .import(name.clone(), visibility, module_def_id, is_prelude);
+                        let result = current_def_map.modules[local_module_id.0].import(
+                            name.clone(),
+                            visibility,
+                            module_def_id,
+                            is_prelude,
+                        );
 
                         // If we error on path resolution don't also say it's unused (in case it ends up being unused)
                         if !has_path_resolution_error {
-                            let module_id = ModuleId {
-                                krate: crate_id,
-                                local_id: resolved_import.module_scope,
-                            };
-                            context.def_interner.usage_tracker.add_unused_item(
-                                module_id,
+                            let defining_module =
+                                ModuleId { krate: crate_id, local_id: local_module_id };
+
+                            context.usage_tracker.add_unused_item(
+                                defining_module,
                                 name.clone(),
                                 UnusedItem::Import,
                                 visibility,
                             );
 
                             if visibility != ItemVisibility::Private {
-                                let local_id = resolved_import.module_scope;
-                                let defining_module = ModuleId { krate: crate_id, local_id };
                                 context.def_interner.register_name_for_auto_import(
                                     name.to_string(),
                                     module_def_id,
@@ -428,14 +423,6 @@ impl DefCollector {
                             }
                         }
 
-                        let last_segment = collected_import.path.last_ident();
-
-                        add_import_reference(
-                            module_def_id,
-                            &last_segment,
-                            &mut context.def_interner,
-                            file_id,
-                        );
                         if let Some(ref alias) = collected_import.alias {
                             add_import_reference(
                                 module_def_id,
@@ -489,7 +476,7 @@ impl DefCollector {
         crate_id: CrateId,
         errors: &mut Vec<(CompilationError, FileId)>,
     ) {
-        let unused_imports = context.def_interner.unused_items().iter();
+        let unused_imports = context.usage_tracker.unused_items().iter();
         let unused_imports = unused_imports.filter(|(module_id, _)| module_id.krate == crate_id);
 
         errors.extend(unused_imports.flat_map(|(module_id, usage_tracker)| {
@@ -507,7 +494,7 @@ impl DefCollector {
 }
 
 fn add_import_reference(
-    def_id: crate::macros_api::ModuleDefId,
+    def_id: crate::hir::def_map::ModuleDefId,
     name: &Ident,
     interner: &mut NodeInterner,
     file_id: FileId,
@@ -544,14 +531,17 @@ fn inject_prelude(
             span: Span::default(),
         };
 
-        if let Ok(PathResolution { module_def_id, error }) = path_resolver::resolve_path(
-            &context.def_maps,
-            ModuleId { krate: crate_id, local_id: crate_root },
+        if let Ok(resolved_import) = resolve_import(
             path,
-            &mut context.def_interner.usage_tracker,
-            &mut None,
+            ModuleId { krate: crate_id, local_id: crate_root },
+            &context.def_maps,
+            &mut context.usage_tracker,
+            None, // references tracker
         ) {
-            assert!(error.is_none(), "Tried to add private item to prelude");
+            assert!(resolved_import.errors.is_empty(), "Tried to add private item to prelude");
+
+            let (module_def_id, _, _) =
+                resolved_import.namespace.types.expect("couldn't resolve std::prelude");
             let module_id = module_def_id.as_module().expect("std::prelude should be a module");
             let prelude = context.module(module_id).scope().names();
 
diff --git a/compiler/noirc_frontend/src/hir/def_collector/dc_mod.rs b/compiler/noirc_frontend/src/hir/def_collector/dc_mod.rs
index b530e023152..e7953aab5a4 100644
--- a/compiler/noirc_frontend/src/hir/def_collector/dc_mod.rs
+++ b/compiler/noirc_frontend/src/hir/def_collector/dc_mod.rs
@@ -11,15 +11,14 @@ use num_traits::Num;
 use rustc_hash::FxHashMap as HashMap;
 
 use crate::ast::{
-    Documented, FunctionDefinition, Ident, ItemVisibility, LetStatement, ModuleDeclaration,
-    NoirFunction, NoirStruct, NoirTrait, NoirTraitImpl, NoirTypeAlias, Pattern, TraitImplItemKind,
-    TraitItem, TypeImpl,
+    Documented, Expression, FunctionDefinition, Ident, ItemVisibility, LetStatement,
+    ModuleDeclaration, NoirFunction, NoirStruct, NoirTrait, NoirTraitImpl, NoirTypeAlias, Pattern,
+    TraitImplItemKind, TraitItem, TypeImpl, UnresolvedType, UnresolvedTypeData,
 };
 use crate::hir::resolution::errors::ResolverError;
-use crate::macros_api::{Expression, NodeInterner, StructId, UnresolvedType, UnresolvedTypeData};
-use crate::node_interner::{ModuleAttributes, ReferenceId};
+use crate::node_interner::{ModuleAttributes, NodeInterner, ReferenceId, StructId};
 use crate::token::SecondaryAttribute;
-use crate::usage_tracker::UnusedItem;
+use crate::usage_tracker::{UnusedItem, UsageTracker};
 use crate::{
     graph::CrateId,
     hir::def_collector::dc_crate::{UnresolvedStruct, UnresolvedTrait},
@@ -98,9 +97,9 @@ pub fn collect_defs(
 
     errors.extend(collector.collect_functions(context, ast.functions, crate_id));
 
-    collector.collect_trait_impls(context, ast.trait_impls, crate_id);
+    errors.extend(collector.collect_trait_impls(context, ast.trait_impls, crate_id));
 
-    collector.collect_impls(context, ast.impls, crate_id);
+    errors.extend(collector.collect_impls(context, ast.impls, crate_id));
 
     collector.collect_attributes(
         ast.inner_attributes,
@@ -147,6 +146,7 @@ impl<'a> ModCollector<'a> {
             let (global, error) = collect_global(
                 &mut context.def_interner,
                 &mut self.def_collector.def_map,
+                &mut context.usage_tracker,
                 global,
                 visibility,
                 self.file_id,
@@ -163,7 +163,13 @@ impl<'a> ModCollector<'a> {
         errors
     }
 
-    fn collect_impls(&mut self, context: &mut Context, impls: Vec<TypeImpl>, krate: CrateId) {
+    fn collect_impls(
+        &mut self,
+        context: &mut Context,
+        impls: Vec<TypeImpl>,
+        krate: CrateId,
+    ) -> Vec<(CompilationError, FileId)> {
+        let mut errors = Vec::new();
         let module_id = ModuleId { krate, local_id: self.module_id };
 
         for r#impl in impls {
@@ -173,8 +179,11 @@ impl<'a> ModCollector<'a> {
                 r#impl,
                 self.file_id,
                 module_id,
+                &mut errors,
             );
         }
+
+        errors
     }
 
     fn collect_trait_impls(
@@ -182,7 +191,9 @@ impl<'a> ModCollector<'a> {
         context: &mut Context,
         impls: Vec<NoirTraitImpl>,
         krate: CrateId,
-    ) {
+    ) -> Vec<(CompilationError, FileId)> {
+        let mut errors = Vec::new();
+
         for mut trait_impl in impls {
             let trait_name = trait_impl.trait_name.clone();
 
@@ -198,6 +209,20 @@ impl<'a> ModCollector<'a> {
             let module = ModuleId { krate, local_id: self.module_id };
 
             for (_, func_id, noir_function) in &mut unresolved_functions.functions {
+                if noir_function.def.attributes.is_test_function() {
+                    let error = DefCollectorErrorKind::TestOnAssociatedFunction {
+                        span: noir_function.name_ident().span(),
+                    };
+                    errors.push((error.into(), self.file_id));
+                }
+
+                if noir_function.def.attributes.has_export() {
+                    let error = DefCollectorErrorKind::ExportOnAssociatedFunction {
+                        span: noir_function.name_ident().span(),
+                    };
+                    errors.push((error.into(), self.file_id));
+                }
+
                 let location = Location::new(noir_function.def.span, self.file_id);
                 context.def_interner.push_function(*func_id, &noir_function.def, module, location);
             }
@@ -224,6 +249,8 @@ impl<'a> ModCollector<'a> {
 
             self.def_collector.items.trait_impls.push(unresolved_trait_impl);
         }
+
+        errors
     }
 
     fn collect_functions(
@@ -246,6 +273,7 @@ impl<'a> ModCollector<'a> {
             let Some(func_id) = collect_function(
                 &mut context.def_interner,
                 &mut self.def_collector.def_map,
+                &mut context.usage_tracker,
                 &function.item,
                 module,
                 self.file_id,
@@ -282,6 +310,7 @@ impl<'a> ModCollector<'a> {
             if let Some((id, the_struct)) = collect_struct(
                 &mut context.def_interner,
                 &mut self.def_collector.def_map,
+                &mut context.usage_tracker,
                 struct_definition,
                 self.file_id,
                 self.module_id,
@@ -336,7 +365,7 @@ impl<'a> ModCollector<'a> {
             );
 
             let parent_module_id = ModuleId { krate, local_id: self.module_id };
-            context.def_interner.usage_tracker.add_unused_item(
+            context.usage_tracker.add_unused_item(
                 parent_module_id,
                 name.clone(),
                 UnusedItem::TypeAlias(type_alias_id),
@@ -357,7 +386,12 @@ impl<'a> ModCollector<'a> {
             if context.def_interner.is_in_lsp_mode() {
                 let parent_module_id = ModuleId { krate, local_id: self.module_id };
                 let name = name.to_string();
-                context.def_interner.register_type_alias(type_alias_id, name, parent_module_id);
+                context.def_interner.register_type_alias(
+                    type_alias_id,
+                    name,
+                    visibility,
+                    parent_module_id,
+                );
             }
         }
         errors
@@ -386,7 +420,8 @@ impl<'a> ModCollector<'a> {
                 Vec::new(),
                 Vec::new(),
                 false,
-                false,
+                false, // is contract
+                false, // is struct
             ) {
                 Ok(module_id) => TraitId(ModuleId { krate, local_id: module_id.local_id }),
                 Err(error) => {
@@ -406,7 +441,7 @@ impl<'a> ModCollector<'a> {
             );
 
             let parent_module_id = ModuleId { krate, local_id: self.module_id };
-            context.def_interner.usage_tracker.add_unused_item(
+            context.usage_tracker.add_unused_item(
                 parent_module_id,
                 name.clone(),
                 UnusedItem::Trait(trait_id),
@@ -531,8 +566,10 @@ impl<'a> ModCollector<'a> {
 
                             associated_types.push(ResolvedGeneric {
                                 name: Rc::new(name.to_string()),
-                                type_var: TypeVariable::unbound(type_variable_id),
-                                kind: Kind::Numeric(Box::new(typ)),
+                                type_var: TypeVariable::unbound(
+                                    type_variable_id,
+                                    Kind::numeric(typ),
+                                ),
                                 span: name.span(),
                             });
                         }
@@ -556,8 +593,7 @@ impl<'a> ModCollector<'a> {
                             let type_variable_id = context.def_interner.next_type_variable_id();
                             associated_types.push(ResolvedGeneric {
                                 name: Rc::new(name.to_string()),
-                                type_var: TypeVariable::unbound(type_variable_id),
-                                kind: Kind::Normal,
+                                type_var: TypeVariable::unbound(type_variable_id, Kind::Normal),
                                 span: name.span(),
                             });
                         }
@@ -589,7 +625,12 @@ impl<'a> ModCollector<'a> {
 
             if context.def_interner.is_in_lsp_mode() {
                 let parent_module_id = ModuleId { krate, local_id: self.module_id };
-                context.def_interner.register_trait(trait_id, name.to_string(), parent_module_id);
+                context.def_interner.register_trait(
+                    trait_id,
+                    name.to_string(),
+                    visibility,
+                    parent_module_id,
+                );
             }
 
             self.def_collector.items.traits.insert(trait_id, unresolved);
@@ -619,6 +660,7 @@ impl<'a> ModCollector<'a> {
                 submodule.contents.inner_attributes.clone(),
                 true,
                 submodule.is_contract,
+                false, // is struct
             ) {
                 Ok(child) => {
                     self.collect_attributes(
@@ -718,7 +760,8 @@ impl<'a> ModCollector<'a> {
             mod_decl.outer_attributes.clone(),
             ast.inner_attributes.clone(),
             true,
-            false,
+            false, // is contract
+            false, // is struct
         ) {
             Ok(child_mod_id) => {
                 self.collect_attributes(
@@ -770,6 +813,7 @@ impl<'a> ModCollector<'a> {
         inner_attributes: Vec<SecondaryAttribute>,
         add_to_parent_scope: bool,
         is_contract: bool,
+        is_struct: bool,
     ) -> Result<ModuleId, DefCollectorErrorKind> {
         push_child_module(
             &mut context.def_interner,
@@ -782,6 +826,7 @@ impl<'a> ModCollector<'a> {
             inner_attributes,
             add_to_parent_scope,
             is_contract,
+            is_struct,
         )
     }
 
@@ -817,6 +862,7 @@ fn push_child_module(
     inner_attributes: Vec<SecondaryAttribute>,
     add_to_parent_scope: bool,
     is_contract: bool,
+    is_struct: bool,
 ) -> Result<ModuleId, DefCollectorErrorKind> {
     // Note: the difference between `location` and `mod_location` is:
     // - `mod_location` will point to either the token "foo" in `mod foo { ... }`
@@ -826,8 +872,14 @@ fn push_child_module(
     // Eventually the location put in `ModuleData` is used for codelenses about `contract`s,
     // so we keep using `location` so that it continues to work as usual.
     let location = Location::new(mod_name.span(), mod_location.file);
-    let new_module =
-        ModuleData::new(Some(parent), location, outer_attributes, inner_attributes, is_contract);
+    let new_module = ModuleData::new(
+        Some(parent),
+        location,
+        outer_attributes,
+        inner_attributes,
+        is_contract,
+        is_struct,
+    );
 
     let module_id = def_map.modules.insert(new_module);
     let modules = &mut def_map.modules;
@@ -862,20 +914,23 @@ fn push_child_module(
                 name: mod_name.0.contents.clone(),
                 location: mod_location,
                 parent: Some(parent),
+                visibility,
             },
         );
 
         if interner.is_in_lsp_mode() {
-            interner.register_module(mod_id, mod_name.0.contents.clone());
+            interner.register_module(mod_id, visibility, mod_name.0.contents.clone());
         }
     }
 
     Ok(mod_id)
 }
 
+#[allow(clippy::too_many_arguments)]
 pub fn collect_function(
     interner: &mut NodeInterner,
     def_map: &mut CrateDefMap,
+    usage_tracker: &mut UsageTracker,
     function: &NoirFunction,
     module: ModuleId,
     file: FileId,
@@ -896,6 +951,7 @@ pub fn collect_function(
     } else {
         function.name() == MAIN_FUNCTION
     };
+    let has_export = function.def.attributes.has_export();
 
     let name = function.name_ident().clone();
     let func_id = interner.push_empty_fn();
@@ -906,9 +962,9 @@ pub fn collect_function(
         interner.register_function(func_id, &function.def);
     }
 
-    if !is_test && !is_entry_point_function {
+    if !is_test && !is_entry_point_function && !has_export {
         let item = UnusedItem::Function(func_id);
-        interner.usage_tracker.add_unused_item(module, name.clone(), item, visibility);
+        usage_tracker.add_unused_item(module, name.clone(), item, visibility);
     }
 
     interner.set_doc_comments(ReferenceId::Function(func_id), doc_comments);
@@ -926,9 +982,11 @@ pub fn collect_function(
     Some(func_id)
 }
 
+#[allow(clippy::too_many_arguments)]
 pub fn collect_struct(
     interner: &mut NodeInterner,
     def_map: &mut CrateDefMap,
+    usage_tracker: &mut UsageTracker,
     struct_definition: Documented<NoirStruct>,
     file_id: FileId,
     module_id: LocalModuleId,
@@ -962,8 +1020,9 @@ pub fn collect_struct(
         location,
         Vec::new(),
         Vec::new(),
-        false,
-        false,
+        false, // add to parent scope
+        false, // is contract
+        true,  // is struct
     ) {
         Ok(module_id) => {
             interner.new_struct(&unresolved, resolved_generics, krate, module_id.local_id, file_id)
@@ -989,12 +1048,14 @@ pub fn collect_struct(
 
     let parent_module_id = ModuleId { krate, local_id: module_id };
 
-    interner.usage_tracker.add_unused_item(
-        parent_module_id,
-        name.clone(),
-        UnusedItem::Struct(id),
-        visibility,
-    );
+    if !unresolved.struct_def.is_abi() {
+        usage_tracker.add_unused_item(
+            parent_module_id,
+            name.clone(),
+            UnusedItem::Struct(id),
+            visibility,
+        );
+    }
 
     if let Err((first_def, second_def)) = result {
         let error = DefCollectorErrorKind::Duplicate {
@@ -1018,6 +1079,7 @@ pub fn collect_impl(
     r#impl: TypeImpl,
     file_id: FileId,
     module_id: ModuleId,
+    errors: &mut Vec<(CompilationError, FileId)>,
 ) {
     let mut unresolved_functions =
         UnresolvedFunctions { file_id, functions: Vec::new(), trait_id: None, self_type: None };
@@ -1025,6 +1087,21 @@ pub fn collect_impl(
     for (method, _) in r#impl.methods {
         let doc_comments = method.doc_comments;
         let mut method = method.item;
+
+        if method.def.attributes.is_test_function() {
+            let error = DefCollectorErrorKind::TestOnAssociatedFunction {
+                span: method.name_ident().span(),
+            };
+            errors.push((error.into(), file_id));
+            continue;
+        }
+        if method.def.attributes.has_export() {
+            let error = DefCollectorErrorKind::ExportOnAssociatedFunction {
+                span: method.name_ident().span(),
+            };
+            errors.push((error.into(), file_id));
+        }
+
         let func_id = interner.push_empty_fn();
         method.def.where_clause.extend(r#impl.where_clause.clone());
         let location = Location::new(method.span(), file_id);
@@ -1164,9 +1241,11 @@ pub(crate) fn collect_trait_impl_items(
     (unresolved_functions, associated_types, associated_constants)
 }
 
+#[allow(clippy::too_many_arguments)]
 pub(crate) fn collect_global(
     interner: &mut NodeInterner,
     def_map: &mut CrateDefMap,
+    usage_tracker: &mut UsageTracker,
     global: Documented<LetStatement>,
     visibility: ItemVisibility,
     file_id: FileId,
@@ -1177,6 +1256,7 @@ pub(crate) fn collect_global(
     let global = global.item;
 
     let name = global.pattern.name_ident().clone();
+    let is_abi = global.attributes.iter().any(|attribute| attribute.is_abi());
 
     let global_id = interner.push_empty_global(
         name.clone(),
@@ -1191,13 +1271,16 @@ pub(crate) fn collect_global(
     // Add the statement to the scope so its path can be looked up later
     let result = def_map.modules[module_id.0].declare_global(name.clone(), visibility, global_id);
 
-    let parent_module_id = ModuleId { krate: crate_id, local_id: module_id };
-    interner.usage_tracker.add_unused_item(
-        parent_module_id,
-        name,
-        UnusedItem::Global(global_id),
-        visibility,
-    );
+    // Globals marked as ABI don't have to be used.
+    if !is_abi {
+        let parent_module_id = ModuleId { krate: crate_id, local_id: module_id };
+        usage_tracker.add_unused_item(
+            parent_module_id,
+            name,
+            UnusedItem::Global(global_id),
+            visibility,
+        );
+    }
 
     let error = result.err().map(|(first_def, second_def)| {
         let err =
@@ -1207,7 +1290,7 @@ pub(crate) fn collect_global(
 
     interner.set_doc_comments(ReferenceId::Global(global_id), doc_comments);
 
-    let global = UnresolvedGlobal { file_id, module_id, global_id, stmt_def: global };
+    let global = UnresolvedGlobal { file_id, module_id, global_id, stmt_def: global, visibility };
     (global, error)
 }
 
diff --git a/compiler/noirc_frontend/src/hir/def_collector/errors.rs b/compiler/noirc_frontend/src/hir/def_collector/errors.rs
index 2f47505db94..cafbc670e32 100644
--- a/compiler/noirc_frontend/src/hir/def_collector/errors.rs
+++ b/compiler/noirc_frontend/src/hir/def_collector/errors.rs
@@ -1,4 +1,4 @@
-use crate::ast::{Ident, ItemVisibility, Path, UnresolvedTypeData};
+use crate::ast::{Ident, ItemVisibility, Path, UnsupportedNumericGenericType};
 use crate::hir::resolution::import::PathResolutionError;
 use crate::hir::type_check::generics::TraitGenerics;
 
@@ -71,8 +71,6 @@ pub enum DefCollectorErrorKind {
         "Either the type or the trait must be from the same crate as the trait implementation"
     )]
     TraitImplOrphaned { span: Span },
-    #[error("The only supported types of numeric generics are integers, fields, and booleans")]
-    UnsupportedNumericGenericType { ident: Ident, typ: UnresolvedTypeData },
     #[error("impl has stricter requirements than trait")]
     ImplIsStricterThanTrait {
         constraint_typ: crate::Type,
@@ -82,6 +80,12 @@ pub enum DefCollectorErrorKind {
         trait_method_name: String,
         trait_method_span: Span,
     },
+    #[error("{0}")]
+    UnsupportedNumericGenericType(#[from] UnsupportedNumericGenericType),
+    #[error("The `#[test]` attribute may only be used on a non-associated function")]
+    TestOnAssociatedFunction { span: Span },
+    #[error("The `#[export]` attribute may only be used on a non-associated function")]
+    ExportOnAssociatedFunction { span: Span },
 }
 
 impl DefCollectorErrorKind {
@@ -90,6 +94,19 @@ impl DefCollectorErrorKind {
     }
 }
 
+impl<'a> From<&'a UnsupportedNumericGenericType> for Diagnostic {
+    fn from(error: &'a UnsupportedNumericGenericType) -> Diagnostic {
+        let name = &error.ident.0.contents;
+        let typ = &error.typ;
+
+        Diagnostic::simple_error(
+            format!("{name} has a type of {typ}. The only supported numeric generic types are `u1`, `u8`, `u16`, and `u32`."),
+            "Unsupported numeric generic type".to_string(),
+            error.ident.0.span(),
+        )
+    }
+}
+
 impl fmt::Display for DuplicateType {
     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
         match *self {
@@ -167,8 +184,8 @@ impl<'a> From<&'a DefCollectorErrorKind> for Diagnostic {
             DefCollectorErrorKind::PathResolutionError(error) => error.into(),
             DefCollectorErrorKind::CannotReexportItemWithLessVisibility{item_name, desired_visibility} => {
                 Diagnostic::simple_warning(
-                    format!("cannot re-export {item_name} because it has less visibility than this use statement"), 
-                    format!("consider marking {item_name} as {desired_visibility}"), 
+                    format!("cannot re-export {item_name} because it has less visibility than this use statement"),
+                    format!("consider marking {item_name} as {desired_visibility}"),
                     item_name.span())
             }
             DefCollectorErrorKind::NonStructTypeInImpl { span } => Diagnostic::simple_error(
@@ -266,15 +283,6 @@ impl<'a> From<&'a DefCollectorErrorKind> for Diagnostic {
                 "Either the type or the trait must be from the same crate as the trait implementation".into(),
                 *span,
             ),
-            DefCollectorErrorKind::UnsupportedNumericGenericType { ident, typ } => {
-                let name = &ident.0.contents;
-
-                Diagnostic::simple_error(
-                    format!("{name} has a type of {typ}. The only supported types of numeric generics are integers and fields"),
-                    "Unsupported numeric generic type".to_string(),
-                    ident.0.span(),
-                )
-            }
             DefCollectorErrorKind::ImplIsStricterThanTrait { constraint_typ, constraint_name, constraint_generics, constraint_span, trait_method_name, trait_method_span } => {
                 let constraint = format!("{}{}", constraint_name, constraint_generics);
 
@@ -286,6 +294,17 @@ impl<'a> From<&'a DefCollectorErrorKind> for Diagnostic {
                 diag.add_secondary(format!("definition of `{trait_method_name}` from trait"), *trait_method_span);
                 diag
             }
+            DefCollectorErrorKind::UnsupportedNumericGenericType(err) => err.into(),
+            DefCollectorErrorKind::TestOnAssociatedFunction { span } => Diagnostic::simple_error(
+                "The `#[test]` attribute is disallowed on `impl` methods".into(),
+                String::new(),
+                *span,
+            ),
+            DefCollectorErrorKind::ExportOnAssociatedFunction { span } => Diagnostic::simple_error(
+                "The `#[export]` attribute is disallowed on `impl` methods".into(),
+                String::new(),
+                *span,
+            ),
         }
     }
 }
diff --git a/compiler/noirc_frontend/src/hir/def_map/mod.rs b/compiler/noirc_frontend/src/hir/def_map/mod.rs
index 9afe897a167..d9d6e150a7a 100644
--- a/compiler/noirc_frontend/src/hir/def_map/mod.rs
+++ b/compiler/noirc_frontend/src/hir/def_map/mod.rs
@@ -2,7 +2,8 @@ use crate::graph::CrateId;
 use crate::hir::def_collector::dc_crate::{CompilationError, DefCollector};
 use crate::hir::Context;
 use crate::node_interner::{FuncId, GlobalId, NodeInterner, StructId};
-use crate::parser::{parse_program, ParsedModule, ParserError};
+use crate::parse_program;
+use crate::parser::{ParsedModule, ParserError};
 use crate::token::{FunctionAttribute, SecondaryAttribute, TestScope};
 use fm::{FileId, FileManager};
 use noirc_arena::{Arena, Index};
@@ -102,7 +103,8 @@ impl CrateDefMap {
             location,
             Vec::new(),
             ast.inner_attributes.clone(),
-            false,
+            false, // is contract
+            false, // is struct
         ));
 
         let def_map = CrateDefMap {
@@ -167,7 +169,7 @@ impl CrateDefMap {
             module.value_definitions().filter_map(|id| {
                 if let Some(func_id) = id.as_function() {
                     let attributes = interner.function_attributes(&func_id);
-                    match &attributes.function {
+                    match attributes.function() {
                         Some(FunctionAttribute::Test(scope)) => {
                             let location = interner.function_meta(&func_id).name.location;
                             Some(TestFunction::new(func_id, scope.clone(), location))
@@ -191,11 +193,7 @@ impl CrateDefMap {
             module.value_definitions().filter_map(|id| {
                 if let Some(func_id) = id.as_function() {
                     let attributes = interner.function_attributes(&func_id);
-                    if attributes.secondary.contains(&SecondaryAttribute::Export) {
-                        Some(func_id)
-                    } else {
-                        None
-                    }
+                    attributes.has_export().then_some(func_id)
                 } else {
                     None
                 }
@@ -291,6 +289,29 @@ impl CrateDefMap {
             String::new()
         }
     }
+
+    /// Return a topological ordering of each module such that any child modules
+    /// are before their parent modules. Sibling modules will respect the ordering
+    /// declared from their parent module (the `mod foo; mod bar;` declarations).
+    pub fn get_module_topological_order(&self) -> HashMap<LocalModuleId, usize> {
+        let mut ordering = HashMap::default();
+        self.topologically_sort_modules(self.root, &mut 0, &mut ordering);
+        ordering
+    }
+
+    fn topologically_sort_modules(
+        &self,
+        current: LocalModuleId,
+        index: &mut usize,
+        ordering: &mut HashMap<LocalModuleId, usize>,
+    ) {
+        for child in &self.modules[current.0].child_declaration_order {
+            self.topologically_sort_modules(*child, index, ordering);
+        }
+
+        ordering.insert(current, *index);
+        *index += 1;
+    }
 }
 
 /// Specifies a contract function and extra metadata that
diff --git a/compiler/noirc_frontend/src/hir/def_map/module_data.rs b/compiler/noirc_frontend/src/hir/def_map/module_data.rs
index ff36bcf27d6..06188f3920b 100644
--- a/compiler/noirc_frontend/src/hir/def_map/module_data.rs
+++ b/compiler/noirc_frontend/src/hir/def_map/module_data.rs
@@ -14,6 +14,11 @@ pub struct ModuleData {
     pub parent: Option<LocalModuleId>,
     pub children: HashMap<Ident, LocalModuleId>,
 
+    /// Each child in the order they were declared in the parent module.
+    /// E.g. for a module containing `mod foo; mod bar; mod baz` this would
+    /// be `vec![foo, bar, baz]`.
+    pub child_declaration_order: Vec<LocalModuleId>,
+
     /// Contains all definitions visible to the current module. This includes
     /// all definitions in self.definitions as well as all imported definitions.
     scope: ItemScope,
@@ -26,6 +31,9 @@ pub struct ModuleData {
     /// True if this module is a `contract Foo { ... }` module containing contract functions
     pub is_contract: bool,
 
+    /// True if this module is actually a struct
+    pub is_struct: bool,
+
     pub attributes: Vec<SecondaryAttribute>,
 }
 
@@ -36,6 +44,7 @@ impl ModuleData {
         outer_attributes: Vec<SecondaryAttribute>,
         inner_attributes: Vec<SecondaryAttribute>,
         is_contract: bool,
+        is_struct: bool,
     ) -> ModuleData {
         let mut attributes = outer_attributes;
         attributes.extend(inner_attributes);
@@ -43,10 +52,12 @@ impl ModuleData {
         ModuleData {
             parent,
             children: HashMap::new(),
+            child_declaration_order: Vec::new(),
             scope: ItemScope::default(),
             definitions: ItemScope::default(),
             location,
             is_contract,
+            is_struct,
             attributes,
         }
     }
@@ -68,6 +79,10 @@ impl ModuleData {
     ) -> Result<(), (Ident, Ident)> {
         self.scope.add_definition(name.clone(), visibility, item_id, trait_id)?;
 
+        if let ModuleDefId::ModuleId(child) = item_id {
+            self.child_declaration_order.push(child.local_id);
+        }
+
         // definitions is a subset of self.scope so it is expected if self.scope.define_func_def
         // returns without error, so will self.definitions.define_func_def.
         self.definitions.add_definition(name, visibility, item_id, trait_id)
diff --git a/compiler/noirc_frontend/src/hir/def_map/module_def.rs b/compiler/noirc_frontend/src/hir/def_map/module_def.rs
index a487bda81b3..a751eacd2dd 100644
--- a/compiler/noirc_frontend/src/hir/def_map/module_def.rs
+++ b/compiler/noirc_frontend/src/hir/def_map/module_def.rs
@@ -99,79 +99,3 @@ impl From<TraitId> for ModuleDefId {
         ModuleDefId::TraitId(trait_id)
     }
 }
-
-pub trait TryFromModuleDefId: Sized {
-    fn try_from(id: ModuleDefId) -> Option<Self>;
-    fn dummy_id() -> Self;
-    fn description() -> String;
-}
-
-impl TryFromModuleDefId for FuncId {
-    fn try_from(id: ModuleDefId) -> Option<Self> {
-        id.as_function()
-    }
-
-    fn dummy_id() -> Self {
-        FuncId::dummy_id()
-    }
-
-    fn description() -> String {
-        "function".to_string()
-    }
-}
-
-impl TryFromModuleDefId for StructId {
-    fn try_from(id: ModuleDefId) -> Option<Self> {
-        id.as_type()
-    }
-
-    fn dummy_id() -> Self {
-        StructId::dummy_id()
-    }
-
-    fn description() -> String {
-        "type".to_string()
-    }
-}
-
-impl TryFromModuleDefId for TypeAliasId {
-    fn try_from(id: ModuleDefId) -> Option<Self> {
-        id.as_type_alias()
-    }
-
-    fn dummy_id() -> Self {
-        TypeAliasId::dummy_id()
-    }
-
-    fn description() -> String {
-        "type alias".to_string()
-    }
-}
-
-impl TryFromModuleDefId for TraitId {
-    fn try_from(id: ModuleDefId) -> Option<Self> {
-        id.as_trait()
-    }
-
-    fn dummy_id() -> Self {
-        TraitId::dummy_id()
-    }
-
-    fn description() -> String {
-        "trait".to_string()
-    }
-}
-
-impl TryFromModuleDefId for GlobalId {
-    fn try_from(id: ModuleDefId) -> Option<Self> {
-        id.as_global()
-    }
-
-    fn dummy_id() -> Self {
-        GlobalId::dummy_id()
-    }
-
-    fn description() -> String {
-        "global".to_string()
-    }
-}
diff --git a/compiler/noirc_frontend/src/hir/def_map/namespace.rs b/compiler/noirc_frontend/src/hir/def_map/namespace.rs
index 6fac6d2b991..a600d98dd8b 100644
--- a/compiler/noirc_frontend/src/hir/def_map/namespace.rs
+++ b/compiler/noirc_frontend/src/hir/def_map/namespace.rs
@@ -13,14 +13,6 @@ impl PerNs {
         PerNs { types: Some((t, ItemVisibility::Public, false)), values: None }
     }
 
-    pub fn take_types(self) -> Option<ModuleDefId> {
-        self.types.map(|it| it.0)
-    }
-
-    pub fn take_values(self) -> Option<ModuleDefId> {
-        self.values.map(|it| it.0)
-    }
-
     pub fn iter_defs(self) -> impl Iterator<Item = ModuleDefId> {
         self.types.map(|it| it.0).into_iter().chain(self.values.map(|it| it.0))
     }
diff --git a/compiler/noirc_frontend/src/hir/mod.rs b/compiler/noirc_frontend/src/hir/mod.rs
index c631edfa889..2bd1a852f05 100644
--- a/compiler/noirc_frontend/src/hir/mod.rs
+++ b/compiler/noirc_frontend/src/hir/mod.rs
@@ -11,7 +11,8 @@ use crate::graph::{CrateGraph, CrateId};
 use crate::hir_def::function::FuncMeta;
 use crate::node_interner::{FuncId, NodeInterner, StructId};
 use crate::parser::ParserError;
-use crate::{Generics, Kind, ParsedModule, ResolvedGeneric, Type, TypeVariable};
+use crate::usage_tracker::UsageTracker;
+use crate::{Generics, Kind, ParsedModule, ResolvedGeneric, TypeVariable};
 use def_collector::dc_crate::CompilationError;
 use def_map::{Contract, CrateDefMap};
 use fm::{FileId, FileManager};
@@ -33,6 +34,7 @@ pub struct Context<'file_manager, 'parsed_files> {
     pub def_interner: NodeInterner,
     pub crate_graph: CrateGraph,
     pub def_maps: BTreeMap<CrateId, CrateDefMap>,
+    pub usage_tracker: UsageTracker,
     // In the WASM context, we take ownership of the file manager,
     // which is why this needs to be a Cow. In all use-cases, the file manager
     // is read-only however, once it has been passed to the Context.
@@ -64,6 +66,7 @@ impl Context<'_, '_> {
         Context {
             def_interner: NodeInterner::default(),
             def_maps: BTreeMap::new(),
+            usage_tracker: UsageTracker::default(),
             visited_files: BTreeMap::new(),
             crate_graph: CrateGraph::default(),
             file_manager: Cow::Owned(file_manager),
@@ -80,6 +83,7 @@ impl Context<'_, '_> {
         Context {
             def_interner: NodeInterner::default(),
             def_maps: BTreeMap::new(),
+            usage_tracker: UsageTracker::default(),
             visited_files: BTreeMap::new(),
             crate_graph: CrateGraph::default(),
             file_manager: Cow::Borrowed(file_manager),
@@ -280,19 +284,20 @@ impl Context<'_, '_> {
         vecmap(generics, |generic| {
             // Map the generic to a fresh type variable
             let id = interner.next_type_variable_id();
-            let type_var = TypeVariable::unbound(id);
+
+            let type_var_kind = generic.kind().unwrap_or_else(|err| {
+                errors.push((err.into(), file_id));
+                // When there's an error, unify with any other kinds
+                Kind::Any
+            });
+            let type_var = TypeVariable::unbound(id, type_var_kind);
             let ident = generic.ident();
             let span = ident.0.span();
 
             // Check for name collisions of this generic
             let name = Rc::new(ident.0.contents.clone());
 
-            let kind = generic.kind().unwrap_or_else(|err| {
-                errors.push((err.into(), file_id));
-                Kind::Numeric(Box::new(Type::Error))
-            });
-
-            ResolvedGeneric { name, type_var, kind, span }
+            ResolvedGeneric { name, type_var, span }
         })
     }
 
diff --git a/compiler/noirc_frontend/src/hir/resolution/errors.rs b/compiler/noirc_frontend/src/hir/resolution/errors.rs
index f3c61a7fbe2..774836f8992 100644
--- a/compiler/noirc_frontend/src/hir/resolution/errors.rs
+++ b/compiler/noirc_frontend/src/hir/resolution/errors.rs
@@ -1,9 +1,13 @@
+use acvm::FieldElement;
 pub use noirc_errors::Span;
-use noirc_errors::{CustomDiagnostic as Diagnostic, FileDiagnostic};
+use noirc_errors::{CustomDiagnostic as Diagnostic, FileDiagnostic, Location};
 use thiserror::Error;
 
 use crate::{
-    ast::Ident, hir::comptime::InterpreterError, parser::ParserError, usage_tracker::UnusedItem,
+    ast::{Ident, UnsupportedNumericGenericType},
+    hir::{comptime::InterpreterError, type_check::TypeCheckError},
+    parser::ParserError,
+    usage_tracker::UnusedItem,
     Type,
 };
 
@@ -25,6 +29,8 @@ pub enum ResolverError {
     UnusedVariable { ident: Ident },
     #[error("Unused {}", item.item_type())]
     UnusedItem { ident: Ident, item: UnusedItem },
+    #[error("Unconditional recursion")]
+    UnconditionalRecursion { name: String, span: Span },
     #[error("Could not find variable in this scope")]
     VariableNotDeclared { name: String, span: Span },
     #[error("path is not an identifier")]
@@ -32,7 +38,7 @@ pub enum ResolverError {
     #[error("could not resolve path")]
     PathResolutionError(#[from] PathResolutionError),
     #[error("Expected")]
-    Expected { span: Span, expected: String, got: String },
+    Expected { span: Span, expected: &'static str, got: &'static str },
     #[error("Duplicate field in constructor")]
     DuplicateField { field: Ident },
     #[error("No such field in struct")]
@@ -71,14 +77,10 @@ pub enum ResolverError {
     MutableReferenceToImmutableVariable { variable: String, span: Span },
     #[error("Mutable references to array indices are unsupported")]
     MutableReferenceToArrayElement { span: Span },
-    #[error("Numeric constants should be printed without formatting braces")]
-    NumericConstantInFormatString { name: String, span: Span },
     #[error("Closure environment must be a tuple or unit type")]
     InvalidClosureEnvironment { typ: Type, span: Span },
     #[error("Nested slices, i.e. slices within an array or slice, are not supported")]
     NestedSlices { span: Span },
-    #[error("#[recursive] attribute is only allowed on entry points to a program")]
-    MisplacedRecursiveAttribute { ident: Ident },
     #[error("#[abi(tag)] attribute is only allowed in contracts")]
     AbiAttributeOutsideContract { span: Span },
     #[error("Usage of the `#[foreign]` or `#[builtin]` function attributes are not allowed outside of the Noir standard library")]
@@ -97,14 +99,14 @@ pub enum ResolverError {
     JumpOutsideLoop { is_break: bool, span: Span },
     #[error("Only `comptime` globals can be mutable")]
     MutableGlobal { span: Span },
+    #[error("Globals must have a specified type")]
+    UnspecifiedGlobalType { span: Span, expected_type: Type },
     #[error("Self-referential structs are not supported")]
     SelfReferentialStruct { span: Span },
     #[error("#[no_predicates] attribute is only allowed on constrained functions")]
     NoPredicatesAttributeOnUnconstrained { ident: Ident },
     #[error("#[fold] attribute is only allowed on constrained functions")]
     FoldAttributeOnUnconstrained { ident: Ident },
-    #[error("The only supported types of numeric generics are integers, fields, and booleans")]
-    UnsupportedNumericGenericType { ident: Ident, typ: Type },
     #[error("expected type, found numeric generic parameter")]
     NumericGenericUsedForType { name: String, span: Span },
     #[error("Invalid array length construction")]
@@ -123,8 +125,14 @@ pub enum ResolverError {
     NamedTypeArgs { span: Span, item_kind: &'static str },
     #[error("Associated constants may only be a field or integer type")]
     AssociatedConstantsMustBeNumeric { span: Span },
-    #[error("Overflow in `{lhs} {op} {rhs}`")]
-    OverflowInType { lhs: u32, op: crate::BinaryTypeOperator, rhs: u32, span: Span },
+    #[error("Computing `{lhs} {op} {rhs}` failed with error {err}")]
+    BinaryOpError {
+        lhs: FieldElement,
+        op: crate::BinaryTypeOperator,
+        rhs: FieldElement,
+        err: Box<TypeCheckError>,
+        span: Span,
+    },
     #[error("`quote` cannot be used in runtime code")]
     QuoteInRuntimeCode { span: Span },
     #[error("Comptime-only type `{typ}` cannot be used in runtime code")]
@@ -133,8 +141,24 @@ pub enum ResolverError {
     MutatingComptimeInNonComptimeContext { name: String, span: Span },
     #[error("Failed to parse `{statement}` as an expression")]
     InvalidInternedStatementInExpr { statement: String, span: Span },
+    #[error("{0}")]
+    UnsupportedNumericGenericType(#[from] UnsupportedNumericGenericType),
     #[error("Type `{typ}` is more private than item `{item}`")]
     TypeIsMorePrivateThenItem { typ: String, item: String, span: Span },
+    #[error("Unable to parse attribute `{attribute}`")]
+    UnableToParseAttribute { attribute: String, span: Span },
+    #[error("Attribute function `{function}` is not a path")]
+    AttributeFunctionIsNotAPath { function: String, span: Span },
+    #[error("Attribute function `{name}` is not in scope")]
+    AttributeFunctionNotInScope { name: String, span: Span },
+    #[error("The trait `{missing_trait}` is not implemented for `{type_missing_trait}")]
+    TraitNotImplemented {
+        impl_trait: String,
+        missing_trait: String,
+        type_missing_trait: String,
+        span: Span,
+        missing_trait_location: Location,
+    },
 }
 
 impl ResolverError {
@@ -190,11 +214,28 @@ impl<'a> From<&'a ResolverError> for Diagnostic {
                 diagnostic.unnecessary = true;
                 diagnostic
             }
-            ResolverError::VariableNotDeclared { name, span } => Diagnostic::simple_error(
-                format!("cannot find `{name}` in this scope "),
-                "not found in this scope".to_string(),
-                *span,
-            ),
+            ResolverError::UnconditionalRecursion { name, span} => {
+                Diagnostic::simple_warning(
+                    format!("function `{name}` cannot return without recursing"),
+                    "function cannot return without recursing".to_string(),
+                    *span,
+                )
+            }
+            ResolverError::VariableNotDeclared { name, span } =>  {
+                if name == "_" {
+                    Diagnostic::simple_error(
+                        "in expressions, `_` can only be used on the left-hand side of an assignment".to_string(),
+                        "`_` not allowed here".to_string(),
+                        *span,
+                    )
+                } else {
+                    Diagnostic::simple_error(
+                        format!("cannot find `{name}` in this scope"),
+                        "not found in this scope".to_string(),
+                        *span,
+                    )
+                }
+            },
             ResolverError::PathIsNotIdent { span } => Diagnostic::simple_error(
                 "cannot use path as an identifier".to_string(),
                 String::new(),
@@ -335,11 +376,6 @@ impl<'a> From<&'a ResolverError> for Diagnostic {
             ResolverError::MutableReferenceToArrayElement { span } => {
                 Diagnostic::simple_error("Mutable references to array elements are currently unsupported".into(), "Try storing the element in a fresh variable first".into(), *span)
             },
-            ResolverError::NumericConstantInFormatString { name, span } => Diagnostic::simple_error(
-                format!("cannot find `{name}` in this scope "),
-                "Numeric constants should be printed without formatting braces".to_string(),
-                *span,
-            ),
             ResolverError::InvalidClosureEnvironment { span, typ } => Diagnostic::simple_error(
                 format!("{typ} is not a valid closure environment type"),
                 "Closure environment must be a tuple or unit type".to_string(), *span),
@@ -348,18 +384,6 @@ impl<'a> From<&'a ResolverError> for Diagnostic {
                 "Try to use a constant sized array or BoundedVec instead".into(),
                 *span,
             ),
-            ResolverError::MisplacedRecursiveAttribute { ident } => {
-                let name = &ident.0.contents;
-
-                let mut diag = Diagnostic::simple_error(
-                    format!("misplaced #[recursive] attribute on function {name} rather than the main function"),
-                    "misplaced #[recursive] attribute".to_string(),
-                    ident.0.span(),
-                );
-
-                diag.add_note("The `#[recursive]` attribute specifies to the backend whether it should use a prover which generates proofs that are friendly for recursive verification in another circuit".to_owned());
-                diag
-            }
             ResolverError::AbiAttributeOutsideContract { span } => {
                 Diagnostic::simple_error(
                     "#[abi(tag)] attributes can only be used in contracts".to_string(),
@@ -412,6 +436,13 @@ impl<'a> From<&'a ResolverError> for Diagnostic {
                     *span,
                 )
             },
+            ResolverError::UnspecifiedGlobalType { span, expected_type } => {
+                Diagnostic::simple_error(
+                    "Globals must have a specified type".to_string(),
+                    format!("Inferred type is `{expected_type}`"),
+                    *span,
+                )
+            },
             ResolverError::SelfReferentialStruct { span } => {
                 Diagnostic::simple_error(
                     "Self-referential structs are not supported".into(),
@@ -443,15 +474,6 @@ impl<'a> From<&'a ResolverError> for Diagnostic {
                 diag.add_note("The `#[fold]` attribute specifies whether a constrained function should be treated as a separate circuit rather than inlined into the program entry point".to_owned());
                 diag
             }
-            ResolverError::UnsupportedNumericGenericType { ident , typ } => {
-                let name = &ident.0.contents;
-
-                Diagnostic::simple_error(
-                    format!("{name} has a type of {typ}. The only supported types of numeric generics are integers, fields, and booleans."),
-                    "Unsupported numeric generic type".to_string(),
-                    ident.0.span(),
-                )
-            }
             ResolverError::NumericGenericUsedForType { name, span } => {
                 Diagnostic::simple_error(
                     format!("expected type, found numeric generic parameter {name}"),
@@ -509,10 +531,10 @@ impl<'a> From<&'a ResolverError> for Diagnostic {
                     *span,
                 )
             }
-            ResolverError::OverflowInType { lhs, op, rhs, span } => {
+            ResolverError::BinaryOpError { lhs, op, rhs, err, span } => {
                 Diagnostic::simple_error(
-                    format!("Overflow in `{lhs} {op} {rhs}`"),
-                    "Overflow here".to_string(),
+                    format!("Computing `{lhs} {op} {rhs}` failed with error {err}"),
+                    String::new(),
                     *span,
                 )
             }
@@ -544,6 +566,7 @@ impl<'a> From<&'a ResolverError> for Diagnostic {
                     *span,
                 )
             },
+            ResolverError::UnsupportedNumericGenericType(err) => err.into(),
             ResolverError::TypeIsMorePrivateThenItem { typ, item, span } => {
                 Diagnostic::simple_warning(
                     format!("Type `{typ}` is more private than item `{item}`"),
@@ -551,6 +574,35 @@ impl<'a> From<&'a ResolverError> for Diagnostic {
                     *span,
                 )
             },
+            ResolverError::UnableToParseAttribute { attribute, span } => {
+                Diagnostic::simple_error(
+                    format!("Unable to parse attribute `{attribute}`"),
+                    "Attribute should be a function or function call".into(),
+                    *span,
+                )
+            },
+            ResolverError::AttributeFunctionIsNotAPath { function, span } => {
+                Diagnostic::simple_error(
+                    format!("Attribute function `{function}` is not a path"),
+                    "An attribute's function should be a single identifier or a path".into(),
+                    *span,
+                )
+            },
+            ResolverError::AttributeFunctionNotInScope { name, span } => {
+                Diagnostic::simple_error(
+                    format!("Attribute function `{name}` is not in scope"),
+                    String::new(),
+                    *span,
+                )
+            },
+            ResolverError::TraitNotImplemented { impl_trait, missing_trait: the_trait, type_missing_trait: typ, span, missing_trait_location} => {
+                let mut diagnostic = Diagnostic::simple_error(
+                    format!("The trait bound `{typ}: {the_trait}` is not satisfied"), 
+                    format!("The trait `{the_trait}` is not implemented for `{typ}")
+                    , *span);
+                diagnostic.add_secondary_with_file(format!("required by this bound in `{impl_trait}"), missing_trait_location.span, missing_trait_location.file);
+                diagnostic
+            },
         }
     }
 }
diff --git a/compiler/noirc_frontend/src/hir/resolution/import.rs b/compiler/noirc_frontend/src/hir/resolution/import.rs
index 73a1b1ccb7c..376b85bfbd9 100644
--- a/compiler/noirc_frontend/src/hir/resolution/import.rs
+++ b/compiler/noirc_frontend/src/hir/resolution/import.rs
@@ -3,14 +3,17 @@ use thiserror::Error;
 
 use crate::graph::CrateId;
 use crate::hir::def_collector::dc_crate::CompilationError;
-use crate::node_interner::ReferenceId;
+
+use crate::locations::ReferencesTracker;
 use crate::usage_tracker::UsageTracker;
+
 use std::collections::BTreeMap;
 
-use crate::ast::{Ident, ItemVisibility, Path, PathKind, PathSegment};
-use crate::hir::def_map::{CrateDefMap, LocalModuleId, ModuleDefId, ModuleId, PerNs};
+use crate::ast::{Ident, ItemVisibility, Path, PathKind};
+use crate::hir::def_map::{CrateDefMap, LocalModuleId, ModuleData, ModuleDefId, ModuleId, PerNs};
 
 use super::errors::ResolverError;
+use super::visibility::item_in_module_is_visible;
 
 #[derive(Debug, Clone)]
 pub struct ImportDirective {
@@ -21,21 +24,17 @@ pub struct ImportDirective {
     pub is_prelude: bool,
 }
 
-struct NamespaceResolution {
-    module_id: ModuleId,
-    namespace: PerNs,
-    error: Option<PathResolutionError>,
-}
-
-type NamespaceResolutionResult = Result<NamespaceResolution, PathResolutionError>;
-
-pub struct PathResolution {
-    pub module_def_id: ModuleDefId,
-
-    pub error: Option<PathResolutionError>,
+impl ImportDirective {
+    /// Returns the name that's brought into scope: either the alias or the last segment of the path
+    pub fn name(&self) -> Ident {
+        match &self.alias {
+            None => self.path.last_ident(),
+            Some(ident) => ident.clone(),
+        }
+    }
 }
 
-pub(crate) type PathResolutionResult = Result<PathResolution, PathResolutionError>;
+type ImportResolutionResult = Result<ResolvedImport, PathResolutionError>;
 
 #[derive(Debug, Clone, PartialEq, Eq, Error)]
 pub enum PathResolutionError {
@@ -45,18 +44,18 @@ pub enum PathResolutionError {
     Private(Ident),
     #[error("There is no super module")]
     NoSuper(Span),
+    #[error("turbofish (`::<_>`) not allowed on {item}")]
+    TurbofishNotAllowedOnItem { item: String, span: Span },
+    #[error("{ident} is a {kind}, not a module")]
+    NotAModule { ident: Ident, kind: &'static str },
 }
 
 #[derive(Debug)]
 pub struct ResolvedImport {
-    // name of the namespace, either last path segment or an alias
-    pub name: Ident,
     // The symbol which we have resolved to
-    pub resolved_namespace: PerNs,
+    pub namespace: PerNs,
     // The module which we must add the resolved namespace to
-    pub module_scope: LocalModuleId,
-    pub is_prelude: bool,
-    pub error: Option<PathResolutionError>,
+    pub errors: Vec<PathResolutionError>,
 }
 
 impl From<PathResolutionError> for CompilationError {
@@ -80,389 +79,258 @@ impl<'a> From<&'a PathResolutionError> for CustomDiagnostic {
             PathResolutionError::NoSuper(span) => {
                 CustomDiagnostic::simple_error(error.to_string(), String::new(), *span)
             }
+            PathResolutionError::TurbofishNotAllowedOnItem { item: _, span } => {
+                CustomDiagnostic::simple_error(error.to_string(), String::new(), *span)
+            }
+            PathResolutionError::NotAModule { ident, kind: _ } => {
+                CustomDiagnostic::simple_error(error.to_string(), String::new(), ident.span())
+            }
         }
     }
 }
 
+/// Resolves a Path in a `use` statement, assuming it's located in `importing_module`.
+///
+/// If the imported name can't be found, `Err` will be returned. If it can be found, `Ok`
+/// will be returned with a potential list of errors if, for example, one of the segments
+/// is not accessible from the importing module (e.g. because it's private).
 pub fn resolve_import(
-    crate_id: CrateId,
-    import_directive: &ImportDirective,
+    path: Path,
+    importing_module: ModuleId,
     def_maps: &BTreeMap<CrateId, CrateDefMap>,
     usage_tracker: &mut UsageTracker,
-    path_references: &mut Option<&mut Vec<ReferenceId>>,
-) -> Result<ResolvedImport, PathResolutionError> {
-    let module_scope = import_directive.module_id;
-    let NamespaceResolution {
-        module_id: resolved_module,
-        namespace: resolved_namespace,
-        mut error,
-    } = resolve_path_to_ns(
-        import_directive,
-        crate_id,
-        crate_id,
-        def_maps,
-        usage_tracker,
-        path_references,
-    )?;
-
-    let name = resolve_path_name(import_directive);
-
-    let visibility = resolved_namespace
-        .values
-        .or(resolved_namespace.types)
-        .map(|(_, visibility, _)| visibility)
-        .expect("Found empty namespace");
-
-    error = error.or_else(|| {
-        if can_reference_module_id(
-            def_maps,
-            crate_id,
-            import_directive.module_id,
-            resolved_module,
-            visibility,
-        ) {
-            None
-        } else {
-            Some(PathResolutionError::Private(name.clone()))
-        }
-    });
-
-    Ok(ResolvedImport {
-        name,
-        resolved_namespace,
-        module_scope,
-        is_prelude: import_directive.is_prelude,
-        error,
-    })
+    references_tracker: Option<ReferencesTracker>,
+) -> ImportResolutionResult {
+    let (path, module_id, references_tracker) =
+        resolve_path_kind(path, importing_module, def_maps, references_tracker)?;
+    let mut solver =
+        ImportSolver::new(importing_module, def_maps, usage_tracker, references_tracker);
+    solver.resolve_name_in_module(path, module_id)
 }
 
-fn resolve_path_to_ns(
-    import_directive: &ImportDirective,
-    crate_id: CrateId,
-    importing_crate: CrateId,
+/// Given a Path and a ModuleId it's being used in, this function returns a plain Path
+/// and a ModuleId where that plain Path should be resolved. That is, this method will
+/// resolve the Path kind and translate it to a plain path.
+///
+/// The third value in the tuple is a reference tracker that must be passed to this
+/// method, which is used in case the path kind is `dep`: the segment after `dep`
+/// will be linked to the root module of the external dependency.
+pub fn resolve_path_kind<'r>(
+    path: Path,
+    importing_module: ModuleId,
     def_maps: &BTreeMap<CrateId, CrateDefMap>,
-    usage_tracker: &mut UsageTracker,
-    path_references: &mut Option<&mut Vec<ReferenceId>>,
-) -> NamespaceResolutionResult {
-    let import_path = &import_directive.path.segments;
-
-    match import_directive.path.kind {
-        crate::ast::PathKind::Crate => {
-            // Resolve from the root of the crate
-            resolve_path_from_crate_root(
-                crate_id,
-                importing_crate,
-                import_path,
-                def_maps,
-                usage_tracker,
-                path_references,
-            )
+    references_tracker: Option<ReferencesTracker<'r>>,
+) -> Result<(Path, ModuleId, Option<ReferencesTracker<'r>>), PathResolutionError> {
+    let mut solver =
+        PathResolutionTargetResolver { importing_module, def_maps, references_tracker };
+    let (path, module_id) = solver.resolve(path)?;
+    Ok((path, module_id, solver.references_tracker))
+}
+
+struct PathResolutionTargetResolver<'def_maps, 'references_tracker> {
+    importing_module: ModuleId,
+    def_maps: &'def_maps BTreeMap<CrateId, CrateDefMap>,
+    references_tracker: Option<ReferencesTracker<'references_tracker>>,
+}
+
+impl<'def_maps, 'references_tracker> PathResolutionTargetResolver<'def_maps, 'references_tracker> {
+    fn resolve(&mut self, path: Path) -> Result<(Path, ModuleId), PathResolutionError> {
+        match path.kind {
+            PathKind::Crate => self.resolve_crate_path(path),
+            PathKind::Plain => self.resolve_plain_path(path, self.importing_module),
+            PathKind::Dep => self.resolve_dep_path(path),
+            PathKind::Super => self.resolve_super_path(path),
         }
-        crate::ast::PathKind::Plain => {
-            // There is a possibility that the import path is empty
-            // In that case, early return
-            if import_path.is_empty() {
-                return resolve_name_in_module(
-                    crate_id,
-                    importing_crate,
-                    import_path,
-                    import_directive.module_id,
-                    def_maps,
-                    true,
-                    usage_tracker,
-                    path_references,
-                );
-            }
+    }
 
-            let def_map = &def_maps[&crate_id];
-            let current_mod_id = ModuleId { krate: crate_id, local_id: import_directive.module_id };
-            let current_mod = &def_map.modules[current_mod_id.local_id.0];
-            let first_segment =
-                &import_path.first().expect("ice: could not fetch first segment").ident;
-            if current_mod.find_name(first_segment).is_none() {
-                // Resolve externally when first segment is unresolved
-                return resolve_external_dep(
-                    crate_id,
-                    // def_map,
-                    import_directive,
-                    def_maps,
-                    usage_tracker,
-                    path_references,
-                    importing_crate,
-                );
-            }
+    fn resolve_crate_path(&mut self, path: Path) -> Result<(Path, ModuleId), PathResolutionError> {
+        let root_module = self.def_maps[&self.importing_module.krate].root;
+        let current_module = ModuleId { krate: self.importing_module.krate, local_id: root_module };
+        Ok((path, current_module))
+    }
 
-            resolve_name_in_module(
-                crate_id,
-                importing_crate,
-                import_path,
-                import_directive.module_id,
-                def_maps,
-                true,
-                usage_tracker,
-                path_references,
-            )
+    fn resolve_plain_path(
+        &mut self,
+        path: Path,
+        current_module: ModuleId,
+    ) -> Result<(Path, ModuleId), PathResolutionError> {
+        // There is a possibility that the import path is empty. In that case, early return.
+        // This happens on import statements such as `use crate` or `use std`.
+        if path.segments.is_empty() {
+            return Ok((path, current_module));
         }
 
-        crate::ast::PathKind::Dep => resolve_external_dep(
-            crate_id,
-            import_directive,
-            def_maps,
-            usage_tracker,
-            path_references,
-            importing_crate,
-        ),
-
-        crate::ast::PathKind::Super => {
-            if let Some(parent_module_id) =
-                def_maps[&crate_id].modules[import_directive.module_id.0].parent
-            {
-                resolve_name_in_module(
-                    crate_id,
-                    importing_crate,
-                    import_path,
-                    parent_module_id,
-                    def_maps,
-                    false,
-                    usage_tracker,
-                    path_references,
-                )
-            } else {
-                let span_start = import_directive.path.span().start();
-                let span = Span::from(span_start..span_start + 5); // 5 == "super".len()
-                Err(PathResolutionError::NoSuper(span))
-            }
+        let first_segment =
+            &path.segments.first().expect("ice: could not fetch first segment").ident;
+        if get_module(self.def_maps, current_module).find_name(first_segment).is_none() {
+            // Resolve externally when first segment is unresolved
+            return self.resolve_dep_path(path);
         }
+
+        Ok((path, current_module))
     }
-}
 
-fn resolve_path_from_crate_root(
-    crate_id: CrateId,
-    importing_crate: CrateId,
+    fn resolve_dep_path(
+        &mut self,
+        mut path: Path,
+    ) -> Result<(Path, ModuleId), PathResolutionError> {
+        // Use extern_prelude to get the dep
+        let current_def_map = &self.def_maps[&self.importing_module.krate];
+
+        // Fetch the root module from the prelude
+        let crate_name = &path.segments.first().unwrap().ident;
+        let dep_module = current_def_map
+            .extern_prelude
+            .get(&crate_name.0.contents)
+            .ok_or_else(|| PathResolutionError::Unresolved(crate_name.to_owned()))?;
+
+        if let Some(references_tracker) = &mut self.references_tracker {
+            let span = crate_name.span();
+            references_tracker.add_reference(ModuleDefId::ModuleId(*dep_module), span, false);
+        }
 
-    import_path: &[PathSegment],
-    def_maps: &BTreeMap<CrateId, CrateDefMap>,
-    usage_tracker: &mut UsageTracker,
-    path_references: &mut Option<&mut Vec<ReferenceId>>,
-) -> NamespaceResolutionResult {
-    let starting_mod = def_maps[&crate_id].root;
-    resolve_name_in_module(
-        crate_id,
-        importing_crate,
-        import_path,
-        starting_mod,
-        def_maps,
-        false,
-        usage_tracker,
-        path_references,
-    )
-}
+        // Now the path can be solved starting from the second segment as a plain path
+        path.kind = PathKind::Plain;
+        path.segments.remove(0);
 
-#[allow(clippy::too_many_arguments)]
-fn resolve_name_in_module(
-    krate: CrateId,
-    importing_crate: CrateId,
-    import_path: &[PathSegment],
-    starting_mod: LocalModuleId,
-    def_maps: &BTreeMap<CrateId, CrateDefMap>,
-    plain: bool,
-    usage_tracker: &mut UsageTracker,
-    path_references: &mut Option<&mut Vec<ReferenceId>>,
-) -> NamespaceResolutionResult {
-    let def_map = &def_maps[&krate];
-    let mut current_mod_id = ModuleId { krate, local_id: starting_mod };
-    let mut current_mod = &def_map.modules[current_mod_id.local_id.0];
-
-    // There is a possibility that the import path is empty
-    // In that case, early return
-    if import_path.is_empty() {
-        return Ok(NamespaceResolution {
-            module_id: current_mod_id,
-            namespace: PerNs::types(current_mod_id.into()),
-            error: None,
-        });
+        Ok((path, *dep_module))
     }
 
-    let first_segment = &import_path.first().expect("ice: could not fetch first segment").ident;
-    let mut current_ns = current_mod.find_name(first_segment);
-    if current_ns.is_none() {
-        return Err(PathResolutionError::Unresolved(first_segment.clone()));
+    fn resolve_super_path(&mut self, path: Path) -> Result<(Path, ModuleId), PathResolutionError> {
+        let Some(parent_module_id) = get_module(self.def_maps, self.importing_module).parent else {
+            let span_start = path.span.start();
+            let span = Span::from(span_start..span_start + 5); // 5 == "super".len()
+            return Err(PathResolutionError::NoSuper(span));
+        };
+
+        let current_module =
+            ModuleId { krate: self.importing_module.krate, local_id: parent_module_id };
+        Ok((path, current_module))
     }
+}
 
-    usage_tracker.mark_as_referenced(current_mod_id, first_segment);
+struct ImportSolver<'def_maps, 'usage_tracker, 'references_tracker> {
+    importing_module: ModuleId,
+    def_maps: &'def_maps BTreeMap<CrateId, CrateDefMap>,
+    usage_tracker: &'usage_tracker mut UsageTracker,
+    references_tracker: Option<ReferencesTracker<'references_tracker>>,
+}
 
-    let mut warning: Option<PathResolutionError> = None;
-    for (index, (last_segment, current_segment)) in
-        import_path.iter().zip(import_path.iter().skip(1)).enumerate()
-    {
-        let last_segment = &last_segment.ident;
-        let current_segment = &current_segment.ident;
+impl<'def_maps, 'usage_tracker, 'references_tracker>
+    ImportSolver<'def_maps, 'usage_tracker, 'references_tracker>
+{
+    fn new(
+        importing_module: ModuleId,
+        def_maps: &'def_maps BTreeMap<CrateId, CrateDefMap>,
+        usage_tracker: &'usage_tracker mut UsageTracker,
+        references_tracker: Option<ReferencesTracker<'references_tracker>>,
+    ) -> Self {
+        Self { importing_module, def_maps, usage_tracker, references_tracker }
+    }
 
-        let (typ, visibility) = match current_ns.types {
-            None => return Err(PathResolutionError::Unresolved(last_segment.clone())),
-            Some((typ, visibility, _)) => (typ, visibility),
-        };
+    fn resolve_name_in_module(
+        &mut self,
+        path: Path,
+        starting_module: ModuleId,
+    ) -> ImportResolutionResult {
+        // There is a possibility that the import path is empty. In that case, early return.
+        if path.segments.is_empty() {
+            return Ok(ResolvedImport {
+                namespace: PerNs::types(starting_module.into()),
+                errors: Vec::new(),
+            });
+        }
 
-        // In the type namespace, only Mod can be used in a path.
-        current_mod_id = match typ {
-            ModuleDefId::ModuleId(id) => {
-                if let Some(path_references) = path_references {
-                    path_references.push(ReferenceId::Module(id));
-                }
-                id
-            }
-            ModuleDefId::FunctionId(_) => panic!("functions cannot be in the type namespace"),
-            // TODO: If impls are ever implemented, types can be used in a path
-            ModuleDefId::TypeId(id) => {
-                if let Some(path_references) = path_references {
-                    path_references.push(ReferenceId::Struct(id));
-                }
-                id.module_id()
-            }
-            ModuleDefId::TypeAliasId(_) => panic!("type aliases cannot be used in type namespace"),
-            ModuleDefId::TraitId(id) => {
-                if let Some(path_references) = path_references {
-                    path_references.push(ReferenceId::Trait(id));
+        let plain_or_crate = matches!(path.kind, PathKind::Plain | PathKind::Crate);
+
+        // The current module and module ID as we resolve path segments
+        let mut current_module_id = starting_module;
+        let mut current_module = get_module(self.def_maps, starting_module);
+
+        let first_segment =
+            &path.segments.first().expect("ice: could not fetch first segment").ident;
+        let mut current_ns = current_module.find_name(first_segment);
+        if current_ns.is_none() {
+            return Err(PathResolutionError::Unresolved(first_segment.clone()));
+        }
+
+        self.usage_tracker.mark_as_referenced(current_module_id, first_segment);
+
+        let mut errors = Vec::new();
+        for (index, (last_segment, current_segment)) in
+            path.segments.iter().zip(path.segments.iter().skip(1)).enumerate()
+        {
+            let last_ident = &last_segment.ident;
+            let current_ident = &current_segment.ident;
+
+            let (typ, visibility) = match current_ns.types {
+                None => return Err(PathResolutionError::Unresolved(last_ident.clone())),
+                Some((typ, visibility, _)) => (typ, visibility),
+            };
+
+            self.add_reference(typ, last_segment.span, last_segment.ident.is_self_type_name());
+
+            // In the type namespace, only Mod can be used in a path.
+            current_module_id = match typ {
+                ModuleDefId::ModuleId(id) => id,
+                ModuleDefId::TypeId(id) => id.module_id(),
+                ModuleDefId::TypeAliasId(..) => {
+                    return Err(PathResolutionError::NotAModule {
+                        ident: last_segment.ident.clone(),
+                        kind: "type alias",
+                    });
                 }
-                id.0
-            }
-            ModuleDefId::GlobalId(_) => panic!("globals cannot be in the type namespace"),
-        };
+                ModuleDefId::TraitId(id) => id.0,
+                ModuleDefId::FunctionId(_) => panic!("functions cannot be in the type namespace"),
+                ModuleDefId::GlobalId(_) => panic!("globals cannot be in the type namespace"),
+            };
 
-        warning = warning.or_else(|| {
-            // If the path is plain, the first segment will always refer to
+            // If the path is plain or crate, the first segment will always refer to
             // something that's visible from the current module.
-            if (plain && index == 0)
-                || can_reference_module_id(
-                    def_maps,
-                    importing_crate,
-                    starting_mod,
-                    current_mod_id,
-                    visibility,
-                )
+            if !((plain_or_crate && index == 0)
+                || self.item_in_module_is_visible(current_module_id, visibility))
             {
-                None
-            } else {
-                Some(PathResolutionError::Private(last_segment.clone()))
+                errors.push(PathResolutionError::Private(last_ident.clone()));
             }
-        });
 
-        current_mod = &def_maps[&current_mod_id.krate].modules[current_mod_id.local_id.0];
+            current_module =
+                &self.def_maps[&current_module_id.krate].modules[current_module_id.local_id.0];
+
+            // Check if namespace
+            let found_ns = current_module.find_name(current_ident);
+            if found_ns.is_none() {
+                return Err(PathResolutionError::Unresolved(current_ident.clone()));
+            }
 
-        // Check if namespace
-        let found_ns = current_mod.find_name(current_segment);
+            self.usage_tracker.mark_as_referenced(current_module_id, current_ident);
 
-        if found_ns.is_none() {
-            return Err(PathResolutionError::Unresolved(current_segment.clone()));
+            current_ns = found_ns;
         }
 
-        usage_tracker.mark_as_referenced(current_mod_id, current_segment);
-
-        current_ns = found_ns;
-    }
+        let (module_def_id, visibility, _) =
+            current_ns.values.or(current_ns.types).expect("Found empty namespace");
 
-    Ok(NamespaceResolution { module_id: current_mod_id, namespace: current_ns, error: warning })
-}
+        self.add_reference(module_def_id, path.segments.last().unwrap().ident.span(), false);
 
-fn resolve_path_name(import_directive: &ImportDirective) -> Ident {
-    match &import_directive.alias {
-        None => import_directive.path.last_ident(),
-        Some(ident) => ident.clone(),
-    }
-}
+        if !self.item_in_module_is_visible(current_module_id, visibility) {
+            errors.push(PathResolutionError::Private(path.last_ident()));
+        }
 
-fn resolve_external_dep(
-    crate_id: CrateId,
-    directive: &ImportDirective,
-    def_maps: &BTreeMap<CrateId, CrateDefMap>,
-    usage_tracker: &mut UsageTracker,
-    path_references: &mut Option<&mut Vec<ReferenceId>>,
-    importing_crate: CrateId,
-) -> NamespaceResolutionResult {
-    // Use extern_prelude to get the dep
-    let path = &directive.path.segments;
-
-    let current_def_map = &def_maps[&crate_id];
-
-    // Fetch the root module from the prelude
-    let crate_name = &path.first().unwrap().ident;
-    let dep_module = current_def_map
-        .extern_prelude
-        .get(&crate_name.0.contents)
-        .ok_or_else(|| PathResolutionError::Unresolved(crate_name.to_owned()))?;
-
-    // Create an import directive for the dependency crate
-    // XXX: This will panic if the path is of the form `use std`. Ideal algorithm will not distinguish between crate and module
-    // See `singleton_import.nr` test case for a check that such cases are handled elsewhere.
-    let path_without_crate_name = &path[1..];
-
-    if let Some(path_references) = path_references {
-        path_references.push(ReferenceId::Module(*dep_module));
+        Ok(ResolvedImport { namespace: current_ns, errors })
     }
 
-    let path = Path {
-        segments: path_without_crate_name.to_vec(),
-        kind: PathKind::Plain,
-        span: Span::default(),
-    };
-    let dep_directive = ImportDirective {
-        visibility: ItemVisibility::Private,
-        module_id: dep_module.local_id,
-        path,
-        alias: directive.alias.clone(),
-        is_prelude: false,
-    };
-
-    resolve_path_to_ns(
-        &dep_directive,
-        dep_module.krate,
-        importing_crate,
-        def_maps,
-        usage_tracker,
-        path_references,
-    )
-}
-
-// Returns false if the given private function is being called from a non-child module, or
-// if the given pub(crate) function is being called from another crate. Otherwise returns true.
-pub fn can_reference_module_id(
-    def_maps: &BTreeMap<CrateId, CrateDefMap>,
-    importing_crate: CrateId,
-    current_module: LocalModuleId,
-    target_module: ModuleId,
-    visibility: ItemVisibility,
-) -> bool {
-    // Note that if the target module is in a different crate from the current module then we will either
-    // return true as the target module is public or return false as it is private without looking at the `CrateDefMap` in either case.
-    let same_crate = target_module.krate == importing_crate;
-    let target_crate_def_map = &def_maps[&target_module.krate];
-
-    match visibility {
-        ItemVisibility::Public => true,
-        ItemVisibility::PublicCrate => same_crate,
-        ItemVisibility::Private => {
-            same_crate
-                && module_descendent_of_target(
-                    target_crate_def_map,
-                    target_module.local_id,
-                    current_module,
-                )
+    fn add_reference(&mut self, reference_id: ModuleDefId, span: Span, is_self_type_name: bool) {
+        if let Some(references_tracker) = &mut self.references_tracker {
+            references_tracker.add_reference(reference_id, span, is_self_type_name);
         }
     }
-}
 
-// Returns true if `current` is a (potentially nested) child module of `target`.
-// This is also true if `current == target`.
-fn module_descendent_of_target(
-    def_map: &CrateDefMap,
-    target: LocalModuleId,
-    current: LocalModuleId,
-) -> bool {
-    if current == target {
-        return true;
+    fn item_in_module_is_visible(&self, module: ModuleId, visibility: ItemVisibility) -> bool {
+        item_in_module_is_visible(self.def_maps, self.importing_module, module, visibility)
     }
+}
 
-    def_map.modules[current.0]
-        .parent
-        .map_or(false, |parent| module_descendent_of_target(def_map, target, parent))
+fn get_module(def_maps: &BTreeMap<CrateId, CrateDefMap>, module: ModuleId) -> &ModuleData {
+    let message = "A crate should always be present for a given crate id";
+    &def_maps.get(&module.krate).expect(message).modules[module.local_id.0]
 }
diff --git a/compiler/noirc_frontend/src/hir/resolution/mod.rs b/compiler/noirc_frontend/src/hir/resolution/mod.rs
index 01a3fe856e5..44a0114074e 100644
--- a/compiler/noirc_frontend/src/hir/resolution/mod.rs
+++ b/compiler/noirc_frontend/src/hir/resolution/mod.rs
@@ -7,4 +7,4 @@
 //! will have the same DefinitionId.
 pub mod errors;
 pub mod import;
-pub mod path_resolver;
+pub mod visibility;
diff --git a/compiler/noirc_frontend/src/hir/resolution/path_resolver.rs b/compiler/noirc_frontend/src/hir/resolution/path_resolver.rs
deleted file mode 100644
index 50089d849ae..00000000000
--- a/compiler/noirc_frontend/src/hir/resolution/path_resolver.rs
+++ /dev/null
@@ -1,84 +0,0 @@
-use super::import::{resolve_import, ImportDirective, PathResolution, PathResolutionResult};
-use crate::ast::{ItemVisibility, Path};
-use crate::node_interner::ReferenceId;
-use crate::usage_tracker::UsageTracker;
-use std::collections::BTreeMap;
-
-use crate::graph::CrateId;
-use crate::hir::def_map::{CrateDefMap, LocalModuleId, ModuleId};
-
-pub trait PathResolver {
-    /// Resolve the given path returning the resolved ModuleDefId.
-    /// If `path_references` is `Some`, a `ReferenceId` for each segment in `path`
-    /// will be resolved and pushed (some entries will be None if they don't refer to
-    /// a module or type).
-    fn resolve(
-        &self,
-        def_maps: &BTreeMap<CrateId, CrateDefMap>,
-        path: Path,
-        usage_tracker: &mut UsageTracker,
-        path_references: &mut Option<&mut Vec<ReferenceId>>,
-    ) -> PathResolutionResult;
-
-    fn local_module_id(&self) -> LocalModuleId;
-
-    fn module_id(&self) -> ModuleId;
-}
-
-pub struct StandardPathResolver {
-    // Module that we are resolving the path in
-    module_id: ModuleId,
-}
-
-impl StandardPathResolver {
-    pub fn new(module_id: ModuleId) -> StandardPathResolver {
-        Self { module_id }
-    }
-}
-
-impl PathResolver for StandardPathResolver {
-    fn resolve(
-        &self,
-        def_maps: &BTreeMap<CrateId, CrateDefMap>,
-        path: Path,
-        usage_tracker: &mut UsageTracker,
-        path_references: &mut Option<&mut Vec<ReferenceId>>,
-    ) -> PathResolutionResult {
-        resolve_path(def_maps, self.module_id, path, usage_tracker, path_references)
-    }
-
-    fn local_module_id(&self) -> LocalModuleId {
-        self.module_id.local_id
-    }
-
-    fn module_id(&self) -> ModuleId {
-        self.module_id
-    }
-}
-
-/// Resolve the given path to a function or a type.
-/// In the case of a conflict, functions are given priority
-pub fn resolve_path(
-    def_maps: &BTreeMap<CrateId, CrateDefMap>,
-    module_id: ModuleId,
-    path: Path,
-    usage_tracker: &mut UsageTracker,
-    path_references: &mut Option<&mut Vec<ReferenceId>>,
-) -> PathResolutionResult {
-    // lets package up the path into an ImportDirective and resolve it using that
-    let import = ImportDirective {
-        visibility: ItemVisibility::Private,
-        module_id: module_id.local_id,
-        path,
-        alias: None,
-        is_prelude: false,
-    };
-    let resolved_import =
-        resolve_import(module_id.krate, &import, def_maps, usage_tracker, path_references)?;
-
-    let namespace = resolved_import.resolved_namespace;
-    let id =
-        namespace.values.or(namespace.types).map(|(id, _, _)| id).expect("Found empty namespace");
-
-    Ok(PathResolution { module_def_id: id, error: resolved_import.error })
-}
diff --git a/compiler/noirc_frontend/src/hir/resolution/visibility.rs b/compiler/noirc_frontend/src/hir/resolution/visibility.rs
new file mode 100644
index 00000000000..c2fe887fe62
--- /dev/null
+++ b/compiler/noirc_frontend/src/hir/resolution/visibility.rs
@@ -0,0 +1,149 @@
+use crate::graph::CrateId;
+use crate::node_interner::{FuncId, NodeInterner, StructId};
+use crate::Type;
+
+use std::collections::BTreeMap;
+
+use crate::ast::ItemVisibility;
+use crate::hir::def_map::{CrateDefMap, DefMaps, LocalModuleId, ModuleId};
+
+/// Returns true if an item with the given visibility in the target module
+/// is visible from the current module. For example:
+/// ```text
+/// mod foo {
+///     ^^^ <-- target module
+///   pub(crate) fn bar() {}
+///   ^^^^^^^^^^ <- visibility
+/// }
+/// ```
+pub fn item_in_module_is_visible(
+    def_maps: &BTreeMap<CrateId, CrateDefMap>,
+    current_module: ModuleId,
+    target_module: ModuleId,
+    visibility: ItemVisibility,
+) -> bool {
+    // Note that if the target module is in a different crate from the current module then we will either
+    // return true as the target module is public or return false as it is private without looking at the `CrateDefMap` in either case.
+    let same_crate = target_module.krate == current_module.krate;
+
+    match visibility {
+        ItemVisibility::Public => true,
+        ItemVisibility::PublicCrate => same_crate,
+        ItemVisibility::Private => {
+            if !same_crate {
+                return false;
+            }
+
+            let target_crate_def_map = &def_maps[&target_module.krate];
+            module_descendent_of_target(
+                target_crate_def_map,
+                target_module.local_id,
+                current_module.local_id,
+            ) || module_is_parent_of_struct_module(
+                target_crate_def_map,
+                current_module.local_id,
+                target_module.local_id,
+            )
+        }
+    }
+}
+
+// Returns true if `current` is a (potentially nested) child module of `target`.
+// This is also true if `current == target`.
+pub(crate) fn module_descendent_of_target(
+    def_map: &CrateDefMap,
+    target: LocalModuleId,
+    current: LocalModuleId,
+) -> bool {
+    if current == target {
+        return true;
+    }
+
+    def_map.modules[current.0]
+        .parent
+        .map_or(false, |parent| module_descendent_of_target(def_map, target, parent))
+}
+
+/// Returns true if `target` is a struct and its parent is `current`.
+fn module_is_parent_of_struct_module(
+    def_map: &CrateDefMap,
+    current: LocalModuleId,
+    target: LocalModuleId,
+) -> bool {
+    let module_data = &def_map.modules[target.0];
+    module_data.is_struct && module_data.parent == Some(current)
+}
+
+pub fn struct_member_is_visible(
+    struct_id: StructId,
+    visibility: ItemVisibility,
+    current_module_id: ModuleId,
+    def_maps: &BTreeMap<CrateId, CrateDefMap>,
+) -> bool {
+    match visibility {
+        ItemVisibility::Public => true,
+        ItemVisibility::PublicCrate => {
+            struct_id.parent_module_id(def_maps).krate == current_module_id.krate
+        }
+        ItemVisibility::Private => {
+            let struct_parent_module_id = struct_id.parent_module_id(def_maps);
+            if struct_parent_module_id.krate != current_module_id.krate {
+                return false;
+            }
+
+            if struct_parent_module_id.local_id == current_module_id.local_id {
+                return true;
+            }
+
+            let def_map = &def_maps[&current_module_id.krate];
+            module_descendent_of_target(
+                def_map,
+                struct_parent_module_id.local_id,
+                current_module_id.local_id,
+            )
+        }
+    }
+}
+
+pub fn method_call_is_visible(
+    object_type: &Type,
+    func_id: FuncId,
+    current_module: ModuleId,
+    interner: &NodeInterner,
+    def_maps: &DefMaps,
+) -> bool {
+    let modifiers = interner.function_modifiers(&func_id);
+    match modifiers.visibility {
+        ItemVisibility::Public => true,
+        ItemVisibility::PublicCrate => {
+            if object_type.is_primitive() {
+                current_module.krate.is_stdlib()
+            } else {
+                interner.function_module(func_id).krate == current_module.krate
+            }
+        }
+        ItemVisibility::Private => {
+            if object_type.is_primitive() {
+                let func_module = interner.function_module(func_id);
+                item_in_module_is_visible(
+                    def_maps,
+                    current_module,
+                    func_module,
+                    modifiers.visibility,
+                )
+            } else {
+                let func_meta = interner.function_meta(&func_id);
+                if let Some(struct_id) = func_meta.struct_id {
+                    struct_member_is_visible(
+                        struct_id,
+                        modifiers.visibility,
+                        current_module,
+                        def_maps,
+                    )
+                } else {
+                    true
+                }
+            }
+        }
+    }
+}
diff --git a/compiler/noirc_frontend/src/hir/type_check/errors.rs b/compiler/noirc_frontend/src/hir/type_check/errors.rs
index 00e73e682e8..15b8d50c78b 100644
--- a/compiler/noirc_frontend/src/hir/type_check/errors.rs
+++ b/compiler/noirc_frontend/src/hir/type_check/errors.rs
@@ -5,14 +5,14 @@ use noirc_errors::CustomDiagnostic as Diagnostic;
 use noirc_errors::Span;
 use thiserror::Error;
 
-use crate::ast::ConstrainKind;
-use crate::ast::{BinaryOpKind, FunctionReturnType, IntegerBitSize, Signedness};
+use crate::ast::{
+    BinaryOpKind, ConstrainKind, FunctionReturnType, Ident, IntegerBitSize, Signedness,
+};
 use crate::hir::resolution::errors::ResolverError;
 use crate::hir_def::expr::HirBinaryOp;
 use crate::hir_def::traits::TraitConstraint;
-use crate::hir_def::types::Type;
-use crate::macros_api::Ident;
-use crate::macros_api::NodeInterner;
+use crate::hir_def::types::{BinaryTypeOperator, Kind, Type};
+use crate::node_interner::NodeInterner;
 
 #[derive(Error, Debug, Clone, PartialEq, Eq)]
 pub enum Source {
@@ -34,12 +34,22 @@ pub enum Source {
     Return(FunctionReturnType, Span),
 }
 
-#[derive(Error, Debug, Clone)]
+#[derive(Error, Debug, Clone, PartialEq, Eq)]
 pub enum TypeCheckError {
     #[error("Operator {op:?} cannot be used in a {place:?}")]
     OpCannotBeUsed { op: HirBinaryOp, place: &'static str, span: Span },
+    #[error("Division by zero: {lhs} / {rhs}")]
+    DivisionByZero { lhs: FieldElement, rhs: FieldElement, span: Span },
+    #[error("Modulo on Field elements: {lhs} % {rhs}")]
+    ModuloOnFields { lhs: FieldElement, rhs: FieldElement, span: Span },
     #[error("The value `{expr:?}` cannot fit into `{ty}` which has range `{range}`")]
     OverflowingAssignment { expr: FieldElement, ty: Type, range: String, span: Span },
+    #[error(
+        "The value `{value}` cannot fit into `{kind}` which has a maximum size of `{maximum_size}`"
+    )]
+    OverflowingConstant { value: FieldElement, kind: Kind, maximum_size: FieldElement, span: Span },
+    #[error("Evaluating `{op}` on `{lhs}`, `{rhs}` failed")]
+    FailingBinaryOp { op: BinaryTypeOperator, lhs: i128, rhs: i128, span: Span },
     #[error("Type {typ:?} cannot be used in a {place:?}")]
     TypeCannotBeUsed { typ: Type, place: &'static str, span: Span },
     #[error("Expected type {expected_typ:?} is not the same as {expr_typ:?}")]
@@ -48,12 +58,25 @@ pub enum TypeCheckError {
     TypeMismatchWithSource { expected: Type, actual: Type, span: Span, source: Source },
     #[error("Expected type {expected_kind:?} is not the same as {expr_kind:?}")]
     TypeKindMismatch { expected_kind: String, expr_kind: String, expr_span: Span },
+    #[error("Evaluating {to} resulted in {to_value}, but {from_value} was expected")]
+    TypeCanonicalizationMismatch {
+        to: Type,
+        from: Type,
+        to_value: FieldElement,
+        from_value: FieldElement,
+        span: Span,
+    },
+    // TODO(https://github.com/noir-lang/noir/issues/6238): implement handling for larger types
+    #[error("Expected type {expected_kind} when evaluating globals, but found {expr_kind} (this warning may become an error in the future)")]
+    EvaluatedGlobalIsntU32 { expected_kind: String, expr_kind: String, expr_span: Span },
     #[error("Expected {expected:?} found {found:?}")]
     ArityMisMatch { expected: usize, found: usize, span: Span },
     #[error("Return type in a function cannot be public")]
     PublicReturnType { typ: Type, span: Span },
     #[error("Cannot cast type {from}, 'as' is only for primitive field or integer types")]
-    InvalidCast { from: Type, span: Span },
+    InvalidCast { from: Type, span: Span, reason: String },
+    #[error("Casting value of type {from} to a smaller type ({to})")]
+    DownsizingCast { from: Type, to: Type, span: Span, reason: String },
     #[error("Expected a function, but found a(n) {found}")]
     ExpectedFunction { found: Type, span: Span },
     #[error("Type {lhs_type} has no member named {field_name}")]
@@ -76,6 +99,8 @@ pub enum TypeCheckError {
     CannotMutateImmutableVariable { name: String, span: Span },
     #[error("No method named '{method_name}' found for type '{object_type}'")]
     UnresolvedMethodCall { method_name: String, object_type: Type, span: Span },
+    #[error("Cannot invoke function field '{method_name}' on type '{object_type}' as a method")]
+    CannotInvokeStructFieldFunctionType { method_name: String, object_type: Type, span: Span },
     #[error("Integers must have the same signedness LHS is {sign_x:?}, RHS is {sign_y:?}")]
     IntegerSignedness { sign_x: Signedness, sign_y: Signedness, span: Span },
     #[error("Integers must have the same bit width LHS is {bit_width_x}, RHS is {bit_width_y}")]
@@ -153,6 +178,8 @@ pub enum TypeCheckError {
     Unsafe { span: Span },
     #[error("Converting an unconstrained fn to a non-unconstrained fn is unsafe")]
     UnsafeFn { span: Span },
+    #[error("Expected a constant, but found `{typ}`")]
+    NonConstantEvaluated { typ: Type, span: Span },
     #[error("Slices must have constant length")]
     NonConstantSliceLength { span: Span },
     #[error("Only sized types may be used in the entry point to a program")]
@@ -169,8 +196,6 @@ pub enum TypeCheckError {
     StringIndexAssign { span: Span },
     #[error("Macro calls may only return `Quoted` values")]
     MacroReturningNonExpr { typ: Type, span: Span },
-    #[error("turbofish (`::<_>`) usage at this position isn't supported yet")]
-    UnsupportedTurbofishUsage { span: Span },
     #[error("`{name}` has already been specified")]
     DuplicateNamedTypeArg { name: Ident, prev_span: Span },
     #[error("`{item}` has no associated type named `{name}`")]
@@ -181,11 +206,13 @@ pub enum TypeCheckError {
     UnspecifiedType { span: Span },
     #[error("Binding `{typ}` here to the `_` inside would create a cyclic type")]
     CyclicType { typ: Type, span: Span },
+    #[error("Type annotations required before indexing this array or slice")]
+    TypeAnnotationsNeededForIndex { span: Span },
 }
 
 #[derive(Debug, Clone, PartialEq, Eq)]
 pub struct NoMatchingImplFoundError {
-    constraints: Vec<(Type, String)>,
+    pub(crate) constraints: Vec<(Type, String)>,
     pub span: Span,
 }
 
@@ -193,6 +220,10 @@ impl TypeCheckError {
     pub fn add_context(self, ctx: &'static str) -> Self {
         TypeCheckError::Context { err: Box::new(self), ctx }
     }
+
+    pub(crate) fn is_non_constant_evaluated(&self) -> bool {
+        matches!(self, TypeCheckError::NonConstantEvaluated { .. })
+    }
 }
 
 impl<'a> From<&'a TypeCheckError> for Diagnostic {
@@ -213,6 +244,16 @@ impl<'a> From<&'a TypeCheckError> for Diagnostic {
                 String::new(),
                 *span,
             ),
+            TypeCheckError::DivisionByZero { lhs, rhs, span } => Diagnostic::simple_error(
+                format!("Division by zero: {lhs} / {rhs}"),
+                String::new(),
+                *span,
+            ),
+            TypeCheckError::ModuloOnFields { lhs, rhs, span } => Diagnostic::simple_error(
+                format!("Modulo on Field elements: {lhs} % {rhs}"),
+                String::new(),
+                *span,
+            ),
             TypeCheckError::TypeMismatch { expected_typ, expr_typ, expr_span } => {
                 Diagnostic::simple_error(
                     format!("Expected type {expected_typ}, found type {expr_typ}"),
@@ -227,6 +268,22 @@ impl<'a> From<&'a TypeCheckError> for Diagnostic {
                     *expr_span,
                 )
             }
+            TypeCheckError::TypeCanonicalizationMismatch { to, from, to_value, from_value, span } => {
+                Diagnostic::simple_error(
+                    format!("Evaluating {to} resulted in {to_value}, but {from_value} was expected"),
+                    format!("from evaluating {from} without simplifications"),
+                    *span,
+                )
+            }
+            // TODO(https://github.com/noir-lang/noir/issues/6238): implement
+            // handling for larger types
+            TypeCheckError::EvaluatedGlobalIsntU32 { expected_kind, expr_kind, expr_span } => {
+                Diagnostic::simple_warning(
+                    format!("Expected type {expected_kind} when evaluating globals, but found {expr_kind} (this warning may become an error in the future)"),
+                    String::new(),
+                    *expr_span,
+                )
+            }
             TypeCheckError::TraitMethodParameterTypeMismatch { method_name, expected_typ, actual_typ, parameter_index, parameter_span } => {
                 Diagnostic::simple_error(
                     format!("Parameter #{parameter_index} of method `{method_name}` must be of type {expected_typ}, not {actual_typ}"),
@@ -284,8 +341,14 @@ impl<'a> From<&'a TypeCheckError> for Diagnostic {
                 };
                 Diagnostic::simple_error(msg, String::new(), *span)
             }
-            TypeCheckError::InvalidCast { span, .. }
-            | TypeCheckError::ExpectedFunction { span, .. }
+            TypeCheckError::InvalidCast { span, reason, .. } => {
+                Diagnostic::simple_error(error.to_string(), reason.clone(), *span)
+            }
+            TypeCheckError::DownsizingCast { span, reason, .. } => {
+                Diagnostic::simple_warning(error.to_string(), reason.clone(), *span)
+            }
+
+            TypeCheckError::ExpectedFunction { span, .. }
             | TypeCheckError::AccessUnknownMember { span, .. }
             | TypeCheckError::UnsupportedCast { span }
             | TypeCheckError::TupleIndexOutOfBounds { span, .. }
@@ -302,11 +365,14 @@ impl<'a> From<&'a TypeCheckError> for Diagnostic {
             | TypeCheckError::AmbiguousBitWidth { span, .. }
             | TypeCheckError::IntegerAndFieldBinaryOperation { span }
             | TypeCheckError::OverflowingAssignment { span, .. }
+            | TypeCheckError::OverflowingConstant { span, .. }
+            | TypeCheckError::FailingBinaryOp { span, .. }
             | TypeCheckError::FieldModulo { span }
             | TypeCheckError::FieldNot { span }
             | TypeCheckError::ConstrainedReferenceToUnconstrained { span }
             | TypeCheckError::UnconstrainedReferenceToConstrained { span }
             | TypeCheckError::UnconstrainedSliceReturnToConstrained { span }
+            | TypeCheckError::NonConstantEvaluated { span, .. }
             | TypeCheckError::NonConstantSliceLength { span }
             | TypeCheckError::StringIndexAssign { span }
             | TypeCheckError::InvalidShiftSize { span } => {
@@ -414,14 +480,14 @@ impl<'a> From<&'a TypeCheckError> for Diagnostic {
                 let msg = format!("Expected {expected_count} generic{expected_plural} from this function, but {actual_count} {actual_plural} provided");
                 Diagnostic::simple_error(msg, "".into(), *span)
             },
-            TypeCheckError::MacroReturningNonExpr { typ, span } => Diagnostic::simple_error(
-                format!("Expected macro call to return a `Quoted` but found a(n) `{typ}`"),
-                "Macro calls must return quoted values, otherwise there is no code to insert".into(),
-                *span,
-            ),
-            TypeCheckError::UnsupportedTurbofishUsage { span } => {
-                let msg = "turbofish (`::<_>`)  usage at this position isn't supported yet";
-                Diagnostic::simple_error(msg.to_string(), "".to_string(), *span)
+            TypeCheckError::MacroReturningNonExpr { typ, span } =>  {
+                let mut error = Diagnostic::simple_error(
+                    format!("Expected macro call to return a `Quoted` but found a(n) `{typ}`"),
+                    "Macro calls must return quoted values, otherwise there is no code to insert.".into(),
+                    *span,
+                );
+                error.add_secondary("Hint: remove the `!` from the end of the function name.".to_string(), *span);
+                error
             },
             TypeCheckError::DuplicateNamedTypeArg { name, prev_span } => {
                 let msg = format!("`{name}` has already been specified");
@@ -449,6 +515,20 @@ impl<'a> From<&'a TypeCheckError> for Diagnostic {
             TypeCheckError::CyclicType { typ: _, span } => {
                 Diagnostic::simple_error(error.to_string(), "Cyclic types have unlimited size and are prohibited in Noir".into(), *span)
             }
+            TypeCheckError::CannotInvokeStructFieldFunctionType { method_name, object_type, span } => {
+                Diagnostic::simple_error(
+                    format!("Cannot invoke function field '{method_name}' on type '{object_type}' as a method"), 
+                    format!("to call the function stored in '{method_name}', surround the field access with parentheses: '(', ')'"),
+                    *span,
+                )
+            },
+            TypeCheckError::TypeAnnotationsNeededForIndex { span } => {
+                Diagnostic::simple_error(
+                    "Type annotations required before indexing this array or slice".into(), 
+                    "Type annotations needed before this point, can't decide if this is an array or slice".into(),
+                    *span,
+                )
+            },
         }
     }
 }
@@ -486,8 +566,8 @@ impl NoMatchingImplFoundError {
         let constraints = failing_constraints
             .into_iter()
             .map(|constraint| {
-                let r#trait = interner.try_get_trait(constraint.trait_id)?;
-                let name = format!("{}{}", r#trait.name, constraint.trait_generics);
+                let r#trait = interner.try_get_trait(constraint.trait_bound.trait_id)?;
+                let name = format!("{}{}", r#trait.name, constraint.trait_bound.trait_generics);
                 Some((constraint.typ, name))
             })
             .collect::<Option<Vec<_>>>()?;
diff --git a/compiler/noirc_frontend/src/hir/type_check/generics.rs b/compiler/noirc_frontend/src/hir/type_check/generics.rs
index b86e2350279..370223f1f11 100644
--- a/compiler/noirc_frontend/src/hir/type_check/generics.rs
+++ b/compiler/noirc_frontend/src/hir/type_check/generics.rs
@@ -4,8 +4,7 @@ use iter_extended::vecmap;
 
 use crate::{
     hir_def::traits::NamedType,
-    macros_api::NodeInterner,
-    node_interner::{FuncId, TraitId, TypeAliasId},
+    node_interner::{FuncId, NodeInterner, TraitId, TypeAliasId},
     ResolvedGeneric, StructType, Type,
 };
 
@@ -134,6 +133,10 @@ impl TraitGenerics {
             vecmap(&self.named, |named| NamedType { name: named.name.clone(), typ: f(&named.typ) });
         TraitGenerics { ordered, named }
     }
+
+    pub fn is_empty(&self) -> bool {
+        self.ordered.is_empty() && self.named.is_empty()
+    }
 }
 
 impl std::fmt::Display for TraitGenerics {
diff --git a/compiler/noirc_frontend/src/hir_def/expr.rs b/compiler/noirc_frontend/src/hir_def/expr.rs
index 063b960863c..e243fc88cff 100644
--- a/compiler/noirc_frontend/src/hir_def/expr.rs
+++ b/compiler/noirc_frontend/src/hir_def/expr.rs
@@ -7,11 +7,11 @@ use crate::hir::type_check::generics::TraitGenerics;
 use crate::node_interner::{
     DefinitionId, DefinitionKind, ExprId, FuncId, NodeInterner, StmtId, TraitMethodId,
 };
-use crate::token::Tokens;
+use crate::token::{FmtStrFragment, Tokens};
 use crate::Shared;
 
 use super::stmt::HirPattern;
-use super::traits::TraitConstraint;
+use super::traits::{ResolvedTraitBound, TraitConstraint};
 use super::types::{StructType, Type};
 
 /// A HirExpression is the result of an Expression in the AST undergoing
@@ -70,7 +70,14 @@ pub enum ImplKind {
     /// and eventually linked to this id. The boolean indicates whether the impl
     /// is already assumed to exist - e.g. when resolving a path such as `T::default`
     /// when there is a corresponding `T: Default` constraint in scope.
-    TraitMethod(TraitMethodId, TraitConstraint, bool),
+    TraitMethod(TraitMethod),
+}
+
+#[derive(Debug, Clone)]
+pub struct TraitMethod {
+    pub method_id: TraitMethodId,
+    pub constraint: TraitConstraint,
+    pub assumed: bool,
 }
 
 impl Eq for HirIdent {}
@@ -107,7 +114,7 @@ pub enum HirLiteral {
     Bool(bool),
     Integer(FieldElement, bool), //true for negative integer and false for positive
     Str(String),
-    FmtStr(String, Vec<ExprId>),
+    FmtStr(Vec<FmtStrFragment>, Vec<ExprId>, u32 /* length */),
     Unit,
 }
 
@@ -243,11 +250,13 @@ impl HirMethodCallExpression {
                 let id = interner.trait_method_id(method_id);
                 let constraint = TraitConstraint {
                     typ: object_type,
-                    trait_id: method_id.trait_id,
-                    trait_generics,
-                    span: location.span,
+                    trait_bound: ResolvedTraitBound {
+                        trait_id: method_id.trait_id,
+                        trait_generics,
+                        span: location.span,
+                    },
                 };
-                (id, ImplKind::TraitMethod(method_id, constraint, false))
+                (id, ImplKind::TraitMethod(TraitMethod { method_id, constraint, assumed: false }))
             }
         };
         let func_var = HirIdent { location, id, impl_kind };
diff --git a/compiler/noirc_frontend/src/hir_def/function.rs b/compiler/noirc_frontend/src/hir_def/function.rs
index 39c87607446..db6c3507b15 100644
--- a/compiler/noirc_frontend/src/hir_def/function.rs
+++ b/compiler/noirc_frontend/src/hir_def/function.rs
@@ -5,12 +5,11 @@ use noirc_errors::{Location, Span};
 use super::expr::{HirBlockExpression, HirExpression, HirIdent};
 use super::stmt::HirPattern;
 use super::traits::TraitConstraint;
-use crate::ast::{FunctionKind, FunctionReturnType, Visibility};
+use crate::ast::{BlockExpression, FunctionKind, FunctionReturnType, Visibility};
 use crate::graph::CrateId;
 use crate::hir::def_map::LocalModuleId;
-use crate::macros_api::{BlockExpression, StructId};
-use crate::node_interner::{ExprId, NodeInterner, TraitId, TraitImplId};
-use crate::token::CustomAttribute;
+use crate::node_interner::{ExprId, NodeInterner, StructId, TraitId, TraitImplId};
+
 use crate::{ResolvedGeneric, Type};
 
 /// A Hir function is a block expression with a list of statements.
@@ -165,9 +164,6 @@ pub struct FuncMeta {
     /// If this function is from an impl (trait or regular impl), this
     /// is the object type of the impl. Otherwise this is None.
     pub self_type: Option<Type>,
-
-    /// Custom attributes attached to this function.
-    pub custom_attributes: Vec<CustomAttribute>,
 }
 
 #[derive(Debug, Clone)]
diff --git a/compiler/noirc_frontend/src/hir_def/stmt.rs b/compiler/noirc_frontend/src/hir_def/stmt.rs
index 0b4dbeb3006..0258cfd8ddb 100644
--- a/compiler/noirc_frontend/src/hir_def/stmt.rs
+++ b/compiler/noirc_frontend/src/hir_def/stmt.rs
@@ -1,7 +1,7 @@
 use super::expr::HirIdent;
 use crate::ast::Ident;
-use crate::macros_api::SecondaryAttribute;
 use crate::node_interner::{ExprId, StmtId};
+use crate::token::SecondaryAttribute;
 use crate::Type;
 use fm::FileId;
 use noirc_errors::{Location, Span};
@@ -105,7 +105,7 @@ impl HirPattern {
         }
     }
 
-    pub(crate) fn location(&self) -> Location {
+    pub fn location(&self) -> Location {
         match self {
             HirPattern::Identifier(ident) => ident.location,
             HirPattern::Mutable(_, location)
diff --git a/compiler/noirc_frontend/src/hir_def/traits.rs b/compiler/noirc_frontend/src/hir_def/traits.rs
index 0572ba403a1..6fd3c4f7a24 100644
--- a/compiler/noirc_frontend/src/hir_def/traits.rs
+++ b/compiler/noirc_frontend/src/hir_def/traits.rs
@@ -3,12 +3,12 @@ use rustc_hash::FxHashMap as HashMap;
 
 use crate::ast::{Ident, NoirFunction};
 use crate::hir::type_check::generics::TraitGenerics;
+use crate::ResolvedGeneric;
 use crate::{
     graph::CrateId,
     node_interner::{FuncId, TraitId, TraitMethodId},
     Generics, Type, TypeBindings, TypeVariable,
 };
-use crate::{ResolvedGeneric, TypeVariableKind};
 use fm::FileId;
 use noirc_errors::{Location, Span};
 
@@ -72,6 +72,11 @@ pub struct Trait {
     /// match the definition in the trait, we bind this TypeVariable to whatever
     /// the correct Self type is for that particular impl block.
     pub self_type_typevar: TypeVariable,
+
+    /// The resolved trait bounds (for example in `trait Foo: Bar + Baz`, this would be `Bar + Baz`)
+    pub trait_bounds: Vec<ResolvedTraitBound>,
+
+    pub where_clause: Vec<TraitConstraint>,
 }
 
 #[derive(Debug)]
@@ -101,15 +106,25 @@ pub struct TraitImpl {
 #[derive(Debug, Clone, PartialEq, Eq)]
 pub struct TraitConstraint {
     pub typ: Type,
-    pub trait_id: TraitId,
-    pub trait_generics: TraitGenerics,
-    pub span: Span,
+    pub trait_bound: ResolvedTraitBound,
 }
 
 impl TraitConstraint {
     pub fn apply_bindings(&mut self, type_bindings: &TypeBindings) {
         self.typ = self.typ.substitute(type_bindings);
+        self.trait_bound.apply_bindings(type_bindings);
+    }
+}
+
+#[derive(Debug, Clone, PartialEq, Eq)]
+pub struct ResolvedTraitBound {
+    pub trait_id: TraitId,
+    pub trait_generics: TraitGenerics,
+    pub span: Span,
+}
 
+impl ResolvedTraitBound {
+    pub fn apply_bindings(&mut self, type_bindings: &TypeBindings) {
         for typ in &mut self.trait_generics.ordered {
             *typ = typ.substitute(type_bindings);
         }
@@ -137,6 +152,14 @@ impl Trait {
         self.methods = methods;
     }
 
+    pub fn set_trait_bounds(&mut self, trait_bounds: Vec<ResolvedTraitBound>) {
+        self.trait_bounds = trait_bounds;
+    }
+
+    pub fn set_where_clause(&mut self, where_clause: Vec<TraitConstraint>) {
+        self.where_clause = where_clause;
+    }
+
     pub fn find_method(&self, name: &str) -> Option<TraitMethodId> {
         for (idx, method) in self.methods.iter().enumerate() {
             if &method.name == name {
@@ -168,10 +191,12 @@ impl Trait {
         });
 
         TraitConstraint {
-            typ: Type::TypeVariable(self.self_type_typevar.clone(), TypeVariableKind::Normal),
-            trait_generics: TraitGenerics { ordered, named },
-            trait_id: self.id,
-            span,
+            typ: Type::TypeVariable(self.self_type_typevar.clone()),
+            trait_bound: ResolvedTraitBound {
+                trait_generics: TraitGenerics { ordered, named },
+                trait_id: self.id,
+                span,
+            },
         }
     }
 }
diff --git a/compiler/noirc_frontend/src/hir_def/types.rs b/compiler/noirc_frontend/src/hir_def/types.rs
index c170d2cc08f..2c9a44c079d 100644
--- a/compiler/noirc_frontend/src/hir_def/types.rs
+++ b/compiler/noirc_frontend/src/hir_def/types.rs
@@ -5,8 +5,13 @@ use std::{
     rc::Rc,
 };
 
+#[cfg(test)]
+use proptest_derive::Arbitrary;
+
+use acvm::{AcirField, FieldElement};
+
 use crate::{
-    ast::IntegerBitSize,
+    ast::{IntegerBitSize, ItemVisibility},
     hir::type_check::{generics::TraitGenerics, TypeCheckError},
     node_interner::{ExprId, NodeInterner, TraitId, TypeAliasId},
 };
@@ -78,7 +83,7 @@ pub enum Type {
     /// is a process that replaces each NamedGeneric in a generic function with a TypeVariable.
     /// Doing this at each call site of a generic function is how they can be called with
     /// different argument types each time.
-    TypeVariable(TypeVariable, TypeVariableKind),
+    TypeVariable(TypeVariable),
 
     /// `impl Trait` when used in a type position.
     /// These are only matched based on the TraitId. The trait name parameter is only
@@ -87,7 +92,15 @@ pub enum Type {
 
     /// NamedGenerics are the 'T' or 'U' in a user-defined generic function
     /// like `fn foo<T, U>(...) {}`. Unlike TypeVariables, they cannot be bound over.
-    NamedGeneric(TypeVariable, Rc<String>, Kind),
+    NamedGeneric(TypeVariable, Rc<String>),
+
+    /// A cast (to, from) that's checked at monomorphization.
+    ///
+    /// Simplifications on arithmetic generics are only allowed on the LHS.
+    CheckedCast {
+        from: Box<Type>,
+        to: Box<Type>,
+    },
 
     /// A functions with arguments, a return type and environment.
     /// the environment should be `Unit` by default,
@@ -110,9 +123,11 @@ pub enum Type {
     /// will be and thus needs the full TypeVariable link.
     Forall(GenericTypeVars, Box<Type>),
 
-    /// A type-level integer. Included to let an Array's size type variable
-    /// bind to an integer without special checks to bind it to a non-type.
-    Constant(u32, Kind),
+    /// A type-level integer. Included to let
+    /// 1. an Array's size type variable
+    ///     bind to an integer without special checks to bind it to a non-type.
+    /// 2. values to be used at the type level
+    Constant(FieldElement, Kind),
 
     /// The type of quoted code in macros. This is always a comptime-only type
     Quoted(QuotedType),
@@ -134,34 +149,84 @@ pub enum Type {
 /// is expected (such as in an array length position) are expected to be of kind `Kind::Numeric`.
 #[derive(PartialEq, Eq, Clone, Hash, Debug, PartialOrd, Ord)]
 pub enum Kind {
+    /// Can bind to any type
+    // TODO(https://github.com/noir-lang/noir/issues/6194): evaluate need for and usage of
+    Any,
+
+    /// Can bind to any type, except Type::Constant and Type::InfixExpr
     Normal,
+
+    /// A generic integer or field type. This is a more specific kind of TypeVariable
+    /// that can only be bound to Type::Field, Type::Integer, or other polymorphic integers.
+    /// This is the type of undecorated integer literals like `46`. Typing them in this way
+    /// allows them to be polymorphic over the actual integer/field type used without requiring
+    /// type annotations on each integer literal.
+    IntegerOrField,
+
+    /// A generic integer type. This is a more specific kind of TypeVariable
+    /// that can only be bound to Type::Integer, or other polymorphic integers.
+    Integer,
+
+    /// Can bind to a Type::Constant or Type::InfixExpr of the given kind
     Numeric(Box<Type>),
 }
 
 impl Kind {
+    // Kind::Numeric constructor helper
+    pub fn numeric(typ: Type) -> Kind {
+        Kind::Numeric(Box::new(typ))
+    }
+
     pub(crate) fn is_error(&self) -> bool {
-        match self {
-            Self::Numeric(typ) => **typ == Type::Error,
+        match self.follow_bindings() {
+            Self::Numeric(typ) => *typ == Type::Error,
             _ => false,
         }
     }
 
-    pub(crate) fn is_numeric(&self) -> bool {
-        matches!(self, Self::Numeric { .. })
+    pub(crate) fn is_type_level_field_element(&self) -> bool {
+        let type_level = false;
+        self.is_field_element(type_level)
     }
 
-    pub(crate) fn matches_opt(&self, other: Option<Self>) -> bool {
-        other.as_ref().map_or(true, |other_kind| self.unifies(other_kind))
+    /// If value_level, only check for Type::FieldElement,
+    /// else only check for a type-level FieldElement
+    fn is_field_element(&self, value_level: bool) -> bool {
+        match self.follow_bindings() {
+            Kind::Numeric(typ) => typ.is_field_element(value_level),
+            Kind::IntegerOrField => value_level,
+            _ => false,
+        }
     }
 
     pub(crate) fn u32() -> Self {
-        Self::Numeric(Box::new(Type::Integer(Signedness::Unsigned, IntegerBitSize::ThirtyTwo)))
+        Self::numeric(Type::Integer(Signedness::Unsigned, IntegerBitSize::ThirtyTwo))
+    }
+
+    pub(crate) fn follow_bindings(&self) -> Self {
+        match self {
+            Self::Any => Self::Any,
+            Self::Normal => Self::Normal,
+            Self::Integer => Self::Integer,
+            Self::IntegerOrField => Self::IntegerOrField,
+            Self::Numeric(typ) => Self::numeric(typ.follow_bindings()),
+        }
     }
 
     /// Unifies this kind with the other. Returns true on success
     pub(crate) fn unifies(&self, other: &Kind) -> bool {
         match (self, other) {
-            (Kind::Normal, Kind::Normal) => true,
+            // Kind::Any unifies with everything
+            (Kind::Any, _) | (_, Kind::Any) => true,
+
+            // Kind::Normal unifies with Kind::Integer and Kind::IntegerOrField
+            (Kind::Normal, Kind::Integer | Kind::IntegerOrField)
+            | (Kind::Integer | Kind::IntegerOrField, Kind::Normal) => true,
+
+            // Kind::Integer unifies with Kind::IntegerOrField
+            (Kind::Integer | Kind::IntegerOrField, Kind::Integer | Kind::IntegerOrField) => true,
+
+            // Kind::Numeric unifies along its Type argument
             (Kind::Numeric(lhs), Kind::Numeric(rhs)) => {
                 let mut bindings = TypeBindings::new();
                 let unifies = lhs.try_unify(rhs, &mut bindings).is_ok();
@@ -170,7 +235,9 @@ impl Kind {
                 }
                 unifies
             }
-            _ => false,
+
+            // everything unifies with itself
+            (lhs, rhs) => lhs == rhs,
         }
     }
 
@@ -181,18 +248,58 @@ impl Kind {
             Err(UnificationError)
         }
     }
+
+    /// Returns the default type this type variable should be bound to if it is still unbound
+    /// during monomorphization.
+    pub(crate) fn default_type(&self) -> Option<Type> {
+        match self {
+            Kind::IntegerOrField => Some(Type::default_int_or_field_type()),
+            Kind::Integer => Some(Type::default_int_type()),
+            Kind::Any | Kind::Normal | Kind::Numeric(..) => None,
+        }
+    }
+
+    fn integral_maximum_size(&self) -> Option<FieldElement> {
+        match self.follow_bindings() {
+            Kind::Any | Kind::IntegerOrField | Kind::Integer | Kind::Normal => None,
+            Self::Numeric(typ) => typ.integral_maximum_size(),
+        }
+    }
+
+    /// Ensure the given value fits in self.integral_maximum_size()
+    fn ensure_value_fits(
+        &self,
+        value: FieldElement,
+        span: Span,
+    ) -> Result<FieldElement, TypeCheckError> {
+        match self.integral_maximum_size() {
+            None => Ok(value),
+            Some(maximum_size) => (value <= maximum_size).then_some(value).ok_or_else(|| {
+                TypeCheckError::OverflowingConstant {
+                    value,
+                    kind: self.clone(),
+                    maximum_size,
+                    span,
+                }
+            }),
+        }
+    }
 }
 
 impl std::fmt::Display for Kind {
     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
         match self {
+            Kind::Any => write!(f, "any"),
             Kind::Normal => write!(f, "normal"),
+            Kind::Integer => write!(f, "int"),
+            Kind::IntegerOrField => write!(f, "intOrField"),
             Kind::Numeric(typ) => write!(f, "numeric {}", typ),
         }
     }
 }
 
 #[derive(Debug, PartialEq, Eq, Copy, Clone, Hash, PartialOrd, Ord)]
+#[cfg_attr(test, derive(strum_macros::EnumIter))]
 pub enum QuotedType {
     Expr,
     Quoted,
@@ -209,15 +316,14 @@ pub enum QuotedType {
     CtString,
 }
 
-/// A list of TypeVariableIds to bind to a type. Storing the
+/// A list of (TypeVariableId, Kind)'s to bind to a type. Storing the
 /// TypeVariable in addition to the matching TypeVariableId allows
 /// the binding to later be undone if needed.
-pub type TypeBindings = HashMap<TypeVariableId, (TypeVariable, Type)>;
+pub type TypeBindings = HashMap<TypeVariableId, (TypeVariable, Kind, Type)>;
 
 /// Represents a struct type in the type system. Each instance of this
 /// rust struct will be shared across all Type::Struct variants that represent
 /// the same struct type.
-#[derive(Eq)]
 pub struct StructType {
     /// A unique id representing this struct type. Used to check if two
     /// struct types are equal.
@@ -228,15 +334,21 @@ pub struct StructType {
     /// Fields are ordered and private, they should only
     /// be accessed through get_field(), get_fields(), or instantiate()
     /// since these will handle applying generic arguments to fields as well.
-    fields: Vec<(Ident, Type)>,
+    fields: Vec<StructField>,
 
     pub generics: Generics,
     pub location: Location,
 }
 
+pub struct StructField {
+    pub visibility: ItemVisibility,
+    pub name: Ident,
+    pub typ: Type,
+}
+
 /// Corresponds to generic lists such as `<T, U>` in the source program.
 /// Used mainly for resolved types which no longer need information such
-/// as names or kinds.
+/// as names or kinds
 pub type GenericTypeVars = Vec<TypeVariable>;
 
 /// Corresponds to generic lists such as `<T, U>` with additional
@@ -248,17 +360,16 @@ pub type Generics = Vec<ResolvedGeneric>;
 pub struct ResolvedGeneric {
     pub name: Rc<String>,
     pub type_var: TypeVariable,
-    pub kind: Kind,
     pub span: Span,
 }
 
 impl ResolvedGeneric {
     pub fn as_named_generic(self) -> Type {
-        Type::NamedGeneric(self.type_var, self.name, self.kind)
+        Type::NamedGeneric(self.type_var, self.name)
     }
 
-    pub(crate) fn is_numeric(&self) -> bool {
-        self.kind.is_numeric()
+    pub fn kind(&self) -> Kind {
+        self.type_var.kind()
     }
 }
 
@@ -274,6 +385,8 @@ impl std::hash::Hash for StructType {
     }
 }
 
+impl Eq for StructType {}
+
 impl PartialEq for StructType {
     fn eq(&self, other: &Self) -> bool {
         self.id == other.id
@@ -298,7 +411,7 @@ impl StructType {
         name: Ident,
 
         location: Location,
-        fields: Vec<(Ident, Type)>,
+        fields: Vec<StructField>,
         generics: Generics,
     ) -> StructType {
         StructType { id, fields, name, location, generics }
@@ -308,7 +421,7 @@ impl StructType {
     /// fields are resolved strictly after the struct itself is initially
     /// created. Therefore, this method is used to set the fields once they
     /// become known.
-    pub fn set_fields(&mut self, fields: Vec<(Ident, Type)>) {
+    pub fn set_fields(&mut self, fields: Vec<StructField>) {
         self.fields = fields;
     }
 
@@ -316,39 +429,68 @@ impl StructType {
         self.fields.len()
     }
 
-    /// Returns the field matching the given field name, as well as its field index.
-    pub fn get_field(&self, field_name: &str, generic_args: &[Type]) -> Option<(Type, usize)> {
+    /// Returns the field matching the given field name, as well as its visibility and field index.
+    pub fn get_field(
+        &self,
+        field_name: &str,
+        generic_args: &[Type],
+    ) -> Option<(Type, ItemVisibility, usize)> {
         assert_eq!(self.generics.len(), generic_args.len());
 
-        self.fields.iter().enumerate().find(|(_, (name, _))| name.0.contents == field_name).map(
-            |(i, (_, typ))| {
+        self.fields.iter().enumerate().find(|(_, field)| field.name.0.contents == field_name).map(
+            |(i, field)| {
                 let substitutions = self
                     .generics
                     .iter()
                     .zip(generic_args)
-                    .map(|(old, new)| (old.type_var.id(), (old.type_var.clone(), new.clone())))
+                    .map(|(old, new)| {
+                        (
+                            old.type_var.id(),
+                            (old.type_var.clone(), old.type_var.kind(), new.clone()),
+                        )
+                    })
                     .collect();
 
-                (typ.substitute(&substitutions), i)
+                (field.typ.substitute(&substitutions), field.visibility, i)
             },
         )
     }
 
     /// Returns all the fields of this type, after being applied to the given generic arguments.
+    pub fn get_fields_with_visibility(
+        &self,
+        generic_args: &[Type],
+    ) -> Vec<(String, ItemVisibility, Type)> {
+        let substitutions = self.get_fields_substitutions(generic_args);
+
+        vecmap(&self.fields, |field| {
+            let name = field.name.0.contents.clone();
+            (name, field.visibility, field.typ.substitute(&substitutions))
+        })
+    }
+
     pub fn get_fields(&self, generic_args: &[Type]) -> Vec<(String, Type)> {
+        let substitutions = self.get_fields_substitutions(generic_args);
+
+        vecmap(&self.fields, |field| {
+            let name = field.name.0.contents.clone();
+            (name, field.typ.substitute(&substitutions))
+        })
+    }
+
+    fn get_fields_substitutions(
+        &self,
+        generic_args: &[Type],
+    ) -> HashMap<TypeVariableId, (TypeVariable, Kind, Type)> {
         assert_eq!(self.generics.len(), generic_args.len());
 
-        let substitutions = self
-            .generics
+        self.generics
             .iter()
             .zip(generic_args)
-            .map(|(old, new)| (old.type_var.id(), (old.type_var.clone(), new.clone())))
-            .collect();
-
-        vecmap(&self.fields, |(name, typ)| {
-            let name = name.0.contents.clone();
-            (name, typ.substitute(&substitutions))
-        })
+            .map(|(old, new)| {
+                (old.type_var.id(), (old.type_var.clone(), old.type_var.kind(), new.clone()))
+            })
+            .collect()
     }
 
     /// Returns the name and raw types of each field of this type.
@@ -357,30 +499,27 @@ impl StructType {
     ///
     /// This method is almost never what is wanted for type checking or monomorphization,
     /// prefer to use `get_fields` whenever possible.
-    pub fn get_fields_as_written(&self) -> Vec<(String, Type)> {
-        vecmap(&self.fields, |(name, typ)| (name.0.contents.clone(), typ.clone()))
+    pub fn get_fields_as_written(&self) -> Vec<StructField> {
+        vecmap(&self.fields, |field| StructField {
+            visibility: field.visibility,
+            name: field.name.clone(),
+            typ: field.typ.clone(),
+        })
     }
 
     /// Returns the field at the given index. Panics if no field exists at the given index.
-    pub fn field_at(&self, index: usize) -> &(Ident, Type) {
+    pub fn field_at(&self, index: usize) -> &StructField {
         &self.fields[index]
     }
 
     pub fn field_names(&self) -> BTreeSet<Ident> {
-        self.fields.iter().map(|(name, _)| name.clone()).collect()
-    }
-
-    /// Search the fields of a struct for any types with a `TypeKind::Numeric`
-    pub fn find_numeric_generics_in_fields(&self, found_names: &mut Vec<String>) {
-        for (_, field) in self.fields.iter() {
-            field.find_numeric_type_vars(found_names);
-        }
+        self.fields.iter().map(|field| field.name.clone()).collect()
     }
 
     /// Instantiate this struct type, returning a Vec of the new generic args (in
     /// the same order as self.generics)
     pub fn instantiate(&self, interner: &mut NodeInterner) -> Vec<Type> {
-        vecmap(&self.generics, |_| interner.next_type_variable())
+        vecmap(&self.generics, |generic| interner.next_type_variable_with_kind(generic.kind()))
     }
 }
 
@@ -454,11 +593,18 @@ impl TypeAlias {
             .generics
             .iter()
             .zip(generic_args)
-            .map(|(old, new)| (old.type_var.id(), (old.type_var.clone(), new.clone())))
+            .map(|(old, new)| {
+                (old.type_var.id(), (old.type_var.clone(), old.type_var.kind(), new.clone()))
+            })
             .collect();
 
         self.typ.substitute(&substitutions)
     }
+
+    pub fn instantiate(&self, interner: &NodeInterner) -> Type {
+        let args = vecmap(&self.generics, |_| interner.next_type_variable());
+        self.get_type(&args)
+    }
 }
 
 /// A shared, mutable reference to some T.
@@ -518,6 +664,7 @@ impl<T> Shared<T> {
 
 /// A restricted subset of binary operators useable on
 /// type level integers for use in the array length positions of types.
+#[cfg_attr(test, derive(Arbitrary))]
 #[derive(Debug, Copy, Clone, Hash, PartialEq, Eq, PartialOrd, Ord)]
 pub enum BinaryTypeOperator {
     Addition,
@@ -527,31 +674,14 @@ pub enum BinaryTypeOperator {
     Modulo,
 }
 
-#[derive(Debug, PartialEq, Eq, Clone, Hash, PartialOrd, Ord)]
-pub enum TypeVariableKind {
-    /// Can bind to any type
-    Normal,
-
-    /// A generic integer or field type. This is a more specific kind of TypeVariable
-    /// that can only be bound to Type::Field, Type::Integer, or other polymorphic integers.
-    /// This is the type of undecorated integer literals like `46`. Typing them in this way
-    /// allows them to be polymorphic over the actual integer/field type used without requiring
-    /// type annotations on each integer literal.
-    IntegerOrField,
-
-    /// A generic integer type. This is a more specific kind of TypeVariable
-    /// that can only be bound to Type::Integer, or other polymorphic integers.
-    Integer,
-}
-
 /// A TypeVariable is a mutable reference that is either
 /// bound to some type, or unbound with a given TypeVariableId.
 #[derive(PartialEq, Eq, Clone, Hash, PartialOrd, Ord)]
 pub struct TypeVariable(TypeVariableId, Shared<TypeBinding>);
 
 impl TypeVariable {
-    pub fn unbound(id: TypeVariableId) -> Self {
-        TypeVariable(id, Shared::new(TypeBinding::Unbound(id)))
+    pub fn unbound(id: TypeVariableId, type_var_kind: Kind) -> Self {
+        TypeVariable(id, Shared::new(TypeBinding::Unbound(id, type_var_kind)))
     }
 
     pub fn id(&self) -> TypeVariableId {
@@ -568,19 +698,27 @@ impl TypeVariable {
             TypeBinding::Bound(binding) => {
                 unreachable!("TypeVariable::bind, cannot bind bound var {} to {}", binding, typ)
             }
-            TypeBinding::Unbound(id) => *id,
+            TypeBinding::Unbound(id, _) => *id,
         };
 
         assert!(!typ.occurs(id), "{self:?} occurs within {typ:?}");
         *self.1.borrow_mut() = TypeBinding::Bound(typ);
     }
 
-    pub fn try_bind(&self, binding: Type, span: Span) -> Result<(), TypeCheckError> {
+    pub fn try_bind(&self, binding: Type, kind: &Kind, span: Span) -> Result<(), TypeCheckError> {
+        if !binding.kind().unifies(kind) {
+            return Err(TypeCheckError::TypeKindMismatch {
+                expected_kind: format!("{}", kind),
+                expr_kind: format!("{}", binding.kind()),
+                expr_span: span,
+            });
+        }
+
         let id = match &*self.1.borrow() {
             TypeBinding::Bound(binding) => {
                 unreachable!("Expected unbound, found bound to {binding}")
             }
-            TypeBinding::Unbound(id) => *id,
+            TypeBinding::Unbound(id, _) => *id,
         };
 
         if binding.occurs(id) {
@@ -599,18 +737,60 @@ impl TypeVariable {
     /// Unbind this type variable, setting it to Unbound(id).
     ///
     /// This is generally a logic error to use outside of monomorphization.
-    pub fn unbind(&self, id: TypeVariableId) {
-        *self.1.borrow_mut() = TypeBinding::Unbound(id);
+    pub fn unbind(&self, id: TypeVariableId, type_var_kind: Kind) {
+        *self.1.borrow_mut() = TypeBinding::Unbound(id, type_var_kind);
     }
 
     /// Forcibly bind a type variable to a new type - even if the type
     /// variable is already bound to a different type. This generally
     /// a logic error to use outside of monomorphization.
+    ///
+    /// Asserts that the given type is compatible with the given Kind
     pub fn force_bind(&self, typ: Type) {
         if !typ.occurs(self.id()) {
             *self.1.borrow_mut() = TypeBinding::Bound(typ);
         }
     }
+
+    pub fn kind(&self) -> Kind {
+        match &*self.borrow() {
+            TypeBinding::Bound(binding) => binding.kind(),
+            TypeBinding::Unbound(_, type_var_kind) => type_var_kind.clone(),
+        }
+    }
+
+    /// Check that if bound, it's an integer
+    /// and if unbound, that it's a Kind::Integer
+    pub fn is_integer(&self) -> bool {
+        match &*self.borrow() {
+            TypeBinding::Bound(binding) => matches!(binding.follow_bindings(), Type::Integer(..)),
+            TypeBinding::Unbound(_, type_var_kind) => {
+                matches!(type_var_kind.follow_bindings(), Kind::Integer)
+            }
+        }
+    }
+
+    /// Check that if bound, it's an integer or field
+    /// and if unbound, that it's a Kind::IntegerOrField
+    pub fn is_integer_or_field(&self) -> bool {
+        match &*self.borrow() {
+            TypeBinding::Bound(binding) => {
+                matches!(binding.follow_bindings(), Type::Integer(..) | Type::FieldElement)
+            }
+            TypeBinding::Unbound(_, type_var_kind) => {
+                matches!(type_var_kind.follow_bindings(), Kind::IntegerOrField)
+            }
+        }
+    }
+
+    /// If value_level, only check for Type::FieldElement,
+    /// else only check for a type-level FieldElement
+    fn is_field_element(&self, value_level: bool) -> bool {
+        match &*self.borrow() {
+            TypeBinding::Bound(binding) => binding.is_field_element(value_level),
+            TypeBinding::Unbound(_, type_var_kind) => type_var_kind.is_field_element(value_level),
+        }
+    }
 }
 
 /// TypeBindings are the mutable insides of a TypeVariable.
@@ -618,12 +798,12 @@ impl TypeVariable {
 #[derive(Clone, PartialEq, Eq, Hash, Debug, PartialOrd, Ord)]
 pub enum TypeBinding {
     Bound(Type),
-    Unbound(TypeVariableId),
+    Unbound(TypeVariableId, Kind),
 }
 
 impl TypeBinding {
     pub fn is_unbound(&self) -> bool {
-        matches!(self, TypeBinding::Unbound(_))
+        matches!(self, TypeBinding::Unbound(_, _))
     }
 }
 
@@ -647,22 +827,18 @@ impl std::fmt::Display for Type {
                 Signedness::Signed => write!(f, "i{num_bits}"),
                 Signedness::Unsigned => write!(f, "u{num_bits}"),
             },
-            Type::TypeVariable(var, TypeVariableKind::Normal) => write!(f, "{}", var.borrow()),
-            Type::TypeVariable(binding, TypeVariableKind::Integer) => {
-                if let TypeBinding::Unbound(_) = &*binding.borrow() {
-                    write!(f, "{}", Type::default_int_type())
-                } else {
-                    write!(f, "{}", binding.borrow())
-                }
-            }
-            Type::TypeVariable(binding, TypeVariableKind::IntegerOrField) => {
-                if let TypeBinding::Unbound(_) = &*binding.borrow() {
-                    // Show a Field by default if this TypeVariableKind::IntegerOrField is unbound, since that is
-                    // what they bind to by default anyway. It is less confusing than displaying it
-                    // as a generic.
-                    write!(f, "Field")
-                } else {
-                    write!(f, "{}", binding.borrow())
+            Type::TypeVariable(var) => {
+                let binding = &var.1;
+                match &*binding.borrow() {
+                    TypeBinding::Unbound(_, type_var_kind) => match type_var_kind {
+                        Kind::Any | Kind::Normal => write!(f, "{}", var.borrow()),
+                        Kind::Integer => write!(f, "{}", Type::default_int_type()),
+                        Kind::IntegerOrField => write!(f, "Field"),
+                        Kind::Numeric(_typ) => write!(f, "_"),
+                    },
+                    TypeBinding::Bound(binding) => {
+                        write!(f, "{}", binding)
+                    }
                 }
             }
             Type::Struct(s, args) => {
@@ -695,11 +871,12 @@ impl std::fmt::Display for Type {
             }
             Type::Unit => write!(f, "()"),
             Type::Error => write!(f, "error"),
-            Type::NamedGeneric(binding, name, _) => match &*binding.borrow() {
+            Type::NamedGeneric(binding, name) => match &*binding.borrow() {
                 TypeBinding::Bound(binding) => binding.fmt(f),
-                TypeBinding::Unbound(_) if name.is_empty() => write!(f, "_"),
-                TypeBinding::Unbound(_) => write!(f, "{name}"),
+                TypeBinding::Unbound(_, _) if name.is_empty() => write!(f, "_"),
+                TypeBinding::Unbound(_, _) => write!(f, "{name}"),
             },
+            Type::CheckedCast { to, .. } => write!(f, "{to}"),
             Type::Constant(x, _kind) => write!(f, "{x}"),
             Type::Forall(typevars, typ) => {
                 let typevars = vecmap(typevars, |var| var.id().to_string());
@@ -724,7 +901,7 @@ impl std::fmt::Display for Type {
             }
             Type::Quoted(quoted) => write!(f, "{}", quoted),
             Type::InfixExpr(lhs, op, rhs) => {
-                let this = self.canonicalize();
+                let this = self.canonicalize_checked();
 
                 // Prevent infinite recursion
                 if this != *self {
@@ -759,7 +936,7 @@ impl std::fmt::Display for TypeBinding {
     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
         match self {
             TypeBinding::Bound(typ) => typ.fmt(f),
-            TypeBinding::Unbound(id) => id.fmt(f),
+            TypeBinding::Unbound(id, _) => id.fmt(f),
         }
     }
 }
@@ -795,23 +972,25 @@ impl Type {
         Type::Integer(Signedness::Unsigned, IntegerBitSize::ThirtyTwo)
     }
 
+    pub fn type_variable_with_kind(interner: &NodeInterner, type_var_kind: Kind) -> Type {
+        let id = interner.next_type_variable_id();
+        let var = TypeVariable::unbound(id, type_var_kind);
+        Type::TypeVariable(var)
+    }
+
     pub fn type_variable(id: TypeVariableId) -> Type {
-        let var = TypeVariable::unbound(id);
-        Type::TypeVariable(var, TypeVariableKind::Normal)
+        let var = TypeVariable::unbound(id, Kind::Any);
+        Type::TypeVariable(var)
     }
 
-    pub fn polymorphic_integer_or_field(interner: &mut NodeInterner) -> Type {
-        let id = interner.next_type_variable_id();
-        let kind = TypeVariableKind::IntegerOrField;
-        let var = TypeVariable::unbound(id);
-        Type::TypeVariable(var, kind)
+    pub fn polymorphic_integer_or_field(interner: &NodeInterner) -> Type {
+        let type_var_kind = Kind::IntegerOrField;
+        Self::type_variable_with_kind(interner, type_var_kind)
     }
 
-    pub fn polymorphic_integer(interner: &mut NodeInterner) -> Type {
-        let id = interner.next_type_variable_id();
-        let kind = TypeVariableKind::Integer;
-        let var = TypeVariable::unbound(id);
-        Type::TypeVariable(var, kind)
+    pub fn polymorphic_integer(interner: &NodeInterner) -> Type {
+        let type_var_kind = Kind::Integer;
+        Self::type_variable_with_kind(interner, type_var_kind)
     }
 
     /// A bit of an awkward name for this function - this function returns
@@ -820,9 +999,9 @@ impl Type {
     /// they shouldn't be bound over until monomorphization.
     pub fn is_bindable(&self) -> bool {
         match self {
-            Type::TypeVariable(binding, _) => match &*binding.borrow() {
+            Type::TypeVariable(binding) => match &*binding.borrow() {
                 TypeBinding::Bound(binding) => binding.is_bindable(),
-                TypeBinding::Unbound(_) => true,
+                TypeBinding::Unbound(_, _) => true,
             },
             Type::Alias(alias, args) => alias.borrow().get_type(args).is_bindable(),
             _ => false,
@@ -841,6 +1020,17 @@ impl Type {
         matches!(self.follow_bindings(), Type::Integer(_, _))
     }
 
+    /// If value_level, only check for Type::FieldElement,
+    /// else only check for a type-level FieldElement
+    fn is_field_element(&self, value_level: bool) -> bool {
+        match self.follow_bindings() {
+            Type::FieldElement => value_level,
+            Type::TypeVariable(var) => var.is_field_element(value_level),
+            Type::Constant(_, kind) => !value_level && kind.is_field_element(true),
+            _ => false,
+        }
+    }
+
     pub fn is_signed(&self) -> bool {
         matches!(self.follow_bindings(), Type::Integer(Signedness::Signed, _))
     }
@@ -849,97 +1039,59 @@ impl Type {
         matches!(self.follow_bindings(), Type::Integer(Signedness::Unsigned, _))
     }
 
-    pub fn is_numeric(&self) -> bool {
+    /// While Kind::is_numeric refers to numeric _types_,
+    /// this method checks for numeric _values_
+    pub fn is_numeric_value(&self) -> bool {
+        use Kind as K;
         use Type::*;
-        use TypeVariableKind as K;
-        matches!(
-            self.follow_bindings(),
-            FieldElement | Integer(..) | Bool | TypeVariable(_, K::Integer | K::IntegerOrField)
-        )
+        match self.follow_bindings() {
+            FieldElement => true,
+            Integer(..) => true,
+            Bool => true,
+            TypeVariable(var) => match &*var.borrow() {
+                TypeBinding::Bound(typ) => typ.is_numeric_value(),
+                TypeBinding::Unbound(_, type_var_kind) => {
+                    matches!(type_var_kind, K::Integer | K::IntegerOrField)
+                }
+            },
+            _ => false,
+        }
     }
 
-    pub fn find_numeric_type_vars(&self, found_names: &mut Vec<String>) {
-        // Return whether the named generic has a TypeKind::Numeric and save its name
-        let named_generic_is_numeric = |typ: &Type, found_names: &mut Vec<String>| {
-            if let Type::NamedGeneric(_, name, Kind::Numeric { .. }) = typ {
-                found_names.push(name.to_string());
-                true
-            } else {
-                false
-            }
-        };
-
-        match self {
+    pub fn is_primitive(&self) -> bool {
+        match self.follow_bindings() {
             Type::FieldElement
-            | Type::Integer(_, _)
+            | Type::Array(_, _)
+            | Type::Slice(_)
+            | Type::Integer(..)
             | Type::Bool
+            | Type::String(_)
+            | Type::FmtString(_, _)
             | Type::Unit
-            | Type::Error
-            | Type::Constant(_, _)
-            | Type::Forall(_, _)
-            | Type::Quoted(_) => {}
-
-            Type::TypeVariable(type_var, _) => {
-                if let TypeBinding::Bound(typ) = &*type_var.borrow() {
-                    named_generic_is_numeric(typ, found_names);
-                }
-            }
-
-            Type::NamedGeneric(_, _, _) => {
-                named_generic_is_numeric(self, found_names);
+            | Type::Function(..)
+            | Type::Tuple(..) => true,
+            Type::Alias(alias_type, generics) => {
+                alias_type.borrow().get_type(&generics).is_primitive()
             }
+            Type::MutableReference(typ) => typ.is_primitive(),
+            Type::Struct(..)
+            | Type::TypeVariable(..)
+            | Type::TraitAsType(..)
+            | Type::NamedGeneric(..)
+            | Type::CheckedCast { .. }
+            | Type::Forall(..)
+            | Type::Constant(..)
+            | Type::Quoted(..)
+            | Type::InfixExpr(..)
+            | Type::Error => false,
+        }
+    }
 
-            Type::TraitAsType(_, _, args) => {
-                for arg in args.ordered.iter() {
-                    arg.find_numeric_type_vars(found_names);
-                }
-                for arg in args.named.iter() {
-                    arg.typ.find_numeric_type_vars(found_names);
-                }
-            }
-            Type::Array(length, elem) => {
-                elem.find_numeric_type_vars(found_names);
-                named_generic_is_numeric(length, found_names);
-            }
-            Type::Slice(elem) => elem.find_numeric_type_vars(found_names),
-            Type::Tuple(fields) => {
-                for field in fields.iter() {
-                    field.find_numeric_type_vars(found_names);
-                }
-            }
-            Type::Function(parameters, return_type, env, _unconstrained) => {
-                for parameter in parameters.iter() {
-                    parameter.find_numeric_type_vars(found_names);
-                }
-                return_type.find_numeric_type_vars(found_names);
-                env.find_numeric_type_vars(found_names);
-            }
-            Type::Struct(_, generics) => {
-                for generic in generics.iter() {
-                    if !named_generic_is_numeric(generic, found_names) {
-                        generic.find_numeric_type_vars(found_names);
-                    }
-                }
-            }
-            Type::Alias(_, generics) => {
-                for generic in generics.iter() {
-                    if !named_generic_is_numeric(generic, found_names) {
-                        generic.find_numeric_type_vars(found_names);
-                    }
-                }
-            }
-            Type::MutableReference(element) => element.find_numeric_type_vars(found_names),
-            Type::String(length) => {
-                named_generic_is_numeric(length, found_names);
-            }
-            Type::FmtString(length, elements) => {
-                elements.find_numeric_type_vars(found_names);
-                named_generic_is_numeric(length, found_names);
-            }
-            Type::InfixExpr(lhs, _op, rhs) => {
-                lhs.find_numeric_type_vars(found_names);
-                rhs.find_numeric_type_vars(found_names);
-            }
+    pub fn is_function(&self) -> bool {
+        match self.follow_bindings_shallow().as_ref() {
+            Type::Function(..) => true,
+            Type::Alias(alias_type, _) => alias_type.borrow().typ.is_function(),
+            _ => false,
         }
     }
 
@@ -962,16 +1114,17 @@ impl Type {
             | Type::Error => true,
 
             Type::FmtString(_, _)
-            | Type::TypeVariable(_, _)
-            | Type::NamedGeneric(_, _, _)
+            | Type::TypeVariable(_)
+            | Type::NamedGeneric(_, _)
             | Type::Function(_, _, _, _)
             | Type::MutableReference(_)
             | Type::Forall(_, _)
             | Type::Quoted(_)
             | Type::Slice(_)
-            | Type::InfixExpr(_, _, _)
             | Type::TraitAsType(..) => false,
 
+            Type::CheckedCast { to, .. } => to.is_valid_for_program_input(),
+
             Type::Alias(alias, generics) => {
                 let alias = alias.borrow();
                 alias.get_type(generics).is_valid_for_program_input()
@@ -987,6 +1140,10 @@ impl Type {
                 .get_fields(generics)
                 .into_iter()
                 .all(|(_, field)| field.is_valid_for_program_input()),
+
+            Type::InfixExpr(lhs, _, rhs) => {
+                lhs.is_valid_for_program_input() && rhs.is_valid_for_program_input()
+            }
         }
     }
 
@@ -1005,8 +1162,8 @@ impl Type {
             | Type::Bool
             | Type::Unit
             | Type::Constant(_, _)
-            | Type::TypeVariable(_, _)
-            | Type::NamedGeneric(_, _, _)
+            | Type::TypeVariable(_)
+            | Type::NamedGeneric(_, _)
             | Type::InfixExpr(..)
             | Type::Error => true,
 
@@ -1021,6 +1178,8 @@ impl Type {
             | Type::Quoted(_)
             | Type::TraitAsType(..) => false,
 
+            Type::CheckedCast { to, .. } => to.is_valid_non_inlined_function_input(),
+
             Type::Alias(alias, generics) => {
                 let alias = alias.borrow();
                 alias.get_type(generics).is_valid_non_inlined_function_input()
@@ -1054,7 +1213,7 @@ impl Type {
             | Type::InfixExpr(..)
             | Type::Error => true,
 
-            Type::TypeVariable(type_var, _) | Type::NamedGeneric(type_var, _, _) => {
+            Type::TypeVariable(type_var) | Type::NamedGeneric(type_var, _) => {
                 if let TypeBinding::Bound(typ) = &*type_var.borrow() {
                     typ.is_valid_for_unconstrained_boundary()
                 } else {
@@ -1062,6 +1221,8 @@ impl Type {
                 }
             }
 
+            Type::CheckedCast { to, .. } => to.is_valid_for_unconstrained_boundary(),
+
             // Quoted objects only exist at compile-time where the only execution
             // environment is the interpreter. In this environment, they are valid.
             Type::Quoted(_) => true,
@@ -1094,10 +1255,11 @@ impl Type {
     pub fn generic_count(&self) -> usize {
         match self {
             Type::Forall(generics, _) => generics.len(),
-            Type::TypeVariable(type_variable, _) | Type::NamedGeneric(type_variable, _, _) => {
+            Type::CheckedCast { to, .. } => to.generic_count(),
+            Type::TypeVariable(type_variable) | Type::NamedGeneric(type_variable, _) => {
                 match &*type_variable.borrow() {
                     TypeBinding::Bound(binding) => binding.generic_count(),
-                    TypeBinding::Unbound(_) => 0,
+                    TypeBinding::Unbound(_, _) => 0,
                 }
             }
             _ => 0,
@@ -1105,9 +1267,10 @@ impl Type {
     }
 
     /// Takes a monomorphic type and generalizes it over each of the type variables in the
-    /// given type bindings, ignoring what each type variable is bound to in the TypeBindings.
+    /// given type bindings, ignoring what each type variable is bound to in the TypeBindings
+    /// and their Kind's
     pub(crate) fn generalize_from_substitutions(self, type_bindings: TypeBindings) -> Type {
-        let polymorphic_type_vars = vecmap(type_bindings, |(_, (type_var, _))| type_var);
+        let polymorphic_type_vars = vecmap(type_bindings, |(_, (type_var, _kind, _))| type_var);
         Type::Forall(polymorphic_type_vars, Box::new(self))
     }
 
@@ -1130,82 +1293,77 @@ impl Type {
         }
     }
 
-    pub(crate) fn kind(&self) -> Option<Kind> {
+    pub(crate) fn kind(&self) -> Kind {
         match self {
-            Type::NamedGeneric(_, _, kind) => Some(kind.clone()),
-            Type::Constant(_, kind) => Some(kind.clone()),
-            Type::TypeVariable(var, _) => match *var.borrow() {
+            Type::CheckedCast { to, .. } => to.kind(),
+            Type::NamedGeneric(var, _) => var.kind(),
+            Type::Constant(_, kind) => kind.clone(),
+            Type::TypeVariable(var) => match &*var.borrow() {
                 TypeBinding::Bound(ref typ) => typ.kind(),
-                TypeBinding::Unbound(_) => None,
+                TypeBinding::Unbound(_, ref type_var_kind) => type_var_kind.clone(),
             },
-            Type::InfixExpr(lhs, _op, rhs) => Some(lhs.infix_kind(rhs)),
+            Type::InfixExpr(lhs, _op, rhs) => lhs.infix_kind(rhs),
+            Type::Alias(def, generics) => def.borrow().get_type(generics).kind(),
+            // This is a concrete FieldElement, not an IntegerOrField
             Type::FieldElement
+            | Type::Integer(..)
             | Type::Array(..)
             | Type::Slice(..)
-            | Type::Integer(..)
             | Type::Bool
             | Type::String(..)
             | Type::FmtString(..)
             | Type::Unit
             | Type::Tuple(..)
             | Type::Struct(..)
-            | Type::Alias(..)
             | Type::TraitAsType(..)
             | Type::Function(..)
             | Type::MutableReference(..)
             | Type::Forall(..)
-            | Type::Quoted(..)
-            | Type::Error => Some(Kind::Normal),
+            | Type::Quoted(..) => Kind::Normal,
+            Type::Error => Kind::Any,
         }
     }
 
-    /// if both Kind's are equal to Some(_), return that Kind,
-    ///     otherwise return a Kind error
-    /// if both Kind's are None, default to u32
-    /// if exactly one Kind is None, return the other one
+    /// Unifies self and other kinds or fails with a Kind error
     fn infix_kind(&self, other: &Self) -> Kind {
-        match (self.kind(), other.kind()) {
-            (Some(self_kind), Some(other_kind)) => {
-                if self_kind == other_kind {
-                    self_kind
-                } else {
-                    Kind::Numeric(Box::new(Type::Error))
-                }
-            }
-            (None, None) => Kind::u32(),
-            (Some(self_kind), None) => self_kind,
-            (None, Some(other_kind)) => other_kind,
+        let self_kind = self.kind();
+        let other_kind = other.kind();
+        if self_kind.unifies(&other_kind) {
+            self_kind
+        } else {
+            Kind::numeric(Type::Error)
         }
     }
 
     /// Returns the number of field elements required to represent the type once encoded.
-    pub fn field_count(&self) -> u32 {
+    pub fn field_count(&self, location: &Location) -> u32 {
         match self {
             Type::FieldElement | Type::Integer { .. } | Type::Bool => 1,
             Type::Array(size, typ) => {
                 let length = size
-                    .evaluate_to_u32()
+                    .evaluate_to_u32(location.span)
                     .expect("Cannot have variable sized arrays as a parameter to main");
                 let typ = typ.as_ref();
-                length * typ.field_count()
+                length * typ.field_count(location)
             }
             Type::Struct(def, args) => {
                 let struct_type = def.borrow();
                 let fields = struct_type.get_fields(args);
-                fields.iter().fold(0, |acc, (_, field_type)| acc + field_type.field_count())
+                fields.iter().fold(0, |acc, (_, field_type)| acc + field_type.field_count(location))
             }
-            Type::Alias(def, generics) => def.borrow().get_type(generics).field_count(),
+            Type::CheckedCast { to, .. } => to.field_count(location),
+            Type::Alias(def, generics) => def.borrow().get_type(generics).field_count(location),
             Type::Tuple(fields) => {
-                fields.iter().fold(0, |acc, field_typ| acc + field_typ.field_count())
+                fields.iter().fold(0, |acc, field_typ| acc + field_typ.field_count(location))
             }
             Type::String(size) => size
-                .evaluate_to_u32()
+                .evaluate_to_u32(location.span)
                 .expect("Cannot have variable sized strings as a parameter to main"),
             Type::FmtString(_, _)
             | Type::Unit
-            | Type::TypeVariable(_, _)
+            | Type::TypeVariable(_)
             | Type::TraitAsType(..)
-            | Type::NamedGeneric(_, _, _)
+            | Type::NamedGeneric(_, _)
             | Type::Function(_, _, _, _)
             | Type::MutableReference(_)
             | Type::Forall(_, _)
@@ -1261,71 +1419,62 @@ impl Type {
     ) -> Result<(), UnificationError> {
         let target_id = match &*var.borrow() {
             TypeBinding::Bound(_) => unreachable!(),
-            TypeBinding::Unbound(id) => *id,
+            TypeBinding::Unbound(id, _) => *id,
         };
 
+        if !self.kind().unifies(&Kind::IntegerOrField) {
+            return Err(UnificationError);
+        }
+
         let this = self.substitute(bindings).follow_bindings();
         match &this {
             Type::Integer(..) => {
-                bindings.insert(target_id, (var.clone(), this));
+                bindings.insert(target_id, (var.clone(), Kind::Integer, this));
                 Ok(())
             }
             Type::FieldElement if !only_integer => {
-                bindings.insert(target_id, (var.clone(), this));
+                bindings.insert(target_id, (var.clone(), Kind::IntegerOrField, this));
                 Ok(())
             }
-            Type::TypeVariable(self_var, TypeVariableKind::IntegerOrField) => {
+            Type::TypeVariable(self_var) => {
                 let borrow = self_var.borrow();
                 match &*borrow {
                     TypeBinding::Bound(typ) => {
                         typ.try_bind_to_polymorphic_int(var, bindings, only_integer)
                     }
                     // Avoid infinitely recursive bindings
-                    TypeBinding::Unbound(id) if *id == target_id => Ok(()),
-                    TypeBinding::Unbound(new_target_id) => {
+                    TypeBinding::Unbound(ref id, _) if *id == target_id => Ok(()),
+                    TypeBinding::Unbound(ref new_target_id, Kind::IntegerOrField) => {
+                        let type_var_kind = Kind::IntegerOrField;
                         if only_integer {
+                            let var_clone = var.clone();
+                            Kind::Integer.unify(&type_var_kind)?;
                             // Integer is more specific than IntegerOrField so we bind the type
                             // variable to Integer instead.
-                            let clone = Type::TypeVariable(var.clone(), TypeVariableKind::Integer);
-                            bindings.insert(*new_target_id, (self_var.clone(), clone));
+                            let clone = Type::TypeVariable(var_clone);
+                            bindings
+                                .insert(*new_target_id, (self_var.clone(), type_var_kind, clone));
                         } else {
-                            bindings.insert(target_id, (var.clone(), this.clone()));
+                            bindings.insert(
+                                target_id,
+                                (var.clone(), Kind::IntegerOrField, this.clone()),
+                            );
                         }
                         Ok(())
                     }
-                }
-            }
-            Type::TypeVariable(self_var, TypeVariableKind::Integer) => {
-                let borrow = self_var.borrow();
-                match &*borrow {
-                    TypeBinding::Bound(typ) => {
-                        typ.try_bind_to_polymorphic_int(var, bindings, only_integer)
-                    }
-                    // Avoid infinitely recursive bindings
-                    TypeBinding::Unbound(id) if *id == target_id => Ok(()),
-                    TypeBinding::Unbound(_) => {
-                        bindings.insert(target_id, (var.clone(), this.clone()));
+                    TypeBinding::Unbound(_new_target_id, Kind::Integer) => {
+                        Kind::Integer.unify(&Kind::Integer)?;
+                        bindings.insert(target_id, (var.clone(), Kind::Integer, this.clone()));
                         Ok(())
                     }
-                }
-            }
-            Type::TypeVariable(self_var, TypeVariableKind::Normal) => {
-                let borrow = self_var.borrow();
-                match &*borrow {
-                    TypeBinding::Bound(typ) => {
-                        typ.try_bind_to_polymorphic_int(var, bindings, only_integer)
-                    }
-                    // Avoid infinitely recursive bindings
-                    TypeBinding::Unbound(id) if *id == target_id => Ok(()),
-                    TypeBinding::Unbound(new_target_id) => {
+                    TypeBinding::Unbound(new_target_id, ref type_var_kind) => {
+                        let var_clone = var.clone();
                         // Bind to the most specific type variable kind
-                        let clone_kind = if only_integer {
-                            TypeVariableKind::Integer
-                        } else {
-                            TypeVariableKind::IntegerOrField
-                        };
-                        let clone = Type::TypeVariable(var.clone(), clone_kind);
-                        bindings.insert(*new_target_id, (self_var.clone(), clone));
+                        let clone_kind =
+                            if only_integer { Kind::Integer } else { Kind::IntegerOrField };
+                        clone_kind.unify(type_var_kind)?;
+                        let clone = Type::TypeVariable(var_clone);
+                        bindings.insert(*new_target_id, (self_var.clone(), clone_kind, clone));
                         Ok(())
                     }
                 }
@@ -1335,7 +1484,7 @@ impl Type {
     }
 
     /// Try to bind the given type variable to self. Although the given type variable
-    /// is expected to be of TypeVariableKind::Normal, this binding can still fail
+    /// is expected to be of Kind::Normal, this binding can still fail
     /// if the given type variable occurs within `self` as that would create a recursive type.
     ///
     /// If successful, the binding is placed in the
@@ -1344,18 +1493,23 @@ impl Type {
         &self,
         var: &TypeVariable,
         bindings: &mut TypeBindings,
+        kind: Kind,
     ) -> Result<(), UnificationError> {
         let target_id = match &*var.borrow() {
             TypeBinding::Bound(_) => unreachable!(),
-            TypeBinding::Unbound(id) => *id,
+            TypeBinding::Unbound(id, _) => *id,
         };
 
+        if !self.kind().unifies(&kind) {
+            return Err(UnificationError);
+        }
+
         let this = self.substitute(bindings).follow_bindings();
-        if let Some(binding) = this.get_inner_type_variable() {
+        if let Some((binding, kind)) = this.get_inner_type_variable() {
             match &*binding.borrow() {
-                TypeBinding::Bound(typ) => return typ.try_bind_to(var, bindings),
+                TypeBinding::Bound(typ) => return typ.try_bind_to(var, bindings, kind),
                 // Don't recursively bind the same id to itself
-                TypeBinding::Unbound(id) if *id == target_id => return Ok(()),
+                TypeBinding::Unbound(id, _) if *id == target_id => return Ok(()),
                 _ => (),
             }
         }
@@ -1365,14 +1519,16 @@ impl Type {
         if this.occurs(target_id) {
             Err(UnificationError)
         } else {
-            bindings.insert(target_id, (var.clone(), this.clone()));
+            bindings.insert(target_id, (var.clone(), this.kind(), this.clone()));
             Ok(())
         }
     }
 
-    fn get_inner_type_variable(&self) -> Option<Shared<TypeBinding>> {
+    fn get_inner_type_variable(&self) -> Option<(Shared<TypeBinding>, Kind)> {
         match self {
-            Type::TypeVariable(var, _) | Type::NamedGeneric(var, _, _) => Some(var.1.clone()),
+            Type::TypeVariable(var) => Some((var.1.clone(), var.kind())),
+            Type::NamedGeneric(var, _) => Some((var.1.clone(), var.kind())),
+            Type::CheckedCast { to, .. } => to.get_inner_type_variable(),
             _ => None,
         }
     }
@@ -1398,14 +1554,16 @@ impl Type {
         bindings: &mut TypeBindings,
     ) -> Result<(), UnificationError> {
         use Type::*;
-        use TypeVariableKind as Kind;
 
-        let lhs = match self {
+        let lhs = self.follow_bindings_shallow();
+        let rhs = other.follow_bindings_shallow();
+
+        let lhs = match lhs.as_ref() {
             Type::InfixExpr(..) => Cow::Owned(self.canonicalize()),
             other => Cow::Borrowed(other),
         };
 
-        let rhs = match other {
+        let rhs = match rhs.as_ref() {
             Type::InfixExpr(..) => Cow::Owned(other.canonicalize()),
             other => Cow::Borrowed(other),
         };
@@ -1418,27 +1576,36 @@ impl Type {
                 alias.try_unify(other, bindings)
             }
 
-            (TypeVariable(var, Kind::IntegerOrField), other)
-            | (other, TypeVariable(var, Kind::IntegerOrField)) => {
-                other.try_unify_to_type_variable(var, bindings, |bindings| {
-                    let only_integer = false;
-                    other.try_bind_to_polymorphic_int(var, bindings, only_integer)
-                })
-            }
-
-            (TypeVariable(var, Kind::Integer), other)
-            | (other, TypeVariable(var, Kind::Integer)) => {
-                other.try_unify_to_type_variable(var, bindings, |bindings| {
-                    let only_integer = true;
-                    other.try_bind_to_polymorphic_int(var, bindings, only_integer)
-                })
-            }
-
-            (TypeVariable(var, Kind::Normal), other) | (other, TypeVariable(var, Kind::Normal)) => {
-                other.try_unify_to_type_variable(var, bindings, |bindings| {
-                    other.try_bind_to(var, bindings)
-                })
-            }
+            (TypeVariable(var), other) | (other, TypeVariable(var)) => match &*var.borrow() {
+                TypeBinding::Bound(typ) => {
+                    if typ.is_numeric_value() {
+                        other.try_unify_to_type_variable(var, bindings, |bindings| {
+                            let only_integer = matches!(typ, Type::Integer(..));
+                            other.try_bind_to_polymorphic_int(var, bindings, only_integer)
+                        })
+                    } else {
+                        other.try_unify_to_type_variable(var, bindings, |bindings| {
+                            other.try_bind_to(var, bindings, typ.kind())
+                        })
+                    }
+                }
+                TypeBinding::Unbound(_id, Kind::IntegerOrField) => other
+                    .try_unify_to_type_variable(var, bindings, |bindings| {
+                        let only_integer = false;
+                        other.try_bind_to_polymorphic_int(var, bindings, only_integer)
+                    }),
+                TypeBinding::Unbound(_id, Kind::Integer) => {
+                    other.try_unify_to_type_variable(var, bindings, |bindings| {
+                        let only_integer = true;
+                        other.try_bind_to_polymorphic_int(var, bindings, only_integer)
+                    })
+                }
+                TypeBinding::Unbound(_id, type_var_kind) => {
+                    other.try_unify_to_type_variable(var, bindings, |bindings| {
+                        other.try_bind_to(var, bindings, type_var_kind.clone())
+                    })
+                }
+            },
 
             (Array(len_a, elem_a), Array(len_b, elem_b)) => {
                 len_a.try_unify(len_b, bindings)?;
@@ -1479,7 +1646,11 @@ impl Type {
                 }
             }
 
-            (NamedGeneric(binding, _, _), other) | (other, NamedGeneric(binding, _, _))
+            (CheckedCast { to, .. }, other) | (other, CheckedCast { to, .. }) => {
+                to.try_unify(other, bindings)
+            }
+
+            (NamedGeneric(binding, _), other) | (other, NamedGeneric(binding, _))
                 if !binding.borrow().is_unbound() =>
             {
                 if let TypeBinding::Bound(link) = &*binding.borrow() {
@@ -1489,13 +1660,13 @@ impl Type {
                 }
             }
 
-            (NamedGeneric(binding_a, name_a, kind_a), NamedGeneric(binding_b, name_b, kind_b)) => {
+            (NamedGeneric(binding_a, name_a), NamedGeneric(binding_b, name_b)) => {
                 // Bound NamedGenerics are caught by the check above
                 assert!(binding_a.borrow().is_unbound());
                 assert!(binding_b.borrow().is_unbound());
 
                 if name_a == name_b {
-                    kind_a.unify(kind_b)
+                    binding_a.kind().unify(&binding_b.kind())
                 } else {
                     Err(UnificationError)
                 }
@@ -1541,14 +1712,15 @@ impl Type {
             }
 
             (Constant(value, kind), other) | (other, Constant(value, kind)) => {
-                if let Some(other_value) = other.evaluate_to_u32() {
-                    if *value == other_value && kind.matches_opt(other.kind()) {
+                let dummy_span = Span::default();
+                if let Ok(other_value) = other.evaluate_to_field_element(kind, dummy_span) {
+                    if *value == other_value && kind.unifies(&other.kind()) {
                         Ok(())
                     } else {
                         Err(UnificationError)
                     }
                 } else if let InfixExpr(lhs, op, rhs) = other {
-                    if let Some(inverse) = op.inverse() {
+                    if let Some(inverse) = op.approx_inverse() {
                         // Handle cases like `4 = a + b` by trying to solve to `a = 4 - b`
                         let new_type = InfixExpr(
                             Box::new(Constant(*value, kind.clone())),
@@ -1583,18 +1755,23 @@ impl Type {
         bindings: &mut TypeBindings,
 
         // Bind the type variable to a type. This is factored out since depending on the
-        // TypeVariableKind, there are different methods to check whether the variable can
+        // Kind, there are different methods to check whether the variable can
         // bind to the given type or not.
         bind_variable: impl FnOnce(&mut TypeBindings) -> Result<(), UnificationError>,
     ) -> Result<(), UnificationError> {
         match &*type_variable.borrow() {
             // If it is already bound, unify against what it is bound to
             TypeBinding::Bound(link) => link.try_unify(self, bindings),
-            TypeBinding::Unbound(id) => {
+            TypeBinding::Unbound(id, _) => {
                 // We may have already "bound" this type variable in this call to
                 // try_unify, so check those bindings as well.
                 match bindings.get(id) {
-                    Some((_, binding)) => binding.clone().try_unify(self, bindings),
+                    Some((_, kind, binding)) => {
+                        if !kind.unifies(&binding.kind()) {
+                            return Err(UnificationError);
+                        }
+                        binding.clone().try_unify(self, bindings)
+                    }
 
                     // Otherwise, bind it
                     None => bind_variable(bindings),
@@ -1697,29 +1874,113 @@ impl Type {
     /// Apply the given type bindings, making them permanently visible for each
     /// clone of each type variable bound.
     pub fn apply_type_bindings(bindings: TypeBindings) {
-        for (type_variable, binding) in bindings.values() {
+        for (type_variable, _kind, binding) in bindings.values() {
             type_variable.bind(binding.clone());
         }
     }
 
     /// If this type is a Type::Constant (used in array lengths), or is bound
     /// to a Type::Constant, return the constant as a u32.
-    pub fn evaluate_to_u32(&self) -> Option<u32> {
-        if let Some(binding) = self.get_inner_type_variable() {
+    pub fn evaluate_to_u32(&self, span: Span) -> Result<u32, TypeCheckError> {
+        self.evaluate_to_field_element(&Kind::u32(), span).map(|field_element| {
+            field_element
+                .try_to_u32()
+                .expect("ICE: size should have already been checked by evaluate_to_field_element")
+        })
+    }
+
+    // TODO(https://github.com/noir-lang/noir/issues/6260): remove
+    // the unifies checks once all kinds checks are implemented?
+    pub(crate) fn evaluate_to_field_element(
+        &self,
+        kind: &Kind,
+        span: Span,
+    ) -> Result<acvm::FieldElement, TypeCheckError> {
+        let run_simplifications = true;
+        self.evaluate_to_field_element_helper(kind, span, run_simplifications)
+    }
+
+    /// evaluate_to_field_element with optional generic arithmetic simplifications
+    pub(crate) fn evaluate_to_field_element_helper(
+        &self,
+        kind: &Kind,
+        span: Span,
+        run_simplifications: bool,
+    ) -> Result<acvm::FieldElement, TypeCheckError> {
+        if let Some((binding, binding_kind)) = self.get_inner_type_variable() {
             if let TypeBinding::Bound(binding) = &*binding.borrow() {
-                return binding.evaluate_to_u32();
+                if kind.unifies(&binding_kind) {
+                    return binding.evaluate_to_field_element_helper(
+                        &binding_kind,
+                        span,
+                        run_simplifications,
+                    );
+                }
             }
         }
 
-        match self.canonicalize() {
-            Type::Array(len, _elem) => len.evaluate_to_u32(),
-            Type::Constant(x, _) => Some(x),
+        let could_be_checked_cast = false;
+        match self.canonicalize_helper(could_be_checked_cast, run_simplifications) {
+            Type::Constant(x, constant_kind) => {
+                if kind.unifies(&constant_kind) {
+                    kind.ensure_value_fits(x, span)
+                } else {
+                    Err(TypeCheckError::TypeKindMismatch {
+                        expected_kind: format!("{}", constant_kind),
+                        expr_kind: format!("{}", kind),
+                        expr_span: span,
+                    })
+                }
+            }
             Type::InfixExpr(lhs, op, rhs) => {
-                let lhs = lhs.evaluate_to_u32()?;
-                let rhs = rhs.evaluate_to_u32()?;
-                op.function(lhs, rhs)
+                let infix_kind = lhs.infix_kind(&rhs);
+                if kind.unifies(&infix_kind) {
+                    let lhs_value = lhs.evaluate_to_field_element_helper(
+                        &infix_kind,
+                        span,
+                        run_simplifications,
+                    )?;
+                    let rhs_value = rhs.evaluate_to_field_element_helper(
+                        &infix_kind,
+                        span,
+                        run_simplifications,
+                    )?;
+                    op.function(lhs_value, rhs_value, &infix_kind, span)
+                } else {
+                    Err(TypeCheckError::TypeKindMismatch {
+                        expected_kind: format!("{}", kind),
+                        expr_kind: format!("{}", infix_kind),
+                        expr_span: span,
+                    })
+                }
             }
-            _ => None,
+            Type::CheckedCast { from, to } => {
+                let to_value = to.evaluate_to_field_element(kind, span)?;
+
+                // if both 'to' and 'from' evaluate to a constant,
+                // return None unless they match
+                let skip_simplifications = false;
+                if let Ok(from_value) =
+                    from.evaluate_to_field_element_helper(kind, span, skip_simplifications)
+                {
+                    if to_value == from_value {
+                        Ok(to_value)
+                    } else {
+                        let to = *to.clone();
+                        let from = *from.clone();
+                        Err(TypeCheckError::TypeCanonicalizationMismatch {
+                            to,
+                            from,
+                            to_value,
+                            from_value,
+                            span,
+                        })
+                    }
+                } else {
+                    Ok(to_value)
+                }
+            }
+            other => Err(TypeCheckError::NonConstantEvaluated { typ: other, span }),
         }
     }
 
@@ -1731,8 +1992,8 @@ impl Type {
             // only to have to call .into_iter again afterward. Trying to elide
             // collecting to a Vec leads to us dropping the temporary Ref before
             // the iterator is returned
-            Type::Struct(def, args) => vecmap(&def.borrow().fields, |(name, _)| {
-                let name = &name.0.contents;
+            Type::Struct(def, args) => vecmap(&def.borrow().fields, |field| {
+                let name = &field.name.0.contents;
                 let typ = def.borrow().get_field(name, args).unwrap().0;
                 (name.clone(), typ)
             }),
@@ -1747,14 +2008,20 @@ impl Type {
 
     /// Retrieves the type of the given field name
     /// Panics if the type is not a struct or tuple.
-    pub fn get_field_type(&self, field_name: &str) -> Option<Type> {
+    pub fn get_field_type_and_visibility(
+        &self,
+        field_name: &str,
+    ) -> Option<(Type, ItemVisibility)> {
         match self.follow_bindings() {
-            Type::Struct(def, args) => {
-                def.borrow().get_field(field_name, &args).map(|(typ, _)| typ)
-            }
+            Type::Struct(def, args) => def
+                .borrow()
+                .get_field(field_name, &args)
+                .map(|(typ, visibility, _)| (typ, visibility)),
             Type::Tuple(fields) => {
                 let mut fields = fields.into_iter().enumerate();
-                fields.find(|(i, _)| i.to_string() == *field_name).map(|(_, typ)| typ)
+                fields
+                    .find(|(i, _)| i.to_string() == *field_name)
+                    .map(|(_, typ)| (typ, ItemVisibility::Public))
             }
             _ => None,
         }
@@ -1771,9 +2038,9 @@ impl Type {
         match self {
             Type::Forall(typevars, typ) => {
                 for var in typevars {
-                    bindings
-                        .entry(var.id())
-                        .or_insert_with(|| (var.clone(), interner.next_type_variable()));
+                    bindings.entry(var.id()).or_insert_with(|| {
+                        (var.clone(), var.kind(), interner.next_type_variable_with_kind(var.kind()))
+                    });
                 }
 
                 let instantiated = typ.force_substitute(&bindings);
@@ -1792,8 +2059,8 @@ impl Type {
                 let replacements = typevars
                     .iter()
                     .map(|var| {
-                        let new = interner.next_type_variable();
-                        (var.id(), (var.clone(), new))
+                        let new = interner.next_type_variable_with_kind(var.kind());
+                        (var.id(), (var.clone(), var.kind(), new))
                     })
                     .collect();
 
@@ -1827,7 +2094,7 @@ impl Type {
                 let replacements = typevars
                     .iter()
                     .zip(bindings)
-                    .map(|(var, binding)| (var.id(), (var.clone(), binding)))
+                    .map(|(var, binding)| (var.id(), (var.clone(), var.kind(), binding)))
                     .collect();
 
                 let instantiated = typ.substitute(&replacements);
@@ -1839,9 +2106,7 @@ impl Type {
 
     fn type_variable_id(&self) -> Option<TypeVariableId> {
         match self {
-            Type::TypeVariable(variable, _) | Type::NamedGeneric(variable, _, _) => {
-                Some(variable.0)
-            }
+            Type::TypeVariable(variable) | Type::NamedGeneric(variable, _) => Some(variable.0),
             _ => None,
         }
     }
@@ -1894,15 +2159,24 @@ impl Type {
             // type variables that have already been bound over.
             // This is needed for monomorphizing trait impl methods.
             match type_bindings.get(&binding.0) {
-                Some((_, replacement)) if substitute_bound_typevars => {
+                Some((_, _kind, replacement)) if substitute_bound_typevars => {
                     recur_on_binding(binding.0, replacement)
                 }
                 _ => match &*binding.borrow() {
                     TypeBinding::Bound(binding) => {
                         binding.substitute_helper(type_bindings, substitute_bound_typevars)
                     }
-                    TypeBinding::Unbound(id) => match type_bindings.get(id) {
-                        Some((_, replacement)) => recur_on_binding(binding.0, replacement),
+                    TypeBinding::Unbound(id, _) => match type_bindings.get(id) {
+                        Some((_, kind, replacement)) => {
+                            assert!(
+                                kind.unifies(&replacement.kind()),
+                                "while substituting (unbound): expected kind of unbound TypeVariable ({:?}) to match the kind of its binding ({:?})",
+                                kind,
+                                replacement.kind()
+                            );
+
+                            recur_on_binding(binding.0, replacement)
+                        }
                         None => self.clone(),
                     },
                 },
@@ -1928,7 +2202,12 @@ impl Type {
                 let fields = fields.substitute_helper(type_bindings, substitute_bound_typevars);
                 Type::FmtString(Box::new(size), Box::new(fields))
             }
-            Type::NamedGeneric(binding, _, _) | Type::TypeVariable(binding, _) => {
+            Type::CheckedCast { from, to } => {
+                let from = from.substitute_helper(type_bindings, substitute_bound_typevars);
+                let to = to.substitute_helper(type_bindings, substitute_bound_typevars);
+                Type::CheckedCast { from: Box::new(from), to: Box::new(to) }
+            }
+            Type::NamedGeneric(binding, _) | Type::TypeVariable(binding) => {
                 substitute_binding(binding)
             }
             // Do not substitute_helper fields, it can lead to infinite recursion
@@ -2017,12 +2296,13 @@ impl Type {
                     || args.named.iter().any(|arg| arg.typ.occurs(target_id))
             }
             Type::Tuple(fields) => fields.iter().any(|field| field.occurs(target_id)),
-            Type::NamedGeneric(type_var, _, _) | Type::TypeVariable(type_var, _) => {
+            Type::CheckedCast { from, to } => from.occurs(target_id) || to.occurs(target_id),
+            Type::NamedGeneric(type_var, _) | Type::TypeVariable(type_var) => {
                 match &*type_var.borrow() {
                     TypeBinding::Bound(binding) => {
                         type_var.id() == target_id || binding.occurs(target_id)
                     }
-                    TypeBinding::Unbound(id) => *id == target_id,
+                    TypeBinding::Unbound(id, _) => *id == target_id,
                 }
             }
             Type::Forall(typevars, typ) => {
@@ -2075,13 +2355,17 @@ impl Type {
                 def.borrow().get_type(args).follow_bindings()
             }
             Tuple(args) => Tuple(vecmap(args, |arg| arg.follow_bindings())),
-            TypeVariable(var, _) | NamedGeneric(var, _, _) => {
+            CheckedCast { from, to } => {
+                let from = Box::new(from.follow_bindings());
+                let to = Box::new(to.follow_bindings());
+                CheckedCast { from, to }
+            }
+            TypeVariable(var) | NamedGeneric(var, _) => {
                 if let TypeBinding::Bound(typ) = &*var.borrow() {
                     return typ.follow_bindings();
                 }
                 self.clone()
             }
-
             Function(args, ret, env, unconstrained) => {
                 let args = vecmap(args, |arg| arg.follow_bindings());
                 let ret = Box::new(ret.follow_bindings());
@@ -2113,8 +2397,23 @@ impl Type {
         }
     }
 
+    /// Follow bindings if this is a type variable or generic to the first non-typevariable
+    /// type. Unlike `follow_bindings`, this won't recursively follow any bindings on any
+    /// fields or arguments of this type.
+    pub fn follow_bindings_shallow(&self) -> Cow<Type> {
+        match self {
+            Type::TypeVariable(var) | Type::NamedGeneric(var, _) => {
+                if let TypeBinding::Bound(typ) = &*var.borrow() {
+                    return Cow::Owned(typ.follow_bindings_shallow().into_owned());
+                }
+                Cow::Borrowed(self)
+            }
+            other => Cow::Borrowed(other),
+        }
+    }
+
     pub fn from_generics(generics: &GenericTypeVars) -> Vec<Type> {
-        vecmap(generics, |var| Type::TypeVariable(var.clone(), TypeVariableKind::Normal))
+        vecmap(generics, |var| Type::TypeVariable(var.clone()))
     }
 
     /// Replace any `Type::NamedGeneric` in this type with a `Type::TypeVariable`
@@ -2156,12 +2455,11 @@ impl Type {
                 typ.replace_named_generics_with_type_variables();
                 *self = typ;
             }
-            Type::TypeVariable(var, _) => {
+            Type::TypeVariable(var) => {
                 let var = var.borrow();
                 if let TypeBinding::Bound(binding) = &*var {
-                    let mut binding = binding.clone();
+                    let binding = binding.clone();
                     drop(var);
-                    binding.replace_named_generics_with_type_variables();
                     *self = binding;
                 }
             }
@@ -2173,7 +2471,11 @@ impl Type {
                     generic.typ.replace_named_generics_with_type_variables();
                 }
             }
-            Type::NamedGeneric(var, _, _) => {
+            Type::CheckedCast { from, to } => {
+                from.replace_named_generics_with_type_variables();
+                to.replace_named_generics_with_type_variables();
+            }
+            Type::NamedGeneric(var, _) => {
                 let type_binding = var.borrow();
                 if let TypeBinding::Bound(binding) = &*type_binding {
                     let mut binding = binding.clone();
@@ -2182,7 +2484,7 @@ impl Type {
                     *self = binding;
                 } else {
                     drop(type_binding);
-                    *self = Type::TypeVariable(var.clone(), TypeVariableKind::Normal);
+                    *self = Type::TypeVariable(var.clone());
                 }
             }
             Type::Function(args, ret, env, _unconstrained) => {
@@ -2207,6 +2509,52 @@ impl Type {
             _ => None,
         }
     }
+
+    pub(crate) fn integral_maximum_size(&self) -> Option<FieldElement> {
+        match self {
+            Type::FieldElement => None,
+            Type::Integer(sign, num_bits) => {
+                let mut max_bit_size = num_bits.bit_size();
+                if sign == &Signedness::Signed {
+                    max_bit_size -= 1;
+                }
+                Some(((1u128 << max_bit_size) - 1).into())
+            }
+            Type::Bool => Some(FieldElement::one()),
+            Type::TypeVariable(var) => {
+                let binding = &var.1;
+                match &*binding.borrow() {
+                    TypeBinding::Unbound(_, type_var_kind) => match type_var_kind {
+                        Kind::Any | Kind::Normal | Kind::Integer | Kind::IntegerOrField => None,
+                        Kind::Numeric(typ) => typ.integral_maximum_size(),
+                    },
+                    TypeBinding::Bound(typ) => typ.integral_maximum_size(),
+                }
+            }
+            Type::Alias(alias, args) => alias.borrow().get_type(args).integral_maximum_size(),
+            Type::CheckedCast { to, .. } => to.integral_maximum_size(),
+            Type::NamedGeneric(binding, _name) => match &*binding.borrow() {
+                TypeBinding::Bound(typ) => typ.integral_maximum_size(),
+                TypeBinding::Unbound(_, kind) => kind.integral_maximum_size(),
+            },
+            Type::MutableReference(typ) => typ.integral_maximum_size(),
+            Type::InfixExpr(lhs, _op, rhs) => lhs.infix_kind(rhs).integral_maximum_size(),
+            Type::Constant(_, kind) => kind.integral_maximum_size(),
+
+            Type::Array(..)
+            | Type::Slice(..)
+            | Type::String(..)
+            | Type::FmtString(..)
+            | Type::Unit
+            | Type::Tuple(..)
+            | Type::Struct(..)
+            | Type::TraitAsType(..)
+            | Type::Function(..)
+            | Type::Forall(..)
+            | Type::Quoted(..)
+            | Type::Error => None,
+        }
+    }
 }
 
 /// Wraps a given `expression` in `expression.as_slice()`
@@ -2244,13 +2592,40 @@ fn convert_array_expression_to_slice(
 
 impl BinaryTypeOperator {
     /// Perform the actual rust numeric operation associated with this operator
-    pub fn function(self, a: u32, b: u32) -> Option<u32> {
-        match self {
-            BinaryTypeOperator::Addition => a.checked_add(b),
-            BinaryTypeOperator::Subtraction => a.checked_sub(b),
-            BinaryTypeOperator::Multiplication => a.checked_mul(b),
-            BinaryTypeOperator::Division => a.checked_div(b),
-            BinaryTypeOperator::Modulo => a.checked_rem(b),
+    pub fn function(
+        self,
+        a: FieldElement,
+        b: FieldElement,
+        kind: &Kind,
+        span: Span,
+    ) -> Result<FieldElement, TypeCheckError> {
+        match kind.follow_bindings().integral_maximum_size() {
+            None => match self {
+                BinaryTypeOperator::Addition => Ok(a + b),
+                BinaryTypeOperator::Subtraction => Ok(a - b),
+                BinaryTypeOperator::Multiplication => Ok(a * b),
+                BinaryTypeOperator::Division => (b != FieldElement::zero())
+                    .then(|| a / b)
+                    .ok_or(TypeCheckError::DivisionByZero { lhs: a, rhs: b, span }),
+                BinaryTypeOperator::Modulo => {
+                    Err(TypeCheckError::ModuloOnFields { lhs: a, rhs: b, span })
+                }
+            },
+            Some(_maximum_size) => {
+                let a = a.to_i128();
+                let b = b.to_i128();
+
+                let err = TypeCheckError::FailingBinaryOp { op: self, lhs: a, rhs: b, span };
+                let result = match self {
+                    BinaryTypeOperator::Addition => a.checked_add(b).ok_or(err)?,
+                    BinaryTypeOperator::Subtraction => a.checked_sub(b).ok_or(err)?,
+                    BinaryTypeOperator::Multiplication => a.checked_mul(b).ok_or(err)?,
+                    BinaryTypeOperator::Division => a.checked_div(b).ok_or(err)?,
+                    BinaryTypeOperator::Modulo => a.checked_rem(b).ok_or(err)?,
+                };
+
+                Ok(result.into())
+            }
         }
     }
 
@@ -2263,21 +2638,20 @@ impl BinaryTypeOperator {
         match self {
             BinaryTypeOperator::Addition => Some(BinaryTypeOperator::Subtraction),
             BinaryTypeOperator::Subtraction => Some(BinaryTypeOperator::Addition),
-            BinaryTypeOperator::Multiplication => Some(BinaryTypeOperator::Division),
-            BinaryTypeOperator::Division => Some(BinaryTypeOperator::Multiplication),
+            BinaryTypeOperator::Multiplication => None,
+            BinaryTypeOperator::Division => None,
             BinaryTypeOperator::Modulo => None,
         }
     }
-}
 
-impl TypeVariableKind {
-    /// Returns the default type this type variable should be bound to if it is still unbound
-    /// during monomorphization.
-    pub(crate) fn default_type(&self) -> Option<Type> {
+    /// Return the operator that will "undo" this operation if applied to the rhs
+    fn approx_inverse(self) -> Option<BinaryTypeOperator> {
         match self {
-            TypeVariableKind::IntegerOrField => Some(Type::default_int_or_field_type()),
-            TypeVariableKind::Integer => Some(Type::default_int_type()),
-            TypeVariableKind::Normal => None,
+            BinaryTypeOperator::Addition => Some(BinaryTypeOperator::Subtraction),
+            BinaryTypeOperator::Subtraction => Some(BinaryTypeOperator::Addition),
+            BinaryTypeOperator::Multiplication => Some(BinaryTypeOperator::Division),
+            BinaryTypeOperator::Division => Some(BinaryTypeOperator::Multiplication),
+            BinaryTypeOperator::Modulo => None,
         }
     }
 }
@@ -2295,7 +2669,9 @@ impl From<&Type> for PrintableType {
         match value {
             Type::FieldElement => PrintableType::Field,
             Type::Array(size, typ) => {
-                let length = size.evaluate_to_u32().expect("Cannot print variable sized arrays");
+                let dummy_span = Span::default();
+                let length =
+                    size.evaluate_to_u32(dummy_span).expect("Cannot print variable sized arrays");
                 let typ = typ.as_ref();
                 PrintableType::Array { length, typ: Box::new(typ.into()) }
             }
@@ -2309,19 +2685,20 @@ impl From<&Type> for PrintableType {
                 }
                 Signedness::Signed => PrintableType::SignedInteger { width: (*bit_width).into() },
             },
-            Type::TypeVariable(binding, TypeVariableKind::Integer) => match &*binding.borrow() {
+            Type::TypeVariable(binding) => match &*binding.borrow() {
                 TypeBinding::Bound(typ) => typ.into(),
-                TypeBinding::Unbound(_) => Type::default_int_type().into(),
-            },
-            Type::TypeVariable(binding, TypeVariableKind::IntegerOrField) => {
-                match &*binding.borrow() {
-                    TypeBinding::Bound(typ) => typ.into(),
-                    TypeBinding::Unbound(_) => Type::default_int_or_field_type().into(),
+                TypeBinding::Unbound(_, Kind::Integer) => Type::default_int_type().into(),
+                TypeBinding::Unbound(_, Kind::IntegerOrField) => {
+                    Type::default_int_or_field_type().into()
                 }
-            }
+                TypeBinding::Unbound(_, Kind::Numeric(typ)) => (*typ.clone()).into(),
+                TypeBinding::Unbound(_, Kind::Any | Kind::Normal) => unreachable!(),
+            },
             Type::Bool => PrintableType::Boolean,
             Type::String(size) => {
-                let size = size.evaluate_to_u32().expect("Cannot print variable sized strings");
+                let dummy_span = Span::default();
+                let size =
+                    size.evaluate_to_u32(dummy_span).expect("Cannot print variable sized strings");
                 PrintableType::String { length: size }
             }
             Type::FmtString(_, _) => unreachable!("format strings cannot be printed"),
@@ -2337,7 +2714,7 @@ impl From<&Type> for PrintableType {
             Type::Alias(alias, args) => alias.borrow().get_type(args).into(),
             Type::TraitAsType(..) => unreachable!(),
             Type::Tuple(types) => PrintableType::Tuple { types: vecmap(types, |typ| typ.into()) },
-            Type::TypeVariable(_, _) => unreachable!(),
+            Type::CheckedCast { to, .. } => to.as_ref().into(),
             Type::NamedGeneric(..) => unreachable!(),
             Type::Forall(..) => unreachable!(),
             Type::Function(arguments, return_type, env, unconstrained) => PrintableType::Function {
@@ -2371,12 +2748,18 @@ impl std::fmt::Debug for Type {
                 Signedness::Signed => write!(f, "i{num_bits}"),
                 Signedness::Unsigned => write!(f, "u{num_bits}"),
             },
-            Type::TypeVariable(var, TypeVariableKind::Normal) => write!(f, "{:?}", var),
-            Type::TypeVariable(binding, TypeVariableKind::IntegerOrField) => {
-                write!(f, "IntOrField{:?}", binding)
-            }
-            Type::TypeVariable(binding, TypeVariableKind::Integer) => {
-                write!(f, "Int{:?}", binding)
+            Type::TypeVariable(var) => {
+                let binding = &var.1;
+                if let TypeBinding::Unbound(_, type_var_kind) = &*binding.borrow() {
+                    match type_var_kind {
+                        Kind::Any | Kind::Normal => write!(f, "{:?}", var),
+                        Kind::IntegerOrField => write!(f, "IntOrField{:?}", binding),
+                        Kind::Integer => write!(f, "Int{:?}", binding),
+                        Kind::Numeric(typ) => write!(f, "Numeric({:?}: {:?})", binding, typ),
+                    }
+                } else {
+                    write!(f, "{}", binding.borrow())
+                }
             }
             Type::Struct(s, args) => {
                 let args = vecmap(args, |arg| format!("{:?}", arg));
@@ -2406,8 +2789,9 @@ impl std::fmt::Debug for Type {
             }
             Type::Unit => write!(f, "()"),
             Type::Error => write!(f, "error"),
-            Type::NamedGeneric(binding, name, kind) => match kind {
-                Kind::Normal => {
+            Type::CheckedCast { to, .. } => write!(f, "{:?}", to),
+            Type::NamedGeneric(binding, name) => match binding.kind() {
+                Kind::Any | Kind::Normal | Kind::Integer | Kind::IntegerOrField => {
                     write!(f, "{}{:?}", name, binding)
                 }
                 Kind::Numeric(typ) => {
@@ -2467,7 +2851,8 @@ impl std::fmt::Debug for StructType {
 
 impl std::hash::Hash for Type {
     fn hash<H: std::hash::Hasher>(&self, state: &mut H) {
-        if let Some(variable) = self.get_inner_type_variable() {
+        if let Some((variable, kind)) = self.get_inner_type_variable() {
+            kind.hash(state);
             if let TypeBinding::Bound(typ) = &*variable.borrow() {
                 typ.hash(state);
                 return;
@@ -2503,7 +2888,7 @@ impl std::hash::Hash for Type {
                 alias.hash(state);
                 args.hash(state);
             }
-            Type::TypeVariable(var, _) | Type::NamedGeneric(var, ..) => var.hash(state),
+            Type::TypeVariable(var) | Type::NamedGeneric(var, ..) => var.hash(state),
             Type::TraitAsType(trait_id, _, args) => {
                 trait_id.hash(state);
                 args.hash(state);
@@ -2519,6 +2904,7 @@ impl std::hash::Hash for Type {
                 vars.hash(state);
                 typ.hash(state);
             }
+            Type::CheckedCast { to, .. } => to.hash(state),
             Type::Constant(value, _) => value.hash(state),
             Type::Quoted(typ) => typ.hash(state),
             Type::InfixExpr(lhs, op, rhs) => {
@@ -2532,13 +2918,19 @@ impl std::hash::Hash for Type {
 
 impl PartialEq for Type {
     fn eq(&self, other: &Self) -> bool {
-        if let Some(variable) = self.get_inner_type_variable() {
+        if let Some((variable, kind)) = self.get_inner_type_variable() {
+            if kind != other.kind() {
+                return false;
+            }
             if let TypeBinding::Bound(typ) = &*variable.borrow() {
                 return typ == other;
             }
         }
 
-        if let Some(variable) = other.get_inner_type_variable() {
+        if let Some((variable, other_kind)) = other.get_inner_type_variable() {
+            if self.kind() != other_kind {
+                return false;
+            }
             if let TypeBinding::Bound(typ) = &*variable.borrow() {
                 return self == typ;
             }
@@ -2579,6 +2971,7 @@ impl PartialEq for Type {
             (Forall(lhs_vars, lhs_type), Forall(rhs_vars, rhs_type)) => {
                 lhs_vars == rhs_vars && lhs_type == rhs_type
             }
+            (CheckedCast { to, .. }, other) | (other, CheckedCast { to, .. }) => **to == *other,
             (Constant(lhs, lhs_kind), Constant(rhs, rhs_kind)) => {
                 lhs == rhs && lhs_kind == rhs_kind
             }
@@ -2592,8 +2985,8 @@ impl PartialEq for Type {
             // still want them to be equal for canonicalization checks in arithmetic generics.
             // Without this we'd fail the `serialize` test.
             (
-                NamedGeneric(lhs_var, _, _) | TypeVariable(lhs_var, _),
-                NamedGeneric(rhs_var, _, _) | TypeVariable(rhs_var, _),
+                NamedGeneric(lhs_var, _) | TypeVariable(lhs_var),
+                NamedGeneric(rhs_var, _) | TypeVariable(rhs_var),
             ) => lhs_var.id() == rhs_var.id(),
             _ => false,
         }
diff --git a/compiler/noirc_frontend/src/hir_def/types/arithmetic.rs b/compiler/noirc_frontend/src/hir_def/types/arithmetic.rs
index 54b4c27a1f3..8cdf6f5502c 100644
--- a/compiler/noirc_frontend/src/hir_def/types/arithmetic.rs
+++ b/compiler/noirc_frontend/src/hir_def/types/arithmetic.rs
@@ -1,5 +1,8 @@
 use std::collections::BTreeMap;
 
+use acvm::{AcirField, FieldElement};
+use noirc_errors::Span;
+
 use crate::{BinaryTypeOperator, Type, TypeBindings, UnificationError};
 
 impl Type {
@@ -13,32 +16,81 @@ impl Type {
     /// - `canonicalize[((1 + N) + M) + 2] = (M + N) + 3`
     /// - `canonicalize[A + 2 * B + 3 - 2] = A + (B * 2) + 3 - 2`
     pub fn canonicalize(&self) -> Type {
+        match self.follow_bindings() {
+            Type::CheckedCast { from, to } => Type::CheckedCast {
+                from: Box::new(from.canonicalize_checked()),
+                to: Box::new(to.canonicalize_unchecked()),
+            },
+
+            other => {
+                let non_checked_cast = false;
+                let run_simplifications = true;
+                other.canonicalize_helper(non_checked_cast, run_simplifications)
+            }
+        }
+    }
+
+    /// Only simplify constants and drop/skip any CheckedCast's
+    pub(crate) fn canonicalize_checked(&self) -> Type {
+        let found_checked_cast = true;
+        let skip_simplifications = false;
+        self.canonicalize_helper(found_checked_cast, skip_simplifications)
+    }
+
+    /// Run all simplifications and drop/skip any CheckedCast's
+    fn canonicalize_unchecked(&self) -> Type {
+        let found_checked_cast = true;
+        let run_simplifications = true;
+        self.canonicalize_helper(found_checked_cast, run_simplifications)
+    }
+
+    /// If found_checked_cast, then drop additional CheckedCast's
+    ///
+    /// If run_simplifications is false, then only:
+    /// - Attempt to evaluate each sub-expression to a constant
+    /// - Drop nested CheckedCast's
+    ///
+    /// Otherwise also attempt try_simplify_partial_constants, sort_commutative,
+    /// and other simplifications
+    pub(crate) fn canonicalize_helper(
+        &self,
+        found_checked_cast: bool,
+        run_simplifications: bool,
+    ) -> Type {
         match self.follow_bindings() {
             Type::InfixExpr(lhs, op, rhs) => {
-                // evaluate_to_u32 also calls canonicalize so if we just called
-                // `self.evaluate_to_u32()` we'd get infinite recursion.
-                if let (Some(lhs_u32), Some(rhs_u32)) =
-                    (lhs.evaluate_to_u32(), rhs.evaluate_to_u32())
-                {
-                    if let Some(result) = op.function(lhs_u32, rhs_u32) {
-                        return Type::Constant(result, lhs.infix_kind(&rhs));
+                let kind = lhs.infix_kind(&rhs);
+                let dummy_span = Span::default();
+                // evaluate_to_field_element also calls canonicalize so if we just called
+                // `self.evaluate_to_field_element(..)` we'd get infinite recursion.
+                if let (Ok(lhs_value), Ok(rhs_value)) = (
+                    lhs.evaluate_to_field_element_helper(&kind, dummy_span, run_simplifications),
+                    rhs.evaluate_to_field_element_helper(&kind, dummy_span, run_simplifications),
+                ) {
+                    if let Ok(result) = op.function(lhs_value, rhs_value, &kind, dummy_span) {
+                        return Type::Constant(result, kind);
                     }
                 }
 
-                let lhs = lhs.canonicalize();
-                let rhs = rhs.canonicalize();
+                let lhs = lhs.canonicalize_helper(found_checked_cast, run_simplifications);
+                let rhs = rhs.canonicalize_helper(found_checked_cast, run_simplifications);
+
+                if !run_simplifications {
+                    return Type::InfixExpr(Box::new(lhs), op, Box::new(rhs));
+                }
+
                 if let Some(result) = Self::try_simplify_non_constants_in_lhs(&lhs, op, &rhs) {
-                    return result.canonicalize();
+                    return result.canonicalize_unchecked();
                 }
 
                 if let Some(result) = Self::try_simplify_non_constants_in_rhs(&lhs, op, &rhs) {
-                    return result.canonicalize();
+                    return result.canonicalize_unchecked();
                 }
 
                 // Try to simplify partially constant expressions in the form `(N op1 C1) op2 C2`
                 // where C1 and C2 are constants that can be combined (e.g. N + 5 - 3 = N + 2)
                 if let Some(result) = Self::try_simplify_partial_constants(&lhs, op, &rhs) {
-                    return result.canonicalize();
+                    return result.canonicalize_unchecked();
                 }
 
                 if op.is_commutative() {
@@ -47,6 +99,18 @@ impl Type {
 
                 Type::InfixExpr(Box::new(lhs), op, Box::new(rhs))
             }
+            Type::CheckedCast { from, to } => {
+                let inner_found_checked_cast = true;
+                let to = to.canonicalize_helper(inner_found_checked_cast, run_simplifications);
+
+                if found_checked_cast {
+                    return to;
+                }
+
+                let from = from.canonicalize_checked();
+
+                Type::CheckedCast { from: Box::new(from), to: Box::new(to) }
+            }
             other => other,
         }
     }
@@ -57,18 +121,25 @@ impl Type {
         // Maps each term to the number of times that term was used.
         let mut sorted = BTreeMap::new();
 
-        let zero_value = if op == BinaryTypeOperator::Addition { 0 } else { 1 };
+        let zero_value = if op == BinaryTypeOperator::Addition {
+            FieldElement::zero()
+        } else {
+            FieldElement::one()
+        };
         let mut constant = zero_value;
 
         // Push each non-constant term to `sorted` to sort them. Recur on InfixExprs with the same operator.
         while let Some(item) = queue.pop() {
-            match item.canonicalize() {
-                Type::InfixExpr(lhs, new_op, rhs) if new_op == op => {
-                    queue.push(*lhs);
-                    queue.push(*rhs);
+            match item.canonicalize_unchecked() {
+                Type::InfixExpr(lhs_inner, new_op, rhs_inner) if new_op == op => {
+                    queue.push(*lhs_inner);
+                    queue.push(*rhs_inner);
                 }
                 Type::Constant(new_constant, new_constant_kind) => {
-                    if let Some(result) = op.function(constant, new_constant) {
+                    let dummy_span = Span::default();
+                    if let Ok(result) =
+                        op.function(constant, new_constant, &new_constant_kind, dummy_span)
+                    {
                         constant = result;
                     } else {
                         let constant = Type::Constant(new_constant, new_constant_kind);
@@ -112,23 +183,33 @@ impl Type {
     /// Precondition: `lhs & rhs are in canonical form`
     ///
     /// - Simplifies `(N +/- M) -/+ M` to `N`
-    /// - Simplifies `(N */÷ M) ÷/* M` to `N`
+    /// - Simplifies `(N * M) ÷ M` to `N`
     fn try_simplify_non_constants_in_lhs(
         lhs: &Type,
         op: BinaryTypeOperator,
         rhs: &Type,
     ) -> Option<Type> {
-        let Type::InfixExpr(l_lhs, l_op, l_rhs) = lhs.follow_bindings() else {
-            return None;
-        };
+        match lhs.follow_bindings() {
+            Type::CheckedCast { from, to } => {
+                // Apply operation directly to `from` while attempting simplification to `to`.
+                let from = Type::InfixExpr(from, op, Box::new(rhs.clone()));
+                let to = Self::try_simplify_non_constants_in_lhs(&to, op, rhs)?;
+                Some(Type::CheckedCast { from: Box::new(from), to: Box::new(to) })
+            }
+            Type::InfixExpr(l_lhs, l_op, l_rhs) => {
+                // Note that this is exact, syntactic equality, not unification.
+                // `rhs` is expected to already be in canonical form.
+                if l_op.approx_inverse() != Some(op)
+                    || l_op == BinaryTypeOperator::Division
+                    || l_rhs.canonicalize_unchecked() != *rhs
+                {
+                    return None;
+                }
 
-        // Note that this is exact, syntactic equality, not unification.
-        // `rhs` is expected to already be in canonical form.
-        if l_op.inverse() != Some(op) || l_rhs.canonicalize() != *rhs {
-            return None;
+                Some(*l_lhs)
+            }
+            _ => None,
         }
-
-        Some(*l_lhs)
     }
 
     /// Try to simplify non-constant expressions in the form `N op1 (M op1 N)`
@@ -145,23 +226,31 @@ impl Type {
         op: BinaryTypeOperator,
         rhs: &Type,
     ) -> Option<Type> {
-        let Type::InfixExpr(r_lhs, r_op, r_rhs) = rhs.follow_bindings() else {
-            return None;
-        };
+        match rhs.follow_bindings() {
+            Type::CheckedCast { from, to } => {
+                // Apply operation directly to `from` while attempting simplification to `to`.
+                let from = Type::InfixExpr(Box::new(lhs.clone()), op, from);
+                let to = Self::try_simplify_non_constants_in_rhs(lhs, op, &to)?;
+                Some(Type::CheckedCast { from: Box::new(from), to: Box::new(to) })
+            }
+            Type::InfixExpr(r_lhs, r_op, r_rhs) => {
+                // `N / (M * N)` should be simplified to `1 / M`, but we only handle
+                // simplifying to `M` in this function.
+                if op == BinaryTypeOperator::Division && r_op == BinaryTypeOperator::Multiplication
+                {
+                    return None;
+                }
 
-        // `N / (M * N)` should be simplified to `1 / M`, but we only handle
-        // simplifying to `M` in this function.
-        if op == BinaryTypeOperator::Division && r_op == BinaryTypeOperator::Multiplication {
-            return None;
-        }
+                // Note that this is exact, syntactic equality, not unification.
+                // `lhs` is expected to already be in canonical form.
+                if r_op.inverse() != Some(op) || *lhs != r_rhs.canonicalize_unchecked() {
+                    return None;
+                }
 
-        // Note that this is exact, syntactic equality, not unification.
-        // `lhs` is expected to already be in canonical form.
-        if r_op.inverse() != Some(op) || *lhs != r_rhs.canonicalize() {
-            return None;
+                Some(*r_lhs)
+            }
+            _ => None,
         }
-
-        Some(*r_lhs)
     }
 
     /// Given:
@@ -174,14 +263,17 @@ impl Type {
     fn parse_partial_constant_expr(
         lhs: &Type,
         rhs: &Type,
-    ) -> Option<(Box<Type>, BinaryTypeOperator, u32, u32)> {
-        let rhs = rhs.evaluate_to_u32()?;
+    ) -> Option<(Box<Type>, BinaryTypeOperator, FieldElement, FieldElement)> {
+        let kind = lhs.infix_kind(rhs);
+        let dummy_span = Span::default();
+        let rhs = rhs.evaluate_to_field_element(&kind, dummy_span).ok()?;
 
         let Type::InfixExpr(l_type, l_op, l_rhs) = lhs.follow_bindings() else {
             return None;
         };
 
-        let l_rhs = l_rhs.evaluate_to_u32()?;
+        let dummy_span = Span::default();
+        let l_rhs = l_rhs.evaluate_to_field_element(&kind, dummy_span).ok()?;
         Some((l_type, l_op, l_rhs, rhs))
     }
 
@@ -190,7 +282,8 @@ impl Type {
     /// Precondition: `lhs & rhs are in canonical form`
     ///
     /// - Simplifies `(N +/- C1) +/- C2` to `N +/- (C1 +/- C2)` if C1 and C2 are constants.
-    /// - Simplifies `(N */÷ C1) */÷ C2` to `N */÷ (C1 */÷ C2)` if C1 and C2 are constants.
+    /// - Simplifies `(N * C1) ÷ C2` to `N * (C1 ÷ C2)` if C1 and C2 are constants which divide
+    ///   without a remainder.
     fn try_simplify_partial_constants(
         lhs: &Type,
         mut op: BinaryTypeOperator,
@@ -205,20 +298,24 @@ impl Type {
                 if l_op == Subtraction {
                     op = op.inverse()?;
                 }
-                let result = op.function(l_const, r_const)?;
+                let dummy_span = Span::default();
+                let result =
+                    op.function(l_const, r_const, &lhs.infix_kind(rhs), dummy_span).ok()?;
                 let constant = Type::Constant(result, lhs.infix_kind(rhs));
                 Some(Type::InfixExpr(l_type, l_op, Box::new(constant)))
             }
-            (Multiplication | Division, Multiplication | Division) => {
-                // If l_op is a division we want to inverse the rhs operator.
-                if l_op == Division {
-                    op = op.inverse()?;
-                }
+            (Multiplication, Division) => {
+                // We need to ensure the result divides evenly to preserve integer division semantics
+                let divides_evenly = !lhs.infix_kind(rhs).is_type_level_field_element()
+                    && l_const.to_i128().checked_rem(r_const.to_i128()) == Some(0);
+
                 // If op is a division we need to ensure it divides evenly
-                if op == Division && (r_const == 0 || l_const % r_const != 0) {
+                if op == Division && (r_const == FieldElement::zero() || !divides_evenly) {
                     None
                 } else {
-                    let result = op.function(l_const, r_const)?;
+                    let dummy_span = Span::default();
+                    let result =
+                        op.function(l_const, r_const, &lhs.infix_kind(rhs), dummy_span).ok()?;
                     let constant = Box::new(Type::Constant(result, lhs.infix_kind(rhs)));
                     Some(Type::InfixExpr(l_type, l_op, constant))
                 }
@@ -235,9 +332,11 @@ impl Type {
         bindings: &mut TypeBindings,
     ) -> Result<(), UnificationError> {
         if let Type::InfixExpr(lhs_a, op_a, rhs_a) = self {
-            if let Some(inverse) = op_a.inverse() {
-                if let Some(rhs_a_u32) = rhs_a.evaluate_to_u32() {
-                    let rhs_a = Box::new(Type::Constant(rhs_a_u32, lhs_a.infix_kind(rhs_a)));
+            if let Some(inverse) = op_a.approx_inverse() {
+                let kind = lhs_a.infix_kind(rhs_a);
+                let dummy_span = Span::default();
+                if let Ok(rhs_a_value) = rhs_a.evaluate_to_field_element(&kind, dummy_span) {
+                    let rhs_a = Box::new(Type::Constant(rhs_a_value, kind));
                     let new_other = Type::InfixExpr(Box::new(other.clone()), inverse, rhs_a);
 
                     let mut tmp_bindings = bindings.clone();
@@ -250,9 +349,11 @@ impl Type {
         }
 
         if let Type::InfixExpr(lhs_b, op_b, rhs_b) = other {
-            if let Some(inverse) = op_b.inverse() {
-                if let Some(rhs_b_u32) = rhs_b.evaluate_to_u32() {
-                    let rhs_b = Box::new(Type::Constant(rhs_b_u32, lhs_b.infix_kind(rhs_b)));
+            if let Some(inverse) = op_b.approx_inverse() {
+                let kind = lhs_b.infix_kind(rhs_b);
+                let dummy_span = Span::default();
+                if let Ok(rhs_b_value) = rhs_b.evaluate_to_field_element(&kind, dummy_span) {
+                    let rhs_b = Box::new(Type::Constant(rhs_b_value, kind));
                     let new_self = Type::InfixExpr(Box::new(self.clone()), inverse, rhs_b);
 
                     let mut tmp_bindings = bindings.clone();
@@ -267,3 +368,301 @@ impl Type {
         Err(UnificationError)
     }
 }
+
+#[cfg(test)]
+mod tests {
+    use acvm::{AcirField, FieldElement};
+
+    use crate::hir_def::types::{BinaryTypeOperator, Kind, Type, TypeVariable, TypeVariableId};
+
+    #[test]
+    fn solves_n_minus_one_plus_one_through_checked_casts() {
+        // We want to test that the inclusion of a `CheckedCast` won't prevent us from canonicalizing
+        // the expression `(N - 1) + 1` to `N` if there exists a `CheckedCast` on the `N - 1` term.
+
+        let n = Type::NamedGeneric(
+            TypeVariable::unbound(TypeVariableId(0), Kind::u32()),
+            std::rc::Rc::new("N".to_owned()),
+        );
+        let n_minus_one = Type::InfixExpr(
+            Box::new(n.clone()),
+            BinaryTypeOperator::Subtraction,
+            Box::new(Type::Constant(FieldElement::one(), Kind::u32())),
+        );
+        let checked_cast_n_minus_one =
+            Type::CheckedCast { from: Box::new(n_minus_one.clone()), to: Box::new(n_minus_one) };
+
+        let n_minus_one_plus_one = Type::InfixExpr(
+            Box::new(checked_cast_n_minus_one.clone()),
+            BinaryTypeOperator::Addition,
+            Box::new(Type::Constant(FieldElement::one(), Kind::u32())),
+        );
+
+        let canonicalized_typ = n_minus_one_plus_one.canonicalize();
+
+        assert_eq!(n, canonicalized_typ);
+
+        // We also want to check that if the `CheckedCast` is on the RHS then we'll still be able to canonicalize
+        // the expression `1 + (N - 1)` to `N`.
+
+        let one_plus_n_minus_one = Type::InfixExpr(
+            Box::new(Type::Constant(FieldElement::one(), Kind::u32())),
+            BinaryTypeOperator::Addition,
+            Box::new(checked_cast_n_minus_one),
+        );
+
+        let canonicalized_typ = one_plus_n_minus_one.canonicalize();
+
+        assert_eq!(n, canonicalized_typ);
+    }
+
+    #[test]
+    fn instantiate_after_canonicalize_smoke_test() {
+        let field_element_kind = Kind::numeric(Type::FieldElement);
+        let x_var = TypeVariable::unbound(TypeVariableId(0), field_element_kind.clone());
+        let x_type = Type::TypeVariable(x_var.clone());
+        let one = Type::Constant(FieldElement::one(), field_element_kind.clone());
+
+        let lhs = Type::InfixExpr(
+            Box::new(x_type.clone()),
+            BinaryTypeOperator::Addition,
+            Box::new(one.clone()),
+        );
+        let rhs =
+            Type::InfixExpr(Box::new(one), BinaryTypeOperator::Addition, Box::new(x_type.clone()));
+
+        // canonicalize
+        let lhs = lhs.canonicalize();
+        let rhs = rhs.canonicalize();
+
+        // bind vars
+        let two = Type::Constant(FieldElement::from(2u128), field_element_kind.clone());
+        x_var.bind(two);
+
+        // canonicalize (expect constant)
+        let lhs = lhs.canonicalize();
+        let rhs = rhs.canonicalize();
+
+        // ensure we've canonicalized to constants
+        assert!(matches!(lhs, Type::Constant(..)));
+        assert!(matches!(rhs, Type::Constant(..)));
+
+        // ensure result kinds are the same as the original kind
+        assert_eq!(lhs.kind(), field_element_kind);
+        assert_eq!(rhs.kind(), field_element_kind);
+
+        // ensure results are the same
+        assert_eq!(lhs, rhs);
+    }
+}
+
+#[cfg(test)]
+mod proptests {
+
+    use acvm::{AcirField, FieldElement};
+    use proptest::arbitrary::any;
+    use proptest::collection;
+    use proptest::prelude::*;
+    use proptest::result::maybe_ok;
+    use proptest::strategy;
+
+    use crate::ast::{IntegerBitSize, Signedness};
+    use crate::hir_def::types::{BinaryTypeOperator, Kind, Type, TypeVariable, TypeVariableId};
+
+    prop_compose! {
+        // maximum_size must be non-zero
+        fn arbitrary_u128_field_element(maximum_size: u128)
+            (u128_value in any::<u128>())
+            -> FieldElement
+        {
+            assert!(maximum_size != 0);
+            FieldElement::from(u128_value % maximum_size)
+        }
+    }
+
+    // NOTE: this is roughly the same method from acvm/tests/solver
+    prop_compose! {
+        // Use both `u128` and hex proptest strategies
+        fn arbitrary_field_element()
+            (u128_or_hex in maybe_ok(any::<u128>(), "[0-9a-f]{64}"))
+            -> FieldElement
+        {
+            match u128_or_hex {
+                Ok(number) => FieldElement::from(number),
+                Err(hex) => FieldElement::from_hex(&hex).expect("should accept any 32 byte hex string"),
+            }
+        }
+    }
+
+    // Generate (arbitrary_unsigned_type, generator for that type)
+    fn arbitrary_unsigned_type_with_generator() -> BoxedStrategy<(Type, BoxedStrategy<FieldElement>)>
+    {
+        prop_oneof![
+            strategy::Just((Type::FieldElement, arbitrary_field_element().boxed())),
+            any::<IntegerBitSize>().prop_map(|bit_size| {
+                let typ = Type::Integer(Signedness::Unsigned, bit_size);
+                let maximum_size = typ.integral_maximum_size().unwrap().to_u128();
+                (typ, arbitrary_u128_field_element(maximum_size).boxed())
+            }),
+            strategy::Just((Type::Bool, arbitrary_u128_field_element(1).boxed())),
+        ]
+        .boxed()
+    }
+
+    prop_compose! {
+        fn arbitrary_variable(typ: Type, num_variables: usize)
+            (variable_index in any::<usize>())
+        -> Type {
+            assert!(num_variables != 0);
+            let id = TypeVariableId(variable_index % num_variables);
+            let kind = Kind::numeric(typ.clone());
+            let var = TypeVariable::unbound(id, kind);
+            Type::TypeVariable(var)
+        }
+    }
+
+    fn first_n_variables(typ: Type, num_variables: usize) -> impl Iterator<Item = TypeVariable> {
+        (0..num_variables).map(move |id| {
+            let id = TypeVariableId(id);
+            let kind = Kind::numeric(typ.clone());
+            TypeVariable::unbound(id, kind)
+        })
+    }
+
+    fn arbitrary_infix_expr(
+        typ: Type,
+        arbitrary_value: BoxedStrategy<FieldElement>,
+        num_variables: usize,
+    ) -> impl Strategy<Value = Type> {
+        let leaf = prop_oneof![
+            arbitrary_variable(typ.clone(), num_variables),
+            arbitrary_value
+                .prop_map(move |value| Type::Constant(value, Kind::numeric(typ.clone()))),
+        ];
+
+        leaf.prop_recursive(
+            8,   // 8 levels deep maximum
+            256, // Shoot for maximum size of 256 nodes
+            10,  // We put up to 10 items per collection
+            |inner| {
+                (inner.clone(), any::<BinaryTypeOperator>(), inner)
+                    .prop_map(|(lhs, op, rhs)| Type::InfixExpr(Box::new(lhs), op, Box::new(rhs)))
+            },
+        )
+    }
+
+    prop_compose! {
+        // (infix_expr, type, generator)
+        fn arbitrary_infix_expr_type_gen(num_variables: usize)
+            (type_and_gen in arbitrary_unsigned_type_with_generator())
+            (infix_expr in arbitrary_infix_expr(type_and_gen.clone().0, type_and_gen.clone().1, num_variables), type_and_gen in Just(type_and_gen))
+        -> (Type, Type, BoxedStrategy<FieldElement>) {
+            let (typ, value_generator) = type_and_gen;
+            (infix_expr, typ, value_generator)
+        }
+    }
+
+    prop_compose! {
+        // (Type::InfixExpr, numeric kind, bindings)
+        fn arbitrary_infix_expr_with_bindings_sized(num_variables: usize)
+            (infix_type_gen in arbitrary_infix_expr_type_gen(num_variables))
+            (values in collection::vec(infix_type_gen.clone().2, num_variables), infix_type_gen in Just(infix_type_gen))
+        -> (Type, Type, Vec<(TypeVariable, Type)>) {
+            let (infix_expr, typ, _value_generator) = infix_type_gen;
+            let bindings: Vec<_> = first_n_variables(typ.clone(), num_variables)
+                .zip(values.iter().map(|value| {
+                    Type::Constant(*value, Kind::numeric(typ.clone()))
+                }))
+                .collect();
+            (infix_expr, typ, bindings)
+        }
+    }
+
+    prop_compose! {
+        // the lint misfires on 'num_variables'
+        #[allow(unused_variables)]
+        fn arbitrary_infix_expr_with_bindings(max_num_variables: usize)
+            (num_variables in any::<usize>().prop_map(move |num_variables| (num_variables % max_num_variables).clamp(1, max_num_variables)))
+            (infix_type_bindings in arbitrary_infix_expr_with_bindings_sized(num_variables), num_variables in Just(num_variables))
+        -> (Type, Type, Vec<(TypeVariable, Type)>) {
+            infix_type_bindings
+        }
+    }
+
+    proptest! {
+        #[test]
+        // Expect cases that don't resolve to constants, e.g. see
+        // `arithmetic_generics_checked_cast_indirect_zeros`
+        #[should_panic(expected = "matches!(infix, Type :: Constant(..))")]
+        fn instantiate_before_or_after_canonicalize(infix_type_bindings in arbitrary_infix_expr_with_bindings(10)) {
+            let (infix, typ, bindings) = infix_type_bindings;
+
+            // canonicalize
+            let infix_canonicalized = infix.canonicalize();
+
+            // bind vars
+            for (var, binding) in bindings {
+                var.bind(binding);
+            }
+
+            // attempt to canonicalize to a constant
+            let infix = infix.canonicalize();
+            let infix_canonicalized = infix_canonicalized.canonicalize();
+
+            // ensure we've canonicalized to constants
+            prop_assert!(matches!(infix, Type::Constant(..)));
+            prop_assert!(matches!(infix_canonicalized, Type::Constant(..)));
+
+            // ensure result kinds are the same as the original kind
+            let kind = Kind::numeric(typ);
+            prop_assert_eq!(infix.kind(), kind.clone());
+            prop_assert_eq!(infix_canonicalized.kind(), kind);
+
+            // ensure results are the same
+            prop_assert_eq!(infix, infix_canonicalized);
+        }
+
+        #[test]
+        fn instantiate_before_or_after_canonicalize_checked_cast(infix_type_bindings in arbitrary_infix_expr_with_bindings(10)) {
+            let (infix, typ, bindings) = infix_type_bindings;
+
+            // wrap in CheckedCast
+            let infix = Type::CheckedCast {
+                from: Box::new(infix.clone()),
+                to: Box::new(infix)
+            };
+
+            // canonicalize
+            let infix_canonicalized = infix.canonicalize();
+
+            // bind vars
+            for (var, binding) in bindings {
+                var.bind(binding);
+            }
+
+            // attempt to canonicalize to a constant
+            let infix = infix.canonicalize();
+            let infix_canonicalized = infix_canonicalized.canonicalize();
+
+            // ensure result kinds are the same as the original kind
+            let kind = Kind::numeric(typ);
+            prop_assert_eq!(infix.kind(), kind.clone());
+            prop_assert_eq!(infix_canonicalized.kind(), kind.clone());
+
+            // ensure the results are still wrapped in CheckedCast's
+            match (&infix, &infix_canonicalized) {
+                (Type::CheckedCast { from, to }, Type::CheckedCast { from: from_canonicalized, to: to_canonicalized }) => {
+                    // ensure from's are the same
+                    prop_assert_eq!(from, from_canonicalized);
+
+                    // ensure to's have the same kinds
+                    prop_assert_eq!(to.kind(), kind.clone());
+                    prop_assert_eq!(to_canonicalized.kind(), kind);
+                }
+                _ => {
+                    prop_assert!(false, "expected CheckedCast");
+                }
+            }
+        }
+    }
+}
diff --git a/compiler/noirc_frontend/src/lexer/errors.rs b/compiler/noirc_frontend/src/lexer/errors.rs
index 6e64c509195..f95ccba061a 100644
--- a/compiler/noirc_frontend/src/lexer/errors.rs
+++ b/compiler/noirc_frontend/src/lexer/errors.rs
@@ -20,6 +20,8 @@ pub enum LexerErrorKind {
     IntegerLiteralTooLarge { span: Span, limit: String },
     #[error("{:?} is not a valid attribute", found)]
     MalformedFuncAttribute { span: Span, found: String },
+    #[error("Malformed test attribute")]
+    MalformedTestAttribute { span: Span },
     #[error("{:?} is not a valid inner attribute", found)]
     InvalidInnerAttribute { span: Span, found: String },
     #[error("Logical and used instead of bitwise and")]
@@ -28,6 +30,10 @@ pub enum LexerErrorKind {
     UnterminatedBlockComment { span: Span },
     #[error("Unterminated string literal")]
     UnterminatedStringLiteral { span: Span },
+    #[error("Invalid format string: expected '}}', found {found:?}")]
+    InvalidFormatString { found: char, span: Span },
+    #[error("Invalid format string: expected letter or underscore, found '}}'")]
+    EmptyFormatStringInterpolation { span: Span },
     #[error(
         "'\\{escaped}' is not a valid escape sequence. Use '\\' for a literal backslash character."
     )]
@@ -61,10 +67,13 @@ impl LexerErrorKind {
             LexerErrorKind::InvalidIntegerLiteral { span, .. } => *span,
             LexerErrorKind::IntegerLiteralTooLarge { span, .. } => *span,
             LexerErrorKind::MalformedFuncAttribute { span, .. } => *span,
+            LexerErrorKind::MalformedTestAttribute { span, .. } => *span,
             LexerErrorKind::InvalidInnerAttribute { span, .. } => *span,
             LexerErrorKind::LogicalAnd { span } => *span,
             LexerErrorKind::UnterminatedBlockComment { span } => *span,
             LexerErrorKind::UnterminatedStringLiteral { span } => *span,
+            LexerErrorKind::InvalidFormatString { span, .. } => *span,
+            LexerErrorKind::EmptyFormatStringInterpolation { span, .. } => *span,
             LexerErrorKind::InvalidEscape { span, .. } => *span,
             LexerErrorKind::InvalidQuoteDelimiter { delimiter } => delimiter.to_span(),
             LexerErrorKind::NonAsciiComment { span, .. } => *span,
@@ -109,6 +118,11 @@ impl LexerErrorKind {
                 format!(" {found} is not a valid attribute"),
                 *span,
             ),
+            LexerErrorKind::MalformedTestAttribute { span } => (
+                "Malformed test attribute".to_string(),
+                "The test attribute can be written in one of these forms: `#[test]`, `#[test(should_fail)]` or `#[test(should_fail_with = \"message\")]`".to_string(),
+                *span,
+            ),
             LexerErrorKind::InvalidInnerAttribute { span, found } => (
                 "Invalid inner attribute".to_string(),
                 format!(" {found} is not a valid inner attribute"),
@@ -122,6 +136,32 @@ impl LexerErrorKind {
             LexerErrorKind::UnterminatedBlockComment { span } => ("Unterminated block comment".to_string(), "Unterminated block comment".to_string(), *span),
             LexerErrorKind::UnterminatedStringLiteral { span } =>
                 ("Unterminated string literal".to_string(), "Unterminated string literal".to_string(), *span),
+            LexerErrorKind::InvalidFormatString { found, span } => {
+                if found == &'}' {
+                    (
+                        "Invalid format string: unmatched '}}' found".to_string(),
+                        "If you intended to print '}', you can escape it using '}}'".to_string(),
+                        *span,
+                    )
+                } else {
+                    (
+                        format!("Invalid format string: expected '}}', found {found:?}"),
+                        if found == &'.' {
+                            "Field access isn't supported in format strings".to_string()
+                        } else {
+                            "If you intended to print '{', you can escape it using '{{'".to_string()
+                        },
+                        *span,
+                    )
+                }
+            }
+            LexerErrorKind::EmptyFormatStringInterpolation { span } => {
+                (
+                    "Invalid format string: expected letter or underscore, found '}}'".to_string(),
+                    "If you intended to print '{' or '}', you can escape them using '{{' and '}}' respectively".to_string(),
+                    *span,
+                )
+            }
             LexerErrorKind::InvalidEscape { escaped, span } =>
                 (format!("'\\{escaped}' is not a valid escape sequence. Use '\\' for a literal backslash character."), "Invalid escape sequence".to_string(), *span),
             LexerErrorKind::InvalidQuoteDelimiter { delimiter } => {
@@ -143,10 +183,3 @@ impl<'a> From<&'a LexerErrorKind> for Diagnostic {
         Diagnostic::simple_error(primary, secondary, span)
     }
 }
-
-impl From<LexerErrorKind> for chumsky::error::Simple<SpannedToken, Span> {
-    fn from(error: LexerErrorKind) -> Self {
-        let (_, message, span) = error.parts();
-        chumsky::error::Simple::custom(span, message)
-    }
-}
diff --git a/compiler/noirc_frontend/src/lexer/lexer.rs b/compiler/noirc_frontend/src/lexer/lexer.rs
index 95eb41fd6d0..a5c4b2cd772 100644
--- a/compiler/noirc_frontend/src/lexer/lexer.rs
+++ b/compiler/noirc_frontend/src/lexer/lexer.rs
@@ -1,8 +1,8 @@
-use crate::token::{Attribute, DocStyle};
+use crate::token::DocStyle;
 
 use super::{
     errors::LexerErrorKind,
-    token::{IntType, Keyword, SpannedToken, Token, Tokens},
+    token::{FmtStrFragment, IntType, Keyword, SpannedToken, Token, Tokens},
 };
 use acvm::{AcirField, FieldElement};
 use noirc_errors::{Position, Span};
@@ -86,6 +86,11 @@ impl<'a> Lexer<'a> {
         self.peek_char() == Some(ch)
     }
 
+    /// Peeks at the character two positions ahead and returns true if it is equal to the char argument
+    fn peek2_char_is(&mut self, ch: char) -> bool {
+        self.peek2_char() == Some(ch)
+    }
+
     fn ampersand(&mut self) -> SpannedTokenResult {
         if self.peek_char_is('&') {
             // When we issue this error the first '&' will already be consumed
@@ -134,7 +139,7 @@ impl<'a> Lexer<'a> {
             Some('f') => self.eat_format_string_or_alpha_numeric(),
             Some('r') => self.eat_raw_string_or_alpha_numeric(),
             Some('q') => self.eat_quote_or_alpha_numeric(),
-            Some('#') => self.eat_attribute(),
+            Some('#') => self.eat_attribute_start(),
             Some(ch) if ch.is_ascii_alphanumeric() || ch == '_' => self.eat_alpha_numeric(ch),
             Some(ch) => {
                 // We don't report invalid tokens in the source as errors until parsing to
@@ -152,6 +157,7 @@ impl<'a> Lexer<'a> {
         Ok(token.into_single_span(self.position))
     }
 
+    /// If `single` is followed by `character` then extend it as `double`.
     fn single_double_peek_token(
         &mut self,
         character: char,
@@ -169,13 +175,23 @@ impl<'a> Lexer<'a> {
         }
     }
 
-    /// Given that some tokens can contain two characters, such as <= , !=, >=
-    /// Glue will take the first character of the token and check if it can be glued onto the next character
-    /// forming a double token
+    /// Given that some tokens can contain two characters, such as <= , !=, >=, or even three like ..=
+    /// Glue will take the first character of the token and check if it can be glued onto the next character(s)
+    /// forming a double or triple token
+    ///
+    /// Returns an error if called with a token which cannot be extended with anything.
     fn glue(&mut self, prev_token: Token) -> SpannedTokenResult {
-        let spanned_prev_token = prev_token.clone().into_single_span(self.position);
         match prev_token {
-            Token::Dot => self.single_double_peek_token('.', prev_token, Token::DoubleDot),
+            Token::Dot => {
+                if self.peek_char_is('.') && self.peek2_char_is('=') {
+                    let start = self.position;
+                    self.next_char();
+                    self.next_char();
+                    Ok(Token::DoubleDotEqual.into_span(start, start + 2))
+                } else {
+                    self.single_double_peek_token('.', prev_token, Token::DoubleDot)
+                }
+            }
             Token::Less => {
                 let start = self.position;
                 if self.peek_char_is('=') {
@@ -214,7 +230,7 @@ impl<'a> Lexer<'a> {
                     return self.parse_block_comment(start);
                 }
 
-                Ok(spanned_prev_token)
+                Ok(prev_token.into_single_span(start))
             }
             _ => Err(LexerErrorKind::NotADoubleChar {
                 span: Span::single_char(self.position),
@@ -266,7 +282,7 @@ impl<'a> Lexer<'a> {
         }
     }
 
-    fn eat_attribute(&mut self) -> SpannedTokenResult {
+    fn eat_attribute_start(&mut self) -> SpannedTokenResult {
         let start = self.position;
 
         let is_inner = if self.peek_char_is('!') {
@@ -285,40 +301,14 @@ impl<'a> Lexer<'a> {
         }
         self.next_char();
 
-        let contents_start = self.position + 1;
-
-        let word = self.eat_while(None, |ch| ch != ']');
-
-        let contents_end = self.position;
-
-        if !self.peek_char_is(']') {
-            return Err(LexerErrorKind::UnexpectedCharacter {
-                span: Span::single_char(self.position),
-                expected: "]".to_owned(),
-                found: self.next_char(),
-            });
+        let is_tag = self.peek_char_is('\'');
+        if is_tag {
+            self.next_char();
         }
-        self.next_char();
 
         let end = self.position;
 
-        let span = Span::inclusive(start, end);
-        let contents_span = Span::inclusive(contents_start, contents_end);
-
-        let attribute = Attribute::lookup_attribute(&word, span, contents_span)?;
-        if is_inner {
-            match attribute {
-                Attribute::Function(attribute) => Err(LexerErrorKind::InvalidInnerAttribute {
-                    span: Span::from(start..end),
-                    found: attribute.to_string(),
-                }),
-                Attribute::Secondary(attribute) => {
-                    Ok(Token::InnerAttribute(attribute).into_span(start, end))
-                }
-            }
-        } else {
-            Ok(Token::Attribute(attribute).into_span(start, end))
-        }
+        Ok(Token::AttributeStart { is_inner, is_tag }.into_span(start, end))
     }
 
     //XXX(low): Can increase performance if we use iterator semantic and utilize some of the methods on String. See below
@@ -350,11 +340,11 @@ impl<'a> Lexer<'a> {
 
         // Check if word an int type
         // if no error occurred, then it is either a valid integer type or it is not an int type
-        let parsed_token = IntType::lookup_int_type(&word)?;
+        let parsed_token = IntType::lookup_int_type(&word);
 
         // Check if it is an int type
-        if let Some(int_type_token) = parsed_token {
-            return Ok(int_type_token.into_span(start, end));
+        if let Some(int_type) = parsed_token {
+            return Ok(Token::IntType(int_type).into_span(start, end));
         }
 
         // Else it is just an identifier
@@ -421,51 +411,190 @@ impl<'a> Lexer<'a> {
         let start = self.position;
         let mut string = String::new();
 
-        while let Some(next) = self.next_char() {
-            let char = match next {
-                '"' => break,
-                '\\' => match self.next_char() {
-                    Some('r') => '\r',
-                    Some('n') => '\n',
-                    Some('t') => '\t',
-                    Some('0') => '\0',
-                    Some('"') => '"',
-                    Some('\\') => '\\',
-                    Some(escaped) => {
-                        let span = Span::inclusive(start, self.position);
-                        return Err(LexerErrorKind::InvalidEscape { escaped, span });
-                    }
-                    None => {
-                        let span = Span::inclusive(start, self.position);
-                        return Err(LexerErrorKind::UnterminatedStringLiteral { span });
-                    }
-                },
-                other => other,
-            };
+        loop {
+            if let Some(next) = self.next_char() {
+                let char = match next {
+                    '"' => break,
+                    '\\' => match self.next_char() {
+                        Some('r') => '\r',
+                        Some('n') => '\n',
+                        Some('t') => '\t',
+                        Some('0') => '\0',
+                        Some('"') => '"',
+                        Some('\\') => '\\',
+                        Some(escaped) => {
+                            let span = Span::inclusive(start, self.position);
+                            return Err(LexerErrorKind::InvalidEscape { escaped, span });
+                        }
+                        None => {
+                            let span = Span::inclusive(start, self.position);
+                            return Err(LexerErrorKind::UnterminatedStringLiteral { span });
+                        }
+                    },
+                    other => other,
+                };
 
-            string.push(char);
+                string.push(char);
+            } else {
+                let span = Span::inclusive(start, self.position);
+                return Err(LexerErrorKind::UnterminatedStringLiteral { span });
+            }
         }
 
         let str_literal_token = Token::Str(string);
-
         let end = self.position;
         Ok(str_literal_token.into_span(start, end))
     }
 
-    // This differs from `eat_string_literal` in that we want the leading `f` to be captured in the Span
     fn eat_fmt_string(&mut self) -> SpannedTokenResult {
         let start = self.position;
-
         self.next_char();
 
-        let str_literal = self.eat_while(None, |ch| ch != '"');
+        let mut fragments = Vec::new();
+        let mut length = 0;
+
+        loop {
+            // String fragment until '{' or '"'
+            let mut string = String::new();
+            let mut found_curly = false;
+
+            loop {
+                if let Some(next) = self.next_char() {
+                    let char = match next {
+                        '"' => break,
+                        '\\' => match self.next_char() {
+                            Some('r') => '\r',
+                            Some('n') => '\n',
+                            Some('t') => '\t',
+                            Some('0') => '\0',
+                            Some('"') => '"',
+                            Some('\\') => '\\',
+                            Some(escaped) => {
+                                let span = Span::inclusive(start, self.position);
+                                return Err(LexerErrorKind::InvalidEscape { escaped, span });
+                            }
+                            None => {
+                                let span = Span::inclusive(start, self.position);
+                                return Err(LexerErrorKind::UnterminatedStringLiteral { span });
+                            }
+                        },
+                        '{' if self.peek_char_is('{') => {
+                            self.next_char();
+                            '{'
+                        }
+                        '}' if self.peek_char_is('}') => {
+                            self.next_char();
+                            '}'
+                        }
+                        '}' => {
+                            let error_position = self.position;
+
+                            // Keep consuming chars until we find the closing double quote
+                            self.skip_until_string_end();
+
+                            let span = Span::inclusive(error_position, error_position);
+                            return Err(LexerErrorKind::InvalidFormatString { found: '}', span });
+                        }
+                        '{' => {
+                            found_curly = true;
+                            break;
+                        }
+                        other => other,
+                    };
+
+                    string.push(char);
+                    length += 1;
+
+                    if char == '{' || char == '}' {
+                        // This might look a bit strange, but if there's `{{` or `}}` in the format string
+                        // then it will be `{` and `}` in the string fragment respectively, but on the codegen
+                        // phase it will be translated back to `{{` and `}}` to avoid executing an interpolation,
+                        // thus the actual length of the codegen'd string will be one more than what we get here.
+                        //
+                        // We could just make the fragment include the double curly braces, but then the interpreter
+                        // would need to undo the curly braces, so it's simpler to add them during codegen.
+                        length += 1;
+                    }
+                } else {
+                    let span = Span::inclusive(start, self.position);
+                    return Err(LexerErrorKind::UnterminatedStringLiteral { span });
+                }
+            }
+
+            if !string.is_empty() {
+                fragments.push(FmtStrFragment::String(string));
+            }
+
+            if !found_curly {
+                break;
+            }
+
+            length += 1; // for the curly brace
+
+            // Interpolation fragment until '}' or '"'
+            let mut string = String::new();
+            let interpolation_start = self.position + 1; // + 1 because we are at '{'
+            let mut first_char = true;
+            while let Some(next) = self.next_char() {
+                let char = match next {
+                    '}' => {
+                        if string.is_empty() {
+                            let error_position = self.position;
+
+                            // Keep consuming chars until we find the closing double quote
+                            self.skip_until_string_end();
+
+                            let span = Span::inclusive(error_position, error_position);
+                            return Err(LexerErrorKind::EmptyFormatStringInterpolation { span });
+                        }
+
+                        break;
+                    }
+                    other => {
+                        let is_valid_char = if first_char {
+                            other.is_ascii_alphabetic() || other == '_'
+                        } else {
+                            other.is_ascii_alphanumeric() || other == '_'
+                        };
+                        if !is_valid_char {
+                            let error_position = self.position;
+
+                            // Keep consuming chars until we find the closing double quote
+                            // (unless we bumped into a double quote now, in which case we are done)
+                            if other != '"' {
+                                self.skip_until_string_end();
+                            }
+
+                            let span = Span::inclusive(error_position, error_position);
+                            return Err(LexerErrorKind::InvalidFormatString { found: other, span });
+                        }
+                        first_char = false;
+                        other
+                    }
+                };
+                length += 1;
+                string.push(char);
+            }
 
-        let str_literal_token = Token::FmtStr(str_literal);
+            length += 1; // for the closing curly brace
 
-        self.next_char(); // Advance past the closing quote
+            let interpolation_span = Span::from(interpolation_start..self.position);
+            fragments.push(FmtStrFragment::Interpolation(string, interpolation_span));
+        }
 
+        let token = Token::FmtStr(fragments, length);
         let end = self.position;
-        Ok(str_literal_token.into_span(start, end))
+        Ok(token.into_span(start, end))
+    }
+
+    fn skip_until_string_end(&mut self) {
+        while let Some(next) = self.next_char() {
+            if next == '\'' && self.peek_char_is('"') {
+                self.next_char();
+            } else if next == '"' {
+                break;
+            }
+        }
     }
 
     fn eat_format_string_or_alpha_numeric(&mut self) -> SpannedTokenResult {
@@ -554,7 +683,11 @@ impl<'a> Lexer<'a> {
             return self.lookup_word_token(word, start, end);
         }
 
-        let delimiter = self.next_token()?;
+        let mut delimiter = self.next_token()?;
+        while let Token::Whitespace(_) = delimiter.token() {
+            delimiter = self.next_token()?;
+        }
+
         let (start_delim, end_delim) = match delimiter.token() {
             Token::LeftBrace => (Token::LeftBrace, Token::RightBrace),
             Token::LeftBracket => (Token::LeftBracket, Token::RightBracket),
@@ -700,11 +833,10 @@ mod tests {
     use iter_extended::vecmap;
 
     use super::*;
-    use crate::token::{CustomAttribute, FunctionAttribute, SecondaryAttribute, TestScope};
 
     #[test]
-    fn test_single_double_char() {
-        let input = "! != + ( ) { } [ ] | , ; : :: < <= > >= & - -> . .. % / * = == << >>";
+    fn test_single_multi_char() {
+        let input = "! != + ( ) { } [ ] | , ; : :: < <= > >= & - -> . .. ..= % / * = == << >>";
 
         let expected = vec![
             Token::Bang,
@@ -730,6 +862,7 @@ mod tests {
             Token::Arrow,
             Token::Dot,
             Token::DoubleDot,
+            Token::DoubleDotEqual,
             Token::Percent,
             Token::Slash,
             Token::Star,
@@ -759,179 +892,39 @@ mod tests {
     }
 
     #[test]
-    fn deprecated_attribute() {
-        let input = r#"#[deprecated]"#;
-        let mut lexer = Lexer::new(input);
-
-        let token = lexer.next_token().unwrap();
-        assert_eq!(
-            token.token(),
-            &Token::Attribute(Attribute::Secondary(SecondaryAttribute::Deprecated(None)))
-        );
-    }
-
-    #[test]
-    fn test_attribute_with_common_punctuation() {
-        let input =
-            r#"#[test(should_fail_with = "stmt. q? exclaim! & symbols, 1% shouldn't fail")]"#;
-        let mut lexer = Lexer::new(input);
-
-        let token = lexer.next_token().unwrap().token().clone();
-        assert_eq!(
-            token,
-            Token::Attribute(Attribute::Function(FunctionAttribute::Test(
-                TestScope::ShouldFailWith {
-                    reason: "stmt. q? exclaim! & symbols, 1% shouldn't fail".to_owned().into()
-                }
-            )))
-        );
-    }
-
-    #[test]
-    fn deprecated_attribute_with_note() {
-        let input = r#"#[deprecated("hello")]"#;
-        let mut lexer = Lexer::new(input);
-
-        let token = lexer.next_token().unwrap();
-        assert_eq!(
-            token.token(),
-            &Token::Attribute(Attribute::Secondary(crate::token::SecondaryAttribute::Deprecated(
-                "hello".to_string().into()
-            )))
-        );
-    }
-
-    #[test]
-    fn test_custom_gate_syntax() {
-        let input = "#[foreign(sha256)]#[foreign(blake2s)]#[builtin(sum)]";
-
-        let expected = vec![
-            Token::Attribute(Attribute::Function(FunctionAttribute::Foreign("sha256".to_string()))),
-            Token::Attribute(Attribute::Function(FunctionAttribute::Foreign(
-                "blake2s".to_string(),
-            ))),
-            Token::Attribute(Attribute::Function(FunctionAttribute::Builtin("sum".to_string()))),
-        ];
-
-        let mut lexer = Lexer::new(input);
-        for token in expected.into_iter() {
-            let got = lexer.next_token().unwrap();
-            assert_eq!(got, token);
-        }
-    }
-
-    #[test]
-    fn custom_attribute() {
-        let input = r#"#[custom(hello)]"#;
-        let mut lexer = Lexer::new(input);
-
-        let token = lexer.next_token().unwrap();
-        assert_eq!(
-            token.token(),
-            &Token::Attribute(Attribute::Secondary(SecondaryAttribute::Custom(CustomAttribute {
-                contents: "custom(hello)".to_string(),
-                span: Span::from(0..16),
-                contents_span: Span::from(2..15)
-            })))
-        );
-    }
-
-    #[test]
-    fn test_attribute() {
-        let input = r#"#[test]"#;
-        let mut lexer = Lexer::new(input);
-
-        let token = lexer.next_token().unwrap();
-        assert_eq!(
-            token.token(),
-            &Token::Attribute(Attribute::Function(FunctionAttribute::Test(TestScope::None)))
-        );
-    }
-
-    #[test]
-    fn fold_attribute() {
-        let input = r#"#[fold]"#;
-
-        let mut lexer = Lexer::new(input);
-        let token = lexer.next_token().unwrap();
-
-        assert_eq!(token.token(), &Token::Attribute(Attribute::Function(FunctionAttribute::Fold)));
-    }
-
-    #[test]
-    fn contract_library_method_attribute() {
-        let input = r#"#[contract_library_method]"#;
+    fn test_attribute_start() {
+        let input = r#"#[something]"#;
         let mut lexer = Lexer::new(input);
 
         let token = lexer.next_token().unwrap();
-        assert_eq!(
-            token.token(),
-            &Token::Attribute(Attribute::Secondary(SecondaryAttribute::ContractLibraryMethod))
-        );
+        assert_eq!(token.token(), &Token::AttributeStart { is_inner: false, is_tag: false });
     }
 
     #[test]
-    fn test_attribute_with_valid_scope() {
-        let input = r#"#[test(should_fail)]"#;
+    fn test_attribute_start_with_tag() {
+        let input = r#"#['something]"#;
         let mut lexer = Lexer::new(input);
 
         let token = lexer.next_token().unwrap();
-        assert_eq!(
-            token.token(),
-            &Token::Attribute(Attribute::Function(FunctionAttribute::Test(
-                TestScope::ShouldFailWith { reason: None }
-            )))
-        );
+        assert_eq!(token.token(), &Token::AttributeStart { is_inner: false, is_tag: true });
     }
 
     #[test]
-    fn test_attribute_with_valid_scope_should_fail_with() {
-        let input = r#"#[test(should_fail_with = "hello")]"#;
+    fn test_inner_attribute_start() {
+        let input = r#"#![something]"#;
         let mut lexer = Lexer::new(input);
 
         let token = lexer.next_token().unwrap();
-        assert_eq!(
-            token.token(),
-            &Token::Attribute(Attribute::Function(FunctionAttribute::Test(
-                TestScope::ShouldFailWith { reason: Some("hello".to_owned()) }
-            )))
-        );
+        assert_eq!(token.token(), &Token::AttributeStart { is_inner: true, is_tag: false });
     }
 
     #[test]
-    fn test_attribute_with_invalid_scope() {
-        let input = r#"#[test(invalid_scope)]"#;
-        let mut lexer = Lexer::new(input);
-
-        let token = lexer.next().unwrap();
-        let err = match token {
-            Ok(_) => panic!("test has an invalid scope, so expected an error"),
-            Err(err) => err,
-        };
-
-        // Check if error is MalformedFuncAttribute and found is "foo"
-        let sub_string = match err {
-            LexerErrorKind::MalformedFuncAttribute { found, .. } => found,
-            _ => panic!("expected malformed func attribute error"),
-        };
-
-        assert_eq!(sub_string, "test(invalid_scope)");
-    }
-
-    #[test]
-    fn test_inner_attribute() {
-        let input = r#"#![something]"#;
+    fn test_inner_attribute_start_with_tag() {
+        let input = r#"#!['something]"#;
         let mut lexer = Lexer::new(input);
 
         let token = lexer.next_token().unwrap();
-        assert_eq!(
-            token.token(),
-            &Token::InnerAttribute(SecondaryAttribute::Custom(CustomAttribute {
-                contents: "something".to_string(),
-                span: Span::from(0..13),
-                contents_span: Span::from(3..12),
-            }))
-        );
+        assert_eq!(token.token(), &Token::AttributeStart { is_inner: true, is_tag: true });
     }
 
     #[test]
@@ -1108,6 +1101,155 @@ mod tests {
         }
     }
 
+    #[test]
+    fn test_eat_string_literal_with_escapes() {
+        let input = "let _word = \"hello\\n\\t\"";
+
+        let expected = vec![
+            Token::Keyword(Keyword::Let),
+            Token::Ident("_word".to_string()),
+            Token::Assign,
+            Token::Str("hello\n\t".to_string()),
+        ];
+        let mut lexer = Lexer::new(input);
+
+        for token in expected.into_iter() {
+            let got = lexer.next_token().unwrap();
+            assert_eq!(got, token);
+        }
+    }
+
+    #[test]
+    fn test_eat_string_literal_missing_double_quote() {
+        let input = "\"hello";
+        let mut lexer = Lexer::new(input);
+        assert!(matches!(
+            lexer.next_token(),
+            Err(LexerErrorKind::UnterminatedStringLiteral { .. })
+        ));
+    }
+
+    #[test]
+    fn test_eat_fmt_string_literal_without_interpolations() {
+        let input = "let _word = f\"hello\"";
+
+        let expected = vec![
+            Token::Keyword(Keyword::Let),
+            Token::Ident("_word".to_string()),
+            Token::Assign,
+            Token::FmtStr(vec![FmtStrFragment::String("hello".to_string())], 5),
+        ];
+        let mut lexer = Lexer::new(input);
+
+        for token in expected.into_iter() {
+            let got = lexer.next_token().unwrap();
+            assert_eq!(got, token);
+        }
+    }
+
+    #[test]
+    fn test_eat_fmt_string_literal_with_escapes_without_interpolations() {
+        let input = "let _word = f\"hello\\n\\t{{x}}\"";
+
+        let expected = vec![
+            Token::Keyword(Keyword::Let),
+            Token::Ident("_word".to_string()),
+            Token::Assign,
+            Token::FmtStr(vec![FmtStrFragment::String("hello\n\t{x}".to_string())], 12),
+        ];
+        let mut lexer = Lexer::new(input);
+
+        for token in expected.into_iter() {
+            let got = lexer.next_token().unwrap();
+            assert_eq!(got, token);
+        }
+    }
+
+    #[test]
+    fn test_eat_fmt_string_literal_with_interpolations() {
+        let input = "let _word = f\"hello {world} and {_another} {vAr_123}\"";
+
+        let expected = vec![
+            Token::Keyword(Keyword::Let),
+            Token::Ident("_word".to_string()),
+            Token::Assign,
+            Token::FmtStr(
+                vec![
+                    FmtStrFragment::String("hello ".to_string()),
+                    FmtStrFragment::Interpolation("world".to_string(), Span::from(21..26)),
+                    FmtStrFragment::String(" and ".to_string()),
+                    FmtStrFragment::Interpolation("_another".to_string(), Span::from(33..41)),
+                    FmtStrFragment::String(" ".to_string()),
+                    FmtStrFragment::Interpolation("vAr_123".to_string(), Span::from(44..51)),
+                ],
+                38,
+            ),
+        ];
+        let mut lexer = Lexer::new(input);
+
+        for token in expected.into_iter() {
+            let got = lexer.next_token().unwrap().into_token();
+            assert_eq!(got, token);
+        }
+    }
+
+    #[test]
+    fn test_eat_fmt_string_literal_missing_double_quote() {
+        let input = "f\"hello";
+        let mut lexer = Lexer::new(input);
+        assert!(matches!(
+            lexer.next_token(),
+            Err(LexerErrorKind::UnterminatedStringLiteral { .. })
+        ));
+    }
+
+    #[test]
+    fn test_eat_fmt_string_literal_invalid_char_in_interpolation() {
+        let input = "f\"hello {foo.bar}\" true";
+        let mut lexer = Lexer::new(input);
+        assert!(matches!(lexer.next_token(), Err(LexerErrorKind::InvalidFormatString { .. })));
+
+        // Make sure the lexer went past the ending double quote for better recovery
+        let token = lexer.next_token().unwrap().into_token();
+        assert!(matches!(token, Token::Bool(true)));
+    }
+
+    #[test]
+    fn test_eat_fmt_string_literal_double_quote_inside_interpolation() {
+        let input = "f\"hello {world\" true";
+        let mut lexer = Lexer::new(input);
+        assert!(matches!(lexer.next_token(), Err(LexerErrorKind::InvalidFormatString { .. })));
+
+        // Make sure the lexer stopped parsing the string literal when it found \" inside the interpolation
+        let token = lexer.next_token().unwrap().into_token();
+        assert!(matches!(token, Token::Bool(true)));
+    }
+
+    #[test]
+    fn test_eat_fmt_string_literal_unmatched_closing_curly() {
+        let input = "f\"hello }\" true";
+        let mut lexer = Lexer::new(input);
+        assert!(matches!(lexer.next_token(), Err(LexerErrorKind::InvalidFormatString { .. })));
+
+        // Make sure the lexer went past the ending double quote for better recovery
+        let token = lexer.next_token().unwrap().into_token();
+        assert!(matches!(token, Token::Bool(true)));
+    }
+
+    #[test]
+    fn test_eat_fmt_string_literal_empty_interpolation() {
+        let input = "f\"{}\" true";
+        let mut lexer = Lexer::new(input);
+        assert!(matches!(
+            lexer.next_token(),
+            Err(LexerErrorKind::EmptyFormatStringInterpolation { .. })
+        ));
+
+        // Make sure the lexer went past the ending double quote for better recovery
+        let token = lexer.next_token().unwrap().into_token();
+        assert!(matches!(token, Token::Bool(true)));
+    }
+
     #[test]
     fn test_eat_integer_literals() {
         let test_cases: Vec<(&str, Token)> = vec![
@@ -1297,7 +1439,7 @@ mod tests {
                     format!("let s = r#####\"{s}\"#####;"),
                 ],
             ),
-            (Some(Token::FmtStr("".to_string())), vec![format!("assert(x == y, f\"{s}\");")]),
+            (Some(Token::FmtStr(vec![], 0)), vec![format!("assert(x == y, f\"{s}\");")]),
             // expected token not found
             // (Some(Token::LineComment("".to_string(), None)), vec![
             (None, vec![format!("//{s}"), format!("// {s}")]),
@@ -1342,11 +1484,16 @@ mod tests {
                             Err(LexerErrorKind::InvalidIntegerLiteral { .. })
                             | Err(LexerErrorKind::UnexpectedCharacter { .. })
                             | Err(LexerErrorKind::NonAsciiComment { .. })
-                            | Err(LexerErrorKind::UnterminatedBlockComment { .. }) => {
+                            | Err(LexerErrorKind::UnterminatedBlockComment { .. })
+                            | Err(LexerErrorKind::UnterminatedStringLiteral { .. })
+                            | Err(LexerErrorKind::InvalidFormatString { .. }) => {
                                 expected_token_found = true;
                             }
                             Err(err) => {
-                                panic!("Unexpected lexer error found: {:?}", err)
+                                panic!(
+                                    "Unexpected lexer error found {:?} for input string {:?}",
+                                    err, blns_program_str
+                                )
                             }
                         }
                     }
diff --git a/compiler/noirc_frontend/src/lexer/token.rs b/compiler/noirc_frontend/src/lexer/token.rs
index 97faea4b445..f35515045db 100644
--- a/compiler/noirc_frontend/src/lexer/token.rs
+++ b/compiler/noirc_frontend/src/lexer/token.rs
@@ -1,9 +1,9 @@
-use acvm::{acir::AcirField, FieldElement};
+use acvm::FieldElement;
 use noirc_errors::{Position, Span, Spanned};
-use std::{fmt, iter::Map, vec::IntoIter};
+use std::fmt::{self, Display};
 
 use crate::{
-    lexer::errors::LexerErrorKind,
+    ast::{Expression, Path},
     node_interner::{
         ExprId, InternedExpressionKind, InternedPattern, InternedStatementKind,
         InternedUnresolvedTypeData, QuotedTypeId,
@@ -25,11 +25,13 @@ pub enum BorrowedToken<'input> {
     Str(&'input str),
     /// the u8 is the number of hashes, i.e. r###..
     RawStr(&'input str, u8),
-    FmtStr(&'input str),
+    FmtStr(&'input [FmtStrFragment], u32 /* length */),
     Keyword(Keyword),
     IntType(IntType),
-    Attribute(Attribute),
-    InnerAttribute(SecondaryAttribute),
+    AttributeStart {
+        is_inner: bool,
+        is_tag: bool,
+    },
     LineComment(&'input str, Option<DocStyle>),
     BlockComment(&'input str, Option<DocStyle>),
     Quote(&'input Tokens),
@@ -73,6 +75,8 @@ pub enum BorrowedToken<'input> {
     Dot,
     /// ..
     DoubleDot,
+    /// ..=
+    DoubleDotEqual,
     /// (
     LeftParen,
     /// )
@@ -132,11 +136,13 @@ pub enum Token {
     Str(String),
     /// the u8 is the number of hashes, i.e. r###..
     RawStr(String, u8),
-    FmtStr(String),
+    FmtStr(Vec<FmtStrFragment>, u32 /* length */),
     Keyword(Keyword),
     IntType(IntType),
-    Attribute(Attribute),
-    InnerAttribute(SecondaryAttribute),
+    AttributeStart {
+        is_inner: bool,
+        is_tag: bool,
+    },
     LineComment(String, Option<DocStyle>),
     BlockComment(String, Option<DocStyle>),
     // A `quote { ... }` along with the tokens in its token stream.
@@ -190,6 +196,8 @@ pub enum Token {
     Dot,
     /// ..
     DoubleDot,
+    /// ..=
+    DoubleDotEqual,
     /// (
     LeftParen,
     /// )
@@ -247,11 +255,12 @@ pub fn token_to_borrowed_token(token: &Token) -> BorrowedToken<'_> {
         Token::Int(n) => BorrowedToken::Int(*n),
         Token::Bool(b) => BorrowedToken::Bool(*b),
         Token::Str(ref b) => BorrowedToken::Str(b),
-        Token::FmtStr(ref b) => BorrowedToken::FmtStr(b),
+        Token::FmtStr(ref b, length) => BorrowedToken::FmtStr(b, *length),
         Token::RawStr(ref b, hashes) => BorrowedToken::RawStr(b, *hashes),
         Token::Keyword(k) => BorrowedToken::Keyword(*k),
-        Token::Attribute(ref a) => BorrowedToken::Attribute(a.clone()),
-        Token::InnerAttribute(ref a) => BorrowedToken::InnerAttribute(a.clone()),
+        Token::AttributeStart { is_inner, is_tag } => {
+            BorrowedToken::AttributeStart { is_inner: *is_inner, is_tag: *is_tag }
+        }
         Token::LineComment(ref s, _style) => BorrowedToken::LineComment(s, *_style),
         Token::BlockComment(ref s, _style) => BorrowedToken::BlockComment(s, *_style),
         Token::Quote(stream) => BorrowedToken::Quote(stream),
@@ -279,6 +288,7 @@ pub fn token_to_borrowed_token(token: &Token) -> BorrowedToken<'_> {
         Token::ShiftRight => BorrowedToken::ShiftRight,
         Token::Dot => BorrowedToken::Dot,
         Token::DoubleDot => BorrowedToken::DoubleDot,
+        Token::DoubleDotEqual => BorrowedToken::DoubleDotEqual,
         Token::LeftParen => BorrowedToken::LeftParen,
         Token::RightParen => BorrowedToken::RightParen,
         Token::LeftBrace => BorrowedToken::LeftBrace,
@@ -302,6 +312,35 @@ pub fn token_to_borrowed_token(token: &Token) -> BorrowedToken<'_> {
     }
 }
 
+#[derive(Clone, PartialEq, Eq, Hash, Debug, PartialOrd, Ord)]
+pub enum FmtStrFragment {
+    String(String),
+    Interpolation(String, Span),
+}
+
+impl Display for FmtStrFragment {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        match self {
+            FmtStrFragment::String(string) => {
+                // Undo the escapes when displaying the fmt string
+                let string = string
+                    .replace('{', "{{")
+                    .replace('}', "}}")
+                    .replace('\r', "\\r")
+                    .replace('\n', "\\n")
+                    .replace('\t', "\\t")
+                    .replace('\0', "\\0")
+                    .replace('\'', "\\'")
+                    .replace('\"', "\\\"");
+                write!(f, "{}", string)
+            }
+            FmtStrFragment::Interpolation(string, _span) => {
+                write!(f, "{{{}}}", string)
+            }
+        }
+    }
+}
+
 #[derive(Clone, Copy, PartialEq, Eq, Hash, Debug, PartialOrd, Ord)]
 pub enum DocStyle {
     Outer,
@@ -362,19 +401,36 @@ impl fmt::Display for Token {
     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
         match *self {
             Token::Ident(ref s) => write!(f, "{s}"),
-            Token::Int(n) => write!(f, "{}", n.to_u128()),
+            Token::Int(n) => write!(f, "{}", n),
             Token::Bool(b) => write!(f, "{b}"),
             Token::Str(ref b) => write!(f, "{b:?}"),
-            Token::FmtStr(ref b) => write!(f, "f{b:?}"),
+            Token::FmtStr(ref b, _length) => write!(f, "f{b:?}"),
             Token::RawStr(ref b, hashes) => {
                 let h: String = std::iter::once('#').cycle().take(hashes as usize).collect();
                 write!(f, "r{h}{b:?}{h}")
             }
             Token::Keyword(k) => write!(f, "{k}"),
-            Token::Attribute(ref a) => write!(f, "{a}"),
-            Token::InnerAttribute(ref a) => write!(f, "#![{a}]"),
-            Token::LineComment(ref s, _style) => write!(f, "//{s}"),
-            Token::BlockComment(ref s, _style) => write!(f, "/*{s}*/"),
+            Token::AttributeStart { is_inner, is_tag } => {
+                write!(f, "#")?;
+                if is_inner {
+                    write!(f, "!")?;
+                }
+                write!(f, "[")?;
+                if is_tag {
+                    write!(f, "'")?;
+                }
+                Ok(())
+            }
+            Token::LineComment(ref s, style) => match style {
+                Some(DocStyle::Inner) => write!(f, "//!{s}"),
+                Some(DocStyle::Outer) => write!(f, "///{s}"),
+                None => write!(f, "//{s}"),
+            },
+            Token::BlockComment(ref s, style) => match style {
+                Some(DocStyle::Inner) => write!(f, "/*!{s}*/"),
+                Some(DocStyle::Outer) => write!(f, "/**{s}*/"),
+                None => write!(f, "/*{s}*/"),
+            },
             Token::Quote(ref stream) => {
                 write!(f, "quote {{")?;
                 for token in stream.0.iter() {
@@ -409,6 +465,7 @@ impl fmt::Display for Token {
             Token::ShiftRight => write!(f, ">>"),
             Token::Dot => write!(f, "."),
             Token::DoubleDot => write!(f, ".."),
+            Token::DoubleDotEqual => write!(f, "..="),
             Token::LeftParen => write!(f, "("),
             Token::RightParen => write!(f, ")"),
             Token::LeftBrace => write!(f, "{{"),
@@ -450,6 +507,7 @@ pub enum TokenKind {
     InternedUnresolvedTypeData,
     InternedPattern,
     UnquoteMarker,
+    Comment,
     OuterDocComment,
     InnerDocComment,
 }
@@ -471,6 +529,7 @@ impl fmt::Display for TokenKind {
             TokenKind::InternedUnresolvedTypeData => write!(f, "interned unresolved type"),
             TokenKind::InternedPattern => write!(f, "interned pattern"),
             TokenKind::UnquoteMarker => write!(f, "macro result"),
+            TokenKind::Comment => write!(f, "comment"),
             TokenKind::OuterDocComment => write!(f, "outer doc comment"),
             TokenKind::InnerDocComment => write!(f, "inner doc comment"),
         }
@@ -485,10 +544,8 @@ impl Token {
             | Token::Bool(_)
             | Token::Str(_)
             | Token::RawStr(..)
-            | Token::FmtStr(_) => TokenKind::Literal,
+            | Token::FmtStr(_, _) => TokenKind::Literal,
             Token::Keyword(_) => TokenKind::Keyword,
-            Token::Attribute(_) => TokenKind::Attribute,
-            Token::InnerAttribute(_) => TokenKind::InnerAttribute,
             Token::UnquoteMarker(_) => TokenKind::UnquoteMarker,
             Token::Quote(_) => TokenKind::Quote,
             Token::QuotedType(_) => TokenKind::QuotedType,
@@ -497,6 +554,7 @@ impl Token {
             Token::InternedLValue(_) => TokenKind::InternedLValue,
             Token::InternedUnresolvedTypeData(_) => TokenKind::InternedUnresolvedTypeData,
             Token::InternedPattern(_) => TokenKind::InternedPattern,
+            Token::LineComment(_, None) | Token::BlockComment(_, None) => TokenKind::Comment,
             Token::LineComment(_, Some(DocStyle::Outer))
             | Token::BlockComment(_, Some(DocStyle::Outer)) => TokenKind::OuterDocComment,
             Token::LineComment(_, Some(DocStyle::Inner))
@@ -568,7 +626,7 @@ impl IntType {
     // XXX: Result<Option<Token, LexerErrorKind>
     // Is not the best API. We could split this into two functions. One that checks if the
     // word is a integer, which only returns an Option
-    pub(crate) fn lookup_int_type(word: &str) -> Result<Option<Token>, LexerErrorKind> {
+    pub fn lookup_int_type(word: &str) -> Option<IntType> {
         // Check if the first string is a 'u' or 'i'
 
         let is_signed = if word.starts_with('i') {
@@ -576,20 +634,20 @@ impl IntType {
         } else if word.starts_with('u') {
             false
         } else {
-            return Ok(None);
+            return None;
         };
 
         // Word start with 'u' or 'i'. Check if the latter is an integer
 
         let str_as_u32 = match word[1..].parse::<u32>() {
             Ok(str_as_u32) => str_as_u32,
-            Err(_) => return Ok(None),
+            Err(_) => return None,
         };
 
         if is_signed {
-            Ok(Some(Token::IntType(IntType::Signed(str_as_u32))))
+            Some(IntType::Signed(str_as_u32))
         } else {
-            Ok(Some(Token::IntType(IntType::Unsigned(str_as_u32))))
+            Some(IntType::Unsigned(str_as_u32))
         }
     }
 }
@@ -605,44 +663,25 @@ pub enum TestScope {
     None,
 }
 
-impl TestScope {
-    fn lookup_str(string: &str) -> Option<TestScope> {
-        match string.trim() {
-            "should_fail" => Some(TestScope::ShouldFailWith { reason: None }),
-            s if s.starts_with("should_fail_with") => {
-                let parts: Vec<&str> = s.splitn(2, '=').collect();
-                if parts.len() == 2 {
-                    let reason = parts[1].trim();
-                    let reason = reason.trim_matches('"');
-                    Some(TestScope::ShouldFailWith { reason: Some(reason.to_string()) })
-                } else {
-                    None
-                }
-            }
-            _ => None,
-        }
-    }
-}
-
 impl fmt::Display for TestScope {
     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
         match self {
             TestScope::None => write!(f, ""),
             TestScope::ShouldFailWith { reason } => match reason {
-                Some(failure_reason) => write!(f, "(should_fail_with = ({failure_reason}))"),
-                None => write!(f, "should_fail"),
+                Some(failure_reason) => write!(f, "(should_fail_with = {failure_reason:?})"),
+                None => write!(f, "(should_fail)"),
             },
         }
     }
 }
 
-#[derive(PartialEq, Eq, Hash, Debug, Clone, PartialOrd, Ord)]
+#[derive(PartialEq, Eq, Debug, Clone)]
 // Attributes are special language markers in the target language
 // An example of one is `#[SHA256]` . Currently only Foreign attributes are supported
 // Calls to functions which have the foreign attribute are executed in the host language
 pub struct Attributes {
     // Each function can have a single Primary Attribute
-    pub function: Option<FunctionAttribute>,
+    pub function: Option<(FunctionAttribute, usize /* index in list */)>,
     // Each function can have many Secondary Attributes
     pub secondary: Vec<SecondaryAttribute>,
 }
@@ -652,18 +691,25 @@ impl Attributes {
         Self { function: None, secondary: Vec::new() }
     }
 
+    pub fn function(&self) -> Option<&FunctionAttribute> {
+        self.function.as_ref().map(|(attr, _)| attr)
+    }
+
+    pub fn set_function(&mut self, function: FunctionAttribute) {
+        // Assume the index in the list doesn't matter anymore at this point
+        self.function = Some((function, 0));
+    }
+
     /// Returns true if one of the secondary attributes is `contract_library_method`
     ///
     /// This is useful for finding out if we should compile a contract method
     /// as an entry point or not.
     pub fn has_contract_library_method(&self) -> bool {
-        self.secondary
-            .iter()
-            .any(|attribute| attribute == &SecondaryAttribute::ContractLibraryMethod)
+        self.has_secondary_attr(&SecondaryAttribute::ContractLibraryMethod)
     }
 
     pub fn is_test_function(&self) -> bool {
-        matches!(self.function, Some(FunctionAttribute::Test(_)))
+        matches!(self.function(), Some(FunctionAttribute::Test(_)))
     }
 
     /// True if these attributes mean the given function is an entry point function if it was
@@ -691,26 +737,36 @@ impl Attributes {
     }
 
     pub fn is_foldable(&self) -> bool {
-        self.function.as_ref().map_or(false, |func_attribute| func_attribute.is_foldable())
+        self.function().map_or(false, |func_attribute| func_attribute.is_foldable())
     }
 
     pub fn is_no_predicates(&self) -> bool {
-        self.function.as_ref().map_or(false, |func_attribute| func_attribute.is_no_predicates())
+        self.function().map_or(false, |func_attribute| func_attribute.is_no_predicates())
     }
 
     pub fn has_varargs(&self) -> bool {
-        self.secondary.iter().any(|attr| matches!(attr, SecondaryAttribute::Varargs))
+        self.has_secondary_attr(&SecondaryAttribute::Varargs)
     }
 
     pub fn has_use_callers_scope(&self) -> bool {
-        self.secondary.iter().any(|attr| matches!(attr, SecondaryAttribute::UseCallersScope))
+        self.has_secondary_attr(&SecondaryAttribute::UseCallersScope)
+    }
+
+    /// True if the function is marked with an `#[export]` attribute.
+    pub fn has_export(&self) -> bool {
+        self.has_secondary_attr(&SecondaryAttribute::Export)
+    }
+
+    /// Check if secondary attributes contain a specific instance.
+    pub fn has_secondary_attr(&self, attr: &SecondaryAttribute) -> bool {
+        self.secondary.contains(attr)
     }
 }
 
 /// An Attribute can be either a Primary Attribute or a Secondary Attribute
 /// A Primary Attribute can alter the function type, thus there can only be one
 /// A secondary attribute has no effect and is either consumed by a library or used as a notice for the developer
-#[derive(PartialEq, Eq, Hash, Debug, Clone, PartialOrd, Ord)]
+#[derive(PartialEq, Eq, Debug, Clone)]
 pub enum Attribute {
     Function(FunctionAttribute),
     Secondary(SecondaryAttribute),
@@ -725,100 +781,6 @@ impl fmt::Display for Attribute {
     }
 }
 
-impl Attribute {
-    /// If the string is a fixed attribute return that, else
-    /// return the custom attribute
-    pub(crate) fn lookup_attribute(
-        word: &str,
-        span: Span,
-        contents_span: Span,
-    ) -> Result<Attribute, LexerErrorKind> {
-        let word_segments: Vec<&str> = word
-            .split(|c| c == '(' || c == ')')
-            .filter(|string_segment| !string_segment.is_empty())
-            .collect();
-
-        let validate = |slice: &str| {
-            let is_valid = slice
-                .chars()
-                .all(|ch| {
-                    ch.is_ascii_alphabetic()
-                        || ch.is_numeric()
-                        || ch.is_ascii_punctuation()
-                        || ch == ' '
-                })
-                .then_some(());
-
-            is_valid.ok_or(LexerErrorKind::MalformedFuncAttribute { span, found: word.to_owned() })
-        };
-
-        let attribute = match &word_segments[..] {
-            // Primary Attributes
-            ["foreign", name] => {
-                validate(name)?;
-                Attribute::Function(FunctionAttribute::Foreign(name.to_string()))
-            }
-            ["builtin", name] => {
-                validate(name)?;
-                Attribute::Function(FunctionAttribute::Builtin(name.to_string()))
-            }
-            ["oracle", name] => {
-                validate(name)?;
-                Attribute::Function(FunctionAttribute::Oracle(name.to_string()))
-            }
-            ["test"] => Attribute::Function(FunctionAttribute::Test(TestScope::None)),
-            ["recursive"] => Attribute::Function(FunctionAttribute::Recursive),
-            ["fold"] => Attribute::Function(FunctionAttribute::Fold),
-            ["no_predicates"] => Attribute::Function(FunctionAttribute::NoPredicates),
-            ["test", name] => {
-                validate(name)?;
-                let malformed_scope =
-                    LexerErrorKind::MalformedFuncAttribute { span, found: word.to_owned() };
-                match TestScope::lookup_str(name) {
-                    Some(scope) => Attribute::Function(FunctionAttribute::Test(scope)),
-                    None => return Err(malformed_scope),
-                }
-            }
-            ["field", name] => {
-                validate(name)?;
-                Attribute::Secondary(SecondaryAttribute::Field(name.to_string()))
-            }
-            // Secondary attributes
-            ["deprecated"] => Attribute::Secondary(SecondaryAttribute::Deprecated(None)),
-            ["contract_library_method"] => {
-                Attribute::Secondary(SecondaryAttribute::ContractLibraryMethod)
-            }
-            ["abi", tag] => Attribute::Secondary(SecondaryAttribute::Abi(tag.to_string())),
-            ["export"] => Attribute::Secondary(SecondaryAttribute::Export),
-            ["deprecated", name] => {
-                if !name.starts_with('"') && !name.ends_with('"') {
-                    return Err(LexerErrorKind::MalformedFuncAttribute {
-                        span,
-                        found: word.to_owned(),
-                    });
-                }
-
-                Attribute::Secondary(SecondaryAttribute::Deprecated(
-                    name.trim_matches('"').to_string().into(),
-                ))
-            }
-            ["varargs"] => Attribute::Secondary(SecondaryAttribute::Varargs),
-            ["use_callers_scope"] => Attribute::Secondary(SecondaryAttribute::UseCallersScope),
-            ["allow", tag] => Attribute::Secondary(SecondaryAttribute::Allow(tag.to_string())),
-            tokens => {
-                tokens.iter().try_for_each(|token| validate(token))?;
-                Attribute::Secondary(SecondaryAttribute::Custom(CustomAttribute {
-                    contents: word.to_owned(),
-                    span,
-                    contents_span,
-                }))
-            }
-        };
-
-        Ok(attribute)
-    }
-}
-
 /// Primary Attributes are those which a function can only have one of.
 /// They change the FunctionKind and thus have direct impact on the IR output
 #[derive(PartialEq, Eq, Hash, Debug, Clone, PartialOrd, Ord)]
@@ -827,9 +789,9 @@ pub enum FunctionAttribute {
     Builtin(String),
     Oracle(String),
     Test(TestScope),
-    Recursive,
     Fold,
     NoPredicates,
+    InlineAlways,
 }
 
 impl FunctionAttribute {
@@ -877,15 +839,22 @@ impl FunctionAttribute {
         matches!(self, FunctionAttribute::NoPredicates)
     }
 
+    /// Check whether we have an `inline_always` attribute
+    /// This is used to indicate that a function should always be inlined
+    /// regardless of the target runtime.
+    pub fn is_inline_always(&self) -> bool {
+        matches!(self, FunctionAttribute::InlineAlways)
+    }
+
     pub fn name(&self) -> &'static str {
         match self {
             FunctionAttribute::Foreign(_) => "foreign",
             FunctionAttribute::Builtin(_) => "builtin",
             FunctionAttribute::Oracle(_) => "oracle",
             FunctionAttribute::Test(_) => "test",
-            FunctionAttribute::Recursive => "recursive",
             FunctionAttribute::Fold => "fold",
             FunctionAttribute::NoPredicates => "no_predicates",
+            FunctionAttribute::InlineAlways => "inline_always",
         }
     }
 }
@@ -897,9 +866,9 @@ impl fmt::Display for FunctionAttribute {
             FunctionAttribute::Foreign(ref k) => write!(f, "#[foreign({k})]"),
             FunctionAttribute::Builtin(ref k) => write!(f, "#[builtin({k})]"),
             FunctionAttribute::Oracle(ref k) => write!(f, "#[oracle({k})]"),
-            FunctionAttribute::Recursive => write!(f, "#[recursive]"),
             FunctionAttribute::Fold => write!(f, "#[fold]"),
             FunctionAttribute::NoPredicates => write!(f, "#[no_predicates]"),
+            FunctionAttribute::InlineAlways => write!(f, "#[inline_always]"),
         }
     }
 }
@@ -907,7 +876,7 @@ impl fmt::Display for FunctionAttribute {
 /// Secondary attributes are those which a function can have many of.
 /// They are not able to change the `FunctionKind` and thus do not have direct impact on the IR output
 /// They are often consumed by libraries or used as notices for the developer
-#[derive(PartialEq, Eq, Hash, Debug, Clone, PartialOrd, Ord)]
+#[derive(PartialEq, Eq, Debug, Clone)]
 pub enum SecondaryAttribute {
     Deprecated(Option<String>),
     // This is an attribute to specify that a function
@@ -916,7 +885,13 @@ pub enum SecondaryAttribute {
     ContractLibraryMethod,
     Export,
     Field(String),
-    Custom(CustomAttribute),
+
+    /// A custom tag attribute: #['foo]
+    Tag(CustomAttribute),
+
+    /// An attribute expected to run a comptime function of the same name: #[foo]
+    Meta(MetaAttribute),
+
     Abi(String),
 
     /// A variable-argument comptime function.
@@ -932,14 +907,6 @@ pub enum SecondaryAttribute {
 }
 
 impl SecondaryAttribute {
-    pub(crate) fn as_custom(&self) -> Option<&CustomAttribute> {
-        if let Self::Custom(attribute) = self {
-            Some(attribute)
-        } else {
-            None
-        }
-    }
-
     pub(crate) fn name(&self) -> Option<String> {
         match self {
             SecondaryAttribute::Deprecated(_) => Some("deprecated".to_string()),
@@ -948,7 +915,8 @@ impl SecondaryAttribute {
             }
             SecondaryAttribute::Export => Some("export".to_string()),
             SecondaryAttribute::Field(_) => Some("field".to_string()),
-            SecondaryAttribute::Custom(custom) => custom.name(),
+            SecondaryAttribute::Tag(custom) => custom.name(),
+            SecondaryAttribute::Meta(meta) => Some(meta.name.last_name().to_string()),
             SecondaryAttribute::Abi(_) => Some("abi".to_string()),
             SecondaryAttribute::Varargs => Some("varargs".to_string()),
             SecondaryAttribute::UseCallersScope => Some("use_callers_scope".to_string()),
@@ -962,23 +930,51 @@ impl SecondaryAttribute {
             _ => false,
         }
     }
-}
 
-impl fmt::Display for SecondaryAttribute {
-    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+    pub(crate) fn is_abi(&self) -> bool {
+        matches!(self, SecondaryAttribute::Abi(_))
+    }
+
+    pub(crate) fn contents(&self) -> String {
         match self {
-            SecondaryAttribute::Deprecated(None) => write!(f, "#[deprecated]"),
+            SecondaryAttribute::Deprecated(None) => "deprecated".to_string(),
             SecondaryAttribute::Deprecated(Some(ref note)) => {
-                write!(f, r#"#[deprecated("{note}")]"#)
+                format!("deprecated({note:?})")
             }
-            SecondaryAttribute::Custom(ref attribute) => write!(f, "#[{}]", attribute.contents),
-            SecondaryAttribute::ContractLibraryMethod => write!(f, "#[contract_library_method]"),
-            SecondaryAttribute::Export => write!(f, "#[export]"),
-            SecondaryAttribute::Field(ref k) => write!(f, "#[field({k})]"),
-            SecondaryAttribute::Abi(ref k) => write!(f, "#[abi({k})]"),
-            SecondaryAttribute::Varargs => write!(f, "#[varargs]"),
-            SecondaryAttribute::UseCallersScope => write!(f, "#[use_callers_scope]"),
-            SecondaryAttribute::Allow(ref k) => write!(f, "#[allow(#{k})]"),
+            SecondaryAttribute::Tag(ref attribute) => format!("'{}", attribute.contents),
+            SecondaryAttribute::Meta(ref meta) => meta.to_string(),
+            SecondaryAttribute::ContractLibraryMethod => "contract_library_method".to_string(),
+            SecondaryAttribute::Export => "export".to_string(),
+            SecondaryAttribute::Field(ref k) => format!("field({k})"),
+            SecondaryAttribute::Abi(ref k) => format!("abi({k})"),
+            SecondaryAttribute::Varargs => "varargs".to_string(),
+            SecondaryAttribute::UseCallersScope => "use_callers_scope".to_string(),
+            SecondaryAttribute::Allow(ref k) => format!("allow({k})"),
+        }
+    }
+}
+
+impl fmt::Display for SecondaryAttribute {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        write!(f, "#[{}]", self.contents())
+    }
+}
+
+#[derive(PartialEq, Eq, Debug, Clone)]
+pub struct MetaAttribute {
+    pub name: Path,
+    pub arguments: Vec<Expression>,
+    pub span: Span,
+}
+
+impl Display for MetaAttribute {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        if self.arguments.is_empty() {
+            write!(f, "{}", self.name)
+        } else {
+            let args =
+                self.arguments.iter().map(ToString::to_string).collect::<Vec<_>>().join(", ");
+            write!(f, "{}({})", self.name, args)
         }
     }
 }
@@ -1004,37 +1000,6 @@ impl CustomAttribute {
     }
 }
 
-impl AsRef<str> for FunctionAttribute {
-    fn as_ref(&self) -> &str {
-        match self {
-            FunctionAttribute::Foreign(string) => string,
-            FunctionAttribute::Builtin(string) => string,
-            FunctionAttribute::Oracle(string) => string,
-            FunctionAttribute::Test { .. } => "",
-            FunctionAttribute::Recursive => "",
-            FunctionAttribute::Fold => "",
-            FunctionAttribute::NoPredicates => "",
-        }
-    }
-}
-
-impl AsRef<str> for SecondaryAttribute {
-    fn as_ref(&self) -> &str {
-        match self {
-            SecondaryAttribute::Deprecated(Some(string)) => string,
-            SecondaryAttribute::Deprecated(None) => "",
-            SecondaryAttribute::Custom(attribute) => &attribute.contents,
-            SecondaryAttribute::Field(string)
-            | SecondaryAttribute::Abi(string)
-            | SecondaryAttribute::Allow(string) => string,
-            SecondaryAttribute::ContractLibraryMethod => "",
-            SecondaryAttribute::Export => "",
-            SecondaryAttribute::Varargs => "",
-            SecondaryAttribute::UseCallersScope => "",
-        }
-    }
-}
-
 /// Note that `self` is not present - it is a contextual keyword rather than a true one as it is
 /// only special within `impl`s. Otherwise `self` functions as a normal identifier.
 #[derive(PartialEq, Eq, Hash, Debug, Copy, Clone, PartialOrd, Ord, strum_macros::EnumIter)]
@@ -1221,25 +1186,6 @@ impl Keyword {
 #[derive(Debug, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]
 pub struct Tokens(pub Vec<SpannedToken>);
 
-type TokenMapIter = Map<IntoIter<SpannedToken>, fn(SpannedToken) -> (Token, Span)>;
-
-impl<'a> From<Tokens> for chumsky::Stream<'a, Token, Span, TokenMapIter> {
-    fn from(tokens: Tokens) -> Self {
-        let end_of_input = match tokens.0.last() {
-            Some(spanned_token) => spanned_token.to_span(),
-            None => Span::single_char(0),
-        };
-
-        fn get_span(token: SpannedToken) -> (Token, Span) {
-            let span = token.to_span();
-            (token.into_token(), span)
-        }
-
-        let iter = tokens.0.into_iter().map(get_span as fn(_) -> _);
-        chumsky::Stream::from_iter(end_of_input, iter)
-    }
-}
-
 #[cfg(test)]
 mod keywords {
     use strum::IntoEnumIterator;
diff --git a/compiler/noirc_frontend/src/lib.rs b/compiler/noirc_frontend/src/lib.rs
index 4391c760701..9d98b125e32 100644
--- a/compiler/noirc_frontend/src/lib.rs
+++ b/compiler/noirc_frontend/src/lib.rs
@@ -36,31 +36,3 @@ pub use hir_def::types::*;
 
 // Unit tests that involve all modules
 pub mod tests;
-
-// API for experimental macros feature
-pub mod macros_api {
-
-    pub use acvm::FieldElement;
-    pub use fm::FileId;
-    pub use noirc_errors::Span;
-
-    pub use crate::graph::CrateId;
-    pub use crate::hir_def::expr::{HirExpression, HirLiteral};
-    pub use crate::hir_def::stmt::HirStatement;
-    pub use crate::node_interner::{NodeInterner, StructId};
-    pub use crate::parser::{parse_program, SortedModule};
-    pub use crate::token::SecondaryAttribute;
-
-    pub use crate::ast::{
-        BlockExpression, CallExpression, CastExpression, Documented, Expression, ExpressionKind,
-        FunctionReturnType, Ident, IndexExpression, ItemVisibility, LetStatement, Literal,
-        MemberAccessExpression, MethodCallExpression, NoirFunction, Path, PathKind, Pattern,
-        Statement, UnresolvedType, UnresolvedTypeData, Visibility,
-    };
-    pub use crate::ast::{
-        ForLoopStatement, ForRange, FunctionDefinition, ImportStatement, NoirStruct, Param,
-        PrefixExpression, Signedness, StatementKind, TypeImpl, UnaryOp,
-    };
-    pub use crate::hir::{def_map::ModuleDefId, Context as HirContext};
-    pub use crate::{StructType, Type};
-}
diff --git a/compiler/noirc_frontend/src/locations.rs b/compiler/noirc_frontend/src/locations.rs
index cba667d5dcb..ecae5b19a95 100644
--- a/compiler/noirc_frontend/src/locations.rs
+++ b/compiler/noirc_frontend/src/locations.rs
@@ -1,13 +1,14 @@
 use fm::FileId;
-use noirc_errors::Location;
+use noirc_errors::{Location, Span};
 use rangemap::RangeMap;
 use rustc_hash::FxHashMap as HashMap;
 
 use crate::{
     ast::{FunctionDefinition, ItemVisibility},
     hir::def_map::{ModuleDefId, ModuleId},
-    macros_api::{NodeInterner, StructId},
-    node_interner::{DefinitionId, FuncId, GlobalId, ReferenceId, TraitId, TypeAliasId},
+    node_interner::{
+        DefinitionId, FuncId, GlobalId, NodeInterner, ReferenceId, StructId, TraitId, TypeAliasId,
+    },
 };
 use petgraph::prelude::NodeIndex as PetGraphIndex;
 
@@ -33,6 +34,27 @@ impl LocationIndices {
     }
 }
 
+pub struct ReferencesTracker<'a> {
+    interner: &'a mut NodeInterner,
+    file_id: FileId,
+}
+
+impl<'a> ReferencesTracker<'a> {
+    pub fn new(interner: &'a mut NodeInterner, file_id: FileId) -> Self {
+        Self { interner, file_id }
+    }
+
+    pub(crate) fn add_reference(
+        &mut self,
+        module_def_id: ModuleDefId,
+        span: Span,
+        is_self_type: bool,
+    ) {
+        let location = Location::new(span, self.file_id);
+        self.interner.add_module_def_id_reference(module_def_id, location, is_self_type);
+    }
+}
+
 impl NodeInterner {
     pub fn reference_location(&self, reference: ReferenceId) -> Location {
         match reference {
@@ -46,7 +68,10 @@ impl NodeInterner {
             ReferenceId::StructMember(id, field_index) => {
                 let struct_type = self.get_struct(id);
                 let struct_type = struct_type.borrow();
-                Location::new(struct_type.field_at(field_index).0.span(), struct_type.location.file)
+                Location::new(
+                    struct_type.field_at(field_index).name.span(),
+                    struct_type.location.file,
+                )
             }
             ReferenceId::Trait(id) => {
                 let trait_type = self.get_trait(id);
@@ -277,8 +302,12 @@ impl NodeInterner {
             .next()
     }
 
-    pub(crate) fn register_module(&mut self, id: ModuleId, name: String) {
-        let visibility = ItemVisibility::Public;
+    pub(crate) fn register_module(
+        &mut self,
+        id: ModuleId,
+        visibility: ItemVisibility,
+        name: String,
+    ) {
         self.register_name_for_auto_import(name, ModuleDefId::ModuleId(id), visibility, None);
     }
 
@@ -286,11 +315,10 @@ impl NodeInterner {
         &mut self,
         id: GlobalId,
         name: String,
+        visibility: ItemVisibility,
         parent_module_id: ModuleId,
     ) {
         self.add_definition_location(ReferenceId::Global(id), Some(parent_module_id));
-
-        let visibility = ItemVisibility::Public;
         self.register_name_for_auto_import(name, ModuleDefId::GlobalId(id), visibility, None);
     }
 
@@ -305,10 +333,14 @@ impl NodeInterner {
         self.register_name_for_auto_import(name, ModuleDefId::TypeId(id), visibility, None);
     }
 
-    pub(crate) fn register_trait(&mut self, id: TraitId, name: String, parent_module_id: ModuleId) {
+    pub(crate) fn register_trait(
+        &mut self,
+        id: TraitId,
+        name: String,
+        visibility: ItemVisibility,
+        parent_module_id: ModuleId,
+    ) {
         self.add_definition_location(ReferenceId::Trait(id), Some(parent_module_id));
-
-        let visibility = ItemVisibility::Public;
         self.register_name_for_auto_import(name, ModuleDefId::TraitId(id), visibility, None);
     }
 
@@ -316,11 +348,10 @@ impl NodeInterner {
         &mut self,
         id: TypeAliasId,
         name: String,
+        visibility: ItemVisibility,
         parent_module_id: ModuleId,
     ) {
         self.add_definition_location(ReferenceId::Alias(id), Some(parent_module_id));
-
-        let visibility = ItemVisibility::Public;
         self.register_name_for_auto_import(name, ModuleDefId::TypeAliasId(id), visibility, None);
     }
 
diff --git a/compiler/noirc_frontend/src/monomorphization/ast.rs b/compiler/noirc_frontend/src/monomorphization/ast.rs
index eb6b4bf7bd4..c9ae3438e42 100644
--- a/compiler/noirc_frontend/src/monomorphization/ast.rs
+++ b/compiler/noirc_frontend/src/monomorphization/ast.rs
@@ -7,11 +7,11 @@ use noirc_errors::{
     Location,
 };
 
-use crate::hir_def::function::FunctionSignature;
 use crate::{
     ast::{BinaryOpKind, IntegerBitSize, Signedness, Visibility},
     token::{Attributes, FunctionAttribute},
 };
+use crate::{hir_def::function::FunctionSignature, token::FmtStrFragment};
 use serde::{Deserialize, Serialize};
 
 use super::HirType;
@@ -48,6 +48,12 @@ pub enum Expression {
     Continue,
 }
 
+impl Expression {
+    pub fn is_array_or_slice_literal(&self) -> bool {
+        matches!(self, Expression::Literal(Literal::Array(_) | Literal::Slice(_)))
+    }
+}
+
 /// A definition is either a local (variable), function, or is a built-in
 /// function that will be generated or referenced by the compiler later.
 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
@@ -106,7 +112,7 @@ pub enum Literal {
     Bool(bool),
     Unit,
     Str(String),
-    FmtStr(String, u64, Box<Expression>),
+    FmtStr(Vec<FmtStrFragment>, u64, Box<Expression>),
 }
 
 #[derive(Debug, Clone, Hash)]
@@ -222,6 +228,8 @@ pub enum InlineType {
     /// All function calls are expected to be inlined into a single ACIR.
     #[default]
     Inline,
+    /// Functions marked as inline always will always be inlined, even in brillig contexts.
+    InlineAlways,
     /// Functions marked as foldable will not be inlined and compiled separately into ACIR
     Fold,
     /// Functions marked to have no predicates will not be inlined in the default inlining pass
@@ -235,12 +243,11 @@ pub enum InlineType {
 
 impl From<&Attributes> for InlineType {
     fn from(attributes: &Attributes) -> Self {
-        attributes.function.as_ref().map_or(InlineType::default(), |func_attribute| {
-            match func_attribute {
-                FunctionAttribute::Fold => InlineType::Fold,
-                FunctionAttribute::NoPredicates => InlineType::NoPredicates,
-                _ => InlineType::default(),
-            }
+        attributes.function().map_or(InlineType::default(), |func_attribute| match func_attribute {
+            FunctionAttribute::Fold => InlineType::Fold,
+            FunctionAttribute::NoPredicates => InlineType::NoPredicates,
+            FunctionAttribute::InlineAlways => InlineType::InlineAlways,
+            _ => InlineType::default(),
         })
     }
 }
@@ -249,6 +256,7 @@ impl InlineType {
     pub fn is_entry_point(&self) -> bool {
         match self {
             InlineType::Inline => false,
+            InlineType::InlineAlways => false,
             InlineType::Fold => true,
             InlineType::NoPredicates => false,
         }
@@ -259,6 +267,7 @@ impl std::fmt::Display for InlineType {
     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
         match self {
             InlineType::Inline => write!(f, "inline"),
+            InlineType::InlineAlways => write!(f, "inline_always"),
             InlineType::Fold => write!(f, "fold"),
             InlineType::NoPredicates => write!(f, "no_predicates"),
         }
@@ -320,8 +329,6 @@ pub struct Program {
     pub main_function_signature: FunctionSignature,
     pub return_location: Option<Location>,
     pub return_visibility: Visibility,
-    /// Indicates to a backend whether a SNARK-friendly prover should be used.  
-    pub recursive: bool,
     pub debug_variables: DebugVariables,
     pub debug_functions: DebugFunctions,
     pub debug_types: DebugTypes,
@@ -335,7 +342,6 @@ impl Program {
         main_function_signature: FunctionSignature,
         return_location: Option<Location>,
         return_visibility: Visibility,
-        recursive: bool,
         debug_variables: DebugVariables,
         debug_functions: DebugFunctions,
         debug_types: DebugTypes,
@@ -346,7 +352,6 @@ impl Program {
             main_function_signature,
             return_location,
             return_visibility,
-            recursive,
             debug_variables,
             debug_functions,
             debug_types,
diff --git a/compiler/noirc_frontend/src/monomorphization/errors.rs b/compiler/noirc_frontend/src/monomorphization/errors.rs
index 4b1951a1aac..c137a6fc90a 100644
--- a/compiler/noirc_frontend/src/monomorphization/errors.rs
+++ b/compiler/noirc_frontend/src/monomorphization/errors.rs
@@ -1,16 +1,21 @@
 use noirc_errors::{CustomDiagnostic, FileDiagnostic, Location};
 
-use crate::{hir::comptime::InterpreterError, Type};
+use crate::{
+    hir::{comptime::InterpreterError, type_check::TypeCheckError},
+    Type,
+};
 
 #[derive(Debug)]
 pub enum MonomorphizationError {
-    UnknownArrayLength { length: Type, location: Location },
+    UnknownArrayLength { length: Type, err: TypeCheckError, location: Location },
     UnknownConstant { location: Location },
     NoDefaultType { location: Location },
     InternalError { message: &'static str, location: Location },
     InterpreterError(InterpreterError),
     ComptimeFnInRuntimeCode { name: String, location: Location },
     ComptimeTypeInRuntimeCode { typ: String, location: Location },
+    CheckedTransmuteFailed { actual: Type, expected: Type, location: Location },
+    CheckedCastFailed { actual: Type, expected: Type, location: Location },
 }
 
 impl MonomorphizationError {
@@ -21,6 +26,8 @@ impl MonomorphizationError {
             | MonomorphizationError::InternalError { location, .. }
             | MonomorphizationError::ComptimeFnInRuntimeCode { location, .. }
             | MonomorphizationError::ComptimeTypeInRuntimeCode { location, .. }
+            | MonomorphizationError::CheckedTransmuteFailed { location, .. }
+            | MonomorphizationError::CheckedCastFailed { location, .. }
             | MonomorphizationError::NoDefaultType { location, .. } => *location,
             MonomorphizationError::InterpreterError(error) => error.get_location(),
         }
@@ -39,12 +46,18 @@ impl From<MonomorphizationError> for FileDiagnostic {
 impl MonomorphizationError {
     fn into_diagnostic(self) -> CustomDiagnostic {
         let message = match &self {
-            MonomorphizationError::UnknownArrayLength { length, .. } => {
-                format!("Could not determine array length `{length}`")
+            MonomorphizationError::UnknownArrayLength { length, err, .. } => {
+                format!("Could not determine array length `{length}`, encountered error: `{err}`")
             }
             MonomorphizationError::UnknownConstant { .. } => {
                 "Could not resolve constant".to_string()
             }
+            MonomorphizationError::CheckedTransmuteFailed { actual, expected, .. } => {
+                format!("checked_transmute failed: `{actual:?}` != `{expected:?}`")
+            }
+            MonomorphizationError::CheckedCastFailed { actual, expected, .. } => {
+                format!("Arithmetic generics simplification failed: `{actual:?}` != `{expected:?}`")
+            }
             MonomorphizationError::NoDefaultType { location } => {
                 let message = "Type annotation needed".into();
                 let secondary = "Could not determine type of generic argument".into();
diff --git a/compiler/noirc_frontend/src/monomorphization/mod.rs b/compiler/noirc_frontend/src/monomorphization/mod.rs
index 12cc3b55b1f..b31a5744d09 100644
--- a/compiler/noirc_frontend/src/monomorphization/mod.rs
+++ b/compiler/noirc_frontend/src/monomorphization/mod.rs
@@ -10,8 +10,9 @@
 //! function, will monomorphize the entire reachable program.
 use crate::ast::{FunctionKind, IntegerBitSize, Signedness, UnaryOp, Visibility};
 use crate::hir::comptime::InterpreterError;
-use crate::hir::type_check::NoMatchingImplFoundError;
+use crate::hir::type_check::{NoMatchingImplFoundError, TypeCheckError};
 use crate::node_interner::{ExprId, ImplSearchErrorKind};
+use crate::token::FmtStrFragment;
 use crate::{
     debug::DebugInstrumenter,
     hir_def::{
@@ -21,7 +22,7 @@ use crate::{
         types,
     },
     node_interner::{self, DefinitionKind, NodeInterner, StmtId, TraitImplKind, TraitMethodId},
-    Type, TypeBinding, TypeBindings,
+    Kind, Type, TypeBinding, TypeBindings,
 };
 use acvm::{acir::AcirField, FieldElement};
 use iter_extended::{btree_map, try_vecmap, vecmap};
@@ -151,7 +152,7 @@ pub fn monomorphize_debug(
         .collect();
 
     let functions = vecmap(monomorphizer.finished_functions, |(_, f)| f);
-    let FuncMeta { return_visibility, kind, .. } = monomorphizer.interner.function_meta(&main);
+    let FuncMeta { return_visibility, .. } = monomorphizer.interner.function_meta(&main);
 
     let (debug_variables, debug_functions, debug_types) =
         monomorphizer.debug_type_tracker.extract_vars_and_types();
@@ -161,7 +162,6 @@ pub fn monomorphize_debug(
         function_sig,
         monomorphizer.return_location,
         *return_visibility,
-        *kind == FunctionKind::Recursive,
         debug_variables,
         debug_functions,
         debug_types,
@@ -222,14 +222,14 @@ impl<'interner> Monomorphizer<'interner> {
                 let attributes = self.interner.function_attributes(&id);
                 match self.interner.function_meta(&id).kind {
                     FunctionKind::LowLevel => {
-                        let attribute = attributes.function.as_ref().expect("all low level functions must contain a function attribute which contains the opcode which it links to");
+                        let attribute = attributes.function().expect("all low level functions must contain a function attribute which contains the opcode which it links to");
                         let opcode = attribute.foreign().expect(
                             "ice: function marked as foreign, but attribute kind does not match this",
                         );
                         Definition::LowLevel(opcode.to_string())
                     }
                     FunctionKind::Builtin => {
-                        let attribute = attributes.function.as_ref().expect("all builtin functions must contain a function attribute which contains the opcode which it links to");
+                        let attribute = attributes.function().expect("all builtin functions must contain a function attribute which contains the opcode which it links to");
                         let opcode = attribute.builtin().expect(
                             "ice: function marked as builtin, but attribute kind does not match this",
                         );
@@ -241,17 +241,12 @@ impl<'interner> Monomorphizer<'interner> {
                         Definition::Function(id)
                     }
                     FunctionKind::Oracle => {
-                        let attribute = attributes.function.as_ref().expect("all oracle functions must contain a function attribute which contains the opcode which it links to");
+                        let attribute = attributes.function().expect("all oracle functions must contain a function attribute which contains the opcode which it links to");
                         let opcode = attribute.oracle().expect(
                             "ice: function marked as builtin, but attribute kind does not match this",
                         );
                         Definition::Oracle(opcode.to_string())
                     }
-                    FunctionKind::Recursive => {
-                        let id =
-                            self.queue_function(id, expr_id, typ, turbofish_generics, trait_method);
-                        Definition::Function(id)
-                    }
                 }
             }
         }
@@ -423,10 +418,10 @@ impl<'interner> Monomorphizer<'interner> {
         let expr = match self.interner.expression(&expr) {
             HirExpression::Ident(ident, generics) => self.ident(ident, expr, generics)?,
             HirExpression::Literal(HirLiteral::Str(contents)) => Literal(Str(contents)),
-            HirExpression::Literal(HirLiteral::FmtStr(contents, idents)) => {
+            HirExpression::Literal(HirLiteral::FmtStr(fragments, idents, _length)) => {
                 let fields = try_vecmap(idents, |ident| self.expr(ident))?;
                 Literal(FmtStr(
-                    contents,
+                    fragments,
                     fields.len() as u64,
                     Box::new(ast::Expression::Tuple(fields)),
                 ))
@@ -576,9 +571,9 @@ impl<'interner> Monomorphizer<'interner> {
         let location = self.interner.expr_location(&array);
         let typ = Self::convert_type(&self.interner.id_type(array), location)?;
 
-        let length = length.evaluate_to_u32().ok_or_else(|| {
+        let length = length.evaluate_to_u32(location.span).map_err(|err| {
             let location = self.interner.expr_location(&array);
-            MonomorphizationError::UnknownArrayLength { location, length }
+            MonomorphizationError::UnknownArrayLength { location, err, length }
         })?;
 
         let contents = try_vecmap(0..length, |_| self.expr(repeated_element))?;
@@ -850,14 +845,21 @@ impl<'interner> Monomorphizer<'interner> {
     ) -> Result<ast::Expression, MonomorphizationError> {
         let typ = self.interner.id_type(expr_id);
 
-        if let ImplKind::TraitMethod(method, _, _) = ident.impl_kind {
-            return self.resolve_trait_method_expr(expr_id, typ, method);
+        if let ImplKind::TraitMethod(method) = ident.impl_kind {
+            return self.resolve_trait_method_expr(expr_id, typ, method.method_id);
         }
 
         // Ensure all instantiation bindings are bound.
         // This ensures even unused type variables like `fn foo<T>() {}` have concrete types
         if let Some(bindings) = self.interner.try_get_instantiation_bindings(expr_id) {
-            for (_, binding) in bindings.values() {
+            for (_, kind, binding) in bindings.values() {
+                match kind {
+                    Kind::Any => (),
+                    Kind::Normal => (),
+                    Kind::Integer => (),
+                    Kind::IntegerOrField => (),
+                    Kind::Numeric(typ) => Self::check_type(typ, ident.location)?,
+                }
                 Self::check_type(binding, ident.location)?;
             }
         }
@@ -916,18 +918,32 @@ impl<'interner> Monomorphizer<'interner> {
                     ast::Expression::Ident(ident)
                 }
             },
-            DefinitionKind::GenericType(type_variable) => {
+            DefinitionKind::NumericGeneric(type_variable, numeric_typ) => {
                 let value = match &*type_variable.borrow() {
-                    TypeBinding::Unbound(_) => {
+                    TypeBinding::Unbound(_, _) => {
                         unreachable!("Unbound type variable used in expression")
                     }
-                    TypeBinding::Bound(binding) => binding.evaluate_to_u32().unwrap_or_else(|| {
-                        panic!("Non-numeric type variable used in expression expecting a value")
-                    }),
+                    TypeBinding::Bound(binding) => {
+                        let location = self.interner.id_location(expr_id);
+                        binding
+                            .evaluate_to_field_element(
+                                &Kind::Numeric(numeric_typ.clone()),
+                                location.span,
+                            )
+                            .map_err(|err| MonomorphizationError::UnknownArrayLength {
+                                length: binding.clone(),
+                                err,
+                                location,
+                            })?
+                    }
                 };
-
-                let value = FieldElement::from(value as u128);
                 let location = self.interner.id_location(expr_id);
+
+                if !Kind::Numeric(numeric_typ.clone()).unifies(&Kind::numeric(typ.clone())) {
+                    let message = "ICE: Generic's kind does not match expected type";
+                    return Err(MonomorphizationError::InternalError { location, message });
+                }
+
                 let typ = Self::convert_type(&typ, ident.location)?;
                 ast::Expression::Literal(ast::Literal::Integer(value, false, typ, location))
             }
@@ -938,24 +954,56 @@ impl<'interner> Monomorphizer<'interner> {
 
     /// Convert a non-tuple/struct type to a monomorphized type
     fn convert_type(typ: &HirType, location: Location) -> Result<ast::Type, MonomorphizationError> {
-        Ok(match typ {
+        let typ = typ.follow_bindings_shallow();
+        Ok(match typ.as_ref() {
             HirType::FieldElement => ast::Type::Field,
             HirType::Integer(sign, bits) => ast::Type::Integer(*sign, *bits),
             HirType::Bool => ast::Type::Bool,
-            HirType::String(size) => ast::Type::String(size.evaluate_to_u32().unwrap_or(0)),
+            HirType::String(size) => {
+                let size = match size.evaluate_to_u32(location.span) {
+                    Ok(size) => size,
+                    // only default variable sizes to size 0
+                    Err(TypeCheckError::NonConstantEvaluated { .. }) => 0,
+                    Err(err) => {
+                        let length = size.as_ref().clone();
+                        return Err(MonomorphizationError::UnknownArrayLength {
+                            location,
+                            err,
+                            length,
+                        });
+                    }
+                };
+                ast::Type::String(size)
+            }
             HirType::FmtString(size, fields) => {
-                let size = size.evaluate_to_u32().unwrap_or(0);
+                let size = match size.evaluate_to_u32(location.span) {
+                    Ok(size) => size,
+                    // only default variable sizes to size 0
+                    Err(TypeCheckError::NonConstantEvaluated { .. }) => 0,
+                    Err(err) => {
+                        let length = size.as_ref().clone();
+                        return Err(MonomorphizationError::UnknownArrayLength {
+                            location,
+                            err,
+                            length,
+                        });
+                    }
+                };
                 let fields = Box::new(Self::convert_type(fields.as_ref(), location)?);
                 ast::Type::FmtString(size, fields)
             }
             HirType::Unit => ast::Type::Unit,
             HirType::Array(length, element) => {
                 let element = Box::new(Self::convert_type(element.as_ref(), location)?);
-                let length = match length.evaluate_to_u32() {
-                    Some(length) => length,
-                    None => {
+                let length = match length.evaluate_to_u32(location.span) {
+                    Ok(length) => length,
+                    Err(err) => {
                         let length = length.as_ref().clone();
-                        return Err(MonomorphizationError::UnknownArrayLength { location, length });
+                        return Err(MonomorphizationError::UnknownArrayLength {
+                            location,
+                            err,
+                            length,
+                        });
                     }
                 };
                 ast::Type::Array(length, element)
@@ -967,8 +1015,8 @@ impl<'interner> Monomorphizer<'interner> {
             HirType::TraitAsType(..) => {
                 unreachable!("All TraitAsType should be replaced before calling convert_type");
             }
-            HirType::NamedGeneric(binding, _, _) => {
-                if let TypeBinding::Bound(binding) = &*binding.borrow() {
+            HirType::NamedGeneric(binding, _) => {
+                if let TypeBinding::Bound(ref binding) = &*binding.borrow() {
                     return Self::convert_type(binding, location);
                 }
 
@@ -979,15 +1027,23 @@ impl<'interner> Monomorphizer<'interner> {
                 ast::Type::Field
             }
 
-            HirType::TypeVariable(binding, kind) => {
-                if let TypeBinding::Bound(binding) = &*binding.borrow() {
-                    return Self::convert_type(binding, location);
-                }
+            HirType::CheckedCast { from, to } => {
+                Self::check_checked_cast(from, to, location)?;
+                Self::convert_type(to, location)?
+            }
+
+            HirType::TypeVariable(ref binding) => {
+                let type_var_kind = match &*binding.borrow() {
+                    TypeBinding::Bound(ref binding) => {
+                        return Self::convert_type(binding, location);
+                    }
+                    TypeBinding::Unbound(_, ref type_var_kind) => type_var_kind.clone(),
+                };
 
                 // Default any remaining unbound type variables.
                 // This should only happen if the variable in question is unused
                 // and within a larger generic type.
-                let default = match kind.default_type() {
+                let default = match type_var_kind.default_type() {
                     Some(typ) => typ,
                     None => return Err(MonomorphizationError::NoDefaultType { location }),
                 };
@@ -1065,7 +1121,8 @@ impl<'interner> Monomorphizer<'interner> {
 
     // Similar to `convert_type` but returns an error if any type variable can't be defaulted.
     fn check_type(typ: &HirType, location: Location) -> Result<(), MonomorphizationError> {
-        match typ {
+        let typ = typ.follow_bindings_shallow();
+        match typ.as_ref() {
             HirType::FieldElement
             | HirType::Integer(..)
             | HirType::Bool
@@ -1082,26 +1139,34 @@ impl<'interner> Monomorphizer<'interner> {
                     Ok(())
                 }
             }
+            HirType::CheckedCast { from, to } => {
+                Self::check_checked_cast(from, to, location)?;
+                Self::check_type(to, location)
+            }
+
             HirType::FmtString(_size, fields) => Self::check_type(fields.as_ref(), location),
             HirType::Array(_length, element) => Self::check_type(element.as_ref(), location),
             HirType::Slice(element) => Self::check_type(element.as_ref(), location),
-            HirType::NamedGeneric(binding, _, _) => {
-                if let TypeBinding::Bound(binding) = &*binding.borrow() {
+            HirType::NamedGeneric(binding, _) => {
+                if let TypeBinding::Bound(ref binding) = &*binding.borrow() {
                     return Self::check_type(binding, location);
                 }
 
                 Ok(())
             }
 
-            HirType::TypeVariable(binding, kind) => {
-                if let TypeBinding::Bound(binding) = &*binding.borrow() {
-                    return Self::check_type(binding, location);
-                }
+            HirType::TypeVariable(ref binding) => {
+                let type_var_kind = match &*binding.borrow() {
+                    TypeBinding::Bound(binding) => {
+                        return Self::check_type(binding, location);
+                    }
+                    TypeBinding::Unbound(_, ref type_var_kind) => type_var_kind.clone(),
+                };
 
                 // Default any remaining unbound type variables.
                 // This should only happen if the variable in question is unused
                 // and within a larger generic type.
-                let default = match kind.default_type() {
+                let default = match type_var_kind.default_type() {
                     Some(typ) => typ,
                     None => return Err(MonomorphizationError::NoDefaultType { location }),
                 };
@@ -1150,6 +1215,40 @@ impl<'interner> Monomorphizer<'interner> {
         }
     }
 
+    /// Check that the 'from' and to' sides of a CheckedCast unify and
+    /// that if the 'to' side evaluates to a field element, that the 'from' side
+    /// evaluates to the same field element
+    fn check_checked_cast(
+        from: &Type,
+        to: &Type,
+        location: Location,
+    ) -> Result<(), MonomorphizationError> {
+        if from.unify(to).is_err() {
+            return Err(MonomorphizationError::CheckedCastFailed {
+                actual: to.clone(),
+                expected: from.clone(),
+                location,
+            });
+        }
+        let to_value = to.evaluate_to_field_element(&to.kind(), location.span);
+        if to_value.is_ok() {
+            let skip_simplifications = false;
+            let from_value = from.evaluate_to_field_element_helper(
+                &to.kind(),
+                location.span,
+                skip_simplifications,
+            );
+            if from_value.is_err() || from_value.unwrap() != to_value.clone().unwrap() {
+                return Err(MonomorphizationError::CheckedCastFailed {
+                    actual: HirType::Constant(to_value.unwrap(), to.kind()),
+                    expected: from.clone(),
+                    location,
+                });
+            }
+        }
+        Ok(())
+    }
+
     fn is_function_closure(&self, t: ast::Type) -> bool {
         if self.is_function_closure_type(&t) {
             true
@@ -1265,7 +1364,7 @@ impl<'interner> Monomorphizer<'interner> {
         };
 
         let call = self
-            .try_evaluate_call(&func, &id, &return_type)
+            .try_evaluate_call(&func, &id, &call.arguments, &arguments, &return_type)?
             .unwrap_or(ast::Expression::Call(ast::Call { func, arguments, return_type, location }));
 
         if !block_expressions.is_empty() {
@@ -1347,13 +1446,15 @@ impl<'interner> Monomorphizer<'interner> {
         &mut self,
         func: &ast::Expression,
         expr_id: &node_interner::ExprId,
+        arguments: &[node_interner::ExprId],
+        argument_values: &[ast::Expression],
         result_type: &ast::Type,
-    ) -> Option<ast::Expression> {
+    ) -> Result<Option<ast::Expression>, MonomorphizationError> {
         if let ast::Expression::Ident(ident) = func {
             if let Definition::Builtin(opcode) = &ident.definition {
                 // TODO(#1736): Move this builtin to the SSA pass
                 let location = self.interner.expr_location(expr_id);
-                return match opcode.as_str() {
+                return Ok(match opcode.as_str() {
                     "modulus_num_bits" => {
                         let bits = (FieldElement::max_num_bits() as u128).into();
                         let typ =
@@ -1382,11 +1483,35 @@ impl<'interner> Monomorphizer<'interner> {
                         let bytes = FieldElement::modulus().to_bytes_le();
                         Some(self.modulus_slice_literal(bytes, IntegerBitSize::Eight, location))
                     }
+                    "checked_transmute" => {
+                        Some(self.checked_transmute(*expr_id, arguments, argument_values)?)
+                    }
                     _ => None,
-                };
+                });
             }
         }
-        None
+        Ok(None)
+    }
+
+    fn checked_transmute(
+        &mut self,
+        expr_id: node_interner::ExprId,
+        arguments: &[node_interner::ExprId],
+        argument_values: &[ast::Expression],
+    ) -> Result<ast::Expression, MonomorphizationError> {
+        let location = self.interner.expr_location(&expr_id);
+        let actual = self.interner.id_type(arguments[0]).follow_bindings();
+        let expected = self.interner.id_type(expr_id).follow_bindings();
+
+        if actual.unify(&expected).is_err() {
+            Err(MonomorphizationError::CheckedTransmuteFailed { actual, expected, location })
+        } else {
+            // Evaluate `checked_transmute(arg)` to `{ arg }`
+            // in case the user did `&mut checked_transmute(arg)`. Wrapping the
+            // arg in a block prevents mutating the original argument.
+            let argument = argument_values[0].clone();
+            Ok(ast::Expression::Block(vec![argument]))
+        }
     }
 
     fn modulus_slice_literal(
@@ -1441,9 +1566,9 @@ impl<'interner> Monomorphizer<'interner> {
     fn follow_bindings(&self, bindings: &TypeBindings) -> TypeBindings {
         bindings
             .iter()
-            .map(|(id, (var, binding))| {
+            .map(|(id, (var, kind, binding))| {
                 let binding2 = binding.follow_bindings();
-                (*id, (var.clone(), binding2))
+                (*id, (var.clone(), kind.clone(), binding2))
             })
             .collect()
     }
@@ -1722,7 +1847,7 @@ impl<'interner> Monomorphizer<'interner> {
                     _ => unreachable!("ICE: format string fields should be structured in a tuple, but got a {zeroed_tuple}"),
                 };
                 ast::Expression::Literal(ast::Literal::FmtStr(
-                    "\0".repeat(*length as usize),
+                    vec![FmtStrFragment::String("\0".repeat(*length as usize))],
                     fields_len,
                     Box::new(zeroed_tuple),
                 ))
@@ -1910,14 +2035,14 @@ fn unwrap_struct_type(
 }
 
 pub fn perform_instantiation_bindings(bindings: &TypeBindings) {
-    for (var, binding) in bindings.values() {
+    for (var, _kind, binding) in bindings.values() {
         var.force_bind(binding.clone());
     }
 }
 
 pub fn undo_instantiation_bindings(bindings: TypeBindings) {
-    for (id, (var, _)) in bindings {
-        var.unbind(id);
+    for (id, (var, kind, _)) in bindings {
+        var.unbind(id, kind);
     }
 }
 
@@ -1944,7 +2069,7 @@ pub fn perform_impl_bindings(
             interner.function_meta(&impl_method).typ.unwrap_forall().1.clone();
 
         // Make each NamedGeneric in this type bindable by replacing it with a TypeVariable
-        // with the same internal id and binding.
+        // with the same internal id, binding.
         trait_method_type.replace_named_generics_with_type_variables();
         impl_method_type.replace_named_generics_with_type_variables();
 
diff --git a/compiler/noirc_frontend/src/monomorphization/printer.rs b/compiler/noirc_frontend/src/monomorphization/printer.rs
index b6421b26a03..9c1072a4117 100644
--- a/compiler/noirc_frontend/src/monomorphization/printer.rs
+++ b/compiler/noirc_frontend/src/monomorphization/printer.rs
@@ -105,9 +105,11 @@ impl AstPrinter {
             super::ast::Literal::Integer(x, _, _, _) => x.fmt(f),
             super::ast::Literal::Bool(x) => x.fmt(f),
             super::ast::Literal::Str(s) => s.fmt(f),
-            super::ast::Literal::FmtStr(s, _, _) => {
+            super::ast::Literal::FmtStr(fragments, _, _) => {
                 write!(f, "f\"")?;
-                s.fmt(f)?;
+                for fragment in fragments {
+                    fragment.fmt(f)?;
+                }
                 write!(f, "\"")
             }
             super::ast::Literal::Unit => {
diff --git a/compiler/noirc_frontend/src/node_interner.rs b/compiler/noirc_frontend/src/node_interner.rs
index a95282a1ec9..6d70ea2fd6d 100644
--- a/compiler/noirc_frontend/src/node_interner.rs
+++ b/compiler/noirc_frontend/src/node_interner.rs
@@ -13,24 +13,18 @@ use petgraph::prelude::DiGraph;
 use petgraph::prelude::NodeIndex as PetGraphIndex;
 use rustc_hash::FxHashMap as HashMap;
 
-use crate::ast::ExpressionKind;
-use crate::ast::Ident;
-use crate::ast::LValue;
-use crate::ast::Pattern;
-use crate::ast::StatementKind;
-use crate::ast::UnresolvedTypeData;
+use crate::ast::{
+    ExpressionKind, Ident, LValue, Pattern, StatementKind, UnaryOp, UnresolvedTypeData,
+};
 use crate::graph::CrateId;
 use crate::hir::comptime;
 use crate::hir::def_collector::dc_crate::CompilationError;
 use crate::hir::def_collector::dc_crate::{UnresolvedStruct, UnresolvedTrait, UnresolvedTypeAlias};
 use crate::hir::def_map::DefMaps;
-use crate::hir::def_map::{LocalModuleId, ModuleId};
+use crate::hir::def_map::{LocalModuleId, ModuleDefId, ModuleId};
 use crate::hir::type_check::generics::TraitGenerics;
 use crate::hir_def::traits::NamedType;
-use crate::macros_api::ModuleDefId;
-use crate::macros_api::UnaryOp;
-use crate::usage_tracker::UnusedItem;
-use crate::usage_tracker::UsageTracker;
+use crate::hir_def::traits::ResolvedTraitBound;
 use crate::QuotedType;
 
 use crate::ast::{BinaryOpKind, FunctionDefinition, ItemVisibility};
@@ -39,7 +33,7 @@ use crate::hir_def::expr::HirIdent;
 use crate::hir_def::stmt::HirLetStatement;
 use crate::hir_def::traits::TraitImpl;
 use crate::hir_def::traits::{Trait, TraitConstraint};
-use crate::hir_def::types::{StructType, Type};
+use crate::hir_def::types::{Kind, StructType, Type};
 use crate::hir_def::{
     expr::HirExpression,
     function::{FuncMeta, HirFunction},
@@ -49,7 +43,7 @@ use crate::locations::LocationIndices;
 use crate::token::{Attributes, SecondaryAttribute};
 use crate::GenericTypeVars;
 use crate::Generics;
-use crate::{Shared, TypeAlias, TypeBindings, TypeVariable, TypeVariableId, TypeVariableKind};
+use crate::{Shared, TypeAlias, TypeBindings, TypeVariable, TypeVariableId};
 
 /// An arbitrary number to limit the recursion depth when searching for trait impls.
 /// This is needed to stop recursing for cases such as `impl<T> Foo for T where T: Eq`
@@ -60,6 +54,7 @@ pub struct ModuleAttributes {
     pub name: String,
     pub location: Location,
     pub parent: Option<LocalModuleId>,
+    pub visibility: ItemVisibility,
 }
 
 type StructAttributes = Vec<SecondaryAttribute>;
@@ -274,8 +269,6 @@ pub struct NodeInterner {
     /// share the same global values.
     pub(crate) comptime_scopes: Vec<HashMap<DefinitionId, comptime::Value>>,
 
-    pub(crate) usage_tracker: UsageTracker,
-
     /// Captures the documentation comments for each module, struct, trait, function, etc.
     pub(crate) doc_comments: HashMap<ReferenceId, Vec<String>>,
 }
@@ -296,6 +289,7 @@ pub enum DependencyId {
     Global(GlobalId),
     Function(FuncId),
     Alias(TypeAliasId),
+    Trait(TraitId),
     Variable(Location),
 }
 
@@ -586,7 +580,7 @@ pub enum DefinitionKind {
 
     /// Generic types in functions (T, U in `fn foo<T, U>(...)` are declared as variables
     /// in scope in case they resolve to numeric generics later.
-    GenericType(TypeVariable),
+    NumericGeneric(TypeVariable, Box<Type>),
 }
 
 impl DefinitionKind {
@@ -601,7 +595,7 @@ impl DefinitionKind {
             DefinitionKind::Function(_) => None,
             DefinitionKind::Global(_) => None,
             DefinitionKind::Local(id) => *id,
-            DefinitionKind::GenericType(_) => None,
+            DefinitionKind::NumericGeneric(_, _) => None,
         }
     }
 }
@@ -682,7 +676,6 @@ impl Default for NodeInterner {
             auto_import_names: HashMap::default(),
             comptime_scopes: vec![HashMap::default()],
             trait_impl_associated_types: HashMap::default(),
-            usage_tracker: UsageTracker::default(),
             doc_comments: HashMap::default(),
         }
     }
@@ -733,10 +726,12 @@ impl NodeInterner {
             crate_id: unresolved_trait.crate_id,
             location: Location::new(unresolved_trait.trait_def.span, unresolved_trait.file_id),
             generics,
-            self_type_typevar: TypeVariable::unbound(self.next_type_variable_id()),
+            self_type_typevar: TypeVariable::unbound(self.next_type_variable_id(), Kind::Normal),
             methods: Vec::new(),
             method_ids: unresolved_trait.method_ids.clone(),
             associated_types,
+            trait_bounds: Vec::new(),
+            where_clause: Vec::new(),
         };
 
         self.traits.insert(type_id, new_trait);
@@ -1336,6 +1331,10 @@ impl NodeInterner {
         Type::type_variable(self.next_type_variable_id())
     }
 
+    pub fn next_type_variable_with_kind(&self, kind: Kind) -> Type {
+        Type::type_variable_with_kind(self, kind)
+    }
+
     pub fn store_instantiation_bindings(
         &mut self,
         expr_id: ExprId,
@@ -1532,9 +1531,11 @@ impl NodeInterner {
             let named = trait_associated_types.to_vec();
             TraitConstraint {
                 typ: object_type.clone(),
-                trait_id,
-                trait_generics: TraitGenerics { ordered, named },
-                span: Span::default(),
+                trait_bound: ResolvedTraitBound {
+                    trait_id,
+                    trait_generics: TraitGenerics { ordered, named },
+                    span: Span::default(),
+                },
             }
         };
 
@@ -1614,9 +1615,11 @@ impl NodeInterner {
 
                 let constraint = TraitConstraint {
                     typ: existing_object_type,
-                    trait_id,
-                    trait_generics,
-                    span: Span::default(),
+                    trait_bound: ResolvedTraitBound {
+                        trait_id,
+                        trait_generics,
+                        span: Span::default(),
+                    },
                 };
                 matching_impls.push((impl_kind.clone(), fresh_bindings, constraint));
             }
@@ -1636,8 +1639,8 @@ impl NodeInterner {
             Err(ImplSearchErrorKind::Nested(errors))
         } else {
             let impls = vecmap(matching_impls, |(_, _, constraint)| {
-                let name = &self.get_trait(constraint.trait_id).name;
-                format!("{}: {name}{}", constraint.typ, constraint.trait_generics)
+                let name = &self.get_trait(constraint.trait_bound.trait_id).name;
+                format!("{}: {name}{}", constraint.typ, constraint.trait_bound.trait_generics)
             });
             Err(ImplSearchErrorKind::MultipleMatching(impls))
         }
@@ -1659,20 +1662,22 @@ impl NodeInterner {
             let constraint_type =
                 constraint.typ.force_substitute(instantiation_bindings).substitute(type_bindings);
 
-            let trait_generics = vecmap(&constraint.trait_generics.ordered, |generic| {
-                generic.force_substitute(instantiation_bindings).substitute(type_bindings)
-            });
+            let trait_generics =
+                vecmap(&constraint.trait_bound.trait_generics.ordered, |generic| {
+                    generic.force_substitute(instantiation_bindings).substitute(type_bindings)
+                });
 
-            let trait_associated_types = vecmap(&constraint.trait_generics.named, |generic| {
-                let typ = generic.typ.force_substitute(instantiation_bindings);
-                NamedType { name: generic.name.clone(), typ: typ.substitute(type_bindings) }
-            });
+            let trait_associated_types =
+                vecmap(&constraint.trait_bound.trait_generics.named, |generic| {
+                    let typ = generic.typ.force_substitute(instantiation_bindings);
+                    NamedType { name: generic.name.clone(), typ: typ.substitute(type_bindings) }
+                });
 
             // We can ignore any associated types on the constraint since those should not affect
             // which impl we choose.
             self.lookup_trait_implementation_helper(
                 &constraint_type,
-                constraint.trait_id,
+                constraint.trait_bound.trait_id,
                 &trait_generics,
                 &trait_associated_types,
                 // Use a fresh set of type bindings here since the constraint_type originates from
@@ -1737,7 +1742,16 @@ impl NodeInterner {
         // Replace each generic with a fresh type variable
         let substitutions = impl_generics
             .into_iter()
-            .map(|typevar| (typevar.id(), (typevar, self.next_type_variable())))
+            .map(|typevar| {
+                let typevar_kind = typevar.kind();
+                let typevar_id = typevar.id();
+                let substitution = (
+                    typevar,
+                    typevar_kind.clone(),
+                    self.next_type_variable_with_kind(typevar_kind),
+                );
+                (typevar_id, substitution)
+            })
             .collect();
 
         let instantiated_object_type = object_type.substitute(&substitutions);
@@ -1857,8 +1871,33 @@ impl NodeInterner {
 
     /// Removes all TraitImplKind::Assumed from the list of known impls for the given trait
     pub fn remove_assumed_trait_implementations_for_trait(&mut self, trait_id: TraitId) {
+        self.remove_assumed_trait_implementations_for_trait_and_parents(trait_id, trait_id);
+    }
+
+    fn remove_assumed_trait_implementations_for_trait_and_parents(
+        &mut self,
+        trait_id: TraitId,
+        starting_trait_id: TraitId,
+    ) {
         let entries = self.trait_implementation_map.entry(trait_id).or_default();
         entries.retain(|(_, kind)| matches!(kind, TraitImplKind::Normal(_)));
+
+        // Also remove assumed implementations for the parent traits, if any
+        if let Some(trait_bounds) =
+            self.try_get_trait(trait_id).map(|the_trait| the_trait.trait_bounds.clone())
+        {
+            for parent_trait_bound in trait_bounds {
+                // Avoid looping forever in case there are cycles
+                if parent_trait_bound.trait_id == starting_trait_id {
+                    continue;
+                }
+
+                self.remove_assumed_trait_implementations_for_trait_and_parents(
+                    parent_trait_bound.trait_id,
+                    starting_trait_id,
+                );
+            }
+        }
     }
 
     /// Tags the given identifier with the selected trait_impl so that monomorphization
@@ -2008,6 +2047,10 @@ impl NodeInterner {
         self.add_dependency(dependent, DependencyId::Alias(dependency));
     }
 
+    pub fn add_trait_dependency(&mut self, dependent: DependencyId, dependency: TraitId) {
+        self.add_dependency(dependent, DependencyId::Trait(dependency));
+    }
+
     pub fn add_dependency(&mut self, dependent: DependencyId, dependency: DependencyId) {
         let dependent_index = self.get_or_insert_dependency(dependent);
         let dependency_index = self.get_or_insert_dependency(dependency);
@@ -2063,6 +2106,11 @@ impl NodeInterner {
                             push_error(alias.name.to_string(), &scc, i, alias.location);
                             break;
                         }
+                        DependencyId::Trait(trait_id) => {
+                            let the_trait = self.get_trait(trait_id);
+                            push_error(the_trait.name.to_string(), &scc, i, the_trait.location);
+                            break;
+                        }
                         // Mutually recursive functions are allowed
                         DependencyId::Function(_) => (),
                         // Local variables should never be in a dependency cycle, scoping rules
@@ -2091,6 +2139,7 @@ impl NodeInterner {
             DependencyId::Global(id) => {
                 Cow::Borrowed(self.get_global(id).ident.0.contents.as_ref())
             }
+            DependencyId::Trait(id) => Cow::Owned(self.get_trait(id).name.to_string()),
             DependencyId::Variable(loc) => {
                 unreachable!("Variable used at location {loc:?} caught in a dependency cycle")
             }
@@ -2137,6 +2186,7 @@ impl NodeInterner {
 
     pub fn get_lvalue(&self, id: InternedExpressionKind, span: Span) -> LValue {
         LValue::from_expression_kind(self.get_expression_kind(id).clone(), span)
+            .expect("Called LValue::from_expression with an invalid expression")
     }
 
     pub fn push_pattern(&mut self, pattern: Pattern) -> InternedPattern {
@@ -2228,11 +2278,17 @@ impl NodeInterner {
         let trait_generics = the_trait.generics.clone();
 
         let self_type_var = the_trait.self_type_typevar.clone();
-        bindings.insert(self_type_var.id(), (self_type_var, impl_self_type));
+        bindings.insert(
+            self_type_var.id(),
+            (self_type_var.clone(), self_type_var.kind(), impl_self_type),
+        );
 
         for (trait_generic, trait_impl_generic) in trait_generics.iter().zip(trait_impl_generics) {
             let type_var = trait_generic.type_var.clone();
-            bindings.insert(type_var.id(), (type_var, trait_impl_generic.clone()));
+            bindings.insert(
+                type_var.id(),
+                (type_var, trait_generic.kind(), trait_impl_generic.clone()),
+            );
         }
 
         // Now that the normal bindings are added, we still need to bind the associated types
@@ -2241,7 +2297,10 @@ impl NodeInterner {
 
         for (trait_type, impl_type) in trait_associated_types.iter().zip(impl_associated_types) {
             let type_variable = trait_type.type_var.clone();
-            bindings.insert(type_variable.id(), (type_variable, impl_type.typ.clone()));
+            bindings.insert(
+                type_variable.id(),
+                (type_variable, trait_type.kind(), impl_type.typ.clone()),
+            );
         }
 
         bindings
@@ -2256,12 +2315,6 @@ impl NodeInterner {
     pub fn doc_comments(&self, id: ReferenceId) -> Option<&Vec<String>> {
         self.doc_comments.get(&id)
     }
-
-    pub fn unused_items(
-        &self,
-    ) -> &std::collections::HashMap<ModuleId, std::collections::HashMap<Ident, UnusedItem>> {
-        self.usage_tracker.unused_items()
-    }
 }
 
 impl Methods {
@@ -2298,7 +2351,7 @@ impl Methods {
     }
 
     /// Select the 1 matching method with an object type matching `typ`
-    fn find_matching_method(
+    pub fn find_matching_method(
         &self,
         typ: &Type,
         has_self_param: bool,
@@ -2362,26 +2415,31 @@ fn get_type_method_key(typ: &Type) -> Option<TypeMethodKey> {
         Type::Array(_, _) => Some(Array),
         Type::Slice(_) => Some(Slice),
         Type::Integer(_, _) => Some(FieldOrInt),
-        Type::TypeVariable(_, TypeVariableKind::IntegerOrField) => Some(FieldOrInt),
-        Type::TypeVariable(_, TypeVariableKind::Integer) => Some(FieldOrInt),
+        Type::TypeVariable(var) => {
+            if var.is_integer() || var.is_integer_or_field() {
+                Some(FieldOrInt)
+            } else {
+                None
+            }
+        }
         Type::Bool => Some(Bool),
         Type::String(_) => Some(String),
         Type::FmtString(_, _) => Some(FmtString),
         Type::Unit => Some(Unit),
         Type::Tuple(_) => Some(Tuple),
         Type::Function(_, _, _, _) => Some(Function),
-        Type::NamedGeneric(_, _, _) => Some(Generic),
+        Type::NamedGeneric(_, _) => Some(Generic),
         Type::Quoted(quoted) => Some(Quoted(*quoted)),
         Type::MutableReference(element) => get_type_method_key(element),
         Type::Alias(alias, _) => get_type_method_key(&alias.borrow().typ),
 
         // We do not support adding methods to these types
-        Type::TypeVariable(_, _)
-        | Type::Forall(_, _)
+        Type::Forall(_, _)
         | Type::Constant(..)
         | Type::Error
         | Type::Struct(_, _)
         | Type::InfixExpr(..)
+        | Type::CheckedCast { .. }
         | Type::TraitAsType(..) => None,
     }
 }
diff --git a/compiler/noirc_frontend/src/parser/errors.rs b/compiler/noirc_frontend/src/parser/errors.rs
index 75fe1bf747f..899928528e6 100644
--- a/compiler/noirc_frontend/src/parser/errors.rs
+++ b/compiler/noirc_frontend/src/parser/errors.rs
@@ -1,4 +1,4 @@
-use crate::ast::{Expression, IntegerBitSize};
+use crate::ast::{Expression, IntegerBitSize, ItemVisibility};
 use crate::lexer::errors::LexerErrorKind;
 use crate::lexer::token::Token;
 use crate::token::TokenKind;
@@ -13,26 +13,52 @@ use super::labels::ParsingRuleLabel;
 
 #[derive(Debug, Clone, PartialEq, Eq, Error)]
 pub enum ParserErrorReason {
-    #[error("Unexpected '{0}', expected a field name")]
+    #[error("Unexpected `;`")]
+    UnexpectedSemicolon,
+    #[error("Unexpected `,`")]
+    UnexpectedComma,
+    #[error("Expected a `{token}` separating these two {items}")]
+    ExpectedTokenSeparatingTwoItems { token: Token, items: &'static str },
+    #[error("Expected `mut` after `&`, found `{found}`")]
+    ExpectedMutAfterAmpersand { found: Token },
+    #[error("Invalid left-hand side of assignment")]
+    InvalidLeftHandSideOfAssignment,
+    #[error("Expected trait, found {found}")]
+    ExpectedTrait { found: String },
+    #[error("Visibility `{visibility}` is not followed by an item")]
+    VisibilityNotFollowedByAnItem { visibility: ItemVisibility },
+    #[error("`unconstrained` is not followed by an item")]
+    UnconstrainedNotFollowedByAnItem,
+    #[error("`comptime` is not followed by an item")]
+    ComptimeNotFollowedByAnItem,
+    #[error("`mut` cannot be applied to this item")]
+    MutableNotApplicable,
+    #[error("`comptime` cannot be applied to this item")]
+    ComptimeNotApplicable,
+    #[error("`unconstrained` cannot be applied to this item")]
+    UnconstrainedNotApplicable,
+    #[error("Expected an identifier or `(expression) after `$` for unquoting")]
+    ExpectedIdentifierOrLeftParenAfterDollar,
+    #[error("`&mut` can only be used with `self")]
+    RefMutCanOnlyBeUsedWithSelf,
+    #[error("Invalid pattern")]
+    InvalidPattern,
+    #[error("Documentation comment does not document anything")]
+    DocCommentDoesNotDocumentAnything,
+
+    #[error("Missing type for function parameter")]
+    MissingTypeForFunctionParameter,
+    #[error("Missing type for numeric generic")]
+    MissingTypeForNumericGeneric,
+    #[error("Expected a function body (`{{ ... }}`), not `;`")]
+    ExpectedFunctionBody,
+    #[error("Expected the global to have a value")]
+    GlobalWithoutValue,
+
+    #[error("Unexpected '{0}', expected a field name or number")]
     ExpectedFieldName(Token),
-    #[error("expected a pattern but found a type - {0}")]
+    #[error("Expected a pattern but found a type - {0}")]
     ExpectedPatternButFoundType(Token),
-    #[error("expected an identifier after .")]
-    ExpectedIdentifierAfterDot,
-    #[error("expected an identifier after ::")]
-    ExpectedIdentifierAfterColons,
-    #[error("expected {{ or -> after function parameters")]
-    ExpectedLeftBraceOrArrowAfterFunctionParameters,
-    #[error("expected {{ after if condition")]
-    ExpectedLeftBraceAfterIfCondition,
-    #[error("expected <, where or {{ after trait name")]
-    ExpectedLeftBracketOrWhereOrLeftBraceOrArrowAfterTraitName,
-    #[error("expected <, where or {{ after impl type")]
-    ExpectedLeftBracketOrWhereOrLeftBraceOrArrowAfterImplType,
-    #[error("expected <, where or {{ after trait impl for type")]
-    ExpectedLeftBracketOrWhereOrLeftBraceOrArrowAfterTraitImplForType,
-    #[error("expected ( or < after function name")]
-    ExpectedLeftParenOrLeftBracketAfterFunctionName,
     #[error("Expected a ; separating these two statements")]
     MissingSeparatingSemi,
     #[error("constrain keyword is deprecated")]
@@ -71,6 +97,17 @@ pub enum ParserErrorReason {
     AssociatedTypesNotAllowedInPaths,
     #[error("Associated types are not allowed on a method call")]
     AssociatedTypesNotAllowedInMethodCalls,
+    #[error("Empty trait alias")]
+    EmptyTraitAlias,
+    #[error(
+        "Wrong number of arguments for attribute `{}`. Expected {}, found {}",
+        name,
+        if min == max { min.to_string() } else { format!("between {} and {}", min, max) },
+        found
+    )]
+    WrongNumberOfAttributeArguments { name: String, min: usize, max: usize, found: usize },
+    #[error("The `deprecated` attribute expects a string argument")]
+    DeprecatedAttributeExpectsAStringArgument,
 }
 
 /// Represents a parsing error, or a parsing error in the making.
@@ -105,6 +142,20 @@ impl ParserError {
         }
     }
 
+    pub fn expected_token(token: Token, found: Token, span: Span) -> ParserError {
+        let mut error = ParserError::empty(found, span);
+        error.expected_tokens.insert(token);
+        error
+    }
+
+    pub fn expected_one_of_tokens(tokens: &[Token], found: Token, span: Span) -> ParserError {
+        let mut error = ParserError::empty(found, span);
+        for token in tokens {
+            error.expected_tokens.insert(token.clone());
+        }
+        error
+    }
+
     pub fn expected_label(label: ParsingRuleLabel, found: Token, span: Span) -> ParserError {
         let mut error = ParserError::empty(found, span);
         error.expected_labels.insert(label);
@@ -136,12 +187,17 @@ impl ParserError {
 
 impl std::fmt::Display for ParserError {
     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        let token_to_string = |token: &Token| match token {
+            Token::EOF => token.to_string(),
+            _ => format!("'{}'", token),
+        };
+
         let reason_str: String = if self.reason.is_none() {
             "".to_string()
         } else {
             format!("\nreason: {}", Diagnostic::from(self))
         };
-        let mut expected = vecmap(&self.expected_tokens, ToString::to_string);
+        let mut expected = vecmap(&self.expected_tokens, token_to_string);
         expected.append(&mut vecmap(&self.expected_labels, |label| format!("{label}")));
 
         if expected.is_empty() {
@@ -154,7 +210,7 @@ impl std::fmt::Display for ParserError {
                 "Expected a{} {} but found {}{}",
                 if vowel { "n" } else { "" },
                 first,
-                self.found,
+                token_to_string(&self.found),
                 reason_str
             )
         } else {
@@ -206,11 +262,16 @@ impl<'a> From<&'a ParserError> for Diagnostic {
                     Diagnostic::simple_warning(reason.to_string(), "".into(), error.span)
                 }
                 ParserErrorReason::ExpectedPatternButFoundType(ty) => Diagnostic::simple_error(
-                    "Expected a ; separating these two statements".into(),
+                    format!("Expected a pattern but found a type - {ty}"),
                     format!("{ty} is a type and cannot be used as a variable name"),
                     error.span,
                 ),
                 ParserErrorReason::Lexer(error) => error.into(),
+                ParserErrorReason::ExpectedMutAfterAmpersand { found } => Diagnostic::simple_error(
+                    format!("Expected `mut` after `&`, found `{found}`"),
+                    "Noir doesn't have immutable references, only mutable references".to_string(),
+                    error.span,
+                ),
                 other => Diagnostic::simple_error(format!("{other}"), String::new(), error.span),
             },
             None => {
@@ -229,45 +290,3 @@ impl<'a> From<&'a ParserError> for Diagnostic {
         }
     }
 }
-
-impl chumsky::Error<Token> for ParserError {
-    type Span = Span;
-    type Label = ParsingRuleLabel;
-
-    fn expected_input_found<Iter>(span: Self::Span, expected: Iter, found: Option<Token>) -> Self
-    where
-        Iter: IntoIterator<Item = Option<Token>>,
-    {
-        ParserError {
-            expected_tokens: expected.into_iter().map(|opt| opt.unwrap_or(Token::EOF)).collect(),
-            expected_labels: SmallOrdSet::new(),
-            found: found.unwrap_or(Token::EOF),
-            reason: None,
-            span,
-        }
-    }
-
-    fn with_label(mut self, label: Self::Label) -> Self {
-        self.expected_tokens.clear();
-        self.expected_labels.clear();
-        self.expected_labels.insert(label);
-        self
-    }
-
-    // Merge two errors into a new one that should encompass both.
-    // If one error has a more specific reason with it then keep
-    // that reason and discard the other if present.
-    // The spans of both errors must match, otherwise the error
-    // messages and error spans may not line up.
-    fn merge(mut self, mut other: Self) -> Self {
-        self.expected_tokens.append(&mut other.expected_tokens);
-        self.expected_labels.append(&mut other.expected_labels);
-
-        if self.reason.is_none() {
-            self.reason = other.reason;
-        }
-
-        self.span = self.span.merge(other.span);
-        self
-    }
-}
diff --git a/compiler/noirc_frontend/src/parser/labels.rs b/compiler/noirc_frontend/src/parser/labels.rs
index fd082dfbe56..604c87801f8 100644
--- a/compiler/noirc_frontend/src/parser/labels.rs
+++ b/compiler/noirc_frontend/src/parser/labels.rs
@@ -11,14 +11,27 @@ pub enum ParsingRuleLabel {
     Cast,
     Expression,
     FieldAccess,
+    Function,
+    GenericParameter,
     Global,
+    Identifier,
+    Integer,
     IntegerType,
+    Item,
+    LValue,
     Parameter,
+    Path,
     Pattern,
     Statement,
     Term,
+    TraitBound,
+    TraitImplItem,
+    TraitItem,
+    Type,
     TypeExpression,
+    TypeOrTypeExpression,
     TokenKind(TokenKind),
+    UseSegment,
 }
 
 impl fmt::Display for ParsingRuleLabel {
@@ -29,14 +42,27 @@ impl fmt::Display for ParsingRuleLabel {
             ParsingRuleLabel::Cast => write!(f, "cast"),
             ParsingRuleLabel::Expression => write!(f, "expression"),
             ParsingRuleLabel::FieldAccess => write!(f, "field access"),
+            ParsingRuleLabel::Function => write!(f, "function"),
+            ParsingRuleLabel::GenericParameter => write!(f, "generic parameter"),
             ParsingRuleLabel::Global => write!(f, "global"),
+            ParsingRuleLabel::Identifier => write!(f, "identifier"),
+            ParsingRuleLabel::Integer => write!(f, "integer"),
             ParsingRuleLabel::IntegerType => write!(f, "integer type"),
+            ParsingRuleLabel::Item => write!(f, "item"),
+            ParsingRuleLabel::LValue => write!(f, "left-hand side of assignment"),
             ParsingRuleLabel::Parameter => write!(f, "parameter"),
+            ParsingRuleLabel::Path => write!(f, "path"),
             ParsingRuleLabel::Pattern => write!(f, "pattern"),
             ParsingRuleLabel::Statement => write!(f, "statement"),
             ParsingRuleLabel::Term => write!(f, "term"),
+            ParsingRuleLabel::TraitBound => write!(f, "trait bound"),
+            ParsingRuleLabel::TraitImplItem => write!(f, "trait impl item"),
+            ParsingRuleLabel::TraitItem => write!(f, "trait item"),
+            ParsingRuleLabel::Type => write!(f, "type"),
             ParsingRuleLabel::TypeExpression => write!(f, "type expression"),
-            ParsingRuleLabel::TokenKind(token_kind) => write!(f, "{token_kind:?}"),
+            ParsingRuleLabel::TypeOrTypeExpression => write!(f, "type or type expression"),
+            ParsingRuleLabel::TokenKind(token_kind) => write!(f, "{token_kind}"),
+            ParsingRuleLabel::UseSegment => write!(f, "identifier, `crate`, `dep` or `super`"),
         }
     }
 }
diff --git a/compiler/noirc_frontend/src/parser/mod.rs b/compiler/noirc_frontend/src/parser/mod.rs
index ad6dd1459e9..17c156476a7 100644
--- a/compiler/noirc_frontend/src/parser/mod.rs
+++ b/compiler/noirc_frontend/src/parser/mod.rs
@@ -12,233 +12,15 @@ mod labels;
 mod parser;
 
 use crate::ast::{
-    Documented, Expression, Ident, ImportStatement, ItemVisibility, LetStatement,
-    ModuleDeclaration, NoirFunction, NoirStruct, NoirTrait, NoirTraitImpl, NoirTypeAlias,
-    Recoverable, StatementKind, TypeImpl, UseTree,
+    Documented, Ident, ImportStatement, ItemVisibility, LetStatement, ModuleDeclaration,
+    NoirFunction, NoirStruct, NoirTrait, NoirTraitImpl, NoirTypeAlias, TypeImpl, UseTree,
 };
-use crate::token::{Keyword, SecondaryAttribute, Token};
+use crate::token::SecondaryAttribute;
 
-use chumsky::prelude::*;
-use chumsky::primitive::Container;
 pub use errors::ParserError;
 pub use errors::ParserErrorReason;
 use noirc_errors::Span;
-pub use parser::path::path_no_turbofish;
-pub use parser::traits::trait_bound;
-pub use parser::{
-    block, expression, fresh_statement, lvalue, module, parse_program, parse_type, pattern,
-    top_level_items, top_level_statement, visibility,
-};
-
-#[derive(Debug, Clone)]
-pub struct TopLevelStatement {
-    pub kind: TopLevelStatementKind,
-    pub doc_comments: Vec<String>,
-}
-
-#[derive(Debug, Clone)]
-pub enum TopLevelStatementKind {
-    Function(NoirFunction),
-    Module(ModuleDeclaration),
-    Import(UseTree, ItemVisibility),
-    Struct(NoirStruct),
-    Trait(NoirTrait),
-    TraitImpl(NoirTraitImpl),
-    Impl(TypeImpl),
-    TypeAlias(NoirTypeAlias),
-    SubModule(ParsedSubModule),
-    Global(LetStatement, ItemVisibility),
-    InnerAttribute(SecondaryAttribute),
-    Error,
-}
-
-impl TopLevelStatementKind {
-    pub fn into_item_kind(self) -> Option<ItemKind> {
-        match self {
-            TopLevelStatementKind::Function(f) => Some(ItemKind::Function(f)),
-            TopLevelStatementKind::Module(m) => Some(ItemKind::ModuleDecl(m)),
-            TopLevelStatementKind::Import(i, visibility) => Some(ItemKind::Import(i, visibility)),
-            TopLevelStatementKind::Struct(s) => Some(ItemKind::Struct(s)),
-            TopLevelStatementKind::Trait(t) => Some(ItemKind::Trait(t)),
-            TopLevelStatementKind::TraitImpl(t) => Some(ItemKind::TraitImpl(t)),
-            TopLevelStatementKind::Impl(i) => Some(ItemKind::Impl(i)),
-            TopLevelStatementKind::TypeAlias(t) => Some(ItemKind::TypeAlias(t)),
-            TopLevelStatementKind::SubModule(s) => Some(ItemKind::Submodules(s)),
-            TopLevelStatementKind::Global(c, visibility) => Some(ItemKind::Global(c, visibility)),
-            TopLevelStatementKind::InnerAttribute(a) => Some(ItemKind::InnerAttribute(a)),
-            TopLevelStatementKind::Error => None,
-        }
-    }
-}
-
-// Helper trait that gives us simpler type signatures for return types:
-// e.g. impl Parser<T> versus impl Parser<Token, T, Error = Simple<Token>>
-pub trait NoirParser<T>: Parser<Token, T, Error = ParserError> + Sized + Clone {}
-impl<P, T> NoirParser<T> for P where P: Parser<Token, T, Error = ParserError> + Clone {}
-
-// ExprParser just serves as a type alias for NoirParser<Expression> + Clone
-pub trait ExprParser: NoirParser<Expression> {}
-impl<P> ExprParser for P where P: NoirParser<Expression> {}
-
-fn parenthesized<P, T>(parser: P) -> impl NoirParser<T>
-where
-    P: NoirParser<T>,
-    T: Recoverable,
-{
-    use Token::*;
-    parser.delimited_by(just(LeftParen), just(RightParen)).recover_with(nested_delimiters(
-        LeftParen,
-        RightParen,
-        [(LeftBracket, RightBracket)],
-        Recoverable::error,
-    ))
-}
-
-fn spanned<P, T>(parser: P) -> impl NoirParser<(T, Span)>
-where
-    P: NoirParser<T>,
-{
-    parser.map_with_span(|value, span| (value, span))
-}
-
-// Parse with the first parser, then continue by
-// repeating the second parser 0 or more times.
-// The passed in function is then used to combine the
-// results of both parsers along with their spans at
-// each step.
-fn foldl_with_span<P1, P2, T1, T2, F>(
-    first_parser: P1,
-    to_be_repeated: P2,
-    f: F,
-) -> impl NoirParser<T1>
-where
-    P1: NoirParser<T1>,
-    P2: NoirParser<T2>,
-    F: Fn(T1, T2, Span) -> T1 + Clone,
-{
-    spanned(first_parser)
-        .then(spanned(to_be_repeated).repeated())
-        .foldl(move |(a, a_span), (b, b_span)| {
-            let span = a_span.merge(b_span);
-            (f(a, b, span), span)
-        })
-        .map(|(value, _span)| value)
-}
-
-/// Sequence the two parsers.
-/// Fails if the first parser fails, otherwise forces
-/// the second parser to succeed while logging any errors.
-fn then_commit<'a, P1, P2, T1, T2>(
-    first_parser: P1,
-    second_parser: P2,
-) -> impl NoirParser<(T1, T2)> + 'a
-where
-    P1: NoirParser<T1> + 'a,
-    P2: NoirParser<T2> + 'a,
-    T2: Clone + Recoverable + 'a,
-{
-    let second_parser = skip_then_retry_until(second_parser)
-        .map_with_span(|option, span| option.unwrap_or_else(|| Recoverable::error(span)));
-
-    first_parser.then(second_parser)
-}
-
-fn then_commit_ignore<'a, P1, P2, T1, T2>(
-    first_parser: P1,
-    second_parser: P2,
-) -> impl NoirParser<T1> + 'a
-where
-    P1: NoirParser<T1> + 'a,
-    P2: NoirParser<T2> + 'a,
-    T1: 'a,
-    T2: Clone + 'a,
-{
-    let second_parser = skip_then_retry_until(second_parser);
-    first_parser.then_ignore(second_parser)
-}
-
-fn ignore_then_commit<'a, P1, P2, T1: 'a, T2: Clone + 'a>(
-    first_parser: P1,
-    second_parser: P2,
-) -> impl NoirParser<T2> + 'a
-where
-    P1: NoirParser<T1> + 'a,
-    P2: NoirParser<T2> + 'a,
-    T2: Recoverable,
-{
-    let second_parser = skip_then_retry_until(second_parser)
-        .map_with_span(|option, span| option.unwrap_or_else(|| Recoverable::error(span)));
-
-    first_parser.ignore_then(second_parser)
-}
-
-fn skip_then_retry_until<'a, P, T>(parser: P) -> impl NoirParser<Option<T>> + 'a
-where
-    P: NoirParser<T> + 'a,
-    T: Clone + 'a,
-{
-    let terminators = [
-        Token::EOF,
-        Token::Colon,
-        Token::Semicolon,
-        Token::RightBrace,
-        Token::Keyword(Keyword::Let),
-        Token::Keyword(Keyword::Constrain),
-    ];
-    force(parser.recover_with(chumsky::prelude::skip_then_retry_until(terminators)))
-}
-
-/// General recovery strategy: try to skip to the target token, failing if we encounter the
-/// 'too_far' token beforehand.
-///
-/// Expects all of `too_far` to be contained within `targets`
-fn try_skip_until<T, C1, C2>(targets: C1, too_far: C2) -> impl NoirParser<T>
-where
-    T: Recoverable + Clone,
-    C1: Container<Token> + Clone,
-    C2: Container<Token> + Clone,
-{
-    chumsky::prelude::none_of(targets)
-        .repeated()
-        .ignore_then(one_of(too_far.clone()).rewind())
-        .try_map(move |peek, span| {
-            if too_far.get_iter().any(|t| t == peek) {
-                // This error will never be shown to the user
-                Err(ParserError::empty(Token::EOF, span))
-            } else {
-                Ok(Recoverable::error(span))
-            }
-        })
-}
-
-/// Recovery strategy for statements: If a statement fails to parse skip until the next ';' or fail
-/// if we find a '}' first.
-fn statement_recovery() -> impl NoirParser<StatementKind> {
-    use Token::*;
-    try_skip_until([Semicolon, RightBrace], RightBrace)
-}
-
-fn parameter_recovery<T: Recoverable + Clone>() -> impl NoirParser<T> {
-    use Token::*;
-    try_skip_until([Comma, RightParen], RightParen)
-}
-
-fn parameter_name_recovery<T: Recoverable + Clone>() -> impl NoirParser<T> {
-    use Token::*;
-    try_skip_until([Colon, RightParen, Comma], [RightParen, Comma])
-}
-
-fn top_level_statement_recovery() -> impl NoirParser<TopLevelStatementKind> {
-    none_of([Token::RightBrace, Token::EOF])
-        .repeated()
-        .ignore_then(one_of([Token::Semicolon]))
-        .map(|_| TopLevelStatementKind::Error)
-}
-
-/// Force the given parser to succeed, logging any errors it had
-fn force<'a, T: 'a>(parser: impl NoirParser<T> + 'a) -> impl NoirParser<Option<T>> + 'a {
-    parser.map(Some).recover_via(empty().map(|_| None))
-}
+pub use parser::{parse_program, Parser, StatementOrExpressionOrLValue};
 
 #[derive(Clone, Default)]
 pub struct SortedModule {
@@ -362,6 +144,35 @@ pub enum ItemKind {
     InnerAttribute(SecondaryAttribute),
 }
 
+impl std::fmt::Display for ItemKind {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        match self {
+            ItemKind::Function(fun) => fun.fmt(f),
+            ItemKind::ModuleDecl(m) => m.fmt(f),
+            ItemKind::Import(tree, visibility) => {
+                if visibility == &ItemVisibility::Private {
+                    write!(f, "use {tree}")
+                } else {
+                    write!(f, "{visibility} use {tree}")
+                }
+            }
+            ItemKind::Trait(t) => t.fmt(f),
+            ItemKind::TraitImpl(i) => i.fmt(f),
+            ItemKind::Struct(s) => s.fmt(f),
+            ItemKind::Impl(i) => i.fmt(f),
+            ItemKind::TypeAlias(t) => t.fmt(f),
+            ItemKind::Submodules(s) => s.fmt(f),
+            ItemKind::Global(c, visibility) => {
+                if visibility != &ItemVisibility::Private {
+                    write!(f, "{visibility} ")?;
+                }
+                c.fmt(f)
+            }
+            ItemKind::InnerAttribute(a) => write!(f, "#![{}]", a),
+        }
+    }
+}
+
 /// A submodule defined via `mod name { contents }` in some larger file.
 /// These submodules always share the same file as some larger ParsedModule
 #[derive(Clone, Debug)]
@@ -453,112 +264,6 @@ impl SortedModule {
     }
 }
 
-#[derive(Debug, Copy, Clone, PartialEq, Eq, PartialOrd)]
-pub enum Precedence {
-    Lowest,
-    Or,
-    And,
-    Xor,
-    LessGreater,
-    Shift,
-    Sum,
-    Product,
-    Highest,
-}
-
-impl Precedence {
-    // Higher the number, the higher(more priority) the precedence
-    // XXX: Check the precedence is correct for operators
-    fn token_precedence(tok: &Token) -> Option<Precedence> {
-        let precedence = match tok {
-            Token::Equal => Precedence::Lowest,
-            Token::NotEqual => Precedence::Lowest,
-            Token::Pipe => Precedence::Or,
-            Token::Ampersand => Precedence::And,
-            Token::Caret => Precedence::Xor,
-            Token::Less => Precedence::LessGreater,
-            Token::LessEqual => Precedence::LessGreater,
-            Token::Greater => Precedence::LessGreater,
-            Token::GreaterEqual => Precedence::LessGreater,
-            Token::ShiftLeft => Precedence::Shift,
-            Token::ShiftRight => Precedence::Shift,
-            Token::Plus => Precedence::Sum,
-            Token::Minus => Precedence::Sum,
-            Token::Slash => Precedence::Product,
-            Token::Star => Precedence::Product,
-            Token::Percent => Precedence::Product,
-            _ => return None,
-        };
-
-        assert_ne!(precedence, Precedence::Highest, "expression_with_precedence in the parser currently relies on the highest precedence level being uninhabited");
-        Some(precedence)
-    }
-
-    /// Return the next higher precedence. E.g. `Sum.next() == Product`
-    fn next(self) -> Self {
-        use Precedence::*;
-        match self {
-            Lowest => Or,
-            Or => Xor,
-            Xor => And,
-            And => LessGreater,
-            LessGreater => Shift,
-            Shift => Sum,
-            Sum => Product,
-            Product => Highest,
-            Highest => Highest,
-        }
-    }
-
-    /// TypeExpressions only contain basic arithmetic operators and
-    /// notably exclude `>` due to parsing conflicts with generic type brackets.
-    fn next_type_precedence(self) -> Self {
-        use Precedence::*;
-        match self {
-            Lowest => Sum,
-            Sum => Product,
-            Product => Highest,
-            Highest => Highest,
-            other => unreachable!("Unexpected precedence level in type expression: {:?}", other),
-        }
-    }
-
-    /// The operators with the lowest precedence still useable in type expressions
-    /// are '+' and '-' with precedence Sum.
-    fn lowest_type_precedence() -> Self {
-        Precedence::Sum
-    }
-}
-
-impl std::fmt::Display for TopLevelStatementKind {
-    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
-        match self {
-            TopLevelStatementKind::Function(fun) => fun.fmt(f),
-            TopLevelStatementKind::Module(m) => m.fmt(f),
-            TopLevelStatementKind::Import(tree, visibility) => {
-                if visibility != &ItemVisibility::Private {
-                    write!(f, "{visibility} ")?;
-                }
-                write!(f, "use {tree}")
-            }
-            TopLevelStatementKind::Trait(t) => t.fmt(f),
-            TopLevelStatementKind::TraitImpl(i) => i.fmt(f),
-            TopLevelStatementKind::Struct(s) => s.fmt(f),
-            TopLevelStatementKind::Impl(i) => i.fmt(f),
-            TopLevelStatementKind::TypeAlias(t) => t.fmt(f),
-            TopLevelStatementKind::SubModule(s) => s.fmt(f),
-            TopLevelStatementKind::Global(c, visibility) => {
-                if visibility != &ItemVisibility::Private {
-                    write!(f, "{visibility} ")?;
-                }
-                c.fmt(f)
-            }
-            TopLevelStatementKind::InnerAttribute(a) => write!(f, "#![{}]", a),
-            TopLevelStatementKind::Error => write!(f, "error"),
-        }
-    }
-}
-
 impl std::fmt::Display for ParsedModule {
     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
         self.clone().into_sorted().fmt(f)
diff --git a/compiler/noirc_frontend/src/parser/parser.rs b/compiler/noirc_frontend/src/parser/parser.rs
index df656dc5a7d..fcc58c5d833 100644
--- a/compiler/noirc_frontend/src/parser/parser.rs
+++ b/compiler/noirc_frontend/src/parser/parser.rs
@@ -1,88 +1,44 @@
-//! This file contains the bulk of the implementation of noir's parser.
-//!
-//! Noir's parser is built off the [chumsky library](https://docs.rs/chumsky/latest/chumsky/)
-//! for parser combinators. In this technique, parsers are built from smaller parsers that
-//! parse e.g. only a single token. Then there are functions which can combine multiple
-//! parsers together to create a larger one. These functions are called parser combinators.
-//! For example, `a.then(b)` combines two parsers a and b and returns one that parses a
-//! then parses b and fails if either fails. Other combinators like `a.or(b)` exist as well
-//! and are used extensively. Note that these form a PEG grammar so if there are multiple
-//! options as in `a.or(b)` the first matching parse will be chosen.
-//!
-//! Noir's grammar is not formally specified but can be estimated by inspecting each function.
-//! For example, a function `f` parsing `choice((a, b, c))` can be roughly translated to
-//! BNF as `f: a | b | c`.
-//!
-//! Occasionally there will also be recovery strategies present, either via `recover_via(Parser)`
-//! or `recover_with(Strategy)`. The difference between the two functions isn't quite so important,
-//! but both allow the parser to recover from a parsing error, log the error, and return an error
-//! expression instead. These are used to parse cases such as `fn foo( { }` where we know the user
-//! meant to write a function and thus we should log the error and return a function with no parameters,
-//! rather than failing to parse a function and trying to subsequently parse a struct. Generally using
-//! recovery strategies improves parser errors but using them incorrectly can be problematic since they
-//! prevent other parsers from being tried afterward since there is no longer an error. Thus, they should
-//! be limited to cases like the above `fn` example where it is clear we shouldn't back out of the
-//! current parser to try alternative parsers in a `choice` expression.
-use self::path::{as_trait_path, type_path};
-use self::primitives::{
-    interned_statement, interned_statement_expr, keyword, macro_quote_marker, mutable_reference,
-    variable,
+use acvm::FieldElement;
+use modifiers::Modifiers;
+use noirc_errors::Span;
+
+use crate::{
+    ast::{Ident, ItemVisibility},
+    lexer::{Lexer, SpannedTokenResult},
+    token::{FmtStrFragment, IntType, Keyword, SpannedToken, Token, TokenKind, Tokens},
 };
-use self::types::{generic_type_args, maybe_comp_time};
-use attributes::{attributes, inner_attribute, validate_secondary_attributes};
-use doc_comments::{inner_doc_comments, outer_doc_comments};
-use types::interned_unresolved_type;
-pub use types::parse_type;
-use visibility::item_visibility;
-pub use visibility::visibility;
-
-use super::{
-    foldl_with_span, labels::ParsingRuleLabel, parameter_name_recovery, parameter_recovery,
-    parenthesized, then_commit, then_commit_ignore, top_level_statement_recovery, ExprParser,
-    NoirParser, ParsedModule, ParsedSubModule, ParserError, ParserErrorReason, Precedence,
-    TopLevelStatementKind,
-};
-use super::{spanned, Item, TopLevelStatement};
-use crate::ast::{
-    BinaryOp, BinaryOpKind, BlockExpression, Documented, ForLoopStatement, ForRange,
-    GenericTypeArgs, Ident, IfExpression, InfixExpression, LValue, Literal, ModuleDeclaration,
-    NoirTypeAlias, Param, Path, Pattern, Recoverable, Statement, TypeImpl, UnaryRhsMemberAccess,
-    UnaryRhsMethodCall, UseTree, UseTreeKind, Visibility,
-};
-use crate::ast::{
-    Expression, ExpressionKind, LetStatement, StatementKind, UnresolvedType, UnresolvedTypeData,
-};
-use crate::lexer::Lexer;
-use crate::parser::{force, ignore_then_commit, statement_recovery};
-use crate::token::{Keyword, Token, TokenKind};
-use acvm::AcirField;
 
-use chumsky::prelude::*;
-use iter_extended::vecmap;
-use noirc_errors::{Span, Spanned};
+use super::{labels::ParsingRuleLabel, ParsedModule, ParserError, ParserErrorReason};
 
-mod assertion;
+mod arguments;
 mod attributes;
 mod doc_comments;
+mod expression;
 mod function;
-mod lambdas;
-mod literals;
-pub(super) mod path;
-mod primitives;
+mod generics;
+mod global;
+mod impls;
+mod infix;
+mod item;
+mod item_visibility;
+mod lambda;
+mod modifiers;
+mod module;
+mod parse_many;
+mod path;
+mod pattern;
+mod statement;
+mod statement_or_expression_or_lvalue;
 mod structs;
-pub(super) mod traits;
+mod tests;
+mod traits;
+mod type_alias;
+mod type_expression;
 mod types;
-mod visibility;
+mod use_tree;
+mod where_clause;
 
-#[cfg(test)]
-mod test_helpers;
-
-use literals::literal;
-use path::{maybe_empty_path, path};
-use primitives::{
-    dereference, ident, interned_expr, negation, not, nothing, right_shift_operator, token_kind,
-};
-use traits::where_clause;
+pub use statement_or_expression_or_lvalue::StatementOrExpressionOrLValue;
 
 /// Entry function for the parser - also handles lexing internally.
 ///
@@ -91,1752 +47,522 @@ use traits::where_clause;
 /// Vec is non-empty, there may be Error nodes in the Ast to fill in the gaps that
 /// failed to parse. Otherwise the Ast is guaranteed to have 0 Error nodes.
 pub fn parse_program(source_program: &str) -> (ParsedModule, Vec<ParserError>) {
-    let (tokens, lexing_errors) = Lexer::lex(source_program);
-    let (module, mut parsing_errors) = program().parse_recovery_verbose(tokens);
-
-    parsing_errors.extend(lexing_errors.into_iter().map(Into::into));
-    let parsed_module = module.unwrap_or_default();
-
-    (parsed_module, parsing_errors)
-}
-
-/// program: module EOF
-fn program() -> impl NoirParser<ParsedModule> {
-    module().then_ignore(just(Token::EOF))
-}
-
-/// module: top_level_statement module
-///       | %empty
-pub fn module() -> impl NoirParser<ParsedModule> {
-    recursive(|module_parser| {
-        inner_doc_comments()
-            .then(
-                empty()
-                    .to(ParsedModule::default())
-                    .then(spanned(top_level_statement(module_parser)).repeated())
-                    .foldl(|mut program, (statement, span)| {
-                        if let Some(kind) = statement.kind.into_item_kind() {
-                            program.items.push(Item {
-                                kind,
-                                span,
-                                doc_comments: statement.doc_comments,
-                            });
-                        }
-                        program
-                    }),
-            )
-            .map(|(doc_comments, mut program)| {
-                program.inner_doc_comments = doc_comments;
-                program
-            })
-    })
-}
-
-/// This parser is used for parsing top level statements in macros
-pub fn top_level_items() -> impl NoirParser<Vec<TopLevelStatement>> {
-    top_level_statement(module()).repeated()
-}
-
-pub fn top_level_statement<'a>(
-    module_parser: impl NoirParser<ParsedModule> + 'a,
-) -> impl NoirParser<TopLevelStatement> + 'a {
-    outer_doc_comments()
-        .then(top_level_statement_kind(module_parser))
-        .map(|(doc_comments, kind)| TopLevelStatement { kind, doc_comments })
-}
-
-/// top_level_statement: function_definition
-///                    | struct_definition
-///                    | trait_definition
-///                    | implementation
-///                    | submodule
-///                    | module_declaration
-///                    | use_statement
-///                    | global_declaration
-fn top_level_statement_kind<'a>(
-    module_parser: impl NoirParser<ParsedModule> + 'a,
-) -> impl NoirParser<TopLevelStatementKind> + 'a {
-    choice((
-        function::function_definition(false).map(TopLevelStatementKind::Function),
-        structs::struct_definition(),
-        traits::trait_definition(),
-        traits::trait_implementation(),
-        implementation(),
-        type_alias_definition().then_ignore(force(just(Token::Semicolon))),
-        submodule(module_parser.clone()),
-        contract(module_parser),
-        module_declaration().then_ignore(force(just(Token::Semicolon))),
-        use_statement().then_ignore(force(just(Token::Semicolon))),
-        global_declaration().then_ignore(force(just(Token::Semicolon))),
-        inner_attribute().map(TopLevelStatementKind::InnerAttribute),
-    ))
-    .recover_via(top_level_statement_recovery())
-}
-
-/// Parses a non-trait implementation, adding a set of methods to a type.
-///
-/// implementation: 'impl' generics type '{' function_definition ... '}'
-fn implementation() -> impl NoirParser<TopLevelStatementKind> {
-    let method = spanned(function::function_definition(true));
-    let methods = outer_doc_comments()
-        .then(method)
-        .map(|(doc_comments, (method, span))| (Documented::new(method, doc_comments), span))
-        .repeated();
-
-    let methods_or_error = just(Token::LeftBrace)
-        .ignore_then(methods)
-        .then_ignore(just(Token::RightBrace))
-        .or_not()
-        .validate(|methods, span, emit| {
-            if let Some(methods) = methods {
-                methods
-            } else {
-                emit(ParserError::with_reason(
-                    ParserErrorReason::ExpectedLeftBracketOrWhereOrLeftBraceOrArrowAfterImplType,
-                    span,
-                ));
-                vec![]
-            }
-        });
-
-    keyword(Keyword::Impl)
-        .ignore_then(function::generics())
-        .then(parse_type().map_with_span(|typ, span| (typ, span)))
-        .then(where_clause())
-        .then(methods_or_error)
-        .map(|args| {
-            let ((other_args, where_clause), methods) = args;
-            let (generics, (object_type, type_span)) = other_args;
-            TopLevelStatementKind::Impl(TypeImpl {
-                generics,
-                object_type,
-                type_span,
-                where_clause,
-                methods,
-            })
-        })
-}
-
-/// global_declaration: 'global' ident global_type_annotation '=' literal
-fn global_declaration() -> impl NoirParser<TopLevelStatementKind> {
-    let p = attributes::attributes()
-        .then(item_visibility())
-        .then(maybe_comp_time())
-        .then(spanned(keyword(Keyword::Mut)).or_not())
-        .then_ignore(keyword(Keyword::Global).labelled(ParsingRuleLabel::Global))
-        .then(ident().map(Pattern::Identifier));
-
-    let p = then_commit(p, optional_type_annotation());
-    let p = then_commit_ignore(p, just(Token::Assign));
-    let p = then_commit(p, expression());
-    p.validate(
-        |((((((attributes, visibility), comptime), mutable), mut pattern), r#type), expression),
-         span,
-         emit| {
-            let global_attributes =
-                attributes::validate_secondary_attributes(attributes, span, emit);
-
-            // Only comptime globals are allowed to be mutable, but we always parse the `mut`
-            // and throw the error in name resolution.
-            if let Some((_, mut_span)) = mutable {
-                let span = mut_span.merge(pattern.span());
-                pattern = Pattern::Mutable(Box::new(pattern), span, false);
-            }
-            (
-                LetStatement {
-                    pattern,
-                    r#type,
-                    comptime,
-                    expression,
-                    attributes: global_attributes,
-                },
-                visibility,
-            )
-        },
-    )
-    .map(|(let_statement, visibility)| TopLevelStatementKind::Global(let_statement, visibility))
-}
-
-/// submodule: 'mod' ident '{' module '}'
-fn submodule(
-    module_parser: impl NoirParser<ParsedModule>,
-) -> impl NoirParser<TopLevelStatementKind> {
-    attributes()
-        .then(item_visibility())
-        .then_ignore(keyword(Keyword::Mod))
-        .then(ident())
-        .then_ignore(just(Token::LeftBrace))
-        .then(module_parser)
-        .then_ignore(just(Token::RightBrace))
-        .validate(|(((attributes, visibility), name), contents), span, emit| {
-            let attributes = validate_secondary_attributes(attributes, span, emit);
-            TopLevelStatementKind::SubModule(ParsedSubModule {
-                visibility,
-                name,
-                contents,
-                outer_attributes: attributes,
-                is_contract: false,
-            })
-        })
-}
-
-/// contract: 'contract' ident '{' module '}'
-fn contract(
-    module_parser: impl NoirParser<ParsedModule>,
-) -> impl NoirParser<TopLevelStatementKind> {
-    attributes()
-        .then(item_visibility())
-        .then_ignore(keyword(Keyword::Contract))
-        .then(ident())
-        .then_ignore(just(Token::LeftBrace))
-        .then(module_parser)
-        .then_ignore(just(Token::RightBrace))
-        .validate(|(((attributes, visibility), name), contents), span, emit| {
-            let attributes = validate_secondary_attributes(attributes, span, emit);
-            TopLevelStatementKind::SubModule(ParsedSubModule {
-                visibility,
-                name,
-                contents,
-                outer_attributes: attributes,
-                is_contract: true,
-            })
-        })
-}
-
-fn type_alias_definition() -> impl NoirParser<TopLevelStatementKind> {
-    use self::Keyword::Type;
-
-    item_visibility()
-        .then_ignore(keyword(Type))
-        .then(ident())
-        .then(function::generics())
-        .then_ignore(just(Token::Assign))
-        .then(parse_type())
-        .map_with_span(|(((visibility, name), generics), typ), span| {
-            TopLevelStatementKind::TypeAlias(NoirTypeAlias {
-                name,
-                generics,
-                typ,
-                visibility,
-                span,
-            })
-        })
-}
-
-fn self_parameter() -> impl NoirParser<Param> {
-    let mut_ref_pattern = just(Token::Ampersand).then_ignore(keyword(Keyword::Mut));
-    let mut_pattern = keyword(Keyword::Mut);
-
-    mut_ref_pattern
-        .or(mut_pattern)
-        .map_with_span(|token, span| (token, span))
-        .or_not()
-        .then(filter_map(move |span, found: Token| match found {
-            Token::Ident(ref word) if word == "self" => Ok(span),
-            _ => Err(ParserError::expected_label(ParsingRuleLabel::Parameter, found, span)),
-        }))
-        .map(|(pattern_keyword, ident_span)| {
-            let ident = Ident::new("self".to_string(), ident_span);
-            let path = Path::from_single("Self".to_owned(), ident_span);
-            let no_args = GenericTypeArgs::default();
-            let mut self_type =
-                UnresolvedTypeData::Named(path, no_args, true).with_span(ident_span);
-            let mut pattern = Pattern::Identifier(ident);
-
-            match pattern_keyword {
-                Some((Token::Ampersand, _)) => {
-                    self_type = UnresolvedTypeData::MutableReference(Box::new(self_type))
-                        .with_span(ident_span);
-                }
-                Some((Token::Keyword(_), span)) => {
-                    pattern = Pattern::Mutable(Box::new(pattern), span.merge(ident_span), true);
-                }
-                _ => (),
-            }
-
-            Param { span: pattern.span(), pattern, typ: self_type, visibility: Visibility::Private }
-        })
-}
-
-/// Function declaration parameters differ from other parameters in that parameter
-/// patterns are not allowed in declarations. All parameters must be identifiers.
-fn function_declaration_parameters() -> impl NoirParser<Vec<(Ident, UnresolvedType)>> {
-    let typ = parse_type().recover_via(parameter_recovery());
-    let typ = just(Token::Colon).ignore_then(typ);
-
-    let full_parameter = ident().recover_via(parameter_name_recovery()).then(typ);
-    let self_parameter = self_parameter().validate(|param, span, emit| {
-        match param.pattern {
-            Pattern::Identifier(ident) => (ident, param.typ),
-            other => {
-                emit(ParserError::with_reason(
-                    ParserErrorReason::PatternInTraitFunctionParameter,
-                    span,
-                ));
-                // into_ident panics on tuple or struct patterns but should be fine to call here
-                // since the `self` parser can only parse `self`, `mut self` or `&mut self`.
-                (other.into_ident(), param.typ)
+    let lexer = Lexer::new(source_program);
+    let mut parser = Parser::for_lexer(lexer);
+    let program = parser.parse_program();
+    let errors = parser.errors;
+    (program, errors)
+}
+
+enum TokenStream<'a> {
+    Lexer(Lexer<'a>),
+    Tokens(Tokens),
+}
+
+impl<'a> TokenStream<'a> {
+    fn next(&mut self) -> Option<SpannedTokenResult> {
+        match self {
+            TokenStream::Lexer(lexer) => lexer.next(),
+            TokenStream::Tokens(tokens) => {
+                // NOTE: `TokenStream::Tokens` is only created via `Parser::for_tokens(tokens)` which
+                // reverses `tokens`. That's why using `pop` here is fine (done for performance reasons).
+                tokens.0.pop().map(Ok)
             }
         }
-    });
-
-    let parameter = full_parameter.or(self_parameter);
-
-    parameter
-        .separated_by(just(Token::Comma))
-        .allow_trailing()
-        .labelled(ParsingRuleLabel::Parameter)
-}
-
-fn block_expr<'a>(
-    statement: impl NoirParser<StatementKind> + 'a,
-) -> impl NoirParser<Expression> + 'a {
-    block(statement).map(ExpressionKind::Block).map_with_span(Expression::new)
-}
-
-pub fn block<'a>(
-    statement: impl NoirParser<StatementKind> + 'a,
-) -> impl NoirParser<BlockExpression> + 'a {
-    use Token::*;
-
-    statement
-        .recover_via(statement_recovery())
-        .then(just(Semicolon).or_not().map_with_span(|s, span| (s, span)))
-        .map_with_span(|(kind, rest), span| (Statement { kind, span }, rest))
-        .repeated()
-        .validate(check_statements_require_semicolon)
-        .delimited_by(just(LeftBrace), just(RightBrace))
-        .recover_with(nested_delimiters(
-            LeftBrace,
-            RightBrace,
-            [(LeftParen, RightParen), (LeftBracket, RightBracket)],
-            |span| vec![Statement { kind: StatementKind::Error, span }],
-        ))
-        .map(|statements| BlockExpression { statements })
+    }
 }
 
-fn check_statements_require_semicolon(
-    statements: Vec<(Statement, (Option<Token>, Span))>,
-    _span: Span,
-    emit: &mut dyn FnMut(ParserError),
-) -> Vec<Statement> {
-    let last = statements.len().saturating_sub(1);
-    let iter = statements.into_iter().enumerate();
-    vecmap(iter, |(i, (statement, (semicolon, span)))| {
-        statement.add_semicolon(semicolon, span, i == last, emit)
-    })
-}
+pub struct Parser<'a> {
+    pub(crate) errors: Vec<ParserError>,
+    tokens: TokenStream<'a>,
 
-/// Parse an optional ': type'
-fn optional_type_annotation<'a>() -> impl NoirParser<UnresolvedType> + 'a {
-    ignore_then_commit(just(Token::Colon), parse_type()).or_not().map_with_span(|r#type, span| {
-        r#type.unwrap_or(UnresolvedTypeData::Unspecified.with_span(span))
-    })
+    // We always have one look-ahead token for these cases:
+    // - check if we get `&` or `&mut`
+    // - check if we get `>` or `>>`
+    token: SpannedToken,
+    next_token: SpannedToken,
+    current_token_span: Span,
+    previous_token_span: Span,
 }
 
-fn module_declaration() -> impl NoirParser<TopLevelStatementKind> {
-    attributes().then(item_visibility()).then_ignore(keyword(Keyword::Mod)).then(ident()).validate(
-        |((attributes, visibility), ident), span, emit| {
-            let attributes = validate_secondary_attributes(attributes, span, emit);
-            TopLevelStatementKind::Module(ModuleDeclaration {
-                visibility,
-                ident,
-                outer_attributes: attributes,
-            })
-        },
-    )
-}
+impl<'a> Parser<'a> {
+    pub fn for_lexer(lexer: Lexer<'a>) -> Self {
+        Self::new(TokenStream::Lexer(lexer))
+    }
 
-fn use_statement() -> impl NoirParser<TopLevelStatementKind> {
-    item_visibility()
-        .then_ignore(keyword(Keyword::Use))
-        .then(use_tree())
-        .map(|(visibility, use_tree)| TopLevelStatementKind::Import(use_tree, visibility))
-}
+    pub fn for_tokens(mut tokens: Tokens) -> Self {
+        tokens.0.reverse();
+        Self::new(TokenStream::Tokens(tokens))
+    }
 
-fn rename() -> impl NoirParser<Option<Ident>> {
-    ignore_then_commit(keyword(Keyword::As), ident()).or_not()
-}
+    pub fn for_str(str: &'a str) -> Self {
+        Self::for_lexer(Lexer::new(str))
+    }
 
-fn use_tree() -> impl NoirParser<UseTree> {
-    recursive(|use_tree| {
-        let simple = path::path_no_turbofish().then(rename()).map(|(mut prefix, alias)| {
-            let ident = prefix.pop().ident;
-            UseTree { prefix, kind: UseTreeKind::Path(ident, alias) }
-        });
-
-        let list = {
-            let prefix = maybe_empty_path().then_ignore(just(Token::DoubleColon));
-            let tree = use_tree
-                .separated_by(just(Token::Comma))
-                .allow_trailing()
-                .delimited_by(just(Token::LeftBrace), just(Token::RightBrace))
-                .map(UseTreeKind::List);
-
-            prefix.then(tree).map(|(prefix, kind)| UseTree { prefix, kind })
+    fn new(tokens: TokenStream<'a>) -> Self {
+        let mut parser = Self {
+            errors: Vec::new(),
+            tokens,
+            token: eof_spanned_token(),
+            next_token: eof_spanned_token(),
+            current_token_span: Default::default(),
+            previous_token_span: Default::default(),
         };
+        parser.read_two_first_tokens();
+        parser
+    }
 
-        choice((list, simple))
-    })
-}
-
-fn statement<'a, P, P2>(
-    expr_parser: P,
-    expr_no_constructors: P2,
-) -> impl NoirParser<StatementKind> + 'a
-where
-    P: ExprParser + 'a,
-    P2: ExprParser + 'a,
-{
-    recursive(|statement| {
-        choice((
-            assertion::constrain(expr_parser.clone()),
-            assertion::assertion(expr_parser.clone()),
-            declaration(expr_parser.clone()),
-            assignment(expr_parser.clone()),
-            if_statement(expr_no_constructors.clone(), statement.clone()),
-            block_statement(statement.clone()),
-            for_loop(expr_no_constructors.clone(), statement.clone()),
-            break_statement(),
-            continue_statement(),
-            return_statement(expr_parser.clone()),
-            comptime_statement(expr_parser.clone(), expr_no_constructors, statement),
-            interned_statement(),
-            expr_parser.map(StatementKind::Expression),
-        ))
-    })
-}
-
-pub fn fresh_statement() -> impl NoirParser<StatementKind> {
-    statement(expression(), expression_no_constructors(expression()))
-}
+    /// Program = Module
+    pub(crate) fn parse_program(&mut self) -> ParsedModule {
+        self.parse_module(
+            false, // nested
+        )
+    }
 
-fn break_statement() -> impl NoirParser<StatementKind> {
-    keyword(Keyword::Break).to(StatementKind::Break)
-}
+    /// Module = InnerDocComments Item*
+    pub(crate) fn parse_module(&mut self, nested: bool) -> ParsedModule {
+        let inner_doc_comments = self.parse_inner_doc_comments();
+        let items = self.parse_module_items(nested);
 
-fn continue_statement() -> impl NoirParser<StatementKind> {
-    keyword(Keyword::Continue).to(StatementKind::Continue)
-}
+        ParsedModule { items, inner_doc_comments }
+    }
 
-fn comptime_statement<'a, P1, P2, S>(
-    expr: P1,
-    expr_no_constructors: P2,
-    statement: S,
-) -> impl NoirParser<StatementKind> + 'a
-where
-    P1: ExprParser + 'a,
-    P2: ExprParser + 'a,
-    S: NoirParser<StatementKind> + 'a,
-{
-    let comptime_statement = choice((
-        declaration(expr),
-        for_loop(expr_no_constructors, statement.clone()),
-        block(statement).map_with_span(|block, span| {
-            StatementKind::Expression(Expression::new(ExpressionKind::Block(block), span))
-        }),
-    ))
-    .map_with_span(|kind, span| Box::new(Statement { kind, span }));
-
-    keyword(Keyword::Comptime).ignore_then(comptime_statement).map(StatementKind::Comptime)
-}
+    /// Invokes `parsing_function` (`parsing_function` must be some `parse_*` method of the parser)
+    /// and returns the result if the parser has no errors, and if the parser consumed all tokens.
+    /// Otherwise returns the list of errors.
+    pub fn parse_result<T, F>(mut self, parsing_function: F) -> Result<T, Vec<ParserError>>
+    where
+        F: FnOnce(&mut Parser<'a>) -> T,
+    {
+        let item = parsing_function(&mut self);
+        if !self.at_eof() {
+            self.expected_token(Token::EOF);
+            return Err(self.errors);
+        }
 
-/// Comptime in an expression position only accepts entire blocks
-fn comptime_expr<'a, S>(statement: S) -> impl NoirParser<ExpressionKind> + 'a
-where
-    S: NoirParser<StatementKind> + 'a,
-{
-    keyword(Keyword::Comptime)
-        .ignore_then(spanned(block(statement)))
-        .map(|(block, span)| ExpressionKind::Comptime(block, span))
-}
+        if self.errors.is_empty() {
+            Ok(item)
+        } else {
+            Err(self.errors)
+        }
+    }
 
-fn unsafe_expr<'a, S>(statement: S) -> impl NoirParser<ExpressionKind> + 'a
-where
-    S: NoirParser<StatementKind> + 'a,
-{
-    keyword(Keyword::Unsafe)
-        .ignore_then(spanned(block(statement)))
-        .map(|(block, span)| ExpressionKind::Unsafe(block, span))
-}
+    /// Invokes `parsing_function` (`parsing_function` must be some `parse_*` method of the parser)
+    /// and returns the result if the parser has no errors, and if the parser consumed all tokens.
+    /// Otherwise returns None.
+    pub fn parse_option<T, F>(self, parsing_function: F) -> Option<T>
+    where
+        F: FnOnce(&mut Parser<'a>) -> Option<T>,
+    {
+        match self.parse_result(parsing_function) {
+            Ok(item) => item,
+            Err(_) => None,
+        }
+    }
 
-fn let_statement<'a, P>(
-    expr_parser: P,
-) -> impl NoirParser<((Pattern, UnresolvedType), Expression)> + 'a
-where
-    P: ExprParser + 'a,
-{
-    let p =
-        ignore_then_commit(keyword(Keyword::Let).labelled(ParsingRuleLabel::Statement), pattern());
-    let p = p.then(optional_type_annotation());
-    let p = then_commit_ignore(p, just(Token::Assign));
-    then_commit(p, expr_parser)
-}
+    /// Bumps this parser by one token. Returns the token that was previously the "current" token.
+    fn bump(&mut self) -> SpannedToken {
+        self.previous_token_span = self.current_token_span;
+        let next_next_token = self.read_token_internal();
+        let next_token = std::mem::replace(&mut self.next_token, next_next_token);
+        let token = std::mem::replace(&mut self.token, next_token);
+        self.current_token_span = self.token.to_span();
+        token
+    }
 
-fn declaration<'a, P>(expr_parser: P) -> impl NoirParser<StatementKind> + 'a
-where
-    P: ExprParser + 'a,
-{
-    attributes().then(let_statement(expr_parser)).validate(
-        |(attributes, ((pattern, typ), expr)), span, emit| {
-            let attributes = attributes::validate_secondary_attributes(attributes, span, emit);
-            StatementKind::new_let(pattern, typ, expr, attributes)
-        },
-    )
-}
+    fn read_two_first_tokens(&mut self) {
+        self.token = self.read_token_internal();
+        self.current_token_span = self.token.to_span();
+        self.next_token = self.read_token_internal();
+    }
 
-pub fn pattern() -> impl NoirParser<Pattern> {
-    recursive(|pattern| {
-        let ident_pattern = ident().map(Pattern::Identifier).map_err(|mut error| {
-            if matches!(error.found(), Token::IntType(..)) {
-                error = ParserError::with_reason(
-                    ParserErrorReason::ExpectedPatternButFoundType(error.found().clone()),
-                    error.span(),
-                );
+    fn read_token_internal(&mut self) -> SpannedToken {
+        loop {
+            let token = self.tokens.next();
+            if let Some(token) = token {
+                match token {
+                    Ok(token) => return token,
+                    Err(lexer_error) => self.errors.push(lexer_error.into()),
+                }
+            } else {
+                return eof_spanned_token();
             }
+        }
+    }
 
-            error
-        });
-
-        let mut_pattern = keyword(Keyword::Mut)
-            .ignore_then(pattern.clone())
-            .map_with_span(|inner, span| Pattern::Mutable(Box::new(inner), span, false));
-
-        let short_field = ident().map(|name| (name.clone(), Pattern::Identifier(name)));
-        let long_field = ident().then_ignore(just(Token::Colon)).then(pattern.clone());
-
-        let struct_pattern_fields = long_field
-            .or(short_field)
-            .separated_by(just(Token::Comma))
-            .delimited_by(just(Token::LeftBrace), just(Token::RightBrace));
-
-        let struct_pattern = path(super::parse_type())
-            .then(struct_pattern_fields)
-            .map_with_span(|(typename, fields), span| Pattern::Struct(typename, fields, span));
-
-        let tuple_pattern = pattern
-            .separated_by(just(Token::Comma))
-            .delimited_by(just(Token::LeftParen), just(Token::RightParen))
-            .map_with_span(Pattern::Tuple);
-
-        let interned =
-            token_kind(TokenKind::InternedPattern).map_with_span(|token, span| match token {
-                Token::InternedPattern(id) => Pattern::Interned(id, span),
-                _ => unreachable!(
-                    "token_kind(InternedPattern) guarantees we parse an interned pattern"
-                ),
-            });
-
-        choice((mut_pattern, tuple_pattern, struct_pattern, ident_pattern, interned))
-    })
-    .labelled(ParsingRuleLabel::Pattern)
-}
-
-fn assignment<'a, P>(expr_parser: P) -> impl NoirParser<StatementKind> + 'a
-where
-    P: ExprParser + 'a,
-{
-    let fallible =
-        lvalue(expr_parser.clone()).then(assign_operator()).labelled(ParsingRuleLabel::Statement);
-
-    then_commit(fallible, expr_parser).map_with_span(
-        |((identifier, operator), expression), span| {
-            StatementKind::assign(identifier, operator, expression, span)
-        },
-    )
-}
-
-/// Parse an assignment operator `=` optionally prefixed by a binary operator for a combined
-/// assign statement shorthand. Notably, this must handle a few corner cases with how `>>` is
-/// lexed as two separate greater-than operators rather than a single right-shift.
-fn assign_operator() -> impl NoirParser<Token> {
-    let shorthand_operators = Token::assign_shorthand_operators();
-    // We need to explicitly check for right_shift here since it is actually
-    // two separate greater-than operators.
-    let shorthand_operators = right_shift_operator().or(one_of(shorthand_operators));
-    let shorthand_syntax = shorthand_operators.then_ignore(just(Token::Assign));
-
-    // Since >> is lexed as two separate "greater-than"s, >>= is lexed as > >=, so
-    // we need to account for that case here as well.
-    let right_shift_fix =
-        just(Token::Greater).then(just(Token::GreaterEqual)).to(Token::ShiftRight);
-
-    let shorthand_syntax = shorthand_syntax.or(right_shift_fix);
-    just(Token::Assign).or(shorthand_syntax)
-}
-
-enum LValueRhs {
-    MemberAccess(Ident, Span),
-    Index(Expression, Span),
-}
-
-pub fn lvalue<'a, P>(expr_parser: P) -> impl NoirParser<LValue> + 'a
-where
-    P: ExprParser + 'a,
-{
-    recursive(|lvalue| {
-        let l_ident = ident().map(LValue::Ident);
-
-        let dereferences = just(Token::Star)
-            .ignore_then(lvalue.clone())
-            .map_with_span(|lvalue, span| LValue::Dereference(Box::new(lvalue), span));
-
-        let parenthesized = lvalue.delimited_by(just(Token::LeftParen), just(Token::RightParen));
-
-        let interned =
-            token_kind(TokenKind::InternedLValue).map_with_span(|token, span| match token {
-                Token::InternedLValue(id) => LValue::Interned(id, span),
-                _ => unreachable!(
-                    "token_kind(InternedLValue) guarantees we parse an interned lvalue"
-                ),
-            });
-
-        let term = choice((parenthesized, dereferences, l_ident, interned));
-
-        let l_member_rhs =
-            just(Token::Dot).ignore_then(field_name()).map_with_span(LValueRhs::MemberAccess);
-
-        let l_index = expr_parser
-            .delimited_by(just(Token::LeftBracket), just(Token::RightBracket))
-            .map_with_span(LValueRhs::Index);
+    fn eat_kind(&mut self, kind: TokenKind) -> Option<SpannedToken> {
+        if self.token.kind() == kind {
+            Some(self.bump())
+        } else {
+            None
+        }
+    }
 
-        term.then(l_member_rhs.or(l_index).repeated()).foldl(|lvalue, rhs| match rhs {
-            LValueRhs::MemberAccess(field_name, span) => {
-                let span = lvalue.span().merge(span);
-                LValue::MemberAccess { object: Box::new(lvalue), field_name, span }
-            }
-            LValueRhs::Index(index, span) => {
-                let span = lvalue.span().merge(span);
-                LValue::Index { array: Box::new(lvalue), index, span }
+    fn eat_keyword(&mut self, keyword: Keyword) -> bool {
+        if let Token::Keyword(kw) = self.token.token() {
+            if *kw == keyword {
+                self.bump();
+                true
+            } else {
+                false
             }
-        })
-    })
-}
+        } else {
+            false
+        }
+    }
 
-fn call_data() -> impl NoirParser<Visibility> {
-    keyword(Keyword::CallData).then(parenthesized(literal())).validate(|token, span, emit| {
-        match token {
-            (_, ExpressionKind::Literal(Literal::Integer(x, _))) => {
-                let id = x.to_u128() as u32;
-                Visibility::CallData(id)
-            }
-            _ => {
-                emit(ParserError::with_reason(ParserErrorReason::InvalidCallDataIdentifier, span));
-                Visibility::CallData(0)
+    fn eat_ident(&mut self) -> Option<Ident> {
+        if let Some(token) = self.eat_kind(TokenKind::Ident) {
+            match token.into_token() {
+                Token::Ident(ident) => Some(Ident::new(ident, self.previous_token_span)),
+                _ => unreachable!(),
             }
+        } else {
+            None
         }
-    })
-}
-
-pub fn expression() -> impl ExprParser {
-    recursive(|expr| {
-        expression_with_precedence(
-            Precedence::Lowest,
-            expr.clone(),
-            expression_no_constructors(expr.clone()),
-            statement(expr.clone(), expression_no_constructors(expr)),
-            false,
-            true,
-        )
-    })
-    .labelled(ParsingRuleLabel::Expression)
-}
+    }
 
-fn expression_no_constructors<'a, P>(expr_parser: P) -> impl ExprParser + 'a
-where
-    P: ExprParser + 'a,
-{
-    recursive(|expr_no_constructors| {
-        expression_with_precedence(
-            Precedence::Lowest,
-            expr_parser.clone(),
-            expr_no_constructors.clone(),
-            statement(expr_parser, expr_no_constructors),
-            false,
-            false,
-        )
-    })
-    .labelled(ParsingRuleLabel::Expression)
-}
+    fn eat_self(&mut self) -> bool {
+        if let Token::Ident(ident) = self.token.token() {
+            if ident == "self" {
+                self.bump();
+                return true;
+            }
+        }
 
-fn return_statement<'a, P>(expr_parser: P) -> impl NoirParser<StatementKind> + 'a
-where
-    P: ExprParser + 'a,
-{
-    ignore_then_commit(keyword(Keyword::Return), expr_parser.or_not())
-        .validate(|_, span, emit| {
-            emit(ParserError::with_reason(ParserErrorReason::EarlyReturn, span));
-            StatementKind::Error
-        })
-        .labelled(ParsingRuleLabel::Statement)
-}
+        false
+    }
 
-// An expression is a single term followed by 0 or more (OP subexpression)*
-// where OP is an operator at the given precedence level and subexpression
-// is an expression at the current precedence level plus one.
-fn expression_with_precedence<'a, P, P2, S>(
-    precedence: Precedence,
-    expr_parser: P,
-    expr_no_constructors: P2,
-    statement: S,
-    // True if we should only parse the restricted subset of operators valid within type expressions
-    is_type_expression: bool,
-    // True if we should also parse constructors `Foo { field1: value1, ... }` as an expression.
-    // This is disabled when parsing the condition of an if statement due to a parsing conflict
-    // with `then` bodies containing only a single variable.
-    allow_constructors: bool,
-) -> impl NoirParser<Expression> + 'a
-where
-    P: ExprParser + 'a,
-    P2: ExprParser + 'a,
-    S: NoirParser<StatementKind> + 'a,
-{
-    if precedence == Precedence::Highest {
-        if is_type_expression {
-            type_expression_term(expr_parser).boxed().labelled(ParsingRuleLabel::Term)
+    fn eat_int_type(&mut self) -> Option<IntType> {
+        let is_int_type = matches!(self.token.token(), Token::IntType(..));
+        if is_int_type {
+            let token = self.bump();
+            match token.into_token() {
+                Token::IntType(int_type) => Some(int_type),
+                _ => unreachable!(),
+            }
         } else {
-            term(expr_parser, expr_no_constructors, statement, allow_constructors)
-                .boxed()
-                .labelled(ParsingRuleLabel::Term)
+            None
         }
-    } else {
-        let next_precedence =
-            if is_type_expression { precedence.next_type_precedence() } else { precedence.next() };
-
-        let next_expr = expression_with_precedence(
-            next_precedence,
-            expr_parser,
-            expr_no_constructors,
-            statement,
-            is_type_expression,
-            allow_constructors,
-        );
-
-        next_expr
-            .clone()
-            .then(then_commit(operator_with_precedence(precedence), next_expr).repeated())
-            .foldl(create_infix_expression)
-            .boxed()
-            .labelled(ParsingRuleLabel::Expression)
     }
-}
-
-fn create_infix_expression(lhs: Expression, (operator, rhs): (BinaryOp, Expression)) -> Expression {
-    let span = lhs.span.merge(rhs.span);
-    let infix = Box::new(InfixExpression { lhs, operator, rhs });
-
-    Expression { span, kind: ExpressionKind::Infix(infix) }
-}
 
-fn operator_with_precedence(precedence: Precedence) -> impl NoirParser<Spanned<BinaryOpKind>> {
-    right_shift_operator()
-        .or(any()) // Parse any single token, we're validating it as an operator next
-        .try_map(move |token, span| {
-            if Precedence::token_precedence(&token) == Some(precedence) {
-                Ok(token.try_into_binary_op(span).unwrap())
-            } else {
-                Err(ParserError::expected_label(ParsingRuleLabel::BinaryOperator, token, span))
+    fn eat_int(&mut self) -> Option<FieldElement> {
+        if matches!(self.token.token(), Token::Int(..)) {
+            let token = self.bump();
+            match token.into_token() {
+                Token::Int(int) => Some(int),
+                _ => unreachable!(),
             }
-        })
-}
-
-fn term<'a, P, P2, S>(
-    expr_parser: P,
-    expr_no_constructors: P2,
-    statement: S,
-    allow_constructors: bool,
-) -> impl NoirParser<Expression> + 'a
-where
-    P: ExprParser + 'a,
-    P2: ExprParser + 'a,
-    S: NoirParser<StatementKind> + 'a,
-{
-    recursive(move |term_parser| {
-        choice((
-            not(term_parser.clone()),
-            negation(term_parser.clone()),
-            mutable_reference(term_parser.clone()),
-            dereference(term_parser),
-        ))
-        .map_with_span(Expression::new)
-        // right-unary operators like a[0] or a.f bind more tightly than left-unary
-        // operators like  - or !, so that !a[0] is parsed as !(a[0]). This is a bit
-        // awkward for casts so -a as i32 actually binds as -(a as i32).
-        .or(atom_or_right_unary(
-            expr_parser,
-            expr_no_constructors,
-            statement,
-            allow_constructors,
-            parse_type(),
-        ))
-    })
-}
-
-/// The equivalent of a 'term' for use in type expressions. Unlike regular terms, the grammar here
-/// is restricted to no longer include right-unary expressions, unary not, and most atoms.
-fn type_expression_term<'a, P>(expr_parser: P) -> impl NoirParser<Expression> + 'a
-where
-    P: ExprParser + 'a,
-{
-    recursive(move |term_parser| {
-        negation(term_parser).map_with_span(Expression::new).or(type_expression_atom(expr_parser))
-    })
-}
+        } else {
+            None
+        }
+    }
 
-fn atom_or_right_unary<'a, P, P2, S>(
-    expr_parser: P,
-    expr_no_constructors: P2,
-    statement: S,
-    allow_constructors: bool,
-    type_parser: impl NoirParser<UnresolvedType> + 'a,
-) -> impl NoirParser<Expression> + 'a
-where
-    P: ExprParser + 'a,
-    P2: ExprParser + 'a,
-    S: NoirParser<StatementKind> + 'a,
-{
-    enum UnaryRhs {
-        Call((Option<Token>, Vec<Expression>)),
-        ArrayIndex(Expression),
-        Cast(UnresolvedType),
-        MemberAccess(UnaryRhsMemberAccess),
-        /// This is to allow `foo.` (no identifier afterwards) to be parsed as `foo`
-        /// and produce an error, rather than just erroring (for LSP).
-        JustADot,
-    }
-
-    // `(arg1, ..., argN)` in `my_func(arg1, ..., argN)`
-    // Optionally accepts a leading `!` for macro calls.
-    let call_rhs = just(Token::Bang)
-        .or_not()
-        .then(parenthesized(expression_list(expr_parser.clone())))
-        .map(UnaryRhs::Call);
-
-    // `[expr]` in `arr[expr]`
-    let array_rhs = expr_parser
-        .clone()
-        .delimited_by(just(Token::LeftBracket), just(Token::RightBracket))
-        .map(UnaryRhs::ArrayIndex);
-
-    // `as Type` in `atom as Type`
-    let cast_rhs = keyword(Keyword::As)
-        .ignore_then(type_parser.clone())
-        .map(UnaryRhs::Cast)
-        .labelled(ParsingRuleLabel::Cast);
-
-    // A turbofish operator is optional in a method call to specify generic types
-    let turbofish = primitives::turbofish(type_parser);
-
-    // `::<A, B>!(arg1, .., argN)` with the turbofish and macro portions being optional.
-    let method_call_rhs = turbofish
-        .then(just(Token::Bang).or_not())
-        .then(parenthesized(expression_list(expr_parser.clone())))
-        .validate(|((turbofish, macro_call), args), span, emit| {
-            if turbofish.as_ref().map_or(false, |generics| !generics.named_args.is_empty()) {
-                let reason = ParserErrorReason::AssociatedTypesNotAllowedInMethodCalls;
-                emit(ParserError::with_reason(reason, span));
+    fn eat_bool(&mut self) -> Option<bool> {
+        if matches!(self.token.token(), Token::Bool(..)) {
+            let token = self.bump();
+            match token.into_token() {
+                Token::Bool(bool) => Some(bool),
+                _ => unreachable!(),
             }
+        } else {
+            None
+        }
+    }
 
-            let macro_call = macro_call.is_some();
-            let turbofish = turbofish.map(|generics| generics.ordered_args);
-            UnaryRhsMethodCall { turbofish, macro_call, args }
-        });
-
-    // `.foo` or `.foo(args)` in `atom.foo` or `atom.foo(args)`
-    let member_rhs = just(Token::Dot)
-        .ignore_then(field_name())
-        .then(method_call_rhs.or_not())
-        .map(|(method_or_field, method_call)| {
-            UnaryRhs::MemberAccess(UnaryRhsMemberAccess { method_or_field, method_call })
-        })
-        .labelled(ParsingRuleLabel::FieldAccess);
-
-    let just_a_dot =
-        just(Token::Dot).map(|_| UnaryRhs::JustADot).validate(|value, span, emit_error| {
-            emit_error(ParserError::with_reason(
-                ParserErrorReason::ExpectedIdentifierAfterDot,
-                span,
-            ));
-            value
-        });
-
-    let rhs = choice((call_rhs, array_rhs, cast_rhs, member_rhs, just_a_dot));
-
-    foldl_with_span(
-        atom(expr_parser, expr_no_constructors, statement, allow_constructors),
-        rhs,
-        |lhs, rhs, span| match rhs {
-            UnaryRhs::Call((is_macro, args)) => {
-                Expression::call(lhs, is_macro.is_some(), args, span)
+    fn eat_str(&mut self) -> Option<String> {
+        if matches!(self.token.token(), Token::Str(..)) {
+            let token = self.bump();
+            match token.into_token() {
+                Token::Str(string) => Some(string),
+                _ => unreachable!(),
             }
-            UnaryRhs::ArrayIndex(index) => Expression::index(lhs, index, span),
-            UnaryRhs::Cast(r#type) => Expression::cast(lhs, r#type, span),
-            UnaryRhs::MemberAccess(field) => {
-                Expression::member_access_or_method_call(lhs, field, span)
-            }
-            UnaryRhs::JustADot => lhs,
-        },
-    )
-}
-
-fn if_expr<'a, P, S>(expr_no_constructors: P, statement: S) -> impl NoirParser<ExpressionKind> + 'a
-where
-    P: ExprParser + 'a,
-    S: NoirParser<StatementKind> + 'a,
-{
-    recursive(|if_parser| {
-        let if_block = block_expr(statement.clone());
-        // The else block could also be an `else if` block, in which case we must recursively parse it.
-        let else_block = block_expr(statement).or(if_parser.map_with_span(|kind, span| {
-            // Wrap the inner `if` expression in a block expression.
-            // i.e. rewrite the sugared form `if cond1 {} else if cond2 {}` as `if cond1 {} else { if cond2 {} }`.
-            let if_expression = Expression::new(kind, span);
-            let desugared_else = BlockExpression {
-                statements: vec![Statement {
-                    kind: StatementKind::Expression(if_expression),
-                    span,
-                }],
-            };
-            Expression::new(ExpressionKind::Block(desugared_else), span)
-        }));
-
-        keyword(Keyword::If)
-            .ignore_then(expr_no_constructors)
-            .then(if_block.then(keyword(Keyword::Else).ignore_then(else_block).or_not()).or_not())
-            .validate(|(condition, consequence_and_alternative), span, emit_error| {
-                if let Some((consequence, alternative)) = consequence_and_alternative {
-                    ExpressionKind::If(Box::new(IfExpression {
-                        condition,
-                        consequence,
-                        alternative,
-                    }))
-                } else {
-                    // We allow `if cond` without a block mainly for LSP, so that it parses right
-                    // and autocompletion works there.
-                    emit_error(ParserError::with_reason(
-                        ParserErrorReason::ExpectedLeftBraceAfterIfCondition,
-                        span,
-                    ));
-
-                    let span_end = condition.span.end();
-                    ExpressionKind::If(Box::new(IfExpression {
-                        condition,
-                        consequence: Expression::new(
-                            ExpressionKind::Error,
-                            Span::from(span_end..span_end),
-                        ),
-                        alternative: None,
-                    }))
-                }
-            })
-    })
-}
-
-fn if_statement<'a, P, S>(
-    expr_no_constructors: P,
-    statement: S,
-) -> impl NoirParser<StatementKind> + 'a
-where
-    P: ExprParser + 'a,
-    S: NoirParser<StatementKind> + 'a,
-{
-    if_expr(expr_no_constructors, statement).map_with_span(|expression_kind, span| {
-        StatementKind::Expression(Expression::new(expression_kind, span))
-    })
-}
-
-fn block_statement<'a, S>(statement: S) -> impl NoirParser<StatementKind> + 'a
-where
-    S: NoirParser<StatementKind> + 'a,
-{
-    block(statement).map_with_span(|block, span| {
-        StatementKind::Expression(Expression::new(ExpressionKind::Block(block), span))
-    })
-}
-
-fn for_loop<'a, P, S>(expr_no_constructors: P, statement: S) -> impl NoirParser<StatementKind> + 'a
-where
-    P: ExprParser + 'a,
-    S: NoirParser<StatementKind> + 'a,
-{
-    keyword(Keyword::For)
-        .ignore_then(ident())
-        .then_ignore(keyword(Keyword::In))
-        .then(for_range(expr_no_constructors))
-        .then(block_expr(statement))
-        .map_with_span(|((identifier, range), block), span| {
-            StatementKind::For(ForLoopStatement { identifier, range, block, span })
-        })
-}
-
-/// The 'range' of a for loop. Either an actual range `start .. end` or an array expression.
-fn for_range<P>(expr_no_constructors: P) -> impl NoirParser<ForRange>
-where
-    P: ExprParser,
-{
-    expr_no_constructors
-        .clone()
-        .then_ignore(just(Token::DoubleDot))
-        .then(expr_no_constructors.clone())
-        .map(|(start, end)| ForRange::Range(start, end))
-        .or(expr_no_constructors.map(ForRange::Array))
-}
-
-fn array_expr<P>(expr_parser: P) -> impl NoirParser<ExpressionKind>
-where
-    P: ExprParser,
-{
-    standard_array(expr_parser.clone()).or(array_sugar(expr_parser))
-}
-
-/// [a, b, c, ...]
-fn standard_array<P>(expr_parser: P) -> impl NoirParser<ExpressionKind>
-where
-    P: ExprParser,
-{
-    expression_list(expr_parser)
-        .delimited_by(just(Token::LeftBracket), just(Token::RightBracket))
-        .validate(|elements, _span, _emit| ExpressionKind::array(elements))
-}
-
-/// [a; N]
-fn array_sugar<P>(expr_parser: P) -> impl NoirParser<ExpressionKind>
-where
-    P: ExprParser,
-{
-    expr_parser
-        .clone()
-        .then(just(Token::Semicolon).ignore_then(expr_parser))
-        .delimited_by(just(Token::LeftBracket), just(Token::RightBracket))
-        .map(|(lhs, count)| ExpressionKind::repeated_array(lhs, count))
-}
-
-fn slice_expr<P>(expr_parser: P) -> impl NoirParser<ExpressionKind>
-where
-    P: ExprParser,
-{
-    just(Token::Ampersand)
-        .ignore_then(standard_slice(expr_parser.clone()).or(slice_sugar(expr_parser)))
-}
-
-/// &[a, b, c, ...]
-fn standard_slice<P>(expr_parser: P) -> impl NoirParser<ExpressionKind>
-where
-    P: ExprParser,
-{
-    expression_list(expr_parser)
-        .delimited_by(just(Token::LeftBracket), just(Token::RightBracket))
-        .validate(|elements, _span, _emit| ExpressionKind::slice(elements))
-}
+        } else {
+            None
+        }
+    }
 
-/// &[a; N]
-fn slice_sugar<P>(expr_parser: P) -> impl NoirParser<ExpressionKind>
-where
-    P: ExprParser,
-{
-    expr_parser
-        .clone()
-        .then(just(Token::Semicolon).ignore_then(expr_parser))
-        .delimited_by(just(Token::LeftBracket), just(Token::RightBracket))
-        .map(|(lhs, count)| ExpressionKind::repeated_slice(lhs, count))
-}
+    fn eat_raw_str(&mut self) -> Option<(String, u8)> {
+        if matches!(self.token.token(), Token::RawStr(..)) {
+            let token = self.bump();
+            match token.into_token() {
+                Token::RawStr(string, n) => Some((string, n)),
+                _ => unreachable!(),
+            }
+        } else {
+            None
+        }
+    }
 
-fn expression_list<P>(expr_parser: P) -> impl NoirParser<Vec<Expression>>
-where
-    P: ExprParser,
-{
-    expr_parser.separated_by(just(Token::Comma)).allow_trailing()
-}
+    fn eat_fmt_str(&mut self) -> Option<(Vec<FmtStrFragment>, u32)> {
+        if matches!(self.token.token(), Token::FmtStr(..)) {
+            let token = self.bump();
+            match token.into_token() {
+                Token::FmtStr(fragments, length) => Some((fragments, length)),
+                _ => unreachable!(),
+            }
+        } else {
+            None
+        }
+    }
 
-/// Atoms are parameterized on whether constructor expressions are allowed or not.
-/// Certain constructs like `if` and `for` disallow constructor expressions when a
-/// block may be expected.
-fn atom<'a, P, P2, S>(
-    expr_parser: P,
-    expr_no_constructors: P2,
-    statement: S,
-    allow_constructors: bool,
-) -> impl NoirParser<Expression> + 'a
-where
-    P: ExprParser + 'a,
-    P2: ExprParser + 'a,
-    S: NoirParser<StatementKind> + 'a,
-{
-    choice((
-        if_expr(expr_no_constructors, statement.clone()),
-        slice_expr(expr_parser.clone()),
-        array_expr(expr_parser.clone()),
-        if allow_constructors {
-            constructor(expr_parser.clone()).boxed()
+    fn eat_quote(&mut self) -> Option<Tokens> {
+        if matches!(self.token.token(), Token::Quote(..)) {
+            let token = self.bump();
+            match token.into_token() {
+                Token::Quote(tokens) => Some(tokens),
+                _ => unreachable!(),
+            }
         } else {
-            nothing().boxed()
-        },
-        lambdas::lambda(expr_parser.clone()),
-        block(statement.clone()).map(ExpressionKind::Block),
-        comptime_expr(statement.clone()),
-        unsafe_expr(statement),
-        quote(),
-        unquote(expr_parser.clone()),
-        variable(),
-        literal(),
-        as_trait_path(parse_type()).map(ExpressionKind::AsTraitPath),
-        type_path(parse_type()),
-        macro_quote_marker(),
-        interned_expr(),
-        interned_statement_expr(),
-    ))
-    .map_with_span(Expression::new)
-    .or(parenthesized(expr_parser.clone()).map_with_span(|sub_expr, span| {
-        Expression::new(ExpressionKind::Parenthesized(sub_expr.into()), span)
-    }))
-    .or(tuple(expr_parser))
-    .labelled(ParsingRuleLabel::Atom)
-}
+            None
+        }
+    }
 
-/// Atoms within type expressions are limited to only variables, literals, and parenthesized
-/// type expressions.
-fn type_expression_atom<'a, P>(expr_parser: P) -> impl NoirParser<Expression> + 'a
-where
-    P: ExprParser + 'a,
-{
-    primitives::variable_no_turbofish()
-        .or(literal())
-        .map_with_span(Expression::new)
-        .or(parenthesized(expr_parser))
-        .labelled(ParsingRuleLabel::Atom)
-}
+    fn eat_attribute_start(&mut self) -> Option<bool> {
+        if matches!(self.token.token(), Token::AttributeStart { is_inner: false, .. }) {
+            let token = self.bump();
+            match token.into_token() {
+                Token::AttributeStart { is_tag, .. } => Some(is_tag),
+                _ => unreachable!(),
+            }
+        } else {
+            None
+        }
+    }
 
-fn quote() -> impl NoirParser<ExpressionKind> {
-    token_kind(TokenKind::Quote).map(|token| {
-        ExpressionKind::Quote(match token {
-            Token::Quote(tokens) => tokens,
-            _ => unreachable!("token_kind(Quote) should guarantee parsing only a quote token"),
-        })
-    })
-}
+    fn eat_inner_attribute_start(&mut self) -> Option<bool> {
+        if matches!(self.token.token(), Token::AttributeStart { is_inner: true, .. }) {
+            let token = self.bump();
+            match token.into_token() {
+                Token::AttributeStart { is_tag, .. } => Some(is_tag),
+                _ => unreachable!(),
+            }
+        } else {
+            None
+        }
+    }
 
-/// unquote: '$' variable
-///        | '$' '(' expression ')'
-fn unquote<'a, P>(expr_parser: P) -> impl NoirParser<ExpressionKind> + 'a
-where
-    P: ExprParser + 'a,
-{
-    let unquote = variable().map_with_span(Expression::new).or(parenthesized(expr_parser));
-    just(Token::DollarSign).ignore_then(unquote).map(|expr| ExpressionKind::Unquote(Box::new(expr)))
-}
+    fn eat_comma(&mut self) -> bool {
+        self.eat(Token::Comma)
+    }
 
-fn tuple<P>(expr_parser: P) -> impl NoirParser<Expression>
-where
-    P: ExprParser,
-{
-    parenthesized(expression_list(expr_parser)).map_with_span(|elements, span| {
-        let kind = if elements.is_empty() {
-            ExpressionKind::Literal(Literal::Unit)
+    fn eat_commas(&mut self) -> bool {
+        if self.eat_comma() {
+            while self.eat_comma() {
+                self.push_error(ParserErrorReason::UnexpectedComma, self.previous_token_span);
+            }
+            true
         } else {
-            ExpressionKind::Tuple(elements)
-        };
-        Expression::new(kind, span)
-    })
-}
-
-fn field_name() -> impl NoirParser<Ident> {
-    ident().or(token_kind(TokenKind::Literal).validate(|token, span, emit| match token {
-        Token::Int(_) => Ident::from(Spanned::from(span, token.to_string())),
-        other => {
-            emit(ParserError::with_reason(ParserErrorReason::ExpectedFieldName(other), span));
-            Ident::error(span)
+            false
         }
-    }))
-}
-
-fn constructor(expr_parser: impl ExprParser) -> impl NoirParser<ExpressionKind> {
-    let args = constructor_field(expr_parser)
-        .separated_by(just(Token::Comma))
-        .allow_trailing()
-        .delimited_by(just(Token::LeftBrace), just(Token::RightBrace));
+    }
 
-    let path = path(super::parse_type()).map(UnresolvedType::from_path);
-    let interned_unresolved_type = interned_unresolved_type();
-    let typ = choice((path, interned_unresolved_type));
+    fn eat_semicolon(&mut self) -> bool {
+        self.eat(Token::Semicolon)
+    }
 
-    typ.then(args).map(ExpressionKind::constructor)
-}
+    fn eat_semicolons(&mut self) -> bool {
+        if self.eat_semicolon() {
+            while self.eat_semicolon() {
+                self.push_error(ParserErrorReason::UnexpectedSemicolon, self.previous_token_span);
+            }
+            true
+        } else {
+            false
+        }
+    }
 
-fn constructor_field<P>(expr_parser: P) -> impl NoirParser<(Ident, Expression)>
-where
-    P: ExprParser,
-{
-    let long_form = ident().then_ignore(just(Token::Colon)).then(expr_parser);
-    let short_form = ident().map(|ident| (ident.clone(), ident.into()));
-    long_form.or(short_form)
-}
+    fn eat_colon(&mut self) -> bool {
+        self.eat(Token::Colon)
+    }
 
-#[cfg(test)]
-mod test {
-    use super::test_helpers::*;
-    use super::*;
-    use crate::ast::ArrayLiteral;
-
-    #[test]
-    fn parse_infix() {
-        let valid = vec!["x + 6", "x - k", "x + (x + a)", " x * (x + a) + (x - 4)"];
-        parse_all(expression(), valid);
-        parse_all_failing(expression(), vec!["y ! x"]);
-    }
-
-    #[test]
-    fn parse_function_call() {
-        let valid = vec![
-            "std::hash ()",
-            " std::hash(x,y,a+b)",
-            "crate::foo (x)",
-            "hash (x,)",
-            "(foo + bar)()",
-            "(bar)()()()",
-        ];
-        parse_all(expression(), valid);
-    }
-
-    #[test]
-    fn parse_cast() {
-        let expression_nc = expression_no_constructors(expression());
-        parse_all(
-            atom_or_right_unary(
-                expression(),
-                expression_no_constructors(expression()),
-                fresh_statement(),
-                true,
-                parse_type(),
-            ),
-            vec!["x as u8", "x as u16", "0 as Field", "(x + 3) as [Field; 8]"],
-        );
-        parse_all_failing(
-            atom_or_right_unary(expression(), expression_nc, fresh_statement(), true, parse_type()),
-            vec!["x as pub u8"],
-        );
+    fn eat_double_colon(&mut self) -> bool {
+        self.eat(Token::DoubleColon)
     }
 
-    #[test]
-    fn parse_array_index() {
-        let valid = vec![
-            "x[9]",
-            "y[x+a]",
-            " foo [foo+5]",
-            "baz[bar]",
-            "foo.bar[3] as Field .baz as u32 [7]",
-        ];
-        parse_all(
-            atom_or_right_unary(
-                expression(),
-                expression_no_constructors(expression()),
-                fresh_statement(),
-                true,
-                parse_type(),
-            ),
-            valid,
-        );
+    fn eat_left_paren(&mut self) -> bool {
+        self.eat(Token::LeftParen)
     }
 
-    fn expr_to_array(expr: ExpressionKind) -> ArrayLiteral {
-        let lit = match expr {
-            ExpressionKind::Literal(literal) => literal,
-            _ => unreachable!("expected a literal"),
-        };
+    fn eat_right_paren(&mut self) -> bool {
+        self.eat(Token::RightParen)
+    }
 
-        match lit {
-            Literal::Array(arr) => arr,
-            _ => unreachable!("expected an array"),
-        }
+    fn eat_left_brace(&mut self) -> bool {
+        self.eat(Token::LeftBrace)
     }
 
-    #[test]
-    fn parse_array() {
-        let valid = vec![
-            "[0, 1, 2,3, 4]",
-            "[0,1,2,3,4,]", // Trailing commas are valid syntax
-            "[0;5]",
-        ];
+    fn eat_left_bracket(&mut self) -> bool {
+        self.eat(Token::LeftBracket)
+    }
 
-        for expr in parse_all(array_expr(expression()), valid) {
-            match expr_to_array(expr) {
-                ArrayLiteral::Standard(elements) => assert_eq!(elements.len(), 5),
-                ArrayLiteral::Repeated { length, .. } => {
-                    assert_eq!(length.kind, ExpressionKind::integer(5i128.into()));
-                }
-            }
-        }
+    fn eat_right_bracket(&mut self) -> bool {
+        self.eat(Token::RightBracket)
+    }
 
-        parse_all_failing(
-            array_expr(expression()),
-            vec!["0,1,2,3,4]", "[[0,1,2,3,4]", "[0,1,2,,]", "[0,1,2,3,4"],
-        );
+    fn eat_less(&mut self) -> bool {
+        self.eat(Token::Less)
     }
 
-    #[test]
-    fn parse_array_sugar() {
-        let valid = vec!["[0;7]", "[(1, 2); 4]", "[0;Four]", "[2;1+3-a]"];
-        parse_all(array_expr(expression()), valid);
+    fn eat_assign(&mut self) -> bool {
+        self.eat(Token::Assign)
+    }
 
-        let invalid = vec!["[0;;4]", "[1, 2; 3]"];
-        parse_all_failing(array_expr(expression()), invalid);
+    fn eat_dot(&mut self) -> bool {
+        self.eat(Token::Dot)
     }
 
-    fn expr_to_slice(expr: ExpressionKind) -> ArrayLiteral {
-        let lit = match expr {
-            ExpressionKind::Literal(literal) => literal,
-            _ => unreachable!("expected a literal"),
-        };
+    fn eat_pipe(&mut self) -> bool {
+        self.eat(Token::Pipe)
+    }
 
-        match lit {
-            Literal::Slice(arr) => arr,
-            _ => unreachable!("expected a slice: {:?}", lit),
+    fn eat(&mut self, token: Token) -> bool {
+        if self.token.token() == &token {
+            self.bump();
+            true
+        } else {
+            false
         }
     }
 
-    #[test]
-    fn parse_slice() {
-        let valid = vec![
-            "&[0, 1, 2,3, 4]",
-            "&[0,1,2,3,4,]", // Trailing commas are valid syntax
-            "&[0;5]",
-        ];
-
-        for expr in parse_all(slice_expr(expression()), valid) {
-            match expr_to_slice(expr) {
-                ArrayLiteral::Standard(elements) => assert_eq!(elements.len(), 5),
-                ArrayLiteral::Repeated { length, .. } => {
-                    assert_eq!(length.kind, ExpressionKind::integer(5i128.into()));
-                }
-            }
+    fn eat_keyword_or_error(&mut self, keyword: Keyword) {
+        if !self.eat_keyword(keyword) {
+            self.expected_token(Token::Keyword(keyword));
         }
+    }
 
-        parse_all_failing(
-            slice_expr(expression()),
-            vec!["0,1,2,3,4]", "&[[0,1,2,3,4]", "&[0,1,2,,]", "&[0,1,2,3,4"],
-        );
+    fn eat_or_error(&mut self, token: Token) {
+        if !self.eat(token.clone()) {
+            self.expected_token(token);
+        }
     }
 
-    #[test]
-    fn parse_slice_sugar() {
-        let valid = vec!["&[0;7]", "&[(1, 2); 4]", "&[0;Four]", "&[2;1+3-a]"];
-        parse_all(slice_expr(expression()), valid);
+    fn at(&self, token: Token) -> bool {
+        self.token.token() == &token
+    }
 
-        let invalid = vec!["&[0;;4]", "&[1, 2; 3]"];
-        parse_all_failing(slice_expr(expression()), invalid);
+    fn at_keyword(&self, keyword: Keyword) -> bool {
+        self.at(Token::Keyword(keyword))
     }
 
-    #[test]
-    fn parse_block() {
-        parse_with(block(fresh_statement()), "{ [0,1,2,3,4] }").unwrap();
+    fn next_is(&self, token: Token) -> bool {
+        self.next_token.token() == &token
+    }
 
-        parse_all_failing(
-            block(fresh_statement()),
-            vec![
-                "[0,1,2,3,4] }",
-                "{ [0,1,2,3,4]",
-                "{ [0,1,2,,] }", // Contents of the block must still be a valid expression
-                "{ [0,1,2,3 }",
-                "{ 0,1,2,3] }",
-                "[[0,1,2,3,4]}",
-            ],
-        );
+    fn at_eof(&self) -> bool {
+        self.token.token() == &Token::EOF
     }
 
-    #[test]
-    fn parse_let() {
-        // Why is it valid to specify a let declaration as having type u8?
-        //
-        // Let statements are not type checked here, so the parser will accept as
-        // long as it is a type. Other statements such as Public are type checked
-        // Because for now, they can only have one type
-        parse_all(
-            declaration(expression()),
-            vec!["let _ = 42", "let x = y", "let x : u8 = y", "let x: u16 = y"],
-        );
+    fn span_since(&self, start_span: Span) -> Span {
+        if self.current_token_span == start_span {
+            start_span
+        } else {
+            let end_span = self.previous_token_span;
+            Span::from(start_span.start()..end_span.end())
+        }
     }
 
-    #[test]
-    fn parse_invalid_pub() {
-        // pub cannot be used to declare a statement
-        parse_all_failing(fresh_statement(), vec!["pub x = y", "pub x : pub Field = y"]);
+    fn span_at_previous_token_end(&self) -> Span {
+        Span::from(self.previous_token_span.end()..self.previous_token_span.end())
     }
 
-    #[test]
-    fn parse_for_loop() {
-        parse_all(
-            for_loop(expression_no_constructors(expression()), fresh_statement()),
-            vec!["for i in x+y..z {}", "for i in 0..100 { foo; bar }"],
-        );
+    fn expected_identifier(&mut self) {
+        self.expected_label(ParsingRuleLabel::Identifier);
+    }
 
-        parse_all_failing(
-            for_loop(expression_no_constructors(expression()), fresh_statement()),
-            vec![
-                "for 1 in x+y..z {}",  // Cannot have a literal as the loop identifier
-                "for i in 0...100 {}", // Only '..' is supported, there are no inclusive ranges yet
-                "for i in 0..=100 {}", // Only '..' is supported, there are no inclusive ranges yet
-            ],
-        );
+    fn expected_token(&mut self, token: Token) {
+        self.errors.push(ParserError::expected_token(
+            token,
+            self.token.token().clone(),
+            self.current_token_span,
+        ));
     }
 
-    #[test]
-    fn parse_parenthesized_expression() {
-        parse_all(
-            atom(expression(), expression_no_constructors(expression()), fresh_statement(), true),
-            vec!["(0)", "(x+a)", "({(({{({(nested)})}}))})"],
-        );
-        parse_all_failing(
-            atom(expression(), expression_no_constructors(expression()), fresh_statement(), true),
-            vec!["(x+a", "((x+a)", "(,)"],
-        );
+    fn expected_one_of_tokens(&mut self, tokens: &[Token]) {
+        self.errors.push(ParserError::expected_one_of_tokens(
+            tokens,
+            self.token.token().clone(),
+            self.current_token_span,
+        ));
     }
 
-    #[test]
-    fn parse_tuple() {
-        parse_all(tuple(expression()), vec!["()", "(x,)", "(a,b+2)", "(a,(b,c,),d,)"]);
+    fn expected_label(&mut self, label: ParsingRuleLabel) {
+        self.errors.push(ParserError::expected_label(
+            label,
+            self.token.token().clone(),
+            self.current_token_span,
+        ));
     }
 
-    #[test]
-    fn parse_if_expr() {
-        parse_all(
-            if_expr(expression_no_constructors(expression()), fresh_statement()),
-            vec!["if x + a {  } else {  }", "if x {}", "if x {} else if y {} else {}"],
-        );
+    fn expected_token_separating_items(&mut self, token: Token, items: &'static str, span: Span) {
+        self.push_error(ParserErrorReason::ExpectedTokenSeparatingTwoItems { token, items }, span);
+    }
 
-        parse_all_failing(
-            if_expr(expression_no_constructors(expression()), fresh_statement()),
-            vec!["if (x / a) + 1 {} else", "if foo then 1 else 2", "if true { 1 }else 3"],
+    fn expected_mut_after_ampersand(&mut self) {
+        self.push_error(
+            ParserErrorReason::ExpectedMutAfterAmpersand { found: self.token.token().clone() },
+            self.current_token_span,
         );
     }
 
-    #[test]
-    fn parse_if_without_block() {
-        let src = "if foo";
-        let parser = if_expr(expression_no_constructors(expression()), fresh_statement());
-        let (expression_kind, errors) = parse_recover(parser, src);
-
-        let expression_kind = expression_kind.unwrap();
-        let ExpressionKind::If(if_expression) = expression_kind else {
-            panic!("Expected an if expression, got {:?}", expression_kind);
-        };
+    fn modifiers_not_followed_by_an_item(&mut self, modifiers: Modifiers) {
+        self.visibility_not_followed_by_an_item(modifiers);
+        self.unconstrained_not_followed_by_an_item(modifiers);
+        self.comptime_not_followed_by_an_item(modifiers);
+    }
 
-        assert_eq!(if_expression.consequence.kind, ExpressionKind::Error);
-        assert_eq!(if_expression.alternative, None);
-
-        assert_eq!(errors.len(), 1);
-        assert_eq!(errors[0].message, "expected { after if condition");
-    }
-
-    #[test]
-    fn parse_module_declaration() {
-        parse_with(module_declaration(), "mod foo").unwrap();
-        parse_with(module_declaration(), "#[attr] mod foo").unwrap();
-        parse_with(module_declaration(), "mod 1").unwrap_err();
-    }
-
-    #[test]
-    fn parse_submodule_declaration() {
-        parse_with(submodule(module()), "mod foo {}").unwrap();
-        parse_with(submodule(module()), "#[attr] mod foo {}").unwrap();
-    }
-
-    #[test]
-    fn parse_contract() {
-        parse_with(contract(module()), "contract foo {}").unwrap();
-        parse_with(contract(module()), "#[attr] contract foo {}").unwrap();
-    }
-
-    #[test]
-    fn parse_use() {
-        let valid_use_statements = [
-            "use std::hash",
-            "use std",
-            "use foo::bar as hello",
-            "use bar as bar",
-            "use foo::{}",
-            "use foo::{bar,}",
-            "use foo::{bar, hello}",
-            "use foo::{bar as bar2, hello}",
-            "use foo::{bar as bar2, hello::{foo}, nested::{foo, bar}}",
-            "use std::{println, bar::baz}",
-        ];
-
-        let invalid_use_statements = [
-            "use std as ;",
-            "use foobar as as;",
-            "use hello:: as foo;",
-            "use foo bar::baz",
-            "use foo bar::{baz}",
-            "use foo::{,}",
-        ];
-
-        let use_statements = valid_use_statements
-            .into_iter()
-            .map(|valid_str| (valid_str, true))
-            .chain(invalid_use_statements.into_iter().map(|invalid_str| (invalid_str, false)));
-
-        for (use_statement_str, expect_valid) in use_statements {
-            let mut use_statement_str = use_statement_str.to_string();
-            if expect_valid {
-                let (result_opt, _diagnostics) =
-                    parse_recover(&use_statement(), &use_statement_str);
-                use_statement_str.push(';');
-                match result_opt.unwrap() {
-                    TopLevelStatementKind::Import(expected_use_statement, _visibility) => {
-                        Some(expected_use_statement)
-                    }
-                    _ => unreachable!(),
-                }
-            } else {
-                let result = parse_with(&use_statement(), &use_statement_str);
-                assert!(result.is_err());
-                None
-            };
+    fn visibility_not_followed_by_an_item(&mut self, modifiers: Modifiers) {
+        if modifiers.visibility != ItemVisibility::Private {
+            self.push_error(
+                ParserErrorReason::VisibilityNotFollowedByAnItem {
+                    visibility: modifiers.visibility,
+                },
+                modifiers.visibility_span,
+            );
         }
     }
 
-    #[test]
-    fn parse_type_aliases() {
-        let cases = vec!["type foo = u8", "type bar = String", "type baz<T> = Vec<T>"];
-        parse_all(type_alias_definition(), cases);
-
-        let failing = vec!["type = u8", "type foo", "type foo = 1"];
-        parse_all_failing(type_alias_definition(), failing);
-    }
-
-    #[test]
-    fn parse_member_access() {
-        let cases = vec!["a.b", "a + b.c", "foo.bar as u32"];
-        parse_all(expression(), cases);
-    }
-
-    #[test]
-    fn parse_constructor() {
-        let cases = vec![
-            "Baz",
-            "Bar { ident: 32 }",
-            "Baz { other: 2 + 42, ident: foo() + 1 }",
-            "Baz { other, ident: foo() + 1, foo }",
-        ];
-
-        parse_all(expression(), cases);
-        parse_with(expression(), "Foo { a + b }").unwrap_err();
-    }
-
-    // Semicolons are:
-    // - Required after non-expression statements
-    // - Optional after for, if, block expressions
-    // - Optional after an expression as the last statement of a block
-    // - Required after an expression as the non-final statement of a block
-    #[test]
-    fn parse_semicolons() {
-        let cases = vec![
-            "{ if true {} if false {} foo }",
-            "{ if true {}; if false {} foo }",
-            "{ for x in 0..1 {} if false {} foo; }",
-            "{ let x = 2; }",
-            "{ expr1; expr2 }",
-            "{ expr1; expr2; }",
-        ];
-        parse_all(block(fresh_statement()), cases);
-
-        let failing = vec![
-            // We disallow multiple semicolons after a statement unlike rust where it is a warning
-            "{ test;; foo }",
-            "{ for x in 0..1 {} foo if false {} }",
-            "{ let x = 2 }",
-            "{ expr1 expr2 }",
-        ];
-        parse_all_failing(block(fresh_statement()), failing);
-    }
-
-    #[test]
-    fn statement_recovery() {
-        let cases = vec![
-            Case { source: "let a = 4 + 3", expect: "let a = (4 + 3)", errors: 0 },
-            Case { source: "let a: = 4 + 3", expect: "let a: error = (4 + 3)", errors: 1 },
-            Case { source: "let = 4 + 3", expect: "let $error = (4 + 3)", errors: 1 },
-            Case { source: "let = ", expect: "let $error = Error", errors: 2 },
-            Case { source: "let", expect: "let $error = Error", errors: 3 },
-            Case { source: "foo = one two three", expect: "foo = one", errors: 1 },
-            Case { source: "constrain", expect: "constrain Error", errors: 2 },
-            Case { source: "assert", expect: "assert()", errors: 1 },
-            Case { source: "constrain x ==", expect: "constrain (x == Error)", errors: 2 },
-            Case { source: "assert(x ==)", expect: "assert((x == Error))", errors: 1 },
-            Case { source: "assert(x == x, x)", expect: "assert((x == x), x)", errors: 0 },
-            Case { source: "assert_eq(x,)", expect: "assert_eq(x)", errors: 0 },
-            Case { source: "assert_eq(x, x, x, x)", expect: "assert_eq(x, x, x, x)", errors: 0 },
-            Case { source: "assert_eq(x, x, x)", expect: "assert_eq(x, x, x)", errors: 0 },
-        ];
-
-        check_cases_with_errors(&cases[..], fresh_statement());
-    }
-
-    #[test]
-    fn return_validation() {
-        let cases = [
-            Case {
-                source: "{ return 42; }",
-                expect: concat!("{\n", "    Error\n", "}",),
-                errors: 1,
-            },
-            Case {
-                source: "{ return 1; return 2; }",
-                expect: concat!("{\n", "    Error\n", "    Error\n", "}"),
-                errors: 2,
-            },
-            Case {
-                source: "{ return 123; let foo = 4 + 3; }",
-                expect: concat!("{\n", "    Error\n", "    let foo = (4 + 3)\n", "}"),
-                errors: 1,
-            },
-            Case {
-                source: "{ return 1 + 2 }",
-                expect: concat!("{\n", "    Error\n", "}",),
-                errors: 2,
-            },
-            Case { source: "{ return; }", expect: concat!("{\n", "    Error\n", "}",), errors: 1 },
-        ];
-
-        check_cases_with_errors(&cases[..], block(fresh_statement()));
-    }
-
-    #[test]
-    fn expr_no_constructors() {
-        let cases = [
-            Case {
-                source: "{ if structure { a: 1 } {} }",
-                expect: concat!(
-                    "{\n",
-                    "    if structure {\n",
-                    "        Error\n",
-                    "    }\n",
-                    "    {\n",
-                    "    }\n",
-                    "}",
-                ),
-                errors: 1,
-            },
-            Case {
-                source: "{ if ( structure { a: 1 } ) {} }",
-                expect: concat!("{\n", "    if ((structure { a: 1 })) {\n", "    }\n", "}",),
-                errors: 0,
-            },
-            Case {
-                source: "{ if ( structure {} ) {} }",
-                expect: concat!("{\n", "    if ((structure {  })) {\n", "    }\n", "}"),
-                errors: 0,
-            },
-            Case {
-                source: "{ if (a { x: 1 }, b { y: 2 }) {} }",
-                expect: concat!("{\n", "    if ((a { x: 1 }), (b { y: 2 })) {\n", "    }\n", "}",),
-                errors: 0,
-            },
-            Case {
-                source: "{ if ({ let foo = bar { baz: 42 }; foo == bar { baz: 42 }}) {} }",
-                expect: concat!(
-                    "{\n",
-                    "    if ({\n",
-                    "        let foo = (bar { baz: 42 })\n",
-                    "        (foo == (bar { baz: 42 }))\n",
-                    "    }) {\n",
-                    "    }\n",
-                    "}",
-                ),
-                errors: 0,
-            },
-        ];
-
-        check_cases_with_errors(&cases[..], block(fresh_statement()));
-    }
-
-    #[test]
-    fn test_quote() {
-        let cases = vec![
-            "quote {}",
-            "quote { a.b }",
-            "quote { ) ( }", // invalid syntax is fine in a quote
-            "quote { { } }", // Nested `{` and `}` shouldn't close the quote as long as they are matched.
-            "quote { 1 { 2 { 3 { 4 { 5 } 4 4 } 3 3 } 2 2 } 1 1 }",
-        ];
-        parse_all(quote(), cases);
-
-        let failing = vec!["quote {}}", "quote a", "quote { { { } } } }"];
-        parse_all_failing(quote(), failing);
-    }
-
-    #[test]
-    fn test_parses_block_statement_not_infix_expression() {
-        let src = r#"
-        {
-          {}
-          -1
-        }"#;
-        let (block_expr, _) = parse_recover(block(fresh_statement()), src);
-        let block_expr = block_expr.expect("Failed to parse module");
-        assert_eq!(block_expr.statements.len(), 2);
-    }
-
-    #[test]
-    fn test_parses_if_statement_not_infix_expression() {
-        let src = r#"
-        {
-          if 1 { 2 } else { 3 }
-          -1
-        }"#;
-        let (block_expr, _) = parse_recover(block(fresh_statement()), src);
-        let block_expr = block_expr.expect("Failed to parse module");
-        assert_eq!(block_expr.statements.len(), 2);
-    }
-
-    #[test]
-    fn test_parses_if_statement_followed_by_tuple_as_two_separate_statements() {
-        // Regression for #1310: this should not be parsed as a function call
-        let src = r#"
-        {
-          if 1 { 2 } else { 3 } (1, 2)
-        }"#;
-        let (block_expr, _) = parse_recover(block(fresh_statement()), src);
-        let block_expr = block_expr.expect("Failed to parse module");
-        assert_eq!(block_expr.statements.len(), 2);
-    }
-
-    #[test]
-    fn test_parses_member_access_without_member_name() {
-        let src = "{ foo. }";
-
-        let (Some(block_expression), errors) = parse_recover(block(fresh_statement()), src) else {
-            panic!("Expected to be able to parse a block expression");
-        };
-
-        assert_eq!(errors.len(), 1);
-        assert_eq!(errors[0].message, "expected an identifier after .");
-
-        let statement = &block_expression.statements[0];
-        let StatementKind::Expression(expr) = &statement.kind else {
-            panic!("Expected an expression statement");
-        };
+    fn unconstrained_not_followed_by_an_item(&mut self, modifiers: Modifiers) {
+        if let Some(span) = modifiers.unconstrained {
+            self.push_error(ParserErrorReason::UnconstrainedNotFollowedByAnItem, span);
+        }
+    }
 
-        let ExpressionKind::Variable(var) = &expr.kind else {
-            panic!("Expected a variable expression");
-        };
+    fn comptime_not_followed_by_an_item(&mut self, modifiers: Modifiers) {
+        if let Some(span) = modifiers.comptime {
+            self.push_error(ParserErrorReason::ComptimeNotFollowedByAnItem, span);
+        }
+    }
 
-        assert_eq!(var.to_string(), "foo");
+    fn comptime_mutable_and_unconstrained_not_applicable(&mut self, modifiers: Modifiers) {
+        self.mutable_not_applicable(modifiers);
+        self.comptime_not_applicable(modifiers);
+        self.unconstrained_not_applicable(modifiers);
     }
 
-    #[test]
-    fn parse_recover_impl_without_body() {
-        let src = "impl Foo";
+    fn mutable_not_applicable(&mut self, modifiers: Modifiers) {
+        if let Some(span) = modifiers.mutable {
+            self.push_error(ParserErrorReason::MutableNotApplicable, span);
+        }
+    }
 
-        let (top_level_statement, errors) = parse_recover(implementation(), src);
-        assert_eq!(errors.len(), 1);
-        assert_eq!(errors[0].message, "expected <, where or { after impl type");
+    fn comptime_not_applicable(&mut self, modifiers: Modifiers) {
+        if let Some(span) = modifiers.comptime {
+            self.push_error(ParserErrorReason::ComptimeNotApplicable, span);
+        }
+    }
 
-        let top_level_statement = top_level_statement.unwrap();
-        let TopLevelStatementKind::Impl(impl_) = top_level_statement else {
-            panic!("Expected to parse an impl");
-        };
+    fn unconstrained_not_applicable(&mut self, modifiers: Modifiers) {
+        if let Some(span) = modifiers.unconstrained {
+            self.push_error(ParserErrorReason::UnconstrainedNotApplicable, span);
+        }
+    }
 
-        assert_eq!(impl_.object_type.to_string(), "Foo");
-        assert!(impl_.methods.is_empty());
+    fn push_error(&mut self, reason: ParserErrorReason, span: Span) {
+        self.errors.push(ParserError::with_reason(reason, span));
     }
 }
+
+fn eof_spanned_token() -> SpannedToken {
+    SpannedToken::new(Token::EOF, Default::default())
+}
diff --git a/compiler/noirc_frontend/src/parser/parser/arguments.rs b/compiler/noirc_frontend/src/parser/parser/arguments.rs
new file mode 100644
index 00000000000..380f42809a6
--- /dev/null
+++ b/compiler/noirc_frontend/src/parser/parser/arguments.rs
@@ -0,0 +1,40 @@
+use crate::{ast::Expression, token::Token};
+
+use super::{parse_many::separated_by_comma_until_right_paren, Parser};
+
+pub(crate) struct CallArguments {
+    pub(crate) arguments: Vec<Expression>,
+    pub(crate) is_macro_call: bool,
+}
+
+impl<'a> Parser<'a> {
+    /// Arguments = '(' ArgumentsList? ')'
+    ///
+    /// ArgumentsList = Expression ( ',' Expression )? ','?
+    pub(crate) fn parse_arguments(&mut self) -> Option<Vec<Expression>> {
+        if !self.eat_left_paren() {
+            return None;
+        }
+
+        let arguments = self.parse_many(
+            "arguments",
+            separated_by_comma_until_right_paren(),
+            Self::parse_expression_in_list,
+        );
+
+        Some(arguments)
+    }
+
+    /// CallArguments = '!'? Arguments
+    pub(super) fn parse_call_arguments(&mut self) -> Option<CallArguments> {
+        let is_macro_call = self.at(Token::Bang) && self.next_is(Token::LeftParen);
+
+        if is_macro_call {
+            // Given that we expected '!' '(', it's safe to skip the '!' because the next
+            // `self.parse_arguments()` will always return `Some`.
+            self.bump();
+        }
+
+        self.parse_arguments().map(|arguments| CallArguments { arguments, is_macro_call })
+    }
+}
diff --git a/compiler/noirc_frontend/src/parser/parser/assertion.rs b/compiler/noirc_frontend/src/parser/parser/assertion.rs
deleted file mode 100644
index 9eb429ef295..00000000000
--- a/compiler/noirc_frontend/src/parser/parser/assertion.rs
+++ /dev/null
@@ -1,196 +0,0 @@
-use crate::ast::StatementKind;
-use crate::parser::{ignore_then_commit, then_commit, ParserError, ParserErrorReason};
-use crate::parser::{labels::ParsingRuleLabel, parenthesized, ExprParser, NoirParser};
-
-use crate::ast::{ConstrainKind, ConstrainStatement};
-use crate::token::{Keyword, Token};
-
-use chumsky::prelude::*;
-
-use super::keyword;
-
-pub(super) fn constrain<'a, P>(expr_parser: P) -> impl NoirParser<StatementKind> + 'a
-where
-    P: ExprParser + 'a,
-{
-    ignore_then_commit(
-        keyword(Keyword::Constrain).labelled(ParsingRuleLabel::Statement),
-        expr_parser,
-    )
-    .map_with_span(|expr, span| {
-        StatementKind::Constrain(ConstrainStatement {
-            kind: ConstrainKind::Constrain,
-            arguments: vec![expr],
-            span,
-        })
-    })
-    .validate(|expr, span, emit| {
-        emit(ParserError::with_reason(ParserErrorReason::ConstrainDeprecated, span));
-        expr
-    })
-}
-
-pub(super) fn assertion<'a, P>(expr_parser: P) -> impl NoirParser<StatementKind> + 'a
-where
-    P: ExprParser + 'a,
-{
-    let keyword = choice((
-        keyword(Keyword::Assert).map(|_| ConstrainKind::Assert),
-        keyword(Keyword::AssertEq).map(|_| ConstrainKind::AssertEq),
-    ));
-
-    let argument_parser = expr_parser.separated_by(just(Token::Comma)).allow_trailing();
-
-    then_commit(keyword, parenthesized(argument_parser))
-        .labelled(ParsingRuleLabel::Statement)
-        .map_with_span(|(kind, arguments), span| {
-            StatementKind::Constrain(ConstrainStatement { arguments, kind, span })
-        })
-}
-
-#[cfg(test)]
-mod test {
-    use super::*;
-    use crate::{
-        ast::{BinaryOpKind, ExpressionKind, Literal},
-        parser::parser::{
-            expression,
-            test_helpers::{parse_all, parse_all_failing, parse_with},
-        },
-    };
-
-    /// Deprecated constrain usage test
-    #[test]
-    fn parse_constrain() {
-        let errors = parse_with(constrain(expression()), "constrain x == y").unwrap_err();
-        assert_eq!(errors.len(), 1);
-        assert!(format!("{}", errors.first().unwrap()).contains("deprecated"));
-
-        // Currently we disallow constrain statements where the outer infix operator
-        // produces a value. This would require an implicit `==` which
-        // may not be intuitive to the user.
-        //
-        // If this is deemed useful, one would either apply a transformation
-        // or interpret it with an `==` in the evaluator
-        let disallowed_operators = vec![
-            BinaryOpKind::And,
-            BinaryOpKind::Subtract,
-            BinaryOpKind::Divide,
-            BinaryOpKind::Multiply,
-            BinaryOpKind::Or,
-        ];
-
-        for operator in disallowed_operators {
-            let src = format!("constrain x {} y;", operator.as_string());
-            let errors = parse_with(constrain(expression()), &src).unwrap_err();
-            assert_eq!(errors.len(), 2);
-            assert!(format!("{}", errors.first().unwrap()).contains("deprecated"));
-        }
-
-        // These are general cases which should always work.
-        //
-        // The first case is the most noteworthy. It contains two `==`
-        // The first (inner) `==` is a predicate which returns 0/1
-        // The outer layer is an infix `==` which is
-        // associated with the Constrain statement
-        let errors = parse_all_failing(
-            constrain(expression()),
-            vec![
-                "constrain ((x + y) == k) + z == y",
-                "constrain (x + !y) == y",
-                "constrain (x ^ y) == y",
-                "constrain (x ^ y) == (y + m)",
-                "constrain x + x ^ x == y | m",
-            ],
-        );
-        assert_eq!(errors.len(), 5);
-        assert!(errors
-            .iter()
-            .all(|err| { err.is_error() && err.to_string().contains("deprecated") }));
-    }
-
-    /// This is the standard way to declare an assert statement
-    #[test]
-    fn parse_assert() {
-        parse_with(assertion(expression()), "assert(x == y)").unwrap();
-
-        // Currently we disallow constrain statements where the outer infix operator
-        // produces a value. This would require an implicit `==` which
-        // may not be intuitive to the user.
-        //
-        // If this is deemed useful, one would either apply a transformation
-        // or interpret it with an `==` in the evaluator
-        let disallowed_operators = vec![
-            BinaryOpKind::And,
-            BinaryOpKind::Subtract,
-            BinaryOpKind::Divide,
-            BinaryOpKind::Multiply,
-            BinaryOpKind::Or,
-        ];
-
-        for operator in disallowed_operators {
-            let src = format!("assert(x {} y);", operator.as_string());
-            parse_with(assertion(expression()), &src).unwrap_err();
-        }
-
-        // These are general cases which should always work.
-        //
-        // The first case is the most noteworthy. It contains two `==`
-        // The first (inner) `==` is a predicate which returns 0/1
-        // The outer layer is an infix `==` which is
-        // associated with the Constrain statement
-        parse_all(
-            assertion(expression()),
-            vec![
-                "assert(((x + y) == k) + z == y)",
-                "assert((x + !y) == y)",
-                "assert((x ^ y) == y)",
-                "assert((x ^ y) == (y + m))",
-                "assert(x + x ^ x == y | m)",
-            ],
-        );
-
-        match parse_with(assertion(expression()), "assert(x == y, \"assertion message\")").unwrap()
-        {
-            StatementKind::Constrain(ConstrainStatement { arguments, .. }) => {
-                let message = arguments.last().unwrap();
-                match &message.kind {
-                    ExpressionKind::Literal(Literal::Str(message_string)) => {
-                        assert_eq!(message_string, "assertion message");
-                    }
-                    _ => unreachable!(),
-                }
-            }
-            _ => unreachable!(),
-        }
-    }
-
-    /// This is the standard way to assert that two expressions are equivalent
-    #[test]
-    fn parse_assert_eq() {
-        parse_all(
-            assertion(expression()),
-            vec![
-                "assert_eq(x, y)",
-                "assert_eq(((x + y) == k) + z, y)",
-                "assert_eq(x + !y, y)",
-                "assert_eq(x ^ y, y)",
-                "assert_eq(x ^ y, y + m)",
-                "assert_eq(x + x ^ x, y | m)",
-            ],
-        );
-        match parse_with(assertion(expression()), "assert_eq(x, y, \"assertion message\")").unwrap()
-        {
-            StatementKind::Constrain(ConstrainStatement { arguments, .. }) => {
-                let message = arguments.last().unwrap();
-                match &message.kind {
-                    ExpressionKind::Literal(Literal::Str(message_string)) => {
-                        assert_eq!(message_string, "assertion message");
-                    }
-                    _ => unreachable!(),
-                }
-            }
-            _ => unreachable!(),
-        }
-    }
-}
diff --git a/compiler/noirc_frontend/src/parser/parser/attributes.rs b/compiler/noirc_frontend/src/parser/parser/attributes.rs
index 66d0ca29ca6..12cb37edb4b 100644
--- a/compiler/noirc_frontend/src/parser/parser/attributes.rs
+++ b/compiler/noirc_frontend/src/parser/parser/attributes.rs
@@ -1,78 +1,638 @@
-use chumsky::Parser;
 use noirc_errors::Span;
 
-use crate::{
-    macros_api::SecondaryAttribute,
-    parser::{NoirParser, ParserError, ParserErrorReason},
-    token::{Attribute, Attributes, Token, TokenKind},
-};
+use crate::ast::{Expression, ExpressionKind, Ident, Literal, Path};
+use crate::lexer::errors::LexerErrorKind;
+use crate::parser::labels::ParsingRuleLabel;
+use crate::parser::ParserErrorReason;
+use crate::token::{Attribute, FunctionAttribute, MetaAttribute, TestScope, Token};
+use crate::token::{CustomAttribute, SecondaryAttribute};
 
-use super::primitives::token_kind;
+use super::parse_many::without_separator;
+use super::Parser;
 
-fn attribute() -> impl NoirParser<Attribute> {
-    token_kind(TokenKind::Attribute).map(|token| match token {
-        Token::Attribute(attribute) => attribute,
-        _ => unreachable!("Parser should have already errored due to token not being an attribute"),
-    })
-}
+impl<'a> Parser<'a> {
+    /// InnerAttribute = '#![' SecondaryAttribute ']'
+    pub(super) fn parse_inner_attribute(&mut self) -> Option<SecondaryAttribute> {
+        let start_span = self.current_token_span;
+        let is_tag = self.eat_inner_attribute_start()?;
+        let attribute = if is_tag {
+            self.parse_tag_attribute(start_span)
+        } else {
+            self.parse_non_tag_attribute(start_span)
+        };
 
-pub(super) fn attributes() -> impl NoirParser<Vec<Attribute>> {
-    attribute().repeated()
-}
+        match attribute {
+            Attribute::Function(function_attribute) => {
+                self.errors.push(
+                    LexerErrorKind::InvalidInnerAttribute {
+                        span: self.span_since(start_span),
+                        found: function_attribute.to_string(),
+                    }
+                    .into(),
+                );
+                None
+            }
+            Attribute::Secondary(secondary_attribute) => Some(secondary_attribute),
+        }
+    }
 
-pub(super) fn validate_attributes(
-    attributes: Vec<Attribute>,
-    span: Span,
-    emit: &mut dyn FnMut(ParserError),
-) -> Attributes {
-    let mut primary = None;
-    let mut secondary = Vec::new();
+    /// Attributes = Attribute*
+    pub(super) fn parse_attributes(&mut self) -> Vec<(Attribute, Span)> {
+        self.parse_many("attributes", without_separator(), Self::parse_attribute)
+    }
 
-    for attribute in attributes {
-        match attribute {
-            Attribute::Function(attr) => {
-                if primary.is_some() {
-                    emit(ParserError::with_reason(
-                        ParserErrorReason::MultipleFunctionAttributesFound,
-                        span,
-                    ));
+    /// Attribute = '#[' (FunctionAttribute | SecondaryAttribute) ']'
+    ///
+    /// FunctionAttribute
+    ///     = 'builtin' '(' AttributeValue ')'
+    ///     | 'fold'
+    ///     | 'foreign' '(' AttributeValue ')'
+    ///     | 'inline_always'
+    ///     | 'no_predicates'
+    ///     | 'oracle' '(' AttributeValue ')'
+    ///     | 'recursive'
+    ///     | 'test'
+    ///     | 'test' '(' 'should_fail' ')'
+    ///     | 'test' '(' 'should_fail_with' '=' string ')'
+    ///
+    /// SecondaryAttribute
+    ///     = 'abi' '(' AttributeValue ')'
+    ///     | 'allow' '(' AttributeValue ')'
+    ///     | 'deprecated'
+    ///     | 'deprecated' '(' string ')'
+    ///     | 'contract_library_method'
+    ///     | 'export'
+    ///     | 'field' '(' AttributeValue ')'
+    ///     | 'use_callers_scope'
+    ///     | 'varargs'
+    ///     | MetaAttribute
+    ///
+    /// MetaAttribute
+    ///     = Path Arguments?
+    ///
+    /// AttributeValue
+    ///     = Path
+    ///     | integer
+    pub(crate) fn parse_attribute(&mut self) -> Option<(Attribute, Span)> {
+        let start_span = self.current_token_span;
+        let is_tag = self.eat_attribute_start()?;
+        let attribute = if is_tag {
+            self.parse_tag_attribute(start_span)
+        } else {
+            self.parse_non_tag_attribute(start_span)
+        };
+        Some((attribute, self.span_since(start_span)))
+    }
+
+    pub(super) fn validate_secondary_attributes(
+        &mut self,
+        attributes: Vec<(Attribute, Span)>,
+    ) -> Vec<SecondaryAttribute> {
+        attributes
+            .into_iter()
+            .filter_map(|(attribute, span)| match attribute {
+                Attribute::Function(..) => {
+                    self.push_error(ParserErrorReason::NoFunctionAttributesAllowedOnStruct, span);
+                    None
+                }
+                Attribute::Secondary(attr) => Some(attr),
+            })
+            .collect()
+    }
+
+    fn parse_tag_attribute(&mut self, start_span: Span) -> Attribute {
+        let contents_start_span = self.current_token_span;
+        let mut contents_span = contents_start_span;
+        let mut contents = String::new();
+
+        let mut brackets_count = 1; // 1 because of the starting `#[`
+
+        while !self.at_eof() {
+            if self.at(Token::LeftBracket) {
+                brackets_count += 1;
+            } else if self.at(Token::RightBracket) {
+                brackets_count -= 1;
+                if brackets_count == 0 {
+                    contents_span = self.span_since(contents_start_span);
+                    self.bump();
+                    break;
                 }
-                primary = Some(attr);
             }
-            Attribute::Secondary(attr) => secondary.push(attr),
+
+            contents.push_str(&self.token.to_string());
+            self.bump();
         }
+
+        Attribute::Secondary(SecondaryAttribute::Tag(CustomAttribute {
+            contents,
+            span: self.span_since(start_span),
+            contents_span,
+        }))
     }
 
-    Attributes { function: primary, secondary }
-}
+    fn parse_non_tag_attribute(&mut self, start_span: Span) -> Attribute {
+        if matches!(&self.token.token(), Token::Keyword(..))
+            && (self.next_is(Token::LeftParen) || self.next_is(Token::RightBracket))
+        {
+            // This is a Meta attribute with the syntax `keyword(arg1, arg2, .., argN)`
+            let path = Path::from_single(self.token.to_string(), self.current_token_span);
+            self.bump();
+            self.parse_meta_attribute(path, start_span)
+        } else if let Some(path) = self.parse_path_no_turbofish() {
+            if let Some(ident) = path.as_ident() {
+                if ident.0.contents == "test" {
+                    // The test attribute is the only secondary attribute that has `a = b` in its syntax
+                    // (`should_fail_with = "..."``) so we parse it differently.
+                    self.parse_test_attribute(start_span)
+                } else {
+                    // Every other attribute has the form `name(arg1, arg2, .., argN)`
+                    self.parse_ident_attribute_other_than_test(ident, start_span)
+                }
+            } else {
+                // This is a Meta attribute with the syntax `path(arg1, arg2, .., argN)`
+                self.parse_meta_attribute(path, start_span)
+            }
+        } else {
+            self.expected_label(ParsingRuleLabel::Path);
+            self.parse_tag_attribute(start_span)
+        }
+    }
 
-pub(super) fn validate_secondary_attributes(
-    attributes: Vec<Attribute>,
-    span: Span,
-    emit: &mut dyn FnMut(ParserError),
-) -> Vec<SecondaryAttribute> {
-    let mut struct_attributes = vec![];
+    fn parse_meta_attribute(&mut self, name: Path, start_span: Span) -> Attribute {
+        let arguments = self.parse_arguments().unwrap_or_default();
+        self.skip_until_right_bracket();
+        Attribute::Secondary(SecondaryAttribute::Meta(MetaAttribute {
+            name,
+            arguments,
+            span: self.span_since(start_span),
+        }))
+    }
 
-    for attribute in attributes {
-        match attribute {
-            Attribute::Function(..) => {
-                emit(ParserError::with_reason(
-                    ParserErrorReason::NoFunctionAttributesAllowedOnStruct,
-                    span,
-                ));
+    fn parse_ident_attribute_other_than_test(
+        &mut self,
+        ident: &Ident,
+        start_span: Span,
+    ) -> Attribute {
+        let arguments = self.parse_arguments().unwrap_or_default();
+        self.skip_until_right_bracket();
+        match ident.0.contents.as_str() {
+            "abi" => self.parse_single_name_attribute(ident, arguments, start_span, |name| {
+                Attribute::Secondary(SecondaryAttribute::Abi(name))
+            }),
+            "allow" => self.parse_single_name_attribute(ident, arguments, start_span, |name| {
+                Attribute::Secondary(SecondaryAttribute::Allow(name))
+            }),
+            "builtin" => self.parse_single_name_attribute(ident, arguments, start_span, |name| {
+                Attribute::Function(FunctionAttribute::Builtin(name))
+            }),
+            "deprecated" => self.parse_deprecated_attribute(ident, arguments),
+            "contract_library_method" => {
+                let attr = Attribute::Secondary(SecondaryAttribute::ContractLibraryMethod);
+                self.parse_no_args_attribute(ident, arguments, attr)
+            }
+            "export" => {
+                let attr = Attribute::Secondary(SecondaryAttribute::Export);
+                self.parse_no_args_attribute(ident, arguments, attr)
+            }
+            "field" => self.parse_single_name_attribute(ident, arguments, start_span, |name| {
+                Attribute::Secondary(SecondaryAttribute::Field(name))
+            }),
+            "fold" => {
+                let attr = Attribute::Function(FunctionAttribute::Fold);
+                self.parse_no_args_attribute(ident, arguments, attr)
+            }
+            "foreign" => self.parse_single_name_attribute(ident, arguments, start_span, |name| {
+                Attribute::Function(FunctionAttribute::Foreign(name))
+            }),
+            "inline_always" => {
+                let attr = Attribute::Function(FunctionAttribute::InlineAlways);
+                self.parse_no_args_attribute(ident, arguments, attr)
+            }
+            "no_predicates" => {
+                let attr = Attribute::Function(FunctionAttribute::NoPredicates);
+                self.parse_no_args_attribute(ident, arguments, attr)
+            }
+            "oracle" => self.parse_single_name_attribute(ident, arguments, start_span, |name| {
+                Attribute::Function(FunctionAttribute::Oracle(name))
+            }),
+            "use_callers_scope" => {
+                let attr = Attribute::Secondary(SecondaryAttribute::UseCallersScope);
+                self.parse_no_args_attribute(ident, arguments, attr)
+            }
+            "varargs" => {
+                let attr = Attribute::Secondary(SecondaryAttribute::Varargs);
+                self.parse_no_args_attribute(ident, arguments, attr)
             }
-            Attribute::Secondary(attr) => struct_attributes.push(attr),
+            _ => Attribute::Secondary(SecondaryAttribute::Meta(MetaAttribute {
+                name: Path::from_ident(ident.clone()),
+                arguments,
+                span: self.span_since(start_span),
+            })),
         }
     }
 
-    struct_attributes
+    fn parse_deprecated_attribute(
+        &mut self,
+        ident: &Ident,
+        mut arguments: Vec<Expression>,
+    ) -> Attribute {
+        if arguments.is_empty() {
+            return Attribute::Secondary(SecondaryAttribute::Deprecated(None));
+        }
+
+        if arguments.len() > 1 {
+            self.push_error(
+                ParserErrorReason::WrongNumberOfAttributeArguments {
+                    name: ident.to_string(),
+                    min: 0,
+                    max: 1,
+                    found: arguments.len(),
+                },
+                ident.span(),
+            );
+            return Attribute::Secondary(SecondaryAttribute::Deprecated(None));
+        }
+
+        let argument = arguments.remove(0);
+        let ExpressionKind::Literal(Literal::Str(message)) = argument.kind else {
+            self.push_error(
+                ParserErrorReason::DeprecatedAttributeExpectsAStringArgument,
+                argument.span,
+            );
+            return Attribute::Secondary(SecondaryAttribute::Deprecated(None));
+        };
+
+        Attribute::Secondary(SecondaryAttribute::Deprecated(Some(message)))
+    }
+
+    fn parse_test_attribute(&mut self, start_span: Span) -> Attribute {
+        let scope = if self.eat_left_paren() {
+            let scope = if let Some(ident) = self.eat_ident() {
+                match ident.0.contents.as_str() {
+                    "should_fail" => Some(TestScope::ShouldFailWith { reason: None }),
+                    "should_fail_with" => {
+                        self.eat_or_error(Token::Assign);
+                        if let Some(reason) = self.eat_str() {
+                            Some(TestScope::ShouldFailWith { reason: Some(reason) })
+                        } else {
+                            Some(TestScope::ShouldFailWith { reason: None })
+                        }
+                    }
+                    _ => None,
+                }
+            } else {
+                None
+            };
+            self.eat_or_error(Token::RightParen);
+            scope
+        } else {
+            Some(TestScope::None)
+        };
+
+        self.skip_until_right_bracket();
+
+        let scope = if let Some(scope) = scope {
+            scope
+        } else {
+            self.errors.push(
+                LexerErrorKind::MalformedTestAttribute { span: self.span_since(start_span) }.into(),
+            );
+            TestScope::None
+        };
+
+        Attribute::Function(FunctionAttribute::Test(scope))
+    }
+
+    fn parse_single_name_attribute<F>(
+        &mut self,
+        ident: &Ident,
+        mut arguments: Vec<Expression>,
+        start_span: Span,
+        f: F,
+    ) -> Attribute
+    where
+        F: FnOnce(String) -> Attribute,
+    {
+        if arguments.len() != 1 {
+            self.push_error(
+                ParserErrorReason::WrongNumberOfAttributeArguments {
+                    name: ident.to_string(),
+                    min: 1,
+                    max: 1,
+                    found: arguments.len(),
+                },
+                self.current_token_span,
+            );
+            return f(String::new());
+        }
+
+        let argument = arguments.remove(0);
+        match argument.kind {
+            ExpressionKind::Variable(..) | ExpressionKind::Literal(Literal::Integer(..)) => {
+                f(argument.to_string())
+            }
+            _ => {
+                let span = self.span_since(start_span);
+                self.errors.push(
+                    LexerErrorKind::MalformedFuncAttribute { span, found: argument.to_string() }
+                        .into(),
+                );
+                f(String::new())
+            }
+        }
+    }
+
+    fn parse_no_args_attribute(
+        &mut self,
+        ident: &Ident,
+        arguments: Vec<Expression>,
+        attribute: Attribute,
+    ) -> Attribute {
+        if !arguments.is_empty() {
+            self.push_error(
+                ParserErrorReason::WrongNumberOfAttributeArguments {
+                    name: ident.to_string(),
+                    min: 0,
+                    max: 0,
+                    found: arguments.len(),
+                },
+                ident.span(),
+            );
+        }
+
+        attribute
+    }
+
+    fn skip_until_right_bracket(&mut self) {
+        let mut brackets_count = 1; // 1 because of the starting `#[`
+
+        while !self.at_eof() {
+            if self.at(Token::LeftBracket) {
+                brackets_count += 1;
+            } else if self.at(Token::RightBracket) {
+                brackets_count -= 1;
+                if brackets_count == 0 {
+                    self.bump();
+                    break;
+                }
+            }
+
+            self.expected_token(Token::RightBracket);
+            self.bump();
+        }
+    }
 }
 
-pub(super) fn inner_attribute() -> impl NoirParser<SecondaryAttribute> {
-    token_kind(TokenKind::InnerAttribute).map(|token| match token {
-        Token::InnerAttribute(attribute) => attribute,
-        _ => unreachable!(
-            "Parser should have already errored due to token not being an inner attribute"
-        ),
-    })
+#[cfg(test)]
+mod tests {
+    use noirc_errors::Span;
+
+    use crate::{
+        parser::{parser::tests::expect_no_errors, Parser},
+        token::{Attribute, FunctionAttribute, SecondaryAttribute, TestScope},
+    };
+
+    fn parse_inner_secondary_attribute_no_errors(src: &str, expected: SecondaryAttribute) {
+        let mut parser = Parser::for_str(src);
+        let attribute = parser.parse_inner_attribute();
+        expect_no_errors(&parser.errors);
+        assert_eq!(attribute.unwrap(), expected);
+    }
+
+    fn parse_attribute_no_errors(src: &str, expected: Attribute) {
+        let mut parser = Parser::for_str(src);
+        let (attribute, _span) = parser.parse_attribute().unwrap();
+        expect_no_errors(&parser.errors);
+        assert_eq!(attribute, expected);
+    }
+
+    #[test]
+    fn parses_inner_attribute_as_tag() {
+        let src = "#!['hello]";
+        let mut parser = Parser::for_str(src);
+        let Some(SecondaryAttribute::Tag(custom)) = parser.parse_inner_attribute() else {
+            panic!("Expected inner tag attribute");
+        };
+        expect_no_errors(&parser.errors);
+        assert_eq!(custom.contents, "hello");
+        assert_eq!(custom.span, Span::from(0..src.len() as u32));
+        assert_eq!(custom.contents_span, Span::from(4..src.len() as u32 - 1));
+    }
+
+    #[test]
+    fn parses_inner_attribute_as_tag_with_nested_brackets() {
+        let src = "#!['hello[1]]";
+        let mut parser = Parser::for_str(src);
+        let Some(SecondaryAttribute::Tag(custom)) = parser.parse_inner_attribute() else {
+            panic!("Expected inner tag attribute");
+        };
+        expect_no_errors(&parser.errors);
+        assert_eq!(custom.contents, "hello[1]");
+    }
+
+    #[test]
+    fn parses_inner_attribute_deprecated() {
+        let src = "#![deprecated]";
+        let expected = SecondaryAttribute::Deprecated(None);
+        parse_inner_secondary_attribute_no_errors(src, expected);
+    }
+
+    #[test]
+    fn parses_inner_attribute_deprecated_with_message() {
+        let src = "#![deprecated(\"use something else\")]";
+        let expected = SecondaryAttribute::Deprecated(Some("use something else".to_string()));
+        parse_inner_secondary_attribute_no_errors(src, expected);
+    }
+
+    #[test]
+    fn parses_inner_attribute_contract_library_method() {
+        let src = "#![contract_library_method]";
+        let expected = SecondaryAttribute::ContractLibraryMethod;
+        parse_inner_secondary_attribute_no_errors(src, expected);
+    }
+
+    #[test]
+    fn parses_inner_attribute_export() {
+        let src = "#![export]";
+        let expected = SecondaryAttribute::Export;
+        parse_inner_secondary_attribute_no_errors(src, expected);
+    }
+
+    #[test]
+    fn parses_inner_attribute_varargs() {
+        let src = "#![varargs]";
+        let expected = SecondaryAttribute::Varargs;
+        parse_inner_secondary_attribute_no_errors(src, expected);
+    }
+
+    #[test]
+    fn parses_inner_attribute_use_callers_scope() {
+        let src = "#![use_callers_scope]";
+        let expected = SecondaryAttribute::UseCallersScope;
+        parse_inner_secondary_attribute_no_errors(src, expected);
+    }
+
+    #[test]
+    fn parses_attribute_abi() {
+        let src = "#[abi(foo)]";
+        let expected = Attribute::Secondary(SecondaryAttribute::Abi("foo".to_string()));
+        parse_attribute_no_errors(src, expected);
+    }
+
+    #[test]
+    fn parses_attribute_foreign() {
+        let src = "#[foreign(foo)]";
+        let expected = Attribute::Function(FunctionAttribute::Foreign("foo".to_string()));
+        parse_attribute_no_errors(src, expected);
+    }
+
+    #[test]
+    fn parses_attribute_builtin() {
+        let src = "#[builtin(foo)]";
+        let expected = Attribute::Function(FunctionAttribute::Builtin("foo".to_string()));
+        parse_attribute_no_errors(src, expected);
+    }
+
+    #[test]
+    fn parses_attribute_oracle() {
+        let src = "#[oracle(foo)]";
+        let expected = Attribute::Function(FunctionAttribute::Oracle("foo".to_string()));
+        parse_attribute_no_errors(src, expected);
+    }
+
+    #[test]
+    fn parses_attribute_fold() {
+        let src = "#[fold]";
+        let expected = Attribute::Function(FunctionAttribute::Fold);
+        parse_attribute_no_errors(src, expected);
+    }
+
+    #[test]
+    fn parses_attribute_no_predicates() {
+        let src = "#[no_predicates]";
+        let expected = Attribute::Function(FunctionAttribute::NoPredicates);
+        parse_attribute_no_errors(src, expected);
+    }
+
+    #[test]
+    fn parses_attribute_inline_always() {
+        let src = "#[inline_always]";
+        let expected = Attribute::Function(FunctionAttribute::InlineAlways);
+        parse_attribute_no_errors(src, expected);
+    }
+
+    #[test]
+    fn parses_attribute_field() {
+        let src = "#[field(bn254)]";
+        let expected = Attribute::Secondary(SecondaryAttribute::Field("bn254".to_string()));
+        parse_attribute_no_errors(src, expected);
+    }
+
+    #[test]
+    fn parses_attribute_field_with_integer() {
+        let src = "#[field(23)]";
+        let expected = Attribute::Secondary(SecondaryAttribute::Field("23".to_string()));
+        parse_attribute_no_errors(src, expected);
+    }
+
+    #[test]
+    fn parses_attribute_allow() {
+        let src = "#[allow(unused_vars)]";
+        let expected = Attribute::Secondary(SecondaryAttribute::Allow("unused_vars".to_string()));
+        parse_attribute_no_errors(src, expected);
+    }
+
+    #[test]
+    fn parses_attribute_test_no_scope() {
+        let src = "#[test]";
+        let expected = Attribute::Function(FunctionAttribute::Test(TestScope::None));
+        parse_attribute_no_errors(src, expected);
+    }
+
+    #[test]
+    fn parses_attribute_test_should_fail() {
+        let src = "#[test(should_fail)]";
+        let expected = Attribute::Function(FunctionAttribute::Test(TestScope::ShouldFailWith {
+            reason: None,
+        }));
+        parse_attribute_no_errors(src, expected);
+    }
+
+    #[test]
+    fn parses_attribute_test_should_fail_with() {
+        let src = "#[test(should_fail_with = \"reason\")]";
+        let expected = Attribute::Function(FunctionAttribute::Test(TestScope::ShouldFailWith {
+            reason: Some("reason".to_string()),
+        }));
+        parse_attribute_no_errors(src, expected);
+    }
+
+    #[test]
+    fn parses_meta_attribute_single_identifier_no_arguments() {
+        let src = "#[foo]";
+        let mut parser = Parser::for_str(src);
+        let (attribute, _span) = parser.parse_attribute().unwrap();
+        expect_no_errors(&parser.errors);
+        let Attribute::Secondary(SecondaryAttribute::Meta(meta)) = attribute else {
+            panic!("Expected meta attribute");
+        };
+        assert_eq!(meta.name.to_string(), "foo");
+        assert!(meta.arguments.is_empty());
+    }
+
+    #[test]
+    fn parses_meta_attribute_single_identifier_as_keyword() {
+        let src = "#[dep]";
+        let mut parser = Parser::for_str(src);
+        let (attribute, _span) = parser.parse_attribute().unwrap();
+        expect_no_errors(&parser.errors);
+        let Attribute::Secondary(SecondaryAttribute::Meta(meta)) = attribute else {
+            panic!("Expected meta attribute");
+        };
+        assert_eq!(meta.name.to_string(), "dep");
+        assert!(meta.arguments.is_empty());
+    }
+
+    #[test]
+    fn parses_meta_attribute_single_identifier_with_arguments() {
+        let src = "#[foo(1, 2, 3)]";
+        let mut parser = Parser::for_str(src);
+        let (attribute, _span) = parser.parse_attribute().unwrap();
+        expect_no_errors(&parser.errors);
+        let Attribute::Secondary(SecondaryAttribute::Meta(meta)) = attribute else {
+            panic!("Expected meta attribute");
+        };
+        assert_eq!(meta.name.to_string(), "foo");
+        assert_eq!(meta.arguments.len(), 3);
+        assert_eq!(meta.arguments[0].to_string(), "1");
+    }
+
+    #[test]
+    fn parses_meta_attribute_path_with_arguments() {
+        let src = "#[foo::bar(1, 2, 3)]";
+        let mut parser = Parser::for_str(src);
+        let (attribute, _span) = parser.parse_attribute().unwrap();
+        expect_no_errors(&parser.errors);
+        let Attribute::Secondary(SecondaryAttribute::Meta(meta)) = attribute else {
+            panic!("Expected meta attribute");
+        };
+        assert_eq!(meta.name.to_string(), "foo::bar");
+        assert_eq!(meta.arguments.len(), 3);
+        assert_eq!(meta.arguments[0].to_string(), "1");
+    }
+
+    #[test]
+    fn parses_attributes() {
+        let src = "#[test] #[deprecated]";
+        let mut parser = Parser::for_str(src);
+        let mut attributes = parser.parse_attributes();
+        expect_no_errors(&parser.errors);
+        assert_eq!(attributes.len(), 2);
+
+        let (attr, _) = attributes.remove(0);
+        assert!(matches!(attr, Attribute::Function(FunctionAttribute::Test(TestScope::None))));
+
+        let (attr, _) = attributes.remove(0);
+        assert!(matches!(attr, Attribute::Secondary(SecondaryAttribute::Deprecated(None))));
+    }
 }
diff --git a/compiler/noirc_frontend/src/parser/parser/doc_comments.rs b/compiler/noirc_frontend/src/parser/parser/doc_comments.rs
index 151ff21017f..578a49641f6 100644
--- a/compiler/noirc_frontend/src/parser/parser/doc_comments.rs
+++ b/compiler/noirc_frontend/src/parser/parser/doc_comments.rs
@@ -1,36 +1,58 @@
-use chumsky::Parser;
-
-use crate::{
-    parser::NoirParser,
-    token::{DocStyle, Token, TokenKind},
-};
-
-use super::primitives::token_kind;
-
-fn outer_doc_comment() -> impl NoirParser<String> {
-    token_kind(TokenKind::OuterDocComment).map(|token| match token {
-        Token::LineComment(comment, Some(DocStyle::Outer)) => comment,
-        Token::BlockComment(comment, Some(DocStyle::Outer)) => comment,
-        _ => unreachable!(
-            "Parser should have already errored due to token not being an outer doc comment"
-        ),
-    })
-}
+use crate::token::{DocStyle, Token, TokenKind};
 
-pub(super) fn outer_doc_comments() -> impl NoirParser<Vec<String>> {
-    outer_doc_comment().repeated()
-}
+use super::{parse_many::without_separator, Parser};
+
+impl<'a> Parser<'a> {
+    /// InnerDocComments = inner_doc_comment*
+    pub(super) fn parse_inner_doc_comments(&mut self) -> Vec<String> {
+        self.parse_many("inner doc comments", without_separator(), Self::parse_inner_doc_comment)
+    }
+
+    fn parse_inner_doc_comment(&mut self) -> Option<String> {
+        self.eat_kind(TokenKind::InnerDocComment).map(|token| match token.into_token() {
+            Token::LineComment(comment, Some(DocStyle::Inner))
+            | Token::BlockComment(comment, Some(DocStyle::Inner)) => comment,
+            _ => unreachable!(),
+        })
+    }
 
-fn inner_doc_comment() -> impl NoirParser<String> {
-    token_kind(TokenKind::InnerDocComment).map(|token| match token {
-        Token::LineComment(comment, Some(DocStyle::Inner)) => comment,
-        Token::BlockComment(comment, Some(DocStyle::Inner)) => comment,
-        _ => unreachable!(
-            "Parser should have already errored due to token not being an inner doc comment"
-        ),
-    })
+    /// OuterDocComments = outer_doc_comments*
+    pub(super) fn parse_outer_doc_comments(&mut self) -> Vec<String> {
+        self.parse_many("outer doc comments", without_separator(), Self::parse_outer_doc_comment)
+    }
+
+    fn parse_outer_doc_comment(&mut self) -> Option<String> {
+        self.eat_kind(TokenKind::OuterDocComment).map(|token| match token.into_token() {
+            Token::LineComment(comment, Some(DocStyle::Outer))
+            | Token::BlockComment(comment, Some(DocStyle::Outer)) => comment,
+            _ => unreachable!(),
+        })
+    }
 }
 
-pub(super) fn inner_doc_comments() -> impl NoirParser<Vec<String>> {
-    inner_doc_comment().repeated()
+#[cfg(test)]
+mod tests {
+    use crate::parser::{parser::tests::expect_no_errors, Parser};
+
+    #[test]
+    fn parses_inner_doc_comments() {
+        let src = "//! Hello\n//! World";
+        let mut parser = Parser::for_str(src);
+        let comments = parser.parse_inner_doc_comments();
+        expect_no_errors(&parser.errors);
+        assert_eq!(comments.len(), 2);
+        assert_eq!(comments[0], " Hello");
+        assert_eq!(comments[1], " World");
+    }
+
+    #[test]
+    fn parses_outer_doc_comments() {
+        let src = "/// Hello\n/// World";
+        let mut parser = Parser::for_str(src);
+        let comments = parser.parse_outer_doc_comments();
+        expect_no_errors(&parser.errors);
+        assert_eq!(comments.len(), 2);
+        assert_eq!(comments[0], " Hello");
+        assert_eq!(comments[1], " World");
+    }
 }
diff --git a/compiler/noirc_frontend/src/parser/parser/expression.rs b/compiler/noirc_frontend/src/parser/parser/expression.rs
new file mode 100644
index 00000000000..526a0c3dd6e
--- /dev/null
+++ b/compiler/noirc_frontend/src/parser/parser/expression.rs
@@ -0,0 +1,1654 @@
+use iter_extended::vecmap;
+use noirc_errors::Span;
+
+use crate::{
+    ast::{
+        ArrayLiteral, BlockExpression, CallExpression, CastExpression, ConstructorExpression,
+        Expression, ExpressionKind, Ident, IfExpression, IndexExpression, Literal,
+        MemberAccessExpression, MethodCallExpression, Statement, TypePath, UnaryOp, UnresolvedType,
+    },
+    parser::{labels::ParsingRuleLabel, parser::parse_many::separated_by_comma, ParserErrorReason},
+    token::{Keyword, Token, TokenKind},
+};
+
+use super::{
+    parse_many::{
+        separated_by_comma_until_right_brace, separated_by_comma_until_right_paren,
+        without_separator,
+    },
+    Parser,
+};
+
+impl<'a> Parser<'a> {
+    pub(crate) fn parse_expression_or_error(&mut self) -> Expression {
+        self.parse_expression_or_error_impl(true) // allow constructors
+    }
+
+    /// Expression = EqualOrNotEqualExpression
+    pub(crate) fn parse_expression(&mut self) -> Option<Expression> {
+        self.parse_expression_impl(true) // allow constructors
+    }
+
+    /// When parsing `if` conditions we don't allow constructors.
+    /// For example `if foo { 1 }` shouldn't have `foo { 1 }` as the condition, but `foo` instead.
+    /// The same goes with `for`: `for x in foo { 1 }` should have `foo` as the collection, not `foo { 1 }`.
+    ///
+    /// ExpressionExceptConstructor = "Expression except ConstructorException"
+    pub(crate) fn parse_expression_except_constructor_or_error(&mut self) -> Expression {
+        self.parse_expression_or_error_impl(false) // allow constructors
+    }
+
+    pub(crate) fn parse_expression_or_error_impl(
+        &mut self,
+        allow_constructors: bool,
+    ) -> Expression {
+        if let Some(expr) = self.parse_expression_impl(allow_constructors) {
+            expr
+        } else {
+            self.push_expected_expression();
+            Expression { kind: ExpressionKind::Error, span: self.span_at_previous_token_end() }
+        }
+    }
+
+    fn parse_expression_impl(&mut self, allow_constructors: bool) -> Option<Expression> {
+        self.parse_equal_or_not_equal(allow_constructors)
+    }
+
+    /// Term
+    ///    = UnaryOp Term
+    ///    | AtomOrUnaryRightExpression
+    pub(super) fn parse_term(&mut self, allow_constructors: bool) -> Option<Expression> {
+        let start_span = self.current_token_span;
+
+        if let Some(operator) = self.parse_unary_op() {
+            let Some(rhs) = self.parse_term(allow_constructors) else {
+                self.expected_label(ParsingRuleLabel::Expression);
+                return None;
+            };
+            let kind = ExpressionKind::prefix(operator, rhs);
+            let span = self.span_since(start_span);
+            return Some(Expression { kind, span });
+        }
+
+        self.parse_atom_or_unary_right(allow_constructors)
+    }
+
+    /// UnaryOp = '&' 'mut' | '-' | '!' | '*'
+    fn parse_unary_op(&mut self) -> Option<UnaryOp> {
+        if self.at(Token::Ampersand) && self.next_is(Token::Keyword(Keyword::Mut)) {
+            self.bump();
+            self.bump();
+            Some(UnaryOp::MutableReference)
+        } else if self.eat(Token::Minus) {
+            Some(UnaryOp::Minus)
+        } else if self.eat(Token::Bang) {
+            Some(UnaryOp::Not)
+        } else if self.eat(Token::Star) {
+            Some(UnaryOp::Dereference { implicitly_added: false })
+        } else {
+            None
+        }
+    }
+
+    /// AtomOrUnaryRightExpression
+    ///     = Atom
+    ///     | UnaryRightExpression
+    fn parse_atom_or_unary_right(&mut self, allow_constructors: bool) -> Option<Expression> {
+        let start_span = self.current_token_span;
+        let mut atom = self.parse_atom(allow_constructors)?;
+        let mut parsed;
+
+        loop {
+            (atom, parsed) = self.parse_unary_right(atom, start_span);
+            if parsed {
+                continue;
+            } else {
+                break;
+            }
+        }
+
+        Some(atom)
+    }
+
+    /// UnaryRightExpression
+    ///     = CallExpression
+    ///     | MemberAccessOrMethodCallExpression
+    ///     | CastExpression
+    ///     | IndexExpression
+    fn parse_unary_right(&mut self, mut atom: Expression, start_span: Span) -> (Expression, bool) {
+        let mut parsed;
+
+        (atom, parsed) = self.parse_call(atom, start_span);
+        if parsed {
+            return (atom, parsed);
+        }
+
+        (atom, parsed) = self.parse_member_access_or_method_call(atom, start_span);
+        if parsed {
+            return (atom, parsed);
+        }
+
+        (atom, parsed) = self.parse_cast(atom, start_span);
+        if parsed {
+            return (atom, parsed);
+        }
+
+        self.parse_index(atom, start_span)
+    }
+
+    /// CallExpression = Atom CallArguments
+    fn parse_call(&mut self, atom: Expression, start_span: Span) -> (Expression, bool) {
+        if let Some(call_arguments) = self.parse_call_arguments() {
+            let kind = ExpressionKind::Call(Box::new(CallExpression {
+                func: Box::new(atom),
+                arguments: call_arguments.arguments,
+                is_macro_call: call_arguments.is_macro_call,
+            }));
+            let span = self.span_since(start_span);
+            let atom = Expression { kind, span };
+            (atom, true)
+        } else {
+            (atom, false)
+        }
+    }
+
+    /// MemberAccessOrMethodCallExpression
+    ///     = MemberAccessExpression
+    ///     | MethodCallExpression
+    ///
+    /// MemberAccessExpression = Atom '.' identifier
+    ///
+    /// MethodCallExpression = Atom '.' identifier CallArguments
+    fn parse_member_access_or_method_call(
+        &mut self,
+        atom: Expression,
+        start_span: Span,
+    ) -> (Expression, bool) {
+        if !self.eat_dot() {
+            return (atom, false);
+        }
+
+        let Some(field_name) = self.parse_member_access_field_name() else { return (atom, true) };
+
+        let generics = self.parse_generics_after_member_access_field_name();
+
+        let kind = if let Some(call_arguments) = self.parse_call_arguments() {
+            ExpressionKind::MethodCall(Box::new(MethodCallExpression {
+                object: atom,
+                method_name: field_name,
+                generics,
+                arguments: call_arguments.arguments,
+                is_macro_call: call_arguments.is_macro_call,
+            }))
+        } else {
+            ExpressionKind::MemberAccess(Box::new(MemberAccessExpression {
+                lhs: atom,
+                rhs: field_name,
+            }))
+        };
+
+        let span = self.span_since(start_span);
+        let atom = Expression { kind, span };
+        (atom, true)
+    }
+
+    fn parse_member_access_field_name(&mut self) -> Option<Ident> {
+        if let Some(ident) = self.eat_ident() {
+            Some(ident)
+        } else if let Some(int) = self.eat_int() {
+            Some(Ident::new(int.to_string(), self.previous_token_span))
+        } else {
+            self.push_error(
+                ParserErrorReason::ExpectedFieldName(self.token.token().clone()),
+                self.current_token_span,
+            );
+            None
+        }
+    }
+
+    /// CastExpression = Atom 'as' Type
+    fn parse_cast(&mut self, atom: Expression, start_span: Span) -> (Expression, bool) {
+        if !self.eat_keyword(Keyword::As) {
+            return (atom, false);
+        }
+
+        let typ = self.parse_type_or_error();
+        let kind = ExpressionKind::Cast(Box::new(CastExpression { lhs: atom, r#type: typ }));
+        let span = self.span_since(start_span);
+        let atom = Expression { kind, span };
+        (atom, true)
+    }
+
+    /// IndexExpression = Atom '[' Expression ']'
+    fn parse_index(&mut self, atom: Expression, start_span: Span) -> (Expression, bool) {
+        if !self.eat_left_bracket() {
+            return (atom, false);
+        }
+
+        let index = self.parse_expression_or_error();
+        self.eat_or_error(Token::RightBracket);
+        let kind = ExpressionKind::Index(Box::new(IndexExpression { collection: atom, index }));
+        let span = self.span_since(start_span);
+        let atom = Expression { kind, span };
+        (atom, true)
+    }
+
+    fn parse_generics_after_member_access_field_name(&mut self) -> Option<Vec<UnresolvedType>> {
+        if self.eat_double_colon() {
+            let generics =
+                self.parse_path_generics(ParserErrorReason::AssociatedTypesNotAllowedInMethodCalls);
+            if generics.is_none() {
+                self.expected_token(Token::Less);
+            }
+            generics
+        } else {
+            None
+        }
+    }
+
+    /// Atom
+    ///     = Literal
+    ///     | ParenthesesExpression
+    ///     | UnsafeExpression
+    ///     | PathExpression
+    ///     | IfExpression
+    ///     | Lambda
+    ///     | ComptimeExpression
+    ///     | UnquoteExpression
+    ///     | TypePathExpression
+    ///     | AsTraitPath
+    ///     | ResolvedExpression
+    ///     | InternedExpression
+    ///     | InternedStatementExpression
+    fn parse_atom(&mut self, allow_constructors: bool) -> Option<Expression> {
+        let start_span = self.current_token_span;
+        let kind = self.parse_atom_kind(allow_constructors)?;
+        Some(Expression { kind, span: self.span_since(start_span) })
+    }
+
+    fn parse_atom_kind(&mut self, allow_constructors: bool) -> Option<ExpressionKind> {
+        if let Some(literal) = self.parse_literal() {
+            return Some(literal);
+        }
+
+        if let Some(kind) = self.parse_parentheses_expression() {
+            return Some(kind);
+        }
+
+        if let Some(kind) = self.parse_unsafe_expr() {
+            return Some(kind);
+        }
+
+        if let Some(kind) = self.parse_path_expr(allow_constructors) {
+            return Some(kind);
+        }
+
+        // A constructor where the type is an interned unresolved type data is valid
+        if matches!(self.token.token(), Token::InternedUnresolvedTypeData(..))
+            && self.next_is(Token::LeftBrace)
+        {
+            let span = self.current_token_span;
+            let typ = self.parse_interned_type().unwrap();
+            self.eat_or_error(Token::LeftBrace);
+            let typ = UnresolvedType { typ, span };
+            return Some(self.parse_constructor(typ));
+        }
+
+        if let Some(kind) = self.parse_if_expr() {
+            return Some(kind);
+        }
+
+        if let Some(kind) = self.parse_lambda() {
+            return Some(kind);
+        }
+
+        if let Some(kind) = self.parse_comptime_expr() {
+            return Some(kind);
+        }
+
+        if let Some(kind) = self.parse_unquote_expr() {
+            return Some(kind);
+        }
+
+        if let Some(kind) = self.parse_type_path_expr() {
+            return Some(kind);
+        }
+
+        if let Some(as_trait_path) = self.parse_as_trait_path() {
+            return Some(ExpressionKind::AsTraitPath(as_trait_path));
+        }
+
+        if let Some(kind) = self.parse_resolved_expr() {
+            return Some(kind);
+        }
+
+        if let Some(kind) = self.parse_interned_expr() {
+            return Some(kind);
+        }
+
+        if let Some(kind) = self.parse_interned_statement_expr() {
+            return Some(kind);
+        }
+
+        None
+    }
+
+    /// ResolvedExpression = unquote_marker
+    fn parse_resolved_expr(&mut self) -> Option<ExpressionKind> {
+        if let Some(token) = self.eat_kind(TokenKind::UnquoteMarker) {
+            match token.into_token() {
+                Token::UnquoteMarker(expr_id) => return Some(ExpressionKind::Resolved(expr_id)),
+                _ => unreachable!(""),
+            }
+        }
+
+        None
+    }
+
+    /// InternedExpression = interned_expr
+    fn parse_interned_expr(&mut self) -> Option<ExpressionKind> {
+        if let Some(token) = self.eat_kind(TokenKind::InternedExpr) {
+            match token.into_token() {
+                Token::InternedExpr(id) => return Some(ExpressionKind::Interned(id)),
+                _ => unreachable!(""),
+            }
+        }
+
+        None
+    }
+
+    /// InternedStatementExpression = interned_statement
+    fn parse_interned_statement_expr(&mut self) -> Option<ExpressionKind> {
+        if let Some(token) = self.eat_kind(TokenKind::InternedStatement) {
+            match token.into_token() {
+                Token::InternedStatement(id) => return Some(ExpressionKind::InternedStatement(id)),
+                _ => unreachable!(""),
+            }
+        }
+
+        None
+    }
+
+    /// UnsafeExpression = 'unsafe' Block
+    fn parse_unsafe_expr(&mut self) -> Option<ExpressionKind> {
+        if !self.eat_keyword(Keyword::Unsafe) {
+            return None;
+        }
+
+        let start_span = self.current_token_span;
+        if let Some(block) = self.parse_block() {
+            Some(ExpressionKind::Unsafe(block, self.span_since(start_span)))
+        } else {
+            Some(ExpressionKind::Error)
+        }
+    }
+
+    /// PathExpression
+    ///     = VariableExpression
+    ///     | ConstructorExpression
+    ///
+    /// VariableExpression = Path
+    fn parse_path_expr(&mut self, allow_constructors: bool) -> Option<ExpressionKind> {
+        let Some(path) = self.parse_path() else {
+            return None;
+        };
+
+        if allow_constructors && self.eat_left_brace() {
+            let typ = UnresolvedType::from_path(path);
+            return Some(self.parse_constructor(typ));
+        }
+
+        Some(ExpressionKind::Variable(path))
+    }
+
+    /// ConstructorExpression = Type '{' ConstructorFields? '}'
+    ///
+    /// ConstructorFields = ConstructorField ( ',' ConstructorField )* ','?
+    ///
+    /// ConstructorField = identifier ( ':' Expression )?
+    fn parse_constructor(&mut self, typ: UnresolvedType) -> ExpressionKind {
+        let fields = self.parse_many(
+            "constructor fields",
+            separated_by_comma_until_right_brace(),
+            Self::parse_constructor_field,
+        );
+
+        ExpressionKind::Constructor(Box::new(ConstructorExpression {
+            typ,
+            fields,
+            struct_type: None,
+        }))
+    }
+
+    fn parse_constructor_field(&mut self) -> Option<(Ident, Expression)> {
+        let Some(ident) = self.eat_ident() else {
+            return None;
+        };
+
+        Some(if self.eat_colon() {
+            let expression = self.parse_expression_or_error();
+            (ident, expression)
+        } else if self.at(Token::DoubleColon) || self.at(Token::Assign) {
+            // If we find '='  or '::' instead of ':', assume the user meant ':`, error and continue
+            self.expected_token(Token::Colon);
+            self.bump();
+            let expression = self.parse_expression_or_error();
+            (ident, expression)
+        } else {
+            (ident.clone(), ident.into())
+        })
+    }
+
+    /// IfExpression = 'if' ExpressionExceptConstructor Block ( 'else' ( Block | IfExpression ) )?
+    pub(super) fn parse_if_expr(&mut self) -> Option<ExpressionKind> {
+        if !self.eat_keyword(Keyword::If) {
+            return None;
+        }
+
+        let condition = self.parse_expression_except_constructor_or_error();
+
+        let start_span = self.current_token_span;
+        let Some(consequence) = self.parse_block() else {
+            self.expected_token(Token::LeftBrace);
+            let span = self.span_at_previous_token_end();
+            return Some(ExpressionKind::If(Box::new(IfExpression {
+                condition,
+                consequence: Expression { kind: ExpressionKind::Error, span },
+                alternative: None,
+            })));
+        };
+        let span = self.span_since(start_span);
+        let consequence = Expression { kind: ExpressionKind::Block(consequence), span };
+
+        let alternative = if self.eat_keyword(Keyword::Else) {
+            let start_span = self.current_token_span;
+            if let Some(block) = self.parse_block() {
+                let span = self.span_since(start_span);
+                Some(Expression { kind: ExpressionKind::Block(block), span })
+            } else if let Some(if_expr) = self.parse_if_expr() {
+                Some(Expression { kind: if_expr, span: self.span_since(start_span) })
+            } else {
+                self.expected_token(Token::LeftBrace);
+                None
+            }
+        } else {
+            None
+        };
+
+        Some(ExpressionKind::If(Box::new(IfExpression { condition, consequence, alternative })))
+    }
+
+    /// ComptimeExpression = 'comptime' Block
+    fn parse_comptime_expr(&mut self) -> Option<ExpressionKind> {
+        if !self.eat_keyword(Keyword::Comptime) {
+            return None;
+        }
+
+        let start_span = self.current_token_span;
+
+        let Some(block) = self.parse_block() else {
+            self.expected_token(Token::LeftBrace);
+            return None;
+        };
+
+        Some(ExpressionKind::Comptime(block, self.span_since(start_span)))
+    }
+
+    /// UnquoteExpression
+    ///     = '$' identifier
+    ///     | '$' '(' Expression ')'
+    fn parse_unquote_expr(&mut self) -> Option<ExpressionKind> {
+        let start_span = self.current_token_span;
+
+        if !self.eat(Token::DollarSign) {
+            return None;
+        }
+
+        if let Some(path) = self.parse_path() {
+            let expr = Expression {
+                kind: ExpressionKind::Variable(path),
+                span: self.span_since(start_span),
+            };
+            return Some(ExpressionKind::Unquote(Box::new(expr)));
+        }
+
+        let span_at_left_paren = self.current_token_span;
+        if self.eat_left_paren() {
+            let expr = self.parse_expression_or_error();
+            self.eat_or_error(Token::RightParen);
+            let expr = Expression {
+                kind: ExpressionKind::Parenthesized(Box::new(expr)),
+                span: self.span_since(span_at_left_paren),
+            };
+            return Some(ExpressionKind::Unquote(Box::new(expr)));
+        }
+
+        self.push_error(
+            ParserErrorReason::ExpectedIdentifierOrLeftParenAfterDollar,
+            self.current_token_span,
+        );
+
+        None
+    }
+
+    /// TypePathExpression = PrimitiveType '::' identifier ( '::' GenericTypeArgs )?
+    fn parse_type_path_expr(&mut self) -> Option<ExpressionKind> {
+        let start_span = self.current_token_span;
+        let Some(typ) = self.parse_primitive_type() else {
+            return None;
+        };
+        let typ = UnresolvedType { typ, span: self.span_since(start_span) };
+
+        self.eat_or_error(Token::DoubleColon);
+
+        let item = if let Some(ident) = self.eat_ident() {
+            ident
+        } else {
+            self.expected_identifier();
+            Ident::new(String::new(), self.span_at_previous_token_end())
+        };
+
+        let turbofish = self.eat_double_colon().then(|| {
+            let generics = self.parse_generic_type_args();
+            if generics.is_empty() {
+                self.expected_token(Token::Less);
+            }
+            generics
+        });
+
+        Some(ExpressionKind::TypePath(TypePath { typ, item, turbofish }))
+    }
+
+    /// Literal
+    ///     = bool
+    ///     | int
+    ///     | str
+    ///     | rawstr
+    ///     | fmtstr
+    ///     | QuoteExpression
+    ///     | ArrayExpression
+    ///     | SliceExpression
+    ///     | BlockExpression
+    ///
+    /// QuoteExpression = 'quote' '{' token* '}'
+    ///
+    /// ArrayExpression = ArrayLiteral
+    ///
+    /// BlockExpression = Block
+    fn parse_literal(&mut self) -> Option<ExpressionKind> {
+        if let Some(bool) = self.eat_bool() {
+            return Some(ExpressionKind::boolean(bool));
+        }
+
+        if let Some(int) = self.eat_int() {
+            return Some(ExpressionKind::integer(int));
+        }
+
+        if let Some(string) = self.eat_str() {
+            return Some(ExpressionKind::string(string));
+        }
+
+        if let Some((string, n)) = self.eat_raw_str() {
+            return Some(ExpressionKind::raw_string(string, n));
+        }
+
+        if let Some((fragments, length)) = self.eat_fmt_str() {
+            return Some(ExpressionKind::format_string(fragments, length));
+        }
+
+        if let Some(tokens) = self.eat_quote() {
+            return Some(ExpressionKind::Quote(tokens));
+        }
+
+        if let Some(literal) = self.parse_array_literal() {
+            return Some(ExpressionKind::Literal(Literal::Array(literal)));
+        }
+
+        if let Some(literal) = self.parse_slice_literal() {
+            return Some(ExpressionKind::Literal(Literal::Slice(literal)));
+        }
+
+        if let Some(kind) = self.parse_block() {
+            return Some(ExpressionKind::Block(kind));
+        }
+
+        None
+    }
+
+    /// ArrayLiteral
+    ///     = StandardArrayLiteral
+    ///     | RepeatedArrayLiteral
+    ///
+    /// StandardArrayLiteral = '[' ArrayElements? ']'
+    ///
+    /// ArrayElements = Expression ( ',' Expression )? ','?
+    ///
+    /// RepeatedArrayLiteral = '[' Expression ';' TypeExpression ']'
+    fn parse_array_literal(&mut self) -> Option<ArrayLiteral> {
+        if !self.eat_left_bracket() {
+            return None;
+        }
+
+        if self.eat_right_bracket() {
+            return Some(ArrayLiteral::Standard(Vec::new()));
+        }
+
+        let first_expr = self.parse_expression_or_error();
+        if first_expr.kind == ExpressionKind::Error {
+            return Some(ArrayLiteral::Standard(Vec::new()));
+        }
+
+        if self.eat_semicolon() {
+            let length = self.parse_expression_or_error();
+            self.eat_or_error(Token::RightBracket);
+            return Some(ArrayLiteral::Repeated {
+                repeated_element: Box::new(first_expr),
+                length: Box::new(length),
+            });
+        }
+
+        let comma_after_first_expr = self.eat_comma();
+        let second_expr_span = self.current_token_span;
+
+        let mut exprs = self.parse_many(
+            "expressions",
+            separated_by_comma().until(Token::RightBracket),
+            Self::parse_expression_in_list,
+        );
+
+        if !exprs.is_empty() && !comma_after_first_expr {
+            self.expected_token_separating_items(Token::Comma, "expressions", second_expr_span);
+        }
+
+        exprs.insert(0, first_expr);
+
+        Some(ArrayLiteral::Standard(exprs))
+    }
+
+    /// SliceExpression = '&' ArrayLiteral
+    fn parse_slice_literal(&mut self) -> Option<ArrayLiteral> {
+        if !(self.at(Token::Ampersand) && self.next_is(Token::LeftBracket)) {
+            return None;
+        }
+
+        self.bump();
+        self.parse_array_literal()
+    }
+
+    /// ParenthesesExpression
+    ///     = UnitLiteral
+    ///     | ParenthesizedExpression
+    ///     | TupleExpression
+    ///
+    /// UnitLiteral = '(' ')'
+    ///
+    /// ParenthesizedExpression = '(' Expression ')'
+    ///
+    /// TupleExpression = '(' Expression ( ',' Expression )+ ','? ')'
+    fn parse_parentheses_expression(&mut self) -> Option<ExpressionKind> {
+        if !self.eat_left_paren() {
+            return None;
+        }
+
+        if self.eat_right_paren() {
+            return Some(ExpressionKind::Literal(Literal::Unit));
+        }
+
+        let (mut exprs, trailing_comma) = self.parse_many_return_trailing_separator_if_any(
+            "expressions",
+            separated_by_comma_until_right_paren(),
+            Self::parse_expression_in_list,
+        );
+
+        Some(if exprs.len() == 1 && !trailing_comma {
+            ExpressionKind::Parenthesized(Box::new(exprs.remove(0)))
+        } else {
+            ExpressionKind::Tuple(exprs)
+        })
+    }
+
+    pub(super) fn parse_expression_in_list(&mut self) -> Option<Expression> {
+        if let Some(expr) = self.parse_expression() {
+            Some(expr)
+        } else {
+            self.expected_label(ParsingRuleLabel::Expression);
+            None
+        }
+    }
+
+    /// Block = '{' Statement* '}'
+    pub(super) fn parse_block(&mut self) -> Option<BlockExpression> {
+        if !self.eat_left_brace() {
+            return None;
+        }
+
+        let statements = self.parse_many(
+            "statements",
+            without_separator().until(Token::RightBrace),
+            Self::parse_statement_in_block,
+        );
+
+        let statements = self.check_statements_require_semicolon(statements);
+
+        Some(BlockExpression { statements })
+    }
+
+    fn parse_statement_in_block(&mut self) -> Option<(Statement, (Option<Token>, Span))> {
+        if let Some(statement) = self.parse_statement() {
+            Some(statement)
+        } else {
+            self.expected_label(ParsingRuleLabel::Statement);
+            None
+        }
+    }
+
+    fn check_statements_require_semicolon(
+        &mut self,
+        statements: Vec<(Statement, (Option<Token>, Span))>,
+    ) -> Vec<Statement> {
+        let last = statements.len().saturating_sub(1);
+        let iter = statements.into_iter().enumerate();
+        vecmap(iter, |(i, (statement, (semicolon, span)))| {
+            statement
+                .add_semicolon(semicolon, span, i == last, &mut |error| self.errors.push(error))
+        })
+    }
+
+    pub(super) fn push_expected_expression(&mut self) {
+        self.expected_label(ParsingRuleLabel::Expression);
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use strum::IntoEnumIterator;
+
+    use crate::{
+        ast::{
+            ArrayLiteral, BinaryOpKind, Expression, ExpressionKind, Literal, StatementKind,
+            UnaryOp, UnresolvedTypeData,
+        },
+        parser::{
+            parser::tests::{
+                expect_no_errors, get_single_error, get_single_error_reason,
+                get_source_with_error_span,
+            },
+            Parser, ParserErrorReason,
+        },
+        token::Token,
+    };
+
+    fn parse_expression_no_errors(src: &str) -> Expression {
+        let mut parser = Parser::for_str(src);
+        let expr = parser.parse_expression_or_error();
+        assert_eq!(expr.span.end() as usize, src.len());
+        expect_no_errors(&parser.errors);
+        expr
+    }
+
+    #[test]
+    fn parses_bool_literals() {
+        let src = "true";
+        let expr = parse_expression_no_errors(src);
+        assert!(matches!(expr.kind, ExpressionKind::Literal(Literal::Bool(true))));
+
+        let src = "false";
+        let expr = parse_expression_no_errors(src);
+        assert!(matches!(expr.kind, ExpressionKind::Literal(Literal::Bool(false))));
+    }
+
+    #[test]
+    fn parses_integer_literal() {
+        let src = "42";
+        let expr = parse_expression_no_errors(src);
+        let ExpressionKind::Literal(Literal::Integer(field, negative)) = expr.kind else {
+            panic!("Expected integer literal");
+        };
+        assert_eq!(field, 42_u128.into());
+        assert!(!negative);
+    }
+
+    #[test]
+    fn parses_negative_integer_literal() {
+        let src = "-42";
+        let expr = parse_expression_no_errors(src);
+        let ExpressionKind::Literal(Literal::Integer(field, negative)) = expr.kind else {
+            panic!("Expected integer literal");
+        };
+        assert_eq!(field, 42_u128.into());
+        assert!(negative);
+    }
+
+    #[test]
+    fn parses_parenthesized_expression() {
+        let src = "(42)";
+        let expr = parse_expression_no_errors(src);
+        let ExpressionKind::Parenthesized(expr) = expr.kind else {
+            panic!("Expected parenthesized expression");
+        };
+        let ExpressionKind::Literal(Literal::Integer(field, negative)) = expr.kind else {
+            panic!("Expected integer literal");
+        };
+        assert_eq!(field, 42_u128.into());
+        assert!(!negative);
+    }
+
+    #[test]
+    fn parses_unit() {
+        let src = "()";
+        let expr = parse_expression_no_errors(src);
+        assert!(matches!(expr.kind, ExpressionKind::Literal(Literal::Unit)));
+    }
+
+    #[test]
+    fn parses_str() {
+        let src = "\"hello\"";
+        let expr = parse_expression_no_errors(src);
+        let ExpressionKind::Literal(Literal::Str(string)) = expr.kind else {
+            panic!("Expected string literal");
+        };
+        assert_eq!(string, "hello");
+    }
+
+    #[test]
+    fn parses_raw_str() {
+        let src = "r#\"hello\"#";
+        let expr = parse_expression_no_errors(src);
+        let ExpressionKind::Literal(Literal::RawStr(string, n)) = expr.kind else {
+            panic!("Expected raw string literal");
+        };
+        assert_eq!(string, "hello");
+        assert_eq!(n, 1);
+    }
+
+    #[test]
+    fn parses_fmt_str() {
+        let src = "f\"hello\"";
+        let expr = parse_expression_no_errors(src);
+        let ExpressionKind::Literal(Literal::FmtStr(fragments, length)) = expr.kind else {
+            panic!("Expected format string literal");
+        };
+        assert_eq!(fragments[0].to_string(), "hello");
+        assert_eq!(length, 5);
+    }
+
+    #[test]
+    fn parses_tuple_expression() {
+        let src = "(1, 2)";
+        let expr = parse_expression_no_errors(src);
+        let ExpressionKind::Tuple(mut exprs) = expr.kind else {
+            panic!("Expected tuple expression");
+        };
+        assert_eq!(exprs.len(), 2);
+
+        let expr = exprs.remove(0);
+        let ExpressionKind::Literal(Literal::Integer(field, negative)) = expr.kind else {
+            panic!("Expected integer literal");
+        };
+        assert_eq!(field, 1_u128.into());
+        assert!(!negative);
+
+        let expr = exprs.remove(0);
+        let ExpressionKind::Literal(Literal::Integer(field, negative)) = expr.kind else {
+            panic!("Expected integer literal");
+        };
+        assert_eq!(field, 2_u128.into());
+        assert!(!negative);
+    }
+
+    #[test]
+    fn parses_block_expression_with_a_single_expression() {
+        let src = "{ 1 }";
+        let expr = parse_expression_no_errors(src);
+        let ExpressionKind::Block(mut block) = expr.kind else {
+            panic!("Expected block expression");
+        };
+        assert_eq!(block.statements.len(), 1);
+
+        let statement = block.statements.remove(0);
+        let StatementKind::Expression(expr) = statement.kind else {
+            panic!("Expected expression statement");
+        };
+
+        let ExpressionKind::Literal(Literal::Integer(field, negative)) = expr.kind else {
+            panic!("Expected integer literal");
+        };
+        assert_eq!(field, 1_u128.into());
+        assert!(!negative);
+    }
+
+    #[test]
+    fn parses_block_expression_with_multiple_statements() {
+        let src = "
+        {
+            let x = 1;
+            let y = 2;
+            3
+        }";
+        let expr = parse_expression_no_errors(src);
+        let ExpressionKind::Block(block) = expr.kind else {
+            panic!("Expected block expression");
+        };
+        assert_eq!(block.statements.len(), 3);
+        assert_eq!(block.statements[0].kind.to_string(), "let x = 1");
+        assert_eq!(block.statements[1].kind.to_string(), "let y = 2");
+        assert_eq!(block.statements[2].kind.to_string(), "3");
+    }
+
+    #[test]
+    fn parses_block_expression_adds_semicolons() {
+        let src = "
+        {
+            1
+            2
+            3
+        }";
+        let mut parser = Parser::for_str(src);
+        let expr = parser.parse_expression_or_error();
+        assert_eq!(expr.span.end() as usize, src.len());
+        assert_eq!(parser.errors.len(), 2);
+        assert!(matches!(
+            parser.errors[0].reason(),
+            Some(ParserErrorReason::MissingSeparatingSemi)
+        ));
+        assert!(matches!(
+            parser.errors[1].reason(),
+            Some(ParserErrorReason::MissingSeparatingSemi)
+        ));
+        let ExpressionKind::Block(block) = expr.kind else {
+            panic!("Expected block expression");
+        };
+        assert_eq!(block.statements.len(), 3);
+    }
+
+    #[test]
+    fn parses_unsafe_expression() {
+        let src = "unsafe { 1 }";
+        let expr = parse_expression_no_errors(src);
+        let ExpressionKind::Unsafe(block, _) = expr.kind else {
+            panic!("Expected unsafe expression");
+        };
+        assert_eq!(block.statements.len(), 1);
+    }
+
+    #[test]
+    fn parses_unclosed_parentheses() {
+        let src = "
+        ( 
+         ^
+        ";
+        let (src, span) = get_source_with_error_span(src);
+        let mut parser = Parser::for_str(&src);
+        parser.parse_expression();
+        let error = get_single_error(&parser.errors, span);
+        assert_eq!(error.to_string(), "Expected an expression but found end of input");
+    }
+
+    #[test]
+    fn parses_missing_comma_in_tuple() {
+        let src = "
+        (1 2)
+           ^
+        ";
+        let (src, span) = get_source_with_error_span(src);
+        let mut parser = Parser::for_str(&src);
+        parser.parse_expression();
+        let reason = get_single_error_reason(&parser.errors, span);
+        let ParserErrorReason::ExpectedTokenSeparatingTwoItems { token, items } = reason else {
+            panic!("Expected a different error");
+        };
+        assert_eq!(token, &Token::Comma);
+        assert_eq!(*items, "expressions");
+    }
+
+    #[test]
+    fn parses_empty_array_expression() {
+        let src = "[]";
+        let expr = parse_expression_no_errors(src);
+        let ExpressionKind::Literal(Literal::Array(ArrayLiteral::Standard(exprs))) = expr.kind
+        else {
+            panic!("Expected array literal");
+        };
+        assert!(exprs.is_empty());
+    }
+
+    #[test]
+    fn parses_array_expression_with_one_element() {
+        let src = "[1]";
+        let expr = parse_expression_no_errors(src);
+        let ExpressionKind::Literal(Literal::Array(ArrayLiteral::Standard(exprs))) = expr.kind
+        else {
+            panic!("Expected array literal");
+        };
+        assert_eq!(exprs.len(), 1);
+        assert_eq!(exprs[0].to_string(), "1");
+    }
+
+    #[test]
+    fn parses_array_expression_with_two_elements() {
+        let src = "[1, 3]";
+        let expr = parse_expression_no_errors(src);
+        let ExpressionKind::Literal(Literal::Array(ArrayLiteral::Standard(exprs))) = expr.kind
+        else {
+            panic!("Expected array literal");
+        };
+        assert_eq!(exprs.len(), 2);
+        assert_eq!(exprs[0].to_string(), "1");
+        assert_eq!(exprs[1].to_string(), "3");
+    }
+
+    #[test]
+    fn parses_array_expression_with_two_elements_missing_comma() {
+        let src = "
+        [1 3]
+           ^
+        ";
+        let (src, span) = get_source_with_error_span(src);
+        let mut parser = Parser::for_str(&src);
+        let expr = parser.parse_expression_or_error();
+        assert_eq!(expr.span.end() as usize, src.len());
+
+        let reason = get_single_error_reason(&parser.errors, span);
+        let ParserErrorReason::ExpectedTokenSeparatingTwoItems { token, items } = reason else {
+            panic!("Expected a different error");
+        };
+        assert_eq!(token, &Token::Comma);
+        assert_eq!(*items, "expressions");
+
+        let ExpressionKind::Literal(Literal::Array(ArrayLiteral::Standard(exprs))) = expr.kind
+        else {
+            panic!("Expected array literal");
+        };
+        assert_eq!(exprs.len(), 2);
+        assert_eq!(exprs[0].to_string(), "1");
+        assert_eq!(exprs[1].to_string(), "3");
+    }
+
+    #[test]
+    fn parses_repeated_array_expression() {
+        let src = "[1; 10]";
+        let expr = parse_expression_no_errors(src);
+        let ExpressionKind::Literal(Literal::Array(ArrayLiteral::Repeated {
+            repeated_element,
+            length,
+        })) = expr.kind
+        else {
+            panic!("Expected array literal");
+        };
+        assert_eq!(repeated_element.to_string(), "1");
+        assert_eq!(length.to_string(), "10");
+    }
+
+    #[test]
+    fn parses_empty_slice_expression() {
+        let src = "&[]";
+        let expr = parse_expression_no_errors(src);
+        let ExpressionKind::Literal(Literal::Slice(ArrayLiteral::Standard(exprs))) = expr.kind
+        else {
+            panic!("Expected slice literal");
+        };
+        assert!(exprs.is_empty());
+    }
+
+    #[test]
+    fn parses_variable_ident() {
+        let src = "foo";
+        let expr = parse_expression_no_errors(src);
+        let ExpressionKind::Variable(path) = expr.kind else {
+            panic!("Expected variable");
+        };
+        assert_eq!(path.to_string(), "foo");
+    }
+
+    #[test]
+    fn parses_variable_path() {
+        let src = "foo::bar";
+        let expr = parse_expression_no_errors(src);
+        let ExpressionKind::Variable(path) = expr.kind else {
+            panic!("Expected variable");
+        };
+        assert_eq!(path.to_string(), "foo::bar");
+    }
+
+    #[test]
+    fn parses_variable_path_with_turbofish() {
+        let src = "foo::<9>";
+        parse_expression_no_errors(src);
+    }
+
+    #[test]
+    fn parses_mutable_ref() {
+        let src = "&mut foo";
+        let expr = parse_expression_no_errors(src);
+        let ExpressionKind::Prefix(prefix) = expr.kind else {
+            panic!("Expected prefix expression");
+        };
+        assert!(matches!(prefix.operator, UnaryOp::MutableReference));
+
+        let ExpressionKind::Variable(path) = prefix.rhs.kind else {
+            panic!("Expected variable");
+        };
+        assert_eq!(path.to_string(), "foo");
+    }
+
+    #[test]
+    fn parses_minus() {
+        let src = "-foo";
+        let expr = parse_expression_no_errors(src);
+        let ExpressionKind::Prefix(prefix) = expr.kind else {
+            panic!("Expected prefix expression");
+        };
+        assert!(matches!(prefix.operator, UnaryOp::Minus));
+
+        let ExpressionKind::Variable(path) = prefix.rhs.kind else {
+            panic!("Expected variable");
+        };
+        assert_eq!(path.to_string(), "foo");
+    }
+
+    #[test]
+    fn parses_not() {
+        let src = "!foo";
+        let expr = parse_expression_no_errors(src);
+        let ExpressionKind::Prefix(prefix) = expr.kind else {
+            panic!("Expected prefix expression");
+        };
+        assert!(matches!(prefix.operator, UnaryOp::Not));
+
+        let ExpressionKind::Variable(path) = prefix.rhs.kind else {
+            panic!("Expected variable");
+        };
+        assert_eq!(path.to_string(), "foo");
+    }
+
+    #[test]
+    fn parses_dereference() {
+        let src = "*foo";
+        let expr = parse_expression_no_errors(src);
+        let ExpressionKind::Prefix(prefix) = expr.kind else {
+            panic!("Expected prefix expression");
+        };
+        assert!(matches!(prefix.operator, UnaryOp::Dereference { implicitly_added: false }));
+
+        let ExpressionKind::Variable(path) = prefix.rhs.kind else {
+            panic!("Expected variable");
+        };
+        assert_eq!(path.to_string(), "foo");
+    }
+
+    #[test]
+    fn parses_quote() {
+        let src = "quote { 1 }";
+        let expr = parse_expression_no_errors(src);
+        let ExpressionKind::Quote(tokens) = expr.kind else {
+            panic!("Expected quote expression");
+        };
+        assert_eq!(tokens.0.len(), 1);
+    }
+
+    #[test]
+    fn parses_call() {
+        let src = "foo(1, 2)";
+        let expr = parse_expression_no_errors(src);
+        let ExpressionKind::Call(call) = expr.kind else {
+            panic!("Expected call expression");
+        };
+        assert_eq!(call.func.to_string(), "foo");
+        assert_eq!(call.arguments.len(), 2);
+        assert!(!call.is_macro_call);
+    }
+
+    #[test]
+    fn parses_call_missing_comma() {
+        let src = "
+        foo(1 2)
+              ^
+        ";
+        let (src, span) = get_source_with_error_span(src);
+        let mut parser = Parser::for_str(&src);
+        let expr = parser.parse_expression_or_error();
+        assert_eq!(expr.span.end() as usize, src.len());
+        let reason = get_single_error_reason(&parser.errors, span);
+        let ParserErrorReason::ExpectedTokenSeparatingTwoItems { token, items } = reason else {
+            panic!("Expected a different error");
+        };
+        assert_eq!(token, &Token::Comma);
+        assert_eq!(*items, "arguments");
+
+        let ExpressionKind::Call(call) = expr.kind else {
+            panic!("Expected call expression");
+        };
+        assert_eq!(call.func.to_string(), "foo");
+        assert_eq!(call.arguments.len(), 2);
+        assert!(!call.is_macro_call);
+    }
+
+    #[test]
+    fn parses_call_with_wrong_expression() {
+        let src = "foo(]) ";
+        let mut parser = Parser::for_str(src);
+        parser.parse_expression_or_error();
+        assert!(!parser.errors.is_empty());
+    }
+
+    #[test]
+    fn parses_call_with_turbofish() {
+        let src = "foo::<T>(1, 2)";
+        let expr = parse_expression_no_errors(src);
+        let ExpressionKind::Call(call) = expr.kind else {
+            panic!("Expected call expression");
+        };
+        assert_eq!(call.func.to_string(), "foo::<T>");
+        assert_eq!(call.arguments.len(), 2);
+        assert!(!call.is_macro_call);
+    }
+
+    #[test]
+    fn parses_macro_call() {
+        let src = "foo!(1, 2)";
+        let expr = parse_expression_no_errors(src);
+        let ExpressionKind::Call(call) = expr.kind else {
+            panic!("Expected call expression");
+        };
+        assert_eq!(call.func.to_string(), "foo");
+        assert_eq!(call.arguments.len(), 2);
+        assert!(call.is_macro_call);
+    }
+
+    #[test]
+    fn parses_member_access() {
+        let src = "foo.bar";
+        let expr = parse_expression_no_errors(src);
+        let ExpressionKind::MemberAccess(member_access) = expr.kind else {
+            panic!("Expected member access expression");
+        };
+        assert_eq!(member_access.lhs.to_string(), "foo");
+        assert_eq!(member_access.rhs.to_string(), "bar");
+    }
+
+    #[test]
+    fn parses_method_call() {
+        let src = "foo.bar(1, 2)";
+        let expr = parse_expression_no_errors(src);
+        let ExpressionKind::MethodCall(method_call) = expr.kind else {
+            panic!("Expected method call expression");
+        };
+        assert_eq!(method_call.object.to_string(), "foo");
+        assert_eq!(method_call.method_name.to_string(), "bar");
+        assert!(!method_call.is_macro_call);
+        assert_eq!(method_call.arguments.len(), 2);
+        assert!(method_call.generics.is_none());
+    }
+
+    #[test]
+    fn parses_method_call_with_turbofish() {
+        let src = "foo.bar::<T, U>(1, 2)";
+        let expr = parse_expression_no_errors(src);
+        let ExpressionKind::MethodCall(method_call) = expr.kind else {
+            panic!("Expected method call expression");
+        };
+        assert_eq!(method_call.object.to_string(), "foo");
+        assert_eq!(method_call.method_name.to_string(), "bar");
+        assert!(!method_call.is_macro_call);
+        assert_eq!(method_call.arguments.len(), 2);
+        assert_eq!(method_call.generics.unwrap().len(), 2);
+    }
+
+    #[test]
+    fn parses_method_macro_call() {
+        let src = "foo.bar!(1, 2)";
+        let expr = parse_expression_no_errors(src);
+        let ExpressionKind::MethodCall(method_call) = expr.kind else {
+            panic!("Expected method call expression");
+        };
+        assert_eq!(method_call.object.to_string(), "foo");
+        assert_eq!(method_call.method_name.to_string(), "bar");
+        assert!(method_call.is_macro_call);
+        assert_eq!(method_call.arguments.len(), 2);
+        assert!(method_call.generics.is_none());
+    }
+
+    #[test]
+    fn parses_empty_constructor() {
+        let src = "Foo {}";
+        let expr = parse_expression_no_errors(src);
+        let ExpressionKind::Constructor(constructor) = expr.kind else {
+            panic!("Expected constructor");
+        };
+        assert_eq!(constructor.typ.to_string(), "Foo");
+        assert!(constructor.fields.is_empty());
+    }
+
+    #[test]
+    fn parses_constructor_with_fields() {
+        let src = "Foo { x: 1, y, z: 2 }";
+        let expr = parse_expression_no_errors(src);
+        let ExpressionKind::Constructor(mut constructor) = expr.kind else {
+            panic!("Expected constructor");
+        };
+        assert_eq!(constructor.typ.to_string(), "Foo");
+        assert_eq!(constructor.fields.len(), 3);
+
+        let (name, expr) = constructor.fields.remove(0);
+        assert_eq!(name.to_string(), "x");
+        assert_eq!(expr.to_string(), "1");
+
+        let (name, expr) = constructor.fields.remove(0);
+        assert_eq!(name.to_string(), "y");
+        assert_eq!(expr.to_string(), "y");
+
+        let (name, expr) = constructor.fields.remove(0);
+        assert_eq!(name.to_string(), "z");
+        assert_eq!(expr.to_string(), "2");
+    }
+
+    #[test]
+    fn parses_constructor_with_fields_recovers_if_assign_instead_of_colon() {
+        let src = "
+        Foo { x = 1, y }
+                ^
+        ";
+        let (src, span) = get_source_with_error_span(src);
+        let mut parser = Parser::for_str(&src);
+        let expr = parser.parse_expression_or_error();
+
+        let error = get_single_error(&parser.errors, span);
+        assert_eq!(error.to_string(), "Expected a ':' but found '='");
+
+        let ExpressionKind::Constructor(mut constructor) = expr.kind else {
+            panic!("Expected constructor");
+        };
+        assert_eq!(constructor.typ.to_string(), "Foo");
+        assert_eq!(constructor.fields.len(), 2);
+
+        let (name, expr) = constructor.fields.remove(0);
+        assert_eq!(name.to_string(), "x");
+        assert_eq!(expr.to_string(), "1");
+
+        let (name, expr) = constructor.fields.remove(0);
+        assert_eq!(name.to_string(), "y");
+        assert_eq!(expr.to_string(), "y");
+    }
+
+    #[test]
+    fn parses_constructor_recovers_if_double_colon_instead_of_colon() {
+        let src = "
+        Foo { x: 1, y:: z }
+                     ^^
+        ";
+        let (src, span) = get_source_with_error_span(src);
+        let mut parser = Parser::for_str(&src);
+        let expr = parser.parse_expression_or_error();
+
+        let error = get_single_error(&parser.errors, span);
+        assert_eq!(error.to_string(), "Expected a ':' but found '::'");
+
+        let ExpressionKind::Constructor(mut constructor) = expr.kind else {
+            panic!("Expected constructor");
+        };
+        assert_eq!(constructor.typ.to_string(), "Foo");
+        assert_eq!(constructor.fields.len(), 2);
+
+        let (name, expr) = constructor.fields.remove(0);
+        assert_eq!(name.to_string(), "x");
+        assert_eq!(expr.to_string(), "1");
+
+        let (name, expr) = constructor.fields.remove(0);
+        assert_eq!(name.to_string(), "y");
+        assert_eq!(expr.to_string(), "z");
+    }
+
+    #[test]
+    fn parses_parses_if_true() {
+        let src = "if true { 1 }";
+        let expr = parse_expression_no_errors(src);
+        let ExpressionKind::If(if_expr) = expr.kind else {
+            panic!("Expected if");
+        };
+        assert_eq!(if_expr.condition.to_string(), "true");
+        let ExpressionKind::Block(block_expr) = if_expr.consequence.kind else {
+            panic!("Expected block");
+        };
+        assert_eq!(block_expr.statements.len(), 1);
+        assert_eq!(block_expr.statements[0].kind.to_string(), "1");
+        assert!(if_expr.alternative.is_none());
+    }
+
+    #[test]
+    fn parses_parses_if_var() {
+        let src = "if foo { 1 }";
+        let expr = parse_expression_no_errors(src);
+        let ExpressionKind::If(if_expr) = expr.kind else {
+            panic!("Expected if");
+        };
+        assert_eq!(if_expr.condition.to_string(), "foo");
+    }
+
+    #[test]
+    fn parses_parses_if_else() {
+        let src = "if true { 1 } else { 2 }";
+        let expr = parse_expression_no_errors(src);
+        let ExpressionKind::If(if_expr) = expr.kind else {
+            panic!("Expected if");
+        };
+        assert_eq!(if_expr.condition.to_string(), "true");
+        assert!(if_expr.alternative.is_some());
+    }
+
+    #[test]
+    fn parses_parses_if_else_if() {
+        let src = "if true { 1 } else if false { 2 } else { 3 }";
+        let expr = parse_expression_no_errors(src);
+        let ExpressionKind::If(if_expr) = expr.kind else {
+            panic!("Expected if");
+        };
+        assert_eq!(if_expr.condition.to_string(), "true");
+        let ExpressionKind::If(..) = if_expr.alternative.unwrap().kind else {
+            panic!("Expected if");
+        };
+    }
+
+    #[test]
+    fn parses_cast() {
+        let src = "1 as u8";
+        let expr = parse_expression_no_errors(src);
+        let ExpressionKind::Cast(cast_expr) = expr.kind else {
+            panic!("Expected cast");
+        };
+        assert_eq!(cast_expr.lhs.to_string(), "1");
+        assert_eq!(cast_expr.r#type.to_string(), "u8");
+    }
+
+    #[test]
+    fn parses_cast_missing_type() {
+        let src = "
+        1 as 
+            ^
+        ";
+        let (src, span) = get_source_with_error_span(src);
+        let mut parser = Parser::for_str(&src);
+        parser.parse_expression();
+        let error = get_single_error(&parser.errors, span);
+        assert_eq!(error.to_string(), "Expected a type but found end of input");
+    }
+
+    #[test]
+    fn parses_index() {
+        let src = "1[2]";
+        let expr = parse_expression_no_errors(src);
+        let ExpressionKind::Index(index_expr) = expr.kind else {
+            panic!("Expected index");
+        };
+        assert_eq!(index_expr.collection.to_string(), "1");
+        assert_eq!(index_expr.index.to_string(), "2");
+    }
+
+    #[test]
+    fn parses_operators() {
+        for operator in BinaryOpKind::iter() {
+            let src = format!("1 {operator} 2");
+            let mut parser = Parser::for_str(&src);
+            let expr = parser.parse_expression_or_error();
+            assert_eq!(expr.span.end() as usize, src.len());
+            assert!(parser.errors.is_empty(), "Expected no errors for {operator}");
+            let ExpressionKind::Infix(infix_expr) = expr.kind else {
+                panic!("Expected infix for {operator}");
+            };
+            assert_eq!(infix_expr.lhs.to_string(), "1");
+            assert_eq!(infix_expr.operator.contents, operator);
+            assert_eq!(infix_expr.rhs.to_string(), "2");
+        }
+    }
+
+    #[test]
+    fn parses_operator_precedence() {
+        // This test produces a gigantic expression with lots of infix expressions without parentheses.
+        // We parse it, then we transform that to a string. Because `InfixExpression::to_string()` adds parentheses
+        // around it, we can check the operator precedence is correct by checking where parentheses were placed.
+        let multiply_or_divide_or_modulo = "1 * 2 / 3 % 4";
+        let expected_multiply_or_divide_or_modulo = "(((1 * 2) / 3) % 4)";
+
+        let add_or_subtract = format!("{multiply_or_divide_or_modulo} + {multiply_or_divide_or_modulo} - {multiply_or_divide_or_modulo}");
+        let expected_add_or_subtract = format!("(({expected_multiply_or_divide_or_modulo} + {expected_multiply_or_divide_or_modulo}) - {expected_multiply_or_divide_or_modulo})");
+
+        let shift = format!("{add_or_subtract} << {add_or_subtract} >> {add_or_subtract}");
+        let expected_shift = format!("(({expected_add_or_subtract} << {expected_add_or_subtract}) >> {expected_add_or_subtract})");
+
+        let less_or_greater = format!("{shift} < {shift} > {shift} <= {shift} >= {shift}");
+        let expected_less_or_greater = format!("(((({expected_shift} < {expected_shift}) > {expected_shift}) <= {expected_shift}) >= {expected_shift})");
+
+        let xor = format!("{less_or_greater} ^ {less_or_greater}");
+        let expected_xor = format!("({expected_less_or_greater} ^ {expected_less_or_greater})");
+
+        let and = format!("{xor} & {xor}");
+        let expected_and = format!("({expected_xor} & {expected_xor})");
+
+        let or = format!("{and} | {and}");
+        let expected_or = format!("({expected_and} | {expected_and})");
+
+        let equal_or_not_equal = format!("{or} == {or} != {or}");
+        let expected_equal_or_not_equal =
+            format!("(({expected_or} == {expected_or}) != {expected_or})");
+
+        let src = &equal_or_not_equal;
+        let expected_src = expected_equal_or_not_equal;
+
+        let expr = parse_expression_no_errors(src);
+        let ExpressionKind::Infix(infix_expr) = expr.kind else {
+            panic!("Expected infix");
+        };
+        assert_eq!(infix_expr.to_string(), expected_src);
+    }
+
+    #[test]
+    fn parses_empty_lambda() {
+        let src = "|| 1";
+        let expr = parse_expression_no_errors(src);
+        let ExpressionKind::Lambda(lambda) = expr.kind else {
+            panic!("Expected lambda");
+        };
+        assert!(lambda.parameters.is_empty());
+        assert_eq!(lambda.body.to_string(), "1");
+        assert!(matches!(lambda.return_type.typ, UnresolvedTypeData::Unspecified));
+    }
+
+    #[test]
+    fn parses_lambda_with_arguments() {
+        let src = "|x, y: Field| 1";
+        let expr = parse_expression_no_errors(src);
+        let ExpressionKind::Lambda(mut lambda) = expr.kind else {
+            panic!("Expected lambda");
+        };
+        assert_eq!(lambda.parameters.len(), 2);
+
+        let (pattern, typ) = lambda.parameters.remove(0);
+        assert_eq!(pattern.to_string(), "x");
+        assert!(matches!(typ.typ, UnresolvedTypeData::Unspecified));
+
+        let (pattern, typ) = lambda.parameters.remove(0);
+        assert_eq!(pattern.to_string(), "y");
+        assert!(matches!(typ.typ, UnresolvedTypeData::FieldElement));
+    }
+
+    #[test]
+    fn parses_lambda_with_return_type() {
+        let src = "|| -> Field 1";
+        let expr = parse_expression_no_errors(src);
+        let ExpressionKind::Lambda(lambda) = expr.kind else {
+            panic!("Expected lambda");
+        };
+        assert!(lambda.parameters.is_empty());
+        assert_eq!(lambda.body.to_string(), "1");
+        assert!(matches!(lambda.return_type.typ, UnresolvedTypeData::FieldElement));
+    }
+
+    #[test]
+    fn parses_as_trait_path() {
+        let src = "<Field as foo::Bar>::baz";
+        let expr = parse_expression_no_errors(src);
+        let ExpressionKind::AsTraitPath(as_trait_path) = expr.kind else {
+            panic!("Expected as_trait_path")
+        };
+        assert_eq!(as_trait_path.typ.typ.to_string(), "Field");
+        assert_eq!(as_trait_path.trait_path.to_string(), "foo::Bar");
+        assert!(as_trait_path.trait_generics.is_empty());
+        assert_eq!(as_trait_path.impl_item.to_string(), "baz");
+    }
+
+    #[test]
+    fn parses_comptime_expression() {
+        let src = "comptime { 1 }";
+        let expr = parse_expression_no_errors(src);
+        let ExpressionKind::Comptime(block, _) = expr.kind else {
+            panic!("Expected comptime block");
+        };
+        assert_eq!(block.statements.len(), 1);
+    }
+
+    #[test]
+    fn parses_type_path() {
+        let src = "Field::foo";
+        let expr = parse_expression_no_errors(src);
+        let ExpressionKind::TypePath(type_path) = expr.kind else {
+            panic!("Expected type_path");
+        };
+        assert_eq!(type_path.typ.to_string(), "Field");
+        assert_eq!(type_path.item.to_string(), "foo");
+        assert!(type_path.turbofish.is_none());
+    }
+
+    #[test]
+    fn parses_type_path_with_generics() {
+        let src = "Field::foo::<T>";
+        let expr = parse_expression_no_errors(src);
+        let ExpressionKind::TypePath(type_path) = expr.kind else {
+            panic!("Expected type_path");
+        };
+        assert_eq!(type_path.typ.to_string(), "Field");
+        assert_eq!(type_path.item.to_string(), "foo");
+        assert!(type_path.turbofish.is_some());
+    }
+
+    #[test]
+    fn parses_unquote_var() {
+        let src = "$foo::bar";
+        let expr = parse_expression_no_errors(src);
+        let ExpressionKind::Unquote(expr) = expr.kind else {
+            panic!("Expected unquote");
+        };
+        let ExpressionKind::Variable(path) = expr.kind else {
+            panic!("Expected unquote");
+        };
+        assert_eq!(path.to_string(), "foo::bar");
+    }
+
+    #[test]
+    fn parses_unquote_expr() {
+        let src = "$(1 + 2)";
+        let expr = parse_expression_no_errors(src);
+        let ExpressionKind::Unquote(expr) = expr.kind else {
+            panic!("Expected unquote");
+        };
+        assert_eq!(expr.kind.to_string(), "((1 + 2))");
+    }
+}
diff --git a/compiler/noirc_frontend/src/parser/parser/function.rs b/compiler/noirc_frontend/src/parser/parser/function.rs
index dc8b968ea7a..438757b5d79 100644
--- a/compiler/noirc_frontend/src/parser/parser/function.rs
+++ b/compiler/noirc_frontend/src/parser/parser/function.rs
@@ -1,319 +1,493 @@
-use super::{
-    attributes::{attributes, validate_attributes},
-    block, fresh_statement, ident, keyword, maybe_comp_time, nothing, parameter_name_recovery,
-    parameter_recovery, parenthesized, parse_type, pattern,
-    primitives::token_kind,
-    self_parameter,
-    visibility::{item_visibility, visibility},
-    where_clause, NoirParser,
-};
-use crate::token::{Keyword, Token, TokenKind};
-use crate::{
-    ast::{BlockExpression, IntegerBitSize},
-    parser::spanned,
+use crate::ast::{
+    BlockExpression, GenericTypeArgs, Ident, Path, Pattern, UnresolvedTraitConstraint,
+    UnresolvedType,
 };
+use crate::token::{Attribute, Attributes, Keyword, Token};
+use crate::{ast::UnresolvedGenerics, parser::labels::ParsingRuleLabel};
 use crate::{
     ast::{
-        FunctionDefinition, FunctionReturnType, ItemVisibility, NoirFunction, Param, Visibility,
+        FunctionDefinition, FunctionReturnType, ItemVisibility, NoirFunction, Param,
+        UnresolvedTypeData, Visibility,
     },
-    macros_api::UnresolvedTypeData,
-    parser::{ParserError, ParserErrorReason},
-};
-use crate::{
-    ast::{Signedness, UnresolvedGeneric, UnresolvedGenerics},
-    parser::labels::ParsingRuleLabel,
+    parser::ParserErrorReason,
 };
+use acvm::AcirField;
 
-use chumsky::prelude::*;
 use noirc_errors::Span;
 
-/// function_definition: attribute function_modifiers 'fn' ident generics '(' function_parameters ')' function_return_type block
-///                      function_modifiers 'fn' ident generics '(' function_parameters ')' function_return_type block
-pub(super) fn function_definition(allow_self: bool) -> impl NoirParser<NoirFunction> {
-    let body_or_error =
-        spanned(block(fresh_statement()).or_not()).validate(|(body, body_span), span, emit| {
-            if let Some(body) = body {
-                (body, body_span)
-            } else {
-                emit(ParserError::with_reason(
-                    ParserErrorReason::ExpectedLeftBraceOrArrowAfterFunctionParameters,
-                    span,
-                ));
-                (BlockExpression { statements: vec![] }, Span::from(span.end()..span.end()))
-            }
-        });
-
-    attributes()
-        .then(function_modifiers())
-        .then_ignore(keyword(Keyword::Fn))
-        .then(ident())
-        .then(generics())
-        .then(
-            parenthesized(function_parameters(allow_self))
-                .then(function_return_type())
-                .then(where_clause())
-                .then(body_or_error)
-                // Allow parsing just `fn foo` for recovery and LSP autocompletion
-                .or_not(),
+use super::parse_many::separated_by_comma_until_right_paren;
+use super::pattern::SelfPattern;
+use super::{pattern::PatternOrSelf, Parser};
+
+pub(crate) struct FunctionDefinitionWithOptionalBody {
+    pub(crate) name: Ident,
+    pub(crate) generics: UnresolvedGenerics,
+    pub(crate) parameters: Vec<Param>,
+    pub(crate) body: Option<BlockExpression>,
+    pub(crate) span: Span,
+    pub(crate) where_clause: Vec<UnresolvedTraitConstraint>,
+    pub(crate) return_type: FunctionReturnType,
+    pub(crate) return_visibility: Visibility,
+}
+
+impl<'a> Parser<'a> {
+    /// Function = 'fn' identifier Generics FunctionParameters ( '->' Visibility Type )? WhereClause ( Block | ';' )
+    pub(crate) fn parse_function(
+        &mut self,
+        attributes: Vec<(Attribute, Span)>,
+        visibility: ItemVisibility,
+        is_comptime: bool,
+        is_unconstrained: bool,
+        allow_self: bool,
+    ) -> NoirFunction {
+        self.parse_function_definition(
+            attributes,
+            visibility,
+            is_comptime,
+            is_unconstrained,
+            allow_self,
         )
-        .validate(|args, span, emit| {
-            let (
-                (((attributes, (is_unconstrained, visibility, is_comptime)), name), generics),
-                params_and_others,
-            ) = args;
-
-            // Validate collected attributes, filtering them into function and secondary variants
-            let attributes = validate_attributes(attributes, span, emit);
-
-            let function_definition = if let Some(params_and_others) = params_and_others {
-                let (
-                    ((parameters, (return_visibility, return_type)), where_clause),
-                    (body, body_span),
-                ) = params_and_others;
-
-                FunctionDefinition {
-                    span: body_span,
-                    name,
-                    attributes,
-                    is_unconstrained,
-                    visibility,
-                    is_comptime,
-                    generics,
-                    parameters,
-                    body,
-                    where_clause,
-                    return_type,
-                    return_visibility,
-                }
+        .into()
+    }
+
+    pub(crate) fn parse_function_definition(
+        &mut self,
+        attributes: Vec<(Attribute, Span)>,
+        visibility: ItemVisibility,
+        is_comptime: bool,
+        is_unconstrained: bool,
+        allow_self: bool,
+    ) -> FunctionDefinition {
+        let attributes = self.validate_attributes(attributes);
+
+        let func = self.parse_function_definition_with_optional_body(
+            false, // allow optional body
+            allow_self,
+        );
+
+        FunctionDefinition {
+            name: func.name,
+            attributes,
+            is_unconstrained,
+            is_comptime,
+            visibility,
+            generics: func.generics,
+            parameters: func.parameters,
+            body: func.body.unwrap_or_else(empty_body),
+            span: func.span,
+            where_clause: func.where_clause,
+            return_type: func.return_type,
+            return_visibility: func.return_visibility,
+        }
+    }
+
+    pub(super) fn parse_function_definition_with_optional_body(
+        &mut self,
+        allow_optional_body: bool,
+        allow_self: bool,
+    ) -> FunctionDefinitionWithOptionalBody {
+        let Some(name) = self.eat_ident() else {
+            self.expected_identifier();
+            return empty_function(self.previous_token_span);
+        };
+
+        let generics = self.parse_generics();
+        let parameters = self.parse_function_parameters(allow_self);
+
+        let (return_type, return_visibility) = if self.eat(Token::Arrow) {
+            let visibility = self.parse_visibility();
+            (FunctionReturnType::Ty(self.parse_type_or_error()), visibility)
+        } else {
+            (FunctionReturnType::Default(self.span_at_previous_token_end()), Visibility::Private)
+        };
+
+        let where_clause = self.parse_where_clause();
+
+        let body_start_span = self.current_token_span;
+        let body = if self.eat_semicolons() {
+            if !allow_optional_body {
+                self.push_error(ParserErrorReason::ExpectedFunctionBody, body_start_span);
+            }
+
+            None
+        } else {
+            Some(self.parse_block().unwrap_or_else(empty_body))
+        };
+
+        FunctionDefinitionWithOptionalBody {
+            name,
+            generics,
+            parameters,
+            body,
+            span: self.span_since(body_start_span),
+            where_clause,
+            return_type,
+            return_visibility,
+        }
+    }
+
+    /// FunctionParameters = '(' FunctionParametersList? ')'
+    ///
+    /// FunctionParametersList = FunctionParameter ( ',' FunctionParameter )* ','?
+    ///
+    /// FunctionParameter = Visibility PatternOrSelf ':' Type
+    fn parse_function_parameters(&mut self, allow_self: bool) -> Vec<Param> {
+        if !self.eat_left_paren() {
+            return Vec::new();
+        }
+
+        self.parse_many("parameters", separated_by_comma_until_right_paren(), |parser| {
+            parser.parse_function_parameter(allow_self)
+        })
+    }
+
+    fn parse_function_parameter(&mut self, allow_self: bool) -> Option<Param> {
+        loop {
+            let start_span = self.current_token_span;
+
+            let pattern_or_self = if allow_self {
+                self.parse_pattern_or_self()
             } else {
-                emit(ParserError::with_reason(
-                    ParserErrorReason::ExpectedLeftParenOrLeftBracketAfterFunctionName,
-                    span,
-                ));
-
-                let empty_span = Span::from(span.end()..span.end());
-                FunctionDefinition {
-                    span: empty_span,
-                    name,
-                    attributes,
-                    is_unconstrained,
-                    visibility,
-                    is_comptime,
-                    generics,
-                    parameters: Vec::new(),
-                    body: BlockExpression { statements: vec![] },
-                    where_clause: Vec::new(),
-                    return_type: FunctionReturnType::Default(empty_span),
-                    return_visibility: Visibility::Private,
+                self.parse_pattern().map(PatternOrSelf::Pattern)
+            };
+
+            let Some(pattern_or_self) = pattern_or_self else {
+                self.expected_label(ParsingRuleLabel::Pattern);
+
+                // Let's try with the next token
+                self.bump();
+                if self.at_eof() {
+                    return None;
+                } else {
+                    continue;
                 }
             };
-            function_definition.into()
-        })
-}
 
-/// function_modifiers: 'unconstrained'? (visibility)?
-///
-/// returns (is_unconstrained, visibility) for whether each keyword was present
-pub(super) fn function_modifiers() -> impl NoirParser<(bool, ItemVisibility, bool)> {
-    keyword(Keyword::Unconstrained).or_not().then(item_visibility()).then(maybe_comp_time()).map(
-        |((unconstrained, visibility), comptime)| (unconstrained.is_some(), visibility, comptime),
-    )
-}
+            return Some(match pattern_or_self {
+                PatternOrSelf::Pattern(pattern) => self.pattern_param(pattern, start_span),
+                PatternOrSelf::SelfPattern(self_pattern) => self.self_pattern_param(self_pattern),
+            });
+        }
+    }
 
-pub(super) fn numeric_generic() -> impl NoirParser<UnresolvedGeneric> {
-    keyword(Keyword::Let)
-        .ignore_then(ident())
-        .then_ignore(just(Token::Colon))
-        .then(parse_type())
-        .map(|(ident, typ)| UnresolvedGeneric::Numeric { ident, typ })
-        .validate(|generic, span, emit| {
-            if let UnresolvedGeneric::Numeric { typ, .. } = &generic {
-                if let UnresolvedTypeData::Integer(signedness, bit_size) = typ.typ {
-                    if matches!(signedness, Signedness::Signed)
-                        || matches!(bit_size, IntegerBitSize::SixtyFour)
-                    {
-                        emit(ParserError::with_reason(
-                            ParserErrorReason::ForbiddenNumericGenericType,
-                            span,
-                        ));
-                    }
+    fn pattern_param(&mut self, pattern: Pattern, start_span: Span) -> Param {
+        let (visibility, typ) = if !self.eat_colon() {
+            self.push_error(
+                ParserErrorReason::MissingTypeForFunctionParameter,
+                Span::from(pattern.span().start()..self.current_token_span.end()),
+            );
+
+            let visibility = Visibility::Private;
+            let typ = UnresolvedType { typ: UnresolvedTypeData::Error, span: Span::default() };
+            (visibility, typ)
+        } else {
+            (self.parse_visibility(), self.parse_type_or_error())
+        };
+
+        Param { visibility, pattern, typ, span: self.span_since(start_span) }
+    }
+
+    fn self_pattern_param(&mut self, self_pattern: SelfPattern) -> Param {
+        let ident_span = self.previous_token_span;
+        let ident = Ident::new("self".to_string(), ident_span);
+        let path = Path::from_single("Self".to_owned(), ident_span);
+        let no_args = GenericTypeArgs::default();
+        let mut self_type = UnresolvedTypeData::Named(path, no_args, true).with_span(ident_span);
+        let mut pattern = Pattern::Identifier(ident);
+
+        if self_pattern.reference {
+            self_type =
+                UnresolvedTypeData::MutableReference(Box::new(self_type)).with_span(ident_span);
+        } else if self_pattern.mutable {
+            pattern = Pattern::Mutable(Box::new(pattern), ident_span, true);
+        }
+
+        Param {
+            visibility: Visibility::Private,
+            pattern,
+            typ: self_type,
+            span: self.span_since(ident_span),
+        }
+    }
+
+    /// Visibility
+    ///     = 'pub'
+    ///     | 'return_data'
+    ///     | 'call_data' '(' int ')'
+    ///     | nothing
+    fn parse_visibility(&mut self) -> Visibility {
+        if self.eat_keyword(Keyword::Pub) {
+            return Visibility::Public;
+        }
+
+        if self.eat_keyword(Keyword::ReturnData) {
+            return Visibility::ReturnData;
+        }
+
+        if self.eat_keyword(Keyword::CallData) {
+            if self.eat_left_paren() {
+                if let Some(int) = self.eat_int() {
+                    self.eat_or_error(Token::RightParen);
+
+                    let id = int.to_u128() as u32;
+                    return Visibility::CallData(id);
+                } else {
+                    self.expected_label(ParsingRuleLabel::Integer);
+                    self.eat_right_paren();
+                    return Visibility::CallData(0);
                 }
+            } else {
+                self.expected_token(Token::LeftParen);
+                return Visibility::CallData(0);
             }
-            generic
-        })
-}
+        }
 
-pub(super) fn generic_type() -> impl NoirParser<UnresolvedGeneric> {
-    ident().map(UnresolvedGeneric::Variable)
-}
+        Visibility::Private
+    }
+
+    fn validate_attributes(&mut self, attributes: Vec<(Attribute, Span)>) -> Attributes {
+        let mut function = None;
+        let mut secondary = Vec::new();
+
+        for (index, (attribute, span)) in attributes.into_iter().enumerate() {
+            match attribute {
+                Attribute::Function(attr) => {
+                    if function.is_none() {
+                        function = Some((attr, index));
+                    } else {
+                        self.push_error(ParserErrorReason::MultipleFunctionAttributesFound, span);
+                    }
+                }
+                Attribute::Secondary(attr) => secondary.push(attr),
+            }
+        }
 
-pub(super) fn resolved_generic() -> impl NoirParser<UnresolvedGeneric> {
-    token_kind(TokenKind::QuotedType).map_with_span(|token, span| match token {
-        Token::QuotedType(id) => UnresolvedGeneric::Resolved(id, span),
-        _ => unreachable!("token_kind(QuotedType) guarantees we parse a quoted type"),
-    })
+        Attributes { function, secondary }
+    }
 }
 
-pub(super) fn generic() -> impl NoirParser<UnresolvedGeneric> {
-    generic_type().or(numeric_generic()).or(resolved_generic())
+fn empty_function(span: Span) -> FunctionDefinitionWithOptionalBody {
+    FunctionDefinitionWithOptionalBody {
+        name: Ident::default(),
+        generics: Vec::new(),
+        parameters: Vec::new(),
+        body: None,
+        span: Span::from(span.end()..span.end()),
+        where_clause: Vec::new(),
+        return_type: FunctionReturnType::Default(Span::default()),
+        return_visibility: Visibility::Private,
+    }
 }
 
-/// non_empty_ident_list: ident ',' non_empty_ident_list
-///                     | ident
-///
-/// generics: '<' non_empty_ident_list '>'
-///         | %empty
-pub(super) fn generics() -> impl NoirParser<UnresolvedGenerics> {
-    generic()
-        .separated_by(just(Token::Comma))
-        .allow_trailing()
-        .delimited_by(just(Token::Less), just(Token::Greater))
-        .or_not()
-        .map(|opt| opt.unwrap_or_default())
+fn empty_body() -> BlockExpression {
+    BlockExpression { statements: Vec::new() }
 }
 
-pub(super) fn function_return_type() -> impl NoirParser<(Visibility, FunctionReturnType)> {
-    #[allow(deprecated)]
-    just(Token::Arrow).ignore_then(visibility()).then(spanned(parse_type())).or_not().map_with_span(
-        |ret, span| match ret {
-            Some((visibility, (ty, _))) => (visibility, FunctionReturnType::Ty(ty)),
-            None => (Visibility::Private, FunctionReturnType::Default(span)),
+#[cfg(test)]
+mod tests {
+    use crate::{
+        ast::{ItemVisibility, NoirFunction, UnresolvedTypeData, Visibility},
+        parser::{
+            parser::{
+                parse_program,
+                tests::{
+                    expect_no_errors, get_single_error, get_single_error_reason,
+                    get_source_with_error_span,
+                },
+            },
+            ItemKind, ParserErrorReason,
         },
-    )
-}
+    };
 
-fn function_parameters<'a>(allow_self: bool) -> impl NoirParser<Vec<Param>> + 'a {
-    let typ = parse_type().recover_via(parameter_recovery());
+    fn parse_function_no_error(src: &str) -> NoirFunction {
+        let (mut module, errors) = parse_program(src);
+        expect_no_errors(&errors);
+        assert_eq!(module.items.len(), 1);
+        let item = module.items.remove(0);
+        let ItemKind::Function(noir_function) = item.kind else {
+            panic!("Expected function");
+        };
+        noir_function
+    }
 
-    let full_parameter = pattern()
-        .recover_via(parameter_name_recovery())
-        .then_ignore(just(Token::Colon))
-        .then(visibility())
-        .then(typ)
-        .map_with_span(|((pattern, visibility), typ), span| Param {
-            visibility,
-            pattern,
-            typ,
-            span,
-        });
+    #[test]
+    fn parse_simple_function() {
+        let src = "fn foo() {}";
+        let noir_function = parse_function_no_error(src);
+        assert_eq!("foo", noir_function.def.name.to_string());
+        assert!(noir_function.def.parameters.is_empty());
+        assert!(noir_function.def.generics.is_empty());
+    }
 
-    let self_parameter = if allow_self { self_parameter().boxed() } else { nothing().boxed() };
+    #[test]
+    fn parse_function_with_generics() {
+        let src = "fn foo<A>() {}";
+        let noir_function = parse_function_no_error(src);
+        assert_eq!(noir_function.def.generics.len(), 1);
+    }
 
-    let parameter = full_parameter.or(self_parameter);
+    #[test]
+    fn parse_function_with_arguments() {
+        let src = "fn foo(x: Field, y: Field) {}";
+        let mut noir_function = parse_function_no_error(src);
+        assert_eq!(noir_function.def.parameters.len(), 2);
 
-    parameter
-        .separated_by(just(Token::Comma))
-        .allow_trailing()
-        .labelled(ParsingRuleLabel::Parameter)
-}
+        let param = noir_function.def.parameters.remove(0);
+        assert_eq!("x", param.pattern.to_string());
+        assert_eq!("Field", param.typ.to_string());
+        assert_eq!(param.visibility, Visibility::Private);
 
-#[cfg(test)]
-mod test {
-    use super::*;
-    use crate::parser::parser::test_helpers::*;
+        let param = noir_function.def.parameters.remove(0);
+        assert_eq!("y", param.pattern.to_string());
+        assert_eq!("Field", param.typ.to_string());
+        assert_eq!(param.visibility, Visibility::Private);
+    }
 
     #[test]
-    fn regression_skip_comment() {
-        parse_all(
-            function_definition(false),
-            vec![
-                "fn main(
-                // This comment should be skipped
-                x : Field,
-                // And this one
-                y : Field,
-            ) {
-            }",
-                "fn main(x : Field, y : Field,) {
-                foo::bar(
-                    // Comment for x argument
-                    x,
-                    // Comment for y argument
-                    y
-                )
-            }",
-            ],
-        );
+    fn parse_function_with_argument_pub_visibility() {
+        let src = "fn foo(x: pub Field) {}";
+        let mut noir_function = parse_function_no_error(src);
+        assert_eq!(noir_function.def.parameters.len(), 1);
+
+        let param = noir_function.def.parameters.remove(0);
+        assert_eq!("x", param.pattern.to_string());
+        assert_eq!("Field", param.typ.to_string());
+        assert_eq!(param.visibility, Visibility::Public);
     }
 
     #[test]
-    fn parse_function() {
-        parse_all(
-            function_definition(false),
-            vec![
-                "fn func_name() {}",
-                "fn f(foo: pub u8, y : pub Field) -> u8 { x + a }",
-                "fn f(f: pub Field, y : Field, z : Field) -> u8 { x + a }",
-                "fn func_name(f: Field, y : pub Field, z : pub [u8;5],) {}",
-                "fn f(f: pub Field, y : Field, z : Field) -> u8 { x + a }",
-                "fn f<T>(f: pub Field, y : T, z : Field) -> u8 { x + a }",
-                "fn func_name(x: [Field], y : [Field;2],y : pub [Field;2], z : pub [u8;5])  {}",
-                "fn main(x: pub u8, y: pub u8) -> pub [u8; 2] { [x, y] }",
-                "fn f(f: pub Field, y : Field, z : Field) -> u8 { x + a }",
-                "fn f<T>(f: pub Field, y : T, z : Field) -> u8 { x + a }",
-                "fn func_name<T>(f: Field, y : T) where T: SomeTrait {}",
-                "fn func_name<T>(f: Field, y : T) where T: SomeTrait + SomeTrait2 {}",
-                "fn func_name<T>(f: Field, y : T) where T: SomeTrait, T: SomeTrait2 {}",
-                "fn func_name<T>(f: Field, y : T) where T: SomeTrait<A> + SomeTrait2 {}",
-                "fn func_name<T>(f: Field, y : T) where T: SomeTrait<A, B> + SomeTrait2 {}",
-                "fn func_name<T>(f: Field, y : T) where T: SomeTrait<A, B> + SomeTrait2<C> {}",
-                "fn func_name<T>(f: Field, y : T) where T: SomeTrait + SomeTrait2<C> {}",
-                "fn func_name<T>(f: Field, y : T) where T: SomeTrait + SomeTrait2<C> + TraitY {}",
-                "fn func_name<T>(f: Field, y : T, z : U) where SomeStruct<T>: SomeTrait<U> {}",
-                // 'where u32: SomeTrait' is allowed in Rust.
-                // It will result in compiler error in case SomeTrait isn't implemented for u32.
-                "fn func_name<T>(f: Field, y : T) where u32: SomeTrait {}",
-                // A trailing plus is allowed by Rust, so we support it as well.
-                "fn func_name<T>(f: Field, y : T) where T: SomeTrait + {}",
-                // The following should produce compile error on later stage. From the parser's perspective it's fine
-                "fn func_name<A>(f: Field, y : Field, z : Field) where T: SomeTrait {}",
-                // TODO: this fails with known EOF != EOF error
-                // https://github.com/noir-lang/noir/issues/4763
-                // fn func_name(x: impl Eq) {} with error Expected an end of input but found end of input
-                // "fn func_name(x: impl Eq) {}",
-                "fn func_name<T>(x: impl Eq, y : T) where T: SomeTrait + Eq {}",
-                "fn func_name<let N: u32>(x: [Field; N]) {}",
-            ],
-        );
+    fn parse_function_with_argument_return_data_visibility() {
+        let src = "fn foo(x: return_data Field) {}";
+        let mut noir_function = parse_function_no_error(src);
+        assert_eq!(noir_function.def.parameters.len(), 1);
 
-        parse_all_failing(
-            function_definition(false),
-            vec![
-                "fn x2( f: []Field,,) {}",
-                "fn ( f: []Field) {}",
-                "fn ( f: []Field) {}",
-                // TODO: Check for more specific error messages
-                "fn func_name<T>(f: Field, y : pub Field, z : pub [u8;5],) where T: {}",
-                "fn func_name<T>(f: Field, y : pub Field, z : pub [u8;5],) where SomeTrait {}",
-                "fn func_name<T>(f: Field, y : pub Field, z : pub [u8;5],) SomeTrait {}",
-                // A leading plus is not allowed.
-                "fn func_name<T>(f: Field, y : T) where T: + SomeTrait {}",
-                "fn func_name<T>(f: Field, y : T) where T: TraitX + <Y> {}",
-                // Test ill-formed numeric generics
-                "fn func_name<let T>(y: T) {}",
-                "fn func_name<let T:>(y: T) {}",
-                "fn func_name<T:>(y: T) {}",
-                // Test failure of missing `let`
-                "fn func_name<T: u32>(y: T) {}",
-                // Test that signed numeric generics are banned
-                "fn func_name<let N: i8>() {}",
-                // Test that `u64` is banned
-                "fn func_name<let N: u64>(x: [Field; N]) {}",
-            ],
-        );
+        let param = noir_function.def.parameters.remove(0);
+        assert_eq!(param.visibility, Visibility::ReturnData);
     }
 
     #[test]
-    fn parse_recover_function_without_body() {
-        let src = "fn foo(x: i32)";
+    fn parse_function_with_argument_call_data_visibility() {
+        let src = "fn foo(x: call_data(42) Field) {}";
+        let mut noir_function = parse_function_no_error(src);
+        assert_eq!(noir_function.def.parameters.len(), 1);
+
+        let param = noir_function.def.parameters.remove(0);
+        assert_eq!(param.visibility, Visibility::CallData(42));
+    }
 
-        let (noir_function, errors) = parse_recover(function_definition(false), src);
+    #[test]
+    fn parse_function_return_type() {
+        let src = "fn foo() -> Field {}";
+        let noir_function = parse_function_no_error(src);
+        assert_eq!(noir_function.def.return_visibility, Visibility::Private);
+        assert_eq!(noir_function.return_type().typ, UnresolvedTypeData::FieldElement);
+    }
+
+    #[test]
+    fn parse_function_return_visibility() {
+        let src = "fn foo() -> pub Field {}";
+        let noir_function = parse_function_no_error(src);
+        assert_eq!(noir_function.def.return_visibility, Visibility::Public);
+        assert_eq!(noir_function.return_type().typ, UnresolvedTypeData::FieldElement);
+    }
+
+    #[test]
+    fn parse_function_unclosed_parentheses() {
+        let src = "fn foo(x: i32,";
+        let (module, errors) = parse_program(src);
         assert_eq!(errors.len(), 1);
-        assert_eq!(errors[0].message, "expected { or -> after function parameters");
+        assert_eq!(module.items.len(), 1);
+        let item = &module.items[0];
+        let ItemKind::Function(noir_function) = &item.kind else {
+            panic!("Expected function");
+        };
+        assert_eq!("foo", noir_function.def.name.to_string());
+    }
+
+    #[test]
+    fn parse_error_multiple_function_attributes_found() {
+        let src = "
+        #[foreign(foo)] #[oracle(bar)] fn foo() {}
+                        ^^^^^^^^^^^^^^
+        ";
+        let (src, span) = get_source_with_error_span(src);
+        let (_, errors) = parse_program(&src);
+        let reason = get_single_error_reason(&errors, span);
+        assert!(matches!(reason, ParserErrorReason::MultipleFunctionAttributesFound));
+    }
+
+    #[test]
+    fn parse_function_found_semicolon_instead_of_braces() {
+        let src = "
+        fn foo();
+                ^
+        ";
+        let (src, span) = get_source_with_error_span(src);
+        let (_, errors) = parse_program(&src);
+        let reason = get_single_error_reason(&errors, span);
+        assert!(matches!(reason, ParserErrorReason::ExpectedFunctionBody));
+    }
 
-        let noir_function = noir_function.unwrap();
-        assert_eq!(noir_function.name(), "foo");
+    #[test]
+    fn recovers_on_wrong_parameter_name() {
+        let src = "
+        fn foo(1 x: i32) {}
+               ^
+        ";
+        let (src, span) = get_source_with_error_span(src);
+        let (module, errors) = parse_program(&src);
+        assert_eq!(module.items.len(), 1);
+        let ItemKind::Function(noir_function) = &module.items[0].kind else {
+            panic!("Expected function");
+        };
         assert_eq!(noir_function.parameters().len(), 1);
-        assert!(noir_function.def.body.statements.is_empty());
+
+        let error = get_single_error(&errors, span);
+        assert_eq!(error.to_string(), "Expected a pattern but found '1'");
+    }
+
+    #[test]
+    fn recovers_on_missing_colon_after_parameter_name() {
+        let src = "
+        fn foo(x, y: i32) {}
+               ^^
+        ";
+        let (src, span) = get_source_with_error_span(src);
+        let (module, errors) = parse_program(&src);
+        assert_eq!(module.items.len(), 1);
+        let ItemKind::Function(noir_function) = &module.items[0].kind else {
+            panic!("Expected function");
+        };
+        assert_eq!(noir_function.parameters().len(), 2);
+
+        let error = get_single_error(&errors, span);
+        assert!(error.to_string().contains("Missing type for function parameter"));
+    }
+
+    #[test]
+    fn recovers_on_missing_type_after_parameter_colon() {
+        let src = "
+        fn foo(x: , y: i32) {}
+                  ^
+        ";
+        let (src, span) = get_source_with_error_span(src);
+        let (module, errors) = parse_program(&src);
+        assert_eq!(module.items.len(), 1);
+        let ItemKind::Function(noir_function) = &module.items[0].kind else {
+            panic!("Expected function");
+        };
+        assert_eq!(noir_function.parameters().len(), 2);
+
+        let error = get_single_error(&errors, span);
+        assert_eq!(error.to_string(), "Expected a type but found ','");
+    }
+
+    #[test]
+    fn parse_function_with_unconstrained_after_visibility() {
+        let src = "pub unconstrained fn foo() {}";
+        let noir_function = parse_function_no_error(src);
+        assert_eq!("foo", noir_function.def.name.to_string());
+        assert!(noir_function.def.is_unconstrained);
+        assert_eq!(noir_function.def.visibility, ItemVisibility::Public);
     }
 }
diff --git a/compiler/noirc_frontend/src/parser/parser/generics.rs b/compiler/noirc_frontend/src/parser/parser/generics.rs
new file mode 100644
index 00000000000..f577a237615
--- /dev/null
+++ b/compiler/noirc_frontend/src/parser/parser/generics.rs
@@ -0,0 +1,285 @@
+use crate::{
+    ast::{
+        GenericTypeArg, GenericTypeArgs, IntegerBitSize, Signedness, UnresolvedGeneric,
+        UnresolvedGenerics, UnresolvedType, UnresolvedTypeData,
+    },
+    parser::{labels::ParsingRuleLabel, ParserErrorReason},
+    token::{Keyword, Token, TokenKind},
+};
+
+use super::{parse_many::separated_by_comma, Parser};
+
+impl<'a> Parser<'a> {
+    /// Generics = ( '<' GenericsList? '>' )?
+    ///
+    /// GenericsList = Generic ( ',' Generic )* ','?
+    pub(super) fn parse_generics(&mut self) -> UnresolvedGenerics {
+        if !self.eat_less() {
+            return Vec::new();
+        }
+
+        self.parse_many(
+            "generic parameters",
+            separated_by_comma().until(Token::Greater),
+            Self::parse_generic_in_list,
+        )
+    }
+
+    fn parse_generic_in_list(&mut self) -> Option<UnresolvedGeneric> {
+        if let Some(generic) = self.parse_generic() {
+            Some(generic)
+        } else {
+            self.expected_label(ParsingRuleLabel::GenericParameter);
+            None
+        }
+    }
+
+    /// Generic
+    ///     = VariableGeneric
+    ///     | NumericGeneric
+    ///     | ResolvedGeneric
+    fn parse_generic(&mut self) -> Option<UnresolvedGeneric> {
+        if let Some(generic) = self.parse_variable_generic() {
+            return Some(generic);
+        }
+
+        if let Some(generic) = self.parse_numeric_generic() {
+            return Some(generic);
+        }
+
+        if let Some(generic) = self.parse_resolved_generic() {
+            return Some(generic);
+        }
+
+        None
+    }
+
+    /// VariableGeneric = identifier
+    fn parse_variable_generic(&mut self) -> Option<UnresolvedGeneric> {
+        self.eat_ident().map(UnresolvedGeneric::Variable)
+    }
+
+    /// NumericGeneric = 'let' identifier ':' Type
+    fn parse_numeric_generic(&mut self) -> Option<UnresolvedGeneric> {
+        if !self.eat_keyword(Keyword::Let) {
+            return None;
+        }
+
+        let ident = self.eat_ident()?;
+
+        if !self.eat_colon() {
+            // If we didn't get a type after the colon, error and assume it's u32
+            self.push_error(
+                ParserErrorReason::MissingTypeForNumericGeneric,
+                self.current_token_span,
+            );
+            let typ = UnresolvedType {
+                typ: UnresolvedTypeData::Integer(Signedness::Unsigned, IntegerBitSize::ThirtyTwo),
+                span: self.span_at_previous_token_end(),
+            };
+            return Some(UnresolvedGeneric::Numeric { ident, typ });
+        }
+
+        let typ = self.parse_type_or_error();
+        if let UnresolvedTypeData::Integer(signedness, bit_size) = &typ.typ {
+            if matches!(signedness, Signedness::Signed)
+                || matches!(bit_size, IntegerBitSize::SixtyFour)
+            {
+                self.push_error(ParserErrorReason::ForbiddenNumericGenericType, typ.span);
+            }
+        }
+
+        Some(UnresolvedGeneric::Numeric { ident, typ })
+    }
+
+    /// ResolvedGeneric = quoted_type
+    fn parse_resolved_generic(&mut self) -> Option<UnresolvedGeneric> {
+        let token = self.eat_kind(TokenKind::QuotedType)?;
+        match token.into_token() {
+            Token::QuotedType(id) => {
+                Some(UnresolvedGeneric::Resolved(id, self.previous_token_span))
+            }
+            _ => unreachable!(),
+        }
+    }
+
+    /// GenericTypeArgs = ( '<' GenericTypeArgsList? '>' )
+    ///
+    /// GenericTypeArgsList = GenericTypeArg ( ',' GenericTypeArg )* ','?
+    ///
+    /// GenericTypeArg
+    ///     = NamedTypeArg
+    ///     | OrderedTypeArg
+    ///
+    /// NamedTypeArg = identifier '=' Type
+    ///
+    /// OrderedTypeArg = TypeOrTypeExpression
+    pub(super) fn parse_generic_type_args(&mut self) -> GenericTypeArgs {
+        let mut generic_type_args = GenericTypeArgs::default();
+        if !self.eat_less() {
+            return generic_type_args;
+        }
+
+        let generics = self.parse_many(
+            "generic parameters",
+            separated_by_comma().until(Token::Greater),
+            Self::parse_generic_type_arg,
+        );
+
+        for generic in generics {
+            match generic {
+                GenericTypeArg::Ordered(typ) => {
+                    generic_type_args.ordered_args.push(typ);
+                    generic_type_args.kinds.push(crate::ast::GenericTypeArgKind::Ordered);
+                }
+                GenericTypeArg::Named(name, typ) => {
+                    generic_type_args.named_args.push((name, typ));
+                    generic_type_args.kinds.push(crate::ast::GenericTypeArgKind::Named);
+                }
+            }
+        }
+
+        generic_type_args
+    }
+
+    fn parse_generic_type_arg(&mut self) -> Option<GenericTypeArg> {
+        if matches!(self.token.token(), Token::Ident(..)) && self.next_is(Token::Assign) {
+            let ident = self.eat_ident().unwrap();
+
+            self.eat_assign();
+
+            let typ = self.parse_type_or_error();
+            return Some(GenericTypeArg::Named(ident, typ));
+        }
+
+        // Otherwise
+        let Some(typ) = self.parse_type_or_type_expression() else {
+            self.expected_label(ParsingRuleLabel::TypeOrTypeExpression);
+            return None;
+        };
+
+        Some(GenericTypeArg::Ordered(typ))
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use crate::{
+        ast::{GenericTypeArgs, IntegerBitSize, Signedness, UnresolvedGeneric, UnresolvedTypeData},
+        parser::{
+            parser::tests::{
+                expect_no_errors, get_single_error_reason, get_source_with_error_span,
+            },
+            Parser, ParserErrorReason,
+        },
+    };
+
+    fn parse_generics_no_errors(src: &str) -> Vec<UnresolvedGeneric> {
+        let mut parser = Parser::for_str(src);
+        let generics = parser.parse_generics();
+        expect_no_errors(&parser.errors);
+        generics
+    }
+
+    fn parse_generic_type_args_no_errors(src: &str) -> GenericTypeArgs {
+        let mut parser = Parser::for_str(src);
+        let generics = parser.parse_generic_type_args();
+        expect_no_errors(&parser.errors);
+        generics
+    }
+
+    #[test]
+    fn parses_no_generics() {
+        let src = "1";
+        let generics = parse_generics_no_errors(src);
+        assert!(generics.is_empty());
+    }
+
+    #[test]
+    fn parses_generics() {
+        let src = "<A, let B: u32>";
+        let mut generics = parse_generics_no_errors(src);
+        assert_eq!(generics.len(), 2);
+
+        let generic = generics.remove(0);
+        let UnresolvedGeneric::Variable(ident) = generic else {
+            panic!("Expected generic variable");
+        };
+        assert_eq!("A", ident.to_string());
+
+        let generic = generics.remove(0);
+        let UnresolvedGeneric::Numeric { ident, typ } = generic else {
+            panic!("Expected generic numeric");
+        };
+        assert_eq!("B", ident.to_string());
+        assert_eq!(
+            typ.typ,
+            UnresolvedTypeData::Integer(Signedness::Unsigned, IntegerBitSize::ThirtyTwo)
+        );
+    }
+
+    #[test]
+    fn parses_no_generic_type_args() {
+        let src = "1";
+        let generics = parse_generic_type_args_no_errors(src);
+        assert!(generics.is_empty());
+    }
+
+    #[test]
+    fn parses_generic_type_args() {
+        let src = "<i32, X = Field>";
+        let generics = parse_generic_type_args_no_errors(src);
+        assert!(!generics.is_empty());
+        assert_eq!(generics.ordered_args.len(), 1);
+        assert_eq!(generics.ordered_args[0].to_string(), "i32");
+        assert_eq!(generics.named_args.len(), 1);
+        assert_eq!(generics.named_args[0].0.to_string(), "X");
+        assert_eq!(generics.named_args[0].1.to_string(), "Field");
+    }
+
+    #[test]
+    fn parses_generic_type_arg_that_is_a_path() {
+        let src = "<foo::Bar>";
+        let generics = parse_generic_type_args_no_errors(src);
+        assert!(!generics.is_empty());
+        assert_eq!(generics.ordered_args.len(), 1);
+        assert_eq!(generics.ordered_args[0].to_string(), "foo::Bar");
+        assert_eq!(generics.named_args.len(), 0);
+    }
+
+    #[test]
+    fn parses_generic_type_arg_that_is_an_int() {
+        let src = "<1>";
+        let generics = parse_generic_type_args_no_errors(src);
+        assert!(!generics.is_empty());
+        assert_eq!(generics.ordered_args.len(), 1);
+        assert_eq!(generics.ordered_args[0].to_string(), "1");
+    }
+
+    #[test]
+    fn parse_numeric_generic_error_if_invalid_integer() {
+        let src = "
+        <let N: u64>
+                ^^^
+        ";
+        let (src, span) = get_source_with_error_span(src);
+        let mut parser = Parser::for_str(&src);
+        parser.parse_generics();
+        let reason = get_single_error_reason(&parser.errors, span);
+        assert!(matches!(reason, ParserErrorReason::ForbiddenNumericGenericType));
+    }
+
+    #[test]
+    fn parse_arithmetic_generic_on_variable() {
+        let src = "<N - 1>";
+        let generics = parse_generic_type_args_no_errors(src);
+        assert_eq!(generics.ordered_args[0].to_string(), "(N - 1)");
+    }
+
+    #[test]
+    fn parse_var_with_turbofish_in_generic() {
+        let src = "<N<1>>";
+        let generics = parse_generic_type_args_no_errors(src);
+        assert_eq!(generics.ordered_args[0].to_string(), "N<1>");
+    }
+}
diff --git a/compiler/noirc_frontend/src/parser/parser/global.rs b/compiler/noirc_frontend/src/parser/parser/global.rs
new file mode 100644
index 00000000000..5ece510022a
--- /dev/null
+++ b/compiler/noirc_frontend/src/parser/parser/global.rs
@@ -0,0 +1,171 @@
+use noirc_errors::Span;
+
+use crate::{
+    ast::{
+        Expression, ExpressionKind, Ident, LetStatement, Pattern, UnresolvedType,
+        UnresolvedTypeData,
+    },
+    parser::ParserErrorReason,
+    token::{Attribute, Token},
+};
+
+use super::Parser;
+
+impl<'a> Parser<'a> {
+    /// Global = 'global' identifier OptionalTypeAnnotation '=' Expression ';'
+    pub(crate) fn parse_global(
+        &mut self,
+        attributes: Vec<(Attribute, Span)>,
+        comptime: bool,
+        mutable: bool,
+    ) -> LetStatement {
+        // Only comptime globals are allowed to be mutable, but we always parse the `mut`
+        // and throw the error in name resolution.
+
+        let attributes = self.validate_secondary_attributes(attributes);
+
+        let Some(ident) = self.eat_ident() else {
+            self.eat_semicolons();
+            return LetStatement {
+                pattern: ident_to_pattern(Ident::default(), mutable),
+                r#type: UnresolvedType {
+                    typ: UnresolvedTypeData::Unspecified,
+                    span: Span::default(),
+                },
+                expression: Expression { kind: ExpressionKind::Error, span: Span::default() },
+                attributes,
+                comptime,
+            };
+        };
+
+        let pattern = ident_to_pattern(ident, mutable);
+
+        let typ = self.parse_optional_type_annotation();
+
+        let expression = if self.eat_assign() {
+            self.parse_expression_or_error()
+        } else {
+            self.push_error(ParserErrorReason::GlobalWithoutValue, pattern.span());
+            Expression { kind: ExpressionKind::Error, span: Span::default() }
+        };
+
+        if !self.eat_semicolons() {
+            self.expected_token(Token::Semicolon);
+        }
+
+        LetStatement { pattern, r#type: typ, expression, attributes, comptime }
+    }
+}
+
+fn ident_to_pattern(ident: Ident, mutable: bool) -> Pattern {
+    if mutable {
+        let span = ident.span();
+        Pattern::Mutable(Box::new(Pattern::Identifier(ident)), span, false)
+    } else {
+        Pattern::Identifier(ident)
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use crate::{
+        ast::{
+            IntegerBitSize, ItemVisibility, LetStatement, Pattern, Signedness, UnresolvedTypeData,
+        },
+        parser::{
+            parser::{
+                parse_program,
+                tests::{
+                    expect_no_errors, get_single_error, get_single_error_reason,
+                    get_source_with_error_span,
+                },
+            },
+            ItemKind, ParserErrorReason,
+        },
+    };
+
+    fn parse_global_no_errors(src: &str) -> (LetStatement, ItemVisibility) {
+        let (mut module, errors) = parse_program(src);
+        expect_no_errors(&errors);
+        assert_eq!(module.items.len(), 1);
+        let item = module.items.remove(0);
+        let ItemKind::Global(let_statement, visibility) = item.kind else {
+            panic!("Expected global");
+        };
+        (let_statement, visibility)
+    }
+
+    #[test]
+    fn parse_global_no_type_annotation() {
+        let src = "global foo = 1;";
+        let (let_statement, visibility) = parse_global_no_errors(src);
+        let Pattern::Identifier(name) = &let_statement.pattern else {
+            panic!("Expected identifier pattern");
+        };
+        assert_eq!("foo", name.to_string());
+        assert!(matches!(let_statement.r#type.typ, UnresolvedTypeData::Unspecified));
+        assert!(!let_statement.comptime);
+        assert_eq!(visibility, ItemVisibility::Private);
+    }
+
+    #[test]
+    fn parse_global_with_type_annotation() {
+        let src = "global foo: i32 = 1;";
+        let (let_statement, _visibility) = parse_global_no_errors(src);
+        let Pattern::Identifier(name) = &let_statement.pattern else {
+            panic!("Expected identifier pattern");
+        };
+        assert_eq!("foo", name.to_string());
+        assert!(matches!(
+            let_statement.r#type.typ,
+            UnresolvedTypeData::Integer(Signedness::Signed, IntegerBitSize::ThirtyTwo)
+        ));
+    }
+
+    #[test]
+    fn parse_comptime_global() {
+        let src = "comptime global foo: i32 = 1;";
+        let (let_statement, _visibility) = parse_global_no_errors(src);
+        assert!(let_statement.comptime);
+    }
+
+    #[test]
+    fn parse_mutable_global() {
+        let src = "mut global foo: i32 = 1;";
+        let (let_statement, _visibility) = parse_global_no_errors(src);
+        let Pattern::Mutable(pattern, _, _) = &let_statement.pattern else {
+            panic!("Expected mutable pattern");
+        };
+        let pattern: &Pattern = pattern;
+        let Pattern::Identifier(name) = pattern else {
+            panic!("Expected identifier pattern");
+        };
+        assert_eq!("foo", name.to_string());
+        assert_eq!(pattern.span().start(), 11);
+        assert_eq!(pattern.span().end(), 14);
+    }
+
+    #[test]
+    fn parse_global_no_value() {
+        let src = "
+        global foo;
+               ^^^
+        ";
+        let (src, span) = get_source_with_error_span(src);
+        let (_, errors) = parse_program(&src);
+        let reason = get_single_error_reason(&errors, span);
+        assert!(matches!(reason, ParserErrorReason::GlobalWithoutValue));
+    }
+
+    #[test]
+    fn parse_global_no_semicolon() {
+        let src = "
+        global foo = 1 
+                      ^ 
+        ";
+        let (src, span) = get_source_with_error_span(src);
+        let (_, errors) = parse_program(&src);
+        let error = get_single_error(&errors, span);
+        assert_eq!(error.to_string(), "Expected a ';' but found end of input");
+    }
+}
diff --git a/compiler/noirc_frontend/src/parser/parser/impls.rs b/compiler/noirc_frontend/src/parser/parser/impls.rs
new file mode 100644
index 00000000000..8e6b3bae0e9
--- /dev/null
+++ b/compiler/noirc_frontend/src/parser/parser/impls.rs
@@ -0,0 +1,566 @@
+use noirc_errors::Span;
+
+use crate::{
+    ast::{
+        Documented, Expression, ExpressionKind, GenericTypeArgs, Ident, ItemVisibility,
+        NoirFunction, NoirTraitImpl, Path, TraitImplItem, TraitImplItemKind, TypeImpl,
+        UnresolvedGeneric, UnresolvedType, UnresolvedTypeData,
+    },
+    parser::{labels::ParsingRuleLabel, ParserErrorReason},
+    token::{Keyword, Token},
+};
+
+use super::{parse_many::without_separator, Parser};
+
+pub(crate) enum Impl {
+    Impl(TypeImpl),
+    TraitImpl(NoirTraitImpl),
+}
+
+impl<'a> Parser<'a> {
+    /// Impl
+    ///     = TypeImpl
+    ///     | TraitImpl
+    pub(crate) fn parse_impl(&mut self) -> Impl {
+        let generics = self.parse_generics();
+
+        let type_span_start = self.current_token_span;
+        let object_type = self.parse_type_or_error();
+        let type_span = self.span_since(type_span_start);
+
+        if self.eat_keyword(Keyword::For) {
+            if let UnresolvedTypeData::Named(trait_name, trait_generics, _) = object_type.typ {
+                return Impl::TraitImpl(self.parse_trait_impl(
+                    generics,
+                    trait_generics,
+                    trait_name,
+                ));
+            } else {
+                self.push_error(
+                    ParserErrorReason::ExpectedTrait { found: object_type.typ.to_string() },
+                    self.current_token_span,
+                );
+
+                // Error, but we continue parsing the type and assume this is going to be a regular type impl
+                self.parse_type();
+            };
+        }
+
+        self.parse_type_impl(object_type, type_span, generics)
+    }
+
+    /// TypeImpl = 'impl' Generics Type TypeImplBody
+    fn parse_type_impl(
+        &mut self,
+        object_type: UnresolvedType,
+        type_span: Span,
+        generics: Vec<UnresolvedGeneric>,
+    ) -> Impl {
+        let where_clause = self.parse_where_clause();
+        let methods = self.parse_type_impl_body();
+
+        Impl::Impl(TypeImpl { object_type, type_span, generics, where_clause, methods })
+    }
+
+    /// TypeImplBody = '{' TypeImplItem* '}'
+    ///
+    /// TypeImplItem = OuterDocComments Attributes Modifiers Function
+    fn parse_type_impl_body(&mut self) -> Vec<(Documented<NoirFunction>, Span)> {
+        if !self.eat_left_brace() {
+            self.expected_token(Token::LeftBrace);
+            return Vec::new();
+        }
+
+        self.parse_many(
+            "type impl methods",
+            without_separator().until(Token::RightBrace),
+            Self::parse_type_impl_method,
+        )
+    }
+
+    fn parse_type_impl_method(&mut self) -> Option<(Documented<NoirFunction>, Span)> {
+        self.parse_item_in_list(ParsingRuleLabel::Function, |parser| {
+            let doc_comments = parser.parse_outer_doc_comments();
+            let start_span = parser.current_token_span;
+            let attributes = parser.parse_attributes();
+            let modifiers = parser.parse_modifiers(
+                false, // allow mutable
+            );
+
+            if parser.eat_keyword(Keyword::Fn) {
+                let method = parser.parse_function(
+                    attributes,
+                    modifiers.visibility,
+                    modifiers.comptime.is_some(),
+                    modifiers.unconstrained.is_some(),
+                    true, // allow_self
+                );
+                Some((Documented::new(method, doc_comments), parser.span_since(start_span)))
+            } else {
+                parser.modifiers_not_followed_by_an_item(modifiers);
+                None
+            }
+        })
+    }
+
+    /// TraitImpl = 'impl' Generics Path GenericTypeArgs 'for' Type TraitImplBody
+    fn parse_trait_impl(
+        &mut self,
+        impl_generics: Vec<UnresolvedGeneric>,
+        trait_generics: GenericTypeArgs,
+        trait_name: Path,
+    ) -> NoirTraitImpl {
+        let object_type = self.parse_type_or_error();
+        let where_clause = self.parse_where_clause();
+        let items = self.parse_trait_impl_body();
+        let is_synthetic = false;
+
+        NoirTraitImpl {
+            impl_generics,
+            trait_name,
+            trait_generics,
+            object_type,
+            where_clause,
+            items,
+            is_synthetic,
+        }
+    }
+
+    /// TraitImplBody = '{' TraitImplItem* '}'
+    fn parse_trait_impl_body(&mut self) -> Vec<Documented<TraitImplItem>> {
+        if !self.eat_left_brace() {
+            self.expected_token(Token::LeftBrace);
+            return Vec::new();
+        }
+
+        self.parse_many(
+            "trait impl item",
+            without_separator().until(Token::RightBrace),
+            Self::parse_trait_impl_item,
+        )
+    }
+
+    fn parse_trait_impl_item(&mut self) -> Option<Documented<TraitImplItem>> {
+        self.parse_item_in_list(ParsingRuleLabel::TraitImplItem, |parser| {
+            let start_span = parser.current_token_span;
+            let doc_comments = parser.parse_outer_doc_comments();
+
+            if let Some(kind) = parser.parse_trait_impl_item_kind() {
+                let item = TraitImplItem { kind, span: parser.span_since(start_span) };
+                Some(Documented::new(item, doc_comments))
+            } else {
+                None
+            }
+        })
+    }
+
+    /// TraitImplItem
+    ///     = TraitImplType
+    ///     | TraitImplConstant
+    ///     | TraitImplFunction
+    fn parse_trait_impl_item_kind(&mut self) -> Option<TraitImplItemKind> {
+        if let Some(kind) = self.parse_trait_impl_type() {
+            return Some(kind);
+        }
+
+        if let Some(kind) = self.parse_trait_impl_constant() {
+            return Some(kind);
+        }
+
+        self.parse_trait_impl_function()
+    }
+
+    /// TraitImplType = 'type' identifier ( ':' Type )? ';'
+    fn parse_trait_impl_type(&mut self) -> Option<TraitImplItemKind> {
+        if !self.eat_keyword(Keyword::Type) {
+            return None;
+        }
+
+        let Some(name) = self.eat_ident() else {
+            self.expected_identifier();
+            self.eat_semicolons();
+            return Some(TraitImplItemKind::Type {
+                name: Ident::default(),
+                alias: UnresolvedType { typ: UnresolvedTypeData::Error, span: Span::default() },
+            });
+        };
+
+        let alias = if self.eat_assign() {
+            self.parse_type_or_error()
+        } else {
+            UnresolvedType { typ: UnresolvedTypeData::Error, span: Span::default() }
+        };
+
+        self.eat_semicolons();
+
+        Some(TraitImplItemKind::Type { name, alias })
+    }
+
+    /// TraitImplConstant = 'let' identifier OptionalTypeAnnotation ';'
+    fn parse_trait_impl_constant(&mut self) -> Option<TraitImplItemKind> {
+        if !self.eat_keyword(Keyword::Let) {
+            return None;
+        }
+
+        let name = match self.eat_ident() {
+            Some(name) => name,
+            None => {
+                self.expected_identifier();
+                Ident::default()
+            }
+        };
+
+        let typ = self.parse_optional_type_annotation();
+
+        let expr = if self.eat_assign() {
+            self.parse_expression_or_error()
+        } else {
+            self.expected_token(Token::Assign);
+            Expression { kind: ExpressionKind::Error, span: Span::default() }
+        };
+
+        self.eat_semicolons();
+
+        Some(TraitImplItemKind::Constant(name, typ, expr))
+    }
+
+    /// TraitImplFunction = Attributes Modifiers Function
+    fn parse_trait_impl_function(&mut self) -> Option<TraitImplItemKind> {
+        let attributes = self.parse_attributes();
+
+        let modifiers = self.parse_modifiers(
+            false, // allow mut
+        );
+        if modifiers.visibility != ItemVisibility::Private {
+            self.push_error(
+                ParserErrorReason::TraitImplVisibilityIgnored,
+                modifiers.visibility_span,
+            );
+        }
+
+        if !self.eat_keyword(Keyword::Fn) {
+            self.modifiers_not_followed_by_an_item(modifiers);
+            return None;
+        }
+
+        let noir_function = self.parse_function(
+            attributes,
+            ItemVisibility::Public,
+            modifiers.comptime.is_some(),
+            modifiers.unconstrained.is_some(),
+            true, // allow_self
+        );
+        Some(TraitImplItemKind::Function(noir_function))
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use crate::{
+        ast::{
+            ItemVisibility, NoirTraitImpl, Pattern, TraitImplItemKind, TypeImpl, UnresolvedTypeData,
+        },
+        parser::{
+            parser::{
+                parse_program,
+                tests::{expect_no_errors, get_single_error, get_source_with_error_span},
+            },
+            ItemKind,
+        },
+    };
+
+    fn parse_type_impl_no_errors(src: &str) -> TypeImpl {
+        let (mut module, errors) = parse_program(src);
+        expect_no_errors(&errors);
+        assert_eq!(module.items.len(), 1);
+        let item = module.items.remove(0);
+        let ItemKind::Impl(type_impl) = item.kind else {
+            panic!("Expected type impl");
+        };
+        type_impl
+    }
+
+    fn parse_trait_impl_no_errors(src: &str) -> NoirTraitImpl {
+        let (mut module, errors) = parse_program(src);
+        expect_no_errors(&errors);
+        assert_eq!(module.items.len(), 1);
+        let item = module.items.remove(0);
+        let ItemKind::TraitImpl(noir_trait_impl) = item.kind else {
+            panic!("Expected trait impl");
+        };
+        noir_trait_impl
+    }
+
+    #[test]
+    fn parse_empty_impl() {
+        let src = "impl Foo {}";
+        let type_impl = parse_type_impl_no_errors(src);
+        assert_eq!(type_impl.object_type.to_string(), "Foo");
+        assert!(type_impl.generics.is_empty());
+        assert!(type_impl.methods.is_empty());
+    }
+
+    #[test]
+    fn parse_empty_impl_with_generics() {
+        let src = "impl <A, B> Foo {}";
+        let type_impl = parse_type_impl_no_errors(src);
+        assert_eq!(type_impl.object_type.to_string(), "Foo");
+        assert_eq!(type_impl.generics.len(), 2);
+        assert!(type_impl.methods.is_empty());
+    }
+
+    #[test]
+    fn parse_impl_with_methods() {
+        let src = "impl Foo { unconstrained fn foo() {} pub comptime fn bar() {} }";
+        let mut type_impl = parse_type_impl_no_errors(src);
+        assert_eq!(type_impl.object_type.to_string(), "Foo");
+        assert_eq!(type_impl.methods.len(), 2);
+
+        let (method, _) = type_impl.methods.remove(0);
+        let method = method.item;
+        assert_eq!(method.def.name.to_string(), "foo");
+        assert!(method.def.is_unconstrained);
+        assert!(!method.def.is_comptime);
+        assert_eq!(method.def.visibility, ItemVisibility::Private);
+
+        let (method, _) = type_impl.methods.remove(0);
+        let method = method.item;
+        assert_eq!(method.def.name.to_string(), "bar");
+        assert!(method.def.is_comptime);
+        assert_eq!(method.def.visibility, ItemVisibility::Public);
+    }
+
+    #[test]
+    fn parse_impl_with_attribute_on_method() {
+        let src = "
+        impl Foo {
+            #[something]
+            fn foo(self) {}
+        }
+        ";
+        let type_impl = parse_type_impl_no_errors(src);
+        let attributes = type_impl.methods[0].0.item.attributes();
+        assert_eq!(attributes.secondary.len(), 1);
+    }
+
+    #[test]
+    fn parse_impl_with_self_argument() {
+        let src = "impl Foo { fn foo(self) {} }";
+        let mut type_impl = parse_type_impl_no_errors(src);
+        assert_eq!(type_impl.methods.len(), 1);
+
+        let (method, _) = type_impl.methods.remove(0);
+        let mut method = method.item;
+        assert_eq!(method.def.name.to_string(), "foo");
+        assert_eq!(method.def.parameters.len(), 1);
+
+        let param = method.def.parameters.remove(0);
+        let Pattern::Identifier(name) = param.pattern else {
+            panic!("Expected identifier pattern");
+        };
+        assert_eq!(name.to_string(), "self");
+        assert_eq!(param.typ.to_string(), "Self");
+    }
+
+    #[test]
+    fn parse_impl_with_mut_self_argument() {
+        let src = "impl Foo { fn foo(mut self) {} }";
+        let mut type_impl = parse_type_impl_no_errors(src);
+        assert_eq!(type_impl.methods.len(), 1);
+
+        let (method, _) = type_impl.methods.remove(0);
+        let mut method = method.item;
+        assert_eq!(method.def.name.to_string(), "foo");
+        assert_eq!(method.def.parameters.len(), 1);
+
+        let param = method.def.parameters.remove(0);
+        let Pattern::Mutable(pattern, _, true) = param.pattern else {
+            panic!("Expected mutable pattern");
+        };
+        let pattern: &Pattern = &pattern;
+        let Pattern::Identifier(name) = pattern else {
+            panic!("Expected identifier pattern");
+        };
+        assert_eq!(name.to_string(), "self");
+        assert_eq!(param.typ.to_string(), "Self");
+    }
+
+    #[test]
+    fn parse_impl_with_reference_mut_self_argument() {
+        let src = "impl Foo { fn foo(&mut self) {} }";
+        let mut type_impl = parse_type_impl_no_errors(src);
+        assert_eq!(type_impl.methods.len(), 1);
+
+        let (method, _) = type_impl.methods.remove(0);
+        let mut method = method.item;
+        assert_eq!(method.def.name.to_string(), "foo");
+        assert_eq!(method.def.parameters.len(), 1);
+
+        let param = method.def.parameters.remove(0);
+        let Pattern::Identifier(name) = param.pattern else {
+            panic!("Expected identifier pattern");
+        };
+        assert_eq!(name.to_string(), "self");
+        assert_eq!(param.typ.to_string(), "&mut Self");
+    }
+
+    #[test]
+    fn parse_impl_with_self_argument_followed_by_type() {
+        let src = "impl Foo { fn foo(self: Foo) {} }";
+        let mut type_impl = parse_type_impl_no_errors(src);
+        assert_eq!(type_impl.methods.len(), 1);
+
+        let (method, _) = type_impl.methods.remove(0);
+        let mut method = method.item;
+        assert_eq!(method.def.name.to_string(), "foo");
+        assert_eq!(method.def.parameters.len(), 1);
+
+        let param = method.def.parameters.remove(0);
+        let Pattern::Identifier(name) = param.pattern else {
+            panic!("Expected identifier pattern");
+        };
+        assert_eq!(name.to_string(), "self");
+        assert_eq!(param.typ.to_string(), "Foo");
+    }
+
+    #[test]
+    fn parse_empty_impl_missing_right_brace() {
+        let src = "impl Foo {";
+        let (module, errors) = parse_program(src);
+        assert_eq!(errors.len(), 1);
+        assert_eq!(module.items.len(), 1);
+        let item = &module.items[0];
+        let ItemKind::Impl(type_impl) = &item.kind else {
+            panic!("Expected type impl");
+        };
+        assert_eq!(type_impl.object_type.to_string(), "Foo");
+    }
+
+    #[test]
+    fn parse_empty_impl_incorrect_body() {
+        let src = "impl Foo { hello fn foo() {} }";
+        let (module, errors) = parse_program(src);
+        assert_eq!(errors.len(), 1);
+        assert_eq!(module.items.len(), 1);
+        let item = &module.items[0];
+        let ItemKind::Impl(type_impl) = &item.kind else {
+            panic!("Expected type impl");
+        };
+        assert_eq!(type_impl.object_type.to_string(), "Foo");
+        assert_eq!(type_impl.methods.len(), 1);
+    }
+
+    #[test]
+    fn parse_empty_trait_impl() {
+        let src = "impl Foo for Field {}";
+        let trait_impl = parse_trait_impl_no_errors(src);
+        assert_eq!(trait_impl.trait_name.to_string(), "Foo");
+        assert!(matches!(trait_impl.object_type.typ, UnresolvedTypeData::FieldElement));
+        assert!(trait_impl.items.is_empty());
+        assert!(trait_impl.impl_generics.is_empty());
+    }
+
+    #[test]
+    fn parse_empty_trait_impl_with_generics() {
+        let src = "impl <T> Foo for Field {}";
+        let trait_impl = parse_trait_impl_no_errors(src);
+        assert_eq!(trait_impl.trait_name.to_string(), "Foo");
+        assert!(matches!(trait_impl.object_type.typ, UnresolvedTypeData::FieldElement));
+        assert!(trait_impl.items.is_empty());
+        assert_eq!(trait_impl.impl_generics.len(), 1);
+    }
+
+    #[test]
+    fn parse_trait_impl_with_function() {
+        let src = "impl Foo for Field { fn foo() {} }";
+        let mut trait_impl = parse_trait_impl_no_errors(src);
+        assert_eq!(trait_impl.trait_name.to_string(), "Foo");
+        assert_eq!(trait_impl.items.len(), 1);
+
+        let item = trait_impl.items.remove(0).item;
+        let TraitImplItemKind::Function(function) = item.kind else {
+            panic!("Expected function");
+        };
+        assert_eq!(function.def.name.to_string(), "foo");
+        assert_eq!(function.def.visibility, ItemVisibility::Public);
+    }
+
+    #[test]
+    fn parse_trait_impl_with_generic_type_args() {
+        let src = "impl Foo<i32, X = Field> for Field { }";
+        let trait_impl = parse_trait_impl_no_errors(src);
+        assert_eq!(trait_impl.trait_name.to_string(), "Foo");
+        assert!(!trait_impl.trait_generics.is_empty());
+    }
+
+    #[test]
+    fn parse_trait_impl_with_type() {
+        let src = "impl Foo for Field { type Foo = i32; }";
+        let mut trait_impl = parse_trait_impl_no_errors(src);
+        assert_eq!(trait_impl.trait_name.to_string(), "Foo");
+        assert_eq!(trait_impl.items.len(), 1);
+
+        let item = trait_impl.items.remove(0).item;
+        let TraitImplItemKind::Type { name, alias } = item.kind else {
+            panic!("Expected type");
+        };
+        assert_eq!(name.to_string(), "Foo");
+        assert_eq!(alias.to_string(), "i32");
+    }
+
+    #[test]
+    fn parse_trait_impl_with_let() {
+        let src = "impl Foo for Field { let x: Field = 1; }";
+        let mut trait_impl = parse_trait_impl_no_errors(src);
+        assert_eq!(trait_impl.trait_name.to_string(), "Foo");
+        assert_eq!(trait_impl.items.len(), 1);
+
+        let item = trait_impl.items.remove(0).item;
+        let TraitImplItemKind::Constant(name, typ, expr) = item.kind else {
+            panic!("Expected constant");
+        };
+        assert_eq!(name.to_string(), "x");
+        assert_eq!(typ.to_string(), "Field");
+        assert_eq!(expr.to_string(), "1");
+    }
+
+    #[test]
+    fn recovers_on_unknown_impl_item() {
+        let src = "
+        impl Foo { hello fn foo() {} }
+                   ^^^^^
+        ";
+        let (src, span) = get_source_with_error_span(src);
+        let (module, errors) = parse_program(&src);
+
+        assert_eq!(module.items.len(), 1);
+        let item = &module.items[0];
+        let ItemKind::Impl(type_impl) = &item.kind else {
+            panic!("Expected impl");
+        };
+        assert_eq!(type_impl.methods.len(), 1);
+
+        let error = get_single_error(&errors, span);
+        assert_eq!(error.to_string(), "Expected a function but found 'hello'");
+    }
+
+    #[test]
+    fn recovers_on_unknown_trait_impl_item() {
+        let src = "
+        impl Foo for i32 { hello fn foo() {} }
+                           ^^^^^
+        ";
+        let (src, span) = get_source_with_error_span(src);
+        let (module, errors) = parse_program(&src);
+
+        assert_eq!(module.items.len(), 1);
+        let item = &module.items[0];
+        let ItemKind::TraitImpl(trait_imp) = &item.kind else {
+            panic!("Expected trait impl");
+        };
+        assert_eq!(trait_imp.items.len(), 1);
+
+        let error = get_single_error(&errors, span);
+        assert_eq!(error.to_string(), "Expected a trait impl item but found 'hello'");
+    }
+}
diff --git a/compiler/noirc_frontend/src/parser/parser/infix.rs b/compiler/noirc_frontend/src/parser/parser/infix.rs
new file mode 100644
index 00000000000..f006923b8a2
--- /dev/null
+++ b/compiler/noirc_frontend/src/parser/parser/infix.rs
@@ -0,0 +1,193 @@
+use noirc_errors::{Span, Spanned};
+
+use crate::{
+    ast::{BinaryOpKind, Expression, ExpressionKind, InfixExpression},
+    token::Token,
+};
+
+use super::Parser;
+
+impl<'a> Parser<'a> {
+    /// EqualOrNotEqualExpression
+    ///     = OrExpression ( ( '==' | '!=' ) OrExpression )*
+    pub(super) fn parse_equal_or_not_equal(
+        &mut self,
+        allow_constructors: bool,
+    ) -> Option<Expression> {
+        self.parse_infix(allow_constructors, Parser::parse_or, |parser| {
+            if parser.eat(Token::Equal) {
+                Some(BinaryOpKind::Equal)
+            } else if parser.eat(Token::NotEqual) {
+                Some(BinaryOpKind::NotEqual)
+            } else {
+                None
+            }
+        })
+    }
+
+    /// OrExpression
+    ///     = AndExpression ( '|' AndExpression )*
+    pub(super) fn parse_or(&mut self, allow_constructors: bool) -> Option<Expression> {
+        self.parse_infix(allow_constructors, Parser::parse_and, |parser| {
+            // Don't parse `x |= ...`, etc.
+            if parser.next_is(Token::Assign) {
+                None
+            } else if parser.eat(Token::Pipe) {
+                Some(BinaryOpKind::Or)
+            } else {
+                None
+            }
+        })
+    }
+
+    /// AndExpression
+    ///     = XorExpression ( '&' XorExpression )*
+    pub(super) fn parse_and(&mut self, allow_constructors: bool) -> Option<Expression> {
+        self.parse_infix(allow_constructors, Parser::parse_xor, |parser| {
+            // Don't parse `x |= ...`, etc.
+            if parser.next_is(Token::Assign) {
+                None
+            } else if parser.eat(Token::Ampersand) {
+                Some(BinaryOpKind::And)
+            } else {
+                None
+            }
+        })
+    }
+
+    /// XorExpression
+    ///     = LessOrGreaterExpression ( '^' LessOrGreaterExpression )*
+    pub(super) fn parse_xor(&mut self, allow_constructors: bool) -> Option<Expression> {
+        self.parse_infix(allow_constructors, Parser::parse_less_or_greater, |parser| {
+            // Don't parse `x |= ...`, etc.
+            if parser.next_is(Token::Assign) {
+                None
+            } else if parser.eat(Token::Caret) {
+                Some(BinaryOpKind::Xor)
+            } else {
+                None
+            }
+        })
+    }
+
+    /// LessOrGreaterExpression
+    ///     = ShiftExpression ( ( '<' | '<=' | '>' | '>=' ) ShiftExpression )*
+    pub(super) fn parse_less_or_greater(&mut self, allow_constructors: bool) -> Option<Expression> {
+        self.parse_infix(allow_constructors, Parser::parse_shift, |parser| {
+            if parser.eat(Token::Less) {
+                Some(BinaryOpKind::Less)
+            } else if parser.eat(Token::LessEqual) {
+                Some(BinaryOpKind::LessEqual)
+            } else if parser.next_token.token() != &Token::GreaterEqual
+                && parser.eat(Token::Greater)
+            {
+                // Make sure to skip the `>>=` case, as `>>=` is lexed as `> >=`.
+                Some(BinaryOpKind::Greater)
+            } else if parser.eat(Token::GreaterEqual) {
+                Some(BinaryOpKind::GreaterEqual)
+            } else {
+                None
+            }
+        })
+    }
+
+    /// ShiftExpression
+    ///     = AddOrSubtractExpression ( ( '<<' | '>' '>' ) AddOrSubtractExpression )*
+    pub(super) fn parse_shift(&mut self, allow_constructors: bool) -> Option<Expression> {
+        self.parse_infix(allow_constructors, Parser::parse_add_or_subtract, |parser| {
+            if !parser.next_is(Token::Assign) && parser.eat(Token::ShiftLeft) {
+                Some(BinaryOpKind::ShiftLeft)
+            } else if parser.at(Token::Greater) && parser.next_is(Token::Greater) {
+                // Right-shift (>>) is issued as two separate > tokens by the lexer as this makes it easier
+                // to parse nested generic types. For normal expressions however, it means we have to manually
+                // parse two greater-than tokens as a single right-shift here.
+                parser.bump();
+                parser.bump();
+                Some(BinaryOpKind::ShiftRight)
+            } else {
+                None
+            }
+        })
+    }
+
+    /// AddOrSubtractExpression
+    ///     = MultiplyOrDivideOrModuloExpression ( ( '+' | '-' ) MultiplyOrDivideOrModuloExpression )*
+    pub(super) fn parse_add_or_subtract(&mut self, allow_constructors: bool) -> Option<Expression> {
+        self.parse_infix(allow_constructors, Parser::parse_multiply_or_divide_or_modulo, |parser| {
+            if parser.next_is(Token::Assign) {
+                None
+            } else if parser.eat(Token::Plus) {
+                Some(BinaryOpKind::Add)
+            } else if parser.eat(Token::Minus) {
+                Some(BinaryOpKind::Subtract)
+            } else {
+                None
+            }
+        })
+    }
+
+    /// MultiplyOrDivideOrModuloExpression
+    ///     = Term ( ( '*' | '/' | '%' ) Term )*
+    pub(super) fn parse_multiply_or_divide_or_modulo(
+        &mut self,
+        allow_constructors: bool,
+    ) -> Option<Expression> {
+        self.parse_infix(allow_constructors, Parser::parse_term, |parser| {
+            if parser.next_is(Token::Assign) {
+                None
+            } else if parser.eat(Token::Star) {
+                Some(BinaryOpKind::Multiply)
+            } else if parser.eat(Token::Slash) {
+                Some(BinaryOpKind::Divide)
+            } else if parser.eat(Token::Percent) {
+                Some(BinaryOpKind::Modulo)
+            } else {
+                None
+            }
+        })
+    }
+
+    fn parse_infix<Next, Op>(
+        &mut self,
+        allow_constructors: bool,
+        mut next: Next,
+        mut op: Op,
+    ) -> Option<Expression>
+    where
+        Next: FnMut(&mut Parser<'a>, bool) -> Option<Expression>,
+        Op: FnMut(&mut Parser<'a>) -> Option<BinaryOpKind>,
+    {
+        let start_span = self.current_token_span;
+        let mut lhs = next(self, allow_constructors)?;
+
+        loop {
+            let operator_start_span = self.current_token_span;
+            let Some(operator) = op(self) else {
+                break;
+            };
+            let operator = Spanned::from(operator_start_span, operator);
+
+            let Some(rhs) = next(self, allow_constructors) else {
+                self.push_expected_expression();
+                break;
+            };
+
+            lhs = self.new_infix_expression(lhs, operator, rhs, start_span);
+        }
+
+        Some(lhs)
+    }
+
+    fn new_infix_expression(
+        &self,
+        lhs: Expression,
+        operator: Spanned<BinaryOpKind>,
+        rhs: Expression,
+        start_span: Span,
+    ) -> Expression {
+        let infix_expr = InfixExpression { lhs, operator, rhs };
+        let kind = ExpressionKind::Infix(Box::new(infix_expr));
+        let span = self.span_since(start_span);
+        Expression { kind, span }
+    }
+}
diff --git a/compiler/noirc_frontend/src/parser/parser/item.rs b/compiler/noirc_frontend/src/parser/parser/item.rs
new file mode 100644
index 00000000000..ce712b559d8
--- /dev/null
+++ b/compiler/noirc_frontend/src/parser/parser/item.rs
@@ -0,0 +1,252 @@
+use iter_extended::vecmap;
+
+use crate::{
+    parser::{labels::ParsingRuleLabel, Item, ItemKind},
+    token::{Keyword, Token},
+};
+
+use super::{impls::Impl, parse_many::without_separator, Parser};
+
+impl<'a> Parser<'a> {
+    pub(crate) fn parse_top_level_items(&mut self) -> Vec<Item> {
+        self.parse_module_items(
+            false, // nested
+        )
+    }
+
+    pub(crate) fn parse_module_items(&mut self, nested: bool) -> Vec<Item> {
+        self.parse_many_to_many("items", without_separator(), |parser| {
+            parser.parse_module_item_in_list(nested)
+        })
+    }
+
+    fn parse_module_item_in_list(&mut self, nested: bool) -> Vec<Item> {
+        loop {
+            // We only break out of the loop on `}` if we are inside a `mod { ..`
+            if nested && self.at(Token::RightBrace) {
+                return vec![];
+            }
+
+            // We always break on EOF (we don't error because if we are inside `mod { ..`
+            // the outer parsing logic will error instead)
+            if self.at_eof() {
+                return vec![];
+            }
+
+            let parsed_items = self.parse_item();
+            if parsed_items.is_empty() {
+                // If we couldn't parse an item we check which token we got
+                match self.token.token() {
+                    Token::RightBrace if nested => {
+                        return vec![];
+                    }
+                    Token::EOF => return vec![],
+                    _ => (),
+                }
+
+                self.expected_label(ParsingRuleLabel::Item);
+                // We'll try parsing an item starting on the next token
+                self.bump();
+                continue;
+            };
+
+            return parsed_items;
+        }
+    }
+
+    /// Parses an item inside an impl or trait, with good recovery:
+    /// - If we run into EOF, we error that we expect a '}'
+    /// - If we can't parse an item and we don't end up in '}', error but try with the next token
+    pub(super) fn parse_item_in_list<T, F>(
+        &mut self,
+        label: ParsingRuleLabel,
+        mut f: F,
+    ) -> Option<T>
+    where
+        F: FnMut(&mut Parser<'a>) -> Option<T>,
+    {
+        loop {
+            if self.at_eof() {
+                self.expected_token(Token::RightBrace);
+                return None;
+            }
+
+            let Some(item) = f(self) else {
+                if !self.at(Token::RightBrace) {
+                    self.expected_label(label.clone());
+
+                    // Try with the next token
+                    self.bump();
+                    continue;
+                }
+
+                return None;
+            };
+
+            return Some(item);
+        }
+    }
+
+    /// Item = OuterDocComments ItemKind
+    fn parse_item(&mut self) -> Vec<Item> {
+        let start_span = self.current_token_span;
+        let doc_comments = self.parse_outer_doc_comments();
+        let kinds = self.parse_item_kind();
+        let span = self.span_since(start_span);
+
+        vecmap(kinds, |kind| Item { kind, span, doc_comments: doc_comments.clone() })
+    }
+
+    /// This method returns one 'ItemKind' in the majority of cases.
+    /// The current exception is when parsing a trait alias,
+    /// which returns both the trait and the impl.
+    ///
+    /// ItemKind
+    ///     = InnerAttribute
+    ///     | Attributes Modifiers
+    ///         ( Use
+    ///         | ModOrContract
+    ///         | Struct
+    ///         | Impl
+    ///         | Trait
+    ///         | Global
+    ///         | TypeAlias
+    ///         | Function
+    ///         )
+    fn parse_item_kind(&mut self) -> Vec<ItemKind> {
+        if let Some(kind) = self.parse_inner_attribute() {
+            return vec![ItemKind::InnerAttribute(kind)];
+        }
+
+        let start_span = self.current_token_span;
+        let attributes = self.parse_attributes();
+
+        let modifiers = self.parse_modifiers(
+            true, // allow mut
+        );
+
+        if self.eat_keyword(Keyword::Use) {
+            self.comptime_mutable_and_unconstrained_not_applicable(modifiers);
+
+            let use_tree = self.parse_use_tree();
+            return vec![ItemKind::Import(use_tree, modifiers.visibility)];
+        }
+
+        if let Some(is_contract) = self.eat_mod_or_contract() {
+            self.comptime_mutable_and_unconstrained_not_applicable(modifiers);
+
+            return vec![self.parse_mod_or_contract(attributes, is_contract, modifiers.visibility)];
+        }
+
+        if self.eat_keyword(Keyword::Struct) {
+            self.comptime_mutable_and_unconstrained_not_applicable(modifiers);
+
+            return vec![ItemKind::Struct(self.parse_struct(
+                attributes,
+                modifiers.visibility,
+                start_span,
+            ))];
+        }
+
+        if self.eat_keyword(Keyword::Impl) {
+            self.comptime_mutable_and_unconstrained_not_applicable(modifiers);
+
+            return vec![match self.parse_impl() {
+                Impl::Impl(type_impl) => ItemKind::Impl(type_impl),
+                Impl::TraitImpl(noir_trait_impl) => ItemKind::TraitImpl(noir_trait_impl),
+            }];
+        }
+
+        if self.eat_keyword(Keyword::Trait) {
+            self.comptime_mutable_and_unconstrained_not_applicable(modifiers);
+
+            let (noir_trait, noir_impl) =
+                self.parse_trait(attributes, modifiers.visibility, start_span);
+            let mut output = vec![ItemKind::Trait(noir_trait)];
+            if let Some(noir_impl) = noir_impl {
+                output.push(ItemKind::TraitImpl(noir_impl));
+            }
+
+            return output;
+        }
+
+        if self.eat_keyword(Keyword::Global) {
+            self.unconstrained_not_applicable(modifiers);
+
+            return vec![ItemKind::Global(
+                self.parse_global(
+                    attributes,
+                    modifiers.comptime.is_some(),
+                    modifiers.mutable.is_some(),
+                ),
+                modifiers.visibility,
+            )];
+        }
+
+        if self.eat_keyword(Keyword::Type) {
+            self.comptime_mutable_and_unconstrained_not_applicable(modifiers);
+
+            return vec![ItemKind::TypeAlias(
+                self.parse_type_alias(modifiers.visibility, start_span),
+            )];
+        }
+
+        if self.eat_keyword(Keyword::Fn) {
+            self.mutable_not_applicable(modifiers);
+
+            return vec![ItemKind::Function(self.parse_function(
+                attributes,
+                modifiers.visibility,
+                modifiers.comptime.is_some(),
+                modifiers.unconstrained.is_some(),
+                false, // allow_self
+            ))];
+        }
+
+        vec![]
+    }
+
+    fn eat_mod_or_contract(&mut self) -> Option<bool> {
+        if self.eat_keyword(Keyword::Mod) {
+            Some(false)
+        } else if self.eat_keyword(Keyword::Contract) {
+            Some(true)
+        } else {
+            None
+        }
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use crate::{
+        parse_program,
+        parser::parser::tests::{get_single_error, get_source_with_error_span},
+    };
+
+    #[test]
+    fn recovers_on_unknown_item() {
+        let src = "
+        fn foo() {} hello fn bar() {}
+                    ^^^^^
+        ";
+        let (src, span) = get_source_with_error_span(src);
+        let (module, errors) = parse_program(&src);
+        assert_eq!(module.items.len(), 2);
+        let error = get_single_error(&errors, span);
+        assert_eq!(error.to_string(), "Expected an item but found 'hello'");
+    }
+
+    #[test]
+    fn errors_on_eof_in_nested_mod() {
+        let src = "
+        mod foo { fn foo() {} 
+                             ^
+        ";
+        let (src, span) = get_source_with_error_span(src);
+        let (module, errors) = parse_program(&src);
+        assert_eq!(module.items.len(), 1);
+        let error = get_single_error(&errors, span);
+        assert_eq!(error.to_string(), "Expected a '}' but found end of input");
+    }
+}
diff --git a/compiler/noirc_frontend/src/parser/parser/item_visibility.rs b/compiler/noirc_frontend/src/parser/parser/item_visibility.rs
new file mode 100644
index 00000000000..5aea5f6a45f
--- /dev/null
+++ b/compiler/noirc_frontend/src/parser/parser/item_visibility.rs
@@ -0,0 +1,114 @@
+use crate::{
+    ast::ItemVisibility,
+    token::{Keyword, Token},
+};
+
+use super::Parser;
+
+impl<'a> Parser<'a> {
+    /// ItemVisibility
+    ///     = 'pub'                 // ItemVisibility::Public
+    ///     | 'pub' '(' 'crate' ')' // ItemVisibility::PublicCrate
+    ///     | nothing               // ItemVisibility::Private
+    pub(super) fn parse_item_visibility(&mut self) -> ItemVisibility {
+        if !self.eat_keyword(Keyword::Pub) {
+            return ItemVisibility::Private;
+        }
+
+        if !self.eat_left_paren() {
+            // `pub`
+            return ItemVisibility::Public;
+        }
+
+        if !self.eat_keyword(Keyword::Crate) {
+            // `pub(` or `pub()`
+            self.expected_token(Token::Keyword(Keyword::Crate));
+            self.eat_right_paren();
+            return ItemVisibility::Public;
+        }
+
+        self.eat_or_error(Token::RightParen);
+
+        // `pub(crate)``
+        ItemVisibility::PublicCrate
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use crate::{
+        ast::ItemVisibility,
+        parser::{
+            parser::tests::{expect_no_errors, get_single_error, get_source_with_error_span},
+            Parser,
+        },
+    };
+
+    #[test]
+    fn parses_private_visibility() {
+        let src = "(";
+        let mut parser = Parser::for_str(src);
+        let visibility = parser.parse_item_visibility();
+        expect_no_errors(&parser.errors);
+        assert_eq!(visibility, ItemVisibility::Private);
+    }
+
+    #[test]
+    fn parses_public_visibility() {
+        let src = "pub";
+        let mut parser = Parser::for_str(src);
+        let visibility = parser.parse_item_visibility();
+        expect_no_errors(&parser.errors);
+        assert_eq!(visibility, ItemVisibility::Public);
+    }
+
+    #[test]
+    fn parses_public_visibility_unclosed_parentheses() {
+        let src = "
+        pub( 
+            ^
+        ";
+        let (src, span) = get_source_with_error_span(src);
+        let mut parser = Parser::for_str(&src);
+        let visibility = parser.parse_item_visibility();
+        assert_eq!(visibility, ItemVisibility::Public);
+        let error = get_single_error(&parser.errors, span);
+        assert_eq!(error.to_string(), "Expected a 'crate' but found end of input");
+    }
+
+    #[test]
+    fn parses_public_visibility_no_crate_after_pub() {
+        let src = "
+        pub(hello
+            ^^^^^
+        ";
+        let (src, span) = get_source_with_error_span(src);
+        let mut parser = Parser::for_str(&src);
+        let visibility = parser.parse_item_visibility();
+        assert_eq!(visibility, ItemVisibility::Public);
+        let error = get_single_error(&parser.errors, span);
+        assert_eq!(error.to_string(), "Expected a 'crate' but found 'hello'");
+    }
+    #[test]
+    fn parses_public_visibility_missing_paren_after_pub_crate() {
+        let src = "
+        pub(crate 
+                 ^
+        ";
+        let (src, span) = get_source_with_error_span(src);
+        let mut parser = Parser::for_str(&src);
+        let visibility = parser.parse_item_visibility();
+        assert_eq!(visibility, ItemVisibility::PublicCrate);
+        let error = get_single_error(&parser.errors, span);
+        assert_eq!(error.to_string(), "Expected a ')' but found end of input");
+    }
+
+    #[test]
+    fn parses_public_crate_visibility() {
+        let src = "pub(crate)";
+        let mut parser = Parser::for_str(src);
+        let visibility = parser.parse_item_visibility();
+        expect_no_errors(&parser.errors);
+        assert_eq!(visibility, ItemVisibility::PublicCrate);
+    }
+}
diff --git a/compiler/noirc_frontend/src/parser/parser/lambda.rs b/compiler/noirc_frontend/src/parser/parser/lambda.rs
new file mode 100644
index 00000000000..a6eeb428621
--- /dev/null
+++ b/compiler/noirc_frontend/src/parser/parser/lambda.rs
@@ -0,0 +1,58 @@
+use crate::{
+    ast::{ExpressionKind, Lambda, Pattern, UnresolvedType},
+    parser::labels::ParsingRuleLabel,
+    token::Token,
+};
+
+use super::{parse_many::separated_by_comma, Parser};
+
+impl<'a> Parser<'a> {
+    /// Lambda = '|' LambdaParameters? '|' ( '->' Type )? Expression
+    ///
+    /// LambdaParameters = LambdaParameter ( ',' LambdaParameter )? ','?
+    ///
+    /// LambdaParameter
+    ///     = Pattern OptionalTypeAnnotation
+    pub(super) fn parse_lambda(&mut self) -> Option<ExpressionKind> {
+        if !self.eat_pipe() {
+            return None;
+        }
+
+        let parameters = self.parse_lambda_parameters();
+        let return_type = if self.eat(Token::Arrow) {
+            self.parse_type_or_error()
+        } else {
+            self.unspecified_type_at_previous_token_end()
+        };
+        let body = self.parse_expression_or_error();
+
+        Some(ExpressionKind::Lambda(Box::new(Lambda { parameters, return_type, body })))
+    }
+
+    fn parse_lambda_parameters(&mut self) -> Vec<(Pattern, UnresolvedType)> {
+        self.parse_many(
+            "parameters",
+            separated_by_comma().until(Token::Pipe),
+            Self::parse_lambda_parameter,
+        )
+    }
+
+    fn parse_lambda_parameter(&mut self) -> Option<(Pattern, UnresolvedType)> {
+        loop {
+            let Some(pattern) = self.parse_pattern() else {
+                self.expected_label(ParsingRuleLabel::Pattern);
+
+                // Let's try with the next token.
+                self.bump();
+                if self.at_eof() {
+                    return None;
+                } else {
+                    continue;
+                }
+            };
+
+            let typ = self.parse_optional_type_annotation();
+            return Some((pattern, typ));
+        }
+    }
+}
diff --git a/compiler/noirc_frontend/src/parser/parser/lambdas.rs b/compiler/noirc_frontend/src/parser/parser/lambdas.rs
deleted file mode 100644
index 5ef0b918375..00000000000
--- a/compiler/noirc_frontend/src/parser/parser/lambdas.rs
+++ /dev/null
@@ -1,43 +0,0 @@
-use chumsky::{primitive::just, Parser};
-
-use super::{parse_type, pattern};
-use crate::ast::{Expression, ExpressionKind, Lambda, Pattern, UnresolvedType};
-use crate::macros_api::UnresolvedTypeData;
-use crate::{
-    parser::{labels::ParsingRuleLabel, parameter_name_recovery, parameter_recovery, NoirParser},
-    token::Token,
-};
-
-pub(super) fn lambda<'a>(
-    expr_parser: impl NoirParser<Expression> + 'a,
-) -> impl NoirParser<ExpressionKind> + 'a {
-    lambda_parameters()
-        .delimited_by(just(Token::Pipe), just(Token::Pipe))
-        .then(lambda_return_type())
-        .then(expr_parser)
-        .map(|((parameters, return_type), body)| {
-            ExpressionKind::Lambda(Box::new(Lambda { parameters, return_type, body }))
-        })
-}
-
-fn lambda_parameters() -> impl NoirParser<Vec<(Pattern, UnresolvedType)>> {
-    let typ = parse_type().recover_via(parameter_recovery());
-    let typ = just(Token::Colon).ignore_then(typ);
-
-    let parameter =
-        pattern().recover_via(parameter_name_recovery()).then(typ.or_not().map_with_span(
-            |typ, span| typ.unwrap_or(UnresolvedTypeData::Unspecified.with_span(span)),
-        ));
-
-    parameter
-        .separated_by(just(Token::Comma))
-        .allow_trailing()
-        .labelled(ParsingRuleLabel::Parameter)
-}
-
-fn lambda_return_type() -> impl NoirParser<UnresolvedType> {
-    just(Token::Arrow)
-        .ignore_then(parse_type())
-        .or_not()
-        .map_with_span(|ret, span| ret.unwrap_or(UnresolvedTypeData::Unspecified.with_span(span)))
-}
diff --git a/compiler/noirc_frontend/src/parser/parser/literals.rs b/compiler/noirc_frontend/src/parser/parser/literals.rs
deleted file mode 100644
index b25b6acc9e2..00000000000
--- a/compiler/noirc_frontend/src/parser/parser/literals.rs
+++ /dev/null
@@ -1,158 +0,0 @@
-use chumsky::Parser;
-
-use crate::{
-    ast::ExpressionKind,
-    parser::NoirParser,
-    token::{Token, TokenKind},
-};
-
-use super::primitives::token_kind;
-
-pub(super) fn literal() -> impl NoirParser<ExpressionKind> {
-    token_kind(TokenKind::Literal).map(|token| match token {
-        Token::Int(x) => ExpressionKind::integer(x),
-        Token::Bool(b) => ExpressionKind::boolean(b),
-        Token::Str(s) => ExpressionKind::string(s),
-        Token::RawStr(s, hashes) => ExpressionKind::raw_string(s, hashes),
-        Token::FmtStr(s) => ExpressionKind::format_string(s),
-        unexpected => unreachable!("Non-literal {} parsed as a literal", unexpected),
-    })
-}
-
-#[cfg(test)]
-mod test {
-    use super::*;
-    use crate::ast::Literal;
-    use crate::parser::parser::{
-        expression, expression_no_constructors, fresh_statement, term, test_helpers::*,
-    };
-
-    fn expr_to_lit(expr: ExpressionKind) -> Literal {
-        match expr {
-            ExpressionKind::Literal(literal) => literal,
-            _ => unreachable!("expected a literal"),
-        }
-    }
-
-    #[test]
-    fn parse_int() {
-        let int = parse_with(literal(), "5").unwrap();
-        let hex = parse_with(literal(), "0x05").unwrap();
-
-        match (expr_to_lit(int), expr_to_lit(hex)) {
-            (Literal::Integer(int, false), Literal::Integer(hex, false)) => assert_eq!(int, hex),
-            _ => unreachable!(),
-        }
-    }
-
-    #[test]
-    fn parse_string() {
-        let expr = parse_with(literal(), r#""hello""#).unwrap();
-        match expr_to_lit(expr) {
-            Literal::Str(s) => assert_eq!(s, "hello"),
-            _ => unreachable!(),
-        };
-    }
-
-    #[test]
-    fn parse_bool() {
-        let expr_true = parse_with(literal(), "true").unwrap();
-        let expr_false = parse_with(literal(), "false").unwrap();
-
-        match (expr_to_lit(expr_true), expr_to_lit(expr_false)) {
-            (Literal::Bool(t), Literal::Bool(f)) => {
-                assert!(t);
-                assert!(!f);
-            }
-            _ => unreachable!(),
-        };
-    }
-
-    #[test]
-    fn parse_unary() {
-        parse_all(
-            term(expression(), expression_no_constructors(expression()), fresh_statement(), true),
-            vec!["!hello", "-hello", "--hello", "-!hello", "!-hello"],
-        );
-        parse_all_failing(
-            term(expression(), expression_no_constructors(expression()), fresh_statement(), true),
-            vec!["+hello", "/hello"],
-        );
-    }
-
-    #[test]
-    fn parse_raw_string_expr() {
-        let cases = vec![
-            Case { source: r#" r"foo" "#, expect: r#"r"foo""#, errors: 0 },
-            Case { source: r##" r#"foo"# "##, expect: r##"r#"foo"#"##, errors: 0 },
-            // backslash
-            Case { source: r#" r"\\" "#, expect: r#"r"\\""#, errors: 0 },
-            Case { source: r##" r#"\"# "##, expect: r##"r#"\"#"##, errors: 0 },
-            Case { source: r##" r#"\\"# "##, expect: r##"r#"\\"#"##, errors: 0 },
-            Case { source: r##" r#"\\\"# "##, expect: r##"r#"\\\"#"##, errors: 0 },
-            // escape sequence
-            Case {
-                source: r##" r#"\t\n\\t\\n\\\t\\\n\\\\"# "##,
-                expect: r##"r#"\t\n\\t\\n\\\t\\\n\\\\"#"##,
-                errors: 0,
-            },
-            Case { source: r##" r#"\\\\\\\\"# "##, expect: r##"r#"\\\\\\\\"#"##, errors: 0 },
-            // mismatch - errors:
-            Case { source: r###" r#"foo"## "###, expect: r##"r#"foo"#"##, errors: 1 },
-            Case { source: r##" r##"foo"# "##, expect: "(none)", errors: 2 },
-            // mismatch: short:
-            Case { source: r##" r"foo"# "##, expect: r#"r"foo""#, errors: 1 },
-            Case { source: r#" r#"foo" "#, expect: "(none)", errors: 2 },
-            // empty string
-            Case { source: r#"r"""#, expect: r#"r"""#, errors: 0 },
-            #[allow(clippy::needless_raw_string_hashes)]
-            Case { source: r####"r###""###"####, expect: r####"r###""###"####, errors: 0 },
-            // miscellaneous
-            Case { source: r##" r#\"foo\"# "##, expect: "r", errors: 2 },
-            Case { source: r#" r\"foo\" "#, expect: "r", errors: 1 },
-            Case { source: r##" r##"foo"# "##, expect: "(none)", errors: 2 },
-            // missing 'r' letter
-            Case { source: r##" ##"foo"# "##, expect: r#""foo""#, errors: 2 },
-            Case { source: r#" #"foo" "#, expect: "foo", errors: 2 },
-            // whitespace
-            Case { source: r##" r #"foo"# "##, expect: "r", errors: 2 },
-            Case { source: r##" r# "foo"# "##, expect: "r", errors: 3 },
-            Case { source: r#" r#"foo" # "#, expect: "(none)", errors: 2 },
-            // after identifier
-            Case { source: r##" bar#"foo"# "##, expect: "bar", errors: 2 },
-            // nested
-            Case {
-                source: r###"r##"foo r#"bar"# r"baz" ### bye"##"###,
-                expect: r###"r##"foo r#"bar"# r"baz" ### bye"##"###,
-                errors: 0,
-            },
-        ];
-
-        check_cases_with_errors(&cases[..], expression());
-    }
-
-    #[test]
-    fn parse_raw_string_lit() {
-        let lit_cases = vec![
-            Case { source: r#" r"foo" "#, expect: r#"r"foo""#, errors: 0 },
-            Case { source: r##" r#"foo"# "##, expect: r##"r#"foo"#"##, errors: 0 },
-            // backslash
-            Case { source: r#" r"\\" "#, expect: r#"r"\\""#, errors: 0 },
-            Case { source: r##" r#"\"# "##, expect: r##"r#"\"#"##, errors: 0 },
-            Case { source: r##" r#"\\"# "##, expect: r##"r#"\\"#"##, errors: 0 },
-            Case { source: r##" r#"\\\"# "##, expect: r##"r#"\\\"#"##, errors: 0 },
-            // escape sequence
-            Case {
-                source: r##" r#"\t\n\\t\\n\\\t\\\n\\\\"# "##,
-                expect: r##"r#"\t\n\\t\\n\\\t\\\n\\\\"#"##,
-                errors: 0,
-            },
-            Case { source: r##" r#"\\\\\\\\"# "##, expect: r##"r#"\\\\\\\\"#"##, errors: 0 },
-            // mismatch - errors:
-            Case { source: r###" r#"foo"## "###, expect: r##"r#"foo"#"##, errors: 1 },
-            Case { source: r##" r##"foo"# "##, expect: "(none)", errors: 2 },
-        ];
-
-        check_cases_with_errors(&lit_cases[..], literal());
-    }
-}
diff --git a/compiler/noirc_frontend/src/parser/parser/modifiers.rs b/compiler/noirc_frontend/src/parser/parser/modifiers.rs
new file mode 100644
index 00000000000..a668d3bae6a
--- /dev/null
+++ b/compiler/noirc_frontend/src/parser/parser/modifiers.rs
@@ -0,0 +1,52 @@
+use noirc_errors::Span;
+
+use crate::{ast::ItemVisibility, token::Keyword};
+
+use super::Parser;
+
+#[derive(Debug, Copy, Clone, PartialEq, Eq)]
+pub(crate) struct Modifiers {
+    pub(crate) visibility: ItemVisibility,
+    pub(crate) visibility_span: Span,
+    pub(crate) unconstrained: Option<Span>,
+    pub(crate) comptime: Option<Span>,
+    pub(crate) mutable: Option<Span>,
+}
+
+impl<'a> Parser<'a> {
+    /// Modifiers = ItemVisibility 'unconstrained'? 'comptime'? 'mut'?
+    ///
+    /// NOTE: we also allow `unconstrained` before the visibility for backwards compatibility.
+    /// The formatter will put it after the visibility.
+    pub(crate) fn parse_modifiers(&mut self, allow_mutable: bool) -> Modifiers {
+        let unconstrained = if self.eat_keyword(Keyword::Unconstrained) {
+            Some(self.previous_token_span)
+        } else {
+            None
+        };
+
+        let start_span = self.current_token_span;
+        let visibility = self.parse_item_visibility();
+        let visibility_span = self.span_since(start_span);
+
+        let unconstrained = if unconstrained.is_none() {
+            if self.eat_keyword(Keyword::Unconstrained) {
+                Some(self.previous_token_span)
+            } else {
+                None
+            }
+        } else {
+            unconstrained
+        };
+
+        let comptime =
+            if self.eat_keyword(Keyword::Comptime) { Some(self.previous_token_span) } else { None };
+        let mutable = if allow_mutable && self.eat_keyword(Keyword::Mut) {
+            Some(self.previous_token_span)
+        } else {
+            None
+        };
+
+        Modifiers { visibility, visibility_span, unconstrained, comptime, mutable }
+    }
+}
diff --git a/compiler/noirc_frontend/src/parser/parser/module.rs b/compiler/noirc_frontend/src/parser/parser/module.rs
new file mode 100644
index 00000000000..263338863c0
--- /dev/null
+++ b/compiler/noirc_frontend/src/parser/parser/module.rs
@@ -0,0 +1,104 @@
+use noirc_errors::Span;
+
+use crate::{
+    ast::{Ident, ItemVisibility, ModuleDeclaration},
+    parser::{ItemKind, ParsedSubModule},
+    token::{Attribute, Token},
+};
+
+use super::Parser;
+
+impl<'a> Parser<'a> {
+    /// ModOrContract
+    ///     = ( 'mod' | 'contract' ) identifier ( '{' Module '}' | ';' )
+    pub(super) fn parse_mod_or_contract(
+        &mut self,
+        attributes: Vec<(Attribute, Span)>,
+        is_contract: bool,
+        visibility: ItemVisibility,
+    ) -> ItemKind {
+        let outer_attributes = self.validate_secondary_attributes(attributes);
+
+        let Some(ident) = self.eat_ident() else {
+            self.expected_identifier();
+            return ItemKind::ModuleDecl(ModuleDeclaration {
+                visibility,
+                ident: Ident::default(),
+                outer_attributes,
+            });
+        };
+
+        if self.eat_left_brace() {
+            let contents = self.parse_module(
+                true, // nested
+            );
+            self.eat_or_error(Token::RightBrace);
+            ItemKind::Submodules(ParsedSubModule {
+                visibility,
+                name: ident,
+                contents,
+                outer_attributes,
+                is_contract,
+            })
+        } else {
+            if !self.eat_semicolons() {
+                self.expected_token(Token::Semicolon);
+            }
+            ItemKind::ModuleDecl(ModuleDeclaration { visibility, ident, outer_attributes })
+        }
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use crate::parser::{
+        parser::{parse_program, tests::expect_no_errors},
+        ItemKind,
+    };
+
+    #[test]
+    fn parse_module_declaration() {
+        // TODO: `contract foo;` is parsed correctly but we don't it's considered a module
+        let src = "mod foo;";
+        let (module, errors) = parse_program(src);
+        expect_no_errors(&errors);
+        assert_eq!(module.items.len(), 1);
+        let item = &module.items[0];
+        let ItemKind::ModuleDecl(module) = &item.kind else {
+            panic!("Expected module declaration");
+        };
+        assert_eq!("foo", module.ident.to_string());
+    }
+
+    #[test]
+    fn parse_submodule() {
+        let src = "mod foo { mod bar; }";
+        let (module, errors) = parse_program(src);
+        dbg!(&errors);
+        expect_no_errors(&errors);
+        assert_eq!(module.items.len(), 1);
+        let item = &module.items[0];
+        let ItemKind::Submodules(parsed_submodule) = &item.kind else {
+            panic!("Expected submodules declaration");
+        };
+        assert!(!parsed_submodule.is_contract);
+        assert_eq!("foo", parsed_submodule.name.to_string());
+        assert_eq!(parsed_submodule.contents.items.len(), 1);
+    }
+
+    #[test]
+    fn parse_contract() {
+        let src = "contract foo {}";
+        let (module, errors) = parse_program(src);
+        dbg!(&errors);
+        expect_no_errors(&errors);
+        assert_eq!(module.items.len(), 1);
+        let item = &module.items[0];
+        let ItemKind::Submodules(parsed_submodule) = &item.kind else {
+            panic!("Expected submodules declaration");
+        };
+        assert!(parsed_submodule.is_contract);
+        assert_eq!("foo", parsed_submodule.name.to_string());
+        assert_eq!(parsed_submodule.contents.items.len(), 0);
+    }
+}
diff --git a/compiler/noirc_frontend/src/parser/parser/parse_many.rs b/compiler/noirc_frontend/src/parser/parser/parse_many.rs
new file mode 100644
index 00000000000..be156eb1618
--- /dev/null
+++ b/compiler/noirc_frontend/src/parser/parser/parse_many.rs
@@ -0,0 +1,142 @@
+use crate::token::Token;
+
+use super::Parser;
+
+impl<'a> Parser<'a> {
+    /// Parses a list of items separated by a token, optionally ending when another token is found.
+    /// The given function `f` must parse one item (eventually parsing many, if separators are found).
+    /// If no item is parsed, `f` must report an error and return `None`.
+    pub(super) fn parse_many<T, F>(
+        &mut self,
+        items: &'static str,
+        separated_by: SeparatedBy,
+        f: F,
+    ) -> Vec<T>
+    where
+        F: FnMut(&mut Parser<'a>) -> Option<T>,
+    {
+        self.parse_many_return_trailing_separator_if_any(items, separated_by, f).0
+    }
+
+    /// parse_many, where the given function `f` may return multiple results
+    pub(super) fn parse_many_to_many<T, F>(
+        &mut self,
+        items: &'static str,
+        separated_by: SeparatedBy,
+        f: F,
+    ) -> Vec<T>
+    where
+        F: FnMut(&mut Parser<'a>) -> Vec<T>,
+    {
+        self.parse_many_to_many_return_trailing_separator_if_any(items, separated_by, f).0
+    }
+
+    /// Same as parse_many, but returns a bool indicating whether a trailing separator was found.
+    pub(super) fn parse_many_return_trailing_separator_if_any<T, F>(
+        &mut self,
+        items: &'static str,
+        separated_by: SeparatedBy,
+        mut f: F,
+    ) -> (Vec<T>, bool)
+    where
+        F: FnMut(&mut Parser<'a>) -> Option<T>,
+    {
+        let f = |x: &mut Parser<'a>| {
+            if let Some(result) = f(x) {
+                vec![result]
+            } else {
+                vec![]
+            }
+        };
+        self.parse_many_to_many_return_trailing_separator_if_any(items, separated_by, f)
+    }
+
+    /// Same as parse_many, but returns a bool indicating whether a trailing separator was found.
+    fn parse_many_to_many_return_trailing_separator_if_any<T, F>(
+        &mut self,
+        items: &'static str,
+        separated_by: SeparatedBy,
+        mut f: F,
+    ) -> (Vec<T>, bool)
+    where
+        F: FnMut(&mut Parser<'a>) -> Vec<T>,
+    {
+        let mut elements: Vec<T> = Vec::new();
+        let mut trailing_separator = false;
+        loop {
+            if let Some(end) = &separated_by.until {
+                if self.eat(end.clone()) {
+                    break;
+                }
+            }
+
+            let start_span = self.current_token_span;
+            let mut new_elements = f(self);
+            if new_elements.is_empty() {
+                if let Some(end) = &separated_by.until {
+                    self.eat(end.clone());
+                }
+                break;
+            }
+
+            if let Some(separator) = &separated_by.token {
+                if !trailing_separator && !elements.is_empty() {
+                    self.expected_token_separating_items(separator.clone(), items, start_span);
+                }
+            }
+
+            elements.append(&mut new_elements);
+
+            trailing_separator = if let Some(separator) = &separated_by.token {
+                self.eat(separator.clone())
+            } else {
+                true
+            };
+
+            if !trailing_separator && !separated_by.continue_if_separator_is_missing {
+                if let Some(end) = &separated_by.until {
+                    self.eat(end.clone());
+                }
+                break;
+            }
+        }
+
+        (elements, trailing_separator)
+    }
+}
+
+pub(super) struct SeparatedBy {
+    pub(super) token: Option<Token>,
+    pub(super) until: Option<Token>,
+    pub(super) continue_if_separator_is_missing: bool,
+}
+
+impl SeparatedBy {
+    pub(super) fn until(self, token: Token) -> SeparatedBy {
+        SeparatedBy { until: Some(token), ..self }
+    }
+
+    pub(super) fn stop_if_separator_is_missing(self) -> SeparatedBy {
+        SeparatedBy { continue_if_separator_is_missing: false, ..self }
+    }
+}
+
+pub(super) fn separated_by(token: Token) -> SeparatedBy {
+    SeparatedBy { token: Some(token), until: None, continue_if_separator_is_missing: true }
+}
+
+pub(super) fn separated_by_comma() -> SeparatedBy {
+    separated_by(Token::Comma)
+}
+
+pub(super) fn separated_by_comma_until_right_paren() -> SeparatedBy {
+    separated_by_comma().until(Token::RightParen)
+}
+
+pub(super) fn separated_by_comma_until_right_brace() -> SeparatedBy {
+    separated_by_comma().until(Token::RightBrace)
+}
+
+pub(super) fn without_separator() -> SeparatedBy {
+    SeparatedBy { token: None, until: None, continue_if_separator_is_missing: true }
+}
diff --git a/compiler/noirc_frontend/src/parser/parser/path.rs b/compiler/noirc_frontend/src/parser/parser/path.rs
index 1c9c24f5376..99aedc6df89 100644
--- a/compiler/noirc_frontend/src/parser/parser/path.rs
+++ b/compiler/noirc_frontend/src/parser/parser/path.rs
@@ -1,171 +1,356 @@
-use crate::ast::{AsTraitPath, Ident, Path, PathKind, PathSegment, TypePath, UnresolvedType};
-use crate::macros_api::ExpressionKind;
-use crate::parser::{NoirParser, ParserError, ParserErrorReason};
+use crate::ast::{AsTraitPath, Ident, Path, PathKind, PathSegment, UnresolvedType};
+use crate::parser::ParserErrorReason;
 
 use crate::token::{Keyword, Token};
 
-use chumsky::prelude::*;
 use noirc_errors::Span;
 
-use super::keyword;
-use super::primitives::{ident, path_segment, path_segment_no_turbofish, turbofish};
-use super::types::{generic_type_args, primitive_type};
+use crate::{parser::labels::ParsingRuleLabel, token::TokenKind};
 
-pub(super) fn path<'a>(
-    type_parser: impl NoirParser<UnresolvedType> + 'a,
-) -> impl NoirParser<Path> + 'a {
-    path_inner(path_segment(type_parser))
-}
+use super::Parser;
 
-pub fn path_no_turbofish() -> impl NoirParser<Path> {
-    path_inner(path_segment_no_turbofish())
-}
+impl<'a> Parser<'a> {
+    #[cfg(test)]
+    pub(crate) fn parse_path_or_error(&mut self) -> Path {
+        if let Some(path) = self.parse_path() {
+            path
+        } else {
+            self.expected_label(ParsingRuleLabel::Path);
 
-fn path_inner<'a>(segment: impl NoirParser<PathSegment> + 'a) -> impl NoirParser<Path> + 'a {
-    let segments = segment
-        .separated_by(just(Token::DoubleColon))
-        .at_least(1)
-        .then(just(Token::DoubleColon).then_ignore(none_of(Token::LeftBrace).rewind()).or_not())
-        .validate(|(path_segments, trailing_colons), span, emit_error| {
-            if trailing_colons.is_some() {
-                emit_error(ParserError::with_reason(
-                    ParserErrorReason::ExpectedIdentifierAfterColons,
-                    span,
-                ));
+            Path {
+                segments: Vec::new(),
+                kind: PathKind::Plain,
+                span: self.span_at_previous_token_end(),
             }
-            path_segments
-        });
-    let make_path = |kind| move |segments, span| Path { segments, kind, span };
-
-    let prefix = |key| keyword(key).ignore_then(just(Token::DoubleColon));
-    let path_kind =
-        |key, kind| prefix(key).ignore_then(segments.clone()).map_with_span(make_path(kind));
-
-    choice((
-        path_kind(Keyword::Crate, PathKind::Crate),
-        path_kind(Keyword::Dep, PathKind::Dep),
-        path_kind(Keyword::Super, PathKind::Super),
-        segments.map_with_span(make_path(PathKind::Plain)),
-    ))
-}
+        }
+    }
 
-/// Parses `<MyType as Trait>::path_segment`
-/// These paths only support exactly two segments.
-pub(super) fn as_trait_path<'a>(
-    type_parser: impl NoirParser<UnresolvedType> + 'a,
-) -> impl NoirParser<AsTraitPath> + 'a {
-    just(Token::Less)
-        .ignore_then(type_parser.clone())
-        .then_ignore(keyword(Keyword::As))
-        .then(path(type_parser.clone()))
-        .then(generic_type_args(type_parser))
-        .then_ignore(just(Token::Greater))
-        .then_ignore(just(Token::DoubleColon))
-        .then(ident())
-        .map(|(((typ, trait_path), trait_generics), impl_item)| AsTraitPath {
-            typ,
-            trait_path,
-            trait_generics,
-            impl_item,
-        })
-}
+    /// Tries to parse a Path.
+    /// Note that `crate::`, `super::`, etc., are not valid paths on their own.
+    ///
+    /// Path = PathKind identifier Turbofish? ( '::' identifier Turbofish? )*
+    ///
+    /// Turbofish = '::' PathGenerics
+    pub(crate) fn parse_path(&mut self) -> Option<Path> {
+        self.parse_path_impl(
+            true, // allow turbofish
+            true, // allow trailing double colon
+        )
+    }
 
-/// Parses `MyType::path_segment`
-/// These paths only support exactly two segments.
-/// Unlike normal paths `MyType` here can also be a primitive type or interned type
-/// in addition to a named type.
-pub(super) fn type_path<'a>(
-    type_parser: impl NoirParser<UnresolvedType> + 'a,
-) -> impl NoirParser<ExpressionKind> + 'a {
-    primitive_type()
-        .then_ignore(just(Token::DoubleColon))
-        .then(ident().or_not())
-        .then(turbofish(type_parser))
-        .validate(|((typ, item), turbofish), span, emit| {
-            let turbofish = turbofish.unwrap_or_default();
-            let item = if let Some(item) = item {
-                item
-            } else {
-                emit(ParserError::with_reason(
-                    ParserErrorReason::ExpectedIdentifierAfterColons,
-                    span,
-                ));
-                Ident::new(String::new(), Span::from(span.end()..span.end()))
-            };
-            ExpressionKind::TypePath(TypePath { typ, item, turbofish })
-        })
-}
+    pub(crate) fn parse_path_no_turbofish_or_error(&mut self) -> Path {
+        if let Some(path) = self.parse_path_no_turbofish() {
+            path
+        } else {
+            self.expected_label(ParsingRuleLabel::Path);
+
+            Path {
+                segments: Vec::new(),
+                kind: PathKind::Plain,
+                span: self.span_at_previous_token_end(),
+            }
+        }
+    }
 
-fn empty_path() -> impl NoirParser<Path> {
-    let make_path = |kind| move |_, span| Path { segments: Vec::new(), kind, span };
-    let path_kind = |key, kind| keyword(key).map_with_span(make_path(kind));
+    /// PathNoTurbofish = PathKind identifier ( '::' identifier )*
+    pub fn parse_path_no_turbofish(&mut self) -> Option<Path> {
+        self.parse_path_impl(
+            false, // allow turbofish
+            true,  // allow trailing double colon
+        )
+    }
 
-    choice((path_kind(Keyword::Crate, PathKind::Crate), path_kind(Keyword::Dep, PathKind::Plain)))
-}
+    pub(super) fn parse_path_impl(
+        &mut self,
+        allow_turbofish: bool,
+        allow_trailing_double_colon: bool,
+    ) -> Option<Path> {
+        let start_span = self.current_token_span;
+
+        let kind = self.parse_path_kind();
+
+        let path = self.parse_optional_path_after_kind(
+            kind,
+            allow_turbofish,
+            allow_trailing_double_colon,
+            start_span,
+        )?;
+        if path.segments.is_empty() {
+            if path.kind != PathKind::Plain {
+                self.expected_identifier();
+            }
+            None
+        } else {
+            Some(path)
+        }
+    }
+
+    pub(super) fn parse_optional_path_after_kind(
+        &mut self,
+        kind: PathKind,
+        allow_turbofish: bool,
+        allow_trailing_double_colon: bool,
+        start_span: Span,
+    ) -> Option<Path> {
+        let path = self.parse_path_after_kind(
+            kind,
+            allow_turbofish,
+            allow_trailing_double_colon,
+            start_span,
+        );
+
+        if path.segments.is_empty() && path.kind == PathKind::Plain {
+            None
+        } else {
+            Some(path)
+        }
+    }
+
+    /// Parses a path assuming the path's kind (plain, `crate::`, `super::`, etc.)
+    /// was already parsed. Note that this method always returns a Path, even if it
+    /// ends up being just `crate::` or an empty path.
+    pub(super) fn parse_path_after_kind(
+        &mut self,
+        kind: PathKind,
+        allow_turbofish: bool,
+        allow_trailing_double_colon: bool,
+        start_span: Span,
+    ) -> Path {
+        let mut segments = Vec::new();
+
+        if self.token.kind() == TokenKind::Ident {
+            loop {
+                let ident = self.eat_ident().unwrap();
+                let span = ident.span();
+
+                let generics = if allow_turbofish
+                    && self.at(Token::DoubleColon)
+                    && self.next_is(Token::Less)
+                {
+                    self.bump();
+                    self.parse_path_generics(ParserErrorReason::AssociatedTypesNotAllowedInPaths)
+                } else {
+                    None
+                };
+
+                segments.push(PathSegment { ident, generics, span });
+
+                if self.at(Token::DoubleColon)
+                    && matches!(self.next_token.token(), Token::Ident(..))
+                {
+                    // Skip the double colons
+                    self.bump();
+                } else {
+                    if allow_trailing_double_colon && self.eat_double_colon() {
+                        self.expected_identifier();
+                        break;
+                    }
+
+                    break;
+                }
+            }
+        }
+
+        Path { segments, kind, span: self.span_since(start_span) }
+    }
+
+    /// PathGenerics = GenericTypeArgs
+    pub(super) fn parse_path_generics(
+        &mut self,
+        on_named_arg_error: ParserErrorReason,
+    ) -> Option<Vec<UnresolvedType>> {
+        if self.token.token() != &Token::Less {
+            return None;
+        };
 
-pub(super) fn maybe_empty_path() -> impl NoirParser<Path> {
-    path_no_turbofish().or(empty_path())
+        let generics = self.parse_generic_type_args();
+        for (name, _typ) in &generics.named_args {
+            self.push_error(on_named_arg_error.clone(), name.span());
+        }
+
+        Some(generics.ordered_args)
+    }
+
+    /// PathKind
+    ///     | 'crate' '::'
+    ///     | 'dep' '::'
+    ///     | 'super' '::'
+    ///     | nothing
+    pub(super) fn parse_path_kind(&mut self) -> PathKind {
+        let kind = if self.eat_keyword(Keyword::Crate) {
+            PathKind::Crate
+        } else if self.eat_keyword(Keyword::Dep) {
+            PathKind::Dep
+        } else if self.eat_keyword(Keyword::Super) {
+            PathKind::Super
+        } else {
+            PathKind::Plain
+        };
+        if kind != PathKind::Plain {
+            self.eat_or_error(Token::DoubleColon);
+        }
+        kind
+    }
+
+    /// AsTraitPath = '<' Type 'as' PathNoTurbofish GenericTypeArgs '>' '::' identifier
+    pub(super) fn parse_as_trait_path(&mut self) -> Option<AsTraitPath> {
+        if !self.eat_less() {
+            return None;
+        }
+
+        let typ = self.parse_type_or_error();
+        self.eat_keyword_or_error(Keyword::As);
+        let trait_path = self.parse_path_no_turbofish_or_error();
+        let trait_generics = self.parse_generic_type_args();
+        self.eat_or_error(Token::Greater);
+        self.eat_or_error(Token::DoubleColon);
+        let impl_item = if let Some(ident) = self.eat_ident() {
+            ident
+        } else {
+            self.expected_identifier();
+            Ident::new(String::new(), self.span_at_previous_token_end())
+        };
+
+        Some(AsTraitPath { typ, trait_path, trait_generics, impl_item })
+    }
 }
 
 #[cfg(test)]
-mod test {
-    use super::*;
-    use crate::parser::{
-        parse_type,
-        parser::test_helpers::{parse_all_failing, parse_recover, parse_with},
+mod tests {
+
+    use crate::{
+        ast::{Path, PathKind},
+        parser::{
+            parser::tests::{expect_no_errors, get_single_error, get_source_with_error_span},
+            Parser,
+        },
     };
 
+    fn parse_path_no_errors(src: &str) -> Path {
+        let mut parser = Parser::for_str(src);
+        let path = parser.parse_path_or_error();
+        expect_no_errors(&parser.errors);
+        path
+    }
+
     #[test]
-    fn parse_path() {
-        let cases = vec![
-            ("std", vec!["std"]),
-            ("std::hash", vec!["std", "hash"]),
-            ("std::hash::collections", vec!["std", "hash", "collections"]),
-            ("foo::bar", vec!["foo", "bar"]),
-            ("crate::std::hash", vec!["std", "hash"]),
-        ];
-
-        for (src, expected_segments) in cases {
-            let path: Path = parse_with(path(parse_type()), src).unwrap();
-            for (segment, expected) in path.segments.into_iter().zip(expected_segments) {
-                assert_eq!(segment.ident.0.contents, expected);
-            }
-        }
+    fn parses_plain_one_segment() {
+        let src = "foo";
+        let path = parse_path_no_errors(src);
+        assert_eq!(path.kind, PathKind::Plain);
+        assert_eq!(path.segments.len(), 1);
+        assert_eq!(path.segments[0].ident.to_string(), "foo");
+        assert!(path.segments[0].generics.is_none());
+    }
 
-        parse_all_failing(path(parse_type()), vec!["std::", "::std", "std::hash::", "foo::1"]);
+    #[test]
+    fn parses_plain_two_segments() {
+        let src = "foo::bar";
+        let path = parse_path_no_errors(src);
+        assert_eq!(path.kind, PathKind::Plain);
+        assert_eq!(path.segments.len(), 2);
+        assert_eq!(path.segments[0].ident.to_string(), "foo");
+        assert!(path.segments[0].generics.is_none());
+        assert_eq!(path.segments[1].ident.to_string(), "bar");
+        assert!(path.segments[1].generics.is_none());
     }
 
     #[test]
-    fn parse_path_kinds() {
-        let cases = vec![
-            ("std", PathKind::Plain),
-            ("hash::collections", PathKind::Plain),
-            ("crate::std::hash", PathKind::Crate),
-            ("super::foo", PathKind::Super),
-        ];
-
-        for (src, expected_path_kind) in cases {
-            let path = parse_with(path(parse_type()), src).unwrap();
-            assert_eq!(path.kind, expected_path_kind);
-        }
+    fn parses_crate_two_segments() {
+        let src = "crate::foo::bar";
+        let path = parse_path_no_errors(src);
+        assert_eq!(path.kind, PathKind::Crate);
+        assert_eq!(path.segments.len(), 2);
+        assert_eq!(path.segments[0].ident.to_string(), "foo");
+        assert!(path.segments[0].generics.is_none());
+        assert_eq!(path.segments[1].ident.to_string(), "bar");
+        assert!(path.segments[1].generics.is_none());
+    }
 
-        parse_all_failing(
-            path(parse_type()),
-            vec!["crate", "crate::std::crate", "foo::bar::crate", "foo::dep"],
-        );
+    #[test]
+    fn parses_super_two_segments() {
+        let src = "super::foo::bar";
+        let path = parse_path_no_errors(src);
+        assert_eq!(path.kind, PathKind::Super);
+        assert_eq!(path.segments.len(), 2);
+        assert_eq!(path.segments[0].ident.to_string(), "foo");
+        assert!(path.segments[0].generics.is_none());
+        assert_eq!(path.segments[1].ident.to_string(), "bar");
+        assert!(path.segments[1].generics.is_none());
     }
 
     #[test]
-    fn parse_path_with_trailing_colons() {
-        let src = "foo::bar::";
+    fn parses_dep_two_segments() {
+        let src = "dep::foo::bar";
+        let path = parse_path_no_errors(src);
+        assert_eq!(path.kind, PathKind::Dep);
+        assert_eq!(path.segments.len(), 2);
+        assert_eq!(path.segments[0].ident.to_string(), "foo");
+        assert!(path.segments[0].generics.is_none());
+        assert_eq!(path.segments[1].ident.to_string(), "bar");
+        assert!(path.segments[1].generics.is_none());
+    }
+
+    #[test]
+    fn parses_plain_one_segment_with_trailing_colons() {
+        let src = "foo::";
+        let mut parser = Parser::for_str(src);
+        let path = parser.parse_path_or_error();
+        assert_eq!(path.span.end() as usize, src.len());
+        assert_eq!(parser.errors.len(), 1);
+        assert_eq!(path.kind, PathKind::Plain);
+        assert_eq!(path.segments.len(), 1);
+        assert_eq!(path.segments[0].ident.to_string(), "foo");
+        assert!(path.segments[0].generics.is_none());
+    }
 
-        let (path, errors) = parse_recover(path_no_turbofish(), src);
-        let path = path.unwrap();
+    #[test]
+    fn parses_with_turbofish() {
+        let src = "foo::<T, i32>::bar";
+        let mut path = parse_path_no_errors(src);
+        assert_eq!(path.kind, PathKind::Plain);
         assert_eq!(path.segments.len(), 2);
-        assert_eq!(path.segments[0].ident.0.contents, "foo");
-        assert_eq!(path.segments[1].ident.0.contents, "bar");
+        assert_eq!(path.segments[0].ident.to_string(), "foo");
+
+        let generics = path.segments.remove(0).generics;
+        assert_eq!(generics.unwrap().len(), 2);
+
+        let generics = path.segments.remove(0).generics;
+        assert!(generics.is_none());
+    }
+
+    #[test]
+    fn parses_path_stops_before_trailing_double_colon() {
+        let src = "foo::bar::";
+        let mut parser = Parser::for_str(src);
+        let path = parser.parse_path_or_error();
+        assert_eq!(path.span.end() as usize, src.len());
+        assert_eq!(parser.errors.len(), 1);
+        assert_eq!(path.to_string(), "foo::bar");
+    }
+
+    #[test]
+    fn parses_path_with_turbofish_stops_before_trailing_double_colon() {
+        let src = "foo::bar::<1>::";
+        let mut parser = Parser::for_str(src);
+        let path = parser.parse_path_or_error();
+        assert_eq!(path.span.end() as usize, src.len());
+        assert_eq!(parser.errors.len(), 1);
+        assert_eq!(path.to_string(), "foo::bar::<1>");
+    }
+
+    #[test]
+    fn errors_on_crate_double_colons() {
+        let src = "
+        crate:: 
+               ^
+        ";
+        let (src, span) = get_source_with_error_span(src);
+        let mut parser = Parser::for_str(&src);
+        let path = parser.parse_path();
+        assert!(path.is_none());
 
-        assert_eq!(errors.len(), 1);
-        assert_eq!(errors[0].message, "expected an identifier after ::");
+        let error = get_single_error(&parser.errors, span);
+        assert_eq!(error.to_string(), "Expected an identifier but found end of input");
     }
 }
diff --git a/compiler/noirc_frontend/src/parser/parser/pattern.rs b/compiler/noirc_frontend/src/parser/parser/pattern.rs
new file mode 100644
index 00000000000..c4dcab55d73
--- /dev/null
+++ b/compiler/noirc_frontend/src/parser/parser/pattern.rs
@@ -0,0 +1,406 @@
+use noirc_errors::Span;
+
+use crate::{
+    ast::{Ident, Path, Pattern},
+    parser::{labels::ParsingRuleLabel, ParserErrorReason},
+    token::{Keyword, Token, TokenKind},
+};
+
+use super::{
+    parse_many::{separated_by_comma_until_right_brace, separated_by_comma_until_right_paren},
+    Parser,
+};
+
+pub(crate) enum PatternOrSelf {
+    Pattern(Pattern),
+    SelfPattern(SelfPattern),
+}
+
+/// SelfPattern is guaranteed to be `self`, `&self` or `&mut self` without a colon following it.
+pub(crate) struct SelfPattern {
+    pub(crate) reference: bool,
+    pub(crate) mutable: bool,
+}
+
+impl<'a> Parser<'a> {
+    pub(crate) fn parse_pattern_or_error(&mut self) -> Pattern {
+        if let Some(pattern) = self.parse_pattern() {
+            return pattern;
+        }
+
+        self.expected_label(ParsingRuleLabel::Pattern);
+        Pattern::Identifier(Ident::new(String::new(), self.span_at_previous_token_end()))
+    }
+
+    /// Pattern
+    ///     = 'mut' PatternNoMut
+    pub(crate) fn parse_pattern(&mut self) -> Option<Pattern> {
+        let start_span = self.current_token_span;
+        let mutable = self.eat_keyword(Keyword::Mut);
+        self.parse_pattern_after_modifiers(mutable, start_span)
+    }
+
+    /// PatternOrSelf
+    ///     = Pattern
+    ///     | SelfPattern
+    pub(crate) fn parse_pattern_or_self(&mut self) -> Option<PatternOrSelf> {
+        let start_span = self.current_token_span;
+
+        if !self.next_is_colon() && self.eat_self() {
+            return Some(PatternOrSelf::SelfPattern(SelfPattern {
+                reference: false,
+                mutable: false,
+            }));
+        }
+
+        if self.eat_keyword(Keyword::Mut) {
+            if !self.next_is_colon() && self.eat_self() {
+                return Some(PatternOrSelf::SelfPattern(SelfPattern {
+                    reference: false,
+                    mutable: true,
+                }));
+            } else {
+                return Some(PatternOrSelf::Pattern(
+                    self.parse_pattern_after_modifiers(true, start_span)?,
+                ));
+            }
+        }
+
+        if self.at(Token::Ampersand) && self.next_is(Token::Keyword(Keyword::Mut)) {
+            self.bump();
+            self.bump();
+            if !self.next_is_colon() && self.eat_self() {
+                return Some(PatternOrSelf::SelfPattern(SelfPattern {
+                    reference: true,
+                    mutable: true,
+                }));
+            } else {
+                self.push_error(
+                    ParserErrorReason::RefMutCanOnlyBeUsedWithSelf,
+                    self.current_token_span,
+                );
+                return Some(PatternOrSelf::Pattern(
+                    self.parse_pattern_after_modifiers(true, start_span)?,
+                ));
+            }
+        }
+
+        Some(PatternOrSelf::Pattern(self.parse_pattern_after_modifiers(false, start_span)?))
+    }
+
+    fn next_is_colon(&self) -> bool {
+        self.next_is(Token::Colon)
+    }
+
+    pub(crate) fn parse_pattern_after_modifiers(
+        &mut self,
+        mutable: bool,
+        start_span: Span,
+    ) -> Option<Pattern> {
+        let pattern = self.parse_pattern_no_mut()?;
+        Some(if mutable {
+            Pattern::Mutable(
+                Box::new(pattern),
+                self.span_since(start_span),
+                false, // is synthesized
+            )
+        } else {
+            pattern
+        })
+    }
+
+    /// PatternNoMut
+    ///     = InternedPattern
+    ///     | TuplePattern
+    ///     | StructPattern
+    ///     | IdentifierPattern
+    ///
+    /// IdentifierPattern = identifier
+    fn parse_pattern_no_mut(&mut self) -> Option<Pattern> {
+        let start_span = self.current_token_span;
+
+        if let Some(pattern) = self.parse_interned_pattern() {
+            return Some(pattern);
+        }
+
+        if let Some(pattern) = self.parse_tuple_pattern() {
+            return Some(pattern);
+        }
+
+        let Some(mut path) = self.parse_path() else {
+            if self.at_built_in_type() {
+                self.push_error(
+                    ParserErrorReason::ExpectedPatternButFoundType(self.token.token().clone()),
+                    self.current_token_span,
+                );
+            }
+            return None;
+        };
+
+        if self.eat_left_brace() {
+            return Some(self.parse_struct_pattern(path, start_span));
+        }
+
+        if !path.is_ident() {
+            self.push_error(ParserErrorReason::InvalidPattern, path.span);
+
+            let ident = path.segments.pop().unwrap().ident;
+            return Some(Pattern::Identifier(ident));
+        }
+
+        let ident = path.segments.remove(0).ident;
+        Some(Pattern::Identifier(ident))
+    }
+
+    /// InternedPattern = interned_pattern
+    fn parse_interned_pattern(&mut self) -> Option<Pattern> {
+        let Some(token) = self.eat_kind(TokenKind::InternedPattern) else {
+            return None;
+        };
+
+        match token.into_token() {
+            Token::InternedPattern(pattern) => {
+                Some(Pattern::Interned(pattern, self.previous_token_span))
+            }
+            _ => unreachable!(),
+        }
+    }
+
+    /// TuplePattern = '(' PatternList? ')'
+    ///
+    /// PatternList = Pattern ( ',' Pattern )* ','?
+    fn parse_tuple_pattern(&mut self) -> Option<Pattern> {
+        let start_span = self.current_token_span;
+
+        if !self.eat_left_paren() {
+            return None;
+        }
+
+        let patterns = self.parse_many(
+            "tuple elements",
+            separated_by_comma_until_right_paren(),
+            Self::parse_tuple_pattern_element,
+        );
+
+        Some(Pattern::Tuple(patterns, self.span_since(start_span)))
+    }
+
+    fn parse_tuple_pattern_element(&mut self) -> Option<Pattern> {
+        if let Some(pattern) = self.parse_pattern() {
+            Some(pattern)
+        } else {
+            self.expected_label(ParsingRuleLabel::Pattern);
+            None
+        }
+    }
+
+    /// StructPattern = Path '{' StructPatternFields? '}'
+    ///
+    /// StructPatternFields = StructPatternField ( ',' StructPatternField )? ','?
+    ///
+    /// StructPatternField = identifier ( ':' Pattern )?
+    fn parse_struct_pattern(&mut self, path: Path, start_span: Span) -> Pattern {
+        let fields = self.parse_many(
+            "struct fields",
+            separated_by_comma_until_right_brace(),
+            Self::parse_struct_pattern_field,
+        );
+
+        Pattern::Struct(path, fields, self.span_since(start_span))
+    }
+
+    fn parse_struct_pattern_field(&mut self) -> Option<(Ident, Pattern)> {
+        let Some(ident) = self.eat_ident() else {
+            self.expected_identifier();
+            return None;
+        };
+
+        Some(if self.eat_colon() {
+            (ident, self.parse_pattern_or_error())
+        } else if self.at(Token::Assign) {
+            // If we find '=' instead of ':', assume the user meant ':`, error and continue
+            self.expected_token(Token::Colon);
+            self.bump();
+            (ident, self.parse_pattern_or_error())
+        } else {
+            (ident.clone(), Pattern::Identifier(ident))
+        })
+    }
+
+    fn at_built_in_type(&self) -> bool {
+        matches!(
+            self.token.token(),
+            Token::Bool(..)
+                | Token::IntType(..)
+                | Token::Keyword(Keyword::Bool)
+                | Token::Keyword(Keyword::CtString)
+                | Token::Keyword(Keyword::Expr)
+                | Token::Keyword(Keyword::Field)
+                | Token::Keyword(Keyword::FunctionDefinition)
+                | Token::Keyword(Keyword::Module)
+                | Token::Keyword(Keyword::Quoted)
+                | Token::Keyword(Keyword::StructDefinition)
+                | Token::Keyword(Keyword::TraitConstraint)
+                | Token::Keyword(Keyword::TraitDefinition)
+                | Token::Keyword(Keyword::TraitImpl)
+                | Token::Keyword(Keyword::TypedExpr)
+                | Token::Keyword(Keyword::TypeType)
+                | Token::Keyword(Keyword::UnresolvedType)
+        )
+    }
+}
+
+#[cfg(test)]
+mod tests {
+
+    use crate::{
+        ast::Pattern,
+        parser::{
+            parser::tests::{
+                expect_no_errors, get_single_error, get_single_error_reason,
+                get_source_with_error_span,
+            },
+            Parser, ParserErrorReason,
+        },
+        token::{Keyword, Token},
+    };
+
+    fn parse_pattern_no_errors(src: &str) -> Pattern {
+        let mut parser = Parser::for_str(src);
+        let pattern = parser.parse_pattern_or_error();
+        expect_no_errors(&parser.errors);
+        pattern
+    }
+
+    #[test]
+    fn parses_identifier_pattern() {
+        let src = "foo";
+        let pattern = parse_pattern_no_errors(src);
+        let Pattern::Identifier(ident) = pattern else { panic!("Expected an identifier pattern") };
+        assert_eq!(ident.to_string(), "foo");
+    }
+
+    #[test]
+    fn parses_mutable_pattern() {
+        let src = "mut foo";
+        let pattern = parse_pattern_no_errors(src);
+        let Pattern::Mutable(pattern, _, _) = pattern else { panic!("Expected a mutable pattern") };
+        let pattern: &Pattern = &pattern;
+        let Pattern::Identifier(ident) = pattern else { panic!("Expected an identifier pattern") };
+        assert_eq!(ident.to_string(), "foo");
+    }
+
+    #[test]
+    fn parses_tuple_pattern() {
+        let src = "(foo, bar)";
+        let pattern = parse_pattern_no_errors(src);
+        let Pattern::Tuple(mut patterns, _) = pattern else { panic!("Expected a tuple pattern") };
+        assert_eq!(patterns.len(), 2);
+
+        let pattern = patterns.remove(0);
+        let Pattern::Identifier(ident) = pattern else { panic!("Expected an identifier pattern") };
+        assert_eq!(ident.to_string(), "foo");
+
+        let pattern = patterns.remove(0);
+        let Pattern::Identifier(ident) = pattern else { panic!("Expected an identifier pattern") };
+        assert_eq!(ident.to_string(), "bar");
+    }
+
+    #[test]
+    fn parses_unclosed_tuple_pattern() {
+        let src = "(foo,";
+        let mut parser = Parser::for_str(src);
+        let pattern = parser.parse_pattern_or_error();
+        assert_eq!(parser.errors.len(), 1);
+        let Pattern::Tuple(patterns, _) = pattern else { panic!("Expected a tuple pattern") };
+        assert_eq!(patterns.len(), 1);
+    }
+
+    #[test]
+    fn parses_struct_pattern_no_fields() {
+        let src = "foo::Bar {}";
+        let mut parser = Parser::for_str(src);
+        let pattern = parser.parse_pattern_or_error();
+        expect_no_errors(&parser.errors);
+        let Pattern::Struct(path, patterns, _) = pattern else {
+            panic!("Expected a struct pattern")
+        };
+        assert_eq!(path.to_string(), "foo::Bar");
+        assert!(patterns.is_empty());
+    }
+
+    #[test]
+    fn parses_struct_pattern() {
+        let src = "foo::Bar { x: one, y }";
+        let pattern = parse_pattern_no_errors(src);
+        let Pattern::Struct(path, mut patterns, _) = pattern else {
+            panic!("Expected a struct pattern")
+        };
+        assert_eq!(path.to_string(), "foo::Bar");
+        assert_eq!(patterns.len(), 2);
+
+        let (ident, pattern) = patterns.remove(0);
+        assert_eq!(ident.to_string(), "x");
+        assert_eq!(pattern.to_string(), "one");
+
+        let (ident, pattern) = patterns.remove(0);
+        assert_eq!(ident.to_string(), "y");
+        assert_eq!(pattern.to_string(), "y");
+    }
+
+    #[test]
+    fn parses_struct_pattern_recovers_if_assign_instead_of_colon() {
+        let src = "
+        foo::Bar { x = one, y }
+                     ^
+        ";
+        let (src, span) = get_source_with_error_span(src);
+        let mut parser = Parser::for_str(&src);
+        let pattern = parser.parse_pattern_or_error();
+
+        let error = get_single_error(&parser.errors, span);
+        assert_eq!(error.to_string(), "Expected a ':' but found '='");
+
+        let Pattern::Struct(path, mut patterns, _) = pattern else {
+            panic!("Expected a struct pattern")
+        };
+        assert_eq!(path.to_string(), "foo::Bar");
+        assert_eq!(patterns.len(), 2);
+
+        let (ident, pattern) = patterns.remove(0);
+        assert_eq!(ident.to_string(), "x");
+        assert_eq!(pattern.to_string(), "one");
+
+        let (ident, pattern) = patterns.remove(0);
+        assert_eq!(ident.to_string(), "y");
+        assert_eq!(pattern.to_string(), "y");
+    }
+
+    #[test]
+    fn parses_unclosed_struct_pattern() {
+        let src = "foo::Bar { x";
+        let mut parser = Parser::for_str(src);
+        let pattern = parser.parse_pattern_or_error();
+        assert_eq!(parser.errors.len(), 1);
+        let Pattern::Struct(path, _, _) = pattern else { panic!("Expected a struct pattern") };
+        assert_eq!(path.to_string(), "foo::Bar");
+    }
+
+    #[test]
+    fn errors_on_reserved_type() {
+        let src = "
+        Field
+        ^^^^^
+        ";
+        let (src, span) = get_source_with_error_span(src);
+        let mut parser = Parser::for_str(&src);
+        let pattern = parser.parse_pattern();
+        assert!(pattern.is_none());
+
+        let reason = get_single_error_reason(&parser.errors, span);
+        assert!(matches!(
+            reason,
+            ParserErrorReason::ExpectedPatternButFoundType(Token::Keyword(Keyword::Field))
+        ));
+    }
+}
diff --git a/compiler/noirc_frontend/src/parser/parser/primitives.rs b/compiler/noirc_frontend/src/parser/parser/primitives.rs
deleted file mode 100644
index 7fcca89f70c..00000000000
--- a/compiler/noirc_frontend/src/parser/parser/primitives.rs
+++ /dev/null
@@ -1,166 +0,0 @@
-use chumsky::prelude::*;
-
-use crate::ast::{ExpressionKind, GenericTypeArgs, Ident, PathSegment, UnaryOp};
-use crate::macros_api::{StatementKind, UnresolvedType};
-use crate::parser::ParserErrorReason;
-use crate::{
-    parser::{labels::ParsingRuleLabel, ExprParser, NoirParser, ParserError},
-    token::{Keyword, Token, TokenKind},
-};
-
-use super::path::{path, path_no_turbofish};
-use super::types::required_generic_type_args;
-
-/// This parser always parses no input and fails
-pub(super) fn nothing<T>() -> impl NoirParser<T> {
-    one_of([]).map(|_| unreachable!("parser should always error"))
-}
-
-pub(super) fn keyword(keyword: Keyword) -> impl NoirParser<Token> {
-    just(Token::Keyword(keyword))
-}
-
-pub(super) fn token_kind(token_kind: TokenKind) -> impl NoirParser<Token> {
-    filter_map(move |span, found: Token| {
-        if found.kind() == token_kind {
-            Ok(found)
-        } else {
-            Err(ParserError::expected_label(
-                ParsingRuleLabel::TokenKind(token_kind.clone()),
-                found,
-                span,
-            ))
-        }
-    })
-}
-
-pub(super) fn path_segment<'a>(
-    type_parser: impl NoirParser<UnresolvedType> + 'a,
-) -> impl NoirParser<PathSegment> + 'a {
-    ident().then(turbofish(type_parser)).validate(|(ident, generics), span, emit| {
-        if generics.as_ref().map_or(false, |generics| !generics.named_args.is_empty()) {
-            let reason = ParserErrorReason::AssociatedTypesNotAllowedInPaths;
-            emit(ParserError::with_reason(reason, span));
-        }
-
-        let generics = generics.map(|generics| generics.ordered_args);
-        PathSegment { ident, generics, span }
-    })
-}
-
-pub(super) fn path_segment_no_turbofish() -> impl NoirParser<PathSegment> {
-    ident().map(PathSegment::from)
-}
-
-pub(super) fn ident() -> impl NoirParser<Ident> {
-    token_kind(TokenKind::Ident).map_with_span(Ident::from_token)
-}
-
-// Right-shift (>>) is issued as two separate > tokens by the lexer as this makes it easier
-// to parse nested generic types. For normal expressions however, it means we have to manually
-// parse two greater-than tokens as a single right-shift here.
-pub(super) fn right_shift_operator() -> impl NoirParser<Token> {
-    just(Token::Greater).then(just(Token::Greater)).to(Token::ShiftRight)
-}
-
-pub(super) fn not<P>(term_parser: P) -> impl NoirParser<ExpressionKind>
-where
-    P: ExprParser,
-{
-    just(Token::Bang).ignore_then(term_parser).map(|rhs| ExpressionKind::prefix(UnaryOp::Not, rhs))
-}
-
-pub(super) fn negation<P>(term_parser: P) -> impl NoirParser<ExpressionKind>
-where
-    P: ExprParser,
-{
-    just(Token::Minus)
-        .ignore_then(term_parser)
-        .map(|rhs| ExpressionKind::prefix(UnaryOp::Minus, rhs))
-}
-
-pub(super) fn mutable_reference<P>(term_parser: P) -> impl NoirParser<ExpressionKind>
-where
-    P: ExprParser,
-{
-    just(Token::Ampersand)
-        .ignore_then(keyword(Keyword::Mut))
-        .ignore_then(term_parser)
-        .map(|rhs| ExpressionKind::prefix(UnaryOp::MutableReference, rhs))
-}
-
-pub(super) fn dereference<P>(term_parser: P) -> impl NoirParser<ExpressionKind>
-where
-    P: ExprParser,
-{
-    just(Token::Star)
-        .ignore_then(term_parser)
-        .map(|rhs| ExpressionKind::prefix(UnaryOp::Dereference { implicitly_added: false }, rhs))
-}
-
-pub(super) fn turbofish<'a>(
-    type_parser: impl NoirParser<UnresolvedType> + 'a,
-) -> impl NoirParser<Option<GenericTypeArgs>> + 'a {
-    just(Token::DoubleColon).ignore_then(required_generic_type_args(type_parser)).or_not()
-}
-
-pub(super) fn variable() -> impl NoirParser<ExpressionKind> {
-    path(super::parse_type()).map(ExpressionKind::Variable)
-}
-
-pub(super) fn variable_no_turbofish() -> impl NoirParser<ExpressionKind> {
-    path_no_turbofish().map(ExpressionKind::Variable)
-}
-
-pub(super) fn macro_quote_marker() -> impl NoirParser<ExpressionKind> {
-    token_kind(TokenKind::UnquoteMarker).map(|token| match token {
-        Token::UnquoteMarker(expr_id) => ExpressionKind::Resolved(expr_id),
-        other => unreachable!("Non-unquote-marker parsed as an unquote marker: {other:?}"),
-    })
-}
-
-pub(super) fn interned_expr() -> impl NoirParser<ExpressionKind> {
-    token_kind(TokenKind::InternedExpr).map(|token| match token {
-        Token::InternedExpr(id) => ExpressionKind::Interned(id),
-        _ => unreachable!("token_kind(InternedExpr) guarantees we parse an interned expr"),
-    })
-}
-
-pub(super) fn interned_statement() -> impl NoirParser<StatementKind> {
-    token_kind(TokenKind::InternedStatement).map(|token| match token {
-        Token::InternedStatement(id) => StatementKind::Interned(id),
-        _ => {
-            unreachable!("token_kind(InternedStatement) guarantees we parse an interned statement")
-        }
-    })
-}
-
-// This rule is so that we can re-parse StatementKind::Expression and Semi in
-// an expression position (ignoring the semicolon) if needed.
-pub(super) fn interned_statement_expr() -> impl NoirParser<ExpressionKind> {
-    token_kind(TokenKind::InternedStatement).map(|token| match token {
-        Token::InternedStatement(id) => ExpressionKind::InternedStatement(id),
-        _ => {
-            unreachable!("token_kind(InternedStatement) guarantees we parse an interned statement")
-        }
-    })
-}
-
-#[cfg(test)]
-mod test {
-    use crate::parser::parser::{
-        expression, expression_no_constructors, fresh_statement, term, test_helpers::*,
-    };
-
-    #[test]
-    fn parse_unary() {
-        parse_all(
-            term(expression(), expression_no_constructors(expression()), fresh_statement(), true),
-            vec!["!hello", "-hello", "--hello", "-!hello", "!-hello"],
-        );
-        parse_all_failing(
-            term(expression(), expression_no_constructors(expression()), fresh_statement(), true),
-            vec!["+hello", "/hello"],
-        );
-    }
-}
diff --git a/compiler/noirc_frontend/src/parser/parser/statement.rs b/compiler/noirc_frontend/src/parser/parser/statement.rs
new file mode 100644
index 00000000000..ff6117c9348
--- /dev/null
+++ b/compiler/noirc_frontend/src/parser/parser/statement.rs
@@ -0,0 +1,725 @@
+use noirc_errors::{Span, Spanned};
+
+use crate::{
+    ast::{
+        AssignStatement, BinaryOp, BinaryOpKind, ConstrainKind, ConstrainStatement, Expression,
+        ExpressionKind, ForBounds, ForLoopStatement, ForRange, Ident, InfixExpression, LValue,
+        LetStatement, Statement, StatementKind,
+    },
+    parser::{labels::ParsingRuleLabel, ParserErrorReason},
+    token::{Attribute, Keyword, Token, TokenKind},
+};
+
+use super::Parser;
+
+impl<'a> Parser<'a> {
+    pub(crate) fn parse_statement_or_error(&mut self) -> Statement {
+        if let Some((statement, (_token, _span))) = self.parse_statement() {
+            statement
+        } else {
+            self.expected_label(ParsingRuleLabel::Statement);
+            Statement { kind: StatementKind::Error, span: self.span_at_previous_token_end() }
+        }
+    }
+
+    /// Statement = Attributes StatementKind ';'?
+    pub(crate) fn parse_statement(&mut self) -> Option<(Statement, (Option<Token>, Span))> {
+        loop {
+            let attributes = self.parse_attributes();
+            let start_span = self.current_token_span;
+            let kind = self.parse_statement_kind(attributes);
+
+            let (semicolon_token, semicolon_span) = if self.at(Token::Semicolon) {
+                let token = self.token.clone();
+                self.bump();
+                let span = token.to_span();
+
+                (Some(token.into_token()), span)
+            } else {
+                (None, self.previous_token_span)
+            };
+
+            let span = self.span_since(start_span);
+
+            if let Some(kind) = kind {
+                let statement = Statement { kind, span };
+                return Some((statement, (semicolon_token, semicolon_span)));
+            }
+
+            self.expected_label(ParsingRuleLabel::Statement);
+
+            if semicolon_token.is_some() || self.at(Token::RightBrace) || self.at_eof() {
+                return None;
+            } else {
+                self.bump();
+            }
+        }
+    }
+
+    /// StatementKind
+    ///     = BreakStatement
+    ///     | ContinueStatement
+    ///     | ReturnStatement
+    ///     | LetStatement
+    ///     | ConstrainStatement
+    ///     | ComptimeStatement
+    ///     | ForStatement
+    ///     | IfStatement
+    ///     | BlockStatement
+    ///     | AssignStatement
+    ///     | ExpressionStatement
+    ///
+    /// BreakStatement = 'break'
+    ///
+    /// ContinueStatement = 'continue'
+    ///
+    /// ReturnStatement = 'return' Expression?
+    ///
+    /// IfStatement = IfExpression
+    ///
+    /// BlockStatement = Block
+    ///
+    /// AssignStatement = Expression '=' Expression
+    ///
+    /// ExpressionStatement = Expression
+    fn parse_statement_kind(
+        &mut self,
+        attributes: Vec<(Attribute, Span)>,
+    ) -> Option<StatementKind> {
+        let start_span = self.current_token_span;
+
+        if let Some(token) = self.eat_kind(TokenKind::InternedStatement) {
+            match token.into_token() {
+                Token::InternedStatement(statement) => {
+                    return Some(StatementKind::Interned(statement))
+                }
+                _ => unreachable!(),
+            }
+        }
+
+        if self.eat_keyword(Keyword::Break) {
+            return Some(StatementKind::Break);
+        }
+
+        if self.eat_keyword(Keyword::Continue) {
+            return Some(StatementKind::Continue);
+        }
+
+        if self.eat_keyword(Keyword::Return) {
+            self.parse_expression();
+            self.push_error(ParserErrorReason::EarlyReturn, self.span_since(start_span));
+            return Some(StatementKind::Error);
+        }
+
+        if self.at_keyword(Keyword::Let) {
+            let let_statement = self.parse_let_statement(attributes)?;
+            return Some(StatementKind::Let(let_statement));
+        }
+
+        if let Some(constrain) = self.parse_constrain_statement() {
+            return Some(StatementKind::Constrain(constrain));
+        }
+
+        if self.at_keyword(Keyword::Comptime) {
+            return self.parse_comptime_statement(attributes);
+        }
+
+        if let Some(for_loop) = self.parse_for() {
+            return Some(StatementKind::For(for_loop));
+        }
+
+        if let Some(kind) = self.parse_if_expr() {
+            return Some(StatementKind::Expression(Expression {
+                kind,
+                span: self.span_since(start_span),
+            }));
+        }
+
+        if let Some(block) = self.parse_block() {
+            return Some(StatementKind::Expression(Expression {
+                kind: ExpressionKind::Block(block),
+                span: self.span_since(start_span),
+            }));
+        }
+
+        if let Some(token) = self.eat_kind(TokenKind::InternedLValue) {
+            match token.into_token() {
+                Token::InternedLValue(lvalue) => {
+                    let lvalue = LValue::Interned(lvalue, self.span_since(start_span));
+                    self.eat_or_error(Token::Assign);
+                    let expression = self.parse_expression_or_error();
+                    return Some(StatementKind::Assign(AssignStatement { lvalue, expression }));
+                }
+                _ => unreachable!(),
+            }
+        }
+
+        let expression = self.parse_expression()?;
+
+        if self.eat_assign() {
+            if let Some(lvalue) = LValue::from_expression(expression.clone()) {
+                let expression = self.parse_expression_or_error();
+                return Some(StatementKind::Assign(AssignStatement { lvalue, expression }));
+            } else {
+                self.push_error(
+                    ParserErrorReason::InvalidLeftHandSideOfAssignment,
+                    expression.span,
+                );
+            }
+        }
+
+        if let Some(operator) = self.next_is_op_assign() {
+            if let Some(lvalue) = LValue::from_expression(expression.clone()) {
+                // Desugar `a <op>= b` to `a = a <op> b`. This relies on the evaluation of `a` having no side effects,
+                // which is currently enforced by the restricted syntax of LValues.
+                let infix = InfixExpression {
+                    lhs: expression,
+                    operator,
+                    rhs: self.parse_expression_or_error(),
+                };
+                let expression = Expression::new(
+                    ExpressionKind::Infix(Box::new(infix)),
+                    self.span_since(start_span),
+                );
+                return Some(StatementKind::Assign(AssignStatement { lvalue, expression }));
+            } else {
+                self.push_error(
+                    ParserErrorReason::InvalidLeftHandSideOfAssignment,
+                    expression.span,
+                );
+            }
+        }
+
+        Some(StatementKind::Expression(expression))
+    }
+
+    fn next_is_op_assign(&mut self) -> Option<BinaryOp> {
+        let start_span = self.current_token_span;
+        let operator = if self.next_is(Token::Assign) {
+            match self.token.token() {
+                Token::Plus => Some(BinaryOpKind::Add),
+                Token::Minus => Some(BinaryOpKind::Subtract),
+                Token::Star => Some(BinaryOpKind::Multiply),
+                Token::Slash => Some(BinaryOpKind::Divide),
+                Token::Percent => Some(BinaryOpKind::Modulo),
+                Token::Ampersand => Some(BinaryOpKind::And),
+                Token::Caret => Some(BinaryOpKind::Xor),
+                Token::ShiftLeft => Some(BinaryOpKind::ShiftLeft),
+                Token::Pipe => Some(BinaryOpKind::Or),
+                _ => None,
+            }
+        } else if self.at(Token::Greater) && self.next_is(Token::GreaterEqual) {
+            // >>=
+            Some(BinaryOpKind::ShiftRight)
+        } else {
+            None
+        };
+
+        if let Some(operator) = operator {
+            self.bump();
+            self.bump();
+            Some(Spanned::from(self.span_since(start_span), operator))
+        } else {
+            None
+        }
+    }
+
+    /// ForStatement = 'for' identifier 'in' ForRange Block
+    fn parse_for(&mut self) -> Option<ForLoopStatement> {
+        let start_span = self.current_token_span;
+
+        if !self.eat_keyword(Keyword::For) {
+            return None;
+        }
+
+        let Some(identifier) = self.eat_ident() else {
+            self.expected_identifier();
+            let identifier = Ident::default();
+            return Some(self.empty_for_loop(identifier, start_span));
+        };
+
+        if !self.eat_keyword(Keyword::In) {
+            self.expected_token(Token::Keyword(Keyword::In));
+            return Some(self.empty_for_loop(identifier, start_span));
+        }
+
+        let range = self.parse_for_range();
+
+        let block_start_span = self.current_token_span;
+        let block = if let Some(block) = self.parse_block() {
+            Expression {
+                kind: ExpressionKind::Block(block),
+                span: self.span_since(block_start_span),
+            }
+        } else {
+            self.expected_token(Token::LeftBrace);
+            Expression { kind: ExpressionKind::Error, span: self.span_since(block_start_span) }
+        };
+
+        Some(ForLoopStatement { identifier, range, block, span: self.span_since(start_span) })
+    }
+
+    /// ForRange
+    ///     = ExpressionExceptConstructor
+    ///     | ExpressionExceptConstructor '..' ExpressionExceptConstructor
+    fn parse_for_range(&mut self) -> ForRange {
+        let expr = self.parse_expression_except_constructor_or_error();
+
+        if self.eat(Token::DoubleDot) {
+            let end = self.parse_expression_except_constructor_or_error();
+            ForRange::Range(ForBounds { start: expr, end, inclusive: false })
+        } else if self.eat(Token::DoubleDotEqual) {
+            let end = self.parse_expression_except_constructor_or_error();
+            ForRange::Range(ForBounds { start: expr, end, inclusive: true })
+        } else {
+            ForRange::Array(expr)
+        }
+    }
+
+    fn empty_for_loop(&mut self, identifier: Ident, start_span: Span) -> ForLoopStatement {
+        ForLoopStatement {
+            identifier,
+            range: ForRange::Array(Expression {
+                kind: ExpressionKind::Error,
+                span: Span::default(),
+            }),
+            block: Expression { kind: ExpressionKind::Error, span: Span::default() },
+            span: self.span_since(start_span),
+        }
+    }
+
+    /// ComptimeStatement
+    ///     = ComptimeBlock
+    ///     | ComptimeLet
+    ///     | ComptimeFor
+    ///
+    /// ComptimeBlock = 'comptime' Block
+    ///
+    /// ComptimeLet = 'comptime' LetStatement
+    ///
+    /// ComptimeFor = 'comptime' ForStatement
+    fn parse_comptime_statement(
+        &mut self,
+        attributes: Vec<(Attribute, Span)>,
+    ) -> Option<StatementKind> {
+        let start_span = self.current_token_span;
+
+        if !self.eat_keyword(Keyword::Comptime) {
+            return None;
+        }
+
+        if let Some(kind) = self.parse_comptime_statement_kind(attributes) {
+            return Some(StatementKind::Comptime(Box::new(Statement {
+                kind,
+                span: self.span_since(start_span),
+            })));
+        }
+
+        self.expected_one_of_tokens(&[
+            Token::LeftBrace,
+            Token::Keyword(Keyword::Let),
+            Token::Keyword(Keyword::For),
+        ]);
+
+        None
+    }
+
+    fn parse_comptime_statement_kind(
+        &mut self,
+        attributes: Vec<(Attribute, Span)>,
+    ) -> Option<StatementKind> {
+        let start_span = self.current_token_span;
+
+        if let Some(block) = self.parse_block() {
+            return Some(StatementKind::Expression(Expression {
+                kind: ExpressionKind::Block(block),
+                span: self.span_since(start_span),
+            }));
+        }
+
+        if let Some(let_statement) = self.parse_let_statement(attributes) {
+            return Some(StatementKind::Let(let_statement));
+        }
+
+        if let Some(for_loop) = self.parse_for() {
+            return Some(StatementKind::For(for_loop));
+        }
+
+        None
+    }
+
+    /// LetStatement = 'let' pattern OptionalTypeAnnotation '=' Expression
+    fn parse_let_statement(&mut self, attributes: Vec<(Attribute, Span)>) -> Option<LetStatement> {
+        if !self.eat_keyword(Keyword::Let) {
+            return None;
+        }
+
+        let attributes = self.validate_secondary_attributes(attributes);
+        let pattern = self.parse_pattern_or_error();
+        let r#type = self.parse_optional_type_annotation();
+        let expression = if self.eat_assign() {
+            self.parse_expression_or_error()
+        } else {
+            self.expected_token(Token::Assign);
+            Expression { kind: ExpressionKind::Error, span: self.current_token_span }
+        };
+
+        Some(LetStatement { pattern, r#type, expression, attributes, comptime: false })
+    }
+
+    /// ConstrainStatement
+    ///     = 'constrain' Expression
+    ///     | 'assert' Arguments
+    ///     | 'assert_eq' Arguments
+    fn parse_constrain_statement(&mut self) -> Option<ConstrainStatement> {
+        let start_span = self.current_token_span;
+        let Some(kind) = self.parse_constrain_kind() else {
+            return None;
+        };
+
+        Some(match kind {
+            ConstrainKind::Assert | ConstrainKind::AssertEq => {
+                let arguments = self.parse_arguments();
+                if arguments.is_none() {
+                    self.expected_token(Token::LeftParen);
+                }
+                let arguments = arguments.unwrap_or_default();
+
+                ConstrainStatement { kind, arguments, span: self.span_since(start_span) }
+            }
+            ConstrainKind::Constrain => {
+                self.push_error(ParserErrorReason::ConstrainDeprecated, self.previous_token_span);
+
+                let expression = self.parse_expression_or_error();
+                ConstrainStatement {
+                    kind,
+                    arguments: vec![expression],
+                    span: self.span_since(start_span),
+                }
+            }
+        })
+    }
+
+    fn parse_constrain_kind(&mut self) -> Option<ConstrainKind> {
+        if self.eat_keyword(Keyword::Assert) {
+            Some(ConstrainKind::Assert)
+        } else if self.eat_keyword(Keyword::AssertEq) {
+            Some(ConstrainKind::AssertEq)
+        } else if self.eat_keyword(Keyword::Constrain) {
+            Some(ConstrainKind::Constrain)
+        } else {
+            None
+        }
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use crate::{
+        ast::{
+            ConstrainKind, ExpressionKind, ForRange, LValue, Statement, StatementKind,
+            UnresolvedTypeData,
+        },
+        parser::{
+            parser::tests::{
+                expect_no_errors, get_single_error, get_single_error_reason,
+                get_source_with_error_span,
+            },
+            Parser, ParserErrorReason,
+        },
+    };
+
+    fn parse_statement_no_errors(src: &str) -> Statement {
+        let mut parser = Parser::for_str(src);
+        let statement = parser.parse_statement_or_error();
+        expect_no_errors(&parser.errors);
+        statement
+    }
+
+    #[test]
+    fn parses_break() {
+        let src = "break";
+        let statement = parse_statement_no_errors(src);
+        assert!(matches!(statement.kind, StatementKind::Break));
+    }
+
+    #[test]
+    fn parses_continue() {
+        let src = "continue";
+        let statement = parse_statement_no_errors(src);
+        assert!(matches!(statement.kind, StatementKind::Continue));
+    }
+
+    #[test]
+    fn parses_let_statement_no_type() {
+        let src = "let x = 1;";
+        let statement = parse_statement_no_errors(src);
+        let StatementKind::Let(let_statement) = statement.kind else {
+            panic!("Expected let statement");
+        };
+        assert_eq!(let_statement.pattern.to_string(), "x");
+        assert!(matches!(let_statement.r#type.typ, UnresolvedTypeData::Unspecified));
+        assert_eq!(let_statement.expression.to_string(), "1");
+        assert!(!let_statement.comptime);
+    }
+
+    #[test]
+    fn parses_let_statement_with_type() {
+        let src = "let x: Field = 1;";
+        let statement = parse_statement_no_errors(src);
+        let StatementKind::Let(let_statement) = statement.kind else {
+            panic!("Expected let statement");
+        };
+        assert_eq!(let_statement.pattern.to_string(), "x");
+        assert_eq!(let_statement.r#type.to_string(), "Field");
+        assert_eq!(let_statement.expression.to_string(), "1");
+        assert!(!let_statement.comptime);
+    }
+
+    #[test]
+    fn parses_assert() {
+        let src = "assert(true, \"good\")";
+        let statement = parse_statement_no_errors(src);
+        let StatementKind::Constrain(constrain) = statement.kind else {
+            panic!("Expected constrain statement");
+        };
+        assert_eq!(constrain.kind, ConstrainKind::Assert);
+        assert_eq!(constrain.arguments.len(), 2);
+    }
+
+    #[test]
+    fn parses_assert_eq() {
+        let src = "assert_eq(1, 2, \"bad\")";
+        let statement = parse_statement_no_errors(src);
+        let StatementKind::Constrain(constrain) = statement.kind else {
+            panic!("Expected constrain statement");
+        };
+        assert_eq!(constrain.kind, ConstrainKind::AssertEq);
+        assert_eq!(constrain.arguments.len(), 3);
+    }
+
+    #[test]
+    fn parses_constrain() {
+        let src = "
+        constrain 1
+        ^^^^^^^^^
+        ";
+        let (src, span) = get_source_with_error_span(src);
+        let mut parser = Parser::for_str(&src);
+        let statement = parser.parse_statement_or_error();
+        let StatementKind::Constrain(constrain) = statement.kind else {
+            panic!("Expected constrain statement");
+        };
+        assert_eq!(constrain.kind, ConstrainKind::Constrain);
+        assert_eq!(constrain.arguments.len(), 1);
+
+        let reason = get_single_error_reason(&parser.errors, span);
+        assert!(matches!(reason, ParserErrorReason::ConstrainDeprecated));
+    }
+
+    #[test]
+    fn parses_comptime_block() {
+        let src = "comptime { 1 }";
+        let statement = parse_statement_no_errors(src);
+        let StatementKind::Comptime(statement) = statement.kind else {
+            panic!("Expected comptime statement");
+        };
+        let StatementKind::Expression(expr) = statement.kind else {
+            panic!("Expected expression statement");
+        };
+        let ExpressionKind::Block(block) = expr.kind else {
+            panic!("Expected block expression");
+        };
+        assert_eq!(block.statements.len(), 1);
+    }
+
+    #[test]
+    fn parses_comptime_let() {
+        let src = "comptime let x = 1;";
+        let statement = parse_statement_no_errors(src);
+        let StatementKind::Comptime(statement) = statement.kind else {
+            panic!("Expected comptime statement");
+        };
+        let StatementKind::Let(..) = statement.kind else {
+            panic!("Expected let statement");
+        };
+    }
+
+    #[test]
+    fn parses_for_array() {
+        let src = "for i in x { }";
+        let statement = parse_statement_no_errors(src);
+        let StatementKind::For(for_loop) = statement.kind else {
+            panic!("Expected for loop");
+        };
+        assert_eq!(for_loop.identifier.to_string(), "i");
+        let ForRange::Array(expr) = for_loop.range else {
+            panic!("Expected array");
+        };
+        assert_eq!(expr.to_string(), "x");
+    }
+
+    #[test]
+    fn parses_for_range() {
+        let src = "for i in 0..10 { }";
+        let statement = parse_statement_no_errors(src);
+        let StatementKind::For(for_loop) = statement.kind else {
+            panic!("Expected for loop");
+        };
+        assert_eq!(for_loop.identifier.to_string(), "i");
+        let ForRange::Range(bounds) = for_loop.range else {
+            panic!("Expected range");
+        };
+        assert_eq!(bounds.start.to_string(), "0");
+        assert_eq!(bounds.end.to_string(), "10");
+        assert!(!bounds.inclusive);
+    }
+
+    #[test]
+    fn parses_for_range_inclusive() {
+        let src = "for i in 0..=10 { }";
+        let statement = parse_statement_no_errors(src);
+        let StatementKind::For(for_loop) = statement.kind else {
+            panic!("Expected for loop");
+        };
+        assert_eq!(for_loop.identifier.to_string(), "i");
+        let ForRange::Range(bounds) = for_loop.range else {
+            panic!("Expected range");
+        };
+        assert_eq!(bounds.start.to_string(), "0");
+        assert_eq!(bounds.end.to_string(), "10");
+        assert!(bounds.inclusive);
+    }
+
+    #[test]
+    fn parses_comptime_for() {
+        let src = "comptime for i in x { }";
+        let statement = parse_statement_no_errors(src);
+        let StatementKind::Comptime(statement) = statement.kind else {
+            panic!("Expected comptime");
+        };
+        let StatementKind::For(for_loop) = statement.kind else {
+            panic!("Expected for loop");
+        };
+        assert_eq!(for_loop.identifier.to_string(), "i");
+        assert!(matches!(for_loop.range, ForRange::Array(..)));
+    }
+
+    #[test]
+    fn parses_assignment() {
+        let src = "x = 1";
+        let statement = parse_statement_no_errors(src);
+        let StatementKind::Assign(assign) = statement.kind else {
+            panic!("Expected assign");
+        };
+        let LValue::Ident(ident) = assign.lvalue else {
+            panic!("Expected ident");
+        };
+        assert_eq!(ident.to_string(), "x");
+        assert_eq!(assign.expression.to_string(), "1");
+    }
+
+    #[test]
+    fn parses_assignment_with_parentheses() {
+        let src = "(x)[0] = 1";
+        let statement = parse_statement_no_errors(src);
+        let StatementKind::Assign(..) = statement.kind else {
+            panic!("Expected assign");
+        };
+    }
+
+    #[test]
+    fn parses_op_assignment() {
+        let src = "x += 1";
+        let statement = parse_statement_no_errors(src);
+        let StatementKind::Assign(assign) = statement.kind else {
+            panic!("Expected assign");
+        };
+        assert_eq!(assign.to_string(), "x = (x + 1)");
+    }
+
+    #[test]
+    fn parses_op_assignment_with_shift_right() {
+        let src = "x >>= 1";
+        let statement = parse_statement_no_errors(src);
+        let StatementKind::Assign(assign) = statement.kind else {
+            panic!("Expected assign");
+        };
+        assert_eq!(assign.to_string(), "x = (x >> 1)");
+    }
+
+    #[test]
+    fn parses_if_statement_followed_by_tuple() {
+        // This shouldn't be parsed as a call
+        let src = "{ if 1 { 2 } (3, 4) }";
+        let statement = parse_statement_no_errors(src);
+        let StatementKind::Expression(expr) = statement.kind else {
+            panic!("Expected expr");
+        };
+        let ExpressionKind::Block(block) = expr.kind else {
+            panic!("Expected block");
+        };
+        assert_eq!(block.statements.len(), 2);
+    }
+
+    #[test]
+    fn parses_block_followed_by_tuple() {
+        // This shouldn't be parsed as a call
+        let src = "{ { 2 } (3, 4) }";
+        let statement = parse_statement_no_errors(src);
+        let StatementKind::Expression(expr) = statement.kind else {
+            panic!("Expected expr");
+        };
+        let ExpressionKind::Block(block) = expr.kind else {
+            panic!("Expected block");
+        };
+        assert_eq!(block.statements.len(), 2);
+    }
+
+    #[test]
+    fn errors_on_return_statement() {
+        // This shouldn't be parsed as a call
+        let src = "
+        return 1
+        ^^^^^^^^
+        ";
+        let (src, span) = get_source_with_error_span(src);
+        let mut parser = Parser::for_str(&src);
+        let statement = parser.parse_statement_or_error();
+        assert!(matches!(statement.kind, StatementKind::Error));
+        let reason = get_single_error_reason(&parser.errors, span);
+        assert!(matches!(reason, ParserErrorReason::EarlyReturn));
+    }
+
+    #[test]
+    fn recovers_on_unknown_statement_followed_by_actual_statement() {
+        let src = "
+        ] let x = 1;
+        ^
+        ";
+        let (src, span) = get_source_with_error_span(src);
+        let mut parser = Parser::for_str(&src);
+        let statement = parser.parse_statement_or_error();
+        assert!(matches!(statement.kind, StatementKind::Let(..)));
+        let error = get_single_error(&parser.errors, span);
+        assert_eq!(error.to_string(), "Expected a statement but found ']'");
+    }
+
+    #[test]
+    fn recovers_on_unknown_statement_followed_by_semicolon() {
+        let src = " ] ;";
+        let mut parser = Parser::for_str(src);
+        let statement = parser.parse_statement();
+        assert!(statement.is_none());
+        assert_eq!(parser.errors.len(), 2);
+    }
+
+    #[test]
+    fn recovers_on_unknown_statement_followed_by_right_brace() {
+        let src = " ] }";
+        let mut parser = Parser::for_str(src);
+        let statement = parser.parse_statement();
+        assert!(statement.is_none());
+        assert_eq!(parser.errors.len(), 2);
+    }
+}
diff --git a/compiler/noirc_frontend/src/parser/parser/statement_or_expression_or_lvalue.rs b/compiler/noirc_frontend/src/parser/parser/statement_or_expression_or_lvalue.rs
new file mode 100644
index 00000000000..fdc187f3fb2
--- /dev/null
+++ b/compiler/noirc_frontend/src/parser/parser/statement_or_expression_or_lvalue.rs
@@ -0,0 +1,55 @@
+use crate::{
+    ast::{AssignStatement, Expression, LValue, Statement, StatementKind},
+    token::{Token, TokenKind},
+};
+
+use super::Parser;
+
+#[derive(Debug)]
+pub enum StatementOrExpressionOrLValue {
+    Statement(Statement),
+    Expression(Expression),
+    LValue(LValue),
+}
+
+impl<'a> Parser<'a> {
+    /// Parses either a statement, an expression or an LValue. Returns `StatementKind::Error`
+    /// if none can be parsed, recording an error if so.
+    ///
+    /// This method is only used in `Quoted::as_expr`.
+    pub(crate) fn parse_statement_or_expression_or_lvalue(
+        &mut self,
+    ) -> StatementOrExpressionOrLValue {
+        let start_span = self.current_token_span;
+
+        // First check if it's an interned LValue
+        if let Some(token) = self.eat_kind(TokenKind::InternedLValue) {
+            match token.into_token() {
+                Token::InternedLValue(lvalue) => {
+                    let lvalue = LValue::Interned(lvalue, self.span_since(start_span));
+
+                    // If it is, it could be something like `lvalue = expr`: check that.
+                    if self.eat(Token::Assign) {
+                        let expression = self.parse_expression_or_error();
+                        let kind = StatementKind::Assign(AssignStatement { lvalue, expression });
+                        return StatementOrExpressionOrLValue::Statement(Statement {
+                            kind,
+                            span: self.span_since(start_span),
+                        });
+                    } else {
+                        return StatementOrExpressionOrLValue::LValue(lvalue);
+                    }
+                }
+                _ => unreachable!(),
+            }
+        }
+
+        // Otherwise, check if it's a statement (which in turn checks if it's an expression)
+        let statement = self.parse_statement_or_error();
+        if let StatementKind::Expression(expr) = statement.kind {
+            StatementOrExpressionOrLValue::Expression(expr)
+        } else {
+            StatementOrExpressionOrLValue::Statement(statement)
+        }
+    }
+}
diff --git a/compiler/noirc_frontend/src/parser/parser/structs.rs b/compiler/noirc_frontend/src/parser/parser/structs.rs
index 729f276e9b8..da8ac64e021 100644
--- a/compiler/noirc_frontend/src/parser/parser/structs.rs
+++ b/compiler/noirc_frontend/src/parser/parser/structs.rs
@@ -1,84 +1,277 @@
-use chumsky::prelude::*;
+use noirc_errors::Span;
 
-use crate::ast::{Documented, NoirStruct, StructField};
-use crate::parser::parser::visibility::item_visibility;
 use crate::{
-    parser::{
-        parser::{
-            attributes::{attributes, validate_secondary_attributes},
-            function, parse_type,
-            primitives::{ident, keyword},
-        },
-        NoirParser, TopLevelStatementKind,
-    },
-    token::{Keyword, Token},
+    ast::{Documented, Ident, ItemVisibility, NoirStruct, StructField, UnresolvedGenerics},
+    parser::ParserErrorReason,
+    token::{Attribute, SecondaryAttribute, Token},
 };
 
-use super::doc_comments::outer_doc_comments;
-
-pub(super) fn struct_definition() -> impl NoirParser<TopLevelStatementKind> {
-    use self::Keyword::Struct;
-    use Token::*;
-
-    let fields = struct_fields()
-        .delimited_by(just(LeftBrace), just(RightBrace))
-        .recover_with(nested_delimiters(
-            LeftBrace,
-            RightBrace,
-            [(LeftParen, RightParen), (LeftBracket, RightBracket)],
-            |_| vec![],
-        ))
-        .or(just(Semicolon).to(Vec::new()));
-
-    attributes()
-        .then(item_visibility())
-        .then_ignore(keyword(Struct))
-        .then(ident())
-        .then(function::generics())
-        .then(fields)
-        .validate(|((((attributes, visibility), name), generics), fields), span, emit| {
-            let attributes = validate_secondary_attributes(attributes, span, emit);
-            TopLevelStatementKind::Struct(NoirStruct {
-                name,
+use super::{parse_many::separated_by_comma_until_right_brace, Parser};
+
+impl<'a> Parser<'a> {
+    /// Struct = 'struct' identifier Generics '{' StructField* '}'
+    ///
+    /// StructField = OuterDocComments identifier ':' Type
+    pub(crate) fn parse_struct(
+        &mut self,
+        attributes: Vec<(Attribute, Span)>,
+        visibility: ItemVisibility,
+        start_span: Span,
+    ) -> NoirStruct {
+        let attributes = self.validate_secondary_attributes(attributes);
+
+        let Some(name) = self.eat_ident() else {
+            self.expected_identifier();
+            return self.empty_struct(
+                Ident::default(),
                 attributes,
                 visibility,
-                generics,
-                fields,
-                span,
-            })
-        })
-}
+                Vec::new(),
+                start_span,
+            );
+        };
+
+        let generics = self.parse_generics();
+
+        if self.eat_semicolons() {
+            return self.empty_struct(name, attributes, visibility, generics, start_span);
+        }
+
+        if !self.eat_left_brace() {
+            self.expected_token(Token::LeftBrace);
+            return self.empty_struct(name, attributes, visibility, generics, start_span);
+        }
+
+        let fields = self.parse_many(
+            "struct fields",
+            separated_by_comma_until_right_brace(),
+            Self::parse_struct_field,
+        );
+
+        NoirStruct {
+            name,
+            attributes,
+            visibility,
+            generics,
+            fields,
+            span: self.span_since(start_span),
+        }
+    }
+
+    fn parse_struct_field(&mut self) -> Option<Documented<StructField>> {
+        let mut doc_comments;
+        let name;
+        let mut visibility;
+
+        // Loop until we find an identifier, skipping anything that's not one
+        loop {
+            let doc_comments_start_span = self.current_token_span;
+            doc_comments = self.parse_outer_doc_comments();
+
+            visibility = self.parse_item_visibility();
 
-fn struct_fields() -> impl NoirParser<Vec<Documented<StructField>>> {
-    let field = ident().then_ignore(just(Token::Colon)).then(parse_type());
-    let field = outer_doc_comments().then(field).map(|(doc_comments, (name, typ))| {
-        Documented::new(StructField { name, typ }, doc_comments)
-    });
-    field.separated_by(just(Token::Comma)).allow_trailing()
+            if let Some(ident) = self.eat_ident() {
+                name = ident;
+                break;
+            }
+
+            if visibility != ItemVisibility::Private {
+                self.expected_identifier();
+            }
+
+            if !doc_comments.is_empty() {
+                self.push_error(
+                    ParserErrorReason::DocCommentDoesNotDocumentAnything,
+                    self.span_since(doc_comments_start_span),
+                );
+            }
+
+            // Though we do have to stop at EOF
+            if self.at_eof() {
+                self.expected_token(Token::RightBrace);
+                return None;
+            }
+
+            // Or if we find a right brace
+            if self.at(Token::RightBrace) {
+                return None;
+            }
+
+            self.expected_identifier();
+            self.bump();
+        }
+
+        self.eat_or_error(Token::Colon);
+
+        let typ = self.parse_type_or_error();
+        Some(Documented::new(StructField { visibility, name, typ }, doc_comments))
+    }
+
+    fn empty_struct(
+        &self,
+        name: Ident,
+        attributes: Vec<SecondaryAttribute>,
+        visibility: ItemVisibility,
+        generics: UnresolvedGenerics,
+        start_span: Span,
+    ) -> NoirStruct {
+        NoirStruct {
+            name,
+            attributes,
+            visibility,
+            generics,
+            fields: Vec::new(),
+            span: self.span_since(start_span),
+        }
+    }
 }
 
 #[cfg(test)]
-mod test {
-    use super::*;
-    use crate::parser::parser::test_helpers::*;
+mod tests {
+    use crate::{
+        ast::{IntegerBitSize, NoirStruct, Signedness, UnresolvedGeneric, UnresolvedTypeData},
+        parser::{
+            parser::{
+                parse_program,
+                tests::{
+                    expect_no_errors, get_single_error, get_single_error_reason,
+                    get_source_with_error_span,
+                },
+            },
+            ItemKind, ParserErrorReason,
+        },
+    };
+
+    fn parse_struct_no_errors(src: &str) -> NoirStruct {
+        let (mut module, errors) = parse_program(src);
+        expect_no_errors(&errors);
+        assert_eq!(module.items.len(), 1);
+        let item = module.items.remove(0);
+        let ItemKind::Struct(noir_struct) = item.kind else {
+            panic!("Expected struct");
+        };
+        noir_struct
+    }
 
     #[test]
-    fn parse_structs() {
-        let cases = vec![
-            "struct Foo;",
-            "struct Foo { }",
-            "struct Bar { ident: Field, }",
-            "struct Baz { ident: Field, other: Field }",
-            "#[attribute] struct Baz { ident: Field, other: Field }",
-        ];
-        parse_all(struct_definition(), cases);
-
-        let failing = vec![
-            "struct {  }",
-            "struct Foo { bar: pub Field }",
-            "struct Foo { bar: pub Field }",
-            "#[oracle(some)] struct Foo { bar: Field }",
-        ];
-        parse_all_failing(struct_definition(), failing);
+    fn parse_empty_struct() {
+        let src = "struct Foo {}";
+        let noir_struct = parse_struct_no_errors(src);
+        assert_eq!("Foo", noir_struct.name.to_string());
+        assert!(noir_struct.fields.is_empty());
+        assert!(noir_struct.generics.is_empty());
+    }
+
+    #[test]
+    fn parse_empty_struct_followed_by_semicolon() {
+        let src = "struct Foo;";
+        let noir_struct = parse_struct_no_errors(src);
+        assert_eq!("Foo", noir_struct.name.to_string());
+        assert!(noir_struct.fields.is_empty());
+        assert!(noir_struct.generics.is_empty());
+    }
+
+    #[test]
+    fn parse_empty_struct_with_generics() {
+        let src = "struct Foo<A, let B: u32> {}";
+        let mut noir_struct = parse_struct_no_errors(src);
+        assert_eq!("Foo", noir_struct.name.to_string());
+        assert!(noir_struct.fields.is_empty());
+        assert_eq!(noir_struct.generics.len(), 2);
+
+        let generic = noir_struct.generics.remove(0);
+        let UnresolvedGeneric::Variable(ident) = generic else {
+            panic!("Expected generic variable");
+        };
+        assert_eq!("A", ident.to_string());
+
+        let generic = noir_struct.generics.remove(0);
+        let UnresolvedGeneric::Numeric { ident, typ } = generic else {
+            panic!("Expected generic numeric");
+        };
+        assert_eq!("B", ident.to_string());
+        assert_eq!(
+            typ.typ,
+            UnresolvedTypeData::Integer(Signedness::Unsigned, IntegerBitSize::ThirtyTwo)
+        );
+    }
+
+    #[test]
+    fn parse_struct_with_fields() {
+        let src = "struct Foo { x: i32, y: Field }";
+        let mut noir_struct = parse_struct_no_errors(src);
+        assert_eq!("Foo", noir_struct.name.to_string());
+        assert_eq!(noir_struct.fields.len(), 2);
+
+        let field = noir_struct.fields.remove(0).item;
+        assert_eq!("x", field.name.to_string());
+        assert!(matches!(
+            field.typ.typ,
+            UnresolvedTypeData::Integer(Signedness::Signed, IntegerBitSize::ThirtyTwo)
+        ));
+
+        let field = noir_struct.fields.remove(0).item;
+        assert_eq!("y", field.name.to_string());
+        assert!(matches!(field.typ.typ, UnresolvedTypeData::FieldElement));
+    }
+
+    #[test]
+    fn parse_empty_struct_with_doc_comments() {
+        let src = "/// Hello\nstruct Foo {}";
+        let (module, errors) = parse_program(src);
+        expect_no_errors(&errors);
+        assert_eq!(module.items.len(), 1);
+        let item = &module.items[0];
+        assert_eq!(item.doc_comments.len(), 1);
+        let ItemKind::Struct(noir_struct) = &item.kind else {
+            panic!("Expected struct");
+        };
+        assert_eq!("Foo", noir_struct.name.to_string());
+    }
+
+    #[test]
+    fn parse_unclosed_struct() {
+        let src = "struct Foo {";
+        let (module, errors) = parse_program(src);
+        assert_eq!(errors.len(), 1);
+        assert_eq!(module.items.len(), 1);
+        let item = &module.items[0];
+        let ItemKind::Struct(noir_struct) = &item.kind else {
+            panic!("Expected struct");
+        };
+        assert_eq!("Foo", noir_struct.name.to_string());
+    }
+
+    #[test]
+    fn parse_error_no_function_attributes_allowed_on_struct() {
+        let src = "
+        #[test] struct Foo {}
+        ^^^^^^^
+        ";
+        let (src, span) = get_source_with_error_span(src);
+        let (_, errors) = parse_program(&src);
+        let reason = get_single_error_reason(&errors, span);
+        assert!(matches!(reason, ParserErrorReason::NoFunctionAttributesAllowedOnStruct));
+    }
+
+    #[test]
+    fn recovers_on_non_field() {
+        let src = "
+        struct Foo { 42 x: i32 }
+                     ^^
+        ";
+        let (src, span) = get_source_with_error_span(src);
+        let (module, errors) = parse_program(&src);
+
+        assert_eq!(module.items.len(), 1);
+        let item = &module.items[0];
+        let ItemKind::Struct(noir_struct) = &item.kind else {
+            panic!("Expected struct");
+        };
+        assert_eq!("Foo", noir_struct.name.to_string());
+        assert_eq!(noir_struct.fields.len(), 1);
+
+        let error = get_single_error(&errors, span);
+        assert_eq!(error.to_string(), "Expected an identifier but found '42'");
     }
 }
diff --git a/compiler/noirc_frontend/src/parser/parser/test_helpers.rs b/compiler/noirc_frontend/src/parser/parser/test_helpers.rs
deleted file mode 100644
index 83c1e148f0e..00000000000
--- a/compiler/noirc_frontend/src/parser/parser/test_helpers.rs
+++ /dev/null
@@ -1,122 +0,0 @@
-use chumsky::primitive::just;
-use chumsky::Parser;
-use iter_extended::vecmap;
-use noirc_errors::CustomDiagnostic;
-
-use crate::{
-    lexer::Lexer,
-    parser::{force, NoirParser},
-    token::Token,
-};
-
-pub(crate) fn parse_with<P, T>(parser: P, program: &str) -> Result<T, Vec<CustomDiagnostic>>
-where
-    P: NoirParser<T>,
-{
-    let (tokens, lexer_errors) = Lexer::lex(program);
-    if !lexer_errors.is_empty() {
-        return Err(vecmap(&lexer_errors, Into::into));
-    }
-    parser.then_ignore(just(Token::EOF)).parse(tokens).map_err(|errors| vecmap(&errors, Into::into))
-}
-
-pub(crate) fn parse_recover<P, T>(parser: P, program: &str) -> (Option<T>, Vec<CustomDiagnostic>)
-where
-    P: NoirParser<T>,
-{
-    let (tokens, lexer_errors) = Lexer::lex(program);
-    let (opt, errs) = parser.then_ignore(force(just(Token::EOF))).parse_recovery(tokens);
-
-    let mut errors = vecmap(&lexer_errors, Into::into);
-    errors.extend(errs.iter().map(Into::into));
-
-    (opt, errors)
-}
-
-pub(crate) fn parse_all<P, T>(parser: P, programs: Vec<&str>) -> Vec<T>
-where
-    P: NoirParser<T>,
-{
-    vecmap(programs, move |program| {
-        let message = format!("Failed to parse:\n{program}");
-        let (op_t, diagnostics) = parse_recover(&parser, program);
-        diagnostics.iter().for_each(|diagnostic| {
-            if diagnostic.is_error() {
-                panic!("{} with error {}", &message, diagnostic);
-            }
-        });
-        op_t.expect(&message)
-    })
-}
-
-pub(crate) fn parse_all_failing<P, T>(parser: P, programs: Vec<&str>) -> Vec<CustomDiagnostic>
-where
-    P: NoirParser<T>,
-    T: std::fmt::Display,
-{
-    programs
-            .into_iter()
-            .flat_map(|program| match parse_with(&parser, program) {
-                Ok(expr) => {
-                    unreachable!(
-                        "Expected this input to fail:\n{}\nYet it successfully parsed as:\n{}",
-                        program, expr
-                    )
-                }
-                Err(diagnostics) => {
-                    if diagnostics.iter().all(|diagnostic: &CustomDiagnostic| diagnostic.is_warning()) {
-                        unreachable!(
-                            "Expected at least one error when parsing:\n{}\nYet it successfully parsed without errors:\n",
-                            program
-                        )
-                    };
-                    diagnostics
-                }
-            })
-            .collect()
-}
-
-#[derive(Copy, Clone)]
-pub(crate) struct Case {
-    pub(crate) source: &'static str,
-    pub(crate) errors: usize,
-    pub(crate) expect: &'static str,
-}
-
-pub(crate) fn check_cases_with_errors<T, P>(cases: &[Case], parser: P)
-where
-    P: NoirParser<T> + Clone,
-    T: std::fmt::Display,
-{
-    let show_errors = |v| vecmap(&v, ToString::to_string).join("\n");
-
-    let results = vecmap(cases, |&case| {
-        let (opt, errors) = parse_recover(parser.clone(), case.source);
-        let actual = opt.map(|ast| ast.to_string());
-        let actual = if let Some(s) = &actual { s.to_string() } else { "(none)".to_string() };
-
-        let result = ((errors.len(), actual.clone()), (case.errors, case.expect.to_string()));
-        if result.0 != result.1 {
-            let num_errors = errors.len();
-            let shown_errors = show_errors(errors);
-            eprintln!(
-                concat!(
-                    "\nExpected {expected_errors} error(s) and got {num_errors}:",
-                    "\n\n{shown_errors}",
-                    "\n\nFrom input:   {src}",
-                    "\nExpected AST: {expected_result}",
-                    "\nActual AST:   {actual}\n",
-                ),
-                expected_errors = case.errors,
-                num_errors = num_errors,
-                shown_errors = shown_errors,
-                src = case.source,
-                expected_result = case.expect,
-                actual = actual,
-            );
-        }
-        result
-    });
-
-    assert_eq!(vecmap(&results, |t| t.0.clone()), vecmap(&results, |t| t.1.clone()),);
-}
diff --git a/compiler/noirc_frontend/src/parser/parser/tests.rs b/compiler/noirc_frontend/src/parser/parser/tests.rs
new file mode 100644
index 00000000000..ea8b1fc638d
--- /dev/null
+++ b/compiler/noirc_frontend/src/parser/parser/tests.rs
@@ -0,0 +1,55 @@
+#![cfg(test)]
+
+use noirc_errors::Span;
+
+use crate::parser::{ParserError, ParserErrorReason};
+
+pub(super) fn get_source_with_error_span(src: &str) -> (String, Span) {
+    let mut lines: Vec<&str> = src.trim_end().lines().collect();
+    let squiggles_line = lines.pop().expect("Expected at least two lines in src (the last one should have squiggles for the error location)");
+    let squiggle_index = squiggles_line
+        .chars()
+        .position(|char| char == '^')
+        .expect("Expected at least one `^` character in the last line of the src");
+    let squiggle_length = squiggles_line.len() - squiggle_index;
+    let last_line = lines.last().expect("Expected at least two lines in src");
+    let src = lines.join("\n");
+    let span_start = src.len() - last_line.len() + squiggle_index;
+    let span_end = span_start + squiggle_length;
+    let span = Span::from(span_start as u32..span_end as u32);
+    (src, span)
+}
+
+pub(super) fn get_single_error(errors: &[ParserError], expected_span: Span) -> &ParserError {
+    if errors.is_empty() {
+        panic!("Expected an error, found none");
+    }
+
+    if errors.len() > 1 {
+        for error in errors {
+            println!("{}", error);
+        }
+        panic!("Expected one error, found {} errors (printed above)", errors.len());
+    }
+
+    assert_eq!(errors[0].span(), expected_span);
+    &errors[0]
+}
+
+pub(super) fn get_single_error_reason(
+    errors: &[ParserError],
+    expected_span: Span,
+) -> &ParserErrorReason {
+    get_single_error(errors, expected_span).reason().unwrap()
+}
+
+pub(super) fn expect_no_errors(errors: &[ParserError]) {
+    if errors.is_empty() {
+        return;
+    }
+
+    for error in errors {
+        println!("{}", error);
+    }
+    panic!("Expected no errors, found {} errors (printed above)", errors.len());
+}
diff --git a/compiler/noirc_frontend/src/parser/parser/traits.rs b/compiler/noirc_frontend/src/parser/parser/traits.rs
index b95319f6da0..e03b629e9ea 100644
--- a/compiler/noirc_frontend/src/parser/parser/traits.rs
+++ b/compiler/noirc_frontend/src/parser/parser/traits.rs
@@ -1,343 +1,560 @@
-use chumsky::prelude::*;
-
-use super::attributes::{attributes, validate_secondary_attributes};
-use super::doc_comments::outer_doc_comments;
-use super::function::{function_modifiers, function_return_type};
-use super::path::path_no_turbofish;
-use super::visibility::item_visibility;
-use super::{
-    block, expression, fresh_statement, function, function_declaration_parameters, let_statement,
-};
+use iter_extended::vecmap;
+
+use noirc_errors::Span;
 
 use crate::ast::{
-    Documented, Expression, ItemVisibility, NoirTrait, NoirTraitImpl, TraitBound, TraitImplItem,
-    TraitImplItemKind, TraitItem, UnresolvedTraitConstraint, UnresolvedType,
+    Documented, GenericTypeArg, GenericTypeArgs, ItemVisibility, NoirTrait, Path, Pattern,
+    TraitItem, UnresolvedGeneric, UnresolvedTraitConstraint, UnresolvedType,
 };
-use crate::macros_api::Pattern;
-use crate::parser::spanned;
 use crate::{
-    parser::{
-        ignore_then_commit, parenthesized, parser::primitives::keyword, NoirParser, ParserError,
-        ParserErrorReason, TopLevelStatementKind,
-    },
-    token::{Keyword, Token},
+    ast::{Ident, UnresolvedTypeData},
+    parser::{labels::ParsingRuleLabel, NoirTraitImpl, ParserErrorReason},
+    token::{Attribute, Keyword, SecondaryAttribute, Token},
 };
 
-use super::{generic_type_args, parse_type, primitives::ident};
-
-pub(super) fn trait_definition() -> impl NoirParser<TopLevelStatementKind> {
-    let trait_body_or_error = just(Token::LeftBrace)
-        .ignore_then(trait_body())
-        .then_ignore(just(Token::RightBrace))
-        .or_not()
-        .validate(|items, span, emit| {
-            if let Some(items) = items {
-                items
-            } else {
-                emit(ParserError::with_reason(
-                    ParserErrorReason::ExpectedLeftBracketOrWhereOrLeftBraceOrArrowAfterTraitName,
-                    span,
-                ));
-                vec![]
+use super::parse_many::without_separator;
+use super::Parser;
+
+impl<'a> Parser<'a> {
+    /// Trait = 'trait' identifier Generics ( ':' TraitBounds )? WhereClause TraitBody
+    ///       | 'trait' identifier Generics '=' TraitBounds WhereClause ';'
+    pub(crate) fn parse_trait(
+        &mut self,
+        attributes: Vec<(Attribute, Span)>,
+        visibility: ItemVisibility,
+        start_span: Span,
+    ) -> (NoirTrait, Option<NoirTraitImpl>) {
+        let attributes = self.validate_secondary_attributes(attributes);
+
+        let Some(name) = self.eat_ident() else {
+            self.expected_identifier();
+            let noir_trait = empty_trait(attributes, visibility, self.span_since(start_span));
+            let no_implicit_impl = None;
+            return (noir_trait, no_implicit_impl);
+        };
+
+        let generics = self.parse_generics();
+
+        // Trait aliases:
+        // trait Foo<..> = A + B + E where ..;
+        let (bounds, where_clause, items, is_alias) = if self.eat_assign() {
+            let bounds = self.parse_trait_bounds();
+
+            if bounds.is_empty() {
+                self.push_error(ParserErrorReason::EmptyTraitAlias, self.previous_token_span);
             }
-        });
 
-    attributes()
-        .then(item_visibility())
-        .then_ignore(keyword(Keyword::Trait))
-        .then(ident())
-        .then(function::generics())
-        .then(where_clause())
-        .then(trait_body_or_error)
-        .validate(
-            |(((((attributes, visibility), name), generics), where_clause), items), span, emit| {
-                let attributes = validate_secondary_attributes(attributes, span, emit);
-                TopLevelStatementKind::Trait(NoirTrait {
-                    name,
-                    generics,
-                    where_clause,
-                    span,
-                    items,
-                    attributes,
-                    visibility,
-                })
-            },
-        )
-}
+            let where_clause = self.parse_where_clause();
+            let items = Vec::new();
+            if !self.eat_semicolon() {
+                self.expected_token(Token::Semicolon);
+            }
 
-fn trait_body() -> impl NoirParser<Vec<Documented<TraitItem>>> {
-    let item =
-        trait_function_declaration().or(trait_type_declaration()).or(trait_constant_declaration());
-    outer_doc_comments()
-        .then(item)
-        .map(|(doc_comments, item)| Documented::new(item, doc_comments))
-        .repeated()
-}
+            let is_alias = true;
+            (bounds, where_clause, items, is_alias)
+        } else {
+            let bounds = if self.eat_colon() { self.parse_trait_bounds() } else { Vec::new() };
+            let where_clause = self.parse_where_clause();
+            let items = self.parse_trait_body();
+            let is_alias = false;
+            (bounds, where_clause, items, is_alias)
+        };
 
-fn optional_default_value() -> impl NoirParser<Option<Expression>> {
-    ignore_then_commit(just(Token::Assign), expression()).or_not()
-}
+        let span = self.span_since(start_span);
 
-fn trait_constant_declaration() -> impl NoirParser<TraitItem> {
-    keyword(Keyword::Let)
-        .ignore_then(ident())
-        .then_ignore(just(Token::Colon))
-        .then(parse_type())
-        .then(optional_default_value())
-        .then_ignore(just(Token::Semicolon))
-        .map(|((name, typ), default_value)| TraitItem::Constant { name, typ, default_value })
-}
+        let noir_impl = is_alias.then(|| {
+            let object_type_ident = Ident::new("#T".to_string(), span);
+            let object_type_path = Path::from_ident(object_type_ident.clone());
+            let object_type_generic = UnresolvedGeneric::Variable(object_type_ident);
 
-/// trait_function_declaration: 'fn' ident generics '(' declaration_parameters ')' function_return_type
-fn trait_function_declaration() -> impl NoirParser<TraitItem> {
-    let trait_function_body_or_semicolon =
-        block(fresh_statement()).map(Option::from).or(just(Token::Semicolon).to(Option::None));
-
-    let trait_function_body_or_semicolon_or_error =
-        trait_function_body_or_semicolon.or_not().validate(|body, span, emit| {
-            if let Some(body) = body {
-                body
-            } else {
-                emit(ParserError::with_reason(
-                    ParserErrorReason::ExpectedLeftBraceOrArrowAfterFunctionParameters,
+            let is_synthesized = true;
+            let object_type = UnresolvedType {
+                typ: UnresolvedTypeData::Named(object_type_path, vec![].into(), is_synthesized),
+                span,
+            };
+
+            let mut impl_generics = generics.clone();
+            impl_generics.push(object_type_generic);
+
+            let trait_name = Path::from_ident(name.clone());
+            let trait_generics: GenericTypeArgs = vecmap(generics.clone(), |generic| {
+                let is_synthesized = true;
+                let generic_type = UnresolvedType {
+                    typ: UnresolvedTypeData::Named(
+                        Path::from_ident(generic.ident().clone()),
+                        vec![].into(),
+                        is_synthesized,
+                    ),
                     span,
-                ));
-                None
-            }
-        });
-
-    function_modifiers()
-        .then_ignore(keyword(Keyword::Fn))
-        .then(ident())
-        .then(function::generics())
-        .then(parenthesized(function_declaration_parameters()))
-        .then(function_return_type().map(|(_, typ)| typ))
-        .then(where_clause())
-        .then(trait_function_body_or_semicolon_or_error)
-        .map(
-            |((((((modifiers, name), generics), parameters), return_type), where_clause), body)| {
-                TraitItem::Function {
-                    name,
-                    generics,
-                    parameters,
-                    return_type,
-                    where_clause,
-                    body,
-                    is_unconstrained: modifiers.0,
-                    visibility: modifiers.1,
-                    is_comptime: modifiers.2,
-                }
-            },
-        )
-}
+                };
 
-/// trait_type_declaration: 'type' ident generics
-fn trait_type_declaration() -> impl NoirParser<TraitItem> {
-    keyword(Keyword::Type)
-        .ignore_then(ident())
-        .then_ignore(just(Token::Semicolon))
-        .map(|name| TraitItem::Type { name })
-}
+                GenericTypeArg::Ordered(generic_type)
+            })
+            .into();
+
+            // bounds from trait
+            let mut where_clause = where_clause.clone();
+            for bound in bounds.clone() {
+                where_clause.push(UnresolvedTraitConstraint {
+                    typ: object_type.clone(),
+                    trait_bound: bound,
+                });
+            }
 
-/// Parses a trait implementation, implementing a particular trait for a type.
-/// This has a similar syntax to `implementation`, but the `for type` clause is required,
-/// and an optional `where` clause is also useable.
-///
-/// trait_implementation: 'impl' generics ident generic_args for type '{' trait_implementation_body '}'
-pub(super) fn trait_implementation() -> impl NoirParser<TopLevelStatementKind> {
-    let body_or_error =
-        just(Token::LeftBrace)
-            .ignore_then(trait_implementation_body())
-            .then_ignore(just(Token::RightBrace))
-            .or_not()
-            .validate(|items, span, emit| {
-                if let Some(items) = items {
-                    items
-                } else {
-                    emit(ParserError::with_reason(
-                        ParserErrorReason::ExpectedLeftBracketOrWhereOrLeftBraceOrArrowAfterTraitImplForType,
-                        span,
-                    ));
+            let items = vec![];
+            let is_synthetic = true;
 
-                    vec![]
-                }
-            });
-
-    keyword(Keyword::Impl)
-        .ignore_then(function::generics())
-        .then(path_no_turbofish())
-        .then(generic_type_args(parse_type()))
-        .then_ignore(keyword(Keyword::For))
-        .then(parse_type())
-        .then(where_clause())
-        .then(body_or_error)
-        .map(|args| {
-            let (((other_args, object_type), where_clause), items) = args;
-            let ((impl_generics, trait_name), trait_generics) = other_args;
-            TopLevelStatementKind::TraitImpl(NoirTraitImpl {
+            NoirTraitImpl {
                 impl_generics,
                 trait_name,
                 trait_generics,
                 object_type,
-                items,
                 where_clause,
-            })
+                items,
+                is_synthetic,
+            }
+        });
+
+        let noir_trait = NoirTrait {
+            name,
+            generics,
+            bounds,
+            where_clause,
+            span,
+            items,
+            attributes,
+            visibility,
+            is_alias,
+        };
+
+        (noir_trait, noir_impl)
+    }
+
+    /// TraitBody = '{' ( OuterDocComments TraitItem )* '}'
+    fn parse_trait_body(&mut self) -> Vec<Documented<TraitItem>> {
+        if !self.eat_left_brace() {
+            self.expected_token(Token::LeftBrace);
+            return Vec::new();
+        }
+
+        self.parse_many(
+            "trait items",
+            without_separator().until(Token::RightBrace),
+            Self::parse_trait_item_in_list,
+        )
+    }
+
+    fn parse_trait_item_in_list(&mut self) -> Option<Documented<TraitItem>> {
+        self.parse_item_in_list(ParsingRuleLabel::TraitItem, |parser| {
+            let doc_comments = parser.parse_outer_doc_comments();
+            parser.parse_trait_item().map(|item| Documented::new(item, doc_comments))
         })
-}
+    }
 
-fn trait_implementation_body() -> impl NoirParser<Vec<Documented<TraitImplItem>>> {
-    let function = function::function_definition(true).validate(|mut f, span, emit| {
-        if f.def().visibility != ItemVisibility::Private {
-            emit(ParserError::with_reason(ParserErrorReason::TraitImplVisibilityIgnored, span));
+    /// TraitItem
+    ///     = TraitType
+    ///     | TraitConstant
+    ///     | TraitFunction
+    fn parse_trait_item(&mut self) -> Option<TraitItem> {
+        if let Some(item) = self.parse_trait_type() {
+            return Some(item);
         }
-        // Trait impl functions are always public
-        f.def_mut().visibility = ItemVisibility::Public;
-        TraitImplItemKind::Function(f)
-    });
-
-    let alias = keyword(Keyword::Type)
-        .ignore_then(ident())
-        .then_ignore(just(Token::Assign))
-        .then(parse_type())
-        .then_ignore(just(Token::Semicolon))
-        .map(|(name, alias)| TraitImplItemKind::Type { name, alias });
-
-    let let_statement = let_statement(expression()).then_ignore(just(Token::Semicolon)).try_map(
-        |((pattern, typ), expr), span| match pattern {
-            Pattern::Identifier(ident) => Ok(TraitImplItemKind::Constant(ident, typ, expr)),
-            _ => Err(ParserError::with_reason(
-                ParserErrorReason::PatternInTraitFunctionParameter,
-                span,
-            )),
-        },
-    );
 
-    let item = choice((function, alias, let_statement));
-    outer_doc_comments()
-        .then(spanned(item).map(|(kind, span)| TraitImplItem { kind, span }))
-        .map(|(doc_comments, item)| Documented::new(item, doc_comments))
-        .repeated()
-}
+        if let Some(item) = self.parse_trait_constant() {
+            return Some(item);
+        }
+
+        if let Some(item) = self.parse_trait_function() {
+            return Some(item);
+        }
 
-pub(super) fn where_clause() -> impl NoirParser<Vec<UnresolvedTraitConstraint>> {
-    struct MultiTraitConstraint {
-        typ: UnresolvedType,
-        trait_bounds: Vec<TraitBound>,
+        None
     }
 
-    let constraints = parse_type()
-        .then_ignore(just(Token::Colon))
-        .then(trait_bounds())
-        .map(|(typ, trait_bounds)| MultiTraitConstraint { typ, trait_bounds });
-
-    keyword(Keyword::Where)
-        .ignore_then(constraints.separated_by(just(Token::Comma)).allow_trailing())
-        .or_not()
-        .map(|option| option.unwrap_or_default())
-        .map(|x: Vec<MultiTraitConstraint>| {
-            let mut result: Vec<UnresolvedTraitConstraint> = Vec::new();
-            for constraint in x {
-                for bound in constraint.trait_bounds {
-                    result.push(UnresolvedTraitConstraint {
-                        typ: constraint.typ.clone(),
-                        trait_bound: bound,
-                    });
-                }
+    /// TraitType = 'type' identifier ';'
+    fn parse_trait_type(&mut self) -> Option<TraitItem> {
+        if !self.eat_keyword(Keyword::Type) {
+            return None;
+        }
+
+        let name = match self.eat_ident() {
+            Some(name) => name,
+            None => {
+                self.expected_identifier();
+                Ident::default()
             }
-            result
-        })
-}
+        };
+
+        self.eat_semicolons();
+
+        Some(TraitItem::Type { name })
+    }
+
+    /// TraitConstant = 'let' identifier ':' Type ( '=' Expression ) ';'
+    fn parse_trait_constant(&mut self) -> Option<TraitItem> {
+        if !self.eat_keyword(Keyword::Let) {
+            return None;
+        }
 
-fn trait_bounds() -> impl NoirParser<Vec<TraitBound>> {
-    trait_bound().separated_by(just(Token::Plus)).at_least(1).allow_trailing()
+        let name = match self.eat_ident() {
+            Some(name) => name,
+            None => {
+                self.expected_identifier();
+                Ident::default()
+            }
+        };
+
+        let typ = if self.eat_colon() {
+            self.parse_type_or_error()
+        } else {
+            self.expected_token(Token::Colon);
+            UnresolvedType { typ: UnresolvedTypeData::Unspecified, span: Span::default() }
+        };
+
+        let default_value =
+            if self.eat_assign() { Some(self.parse_expression_or_error()) } else { None };
+
+        self.eat_semicolons();
+
+        Some(TraitItem::Constant { name, typ, default_value })
+    }
+
+    /// TraitFunction = Modifiers Function
+    fn parse_trait_function(&mut self) -> Option<TraitItem> {
+        let modifiers = self.parse_modifiers(
+            false, // allow mut
+        );
+
+        if !self.eat_keyword(Keyword::Fn) {
+            self.modifiers_not_followed_by_an_item(modifiers);
+            return None;
+        }
+
+        let function = self.parse_function_definition_with_optional_body(
+            true, // allow optional body
+            true, // allow self
+        );
+
+        let parameters = function
+            .parameters
+            .into_iter()
+            .filter_map(|param| {
+                if let Pattern::Identifier(ident) = param.pattern {
+                    Some((ident, param.typ))
+                } else {
+                    self.push_error(ParserErrorReason::InvalidPattern, param.pattern.span());
+                    None
+                }
+            })
+            .collect();
+
+        Some(TraitItem::Function {
+            is_unconstrained: modifiers.unconstrained.is_some(),
+            visibility: modifiers.visibility,
+            is_comptime: modifiers.comptime.is_some(),
+            name: function.name,
+            generics: function.generics,
+            parameters,
+            return_type: function.return_type,
+            where_clause: function.where_clause,
+            body: function.body,
+        })
+    }
 }
 
-pub fn trait_bound() -> impl NoirParser<TraitBound> {
-    path_no_turbofish().then(generic_type_args(parse_type())).map(|(trait_path, trait_generics)| {
-        TraitBound { trait_path, trait_generics, trait_id: None }
-    })
+fn empty_trait(
+    attributes: Vec<SecondaryAttribute>,
+    visibility: ItemVisibility,
+    span: Span,
+) -> NoirTrait {
+    NoirTrait {
+        name: Ident::default(),
+        generics: Vec::new(),
+        bounds: Vec::new(),
+        where_clause: Vec::new(),
+        span,
+        items: Vec::new(),
+        attributes,
+        visibility,
+        is_alias: false,
+    }
 }
 
 #[cfg(test)]
-mod test {
-    use super::*;
-    use crate::parser::parser::test_helpers::*;
+mod tests {
+    use crate::{
+        ast::{NoirTrait, NoirTraitImpl, TraitItem},
+        parser::{
+            parser::{parse_program, tests::expect_no_errors, ParserErrorReason},
+            ItemKind,
+        },
+    };
+
+    fn parse_trait_opt_impl_no_errors(src: &str) -> (NoirTrait, Option<NoirTraitImpl>) {
+        let (mut module, errors) = parse_program(src);
+        expect_no_errors(&errors);
+        let (item, impl_item) = if module.items.len() == 2 {
+            let item = module.items.remove(0);
+            let impl_item = module.items.remove(0);
+            (item, Some(impl_item))
+        } else {
+            assert_eq!(module.items.len(), 1);
+            let item = module.items.remove(0);
+            (item, None)
+        };
+        let ItemKind::Trait(noir_trait) = item.kind else {
+            panic!("Expected trait");
+        };
+        let noir_trait_impl = impl_item.map(|impl_item| {
+            let ItemKind::TraitImpl(noir_trait_impl) = impl_item.kind else {
+                panic!("Expected impl");
+            };
+            noir_trait_impl
+        });
+        (noir_trait, noir_trait_impl)
+    }
+
+    fn parse_trait_with_impl_no_errors(src: &str) -> (NoirTrait, NoirTraitImpl) {
+        let (noir_trait, noir_trait_impl) = parse_trait_opt_impl_no_errors(src);
+        (noir_trait, noir_trait_impl.expect("expected a NoirTraitImpl"))
+    }
+
+    fn parse_trait_no_errors(src: &str) -> NoirTrait {
+        parse_trait_opt_impl_no_errors(src).0
+    }
 
     #[test]
-    fn parse_trait() {
-        parse_all(
-            trait_definition(),
-            vec![
-                // Empty traits are legal in Rust and sometimes used as a way to whitelist certain types
-                // for a particular operation. Also known as `tag` or `marker` traits:
-                // https://stackoverflow.com/questions/71895489/what-is-the-purpose-of-defining-empty-impl-in-rust
-                "trait Empty {}",
-                "trait TraitWithDefaultBody { fn foo(self) {} }",
-                "trait TraitAcceptingMutableRef { fn foo(&mut self); }",
-                "trait TraitWithTypeBoundOperation { fn identity() -> Self; }",
-                "trait TraitWithAssociatedType { type Element; fn item(self, index: Field) -> Self::Element; }",
-                "trait TraitWithAssociatedConstant { let Size: Field; }",
-                "trait TraitWithAssociatedConstantWithDefaultValue { let Size: Field = 10; }",
-                "trait GenericTrait<T> { fn elem(&mut self, index: Field) -> T; }",
-                "trait GenericTraitWithConstraints<T> where T: SomeTrait { fn elem(self, index: Field) -> T; }",
-                "trait TraitWithMultipleGenericParams<A, B, C> where A: SomeTrait, B: AnotherTrait<C> { let Size: Field; fn zero() -> Self; }",
-                "trait TraitWithMultipleGenericParams<A, B, C> where A: SomeTrait, B: AnotherTrait<C>, { let Size: Field; fn zero() -> Self; }",
-            ],
-        );
+    fn parse_empty_trait() {
+        let src = "trait Foo {}";
+        let noir_trait = parse_trait_no_errors(src);
+        assert_eq!(noir_trait.name.to_string(), "Foo");
+        assert!(noir_trait.generics.is_empty());
+        assert!(noir_trait.where_clause.is_empty());
+        assert!(noir_trait.items.is_empty());
+        assert!(!noir_trait.is_alias);
+    }
 
-        parse_all_failing(
-            trait_definition(),
-            vec!["trait MissingBody", "trait WrongDelimiter { fn foo() -> u8, fn bar() -> u8 }"],
-        );
+    #[test]
+    fn parse_empty_trait_alias() {
+        let src = "trait Foo = ;";
+        let (_module, errors) = parse_program(src);
+        assert_eq!(errors.len(), 2);
+        assert_eq!(errors[1].reason(), Some(ParserErrorReason::EmptyTraitAlias).as_ref());
     }
 
     #[test]
-    fn parse_recover_function_without_left_brace_or_semicolon() {
-        let src = "fn foo(x: i32)";
+    fn parse_trait_with_generics() {
+        let src = "trait Foo<A, B> {}";
+        let noir_trait = parse_trait_no_errors(src);
+        assert_eq!(noir_trait.name.to_string(), "Foo");
+        assert_eq!(noir_trait.generics.len(), 2);
+        assert!(noir_trait.where_clause.is_empty());
+        assert!(noir_trait.items.is_empty());
+        assert!(!noir_trait.is_alias);
+    }
 
-        let (trait_item, errors) = parse_recover(trait_function_declaration(), src);
-        assert_eq!(errors.len(), 1);
-        assert_eq!(errors[0].message, "expected { or -> after function parameters");
+    #[test]
+    fn parse_trait_alias_with_generics() {
+        let src = "trait Foo<A, B> = Bar + Baz<A>;";
+        let (noir_trait_alias, noir_trait_impl) = parse_trait_with_impl_no_errors(src);
+        assert_eq!(noir_trait_alias.name.to_string(), "Foo");
+        assert_eq!(noir_trait_alias.generics.len(), 2);
+        assert_eq!(noir_trait_alias.bounds.len(), 2);
+        assert_eq!(noir_trait_alias.bounds[0].to_string(), "Bar");
+        assert_eq!(noir_trait_alias.bounds[1].to_string(), "Baz<A>");
+        assert!(noir_trait_alias.where_clause.is_empty());
+        assert!(noir_trait_alias.items.is_empty());
+        assert!(noir_trait_alias.is_alias);
+
+        assert_eq!(noir_trait_impl.trait_name.to_string(), "Foo");
+        assert_eq!(noir_trait_impl.impl_generics.len(), 3);
+        assert_eq!(noir_trait_impl.trait_generics.ordered_args.len(), 2);
+        assert_eq!(noir_trait_impl.where_clause.len(), 2);
+        assert_eq!(noir_trait_alias.bounds.len(), 2);
+        assert_eq!(noir_trait_alias.bounds[0].to_string(), "Bar");
+        assert_eq!(noir_trait_alias.bounds[1].to_string(), "Baz<A>");
+        assert!(noir_trait_impl.items.is_empty());
+        assert!(noir_trait_impl.is_synthetic);
+
+        // Equivalent to
+        let src = "trait Foo<A, B>: Bar + Baz<A> {}";
+        let noir_trait = parse_trait_no_errors(src);
+        assert_eq!(noir_trait.name.to_string(), noir_trait_alias.name.to_string());
+        assert_eq!(noir_trait.generics.len(), noir_trait_alias.generics.len());
+        assert_eq!(noir_trait.bounds.len(), noir_trait_alias.bounds.len());
+        assert_eq!(noir_trait.bounds[0].to_string(), noir_trait_alias.bounds[0].to_string());
+        assert_eq!(noir_trait.where_clause.is_empty(), noir_trait_alias.where_clause.is_empty());
+        assert_eq!(noir_trait.items.is_empty(), noir_trait_alias.items.is_empty());
+        assert!(!noir_trait.is_alias);
+    }
 
-        let Some(TraitItem::Function { name, parameters, body, .. }) = trait_item else {
-            panic!("Expected to parser trait item as function");
-        };
+    #[test]
+    fn parse_empty_trait_alias_with_generics() {
+        let src = "trait Foo<A, B> = ;";
+        let (_module, errors) = parse_program(src);
+        assert_eq!(errors.len(), 2);
+        assert_eq!(errors[1].reason(), Some(ParserErrorReason::EmptyTraitAlias).as_ref());
+    }
 
-        assert_eq!(name.to_string(), "foo");
-        assert_eq!(parameters.len(), 1);
-        assert!(body.is_none());
+    #[test]
+    fn parse_trait_with_where_clause() {
+        let src = "trait Foo<A, B> where A: Z {}";
+        let noir_trait = parse_trait_no_errors(src);
+        assert_eq!(noir_trait.name.to_string(), "Foo");
+        assert_eq!(noir_trait.generics.len(), 2);
+        assert_eq!(noir_trait.where_clause.len(), 1);
+        assert!(noir_trait.items.is_empty());
+        assert!(!noir_trait.is_alias);
     }
 
     #[test]
-    fn parse_recover_trait_without_body() {
-        let src = "trait Foo";
+    fn parse_trait_alias_with_where_clause() {
+        let src = "trait Foo<A, B> = Bar + Baz<A> where A: Z;";
+        let (noir_trait_alias, noir_trait_impl) = parse_trait_with_impl_no_errors(src);
+        assert_eq!(noir_trait_alias.name.to_string(), "Foo");
+        assert_eq!(noir_trait_alias.generics.len(), 2);
+        assert_eq!(noir_trait_alias.bounds.len(), 2);
+        assert_eq!(noir_trait_alias.bounds[0].to_string(), "Bar");
+        assert_eq!(noir_trait_alias.bounds[1].to_string(), "Baz<A>");
+        assert_eq!(noir_trait_alias.where_clause.len(), 1);
+        assert!(noir_trait_alias.items.is_empty());
+        assert!(noir_trait_alias.is_alias);
+
+        assert_eq!(noir_trait_impl.trait_name.to_string(), "Foo");
+        assert_eq!(noir_trait_impl.impl_generics.len(), 3);
+        assert_eq!(noir_trait_impl.trait_generics.ordered_args.len(), 2);
+        assert_eq!(noir_trait_impl.where_clause.len(), 3);
+        assert_eq!(noir_trait_impl.where_clause[0].to_string(), "A: Z");
+        assert_eq!(noir_trait_impl.where_clause[1].to_string(), "#T: Bar");
+        assert_eq!(noir_trait_impl.where_clause[2].to_string(), "#T: Baz<A>");
+        assert!(noir_trait_impl.items.is_empty());
+        assert!(noir_trait_impl.is_synthetic);
+
+        // Equivalent to
+        let src = "trait Foo<A, B>: Bar + Baz<A> where A: Z {}";
+        let noir_trait = parse_trait_no_errors(src);
+        assert_eq!(noir_trait.name.to_string(), noir_trait_alias.name.to_string());
+        assert_eq!(noir_trait.generics.len(), noir_trait_alias.generics.len());
+        assert_eq!(noir_trait.bounds.len(), noir_trait_alias.bounds.len());
+        assert_eq!(noir_trait.bounds[0].to_string(), noir_trait_alias.bounds[0].to_string());
+        assert_eq!(noir_trait.where_clause.len(), noir_trait_alias.where_clause.len());
+        assert_eq!(
+            noir_trait.where_clause[0].to_string(),
+            noir_trait_alias.where_clause[0].to_string()
+        );
+        assert_eq!(noir_trait.items.is_empty(), noir_trait_alias.items.is_empty());
+        assert!(!noir_trait.is_alias);
+    }
 
-        let (top_level_statement, errors) = parse_recover(trait_definition(), src);
-        assert_eq!(errors.len(), 1);
-        assert_eq!(errors[0].message, "expected <, where or { after trait name");
+    #[test]
+    fn parse_empty_trait_alias_with_where_clause() {
+        let src = "trait Foo<A, B> = where A: Z;";
+        let (_module, errors) = parse_program(src);
+        assert_eq!(errors.len(), 2);
+        assert_eq!(errors[1].reason(), Some(ParserErrorReason::EmptyTraitAlias).as_ref());
+    }
 
-        let top_level_statement = top_level_statement.unwrap();
-        let TopLevelStatementKind::Trait(trait_) = top_level_statement else {
-            panic!("Expected to parse a trait");
+    #[test]
+    fn parse_trait_with_type() {
+        let src = "trait Foo { type Elem; }";
+        let mut noir_trait = parse_trait_no_errors(src);
+        assert_eq!(noir_trait.items.len(), 1);
+
+        let item = noir_trait.items.remove(0).item;
+        let TraitItem::Type { name } = item else {
+            panic!("Expected type");
         };
-
-        assert_eq!(trait_.name.to_string(), "Foo");
-        assert!(trait_.items.is_empty());
+        assert_eq!(name.to_string(), "Elem");
+        assert!(!noir_trait.is_alias);
     }
 
     #[test]
-    fn parse_recover_trait_impl_without_body() {
-        let src = "impl Foo for Bar";
+    fn parse_trait_with_constant() {
+        let src = "trait Foo { let x: Field = 1; }";
+        let mut noir_trait = parse_trait_no_errors(src);
+        assert_eq!(noir_trait.items.len(), 1);
+
+        let item = noir_trait.items.remove(0).item;
+        let TraitItem::Constant { name, typ, default_value } = item else {
+            panic!("Expected constant");
+        };
+        assert_eq!(name.to_string(), "x");
+        assert_eq!(typ.to_string(), "Field");
+        assert_eq!(default_value.unwrap().to_string(), "1");
+        assert!(!noir_trait.is_alias);
+    }
 
-        let (top_level_statement, errors) = parse_recover(trait_implementation(), src);
-        assert_eq!(errors.len(), 1);
-        assert_eq!(errors[0].message, "expected <, where or { after trait impl for type");
+    #[test]
+    fn parse_trait_with_function_no_body() {
+        let src = "trait Foo { fn foo(); }";
+        let mut noir_trait = parse_trait_no_errors(src);
+        assert_eq!(noir_trait.items.len(), 1);
+
+        let item = noir_trait.items.remove(0).item;
+        let TraitItem::Function { body, .. } = item else {
+            panic!("Expected function");
+        };
+        assert!(body.is_none());
+        assert!(!noir_trait.is_alias);
+    }
 
-        let top_level_statement = top_level_statement.unwrap();
-        let TopLevelStatementKind::TraitImpl(trait_impl) = top_level_statement else {
-            panic!("Expected to parse a trait impl");
+    #[test]
+    fn parse_trait_with_function_with_body() {
+        let src = "trait Foo { fn foo() {} }";
+        let mut noir_trait = parse_trait_no_errors(src);
+        assert_eq!(noir_trait.items.len(), 1);
+
+        let item = noir_trait.items.remove(0).item;
+        let TraitItem::Function { body, .. } = item else {
+            panic!("Expected function");
         };
+        assert!(body.is_some());
+        assert!(!noir_trait.is_alias);
+    }
+
+    #[test]
+    fn parse_trait_inheirtance() {
+        let src = "trait Foo: Bar + Baz {}";
+        let noir_trait = parse_trait_no_errors(src);
+        assert_eq!(noir_trait.bounds.len(), 2);
+
+        assert_eq!(noir_trait.bounds[0].to_string(), "Bar");
+        assert_eq!(noir_trait.bounds[1].to_string(), "Baz");
 
-        assert!(trait_impl.items.is_empty());
+        assert_eq!(noir_trait.to_string(), "trait Foo: Bar + Baz {\n}");
+        assert!(!noir_trait.is_alias);
+    }
+
+    #[test]
+    fn parse_trait_alias() {
+        let src = "trait Foo = Bar + Baz;";
+        let (noir_trait_alias, noir_trait_impl) = parse_trait_with_impl_no_errors(src);
+        assert_eq!(noir_trait_alias.bounds.len(), 2);
+
+        assert_eq!(noir_trait_alias.bounds[0].to_string(), "Bar");
+        assert_eq!(noir_trait_alias.bounds[1].to_string(), "Baz");
+
+        assert_eq!(noir_trait_alias.to_string(), "trait Foo = Bar + Baz;");
+        assert!(noir_trait_alias.is_alias);
+
+        assert_eq!(noir_trait_impl.trait_name.to_string(), "Foo");
+        assert_eq!(noir_trait_impl.impl_generics.len(), 1);
+        assert_eq!(noir_trait_impl.trait_generics.ordered_args.len(), 0);
+        assert_eq!(noir_trait_impl.where_clause.len(), 2);
+        assert_eq!(noir_trait_impl.where_clause[0].to_string(), "#T: Bar");
+        assert_eq!(noir_trait_impl.where_clause[1].to_string(), "#T: Baz");
+        assert!(noir_trait_impl.items.is_empty());
+        assert!(noir_trait_impl.is_synthetic);
+
+        // Equivalent to
+        let src = "trait Foo: Bar + Baz {}";
+        let noir_trait = parse_trait_no_errors(src);
+        assert_eq!(noir_trait.name.to_string(), noir_trait_alias.name.to_string());
+        assert_eq!(noir_trait.generics.len(), noir_trait_alias.generics.len());
+        assert_eq!(noir_trait.bounds.len(), noir_trait_alias.bounds.len());
+        assert_eq!(noir_trait.bounds[0].to_string(), noir_trait_alias.bounds[0].to_string());
+        assert_eq!(noir_trait.where_clause.is_empty(), noir_trait_alias.where_clause.is_empty());
+        assert_eq!(noir_trait.items.is_empty(), noir_trait_alias.items.is_empty());
+        assert!(!noir_trait.is_alias);
     }
 }
diff --git a/compiler/noirc_frontend/src/parser/parser/type_alias.rs b/compiler/noirc_frontend/src/parser/parser/type_alias.rs
new file mode 100644
index 00000000000..52815dc3783
--- /dev/null
+++ b/compiler/noirc_frontend/src/parser/parser/type_alias.rs
@@ -0,0 +1,92 @@
+use noirc_errors::Span;
+
+use crate::{
+    ast::{Ident, ItemVisibility, NoirTypeAlias, UnresolvedType, UnresolvedTypeData},
+    token::Token,
+};
+
+use super::Parser;
+
+impl<'a> Parser<'a> {
+    /// TypeAlias = 'type' identifier Generics '=' Type ';'
+    pub(crate) fn parse_type_alias(
+        &mut self,
+        visibility: ItemVisibility,
+        start_span: Span,
+    ) -> NoirTypeAlias {
+        let Some(name) = self.eat_ident() else {
+            self.expected_identifier();
+            return NoirTypeAlias {
+                visibility,
+                name: Ident::default(),
+                generics: Vec::new(),
+                typ: UnresolvedType { typ: UnresolvedTypeData::Error, span: Span::default() },
+                span: start_span,
+            };
+        };
+
+        let generics = self.parse_generics();
+
+        if !self.eat_assign() {
+            self.expected_token(Token::Assign);
+
+            let span = self.span_since(start_span);
+            self.eat_semicolons();
+
+            return NoirTypeAlias {
+                visibility,
+                name,
+                generics,
+                typ: UnresolvedType { typ: UnresolvedTypeData::Error, span: Span::default() },
+                span,
+            };
+        }
+
+        let typ = self.parse_type_or_error();
+        let span = self.span_since(start_span);
+        if !self.eat_semicolons() {
+            self.expected_token(Token::Semicolon);
+        }
+
+        NoirTypeAlias { visibility, name, generics, typ, span }
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use crate::{
+        ast::{NoirTypeAlias, UnresolvedTypeData},
+        parser::{
+            parser::{parse_program, tests::expect_no_errors},
+            ItemKind,
+        },
+    };
+
+    fn parse_type_alias_no_errors(src: &str) -> NoirTypeAlias {
+        let (mut module, errors) = parse_program(src);
+        expect_no_errors(&errors);
+        assert_eq!(module.items.len(), 1);
+        let item = module.items.remove(0);
+        let ItemKind::TypeAlias(alias) = item.kind else {
+            panic!("Expected global");
+        };
+        alias
+    }
+
+    #[test]
+    fn parse_type_alias_no_generics() {
+        let src = "type Foo = Field;";
+        let alias = parse_type_alias_no_errors(src);
+        assert_eq!("Foo", alias.name.to_string());
+        assert!(alias.generics.is_empty());
+        assert_eq!(alias.typ.typ, UnresolvedTypeData::FieldElement);
+    }
+
+    #[test]
+    fn parse_type_alias_with_generics() {
+        let src = "type Foo<A> = Field;";
+        let alias = parse_type_alias_no_errors(src);
+        assert_eq!("Foo", alias.name.to_string());
+        assert_eq!(alias.generics.len(), 1);
+    }
+}
diff --git a/compiler/noirc_frontend/src/parser/parser/type_expression.rs b/compiler/noirc_frontend/src/parser/parser/type_expression.rs
new file mode 100644
index 00000000000..7dd59aedb45
--- /dev/null
+++ b/compiler/noirc_frontend/src/parser/parser/type_expression.rs
@@ -0,0 +1,620 @@
+use crate::{
+    ast::{GenericTypeArgs, UnresolvedType, UnresolvedTypeData, UnresolvedTypeExpression},
+    parser::{labels::ParsingRuleLabel, ParserError},
+    token::Token,
+    BinaryTypeOperator,
+};
+
+use acvm::acir::{AcirField, FieldElement};
+use noirc_errors::Span;
+
+use super::{parse_many::separated_by_comma_until_right_paren, Parser};
+
+impl<'a> Parser<'a> {
+    /// TypeExpression= AddOrSubtractTypeExpression
+    pub(crate) fn parse_type_expression(
+        &mut self,
+    ) -> Result<UnresolvedTypeExpression, ParserError> {
+        match self.parse_add_or_subtract_type_expression() {
+            Some(type_expr) => Ok(type_expr),
+            None => self.expected_type_expression_after_this(),
+        }
+    }
+
+    /// AddOrSubtractTypeExpression
+    ///     = MultiplyOrDivideOrModuloTypeExpression ( ( '+' | '-' ) MultiplyOrDivideOrModuloTypeExpression )*
+    fn parse_add_or_subtract_type_expression(&mut self) -> Option<UnresolvedTypeExpression> {
+        let start_span = self.current_token_span;
+        let lhs = self.parse_multiply_or_divide_or_modulo_type_expression()?;
+        Some(self.parse_add_or_subtract_type_expression_after_lhs(lhs, start_span))
+    }
+
+    fn parse_add_or_subtract_type_expression_after_lhs(
+        &mut self,
+        mut lhs: UnresolvedTypeExpression,
+        start_span: Span,
+    ) -> UnresolvedTypeExpression {
+        loop {
+            let operator = if self.eat(Token::Plus) {
+                BinaryTypeOperator::Addition
+            } else if self.eat(Token::Minus) {
+                BinaryTypeOperator::Subtraction
+            } else {
+                break;
+            };
+
+            match self.parse_multiply_or_divide_or_modulo_type_expression() {
+                Some(rhs) => {
+                    let span = self.span_since(start_span);
+                    lhs = UnresolvedTypeExpression::BinaryOperation(
+                        Box::new(lhs),
+                        operator,
+                        Box::new(rhs),
+                        span,
+                    );
+                }
+                None => {
+                    self.push_expected_expression();
+                }
+            }
+        }
+
+        lhs
+    }
+
+    /// MultiplyOrDivideOrModuloTypeExpression
+    ///     = TermTypeExpression ( ( '*' | '/' | '%' ) TermTypeExpression )*
+    fn parse_multiply_or_divide_or_modulo_type_expression(
+        &mut self,
+    ) -> Option<UnresolvedTypeExpression> {
+        let start_span = self.current_token_span;
+        let lhs = self.parse_term_type_expression()?;
+        Some(self.parse_multiply_or_divide_or_modulo_type_expression_after_lhs(lhs, start_span))
+    }
+
+    fn parse_multiply_or_divide_or_modulo_type_expression_after_lhs(
+        &mut self,
+        mut lhs: UnresolvedTypeExpression,
+        start_span: Span,
+    ) -> UnresolvedTypeExpression {
+        loop {
+            let operator = if self.eat(Token::Star) {
+                BinaryTypeOperator::Multiplication
+            } else if self.eat(Token::Slash) {
+                BinaryTypeOperator::Division
+            } else if self.eat(Token::Percent) {
+                BinaryTypeOperator::Modulo
+            } else {
+                break;
+            };
+
+            match self.parse_term_type_expression() {
+                Some(rhs) => {
+                    let span = self.span_since(start_span);
+                    lhs = UnresolvedTypeExpression::BinaryOperation(
+                        Box::new(lhs),
+                        operator,
+                        Box::new(rhs),
+                        span,
+                    );
+                }
+                None => {
+                    self.push_expected_expression();
+                    break;
+                }
+            }
+        }
+
+        lhs
+    }
+
+    /// TermTypeExpression
+    ///    = '- TermTypeExpression
+    ///    | AtomTypeExpression
+    fn parse_term_type_expression(&mut self) -> Option<UnresolvedTypeExpression> {
+        let start_span = self.current_token_span;
+        if self.eat(Token::Minus) {
+            return match self.parse_term_type_expression() {
+                Some(rhs) => {
+                    let lhs = UnresolvedTypeExpression::Constant(FieldElement::zero(), start_span);
+                    let op = BinaryTypeOperator::Subtraction;
+                    let span = self.span_since(start_span);
+                    Some(UnresolvedTypeExpression::BinaryOperation(
+                        Box::new(lhs),
+                        op,
+                        Box::new(rhs),
+                        span,
+                    ))
+                }
+                None => {
+                    self.push_expected_expression();
+                    None
+                }
+            };
+        }
+
+        self.parse_atom_type_expression()
+    }
+
+    /// AtomTypeExpression
+    ///     = ConstantTypeExpression
+    ///     | VariableTypeExpression
+    ///     | ParenthesizedTypeExpression
+    fn parse_atom_type_expression(&mut self) -> Option<UnresolvedTypeExpression> {
+        if let Some(type_expr) = self.parse_constant_type_expression() {
+            return Some(type_expr);
+        }
+
+        if let Some(type_expr) = self.parse_variable_type_expression() {
+            return Some(type_expr);
+        }
+
+        if let Some(type_expr) = self.parse_parenthesized_type_expression() {
+            return Some(type_expr);
+        }
+
+        None
+    }
+
+    /// ConstantTypeExpression = int
+    fn parse_constant_type_expression(&mut self) -> Option<UnresolvedTypeExpression> {
+        let Some(int) = self.eat_int() else {
+            return None;
+        };
+
+        Some(UnresolvedTypeExpression::Constant(int, self.previous_token_span))
+    }
+
+    /// VariableTypeExpression = Path
+    fn parse_variable_type_expression(&mut self) -> Option<UnresolvedTypeExpression> {
+        let path = self.parse_path()?;
+        Some(UnresolvedTypeExpression::Variable(path))
+    }
+
+    /// ParenthesizedTypeExpression = '(' TypeExpression ')'
+    fn parse_parenthesized_type_expression(&mut self) -> Option<UnresolvedTypeExpression> {
+        // Make sure not to parse `()` as a parenthesized expression
+        if self.at(Token::LeftParen) && !self.next_is(Token::RightParen) {
+            self.bump();
+            match self.parse_type_expression() {
+                Ok(type_expr) => {
+                    self.eat_or_error(Token::RightParen);
+                    Some(type_expr)
+                }
+                Err(error) => {
+                    self.errors.push(error);
+                    self.eat_right_paren();
+                    None
+                }
+            }
+        } else {
+            None
+        }
+    }
+
+    /// TypeOrTypeExpression = Type | TypeExpression
+    pub(crate) fn parse_type_or_type_expression(&mut self) -> Option<UnresolvedType> {
+        let typ = self.parse_add_or_subtract_type_or_type_expression()?;
+        let span = typ.span;
+
+        // If we end up with a Variable type expression, make it a Named type (they are equivalent),
+        // but for testing purposes and simplicity we default to types instead of type expressions.
+        Some(
+            if let UnresolvedTypeData::Expression(UnresolvedTypeExpression::Variable(path)) =
+                typ.typ
+            {
+                UnresolvedType {
+                    typ: UnresolvedTypeData::Named(path, GenericTypeArgs::default(), false),
+                    span,
+                }
+            } else {
+                typ
+            },
+        )
+    }
+
+    fn parse_add_or_subtract_type_or_type_expression(&mut self) -> Option<UnresolvedType> {
+        let start_span = self.current_token_span;
+        let lhs = self.parse_multiply_or_divide_or_modulo_type_or_type_expression()?;
+
+        // If lhs is a type then no operator can follow, so we stop right away
+        if !type_is_type_expr(&lhs) {
+            return Some(lhs);
+        }
+
+        let lhs = type_to_type_expr(lhs).unwrap();
+        let lhs = self.parse_add_or_subtract_type_expression_after_lhs(lhs, start_span);
+        Some(type_expr_to_type(lhs, self.span_since(start_span)))
+    }
+
+    fn parse_multiply_or_divide_or_modulo_type_or_type_expression(
+        &mut self,
+    ) -> Option<UnresolvedType> {
+        let start_span = self.current_token_span;
+        let lhs = self.parse_term_type_or_type_expression()?;
+
+        // If lhs is a type then no operator can follow, so we stop right away
+        if !type_is_type_expr(&lhs) {
+            return Some(lhs);
+        }
+
+        let lhs = type_to_type_expr(lhs).unwrap();
+        let lhs =
+            self.parse_multiply_or_divide_or_modulo_type_expression_after_lhs(lhs, start_span);
+        Some(type_expr_to_type(lhs, self.span_since(start_span)))
+    }
+
+    fn parse_term_type_or_type_expression(&mut self) -> Option<UnresolvedType> {
+        let start_span = self.current_token_span;
+        if self.eat(Token::Minus) {
+            // If we ate '-' what follows must be a type expression, never a type
+            return match self.parse_term_type_expression() {
+                Some(rhs) => {
+                    let lhs = UnresolvedTypeExpression::Constant(FieldElement::zero(), start_span);
+                    let op = BinaryTypeOperator::Subtraction;
+                    let span = self.span_since(start_span);
+                    let type_expr = UnresolvedTypeExpression::BinaryOperation(
+                        Box::new(lhs),
+                        op,
+                        Box::new(rhs),
+                        span,
+                    );
+                    let typ = UnresolvedTypeData::Expression(type_expr);
+                    Some(UnresolvedType { typ, span })
+                }
+                None => {
+                    self.push_expected_expression();
+                    None
+                }
+            };
+        }
+
+        self.parse_atom_type_or_type_expression()
+    }
+
+    fn parse_atom_type_or_type_expression(&mut self) -> Option<UnresolvedType> {
+        let start_span = self.current_token_span;
+
+        if let Some(path) = self.parse_path() {
+            let generics = self.parse_generic_type_args();
+            let typ = UnresolvedTypeData::Named(path, generics, false);
+            let span = self.span_since(start_span);
+            return Some(UnresolvedType { typ, span });
+        }
+
+        if let Some(type_expr) = self.parse_constant_type_expression() {
+            let typ = UnresolvedTypeData::Expression(type_expr);
+            let span = self.span_since(start_span);
+            return Some(UnresolvedType { typ, span });
+        }
+
+        if let Some(typ) = self.parse_parenthesized_type_or_type_expression() {
+            return Some(typ);
+        }
+
+        self.parse_type()
+    }
+
+    fn parse_parenthesized_type_or_type_expression(&mut self) -> Option<UnresolvedType> {
+        let start_span = self.current_token_span;
+
+        if !self.eat_left_paren() {
+            return None;
+        }
+
+        if self.eat_right_paren() {
+            return Some(UnresolvedType {
+                typ: UnresolvedTypeData::Unit,
+                span: self.span_since(start_span),
+            });
+        }
+
+        let Some(typ) = self.parse_type_or_type_expression() else {
+            self.expected_label(ParsingRuleLabel::TypeOrTypeExpression);
+            return None;
+        };
+
+        // If what we just parsed is a type expression then this must be a parenthesized type
+        // expression (there's no such thing as a tuple of type expressions)
+        if let UnresolvedTypeData::Expression(type_expr) = typ.typ {
+            self.eat_or_error(Token::RightParen);
+            return Some(UnresolvedType {
+                typ: UnresolvedTypeData::Expression(type_expr),
+                span: typ.span,
+            });
+        }
+
+        if self.eat_right_paren() {
+            return Some(UnresolvedType {
+                typ: UnresolvedTypeData::Parenthesized(Box::new(typ)),
+                span: self.span_since(start_span),
+            });
+        }
+
+        let comma_after_first_type = self.eat_comma();
+        let second_type_span = self.current_token_span;
+
+        let mut types = self.parse_many(
+            "tuple items",
+            separated_by_comma_until_right_paren(),
+            Self::parse_type_in_list,
+        );
+
+        if !types.is_empty() && !comma_after_first_type {
+            self.expected_token_separating_items(Token::Comma, "tuple items", second_type_span);
+        }
+
+        types.insert(0, typ);
+
+        Some(UnresolvedType {
+            typ: UnresolvedTypeData::Tuple(types),
+            span: self.span_since(start_span),
+        })
+    }
+
+    fn expected_type_expression_after_this(
+        &mut self,
+    ) -> Result<UnresolvedTypeExpression, ParserError> {
+        Err(ParserError::expected_label(
+            ParsingRuleLabel::TypeExpression,
+            self.token.token().clone(),
+            self.current_token_span,
+        ))
+    }
+}
+
+fn type_to_type_expr(typ: UnresolvedType) -> Option<UnresolvedTypeExpression> {
+    match typ.typ {
+        UnresolvedTypeData::Named(var, generics, _) => {
+            if generics.is_empty() {
+                Some(UnresolvedTypeExpression::Variable(var))
+            } else {
+                None
+            }
+        }
+        UnresolvedTypeData::Expression(type_expr) => Some(type_expr),
+        _ => None,
+    }
+}
+
+fn type_is_type_expr(typ: &UnresolvedType) -> bool {
+    match &typ.typ {
+        UnresolvedTypeData::Named(_, generics, _) => generics.is_empty(),
+        UnresolvedTypeData::Expression(..) => true,
+        _ => false,
+    }
+}
+
+fn type_expr_to_type(lhs: UnresolvedTypeExpression, span: Span) -> UnresolvedType {
+    let lhs = UnresolvedTypeData::Expression(lhs);
+    UnresolvedType { typ: lhs, span }
+}
+
+#[cfg(test)]
+mod tests {
+    use core::panic;
+
+    use crate::{
+        ast::{UnresolvedType, UnresolvedTypeData, UnresolvedTypeExpression},
+        parser::{
+            parser::tests::{
+                expect_no_errors, get_single_error_reason, get_source_with_error_span,
+            },
+            Parser, ParserErrorReason,
+        },
+        token::Token,
+        BinaryTypeOperator,
+    };
+
+    fn parse_type_expression_no_errors(src: &str) -> UnresolvedTypeExpression {
+        let mut parser = Parser::for_str(src);
+        let expr = parser.parse_type_expression().unwrap();
+        expect_no_errors(&parser.errors);
+        expr
+    }
+
+    fn parse_type_or_type_expression_no_errors(src: &str) -> UnresolvedType {
+        let mut parser = Parser::for_str(src);
+        let typ = parser.parse_type_or_type_expression().unwrap();
+        expect_no_errors(&parser.errors);
+        typ
+    }
+
+    #[test]
+    fn parses_constant_type_expression() {
+        let src = "42";
+        let expr = parse_type_expression_no_errors(src);
+        let UnresolvedTypeExpression::Constant(n, _) = expr else {
+            panic!("Expected constant");
+        };
+        assert_eq!(n, 42_u32.into());
+    }
+
+    #[test]
+    fn parses_variable_type_expression() {
+        let src = "foo::bar";
+        let expr = parse_type_expression_no_errors(src);
+        let UnresolvedTypeExpression::Variable(path) = expr else {
+            panic!("Expected path");
+        };
+        assert_eq!(path.to_string(), "foo::bar");
+    }
+
+    #[test]
+    fn parses_binary_type_expression() {
+        let src = "1 + 2 * 3 + 4";
+        let expr = parse_type_expression_no_errors(src);
+        let UnresolvedTypeExpression::BinaryOperation(lhs, operator, rhs, _) = expr else {
+            panic!("Expected binary operation");
+        };
+        assert_eq!(lhs.to_string(), "(1 + (2 * 3))");
+        assert_eq!(operator, BinaryTypeOperator::Addition);
+        assert_eq!(rhs.to_string(), "4");
+    }
+
+    #[test]
+    fn parses_parenthesized_type_expression() {
+        let src = "(N)";
+        let expr = parse_type_expression_no_errors(src);
+        let UnresolvedTypeExpression::Variable(path) = expr else {
+            panic!("Expected variable");
+        };
+        assert_eq!(path.to_string(), "N");
+    }
+
+    #[test]
+    fn parses_minus_type_expression() {
+        let src = "-N";
+        let expr = parse_type_expression_no_errors(src);
+        assert_eq!(expr.to_string(), "(0 - N)");
+    }
+
+    #[test]
+    fn parse_type_or_type_expression_constant() {
+        let src = "42";
+        let typ = parse_type_or_type_expression_no_errors(src);
+        let UnresolvedTypeData::Expression(expr) = typ.typ else {
+            panic!("Expected expression");
+        };
+        let UnresolvedTypeExpression::Constant(n, _) = expr else {
+            panic!("Expected constant");
+        };
+        assert_eq!(n, 42_u32.into());
+    }
+
+    #[test]
+    fn parse_type_or_type_expression_variable() {
+        let src = "foo::Bar";
+        let typ = parse_type_or_type_expression_no_errors(src);
+        let UnresolvedTypeData::Named(path, generics, _) = typ.typ else {
+            panic!("Expected named type");
+        };
+        assert_eq!(path.to_string(), "foo::Bar");
+        assert!(generics.is_empty());
+    }
+
+    #[test]
+    fn parses_type_or_type_expression_binary() {
+        let src = "1 + 2 * 3 + 4";
+        let typ = parse_type_or_type_expression_no_errors(src);
+        let UnresolvedTypeData::Expression(expr) = typ.typ else {
+            panic!("Expected expression");
+        };
+        let UnresolvedTypeExpression::BinaryOperation(lhs, operator, rhs, _) = expr else {
+            panic!("Expected binary operation");
+        };
+        assert_eq!(lhs.to_string(), "(1 + (2 * 3))");
+        assert_eq!(operator, BinaryTypeOperator::Addition);
+        assert_eq!(rhs.to_string(), "4");
+    }
+
+    #[test]
+    fn parses_type_or_type_expression_minus() {
+        let src = "-N";
+        let typ = parse_type_or_type_expression_no_errors(src);
+        let UnresolvedTypeData::Expression(expr) = typ.typ else {
+            panic!("Expected expression");
+        };
+        assert_eq!(expr.to_string(), "(0 - N)");
+    }
+
+    #[test]
+    fn parses_type_or_type_expression_unit() {
+        let src = "()";
+        let typ = parse_type_or_type_expression_no_errors(src);
+        let UnresolvedTypeData::Unit = typ.typ else {
+            panic!("Expected unit type");
+        };
+    }
+
+    #[test]
+    fn parses_type_or_type_expression_parenthesized_type() {
+        let src = "(Field)";
+        let typ = parse_type_or_type_expression_no_errors(src);
+        let UnresolvedTypeData::Parenthesized(typ) = typ.typ else {
+            panic!("Expected parenthesized type");
+        };
+        let UnresolvedTypeData::FieldElement = typ.typ else {
+            panic!("Expected field type");
+        };
+    }
+
+    #[test]
+    fn parses_type_or_type_expression_parenthesized_constant() {
+        let src = "(1)";
+        let typ = parse_type_or_type_expression_no_errors(src);
+        let UnresolvedTypeData::Expression(expr) = typ.typ else {
+            panic!("Expected expression type");
+        };
+        assert_eq!(expr.to_string(), "1");
+    }
+
+    #[test]
+    fn parses_type_or_type_expression_tuple_type() {
+        let src = "(Field, bool)";
+        let typ = parse_type_or_type_expression_no_errors(src);
+        let UnresolvedTypeData::Tuple(types) = typ.typ else {
+            panic!("Expected tuple type");
+        };
+        let UnresolvedTypeData::FieldElement = types[0].typ else {
+            panic!("Expected field type");
+        };
+        let UnresolvedTypeData::Bool = types[1].typ else {
+            panic!("Expected bool type");
+        };
+    }
+
+    #[test]
+    fn parses_type_or_type_expression_tuple_type_missing_comma() {
+        let src = "
+        (Field bool)
+               ^^^^
+        ";
+        let (src, span) = get_source_with_error_span(src);
+        let mut parser = Parser::for_str(&src);
+
+        let typ = parser.parse_type_or_type_expression().unwrap();
+
+        let reason = get_single_error_reason(&parser.errors, span);
+        let ParserErrorReason::ExpectedTokenSeparatingTwoItems { token, items } = reason else {
+            panic!("Expected a different error");
+        };
+        assert_eq!(token, &Token::Comma);
+        assert_eq!(*items, "tuple items");
+
+        let UnresolvedTypeData::Tuple(types) = typ.typ else {
+            panic!("Expected tuple type");
+        };
+        let UnresolvedTypeData::FieldElement = types[0].typ else {
+            panic!("Expected field type");
+        };
+        let UnresolvedTypeData::Bool = types[1].typ else {
+            panic!("Expected bool type");
+        };
+    }
+
+    #[test]
+    fn parses_type_or_type_expression_tuple_type_single_element() {
+        let src = "(Field,)";
+        let mut parser = Parser::for_str(src);
+        let typ = parser.parse_type_or_type_expression().unwrap();
+        expect_no_errors(&parser.errors);
+        let UnresolvedTypeData::Tuple(types) = typ.typ else {
+            panic!("Expected tuple type");
+        };
+        assert_eq!(types.len(), 1);
+        let UnresolvedTypeData::FieldElement = types[0].typ else {
+            panic!("Expected field type");
+        };
+    }
+
+    #[test]
+    fn parses_type_or_type_expression_var_minus_one() {
+        let src = "N - 1";
+        let typ = parse_type_or_type_expression_no_errors(src);
+        let UnresolvedTypeData::Expression(expr) = typ.typ else {
+            panic!("Expected expression type");
+        };
+        assert_eq!(expr.to_string(), "(N - 1)");
+    }
+}
diff --git a/compiler/noirc_frontend/src/parser/parser/types.rs b/compiler/noirc_frontend/src/parser/parser/types.rs
index 9dd41d1a288..884db763698 100644
--- a/compiler/noirc_frontend/src/parser/parser/types.rs
+++ b/compiler/noirc_frontend/src/parser/parser/types.rs
@@ -1,412 +1,694 @@
-use super::path::{as_trait_path, path_no_turbofish};
-use super::primitives::{ident, token_kind};
-use super::{
-    expression_with_precedence, keyword, nothing, parenthesized, NoirParser, ParserError,
-    ParserErrorReason, Precedence,
-};
-use crate::ast::{
-    Expression, GenericTypeArg, GenericTypeArgs, Recoverable, UnresolvedType, UnresolvedTypeData,
-    UnresolvedTypeExpression,
+use acvm::{AcirField, FieldElement};
+
+use crate::{
+    ast::{UnresolvedType, UnresolvedTypeData, UnresolvedTypeExpression},
+    parser::{labels::ParsingRuleLabel, ParserErrorReason},
+    token::{Keyword, Token, TokenKind},
+    QuotedType,
 };
-use crate::QuotedType;
 
-use crate::parser::labels::ParsingRuleLabel;
-use crate::token::{Keyword, Token, TokenKind};
+use super::{parse_many::separated_by_comma_until_right_paren, Parser};
 
-use chumsky::prelude::*;
-use noirc_errors::Span;
+impl<'a> Parser<'a> {
+    pub(crate) fn parse_type_or_error(&mut self) -> UnresolvedType {
+        if let Some(typ) = self.parse_type() {
+            typ
+        } else {
+            self.expected_label(ParsingRuleLabel::Type);
+            UnresolvedTypeData::Error.with_span(self.span_at_previous_token_end())
+        }
+    }
 
-pub fn parse_type<'a>() -> impl NoirParser<UnresolvedType> + 'a {
-    recursive(parse_type_inner)
-}
+    pub(crate) fn parse_type(&mut self) -> Option<UnresolvedType> {
+        let start_span = self.current_token_span;
+        let typ = self.parse_unresolved_type_data()?;
+        let span = self.span_since(start_span);
+        Some(UnresolvedType { typ, span })
+    }
 
-pub(super) fn parse_type_inner<'a>(
-    recursive_type_parser: impl NoirParser<UnresolvedType> + 'a,
-) -> impl NoirParser<UnresolvedType> + 'a {
-    choice((
-        primitive_type(),
-        format_string_type(recursive_type_parser.clone()),
-        named_type(recursive_type_parser.clone()),
-        named_trait(recursive_type_parser.clone()),
-        slice_type(recursive_type_parser.clone()),
-        array_type(recursive_type_parser.clone()),
-        parenthesized_type(recursive_type_parser.clone()),
-        tuple_type(recursive_type_parser.clone()),
-        function_type(recursive_type_parser.clone()),
-        mutable_reference_type(recursive_type_parser.clone()),
-        as_trait_path_type(recursive_type_parser),
-    ))
-}
+    fn parse_unresolved_type_data(&mut self) -> Option<UnresolvedTypeData> {
+        if let Some(typ) = self.parse_primitive_type() {
+            return Some(typ);
+        }
 
-pub(super) fn primitive_type() -> impl NoirParser<UnresolvedType> {
-    choice((
-        field_type(),
-        int_type(),
-        bool_type(),
-        string_type(),
-        comptime_type(),
-        resolved_type(),
-        interned_unresolved_type(),
-    ))
-}
+        if let Some(typ) = self.parse_parentheses_type() {
+            return Some(typ);
+        }
 
-fn as_trait_path_type<'a>(
-    type_parser: impl NoirParser<UnresolvedType> + 'a,
-) -> impl NoirParser<UnresolvedType> + 'a {
-    as_trait_path(type_parser)
-        .map_with_span(|path, span| UnresolvedTypeData::AsTraitPath(Box::new(path)).with_span(span))
-}
+        if let Some(typ) = self.parse_array_or_slice_type() {
+            return Some(typ);
+        }
 
-pub(super) fn parenthesized_type(
-    recursive_type_parser: impl NoirParser<UnresolvedType>,
-) -> impl NoirParser<UnresolvedType> {
-    recursive_type_parser
-        .delimited_by(just(Token::LeftParen), just(Token::RightParen))
-        .map_with_span(|typ, span| UnresolvedType {
-            typ: UnresolvedTypeData::Parenthesized(Box::new(typ)),
-            span,
-        })
-}
+        if let Some(typ) = self.parses_mutable_reference_type() {
+            return Some(typ);
+        }
 
-pub(super) fn maybe_comp_time() -> impl NoirParser<bool> {
-    keyword(Keyword::Comptime).or_not().map(|opt| opt.is_some())
-}
+        if let Some(typ) = self.parse_function_type() {
+            return Some(typ);
+        }
 
-pub(super) fn field_type() -> impl NoirParser<UnresolvedType> {
-    keyword(Keyword::Field)
-        .map_with_span(|_, span| UnresolvedTypeData::FieldElement.with_span(span))
-}
+        if let Some(typ) = self.parse_trait_as_type() {
+            return Some(typ);
+        }
 
-pub(super) fn bool_type() -> impl NoirParser<UnresolvedType> {
-    keyword(Keyword::Bool).map_with_span(|_, span| UnresolvedTypeData::Bool.with_span(span))
-}
+        if let Some(typ) = self.parse_as_trait_path_type() {
+            return Some(typ);
+        }
 
-pub(super) fn comptime_type() -> impl NoirParser<UnresolvedType> {
-    choice((
-        expr_type(),
-        struct_definition_type(),
-        trait_constraint_type(),
-        trait_definition_type(),
-        trait_impl_type(),
-        unresolved_type_type(),
-        function_definition_type(),
-        module_type(),
-        type_of_quoted_types(),
-        top_level_item_type(),
-        quoted_type(),
-        typed_expr_type(),
-        comptime_string_type(),
-    ))
-}
+        if let Some(path) = self.parse_path_no_turbofish() {
+            let generics = self.parse_generic_type_args();
+            return Some(UnresolvedTypeData::Named(path, generics, false));
+        }
 
-/// This is the type `Expr` - the type of a quoted, untyped expression object used for macros
-pub(super) fn expr_type() -> impl NoirParser<UnresolvedType> {
-    keyword(Keyword::Expr)
-        .map_with_span(|_, span| UnresolvedTypeData::Quoted(QuotedType::Expr).with_span(span))
-}
+        None
+    }
 
-/// This is the type `StructDefinition` - the type of a quoted struct definition
-pub(super) fn struct_definition_type() -> impl NoirParser<UnresolvedType> {
-    keyword(Keyword::StructDefinition).map_with_span(|_, span| {
-        UnresolvedTypeData::Quoted(QuotedType::StructDefinition).with_span(span)
-    })
-}
+    pub(super) fn parse_primitive_type(&mut self) -> Option<UnresolvedTypeData> {
+        if let Some(typ) = self.parse_field_type() {
+            return Some(typ);
+        }
 
-/// This is the type `TraitConstraint` - the type of a quoted trait constraint
-pub(super) fn trait_constraint_type() -> impl NoirParser<UnresolvedType> {
-    keyword(Keyword::TraitConstraint).map_with_span(|_, span| {
-        UnresolvedTypeData::Quoted(QuotedType::TraitConstraint).with_span(span)
-    })
-}
+        if let Some(typ) = self.parse_int_type() {
+            return Some(typ);
+        }
 
-pub(super) fn trait_definition_type() -> impl NoirParser<UnresolvedType> {
-    keyword(Keyword::TraitDefinition).map_with_span(|_, span| {
-        UnresolvedTypeData::Quoted(QuotedType::TraitDefinition).with_span(span)
-    })
-}
+        if let Some(typ) = self.parse_bool_type() {
+            return Some(typ);
+        }
 
-pub(super) fn trait_impl_type() -> impl NoirParser<UnresolvedType> {
-    keyword(Keyword::TraitImpl)
-        .map_with_span(|_, span| UnresolvedTypeData::Quoted(QuotedType::TraitImpl).with_span(span))
-}
+        if let Some(typ) = self.parse_str_type() {
+            return Some(typ);
+        }
 
-pub(super) fn unresolved_type_type() -> impl NoirParser<UnresolvedType> {
-    keyword(Keyword::UnresolvedType).map_with_span(|_, span| {
-        UnresolvedTypeData::Quoted(QuotedType::UnresolvedType).with_span(span)
-    })
-}
+        if let Some(typ) = self.parse_fmtstr_type() {
+            return Some(typ);
+        }
 
-pub(super) fn function_definition_type() -> impl NoirParser<UnresolvedType> {
-    keyword(Keyword::FunctionDefinition).map_with_span(|_, span| {
-        UnresolvedTypeData::Quoted(QuotedType::FunctionDefinition).with_span(span)
-    })
-}
+        if let Some(typ) = self.parse_comptime_type() {
+            return Some(typ);
+        }
 
-pub(super) fn module_type() -> impl NoirParser<UnresolvedType> {
-    keyword(Keyword::Module)
-        .map_with_span(|_, span| UnresolvedTypeData::Quoted(QuotedType::Module).with_span(span))
-}
+        if let Some(typ) = self.parse_resolved_type() {
+            return Some(typ);
+        }
 
-/// This is the type `TopLevelItem` - the type of a quoted statement in the top level.
-/// E.g. a type definition, trait definition, trait impl, function, etc.
-fn top_level_item_type() -> impl NoirParser<UnresolvedType> {
-    keyword(Keyword::TopLevelItem).map_with_span(|_, span| {
-        UnresolvedTypeData::Quoted(QuotedType::TopLevelItem).with_span(span)
-    })
-}
+        if let Some(typ) = self.parse_interned_type() {
+            return Some(typ);
+        }
 
-/// This is the type `Type` - the type of a quoted noir type.
-fn type_of_quoted_types() -> impl NoirParser<UnresolvedType> {
-    keyword(Keyword::TypeType)
-        .map_with_span(|_, span| UnresolvedTypeData::Quoted(QuotedType::Type).with_span(span))
-}
+        None
+    }
 
-/// This is the type of a quoted, unparsed token stream.
-fn quoted_type() -> impl NoirParser<UnresolvedType> {
-    keyword(Keyword::Quoted)
-        .map_with_span(|_, span| UnresolvedTypeData::Quoted(QuotedType::Quoted).with_span(span))
-}
+    fn parse_bool_type(&mut self) -> Option<UnresolvedTypeData> {
+        if self.eat_keyword(Keyword::Bool) {
+            return Some(UnresolvedTypeData::Bool);
+        }
 
-/// This is the type of a typed/resolved expression.
-fn typed_expr_type() -> impl NoirParser<UnresolvedType> {
-    keyword(Keyword::TypedExpr)
-        .map_with_span(|_, span| UnresolvedTypeData::Quoted(QuotedType::TypedExpr).with_span(span))
-}
+        None
+    }
 
-/// This is the `CtString` type for dynamically-sized compile-time strings
-fn comptime_string_type() -> impl NoirParser<UnresolvedType> {
-    keyword(Keyword::CtString)
-        .map_with_span(|_, span| UnresolvedTypeData::Quoted(QuotedType::CtString).with_span(span))
-}
+    fn parse_field_type(&mut self) -> Option<UnresolvedTypeData> {
+        if self.eat_keyword(Keyword::Field) {
+            return Some(UnresolvedTypeData::FieldElement);
+        }
 
-/// This is the type of an already resolved type.
-/// The only way this can appear in the token input is if an already resolved `Type` object
-/// was spliced into a macro's token stream via the `$` operator.
-pub(super) fn resolved_type() -> impl NoirParser<UnresolvedType> {
-    token_kind(TokenKind::QuotedType).map_with_span(|token, span| match token {
-        Token::QuotedType(id) => UnresolvedTypeData::Resolved(id).with_span(span),
-        _ => unreachable!("token_kind(QuotedType) guarantees we parse a quoted type"),
-    })
-}
+        None
+    }
 
-pub(super) fn interned_unresolved_type() -> impl NoirParser<UnresolvedType> {
-    token_kind(TokenKind::InternedUnresolvedTypeData).map_with_span(|token, span| match token {
-        Token::InternedUnresolvedTypeData(id) => UnresolvedTypeData::Interned(id).with_span(span),
-        _ => unreachable!(
-            "token_kind(InternedUnresolvedTypeData) guarantees we parse an interned unresolved type"
-        ),
-    })
-}
+    fn parse_int_type(&mut self) -> Option<UnresolvedTypeData> {
+        if let Some(int_type) = self.eat_int_type() {
+            return Some(match UnresolvedTypeData::from_int_token(int_type) {
+                Ok(typ) => typ,
+                Err(err) => {
+                    self.push_error(
+                        ParserErrorReason::InvalidBitSize(err.0),
+                        self.previous_token_span,
+                    );
+                    UnresolvedTypeData::Error
+                }
+            });
+        }
 
-pub(super) fn string_type() -> impl NoirParser<UnresolvedType> {
-    keyword(Keyword::String)
-        .ignore_then(type_expression().delimited_by(just(Token::Less), just(Token::Greater)))
-        .map_with_span(|expr, span| UnresolvedTypeData::String(expr).with_span(span))
-}
+        None
+    }
 
-pub(super) fn format_string_type<'a>(
-    type_parser: impl NoirParser<UnresolvedType> + 'a,
-) -> impl NoirParser<UnresolvedType> + 'a {
-    keyword(Keyword::FormatString)
-        .ignore_then(
-            type_expression()
-                .then_ignore(just(Token::Comma))
-                .then(type_parser)
-                .delimited_by(just(Token::Less), just(Token::Greater)),
-        )
-        .map_with_span(|(size, fields), span| {
-            UnresolvedTypeData::FormatString(size, Box::new(fields)).with_span(span)
-        })
-}
+    fn parse_str_type(&mut self) -> Option<UnresolvedTypeData> {
+        if !self.eat_keyword(Keyword::String) {
+            return None;
+        }
 
-pub(super) fn int_type() -> impl NoirParser<UnresolvedType> {
-    filter_map(|span, token: Token| match token {
-        Token::IntType(int_type) => Ok(int_type),
-        unexpected => {
-            Err(ParserError::expected_label(ParsingRuleLabel::IntegerType, unexpected, span))
-        }
-    })
-    .validate(|token, span, emit| {
-        UnresolvedTypeData::from_int_token(token).map(|data| data.with_span(span)).unwrap_or_else(
-            |err| {
-                emit(ParserError::with_reason(ParserErrorReason::InvalidBitSize(err.0), span));
-                UnresolvedType::error(span)
-            },
-        )
-    })
-}
+        if !self.eat_less() {
+            self.expected_token(Token::Less);
+            let expr =
+                UnresolvedTypeExpression::Constant(FieldElement::zero(), self.current_token_span);
+            return Some(UnresolvedTypeData::String(expr));
+        }
 
-pub(super) fn named_type<'a>(
-    type_parser: impl NoirParser<UnresolvedType> + 'a,
-) -> impl NoirParser<UnresolvedType> + 'a {
-    path_no_turbofish().then(generic_type_args(type_parser)).map_with_span(|(path, args), span| {
-        UnresolvedTypeData::Named(path, args, false).with_span(span)
-    })
-}
+        let expr = match self.parse_type_expression() {
+            Ok(expr) => expr,
+            Err(error) => {
+                self.errors.push(error);
+                UnresolvedTypeExpression::Constant(FieldElement::zero(), self.current_token_span)
+            }
+        };
 
-pub(super) fn named_trait<'a>(
-    type_parser: impl NoirParser<UnresolvedType> + 'a,
-) -> impl NoirParser<UnresolvedType> + 'a {
-    keyword(Keyword::Impl)
-        .ignore_then(path_no_turbofish())
-        .then(generic_type_args(type_parser))
-        .map_with_span(|(path, args), span| {
-            UnresolvedTypeData::TraitAsType(path, args).with_span(span)
-        })
-}
+        self.eat_or_error(Token::Greater);
 
-pub(super) fn generic_type_args<'a>(
-    type_parser: impl NoirParser<UnresolvedType> + 'a,
-) -> impl NoirParser<GenericTypeArgs> + 'a {
-    required_generic_type_args(type_parser).or_not().map(Option::unwrap_or_default)
-}
+        Some(UnresolvedTypeData::String(expr))
+    }
 
-pub(super) fn required_generic_type_args<'a>(
-    type_parser: impl NoirParser<UnresolvedType> + 'a,
-) -> impl NoirParser<GenericTypeArgs> + 'a {
-    let generic_type_arg = type_parser
-        .clone()
-        .then_ignore(one_of([Token::Comma, Token::Greater]).rewind())
-        .or(type_expression_validated());
-
-    let named_arg = ident()
-        .then_ignore(just(Token::Assign))
-        .then(generic_type_arg.clone())
-        .map(|(name, typ)| GenericTypeArg::Named(name, typ));
-
-    // We need to parse named arguments first since otherwise when we see
-    // `Foo = Bar`, just `Foo` is a valid type, and we'd parse an ordered
-    // generic before erroring that an `=` is invalid after an ordered generic.
-    choice((named_arg, generic_type_arg.map(GenericTypeArg::Ordered)))
-        .boxed()
-        // Without checking for a terminating ',' or '>' here we may incorrectly
-        // parse a generic `N * 2` as just the type `N` then fail when there is no
-        // separator afterward. Failing early here ensures we try the `type_expression`
-        // parser afterward.
-        .separated_by(just(Token::Comma))
-        .allow_trailing()
-        .at_least(1)
-        .delimited_by(just(Token::Less), just(Token::Greater))
-        .map(GenericTypeArgs::from)
-}
+    fn parse_fmtstr_type(&mut self) -> Option<UnresolvedTypeData> {
+        if !self.eat_keyword(Keyword::FormatString) {
+            return None;
+        }
 
-pub(super) fn array_type<'a>(
-    type_parser: impl NoirParser<UnresolvedType> + 'a,
-) -> impl NoirParser<UnresolvedType> + 'a {
-    just(Token::LeftBracket)
-        .ignore_then(type_parser)
-        .then(just(Token::Semicolon).ignore_then(type_expression()))
-        .then_ignore(just(Token::RightBracket))
-        .map_with_span(|(element_type, size), span| {
-            UnresolvedTypeData::Array(size, Box::new(element_type)).with_span(span)
-        })
-}
+        if !self.eat_less() {
+            self.expected_token(Token::Less);
+            let expr =
+                UnresolvedTypeExpression::Constant(FieldElement::zero(), self.current_token_span);
+            let typ = UnresolvedTypeData::Error.with_span(self.span_at_previous_token_end());
+            return Some(UnresolvedTypeData::FormatString(expr, Box::new(typ)));
+        }
 
-pub(super) fn slice_type(
-    type_parser: impl NoirParser<UnresolvedType>,
-) -> impl NoirParser<UnresolvedType> {
-    just(Token::LeftBracket)
-        .ignore_then(type_parser)
-        .then_ignore(just(Token::RightBracket))
-        .map_with_span(|element_type, span| {
-            UnresolvedTypeData::Slice(Box::new(element_type)).with_span(span)
-        })
-}
+        let expr = match self.parse_type_expression() {
+            Ok(expr) => expr,
+            Err(error) => {
+                self.errors.push(error);
+                UnresolvedTypeExpression::Constant(FieldElement::zero(), self.current_token_span)
+            }
+        };
 
-fn type_expression() -> impl NoirParser<UnresolvedTypeExpression> {
-    type_expression_inner().try_map(UnresolvedTypeExpression::from_expr)
-}
+        if !self.eat_commas() {
+            self.expected_token(Token::Comma);
+        }
+
+        let typ = self.parse_type_or_error();
+
+        self.eat_or_error(Token::Greater);
+
+        Some(UnresolvedTypeData::FormatString(expr, Box::new(typ)))
+    }
 
-/// This parser is the same as `type_expression()`, however, it continues parsing and
-/// emits a parser error in the case of an invalid type expression rather than halting the parser.
-pub(super) fn type_expression_validated() -> impl NoirParser<UnresolvedType> {
-    type_expression_inner().validate(|expr, span, emit| {
-        let type_expr = UnresolvedTypeExpression::from_expr(expr, span);
-        match type_expr {
-            Ok(type_expression) => UnresolvedTypeData::Expression(type_expression).with_span(span),
-            Err(parser_error) => {
-                emit(parser_error);
-                UnresolvedType::error(span)
+    fn parse_comptime_type(&mut self) -> Option<UnresolvedTypeData> {
+        if self.eat_keyword(Keyword::Expr) {
+            return Some(UnresolvedTypeData::Quoted(QuotedType::Expr));
+        }
+        if self.eat_keyword(Keyword::Quoted) {
+            return Some(UnresolvedTypeData::Quoted(QuotedType::Quoted));
+        }
+        if self.eat_keyword(Keyword::TopLevelItem) {
+            return Some(UnresolvedTypeData::Quoted(QuotedType::TopLevelItem));
+        }
+        if self.eat_keyword(Keyword::TypeType) {
+            return Some(UnresolvedTypeData::Quoted(QuotedType::Type));
+        }
+        if self.eat_keyword(Keyword::TypedExpr) {
+            return Some(UnresolvedTypeData::Quoted(QuotedType::TypedExpr));
+        }
+        if self.eat_keyword(Keyword::StructDefinition) {
+            return Some(UnresolvedTypeData::Quoted(QuotedType::StructDefinition));
+        }
+        if self.eat_keyword(Keyword::TraitConstraint) {
+            return Some(UnresolvedTypeData::Quoted(QuotedType::TraitConstraint));
+        }
+        if self.eat_keyword(Keyword::TraitDefinition) {
+            return Some(UnresolvedTypeData::Quoted(QuotedType::TraitDefinition));
+        }
+        if self.eat_keyword(Keyword::TraitImpl) {
+            return Some(UnresolvedTypeData::Quoted(QuotedType::TraitImpl));
+        }
+        if self.eat_keyword(Keyword::UnresolvedType) {
+            return Some(UnresolvedTypeData::Quoted(QuotedType::UnresolvedType));
+        }
+        if self.eat_keyword(Keyword::FunctionDefinition) {
+            return Some(UnresolvedTypeData::Quoted(QuotedType::FunctionDefinition));
+        }
+        if self.eat_keyword(Keyword::Module) {
+            return Some(UnresolvedTypeData::Quoted(QuotedType::Module));
+        }
+        if self.eat_keyword(Keyword::CtString) {
+            return Some(UnresolvedTypeData::Quoted(QuotedType::CtString));
+        }
+        None
+    }
+
+    fn parse_function_type(&mut self) -> Option<UnresolvedTypeData> {
+        let unconstrained = self.eat_keyword(Keyword::Unconstrained);
+
+        if !self.eat_keyword(Keyword::Fn) {
+            if unconstrained {
+                self.expected_token(Token::Keyword(Keyword::Fn));
+                return Some(UnresolvedTypeData::Function(
+                    Vec::new(),
+                    Box::new(self.unspecified_type_at_previous_token_end()),
+                    Box::new(self.unspecified_type_at_previous_token_end()),
+                    unconstrained,
+                ));
             }
+
+            return None;
         }
-    })
-}
 
-fn type_expression_inner() -> impl NoirParser<Expression> {
-    recursive(|expr| {
-        expression_with_precedence(
-            Precedence::lowest_type_precedence(),
-            expr,
-            nothing(),
-            nothing(),
-            true,
-            false,
-        )
-    })
-    .labelled(ParsingRuleLabel::TypeExpression)
-}
+        let env = if self.eat_left_bracket() {
+            let typ = self.parse_type_or_error();
+            self.eat_or_error(Token::RightBracket);
+            typ
+        } else {
+            UnresolvedTypeData::Unit.with_span(self.span_at_previous_token_end())
+        };
+
+        if !self.eat_left_paren() {
+            self.expected_token(Token::LeftParen);
+
+            return Some(UnresolvedTypeData::Function(
+                Vec::new(),
+                Box::new(self.unspecified_type_at_previous_token_end()),
+                Box::new(self.unspecified_type_at_previous_token_end()),
+                unconstrained,
+            ));
+        }
 
-pub(super) fn tuple_type<T>(type_parser: T) -> impl NoirParser<UnresolvedType>
-where
-    T: NoirParser<UnresolvedType>,
-{
-    let fields = type_parser.separated_by(just(Token::Comma)).allow_trailing();
-    parenthesized(fields).map_with_span(|fields, span| {
-        if fields.is_empty() {
-            UnresolvedTypeData::Unit.with_span(span)
+        let args = self.parse_many(
+            "parameters",
+            separated_by_comma_until_right_paren(),
+            Self::parse_parameter,
+        );
+
+        let ret = if self.eat(Token::Arrow) {
+            self.parse_type_or_error()
         } else {
-            UnresolvedTypeData::Tuple(fields).with_span(span)
+            self.expected_token(Token::Arrow);
+            UnresolvedTypeData::Unit.with_span(self.span_at_previous_token_end())
+        };
+
+        Some(UnresolvedTypeData::Function(args, Box::new(ret), Box::new(env), unconstrained))
+    }
+
+    fn parse_parameter(&mut self) -> Option<UnresolvedType> {
+        let typ = self.parse_type_or_error();
+        if let UnresolvedTypeData::Error = typ.typ {
+            None
+        } else {
+            Some(typ)
         }
-    })
-}
+    }
 
-pub(super) fn function_type<T>(type_parser: T) -> impl NoirParser<UnresolvedType>
-where
-    T: NoirParser<UnresolvedType>,
-{
-    let args = parenthesized(type_parser.clone().separated_by(just(Token::Comma)).allow_trailing());
-
-    let env = just(Token::LeftBracket)
-        .ignore_then(type_parser.clone())
-        .then_ignore(just(Token::RightBracket))
-        .or_not()
-        .map_with_span(|t, span| {
-            t.unwrap_or_else(|| UnresolvedTypeData::Unit.with_span(Span::empty(span.end())))
-        });
-
-    keyword(Keyword::Unconstrained)
-        .or_not()
-        .then(keyword(Keyword::Fn))
-        .map(|(unconstrained_token, _fn_token)| unconstrained_token.is_some())
-        .then(env)
-        .then(args)
-        .then_ignore(just(Token::Arrow))
-        .then(type_parser)
-        .map_with_span(|(((unconstrained, env), args), ret), span| {
-            UnresolvedTypeData::Function(args, Box::new(ret), Box::new(env), unconstrained)
-                .with_span(span)
-        })
-}
+    fn parse_trait_as_type(&mut self) -> Option<UnresolvedTypeData> {
+        if !self.eat_keyword(Keyword::Impl) {
+            return None;
+        }
+
+        let Some(path) = self.parse_path_no_turbofish() else {
+            self.expected_label(ParsingRuleLabel::Path);
+            return None;
+        };
+
+        let generics = self.parse_generic_type_args();
+
+        Some(UnresolvedTypeData::TraitAsType(path, generics))
+    }
 
-pub(super) fn mutable_reference_type<T>(type_parser: T) -> impl NoirParser<UnresolvedType>
-where
-    T: NoirParser<UnresolvedType>,
-{
-    just(Token::Ampersand)
-        .ignore_then(keyword(Keyword::Mut))
-        .ignore_then(type_parser)
-        .map_with_span(|element, span| {
-            UnresolvedTypeData::MutableReference(Box::new(element)).with_span(span)
+    fn parse_as_trait_path_type(&mut self) -> Option<UnresolvedTypeData> {
+        let as_trait_path = self.parse_as_trait_path()?;
+        Some(UnresolvedTypeData::AsTraitPath(Box::new(as_trait_path)))
+    }
+
+    fn parse_resolved_type(&mut self) -> Option<UnresolvedTypeData> {
+        if let Some(token) = self.eat_kind(TokenKind::QuotedType) {
+            match token.into_token() {
+                Token::QuotedType(id) => {
+                    return Some(UnresolvedTypeData::Resolved(id));
+                }
+                _ => unreachable!(),
+            }
+        }
+
+        None
+    }
+
+    pub(super) fn parse_interned_type(&mut self) -> Option<UnresolvedTypeData> {
+        if let Some(token) = self.eat_kind(TokenKind::InternedUnresolvedTypeData) {
+            match token.into_token() {
+                Token::InternedUnresolvedTypeData(id) => {
+                    return Some(UnresolvedTypeData::Interned(id));
+                }
+                _ => unreachable!(),
+            }
+        }
+
+        None
+    }
+
+    fn parses_mutable_reference_type(&mut self) -> Option<UnresolvedTypeData> {
+        if self.eat(Token::Ampersand) {
+            if !self.eat_keyword(Keyword::Mut) {
+                self.expected_mut_after_ampersand();
+            }
+
+            return Some(UnresolvedTypeData::MutableReference(Box::new(
+                self.parse_type_or_error(),
+            )));
+        };
+
+        None
+    }
+
+    fn parse_array_or_slice_type(&mut self) -> Option<UnresolvedTypeData> {
+        if !self.eat_left_bracket() {
+            return None;
+        }
+
+        let typ = self.parse_type_or_error();
+
+        if self.eat_semicolon() {
+            match self.parse_type_expression() {
+                Ok(expr) => {
+                    self.eat_or_error(Token::RightBracket);
+                    Some(UnresolvedTypeData::Array(expr, Box::new(typ)))
+                }
+                Err(error) => {
+                    self.errors.push(error);
+                    self.eat_or_error(Token::RightBracket);
+                    Some(UnresolvedTypeData::Slice(Box::new(typ)))
+                }
+            }
+        } else {
+            self.eat_or_error(Token::RightBracket);
+            Some(UnresolvedTypeData::Slice(Box::new(typ)))
+        }
+    }
+
+    fn parse_parentheses_type(&mut self) -> Option<UnresolvedTypeData> {
+        if !self.eat_left_paren() {
+            return None;
+        }
+
+        if self.eat_right_paren() {
+            return Some(UnresolvedTypeData::Unit);
+        }
+
+        let (mut types, trailing_comma) = self.parse_many_return_trailing_separator_if_any(
+            "tuple elements",
+            separated_by_comma_until_right_paren(),
+            Self::parse_type_in_list,
+        );
+
+        Some(if types.len() == 1 && !trailing_comma {
+            UnresolvedTypeData::Parenthesized(Box::new(types.remove(0)))
+        } else {
+            UnresolvedTypeData::Tuple(types)
         })
+    }
+
+    pub(super) fn parse_type_in_list(&mut self) -> Option<UnresolvedType> {
+        if let Some(typ) = self.parse_type() {
+            Some(typ)
+        } else {
+            self.expected_label(ParsingRuleLabel::Type);
+            None
+        }
+    }
+
+    /// OptionalTypeAnnotation = ( ':' Type )?
+    pub(super) fn parse_optional_type_annotation(&mut self) -> UnresolvedType {
+        if self.eat_colon() {
+            self.parse_type_or_error()
+        } else {
+            self.unspecified_type_at_previous_token_end()
+        }
+    }
+
+    pub(super) fn unspecified_type_at_previous_token_end(&self) -> UnresolvedType {
+        UnresolvedTypeData::Unspecified.with_span(self.span_at_previous_token_end())
+    }
 }
 
 #[cfg(test)]
-mod test {
-    use super::*;
-    use crate::parser::parser::test_helpers::*;
+mod tests {
+    use strum::IntoEnumIterator;
+
+    use crate::{
+        ast::{IntegerBitSize, Signedness, UnresolvedType, UnresolvedTypeData},
+        parser::{
+            parser::tests::{expect_no_errors, get_single_error, get_source_with_error_span},
+            Parser,
+        },
+        QuotedType,
+    };
+
+    fn parse_type_no_errors(src: &str) -> UnresolvedType {
+        let mut parser = Parser::for_str(src);
+        let typ = parser.parse_type_or_error();
+        expect_no_errors(&parser.errors);
+        typ
+    }
+
+    #[test]
+    fn parses_unit_type() {
+        let src = "()";
+        let typ = parse_type_no_errors(src);
+        assert!(matches!(typ.typ, UnresolvedTypeData::Unit));
+    }
+
+    #[test]
+    fn parses_bool_type() {
+        let src = "bool";
+        let typ = parse_type_no_errors(src);
+        assert!(matches!(typ.typ, UnresolvedTypeData::Bool));
+    }
+
+    #[test]
+    fn parses_int_type() {
+        let src = "u32";
+        let typ = parse_type_no_errors(src);
+        assert!(matches!(
+            typ.typ,
+            UnresolvedTypeData::Integer(Signedness::Unsigned, IntegerBitSize::ThirtyTwo)
+        ));
+    }
+
+    #[test]
+    fn parses_field_type() {
+        let src = "Field";
+        let typ = parse_type_no_errors(src);
+        assert!(matches!(typ.typ, UnresolvedTypeData::FieldElement));
+    }
+
+    #[test]
+    fn parses_str_type() {
+        let src = "str<10>";
+        let typ = parse_type_no_errors(src);
+        let UnresolvedTypeData::String(expr) = typ.typ else { panic!("Expected a string type") };
+        assert_eq!(expr.to_string(), "10");
+    }
+
+    #[test]
+    fn parses_fmtstr_type() {
+        let src = "fmtstr<10, T>";
+        let typ = parse_type_no_errors(src);
+        let UnresolvedTypeData::FormatString(expr, typ) = typ.typ else {
+            panic!("Expected a format string type")
+        };
+        assert_eq!(expr.to_string(), "10");
+        assert_eq!(typ.to_string(), "T");
+    }
+
+    #[test]
+    fn parses_comptime_types() {
+        for quoted_type in QuotedType::iter() {
+            let src = quoted_type.to_string();
+            let typ = parse_type_no_errors(&src);
+            let UnresolvedTypeData::Quoted(parsed_qouted_type) = typ.typ else {
+                panic!("Expected a quoted type for {}", quoted_type)
+            };
+            assert_eq!(parsed_qouted_type, quoted_type);
+        }
+    }
+
+    #[test]
+    fn parses_tuple_type() {
+        let src = "(Field, bool)";
+        let typ = parse_type_no_errors(src);
+        let UnresolvedTypeData::Tuple(mut types) = typ.typ else { panic!("Expected a tuple type") };
+        assert_eq!(types.len(), 2);
+
+        let typ = types.remove(0);
+        assert!(matches!(typ.typ, UnresolvedTypeData::FieldElement));
+
+        let typ = types.remove(0);
+        assert!(matches!(typ.typ, UnresolvedTypeData::Bool));
+    }
+
+    #[test]
+    fn parses_tuple_type_one_element() {
+        let src = "(Field,)";
+        let typ = parse_type_no_errors(src);
+        let UnresolvedTypeData::Tuple(mut types) = typ.typ else { panic!("Expected a tuple type") };
+        assert_eq!(types.len(), 1);
+
+        let typ = types.remove(0);
+        assert!(matches!(typ.typ, UnresolvedTypeData::FieldElement));
+    }
+
+    #[test]
+    fn parses_parenthesized_type() {
+        let src = "(Field)";
+        let typ = parse_type_no_errors(src);
+        let UnresolvedTypeData::Parenthesized(typ) = typ.typ else {
+            panic!("Expected a parenthesized type")
+        };
+        assert!(matches!(typ.typ, UnresolvedTypeData::FieldElement));
+    }
+
+    #[test]
+    fn parses_unclosed_parentheses_type() {
+        let src = "(Field";
+        let mut parser = Parser::for_str(src);
+        let typ = parser.parse_type_or_error();
+        assert_eq!(parser.errors.len(), 1);
+        let UnresolvedTypeData::Parenthesized(typ) = typ.typ else {
+            panic!("Expected a parenthesized type")
+        };
+        assert!(matches!(typ.typ, UnresolvedTypeData::FieldElement));
+    }
+
+    #[test]
+    fn parses_mutable_reference_type() {
+        let src = "&mut Field";
+        let typ = parse_type_no_errors(src);
+        let UnresolvedTypeData::MutableReference(typ) = typ.typ else {
+            panic!("Expected a mutable reference type")
+        };
+        assert!(matches!(typ.typ, UnresolvedTypeData::FieldElement));
+    }
+
+    #[test]
+    fn parses_named_type_no_generics() {
+        let src = "foo::Bar";
+        let typ = parse_type_no_errors(src);
+        let UnresolvedTypeData::Named(path, generics, _) = typ.typ else {
+            panic!("Expected a named type")
+        };
+        assert_eq!(path.to_string(), "foo::Bar");
+        assert!(generics.is_empty());
+    }
+
+    #[test]
+    fn parses_slice_type() {
+        let src = "[Field]";
+        let typ = parse_type_no_errors(src);
+        let UnresolvedTypeData::Slice(typ) = typ.typ else { panic!("Expected a slice type") };
+        assert!(matches!(typ.typ, UnresolvedTypeData::FieldElement));
+    }
+
+    #[test]
+    fn errors_if_missing_right_bracket_after_slice_type() {
+        let src = "
+        [Field 
+              ^
+        ";
+        let (src, span) = get_source_with_error_span(src);
+        let mut parser = Parser::for_str(&src);
+        parser.parse_type();
+        let error = get_single_error(&parser.errors, span);
+        assert_eq!(error.to_string(), "Expected a ']' but found end of input");
+    }
+
+    #[test]
+    fn parses_array_type() {
+        let src = "[Field; 10]";
+        let typ = parse_type_no_errors(src);
+        let UnresolvedTypeData::Array(expr, typ) = typ.typ else {
+            panic!("Expected an array type")
+        };
+        assert!(matches!(typ.typ, UnresolvedTypeData::FieldElement));
+        assert_eq!(expr.to_string(), "10");
+    }
+
+    #[test]
+    fn parses_empty_function_type() {
+        let src = "fn() -> Field";
+        let typ = parse_type_no_errors(src);
+        let UnresolvedTypeData::Function(args, ret, env, unconstrained) = typ.typ else {
+            panic!("Expected a function type")
+        };
+        assert!(args.is_empty());
+        assert_eq!(ret.typ.to_string(), "Field");
+        assert!(matches!(env.typ, UnresolvedTypeData::Unit));
+        assert!(!unconstrained);
+    }
+
+    #[test]
+    fn parses_function_type_with_arguments() {
+        let src = "fn(Field, bool) -> Field";
+        let typ = parse_type_no_errors(src);
+        let UnresolvedTypeData::Function(args, _ret, _env, _unconstrained) = typ.typ else {
+            panic!("Expected a function type")
+        };
+        assert_eq!(args.len(), 2);
+        assert_eq!(args[0].typ.to_string(), "Field");
+        assert_eq!(args[1].typ.to_string(), "bool");
+    }
+
+    #[test]
+    fn parses_function_type_with_return_type() {
+        let src = "fn() -> Field";
+        let typ = parse_type_no_errors(src);
+        let UnresolvedTypeData::Function(_args, ret, _env, _unconstrained) = typ.typ else {
+            panic!("Expected a function type")
+        };
+        assert_eq!(ret.typ.to_string(), "Field");
+    }
+
+    #[test]
+    fn parses_function_type_with_env() {
+        let src = "fn[Field]() -> Field";
+        let typ = parse_type_no_errors(src);
+        let UnresolvedTypeData::Function(_args, _ret, env, _unconstrained) = typ.typ else {
+            panic!("Expected a function type")
+        };
+        assert_eq!(env.typ.to_string(), "Field");
+    }
+
+    #[test]
+    fn parses_unconstrained_function_type() {
+        let src = "unconstrained fn() -> Field";
+        let typ = parse_type_no_errors(src);
+        let UnresolvedTypeData::Function(_args, _ret, _env, unconstrained) = typ.typ else {
+            panic!("Expected a function type")
+        };
+        assert!(unconstrained);
+    }
+
+    #[test]
+    fn parses_function_type_with_colon_in_parameter() {
+        let src = "fn(value: T) -> Field";
+        let mut parser = Parser::for_str(src);
+        let _ = parser.parse_type_or_error();
+        assert!(!parser.errors.is_empty());
+    }
+
+    #[test]
+    fn parses_trait_as_type_no_generics() {
+        let src = "impl foo::Bar";
+        let typ = parse_type_no_errors(src);
+        let UnresolvedTypeData::TraitAsType(path, generics) = typ.typ else {
+            panic!("Expected trait as type")
+        };
+        assert_eq!(path.to_string(), "foo::Bar");
+        assert!(generics.is_empty());
+    }
 
     #[test]
-    fn parse_type_expression() {
-        parse_all(type_expression(), vec!["(123)", "123", "(1 + 1)", "(1 + (1))"]);
+    fn parses_as_trait_path() {
+        let src = "<Field as foo::Bar>::baz";
+        let typ = parse_type_no_errors(src);
+        let UnresolvedTypeData::AsTraitPath(as_trait_path) = typ.typ else {
+            panic!("Expected as_trait_path")
+        };
+        assert_eq!(as_trait_path.typ.typ.to_string(), "Field");
+        assert_eq!(as_trait_path.trait_path.to_string(), "foo::Bar");
+        assert!(as_trait_path.trait_generics.is_empty());
+        assert_eq!(as_trait_path.impl_item.to_string(), "baz");
     }
 }
diff --git a/compiler/noirc_frontend/src/parser/parser/use_tree.rs b/compiler/noirc_frontend/src/parser/parser/use_tree.rs
new file mode 100644
index 00000000000..08834383f99
--- /dev/null
+++ b/compiler/noirc_frontend/src/parser/parser/use_tree.rs
@@ -0,0 +1,294 @@
+use noirc_errors::Span;
+
+use crate::{
+    ast::{Ident, Path, PathKind, UseTree, UseTreeKind},
+    parser::labels::ParsingRuleLabel,
+    token::{Keyword, Token},
+};
+
+use super::{parse_many::separated_by_comma_until_right_brace, Parser};
+
+impl<'a> Parser<'a> {
+    /// Use = 'use' PathKind PathNoTurbofish UseTree
+    ///
+    /// UseTree = PathNoTurbofish ( '::' '{' UseTreeList? '}' )?
+    ///
+    /// UseTreeList = UseTree (',' UseTree)* ','?
+    pub(super) fn parse_use_tree(&mut self) -> UseTree {
+        let start_span = self.current_token_span;
+
+        let kind = self.parse_path_kind();
+
+        let use_tree = self.parse_use_tree_without_kind(
+            start_span, kind, false, // nested
+        );
+        if !self.eat_semicolons() {
+            self.expected_token(Token::Semicolon);
+        }
+        use_tree
+    }
+
+    pub(super) fn parse_use_tree_without_kind(
+        &mut self,
+        start_span: Span,
+        kind: PathKind,
+        nested: bool,
+    ) -> UseTree {
+        let prefix = self.parse_path_after_kind(
+            kind, false, // allow turbofish
+            false, // allow trailing double colon
+            start_span,
+        );
+        let trailing_double_colon = if prefix.segments.is_empty() && kind != PathKind::Plain {
+            true
+        } else {
+            self.eat_double_colon()
+        };
+
+        if trailing_double_colon {
+            if self.eat_left_brace() {
+                let use_trees = self.parse_many(
+                    "use trees",
+                    separated_by_comma_until_right_brace(),
+                    Self::parse_use_tree_in_list,
+                );
+
+                UseTree {
+                    prefix,
+                    kind: UseTreeKind::List(use_trees),
+                    span: self.span_since(start_span),
+                }
+            } else {
+                self.expected_token(Token::LeftBrace);
+                self.parse_path_use_tree_end(prefix, nested, start_span)
+            }
+        } else {
+            self.parse_path_use_tree_end(prefix, nested, start_span)
+        }
+    }
+
+    fn parse_use_tree_in_list(&mut self) -> Option<UseTree> {
+        let start_span = self.current_token_span;
+
+        // Special case: "self" cannot be followed by anything else
+        if self.eat_self() {
+            return Some(UseTree {
+                prefix: Path { segments: Vec::new(), kind: PathKind::Plain, span: start_span },
+                kind: UseTreeKind::Path(Ident::new("self".to_string(), start_span), None),
+                span: start_span,
+            });
+        }
+
+        let use_tree = self.parse_use_tree_without_kind(
+            start_span,
+            PathKind::Plain,
+            true, // nested
+        );
+
+        // If we didn't advance at all, we are done
+        if start_span == self.current_token_span {
+            self.expected_label(ParsingRuleLabel::UseSegment);
+            None
+        } else {
+            Some(use_tree)
+        }
+    }
+
+    pub(super) fn parse_path_use_tree_end(
+        &mut self,
+        mut prefix: Path,
+        nested: bool,
+        start_span: Span,
+    ) -> UseTree {
+        if prefix.segments.is_empty() {
+            if nested {
+                self.expected_identifier();
+            } else {
+                self.expected_label(ParsingRuleLabel::UseSegment);
+            }
+            UseTree {
+                prefix,
+                kind: UseTreeKind::Path(Ident::default(), None),
+                span: self.span_since(start_span),
+            }
+        } else {
+            let ident = prefix.segments.pop().unwrap().ident;
+            if self.eat_keyword(Keyword::As) {
+                if let Some(alias) = self.eat_ident() {
+                    UseTree {
+                        prefix,
+                        kind: UseTreeKind::Path(ident, Some(alias)),
+                        span: self.span_since(start_span),
+                    }
+                } else {
+                    self.expected_identifier();
+                    UseTree {
+                        prefix,
+                        kind: UseTreeKind::Path(ident, None),
+                        span: self.span_since(start_span),
+                    }
+                }
+            } else {
+                UseTree {
+                    prefix,
+                    kind: UseTreeKind::Path(ident, None),
+                    span: self.span_since(start_span),
+                }
+            }
+        }
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use crate::{
+        ast::{ItemVisibility, PathKind, UseTree, UseTreeKind},
+        parser::{
+            parser::{parse_program, tests::expect_no_errors},
+            ItemKind,
+        },
+    };
+
+    fn parse_use_tree_no_errors(src: &str) -> (UseTree, ItemVisibility) {
+        let (mut module, errors) = parse_program(src);
+        expect_no_errors(&errors);
+        assert_eq!(module.items.len(), 1);
+        let item = module.items.remove(0);
+        let ItemKind::Import(use_tree, visibility) = item.kind else {
+            panic!("Expected import");
+        };
+        (use_tree, visibility)
+    }
+
+    #[test]
+    fn parse_simple() {
+        let src = "use foo;";
+        let (use_tree, visibility) = parse_use_tree_no_errors(src);
+        assert_eq!(visibility, ItemVisibility::Private);
+        assert_eq!(use_tree.prefix.kind, PathKind::Plain);
+        assert_eq!("foo", use_tree.to_string());
+        let UseTreeKind::Path(ident, alias) = &use_tree.kind else {
+            panic!("Expected path");
+        };
+        assert_eq!("foo", ident.to_string());
+        assert!(alias.is_none());
+    }
+
+    #[test]
+    fn parse_simple_pub() {
+        let src = "pub use foo;";
+        let (_use_tree, visibility) = parse_use_tree_no_errors(src);
+        assert_eq!(visibility, ItemVisibility::Public);
+    }
+
+    #[test]
+    fn parse_simple_pub_crate() {
+        let src = "pub(crate) use foo;";
+        let (_use_tree, visibility) = parse_use_tree_no_errors(src);
+        assert_eq!(visibility, ItemVisibility::PublicCrate);
+    }
+
+    #[test]
+    fn parse_simple_with_alias() {
+        let src = "use foo as bar;";
+        let (use_tree, visibility) = parse_use_tree_no_errors(src);
+        assert_eq!(visibility, ItemVisibility::Private);
+        assert_eq!(use_tree.prefix.kind, PathKind::Plain);
+        assert_eq!("foo as bar", use_tree.to_string());
+        let UseTreeKind::Path(ident, alias) = use_tree.kind else {
+            panic!("Expected path");
+        };
+        assert_eq!("foo", ident.to_string());
+        assert_eq!("bar", alias.unwrap().to_string());
+    }
+
+    #[test]
+    fn parse_with_crate_prefix() {
+        let src = "use crate::foo;";
+        let (use_tree, visibility) = parse_use_tree_no_errors(src);
+        assert_eq!(visibility, ItemVisibility::Private);
+        assert_eq!(use_tree.prefix.kind, PathKind::Crate);
+        assert_eq!("crate::foo", use_tree.to_string());
+        let UseTreeKind::Path(ident, alias) = use_tree.kind else {
+            panic!("Expected path");
+        };
+        assert_eq!("foo", ident.to_string());
+        assert!(alias.is_none());
+    }
+
+    #[test]
+    fn parse_with_dep_prefix() {
+        let src = "use dep::foo;";
+        let (use_tree, visibility) = parse_use_tree_no_errors(src);
+        assert_eq!(visibility, ItemVisibility::Private);
+        assert_eq!(use_tree.prefix.kind, PathKind::Dep);
+        assert_eq!("dep::foo", use_tree.to_string());
+        let UseTreeKind::Path(ident, alias) = use_tree.kind else {
+            panic!("Expected path");
+        };
+        assert_eq!("foo", ident.to_string());
+        assert!(alias.is_none());
+    }
+
+    #[test]
+    fn parse_with_super_prefix() {
+        let src = "use super::foo;";
+        let (use_tree, visibility) = parse_use_tree_no_errors(src);
+        assert_eq!(visibility, ItemVisibility::Private);
+        assert_eq!(use_tree.prefix.kind, PathKind::Super);
+        assert_eq!("super::foo", use_tree.to_string());
+        let UseTreeKind::Path(ident, alias) = use_tree.kind else {
+            panic!("Expected path");
+        };
+        assert_eq!("foo", ident.to_string());
+        assert!(alias.is_none());
+    }
+
+    #[test]
+    fn parse_list() {
+        let src = "use foo::{bar, baz};";
+        let (use_tree, visibility) = parse_use_tree_no_errors(src);
+        assert_eq!(visibility, ItemVisibility::Private);
+        assert_eq!(use_tree.prefix.kind, PathKind::Plain);
+        assert_eq!("foo::{bar, baz}", use_tree.to_string());
+        let UseTreeKind::List(use_trees) = &use_tree.kind else {
+            panic!("Expected list");
+        };
+        assert_eq!(use_trees.len(), 2);
+    }
+
+    #[test]
+    fn parse_list_trailing_comma() {
+        let src = "use foo::{bar, baz, };";
+        let (use_tree, visibility) = parse_use_tree_no_errors(src);
+        assert_eq!(visibility, ItemVisibility::Private);
+        assert_eq!(use_tree.prefix.kind, PathKind::Plain);
+        assert_eq!("foo::{bar, baz}", use_tree.to_string());
+        let UseTreeKind::List(use_trees) = &use_tree.kind else {
+            panic!("Expected list");
+        };
+        assert_eq!(use_trees.len(), 2);
+    }
+
+    #[test]
+    fn parse_list_that_starts_with_crate() {
+        let src = "use crate::{foo, bar};";
+        let (use_tree, visibility) = parse_use_tree_no_errors(src);
+        assert_eq!(visibility, ItemVisibility::Private);
+        assert_eq!("crate::{foo, bar}", use_tree.to_string());
+    }
+
+    #[test]
+    fn errors_on_crate_in_subtree() {
+        let src = "use foo::{crate::bar}";
+        let (_, errors) = parse_program(src);
+        assert!(!errors.is_empty());
+    }
+
+    #[test]
+    fn errors_on_double_colon_after_self() {
+        let src = "use foo::{self::bar};";
+        let (_, errors) = parse_program(src);
+        assert!(!errors.is_empty());
+    }
+}
diff --git a/compiler/noirc_frontend/src/parser/parser/visibility.rs b/compiler/noirc_frontend/src/parser/parser/visibility.rs
deleted file mode 100644
index ea46becc932..00000000000
--- a/compiler/noirc_frontend/src/parser/parser/visibility.rs
+++ /dev/null
@@ -1,36 +0,0 @@
-use chumsky::{
-    prelude::{choice, empty, just},
-    Parser,
-};
-
-use crate::{
-    ast::{ItemVisibility, Visibility},
-    parser::NoirParser,
-    token::{Keyword, Token},
-};
-
-use super::{call_data, primitives::keyword};
-
-/// visibility_modifier: 'pub(crate)'? 'pub'? ''
-pub(crate) fn item_visibility() -> impl NoirParser<ItemVisibility> {
-    let is_pub_crate = (keyword(Keyword::Pub)
-        .then_ignore(just(Token::LeftParen))
-        .then_ignore(keyword(Keyword::Crate))
-        .then_ignore(just(Token::RightParen)))
-    .map(|_| ItemVisibility::PublicCrate);
-
-    let is_pub = keyword(Keyword::Pub).map(|_| ItemVisibility::Public);
-
-    let is_private = empty().map(|_| ItemVisibility::Private);
-
-    choice((is_pub_crate, is_pub, is_private))
-}
-
-pub fn visibility() -> impl NoirParser<Visibility> {
-    keyword(Keyword::Pub)
-        .map(|_| Visibility::Public)
-        .or(call_data())
-        .or(keyword(Keyword::ReturnData).map(|_| Visibility::ReturnData))
-        .or_not()
-        .map(|opt| opt.unwrap_or(Visibility::Private))
-}
diff --git a/compiler/noirc_frontend/src/parser/parser/where_clause.rs b/compiler/noirc_frontend/src/parser/parser/where_clause.rs
new file mode 100644
index 00000000000..a753ffb6fd2
--- /dev/null
+++ b/compiler/noirc_frontend/src/parser/parser/where_clause.rs
@@ -0,0 +1,188 @@
+use crate::{
+    ast::{GenericTypeArgs, Path, PathKind, TraitBound, UnresolvedTraitConstraint, UnresolvedType},
+    parser::labels::ParsingRuleLabel,
+    token::{Keyword, Token},
+};
+
+use super::{
+    parse_many::{separated_by, separated_by_comma},
+    Parser,
+};
+
+impl<'a> Parser<'a> {
+    /// WhereClause = 'where' WhereClauseItems?
+    ///
+    /// WhereClauseItems = WhereClauseItem ( ',' WhereClauseItem )* ','?
+    ///
+    /// WhereClauseItem = Type ':' TraitBounds
+    pub(super) fn parse_where_clause(&mut self) -> Vec<UnresolvedTraitConstraint> {
+        if !self.eat_keyword(Keyword::Where) {
+            return Vec::new();
+        }
+
+        // Constraints might end up being empty, but that's accepted as valid syntax
+        let constraints =
+            self.parse_many("where clauses", separated_by_comma(), Self::parse_single_where_clause);
+
+        constraints
+            .into_iter()
+            .flat_map(|(typ, trait_bounds)| {
+                trait_bounds.into_iter().map(move |trait_bound| UnresolvedTraitConstraint {
+                    typ: typ.clone(),
+                    trait_bound,
+                })
+            })
+            .collect()
+    }
+
+    fn parse_single_where_clause(&mut self) -> Option<(UnresolvedType, Vec<TraitBound>)> {
+        let Some(typ) = self.parse_type() else {
+            return None;
+        };
+
+        self.eat_or_error(Token::Colon);
+
+        let trait_bounds = self.parse_trait_bounds();
+
+        Some((typ, trait_bounds))
+    }
+
+    /// TraitBounds = TraitBound ( '+' TraitBound )? '+'?
+    pub(super) fn parse_trait_bounds(&mut self) -> Vec<TraitBound> {
+        self.parse_many(
+            "trait bounds",
+            separated_by(Token::Plus).stop_if_separator_is_missing(),
+            Self::parse_trait_bound_in_list,
+        )
+    }
+
+    fn parse_trait_bound_in_list(&mut self) -> Option<TraitBound> {
+        if let Some(trait_bound) = self.parse_trait_bound() {
+            Some(trait_bound)
+        } else {
+            self.expected_label(ParsingRuleLabel::TraitBound);
+            None
+        }
+    }
+
+    pub(crate) fn parse_trait_bound_or_error(&mut self) -> TraitBound {
+        if let Some(trait_bound) = self.parse_trait_bound() {
+            return trait_bound;
+        }
+
+        self.expected_label(ParsingRuleLabel::TraitBound);
+        TraitBound {
+            trait_path: Path {
+                kind: PathKind::Plain,
+                segments: Vec::new(),
+                span: self.span_at_previous_token_end(),
+            },
+            trait_id: None,
+            trait_generics: GenericTypeArgs::default(),
+        }
+    }
+
+    /// TraitBound = PathNoTurbofish GenericTypeArgs
+    pub(crate) fn parse_trait_bound(&mut self) -> Option<TraitBound> {
+        let trait_path = self.parse_path_no_turbofish()?;
+        let trait_generics = self.parse_generic_type_args();
+        Some(TraitBound { trait_path, trait_generics, trait_id: None })
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use crate::{
+        ast::UnresolvedTraitConstraint,
+        parser::{
+            parser::tests::{
+                expect_no_errors, get_single_error_reason, get_source_with_error_span,
+            },
+            Parser, ParserErrorReason,
+        },
+        token::Token,
+    };
+
+    fn parse_where_clause_no_errors(src: &str) -> Vec<UnresolvedTraitConstraint> {
+        let mut parser = Parser::for_str(src);
+        let constraints = parser.parse_where_clause();
+        expect_no_errors(&parser.errors);
+        constraints
+    }
+
+    #[test]
+    fn parses_no_where_clause() {
+        let src = "{";
+        let constraints = parse_where_clause_no_errors(src);
+        assert!(constraints.is_empty());
+    }
+
+    #[test]
+    fn parses_one_where_clause_with_two_constraints() {
+        let src = "where Foo: Bar<T> + Baz";
+        let mut constraints = parse_where_clause_no_errors(src);
+        assert_eq!(constraints.len(), 2);
+
+        let constraint = constraints.remove(0);
+        assert_eq!(constraint.typ.to_string(), "Foo");
+        assert_eq!(constraint.trait_bound.trait_path.to_string(), "Bar");
+        assert_eq!(constraint.trait_bound.trait_generics.ordered_args[0].to_string(), "T");
+
+        let constraint = constraints.remove(0);
+        assert_eq!(constraint.typ.to_string(), "Foo");
+        assert_eq!(constraint.trait_bound.trait_path.to_string(), "Baz");
+    }
+
+    #[test]
+    fn parses_two_where_clauses() {
+        let src = "where Foo: Bar<T>, i32: Qux {";
+        let mut constraints = parse_where_clause_no_errors(src);
+        assert_eq!(constraints.len(), 2);
+
+        let constraint = constraints.remove(0);
+        assert_eq!(constraint.typ.to_string(), "Foo");
+        assert_eq!(constraint.trait_bound.trait_path.to_string(), "Bar");
+        assert_eq!(constraint.trait_bound.trait_generics.ordered_args[0].to_string(), "T");
+
+        let constraint = constraints.remove(0);
+        assert_eq!(constraint.typ.to_string(), "i32");
+        assert_eq!(constraint.trait_bound.trait_path.to_string(), "Qux");
+    }
+
+    #[test]
+    fn parses_two_where_clauses_missing_comma() {
+        let src = "
+        where Foo: Bar<T> i32: Qux {
+                          ^^^
+        ";
+        let (src, span) = get_source_with_error_span(src);
+        let mut parser = Parser::for_str(&src);
+        let mut constraints = parser.parse_where_clause();
+
+        let reason = get_single_error_reason(&parser.errors, span);
+        let ParserErrorReason::ExpectedTokenSeparatingTwoItems { token, items } = reason else {
+            panic!("Expected a different error");
+        };
+        assert_eq!(token, &Token::Comma);
+        assert_eq!(*items, "where clauses");
+
+        assert_eq!(constraints.len(), 2);
+
+        let constraint = constraints.remove(0);
+        assert_eq!(constraint.typ.to_string(), "Foo");
+        assert_eq!(constraint.trait_bound.trait_path.to_string(), "Bar");
+        assert_eq!(constraint.trait_bound.trait_generics.ordered_args[0].to_string(), "T");
+
+        let constraint = constraints.remove(0);
+        assert_eq!(constraint.typ.to_string(), "i32");
+        assert_eq!(constraint.trait_bound.trait_path.to_string(), "Qux");
+    }
+
+    #[test]
+    fn parses_where_clause_missing_trait_bound() {
+        let src = "where Foo: ";
+        let mut parser = Parser::for_str(src);
+        parser.parse_where_clause();
+        assert!(!parser.errors.is_empty());
+    }
+}
diff --git a/compiler/noirc_frontend/src/tests.rs b/compiler/noirc_frontend/src/tests.rs
index 63013036ca9..8ddf1b571e6 100644
--- a/compiler/noirc_frontend/src/tests.rs
+++ b/compiler/noirc_frontend/src/tests.rs
@@ -1,9 +1,13 @@
 #![cfg(test)]
 
+mod aliases;
+mod arithmetic_generics;
 mod bound_checks;
 mod imports;
+mod metaprogramming;
 mod name_shadowing;
 mod references;
+mod traits;
 mod turbofish;
 mod unused_items;
 mod visibility;
@@ -30,16 +34,15 @@ use crate::hir::Context;
 use crate::node_interner::{NodeInterner, StmtId};
 
 use crate::hir::def_collector::dc_crate::DefCollector;
+use crate::hir::def_map::{CrateDefMap, LocalModuleId};
 use crate::hir_def::expr::HirExpression;
 use crate::hir_def::stmt::HirStatement;
+use crate::monomorphization::ast::Program;
+use crate::monomorphization::errors::MonomorphizationError;
 use crate::monomorphization::monomorphize;
 use crate::parser::{ItemKind, ParserErrorReason};
 use crate::token::SecondaryAttribute;
-use crate::ParsedModule;
-use crate::{
-    hir::def_map::{CrateDefMap, LocalModuleId},
-    parse_program,
-};
+use crate::{parse_program, ParsedModule};
 use fm::FileManager;
 use noirc_arena::Arena;
 
@@ -57,6 +60,15 @@ pub(crate) fn remove_experimental_warnings(errors: &mut Vec<(CompilationError, F
 }
 
 pub(crate) fn get_program(src: &str) -> (ParsedModule, Context, Vec<(CompilationError, FileId)>) {
+    get_program_with_maybe_parser_errors(
+        src, false, // allow parser errors
+    )
+}
+
+pub(crate) fn get_program_with_maybe_parser_errors(
+    src: &str,
+    allow_parser_errors: bool,
+) -> (ParsedModule, Context, Vec<(CompilationError, FileId)>) {
     let root = std::path::Path::new("/");
     let fm = FileManager::new(root);
 
@@ -69,7 +81,7 @@ pub(crate) fn get_program(src: &str) -> (ParsedModule, Context, Vec<(Compilation
     let mut errors = vecmap(parser_errors, |e| (e.into(), root_file_id));
     remove_experimental_warnings(&mut errors);
 
-    if !has_parser_error(&errors) {
+    if allow_parser_errors || !has_parser_error(&errors) {
         let inner_attributes: Vec<SecondaryAttribute> = program
             .items
             .iter()
@@ -90,7 +102,8 @@ pub(crate) fn get_program(src: &str) -> (ParsedModule, Context, Vec<(Compilation
             location,
             Vec::new(),
             inner_attributes.clone(),
-            false,
+            false, // is contract
+            false, // is struct
         ));
 
         let def_map = CrateDefMap {
@@ -123,7 +136,7 @@ pub(crate) fn get_program_errors(src: &str) -> Vec<(CompilationError, FileId)> {
 fn assert_no_errors(src: &str) {
     let errors = get_program_errors(src);
     if !errors.is_empty() {
-        panic!("Expected no errors, got: {:?}", errors);
+        panic!("Expected no errors, got: {:?}; src = {src}", errors);
     }
 }
 
@@ -196,7 +209,7 @@ fn check_trait_implementation_duplicate_method() {
             x + 2 * y
         }
     }
-    
+
     fn main() {
         let _ = Foo { bar: 1, array: [2, 3] }; // silence Foo never constructed warning
     }";
@@ -616,8 +629,8 @@ fn check_trait_impl_for_non_type() {
     for (err, _file_id) in errors {
         match &err {
             CompilationError::ResolverError(ResolverError::Expected { expected, got, .. }) => {
-                assert_eq!(expected, "type");
-                assert_eq!(got, "function");
+                assert_eq!(*expected, "type");
+                assert_eq!(*got, "function");
             }
             _ => {
                 panic!("No other errors are expected! Found = {:?}", err);
@@ -645,7 +658,7 @@ fn check_impl_struct_not_trait() {
             Self { bar: x, array: [x,y] }
         }
     }
-    
+
     fn main() {
         let _ = Default { x: 1, z: 1 }; // silence Default never constructed warning
     }
@@ -1071,6 +1084,18 @@ fn resolve_for_expr() {
     assert_no_errors(src);
 }
 
+#[test]
+fn resolve_for_expr_incl() {
+    let src = r#"
+        fn main(x : u64) {
+            for i in 1..=20 {
+                let _z = x + i;
+            };
+        }
+    "#;
+    assert_no_errors(src);
+}
+
 #[test]
 fn resolve_call_expr() {
     let src = r#"
@@ -1184,8 +1209,6 @@ fn resolve_fmt_strings() {
             let string = f"this is i: {i}";
             println(string);
 
-            println(f"I want to print {0}");
-
             let new_val = 10;
             println(f"random_string{new_val}{new_val}");
         }
@@ -1195,7 +1218,7 @@ fn resolve_fmt_strings() {
     "#;
 
     let errors = get_program_errors(src);
-    assert!(errors.len() == 5, "Expected 5 errors, got: {:?}", errors);
+    assert!(errors.len() == 3, "Expected 5 errors, got: {:?}", errors);
 
     for (err, _file_id) in errors {
         match &err {
@@ -1204,21 +1227,13 @@ fn resolve_fmt_strings() {
             }) => {
                 assert_eq!(name, "i");
             }
-            CompilationError::ResolverError(ResolverError::NumericConstantInFormatString {
-                name,
-                ..
-            }) => {
-                assert_eq!(name, "0");
-            }
             CompilationError::TypeError(TypeCheckError::UnusedResultError {
                 expr_type: _,
                 expr_span,
             }) => {
                 let a = src.get(expr_span.start() as usize..expr_span.end() as usize).unwrap();
                 assert!(
-                    a == "println(string)"
-                        || a == "println(f\"I want to print {0}\")"
-                        || a == "println(f\"random_string{new_val}{new_val}\")"
+                    a == "println(string)" || a == "println(f\"random_string{new_val}{new_val}\")"
                 );
             }
             _ => unimplemented!(),
@@ -1226,10 +1241,18 @@ fn resolve_fmt_strings() {
     }
 }
 
-fn check_rewrite(src: &str, expected: &str) {
+fn monomorphize_program(src: &str) -> Result<Program, MonomorphizationError> {
     let (_program, mut context, _errors) = get_program(src);
     let main_func_id = context.def_interner.find_function("main").unwrap();
-    let program = monomorphize(main_func_id, &mut context.def_interner).unwrap();
+    monomorphize(main_func_id, &mut context.def_interner)
+}
+
+fn get_monomorphization_error(src: &str) -> Option<MonomorphizationError> {
+    monomorphize_program(src).err()
+}
+
+fn check_rewrite(src: &str, expected: &str) {
+    let program = monomorphize_program(src).unwrap();
     assert!(format!("{}", program) == expected);
 }
 
@@ -1267,11 +1290,17 @@ fn lambda$f1(mut env$l1: (Field)) -> Field {
 #[test]
 fn deny_cyclic_globals() {
     let src = r#"
-        global A = B;
-        global B = A;
+        global A: u32 = B;
+        global B: u32 = A;
         fn main() {}
     "#;
-    assert_eq!(get_program_errors(src).len(), 1);
+
+    let errors = get_program_errors(src);
+    assert_eq!(errors.len(), 1);
+    assert!(matches!(
+        errors[0].0,
+        CompilationError::ResolverError(ResolverError::DependencyCycle { .. })
+    ));
 }
 
 #[test]
@@ -1561,7 +1590,7 @@ fn struct_numeric_generic_in_function() {
         inner: u64
     }
 
-    pub fn bar<let N: Foo>() { 
+    pub fn bar<let N: Foo>() {
         let _ = Foo { inner: 1 }; // silence Foo never constructed warning
     }
     "#;
@@ -1586,9 +1615,7 @@ fn struct_numeric_generic_in_struct() {
     assert_eq!(errors.len(), 1);
     assert!(matches!(
         errors[0].0,
-        CompilationError::DefinitionError(
-            DefCollectorErrorKind::UnsupportedNumericGenericType { .. }
-        ),
+        CompilationError::ResolverError(ResolverError::UnsupportedNumericGenericType(_)),
     ));
 }
 
@@ -1641,7 +1668,6 @@ fn bool_generic_as_loop_bound() {
     "#;
     let errors = get_program_errors(src);
     assert_eq!(errors.len(), 3);
-
     assert!(matches!(
         errors[0].0,
         CompilationError::ResolverError(ResolverError::UnsupportedNumericGenericType { .. }),
@@ -1706,7 +1732,7 @@ fn normal_generic_as_array_length() {
 #[test]
 fn numeric_generic_as_param_type() {
     let src = r#"
-    pub fn foo<let I: Field>(x: I) -> I {
+    pub fn foo<let I: u32>(x: I) -> I {
         let _q: I = 5;
         x
     }
@@ -1731,6 +1757,68 @@ fn numeric_generic_as_param_type() {
     ));
 }
 
+#[test]
+fn numeric_generic_as_unused_param_type() {
+    let src = r#"
+    pub fn foo<let I: u32>(_x: I) { }
+    "#;
+    let errors = get_program_errors(src);
+    assert_eq!(errors.len(), 1);
+    assert!(matches!(
+        errors[0].0,
+        CompilationError::TypeError(TypeCheckError::TypeKindMismatch { .. }),
+    ));
+}
+
+#[test]
+fn numeric_generic_as_unused_trait_fn_param_type() {
+    let src = r#"
+    trait Foo {
+        fn foo<let I: u32>(_x: I) { }
+    }
+    "#;
+    let errors = get_program_errors(src);
+    assert_eq!(errors.len(), 2);
+    assert!(matches!(
+        errors[0].0,
+        CompilationError::TypeError(TypeCheckError::TypeKindMismatch { .. }),
+    ));
+    // Foo is unused
+    assert!(matches!(
+        errors[1].0,
+        CompilationError::ResolverError(ResolverError::UnusedItem { .. }),
+    ));
+}
+
+#[test]
+fn numeric_generic_as_return_type() {
+    let src = r#"
+    // std::mem::zeroed() without stdlib
+    trait Zeroed {
+        fn zeroed<T>(self) -> T;
+    }
+
+    fn foo<T, let I: Field>(x: T) -> I where T: Zeroed {
+        x.zeroed()
+    }
+
+    fn main() {}
+    "#;
+    let errors = get_program_errors(src);
+    assert_eq!(errors.len(), 2);
+
+    // Error from the return type
+    assert!(matches!(
+        errors[0].0,
+        CompilationError::TypeError(TypeCheckError::TypeKindMismatch { .. }),
+    ));
+    // foo is unused
+    assert!(matches!(
+        errors[1].0,
+        CompilationError::ResolverError(ResolverError::UnusedItem { .. }),
+    ));
+}
+
 #[test]
 fn numeric_generic_used_in_nested_type_fails() {
     let src = r#"
@@ -1877,6 +1965,125 @@ fn numeric_generic_used_in_turbofish() {
     assert_no_errors(src);
 }
 
+// TODO(https://github.com/noir-lang/noir/issues/6245):
+// allow u16 to be used as an array size
+#[test]
+fn numeric_generic_u16_array_size() {
+    let src = r#"
+    fn len<let N: u32>(_arr: [Field; N]) -> u32 {
+        N
+    }
+
+    pub fn foo<let N: u16>() -> u32 {
+        let fields: [Field; N] = [0; N];
+        len(fields)
+    }
+    "#;
+    let errors = get_program_errors(src);
+    assert_eq!(errors.len(), 2);
+    assert!(matches!(
+        errors[0].0,
+        CompilationError::TypeError(TypeCheckError::TypeKindMismatch { .. }),
+    ));
+    assert!(matches!(
+        errors[1].0,
+        CompilationError::TypeError(TypeCheckError::TypeKindMismatch { .. }),
+    ));
+}
+
+// TODO(https://github.com/noir-lang/noir/issues/6238):
+// The EvaluatedGlobalIsntU32 warning is a stopgap
+// (originally from https://github.com/noir-lang/noir/issues/6125)
+#[test]
+fn numeric_generic_field_larger_than_u32() {
+    let src = r#"
+        global A: Field = 4294967297;
+
+        fn foo<let A: Field>() { }
+
+        fn main() {
+            let _ = foo::<A>();
+        }
+    "#;
+    let errors = get_program_errors(src);
+    assert_eq!(errors.len(), 2);
+    assert!(matches!(
+        errors[0].0,
+        CompilationError::TypeError(TypeCheckError::EvaluatedGlobalIsntU32 { .. }),
+    ));
+    assert!(matches!(
+        errors[1].0,
+        CompilationError::ResolverError(ResolverError::IntegerTooLarge { .. })
+    ));
+}
+
+// TODO(https://github.com/noir-lang/noir/issues/6238):
+// The EvaluatedGlobalIsntU32 warning is a stopgap
+// (originally from https://github.com/noir-lang/noir/issues/6126)
+#[test]
+fn numeric_generic_field_arithmetic_larger_than_u32() {
+    let src = r#"
+        struct Foo<let F: Field> {}
+
+        impl<let F: Field> Foo<F> {
+            fn size(self) -> Field {
+                F
+            }
+        }
+
+        // 2^32 - 1
+        global A: Field = 4294967295;
+
+        fn foo<let A: Field>() -> Foo<A + A> {
+            Foo {}
+        }
+
+        fn main() {
+            let _ = foo::<A>().size();
+        }
+    "#;
+    let errors = get_program_errors(src);
+    assert_eq!(errors.len(), 2);
+
+    assert!(matches!(
+        errors[0].0,
+        CompilationError::TypeError(TypeCheckError::EvaluatedGlobalIsntU32 { .. }),
+    ));
+
+    assert!(matches!(
+        errors[1].0,
+        CompilationError::ResolverError(ResolverError::UnusedVariable { .. })
+    ));
+}
+
+#[test]
+fn cast_256_to_u8_size_checks() {
+    let src = r#"
+        fn main() {
+            assert(256 as u8 == 0);
+        }
+    "#;
+    let errors = get_program_errors(src);
+    assert_eq!(errors.len(), 1);
+    assert!(matches!(
+        errors[0].0,
+        CompilationError::TypeError(TypeCheckError::DownsizingCast { .. }),
+    ));
+}
+
+// TODO(https://github.com/noir-lang/noir/issues/6247):
+// add negative integer literal checks
+#[test]
+fn cast_negative_one_to_u8_size_checks() {
+    let src = r#"
+        fn main() {
+            assert((-1) as u8 != 0);
+        }
+    "#;
+    let errors = get_program_errors(src);
+    assert!(errors.is_empty());
+}
+
 #[test]
 fn constant_used_with_numeric_generic() {
     let src = r#"
@@ -1967,17 +2174,31 @@ fn numeric_generics_type_kind_mismatch() {
     }
 
     global M: u16 = 3;
-    
+
     fn main() {
         let _ = bar::<M>();
     }
     "#;
     let errors = get_program_errors(src);
-    assert_eq!(errors.len(), 1);
+    assert_eq!(errors.len(), 3);
+
+    // TODO(https://github.com/noir-lang/noir/issues/6238):
+    // The EvaluatedGlobalIsntU32 warning is a stopgap
     assert!(matches!(
         errors[0].0,
+        CompilationError::TypeError(TypeCheckError::EvaluatedGlobalIsntU32 { .. }),
+    ));
+
+    assert!(matches!(
+        errors[1].0,
         CompilationError::TypeError(TypeCheckError::TypeKindMismatch { .. }),
     ));
+
+    // TODO(https://github.com/noir-lang/noir/issues/6238): see above
+    assert!(matches!(
+        errors[2].0,
+        CompilationError::TypeError(TypeCheckError::EvaluatedGlobalIsntU32 { .. }),
+    ));
 }
 
 #[test]
@@ -1991,7 +2212,7 @@ fn numeric_generics_value_kind_mismatch_u32_u64() {
     }
 
     impl<T, let MaxLen: u32> BoundedVec<T, MaxLen> {
-        pub fn extend_from_bounded_vec<let Len: u32>(&mut self, _vec: BoundedVec<T, Len>) { 
+        pub fn extend_from_bounded_vec<let Len: u32>(&mut self, _vec: BoundedVec<T, Len>) {
             // We do this to avoid an unused variable warning on `self`
             let _ = self.len;
             for _ in 0..Len { }
@@ -2282,7 +2503,7 @@ fn trait_impl_where_clause_stricter_pass() {
 
         fn bad_foo<A, B>() where A: OtherTrait { }
     }
-    
+
     fn main() {
         let _ = Option { inner: 1 }; // silence Option never constructed warning
     }
@@ -2385,23 +2606,6 @@ fn impl_not_found_for_inner_impl() {
     ));
 }
 
-#[test]
-fn no_super() {
-    let src = "use super::some_func;";
-    let errors = get_program_errors(src);
-    assert_eq!(errors.len(), 1);
-
-    let CompilationError::DefinitionError(DefCollectorErrorKind::PathResolutionError(
-        PathResolutionError::NoSuper(span),
-    )) = &errors[0].0
-    else {
-        panic!("Expected a 'no super' error, got {:?}", errors[0].0);
-    };
-
-    assert_eq!(span.start(), 4);
-    assert_eq!(span.end(), 9);
-}
-
 #[test]
 fn cannot_call_unconstrained_function_outside_of_unsafe() {
     let src = r#"
@@ -2783,9 +2987,7 @@ fn uses_self_type_in_trait_where_clause() {
         }
     }
 
-    struct Bar {
-
-    }
+    struct Bar {}
 
     impl Foo for Bar {
 
@@ -2797,12 +2999,17 @@ fn uses_self_type_in_trait_where_clause() {
     "#;
 
     let errors = get_program_errors(src);
-    assert_eq!(errors.len(), 1);
+    assert_eq!(errors.len(), 2);
+
+    let CompilationError::ResolverError(ResolverError::TraitNotImplemented { .. }) = &errors[0].0
+    else {
+        panic!("Expected a trait not implemented error, got {:?}", errors[0].0);
+    };
 
     let CompilationError::TypeError(TypeCheckError::UnresolvedMethodCall { method_name, .. }) =
-        &errors[0].0
+        &errors[1].0
     else {
-        panic!("Expected an unresolved method call error, got {:?}", errors[0].0);
+        panic!("Expected an unresolved method call error, got {:?}", errors[1].0);
     };
 
     assert_eq!(method_name, "trait_func");
@@ -2999,30 +3206,64 @@ fn as_trait_path_syntax_no_impl() {
 }
 
 #[test]
-fn arithmetic_generics_canonicalization_deduplication_regression() {
-    let source = r#"
-        struct ArrData<let N: u32> {
-            a: [Field; N],
-            b: [Field; N + N - 1],
-        }
+fn dont_infer_globals_to_u32_from_type_use() {
+    let src = r#"
+        global ARRAY_LEN = 3;
+        global STR_LEN: _ = 2;
+        global FMT_STR_LEN = 2;
 
         fn main() {
-            let _f: ArrData<5> = ArrData {
-                a: [0; 5],
-                b: [0; 9],
-            };
+            let _a: [u32; ARRAY_LEN] = [1, 2, 3];
+            let _b: str<STR_LEN> = "hi";
+            let _c: fmtstr<FMT_STR_LEN, _> = f"hi";
         }
     "#;
-    let errors = get_program_errors(source);
-    assert_eq!(errors.len(), 0);
+
+    let errors = get_program_errors(src);
+    assert_eq!(errors.len(), 3);
+    assert!(matches!(
+        errors[0].0,
+        CompilationError::ResolverError(ResolverError::UnspecifiedGlobalType { .. })
+    ));
+    assert!(matches!(
+        errors[1].0,
+        CompilationError::ResolverError(ResolverError::UnspecifiedGlobalType { .. })
+    ));
+    assert!(matches!(
+        errors[2].0,
+        CompilationError::ResolverError(ResolverError::UnspecifiedGlobalType { .. })
+    ));
 }
 
 #[test]
-fn infer_globals_to_u32_from_type_use() {
+fn dont_infer_partial_global_types() {
     let src = r#"
-        global ARRAY_LEN = 3;
-        global STR_LEN = 2;
-        global FMT_STR_LEN = 2;
+        pub global ARRAY: [Field; _] = [0; 3];
+        pub global NESTED_ARRAY: [[Field; _]; 3] = [[]; 3];
+        pub global STR: str<_> = "hi";
+        pub global NESTED_STR: [str<_>] = &["hi"];
+        pub global FMT_STR: fmtstr<_, _> = f"hi {ARRAY}";
+        pub global TUPLE_WITH_MULTIPLE: ([str<_>], [[Field; _]; 3]) = (&["hi"], [[]; 3]);
+
+        fn main() { }
+    "#;
+
+    let errors = get_program_errors(src);
+    assert_eq!(errors.len(), 6);
+    for (error, _file_id) in errors {
+        assert!(matches!(
+            error,
+            CompilationError::ResolverError(ResolverError::UnspecifiedGlobalType { .. })
+        ));
+    }
+}
+
+#[test]
+fn u32_globals_as_sizes_in_types() {
+    let src = r#"
+        global ARRAY_LEN: u32 = 3;
+        global STR_LEN: u32 = 2;
+        global FMT_STR_LEN: u32 = 2;
 
         fn main() {
             let _a: [u32; ARRAY_LEN] = [1, 2, 3];
@@ -3036,7 +3277,38 @@ fn infer_globals_to_u32_from_type_use() {
 }
 
 #[test]
-fn non_u32_in_array_length() {
+fn struct_array_len() {
+    let src = r#"
+        struct Array<T, let N: u32> {
+            inner: [T; N],
+        }
+
+        impl<T, let N: u32> Array<T, N> {
+            pub fn len(self) -> u32 {
+                N as u32
+            }
+        }
+
+        fn main(xs: [Field; 2]) {
+            let ys = Array {
+                inner: xs,
+            };
+            assert(ys.len() == 2);
+        }
+    "#;
+
+    let errors = get_program_errors(src);
+    assert_eq!(errors.len(), 1);
+    assert!(matches!(
+        errors[0].0,
+        CompilationError::ResolverError(ResolverError::UnusedVariable { .. })
+    ));
+}
+
+// TODO(https://github.com/noir-lang/noir/issues/6245):
+// support u16 as an array size
+#[test]
+fn non_u32_as_array_length() {
     let src = r#"
         global ARRAY_LEN: u8 = 3;
 
@@ -3046,10 +3318,13 @@ fn non_u32_in_array_length() {
     "#;
 
     let errors = get_program_errors(src);
-    assert_eq!(errors.len(), 1);
-
+    assert_eq!(errors.len(), 2);
     assert!(matches!(
         errors[0].0,
+        CompilationError::TypeError(TypeCheckError::EvaluatedGlobalIsntU32 { .. })
+    ));
+    assert!(matches!(
+        errors[1].0,
         CompilationError::TypeError(TypeCheckError::TypeKindMismatch { .. })
     ));
 }
@@ -3084,7 +3359,8 @@ fn use_numeric_generic_in_trait_method() {
         }
 
         fn main() {
-            let _ = Bar{}.foo([1,2,3]);
+            let bytes: [u8; 3] = [1,2,3];
+            let _ = Bar{}.foo(bytes);
         }
     "#;
 
@@ -3103,17 +3379,17 @@ fn trait_unconstrained_methods_typechecked_correctly() {
                 self
             }
 
-            unconstrained fn foo(self) -> u64;
+            unconstrained fn foo(self) -> Field;
         }
 
-        impl Foo for Field {
-            unconstrained fn foo(self) -> u64 {
-                self as u64
+        impl Foo for u64 {
+            unconstrained fn foo(self) -> Field {
+                self as Field
             }
         }
 
         unconstrained fn main() {
-            assert_eq(2.foo() as Field, 2.identity());
+            assert_eq(2.foo(), 2.identity() as Field);
         }
     "#;
 
@@ -3121,3 +3397,500 @@ fn trait_unconstrained_methods_typechecked_correctly() {
     println!("{errors:?}");
     assert_eq!(errors.len(), 0);
 }
+
+#[test]
+fn error_if_attribute_not_in_scope() {
+    let src = r#"
+        #[not_in_scope]
+        fn main() {}
+    "#;
+
+    let errors = get_program_errors(src);
+    assert_eq!(errors.len(), 1);
+
+    assert!(matches!(
+        errors[0].0,
+        CompilationError::ResolverError(ResolverError::AttributeFunctionNotInScope { .. })
+    ));
+}
+
+#[test]
+fn arithmetic_generics_rounding_pass() {
+    let src = r#"
+        fn main() {
+            // 3/2*2 = 2
+            round::<3, 2>([1, 2]);
+        }
+
+        fn round<let N: u32, let M: u32>(_x: [Field; N / M * M]) {}
+    "#;
+
+    let errors = get_program_errors(src);
+    assert_eq!(errors.len(), 0);
+}
+
+#[test]
+fn arithmetic_generics_rounding_fail() {
+    let src = r#"
+        fn main() {
+            // Do not simplify N/M*M to just N
+            // This should be 3/2*2 = 2, not 3
+            round::<3, 2>([1, 2, 3]);
+        }
+
+        fn round<let N: u32, let M: u32>(_x: [Field; N / M * M]) {}
+    "#;
+
+    let errors = get_program_errors(src);
+    assert_eq!(errors.len(), 1);
+    assert!(matches!(
+        errors[0].0,
+        CompilationError::TypeError(TypeCheckError::TypeMismatch { .. })
+    ));
+}
+
+#[test]
+fn arithmetic_generics_rounding_fail_on_struct() {
+    let src = r#"
+        struct W<let N: u32> {}
+
+        fn foo<let N: u32, let M: u32>(_x: W<N>, _y: W<M>) -> W<N / M * M> {
+            W {}
+        }
+
+        fn main() {
+            let w_2: W<2> = W {};
+            let w_3: W<3> = W {};
+            // Do not simplify N/M*M to just N
+            // This should be 3/2*2 = 2, not 3
+            let _: W<3> = foo(w_3, w_2);
+        }
+    "#;
+
+    let errors = get_program_errors(src);
+    assert_eq!(errors.len(), 1);
+    assert!(matches!(
+        errors[0].0,
+        CompilationError::TypeError(TypeCheckError::TypeMismatch { .. })
+    ));
+}
+
+#[test]
+fn unconditional_recursion_fail() {
+    let srcs = vec![
+        r#"
+        fn main() {
+            main()
+        }
+        "#,
+        r#"
+        fn main() -> pub bool {
+            if main() { true } else { false }
+        }
+        "#,
+        r#"
+        fn main() -> pub bool {
+            if true { main() } else { main() }
+        }
+        "#,
+        r#"
+        fn main() -> pub u64 {
+            main() + main()
+        }
+        "#,
+        r#"
+        fn main() -> pub u64 {
+            1 + main()
+        }
+        "#,
+        r#"
+        fn main() -> pub bool {
+            let _ = main();
+            true
+        }
+        "#,
+        r#"
+        fn main(a: u64, b: u64) -> pub u64 {
+            main(a + b, main(a, b))
+        }
+        "#,
+        r#"
+        fn main() -> pub u64 {
+            foo(1, main())
+        }
+        fn foo(a: u64, b: u64) -> u64 {
+            a + b
+        }
+        "#,
+        r#"
+        fn main() -> pub u64 {
+            let (a, b) = (main(), main());
+            a + b
+        }
+        "#,
+        r#"
+        fn main() -> pub u64 {
+            let mut sum = 0;
+            for i in 0 .. main() {
+                sum += i;
+            }
+            sum
+        }
+        "#,
+    ];
+
+    for src in srcs {
+        let errors = get_program_errors(src);
+        assert!(
+            !errors.is_empty(),
+            "expected 'unconditional recursion' error, got nothing; src = {src}"
+        );
+
+        for (error, _) in errors {
+            let CompilationError::ResolverError(ResolverError::UnconditionalRecursion { .. }) =
+                error
+            else {
+                panic!("Expected an 'unconditional recursion' error, got {:?}; src = {src}", error);
+            };
+        }
+    }
+}
+
+#[test]
+fn unconditional_recursion_pass() {
+    let srcs = vec![
+        r#"
+        fn main() {
+            if false { main(); }
+        }
+        "#,
+        r#"
+        fn main(i: u64) -> pub u64 {
+            if i == 0 { 0 } else { i + main(i-1) }
+        }
+        "#,
+        // Only immediate self-recursion is detected.
+        r#"
+        fn main() {
+            foo();
+        }
+        fn foo() {
+            bar();
+        }
+        fn bar() {
+            foo();
+        }
+        "#,
+        // For loop bodies are not checked.
+        r#"
+        fn main() -> pub u64 {
+            let mut sum = 0;
+            for _ in 0 .. 10 {
+                sum += main();
+            }
+            sum
+        }
+        "#,
+        // Lambda bodies are not checked.
+        r#"
+        fn main() {
+            let foo = || main();
+            foo();
+        }
+        "#,
+    ];
+
+    for src in srcs {
+        assert_no_errors(src);
+    }
+}
+
+#[test]
+fn uses_self_in_import() {
+    let src = r#"
+    mod moo {
+        pub mod bar {
+            pub fn foo() -> i32 {
+                1
+            }
+        }
+    }
+
+    use moo::bar::{self};
+
+    pub fn baz() -> i32 {
+        bar::foo()
+    }
+
+    fn main() {}
+    "#;
+    assert_no_errors(src);
+}
+
+#[test]
+fn does_not_error_on_return_values_after_block_expression() {
+    // Regression test for https://github.com/noir-lang/noir/issues/4372
+    let src = r#"
+    fn case1() -> [Field] {
+        if true {
+        }
+        &[1]
+    }
+
+    fn case2() -> [u8] {
+        let mut var: u8 = 1;
+        {
+            var += 1;
+        }
+        &[var]
+    }
+
+    fn main() {
+        let _ = case1();
+        let _ = case2();
+    }
+    "#;
+    assert_no_errors(src);
+}
+
+#[test]
+fn use_type_alias_in_method_call() {
+    let src = r#"
+        pub struct Foo {
+        }
+
+        impl Foo {
+            fn new() -> Self {
+                Foo {}
+            }
+        }
+
+        type Bar = Foo;
+
+        fn foo() -> Foo {
+            Bar::new()
+        }
+
+        fn main() {
+            let _ = foo();
+        }
+    "#;
+    assert_no_errors(src);
+}
+
+#[test]
+fn use_type_alias_to_generic_concrete_type_in_method_call() {
+    let src = r#"
+        pub struct Foo<T> {
+            x: T,
+        }
+
+        impl<T> Foo<T> {
+            fn new(x: T) -> Self {
+                Foo { x }
+            }
+        }
+
+        type Bar = Foo<i32>;
+
+        fn foo() -> Bar {
+            Bar::new(1)
+        }
+
+        fn main() {
+            let _ = foo();
+        }
+    "#;
+    assert_no_errors(src);
+}
+
+#[test]
+fn allows_struct_with_generic_infix_type_as_main_input_1() {
+    let src = r#"
+        struct Foo<let N: u32> {
+            x: [u64; N * 2],
+        }
+
+        fn main(_x: Foo<18>) {}
+    "#;
+    assert_no_errors(src);
+}
+
+#[test]
+fn allows_struct_with_generic_infix_type_as_main_input_2() {
+    let src = r#"
+        struct Foo<let N: u32> {
+            x: [u64; N * 2],
+        }
+
+        fn main(_x: Foo<2 * 9>) {}
+    "#;
+    assert_no_errors(src);
+}
+
+#[test]
+fn allows_struct_with_generic_infix_type_as_main_input_3() {
+    let src = r#"
+        struct Foo<let N: u32> {
+            x: [u64; N * 2],
+        }
+
+        global N: u32 = 9;
+
+        fn main(_x: Foo<N * 2>) {}
+    "#;
+    assert_no_errors(src);
+}
+
+#[test]
+fn errors_with_better_message_when_trying_to_invoke_struct_field_that_is_a_function() {
+    let src = r#"
+        pub struct Foo {
+            wrapped: fn(Field) -> bool,
+        }
+
+        impl Foo {
+            fn call(self) -> bool {
+                self.wrapped(1)
+            }
+        }
+
+        fn main() {}
+    "#;
+    let errors = get_program_errors(src);
+    assert_eq!(errors.len(), 1);
+
+    let CompilationError::TypeError(TypeCheckError::CannotInvokeStructFieldFunctionType {
+        method_name,
+        ..
+    }) = &errors[0].0
+    else {
+        panic!("Expected a 'CannotInvokeStructFieldFunctionType' error, got {:?}", errors[0].0);
+    };
+
+    assert_eq!(method_name, "wrapped");
+}
+
+fn test_disallows_attribute_on_impl_method(
+    attr: &str,
+    check_error: impl FnOnce(&CompilationError),
+) {
+    let src = format!(
+        "
+        pub struct Foo {{ }}
+
+        impl Foo {{
+            #[{attr}]
+            fn foo() {{ }}
+        }}
+
+        fn main() {{ }}
+    "
+    );
+    let errors = get_program_errors(&src);
+    assert_eq!(errors.len(), 1);
+    check_error(&errors[0].0);
+}
+
+fn test_disallows_attribute_on_trait_impl_method(
+    attr: &str,
+    check_error: impl FnOnce(&CompilationError),
+) {
+    let src = format!(
+        "
+        pub trait Trait {{
+            fn foo() {{ }}
+        }}
+
+        pub struct Foo {{ }}
+
+        impl Trait for Foo {{
+            #[{attr}]
+            fn foo() {{ }}
+        }}
+
+        fn main() {{ }}
+    "
+    );
+    let errors = get_program_errors(&src);
+    assert_eq!(errors.len(), 1);
+    check_error(&errors[0].0);
+}
+
+#[test]
+fn disallows_test_attribute_on_impl_method() {
+    test_disallows_attribute_on_impl_method("test", |error| {
+        assert!(matches!(
+            error,
+            CompilationError::DefinitionError(
+                DefCollectorErrorKind::TestOnAssociatedFunction { .. }
+            )
+        ));
+    });
+}
+
+#[test]
+fn disallows_test_attribute_on_trait_impl_method() {
+    test_disallows_attribute_on_trait_impl_method("test", |error| {
+        assert!(matches!(
+            error,
+            CompilationError::DefinitionError(
+                DefCollectorErrorKind::TestOnAssociatedFunction { .. }
+            )
+        ));
+    });
+}
+
+#[test]
+fn disallows_export_attribute_on_impl_method() {
+    test_disallows_attribute_on_impl_method("export", |error| {
+        assert!(matches!(
+            error,
+            CompilationError::DefinitionError(
+                DefCollectorErrorKind::ExportOnAssociatedFunction { .. }
+            )
+        ));
+    });
+}
+
+#[test]
+fn disallows_export_attribute_on_trait_impl_method() {
+    test_disallows_attribute_on_trait_impl_method("export", |error| {
+        assert!(matches!(
+            error,
+            CompilationError::DefinitionError(
+                DefCollectorErrorKind::ExportOnAssociatedFunction { .. }
+            )
+        ));
+    });
+}
+
+#[test]
+fn allows_multiple_underscore_parameters() {
+    let src = r#"
+        pub fn foo(_: i32, _: i64) {}
+
+        fn main() {}
+    "#;
+    assert_no_errors(src);
+}
+
+#[test]
+fn disallows_underscore_on_right_hand_side() {
+    let src = r#"
+        fn main() {
+            let _ = 1;
+            let _x = _;
+        }
+    "#;
+    let errors = get_program_errors(src);
+    assert_eq!(errors.len(), 1);
+
+    let CompilationError::ResolverError(ResolverError::VariableNotDeclared { name, .. }) =
+        &errors[0].0
+    else {
+        panic!("Expected a VariableNotDeclared error, got {:?}", errors[0].0);
+    };
+
+    assert_eq!(name, "_");
+}
diff --git a/compiler/noirc_frontend/src/tests/aliases.rs b/compiler/noirc_frontend/src/tests/aliases.rs
new file mode 100644
index 00000000000..8d3433299f6
--- /dev/null
+++ b/compiler/noirc_frontend/src/tests/aliases.rs
@@ -0,0 +1,49 @@
+use super::assert_no_errors;
+
+#[test]
+fn allows_usage_of_type_alias_as_argument_type() {
+    let src = r#"
+    type Foo = Field;
+
+    fn accepts_a_foo(x: Foo) {
+        assert_eq(x, 42);
+    }
+
+    fn main() {
+        accepts_a_foo(42);
+    }
+    "#;
+    assert_no_errors(src);
+}
+
+#[test]
+fn allows_usage_of_type_alias_as_return_type() {
+    let src = r#"
+    type Foo = Field;
+
+    fn returns_a_foo() -> Foo {
+        42
+    }
+
+    fn main() {
+        let _ = returns_a_foo();
+    }
+    "#;
+    assert_no_errors(src);
+}
+
+#[test]
+fn alias_in_let_pattern() {
+    let src = r#"
+        struct Foo<T> { x: T }
+
+        type Bar<U> = Foo<U>;
+
+        fn main() {
+            let Bar { x } = Foo { x: [0] };
+            // This is just to show the compiler knows this is an array.
+            let _: [Field; 1] = x;
+        }
+    "#;
+    assert_no_errors(src);
+}
diff --git a/compiler/noirc_frontend/src/tests/arithmetic_generics.rs b/compiler/noirc_frontend/src/tests/arithmetic_generics.rs
new file mode 100644
index 00000000000..3328fe439ae
--- /dev/null
+++ b/compiler/noirc_frontend/src/tests/arithmetic_generics.rs
@@ -0,0 +1,155 @@
+#![cfg(test)]
+
+use acvm::{AcirField, FieldElement};
+
+use super::get_program_errors;
+use crate::hir::type_check::TypeCheckError;
+use crate::hir_def::types::{BinaryTypeOperator, Type};
+use crate::monomorphization::errors::MonomorphizationError;
+use crate::tests::get_monomorphization_error;
+
+#[test]
+fn arithmetic_generics_canonicalization_deduplication_regression() {
+    let source = r#"
+        struct ArrData<let N: u32> {
+            a: [Field; N],
+            b: [Field; N + N - 1],
+        }
+
+        fn main() {
+            let _f: ArrData<5> = ArrData {
+                a: [0; 5],
+                b: [0; 9],
+            };
+        }
+    "#;
+    let errors = get_program_errors(source);
+    assert_eq!(errors.len(), 0);
+}
+
+#[test]
+fn checked_casts_do_not_prevent_canonicalization() {
+    // Regression test for https://github.com/noir-lang/noir/issues/6495
+    let source = r#"
+    pub trait Serialize<let N: u32> {
+        fn serialize(self) -> [Field; N];
+    }
+
+    pub struct Counted<T> {
+        pub inner: T,
+    }
+
+    pub fn append<T, let N: u32>(array1: [T; N]) -> [T; N + 1] {
+        [array1[0]; N + 1]
+    }
+
+    impl<T, let N: u32> Serialize<N> for Counted<T>
+    where
+        T: Serialize<N - 1>,
+    {
+        fn serialize(self) -> [Field; N] {
+            append(self.inner.serialize())
+        }
+    }
+    "#;
+    let errors = get_program_errors(source);
+    println!("{:?}", errors);
+    assert_eq!(errors.len(), 0);
+}
+
+#[test]
+fn arithmetic_generics_checked_cast_zeros() {
+    let source = r#"
+        struct W<let N: u1> {}
+        
+        fn foo<let N: u1>(_x: W<N>) -> W<(0 * N) / (N % N)> {
+            W {}
+        }
+        
+        fn bar<let N: u1>(_x: W<N>) -> u1 {
+            N
+        }
+        
+        fn main() -> pub u1 {
+            let w_0: W<0> = W {};
+            let w: W<_> = foo(w_0);
+            bar(w)
+        }
+    "#;
+
+    let errors = get_program_errors(source);
+    assert_eq!(errors.len(), 0);
+
+    let monomorphization_error = get_monomorphization_error(source);
+    assert!(monomorphization_error.is_some());
+
+    // Expect a CheckedCast (0 % 0) failure
+    let monomorphization_error = monomorphization_error.unwrap();
+    if let MonomorphizationError::UnknownArrayLength { ref length, ref err, location: _ } =
+        monomorphization_error
+    {
+        match length {
+            Type::CheckedCast { from, to } => {
+                assert!(matches!(*from.clone(), Type::InfixExpr { .. }));
+                assert!(matches!(*to.clone(), Type::InfixExpr { .. }));
+            }
+            _ => panic!("unexpected length: {:?}", length),
+        }
+        assert!(matches!(
+            err,
+            TypeCheckError::FailingBinaryOp { op: BinaryTypeOperator::Modulo, lhs: 0, rhs: 0, .. }
+        ));
+    } else {
+        panic!("unexpected error: {:?}", monomorphization_error);
+    }
+}
+
+#[test]
+fn arithmetic_generics_checked_cast_indirect_zeros() {
+    let source = r#"
+        struct W<let N: Field> {}
+        
+        fn foo<let N: Field>(_x: W<N>) -> W<(N - N) % (N - N)> {
+            W {}
+        }
+        
+        fn bar<let N: Field>(_x: W<N>) -> Field {
+            N
+        }
+        
+        fn main() {
+            let w_0: W<0> = W {};
+            let w = foo(w_0);
+            let _ = bar(w);
+        }
+    "#;
+
+    let errors = get_program_errors(source);
+    assert_eq!(errors.len(), 0);
+
+    let monomorphization_error = get_monomorphization_error(source);
+    assert!(monomorphization_error.is_some());
+
+    // Expect a CheckedCast (0 % 0) failure
+    let monomorphization_error = monomorphization_error.unwrap();
+    if let MonomorphizationError::UnknownArrayLength { ref length, ref err, location: _ } =
+        monomorphization_error
+    {
+        match length {
+            Type::CheckedCast { from, to } => {
+                assert!(matches!(*from.clone(), Type::InfixExpr { .. }));
+                assert!(matches!(*to.clone(), Type::InfixExpr { .. }));
+            }
+            _ => panic!("unexpected length: {:?}", length),
+        }
+        match err {
+            TypeCheckError::ModuloOnFields { lhs, rhs, .. } => {
+                assert_eq!(lhs.clone(), FieldElement::zero());
+                assert_eq!(rhs.clone(), FieldElement::zero());
+            }
+            _ => panic!("expected ModuloOnFields, but found: {:?}", err),
+        }
+    } else {
+        panic!("unexpected error: {:?}", monomorphization_error);
+    }
+}
diff --git a/compiler/noirc_frontend/src/tests/bound_checks.rs b/compiler/noirc_frontend/src/tests/bound_checks.rs
index 271f9d7a1a7..05669bda411 100644
--- a/compiler/noirc_frontend/src/tests/bound_checks.rs
+++ b/compiler/noirc_frontend/src/tests/bound_checks.rs
@@ -14,7 +14,7 @@ fn overflowing_u8() {
     if let CompilationError::TypeError(error) = &errors[0].0 {
         assert_eq!(
             error.to_string(),
-            "The value `2⁸` cannot fit into `u8` which has range `0..=255`"
+            "The value `256` cannot fit into `u8` which has range `0..=255`"
         );
     } else {
         panic!("Expected OverflowingAssignment error, got {:?}", errors[0].0);
@@ -52,7 +52,7 @@ fn overflowing_i8() {
     if let CompilationError::TypeError(error) = &errors[0].0 {
         assert_eq!(
             error.to_string(),
-            "The value `2⁷` cannot fit into `i8` which has range `-128..=127`"
+            "The value `128` cannot fit into `i8` which has range `-128..=127`"
         );
     } else {
         panic!("Expected OverflowingAssignment error, got {:?}", errors[0].0);
diff --git a/compiler/noirc_frontend/src/tests/imports.rs b/compiler/noirc_frontend/src/tests/imports.rs
index dfdc60e15e4..8598d8296e5 100644
--- a/compiler/noirc_frontend/src/tests/imports.rs
+++ b/compiler/noirc_frontend/src/tests/imports.rs
@@ -21,6 +21,23 @@ fn use_super() {
     assert_no_errors(src);
 }
 
+#[test]
+fn no_super() {
+    let src = "use super::some_func;";
+    let errors = get_program_errors(src);
+    assert_eq!(errors.len(), 1);
+
+    let CompilationError::DefinitionError(DefCollectorErrorKind::PathResolutionError(
+        PathResolutionError::NoSuper(span),
+    )) = &errors[0].0
+    else {
+        panic!("Expected a 'no super' error, got {:?}", errors[0].0);
+    };
+
+    assert_eq!(span.start(), 4);
+    assert_eq!(span.end(), 9);
+}
+
 #[test]
 fn use_super_in_path() {
     let src = r#"
@@ -56,7 +73,7 @@ fn warns_on_use_of_private_exported_item() {
     "#;
 
     let errors = get_program_errors(src);
-    assert_eq!(errors.len(), 2); // An existing bug causes this error to be duplicated
+    assert_eq!(errors.len(), 1);
 
     assert!(matches!(
         &errors[0].0,
@@ -110,3 +127,30 @@ fn warns_on_re_export_of_item_with_less_visibility() {
         )
     ));
 }
+
+#[test]
+fn errors_if_using_alias_in_import() {
+    let src = r#"
+    mod foo {
+        pub type bar = i32;
+    }
+
+    use foo::bar::baz;
+
+    fn main() {
+    }
+    "#;
+
+    let errors = get_program_errors(src);
+    assert_eq!(errors.len(), 1);
+
+    let CompilationError::DefinitionError(DefCollectorErrorKind::PathResolutionError(
+        PathResolutionError::NotAModule { ident, kind },
+    )) = &errors[0].0
+    else {
+        panic!("Expected a 'not a module' error, got {:?}", errors[0].0);
+    };
+
+    assert_eq!(ident.to_string(), "bar");
+    assert_eq!(*kind, "type alias");
+}
diff --git a/compiler/noirc_frontend/src/tests/metaprogramming.rs b/compiler/noirc_frontend/src/tests/metaprogramming.rs
index d980cba5cfd..89a049ebc9d 100644
--- a/compiler/noirc_frontend/src/tests/metaprogramming.rs
+++ b/compiler/noirc_frontend/src/tests/metaprogramming.rs
@@ -1,6 +1,29 @@
-use crate::hir::def_collector::dc_crate::CompilationError;
+use noirc_errors::Spanned;
 
-use super::get_program_errors;
+use crate::{
+    ast::Ident,
+    hir::{
+        def_collector::{
+            dc_crate::CompilationError,
+            errors::{DefCollectorErrorKind, DuplicateType},
+        },
+        resolution::errors::ResolverError,
+        type_check::TypeCheckError,
+    },
+};
+
+use super::{assert_no_errors, get_program_errors};
+
+// Regression for #5388
+#[test]
+fn comptime_let() {
+    let src = r#"fn main() {
+        comptime let my_var = 2;
+        assert_eq(my_var, 2);
+    }"#;
+    let errors = get_program_errors(src);
+    assert_eq!(errors.len(), 0);
+}
 
 #[test]
 fn comptime_type_in_runtime_code() {
@@ -63,3 +86,78 @@ fn unquoted_integer_as_integer_token() {
 
     assert_no_errors(src);
 }
+
+#[test]
+fn allows_references_to_structs_generated_by_macros() {
+    let src = r#"
+    comptime fn make_new_struct(_s: StructDefinition) -> Quoted {
+        quote { struct Bar {} }
+    }
+
+    #[make_new_struct]
+    struct Foo {}
+
+    fn main() {
+        let _ = Foo {};
+        let _ = Bar {};
+    }
+    "#;
+
+    assert_no_errors(src);
+}
+
+#[test]
+fn errors_if_macros_inject_functions_with_name_collisions() {
+    let src = r#"
+    comptime fn make_colliding_functions(_s: StructDefinition) -> Quoted {
+        quote { 
+            fn foo() {}
+        }
+    }
+
+    #[make_colliding_functions]
+    struct Foo {}
+
+    #[make_colliding_functions]
+    struct Bar {}
+
+    fn main() {
+        let _ = Foo {};
+        let _ = Bar {};
+        foo();
+    }
+    "#;
+
+    let errors = get_program_errors(src);
+    assert_eq!(errors.len(), 1);
+    assert!(matches!(
+        &errors[0].0,
+        CompilationError::DefinitionError(
+            DefCollectorErrorKind::Duplicate {
+                typ: DuplicateType::Function,
+                first_def: Ident(Spanned { contents, .. }),
+                ..
+            },
+        ) if contents == "foo"
+    ));
+}
+
+#[test]
+fn uses_correct_type_for_attribute_arguments() {
+    let src = r#"
+    #[foo(32)]
+    comptime fn foo(_f: FunctionDefinition, i: u32) {
+        let y: u32 = 1;
+        let _ = y == i;
+    }
+
+    #[bar([0; 2])]
+    comptime fn bar(_f: FunctionDefinition, i: [u32; 2]) {
+        let y: u32 = 1;
+        let _ = y == i[0];
+    }
+
+    fn main() {}
+    "#;
+    assert_no_errors(src);
+}
diff --git a/compiler/noirc_frontend/src/tests/traits.rs b/compiler/noirc_frontend/src/tests/traits.rs
new file mode 100644
index 00000000000..811a32bab86
--- /dev/null
+++ b/compiler/noirc_frontend/src/tests/traits.rs
@@ -0,0 +1,654 @@
+use crate::hir::def_collector::dc_crate::CompilationError;
+use crate::hir::resolution::errors::ResolverError;
+use crate::hir::type_check::TypeCheckError;
+use crate::tests::{get_program_errors, get_program_with_maybe_parser_errors};
+
+use super::assert_no_errors;
+
+#[test]
+fn trait_inheritance() {
+    let src = r#"
+        pub trait Foo {
+            fn foo(self) -> Field;
+        }
+
+        pub trait Bar {
+            fn bar(self) -> Field;
+        }
+
+        pub trait Baz: Foo + Bar {
+            fn baz(self) -> Field;
+        }
+
+        pub fn foo<T>(baz: T) -> (Field, Field, Field) where T: Baz {
+            (baz.foo(), baz.bar(), baz.baz())
+        }
+
+        fn main() {}
+    "#;
+    assert_no_errors(src);
+}
+
+#[test]
+fn trait_inheritance_with_generics() {
+    let src = r#"
+        trait Foo<T> {
+            fn foo(self) -> T;
+        }
+
+        trait Bar<U>: Foo<U> {
+            fn bar(self);
+        }
+
+        pub fn foo<T>(x: T) -> i32 where T: Bar<i32> {
+            x.foo()
+        }
+
+        fn main() {}
+    "#;
+    assert_no_errors(src);
+}
+
+#[test]
+fn trait_inheritance_with_generics_2() {
+    let src = r#"
+        pub trait Foo<T> {
+            fn foo(self) -> T;
+        }
+
+        pub trait Bar<T, U>: Foo<T> {
+            fn bar(self) -> (T, U);
+        }
+
+        pub fn foo<T>(x: T) -> i32 where T: Bar<i32, i32> {
+            x.foo()
+        }
+
+        fn main() {}
+    "#;
+    assert_no_errors(src);
+}
+
+#[test]
+fn trait_inheritance_with_generics_3() {
+    let src = r#"
+        trait Foo<A> {}
+
+        trait Bar<B>: Foo<B> {}
+
+        impl Foo<i32> for () {}
+
+        impl Bar<i32> for () {}
+
+        fn main() {}
+    "#;
+    assert_no_errors(src);
+}
+
+#[test]
+fn trait_inheritance_with_generics_4() {
+    let src = r#"
+        trait Foo { type A; }
+
+        trait Bar<B>: Foo<A = B> {}
+
+        impl Foo for () { type A = i32; }
+
+        impl Bar<i32> for () {}
+
+        fn main() {}
+    "#;
+    assert_no_errors(src);
+}
+
+#[test]
+fn trait_inheritance_dependency_cycle() {
+    let src = r#"
+        trait Foo: Bar {}
+        trait Bar: Foo {}
+        fn main() {}
+    "#;
+    let errors = get_program_errors(src);
+    assert_eq!(errors.len(), 1);
+
+    assert!(matches!(
+        errors[0].0,
+        CompilationError::ResolverError(ResolverError::DependencyCycle { .. })
+    ));
+}
+
+#[test]
+fn trait_inheritance_missing_parent_implementation() {
+    let src = r#"
+        pub trait Foo {}
+
+        pub trait Bar: Foo {}
+
+        pub struct Struct {}
+
+        impl Bar for Struct {}
+
+        fn main() {
+            let _ = Struct {}; // silence Struct never constructed warning
+        }
+    "#;
+    let errors = get_program_errors(src);
+    assert_eq!(errors.len(), 1);
+
+    let CompilationError::ResolverError(ResolverError::TraitNotImplemented {
+        impl_trait,
+        missing_trait: the_trait,
+        type_missing_trait: typ,
+        ..
+    }) = &errors[0].0
+    else {
+        panic!("Expected a TraitNotImplemented error, got {:?}", &errors[0].0);
+    };
+
+    assert_eq!(the_trait, "Foo");
+    assert_eq!(typ, "Struct");
+    assert_eq!(impl_trait, "Bar");
+}
+
+#[test]
+fn errors_on_unknown_type_in_trait_where_clause() {
+    let src = r#"
+        pub trait Foo<T> where T: Unknown {}
+
+        fn main() {
+        }
+    "#;
+    let errors = get_program_errors(src);
+    assert_eq!(errors.len(), 1);
+}
+
+#[test]
+fn does_not_error_if_impl_trait_constraint_is_satisfied_for_concrete_type() {
+    let src = r#"
+        pub trait Greeter {
+            fn greet(self);
+        }
+
+        pub trait Foo<T>
+        where
+            T: Greeter,
+        {
+            fn greet<U>(object: U)
+            where
+                U: Greeter,
+            {
+                object.greet();
+            }
+        }
+
+        pub struct SomeGreeter;
+        impl Greeter for SomeGreeter {
+            fn greet(self) {}
+        }
+
+        pub struct Bar;
+
+        impl Foo<SomeGreeter> for Bar {}
+
+        fn main() {}
+    "#;
+    assert_no_errors(src);
+}
+
+#[test]
+fn does_not_error_if_impl_trait_constraint_is_satisfied_for_type_variable() {
+    let src = r#"
+        pub trait Greeter {
+            fn greet(self);
+        }
+
+        pub trait Foo<T> where T: Greeter {
+            fn greet(object: T) {
+                object.greet();
+            }
+        }
+
+        pub struct Bar;
+
+        impl<T> Foo<T> for Bar where T: Greeter {
+        }
+
+        fn main() {
+        }
+    "#;
+    assert_no_errors(src);
+}
+#[test]
+fn errors_if_impl_trait_constraint_is_not_satisfied() {
+    let src = r#"
+        pub trait Greeter {
+            fn greet(self);
+        }
+
+        pub trait Foo<T>
+        where
+            T: Greeter,
+        {
+            fn greet<U>(object: U)
+            where
+                U: Greeter,
+            {
+                object.greet();
+            }
+        }
+
+        pub struct SomeGreeter;
+
+        pub struct Bar;
+
+        impl Foo<SomeGreeter> for Bar {}
+
+        fn main() {}
+    "#;
+    let errors = get_program_errors(src);
+    assert_eq!(errors.len(), 1);
+
+    let CompilationError::ResolverError(ResolverError::TraitNotImplemented {
+        impl_trait,
+        missing_trait: the_trait,
+        type_missing_trait: typ,
+        ..
+    }) = &errors[0].0
+    else {
+        panic!("Expected a TraitNotImplemented error, got {:?}", &errors[0].0);
+    };
+
+    assert_eq!(the_trait, "Greeter");
+    assert_eq!(typ, "SomeGreeter");
+    assert_eq!(impl_trait, "Foo");
+}
+
+#[test]
+// Regression test for https://github.com/noir-lang/noir/issues/6314
+// Baz inherits from a single trait: Foo
+fn regression_6314_single_inheritance() {
+    let src = r#"
+        trait Foo {
+            fn foo(self) -> Self;
+        }
+        
+        trait Baz: Foo {}
+        
+        impl<T> Baz for T where T: Foo {}
+        
+        fn main() { }
+    "#;
+    assert_no_errors(src);
+}
+
+#[test]
+// Regression test for https://github.com/noir-lang/noir/issues/6314
+// Baz inherits from two traits: Foo and Bar
+fn regression_6314_double_inheritance() {
+    let src = r#"
+        trait Foo {
+            fn foo(self) -> Self;
+        }
+       
+        trait Bar {
+            fn bar(self) -> Self;
+        }
+       
+        trait Baz: Foo + Bar {}
+       
+        impl<T> Baz for T where T: Foo + Bar {}
+       
+        fn baz<T>(x: T) -> T where T: Baz {
+            x.foo().bar()
+        }
+       
+        impl Foo for Field {
+            fn foo(self) -> Self {
+                self + 1
+            }
+        }
+       
+        impl Bar for Field {
+            fn bar(self) -> Self {
+                self + 2
+            }
+        }
+       
+        fn main() {
+            assert(0.foo().bar() == baz(0));
+        }"#;
+
+    assert_no_errors(src);
+}
+
+#[test]
+fn trait_alias_single_member() {
+    let src = r#"
+        trait Foo {
+            fn foo(self) -> Self;
+        }
+       
+        trait Baz = Foo;
+
+        impl Foo for Field {
+            fn foo(self) -> Self { self }
+        }
+
+        fn baz<T>(x: T) -> T where T: Baz {
+            x.foo()
+        }
+
+        fn main() {
+            let x: Field = 0;
+            let _ = baz(x);
+        }
+    "#;
+    assert_no_errors(src);
+}
+
+#[test]
+fn trait_alias_two_members() {
+    let src = r#"
+        pub trait Foo {
+            fn foo(self) -> Self;
+        }
+       
+        pub trait Bar {
+            fn bar(self) -> Self;
+        }
+       
+        pub trait Baz = Foo + Bar;
+       
+        fn baz<T>(x: T) -> T where T: Baz {
+            x.foo().bar()
+        }
+       
+        impl Foo for Field {
+            fn foo(self) -> Self {
+                self + 1
+            }
+        }
+       
+        impl Bar for Field {
+            fn bar(self) -> Self {
+                self + 2
+            }
+        }
+       
+        fn main() {
+            assert(0.foo().bar() == baz(0));
+        }"#;
+
+    assert_no_errors(src);
+}
+
+#[test]
+fn trait_alias_polymorphic_inheritance() {
+    let src = r#"
+        trait Foo {
+            fn foo(self) -> Self;
+        }
+
+        trait Bar<T> {
+            fn bar(self) -> T;
+        }
+       
+        trait Baz<T> = Foo + Bar<T>;
+       
+        fn baz<T, U>(x: T) -> U where T: Baz<U> {
+            x.foo().bar()
+        }
+       
+        impl Foo for Field {
+            fn foo(self) -> Self {
+                self + 1
+            }
+        }
+       
+        impl Bar<bool> for Field {
+            fn bar(self) -> bool {
+                true
+            }
+        }
+       
+        fn main() {
+            assert(0.foo().bar() == baz(0));
+        }"#;
+
+    assert_no_errors(src);
+}
+
+// TODO(https://github.com/noir-lang/noir/issues/6467): currently fails with the
+// same errors as the desugared version
+#[test]
+fn trait_alias_polymorphic_where_clause() {
+    let src = r#"
+        trait Foo {
+            fn foo(self) -> Self;
+        }
+        
+        trait Bar<T> {
+            fn bar(self) -> T;
+        }
+        
+        trait Baz {
+            fn baz(self) -> bool;
+        }
+      
+        trait Qux<T> = Foo + Bar<T> where T: Baz;
+       
+        fn qux<T, U>(x: T) -> bool where T: Qux<U> {
+            x.foo().bar().baz()
+        }
+       
+        impl Foo for Field {
+            fn foo(self) -> Self {
+                self + 1
+            }
+        }
+        
+        impl Bar<bool> for Field {
+            fn bar(self) -> bool {
+                true
+            }
+        }
+        
+        impl Baz for bool {
+            fn baz(self) -> bool {
+                self
+            }
+        }
+        
+        fn main() {
+            assert(0.foo().bar().baz() == qux(0));
+        }
+    "#;
+
+    // TODO(https://github.com/noir-lang/noir/issues/6467)
+    // assert_no_errors(src);
+    let errors = get_program_errors(src);
+    assert_eq!(errors.len(), 2);
+
+    match &errors[0].0 {
+        CompilationError::TypeError(TypeCheckError::UnresolvedMethodCall {
+            method_name, ..
+        }) => {
+            assert_eq!(method_name, "baz");
+        }
+        other => {
+            panic!("expected UnresolvedMethodCall, but found {:?}", other);
+        }
+    }
+
+    match &errors[1].0 {
+        CompilationError::TypeError(TypeCheckError::NoMatchingImplFound(err)) => {
+            assert_eq!(err.constraints.len(), 2);
+            assert_eq!(err.constraints[0].1, "Baz");
+            assert_eq!(err.constraints[1].1, "Qux<_>");
+        }
+        other => {
+            panic!("expected NoMatchingImplFound, but found {:?}", other);
+        }
+    }
+}
+
+// TODO(https://github.com/noir-lang/noir/issues/6467): currently failing, so
+// this just tests that the trait alias has an equivalent error to the expected
+// desugared version
+#[test]
+fn trait_alias_with_where_clause_has_equivalent_errors() {
+    let src = r#"
+        trait Bar {
+            fn bar(self) -> Self;
+        }
+        
+        trait Baz {
+            fn baz(self) -> bool;
+        }
+        
+        trait Qux<T>: Bar where T: Baz {}
+        
+        impl<T, U> Qux<T> for U where
+            U: Bar,
+            T: Baz,
+        {}
+        
+        pub fn qux<T, U>(x: T, _: U) -> bool where U: Qux<T> {
+            x.baz()
+        }
+
+        fn main() {}
+    "#;
+
+    let alias_src = r#"
+        trait Bar {
+            fn bar(self) -> Self;
+        }
+        
+        trait Baz {
+            fn baz(self) -> bool;
+        }
+        
+        trait Qux<T> = Bar where T: Baz;
+        
+        pub fn qux<T, U>(x: T, _: U) -> bool where U: Qux<T> {
+            x.baz()
+        }
+
+        fn main() {}
+    "#;
+
+    let errors = get_program_errors(src);
+    let alias_errors = get_program_errors(alias_src);
+
+    assert_eq!(errors.len(), 1);
+    assert_eq!(alias_errors.len(), 1);
+
+    match (&errors[0].0, &alias_errors[0].0) {
+        (
+            CompilationError::TypeError(TypeCheckError::UnresolvedMethodCall {
+                method_name,
+                object_type,
+                ..
+            }),
+            CompilationError::TypeError(TypeCheckError::UnresolvedMethodCall {
+                method_name: alias_method_name,
+                object_type: alias_object_type,
+                ..
+            }),
+        ) => {
+            assert_eq!(method_name, alias_method_name);
+            assert_eq!(object_type, alias_object_type);
+        }
+        other => {
+            panic!("expected UnresolvedMethodCall, but found {:?}", other);
+        }
+    }
+}
+
+#[test]
+fn removes_assumed_parent_traits_after_function_ends() {
+    let src = r#"
+    trait Foo {}
+    trait Bar: Foo {}
+
+    pub fn foo<T>()
+    where
+        T: Bar,
+    {}
+
+    pub fn bar<T>()
+    where
+        T: Foo,
+    {}
+
+    fn main() {}
+    "#;
+    assert_no_errors(src);
+}
+
+#[test]
+fn trait_bounds_which_are_dependent_on_generic_types_are_resolved_correctly() {
+    // Regression test for https://github.com/noir-lang/noir/issues/6420
+    let src = r#"
+        trait Foo {
+            fn foo() -> Field;
+        }
+
+        trait Bar<T>: Foo {
+            fn bar(self) -> Field {
+                self.foo()
+            }
+        }
+
+        struct MyStruct<T> {
+            inner: Field,
+        }
+
+        trait MarkerTrait {}
+        impl MarkerTrait for Field {}
+
+        // `MyStruct<T>` implements `Foo` only when its generic type `T` implements `MarkerTrait`.
+        impl<T> Foo for MyStruct<T>
+        where
+            T: MarkerTrait,
+        {
+            fn foo() -> Field {
+                42
+            }
+        }
+
+        // We expect this to succeed as `MyStruct<T>` satisfies `Bar`'s trait bounds
+        // of implementing `Foo` when `T` implements `MarkerTrait`.
+        impl<T> Bar<T> for MyStruct<T>
+        where
+            T: MarkerTrait,
+        {
+            fn bar(self) -> Field {
+                31415
+            }
+        }
+
+        fn main() {
+            let foo: MyStruct<Field> = MyStruct { inner: 42 };
+            let _ = foo.bar();
+        }
+    "#;
+    assert_no_errors(src);
+}
+
+#[test]
+fn does_not_crash_on_as_trait_path_with_empty_path() {
+    let src = r#"
+        struct Foo {
+            x: <N>,
+        }
+
+        fn main() {}
+    "#;
+
+    let (_, _, errors) = get_program_with_maybe_parser_errors(
+        src, true, // allow parser errors
+    );
+    assert!(!errors.is_empty());
+}
diff --git a/compiler/noirc_frontend/src/tests/turbofish.rs b/compiler/noirc_frontend/src/tests/turbofish.rs
index 43d536fd196..3e34ea9521b 100644
--- a/compiler/noirc_frontend/src/tests/turbofish.rs
+++ b/compiler/noirc_frontend/src/tests/turbofish.rs
@@ -1,4 +1,8 @@
-use crate::hir::{def_collector::dc_crate::CompilationError, type_check::TypeCheckError};
+use crate::hir::{
+    def_collector::dc_crate::CompilationError,
+    resolution::{errors::ResolverError, import::PathResolutionError},
+    type_check::TypeCheckError,
+};
 
 use super::{assert_no_errors, get_program_errors};
 
@@ -29,11 +33,11 @@ fn turbofish_numeric_generic_nested_call() {
     }
 
     impl<T> Foo<T> {
-        fn static_method<let N: u32>() -> [u8; N] {
+        pub fn static_method<let N: u32>() -> [u8; N] {
             [0; N]
         }
 
-        fn impl_method<let N: u32>(self) -> [T; N] {
+        pub fn impl_method<let N: u32>(self) -> [T; N] {
             [self.a; N]
         }
     }
@@ -100,32 +104,6 @@ fn turbofish_in_constructor() {
     assert_eq!(expr_typ, "Field");
 }
 
-#[test]
-fn turbofish_in_middle_of_variable_unsupported_yet() {
-    let src = r#"
-    struct Foo<T> {
-        x: T
-    }
-
-    impl <T> Foo<T> {
-        fn new(x: T) -> Self {
-            Foo { x }
-        }
-    }
-
-    fn main() {
-        let _ = Foo::<i32>::new(1);
-    }
-    "#;
-    let errors = get_program_errors(src);
-    assert_eq!(errors.len(), 1);
-
-    assert!(matches!(
-        errors[0].0,
-        CompilationError::TypeError(TypeCheckError::UnsupportedTurbofishUsage { .. }),
-    ));
-}
-
 #[test]
 fn turbofish_in_struct_pattern() {
     let src = r#"
@@ -196,3 +174,286 @@ fn turbofish_in_struct_pattern_generic_count_mismatch() {
     assert_eq!(*expected, 1);
     assert_eq!(*found, 2);
 }
+
+#[test]
+fn numeric_turbofish() {
+    let src = r#"
+    struct Reader<let N: u32> {
+    }
+
+    impl<let N: u32> Reader<N> {
+        fn read<let C: u32>(_self: Self) {}
+    }
+
+    fn main() {
+        let reader: Reader<1234> = Reader {};
+        let _ = reader.read::<1234>();
+    }
+    "#;
+    assert_no_errors(src);
+}
+
+#[test]
+fn errors_if_turbofish_after_module() {
+    let src = r#"
+    mod moo {
+        pub fn foo() {}
+    }
+
+    fn main() {
+        moo::<i32>::foo();
+    }
+    "#;
+
+    let errors = get_program_errors(src);
+    assert_eq!(errors.len(), 1);
+
+    let CompilationError::ResolverError(ResolverError::PathResolutionError(
+        PathResolutionError::TurbofishNotAllowedOnItem { item, .. },
+    )) = &errors[0].0
+    else {
+        panic!("Expected a turbofish not allowed on item error, got {:?}", errors[0].0);
+    };
+    assert_eq!(item, "module `moo`");
+}
+
+#[test]
+fn turbofish_in_type_before_call_does_not_error() {
+    let src = r#"
+    struct Foo<T> {
+        x: T
+    }
+
+    impl <T> Foo<T> {
+        fn new(x: T) -> Self {
+            Foo { x }
+        }
+    }
+
+    fn main() {
+        let _ = Foo::<i32>::new(1);
+    }
+    "#;
+    assert_no_errors(src);
+}
+
+#[test]
+fn turbofish_in_type_before_call_errors() {
+    let src = r#"
+    struct Foo<T> {
+        x: T
+    }
+
+    impl <T> Foo<T> {
+        fn new(x: T) -> Self {
+            Foo { x }
+        }
+    }
+
+    fn main() {
+        let _ = Foo::<i32>::new(true);
+    }
+    "#;
+    let errors = get_program_errors(src);
+    assert_eq!(errors.len(), 1);
+
+    let CompilationError::TypeError(TypeCheckError::TypeMismatch {
+        expected_typ,
+        expr_typ,
+        expr_span: _,
+    }) = &errors[0].0
+    else {
+        panic!("Expected a type mismatch error, got {:?}", errors[0].0);
+    };
+
+    assert_eq!(expected_typ, "i32");
+    assert_eq!(expr_typ, "bool");
+}
+
+#[test]
+fn use_generic_type_alias_with_turbofish_in_method_call_does_not_error() {
+    let src = r#"
+        pub struct Foo<T> {
+        }
+
+        impl<T> Foo<T> {
+            fn new() -> Self {
+                Foo {}
+            }
+        }
+
+        type Bar<T> = Foo<T>;
+
+        fn foo() -> Foo<i32> {
+            Bar::<i32>::new()
+        }
+
+        fn main() {
+            let _ = foo();
+        }
+    "#;
+    assert_no_errors(src);
+}
+
+#[test]
+fn use_generic_type_alias_with_turbofish_in_method_call_errors() {
+    let src = r#"
+        pub struct Foo<T> {
+            x: T,
+        }
+
+        impl<T> Foo<T> {
+            fn new(x: T) -> Self {
+                Foo { x }
+            }
+        }
+
+        type Bar<T> = Foo<T>;
+
+        fn main() {
+            let _ = Bar::<i32>::new(true);
+        }
+    "#;
+    let errors = get_program_errors(src);
+    assert_eq!(errors.len(), 1);
+
+    let CompilationError::TypeError(TypeCheckError::TypeMismatch {
+        expected_typ,
+        expr_typ,
+        expr_span: _,
+    }) = &errors[0].0
+    else {
+        panic!("Expected a type mismatch error, got {:?}", errors[0].0);
+    };
+
+    assert_eq!(expected_typ, "i32");
+    assert_eq!(expr_typ, "bool");
+}
+
+#[test]
+fn use_generic_type_alias_with_partial_generics_with_turbofish_in_method_call_does_not_error() {
+    let src = r#"
+        pub struct Foo<T, U> {
+            x: T,
+            y: U,
+        }
+
+        impl<T, U> Foo<T, U> {
+            fn new(x: T, y: U) -> Self {
+                Foo { x, y }
+            }
+        }
+
+        type Bar<T> = Foo<T, i32>;
+
+        fn main() {
+            let _ = Bar::<bool>::new(true, 1);
+        }
+    "#;
+    assert_no_errors(src);
+}
+
+#[test]
+fn use_generic_type_alias_with_partial_generics_with_turbofish_in_method_call_errors_first_type() {
+    let src = r#"
+        pub struct Foo<T, U> {
+            x: T,
+            y: U,
+        }
+
+        impl<T, U> Foo<T, U> {
+            fn new(x: T, y: U) -> Self {
+                Foo { x, y }
+            }
+        }
+
+        type Bar<T> = Foo<T, i32>;
+
+        fn main() {
+            let _ = Bar::<bool>::new(1, 1);
+        }
+    "#;
+    let errors = get_program_errors(src);
+    assert_eq!(errors.len(), 1);
+
+    let CompilationError::TypeError(TypeCheckError::TypeMismatch {
+        expected_typ,
+        expr_typ,
+        expr_span: _,
+    }) = &errors[0].0
+    else {
+        panic!("Expected a type mismatch error, got {:?}", errors[0].0);
+    };
+
+    assert_eq!(expected_typ, "bool");
+    assert_eq!(expr_typ, "Field");
+}
+
+#[test]
+fn use_generic_type_alias_with_partial_generics_with_turbofish_in_method_call_errors_second_type() {
+    let src = r#"
+        pub struct Foo<T, U> {
+            x: T,
+            y: U,
+        }
+
+        impl<T, U> Foo<T, U> {
+            fn new(x: T, y: U) -> Self {
+                Foo { x, y }
+            }
+        }
+
+        type Bar<T> = Foo<T, i32>;
+
+        fn main() {
+            let _ = Bar::<bool>::new(true, true);
+        }
+    "#;
+    let errors = get_program_errors(src);
+    assert_eq!(errors.len(), 1);
+
+    let CompilationError::TypeError(TypeCheckError::TypeMismatch {
+        expected_typ,
+        expr_typ,
+        expr_span: _,
+    }) = &errors[0].0
+    else {
+        panic!("Expected a type mismatch error, got {:?}", errors[0].0);
+    };
+
+    assert_eq!(expected_typ, "i32");
+    assert_eq!(expr_typ, "bool");
+}
+
+#[test]
+fn trait_function_with_turbofish_on_trait_gives_error() {
+    let src = r#"
+    trait Foo<T> {
+        fn foo(_x: T) -> Self;
+    }
+
+    impl<T> Foo<T> for i32 {
+        fn foo(_x: T) -> Self {
+            1
+        }
+    }
+
+    fn main() {
+        let _: i32 = Foo::<bool>::foo(1);
+    }
+    "#;
+    let errors = get_program_errors(src);
+    assert_eq!(errors.len(), 1);
+
+    let CompilationError::TypeError(TypeCheckError::TypeMismatch {
+        expected_typ,
+        expr_typ,
+        expr_span: _,
+    }) = &errors[0].0
+    else {
+        panic!("Expected a type mismatch error, got {:?}", errors[0].0);
+    };
+
+    assert_eq!(expected_typ, "bool");
+    assert_eq!(expr_typ, "Field");
+}
diff --git a/compiler/noirc_frontend/src/tests/unused_items.rs b/compiler/noirc_frontend/src/tests/unused_items.rs
index a4d379b6358..c38e604f2c3 100644
--- a/compiler/noirc_frontend/src/tests/unused_items.rs
+++ b/compiler/noirc_frontend/src/tests/unused_items.rs
@@ -189,76 +189,150 @@ fn errors_on_unused_type_alias() {
 }
 
 #[test]
-fn errors_if_type_alias_aliases_more_private_type() {
+fn warns_on_unused_global() {
     let src = r#"
-    struct Foo {}
-    pub type Bar = Foo;
-    pub fn no_unused_warnings(_b: Bar) {
-        let _ = Foo {};
+    global foo: u32 = 1;
+    global bar: Field = 1;
+
+    fn main() {
+        let _ = bar;
     }
-    fn main() {}
     "#;
 
     let errors = get_program_errors(src);
     assert_eq!(errors.len(), 1);
 
-    let CompilationError::ResolverError(ResolverError::TypeIsMorePrivateThenItem {
-        typ, item, ..
-    }) = &errors[0].0
+    let CompilationError::ResolverError(ResolverError::UnusedItem { ident, item }) = &errors[0].0
     else {
-        panic!("Expected an unused item error");
+        panic!("Expected an unused item warning");
     };
 
-    assert_eq!(typ, "Foo");
-    assert_eq!(item, "Bar");
+    assert_eq!(ident.to_string(), "foo");
+    assert_eq!(item.item_type(), "global");
 }
 
 #[test]
-fn errors_if_type_alias_aliases_more_private_type_in_generic() {
+fn does_not_warn_on_unused_global_if_it_has_an_abi_attribute() {
     let src = r#"
-    pub struct Generic<T> { value: T }
-    struct Foo {}
-    pub type Bar = Generic<Foo>;
-    pub fn no_unused_warnings(_b: Bar) {
-        let _ = Foo {};
-        let _ = Generic { value: 1 };
+    contract foo {
+        #[abi(notes)]
+        global bar: u64 = 1;
     }
+
     fn main() {}
     "#;
+    assert_no_errors(src);
+}
+
+#[test]
+fn does_not_warn_on_unused_struct_if_it_has_an_abi_attribute() {
+    let src = r#"
+    #[abi(dummy)]
+    struct Foo { bar: u8 }
+
+    fn main() {}
+    "#;
+    assert_no_errors(src);
+}
+
+#[test]
+fn does_not_warn_on_unused_function_if_it_has_an_export_attribute() {
+    let src = r#"
+    #[export]
+    fn foo() {}
+
+    fn main() {}
+    "#;
+    assert_no_errors(src);
+}
+
+#[test]
+fn no_warning_on_inner_struct_when_parent_is_used() {
+    let src = r#"
+    struct Bar {
+        inner: [Field; 3],
+    }
+
+    struct Foo {
+        a: Field,
+        bar: Bar,
+    }
+
+    fn main(foos: [Foo; 1]) {
+        assert_eq(foos[0].a, 10);
+    }
+    "#;
 
     let errors = get_program_errors(src);
-    assert_eq!(errors.len(), 1);
+    assert_eq!(errors.len(), 0);
+}
 
-    let CompilationError::ResolverError(ResolverError::TypeIsMorePrivateThenItem {
-        typ, item, ..
-    }) = &errors[0].0
-    else {
-        panic!("Expected an unused item error");
-    };
+#[test]
+fn no_warning_on_struct_if_it_has_an_abi_attribute() {
+    let src = r#"
+    #[abi(functions)]
+    struct Foo {
+        a: Field,
+    }
 
-    assert_eq!(typ, "Foo");
-    assert_eq!(item, "Bar");
+    fn main() {}
+    "#;
+    assert_no_errors(src);
 }
 
 #[test]
-fn warns_on_unused_global() {
+fn no_warning_on_indirect_struct_if_it_has_an_abi_attribute() {
+    let src = r#"
+    struct Bar {
+        field: Field,
+    }
+
+    #[abi(functions)]
+    struct Foo {
+        bar: Bar,
+    }
+
+    fn main() {}
+    "#;
+    assert_no_errors(src);
+}
+
+#[test]
+fn no_warning_on_self_in_trait_impl() {
     let src = r#"
-    global foo = 1;
-    global bar = 1;
+    struct Bar {}
+
+    trait Foo {
+        fn foo(self, a: u64);
+    }
+
+    impl Foo for Bar {
+        fn foo(self, _a: u64) {}
+    }
 
     fn main() {
-        let _ = bar;
+        let _ = Bar {};
     }
     "#;
+    assert_no_errors(src);
+}
 
-    let errors = get_program_errors(src);
-    assert_eq!(errors.len(), 1);
+#[test]
+fn resolves_trait_where_clause_in_the_correct_module() {
+    // This is a regression test for https://github.com/noir-lang/noir/issues/6479
+    let src = r#"
+    mod foo {
+        pub trait Foo {}
+    }
 
-    let CompilationError::ResolverError(ResolverError::UnusedItem { ident, item }) = &errors[0].0
-    else {
-        panic!("Expected an unused item warning");
-    };
+    use foo::Foo;
 
-    assert_eq!(ident.to_string(), "foo");
-    assert_eq!(item.item_type(), "global");
+    pub trait Bar<T>
+    where
+        T: Foo,
+    {}
+
+    fn main() {}
+    "#;
+    assert_no_errors(src);
 }
diff --git a/compiler/noirc_frontend/src/tests/visibility.rs b/compiler/noirc_frontend/src/tests/visibility.rs
index e6c2680ea19..824a1de4c37 100644
--- a/compiler/noirc_frontend/src/tests/visibility.rs
+++ b/compiler/noirc_frontend/src/tests/visibility.rs
@@ -3,7 +3,7 @@ use crate::{
         def_collector::{dc_crate::CompilationError, errors::DefCollectorErrorKind},
         resolution::{errors::ResolverError, import::PathResolutionError},
     },
-    tests::get_program_errors,
+    tests::{assert_no_errors, get_program_errors},
 };
 
 #[test]
@@ -29,44 +29,339 @@ fn errors_once_on_unused_import_that_is_not_accessible() {
     ));
 }
 
+fn assert_type_is_more_private_than_item_error(src: &str, private_typ: &str, public_item: &str) {
+    let errors = get_program_errors(src);
+
+    assert!(!errors.is_empty(), "expected visibility error, got nothing");
+    for (error, _) in &errors {
+        let CompilationError::ResolverError(ResolverError::TypeIsMorePrivateThenItem {
+            typ,
+            item,
+            ..
+        }) = error
+        else {
+            panic!("Expected a type vs item visibility error, got {}", error);
+        };
+
+        assert_eq!(typ, private_typ);
+        assert_eq!(item, public_item);
+    }
+    assert_eq!(errors.len(), 1, "only expected one error");
+}
+
 #[test]
 fn errors_if_type_alias_aliases_more_private_type() {
     let src = r#"
     struct Foo {}
     pub type Bar = Foo;
+    pub fn no_unused_warnings() {
+        let _: Bar = Foo {};
+    }
+    fn main() {}
+    "#;
+    assert_type_is_more_private_than_item_error(src, "Foo", "Bar");
+}
 
-    pub fn no_unused_warnings(_b: Bar) {
+#[test]
+fn errors_if_type_alias_aliases_more_private_type_in_generic() {
+    let src = r#"
+    pub struct Generic<T> { value: T }
+    struct Foo {}
+    pub type Bar = Generic<Foo>;
+    pub fn no_unused_warnings() {
         let _ = Foo {};
+        let _: Bar = Generic { value: Foo {} };
+    }
+    fn main() {}
+    "#;
+    assert_type_is_more_private_than_item_error(src, "Foo", "Bar");
+}
+
+#[test]
+fn errors_if_pub_type_alias_leaks_private_type_in_generic() {
+    let src = r#"
+    pub mod moo {
+        struct Bar {}
+        pub struct Foo<T> { pub value: T }
+        pub type FooBar = Foo<Bar>;
+
+        pub fn no_unused_warnings() {
+            let _: FooBar = Foo { value: Bar {} };
+        }
+    }
+    fn main() {}
+    "#;
+    assert_type_is_more_private_than_item_error(src, "Bar", "FooBar");
+}
+
+#[test]
+fn errors_if_pub_struct_field_leaks_private_type_in_generic() {
+    let src = r#"
+    pub mod moo {
+        struct Bar {}
+        pub struct Foo<T> { pub value: T }
+        pub struct FooBar { pub value: Foo<Bar> }
+
+        pub fn no_unused_warnings() {
+            let _ = FooBar { value: Foo { value: Bar {} } };
+        }
+    }
+    fn main() {}
+    "#;
+    assert_type_is_more_private_than_item_error(src, "Bar", "FooBar::value");
+}
+
+#[test]
+fn errors_if_pub_function_leaks_private_type_in_return() {
+    let src = r#"
+    pub mod moo {
+        struct Bar {}
+
+        pub fn bar() -> Bar {
+            Bar {}
+        }
+    }
+    fn main() {}
+    "#;
+    assert_type_is_more_private_than_item_error(src, "Bar", "bar");
+}
+
+#[test]
+fn errors_if_pub_function_leaks_private_type_in_arg() {
+    let src = r#"
+    pub mod moo {
+        struct Bar {}
+        pub fn bar(_bar: Bar) {}
+
+        pub fn no_unused_warnings() {
+            let _ = Bar {};
+        }
+    }
+    fn main() {}
+    "#;
+    assert_type_is_more_private_than_item_error(src, "Bar", "bar");
+}
+
+#[test]
+fn does_not_error_if_pub_function_is_on_private_struct() {
+    let src = r#"
+    pub mod moo {
+        struct Bar {}
+
+        impl Bar { 
+            pub fn bar() -> Bar { 
+                Bar {}
+            }
+        }
+
+        pub fn no_unused_warnings() {
+            let _ = Bar {};
+        }
+    }
+    fn main() {}
+    "#;
+    assert_no_errors(src);
+}
+
+#[test]
+fn errors_if_pub_function_on_pub_struct_returns_private() {
+    let src = r#"
+    pub mod moo {
+        struct Bar {}
+        pub struct Foo {}
+
+        impl Foo { 
+            pub fn bar() -> Bar { 
+                Bar {}
+            }
+        }
+
+        pub fn no_unused_warnings() {
+            let _ = Foo {};            
+        }
+    }
+    fn main() {}
+    "#;
+    assert_type_is_more_private_than_item_error(src, "Bar", "bar");
+}
+
+#[test]
+fn does_not_error_if_pub_trait_is_defined_on_private_struct() {
+    let src = r#"
+    pub mod moo {
+        struct Bar {}
+
+        pub trait Foo { 
+            fn foo() -> Self;
+        }
+
+        impl Foo for Bar {
+            fn foo() -> Self { 
+                Bar {}
+            }
+        }
+
+        pub fn no_unused_warnings() {
+            let _ = Bar {};
+        }
     }
+    fn main() {}
+    "#;
+    assert_no_errors(src);
+}
+
+#[test]
+fn errors_if_pub_trait_returns_private_struct() {
+    let src = r#"
+    pub mod moo {
+        struct Bar {}
 
+        pub trait Foo { 
+            fn foo() -> Bar;
+        }
+
+        pub fn no_unused_warnings() {
+            let _ = Bar {};
+        }
+    }
     fn main() {}
     "#;
+    assert_type_is_more_private_than_item_error(src, "Bar", "foo");
+}
+
+#[test]
+fn errors_if_trying_to_access_public_function_inside_private_module() {
+    let src = r#"
+    mod foo {
+        mod bar {
+            pub fn baz() {}
+        }
+    }
+    fn main() {
+        foo::bar::baz()
+    }
+    "#;
 
     let errors = get_program_errors(src);
     assert_eq!(errors.len(), 1);
 
-    let CompilationError::ResolverError(ResolverError::TypeIsMorePrivateThenItem {
-        typ, item, ..
-    }) = &errors[0].0
+    let CompilationError::ResolverError(ResolverError::PathResolutionError(
+        PathResolutionError::Private(ident),
+    )) = &errors[0].0
     else {
-        panic!("Expected an unused item error");
+        panic!("Expected a private error");
     };
 
-    assert_eq!(typ, "Foo");
-    assert_eq!(item, "Bar");
+    assert_eq!(ident.to_string(), "bar");
 }
 
 #[test]
-fn errors_if_type_alias_aliases_more_private_type_in_generic() {
+fn warns_if_calling_private_struct_method() {
     let src = r#"
-    pub struct Generic<T> { value: T }
+    mod moo {
+        pub struct Foo {}
 
-    struct Foo {}
-    pub type Bar = Generic<Foo>;
+        impl Foo {
+            fn bar(self) {
+                let _ = self;
+            }
+        }
+    }
+
+    pub fn method(foo: moo::Foo) {
+        foo.bar()
+    }
+
+    fn main() {}
+    "#;
+
+    let errors = get_program_errors(src);
+    assert_eq!(errors.len(), 1);
+
+    let CompilationError::ResolverError(ResolverError::PathResolutionError(
+        PathResolutionError::Private(ident),
+    )) = &errors[0].0
+    else {
+        panic!("Expected a private error");
+    };
 
-    pub fn no_unused_warnings(_b: Bar) {
+    assert_eq!(ident.to_string(), "bar");
+}
+
+#[test]
+fn does_not_warn_if_calling_pub_crate_struct_method_from_same_crate() {
+    let src = r#"
+    mod moo {
+        pub struct Foo {}
+
+        impl Foo {
+            pub(crate) fn bar(self) {
+                let _ = self;
+            }
+        }
+    }
+
+    pub fn method(foo: moo::Foo) {
+        foo.bar()
+    }
+
+    fn main() {}
+    "#;
+    assert_no_errors(src);
+}
+
+#[test]
+fn does_not_error_if_calling_private_struct_function_from_same_struct() {
+    let src = r#"
+    struct Foo {
+
+    }
+
+    impl Foo {
+        fn foo() {
+            Foo::bar()
+        }
+
+        fn bar() {}
+    }
+
+    fn main() {
+        let _ = Foo {};
+    }
+    "#;
+    assert_no_errors(src);
+}
+
+#[test]
+fn does_not_error_if_calling_private_struct_function_from_same_module() {
+    let src = r#"
+    struct Foo;
+
+    impl Foo {
+        fn bar() -> Field {
+            0
+        }
+    }
+
+    fn main() {
         let _ = Foo {};
-        let _ = Generic { value: 1 };
+        assert_eq(Foo::bar(), 0);
+    }
+    "#;
+    assert_no_errors(src);
+}
+
+#[test]
+fn error_when_accessing_private_struct_field() {
+    let src = r#"
+    mod moo {
+        pub struct Foo {
+            x: Field
+        }
+    }
+
+    fn foo(foo: moo::Foo) -> Field {
+        foo.x
     }
 
     fn main() {}
@@ -75,32 +370,182 @@ fn errors_if_type_alias_aliases_more_private_type_in_generic() {
     let errors = get_program_errors(src);
     assert_eq!(errors.len(), 1);
 
-    let CompilationError::ResolverError(ResolverError::TypeIsMorePrivateThenItem {
-        typ, item, ..
-    }) = &errors[0].0
+    let CompilationError::ResolverError(ResolverError::PathResolutionError(
+        PathResolutionError::Private(ident),
+    )) = &errors[0].0
     else {
-        panic!("Expected an unused item error");
+        panic!("Expected a private error");
     };
 
-    assert_eq!(typ, "Foo");
-    assert_eq!(item, "Bar");
+    assert_eq!(ident.to_string(), "x");
 }
 
 #[test]
-fn errors_if_trying_to_access_public_function_inside_private_module() {
+fn does_not_error_when_accessing_private_struct_field_from_nested_module() {
+    let src = r#"
+    struct Foo {
+        x: Field
+    }
+
+    mod nested {
+        fn foo(foo: super::Foo) -> Field {
+            foo.x
+        }
+    }
+
+    fn main() {
+        let _ = Foo { x: 1 };
+    }
+    "#;
+    assert_no_errors(src);
+}
+
+#[test]
+fn does_not_error_when_accessing_pub_crate_struct_field_from_nested_module() {
+    let src = r#"
+    mod moo {
+        pub(crate) struct Foo {
+            pub(crate) x: Field
+        }
+    }
+
+    fn foo(foo: moo::Foo) -> Field {
+        foo.x
+    }
+
+    fn main() {
+        let _ = moo::Foo { x: 1 };
+    }
+    "#;
+    assert_no_errors(src);
+}
+
+#[test]
+fn error_when_using_private_struct_field_in_constructor() {
+    let src = r#"
+    mod moo {
+        pub struct Foo {
+            x: Field
+        }
+    }
+
+    fn main() {
+        let _ = moo::Foo { x: 1 };
+    }
+    "#;
+
+    let errors = get_program_errors(src);
+    assert_eq!(errors.len(), 1);
+
+    let CompilationError::ResolverError(ResolverError::PathResolutionError(
+        PathResolutionError::Private(ident),
+    )) = &errors[0].0
+    else {
+        panic!("Expected a private error");
+    };
+
+    assert_eq!(ident.to_string(), "x");
+}
+
+#[test]
+fn error_when_using_private_struct_field_in_struct_pattern() {
+    let src = r#"
+    mod moo {
+        pub struct Foo {
+            x: Field
+        }
+    }
+
+    fn foo(foo: moo::Foo) -> Field {
+        let moo::Foo { x } = foo;
+        x
+    }
+
+    fn main() {
+    }
+    "#;
+
+    let errors = get_program_errors(src);
+    assert_eq!(errors.len(), 1);
+
+    let CompilationError::ResolverError(ResolverError::PathResolutionError(
+        PathResolutionError::Private(ident),
+    )) = &errors[0].0
+    else {
+        panic!("Expected a private error");
+    };
+
+    assert_eq!(ident.to_string(), "x");
+}
+
+#[test]
+fn does_not_error_if_referring_to_top_level_private_module_via_crate() {
     let src = r#"
     mod foo {
-        mod bar {
-            pub fn baz() {}
+        pub fn bar() {}
+    }
+
+    use crate::foo::bar;
+
+    fn main() {
+        bar()
+    }
+    "#;
+    assert_no_errors(src);
+}
+
+#[test]
+fn visibility_bug_inside_comptime() {
+    let src = r#"
+    mod foo {
+        pub struct Foo {
+            inner: Field,
+        }
+    
+        impl Foo {
+            pub fn new(inner: Field) -> Self {
+                Self { inner }
+            }
         }
     }
+    
+    use foo::Foo;
+    
     fn main() {
-        foo::bar::baz()
+        let _ = Foo::new(5);
+        let _ = comptime { Foo::new(5) };
+    }
+    "#;
+    assert_no_errors(src);
+}
+
+#[test]
+fn errors_if_accessing_private_struct_member_inside_comptime_context() {
+    let src = r#"
+    mod foo {
+        pub struct Foo {
+            inner: Field,
+        }
+    
+        impl Foo {
+            pub fn new(inner: Field) -> Self {
+                Self { inner }
+            }
+        }
+    }
+    
+    use foo::Foo;
+    
+    fn main() {
+        comptime { 
+            let foo = Foo::new(5);
+            let _ = foo.inner;
+        };
     }
     "#;
 
     let errors = get_program_errors(src);
-    assert_eq!(errors.len(), 2); // There's a bug that duplicates this error
+    assert_eq!(errors.len(), 1);
 
     let CompilationError::ResolverError(ResolverError::PathResolutionError(
         PathResolutionError::Private(ident),
@@ -109,5 +554,47 @@ fn errors_if_trying_to_access_public_function_inside_private_module() {
         panic!("Expected a private error");
     };
 
-    assert_eq!(ident.to_string(), "bar");
+    assert_eq!(ident.to_string(), "inner");
+}
+
+#[test]
+fn errors_if_accessing_private_struct_member_inside_function_generated_at_comptime() {
+    let src = r#"
+    mod foo {
+        pub struct Foo {
+            foo_inner: Field,
+        }
+    }
+
+    use foo::Foo;
+
+    #[generate_inner_accessor]
+    struct Bar {
+        bar_inner: Foo,
+    }
+
+    comptime fn generate_inner_accessor(_s: StructDefinition) -> Quoted {
+        quote {
+            fn bar_get_foo_inner(x: Bar) -> Field {
+                x.bar_inner.foo_inner
+            }
+        }
+    }
+
+    fn main(x: Bar) {
+        let _ = bar_get_foo_inner(x);
+    }
+    "#;
+
+    let errors = get_program_errors(src);
+    assert_eq!(errors.len(), 1);
+
+    let CompilationError::ResolverError(ResolverError::PathResolutionError(
+        PathResolutionError::Private(ident),
+    )) = &errors[0].0
+    else {
+        panic!("Expected a private error");
+    };
+
+    assert_eq!(ident.to_string(), "foo_inner");
 }
diff --git a/compiler/noirc_frontend/src/usage_tracker.rs b/compiler/noirc_frontend/src/usage_tracker.rs
index 275ca1f964b..6987358ddb7 100644
--- a/compiler/noirc_frontend/src/usage_tracker.rs
+++ b/compiler/noirc_frontend/src/usage_tracker.rs
@@ -3,8 +3,7 @@ use std::collections::HashMap;
 use crate::{
     ast::{Ident, ItemVisibility},
     hir::def_map::ModuleId,
-    macros_api::StructId,
-    node_interner::{FuncId, GlobalId, TraitId, TypeAliasId},
+    node_interner::{FuncId, GlobalId, StructId, TraitId, TypeAliasId},
 };
 
 #[derive(Debug, Copy, Clone, PartialEq, Eq)]
@@ -36,6 +35,8 @@ pub struct UsageTracker {
 }
 
 impl UsageTracker {
+    /// Register an item as unused, waiting to be marked as used later.
+    /// Things that should not emit warnings should not be added at all.
     pub(crate) fn add_unused_item(
         &mut self,
         module_id: ModuleId,
@@ -74,7 +75,8 @@ impl UsageTracker {
         };
     }
 
-    pub(crate) fn unused_items(&self) -> &HashMap<ModuleId, HashMap<Ident, UnusedItem>> {
+    /// Get all the unused items per module.
+    pub fn unused_items(&self) -> &HashMap<ModuleId, HashMap<Ident, UnusedItem>> {
         &self.unused_items
     }
 }
diff --git a/compiler/noirc_printable_type/Cargo.toml b/compiler/noirc_printable_type/Cargo.toml
index 8bb56703e8a..8d0574aad64 100644
--- a/compiler/noirc_printable_type/Cargo.toml
+++ b/compiler/noirc_printable_type/Cargo.toml
@@ -14,7 +14,6 @@ workspace = true
 [dependencies]
 acvm.workspace = true
 iter-extended.workspace = true
-regex = "1.9.1"
 serde.workspace = true
 serde_json.workspace = true
 thiserror.workspace = true
diff --git a/compiler/noirc_printable_type/src/lib.rs b/compiler/noirc_printable_type/src/lib.rs
index 5ab04c6f576..6ae187da27f 100644
--- a/compiler/noirc_printable_type/src/lib.rs
+++ b/compiler/noirc_printable_type/src/lib.rs
@@ -2,7 +2,7 @@ use std::{collections::BTreeMap, str};
 
 use acvm::{acir::AcirField, brillig_vm::brillig::ForeignCallParam};
 use iter_extended::vecmap;
-use regex::{Captures, Regex};
+
 use serde::{Deserialize, Serialize};
 use thiserror::Error;
 
@@ -69,6 +69,9 @@ pub enum PrintableValueDisplay<F> {
 
 #[derive(Debug, Error)]
 pub enum ForeignCallError {
+    #[error("No handler could be found for foreign call `{0}`")]
+    NoHandler(String),
+
     #[error("Foreign call inputs needed for execution are missing")]
     MissingForeignCallInputs,
 
@@ -250,24 +253,6 @@ fn to_string<F: AcirField>(value: &PrintableValue<F>, typ: &PrintableType) -> Op
     Some(output)
 }
 
-// Taken from Regex docs directly
-fn replace_all<E>(
-    re: &Regex,
-    haystack: &str,
-    mut replacement: impl FnMut(&Captures) -> Result<String, E>,
-) -> Result<String, E> {
-    let mut new = String::with_capacity(haystack.len());
-    let mut last_match = 0;
-    for caps in re.captures_iter(haystack) {
-        let m = caps.get(0).unwrap();
-        new.push_str(&haystack[last_match..m.start()]);
-        new.push_str(&replacement(&caps)?);
-        last_match = m.end();
-    }
-    new.push_str(&haystack[last_match..]);
-    Ok(new)
-}
-
 impl<F: AcirField> std::fmt::Display for PrintableValueDisplay<F> {
     fn fmt(&self, fmt: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
         match self {
@@ -276,18 +261,74 @@ impl<F: AcirField> std::fmt::Display for PrintableValueDisplay<F> {
                 write!(fmt, "{output_string}")
             }
             Self::FmtString(template, values) => {
-                let mut display_iter = values.iter();
-                let re = Regex::new(r"\{([a-zA-Z0-9_]+)\}").map_err(|_| std::fmt::Error)?;
+                let mut values_iter = values.iter();
+                write_template_replacing_interpolations(template, fmt, || {
+                    values_iter.next().and_then(|(value, typ)| to_string(value, typ))
+                })
+            }
+        }
+    }
+}
+
+fn write_template_replacing_interpolations(
+    template: &str,
+    fmt: &mut std::fmt::Formatter<'_>,
+    mut replacement: impl FnMut() -> Option<String>,
+) -> std::fmt::Result {
+    let mut last_index = 0; // How far we've written from the template
+    let mut char_indices = template.char_indices().peekable();
+    while let Some((char_index, char)) = char_indices.next() {
+        // If we see a '}' it must be "}}" because the ones for interpolation are handled
+        // when we see '{'
+        if char == '}' {
+            // Write what we've seen so far in the template, including this '}'
+            write!(fmt, "{}", &template[last_index..=char_index])?;
+
+            // Skip the second '}'
+            let (_, closing_curly) = char_indices.next().unwrap();
+            assert_eq!(closing_curly, '}');
+
+            last_index = char_indices.peek().map(|(index, _)| *index).unwrap_or(template.len());
+            continue;
+        }
+
+        // Keep going forward until we find a '{'
+        if char != '{' {
+            continue;
+        }
+
+        // We'll either have to write an interpolation or '{{' if it's an escape,
+        // so let's write what we've seen so far in the template.
+        write!(fmt, "{}", &template[last_index..char_index])?;
+
+        // If it's '{{', write '{' and keep going
+        if char_indices.peek().map(|(_, char)| char) == Some(&'{') {
+            write!(fmt, "{{")?;
 
-                let formatted_str = replace_all(&re, template, |_: &Captures| {
-                    let (value, typ) = display_iter.next().ok_or(std::fmt::Error)?;
-                    to_string(value, typ).ok_or(std::fmt::Error)
-                })?;
+            // Skip the second '{'
+            char_indices.next().unwrap();
 
-                write!(fmt, "{formatted_str}")
+            last_index = char_indices.peek().map(|(index, _)| *index).unwrap_or(template.len());
+            continue;
+        }
+
+        // Write the interpolation
+        if let Some(string) = replacement() {
+            write!(fmt, "{}", string)?;
+        } else {
+            return Err(std::fmt::Error);
+        }
+
+        // Whatever was inside '{...}' doesn't matter, so skip until we find '}'
+        while let Some((_, char)) = char_indices.next() {
+            if char == '}' {
+                last_index = char_indices.peek().map(|(index, _)| *index).unwrap_or(template.len());
+                break;
             }
         }
     }
+
+    write!(fmt, "{}", &template[last_index..])
 }
 
 /// This trims any leading zeroes.
@@ -387,3 +428,41 @@ pub fn decode_string_value<F: AcirField>(field_elements: &[F]) -> String {
     let final_string = str::from_utf8(&string_as_slice).unwrap();
     final_string.to_owned()
 }
+
+#[cfg(test)]
+mod tests {
+    use acvm::FieldElement;
+
+    use crate::{PrintableType, PrintableValue, PrintableValueDisplay};
+
+    #[test]
+    fn printable_value_display_to_string_without_interpolations() {
+        let template = "hello";
+        let display =
+            PrintableValueDisplay::<FieldElement>::FmtString(template.to_string(), vec![]);
+        assert_eq!(display.to_string(), template);
+    }
+
+    #[test]
+    fn printable_value_display_to_string_with_curly_escapes() {
+        let template = "hello {{world}} {{{{double_escape}}}}";
+        let expected = "hello {world} {{double_escape}}";
+        let display =
+            PrintableValueDisplay::<FieldElement>::FmtString(template.to_string(), vec![]);
+        assert_eq!(display.to_string(), expected);
+    }
+
+    #[test]
+    fn printable_value_display_to_string_with_interpolations() {
+        let template = "hello {one} {{no}} {two} {{not_again}} {three} world";
+        let values = vec![
+            (PrintableValue::String("ONE".to_string()), PrintableType::String { length: 3 }),
+            (PrintableValue::String("TWO".to_string()), PrintableType::String { length: 3 }),
+            (PrintableValue::String("THREE".to_string()), PrintableType::String { length: 5 }),
+        ];
+        let expected = "hello ONE {no} TWO {not_again} THREE world";
+        let display =
+            PrintableValueDisplay::<FieldElement>::FmtString(template.to_string(), values);
+        assert_eq!(display.to_string(), expected);
+    }
+}
diff --git a/compiler/wasm/Cargo.toml b/compiler/wasm/Cargo.toml
index c8b8c3bb06e..9951b23f609 100644
--- a/compiler/wasm/Cargo.toml
+++ b/compiler/wasm/Cargo.toml
@@ -1,10 +1,12 @@
 [package]
 name = "noir_wasm"
+description = "A JS interface to the Noir compiler"
 version.workspace = true
 authors.workspace = true
 edition.workspace = true
 rust-version.workspace = true
 license.workspace = true
+repository.workspace = true
 
 [lints]
 workspace = true
@@ -42,4 +44,4 @@ getrandom = { workspace = true, features = ["js"] }
 rust-embed = { workspace = true, features = ["debug-embed"] }
 
 [build-dependencies]
-build-data.workspace = true
\ No newline at end of file
+build-data.workspace = true
diff --git a/compiler/wasm/LICENSE-APACHE b/compiler/wasm/LICENSE-APACHE
new file mode 100644
index 00000000000..261eeb9e9f8
--- /dev/null
+++ b/compiler/wasm/LICENSE-APACHE
@@ -0,0 +1,201 @@
+                                 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/compiler/wasm/LICENSE-MIT b/compiler/wasm/LICENSE-MIT
new file mode 100644
index 00000000000..a93d7f55c8e
--- /dev/null
+++ b/compiler/wasm/LICENSE-MIT
@@ -0,0 +1,21 @@
+MIT License
+
+ Copyright (c) 2021-2023 noir-lang
+
+ Permission is hereby granted, free of charge, to any person obtaining a copy
+ of this software and associated documentation files (the "Software"), to deal
+ in the Software without restriction, including without limitation the rights
+ to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ copies of the Software, and to permit persons to whom the Software is
+ furnished to do so, subject to the following conditions:
+
+ The above copyright notice and this permission notice shall be included in all
+ copies or substantial portions of the Software.
+
+ THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ SOFTWARE.
diff --git a/compiler/wasm/package.json b/compiler/wasm/package.json
index e20abe5f4ff..946ba8dc699 100644
--- a/compiler/wasm/package.json
+++ b/compiler/wasm/package.json
@@ -3,7 +3,7 @@
   "contributors": [
     "The Noir Team <team@noir-lang.org>"
   ],
-  "version": "0.34.0",
+  "version": "1.0.0-beta.0",
   "license": "(MIT OR Apache-2.0)",
   "main": "dist/main.js",
   "types": "./dist/types/src/index.d.cts",
diff --git a/compiler/wasm/src/compile.rs b/compiler/wasm/src/compile.rs
index 05f42bc91a1..e823f90add5 100644
--- a/compiler/wasm/src/compile.rs
+++ b/compiler/wasm/src/compile.rs
@@ -180,6 +180,13 @@ pub fn compile_program(
             .0;
 
     let optimized_program = nargo::ops::transform_program(compiled_program, expression_width);
+    nargo::ops::check_program(&optimized_program).map_err(|errs| {
+        CompileError::with_file_diagnostics(
+            "Compiled program is not solvable",
+            errs,
+            &context.file_manager,
+        )
+    })?;
     let warnings = optimized_program.warnings.clone();
 
     Ok(JsCompileProgramResult::new(optimized_program.into(), warnings))
diff --git a/compiler/wasm/src/compile_new.rs b/compiler/wasm/src/compile_new.rs
index ef2af1dd654..ac2f79147b3 100644
--- a/compiler/wasm/src/compile_new.rs
+++ b/compiler/wasm/src/compile_new.rs
@@ -118,6 +118,13 @@ impl CompilerContext {
                 .0;
 
         let optimized_program = nargo::ops::transform_program(compiled_program, expression_width);
+        nargo::ops::check_program(&optimized_program).map_err(|errs| {
+            CompileError::with_file_diagnostics(
+                "Compiled program is not solvable",
+                errs,
+                &self.context.file_manager,
+            )
+        })?;
         let warnings = optimized_program.warnings.clone();
 
         Ok(JsCompileProgramResult::new(optimized_program.into(), warnings))
diff --git a/compiler/wasm/tsconfig.json b/compiler/wasm/tsconfig.json
index d2ae58b8fc9..42c7396aa83 100644
--- a/compiler/wasm/tsconfig.json
+++ b/compiler/wasm/tsconfig.json
@@ -18,4 +18,4 @@
     "allowJs": true,
   },
   "exclude": ["node_modules"]
-}
\ No newline at end of file
+}
diff --git a/cspell.json b/cspell.json
index dbc5fb5a43e..5c707e92e21 100644
--- a/cspell.json
+++ b/cspell.json
@@ -14,6 +14,7 @@
         "arithmetization",
         "arity",
         "arkworks",
+        "autoload",
         "backpropagate",
         "Backpropagation",
         "barebones",
@@ -37,7 +38,10 @@
         "callsites",
         "callstack",
         "callstacks",
+        "canonicalization",
         "canonicalize",
+        "canonicalized",
+        "canonicalizing",
         "castable",
         "catmcgee",
         "Celo",
@@ -51,6 +55,7 @@
         "codespan",
         "coeff",
         "combinators",
+        "compinit",
         "comptime",
         "cpus",
         "cranelift",
@@ -91,6 +96,7 @@
         "forall",
         "foralls",
         "formatcp",
+        "fpath",
         "frontends",
         "fuzzer",
         "fxhash",
@@ -100,6 +106,7 @@
         "Guillaume",
         "gzipped",
         "hasher",
+        "heaptrack",
         "hexdigit",
         "higher-kinded",
         "Hindley-Milner",
@@ -148,6 +155,7 @@
         "nargo",
         "neovim",
         "newtype",
+        "nextest",
         "nightlies",
         "nixpkgs",
         "noirc",
@@ -164,20 +172,25 @@
         "plonkc",
         "PLONKish",
         "pprof",
+        "precomputes",
+        "preheader",
         "preimage",
         "preprocess",
         "prettytable",
         "printstd",
         "proptest",
+        "proptests",
         "pseudocode",
         "pubkey",
         "quantile",
         "quasiquote",
         "rangemap",
+        "refcount",
         "repr",
         "reqwest",
         "rfind",
         "rustc",
+        "rustfmt",
         "rustup",
         "sboxed",
         "schnorr",
@@ -195,7 +208,10 @@
         "structs",
         "subexpression",
         "subshell",
+        "subtrait",
         "subtyping",
+        "supertrait",
+        "supertraits",
         "swcurve",
         "Taiko",
         "tarjan",
@@ -223,9 +239,12 @@
         "varargs",
         "vecmap",
         "vitkov",
+        "walkdir",
         "wasi",
         "wasmer",
         "Weierstraß",
+        "whitespace",
+        "whitespaces",
         "zkhash",
         "zshell"
     ],
diff --git a/deny.toml b/deny.toml
index 2d6d3e658b5..661c8095281 100644
--- a/deny.toml
+++ b/deny.toml
@@ -6,8 +6,9 @@ version = 2
 yanked = "warn"
 
 ignore = [
-    "RUSTSEC-2020-0168", # mach unmaintained
-    "RUSTSEC-2020-0016"  # net2 unmaintained
+    "RUSTSEC-2024-0388", # derivative unmaintained
+    "RUSTSEC-2024-0384", # instant unmaintained
+    "RUSTSEC-2020-0016", # net2 unmaintained
 ]
 
 # This section is considered when running `cargo deny check bans`.
@@ -49,16 +50,13 @@ allow = [
     "ISC",
     "0BSD",
     "Unicode-DFS-2016",
+    "Unicode-3.0",
     "Unlicense",
     "Zlib",
-    # https://github.com/briansmith/ring/issues/902
-    "LicenseRef-ring",
-    # https://github.com/rustls/webpki/blob/main/LICENSE ISC Style
-    "LicenseRef-rustls-webpki",
     # bitmaps 2.1.0, im 15.1.0
     "MPL-2.0",
     # Boost Software License
-    "BSL-1.0"
+    "BSL-1.0",
 ]
 
 # Allow 1 or more licenses on a per-crate basis, so that particular licenses
@@ -76,16 +74,6 @@ exceptions = [
     { allow = ["CDDL-1.0"], name = "inferno" },
 ]
 
-[[licenses.clarify]]
-name = "ring"
-expression = "LicenseRef-ring"
-license-files = [{ path = "LICENSE", hash = 0xbd0eed23 }]
-
-[[licenses.clarify]]
-name = "rustls-webpki"
-expression = "LicenseRef-rustls-webpki"
-license-files = [{ path = "LICENSE", hash = 0x001c7e6c }]
-
 # This section is considered when running `cargo deny check sources`.
 # More documentation about the 'sources' section can be found here:
 # https://embarkstudios.github.io/cargo-deny/checks/sources/cfg.html
@@ -101,7 +89,4 @@ unknown-git = "deny"
 #
 # crates.io rejects git dependencies so anything depending on these is unpublishable and you'll ruin my day
 # when I find out.
-allow-git = [
-    "https://github.com/jfecher/chumsky",
-    "https://github.com/noir-lang/clap-markdown",
-]
+allow-git = ["https://github.com/noir-lang/clap-markdown"]
diff --git a/docs/.gitignore b/docs/.gitignore
index 501e7e465ea..7ff8bd69a72 100644
--- a/docs/.gitignore
+++ b/docs/.gitignore
@@ -25,3 +25,4 @@ yarn-error.log*
 
 package-lock.json
 versions.json
+.supermavenignore
diff --git a/docs/.markdownlint.json b/docs/.markdownlint.json
deleted file mode 100644
index 40896b4542f..00000000000
--- a/docs/.markdownlint.json
+++ /dev/null
@@ -1,3 +0,0 @@
-{
-    "no-missing-space-atx": false
-}
diff --git a/docs/README.md b/docs/README.md
index c1d2bbd6d4e..d3554ae39f2 100644
--- a/docs/README.md
+++ b/docs/README.md
@@ -28,7 +28,13 @@ yarn build
 ### Local Development
 
 ```
-yarn workspace docs start
+yarn workspace docs version
+```
+
+This command fetches and compiles the list of documentation versions to build with.
+
+```
+yarn workspace docs dev
 ```
 
 This command starts a local development server and opens up a browser window. Most changes are
diff --git a/docs/docs/explainers/explainer-recursion.md b/docs/docs/explainers/explainer-recursion.md
index 18846176ca7..df8529ef4e0 100644
--- a/docs/docs/explainers/explainer-recursion.md
+++ b/docs/docs/explainers/explainer-recursion.md
@@ -111,7 +111,7 @@ He might find it more efficient to generate a proof for that setup phase separat
 
 ## What params do I need
 
-As you can see in the [recursion reference](noir/standard_library/recursion.md), a simple recursive proof requires:
+As you can see in the [recursion reference](noir/standard_library/recursion.mdx), a simple recursive proof requires:
 
 - The proof to verify
 - The Verification Key of the circuit that generated the proof
diff --git a/docs/docs/explainers/explainer-writing-noir.md b/docs/docs/explainers/explainer-writing-noir.md
index 3ef6e014a2f..3ce4245dc45 100644
--- a/docs/docs/explainers/explainer-writing-noir.md
+++ b/docs/docs/explainers/explainer-writing-noir.md
@@ -1,6 +1,6 @@
 ---
-title: Writing Performant Noir
-description: Understand new considerations when writing Noir
+title: Thinking in Circuits
+description: Considerations when writing Noir programs
 keywords: [Noir, programming, rust]
 tags: [Optimization]
 sidebar_position: 0
diff --git a/docs/docs/getting_started/noir_installation.md b/docs/docs/getting_started/noir_installation.md
new file mode 100644
index 00000000000..05f036d4f6d
--- /dev/null
+++ b/docs/docs/getting_started/noir_installation.md
@@ -0,0 +1,106 @@
+---
+title: Standalone Noir Installation
+description: There are different ways to install Nargo, the one-stop shop and command-line tool for developing Noir programs. This guide explains how to specify which version to install when using noirup, and using WSL for windows.
+keywords: [
+    Installation
+    Nargo
+    Noirup
+    Binaries
+    Compiling from Source
+    WSL for Windows
+    macOS
+    Linux
+    Nix
+    Direnv
+    Uninstalling Nargo
+  ]
+sidebar_position: 2
+---
+
+Noirup is the endorsed method for installing Nargo, streamlining the process of fetching binaries or compiling from source. It supports a range of options to cater to your specific needs, from nightly builds and specific versions to compiling from various sources.
+
+### Installing Noirup
+
+First, ensure you have `noirup` installed:
+
+```sh
+curl -L https://raw.githubusercontent.com/noir-lang/noirup/main/install | bash
+```
+
+### Fetching Binaries
+
+With `noirup`, you can easily switch between different Nargo versions, including nightly builds:
+
+- **Nightly Version**: Install the latest nightly build.
+
+  ```sh
+  noirup --version nightly
+  ```
+
+- **Specific Version**: Install a specific version of Nargo.
+
+  ```sh
+  noirup --version <version>
+  ```
+
+### Compiling from Source
+
+`noirup` also enables compiling Nargo from various sources:
+
+- **From a Specific Branch**: Install from the latest commit on a branch.
+
+  ```sh
+  noirup --branch <branch-name>
+  ```
+
+- **From a Fork**: Install from the main branch of a fork.
+
+  ```sh
+  noirup --repo <username/repo>
+  ```
+
+- **From a Specific Branch in a Fork**: Install from a specific branch in a fork.
+
+  ```sh
+  noirup --repo <username/repo> --branch <branch-name>
+  ```
+
+- **From a Specific Pull Request**: Install from a specific PR.
+
+  ```sh
+  noirup --pr <pr-number>
+  ```
+
+- **From a Specific Commit**: Install from a specific commit.
+
+  ```sh
+  noirup -C <commit-hash>
+  ```
+
+- **From Local Source**: Compile and install from a local directory.
+
+  ```sh
+  noirup --path ./path/to/local/source
+  ```
+
+## Installation on Windows
+
+The default backend for Noir (Barretenberg) doesn't provide Windows binaries at this time. For that reason, Noir cannot be installed natively. However, it is available by using Windows Subsystem for Linux (WSL).
+
+Step 1: Follow the instructions [here](https://learn.microsoft.com/en-us/windows/wsl/install) to install and run WSL.
+
+step 2: Follow the [Noirup instructions](#installing-noirup).
+
+## Setting up shell completions
+
+Once `nargo` is installed, you can [set up shell completions for it](setting_up_shell_completions.md).
+
+## Uninstalling Nargo
+
+If you installed Nargo with `noirup`, you can uninstall Nargo by removing the files in `~/.nargo`, `~/nargo`, and `~/noir_cache`. This ensures that all installed binaries, configurations, and cache related to Nargo are fully removed from your system.
+
+```bash
+rm -r ~/.nargo
+rm -r ~/nargo
+rm -r ~/noir_cache
+```
diff --git a/docs/docs/getting_started/project_breakdown.md b/docs/docs/getting_started/project_breakdown.md
new file mode 100644
index 00000000000..e442e377040
--- /dev/null
+++ b/docs/docs/getting_started/project_breakdown.md
@@ -0,0 +1,159 @@
+---
+title: Project Breakdown
+description:
+  Learn about the anatomy of a Nargo project, including the purpose of the Prover TOML
+  file, and how to prove and verify your program.
+keywords:
+  [Nargo, Nargo project, Prover.toml, proof verification, private asset transfer]
+sidebar_position: 1
+---
+
+This section breaks down our hello world program from the previous section.
+
+## Anatomy of a Nargo Project
+
+Upon creating a new project with `nargo new` and building the in/output files with `nargo check`
+commands, you would get a minimal Nargo project of the following structure:
+
+    - src
+    - Prover.toml
+    - Nargo.toml
+
+The source directory _src_ holds the source code for your Noir program. By default only a _main.nr_
+file will be generated within it.
+
+### Prover.toml
+
+_Prover.toml_ is used for specifying the input values for executing and proving the program. You can specify `toml` files with different names by using the `--prover-name` or `-p` flags, see the [Prover](#provertoml) section below. Optionally you may specify expected output values for prove-time checking as well.
+
+### Nargo.toml
+
+_Nargo.toml_ contains the environmental options of your project. It contains a "package" section and a "dependencies" section.
+
+Example Nargo.toml:
+
+```toml
+[package]
+name = "noir_starter"
+type = "bin"
+authors = ["Alice"]
+compiler_version = "0.9.0"
+description = "Getting started with Noir"
+entry = "circuit/main.nr"
+license = "MIT"
+
+[dependencies]
+ecrecover = {tag = "v0.9.0", git = "https://github.com/colinnielsen/ecrecover-noir.git"}
+```
+
+Nargo.toml for a [workspace](../noir/modules_packages_crates/workspaces.md) will look a bit different. For example:
+
+```toml
+[workspace]
+members = ["crates/a", "crates/b"]
+default-member = "crates/a"
+```
+
+#### Package section
+
+The package section defines a number of fields including:
+
+- `name` (**required**) - the name of the package
+- `type` (**required**) - can be "bin", "lib", or "contract" to specify whether its a binary, library or Aztec contract
+- `authors` (optional) - authors of the project
+- `compiler_version` - specifies the version of the compiler to use. This is enforced by the compiler and follow's [Rust's versioning](https://doc.rust-lang.org/cargo/reference/manifest.html#the-version-field), so a `compiler_version = 0.18.0` will enforce Nargo version 0.18.0, `compiler_version = ^0.18.0` will enforce anything above 0.18.0 but below 0.19.0, etc. For more information, see how [Rust handles these operators](https://docs.rs/semver/latest/semver/enum.Op.html)
+- `description` (optional)
+- `entry` (optional) - a relative filepath to use as the entry point into your package (overrides the default of `src/lib.nr` or `src/main.nr`)
+- `backend` (optional)
+- `license` (optional)
+- `expression_width` (optional) - Sets the default backend expression width. This field will override the default backend expression width specified by the Noir compiler (currently set to width 4).
+
+#### Dependencies section
+
+This is where you will specify any dependencies for your project. See the [Dependencies page](../noir/modules_packages_crates/dependencies.md) for more info.
+
+`./proofs/` and `./contract/` directories will not be immediately visible until you create a proof or
+verifier contract respectively.
+
+### main.nr
+
+The _main.nr_ file contains a `main` method, this method is the entry point into your Noir program.
+
+In our sample program, _main.nr_ looks like this:
+
+```rust
+fn main(x : Field, y : Field) {
+    assert(x != y);
+}
+```
+
+The parameters `x` and `y` can be seen as the API for the program and must be supplied by the prover. Since neither `x` nor `y` is marked as public, the verifier does not supply any inputs, when verifying the proof.
+
+The prover supplies the values for `x` and `y` in the _Prover.toml_ file.
+
+As for the program body, `assert` ensures that the condition to be satisfied (e.g. `x != y`) is constrained by the proof of the execution of said program (i.e. if the condition was not met, the verifier would reject the proof as an invalid proof).
+
+### Prover.toml
+
+The _Prover.toml_ file is a file which the prover uses to supply the inputs to the Noir program (both private and public).
+
+In our hello world program the _Prover.toml_ file looks like this:
+
+```toml
+x = "1"
+y = "2"
+```
+
+When the command `nargo execute` is executed, nargo will execute the Noir program using the inputs specified in `Prover.toml`, aborting if it finds that these do not satisfy the constraints defined by `main`. In this example, `x` and `y` must satisfy the inequality constraint `assert(x != y)`.
+
+If an output name is specified such as `nargo execute foo`, the witness generated by this execution will be written to `./target/foo.gz`. This can then be used to generate a proof of the execution.
+
+#### Arrays of Structs
+
+The following code shows how to pass an array of structs to a Noir program to generate a proof.
+
+```rust
+// main.nr
+struct Foo {
+    bar: Field,
+    baz: Field,
+}
+
+fn main(foos: [Foo; 3]) -> pub Field {
+    foos[2].bar + foos[2].baz
+}
+```
+
+Prover.toml:
+
+```toml
+[[foos]] # foos[0]
+bar = 0
+baz = 0
+
+[[foos]] # foos[1]
+bar = 0
+baz = 0
+
+[[foos]] # foos[2]
+bar = 1
+baz = 2
+```
+
+#### Custom toml files
+
+You can specify a `toml` file with a different name to use for execution by using the `--prover-name` or `-p` flags.
+
+This command looks for proof inputs in the default **Prover.toml** and generates the witness and saves it at `./target/foo.gz`:
+
+```bash
+nargo execute foo
+```
+
+This command looks for proof inputs in the custom **OtherProver.toml** and generates the witness and saves it at `./target/bar.gz`:
+
+```bash
+nargo execute -p OtherProver bar
+```
+
+Now that you understand the concepts, you'll probably want some editor feedback while you are writing more complex code.
diff --git a/docs/docs/getting_started/quick_start.md b/docs/docs/getting_started/quick_start.md
new file mode 100644
index 00000000000..c693624eb82
--- /dev/null
+++ b/docs/docs/getting_started/quick_start.md
@@ -0,0 +1,126 @@
+---
+title: Quick Start
+tags: []
+sidebar_position: 0
+---
+
+## Installation
+
+### Noir
+
+The easiest way to develop with Noir is using Nargo the CLI tool. It provides you the ability to start new projects, compile, execute and test Noir programs from the terminal.
+
+You can use `noirup` the installation script to quickly install and update Nargo:
+
+```bash
+curl -L noirup.dev | bash
+noirup
+```
+
+Once installed, you can [set up shell completions for the `nargo` command](setting_up_shell_completions).
+
+### Proving backend
+
+After installing Noir, we install a proving backend to work with our Noir programs.
+
+Proving backends provide you the abilities to generate proofs, verify proofs, generate smart contracts and more for your Noir programs.
+
+Different proving backends provide different tools for working with Noir programs, here we will use the [Barretenberg proving backend](https://github.com/AztecProtocol/aztec-packages/tree/master/barretenberg) developed by Aztec Labs as an example.
+
+You can use the `bbup` installation script to quickly install and update BB, Barretenberg's CLI tool:
+
+You can find the full list of proving backends compatible with Noir in Awesome Noir.
+
+```bash
+curl -L bbup.dev | bash
+bbup
+```
+
+For the full list of proving backends compatible with Noir, visit [Awesome Noir](https://github.com/noir-lang/awesome-noir/?tab=readme-ov-file#proving-backends).
+
+## Nargo
+
+Nargo provides the ability to initiate and execute Noir projects. Let's initialize the traditional `hello_world`:
+
+```sh
+nargo new hello_world
+```
+
+Two files will be created.
+
+- `src/main.nr` contains a simple boilerplate circuit
+- `Nargo.toml` contains environmental options, such as name, author, dependencies, and others.
+
+Glancing at _main.nr_ , we can see that inputs in Noir are private by default, but can be labeled public using the keyword `pub`. This means that we will _assert_ that we know a value `x` which is different from `y` without revealing `x`:
+
+```rust
+fn main(x : Field, y : pub Field) {
+    assert(x != y);
+}
+```
+
+To learn more about private and public values, check the [Data Types](../noir/concepts/data_types/index.md) section.
+
+### Compiling and executing
+
+We can now use `nargo` to generate a _Prover.toml_ file, where our input values will be specified:
+
+```sh
+cd hello_world
+nargo check
+
+Let's feed some valid values into this file:
+
+```toml
+x = "1"
+y = "2"
+```
+
+We're now ready to compile and execute our Noir program. By default the `nargo execute` command will do both, and generate the `witness` that we need to feed to our proving backend:
+
+```sh
+nargo execute
+```
+
+The witness corresponding to this execution will then be written to the file _./target/witness-name.gz_.
+
+The command also automatically compiles your Noir program if it was not already / was edited, which you may notice the compiled artifacts being written to the file _./target/hello_world.json_.
+
+With circuit compiled and witness generated, we're ready to prove.
+
+## Proving backend
+ 
+Different proving backends may provide different tools and commands to work with Noir programs. Here Barretenberg's `bb` CLI tool is used as an example:
+
+```sh
+bb prove -b ./target/hello_world.json -w ./target/hello_world.gz -o ./target/proof
+```
+
+:::tip
+
+Naming can be confusing, specially as you pass them to the `bb` commands. If unsure, it won't hurt to delete the target folder and start anew to make sure you're using the most recent versions of the compiled circuit and witness.
+
+:::
+
+The proof is now generated in the `target` folder. To verify it we first need to compute the verification key from the compiled circuit, and use it to verify:
+
+```sh
+bb write_vk -b ./target/hello_world.json -o ./target/vk
+bb verify -k ./target/vk -p ./target/proof
+```
+
+:::info
+
+Notice that in order to verify a proof, the verifier knows nothing but the circuit, which is compiled and used to generate the verification key. This is obviously quite important: private inputs remain private.
+
+As for the public inputs, you may have noticed they haven't been specified. This behavior varies with each particular backend, but barretenberg typically attaches them to the proof. You can see them by parsing and splitting it. For example for if your public inputs are 32 bytes:
+
+```bash
+head -c 32 ./target/proof | od -An -v -t x1 | tr -d $' \n'
+```
+
+:::
+
+Congratulations, you have now created and verified a proof for your very first Noir program!
+
+In the [next section](./project_breakdown.md), we will go into more detail on each step performed.
diff --git a/docs/docs/getting_started/setting_up_shell_completions.md b/docs/docs/getting_started/setting_up_shell_completions.md
new file mode 100644
index 00000000000..0447321cbab
--- /dev/null
+++ b/docs/docs/getting_started/setting_up_shell_completions.md
@@ -0,0 +1,87 @@
+---
+title: Setting up shell completions
+tags: []
+sidebar_position: 3
+---
+
+The `nargo` binary provides a command to generate shell completions:
+
+```bash
+nargo generate-completion-script [shell]
+```
+
+where `shell` must be one of `bash`, `elvish`, `fish`, `powershell`, and `zsh`.
+
+Below we explain how to install them in some popular shells.
+
+## Installing Zsh Completions
+
+If you have `oh-my-zsh` installed, you might already have a directory of automatically loading completion scripts — `.oh-my-zsh/completions`.
+If not, first create it:
+
+```bash
+mkdir -p ~/.oh-my-zsh/completions`
+```
+
+Then copy the completion script to that directory:
+
+```bash
+nargo generate-completion-script zsh > ~/.oh-my-zsh/completions/_nargo
+```
+
+Without `oh-my-zsh`, you’ll need to add a path for completion scripts to your function path, and turn on completion script auto-loading. 
+First, add these lines to `~/.zshrc`:
+
+```bash
+fpath=(~/.zsh/completions $fpath)
+autoload -U compinit
+compinit
+```
+
+Next, create a directory at `~/.zsh/completions`:
+
+```bash
+mkdir -p ~/.zsh/completions
+```
+
+Then copy the completion script to that directory:
+
+```bash
+nargo generate-completion-script zsh > ~/.zsh/completions/_nargo
+```
+
+## Installing Bash Completions
+
+If you have [bash-completion](https://github.com/scop/bash-completion) installed, you can just copy the completion script to the `/usr/local/etc/bash_completion.d` directory:
+
+```bash
+nargo generate-completion-script bash > /usr/local/etc/bash_completion.d/nargo
+```
+
+Without `bash-completion`, you’ll need to source the completion script directly. 
+First create a directory such as `~/.bash_completions/`:
+
+```bash
+mkdir ~/.bash_completions/
+```
+
+Copy the completion script to that directory:
+
+```bash
+nargo generate-completion-script bash > ~/.bash_completions/nargo.bash
+```
+
+Then add the following line to `~/.bash_profile` or `~/.bashrc`:
+
+
+```bash
+source ~/.bash_completions/nargo.bash
+```
+
+## Installing Fish Completions
+
+Copy the completion script to any path listed in the environment variable `$fish_completion_path`. For example, a typical location is `~/.config/fish/completions/nargo.fish`:
+
+```bash
+nargo generate-completion-script fish > ~/.config/fish/completions/nargo.fish
+```
diff --git a/docs/docs/how_to/debugger/debugging_with_the_repl.md b/docs/docs/how_to/debugger/debugging_with_the_repl.md
index 09e5bae68ad..1d64dae3f37 100644
--- a/docs/docs/how_to/debugger/debugging_with_the_repl.md
+++ b/docs/docs/how_to/debugger/debugging_with_the_repl.md
@@ -1,7 +1,7 @@
 ---
 title: Using the REPL Debugger
 description:
-  Step by step guide on how to debug your Noir circuits with the REPL Debugger. 
+  Step-by-step guide on how to debug your Noir circuits with the REPL Debugger. 
 keywords:
   [
     Nargo,
diff --git a/docs/docs/how_to/debugger/debugging_with_vs_code.md b/docs/docs/how_to/debugger/debugging_with_vs_code.md
index a5858c1a5eb..8bda93324f5 100644
--- a/docs/docs/how_to/debugger/debugging_with_vs_code.md
+++ b/docs/docs/how_to/debugger/debugging_with_vs_code.md
@@ -1,7 +1,7 @@
 ---
 title: Using the VS Code Debugger
 description:
-  Step by step guide on how to debug your Noir circuits with the VS Code Debugger configuration and features.
+  Step-by-step guide on how to debug your Noir circuits with the VS Code Debugger configuration and features.
 keywords:
   [
     Nargo,
@@ -65,4 +65,4 @@ We just need to click the to the right of the line number 18. Once the breakpoin
 
 Now we are debugging the `keccak256` function, notice the _Call Stack pane_ at the lower right. This lets us inspect the current call stack of our process.
 
-That covers most of the current debugger functionalities. Check out [the reference](../../reference/debugger/debugger_vscode.md) for more details on how to configure the debugger.
\ No newline at end of file
+That covers most of the current debugger functionalities. Check out [the reference](../../reference/debugger/debugger_vscode.md) for more details on how to configure the debugger.
diff --git a/docs/docs/how_to/how-to-oracles.md b/docs/docs/how_to/how-to-oracles.md
index 2f69902062c..0bb8743e361 100644
--- a/docs/docs/how_to/how-to-oracles.md
+++ b/docs/docs/how_to/how-to-oracles.md
@@ -18,8 +18,6 @@ This guide shows you how to use oracles in your Noir program. For the sake of cl
 - You understand the concept of a JSON-RPC server. Visit the [JSON-RPC website](https://www.jsonrpc.org/) if you need a refresher.
 - You are comfortable with server-side JavaScript (e.g. Node.js, managing packages, etc.).
 
-For reference, you can find the snippets used in this tutorial on the [Aztec DevRel Repository](https://github.com/AztecProtocol/dev-rel/tree/main/code-snippets/how-to-oracles).
-
 ## Rundown
 
 This guide has 3 major steps:
@@ -32,7 +30,7 @@ This guide has 3 major steps:
 
 An oracle is defined in a Noir program by defining two methods:
 
-- An unconstrained method - This tells the compiler that it is executing an [unconstrained functions](../noir/concepts//unconstrained.md).
+- An unconstrained method - This tells the compiler that it is executing an [unconstrained function](../noir/concepts//unconstrained.md).
 - A decorated oracle method - This tells the compiler that this method is an RPC call.
 
 An example of an oracle that returns a `Field` would be:
@@ -99,6 +97,12 @@ fn main(input: [Field; 2]) {
     assert(sqrt[0].pow_32(2) as u64 == input[0] as u64);
     assert(sqrt[1].pow_32(2) as u64 == input[1] as u64);
 }
+
+#[test]
+fn test() {
+    let input = [4, 16];
+    main(input);
+}
 ```
 
 :::info
@@ -137,44 +141,38 @@ app.listen(5555);
 Now, we will add our `getSqrt` method, as expected by the `#[oracle(getSqrt)]` decorator in our Noir code. It maps through the params array and returns their square roots:
 
 ```js
-server.addMethod("resolve_function_call", async (params) => {
-  if params.function !== "getSqrt" {
-    throw Error("Unexpected foreign call")
-  };
-  const values = params.inputs[0].Array.map((field) => {
-    return `${Math.sqrt(parseInt(field, 16))}`;
-  });
-  return { values: [{ Array: values }] };
+server.addMethod("resolve_foreign_call", async (params) => {
+    if (params[0].function !== "getSqrt") {
+        throw Error("Unexpected foreign call")
+    };
+    const values = params[0].inputs[0].map((field) => {
+        return `${Math.sqrt(parseInt(field, 16))}`;
+    });
+    return { values: [values] };
 });
 ```
 
 If you're using Typescript, the following types may be helpful in understanding the expected return value and making sure they're easy to follow:
 
 ```js
-interface SingleForeignCallParam {
-  Single: string,
-}
+export type ForeignCallSingle = string;
 
-interface ArrayForeignCallParam {
-  Array: string[],
-}
-
-type ForeignCallParam = SingleForeignCallParam | ArrayForeignCallParam;
+export type ForeignCallArray = string[];
 
-interface ForeignCallResult {
-  values: ForeignCallParam[],
-}
+export type ForeignCallResult = {
+  values: (ForeignCallSingle | ForeignCallArray)[];
+};
 ```
 
-::: Multidimensional Arrays
+:::info Multidimensional Arrays
 
-If the Oracle function is returning an array containing other arrays, such as `[['1','2],['3','4']]`, you need to provide the values in json as flattened values. In the previous example, it would be `['1', '2', '3', '4']`. In the noir program, the Oracle signature can use a nested type, the flattened values will be automatically converted to the nested type.
+If the Oracle function is returning an array containing other arrays, such as `[['1','2],['3','4']]`, you need to provide the values in JSON as flattened values. In the previous example, it would be `['1', '2', '3', '4']`. In the Noir program, the Oracle signature can use a nested type, the flattened values will be automatically converted to the nested type.
 
 :::
 
 ## Step 3 - Usage with Nargo
 
-Using the [`nargo` CLI tool](../getting_started/installation/index.md), you can use oracles in the `nargo test` and `nargo execute`  commands by passing a value to `--oracle-resolver`. For example:
+Using the [`nargo` CLI tool](../reference/nargo_commands.md), you can use oracles in the `nargo test` and `nargo execute`  commands by passing a value to `--oracle-resolver`. For example:
 
 ```bash
 nargo test --oracle-resolver http://localhost:5555
@@ -233,17 +231,21 @@ const client = new JSONRPCClient((jsonRPCRequest) => {
 
 // declaring a function that takes the name of the foreign call (getSqrt) and the inputs
 const foreignCallHandler = async (name, input) => {
-    // notice that the "inputs" parameter contains *all* the inputs
-    // in this case we make the RPC request with the first parameter "numbers", which would be input[0]
-    const oracleReturn = await client.request(name, [
-      input[0].map((i) => i.toString("hex")),
-    ]);
-    return { values: oracleReturn };
+  const inputs = input[0].map((i) => i.toString("hex"))
+  // notice that the "inputs" parameter contains *all* the inputs
+  // in this case we to make the RPC request with the first parameter "numbers", which would be input[0]
+  const oracleReturn = await client.request("resolve_foreign_call", [
+    {
+      function: name,
+      inputs: [inputs]
+    },
+  ]);
+  return [oracleReturn.values[0]];
 };
 
 // the rest of your NoirJS code
 const input = { input: [4, 16] };
-const { witness } = await noir.execute(numbers, foreignCallHandler);
+const { witness } = await noir.execute(input, foreignCallHandler);
 ```
 
 :::tip
diff --git a/docs/docs/how_to/how-to-recursion.md b/docs/docs/how_to/how-to-recursion.md
index 71f02fa5435..399e4d4b38a 100644
--- a/docs/docs/how_to/how-to-recursion.md
+++ b/docs/docs/how_to/how-to-recursion.md
@@ -1,6 +1,6 @@
 ---
 title: How to use recursion on NoirJS
-description: Learn how to implement recursion with NoirJS, a powerful tool for creating smart contracts on the EVM blockchain. This guide assumes familiarity with NoirJS, solidity verifiers, and the Barretenberg proving backend. Discover how to generate both final and intermediate proofs using `noir_js` and `backend_barretenberg`.
+description: Learn how to implement recursion with NoirJS, a powerful tool for creating smart contracts on the EVM blockchain. This guide assumes familiarity with NoirJS, solidity verifiers, and the Barretenberg proving backend. Discover how to generate both final and intermediate proofs using `noir_js` and `bb.js`.
 keywords:
   [
     "NoirJS",
@@ -10,7 +10,6 @@ keywords:
     "solidity verifiers",
     "Barretenberg backend",
     "noir_js",
-    "backend_barretenberg",
     "intermediate proofs",
     "final proofs",
     "nargo compile",
@@ -25,7 +24,7 @@ This guide shows you how to use recursive proofs in your NoirJS app. For the sak
 
 - You already have a NoirJS app. If you don't, please visit the [NoirJS tutorial](../tutorials/noirjs_app.md) and the [reference](../reference/NoirJS/noir_js/index.md).
 - You are familiar with what are recursive proofs and you have read the [recursion explainer](../explainers/explainer-recursion.md)
-- You already built a recursive circuit following [the reference](../noir/standard_library/recursion.md), and understand how it works.
+- You already built a recursive circuit following [the reference](../noir/standard_library/recursion.mdx), and understand how it works.
 
 It is also assumed that you're not using `noir_wasm` for compilation, and instead you've used [`nargo compile`](../reference/nargo_commands.md) to generate the `json` you're now importing into your project. However, the guide should work just the same if you're using `noir_wasm`.
 
@@ -33,18 +32,11 @@ It is also assumed that you're not using `noir_wasm` for compilation, and instea
 
 As you've read in the [explainer](../explainers/explainer-recursion.md), a recursive proof is an intermediate proof. This means that it doesn't necessarily generate the final step that makes it verifiable in a smart contract. However, it is easy to verify within another circuit.
 
-While "standard" usage of NoirJS packages abstracts final proofs, it currently lacks the necessary interface to abstract away intermediate proofs. This means that these proofs need to be created by using the backend directly.
-
-In short:
-
-- `noir_js` generates *only* final proofs
-- `backend_barretenberg` generates both types of proofs
-
 :::
 
 In a standard recursive app, you're also dealing with at least two circuits. For the purpose of this guide, we will assume the following:
 
-- `main`: a circuit of type `assert(x != y)`, where `main` is marked with a `#[recursive]` attribute. This attribute states that the backend should generate proofs that are friendly for verification within another circuit.
+- `main`: a circuit of type `assert(x != y)`, which we want to embed in another circuit recursively. For example when proving with the `bb` tool, we can use the `--recursive` CLI option to tell the backend that it should generate proofs that are friendly for verification within another circuit.
 - `recursive`: a circuit that verifies `main`
 
 For a full example of how recursive proofs work, please refer to the [noir-examples](https://github.com/noir-lang/noir-examples) repository. We will *not* be using it as a reference for this guide.
@@ -58,7 +50,7 @@ For recursion, this doesn't happen, and the only need for `noir_js` is only to `
 It is also recommended that you instantiate the backend with as many threads as possible, to allow for maximum concurrency:
 
 ```js
-const backend = new Backend(circuit, { threads: 8 })
+const backend = new UltraPlonkBackend(circuit, { threads: 8 }, { recursive: true })
 ```
 
 :::tip
@@ -147,7 +139,7 @@ Managing circuits and "who does what" can be confusing. To make sure your naming
 
 ```js
 const circuits = {
-  main: mainJSON, 
+  main: mainJSON,
   recursive: recursiveJSON
 }
 const backends = {
diff --git a/docs/docs/how_to/how-to-solidity-verifier.md b/docs/docs/how_to/how-to-solidity-verifier.md
index a8169595b3d..2cc0f8e57ce 100644
--- a/docs/docs/how_to/how-to-solidity-verifier.md
+++ b/docs/docs/how_to/how-to-solidity-verifier.md
@@ -27,7 +27,7 @@ This allows for a powerful feature set, as one can make use of the conciseness a
 This guide shows you how to generate a Solidity Verifier and deploy it on the [Remix IDE](https://remix.ethereum.org/). It is assumed that:
 
 - You are comfortable with the Solidity programming language and understand how contracts are deployed on the Ethereum network
-- You have Noir installed and you have a Noir program. If you don't, [get started](../getting_started/installation/index.md) with Nargo and the example Hello Noir circuit
+- You have Noir installed and you have a Noir program. If you don't, [get started](../getting_started/quick_start.md) with Nargo and the example Hello Noir circuit
 - You are comfortable navigating RemixIDE. If you aren't or you need a refresher, you can find some video tutorials [here](https://www.youtube.com/channel/UCjTUPyFEr2xDGN6Cg8nKDaA) that could help you.
 
 ## Rundown
@@ -57,7 +57,7 @@ bb contract
 replacing `<noir_artifact_name>` with the name of your Noir project. A new `contract` folder would then be generated in your project directory, containing the Solidity
 file `contract.sol`. It can be deployed to any EVM blockchain acting as a verifier smart contract.
 
-You can find more information about `bb` and the default Noir proving backend on [this page](../getting_started/hello_noir/index.md#proving-backend).
+You can find more information about `bb` and the default Noir proving backend on [this page](../getting_started/quick_start.md#proving-backend).
 
 :::info
 
@@ -133,9 +133,9 @@ To verify a proof using the Solidity verifier contract, we call the `verify` fun
 function verify(bytes calldata _proof, bytes32[] calldata _publicInputs) external view returns (bool)
 ```
 
-When using the default example in the [Hello Noir](../getting_started/hello_noir/index.md) guide, the easiest way to confirm that the verifier contract is doing its job is by calling the `verify` function via remix with the required parameters. Note that the public inputs must be passed in separately to the rest of the proof so we must split the proof as returned from `bb`.
+When using the default example in the [Hello Noir](../getting_started/quick_start.md) guide, the easiest way to confirm that the verifier contract is doing its job is by calling the `verify` function via remix with the required parameters. Note that the public inputs must be passed in separately to the rest of the proof so we must split the proof as returned from `bb`.
 
-First generate a proof with `bb` at the location `./proof` using the steps in [get started](../getting_started/hello_noir/index.md), this proof is in a binary format but we want to convert it into a hex string to pass into Remix, this can be done with the
+First generate a proof with `bb` at the location `./proof` using the steps in [get started](../getting_started/quick_start.md), this proof is in a binary format but we want to convert it into a hex string to pass into Remix, this can be done with the
 
 ```bash
 # This value must be changed to match the number of public inputs (including return values!) in your program.
diff --git a/docs/docs/index.mdx b/docs/docs/index.mdx
index a6bd306f91d..5c116a73b3f 100644
--- a/docs/docs/index.mdx
+++ b/docs/docs/index.mdx
@@ -21,8 +21,17 @@ sidebar_position: 0
 
 import Tabs from '@theme/Tabs';
 import TabItem from '@theme/TabItem';
-
-<img src={require("@site/static/img/logo.png").default} style={{display: "block", width: "50%", margin: "2rem auto"}} alt="Noir Logo"  />
+import ThemedImage from '@theme/ThemedImage';
+import useBaseUrl from '@docusaurus/useBaseUrl';
+
+<ThemedImage
+  sources={{
+    light: useBaseUrl("/img/logoDark.png"),
+    dark: useBaseUrl("/img/logo.png"),
+  }}
+  style={{display: "block", width: "50%", margin: "2rem auto"}} 
+  alt="Noir Logo" 
+/>
 
 Noir is an open-source Domain-Specific Language for safe and seamless construction of privacy-preserving Zero-Knowledge programs, requiring no previous knowledge on the underlying mathematics or cryptography.
 
diff --git a/docs/docs/noir/concepts/comptime.md b/docs/docs/noir/concepts/comptime.md
index cea3a896c17..9661dc1a6ca 100644
--- a/docs/docs/noir/concepts/comptime.md
+++ b/docs/docs/noir/concepts/comptime.md
@@ -5,7 +5,7 @@ keywords: [Noir, comptime, compile-time, metaprogramming, macros, quote, unquote
 sidebar_position: 15
 ---
 
-# Overview
+## Overview
 
 Metaprogramming in Noir is comprised of three parts:
 1. `comptime` code
@@ -21,7 +21,7 @@ for greater analysis and modification of programs.
 
 ---
 
-# Comptime
+## Comptime
 
 `comptime` is a new keyword in Noir which marks an item as executing or existing at compile-time. It can be used in several ways:
 
@@ -32,16 +32,16 @@ for greater analysis and modification of programs.
 - `comptime let` to define a variable whose value is evaluated at compile-time.
 - `comptime for` to run a for loop at compile-time. Syntax sugar for `comptime { for .. }`.
 
-## Scoping
+### Scoping
 
 Note that while in a `comptime` context, any runtime variables _local to the current function_ are never visible.
 
-## Evaluating
+### Evaluating
 
 Evaluation rules of `comptime` follows the normal unconstrained evaluation rules for other Noir code. There are a few things to note though:
 
 - Certain built-in functions may not be available, although more may be added over time.
-- Evaluation order of global items is currently unspecified. For example, given the following two functions we can't guarantee
+- Evaluation order of `comptime {}` blocks within global items is currently unspecified. For example, given the following two functions we can't guarantee
 which `println` will execute first. The ordering of the two printouts will be arbitrary, but should be stable across multiple compilations with the same `nargo` version as long as the program is also unchanged.
 
 ```rust
@@ -56,13 +56,16 @@ fn two() {
 
 - Since evaluation order is unspecified, care should be taken when using mutable globals so that they do not rely on a particular ordering.
 For example, using globals to generate unique ids should be fine but relying on certain ids always being produced (especially after edits to the program) should be avoided.
-- Although most ordering of globals is unspecified, two are:
+- Although the ordering of comptime code is usually unspecified, there are cases where it is:
   - Dependencies of a crate will always be evaluated before the dependent crate.
-  - Any annotations on a function will be run before the function itself is resolved. This is to allow the annotation to modify the function if necessary. Note that if the
+  - Any attributes on a function will be run before the function body is resolved. This is to allow the attribute to modify the function if necessary. Note that if the
     function itself was called at compile-time previously, it will already be resolved and cannot be modified. To prevent accidentally calling functions you wish to modify
-    at compile-time, it may be helpful to sort your `comptime` annotation functions into a different crate along with any dependencies they require.
+    at compile-time, it may be helpful to sort your `comptime` annotation functions into a different submodule crate along with any dependencies they require.
+  - Unlike raw `comptime {}` blocks, attributes on top-level items in the program do have a set evaluation order. Attributes within a module are evaluated top-down, and attributes
+    in different modules are evaluated submodule-first. Sibling modules to the same parent module are evaluated in order of the module declarations (`mod foo; mod bar;`) in their
+    parent module.
 
-## Lowering
+### Lowering
 
 When a `comptime` value is used in runtime code it must be lowered into a runtime value. This means replacing the expression with the literal that it evaluated to. For example, the code:
 
@@ -89,7 +92,7 @@ fn main() {
 }
 ```
 
-Not all types of values can be lowered. For example, `Type`s and `TypeDefinition`s (among other types) cannot be lowered at all.
+Not all types of values can be lowered. For example, references, `Type`s, and `TypeDefinition`s (among other types) cannot be lowered at all.
 
 ```rust
 fn main() {
@@ -100,9 +103,22 @@ fn main() {
 comptime fn get_type() -> Type { ... }
 ```
 
+Values of certain types may also change type when they are lowered. For example, a comptime format string will already be
+formatted, and thus lowers into a runtime string instead:
+
+```rust
+fn main() {
+    let foo = comptime {
+        let i = 2;
+        f"i = {i}"
+    };
+    assert_eq(foo, "i = 2");
+}
+```
+
 ---
 
-# (Quasi) Quote
+## (Quasi) Quote
 
 Macros in Noir are `comptime` functions which return code as a value which is inserted into the call site when it is lowered there.
 A code value in this case is of type `Quoted` and can be created by a `quote { ... }` expression.
@@ -121,7 +137,22 @@ Calling such a function at compile-time without `!` will just return the `Quoted
 For those familiar with quoting from other languages (primarily lisps), Noir's `quote` is actually a _quasiquote_.
 This means we can escape the quoting by using the unquote operator to splice values in the middle of quoted code.
 
-# Unquote
+In addition to curly braces, you can also use square braces for the quote operator:
+
+```rust
+comptime {
+    let q1 = quote { 1 };
+    let q2 = quote [ 2 ];
+    assert_eq(q1, q2);
+
+    // Square braces can be used to quote mismatched curly braces if needed
+    let _ = quote[}];
+}
+```
+
+---
+
+## Unquote
 
 The unquote operator `$` is usable within a `quote` expression.
 It takes a variable as an argument, evaluates the variable, and splices the resulting value into the quoted token stream at that point. For example,
@@ -149,7 +180,7 @@ If it is an expression (even a parenthesized one), it will do nothing. Most like
 
 Unquoting can also be avoided by escaping the `$` with a backslash:
 
-```
+```rust
 comptime {
     let x = quote { 1 + 2 };
 
@@ -158,26 +189,48 @@ comptime {
 }
 ```
 
+### Combining Tokens
+
+Note that `Quoted` is internally a series of separate tokens, and that all unquoting does is combine these token vectors.
+This means that code which appears to append like a string actually appends like a vector internally:
+
+```rust
+comptime {
+    let x = 3;
+    let q = quote { foo$x }; // This is [foo, 3], not [foo3]
+
+    // Spaces are ignored in general, they're never part of a token
+    assert_eq(q, quote { foo   3 });
+}
+```
+
+If you do want string semantics, you can use format strings then convert back to a `Quoted` value with `.quoted_contents()`.
+Note that formatting a quoted value with multiple tokens will always insert a space between each token. If this is
+undesired, you'll need to only operate on quoted values containing a single token. To do this, you can iterate
+over each token of a larger quoted value with `.tokens()`:
+
+#include_code concatenate-example noir_stdlib/src/meta/mod.nr rust
+
 ---
 
-# Annotations
+## Attributes
 
-Annotations provide a way to run a `comptime` function on an item in the program.
-When you use an annotation, the function with the same name will be called with that item as an argument:
+Attributes provide a way to run a `comptime` function on an item in the program.
+When you use an attribute, the function with the same name will be called with that item as an argument:
 
 ```rust
-#[my_struct_annotation]
+#[my_struct_attribute]
 struct Foo {}
 
-comptime fn my_struct_annotation(s: StructDefinition) {
-    println("Called my_struct_annotation!");
+comptime fn my_struct_attribute(s: StructDefinition) {
+    println("Called my_struct_attribute!");
 }
 
-#[my_function_annotation]
+#[my_function_attribute]
 fn foo() {}
 
-comptime fn my_function_annotation(f: FunctionDefinition) {
-    println("Called my_function_annotation!");
+comptime fn my_function_attribute(f: FunctionDefinition) {
+    println("Called my_function_attribute!");
 }
 ```
 
@@ -188,26 +241,58 @@ For example, this is the mechanism used to insert additional trait implementatio
 
 #include_code derive-field-count-example noir_stdlib/src/meta/mod.nr rust
 
-## Calling annotations with additional arguments
+### Calling annotations with additional arguments
 
-Arguments may optionally be given to annotations.
-When this is done, these additional arguments are passed to the annotation function after the item argument.
+Arguments may optionally be given to attributes.
+When this is done, these additional arguments are passed to the attribute function after the item argument.
 
 #include_code annotation-arguments-example noir_stdlib/src/meta/mod.nr rust
 
-We can also take any number of arguments by adding the `varargs` annotation:
+We can also take any number of arguments by adding the `varargs` attribute:
 
 #include_code annotation-varargs-example noir_stdlib/src/meta/mod.nr rust
 
+### Attribute Evaluation Order
+
+Unlike the evaluation order of stray `comptime {}` blocks within functions, attributes have a well-defined evaluation
+order. Within a module, attributes are evaluated top to bottom. Between modules, attributes in child modules are evaluated
+first. Attributes in sibling modules are resolved following the `mod foo; mod bar;` declaration order within their parent
+modules.
+
+```rust
+mod foo; // attributes in foo are run first
+mod bar; // followed by attributes in bar
+
+// followed by any attributes in the parent module
+#[derive(Eq)]
+struct Baz {}
+```
+
+Note that because of this evaluation order, you may get an error trying to derive a trait for a struct whose fields
+have not yet had the trait derived already:
+
+```rust
+// Error! `Bar` field of `Foo` does not (yet) implement Eq!
+#[derive(Eq)]
+struct Foo {
+    bar: Bar
+}
+
+#[derive(Eq)]
+struct Bar {}
+```
+
+In this case, the issue can be resolved by rearranging the structs.
+
 ---
 
-# Comptime API
+## Comptime API
 
 Although `comptime`, `quote`, and unquoting provide a flexible base for writing macros,
 Noir's true metaprogramming ability comes from being able to interact with the compiler through a compile-time API.
 This API can be accessed through built-in functions in `std::meta` as well as on methods of several `comptime` types.
 
-The following is an incomplete list of some `comptime` types along with some useful methods on them.
+The following is an incomplete list of some `comptime` types along with some useful methods on them. You can see more in the standard library [Metaprogramming section](../standard_library/meta).
 
 - `Quoted`: A token stream
 - `Type`: The type of a Noir type
@@ -238,7 +323,7 @@ The following is an incomplete list of some `comptime` types along with some use
 There are many more functions available by exploring the `std::meta` module and its submodules.
 Using these methods is the key to writing powerful metaprogramming libraries.
 
-## `#[use_callers_scope]`
+### `#[use_callers_scope]`
 
 Since certain functions such as `Quoted::as_type`, `Expression::as_type`, or `Quoted::as_trait_constraint` will attempt
 to resolve their contents in a particular scope - it can be useful to change the scope they resolve in. By default
@@ -251,7 +336,7 @@ your attribute function and a helper function it calls use it, then they can bot
 
 ---
 
-# Example: Derive
+## Example: Derive
 
 Using all of the above, we can write a `derive` macro that behaves similarly to Rust's but is not built into the language.
 From the user's perspective it will look like this:
diff --git a/docs/docs/noir/concepts/control_flow.md b/docs/docs/noir/concepts/control_flow.md
index 045d3c3a5f5..b365bb22728 100644
--- a/docs/docs/noir/concepts/control_flow.md
+++ b/docs/docs/noir/concepts/control_flow.md
@@ -42,6 +42,8 @@ for i in 0..10 {
 }
 ```
 
+Alternatively, `start..=end` can be used for a range that is inclusive on both ends.
+
 The index for loops is of type `u64`.
 
 ### Break and Continue
diff --git a/docs/docs/noir/concepts/data_types/arrays.md b/docs/docs/noir/concepts/data_types/arrays.md
index bb68e60fe53..289145a8c4d 100644
--- a/docs/docs/noir/concepts/data_types/arrays.md
+++ b/docs/docs/noir/concepts/data_types/arrays.md
@@ -203,6 +203,8 @@ fn main() {
 
 Same as fold, but uses the first element as the starting element.
 
+Requires `self` to be non-empty.
+
 ```rust
 fn reduce(self, f: fn(T, T) -> T) -> T
 ```
diff --git a/docs/docs/noir/concepts/data_types/index.md b/docs/docs/noir/concepts/data_types/index.md
index 11f51e2b65a..0f2db2b2d75 100644
--- a/docs/docs/noir/concepts/data_types/index.md
+++ b/docs/docs/noir/concepts/data_types/index.md
@@ -105,7 +105,7 @@ type Bad2 = Bad1;
 //   ^^^^^^^^^^^ 'Bad2' recursively depends on itself: Bad2 -> Bad1 -> Bad2
 ```
 
-By default, like functions, type aliases are private to the module the exist in. You can use `pub`
+By default, like functions, type aliases are private to the module they exist in. You can use `pub`
 to make the type alias public or `pub(crate)` to make it public to just its crate:
 
 ```rust
diff --git a/docs/docs/noir/concepts/data_types/integers.md b/docs/docs/noir/concepts/data_types/integers.md
index a1d59bf3166..41a823646dd 100644
--- a/docs/docs/noir/concepts/data_types/integers.md
+++ b/docs/docs/noir/concepts/data_types/integers.md
@@ -47,6 +47,17 @@ fn main() {
 
 The bit size determines the maximum and minimum range of value the integer type can store. For example, an `i8` variable can store a value in the range of -128 to 127 (i.e. $\\-2^{7}\\$ to $\\2^{7}-1\\$).
 
+
+```rust
+fn main(x: i16, y: i16) {
+    // modulo
+    let c = x % y;
+    let c = x % -13;
+}
+```
+
+Modulo operation is defined for negative integers thanks to integer division, so that the equality `x = (x/y)*y + (x%y)` holds.
+
 ## 128 bits Unsigned Integers
 
 The built-in structure `U128` allows you to use 128-bit unsigned integers almost like a native integer type. However, there are some differences to keep in mind:
@@ -68,7 +79,7 @@ fn main() {
 You can construct a U128 from its limbs:
 ```rust
 fn main(x: u64, y: u64) {
-    let x = U128::from_u64s_be(x,y);
+    let z = U128::from_u64s_be(x,y);
     assert(z.hi == x as Field);
     assert(z.lo == y as Field);
 }
diff --git a/docs/docs/noir/concepts/data_types/structs.md b/docs/docs/noir/concepts/data_types/structs.md
index e529347f27d..29951ae843a 100644
--- a/docs/docs/noir/concepts/data_types/structs.md
+++ b/docs/docs/noir/concepts/data_types/structs.md
@@ -69,7 +69,9 @@ fn get_octopus() -> Animal {
 The new variables can be bound with names different from the original struct field names, as
 showcased in the `legs --> feet` binding in the example above.
 
-By default, like functions, structs are private to the module the exist in. You can use `pub`
+### Visibility
+
+By default, like functions, structs are private to the module they exist in. You can use `pub`
 to make the struct public or `pub(crate)` to make it public to just its crate:
 
 ```rust
@@ -79,4 +81,16 @@ pub struct Animal {
     legs: Field,
     eyes: u8,
 }
+```
+
+The same applies to struct fields: by default they are private to the module they exist in,
+but they can be made `pub` or `pub(crate)`:
+
+```rust
+// This struct is now public
+pub struct Animal {
+    hands: Field,           // private to its module
+    pub(crate) legs: Field, // accessible from the entire crate
+    pub eyes: u8,           // accessible from anywhere
+}
 ```
\ No newline at end of file
diff --git a/docs/docs/noir/concepts/globals.md b/docs/docs/noir/concepts/globals.md
index 1145c55dfc7..c64b6c53746 100644
--- a/docs/docs/noir/concepts/globals.md
+++ b/docs/docs/noir/concepts/globals.md
@@ -10,12 +10,12 @@ sidebar_position: 8
 ## Globals
 
 
-Noir supports global variables. The global's type can be inferred by the compiler entirely:
+Noir supports global variables. The global's type must be specified by the user:
 
 ```rust
-global N = 5; // Same as `global N: Field = 5`
+global N: Field = 5;
 
-global TUPLE = (3, 2);
+global TUPLE: (Field, Field) = (3, 2);
 
 fn main() {
     assert(N == 5);
@@ -28,7 +28,7 @@ fn main() {
 Globals can be defined as any expression, so long as they don't depend on themselves - otherwise there would be a dependency cycle! For example:
 
 ```rust
-global T = foo(T); // dependency error
+global T: u32 = foo(T); // dependency error
 ```
 
 :::
@@ -47,7 +47,7 @@ fn main(y : [Field; N]) {
 A global from another module can be imported or referenced externally like any other name:
 
 ```rust
-global N = 20;
+global N: Field = 20;
 
 fn main() {
     assert(my_submodule::N != N);
@@ -62,7 +62,7 @@ When a global is used, Noir replaces the name with its definition on each occurr
 This means globals defined using function calls will repeat the call each time they're used:
 
 ```rust
-global RESULT = foo();
+global RESULT: [Field; 100] = foo();
 
 fn foo() -> [Field; 100] { ... }
 ```
@@ -73,10 +73,10 @@ function performs side-effects like `println`, as these will still occur on each
 
 ### Visibility
 
-By default, like functions, globals are private to the module the exist in. You can use `pub`
+By default, like functions, globals are private to the module they exist in. You can use `pub`
 to make the global public or `pub(crate)` to make it public to just its crate:
 
 ```rust
 // This global is now public
-pub global N = 5;
-```
\ No newline at end of file
+pub global N: u32 = 5;
+```
diff --git a/docs/docs/noir/concepts/traits.md b/docs/docs/noir/concepts/traits.md
index 5d07e0c68f0..b6c0a886eb0 100644
--- a/docs/docs/noir/concepts/traits.md
+++ b/docs/docs/noir/concepts/traits.md
@@ -464,12 +464,121 @@ Since we have an impl for our own type, the behavior of this code will not chang
 to provide its own `impl Default for Foo`. The downside of this pattern is that it requires extra wrapping and
 unwrapping of values when converting to and from the `Wrapper` and `Foo` types.
 
+### Trait Inheritance
+
+Sometimes, you might need one trait to use another trait’s functionality (like "inheritance" in some other languages). In this case, you can specify this relationship by listing any child traits after the parent trait's name and a colon. Now, whenever the parent trait is implemented it will require the child traits to be implemented as well. A parent trait is also called a "super trait."
+
+```rust
+trait Person {
+    fn name(self) -> String;
+}
+
+// Person is a supertrait of Student.
+// Implementing Student requires you to also impl Person.
+trait Student: Person {
+    fn university(self) -> String;
+}
+
+trait Programmer {
+    fn fav_language(self) -> String;
+}
+
+// CompSciStudent (computer science student) is a subtrait of both Programmer 
+// and Student. Implementing CompSciStudent requires you to impl both supertraits.
+trait CompSciStudent: Programmer + Student {
+    fn git_username(self) -> String;
+}
+```
+
+### Trait Aliases
+
+Similar to the proposed Rust feature for [trait aliases](https://github.com/rust-lang/rust/blob/4d215e2426d52ca8d1af166d5f6b5e172afbff67/src/doc/unstable-book/src/language-features/trait-alias.md),
+Noir supports aliasing one or more traits and using those aliases wherever
+traits would normally be used.
+
+```rust
+trait Foo {
+    fn foo(self) -> Self;
+}
+
+trait Bar {
+    fn bar(self) -> Self;
+}
+
+// Equivalent to:
+// trait Baz: Foo + Bar {}
+//
+// impl<T> Baz for T where T: Foo + Bar {}
+trait Baz = Foo + Bar;
+
+// We can use `Baz` to refer to `Foo + Bar`
+fn baz<T>(x: T) -> T where T: Baz {
+    x.foo().bar()
+}
+```
+
+#### Generic Trait Aliases
+
+Trait aliases can also be generic by placing the generic arguments after the
+trait name. These generics are in scope of every item within the trait alias.
+
+```rust
+trait Foo {
+    fn foo(self) -> Self;
+}
+
+trait Bar<T> {
+    fn bar(self) -> T;
+}
+
+// Equivalent to:
+// trait Baz<T>: Foo + Bar<T> {}
+//
+// impl<T, U> Baz<T> for U where U: Foo + Bar<T> {}
+trait Baz<T> = Foo + Bar<T>;
+```
+
+#### Trait Alias Where Clauses
+
+Trait aliases support where clauses to add trait constraints to any of their
+generic arguments, e.g. ensuring `T: Baz` for a trait alias `Qux<T>`.
+
+```rust
+trait Foo {
+    fn foo(self) -> Self;
+}
+
+trait Bar<T> {
+    fn bar(self) -> T;
+}
+
+trait Baz {
+    fn baz(self) -> bool;
+}
+
+// Equivalent to:
+// trait Qux<T>: Foo + Bar<T> where T: Baz {}
+//
+// impl<T, U> Qux<T> for U where
+//     U: Foo + Bar<T>,
+//     T: Baz,
+// {}
+trait Qux<T> = Foo + Bar<T> where T: Baz;
+```
+
+Note that while trait aliases support where clauses,
+the equivalent traits can fail due to [#6467](https://github.com/noir-lang/noir/issues/6467)
+
 ### Visibility
 
-By default, like functions, traits are private to the module the exist in. You can use `pub`
-to make the trait public or `pub(crate)` to make it public to just its crate:
+By default, like functions, traits and trait aliases are private to the module
+they exist in. You can use `pub` to make the trait public or `pub(crate)` to make
+it public to just its crate:
 
 ```rust
 // This trait is now public
 pub trait Trait {}
-```
\ No newline at end of file
+
+// This trait alias is now public
+pub trait Baz = Foo + Bar;
+```
diff --git a/docs/docs/noir/modules_packages_crates/dependencies.md b/docs/docs/noir/modules_packages_crates/dependencies.md
index 24e02de08fe..22186b22598 100644
--- a/docs/docs/noir/modules_packages_crates/dependencies.md
+++ b/docs/docs/noir/modules_packages_crates/dependencies.md
@@ -81,12 +81,10 @@ use std::hash::sha256;
 use std::scalar_mul::fixed_base_embedded_curve;
 ```
 
-Lastly, as demonstrated in the
-[elliptic curve example](../standard_library/cryptographic_primitives/ec_primitives.md#examples), you
-can import multiple items in the same line by enclosing them in curly braces:
+Lastly, You can import multiple items in the same line by enclosing them in curly braces:
 
 ```rust
-use std::ec::tecurve::affine::{Curve, Point};
+use std::hash::{keccak256, sha256};
 ```
 
 We don't have a way to consume libraries from inside a [workspace](./workspaces.md) as external dependencies right now.
diff --git a/docs/docs/noir/modules_packages_crates/modules.md b/docs/docs/noir/modules_packages_crates/modules.md
index 05399c38b4c..14aa1f0579a 100644
--- a/docs/docs/noir/modules_packages_crates/modules.md
+++ b/docs/docs/noir/modules_packages_crates/modules.md
@@ -212,7 +212,7 @@ In this example, the module `some_module` re-exports two public names defined in
 
 ### Visibility
 
-By default, like functions, modules are private to the module (or crate) the exist in. You can use `pub`
+By default, like functions, modules are private to the module (or crate) they exist in. You can use `pub`
 to make the module public or `pub(crate)` to make it public to just its crate:
 
 ```rust
diff --git a/docs/docs/noir/modules_packages_crates/workspaces.md b/docs/docs/noir/modules_packages_crates/workspaces.md
index 513497f12bf..2fbf10aec52 100644
--- a/docs/docs/noir/modules_packages_crates/workspaces.md
+++ b/docs/docs/noir/modules_packages_crates/workspaces.md
@@ -33,10 +33,14 @@ members = ["crates/a", "crates/b"]
 default-member = "crates/a"
 ```
 
-`members` indicates which packages are included in the workspace. As such, all member packages of a workspace will be processed when the `--workspace` flag is used with various commands or if a `default-member` is not specified.
+`members` indicates which packages are included in the workspace. As such, all member packages of a workspace will be processed when the `--workspace` flag is used with various commands or if a `default-member` is not specified. The `--package` option can be used to limit
+the scope of some commands to a specific member of the workspace; otherwise these commands run on the package nearest on the path to the
+current directory where `nargo` was invoked.
 
 `default-member` indicates which package various commands process by default.
 
 Libraries can be defined in a workspace. Inside a workspace, these are consumed as `{ path = "../to_lib" }` dependencies in Nargo.toml.
 
 Inside a workspace, these are consumed as `{ path = "../to_lib" }` dependencies in Nargo.toml.
+
+Please note that nesting regular packages is not supported: certain commands work on the workspace level and will use the topmost Nargo.toml file they can find on the path; unless this is a workspace configuration with `members`, the command might run on some unintended package.
diff --git a/docs/docs/noir/standard_library/black_box_fns.md b/docs/docs/noir/standard_library/black_box_fns.md
index d5694250f05..e9392b20a92 100644
--- a/docs/docs/noir/standard_library/black_box_fns.md
+++ b/docs/docs/noir/standard_library/black_box_fns.md
@@ -14,7 +14,6 @@ Here is a list of the current black box functions:
 
 - [AES128](./cryptographic_primitives/ciphers.mdx#aes128)
 - [SHA256](./cryptographic_primitives/hashes.mdx#sha256)
-- [Schnorr signature verification](./cryptographic_primitives/schnorr.mdx)
 - [Blake2s](./cryptographic_primitives/hashes.mdx#blake2s)
 - [Blake3](./cryptographic_primitives/hashes.mdx#blake3)
 - [Pedersen Hash](./cryptographic_primitives/hashes.mdx#pedersen_hash)
@@ -25,7 +24,7 @@ Here is a list of the current black box functions:
 - XOR
 - RANGE
 - [Keccak256](./cryptographic_primitives/hashes.mdx#keccak256)
-- [Recursive proof verification](./recursion.md)
+- [Recursive proof verification](./recursion.mdx)
 
 Most black box functions are included as part of the Noir standard library, however `AND`, `XOR` and `RANGE` are used as part of the Noir language syntax. For instance, using the bitwise operator `&` will invoke the `AND` black box function.
 
diff --git a/docs/docs/noir/standard_library/containers/boundedvec.md b/docs/docs/noir/standard_library/containers/boundedvec.md
index 98b7d584033..4efb1e4ea0f 100644
--- a/docs/docs/noir/standard_library/containers/boundedvec.md
+++ b/docs/docs/noir/standard_library/containers/boundedvec.md
@@ -246,6 +246,42 @@ Example:
 let bounded_vec: BoundedVec<Field, 10> = BoundedVec::from_array([1, 2, 3])
 ```
 
+### from_parts
+
+```rust
+pub fn from_parts(mut array: [T; MaxLen], len: u32) -> Self
+```
+
+Creates a new BoundedVec from the given array and length.
+The given length must be less than or equal to the length of the array.
+
+This function will zero out any elements at or past index `len` of `array`.
+This incurs an extra runtime cost of O(MaxLen). If you are sure your array is
+zeroed after that index, you can use `from_parts_unchecked` to remove the extra loop.
+
+Example:
+
+#include_code from-parts noir_stdlib/src/collections/bounded_vec.nr rust
+
+### from_parts_unchecked
+
+```rust
+pub fn from_parts_unchecked(array: [T; MaxLen], len: u32) -> Self
+```
+
+Creates a new BoundedVec from the given array and length.
+The given length must be less than or equal to the length of the array.
+
+This function is unsafe because it expects all elements past the `len` index
+of `array` to be zeroed, but does not check for this internally. Use `from_parts`
+for a safe version of this function which does zero out any indices past the
+given length. Invalidating this assumption can notably cause `BoundedVec::eq`
+to give incorrect results since it will check even elements past `len`.
+
+Example:
+
+#include_code from-parts-unchecked noir_stdlib/src/collections/bounded_vec.nr rust
+
 ### map
 
 ```rust
diff --git a/docs/docs/noir/standard_library/cryptographic_primitives/ciphers.mdx b/docs/docs/noir/standard_library/cryptographic_primitives/ciphers.mdx
index 0103791d2e4..d2ceb63175a 100644
--- a/docs/docs/noir/standard_library/cryptographic_primitives/ciphers.mdx
+++ b/docs/docs/noir/standard_library/cryptographic_primitives/ciphers.mdx
@@ -7,7 +7,7 @@ keywords:
 sidebar_position: 0
 ---
 
-import BlackBoxInfo from '@site/src/components/Notes/_blackbox.mdx';
+import BlackBoxInfo from '@site/src/components/Notes/_blackbox';
 
 ## aes128
 
@@ -25,4 +25,4 @@ fn main() {
 ```
 
 
-<BlackBoxInfo />
\ No newline at end of file
+<BlackBoxInfo to="../black_box_fns"/>
\ No newline at end of file
diff --git a/docs/docs/noir/standard_library/cryptographic_primitives/ecdsa_sig_verification.mdx b/docs/docs/noir/standard_library/cryptographic_primitives/ecdsa_sig_verification.mdx
index 6787c9f46a1..d46bdc0729b 100644
--- a/docs/docs/noir/standard_library/cryptographic_primitives/ecdsa_sig_verification.mdx
+++ b/docs/docs/noir/standard_library/cryptographic_primitives/ecdsa_sig_verification.mdx
@@ -5,7 +5,7 @@ keywords: [cryptographic primitives, Noir project, ecdsa, secp256k1, secp256r1,
 sidebar_position: 3
 ---
 
-import BlackBoxInfo from '@site/src/components/Notes/_blackbox.mdx';
+import BlackBoxInfo from '@site/src/components/Notes/_blackbox';
 
 Noir supports ECDSA signatures verification over the secp256k1 and secp256r1 curves.
 
@@ -25,7 +25,7 @@ fn main(hashed_message : [u8;32], pub_key_x : [u8;32], pub_key_y : [u8;32], sign
 }
 ```
 
-<BlackBoxInfo />
+<BlackBoxInfo to="../black_box_fns" />
 
 ## ecdsa_secp256k1::verify_signature_slice
 
@@ -33,7 +33,7 @@ Verifier for ECDSA Secp256k1 signatures where the message is a slice.
 
 #include_code ecdsa_secp256k1_slice noir_stdlib/src/ecdsa_secp256k1.nr rust
 
-<BlackBoxInfo />
+<BlackBoxInfo to="../black_box_fns"/>
 
 ## ecdsa_secp256r1::verify_signature
 
@@ -51,7 +51,7 @@ fn main(hashed_message : [u8;32], pub_key_x : [u8;32], pub_key_y : [u8;32], sign
 }
 ```
 
-<BlackBoxInfo />
+<BlackBoxInfo to="../black_box_fns"/>
 
 ## ecdsa_secp256r1::verify_signature
 
@@ -59,4 +59,4 @@ Verifier for ECDSA Secp256r1 signatures where the message is a slice.
 
 #include_code ecdsa_secp256r1_slice noir_stdlib/src/ecdsa_secp256r1.nr rust
 
-<BlackBoxInfo />
+<BlackBoxInfo to="../black_box_fns"/>
diff --git a/docs/docs/noir/standard_library/cryptographic_primitives/embedded_curve_ops.mdx b/docs/docs/noir/standard_library/cryptographic_primitives/embedded_curve_ops.mdx
index f1122fc37d5..e10688857a6 100644
--- a/docs/docs/noir/standard_library/cryptographic_primitives/embedded_curve_ops.mdx
+++ b/docs/docs/noir/standard_library/cryptographic_primitives/embedded_curve_ops.mdx
@@ -5,7 +5,7 @@ keywords: [cryptographic primitives, Noir project, scalar multiplication]
 sidebar_position: 1
 ---
 
-import BlackBoxInfo from '@site/src/components/Notes/_blackbox.mdx';
+import BlackBoxInfo from '@site/src/components/Notes/_blackbox';
 
 The following functions perform operations over the embedded curve whose coordinates are defined by the configured noir field.
 For the BN254 scalar field, this is BabyJubJub or Grumpkin.
@@ -74,4 +74,4 @@ fn main() {
 }
 ```
 
-<BlackBoxInfo />
+<BlackBoxInfo to="../black_box_fns"/>
diff --git a/docs/docs/noir/standard_library/cryptographic_primitives/hashes.mdx b/docs/docs/noir/standard_library/cryptographic_primitives/hashes.mdx
index d2a8204bccb..b7518fa95c1 100644
--- a/docs/docs/noir/standard_library/cryptographic_primitives/hashes.mdx
+++ b/docs/docs/noir/standard_library/cryptographic_primitives/hashes.mdx
@@ -2,13 +2,13 @@
 title: Hash methods
 description:
   Learn about the cryptographic primitives ready to use for any Noir project, including sha256,
-  blake2s, pedersen, mimc_bn254 and mimc
+  blake2s and pedersen
 keywords:
-  [cryptographic primitives, Noir project, sha256, blake2s, pedersen, mimc_bn254, mimc, hash]
+  [cryptographic primitives, Noir project, sha256, blake2s, pedersen, hash]
 sidebar_position: 0
 ---
 
-import BlackBoxInfo from '@site/src/components/Notes/_blackbox.mdx';
+import BlackBoxInfo from '@site/src/components/Notes/_blackbox';
 
 ## sha256
 
@@ -28,7 +28,7 @@ fn main() {
 ```
 
 
-<BlackBoxInfo />
+<BlackBoxInfo to="../black_box_fns"/>
 
 ## blake2s
 
@@ -45,7 +45,7 @@ fn main() {
 }
 ```
 
-<BlackBoxInfo />
+<BlackBoxInfo to="../black_box_fns"/>
 
 ## blake3
 
@@ -62,7 +62,7 @@ fn main() {
 }
 ```
 
-<BlackBoxInfo />
+<BlackBoxInfo to="../black_box_fns"/>
 
 ## pedersen_hash
 
@@ -74,7 +74,7 @@ example:
 
 #include_code pedersen-hash test_programs/execution_success/pedersen_hash/src/main.nr rust
 
-<BlackBoxInfo />
+<BlackBoxInfo to="../black_box_fns" />
 
 ## pedersen_commitment
 
@@ -86,7 +86,7 @@ example:
 
 #include_code pedersen-commitment test_programs/execution_success/pedersen_commitment/src/main.nr rust
 
-<BlackBoxInfo />
+<BlackBoxInfo to="../black_box_fns"/>
 
 ## keccak256
 
@@ -100,7 +100,7 @@ example:
 
 #include_code keccak256 test_programs/execution_success/keccak256/src/main.nr rust
 
-<BlackBoxInfo />
+<BlackBoxInfo to="../black_box_fns"/>
 
 ## poseidon
 
@@ -131,32 +131,6 @@ example:
 
 #include_code poseidon2 test_programs/execution_success/poseidon2/src/main.nr rust
 
-## mimc_bn254 and mimc
-
-`mimc_bn254` is `mimc`, but with hardcoded parameters for the BN254 curve. You can use it by
-providing an array of Fields, and it returns a Field with the hash. You can use the `mimc` method if
-you're willing to input your own constants:
-
-```rust
-fn mimc<N>(x: Field, k: Field, constants: [Field; N], exp : Field) -> Field
-```
-
-otherwise, use the `mimc_bn254` method:
-
-```rust
-fn mimc_bn254<let N: u32>(array: [Field; N]) -> Field
-```
-
-example:
-
-```rust
-
-fn main() {
-    let x = [163, 117, 178, 149]; // some random bytes
-    let hash = std::hash::mimc::mimc_bn254(x);
-}
-```
-
 ## hash_to_field
 
 ```rust
diff --git a/docs/docs/noir/standard_library/mem.md b/docs/docs/noir/standard_library/mem.md
new file mode 100644
index 00000000000..1e9102b32dc
--- /dev/null
+++ b/docs/docs/noir/standard_library/mem.md
@@ -0,0 +1,82 @@
+---
+title: Memory Module
+description:
+  This module contains functions which manipulate memory in a low-level way
+keywords:
+  [
+    mem, memory, zeroed, transmute, checked_transmute
+  ]
+---
+
+# `std::mem::zeroed`
+
+```rust
+fn zeroed<T>() -> T
+```
+
+Returns a zeroed value of any type.
+This function is generally unsafe to use as the zeroed bit pattern is not guaranteed to be valid for all types.
+It can however, be useful in cases when the value is guaranteed not to be used such as in a BoundedVec library implementing a growable vector, up to a certain length, backed by an array.
+The array can be initialized with zeroed values which are guaranteed to be inaccessible until the vector is pushed to.
+Similarly, enumerations in noir can be implemented using this method by providing zeroed values for the unused variants.
+
+This function currently supports the following types:
+
+- Field
+- Bool
+- Uint
+- Array
+- Slice
+- String
+- Tuple
+- Functions
+  
+Using it on other types could result in unexpected behavior.
+
+# `std::mem::checked_transmute`
+
+```rust
+fn checked_transmute<T, U>(value: T) -> U
+```
+
+Transmutes a value of one type into the same value but with a new type `U`.
+
+This function is safe to use since both types are asserted to be equal later during compilation after the concrete values for generic types become known.
+This function is useful for cases where the compiler may fail a type check that is expected to pass where
+a user knows the two types to be equal. For example, when using arithmetic generics there are cases the compiler
+does not see as equal, such as `[Field; N*(A + B)]` and `[Field; N*A + N*B]`, which users may know to be equal.
+In these cases, `checked_transmute` can be used to cast the value to the desired type while also preserving safety
+by checking this equality once `N`, `A`, `B` are fully resolved.
+
+Note that since this safety check is performed after type checking rather than during, no error is issued if the function
+containing `checked_transmute` is never called.
+
+# `std::mem::array_refcount`
+
+```rust
+fn array_refcount<T, let N: u32>(array: [T; N]) -> u32 {}
+```
+
+Returns the internal reference count of an array value in unconstrained code.
+
+Arrays only have reference count in unconstrained code - using this anywhere
+else will return zero.
+
+This function is mostly intended for debugging compiler optimizations but can also be used
+to find where array copies may be happening in unconstrained code by placing it before array
+mutations.
+
+# `std::mem::slice_refcount`
+
+```rust
+fn slice_refcount<T>(slice: [T]) -> u32 {}
+```
+
+Returns the internal reference count of a slice value in unconstrained code.
+
+Slices only have reference count in unconstrained code - using this anywhere
+else will return zero.
+
+This function is mostly intended for debugging compiler optimizations but can also be used
+to find where slice copies may be happening in unconstrained code by placing it before slice
+mutations.
diff --git a/docs/docs/noir/standard_library/meta/index.md b/docs/docs/noir/standard_library/meta/index.md
index db0e5d0e411..76daa594b1f 100644
--- a/docs/docs/noir/standard_library/meta/index.md
+++ b/docs/docs/noir/standard_library/meta/index.md
@@ -128,7 +128,7 @@ way to write your derive handler. The arguments are as follows:
 - `for_each_field`: An operation to be performed on each field. E.g. `|name| quote { (self.$name == other.$name) }`.
 - `join_fields_with`: A separator to join each result of `for_each_field` with.
   E.g. `quote { & }`. You can also use an empty `quote {}` for no separator.
-- `body`: The result of the field operations are passed into this function for any final processing.
+- `body`: The result of the field operations is passed into this function for any final processing.
   This is the place to insert any setup/teardown code the trait requires. If the trait doesn't require
   any such code, you can return the body as-is: `|body| body`.
 
diff --git a/docs/docs/noir/standard_library/meta/op.md b/docs/docs/noir/standard_library/meta/op.md
index 55d2d244344..90501e05fa4 100644
--- a/docs/docs/noir/standard_library/meta/op.md
+++ b/docs/docs/noir/standard_library/meta/op.md
@@ -142,7 +142,7 @@ Represents a binary operator. One of `+`, `-`, `*`, `/`, `%`, `==`, `!=`, `<`, `
 
 #### is_shift_left
 
-#include_code is_shift_right noir_stdlib/src/meta/op.nr rust
+#include_code is_shift_left noir_stdlib/src/meta/op.nr rust
 
 `true` if this operator is `<<`
 
diff --git a/docs/docs/noir/standard_library/meta/typ.md b/docs/docs/noir/standard_library/meta/typ.md
index 5a8b43b1dfa..455853bfea3 100644
--- a/docs/docs/noir/standard_library/meta/typ.md
+++ b/docs/docs/noir/standard_library/meta/typ.md
@@ -63,6 +63,12 @@ return the numeric constant.
 If this is an integer type, return a boolean which is `true`
 if the type is signed, as well as the number of bits of this integer type.
 
+### as_mutable_reference
+
+#include_code as_mutable_reference noir_stdlib/src/meta/typ.nr rust
+
+If this is a mutable reference type `&mut T`, returns the mutable type `T`.
+
 ### as_slice
 
 #include_code as_slice noir_stdlib/src/meta/typ.nr rust
@@ -95,7 +101,7 @@ If this is a tuple type, returns each element type of the tuple.
 Retrieves the trait implementation that implements the given
 trait constraint for this type. If the trait constraint is not
 found, `None` is returned. Note that since the concrete trait implementation
-for a trait constraint specified from a `where` clause is unknown,
+for a trait constraint specified in a `where` clause is unknown,
 this function will return `None` in these cases. If you only want to know
 whether a type implements a trait, use `implements` instead.
 
@@ -146,6 +152,12 @@ fn foo<T>() where T: Default {
 
 `true` if this type is `Field`.
 
+### is_unit
+
+#include_code is_unit noir_stdlib/src/meta/typ.nr rust
+
+`true` if this type is the unit `()` type.
+
 ## Trait Implementations
 
 ```rust
diff --git a/docs/docs/noir/standard_library/meta/unresolved_type.md b/docs/docs/noir/standard_library/meta/unresolved_type.md
index 9c61f91dee2..8535cbab19c 100644
--- a/docs/docs/noir/standard_library/meta/unresolved_type.md
+++ b/docs/docs/noir/standard_library/meta/unresolved_type.md
@@ -6,8 +6,32 @@ title: UnresolvedType
 
 ## Methods
 
+### as_mutable_reference
+
+#include_code as_mutable_reference noir_stdlib/src/meta/unresolved_type.nr rust
+
+If this is a mutable reference type `&mut T`, returns the mutable type `T`.
+
+### as_slice
+
+#include_code as_slice noir_stdlib/src/meta/unresolved_type.nr rust
+
+If this is a slice `&[T]`, returns the element type `T`.
+
+### is_bool
+
+#include_code is_bool noir_stdlib/src/meta/unresolved_type.nr rust
+
+Returns `true` if this type is `bool`.
+
 ### is_field
 
 #include_code is_field noir_stdlib/src/meta/unresolved_type.nr rust
 
 Returns true if this type refers to the Field type.
+
+### is_unit
+
+#include_code is_unit noir_stdlib/src/meta/unresolved_type.nr rust
+
+Returns true if this type is the unit `()` type.
diff --git a/docs/docs/noir/standard_library/recursion.mdx b/docs/docs/noir/standard_library/recursion.mdx
new file mode 100644
index 00000000000..fcb36278060
--- /dev/null
+++ b/docs/docs/noir/standard_library/recursion.mdx
@@ -0,0 +1,67 @@
+---
+title: Recursive Proofs
+description: Learn about how to write recursive proofs in Noir.
+keywords: [recursion, recursive proofs, verification_key, verify_proof]
+---
+
+import BlackBoxInfo from '@site/src/components/Notes/_blackbox';
+
+Noir supports recursively verifying proofs, meaning you verify the proof of a Noir program in another Noir program. This enables creating proofs of arbitrary size by doing step-wise verification of smaller components of a large proof.
+
+Read [the explainer on recursion](../../explainers/explainer-recursion.md) to know more about this function and the [guide on how to use it.](../../how_to/how-to-recursion.md)
+
+## Verifying Recursive Proofs
+
+```rust
+#[foreign(recursive_aggregation)]
+pub fn verify_proof(verification_key: [Field], proof: [Field], public_inputs: [Field], key_hash: Field) {}
+```
+
+<BlackBoxInfo to="black_box_fns"/>
+
+## Example usage
+
+```rust
+
+fn main(
+    verification_key : [Field; 114],
+    proof : [Field; 93],
+    public_inputs : [Field; 1],
+    key_hash : Field,
+    proof_b : [Field; 93],
+) {
+    std::verify_proof(
+        verification_key,
+        proof,
+        public_inputs,
+        key_hash
+    );
+
+    std::verify_proof(
+        verification_key,
+        proof_b,
+        public_inputs,
+        key_hash
+    );
+}
+```
+
+You can see a full example of recursive proofs in [this example recursion demo repo](https://github.com/noir-lang/noir-examples/tree/master/recursion).
+
+## Parameters
+
+### `verification_key`
+
+The verification key for the zk program that is being verified.
+
+### `proof`
+
+The proof for the zk program that is being verified.
+
+### `public_inputs`
+
+These represent the public inputs of the proof we are verifying.
+
+### `key_hash`
+
+A key hash is used to check the validity of the verification key. The circuit implementing this opcode can use this hash to ensure that the key provided to the circuit matches the key produced by the circuit creator.
diff --git a/docs/docs/reference/noir_codegen.md b/docs/docs/reference/noir_codegen.md
index db8f07dc22e..e4c362f9610 100644
--- a/docs/docs/reference/noir_codegen.md
+++ b/docs/docs/reference/noir_codegen.md
@@ -7,7 +7,8 @@ sidebar_position: 3
 
 When using TypeScript, it is extra work to interpret Noir program outputs in a type-safe way. Third party libraries may exist for popular Noir programs, but they are either hard to find or unmaintained.
 
-Now you can generate TypeScript bindings for your Noir programs in two steps: 
+Now you can generate TypeScript bindings for your Noir programs in two steps:
+
 1. Exporting Noir functions using `nargo export`
 2. Using the TypeScript module `noir_codegen` to generate TypeScript binding
 
@@ -33,7 +34,8 @@ yarn add @noir-lang/noir_codegen -D
 ```
 
 ### Nargo library
-Make sure you have Nargo, v0.25.0 or greater, installed. If you don't, follow the [installation guide](../getting_started/installation/index.md). 
+
+Make sure you have Nargo, v0.25.0 or greater, installed. If you don't, follow the [installation guide](../getting_started/noir_installation.md).
 
 If you're in a new project, make a `circuits` folder and create a new Noir library:
 
diff --git a/docs/docs/tooling/debugger.md b/docs/docs/tooling/debugger.md
index 9b7565ba9ff..200b5fc423a 100644
--- a/docs/docs/tooling/debugger.md
+++ b/docs/docs/tooling/debugger.md
@@ -12,7 +12,7 @@ There are currently two ways of debugging Noir programs:
 1. From VS Code, via the [vscode-noir](https://github.com/noir-lang/vscode-noir) extension. You can install it via the [Visual Studio Marketplace](https://marketplace.visualstudio.com/items?itemName=noir-lang.vscode-noir).
 2. Via the REPL debugger, which ships with Nargo.
 
-In order to use either version of the debugger, you will need to install recent enough versions of Noir, [Nargo](../getting_started/installation/index.md) and vscode-noir:
+In order to use either version of the debugger, you will need to install recent enough versions of Noir, [Nargo](../getting_started/noir_installation.md) and vscode-noir:
 
 - Noir & Nargo ≥0.28.0
 - Noir's VS Code extension ≥0.0.11
diff --git a/docs/docs/tutorials/noirjs_app.md b/docs/docs/tutorials/noirjs_app.md
index eac28168445..6e69ea0bbed 100644
--- a/docs/docs/tutorials/noirjs_app.md
+++ b/docs/docs/tutorials/noirjs_app.md
@@ -24,13 +24,13 @@ Before we start, we want to make sure we have Node, Nargo and the Barretenberg p
 
 We start by opening a terminal and executing `node --version`. If we don't get an output like `v20.10.0`, that means node is not installed. Let's do that by following the handy [nvm guide](https://github.com/nvm-sh/nvm?tab=readme-ov-file#install--update-script).
 
-As for `Nargo`, we can follow the [Nargo guide](../getting_started/installation/index.md) to install it. If you're lazy, just paste this on a terminal and run `noirup`:
+As for `Nargo`, we can follow the [Nargo guide](../getting_started/quick_start.md) to install it. If you're lazy, just paste this on a terminal and run `noirup`:
 
 ```sh
 curl -L https://raw.githubusercontent.com/noir-lang/noirup/main/install | bash
 ```
 
-Follow the instructions on [this page](https://github.com/AztecProtocol/aztec-packages/tree/master/barretenberg/cpp/src/barretenberg/bb#installation) to install `bb`. 
+Follow the instructions on [this page](https://github.com/AztecProtocol/aztec-packages/tree/master/barretenberg/cpp/src/barretenberg/bb#installation) to install `bb`.
 Version 0.41.0 is compatible with `nargo` version 0.31.0, which you can install with `bbup -v 0.41.0` once `bbup` is installed.
 
 Easy enough. Onwards!
@@ -78,7 +78,7 @@ At this point in the tutorial, your folder structure should look like this:
 ### Node and Vite
 
 If you want to explore Nargo, feel free to go on a side-quest now and follow the steps in the
-[getting started](../getting_started/hello_noir/index.md) guide. However, we want our app to run on the browser, so we need Vite.
+[getting started](../getting_started/quick_start.md) guide. However, we want our app to run on the browser, so we need Vite.
 
 Vite is a powerful tool to generate static websites. While it provides all kinds of features, let's just go barebones with some good old vanilla JS.
 
@@ -350,13 +350,17 @@ You should also check out the more advanced examples in the [noir-examples repo]
 ## UltraHonk Backend
 
 Barretenberg has recently exposed a new UltraHonk backend. We can use UltraHonk in NoirJS after version 0.33.0. Everything will be the same as the tutorial above, except that the class we need to import will change:
+
 ```js
 import { UltraHonkBackend, UltraHonkVerifier as Verifier } from '@noir-lang/backend_barretenberg';
 ```
+
 The backend will then be instantiated as such:
+
 ```js
 const backend = new UltraHonkBackend(circuit);
 ```
+
 Then all the commands to prove and verify your circuit will be same.
 
-The only feature currently unsupported with UltraHonk are [recursive proofs](../explainers/explainer-recursion.md).
\ No newline at end of file
+The only feature currently unsupported with UltraHonk are [recursive proofs](../explainers/explainer-recursion.md).
diff --git a/docs/docusaurus.config.ts b/docs/docusaurus.config.ts
index 29f612b0109..eee4e7f8236 100644
--- a/docs/docusaurus.config.ts
+++ b/docs/docusaurus.config.ts
@@ -15,7 +15,7 @@ export default {
   url: 'https://noir-lang.org',
   baseUrl: '/',
   onBrokenLinks: 'throw',
-  onBrokenMarkdownLinks: 'throw',
+  onBrokenMarkdownLinks: process.env.ENV === 'dev' ? 'warn' : 'throw',
   i18n: {
     defaultLocale: 'en',
     locales: ['en'],
@@ -26,7 +26,7 @@ export default {
       '@docusaurus/preset-classic',
       {
         docs: {
-          path: 'processed-docs',
+          path: process.env.ENV === 'dev' ? 'docs' : 'processed-docs',
           sidebarPath: './sidebars.js',
           routeBasePath: '/docs',
           remarkPlugins: [math],
@@ -48,7 +48,7 @@ export default {
     ],
   ],
   customFields: {
-    MATOMO_ENV: process.env.MATOMO_ENV,
+    MATOMO_ENV: process.env.ENV,
   },
   themeConfig: {
     colorMode: {
@@ -57,8 +57,8 @@ export default {
     navbar: {
       logo: {
         alt: 'Noir Logo',
-        src: 'img/logo.svg',
-        srcDark: 'img/logoDark.svg',
+        src: 'img/logoDark.svg',
+        srcDark: 'img/logo.svg',
         href: '/',
       },
       items: [
@@ -181,37 +181,6 @@ export default {
         membersWithOwnFile: ['Interface', 'Class', 'TypeAlias', 'Function'],
       },
     ],
-    [
-      'docusaurus-plugin-typedoc',
-      {
-        id: 'noir_js_backend_barretenberg',
-        entryPoints: ['../tooling/noir_js_backend_barretenberg/src/index.ts'],
-        tsconfig: '../tooling/noir_js_backend_barretenberg/tsconfig.json',
-        entryPointStrategy: 'resolve',
-        out: 'processed-docs/reference/NoirJS/backend_barretenberg',
-        plugin: ['typedoc-plugin-markdown'],
-        name: 'backend_barretenberg',
-        disableSources: true,
-        excludePrivate: true,
-        skipErrorChecking: true,
-        sidebar: {
-          filteredIds: ['reference/NoirJS/backend_barretenberg/index'],
-        },
-        readme: 'none',
-        hidePageHeader: true,
-        hideBreadcrumbs: true,
-        hideInPageTOC: true,
-        useCodeBlocks: true,
-        typeDeclarationFormat: 'table',
-        propertiesFormat: 'table',
-        parametersFormat: 'table',
-        enumMembersFormat: 'table',
-        indexFormat: 'table',
-        outputFileStrategy: 'members',
-        memberPageTitle: '{name}',
-        membersWithOwnFile: ['Interface', 'Class', 'TypeAlias'],
-      },
-    ],
     [
       'docusaurus-plugin-typedoc',
       {
diff --git a/docs/package.json b/docs/package.json
index c81d0b7b24f..39807588eaa 100644
--- a/docs/package.json
+++ b/docs/package.json
@@ -4,7 +4,7 @@
   "private": true,
   "scripts": {
     "preprocess": "yarn workspace @noir-lang/acvm_js build && ./scripts/codegen_nargo_reference.sh && yarn node ./scripts/preprocess/index.js",
-    "start": "yarn preprocess && MATOMO_ENV=dev docusaurus start",
+    "dev": "yarn preprocess && ENV=dev docusaurus start",
     "build": "yarn preprocess && docusaurus build",
     "clean": "rm -rf ./processed-docs ./processed-docs ./build",
     "version::stables": "ts-node ./scripts/setStable.ts",
@@ -13,8 +13,8 @@
     "version": "yarn version::stables && ./scripts/cut_version.sh"
   },
   "dependencies": {
-    "@docusaurus/core": "^3.0.1",
-    "@docusaurus/preset-classic": "^3.0.1",
+    "@docusaurus/core": "^3.5.2",
+    "@docusaurus/preset-classic": "^3.5.2",
     "@easyops-cn/docusaurus-search-local": "^0.35.0",
     "@mdx-js/react": "^3.0.0",
     "@noir-lang/noir_js": "workspace:*",
@@ -31,9 +31,9 @@
     "remark-math": "^6.0.0"
   },
   "devDependencies": {
-    "@docusaurus/module-type-aliases": "^3.0.1",
-    "@docusaurus/tsconfig": "^3.0.1",
-    "@docusaurus/types": "^3.0.1",
+    "@docusaurus/module-type-aliases": "^3.5.2",
+    "@docusaurus/tsconfig": "^3.5.2",
+    "@docusaurus/types": "^3.5.2",
     "@types/prettier": "^3",
     "docusaurus-plugin-typedoc": "1.0.0-next.18",
     "eslint-plugin-prettier": "^5.1.3",
diff --git a/docs/src/components/Notes/_blackbox.jsx b/docs/src/components/Notes/_blackbox.jsx
new file mode 100644
index 00000000000..ae3c5987cb6
--- /dev/null
+++ b/docs/src/components/Notes/_blackbox.jsx
@@ -0,0 +1,12 @@
+import Link from '@docusaurus/Link';
+
+export default function BlackBoxInfo({ to }) {
+  return (
+    <div>
+      <p>
+        This is a black box function. Read <Link to={to}>this section</Link> to learn more about black box functions in
+        Noir.
+      </p>
+    </div>
+  );
+}
diff --git a/docs/src/components/Notes/_blackbox.mdx b/docs/src/components/Notes/_blackbox.mdx
deleted file mode 100644
index 514ca00a7e7..00000000000
--- a/docs/src/components/Notes/_blackbox.mdx
+++ /dev/null
@@ -1,5 +0,0 @@
-:::info
-
-This is a black box function. Read [this section](/docs/noir/standard_library/black_box_fns) to learn more about black box functions in Noir.
-
-:::
diff --git a/docs/src/pages/index.jsx b/docs/src/pages/index.jsx
index e6532b1db85..868df304233 100644
--- a/docs/src/pages/index.jsx
+++ b/docs/src/pages/index.jsx
@@ -31,7 +31,7 @@ export default function Landing() {
 
           <div className="homepage_cta_header_container">
             <div className="homepage_cta_container">
-              <Link to="/docs" target="_blank" rel="noopener noreferrer">
+              <Link to="/docs">
                 <button className="cta-button button button--primary button--lg homepage_cta">Read the Docs</button>
               </Link>
             </div>
diff --git a/docs/static/img/favicon.ico b/docs/static/img/favicon.ico
index 1c85cef482e..0abffba22ef 100644
Binary files a/docs/static/img/favicon.ico and b/docs/static/img/favicon.ico differ
diff --git a/docs/static/img/homepage_header_pic.png b/docs/static/img/homepage_header_pic.png
index d629e202232..f6bdd5378f6 100644
Binary files a/docs/static/img/homepage_header_pic.png and b/docs/static/img/homepage_header_pic.png differ
diff --git a/docs/static/img/logo.png b/docs/static/img/logo.png
index 83d3a66f2b1..0df14cf4f00 100644
Binary files a/docs/static/img/logo.png and b/docs/static/img/logo.png differ
diff --git a/docs/static/img/logo.svg b/docs/static/img/logo.svg
index 8095d6a169d..f6fadf87bcb 100644
--- a/docs/static/img/logo.svg
+++ b/docs/static/img/logo.svg
@@ -1,29 +1,14 @@
-<?xml version="1.0" encoding="utf-8"?>
-<!-- Generator: Adobe Illustrator 27.3.1, SVG Export Plug-In . SVG Version: 6.00 Build 0)  -->
-<svg version="1.1" id="Layer_1" xmlns="http://www.w3.org/2000/svg" xmlns:xlink="http://www.w3.org/1999/xlink" x="0px" y="0px"
-	 viewBox="0 0 704 225.9" style="enable-background:new 0 0 704 225.9;" xml:space="preserve">
-<style type="text/css">
-	.st0{fill:#2F204A;}
-</style>
-<g>
-	<path class="st0" d="M129.1,70.2c-0.8-0.8-1.8-0.8-2.7,0l-43.2,43.2c-0.8,0.8-0.8,1.8,0,2.7l43.2,43.2c0.8,0.8,1.8,0.8,2.7,0
-		l43.2-43.2c0.8-0.8,0.8-1.8,0-2.7L129.1,70.2z"/>
-	<path class="st0" d="M148.6,20.8c-11.5-11.5-30.1-11.5-41.6,0L33.9,93.9c-11.5,11.5-11.5,30.1,0,41.6l73.1,73.1
-		c11.5,11.5,30.1,11.5,41.6,0l72.9-73.3c11.5-11.5,11.5-30.1,0-41.6L148.6,20.8z M202.6,119.7l-69.8,69.8l-0.2,0.2
-		c-2.9,2.7-7.2,2.7-10-0.2l-69.8-69.8l-0.2-0.2c-2.7-2.9-2.7-7.2,0.2-10l70-70l0.2-0.2c2.9-2.5,7.4-2.5,10,0.4l69.6,69.6
-		C205.5,112.1,205.5,116.8,202.6,119.7z"/>
-	<polygon class="st0" points="381.6,146.3 310,39.2 281.9,39.2 281.9,192.1 308.1,192.1 308.1,79.9 383.9,192.1 407.8,192.1 
-		407.8,39.2 381.6,39.2 	"/>
-	<path class="st0" d="M522.1,95.2c-5-5.5-10.8-9.8-17.6-12.7c-6.7-2.9-14.1-4.4-22-4.4c-8,0-15.3,1.5-22,4.4
-		c-6.7,2.9-12.6,7.1-17.6,12.7c-4.7,5.1-8.2,11.2-10.7,18.2c-2.4,7-3.6,14.7-3.6,22.9c0,8.2,1.2,15.9,3.6,22.9
-		c2.4,7,6,13.1,10.7,18.2c5,5.5,10.8,9.8,17.6,12.7c6.7,2.9,14.1,4.4,22,4.4c8,0,15.3-1.5,22-4.4c6.7-2.9,12.6-7.1,17.6-12.7
-		c4.7-5.1,8.2-11.2,10.6-18.2c2.4-7,3.6-14.7,3.6-22.9c0-8.2-1.2-15.9-3.6-22.9C530.4,106.4,526.8,100.3,522.1,95.2z M503.1,163.2
-		c-5,6.5-11.9,9.8-20.6,9.8c-8.7,0-15.5-3.3-20.6-9.8c-5-6.5-7.6-15.5-7.6-26.8c0-11.4,2.5-20.3,7.6-26.8c5-6.5,11.9-9.8,20.6-9.8
-		c8.7,0,15.5,3.3,20.6,9.8c5,6.5,7.6,15.5,7.6,26.8C510.6,147.7,508.1,156.6,503.1,163.2z"/>
-	<rect x="556.2" y="80.3" class="st0" width="25.6" height="111.8"/>
-	<rect x="555.8" y="39.2" class="st0" width="26.4" height="26.2"/>
-	<path class="st0" d="M668.2,79.8c-1.1-0.1-2.3-0.1-3.4-0.1c-7,0-13.2,1.6-18.6,4.7c-5.5,3.1-9.5,7.3-12,12.6V80.3h-25.6v111.8h25.6
-		v-58.8c0-8.5,2.6-15.4,7.9-20.6c5.3-5.2,12.1-7.8,20.7-7.8c1.7,0,3.3,0,4.7,0.1c1.4,0.1,3,0.2,4.7,0.5V80.1
-		C670.7,80,669.4,79.9,668.2,79.8z"/>
-</g>
-</svg>
+<?xml version="1.0" encoding="UTF-8"?>
+<svg id="Layer_2" data-name="Layer 2" xmlns="http://www.w3.org/2000/svg" viewBox="0 0 81.73 57.05">
+  <defs>
+    <style>
+      .cls-1 {
+        fill: #fff;
+        stroke-width: 0px;
+      }
+    </style>
+  </defs>
+  <g id="Layer_1-2" data-name="Layer 1">
+    <path class="cls-1" d="M76.63.94c-1.16-.42-2.44-.64-3.75-.64-5.92,0-12.34,5.05-15.83,14.44-1.44-10.14-6.83-14.74-15.32-14.74-6.97,0-13.68,3.35-19.69,10.13l-.83-8.93-1.86-1.2L0,7.33v4.31l8.15,1.04c.23,4.63.35,7.62.35,13.99v6.08c0,5.02-.06,12.36-.17,18.1l-7.47,1.48v4.73h28.58v-4.73l-6.83-1.41c-.11-5.75-.17-13.13-.17-18.17V15.46c4.57-3.88,8.88-5.79,13.02-5.79,5.75,0,8.07,3.05,8.07,12.11v10.95c0,5.17-.06,12.43-.17,18.11l-7.34,1.47v4.73h28.62v-4.73l-7-1.42c-.11-5.69-.17-12.97-.17-18.16v-10.04c1.78-5.19,4.56-9.39,8.11-12.39l1.03,1.13c2.42,2.71,4.88,4.09,7.96,4.09,2.33,0,4.17-.82,5.45-2.36,3.36-4.05,1.57-10.45-3.38-12.24Z"/>
+  </g>
+</svg>
\ No newline at end of file
diff --git a/docs/static/img/logoDark.png b/docs/static/img/logoDark.png
new file mode 100644
index 00000000000..25d554c486c
Binary files /dev/null and b/docs/static/img/logoDark.png differ
diff --git a/docs/static/img/logoDark.svg b/docs/static/img/logoDark.svg
index dee9f27a6a9..ac0f9897b30 100644
--- a/docs/static/img/logoDark.svg
+++ b/docs/static/img/logoDark.svg
@@ -1,29 +1,13 @@
-<?xml version="1.0" encoding="utf-8"?>
-<!-- Generator: Adobe Illustrator 27.3.1, SVG Export Plug-In . SVG Version: 6.00 Build 0)  -->
-<svg version="1.1" id="Layer_1" xmlns="http://www.w3.org/2000/svg" xmlns:xlink="http://www.w3.org/1999/xlink" x="0px" y="0px"
-	 viewBox="0 0 704 225.9" style="enable-background:new 0 0 704 225.9;" xml:space="preserve">
-<style type="text/css">
-	.st0{fill:white;}
-</style>
-<g>
-	<path class="st0" d="M129.1,70.2c-0.8-0.8-1.8-0.8-2.7,0l-43.2,43.2c-0.8,0.8-0.8,1.8,0,2.7l43.2,43.2c0.8,0.8,1.8,0.8,2.7,0
-		l43.2-43.2c0.8-0.8,0.8-1.8,0-2.7L129.1,70.2z"/>
-	<path class="st0" d="M148.6,20.8c-11.5-11.5-30.1-11.5-41.6,0L33.9,93.9c-11.5,11.5-11.5,30.1,0,41.6l73.1,73.1
-		c11.5,11.5,30.1,11.5,41.6,0l72.9-73.3c11.5-11.5,11.5-30.1,0-41.6L148.6,20.8z M202.6,119.7l-69.8,69.8l-0.2,0.2
-		c-2.9,2.7-7.2,2.7-10-0.2l-69.8-69.8l-0.2-0.2c-2.7-2.9-2.7-7.2,0.2-10l70-70l0.2-0.2c2.9-2.5,7.4-2.5,10,0.4l69.6,69.6
-		C205.5,112.1,205.5,116.8,202.6,119.7z"/>
-	<polygon class="st0" points="381.6,146.3 310,39.2 281.9,39.2 281.9,192.1 308.1,192.1 308.1,79.9 383.9,192.1 407.8,192.1 
-		407.8,39.2 381.6,39.2 	"/>
-	<path class="st0" d="M522.1,95.2c-5-5.5-10.8-9.8-17.6-12.7c-6.7-2.9-14.1-4.4-22-4.4c-8,0-15.3,1.5-22,4.4
-		c-6.7,2.9-12.6,7.1-17.6,12.7c-4.7,5.1-8.2,11.2-10.7,18.2c-2.4,7-3.6,14.7-3.6,22.9c0,8.2,1.2,15.9,3.6,22.9
-		c2.4,7,6,13.1,10.7,18.2c5,5.5,10.8,9.8,17.6,12.7c6.7,2.9,14.1,4.4,22,4.4c8,0,15.3-1.5,22-4.4c6.7-2.9,12.6-7.1,17.6-12.7
-		c4.7-5.1,8.2-11.2,10.6-18.2c2.4-7,3.6-14.7,3.6-22.9c0-8.2-1.2-15.9-3.6-22.9C530.4,106.4,526.8,100.3,522.1,95.2z M503.1,163.2
-		c-5,6.5-11.9,9.8-20.6,9.8c-8.7,0-15.5-3.3-20.6-9.8c-5-6.5-7.6-15.5-7.6-26.8c0-11.4,2.5-20.3,7.6-26.8c5-6.5,11.9-9.8,20.6-9.8
-		c8.7,0,15.5,3.3,20.6,9.8c5,6.5,7.6,15.5,7.6,26.8C510.6,147.7,508.1,156.6,503.1,163.2z"/>
-	<rect x="556.2" y="80.3" class="st0" width="25.6" height="111.8"/>
-	<rect x="555.8" y="39.2" class="st0" width="26.4" height="26.2"/>
-	<path class="st0" d="M668.2,79.8c-1.1-0.1-2.3-0.1-3.4-0.1c-7,0-13.2,1.6-18.6,4.7c-5.5,3.1-9.5,7.3-12,12.6V80.3h-25.6v111.8h25.6
-		v-58.8c0-8.5,2.6-15.4,7.9-20.6c5.3-5.2,12.1-7.8,20.7-7.8c1.7,0,3.3,0,4.7,0.1c1.4,0.1,3,0.2,4.7,0.5V80.1
-		C670.7,80,669.4,79.9,668.2,79.8z"/>
-</g>
-</svg>
+<?xml version="1.0" encoding="UTF-8"?>
+<svg id="Layer_2" data-name="Layer 2" xmlns="http://www.w3.org/2000/svg" viewBox="0 0 81.73 57.05">
+  <defs>
+    <style>
+      .cls-1 {
+        stroke-width: 0px;
+      }
+    </style>
+  </defs>
+  <g id="Layer_1-2" data-name="Layer 1">
+    <path class="cls-1" d="M76.63.94c-1.16-.42-2.44-.64-3.75-.64-5.92,0-12.34,5.05-15.83,14.44-1.44-10.14-6.83-14.74-15.32-14.74-6.97,0-13.68,3.35-19.69,10.13l-.83-8.93-1.86-1.2L0,7.33v4.31l8.15,1.04c.23,4.63.35,7.62.35,13.99v6.08c0,5.02-.06,12.36-.17,18.1l-7.47,1.48v4.73h28.58v-4.73l-6.83-1.41c-.11-5.75-.17-13.13-.17-18.17V15.46c4.57-3.88,8.88-5.79,13.02-5.79,5.75,0,8.07,3.05,8.07,12.11v10.95c0,5.17-.06,12.43-.17,18.11l-7.34,1.47v4.73h28.62v-4.73l-7-1.42c-.11-5.69-.17-12.97-.17-18.16v-10.04c1.78-5.19,4.56-9.39,8.11-12.39l1.03,1.13c2.42,2.71,4.88,4.09,7.96,4.09,2.33,0,4.17-.82,5.45-2.36,3.36-4.05,1.57-10.45-3.38-12.24Z"/>
+  </g>
+</svg>
\ No newline at end of file
diff --git a/docs/versioned_docs/version-v0.32.0/explainers/explainer-recursion.md b/docs/versioned_docs/version-v0.32.0/explainers/explainer-recursion.md
index 18846176ca7..df8529ef4e0 100644
--- a/docs/versioned_docs/version-v0.32.0/explainers/explainer-recursion.md
+++ b/docs/versioned_docs/version-v0.32.0/explainers/explainer-recursion.md
@@ -111,7 +111,7 @@ He might find it more efficient to generate a proof for that setup phase separat
 
 ## What params do I need
 
-As you can see in the [recursion reference](noir/standard_library/recursion.md), a simple recursive proof requires:
+As you can see in the [recursion reference](noir/standard_library/recursion.mdx), a simple recursive proof requires:
 
 - The proof to verify
 - The Verification Key of the circuit that generated the proof
diff --git a/docs/versioned_docs/version-v0.32.0/how_to/debugger/debugging_with_the_repl.md b/docs/versioned_docs/version-v0.32.0/how_to/debugger/debugging_with_the_repl.md
index 09e5bae68ad..1d64dae3f37 100644
--- a/docs/versioned_docs/version-v0.32.0/how_to/debugger/debugging_with_the_repl.md
+++ b/docs/versioned_docs/version-v0.32.0/how_to/debugger/debugging_with_the_repl.md
@@ -1,7 +1,7 @@
 ---
 title: Using the REPL Debugger
 description:
-  Step by step guide on how to debug your Noir circuits with the REPL Debugger. 
+  Step-by-step guide on how to debug your Noir circuits with the REPL Debugger. 
 keywords:
   [
     Nargo,
diff --git a/docs/versioned_docs/version-v0.32.0/how_to/how-to-oracles.md b/docs/versioned_docs/version-v0.32.0/how_to/how-to-oracles.md
index 2f69902062c..94a89710e66 100644
--- a/docs/versioned_docs/version-v0.32.0/how_to/how-to-oracles.md
+++ b/docs/versioned_docs/version-v0.32.0/how_to/how-to-oracles.md
@@ -18,8 +18,6 @@ This guide shows you how to use oracles in your Noir program. For the sake of cl
 - You understand the concept of a JSON-RPC server. Visit the [JSON-RPC website](https://www.jsonrpc.org/) if you need a refresher.
 - You are comfortable with server-side JavaScript (e.g. Node.js, managing packages, etc.).
 
-For reference, you can find the snippets used in this tutorial on the [Aztec DevRel Repository](https://github.com/AztecProtocol/dev-rel/tree/main/code-snippets/how-to-oracles).
-
 ## Rundown
 
 This guide has 3 major steps:
@@ -137,38 +135,32 @@ app.listen(5555);
 Now, we will add our `getSqrt` method, as expected by the `#[oracle(getSqrt)]` decorator in our Noir code. It maps through the params array and returns their square roots:
 
 ```js
-server.addMethod("resolve_function_call", async (params) => {
-  if params.function !== "getSqrt" {
-    throw Error("Unexpected foreign call")
-  };
-  const values = params.inputs[0].Array.map((field) => {
-    return `${Math.sqrt(parseInt(field, 16))}`;
-  });
-  return { values: [{ Array: values }] };
+server.addMethod("resolve_foreign_call", async (params) => {
+    if (params[0].function !== "getSqrt") {
+        throw Error("Unexpected foreign call")
+    };
+    const values = params[0].inputs[0].map((field) => {
+        return `${Math.sqrt(parseInt(field, 16))}`;
+    });
+    return { values: [values] };
 });
 ```
 
 If you're using Typescript, the following types may be helpful in understanding the expected return value and making sure they're easy to follow:
 
 ```js
-interface SingleForeignCallParam {
-  Single: string,
-}
-
-interface ArrayForeignCallParam {
-  Array: string[],
-}
+export type ForeignCallSingle = string;
 
-type ForeignCallParam = SingleForeignCallParam | ArrayForeignCallParam;
+export type ForeignCallArray = string[];
 
-interface ForeignCallResult {
-  values: ForeignCallParam[],
-}
+export type ForeignCallResult = {
+  values: (ForeignCallSingle | ForeignCallArray)[];
+};
 ```
 
-::: Multidimensional Arrays
+:::info Multidimensional Arrays
 
-If the Oracle function is returning an array containing other arrays, such as `[['1','2],['3','4']]`, you need to provide the values in json as flattened values. In the previous example, it would be `['1', '2', '3', '4']`. In the noir program, the Oracle signature can use a nested type, the flattened values will be automatically converted to the nested type.
+If the Oracle function is returning an array containing other arrays, such as `[['1','2],['3','4']]`, you need to provide the values in JSON as flattened values. In the previous example, it would be `['1', '2', '3', '4']`. In the Noir program, the Oracle signature can use a nested type, the flattened values will be automatically converted to the nested type.
 
 :::
 
@@ -233,17 +225,21 @@ const client = new JSONRPCClient((jsonRPCRequest) => {
 
 // declaring a function that takes the name of the foreign call (getSqrt) and the inputs
 const foreignCallHandler = async (name, input) => {
-    // notice that the "inputs" parameter contains *all* the inputs
-    // in this case we make the RPC request with the first parameter "numbers", which would be input[0]
-    const oracleReturn = await client.request(name, [
-      input[0].map((i) => i.toString("hex")),
-    ]);
-    return { values: oracleReturn };
+  const inputs = input[0].map((i) => i.toString("hex"))
+  // notice that the "inputs" parameter contains *all* the inputs
+  // in this case we to make the RPC request with the first parameter "numbers", which would be input[0]
+  const oracleReturn = await client.request("resolve_foreign_call", [
+    {
+      function: name,
+      inputs: [inputs]
+    },
+  ]);
+  return [oracleReturn.values[0]];
 };
 
 // the rest of your NoirJS code
 const input = { input: [4, 16] };
-const { witness } = await noir.execute(numbers, foreignCallHandler);
+const { witness } = await noir.execute(input, foreignCallHandler);
 ```
 
 :::tip
diff --git a/docs/versioned_docs/version-v0.32.0/how_to/how-to-recursion.md b/docs/versioned_docs/version-v0.32.0/how_to/how-to-recursion.md
index 71f02fa5435..c8c4dc9f5b4 100644
--- a/docs/versioned_docs/version-v0.32.0/how_to/how-to-recursion.md
+++ b/docs/versioned_docs/version-v0.32.0/how_to/how-to-recursion.md
@@ -25,7 +25,7 @@ This guide shows you how to use recursive proofs in your NoirJS app. For the sak
 
 - You already have a NoirJS app. If you don't, please visit the [NoirJS tutorial](../tutorials/noirjs_app.md) and the [reference](../reference/NoirJS/noir_js/index.md).
 - You are familiar with what are recursive proofs and you have read the [recursion explainer](../explainers/explainer-recursion.md)
-- You already built a recursive circuit following [the reference](../noir/standard_library/recursion.md), and understand how it works.
+- You already built a recursive circuit following [the reference](../noir/standard_library/recursion.mdx), and understand how it works.
 
 It is also assumed that you're not using `noir_wasm` for compilation, and instead you've used [`nargo compile`](../reference/nargo_commands.md) to generate the `json` you're now importing into your project. However, the guide should work just the same if you're using `noir_wasm`.
 
diff --git a/docs/versioned_docs/version-v0.32.0/noir/standard_library/black_box_fns.md b/docs/versioned_docs/version-v0.32.0/noir/standard_library/black_box_fns.md
index d5694250f05..d6079ab182c 100644
--- a/docs/versioned_docs/version-v0.32.0/noir/standard_library/black_box_fns.md
+++ b/docs/versioned_docs/version-v0.32.0/noir/standard_library/black_box_fns.md
@@ -25,7 +25,7 @@ Here is a list of the current black box functions:
 - XOR
 - RANGE
 - [Keccak256](./cryptographic_primitives/hashes.mdx#keccak256)
-- [Recursive proof verification](./recursion.md)
+- [Recursive proof verification](./recursion.mdx)
 
 Most black box functions are included as part of the Noir standard library, however `AND`, `XOR` and `RANGE` are used as part of the Noir language syntax. For instance, using the bitwise operator `&` will invoke the `AND` black box function.
 
diff --git a/docs/versioned_docs/version-v0.32.0/noir/standard_library/cryptographic_primitives/ciphers.mdx b/docs/versioned_docs/version-v0.32.0/noir/standard_library/cryptographic_primitives/ciphers.mdx
index d75e50d4b89..d6a5e1a79eb 100644
--- a/docs/versioned_docs/version-v0.32.0/noir/standard_library/cryptographic_primitives/ciphers.mdx
+++ b/docs/versioned_docs/version-v0.32.0/noir/standard_library/cryptographic_primitives/ciphers.mdx
@@ -7,7 +7,7 @@ keywords:
 sidebar_position: 0
 ---
 
-import BlackBoxInfo from '@site/src/components/Notes/_blackbox.mdx';
+import BlackBoxInfo from '@site/src/components/Notes/_blackbox';
 
 ## aes128
 
@@ -29,4 +29,4 @@ fn main() {
 ```
 
 
-<BlackBoxInfo />
\ No newline at end of file
+<BlackBoxInfo to="../black_box_fns"/>
\ No newline at end of file
diff --git a/docs/versioned_docs/version-v0.32.0/noir/standard_library/cryptographic_primitives/ecdsa_sig_verification.mdx b/docs/versioned_docs/version-v0.32.0/noir/standard_library/cryptographic_primitives/ecdsa_sig_verification.mdx
index 8520071e95f..4c22e70e8de 100644
--- a/docs/versioned_docs/version-v0.32.0/noir/standard_library/cryptographic_primitives/ecdsa_sig_verification.mdx
+++ b/docs/versioned_docs/version-v0.32.0/noir/standard_library/cryptographic_primitives/ecdsa_sig_verification.mdx
@@ -5,7 +5,7 @@ keywords: [cryptographic primitives, Noir project, ecdsa, secp256k1, secp256r1,
 sidebar_position: 3
 ---
 
-import BlackBoxInfo from '@site/src/components/Notes/_blackbox.mdx';
+import BlackBoxInfo from '@site/src/components/Notes/_blackbox';
 
 Noir supports ECDSA signatures verification over the secp256k1 and secp256r1 curves.
 
@@ -34,7 +34,7 @@ fn main(hashed_message : [u8;32], pub_key_x : [u8;32], pub_key_y : [u8;32], sign
 }
 ```
 
-<BlackBoxInfo />
+<BlackBoxInfo to="../black_box_fns"/>
 
 ## ecdsa_secp256k1::verify_signature_slice
 
@@ -51,7 +51,7 @@ pub fn verify_signature_slice(
 > <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/ecdsa_secp256k1.nr#L13-L20" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/ecdsa_secp256k1.nr#L13-L20</a></sub></sup>
 
 
-<BlackBoxInfo />
+<BlackBoxInfo to="../black_box_fns"/>
 
 ## ecdsa_secp256r1::verify_signature
 
@@ -78,7 +78,7 @@ fn main(hashed_message : [u8;32], pub_key_x : [u8;32], pub_key_y : [u8;32], sign
 }
 ```
 
-<BlackBoxInfo />
+<BlackBoxInfo to="../black_box_fns"/>
 
 ## ecdsa_secp256r1::verify_signature
 
@@ -95,4 +95,4 @@ pub fn verify_signature_slice(
 > <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/ecdsa_secp256r1.nr#L13-L20" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/ecdsa_secp256r1.nr#L13-L20</a></sub></sup>
 
 
-<BlackBoxInfo />
+<BlackBoxInfo to="../black_box_fns"/>
diff --git a/docs/versioned_docs/version-v0.32.0/noir/standard_library/cryptographic_primitives/eddsa.mdx b/docs/versioned_docs/version-v0.32.0/noir/standard_library/cryptographic_primitives/eddsa.mdx
index 1ad42a5ac96..ef4386052eb 100644
--- a/docs/versioned_docs/version-v0.32.0/noir/standard_library/cryptographic_primitives/eddsa.mdx
+++ b/docs/versioned_docs/version-v0.32.0/noir/standard_library/cryptographic_primitives/eddsa.mdx
@@ -5,7 +5,7 @@ keywords: [cryptographic primitives, Noir project, eddsa, signatures]
 sidebar_position: 5
 ---
 
-import BlackBoxInfo from '@site/src/components/Notes/_blackbox.mdx';
+import BlackBoxInfo from '@site/src/components/Notes/_blackbox';
 
 ## eddsa::eddsa_poseidon_verify
 
@@ -23,7 +23,7 @@ use std::hash::poseidon2::Poseidon2Hasher;
 eddsa_verify::<Poseidon2Hasher>(pub_key_a.x, pub_key_a.y, s_a, r8_a.x, r8_a.y, msg);
 ```
 
-<BlackBoxInfo />
+<BlackBoxInfo to="../black_box_fns" />
 
 ## eddsa::eddsa_to_pub
 
diff --git a/docs/versioned_docs/version-v0.32.0/noir/standard_library/cryptographic_primitives/embedded_curve_ops.mdx b/docs/versioned_docs/version-v0.32.0/noir/standard_library/cryptographic_primitives/embedded_curve_ops.mdx
index 0230f6a8ab9..68d033e9d60 100644
--- a/docs/versioned_docs/version-v0.32.0/noir/standard_library/cryptographic_primitives/embedded_curve_ops.mdx
+++ b/docs/versioned_docs/version-v0.32.0/noir/standard_library/cryptographic_primitives/embedded_curve_ops.mdx
@@ -5,7 +5,7 @@ keywords: [cryptographic primitives, Noir project, scalar multiplication]
 sidebar_position: 1
 ---
 
-import BlackBoxInfo from '@site/src/components/Notes/_blackbox.mdx';
+import BlackBoxInfo from '@site/src/components/Notes/_blackbox';
 
 The following functions perform operations over the embedded curve whose coordinates are defined by the configured noir field.
 For the BN254 scalar field, this is BabyJubJub or Grumpkin.
@@ -95,4 +95,4 @@ fn main() {
 }
 ```
 
-<BlackBoxInfo />
+<BlackBoxInfo to="../black_box_fns"/>
diff --git a/docs/versioned_docs/version-v0.32.0/noir/standard_library/cryptographic_primitives/hashes.mdx b/docs/versioned_docs/version-v0.32.0/noir/standard_library/cryptographic_primitives/hashes.mdx
index dadff87bb69..ddcfbb2175f 100644
--- a/docs/versioned_docs/version-v0.32.0/noir/standard_library/cryptographic_primitives/hashes.mdx
+++ b/docs/versioned_docs/version-v0.32.0/noir/standard_library/cryptographic_primitives/hashes.mdx
@@ -8,7 +8,7 @@ keywords:
 sidebar_position: 0
 ---
 
-import BlackBoxInfo from '@site/src/components/Notes/_blackbox.mdx';
+import BlackBoxInfo from '@site/src/components/Notes/_blackbox';
 
 ## sha256
 
@@ -36,7 +36,7 @@ fn main() {
 ```
 
 
-<BlackBoxInfo />
+<BlackBoxInfo to="../black_box_fns"/>
 
 ## blake2s
 
@@ -57,7 +57,7 @@ fn main() {
 }
 ```
 
-<BlackBoxInfo />
+<BlackBoxInfo to="../black_box_fns"/>
 
 ## blake3
 
@@ -78,7 +78,7 @@ fn main() {
 }
 ```
 
-<BlackBoxInfo />
+<BlackBoxInfo to="../black_box_fns"/>
 
 ## pedersen_hash
 
@@ -101,7 +101,7 @@ fn main(x: Field, y: Field, expected_hash: Field) {
 > <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/test_programs/execution_success/pedersen_hash/src/main.nr#L1-L7" target="_blank" rel="noopener noreferrer">Source code: test_programs/execution_success/pedersen_hash/src/main.nr#L1-L7</a></sub></sup>
 
 
-<BlackBoxInfo />
+<BlackBoxInfo to="../black_box_fns"/>
 
 ## pedersen_commitment
 
@@ -125,7 +125,7 @@ fn main(x: Field, y: Field, expected_commitment: std::embedded_curve_ops::Embedd
 > <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/test_programs/execution_success/pedersen_commitment/src/main.nr#L1-L8" target="_blank" rel="noopener noreferrer">Source code: test_programs/execution_success/pedersen_commitment/src/main.nr#L1-L8</a></sub></sup>
 
 
-<BlackBoxInfo />
+<BlackBoxInfo to="../black_box_fns"/>
 
 ## keccak256
 
@@ -164,7 +164,7 @@ fn main(x: Field, result: [u8; 32]) {
 > <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/test_programs/execution_success/keccak256/src/main.nr#L1-L21" target="_blank" rel="noopener noreferrer">Source code: test_programs/execution_success/keccak256/src/main.nr#L1-L21</a></sub></sup>
 
 
-<BlackBoxInfo />
+<BlackBoxInfo to="../black_box_fns"/>
 
 ## poseidon
 
diff --git a/docs/versioned_docs/version-v0.32.0/noir/standard_library/cryptographic_primitives/schnorr.mdx b/docs/versioned_docs/version-v0.32.0/noir/standard_library/cryptographic_primitives/schnorr.mdx
index a32138daaa6..00e7f257612 100644
--- a/docs/versioned_docs/version-v0.32.0/noir/standard_library/cryptographic_primitives/schnorr.mdx
+++ b/docs/versioned_docs/version-v0.32.0/noir/standard_library/cryptographic_primitives/schnorr.mdx
@@ -5,7 +5,7 @@ keywords: [cryptographic primitives, Noir project, schnorr, signatures]
 sidebar_position: 2
 ---
 
-import BlackBoxInfo from '@site/src/components/Notes/_blackbox.mdx';
+import BlackBoxInfo from '@site/src/components/Notes/_blackbox';
 
 ## schnorr::verify_signature
 
@@ -43,7 +43,7 @@ const signature = Array.from(
 ...
 ```
 
-<BlackBoxInfo />
+<BlackBoxInfo to="../black_box_fns"/>
 
 ## schnorr::verify_signature_slice
 
@@ -61,4 +61,4 @@ pub fn verify_signature_slice(
 > <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/schnorr.nr#L13-L20" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/schnorr.nr#L13-L20</a></sub></sup>
 
 
-<BlackBoxInfo />
+<BlackBoxInfo to="../black_box_fns"/>
diff --git a/docs/versioned_docs/version-v0.32.0/noir/standard_library/recursion.md b/docs/versioned_docs/version-v0.32.0/noir/standard_library/recursion.mdx
similarity index 96%
rename from docs/versioned_docs/version-v0.32.0/noir/standard_library/recursion.md
rename to docs/versioned_docs/version-v0.32.0/noir/standard_library/recursion.mdx
index 8cfb37fc52d..8fdb8e8f514 100644
--- a/docs/versioned_docs/version-v0.32.0/noir/standard_library/recursion.md
+++ b/docs/versioned_docs/version-v0.32.0/noir/standard_library/recursion.mdx
@@ -4,7 +4,7 @@ description: Learn about how to write recursive proofs in Noir.
 keywords: [recursion, recursive proofs, verification_key, verify_proof]
 ---
 
-import BlackBoxInfo from '@site/src/components/Notes/_blackbox.mdx';
+import BlackBoxInfo from '@site/src/components/Notes/_blackbox';
 
 Noir supports recursively verifying proofs, meaning you verify the proof of a Noir program in another Noir program. This enables creating proofs of arbitrary size by doing step-wise verification of smaller components of a large proof.
 
@@ -35,7 +35,7 @@ By incorporating this attribute directly in the circuit's definition, tooling li
 pub fn verify_proof(verification_key: [Field], proof: [Field], public_inputs: [Field], key_hash: Field) {}
 ```
 
-<BlackBoxInfo />
+<BlackBoxInfo to="black_box_fns"/>
 
 ## Example usage
 
diff --git a/docs/versioned_docs/version-v0.33.0/explainers/explainer-recursion.md b/docs/versioned_docs/version-v0.33.0/explainers/explainer-recursion.md
index 18846176ca7..df8529ef4e0 100644
--- a/docs/versioned_docs/version-v0.33.0/explainers/explainer-recursion.md
+++ b/docs/versioned_docs/version-v0.33.0/explainers/explainer-recursion.md
@@ -111,7 +111,7 @@ He might find it more efficient to generate a proof for that setup phase separat
 
 ## What params do I need
 
-As you can see in the [recursion reference](noir/standard_library/recursion.md), a simple recursive proof requires:
+As you can see in the [recursion reference](noir/standard_library/recursion.mdx), a simple recursive proof requires:
 
 - The proof to verify
 - The Verification Key of the circuit that generated the proof
diff --git a/docs/versioned_docs/version-v0.33.0/how_to/debugger/debugging_with_the_repl.md b/docs/versioned_docs/version-v0.33.0/how_to/debugger/debugging_with_the_repl.md
index 09e5bae68ad..1d64dae3f37 100644
--- a/docs/versioned_docs/version-v0.33.0/how_to/debugger/debugging_with_the_repl.md
+++ b/docs/versioned_docs/version-v0.33.0/how_to/debugger/debugging_with_the_repl.md
@@ -1,7 +1,7 @@
 ---
 title: Using the REPL Debugger
 description:
-  Step by step guide on how to debug your Noir circuits with the REPL Debugger. 
+  Step-by-step guide on how to debug your Noir circuits with the REPL Debugger. 
 keywords:
   [
     Nargo,
diff --git a/docs/versioned_docs/version-v0.33.0/how_to/how-to-oracles.md b/docs/versioned_docs/version-v0.33.0/how_to/how-to-oracles.md
index 2f69902062c..392dd8b452e 100644
--- a/docs/versioned_docs/version-v0.33.0/how_to/how-to-oracles.md
+++ b/docs/versioned_docs/version-v0.33.0/how_to/how-to-oracles.md
@@ -18,8 +18,6 @@ This guide shows you how to use oracles in your Noir program. For the sake of cl
 - You understand the concept of a JSON-RPC server. Visit the [JSON-RPC website](https://www.jsonrpc.org/) if you need a refresher.
 - You are comfortable with server-side JavaScript (e.g. Node.js, managing packages, etc.).
 
-For reference, you can find the snippets used in this tutorial on the [Aztec DevRel Repository](https://github.com/AztecProtocol/dev-rel/tree/main/code-snippets/how-to-oracles).
-
 ## Rundown
 
 This guide has 3 major steps:
@@ -99,6 +97,12 @@ fn main(input: [Field; 2]) {
     assert(sqrt[0].pow_32(2) as u64 == input[0] as u64);
     assert(sqrt[1].pow_32(2) as u64 == input[1] as u64);
 }
+
+#[test]
+fn test() {
+    let input = [4, 16];
+    main(input);
+}
 ```
 
 :::info
@@ -137,38 +141,32 @@ app.listen(5555);
 Now, we will add our `getSqrt` method, as expected by the `#[oracle(getSqrt)]` decorator in our Noir code. It maps through the params array and returns their square roots:
 
 ```js
-server.addMethod("resolve_function_call", async (params) => {
-  if params.function !== "getSqrt" {
-    throw Error("Unexpected foreign call")
-  };
-  const values = params.inputs[0].Array.map((field) => {
-    return `${Math.sqrt(parseInt(field, 16))}`;
-  });
-  return { values: [{ Array: values }] };
+server.addMethod("resolve_foreign_call", async (params) => {
+    if (params[0].function !== "getSqrt") {
+        throw Error("Unexpected foreign call")
+    };
+    const values = params[0].inputs[0].map((field) => {
+        return `${Math.sqrt(parseInt(field, 16))}`;
+    });
+    return { values: [values] };
 });
 ```
 
 If you're using Typescript, the following types may be helpful in understanding the expected return value and making sure they're easy to follow:
 
 ```js
-interface SingleForeignCallParam {
-  Single: string,
-}
+export type ForeignCallSingle = string;
 
-interface ArrayForeignCallParam {
-  Array: string[],
-}
-
-type ForeignCallParam = SingleForeignCallParam | ArrayForeignCallParam;
+export type ForeignCallArray = string[];
 
-interface ForeignCallResult {
-  values: ForeignCallParam[],
-}
+export type ForeignCallResult = {
+  values: (ForeignCallSingle | ForeignCallArray)[];
+};
 ```
 
-::: Multidimensional Arrays
+:::info Multidimensional Arrays
 
-If the Oracle function is returning an array containing other arrays, such as `[['1','2],['3','4']]`, you need to provide the values in json as flattened values. In the previous example, it would be `['1', '2', '3', '4']`. In the noir program, the Oracle signature can use a nested type, the flattened values will be automatically converted to the nested type.
+If the Oracle function is returning an array containing other arrays, such as `[['1','2],['3','4']]`, you need to provide the values in JSON as flattened values. In the previous example, it would be `['1', '2', '3', '4']`. In the Noir program, the Oracle signature can use a nested type, the flattened values will be automatically converted to the nested type.
 
 :::
 
@@ -233,17 +231,21 @@ const client = new JSONRPCClient((jsonRPCRequest) => {
 
 // declaring a function that takes the name of the foreign call (getSqrt) and the inputs
 const foreignCallHandler = async (name, input) => {
-    // notice that the "inputs" parameter contains *all* the inputs
-    // in this case we make the RPC request with the first parameter "numbers", which would be input[0]
-    const oracleReturn = await client.request(name, [
-      input[0].map((i) => i.toString("hex")),
-    ]);
-    return { values: oracleReturn };
+  const inputs = input[0].map((i) => i.toString("hex"))
+  // notice that the "inputs" parameter contains *all* the inputs
+  // in this case we to make the RPC request with the first parameter "numbers", which would be input[0]
+  const oracleReturn = await client.request("resolve_foreign_call", [
+    {
+      function: name,
+      inputs: [inputs]
+    },
+  ]);
+  return [oracleReturn.values[0]];
 };
 
 // the rest of your NoirJS code
 const input = { input: [4, 16] };
-const { witness } = await noir.execute(numbers, foreignCallHandler);
+const { witness } = await noir.execute(input, foreignCallHandler);
 ```
 
 :::tip
@@ -270,4 +272,4 @@ app.use(cors())
 Hopefully by the end of this guide, you should be able to:
 
 - Write your own logic around Oracles and how to write a JSON RPC server to make them work with your Nargo commands.
-- Provide custom foreign call handlers for NoirJS.
+- Provide custom foreign call handlers for NoirJS.
\ No newline at end of file
diff --git a/docs/versioned_docs/version-v0.33.0/how_to/how-to-recursion.md b/docs/versioned_docs/version-v0.33.0/how_to/how-to-recursion.md
index 71f02fa5435..c8c4dc9f5b4 100644
--- a/docs/versioned_docs/version-v0.33.0/how_to/how-to-recursion.md
+++ b/docs/versioned_docs/version-v0.33.0/how_to/how-to-recursion.md
@@ -25,7 +25,7 @@ This guide shows you how to use recursive proofs in your NoirJS app. For the sak
 
 - You already have a NoirJS app. If you don't, please visit the [NoirJS tutorial](../tutorials/noirjs_app.md) and the [reference](../reference/NoirJS/noir_js/index.md).
 - You are familiar with what are recursive proofs and you have read the [recursion explainer](../explainers/explainer-recursion.md)
-- You already built a recursive circuit following [the reference](../noir/standard_library/recursion.md), and understand how it works.
+- You already built a recursive circuit following [the reference](../noir/standard_library/recursion.mdx), and understand how it works.
 
 It is also assumed that you're not using `noir_wasm` for compilation, and instead you've used [`nargo compile`](../reference/nargo_commands.md) to generate the `json` you're now importing into your project. However, the guide should work just the same if you're using `noir_wasm`.
 
diff --git a/docs/versioned_docs/version-v0.33.0/index.mdx b/docs/versioned_docs/version-v0.33.0/index.mdx
index a6bd306f91d..9ed9662b0b9 100644
--- a/docs/versioned_docs/version-v0.33.0/index.mdx
+++ b/docs/versioned_docs/version-v0.33.0/index.mdx
@@ -51,7 +51,7 @@ Noir can be used both in complex cloud-based backends and in user's smartphones,
     Aztec Contracts leverage Noir to allow for the storage and execution of private information. Writing an Aztec Contract is as easy as writing Noir, and Aztec developers can easily interact with the network storage and execution through the [Aztec.nr](https://docs.aztec.network/developers/contracts/main) library.
   </TabItem>
   <TabItem value="Solidity Verifiers" label="Solidity Verifiers">
-    <img src={require("@site/static/img/solidity_verifier_ex.png").default} style={{display: "block", margin: "2rem auto"}} alt="Soliditry Verifier Example"  />
+    <img src={require("@site/static/img/solidity_verifier_ex.png").default} style={{display: "block", margin: "2rem auto"}} alt="Solidity Verifier Example"  />
     Noir can auto-generate Solidity verifier contracts that verify Noir proofs. This allows for non-interactive verification of proofs containing private information in an immutable system. This feature powers a multitude of use-case scenarios, from P2P chess tournaments, to [Aztec Layer-2 Blockchain](https://docs.aztec.network/)
   </TabItem>
   <TabItem value="Full-Stack Development" label="Full-Stack Development">
diff --git a/docs/versioned_docs/version-v0.33.0/noir/standard_library/black_box_fns.md b/docs/versioned_docs/version-v0.33.0/noir/standard_library/black_box_fns.md
index d5694250f05..d6079ab182c 100644
--- a/docs/versioned_docs/version-v0.33.0/noir/standard_library/black_box_fns.md
+++ b/docs/versioned_docs/version-v0.33.0/noir/standard_library/black_box_fns.md
@@ -25,7 +25,7 @@ Here is a list of the current black box functions:
 - XOR
 - RANGE
 - [Keccak256](./cryptographic_primitives/hashes.mdx#keccak256)
-- [Recursive proof verification](./recursion.md)
+- [Recursive proof verification](./recursion.mdx)
 
 Most black box functions are included as part of the Noir standard library, however `AND`, `XOR` and `RANGE` are used as part of the Noir language syntax. For instance, using the bitwise operator `&` will invoke the `AND` black box function.
 
diff --git a/docs/versioned_docs/version-v0.33.0/noir/standard_library/cryptographic_primitives/ciphers.mdx b/docs/versioned_docs/version-v0.33.0/noir/standard_library/cryptographic_primitives/ciphers.mdx
index d75e50d4b89..d6a5e1a79eb 100644
--- a/docs/versioned_docs/version-v0.33.0/noir/standard_library/cryptographic_primitives/ciphers.mdx
+++ b/docs/versioned_docs/version-v0.33.0/noir/standard_library/cryptographic_primitives/ciphers.mdx
@@ -7,7 +7,7 @@ keywords:
 sidebar_position: 0
 ---
 
-import BlackBoxInfo from '@site/src/components/Notes/_blackbox.mdx';
+import BlackBoxInfo from '@site/src/components/Notes/_blackbox';
 
 ## aes128
 
@@ -29,4 +29,4 @@ fn main() {
 ```
 
 
-<BlackBoxInfo />
\ No newline at end of file
+<BlackBoxInfo to="../black_box_fns"/>
\ No newline at end of file
diff --git a/docs/versioned_docs/version-v0.33.0/noir/standard_library/cryptographic_primitives/ecdsa_sig_verification.mdx b/docs/versioned_docs/version-v0.33.0/noir/standard_library/cryptographic_primitives/ecdsa_sig_verification.mdx
index 8520071e95f..4c22e70e8de 100644
--- a/docs/versioned_docs/version-v0.33.0/noir/standard_library/cryptographic_primitives/ecdsa_sig_verification.mdx
+++ b/docs/versioned_docs/version-v0.33.0/noir/standard_library/cryptographic_primitives/ecdsa_sig_verification.mdx
@@ -5,7 +5,7 @@ keywords: [cryptographic primitives, Noir project, ecdsa, secp256k1, secp256r1,
 sidebar_position: 3
 ---
 
-import BlackBoxInfo from '@site/src/components/Notes/_blackbox.mdx';
+import BlackBoxInfo from '@site/src/components/Notes/_blackbox';
 
 Noir supports ECDSA signatures verification over the secp256k1 and secp256r1 curves.
 
@@ -34,7 +34,7 @@ fn main(hashed_message : [u8;32], pub_key_x : [u8;32], pub_key_y : [u8;32], sign
 }
 ```
 
-<BlackBoxInfo />
+<BlackBoxInfo to="../black_box_fns"/>
 
 ## ecdsa_secp256k1::verify_signature_slice
 
@@ -51,7 +51,7 @@ pub fn verify_signature_slice(
 > <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/ecdsa_secp256k1.nr#L13-L20" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/ecdsa_secp256k1.nr#L13-L20</a></sub></sup>
 
 
-<BlackBoxInfo />
+<BlackBoxInfo to="../black_box_fns"/>
 
 ## ecdsa_secp256r1::verify_signature
 
@@ -78,7 +78,7 @@ fn main(hashed_message : [u8;32], pub_key_x : [u8;32], pub_key_y : [u8;32], sign
 }
 ```
 
-<BlackBoxInfo />
+<BlackBoxInfo to="../black_box_fns"/>
 
 ## ecdsa_secp256r1::verify_signature
 
@@ -95,4 +95,4 @@ pub fn verify_signature_slice(
 > <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/ecdsa_secp256r1.nr#L13-L20" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/ecdsa_secp256r1.nr#L13-L20</a></sub></sup>
 
 
-<BlackBoxInfo />
+<BlackBoxInfo to="../black_box_fns"/>
diff --git a/docs/versioned_docs/version-v0.33.0/noir/standard_library/cryptographic_primitives/eddsa.mdx b/docs/versioned_docs/version-v0.33.0/noir/standard_library/cryptographic_primitives/eddsa.mdx
index 1ad42a5ac96..b283de693c8 100644
--- a/docs/versioned_docs/version-v0.33.0/noir/standard_library/cryptographic_primitives/eddsa.mdx
+++ b/docs/versioned_docs/version-v0.33.0/noir/standard_library/cryptographic_primitives/eddsa.mdx
@@ -5,7 +5,7 @@ keywords: [cryptographic primitives, Noir project, eddsa, signatures]
 sidebar_position: 5
 ---
 
-import BlackBoxInfo from '@site/src/components/Notes/_blackbox.mdx';
+import BlackBoxInfo from '@site/src/components/Notes/_blackbox';
 
 ## eddsa::eddsa_poseidon_verify
 
@@ -23,7 +23,7 @@ use std::hash::poseidon2::Poseidon2Hasher;
 eddsa_verify::<Poseidon2Hasher>(pub_key_a.x, pub_key_a.y, s_a, r8_a.x, r8_a.y, msg);
 ```
 
-<BlackBoxInfo />
+<BlackBoxInfo to="../black_box_fns"/>
 
 ## eddsa::eddsa_to_pub
 
diff --git a/docs/versioned_docs/version-v0.33.0/noir/standard_library/cryptographic_primitives/embedded_curve_ops.mdx b/docs/versioned_docs/version-v0.33.0/noir/standard_library/cryptographic_primitives/embedded_curve_ops.mdx
index 719549bc418..69e0265c81a 100644
--- a/docs/versioned_docs/version-v0.33.0/noir/standard_library/cryptographic_primitives/embedded_curve_ops.mdx
+++ b/docs/versioned_docs/version-v0.33.0/noir/standard_library/cryptographic_primitives/embedded_curve_ops.mdx
@@ -5,7 +5,7 @@ keywords: [cryptographic primitives, Noir project, scalar multiplication]
 sidebar_position: 1
 ---
 
-import BlackBoxInfo from '@site/src/components/Notes/_blackbox.mdx';
+import BlackBoxInfo from '@site/src/components/Notes/_blackbox';
 
 The following functions perform operations over the embedded curve whose coordinates are defined by the configured noir field.
 For the BN254 scalar field, this is BabyJubJub or Grumpkin.
@@ -92,4 +92,4 @@ fn main() {
 }
 ```
 
-<BlackBoxInfo />
+<BlackBoxInfo to="../black_box_fns"/>
diff --git a/docs/versioned_docs/version-v0.33.0/noir/standard_library/cryptographic_primitives/hashes.mdx b/docs/versioned_docs/version-v0.33.0/noir/standard_library/cryptographic_primitives/hashes.mdx
index 63a4a2afd53..797ff8cc22c 100644
--- a/docs/versioned_docs/version-v0.33.0/noir/standard_library/cryptographic_primitives/hashes.mdx
+++ b/docs/versioned_docs/version-v0.33.0/noir/standard_library/cryptographic_primitives/hashes.mdx
@@ -8,7 +8,7 @@ keywords:
 sidebar_position: 0
 ---
 
-import BlackBoxInfo from '@site/src/components/Notes/_blackbox.mdx';
+import BlackBoxInfo from '@site/src/components/Notes/_blackbox';
 
 ## sha256
 
@@ -36,7 +36,7 @@ fn main() {
 ```
 
 
-<BlackBoxInfo />
+<BlackBoxInfo to="../black_box_fns"/>
 
 ## blake2s
 
@@ -57,7 +57,7 @@ fn main() {
 }
 ```
 
-<BlackBoxInfo />
+<BlackBoxInfo to="../black_box_fns"/>
 
 ## blake3
 
@@ -78,7 +78,7 @@ fn main() {
 }
 ```
 
-<BlackBoxInfo />
+<BlackBoxInfo to="../black_box_fns"/>
 
 ## pedersen_hash
 
@@ -101,7 +101,7 @@ fn main(x: Field, y: Field, expected_hash: Field) {
 > <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/test_programs/execution_success/pedersen_hash/src/main.nr#L1-L7" target="_blank" rel="noopener noreferrer">Source code: test_programs/execution_success/pedersen_hash/src/main.nr#L1-L7</a></sub></sup>
 
 
-<BlackBoxInfo />
+<BlackBoxInfo to="../black_box_fns"/>
 
 ## pedersen_commitment
 
@@ -125,7 +125,7 @@ fn main(x: Field, y: Field, expected_commitment: std::embedded_curve_ops::Embedd
 > <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/test_programs/execution_success/pedersen_commitment/src/main.nr#L1-L8" target="_blank" rel="noopener noreferrer">Source code: test_programs/execution_success/pedersen_commitment/src/main.nr#L1-L8</a></sub></sup>
 
 
-<BlackBoxInfo />
+<BlackBoxInfo to="../black_box_fns"/>
 
 ## keccak256
 
@@ -164,7 +164,7 @@ fn main(x: Field, result: [u8; 32]) {
 > <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/test_programs/execution_success/keccak256/src/main.nr#L1-L21" target="_blank" rel="noopener noreferrer">Source code: test_programs/execution_success/keccak256/src/main.nr#L1-L21</a></sub></sup>
 
 
-<BlackBoxInfo />
+<BlackBoxInfo to="../black_box_fns"/>
 
 ## poseidon
 
diff --git a/docs/versioned_docs/version-v0.33.0/noir/standard_library/cryptographic_primitives/schnorr.mdx b/docs/versioned_docs/version-v0.33.0/noir/standard_library/cryptographic_primitives/schnorr.mdx
index a32138daaa6..00e7f257612 100644
--- a/docs/versioned_docs/version-v0.33.0/noir/standard_library/cryptographic_primitives/schnorr.mdx
+++ b/docs/versioned_docs/version-v0.33.0/noir/standard_library/cryptographic_primitives/schnorr.mdx
@@ -5,7 +5,7 @@ keywords: [cryptographic primitives, Noir project, schnorr, signatures]
 sidebar_position: 2
 ---
 
-import BlackBoxInfo from '@site/src/components/Notes/_blackbox.mdx';
+import BlackBoxInfo from '@site/src/components/Notes/_blackbox';
 
 ## schnorr::verify_signature
 
@@ -43,7 +43,7 @@ const signature = Array.from(
 ...
 ```
 
-<BlackBoxInfo />
+<BlackBoxInfo to="../black_box_fns"/>
 
 ## schnorr::verify_signature_slice
 
@@ -61,4 +61,4 @@ pub fn verify_signature_slice(
 > <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/schnorr.nr#L13-L20" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/schnorr.nr#L13-L20</a></sub></sup>
 
 
-<BlackBoxInfo />
+<BlackBoxInfo to="../black_box_fns"/>
diff --git a/docs/docs/noir/standard_library/recursion.md b/docs/versioned_docs/version-v0.33.0/noir/standard_library/recursion.mdx
similarity index 96%
rename from docs/docs/noir/standard_library/recursion.md
rename to docs/versioned_docs/version-v0.33.0/noir/standard_library/recursion.mdx
index 7f4dcebf084..60414a2fa51 100644
--- a/docs/docs/noir/standard_library/recursion.md
+++ b/docs/versioned_docs/version-v0.33.0/noir/standard_library/recursion.mdx
@@ -4,7 +4,7 @@ description: Learn about how to write recursive proofs in Noir.
 keywords: [recursion, recursive proofs, verification_key, verify_proof]
 ---
 
-import BlackBoxInfo from '@site/src/components/Notes/_blackbox.mdx';
+import BlackBoxInfo from '@site/src/components/Notes/_blackbox';
 
 Noir supports recursively verifying proofs, meaning you verify the proof of a Noir program in another Noir program. This enables creating proofs of arbitrary size by doing step-wise verification of smaller components of a large proof.
 
@@ -35,7 +35,7 @@ By incorporating this attribute directly in the circuit's definition, tooling li
 pub fn verify_proof(verification_key: [Field], proof: [Field], public_inputs: [Field], key_hash: Field) {}
 ```
 
-<BlackBoxInfo />
+<BlackBoxInfo to="black_box_fns"/>
 
 ## Example usage
 
diff --git a/docs/versioned_docs/version-v0.34.0/explainers/explainer-recursion.md b/docs/versioned_docs/version-v0.34.0/explainers/explainer-recursion.md
index 18846176ca7..df8529ef4e0 100644
--- a/docs/versioned_docs/version-v0.34.0/explainers/explainer-recursion.md
+++ b/docs/versioned_docs/version-v0.34.0/explainers/explainer-recursion.md
@@ -111,7 +111,7 @@ He might find it more efficient to generate a proof for that setup phase separat
 
 ## What params do I need
 
-As you can see in the [recursion reference](noir/standard_library/recursion.md), a simple recursive proof requires:
+As you can see in the [recursion reference](noir/standard_library/recursion.mdx), a simple recursive proof requires:
 
 - The proof to verify
 - The Verification Key of the circuit that generated the proof
diff --git a/docs/versioned_docs/version-v0.34.0/how_to/debugger/debugging_with_the_repl.md b/docs/versioned_docs/version-v0.34.0/how_to/debugger/debugging_with_the_repl.md
index 09e5bae68ad..1d64dae3f37 100644
--- a/docs/versioned_docs/version-v0.34.0/how_to/debugger/debugging_with_the_repl.md
+++ b/docs/versioned_docs/version-v0.34.0/how_to/debugger/debugging_with_the_repl.md
@@ -1,7 +1,7 @@
 ---
 title: Using the REPL Debugger
 description:
-  Step by step guide on how to debug your Noir circuits with the REPL Debugger. 
+  Step-by-step guide on how to debug your Noir circuits with the REPL Debugger. 
 keywords:
   [
     Nargo,
diff --git a/docs/versioned_docs/version-v0.34.0/how_to/how-to-oracles.md b/docs/versioned_docs/version-v0.34.0/how_to/how-to-oracles.md
index 2f69902062c..392dd8b452e 100644
--- a/docs/versioned_docs/version-v0.34.0/how_to/how-to-oracles.md
+++ b/docs/versioned_docs/version-v0.34.0/how_to/how-to-oracles.md
@@ -18,8 +18,6 @@ This guide shows you how to use oracles in your Noir program. For the sake of cl
 - You understand the concept of a JSON-RPC server. Visit the [JSON-RPC website](https://www.jsonrpc.org/) if you need a refresher.
 - You are comfortable with server-side JavaScript (e.g. Node.js, managing packages, etc.).
 
-For reference, you can find the snippets used in this tutorial on the [Aztec DevRel Repository](https://github.com/AztecProtocol/dev-rel/tree/main/code-snippets/how-to-oracles).
-
 ## Rundown
 
 This guide has 3 major steps:
@@ -99,6 +97,12 @@ fn main(input: [Field; 2]) {
     assert(sqrt[0].pow_32(2) as u64 == input[0] as u64);
     assert(sqrt[1].pow_32(2) as u64 == input[1] as u64);
 }
+
+#[test]
+fn test() {
+    let input = [4, 16];
+    main(input);
+}
 ```
 
 :::info
@@ -137,38 +141,32 @@ app.listen(5555);
 Now, we will add our `getSqrt` method, as expected by the `#[oracle(getSqrt)]` decorator in our Noir code. It maps through the params array and returns their square roots:
 
 ```js
-server.addMethod("resolve_function_call", async (params) => {
-  if params.function !== "getSqrt" {
-    throw Error("Unexpected foreign call")
-  };
-  const values = params.inputs[0].Array.map((field) => {
-    return `${Math.sqrt(parseInt(field, 16))}`;
-  });
-  return { values: [{ Array: values }] };
+server.addMethod("resolve_foreign_call", async (params) => {
+    if (params[0].function !== "getSqrt") {
+        throw Error("Unexpected foreign call")
+    };
+    const values = params[0].inputs[0].map((field) => {
+        return `${Math.sqrt(parseInt(field, 16))}`;
+    });
+    return { values: [values] };
 });
 ```
 
 If you're using Typescript, the following types may be helpful in understanding the expected return value and making sure they're easy to follow:
 
 ```js
-interface SingleForeignCallParam {
-  Single: string,
-}
+export type ForeignCallSingle = string;
 
-interface ArrayForeignCallParam {
-  Array: string[],
-}
-
-type ForeignCallParam = SingleForeignCallParam | ArrayForeignCallParam;
+export type ForeignCallArray = string[];
 
-interface ForeignCallResult {
-  values: ForeignCallParam[],
-}
+export type ForeignCallResult = {
+  values: (ForeignCallSingle | ForeignCallArray)[];
+};
 ```
 
-::: Multidimensional Arrays
+:::info Multidimensional Arrays
 
-If the Oracle function is returning an array containing other arrays, such as `[['1','2],['3','4']]`, you need to provide the values in json as flattened values. In the previous example, it would be `['1', '2', '3', '4']`. In the noir program, the Oracle signature can use a nested type, the flattened values will be automatically converted to the nested type.
+If the Oracle function is returning an array containing other arrays, such as `[['1','2],['3','4']]`, you need to provide the values in JSON as flattened values. In the previous example, it would be `['1', '2', '3', '4']`. In the Noir program, the Oracle signature can use a nested type, the flattened values will be automatically converted to the nested type.
 
 :::
 
@@ -233,17 +231,21 @@ const client = new JSONRPCClient((jsonRPCRequest) => {
 
 // declaring a function that takes the name of the foreign call (getSqrt) and the inputs
 const foreignCallHandler = async (name, input) => {
-    // notice that the "inputs" parameter contains *all* the inputs
-    // in this case we make the RPC request with the first parameter "numbers", which would be input[0]
-    const oracleReturn = await client.request(name, [
-      input[0].map((i) => i.toString("hex")),
-    ]);
-    return { values: oracleReturn };
+  const inputs = input[0].map((i) => i.toString("hex"))
+  // notice that the "inputs" parameter contains *all* the inputs
+  // in this case we to make the RPC request with the first parameter "numbers", which would be input[0]
+  const oracleReturn = await client.request("resolve_foreign_call", [
+    {
+      function: name,
+      inputs: [inputs]
+    },
+  ]);
+  return [oracleReturn.values[0]];
 };
 
 // the rest of your NoirJS code
 const input = { input: [4, 16] };
-const { witness } = await noir.execute(numbers, foreignCallHandler);
+const { witness } = await noir.execute(input, foreignCallHandler);
 ```
 
 :::tip
@@ -270,4 +272,4 @@ app.use(cors())
 Hopefully by the end of this guide, you should be able to:
 
 - Write your own logic around Oracles and how to write a JSON RPC server to make them work with your Nargo commands.
-- Provide custom foreign call handlers for NoirJS.
+- Provide custom foreign call handlers for NoirJS.
\ No newline at end of file
diff --git a/docs/versioned_docs/version-v0.34.0/how_to/how-to-recursion.md b/docs/versioned_docs/version-v0.34.0/how_to/how-to-recursion.md
index 71f02fa5435..c8c4dc9f5b4 100644
--- a/docs/versioned_docs/version-v0.34.0/how_to/how-to-recursion.md
+++ b/docs/versioned_docs/version-v0.34.0/how_to/how-to-recursion.md
@@ -25,7 +25,7 @@ This guide shows you how to use recursive proofs in your NoirJS app. For the sak
 
 - You already have a NoirJS app. If you don't, please visit the [NoirJS tutorial](../tutorials/noirjs_app.md) and the [reference](../reference/NoirJS/noir_js/index.md).
 - You are familiar with what are recursive proofs and you have read the [recursion explainer](../explainers/explainer-recursion.md)
-- You already built a recursive circuit following [the reference](../noir/standard_library/recursion.md), and understand how it works.
+- You already built a recursive circuit following [the reference](../noir/standard_library/recursion.mdx), and understand how it works.
 
 It is also assumed that you're not using `noir_wasm` for compilation, and instead you've used [`nargo compile`](../reference/nargo_commands.md) to generate the `json` you're now importing into your project. However, the guide should work just the same if you're using `noir_wasm`.
 
diff --git a/docs/versioned_docs/version-v0.34.0/noir/standard_library/black_box_fns.md b/docs/versioned_docs/version-v0.34.0/noir/standard_library/black_box_fns.md
index d5694250f05..d6079ab182c 100644
--- a/docs/versioned_docs/version-v0.34.0/noir/standard_library/black_box_fns.md
+++ b/docs/versioned_docs/version-v0.34.0/noir/standard_library/black_box_fns.md
@@ -25,7 +25,7 @@ Here is a list of the current black box functions:
 - XOR
 - RANGE
 - [Keccak256](./cryptographic_primitives/hashes.mdx#keccak256)
-- [Recursive proof verification](./recursion.md)
+- [Recursive proof verification](./recursion.mdx)
 
 Most black box functions are included as part of the Noir standard library, however `AND`, `XOR` and `RANGE` are used as part of the Noir language syntax. For instance, using the bitwise operator `&` will invoke the `AND` black box function.
 
diff --git a/docs/versioned_docs/version-v0.34.0/noir/standard_library/cryptographic_primitives/ciphers.mdx b/docs/versioned_docs/version-v0.34.0/noir/standard_library/cryptographic_primitives/ciphers.mdx
index d75e50d4b89..d6a5e1a79eb 100644
--- a/docs/versioned_docs/version-v0.34.0/noir/standard_library/cryptographic_primitives/ciphers.mdx
+++ b/docs/versioned_docs/version-v0.34.0/noir/standard_library/cryptographic_primitives/ciphers.mdx
@@ -7,7 +7,7 @@ keywords:
 sidebar_position: 0
 ---
 
-import BlackBoxInfo from '@site/src/components/Notes/_blackbox.mdx';
+import BlackBoxInfo from '@site/src/components/Notes/_blackbox';
 
 ## aes128
 
@@ -29,4 +29,4 @@ fn main() {
 ```
 
 
-<BlackBoxInfo />
\ No newline at end of file
+<BlackBoxInfo to="../black_box_fns"/>
\ No newline at end of file
diff --git a/docs/versioned_docs/version-v0.34.0/noir/standard_library/cryptographic_primitives/ecdsa_sig_verification.mdx b/docs/versioned_docs/version-v0.34.0/noir/standard_library/cryptographic_primitives/ecdsa_sig_verification.mdx
index 8520071e95f..4c22e70e8de 100644
--- a/docs/versioned_docs/version-v0.34.0/noir/standard_library/cryptographic_primitives/ecdsa_sig_verification.mdx
+++ b/docs/versioned_docs/version-v0.34.0/noir/standard_library/cryptographic_primitives/ecdsa_sig_verification.mdx
@@ -5,7 +5,7 @@ keywords: [cryptographic primitives, Noir project, ecdsa, secp256k1, secp256r1,
 sidebar_position: 3
 ---
 
-import BlackBoxInfo from '@site/src/components/Notes/_blackbox.mdx';
+import BlackBoxInfo from '@site/src/components/Notes/_blackbox';
 
 Noir supports ECDSA signatures verification over the secp256k1 and secp256r1 curves.
 
@@ -34,7 +34,7 @@ fn main(hashed_message : [u8;32], pub_key_x : [u8;32], pub_key_y : [u8;32], sign
 }
 ```
 
-<BlackBoxInfo />
+<BlackBoxInfo to="../black_box_fns"/>
 
 ## ecdsa_secp256k1::verify_signature_slice
 
@@ -51,7 +51,7 @@ pub fn verify_signature_slice(
 > <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/ecdsa_secp256k1.nr#L13-L20" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/ecdsa_secp256k1.nr#L13-L20</a></sub></sup>
 
 
-<BlackBoxInfo />
+<BlackBoxInfo to="../black_box_fns"/>
 
 ## ecdsa_secp256r1::verify_signature
 
@@ -78,7 +78,7 @@ fn main(hashed_message : [u8;32], pub_key_x : [u8;32], pub_key_y : [u8;32], sign
 }
 ```
 
-<BlackBoxInfo />
+<BlackBoxInfo to="../black_box_fns"/>
 
 ## ecdsa_secp256r1::verify_signature
 
@@ -95,4 +95,4 @@ pub fn verify_signature_slice(
 > <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/ecdsa_secp256r1.nr#L13-L20" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/ecdsa_secp256r1.nr#L13-L20</a></sub></sup>
 
 
-<BlackBoxInfo />
+<BlackBoxInfo to="../black_box_fns"/>
diff --git a/docs/versioned_docs/version-v0.34.0/noir/standard_library/cryptographic_primitives/eddsa.mdx b/docs/versioned_docs/version-v0.34.0/noir/standard_library/cryptographic_primitives/eddsa.mdx
index 1ad42a5ac96..b283de693c8 100644
--- a/docs/versioned_docs/version-v0.34.0/noir/standard_library/cryptographic_primitives/eddsa.mdx
+++ b/docs/versioned_docs/version-v0.34.0/noir/standard_library/cryptographic_primitives/eddsa.mdx
@@ -5,7 +5,7 @@ keywords: [cryptographic primitives, Noir project, eddsa, signatures]
 sidebar_position: 5
 ---
 
-import BlackBoxInfo from '@site/src/components/Notes/_blackbox.mdx';
+import BlackBoxInfo from '@site/src/components/Notes/_blackbox';
 
 ## eddsa::eddsa_poseidon_verify
 
@@ -23,7 +23,7 @@ use std::hash::poseidon2::Poseidon2Hasher;
 eddsa_verify::<Poseidon2Hasher>(pub_key_a.x, pub_key_a.y, s_a, r8_a.x, r8_a.y, msg);
 ```
 
-<BlackBoxInfo />
+<BlackBoxInfo to="../black_box_fns"/>
 
 ## eddsa::eddsa_to_pub
 
diff --git a/docs/versioned_docs/version-v0.34.0/noir/standard_library/cryptographic_primitives/embedded_curve_ops.mdx b/docs/versioned_docs/version-v0.34.0/noir/standard_library/cryptographic_primitives/embedded_curve_ops.mdx
index 8ded020bf27..2da1e34f008 100644
--- a/docs/versioned_docs/version-v0.34.0/noir/standard_library/cryptographic_primitives/embedded_curve_ops.mdx
+++ b/docs/versioned_docs/version-v0.34.0/noir/standard_library/cryptographic_primitives/embedded_curve_ops.mdx
@@ -5,7 +5,7 @@ keywords: [cryptographic primitives, Noir project, scalar multiplication]
 sidebar_position: 1
 ---
 
-import BlackBoxInfo from '@site/src/components/Notes/_blackbox.mdx';
+import BlackBoxInfo from '@site/src/components/Notes/_blackbox';
 
 The following functions perform operations over the embedded curve whose coordinates are defined by the configured noir field.
 For the BN254 scalar field, this is BabyJubJub or Grumpkin.
@@ -92,4 +92,4 @@ fn main() {
 }
 ```
 
-<BlackBoxInfo />
+<BlackBoxInfo to="../black_box_fns"/>
diff --git a/docs/versioned_docs/version-v0.34.0/noir/standard_library/cryptographic_primitives/hashes.mdx b/docs/versioned_docs/version-v0.34.0/noir/standard_library/cryptographic_primitives/hashes.mdx
index 2581690e034..d6640d26f25 100644
--- a/docs/versioned_docs/version-v0.34.0/noir/standard_library/cryptographic_primitives/hashes.mdx
+++ b/docs/versioned_docs/version-v0.34.0/noir/standard_library/cryptographic_primitives/hashes.mdx
@@ -8,7 +8,7 @@ keywords:
 sidebar_position: 0
 ---
 
-import BlackBoxInfo from '@site/src/components/Notes/_blackbox.mdx';
+import BlackBoxInfo from '@site/src/components/Notes/_blackbox';
 
 ## sha256
 
@@ -36,7 +36,7 @@ fn main() {
 ```
 
 
-<BlackBoxInfo />
+<BlackBoxInfo to="../black_box_fns"/>
 
 ## blake2s
 
@@ -57,7 +57,7 @@ fn main() {
 }
 ```
 
-<BlackBoxInfo />
+<BlackBoxInfo to="../black_box_fns"/>
 
 ## blake3
 
@@ -78,7 +78,7 @@ fn main() {
 }
 ```
 
-<BlackBoxInfo />
+<BlackBoxInfo to="../black_box_fns"/>
 
 ## pedersen_hash
 
@@ -101,7 +101,7 @@ fn main(x: Field, y: Field, expected_hash: Field) {
 > <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/test_programs/execution_success/pedersen_hash/src/main.nr#L1-L7" target="_blank" rel="noopener noreferrer">Source code: test_programs/execution_success/pedersen_hash/src/main.nr#L1-L7</a></sub></sup>
 
 
-<BlackBoxInfo />
+<BlackBoxInfo to="../black_box_fns"/>
 
 ## pedersen_commitment
 
@@ -125,7 +125,7 @@ fn main(x: Field, y: Field, expected_commitment: std::embedded_curve_ops::Embedd
 > <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/test_programs/execution_success/pedersen_commitment/src/main.nr#L1-L8" target="_blank" rel="noopener noreferrer">Source code: test_programs/execution_success/pedersen_commitment/src/main.nr#L1-L8</a></sub></sup>
 
 
-<BlackBoxInfo />
+<BlackBoxInfo to="../black_box_fns"/>
 
 ## keccak256
 
@@ -164,7 +164,7 @@ fn main(x: Field, result: [u8; 32]) {
 > <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/test_programs/execution_success/keccak256/src/main.nr#L1-L21" target="_blank" rel="noopener noreferrer">Source code: test_programs/execution_success/keccak256/src/main.nr#L1-L21</a></sub></sup>
 
 
-<BlackBoxInfo />
+<BlackBoxInfo to="../black_box_fns"/>
 
 ## poseidon
 
diff --git a/docs/versioned_docs/version-v0.34.0/noir/standard_library/cryptographic_primitives/schnorr.mdx b/docs/versioned_docs/version-v0.34.0/noir/standard_library/cryptographic_primitives/schnorr.mdx
index a32138daaa6..00e7f257612 100644
--- a/docs/versioned_docs/version-v0.34.0/noir/standard_library/cryptographic_primitives/schnorr.mdx
+++ b/docs/versioned_docs/version-v0.34.0/noir/standard_library/cryptographic_primitives/schnorr.mdx
@@ -5,7 +5,7 @@ keywords: [cryptographic primitives, Noir project, schnorr, signatures]
 sidebar_position: 2
 ---
 
-import BlackBoxInfo from '@site/src/components/Notes/_blackbox.mdx';
+import BlackBoxInfo from '@site/src/components/Notes/_blackbox';
 
 ## schnorr::verify_signature
 
@@ -43,7 +43,7 @@ const signature = Array.from(
 ...
 ```
 
-<BlackBoxInfo />
+<BlackBoxInfo to="../black_box_fns"/>
 
 ## schnorr::verify_signature_slice
 
@@ -61,4 +61,4 @@ pub fn verify_signature_slice(
 > <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/schnorr.nr#L13-L20" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/schnorr.nr#L13-L20</a></sub></sup>
 
 
-<BlackBoxInfo />
+<BlackBoxInfo to="../black_box_fns"/>
diff --git a/docs/versioned_docs/version-v0.33.0/noir/standard_library/recursion.md b/docs/versioned_docs/version-v0.34.0/noir/standard_library/recursion.mdx
similarity index 96%
rename from docs/versioned_docs/version-v0.33.0/noir/standard_library/recursion.md
rename to docs/versioned_docs/version-v0.34.0/noir/standard_library/recursion.mdx
index 7f4dcebf084..60414a2fa51 100644
--- a/docs/versioned_docs/version-v0.33.0/noir/standard_library/recursion.md
+++ b/docs/versioned_docs/version-v0.34.0/noir/standard_library/recursion.mdx
@@ -4,7 +4,7 @@ description: Learn about how to write recursive proofs in Noir.
 keywords: [recursion, recursive proofs, verification_key, verify_proof]
 ---
 
-import BlackBoxInfo from '@site/src/components/Notes/_blackbox.mdx';
+import BlackBoxInfo from '@site/src/components/Notes/_blackbox';
 
 Noir supports recursively verifying proofs, meaning you verify the proof of a Noir program in another Noir program. This enables creating proofs of arbitrary size by doing step-wise verification of smaller components of a large proof.
 
@@ -35,7 +35,7 @@ By incorporating this attribute directly in the circuit's definition, tooling li
 pub fn verify_proof(verification_key: [Field], proof: [Field], public_inputs: [Field], key_hash: Field) {}
 ```
 
-<BlackBoxInfo />
+<BlackBoxInfo to="black_box_fns"/>
 
 ## Example usage
 
diff --git a/docs/versioned_docs/version-v0.35.0/explainers/cspell.json b/docs/versioned_docs/version-v0.35.0/explainers/cspell.json
new file mode 100644
index 00000000000..c60b0a597b1
--- /dev/null
+++ b/docs/versioned_docs/version-v0.35.0/explainers/cspell.json
@@ -0,0 +1,5 @@
+{
+    "words": [
+        "Cryptdoku"
+    ]
+}
diff --git a/docs/versioned_docs/version-v0.35.0/explainers/explainer-oracle.md b/docs/versioned_docs/version-v0.35.0/explainers/explainer-oracle.md
new file mode 100644
index 00000000000..821e1f95c04
--- /dev/null
+++ b/docs/versioned_docs/version-v0.35.0/explainers/explainer-oracle.md
@@ -0,0 +1,57 @@
+---
+title: Oracles
+description: This guide provides an in-depth understanding of how Oracles work in Noir programming. Learn how to use outside calculations in your programs, constrain oracles, and understand their uses and limitations.
+keywords:
+  - Noir Programming
+  - Oracles
+  - JSON-RPC
+  - Foreign Call Handlers
+  - Constrained Functions
+  - Blockchain Programming
+sidebar_position: 1
+---
+
+If you've seen "The Matrix" you may recall "The Oracle" as Gloria Foster smoking cigarettes and baking cookies. While she appears to "know things", she is actually providing a calculation of a pre-determined future. Noir Oracles are similar, in a way. They don't calculate the future (yet), but they allow you to use outside calculations in your programs.
+
+![matrix oracle prediction](@site/static/img/memes/matrix_oracle.jpeg)
+
+A Noir program is usually self-contained. You can pass certain inputs to it, and it will generate a deterministic output for those inputs. But what if you wanted to defer some calculation to an outside process or source?
+
+Oracles are functions that provide this feature.
+
+## Use cases
+
+An example usage for Oracles is proving something on-chain. For example, proving that the ETH-USDC quote was below a certain target at a certain block time. Or even making more complex proofs like proving the ownership of an NFT as an anonymous login method.
+
+Another interesting use case is to defer expensive calculations to be made outside of the Noir program, and then constraining the result; similar to the use of [unconstrained functions](../noir/concepts//unconstrained.md).
+
+In short, anything that can be constrained in a Noir program but needs to be fetched from an external source is a great candidate to be used in oracles.
+
+## Constraining oracles
+
+Just like in The Matrix, Oracles are powerful. But with great power, comes great responsibility. Just because you're using them in a Noir program doesn't mean they're true. Noir has no superpowers. If you want to prove that Portugal won the Euro Cup 2016, you're still relying on potentially untrusted information.
+
+To give a concrete example, Alice wants to login to the [NounsDAO](https://nouns.wtf/) forum with her username "noir_nouner" by proving she owns a noun without revealing her ethereum address. Her Noir program could have an oracle call like this:
+
+```rust
+#[oracle(getNoun)]
+unconstrained fn get_noun(address: Field) -> Field
+```
+
+This oracle could naively resolve with the number of Nouns she possesses. However, it is useless as a trusted source, as the oracle could resolve to anything Alice wants. In order to make this oracle call actually useful, Alice would need to constrain the response from the oracle, by proving her address and the noun count belongs to the state tree of the contract.
+
+In short, **Oracles don't prove anything. Your Noir program does.**
+
+:::danger
+
+If you don't constrain the return of your oracle, you could be clearly opening an attack vector on your Noir program. Make double-triple sure that the return of an oracle call is constrained!
+
+:::
+
+## How to use Oracles
+
+On CLI, Nargo resolves oracles by making JSON RPC calls, which means it would require an RPC node to be running.
+
+In JavaScript, NoirJS accepts and resolves arbitrary call handlers (that is, not limited to JSON) as long as they match the expected types the developer defines. Refer to [Foreign Call Handler](../reference/NoirJS/noir_js/type-aliases/ForeignCallHandler.md) to learn more about NoirJS's call handling.
+
+If you want to build using oracles, follow through to the [oracle guide](../how_to/how-to-oracles.md) for a simple example on how to do that.
diff --git a/docs/versioned_docs/version-v0.35.0/explainers/explainer-recursion.md b/docs/versioned_docs/version-v0.35.0/explainers/explainer-recursion.md
new file mode 100644
index 00000000000..df8529ef4e0
--- /dev/null
+++ b/docs/versioned_docs/version-v0.35.0/explainers/explainer-recursion.md
@@ -0,0 +1,176 @@
+---
+title: Recursive proofs
+description: Explore the concept of recursive proofs in Zero-Knowledge programming. Understand how recursion works in Noir, a language for writing smart contracts on the EVM blockchain. Learn through practical examples like Alice and Bob's guessing game, Charlie's recursive merkle tree, and Daniel's reusable components. Discover how to use recursive proofs to optimize computational resources and improve efficiency.
+
+keywords:
+  [
+    "Recursive Proofs",
+    "Zero-Knowledge Programming",
+    "Noir",
+    "EVM Blockchain",
+    "Smart Contracts",
+    "Recursion in Noir",
+    "Alice and Bob Guessing Game",
+    "Recursive Merkle Tree",
+    "Reusable Components",
+    "Optimizing Computational Resources",
+    "Improving Efficiency",
+    "Verification Key",
+    "Aggregation",
+    "Recursive zkSNARK schemes",
+    "PLONK",
+    "Proving and Verification Keys"
+  ]
+sidebar_position: 1
+pagination_next: how_to/how-to-recursion
+---
+
+In programming, we tend to think of recursion as something calling itself. A classic example would be the calculation of the factorial of a number:
+
+```js
+function factorial(n) {
+    if (n === 0 || n === 1) {
+        return 1;
+    } else {
+        return n * factorial(n - 1);
+    }
+}
+```
+
+In this case, while `n` is not `1`, this function will keep calling itself until it hits the base case, bubbling up the result on the call stack:
+
+```md
+        Is `n` 1?  <---------
+           /\               /
+          /  \         n = n -1 
+         /    \           /
+       Yes     No --------
+```
+
+In Zero-Knowledge, recursion has some similarities.
+
+It is not a Noir function calling itself, but a proof being used as an input to another circuit. In short, you verify one proof *inside* another proof, returning the proof that both proofs are valid.
+
+This means that, given enough computational resources, you can prove the correctness of any arbitrary number of proofs in a single proof. This could be useful to design state channels (for which a common example would be [Bitcoin's Lightning Network](https://en.wikipedia.org/wiki/Lightning_Network)), to save on gas costs by settling one proof on-chain, or simply to make business logic less dependent on a consensus mechanism.
+
+## Examples
+
+Let us look at some of these examples
+
+### Alice and Bob - Guessing game
+
+Alice and Bob are friends, and they like guessing games. They want to play a guessing game online, but for that, they need a trusted third-party that knows both of their secrets and finishes the game once someone wins.
+
+So, they use zero-knowledge proofs. Alice tries to guess Bob's number, and Bob will generate a ZK proof stating whether she succeeded or failed.
+
+This ZK proof can go on a smart contract, revealing the winner and even giving prizes. However, this means every turn needs to be verified on-chain. This incurs some cost and waiting time that may simply make the game too expensive or time-consuming to be worth it.
+
+As a solution, Alice proposes the following: "what if Bob generates his proof, and instead of sending it on-chain, I verify it *within* my own proof before playing my own turn?".
+
+She can then generate a proof that she verified his proof, and so on.
+
+```md
+      Did you fail?  <--------------------------
+           / \                                  /
+          /   \                             n = n -1 
+         /     \                              /
+       Yes      No                           /
+        |        |                          /
+        |        |                         /
+        |      You win                    /
+        |                                /
+        |                               /
+Generate proof of that                 /
+        +                             /
+    my own guess     ----------------
+```
+
+### Charlie - Recursive merkle tree
+
+Charlie is a concerned citizen, and wants to be sure his vote in an election is accounted for. He votes with a ZK proof, but he has no way of knowing that his ZK proof was included in the total vote count!
+
+If the vote collector puts all of the votes into a [Merkle tree](https://en.wikipedia.org/wiki/Merkle_tree), everyone can prove the verification of two proofs within one proof, as such:
+
+```md
+                    abcd
+           __________|______________
+          |                         |
+         ab                         cd 
+     _____|_____              ______|______
+    |           |            |             |              
+  alice        bob        charlie        daniel 
+```
+
+Doing this recursively allows us to arrive on a final proof `abcd` which if true, verifies the correctness of all the votes.
+
+### Daniel - Reusable components
+
+Daniel has a big circuit and a big headache. A part of his circuit is a setup phase that finishes with some assertions that need to be made. But that section alone takes most of the proving time, and is largely independent of the rest of the circuit.
+
+He might find it more efficient to generate a proof for that setup phase separately, and verify that proof recursively in the actual business logic section of his circuit. This will allow for parallelization of both proofs, which results in a considerable speedup.
+
+## What params do I need
+
+As you can see in the [recursion reference](noir/standard_library/recursion.mdx), a simple recursive proof requires:
+
+- The proof to verify
+- The Verification Key of the circuit that generated the proof
+- A hash of this verification key, as it's needed for some backends
+- The public inputs for the proof
+
+:::info
+
+Recursive zkSNARK schemes do not necessarily "verify a proof" in the sense that you expect a true or false to be spit out by the verifier. Rather an aggregation object is built over the public inputs.
+
+So, taking the example of Alice and Bob and their guessing game:
+
+- Alice makes her guess. Her proof is *not* recursive: it doesn't verify any proof within it! It's just a standard `assert(x != y)` circuit
+- Bob verifies Alice's proof and makes his own guess. In this circuit, he doesn't exactly *prove* the verification of Alice's proof. Instead, he *aggregates* his proof to Alice's proof. The actual verification is done when the full proof is verified, for example when using `nargo verify` or through the verifier smart contract.
+
+We can imagine recursive proofs a [relay race](https://en.wikipedia.org/wiki/Relay_race). The first runner doesn't have to receive the baton from anyone else, as he/she already starts with it. But when his/her turn is over, the next runner needs to receive it, run a bit more, and pass it along. Even though every runner could theoretically verify the baton mid-run (why not? 🏃🔍), only at the end of the race does the referee verify that the whole race is valid.
+
+:::
+
+## Some architecture
+
+As with everything in computer science, there's no one-size-fits all. But there are some patterns that could help understanding and implementing them. To give three examples:
+
+### Adding some logic to a proof verification
+
+This would be an approach for something like our guessing game, where proofs are sent back and forth and are verified by each opponent. This circuit would be divided in two sections:
+
+- A `recursive verification` section, which would be just the call to `std::verify_proof`, and that would be skipped on the first move (since there's no proof to verify)
+- A `guessing` section, which is basically the logic part where the actual guessing happens
+
+In such a situation, and assuming Alice is first, she would skip the first part and try to guess Bob's number. Bob would then verify her proof on the first section of his run, and try to guess Alice's number on the second part, and so on.
+
+### Aggregating proofs
+
+In some one-way interaction situations, recursion would allow for aggregation of simple proofs that don't need to be immediately verified on-chain or elsewhere.
+
+To give a practical example, a barman wouldn't need to verify a "proof-of-age" on-chain every time he serves alcohol to a customer. Instead, the architecture would comprise two circuits:
+
+- A `main`, non-recursive circuit with some logic
+- A `recursive` circuit meant to verify two proofs in one proof
+
+The customer's proofs would be intermediate, and made on their phones, and the barman could just verify them locally. He would then aggregate them into a final proof sent on-chain (or elsewhere) at the end of the day.
+
+### Recursively verifying different circuits
+
+Nothing prevents you from verifying different circuits in a recursive proof, for example:
+
+- A `circuit1` circuit
+- A `circuit2` circuit
+- A `recursive` circuit
+
+In this example, a regulator could verify that taxes were paid for a specific purchase by aggregating both a `payer` circuit (proving that a purchase was made and taxes were paid), and a `receipt` circuit (proving that the payment was received)
+
+## How fast is it
+
+At the time of writing, verifying recursive proofs is surprisingly fast. This is because most of the time is spent on generating the verification key that will be used to generate the next proof. So you are able to cache the verification key and reuse it later.
+
+Currently, Noir JS packages don't expose the functionality of loading proving and verification keys, but that feature exists in the underlying `bb.js` package.
+
+## How can I try it
+
+Learn more about using recursion in Nargo and NoirJS in the [how-to guide](../how_to/how-to-recursion.md) and see a full example in [noir-examples](https://github.com/noir-lang/noir-examples).
diff --git a/docs/versioned_docs/version-v0.35.0/explainers/explainer-writing-noir.md b/docs/versioned_docs/version-v0.35.0/explainers/explainer-writing-noir.md
new file mode 100644
index 00000000000..3ef6e014a2f
--- /dev/null
+++ b/docs/versioned_docs/version-v0.35.0/explainers/explainer-writing-noir.md
@@ -0,0 +1,177 @@
+---
+title: Writing Performant Noir
+description: Understand new considerations when writing Noir
+keywords: [Noir, programming, rust]
+tags: [Optimization]
+sidebar_position: 0
+---
+
+
+This article intends to set you up with key concepts essential for writing more viable applications that use zero knowledge proofs, namely around efficient circuits.
+
+## Context - 'Efficient' is subjective
+
+When writing a web application for a performant computer with high-speed internet connection, writing efficient code sometimes is seen as an afterthought only if needed. Large multiplications running at the innermost of nested loops may not even be on a dev's radar.
+When writing firmware for a battery-powered microcontroller, you think of cpu cycles as rations to keep within a product's power budget.
+
+> Code is written to create applications that perform specific tasks within specific constraints
+
+And these constraints differ depending on where the compiled code is execute.
+
+### The Ethereum Virtual Machine (EVM)
+
+In scenarios where extremely low gas costs are required for an Ethereum application to be viable/competitive, Ethereum smart contract developers get into what is colloquially known as: "*gas golfing*". Finding the lowest execution cost of their compiled code (EVM bytecode) to achieve a specific task.
+
+The equivalent optimization task when writing zk circuits is affectionately referred to as "*gate golfing*", finding the lowest gate representation of the compiled Noir code.
+
+### Coding for circuits - a paradigm shift
+
+In zero knowledge cryptography, code is compiled to "circuits" consisting of arithmetic gates, and gate count is the significant cost. Depending on the proving system this is linearly proportionate to proving time, and so from a product point this should be kept as low as possible.
+
+Whilst writing efficient code for web apps and Solidity has a few key differences, writing efficient circuits have a different set of considerations. It is a bit of a paradigm shift, like writing code for GPUs for the first time...
+
+For example, drawing a circle at (0, 0) of radius `r`:
+- For a single CPU thread,
+```
+for theta in 0..2*pi {
+  let x = r * cos(theta);
+  let y = r * sin(theta);
+  draw(x, y);
+} // note: would do 0 - pi/2 and draw +ve/-ve x and y.
+```
+
+- For GPUs (simultaneous parallel calls with x, y across image),
+```
+if (x^2 + y^2 = r^2) {
+  draw(x, y);
+}
+```
+
+([Related](https://www.youtube.com/watch?v=-P28LKWTzrI))
+
+Whilst this CPU -> GPU does not translate to circuits exactly, it is intended to exemplify the difference in intuition when coding for different machine capabilities/constraints.
+
+### Context Takeaway
+
+For those coming from a primarily web app background, this article will explain what you need to consider when writing circuits. Furthermore, for those experienced writing efficient machine code, prepare to shift what you think is efficient 😬
+
+## Translating from Rust
+
+For some applications using Noir, existing code might be a convenient starting point to then proceed to optimize the gate count of.
+
+:::note
+Many valuable functions and algorithms have been written in more established languages (C/C++), and converted to modern ones (like Rust).
+:::
+
+Fortunately for Noir developers, when needing a particular function a Rust implementation can be readily compiled into Noir with some key changes. While the compiler does a decent amount of optimizations, it won't be able to change code that has been optimized for clock-cycles into code optimized for arithmetic gates.
+
+A few things to do when converting Rust code to Noir:
+- `println!` is not a macro, use `println` function (same for `assert_eq`)
+- No early `return` in function. Use constrain via assertion instead
+- No passing by reference. Remove `&` operator to pass by value (copy)
+- No boolean operators (`&&`, `||`). Use bitwise operators (`&`, `|`) with boolean values
+- No type `usize`. Use types `u8`, `u32`, `u64`, ... 
+- `main` return must be public, `pub`
+- No `const`, use `global`
+- Noir's LSP is your friend, so error message should be informative enough to resolve syntax issues.
+
+## Writing efficient Noir for performant products
+
+The following points help refine our understanding over time.
+
+:::note
+A Noir program makes a statement that can be verified.
+:::
+
+It compiles to a structure that represents the calculation, and can assert results within the calculation at any stage (via the `constrain` keyword).
+
+A Noir program compiles to an Abstract Circuit Intermediate Representation which is:
+ - Conceptually a tree structure
+ - Leaves (inputs) are the `Field` type
+ - Nodes contain arithmetic operations to combine them (gates)
+ - The root is the final result (return value)
+
+:::tip
+The command `nargo info` shows the programs circuit size, and is useful to compare the value of changes made.
+You can dig deeper and use the `--print-acir` param to take a closer look at individual ACIR opcodes, and the proving backend to see its gate count (eg for barretenberg, `bb gates -b ./target/program.json`).
+:::
+
+### Use the `Field` type
+
+Since the native type of values in circuits are `Field`s, using them for variables in Noir means less gates converting them under the hood.
+Some things to be mindful of when using a Field type for a regular integer value:
+- A variable of type `Field` can be cast `as` an integer type (eg `u8`, `u64`)
+  - Note: this retains only the bits of the integer type. Eg a Field value of 260 as a `u8` becomes 4
+- For Field types arithmetic operations meaningfully overflow/underflow, yet for integer types they are checked according to their size
+- Comparisons and bitwise operations do not exist for `Field`s, cast to an appropriately sized integer type when you need to
+
+:::tip
+Where possible, use `Field` type for values. Using smaller value types, and bit-packing strategies, will result in MORE gates
+:::
+
+
+### Use Arithmetic over non-arithmetic operations
+
+Since circuits are made of arithmetic gates, the cost of arithmetic operations tends to be one gate. Whereas for procedural code, they represent several clock cycles.
+
+Inversely, non-arithmetic operators are achieved with multiple gates, vs 1 clock cycle for procedural code.
+
+| (cost\op)  | arithmetic<br>(`*`, `+`) | bit-wise ops<br>(eg `<`, `\|`, `>>`) |
+| - | - | - |
+| **cycles** | 10+ | 1 |
+| **gates**  | 1 | 10+ |
+
+Bit-wise operations (e.g. bit shifts `<<` and `>>`), albeit commonly used in general programming and especially for clock cycle optimizations, are on the contrary expensive in gates when performed within circuits.
+
+Translate away from bit shifts when writing constrained functions for the best performance.
+
+On the flip side, feel free to use bit shifts in unconstrained functions and tests if necessary, as they are executed outside of circuits and does not induce performance hits.
+
+### Use static over dynamic values
+
+Another general theme that manifests in different ways is that static reads are represented with less gates than dynamic ones.
+
+Reading from read-only memory (ROM) adds less gates than random-access memory (RAM), 2 vs ~3.25 due to the additional bounds checks. Arrays of fixed length (albeit used at a lower capacity), will generate less gates than dynamic storage.
+
+Related to this, if an index used to access an array is not known at compile time (ie unknown until run time), then ROM will be converted to RAM, expanding the gate count.
+
+:::tip
+Use arrays and indices that are known at compile time where possible.
+Using `assert_constant(i);` before an index, `i`, is used in an array will give a compile error if `i` is NOT known at compile time.
+:::
+
+### Leverage unconstrained execution
+
+Constrained verification can leverage unconstrained execution, this is especially useful for operations that are represented by many gates.
+Use an [unconstrained function](../noir/concepts/unconstrained.md) to perform gate-heavy calculations, then verify and constrain the result.
+
+Eg division generates more gates than multiplication, so calculating the quotient in an unconstrained function then constraining the product for the quotient and divisor (+ any remainder) equals the dividend will be more efficient.
+
+Use `  if is_unconstrained() { /`, to conditionally execute code if being called in an unconstrained vs constrained way.
+
+## Advanced
+
+Unless you're well into the depth of gate optimization, this advanced section can be ignored.
+
+### Combine arithmetic operations
+
+A Noir program can be honed further by combining arithmetic operators in a way that makes the most of each constraint of the backend proving system. This is in scenarios where the backend might not be doing this perfectly.
+
+Eg Barretenberg backend (current default for Noir) is a width-4 PLONKish constraint system
+$ w_1*w_2*q_m + w_1*q_1 + w_2*q_2 + w_3*q_3 + w_4*q_4 + q_c = 0 $
+
+Here we see there is one occurrence of witness 1 and 2 ($w_1$, $w_2$) being multiplied together, with addition to witnesses 1-4 ($w_1$ .. $w_4$) multiplied by 4 corresponding circuit constants ($q_1$ .. $q_4$) (plus a final circuit constant, $q_c$).
+
+Use `nargo info --print-acir`, to inspect the ACIR opcodes (and the proving system for gates), and it may present opportunities to amend the order of operations and reduce the number of constraints.
+
+#### Variable as witness vs expression
+
+If you've come this far and really know what you're doing at the equation level, a temporary lever (that will become unnecessary/useless over time) is: `std::as_witness`. This informs the compiler to save a variable as a witness not an expression.
+
+The compiler will mostly be correct and optimal, but this may help some near term edge cases that are yet to optimize.
+Note: When used incorrectly it will create **less** efficient circuits (higher gate count).
+
+## References
+- Guillaume's ["`Cryptdoku`" talk](https://www.youtube.com/watch?v=MrQyzuogxgg) (Jun'23)
+- Tips from Tom, Jake and Zac.
+- [Idiomatic Noir](https://www.vlayer.xyz/blog/idiomatic-noir-part-1-collections) blog post
diff --git a/docs/docs/getting_started/_category_.json b/docs/versioned_docs/version-v0.35.0/getting_started/_category_.json
similarity index 100%
rename from docs/docs/getting_started/_category_.json
rename to docs/versioned_docs/version-v0.35.0/getting_started/_category_.json
diff --git a/docs/docs/getting_started/backend/_category_.json b/docs/versioned_docs/version-v0.35.0/getting_started/backend/_category_.json
similarity index 100%
rename from docs/docs/getting_started/backend/_category_.json
rename to docs/versioned_docs/version-v0.35.0/getting_started/backend/_category_.json
diff --git a/docs/docs/getting_started/backend/index.md b/docs/versioned_docs/version-v0.35.0/getting_started/backend/index.md
similarity index 100%
rename from docs/docs/getting_started/backend/index.md
rename to docs/versioned_docs/version-v0.35.0/getting_started/backend/index.md
diff --git a/docs/docs/getting_started/hello_noir/_category_.json b/docs/versioned_docs/version-v0.35.0/getting_started/hello_noir/_category_.json
similarity index 100%
rename from docs/docs/getting_started/hello_noir/_category_.json
rename to docs/versioned_docs/version-v0.35.0/getting_started/hello_noir/_category_.json
diff --git a/docs/docs/getting_started/hello_noir/index.md b/docs/versioned_docs/version-v0.35.0/getting_started/hello_noir/index.md
similarity index 100%
rename from docs/docs/getting_started/hello_noir/index.md
rename to docs/versioned_docs/version-v0.35.0/getting_started/hello_noir/index.md
diff --git a/docs/docs/getting_started/hello_noir/project_breakdown.md b/docs/versioned_docs/version-v0.35.0/getting_started/hello_noir/project_breakdown.md
similarity index 100%
rename from docs/docs/getting_started/hello_noir/project_breakdown.md
rename to docs/versioned_docs/version-v0.35.0/getting_started/hello_noir/project_breakdown.md
diff --git a/docs/docs/getting_started/installation/_category_.json b/docs/versioned_docs/version-v0.35.0/getting_started/installation/_category_.json
similarity index 100%
rename from docs/docs/getting_started/installation/_category_.json
rename to docs/versioned_docs/version-v0.35.0/getting_started/installation/_category_.json
diff --git a/docs/docs/getting_started/installation/index.md b/docs/versioned_docs/version-v0.35.0/getting_started/installation/index.md
similarity index 100%
rename from docs/docs/getting_started/installation/index.md
rename to docs/versioned_docs/version-v0.35.0/getting_started/installation/index.md
diff --git a/docs/docs/getting_started/installation/other_install_methods.md b/docs/versioned_docs/version-v0.35.0/getting_started/installation/other_install_methods.md
similarity index 100%
rename from docs/docs/getting_started/installation/other_install_methods.md
rename to docs/versioned_docs/version-v0.35.0/getting_started/installation/other_install_methods.md
diff --git a/docs/versioned_docs/version-v0.35.0/how_to/_category_.json b/docs/versioned_docs/version-v0.35.0/how_to/_category_.json
new file mode 100644
index 00000000000..23b560f610b
--- /dev/null
+++ b/docs/versioned_docs/version-v0.35.0/how_to/_category_.json
@@ -0,0 +1,5 @@
+{
+    "position": 1,
+    "collapsible": true,
+    "collapsed": true
+}
diff --git a/docs/versioned_docs/version-v0.35.0/how_to/debugger/_category_.json b/docs/versioned_docs/version-v0.35.0/how_to/debugger/_category_.json
new file mode 100644
index 00000000000..cc2cbb1c253
--- /dev/null
+++ b/docs/versioned_docs/version-v0.35.0/how_to/debugger/_category_.json
@@ -0,0 +1,6 @@
+{
+    "label": "Debugging",
+    "position": 5,
+    "collapsible": true,
+    "collapsed": true
+}
diff --git a/docs/versioned_docs/version-v0.35.0/how_to/debugger/debugging_with_the_repl.md b/docs/versioned_docs/version-v0.35.0/how_to/debugger/debugging_with_the_repl.md
new file mode 100644
index 00000000000..1d64dae3f37
--- /dev/null
+++ b/docs/versioned_docs/version-v0.35.0/how_to/debugger/debugging_with_the_repl.md
@@ -0,0 +1,164 @@
+---
+title: Using the REPL Debugger
+description:
+  Step-by-step guide on how to debug your Noir circuits with the REPL Debugger. 
+keywords:
+  [
+    Nargo,
+    Noir CLI,
+    Noir Debugger,
+    REPL,
+  ]
+sidebar_position: 1
+---
+
+#### Pre-requisites
+
+In order to use the REPL debugger, first you need to install recent enough versions of Nargo and vscode-noir. 
+
+## Debugging a simple circuit
+
+Let's debug a simple circuit:
+
+```rust
+fn main(x : Field, y : pub Field) {
+    assert(x != y);
+}
+```
+
+To start the REPL debugger, using a terminal, go to a Noir circuit's home directory. Then:
+
+`$ nargo debug`
+
+You should be seeing this in your terminal:
+
+```
+[main] Starting debugger
+At ~/noir-examples/recursion/circuits/main/src/main.nr:1:9
+  1 -> fn main(x : Field, y : pub Field) {
+  2        assert(x != y);
+  3    }
+> 
+```
+
+The debugger displays the current Noir code location, and it is now waiting for us to drive it.
+
+Let's first take a look at the available commands. For that we'll use the `help` command.
+
+```
+> help
+Available commands:
+
+  opcodes                          display ACIR opcodes
+  into                             step into to the next opcode
+  next                             step until a new source location is reached
+  out                              step until a new source location is reached
+                                   and the current stack frame is finished
+  break LOCATION:OpcodeLocation    add a breakpoint at an opcode location
+  over                             step until a new source location is reached
+                                   without diving into function calls
+  restart                          restart the debugging session
+  delete LOCATION:OpcodeLocation   delete breakpoint at an opcode location
+  witness                          show witness map
+  witness index:u32                display a single witness from the witness map
+  witness index:u32 value:String   update a witness with the given value
+  memset index:usize value:String  update a memory cell with the given
+                                   value
+  continue                         continue execution until the end of the
+                                   program
+  vars                             show variable values available at this point
+                                   in execution
+  stacktrace                       display the current stack trace
+  memory                           show memory (valid when executing unconstrained code)
+  step                             step to the next ACIR opcode
+
+Other commands:
+
+  help  Show this help message
+  quit  Quit repl
+
+```
+
+Some commands operate only for unconstrained functions, such as `memory` and `memset`. If you try to use them while execution is paused at an ACIR opcode, the debugger will simply inform you that you are not executing unconstrained code:
+
+```
+> memory
+Unconstrained VM memory not available
+> 
+```
+
+Before continuing, we can take a look at the initial witness map:
+
+```
+> witness
+_0 = 1
+_1 = 2
+>
+```
+
+Cool, since `x==1`, `y==2`, and we want to check that `x != y`, our circuit should succeed. At this point we could intervene and use the witness setter command to change one of the witnesses. Let's set `y=3`, then back to 2, so we don't affect the expected result:
+
+```
+> witness
+_0 = 1
+_1 = 2
+> witness 1 3
+_1 = 3
+> witness
+_0 = 1
+_1 = 3
+> witness 1 2
+_1 = 2
+> witness
+_0 = 1
+_1 = 2
+>
+```
+
+Now we can inspect the current state of local variables. For that we use the `vars` command. 
+
+```
+> vars
+>
+```
+
+We currently have no vars in context, since we are at the entry point of the program. Let's use `next` to execute until the next point in the program.
+
+```
+> vars
+> next
+At ~/noir-examples/recursion/circuits/main/src/main.nr:1:20
+  1 -> fn main(x : Field, y : pub Field) {
+  2        assert(x != y);
+  3    }
+> vars
+x:Field = 0x01
+```
+
+As a result of stepping, the variable `x`, whose initial value comes from the witness map, is now in context and returned by `vars`.
+
+```
+> next
+  1    fn main(x : Field, y : pub Field) {
+  2 ->     assert(x != y);
+  3    }
+> vars
+y:Field = 0x02
+x:Field = 0x01
+```
+
+Stepping again we can finally see both variables and their values. And now we can see that the next assertion should succeed.
+
+Let's continue to the end:
+
+```
+> continue
+(Continuing execution...)
+Finished execution
+> q
+[main] Circuit witness successfully solved
+```
+
+Upon quitting the debugger after a solved circuit, the resulting circuit witness gets saved, equivalent to what would happen if we had run the same circuit with `nargo execute`.
+
+We just went through the basics of debugging using Noir REPL debugger. For a comprehensive reference, check out [the reference page](../../reference/debugger/debugger_repl.md).
diff --git a/docs/versioned_docs/version-v0.35.0/how_to/debugger/debugging_with_vs_code.md b/docs/versioned_docs/version-v0.35.0/how_to/debugger/debugging_with_vs_code.md
new file mode 100644
index 00000000000..a5858c1a5eb
--- /dev/null
+++ b/docs/versioned_docs/version-v0.35.0/how_to/debugger/debugging_with_vs_code.md
@@ -0,0 +1,68 @@
+---
+title: Using the VS Code Debugger
+description:
+  Step by step guide on how to debug your Noir circuits with the VS Code Debugger configuration and features.
+keywords:
+  [
+    Nargo,
+    Noir CLI,
+    Noir Debugger,
+    VS Code,
+    IDE,
+  ]
+sidebar_position: 0
+---
+
+This guide will show you how to use VS Code with the vscode-noir extension to debug a Noir project. 
+
+#### Pre-requisites
+
+- Nargo
+- vscode-noir
+- A Noir project with a `Nargo.toml`, `Prover.toml` and at least one Noir (`.nr`) containing an entry point function (typically `main`).
+
+## Running the debugger
+
+The easiest way to start debugging is to open the file you want to debug, and press `F5`. This will cause the debugger to launch, using your `Prover.toml` file as input.
+
+You should see something like this:
+
+![Debugger launched](@site/static/img/debugger/1-started.png)
+
+Let's inspect the state of the program. For that, we open VS Code's _Debug pane_. Look for this icon:
+
+![Debug pane icon](@site/static/img/debugger/2-icon.png)
+
+You will now see two categories of variables: Locals and Witness Map.
+
+![Debug pane expanded](@site/static/img/debugger/3-debug-pane.png)
+
+1. **Locals**: variables of your program. At this point in execution this section is empty, but as we step through the code it will get populated by `x`, `result`, `digest`, etc. 
+
+2. **Witness map**: these are initially populated from your project's `Prover.toml` file. In this example, they will be used to populate `x` and `result` at the beginning of the `main` function.
+
+Most of the time you will probably be focusing mostly on locals, as they represent the high level state of your program. 
+
+You might be interested in inspecting the witness map in case you are trying to solve a really low level issue in the compiler or runtime itself, so this concerns mostly advanced or niche users.
+
+Let's step through the program, by using the debugger buttons or their corresponding keyboard shortcuts.
+
+![Debugger buttons](@site/static/img/debugger/4-debugger-buttons.png)
+
+Now we can see in the variables pane that there's values for `digest`, `result` and `x`.
+
+![Inspecting locals](@site/static/img/debugger/5-assert.png)
+
+We can also inspect the values of variables by directly hovering on them on the code.
+
+![Hover locals](@site/static/img/debugger/6-hover.png)
+
+Let's set a break point at the `keccak256` function, so we can continue execution up to the point when it's first invoked without having to go one step at a time. 
+
+We just need to click the to the right of the line number 18. Once the breakpoint appears, we can click the `continue` button or use its corresponding keyboard shortcut (`F5` by default).
+
+![Breakpoint](@site/static/img/debugger/7-break.png)
+
+Now we are debugging the `keccak256` function, notice the _Call Stack pane_ at the lower right. This lets us inspect the current call stack of our process.
+
+That covers most of the current debugger functionalities. Check out [the reference](../../reference/debugger/debugger_vscode.md) for more details on how to configure the debugger.
\ No newline at end of file
diff --git a/docs/versioned_docs/version-v0.35.0/how_to/how-to-oracles.md b/docs/versioned_docs/version-v0.35.0/how_to/how-to-oracles.md
new file mode 100644
index 00000000000..392dd8b452e
--- /dev/null
+++ b/docs/versioned_docs/version-v0.35.0/how_to/how-to-oracles.md
@@ -0,0 +1,275 @@
+---
+title: How to use Oracles
+description: Learn how to use oracles in your Noir program with examples in both Nargo and NoirJS. This guide also covers writing a JSON RPC server and providing custom foreign call handlers for NoirJS.
+keywords:
+  - Noir Programming
+  - Oracles
+  - Nargo
+  - NoirJS
+  - JSON RPC Server
+  - Foreign Call Handlers
+sidebar_position: 1
+---
+
+This guide shows you how to use oracles in your Noir program. For the sake of clarity, it assumes that:
+
+- You have read the [explainer on Oracles](../explainers/explainer-oracle.md) and are comfortable with the concept.
+- You have a Noir program to add oracles to. You can create one using the [vite-hardhat starter](https://github.com/noir-lang/noir-starter/tree/main/vite-hardhat) as a boilerplate.
+- You understand the concept of a JSON-RPC server. Visit the [JSON-RPC website](https://www.jsonrpc.org/) if you need a refresher.
+- You are comfortable with server-side JavaScript (e.g. Node.js, managing packages, etc.).
+
+## Rundown
+
+This guide has 3 major steps:
+
+1. How to modify our Noir program to make use of oracle calls as unconstrained functions
+2. How to write a JSON RPC Server to resolve these oracle calls with Nargo
+3. How to use them in Nargo and how to provide a custom resolver in NoirJS
+
+## Step 1 - Modify your Noir program
+
+An oracle is defined in a Noir program by defining two methods:
+
+- An unconstrained method - This tells the compiler that it is executing an [unconstrained functions](../noir/concepts//unconstrained.md).
+- A decorated oracle method - This tells the compiler that this method is an RPC call.
+
+An example of an oracle that returns a `Field` would be:
+
+```rust
+#[oracle(getSqrt)]
+unconstrained fn sqrt(number: Field) -> Field { }
+
+unconstrained fn get_sqrt(number: Field) -> Field {
+    sqrt(number)
+}
+```
+
+In this example, we're wrapping our oracle function in an unconstrained method, and decorating it with `oracle(getSqrt)`. We can then call the unconstrained function as we would call any other function:
+
+```rust
+fn main(input: Field) {
+    let sqrt = get_sqrt(input);
+}
+```
+
+In the next section, we will make this `getSqrt` (defined on the `sqrt` decorator) be a method of the RPC server Noir will use.
+
+:::danger
+
+As explained in the [Oracle Explainer](../explainers/explainer-oracle.md), this `main` function is unsafe unless you constrain its return value. For example:
+
+```rust
+fn main(input: Field) {
+    let sqrt = get_sqrt(input);
+    assert(sqrt.pow_32(2) as u64 == input as u64); // <---- constrain the return of an oracle!
+}
+```
+
+:::
+
+:::info
+
+Currently, oracles only work with single params or array params. For example:
+
+```rust
+#[oracle(getSqrt)]
+unconstrained fn sqrt([Field; 2]) -> [Field; 2] { }
+```
+
+:::
+
+## Step 2 - Write an RPC server
+
+Brillig will call *one* RPC server. Most likely you will have to write your own, and you can do it in whatever language you prefer. In this guide, we will do it in Javascript.
+
+Let's use the above example of an oracle that consumes an array with two `Field` and returns their square roots:
+
+```rust
+#[oracle(getSqrt)]
+unconstrained fn sqrt(input: [Field; 2]) -> [Field; 2] { }
+
+unconstrained fn get_sqrt(input: [Field; 2]) -> [Field; 2] {
+    sqrt(input)
+}
+
+fn main(input: [Field; 2]) {
+    let sqrt = get_sqrt(input);
+    assert(sqrt[0].pow_32(2) as u64 == input[0] as u64);
+    assert(sqrt[1].pow_32(2) as u64 == input[1] as u64);
+}
+
+#[test]
+fn test() {
+    let input = [4, 16];
+    main(input);
+}
+```
+
+:::info
+
+Why square root?
+
+In general, computing square roots is computationally more expensive than multiplications, which takes a toll when speaking about ZK applications. In this case, instead of calculating the square root in Noir, we are using our oracle to offload that computation to be made in plain. In our circuit we can simply multiply the two values.
+
+:::
+
+Now, we should write the correspondent RPC server, starting with the [default JSON-RPC 2.0 boilerplate](https://www.npmjs.com/package/json-rpc-2.0#example):
+
+```js
+import { JSONRPCServer } from "json-rpc-2.0";
+import express from "express";
+import bodyParser from "body-parser";
+
+const app = express();
+app.use(bodyParser.json());
+
+const server = new JSONRPCServer();
+app.post("/", (req, res) => {
+ const jsonRPCRequest = req.body;
+ server.receive(jsonRPCRequest).then((jsonRPCResponse) => {
+  if (jsonRPCResponse) {
+   res.json(jsonRPCResponse);
+  } else {
+   res.sendStatus(204);
+  }
+ });
+});
+
+app.listen(5555);
+```
+
+Now, we will add our `getSqrt` method, as expected by the `#[oracle(getSqrt)]` decorator in our Noir code. It maps through the params array and returns their square roots:
+
+```js
+server.addMethod("resolve_foreign_call", async (params) => {
+    if (params[0].function !== "getSqrt") {
+        throw Error("Unexpected foreign call")
+    };
+    const values = params[0].inputs[0].map((field) => {
+        return `${Math.sqrt(parseInt(field, 16))}`;
+    });
+    return { values: [values] };
+});
+```
+
+If you're using Typescript, the following types may be helpful in understanding the expected return value and making sure they're easy to follow:
+
+```js
+export type ForeignCallSingle = string;
+
+export type ForeignCallArray = string[];
+
+export type ForeignCallResult = {
+  values: (ForeignCallSingle | ForeignCallArray)[];
+};
+```
+
+:::info Multidimensional Arrays
+
+If the Oracle function is returning an array containing other arrays, such as `[['1','2],['3','4']]`, you need to provide the values in JSON as flattened values. In the previous example, it would be `['1', '2', '3', '4']`. In the Noir program, the Oracle signature can use a nested type, the flattened values will be automatically converted to the nested type.
+
+:::
+
+## Step 3 - Usage with Nargo
+
+Using the [`nargo` CLI tool](../getting_started/installation/index.md), you can use oracles in the `nargo test` and `nargo execute`  commands by passing a value to `--oracle-resolver`. For example:
+
+```bash
+nargo test --oracle-resolver http://localhost:5555
+```
+
+This tells `nargo` to use your RPC Server URL whenever it finds an oracle decorator.
+
+## Step 4 - Usage with NoirJS
+
+In a JS environment, an RPC server is not strictly necessary, as you may want to resolve your oracles without needing any JSON call at all. NoirJS simply expects that you pass a callback function when you generate proofs, and that callback function can be anything.
+
+For example, if your Noir program expects the host machine to provide CPU pseudo-randomness, you could simply pass it as the `foreignCallHandler`. You don't strictly need to create an RPC server to serve pseudo-randomness, as you may as well get it directly in your app:
+
+```js
+const foreignCallHandler = (name, inputs) => crypto.randomBytes(16) // etc
+
+await noir.execute(inputs, foreignCallHandler)
+```
+
+As one can see, in NoirJS, the [`foreignCallHandler`](../reference/NoirJS/noir_js/type-aliases/ForeignCallHandler.md) function simply means "a callback function that returns a value of type [`ForeignCallOutput`](../reference/NoirJS/noir_js/type-aliases/ForeignCallOutput.md). It doesn't have to be an RPC call like in the case for Nargo.
+
+:::tip
+
+Does this mean you don't have to write an RPC server like in [Step #2](#step-2---write-an-rpc-server)?
+
+You don't technically have to, but then how would you run `nargo test`? To use both `Nargo` and `NoirJS` in your development flow, you will have to write a JSON RPC server.
+
+:::
+
+In this case, let's make `foreignCallHandler` call the JSON RPC Server we created in [Step #2](#step-2---write-an-rpc-server), by making it a JSON RPC Client.
+
+For example, using the same `getSqrt` program in [Step #1](#step-1---modify-your-noir-program) (comments in the code):
+
+```js
+import { JSONRPCClient } from "json-rpc-2.0";
+
+// declaring the JSONRPCClient
+const client = new JSONRPCClient((jsonRPCRequest) => {
+// hitting the same JSON RPC Server we coded above
+ return fetch("http://localhost:5555", {
+  method: "POST",
+  headers: {
+   "content-type": "application/json",
+  },
+  body: JSON.stringify(jsonRPCRequest),
+ }).then((response) => {
+  if (response.status === 200) {
+   return response
+    .json()
+    .then((jsonRPCResponse) => client.receive(jsonRPCResponse));
+  } else if (jsonRPCRequest.id !== undefined) {
+   return Promise.reject(new Error(response.statusText));
+  }
+ });
+});
+
+// declaring a function that takes the name of the foreign call (getSqrt) and the inputs
+const foreignCallHandler = async (name, input) => {
+  const inputs = input[0].map((i) => i.toString("hex"))
+  // notice that the "inputs" parameter contains *all* the inputs
+  // in this case we to make the RPC request with the first parameter "numbers", which would be input[0]
+  const oracleReturn = await client.request("resolve_foreign_call", [
+    {
+      function: name,
+      inputs: [inputs]
+    },
+  ]);
+  return [oracleReturn.values[0]];
+};
+
+// the rest of your NoirJS code
+const input = { input: [4, 16] };
+const { witness } = await noir.execute(input, foreignCallHandler);
+```
+
+:::tip
+
+If you're in a NoirJS environment running your RPC server together with a frontend app, you'll probably hit a familiar problem in full-stack development: requests being blocked by [CORS](https://developer.mozilla.org/en-US/docs/Web/HTTP/CORS) policy. For development only, you can simply install and use the [`cors` npm package](https://www.npmjs.com/package/cors) to get around the problem:
+
+```bash
+yarn add cors
+```
+
+and use it as a middleware:
+
+```js
+import cors from "cors";
+
+const app = express();
+app.use(cors())
+```
+
+:::
+
+## Conclusion
+
+Hopefully by the end of this guide, you should be able to:
+
+- Write your own logic around Oracles and how to write a JSON RPC server to make them work with your Nargo commands.
+- Provide custom foreign call handlers for NoirJS.
\ No newline at end of file
diff --git a/docs/versioned_docs/version-v0.35.0/how_to/how-to-recursion.md b/docs/versioned_docs/version-v0.35.0/how_to/how-to-recursion.md
new file mode 100644
index 00000000000..c8c4dc9f5b4
--- /dev/null
+++ b/docs/versioned_docs/version-v0.35.0/how_to/how-to-recursion.md
@@ -0,0 +1,180 @@
+---
+title: How to use recursion on NoirJS
+description: Learn how to implement recursion with NoirJS, a powerful tool for creating smart contracts on the EVM blockchain. This guide assumes familiarity with NoirJS, solidity verifiers, and the Barretenberg proving backend. Discover how to generate both final and intermediate proofs using `noir_js` and `backend_barretenberg`.
+keywords:
+  [
+    "NoirJS",
+    "EVM blockchain",
+    "smart contracts",
+    "recursion",
+    "solidity verifiers",
+    "Barretenberg backend",
+    "noir_js",
+    "backend_barretenberg",
+    "intermediate proofs",
+    "final proofs",
+    "nargo compile",
+    "json import",
+    "recursive circuit",
+    "recursive app"
+  ]
+sidebar_position: 1
+---
+
+This guide shows you how to use recursive proofs in your NoirJS app. For the sake of clarity, it is assumed that:
+
+- You already have a NoirJS app. If you don't, please visit the [NoirJS tutorial](../tutorials/noirjs_app.md) and the [reference](../reference/NoirJS/noir_js/index.md).
+- You are familiar with what are recursive proofs and you have read the [recursion explainer](../explainers/explainer-recursion.md)
+- You already built a recursive circuit following [the reference](../noir/standard_library/recursion.mdx), and understand how it works.
+
+It is also assumed that you're not using `noir_wasm` for compilation, and instead you've used [`nargo compile`](../reference/nargo_commands.md) to generate the `json` you're now importing into your project. However, the guide should work just the same if you're using `noir_wasm`.
+
+:::info
+
+As you've read in the [explainer](../explainers/explainer-recursion.md), a recursive proof is an intermediate proof. This means that it doesn't necessarily generate the final step that makes it verifiable in a smart contract. However, it is easy to verify within another circuit.
+
+While "standard" usage of NoirJS packages abstracts final proofs, it currently lacks the necessary interface to abstract away intermediate proofs. This means that these proofs need to be created by using the backend directly.
+
+In short:
+
+- `noir_js` generates *only* final proofs
+- `backend_barretenberg` generates both types of proofs
+
+:::
+
+In a standard recursive app, you're also dealing with at least two circuits. For the purpose of this guide, we will assume the following:
+
+- `main`: a circuit of type `assert(x != y)`, where `main` is marked with a `#[recursive]` attribute. This attribute states that the backend should generate proofs that are friendly for verification within another circuit.
+- `recursive`: a circuit that verifies `main`
+
+For a full example of how recursive proofs work, please refer to the [noir-examples](https://github.com/noir-lang/noir-examples) repository. We will *not* be using it as a reference for this guide.
+
+## Step 1: Setup
+
+In a common NoirJS app, you need to instantiate a backend with something like `const backend = new Backend(circuit)`. Then you feed it to the `noir_js` interface.
+
+For recursion, this doesn't happen, and the only need for `noir_js` is only to `execute` a circuit and get its witness and return value. Everything else is not interfaced, so it needs to happen on the `backend` object.
+
+It is also recommended that you instantiate the backend with as many threads as possible, to allow for maximum concurrency:
+
+```js
+const backend = new Backend(circuit, { threads: 8 })
+```
+
+:::tip
+You can use the [`os.cpus()`](https://nodejs.org/api/os.html#oscpus) object in `nodejs` or [`navigator.hardwareConcurrency`](https://developer.mozilla.org/en-US/docs/Web/API/Navigator/hardwareConcurrency) on the browser to make the most out of those glorious cpu cores
+:::
+
+## Step 2: Generating the witness and the proof for `main`
+
+After instantiating the backend, you should also instantiate `noir_js`. We will use it to execute the circuit and get the witness.
+
+```js
+const noir = new Noir(circuit)
+const { witness } = noir.execute(input)
+```
+
+With this witness, you are now able to generate the intermediate proof for the main circuit:
+
+```js
+const { proof, publicInputs } = await backend.generateProof(witness)
+```
+
+:::warning
+
+Always keep in mind what is actually happening on your development process, otherwise you'll quickly become confused about what circuit we are actually running and why!
+
+In this case, you can imagine that Alice (running the `main` circuit) is proving something to Bob (running the `recursive` circuit), and Bob is verifying her proof within his proof.
+
+With this in mind, it becomes clear that our intermediate proof is the one *meant to be verified within another circuit*, so it must be Alice's. Actually, the only final proof in this theoretical scenario would be the last one, sent on-chain.
+
+:::
+
+## Step 3 - Verification and proof artifacts
+
+Optionally, you are able to verify the intermediate proof:
+
+```js
+const verified = await backend.verifyProof({ proof, publicInputs })
+```
+
+This can be useful to make sure our intermediate proof was correctly generated. But the real goal is to do it within another circuit. For that, we need to generate  recursive proof artifacts that will be passed to the circuit that is verifying the proof we just generated. Instead of passing the proof and verification key as a byte array, we pass them as fields which makes it cheaper to verify in a circuit:
+
+```js
+const { proofAsFields, vkAsFields, vkHash } = await backend.generateRecursiveProofArtifacts( { publicInputs, proof }, publicInputsCount)
+```
+
+This call takes the public inputs and the proof, but also the public inputs count. While this is easily retrievable by simply counting the `publicInputs` length, the backend interface doesn't currently abstract it away.
+
+:::info
+
+The `proofAsFields` has a constant size `[Field; 93]` and verification keys in Barretenberg are always `[Field; 114]`.
+
+:::
+
+:::warning
+
+One common mistake is to forget *who* makes this call.
+
+In a situation where Alice is generating the `main` proof, if she generates the proof artifacts and sends them to Bob, which gladly takes them as true, this would mean Alice could prove anything!
+
+Instead, Bob needs to make sure *he* extracts the proof artifacts, using his own instance of the `main` circuit backend. This way, Alice has to provide a valid proof for the correct `main` circuit.
+
+:::
+
+## Step 4 - Recursive proof generation
+
+With the artifacts, generating a recursive proof is no different from a normal proof. You simply use the `backend` (with the recursive circuit) to generate it:
+
+```js
+const recursiveInputs = {
+    verification_key: vkAsFields, // array of length 114
+    proof: proofAsFields, // array of length 93 + size of public inputs
+    publicInputs: [mainInput.y], // using the example above, where `y` is the only public input
+    key_hash: vkHash,
+}
+
+const { witness, returnValue } = noir.execute(recursiveInputs) // we're executing the recursive circuit now!
+const { proof, publicInputs } = backend.generateProof(witness)
+const verified = backend.verifyProof({ proof, publicInputs })
+```
+
+You can obviously chain this proof into another proof. In fact, if you're using recursive proofs, you're probably interested of using them this way!
+
+:::tip
+
+Managing circuits and "who does what" can be confusing. To make sure your naming is consistent, you can keep them in an object. For example:
+
+```js
+const circuits = {
+  main: mainJSON, 
+  recursive: recursiveJSON
+}
+const backends = {
+  main: new BarretenbergBackend(circuits.main),
+  recursive: new BarretenbergBackend(circuits.recursive)
+}
+const noir_programs = {
+  main: new Noir(circuits.main),
+  recursive: new Noir(circuits.recursive)
+}
+```
+
+This allows you to neatly call exactly the method you want without conflicting names:
+
+```js
+// Alice runs this 👇
+const { witness: mainWitness } = await noir_programs.main.execute(input)
+const proof = await backends.main.generateProof(mainWitness)
+
+// Bob runs this 👇
+const verified = await backends.main.verifyProof(proof)
+const { proofAsFields, vkAsFields, vkHash } = await backends.main.generateRecursiveProofArtifacts(
+    proof,
+    numPublicInputs,
+);
+const { witness: recursiveWitness } = await noir_programs.recursive.execute(recursiveInputs)
+const recursiveProof = await backends.recursive.generateProof(recursiveWitness);
+```
+
+:::
diff --git a/docs/versioned_docs/version-v0.35.0/how_to/how-to-solidity-verifier.md b/docs/versioned_docs/version-v0.35.0/how_to/how-to-solidity-verifier.md
new file mode 100644
index 00000000000..a8169595b3d
--- /dev/null
+++ b/docs/versioned_docs/version-v0.35.0/how_to/how-to-solidity-verifier.md
@@ -0,0 +1,259 @@
+---
+title: Generate a Solidity Verifier
+description:
+  Learn how to run the verifier as a smart contract on the blockchain. Compile a Solidity verifier
+  contract for your Noir program and deploy it on any EVM blockchain acting as a verifier smart
+  contract. Read more to find out
+keywords:
+  [
+    solidity verifier,
+    smart contract,
+    blockchain,
+    compiler,
+    plonk_vk.sol,
+    EVM blockchain,
+    verifying Noir programs,
+    proving backend,
+    Barretenberg,
+  ]
+sidebar_position: 0
+pagination_next: tutorials/noirjs_app
+---
+
+Noir has the ability to generate a verifier contract in Solidity, which can be deployed in many EVM-compatible blockchains such as Ethereum.
+
+This allows for a powerful feature set, as one can make use of the conciseness and the privacy provided by Noir in an immutable ledger. Applications can range from simple P2P guessing games, to complex private DeFi interactions.
+
+This guide shows you how to generate a Solidity Verifier and deploy it on the [Remix IDE](https://remix.ethereum.org/). It is assumed that:
+
+- You are comfortable with the Solidity programming language and understand how contracts are deployed on the Ethereum network
+- You have Noir installed and you have a Noir program. If you don't, [get started](../getting_started/installation/index.md) with Nargo and the example Hello Noir circuit
+- You are comfortable navigating RemixIDE. If you aren't or you need a refresher, you can find some video tutorials [here](https://www.youtube.com/channel/UCjTUPyFEr2xDGN6Cg8nKDaA) that could help you.
+
+## Rundown
+
+Generating a Solidity Verifier contract is actually a one-command process. However, compiling it and deploying it can have some caveats. Here's the rundown of this guide:
+
+1. How to generate a solidity smart contract
+2. How to compile the smart contract in the RemixIDE
+3. How to deploy it to a testnet
+
+## Step 1 - Generate a contract
+
+This is by far the most straightforward step. Just run:
+
+```sh
+nargo compile
+```
+
+This will compile your source code into a Noir build artifact to be stored in the `./target` directory, you can then generate the smart contract using the commands:
+
+```sh
+# Here we pass the path to the newly generated Noir artifact.
+bb write_vk -b ./target/<noir_artifact_name>.json
+bb contract
+```
+
+replacing `<noir_artifact_name>` with the name of your Noir project. A new `contract` folder would then be generated in your project directory, containing the Solidity
+file `contract.sol`. It can be deployed to any EVM blockchain acting as a verifier smart contract.
+
+You can find more information about `bb` and the default Noir proving backend on [this page](../getting_started/hello_noir/index.md#proving-backend).
+
+:::info
+
+It is possible to generate verifier contracts of Noir programs for other smart contract platforms as long as the proving backend supplies an implementation.
+
+Barretenberg, the default proving backend for Nargo, supports generation of verifier contracts, for the time being these are only in Solidity.
+:::
+
+## Step 2 - Compiling
+
+We will mostly skip the details of RemixIDE, as the UI can change from version to version. For now, we can just open
+<a href="https://remix.ethereum.org" target="_blank">Remix</a> and create a blank workspace.
+
+![Create Workspace](@site/static/img/how-tos/solidity_verifier_1.png)
+
+We will create a new file to contain the contract Nargo generated, and copy-paste its content.
+
+:::warning
+
+You'll likely see a warning advising you to not trust pasted code. While it is an important warning, it is irrelevant in the context of this guide and can be ignored. We will not be deploying anywhere near a mainnet.
+
+:::
+
+To compile our the verifier, we can navigate to the compilation tab:
+
+![Compilation Tab](@site/static/img/how-tos/solidity_verifier_2.png)
+
+Remix should automatically match a suitable compiler version. However, hitting the "Compile" button will most likely generate a "Stack too deep" error:
+
+![Stack too deep](@site/static/img/how-tos/solidity_verifier_3.png)
+
+This is due to the verify function needing to put many variables on the stack, but enabling the optimizer resolves the issue. To do this, let's open the "Advanced Configurations" tab and enable optimization. The default 200 runs will suffice.
+
+:::info
+
+This time we will see a warning about an unused function parameter. This is expected, as the `verify` function doesn't use the `_proof` parameter inside a solidity block, it is loaded from calldata and used in assembly.
+
+:::
+
+![Compilation success](@site/static/img/how-tos/solidity_verifier_4.png)
+
+## Step 3 - Deploying
+
+At this point we should have a compiled contract ready to deploy. If we navigate to the deploy section in Remix, we will see many different environments we can deploy to. The steps to deploy on each environment would be out-of-scope for this guide, so we will just use the default Remix VM.
+
+Looking closely, we will notice that our "Solidity Verifier" is actually three contracts working together:
+
+- An `UltraVerificationKey` library which simply stores the verification key for our circuit.
+- An abstract contract `BaseUltraVerifier` containing most of the verifying logic.
+- A main `UltraVerifier` contract that inherits from the Base and uses the Key contract.
+
+Remix will take care of the dependencies for us so we can simply deploy the UltraVerifier contract by selecting it and hitting "deploy":
+
+![Deploying UltraVerifier](@site/static/img/how-tos/solidity_verifier_5.png)
+
+A contract will show up in the "Deployed Contracts" section, where we can retrieve the Verification Key Hash. This is particularly useful for double-checking that the deployer contract is the correct one.
+
+:::note
+
+Why "UltraVerifier"?
+
+To be precise, the Noir compiler (`nargo`) doesn't generate the verifier contract directly. It compiles the Noir code into an intermediate language (ACIR), which is then executed by the backend. So it is the backend that returns the verifier smart contract, not Noir.
+
+In this case, the Barretenberg Backend uses the UltraPlonk proving system, hence the "UltraVerifier" name.
+
+:::
+
+## Step 4 - Verifying
+
+To verify a proof using the Solidity verifier contract, we call the `verify` function in this extended contract:
+
+```solidity
+function verify(bytes calldata _proof, bytes32[] calldata _publicInputs) external view returns (bool)
+```
+
+When using the default example in the [Hello Noir](../getting_started/hello_noir/index.md) guide, the easiest way to confirm that the verifier contract is doing its job is by calling the `verify` function via remix with the required parameters. Note that the public inputs must be passed in separately to the rest of the proof so we must split the proof as returned from `bb`.
+
+First generate a proof with `bb` at the location `./proof` using the steps in [get started](../getting_started/hello_noir/index.md), this proof is in a binary format but we want to convert it into a hex string to pass into Remix, this can be done with the
+
+```bash
+# This value must be changed to match the number of public inputs (including return values!) in your program.
+NUM_PUBLIC_INPUTS=1
+PUBLIC_INPUT_BYTES=32*NUM_PUBLIC_INPUTS
+HEX_PUBLIC_INPUTS=$(head -c $PUBLIC_INPUT_BYTES ./proof | od -An -v -t x1 | tr -d $' \n')
+HEX_PROOF=$(tail -c +$(($PUBLIC_INPUT_BYTES + 1)) ./proof | od -An -v -t x1 | tr -d $' \n')
+
+echo "Public inputs:"
+echo $HEX_PUBLIC_INPUTS
+
+echo "Proof:"
+echo "0x$HEX_PROOF"
+```
+
+Remix expects that the public inputs will be split into an array of `bytes32` values so `HEX_PUBLIC_INPUTS` needs to be split up into 32 byte chunks which are prefixed with `0x` accordingly.
+
+A programmatic example of how the `verify` function is called can be seen in the example zk voting application [here](https://github.com/noir-lang/noir-examples/blob/33e598c257e2402ea3a6b68dd4c5ad492bce1b0a/foundry-voting/src/zkVote.sol#L35):
+
+```solidity
+function castVote(bytes calldata proof, uint proposalId, uint vote, bytes32 nullifierHash) public returns (bool) {
+  // ...
+  bytes32[] memory publicInputs = new bytes32[](4);
+  publicInputs[0] = merkleRoot;
+  publicInputs[1] = bytes32(proposalId);
+  publicInputs[2] = bytes32(vote);
+  publicInputs[3] = nullifierHash;
+  require(verifier.verify(proof, publicInputs), "Invalid proof");
+```
+
+:::info[Return Values]
+
+A circuit doesn't have the concept of a return value. Return values are just syntactic sugar in Noir.
+
+Under the hood, the return value is passed as an input to the circuit and is checked at the end of the circuit program.
+
+For example, if you have Noir program like this:
+
+```rust
+fn main(
+    // Public inputs
+    pubkey_x: pub Field,
+    pubkey_y: pub Field,
+    // Private inputs
+    priv_key: Field,
+) -> pub Field
+```
+
+the `verify` function will expect the public inputs array (second function parameter) to be of length 3, the two inputs and the return value.
+
+Passing only two inputs will result in an error such as `PUBLIC_INPUT_COUNT_INVALID(3, 2)`.
+
+In this case, the inputs parameter to `verify` would be an array ordered as `[pubkey_x, pubkey_y, return`.
+
+:::
+
+:::tip[Structs]
+
+You can pass structs to the verifier contract. They will be flattened so that the array of inputs is 1-dimensional array.
+
+For example, consider the following program:
+
+```rust
+struct Type1 {
+  val1: Field,
+  val2: Field,
+}
+
+struct Nested {
+  t1: Type1,
+  is_true: bool,
+}
+
+fn main(x: pub Field, nested: pub Nested, y: pub Field) {
+  //...
+}
+```
+
+The order of these inputs would be flattened to: `[x, nested.t1.val1, nested.t1.val2, nested.is_true, y]`
+
+:::
+
+The other function you can call is our entrypoint `verify` function, as defined above.
+
+:::tip
+
+It's worth noticing that the `verify` function is actually a `view` function. A `view` function does not alter the blockchain state, so it doesn't need to be distributed (i.e. it will run only on the executing node), and therefore doesn't cost any gas.
+
+This can be particularly useful in some situations. If Alice generated a proof and wants Bob to verify its correctness, Bob doesn't need to run Nargo, NoirJS, or any Noir specific infrastructure. He can simply make a call to the blockchain with the proof and verify it is correct without paying any gas.
+
+It would be incorrect to say that a Noir proof verification costs any gas at all. However, most of the time the result of `verify` is used to modify state (for example, to update a balance, a game state, etc). In that case the whole network needs to execute it, which does incur gas costs (calldata and execution, but not storage).
+
+:::
+
+## A Note on EVM chains
+
+Noir proof verification requires the ecMul, ecAdd and ecPairing precompiles. Not all EVM chains support EC Pairings, notably some of the ZK-EVMs. This means that you won't be able to use the verifier contract in all of them. You can find an incomplete list of which EVM chains support these precompiles [here](https://www.evmdiff.com/features?feature=precompiles).
+
+For example, chains like `zkSync ERA` and `Polygon zkEVM` do not currently support these precompiles, so proof verification via Solidity verifier contracts won't work. Here's a quick list of EVM chains that have been tested and are known to work:
+
+- Optimism
+- Arbitrum
+- Polygon PoS
+- Scroll
+- Celo
+- BSC
+- Blast L2
+- Avalanche C-Chain
+- Mode
+- Linea
+- Moonbeam
+
+If you test any other chains, please open a PR on this page to update the list. See [this doc](https://github.com/noir-lang/noir-starter/tree/main/with-foundry#testing-on-chain) for more info about testing verifier contracts on different EVM chains.
+
+## What's next
+
+Now that you know how to call a Noir Solidity Verifier on a smart contract using Remix, you should be comfortable with using it with some programmatic frameworks, such as [hardhat](https://github.com/noir-lang/noir-starter/tree/main/vite-hardhat) and [foundry](https://github.com/noir-lang/noir-starter/tree/main/with-foundry).
+
+You can find other tools, examples, boilerplates and libraries in the [awesome-noir](https://github.com/noir-lang/awesome-noir) repository.
+
+You should also be ready to write and deploy your first NoirJS app and start generating proofs on websites, phones, and NodeJS environments! Head on to the [NoirJS tutorial](../tutorials/noirjs_app.md) to learn how to do that.
diff --git a/docs/versioned_docs/version-v0.35.0/how_to/merkle-proof.mdx b/docs/versioned_docs/version-v0.35.0/how_to/merkle-proof.mdx
new file mode 100644
index 00000000000..0a128adb2de
--- /dev/null
+++ b/docs/versioned_docs/version-v0.35.0/how_to/merkle-proof.mdx
@@ -0,0 +1,48 @@
+---
+title: Prove Merkle Tree Membership
+description:
+  Learn how to use merkle membership proof in Noir to prove that a given leaf is a member of a
+  merkle tree with a specified root, at a given index.
+keywords:
+  [merkle proof, merkle membership proof, Noir, rust, hash function, Pedersen, sha256, merkle tree]
+sidebar_position: 4
+---
+
+Let's walk through an example of a merkle membership proof in Noir that proves that a given leaf is
+in a merkle tree.
+
+```rust
+
+fn main(message : [Field; 62], index : Field, hashpath : [Field; 40], root : Field) {
+    let leaf = std::hash::hash_to_field(message.as_slice());
+    let merkle_root = std::merkle::compute_merkle_root(leaf, index, hashpath);
+    assert(merkle_root == root);
+}
+
+```
+
+The message is hashed using `hash_to_field`. The specific hash function that is being used is chosen
+by the backend. The only requirement is that this hash function can heuristically be used as a
+random oracle. If only collision resistance is needed, then one can call `std::hash::pedersen_hash`
+instead.
+
+```rust
+let leaf = std::hash::hash_to_field(message.as_slice());
+```
+
+The leaf is then passed to a compute_merkle_root function with the root, index and hashpath. The returned root can then be asserted to be the same as the provided root.
+
+```rust
+let merkle_root = std::merkle::compute_merkle_root(leaf, index, hashpath);
+assert (merkle_root == root);
+```
+
+> **Note:** It is possible to re-implement the merkle tree implementation without standard library.
+> However, for most usecases, it is enough. In general, the standard library will always opt to be
+> as conservative as possible, while striking a balance with efficiency.
+
+An example, the merkle membership proof, only requires a hash function that has collision
+resistance, hence a hash function like Pedersen is allowed, which in most cases is more efficient
+than the even more conservative sha256.
+
+[View an example on the starter repo](https://github.com/noir-lang/noir-examples/blob/3ea09545cabfa464124ec2f3ea8e60c608abe6df/stealthdrop/circuits/src/main.nr#L20)
diff --git a/docs/versioned_docs/version-v0.35.0/how_to/using-devcontainers.mdx b/docs/versioned_docs/version-v0.35.0/how_to/using-devcontainers.mdx
new file mode 100644
index 00000000000..727ec6ca667
--- /dev/null
+++ b/docs/versioned_docs/version-v0.35.0/how_to/using-devcontainers.mdx
@@ -0,0 +1,110 @@
+---
+title: Developer Containers and Codespaces
+description: "Learn how to set up a devcontainer in your GitHub repository for a seamless coding experience with Codespaces. Follow our easy 8-step guide to create your own Noir environment without installing Nargo locally."
+keywords: ["Devcontainer", "Codespaces", "GitHub", "Noir Environment", "Docker Image", "Development Environment", "Remote Coding", "GitHub Codespaces", "Noir Programming", "Nargo", "VSCode Extensions", "Noirup"]
+sidebar_position: 1
+---
+
+Adding a developer container configuration file to your Noir project is one of the easiest way to unlock coding in browser.
+
+## What's a devcontainer after all?
+
+A [Developer Container](https://containers.dev/) (devcontainer for short) is a Docker image that comes preloaded with tools, extensions, and other tools you need to quickly get started or continue a project, without having to install Nargo locally. Think of it as a development environment in a box.
+
+There are many advantages to this:
+
+- It's platform and architecture agnostic
+- You don't need to have an IDE installed, or Nargo, or use a terminal at all
+- It's safer for using on a public machine or public network
+
+One of the best ways of using devcontainers is... not using your machine at all, for maximum control, performance, and ease of use.
+Enter Codespaces.
+
+## Codespaces
+
+If a devcontainer is just a Docker image, then what stops you from provisioning a `p3dn.24xlarge` AWS EC2 instance with 92 vCPUs and 768 GiB RAM and using it to prove your 10-gate SNARK proof? 
+
+Nothing! Except perhaps the 30-40$ per hour it will cost you. 
+
+The problem is that provisioning takes time, and I bet you don't want to see the AWS console every time you want to code something real quick.
+
+Fortunately, there's an easy and free way to get a decent remote machine ready and loaded in less than 2 minutes: Codespaces. [Codespaces is a Github feature](https://github.com/features/codespaces) that allows you to code in a remote machine by using devcontainers, and it's pretty cool:
+
+- You can start coding Noir in less than a minute
+- It uses the resources of a remote machine, so you can code on your grandma's phone if needed be
+- It makes it easy to share work with your frens
+- It's fully reusable, you can stop and restart whenever you need to
+
+:::info
+
+Don't take out your wallet just yet. Free GitHub accounts get about [15-60 hours of coding](https://github.com/features/codespaces) for free per month, depending on the size of your provisioned machine.
+
+:::
+
+## Tell me it's _actually_ easy
+
+It is!
+
+Github comes with a default codespace and you can use it to code your own devcontainer. That's exactly what we will be doing in this guide.
+
+<video width="100%" height="auto" controls>
+  <source src={require('@site/static/video/how-tos/devcontainer.mp4').default} type="video/mp4" />
+  Your browser does not support the video tag.
+</video>
+
+8 simple steps:
+
+#### 1. <a href="https://github.com/new" target="_blank">Create a new repository</a> on GitHub.
+
+#### 2. Click "Start coding with Codespaces". This will use the default image.
+
+#### 3. Create a folder called `.devcontainer` in the root of your repository.
+
+#### 4. Create a Dockerfile in that folder, and paste the following code:
+
+```docker
+FROM --platform=linux/amd64 node:lts-bookworm-slim
+SHELL ["/bin/bash", "-c"]
+RUN apt update && apt install -y curl bash git tar gzip libc++-dev
+RUN curl -L https://raw.githubusercontent.com/noir-lang/noirup/main/install | bash
+ENV PATH="/root/.nargo/bin:$PATH"
+RUN noirup
+ENTRYPOINT ["nargo"]
+```
+#### 5. Create a file called `devcontainer.json` in the same folder, and paste the following code:
+
+```json
+{
+ "name": "Noir on Codespaces",
+ "build": {
+    "context": ".",
+    "dockerfile": "Dockerfile"
+  },
+  "customizations": {
+    "vscode": {
+      "extensions": ["noir-lang.vscode-noir"]
+    }
+  }
+}
+```
+#### 6. Commit and push your changes
+
+This will pull the new image and build it, so it could take a minute or so
+
+#### 8. Done! 
+Just wait for the build to finish, and there's your easy Noir environment.
+
+
+Refer to [noir-starter](https://github.com/noir-lang/noir-starter/) as an example of how devcontainers can be used together with codespaces.
+
+
+
+## How do I use it?
+
+Using the codespace is obviously much easier than setting it up. 
+Just navigate to your repository and click "Code" -> "Open with Codespaces". It should take a few seconds to load, and you're ready to go.
+
+:::info
+
+If you really like the experience, you can add a badge to your readme, links to existing codespaces, and more. 
+Check out the [official docs](https://docs.github.com/en/codespaces/setting-up-your-project-for-codespaces/setting-up-your-repository/facilitating-quick-creation-and-resumption-of-codespaces) for more info.
diff --git a/docs/versioned_docs/version-v0.35.0/index.mdx b/docs/versioned_docs/version-v0.35.0/index.mdx
new file mode 100644
index 00000000000..a6bd306f91d
--- /dev/null
+++ b/docs/versioned_docs/version-v0.35.0/index.mdx
@@ -0,0 +1,67 @@
+---
+title: Noir Lang
+hide_title: true
+description:
+  Learn about the public alpha release of Noir, a domain specific language heavily influenced by Rust that compiles to
+  an intermediate language which can be compiled to an arithmetic circuit or a rank-1 constraint system.
+keywords:
+    [Noir,
+    Domain Specific Language,
+    Rust,
+    Intermediate Language,
+    Arithmetic Circuit,
+    Rank-1 Constraint System,
+    Ethereum Developers,
+    Protocol Developers,
+    Blockchain Developers,
+    Proving System,
+    Smart Contract Language]
+sidebar_position: 0
+---
+
+import Tabs from '@theme/Tabs';
+import TabItem from '@theme/TabItem';
+
+<img src={require("@site/static/img/logo.png").default} style={{display: "block", width: "50%", margin: "2rem auto"}} alt="Noir Logo"  />
+
+Noir is an open-source Domain-Specific Language for safe and seamless construction of privacy-preserving Zero-Knowledge programs, requiring no previous knowledge on the underlying mathematics or cryptography.
+
+ZK programs are programs that can generate short proofs of statements without revealing all inputs to the statements. You can read more about Zero-Knowledge Proofs [here](https://dev.to/spalladino/a-beginners-intro-to-coding-zero-knowledge-proofs-c56).
+
+## What's new about Noir?
+
+Noir works differently from most ZK languages by taking a two-pronged path. First, it compiles the program to an adaptable intermediate language known as ACIR. From there, depending on a given project's needs, ACIR can be further compiled into an arithmetic circuit for integration with the proving backend.
+
+:::info
+
+Noir is backend agnostic, which means it makes no assumptions on which proving backend powers the ZK proof. Being the language that powers [Aztec Contracts](https://docs.aztec.network/developers/contracts/main), it defaults to Aztec's Barretenberg proving backend.
+
+However, the ACIR output can be transformed to be compatible with other PLONK-based backends, or into a [rank-1 constraint system](https://www.rareskills.io/post/rank-1-constraint-system) suitable for backends such as Arkwork's Marlin.
+
+:::
+
+## Who is Noir for?
+
+Noir can be used both in complex cloud-based backends and in user's smartphones, requiring no knowledge on the underlying math or cryptography. From authorization systems that keep a password in the user's device, to complex on-chain verification of recursive proofs, Noir is designed to abstract away complexity without any significant overhead. Here are some examples of situations where Noir can be used:
+
+<Tabs>
+  <TabItem value="Aztec Contracts" label="Aztec Contracts" default>
+    <img src={require("@site/static/img/aztec_logo.png").default} style={{display: "block", width: "50%", margin: "2rem auto"}} alt="Noir Logo"  />
+    
+    Aztec Contracts leverage Noir to allow for the storage and execution of private information. Writing an Aztec Contract is as easy as writing Noir, and Aztec developers can easily interact with the network storage and execution through the [Aztec.nr](https://docs.aztec.network/developers/contracts/main) library.
+  </TabItem>
+  <TabItem value="Solidity Verifiers" label="Solidity Verifiers">
+    <img src={require("@site/static/img/solidity_verifier_ex.png").default} style={{display: "block", margin: "2rem auto"}} alt="Soliditry Verifier Example"  />
+    Noir can auto-generate Solidity verifier contracts that verify Noir proofs. This allows for non-interactive verification of proofs containing private information in an immutable system. This feature powers a multitude of use-case scenarios, from P2P chess tournaments, to [Aztec Layer-2 Blockchain](https://docs.aztec.network/)
+  </TabItem>
+  <TabItem value="Full-Stack Development" label="Full-Stack Development">
+    Aztec Labs developed NoirJS, an easy interface to generate and verify Noir proofs in a Javascript environment. This allows for Noir to be used in webpages, mobile apps, games, and any other environment supporting JS execution in a standalone manner.
+  </TabItem>
+</Tabs>
+
+
+## Libraries
+
+Noir is meant to be easy to extend by simply importing Noir libraries just like in Rust. 
+The [awesome-noir repo](https://github.com/noir-lang/awesome-noir#libraries) is a collection of libraries developed by the Noir community.
+Writing a new library is easy and makes code be composable and easy to reuse. See the section on [dependencies](noir/modules_packages_crates/dependencies.md) for more information.
diff --git a/docs/versioned_docs/version-v0.35.0/migration_notes.md b/docs/versioned_docs/version-v0.35.0/migration_notes.md
new file mode 100644
index 00000000000..6bd740024e5
--- /dev/null
+++ b/docs/versioned_docs/version-v0.35.0/migration_notes.md
@@ -0,0 +1,105 @@
+---
+title: Migration notes
+description: Read about migration notes from previous versions, which could solve problems while updating
+keywords: [Noir, notes, migration, updating, upgrading]
+---
+
+Noir is in full-speed development. Things break fast, wild, and often. This page attempts to leave some notes on errors you might encounter when upgrading and how to resolve them until proper patches are built.
+
+### `backend encountered an error: libc++.so.1`
+
+Depending on your OS, you may encounter the following error when running `nargo prove` for the first time:
+
+```text
+The backend encountered an error: "/home/codespace/.nargo/backends/acvm-backend-barretenberg/backend_binary: error while loading shared libraries: libc++.so.1: cannot open shared object file: No such file or directory\n"
+```
+
+Install the `libc++-dev` library with:
+
+```bash
+sudo apt install libc++-dev
+```
+
+## ≥0.19
+
+### Enforcing `compiler_version`
+
+From this version on, the compiler will check for the `compiler_version` field in `Nargo.toml`, and will error if it doesn't match the current Nargo version in use.
+
+To update, please make sure this field in `Nargo.toml` matches the output of `nargo --version`.
+
+## ≥0.14
+
+The index of the [for loops](noir/concepts/control_flow.md#loops) is now of type `u64` instead of `Field`. An example refactor would be:
+
+```rust
+for i in 0..10 {
+    let i = i as Field;
+}
+```
+
+## ≥v0.11.0 and Nargo backend
+
+From this version onwards, Nargo starts managing backends through the `nargo backend` command. Upgrading to the versions per usual steps might lead to:
+
+### `backend encountered an error`
+
+This is likely due to the existing locally installed version of proving backend (e.g. barretenberg) is incompatible with the version of Nargo in use.
+
+To fix the issue:
+
+1. Uninstall the existing backend
+
+```bash
+nargo backend uninstall acvm-backend-barretenberg
+```
+
+You may replace _acvm-backend-barretenberg_ with the name of your backend listed in `nargo backend ls` or in ~/.nargo/backends.
+
+2. Reinstall a compatible version of the proving backend.
+
+If you are using the default barretenberg backend, simply run:
+
+```
+nargo prove
+```
+
+with your Noir program.
+
+This will trigger the download and installation of the latest version of barretenberg compatible with your Nargo in use.
+
+### `backend encountered an error: illegal instruction`
+
+On certain Intel-based systems, an `illegal instruction` error may arise due to incompatibility of barretenberg with certain CPU instructions.
+
+To fix the issue:
+
+1. Uninstall the existing backend
+
+```bash
+nargo backend uninstall acvm-backend-barretenberg
+```
+
+You may replace _acvm-backend-barretenberg_ with the name of your backend listed in `nargo backend ls` or in ~/.nargo/backends.
+
+2. Reinstall a compatible version of the proving backend.
+
+If you are using the default barretenberg backend, simply run:
+
+```
+nargo backend install acvm-backend-barretenberg https://github.com/noir-lang/barretenberg-js-binary/raw/master/run-bb.tar.gz
+```
+
+This downloads and installs a specific bb.js based version of barretenberg binary from GitHub.
+
+The gzipped file is running [this bash script](https://github.com/noir-lang/barretenberg-js-binary/blob/master/run-bb-js.sh), where we need to gzip it as the Nargo currently expect the backend to be zipped up.
+
+Then run:
+
+```
+DESIRED_BINARY_VERSION=0.8.1 nargo info
+```
+
+This overrides the bb native binary with a bb.js node application instead, which should be compatible with most if not all hardware. This does come with the drawback of being generally slower than native binary.
+
+0.8.1 indicates bb.js version 0.8.1, so if you change that it will update to a different version or the default version in the script if none was supplied.
diff --git a/docs/versioned_docs/version-v0.35.0/noir/concepts/_category_.json b/docs/versioned_docs/version-v0.35.0/noir/concepts/_category_.json
new file mode 100644
index 00000000000..7da08f8a8c5
--- /dev/null
+++ b/docs/versioned_docs/version-v0.35.0/noir/concepts/_category_.json
@@ -0,0 +1,6 @@
+{
+    "label": "Concepts",
+    "position": 0,
+    "collapsible": true,
+    "collapsed": true
+}
\ No newline at end of file
diff --git a/docs/versioned_docs/version-v0.35.0/noir/concepts/assert.md b/docs/versioned_docs/version-v0.35.0/noir/concepts/assert.md
new file mode 100644
index 00000000000..2132de42072
--- /dev/null
+++ b/docs/versioned_docs/version-v0.35.0/noir/concepts/assert.md
@@ -0,0 +1,78 @@
+---
+title: Assert Function
+description:
+  Learn about the `assert` and `static_assert` functions in Noir, which can be used to explicitly
+  constrain the predicate or comparison expression that follows to be true, and what happens if
+  the expression is false at runtime or compile-time, respectively.
+keywords: [Noir programming language, assert statement, predicate expression, comparison expression]
+sidebar_position: 4
+---
+
+Noir includes a special `assert` function which will explicitly constrain the predicate/comparison
+expression that follows to be true. If this expression is false at runtime, the program will fail to
+be proven. Example:
+
+```rust
+fn main(x : Field, y : Field) {
+    assert(x == y);
+}
+```
+
+> Assertions only work for predicate operations, such as `==`. If there's any ambiguity on the operation, the program will fail to compile. For example, it is unclear if `assert(x + y)` would check for `x + y == 0` or simply would return `true`.
+
+You can optionally provide a message to be logged when the assertion fails:
+
+```rust
+assert(x == y, "x and y are not equal");
+```
+
+Aside string literals, the optional message can be a format string or any other type supported as input for Noir's [print](../standard_library/logging.md) functions. This feature lets you incorporate runtime variables into your failed assertion logs:
+
+```rust
+assert(x == y, f"Expected x == y, but got {x} == {y}");
+```
+
+Using a variable as an assertion message directly:
+
+```rust
+struct myStruct {
+  myField: Field
+}
+
+let s = myStruct { myField: y };
+assert(s.myField == x, s);
+```
+
+There is also a special `static_assert` function that behaves like `assert`,
+but that runs at compile-time.
+
+```rust
+fn main(xs: [Field; 3]) {
+    let x = 2 + 2;
+    let y = 4;
+    static_assert(x == y, "expected 2 + 2 to equal 4");
+
+    // This passes since the length of `xs` is known at compile-time
+    static_assert(xs.len() == 3, "expected the input to have 3 elements");
+}
+```
+
+This function fails when passed a dynamic (run-time) argument:
+
+```rust
+fn main(x : Field, y : Field) {
+    // this fails because `x` is not known at compile-time
+    static_assert(x == 2, "expected x to be known at compile-time and equal to 2");
+
+    let mut example_slice = &[];
+    if y == 4 {
+        example_slice = example_slice.push_back(0);
+    }
+
+    // This fails because the length of `example_slice` is not known at
+    // compile-time
+    let error_message = "expected an empty slice, known at compile-time";
+    static_assert(example_slice.len() == 0, error_message);
+}
+```
+
diff --git a/docs/versioned_docs/version-v0.35.0/noir/concepts/comments.md b/docs/versioned_docs/version-v0.35.0/noir/concepts/comments.md
new file mode 100644
index 00000000000..b51a85f5c94
--- /dev/null
+++ b/docs/versioned_docs/version-v0.35.0/noir/concepts/comments.md
@@ -0,0 +1,33 @@
+---
+title: Comments
+description:
+  Learn how to write comments in Noir programming language. A comment is a line of code that is
+  ignored by the compiler, but it can be read by programmers. Single-line and multi-line comments
+  are supported in Noir.
+keywords: [Noir programming language, comments, single-line comments, multi-line comments]
+sidebar_position: 10
+---
+
+A comment is a line in your codebase which the compiler ignores, however it can be read by
+programmers.
+
+Here is a single line comment:
+
+```rust
+// This is a comment and is ignored
+```
+
+`//` is used to tell the compiler to ignore the rest of the line.
+
+Noir also supports multi-line block comments. Start a block comment with `/*` and end the block with `*/`.
+
+Noir does not natively support doc comments. You may be able to use [Rust doc comments](https://doc.rust-lang.org/reference/comments.html) in your code to leverage some Rust documentation build tools with Noir code.
+
+```rust
+/*
+  This is a block comment describing a complex function.
+*/
+fn main(x : Field, y : pub Field) {
+    assert(x != y);
+}
+```
diff --git a/docs/versioned_docs/version-v0.35.0/noir/concepts/comptime.md b/docs/versioned_docs/version-v0.35.0/noir/concepts/comptime.md
new file mode 100644
index 00000000000..50d7e686083
--- /dev/null
+++ b/docs/versioned_docs/version-v0.35.0/noir/concepts/comptime.md
@@ -0,0 +1,440 @@
+---
+title: Compile-time Code & Metaprogramming
+description: Learn how to use metaprogramming in Noir to create macros or derive your own traits
+keywords: [Noir, comptime, compile-time, metaprogramming, macros, quote, unquote]
+sidebar_position: 15
+---
+
+# Overview
+
+Metaprogramming in Noir is comprised of three parts:
+1. `comptime` code
+2. Quoting and unquoting
+3. The metaprogramming API in `std::meta`
+
+Each of these are explained in more detail in the next sections but the wide picture is that
+`comptime` allows us to write code which runs at compile-time. In this `comptime` code we
+can quote and unquote snippets of the program, manipulate them, and insert them in other
+parts of the program. Comptime functions which do this are said to be macros. Additionally,
+there's a compile-time API of built-in types and functions provided by the compiler which allows
+for greater analysis and modification of programs.
+
+---
+
+# Comptime
+
+`comptime` is a new keyword in Noir which marks an item as executing or existing at compile-time. It can be used in several ways:
+
+- `comptime fn` to define functions which execute exclusively during compile-time.
+- `comptime global` to define a global variable which is evaluated at compile-time.
+  - Unlike runtime globals, `comptime global`s can be mutable.
+- `comptime { ... }` to execute a block of statements during compile-time.
+- `comptime let` to define a variable whose value is evaluated at compile-time.
+- `comptime for` to run a for loop at compile-time. Syntax sugar for `comptime { for .. }`.
+
+## Scoping
+
+Note that while in a `comptime` context, any runtime variables _local to the current function_ are never visible.
+
+## Evaluating
+
+Evaluation rules of `comptime` follows the normal unconstrained evaluation rules for other Noir code. There are a few things to note though:
+
+- Certain built-in functions may not be available, although more may be added over time.
+- Evaluation order of global items is currently unspecified. For example, given the following two functions we can't guarantee
+which `println` will execute first. The ordering of the two printouts will be arbitrary, but should be stable across multiple compilations with the same `nargo` version as long as the program is also unchanged.
+
+```rust
+fn one() {
+    comptime { println("one"); }
+}
+
+fn two() {
+    comptime { println("two"); }
+}
+```
+
+- Since evaluation order is unspecified, care should be taken when using mutable globals so that they do not rely on a particular ordering.
+For example, using globals to generate unique ids should be fine but relying on certain ids always being produced (especially after edits to the program) should be avoided.
+- Although most ordering of globals is unspecified, two are:
+  - Dependencies of a crate will always be evaluated before the dependent crate.
+  - Any annotations on a function will be run before the function itself is resolved. This is to allow the annotation to modify the function if necessary. Note that if the
+    function itself was called at compile-time previously, it will already be resolved and cannot be modified. To prevent accidentally calling functions you wish to modify
+    at compile-time, it may be helpful to sort your `comptime` annotation functions into a different crate along with any dependencies they require.
+
+## Lowering
+
+When a `comptime` value is used in runtime code it must be lowered into a runtime value. This means replacing the expression with the literal that it evaluated to. For example, the code:
+
+```rust
+struct Foo { array: [Field; 2], len: u32 }
+
+fn main() {
+    println(comptime {
+        let mut foo = std::mem::zeroed::<Foo>();
+        foo.array[0] = 4;
+        foo.len = 1;
+        foo
+    });
+}
+```
+
+will be converted to the following after `comptime` expressions are evaluated:
+
+```rust
+struct Foo { array: [Field; 2], len: u32 }
+
+fn main() {
+    println(Foo { array: [4, 0], len: 1 });
+}
+```
+
+Not all types of values can be lowered. For example, `Type`s and `TypeDefinition`s (among other types) cannot be lowered at all.
+
+```rust
+fn main() {
+    // There's nothing we could inline here to create a Type value at runtime
+    // let _ = get_type!();
+}
+
+comptime fn get_type() -> Type { ... }
+```
+
+---
+
+# (Quasi) Quote
+
+Macros in Noir are `comptime` functions which return code as a value which is inserted into the call site when it is lowered there.
+A code value in this case is of type `Quoted` and can be created by a `quote { ... }` expression.
+More specifically, the code value `quote` creates is a token stream - a representation of source code as a series of words, numbers, string literals, or operators.
+For example, the expression `quote { Hi "there reader"! }` would quote three tokens: the word "hi", the string "there reader", and an exclamation mark.
+You'll note that snippets that would otherwise be invalid syntax can still be quoted.
+
+When a `Quoted` value is used in runtime code, it is lowered into a `quote { ... }` expression. Since this expression is only valid
+in compile-time code however, we'd get an error if we tried this. Instead, we can use macro insertion to insert each token into the
+program at that point, and parse it as an expression. To do this, we have to add a `!` after the function name returning the `Quoted` value.
+If the value was created locally and there is no function returning it, `std::meta::unquote!(_)` can be used instead.
+Calling such a function at compile-time without `!` will just return the `Quoted` value to be further manipulated. For example:
+
+```rust title="quote-example" showLineNumbers 
+comptime fn quote_one() -> Quoted {
+        quote { 1 }
+    }
+
+    #[test]
+    fn returning_versus_macro_insertion() {
+        comptime
+        {
+            // let _a: Quoted = quote { 1 };
+            let _a: Quoted = quote_one();
+
+            // let _b: Field = 1;
+            let _b: Field = quote_one!();
+
+            // Since integers default to fields, if we
+            // want a different type we have to explicitly cast
+            // let _c: i32 = 1 as i32;
+            let _c: i32 = quote_one!() as i32;
+        }
+    }
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/meta/mod.nr#L121-L142" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/meta/mod.nr#L121-L142</a></sub></sup>
+
+
+For those familiar with quoting from other languages (primarily lisps), Noir's `quote` is actually a _quasiquote_.
+This means we can escape the quoting by using the unquote operator to splice values in the middle of quoted code.
+
+# Unquote
+
+The unquote operator `$` is usable within a `quote` expression.
+It takes a variable as an argument, evaluates the variable, and splices the resulting value into the quoted token stream at that point. For example,
+
+```rust
+comptime {
+    let x = 1 + 2;
+    let y = quote { $x + 4 };
+}
+```
+
+The value of `y` above will be the token stream containing `3`, `+`, and `4`. We can also use this to combine `Quoted` values into larger token streams:
+
+```rust
+comptime {
+    let x = quote { 1 + 2 };
+    let y = quote { $x + 4 };
+}
+```
+
+The value of `y` above is now the token stream containing five tokens: `1 + 2 + 4`.
+
+Note that to unquote something, a variable name _must_ follow the `$` operator in a token stream.
+If it is an expression (even a parenthesized one), it will do nothing. Most likely a parse error will be given when the macro is later unquoted.
+
+Unquoting can also be avoided by escaping the `$` with a backslash:
+
+```
+comptime {
+    let x = quote { 1 + 2 };
+
+    // y contains the four tokens: `$x + 4`
+    let y = quote { \$x + 4 };
+}
+```
+
+---
+
+# Annotations
+
+Annotations provide a way to run a `comptime` function on an item in the program.
+When you use an annotation, the function with the same name will be called with that item as an argument:
+
+```rust
+#[my_struct_annotation]
+struct Foo {}
+
+comptime fn my_struct_annotation(s: StructDefinition) {
+    println("Called my_struct_annotation!");
+}
+
+#[my_function_annotation]
+fn foo() {}
+
+comptime fn my_function_annotation(f: FunctionDefinition) {
+    println("Called my_function_annotation!");
+}
+```
+
+Anything returned from one of these functions will be inserted at top-level along with the original item.
+Note that expressions are not valid at top-level so you'll get an error trying to return `3` or similar just as if you tried to write a program containing `3; struct Foo {}`.
+You can insert other top-level items such as trait impls, structs, or functions this way though.
+For example, this is the mechanism used to insert additional trait implementations into the program when deriving a trait impl from a struct:
+
+```rust title="derive-field-count-example" showLineNumbers 
+trait FieldCount {
+        fn field_count() -> u32;
+    }
+
+    #[derive_field_count]
+    struct Bar { x: Field, y: [Field; 2] }
+
+    comptime fn derive_field_count(s: StructDefinition) -> Quoted {
+        let typ = s.as_type();
+        let field_count = s.fields().len();
+        quote {
+            impl FieldCount for $typ {
+                fn field_count() -> u32 {
+                    $field_count
+                }
+            }
+        }
+    }
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/meta/mod.nr#L144-L163" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/meta/mod.nr#L144-L163</a></sub></sup>
+
+
+## Calling annotations with additional arguments
+
+Arguments may optionally be given to annotations.
+When this is done, these additional arguments are passed to the annotation function after the item argument.
+
+```rust title="annotation-arguments-example" showLineNumbers 
+#[assert_field_is_type(quote { i32 }.as_type())]
+    struct MyStruct { my_field: i32 }
+
+    comptime fn assert_field_is_type(s: StructDefinition, typ: Type) {
+        // Assert the first field in `s` has type `typ`
+        let fields = s.fields();
+        assert_eq(fields[0].1, typ);
+    }
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/meta/mod.nr#L165-L174" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/meta/mod.nr#L165-L174</a></sub></sup>
+
+
+We can also take any number of arguments by adding the `varargs` annotation:
+
+```rust title="annotation-varargs-example" showLineNumbers 
+#[assert_three_args(1, 2, 3)]
+    struct MyOtherStruct { my_other_field: u32 }
+
+    #[varargs]
+    comptime fn assert_three_args(_s: StructDefinition, args: [Field]) {
+        assert_eq(args.len(), 3);
+    }
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/meta/mod.nr#L176-L184" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/meta/mod.nr#L176-L184</a></sub></sup>
+
+
+---
+
+# Comptime API
+
+Although `comptime`, `quote`, and unquoting provide a flexible base for writing macros,
+Noir's true metaprogramming ability comes from being able to interact with the compiler through a compile-time API.
+This API can be accessed through built-in functions in `std::meta` as well as on methods of several `comptime` types.
+
+The following is an incomplete list of some `comptime` types along with some useful methods on them.
+
+- `Quoted`: A token stream
+- `Type`: The type of a Noir type
+  - `fn implements(self, constraint: TraitConstraint) -> bool`
+    - Returns true if `self` implements the given trait constraint
+- `Expr`: A syntactically valid expression. Can be used to recur on a program's parse tree to inspect how it is structured.
+  - Methods:
+    - `fn as_function_call(self) -> Option<(Expr, [Expr])>`
+      - If this is a function call expression, return `(function, arguments)`
+    - `fn as_block(self) -> Option<[Expr]>`
+      - If this is a block, return each statement in the block
+- `FunctionDefinition`: A function definition
+  - Methods:
+    - `fn parameters(self) -> [(Quoted, Type)]`
+      - Returns a slice of `(name, type)` pairs for each parameter
+- `StructDefinition`: A struct definition
+  - Methods:
+    - `fn as_type(self) -> Type`
+      - Returns this `StructDefinition` as a `Type`. Any generics are kept as-is
+    - `fn generics(self) -> [Quoted]`
+      - Return the name of each generic on this struct
+    - `fn fields(self) -> [(Quoted, Type)]`
+      - Return the name and type of each field
+- `TraitConstraint`: A trait constraint such as `From<Field>`
+- `TypedExpr`: A type-checked expression.
+- `UnresolvedType`: A syntactic notation that refers to a Noir type that hasn't been resolved yet
+
+There are many more functions available by exploring the `std::meta` module and its submodules.
+Using these methods is the key to writing powerful metaprogramming libraries.
+
+## `#[use_callers_scope]`
+
+Since certain functions such as `Quoted::as_type`, `Expression::as_type`, or `Quoted::as_trait_constraint` will attempt
+to resolve their contents in a particular scope - it can be useful to change the scope they resolve in. By default
+these functions will resolve in the current function's scope which is usually the attribute function they are called in.
+If you're working on a library however, this may be a completely different module or crate to the item you're trying to
+use the attribute on. If you want to be able to use `Quoted::as_type` to refer to types local to the caller's scope for
+example, you can annotate your attribute function with `#[use_callers_scope]`. This will ensure your attribute, and any
+closures it uses, can refer to anything in the caller's scope. `#[use_callers_scope]` also works recursively. So if both
+your attribute function and a helper function it calls use it, then they can both refer to the same original caller.
+
+---
+
+# Example: Derive
+
+Using all of the above, we can write a `derive` macro that behaves similarly to Rust's but is not built into the language.
+From the user's perspective it will look like this:
+
+```rust
+// Example usage
+#[derive(Default, Eq, Ord)]
+struct MyStruct { my_field: u32 }
+```
+
+To implement `derive` we'll have to create a `comptime` function that accepts
+a variable amount of traits.
+
+```rust title="derive_example" showLineNumbers 
+// These are needed for the unconstrained hashmap we're using to store derive functions
+use crate::collections::umap::UHashMap;
+use crate::hash::BuildHasherDefault;
+use crate::hash::poseidon2::Poseidon2Hasher;
+
+// A derive function is one that given a struct definition can
+// create us a quoted trait impl from it.
+pub type DeriveFunction = fn(StructDefinition) -> Quoted;
+
+// We'll keep a global HANDLERS map to keep track of the derive handler for each trait
+comptime mut global HANDLERS: UHashMap<TraitDefinition, DeriveFunction, BuildHasherDefault<Poseidon2Hasher>> = UHashMap::default();
+
+// Given a struct and a slice of traits to derive, create trait impls for each.
+// This function is as simple as iterating over the slice, checking if we have a trait
+// handler registered for the given trait, calling it, and appending the result.
+#[varargs]
+pub comptime fn derive(s: StructDefinition, traits: [TraitDefinition]) -> Quoted {
+    let mut result = quote {};
+
+    for trait_to_derive in traits {
+        let handler = unsafe {
+            HANDLERS.get(trait_to_derive)
+        };
+        assert(handler.is_some(), f"No derive function registered for `{trait_to_derive}`");
+
+        let trait_impl = handler.unwrap()(s);
+        result = quote { $result $trait_impl };
+    }
+
+    result
+}
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/meta/mod.nr#L31-L65" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/meta/mod.nr#L31-L65</a></sub></sup>
+
+
+Registering a derive function could be done as follows:
+
+```rust title="derive_via" showLineNumbers 
+// To register a handler for a trait, just add it to our handlers map
+pub comptime fn derive_via(t: TraitDefinition, f: DeriveFunction) {
+    HANDLERS.insert(t, f);
+}
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/meta/mod.nr#L67-L74" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/meta/mod.nr#L67-L74</a></sub></sup>
+
+
+```rust title="big-derive-usage-example" showLineNumbers 
+// Finally, to register a handler we call the above function as an annotation
+    // with our handler function.
+    #[derive_via(derive_do_nothing)]
+    trait DoNothing {
+        fn do_nothing(self);
+    }
+
+    comptime fn derive_do_nothing(s: StructDefinition) -> Quoted {
+        // This is simplified since we don't handle generics or where clauses!
+        // In a real example we'd likely also need to introduce each of
+        // `s.generics()` as well as a trait constraint for each generic
+        // to ensure they also implement the trait.
+        let typ = s.as_type();
+        quote {
+            impl DoNothing for $typ {
+                fn do_nothing(self) {
+                    // Traits can't tell us what to do
+                    println("something");
+                }
+            }
+        }
+    }
+
+    // Since `DoNothing` is a simple trait which:
+    // 1. Only has one method
+    // 2. Does not have any generics on the trait itself
+    // We can use `std::meta::make_trait_impl` to help us out.
+    // This helper function will generate our impl for us along with any
+    // necessary where clauses and still provides a flexible interface
+    // for us to work on each field on the struct.
+    comptime fn derive_do_nothing_alt(s: StructDefinition) -> Quoted {
+        let trait_name = quote { DoNothing };
+        let method_signature = quote { fn do_nothing(self) };
+
+        // Call `do_nothing` recursively on each field in the struct
+        let for_each_field = |field_name| quote { self.$field_name.do_nothing(); };
+
+        // Some traits like Eq want to join each field expression with something like `&`.
+        // We don't need that here
+        let join_fields_with = quote {};
+
+        // The body function is a spot to insert any extra setup/teardown needed.
+        // We'll insert our println here. Since we recur on each field, we should see
+        // one println for the struct itself, followed by a println for every field (recursively).
+        let body = |body| quote {
+            println("something");
+            $body
+        };
+        crate::meta::make_trait_impl(
+            s,
+            trait_name,
+            method_signature,
+            for_each_field,
+            join_fields_with,
+            body
+        )
+    }
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/meta/mod.nr#L186-L244" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/meta/mod.nr#L186-L244</a></sub></sup>
+
diff --git a/docs/versioned_docs/version-v0.35.0/noir/concepts/control_flow.md b/docs/versioned_docs/version-v0.35.0/noir/concepts/control_flow.md
new file mode 100644
index 00000000000..045d3c3a5f5
--- /dev/null
+++ b/docs/versioned_docs/version-v0.35.0/noir/concepts/control_flow.md
@@ -0,0 +1,77 @@
+---
+title: Control Flow
+description:
+  Learn how to use loops and if expressions in the Noir programming language. Discover the syntax
+  and examples for for loops and if-else statements.
+keywords: [Noir programming language, loops, for loop, if-else statements, Rust syntax]
+sidebar_position: 2
+---
+
+## If Expressions
+
+Noir supports `if-else` statements. The syntax is most similar to Rust's where it is not required
+for the statement's conditional to be surrounded by parentheses.
+
+```rust
+let a = 0;
+let mut x: u32 = 0;
+
+if a == 0 {
+    if a != 0 {
+        x = 6;
+    } else {
+        x = 2;
+    }
+} else {
+    x = 5;
+    assert(x == 5);
+}
+assert(x == 2);
+```
+
+## Loops
+
+Noir has one kind of loop: the `for` loop. `for` loops allow you to repeat a block of code multiple
+times.
+
+The following block of code between the braces is run 10 times.
+
+```rust
+for i in 0..10 {
+    // do something
+}
+```
+
+The index for loops is of type `u64`.
+
+### Break and Continue
+
+In unconstrained code, `break` and `continue` are also allowed in `for` loops. These are only allowed
+in unconstrained code since normal constrained code requires that Noir knows exactly how many iterations
+a loop may have. `break` and `continue` can be used like so:
+
+```rust
+for i in 0 .. 10 {
+    println("Iteration start")
+
+    if i == 2 {
+        continue;
+    }
+
+    if i == 5 {
+        break;
+    }
+
+    println(i);
+}
+println("Loop end")
+```
+
+When used, `break` will end the current loop early and jump to the statement after the for loop. In the example
+above, the `break` will stop the loop and jump to the `println("Loop end")`.
+
+`continue` will stop the current iteration of the loop, and jump to the start of the next iteration. In the example
+above, `continue` will jump to `println("Iteration start")` when used. Note that the loop continues as normal after this.
+The iteration variable `i` is still increased by one as normal when `continue` is used.
+
+`break` and `continue` cannot currently be used to jump out of more than a single loop at a time.
diff --git a/docs/versioned_docs/version-v0.35.0/noir/concepts/data_bus.mdx b/docs/versioned_docs/version-v0.35.0/noir/concepts/data_bus.mdx
new file mode 100644
index 00000000000..e55e58622ce
--- /dev/null
+++ b/docs/versioned_docs/version-v0.35.0/noir/concepts/data_bus.mdx
@@ -0,0 +1,23 @@
+---
+title: Data Bus
+sidebar_position: 13
+---
+import Experimental from '@site/src/components/Notes/_experimental.mdx';
+
+<Experimental />
+
+The data bus is an optimization that the backend can use to make recursion more efficient.
+In order to use it, you must define some inputs of the program entry points (usually the `main()`
+function) with the `call_data` modifier, and the return values with the `return_data` modifier.
+These modifiers are incompatible with `pub` and `mut` modifiers.
+
+## Example
+
+```rust
+fn main(mut x: u32, y: call_data u32, z: call_data [u32;4] ) -> return_data u32 {
+  let a = z[x];
+  a+y
+}
+```
+
+As a result, both call_data and return_data will be treated as private inputs and encapsulated into a read-only array each, for the backend to process.
diff --git a/docs/versioned_docs/version-v0.35.0/noir/concepts/data_types/_category_.json b/docs/versioned_docs/version-v0.35.0/noir/concepts/data_types/_category_.json
new file mode 100644
index 00000000000..5d694210bbf
--- /dev/null
+++ b/docs/versioned_docs/version-v0.35.0/noir/concepts/data_types/_category_.json
@@ -0,0 +1,5 @@
+{
+    "position": 0,
+    "collapsible": true,
+    "collapsed": true
+}
diff --git a/docs/versioned_docs/version-v0.35.0/noir/concepts/data_types/arrays.md b/docs/versioned_docs/version-v0.35.0/noir/concepts/data_types/arrays.md
new file mode 100644
index 00000000000..bb68e60fe53
--- /dev/null
+++ b/docs/versioned_docs/version-v0.35.0/noir/concepts/data_types/arrays.md
@@ -0,0 +1,274 @@
+---
+title: Arrays
+description:
+  Dive into the Array data type in Noir. Grasp its methods, practical examples, and best practices for efficiently using Arrays in your Noir code.
+keywords:
+  [
+    noir,
+    array type,
+    methods,
+    examples,
+    indexing,
+  ]
+sidebar_position: 4
+---
+
+An array is one way of grouping together values into one compound type. Array types can be inferred
+or explicitly specified via the syntax `[<Type>; <Size>]`:
+
+```rust
+fn main(x : Field, y : Field) {
+    let my_arr = [x, y];
+    let your_arr: [Field; 2] = [x, y];
+}
+```
+
+Here, both `my_arr` and `your_arr` are instantiated as an array containing two `Field` elements.
+
+Array elements can be accessed using indexing:
+
+```rust
+fn main() {
+    let a = [1, 2, 3, 4, 5];
+
+    let first = a[0];
+    let second = a[1];
+}
+```
+
+All elements in an array must be of the same type (i.e. homogeneous). That is, an array cannot group
+a `Field` value and a `u8` value together for example.
+
+You can write mutable arrays, like:
+
+```rust
+fn main() {
+    let mut arr = [1, 2, 3, 4, 5];
+    assert(arr[0] == 1);
+
+    arr[0] = 42;
+    assert(arr[0] == 42);
+}
+```
+
+You can instantiate a new array of a fixed size with the same value repeated for each element. The following example instantiates an array of length 32 where each element is of type Field and has the value 0.
+
+```rust
+let array: [Field; 32] = [0; 32];
+```
+
+Like in Rust, arrays in Noir are a fixed size. However, if you wish to convert an array to a [slice](./slices.mdx), you can just call `as_slice` on your array:
+
+```rust
+let array: [Field; 32] = [0; 32];
+let sl = array.as_slice()
+```
+
+You can define multidimensional arrays:
+
+```rust
+let array : [[Field; 2]; 2];
+let element = array[0][0];
+```
+
+However, multidimensional slices are not supported. For example, the following code will error at compile time:
+
+```rust
+let slice : [[Field]] = &[];
+```
+
+## Types
+
+You can create arrays of primitive types or structs. There is not yet support for nested arrays
+(arrays of arrays) or arrays of structs that contain arrays.
+
+## Methods
+
+For convenience, the STD provides some ready-to-use, common methods for arrays.
+Each of these functions are located within the generic impl `impl<T, N> [T; N] {`.
+So anywhere `self` appears, it refers to the variable `self: [T; N]`.
+
+### len
+
+Returns the length of an array
+
+```rust
+fn len(self) -> Field
+```
+
+example
+
+```rust
+fn main() {
+    let array = [42, 42];
+    assert(array.len() == 2);
+}
+```
+
+### sort
+
+Returns a new sorted array. The original array remains untouched. Notice that this function will
+only work for arrays of fields or integers, not for any arbitrary type. This is because the sorting
+logic it uses internally is optimized specifically for these values. If you need a sort function to
+sort any type, you should use the function `sort_via` described below.
+
+```rust
+fn sort(self) -> [T; N]
+```
+
+example
+
+```rust
+fn main() {
+    let arr = [42, 32];
+    let sorted = arr.sort();
+    assert(sorted == [32, 42]);
+}
+```
+
+### sort_via
+
+Sorts the array with a custom comparison function. The ordering function must return true if the first argument should be sorted to be before the second argument or is equal to the second argument.
+
+Using this method with an operator like `<` that does not return `true` for equal values will result in an assertion failure for arrays with equal elements.
+
+```rust
+fn sort_via(self, ordering: fn(T, T) -> bool) -> [T; N]
+```
+
+example
+
+```rust
+fn main() {
+    let arr = [42, 32]
+    let sorted_ascending = arr.sort_via(|a, b| a <= b);
+    assert(sorted_ascending == [32, 42]); // verifies
+
+    let sorted_descending = arr.sort_via(|a, b| a >= b);
+    assert(sorted_descending == [32, 42]); // does not verify
+}
+```
+
+### map
+
+Applies a function to each element of the array, returning a new array containing the mapped elements.
+
+```rust
+fn map<U>(self, f: fn(T) -> U) -> [U; N]
+```
+
+example
+
+```rust
+let a = [1, 2, 3];
+let b = a.map(|a| a * 2); // b is now [2, 4, 6]
+```
+
+### fold
+
+Applies a function to each element of the array, returning the final accumulated value. The first
+parameter is the initial value.
+
+```rust
+fn fold<U>(self, mut accumulator: U, f: fn(U, T) -> U) -> U
+```
+
+This is a left fold, so the given function will be applied to the accumulator and first element of
+the array, then the second, and so on. For a given call the expected result would be equivalent to:
+
+```rust
+let a1 = [1];
+let a2 = [1, 2];
+let a3 = [1, 2, 3];
+
+let f = |a, b| a - b;
+a1.fold(10, f)  //=> f(10, 1)
+a2.fold(10, f)  //=> f(f(10, 1), 2)
+a3.fold(10, f)  //=> f(f(f(10, 1), 2), 3)
+```
+
+example:
+
+```rust
+
+fn main() {
+    let arr = [2, 2, 2, 2, 2];
+    let folded = arr.fold(0, |a, b| a + b);
+    assert(folded == 10);
+}
+
+```
+
+### reduce
+
+Same as fold, but uses the first element as the starting element.
+
+```rust
+fn reduce(self, f: fn(T, T) -> T) -> T
+```
+
+example:
+
+```rust
+fn main() {
+    let arr = [2, 2, 2, 2, 2];
+    let reduced = arr.reduce(|a, b| a + b);
+    assert(reduced == 10);
+}
+```
+
+### all
+
+Returns true if all the elements satisfy the given predicate
+
+```rust
+fn all(self, predicate: fn(T) -> bool) -> bool
+```
+
+example:
+
+```rust
+fn main() {
+    let arr = [2, 2, 2, 2, 2];
+    let all = arr.all(|a| a == 2);
+    assert(all);
+}
+```
+
+### any
+
+Returns true if any of the elements satisfy the given predicate
+
+```rust
+fn any(self, predicate: fn(T) -> bool) -> bool
+```
+
+example:
+
+```rust
+fn main() {
+    let arr = [2, 2, 2, 2, 5];
+    let any = arr.any(|a| a == 5);
+    assert(any);
+}
+```
+
+### as_str_unchecked
+
+Converts a byte array of type `[u8; N]` to a string. Note that this performs no UTF-8 validation -
+the given array is interpreted as-is as a string.
+
+```rust
+impl<let N: u32> [u8; N] {
+    pub fn as_str_unchecked(self) -> str<N>
+}
+```
+
+example:
+
+```rust
+fn main() {
+    let hi = [104, 105].as_str_unchecked();
+    assert_eq(hi, "hi");
+}
+```
diff --git a/docs/versioned_docs/version-v0.35.0/noir/concepts/data_types/booleans.md b/docs/versioned_docs/version-v0.35.0/noir/concepts/data_types/booleans.md
new file mode 100644
index 00000000000..2507af710e7
--- /dev/null
+++ b/docs/versioned_docs/version-v0.35.0/noir/concepts/data_types/booleans.md
@@ -0,0 +1,28 @@
+---
+title: Booleans
+description:
+  Delve into the Boolean data type in Noir. Understand its methods, practical examples, and best practices for using Booleans in your Noir programs.
+keywords:
+  [
+    noir,
+    boolean type,
+    methods,
+    examples,
+    logical operations,
+  ]
+sidebar_position: 2
+---
+
+
+The `bool` type in Noir has two possible values: `true` and `false`:
+
+```rust
+fn main() {
+    let t = true;
+    let f: bool = false;
+}
+```
+
+The boolean type is most commonly used in conditionals like `if` expressions and `assert`
+statements. More about conditionals is covered in the [Control Flow](../control_flow.md) and
+[Assert Function](../assert.md) sections.
diff --git a/docs/versioned_docs/version-v0.35.0/noir/concepts/data_types/fields.md b/docs/versioned_docs/version-v0.35.0/noir/concepts/data_types/fields.md
new file mode 100644
index 00000000000..814b996facb
--- /dev/null
+++ b/docs/versioned_docs/version-v0.35.0/noir/concepts/data_types/fields.md
@@ -0,0 +1,240 @@
+---
+title: Fields
+description:
+  Dive deep into the Field data type in Noir. Understand its methods, practical examples, and best practices to effectively use Fields in your Noir programs.
+keywords:
+  [
+    noir,
+    field type,
+    methods,
+    examples,
+    best practices,
+  ]
+sidebar_position: 0
+---
+
+The field type corresponds to the native field type of the proving backend.
+
+The size of a Noir field depends on the elliptic curve's finite field for the proving backend
+adopted. For example, a field would be a 254-bit integer when paired with the default backend that
+spans the Grumpkin curve.
+
+Fields support integer arithmetic and are often used as the default numeric type in Noir:
+
+```rust
+fn main(x : Field, y : Field)  {
+    let z = x + y;
+}
+```
+
+`x`, `y` and `z` are all private fields in this example. Using the `let` keyword we defined a new
+private value `z` constrained to be equal to `x + y`.
+
+If proving efficiency is of priority, fields should be used as a default for solving problems.
+Smaller integer types (e.g. `u64`) incur extra range constraints.
+
+## Methods
+
+After declaring a Field, you can use these common methods on it:
+
+### to_le_bits
+
+Transforms the field into an array of bits, Little Endian.
+
+```rust title="to_le_bits" showLineNumbers 
+pub fn to_le_bits<let N: u32>(self: Self) -> [u1; N] {}
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/field/mod.nr#L33-L35" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/field/mod.nr#L33-L35</a></sub></sup>
+
+
+example:
+
+```rust title="to_le_bits_example" showLineNumbers 
+fn test_to_le_bits() {
+        let field = 2;
+        let bits: [u1; 8] = field.to_le_bits();
+        assert_eq(bits, [0, 1, 0, 0, 0, 0, 0, 0]);
+    }
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/field/mod.nr#L255-L261" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/field/mod.nr#L255-L261</a></sub></sup>
+
+
+
+### to_be_bits
+
+Transforms the field into an array of bits, Big Endian.
+
+```rust title="to_be_bits" showLineNumbers 
+pub fn to_be_bits<let N: u32>(self: Self) -> [u1; N] {}
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/field/mod.nr#L49-L51" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/field/mod.nr#L49-L51</a></sub></sup>
+
+
+example:
+
+```rust title="to_be_bits_example" showLineNumbers 
+fn test_to_be_bits() {
+        let field = 2;
+        let bits: [u1; 8] = field.to_be_bits();
+        assert_eq(bits, [0, 0, 0, 0, 0, 0, 1, 0]);
+    }
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/field/mod.nr#L246-L252" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/field/mod.nr#L246-L252</a></sub></sup>
+
+
+
+### to_le_bytes
+
+Transforms into an array of bytes, Little Endian
+
+```rust title="to_le_bytes" showLineNumbers 
+pub fn to_le_bytes<let N: u32>(self: Self) -> [u8; N] {
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/field/mod.nr#L62-L64" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/field/mod.nr#L62-L64</a></sub></sup>
+
+
+example:
+
+```rust title="to_le_bytes_example" showLineNumbers 
+fn test_to_le_bytes() {
+        let field = 2;
+        let bits: [u8; 8] = field.to_le_bytes();
+        assert_eq(bits, [2, 0, 0, 0, 0, 0, 0, 0]);
+        assert_eq(Field::from_le_bytes::<8>(bits), field);
+    }
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/field/mod.nr#L274-L281" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/field/mod.nr#L274-L281</a></sub></sup>
+
+
+### to_be_bytes
+
+Transforms into an array of bytes, Big Endian
+
+```rust title="to_be_bytes" showLineNumbers 
+pub fn to_be_bytes<let N: u32>(self: Self) -> [u8; N] {
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/field/mod.nr#L95-L97" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/field/mod.nr#L95-L97</a></sub></sup>
+
+
+example:
+
+```rust title="to_be_bytes_example" showLineNumbers 
+fn test_to_be_bytes() {
+        let field = 2;
+        let bits: [u8; 8] = field.to_be_bytes();
+        assert_eq(bits, [0, 0, 0, 0, 0, 0, 0, 2]);
+        assert_eq(Field::from_be_bytes::<8>(bits), field);
+    }
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/field/mod.nr#L264-L271" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/field/mod.nr#L264-L271</a></sub></sup>
+
+
+
+### to_le_radix
+
+Decomposes into an array over the specified base, Little Endian
+
+```rust title="to_le_radix" showLineNumbers 
+pub fn to_le_radix<let N: u32>(self: Self, radix: u32) -> [u8; N] {
+        crate::assert_constant(radix);
+        self.__to_le_radix(radix)
+    }
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/field/mod.nr#L119-L124" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/field/mod.nr#L119-L124</a></sub></sup>
+
+
+
+example:
+
+```rust title="to_le_radix_example" showLineNumbers 
+fn test_to_le_radix() {
+        let field = 2;
+        let bits: [u8; 8] = field.to_le_radix(256);
+        assert_eq(bits, [2, 0, 0, 0, 0, 0, 0, 0]);
+        assert_eq(Field::from_le_bytes::<8>(bits), field);
+    }
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/field/mod.nr#L294-L301" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/field/mod.nr#L294-L301</a></sub></sup>
+
+
+
+### to_be_radix
+
+Decomposes into an array over the specified base, Big Endian
+
+```rust title="to_be_radix" showLineNumbers 
+pub fn to_be_radix<let N: u32>(self: Self, radix: u32) -> [u8; N] {
+        crate::assert_constant(radix);
+        self.__to_be_radix(radix)
+    }
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/field/mod.nr#L126-L131" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/field/mod.nr#L126-L131</a></sub></sup>
+
+
+example:
+
+```rust title="to_be_radix_example" showLineNumbers 
+fn test_to_be_radix() {
+        let field = 2;
+        let bits: [u8; 8] = field.to_be_radix(256);
+        assert_eq(bits, [0, 0, 0, 0, 0, 0, 0, 2]);
+        assert_eq(Field::from_be_bytes::<8>(bits), field);
+    }
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/field/mod.nr#L284-L291" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/field/mod.nr#L284-L291</a></sub></sup>
+
+
+
+### pow_32
+
+Returns the value to the power of the specified exponent
+
+```rust
+fn pow_32(self, exponent: Field) -> Field
+```
+
+example:
+
+```rust
+fn main() {
+    let field = 2
+    let pow = field.pow_32(4);
+    assert(pow == 16);
+}
+```
+
+### assert_max_bit_size
+
+Adds a constraint to specify that the field can be represented with `bit_size` number of bits
+
+```rust title="assert_max_bit_size" showLineNumbers 
+pub fn assert_max_bit_size(self, bit_size: u32) {
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/field/mod.nr#L10-L12" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/field/mod.nr#L10-L12</a></sub></sup>
+
+
+example:
+
+```rust
+fn main() {
+    let field = 2
+    field.assert_max_bit_size(32);
+}
+```
+
+### sgn0
+
+Parity of (prime) Field element, i.e. sgn0(x mod p) = 0 if x ∈ \{0, ..., p-1\} is even, otherwise sgn0(x mod p) = 1.
+
+```rust
+fn sgn0(self) -> u1
+```
+
+
+### lt
+
+Returns true if the field is less than the other field
+
+```rust
+pub fn lt(self, another: Field) -> bool
+```
diff --git a/docs/versioned_docs/version-v0.35.0/noir/concepts/data_types/function_types.md b/docs/versioned_docs/version-v0.35.0/noir/concepts/data_types/function_types.md
new file mode 100644
index 00000000000..f6121af17e2
--- /dev/null
+++ b/docs/versioned_docs/version-v0.35.0/noir/concepts/data_types/function_types.md
@@ -0,0 +1,26 @@
+---
+title: Function types
+sidebar_position: 10
+---
+
+Noir supports higher-order functions. The syntax for a function type is as follows:
+
+```rust
+fn(arg1_type, arg2_type, ...) -> return_type
+```
+
+Example:
+
+```rust
+fn assert_returns_100(f: fn() -> Field) { // f takes no args and returns a Field
+    assert(f() == 100);
+}
+
+fn main() {
+    assert_returns_100(|| 100); // ok
+    assert_returns_100(|| 150); // fails
+}
+```
+
+A function type also has an optional capture environment - this is necessary to support closures.
+See [Lambdas](../lambdas.md) for more details.
diff --git a/docs/versioned_docs/version-v0.35.0/noir/concepts/data_types/index.md b/docs/versioned_docs/version-v0.35.0/noir/concepts/data_types/index.md
new file mode 100644
index 00000000000..11f51e2b65a
--- /dev/null
+++ b/docs/versioned_docs/version-v0.35.0/noir/concepts/data_types/index.md
@@ -0,0 +1,126 @@
+---
+title: Data Types
+description:
+  Get a clear understanding of the two categories of Noir data types - primitive types and compound
+  types. Learn about their characteristics, differences, and how to use them in your Noir
+  programming.
+keywords:
+  [
+    noir,
+    data types,
+    primitive types,
+    compound types,
+    private types,
+    public types,
+  ]
+---
+
+Every value in Noir has a type, which determines which operations are valid for it.
+
+All values in Noir are fundamentally composed of `Field` elements. For a more approachable
+developing experience, abstractions are added on top to introduce different data types in Noir.
+
+Noir has two category of data types: primitive types (e.g. `Field`, integers, `bool`) and compound
+types that group primitive types (e.g. arrays, tuples, structs). Each value can either be private or
+public.
+
+## Private & Public Types
+
+A **private value** is known only to the Prover, while a **public value** is known by both the
+Prover and Verifier. Mark values as `private` when the value should only be known to the prover. All
+primitive types (including individual fields of compound types) in Noir are private by default, and
+can be marked public when certain values are intended to be revealed to the Verifier.
+
+> **Note:** For public values defined in Noir programs paired with smart contract verifiers, once
+> the proofs are verified on-chain the values can be considered known to everyone that has access to
+> that blockchain.
+
+Public data types are treated no differently to private types apart from the fact that their values
+will be revealed in proofs generated. Simply changing the value of a public type will not change the
+circuit (where the same goes for changing values of private types as well).
+
+_Private values_ are also referred to as _witnesses_ sometimes.
+
+> **Note:** The terms private and public when applied to a type (e.g. `pub Field`) have a different
+> meaning than when applied to a function (e.g. `pub fn foo() {}`).
+>
+> The former is a visibility modifier for the Prover to interpret if a value should be made known to
+> the Verifier, while the latter is a visibility modifier for the compiler to interpret if a
+> function should be made accessible to external Noir programs like in other languages.
+
+### pub Modifier
+
+All data types in Noir are private by default. Types are explicitly declared as public using the
+`pub` modifier:
+
+```rust
+fn main(x : Field, y : pub Field) -> pub Field {
+    x + y
+}
+```
+
+In this example, `x` is **private** while `y` and `x + y` (the return value) are **public**. Note
+that visibility is handled **per variable**, so it is perfectly valid to have one input that is
+private and another that is public.
+
+> **Note:** Public types can only be declared through parameters on `main`.
+
+## Type Aliases
+
+A type alias is a new name for an existing type. Type aliases are declared with the keyword `type`:
+
+```rust
+type Id = u8;
+
+fn main() {
+    let id: Id = 1;
+    let zero: u8 = 0;
+    assert(zero + 1 == id);
+}
+```
+
+Type aliases can also be used with [generics](../generics.md):
+
+```rust
+type Id<Size> = Size;
+
+fn main() {
+    let id: Id<u32> = 1;
+    let zero: u32 = 0;
+    assert(zero + 1 == id);
+}
+```
+
+Type aliases can even refer to other aliases. An error will be issued if they form a cycle:
+
+```rust
+// Ok!
+type A = B;
+type B = Field;
+
+type Bad1 = Bad2;
+
+// error: Dependency cycle found
+type Bad2 = Bad1;
+//   ^^^^^^^^^^^ 'Bad2' recursively depends on itself: Bad2 -> Bad1 -> Bad2
+```
+
+By default, like functions, type aliases are private to the module the exist in. You can use `pub`
+to make the type alias public or `pub(crate)` to make it public to just its crate:
+
+```rust
+// This type alias is now public
+pub type Id = u8;
+```
+
+## Wildcard Type
+Noir can usually infer the type of the variable from the context, so specifying the type of a variable is only required when it cannot be inferred. However, specifying a complex type can be tedious, especially when it has multiple generic arguments. Often some of the generic types can be inferred from the context, and Noir only needs a hint to properly infer the other types. We can partially specify a variable's type by using `_` as a marker, indicating where we still want the compiler to infer the type.
+
+```rust
+let a: [_; 4] = foo(b);
+```
+ 
+
+### BigInt
+
+You can achieve BigInt functionality using the [Noir BigInt](https://github.com/shuklaayush/noir-bigint) library.
diff --git a/docs/versioned_docs/version-v0.35.0/noir/concepts/data_types/integers.md b/docs/versioned_docs/version-v0.35.0/noir/concepts/data_types/integers.md
new file mode 100644
index 00000000000..a1d59bf3166
--- /dev/null
+++ b/docs/versioned_docs/version-v0.35.0/noir/concepts/data_types/integers.md
@@ -0,0 +1,156 @@
+---
+title: Integers
+description: Explore the Integer data type in Noir. Learn about its methods, see real-world examples, and grasp how to efficiently use Integers in your Noir code.
+keywords: [noir, integer types, methods, examples, arithmetic]
+sidebar_position: 1
+---
+
+An integer type is a range constrained field type.
+The Noir frontend supports both unsigned and signed integer types.
+The allowed sizes are 1, 8, 16, 32 and 64 bits.
+
+:::info
+
+When an integer is defined in Noir without a specific type, it will default to `Field`.
+
+The one exception is for loop indices which default to `u64` since comparisons on `Field`s are not possible.
+
+:::
+
+## Unsigned Integers
+
+An unsigned integer type is specified first with the letter `u` (indicating its unsigned nature) followed by its bit size (e.g. `8`):
+
+```rust
+fn main() {
+    let x: u8 = 1;
+    let y: u8 = 1;
+    let z = x + y;
+    assert (z == 2);
+}
+```
+
+The bit size determines the maximum value the integer type can store. For example, a `u8` variable can store a value in the range of 0 to 255 (i.e. $\\2^{8}-1\\$).
+
+## Signed Integers
+
+A signed integer type is specified first with the letter `i` (which stands for integer) followed by its bit size (e.g. `8`):
+
+```rust
+fn main() {
+    let x: i8 = -1;
+    let y: i8 = -1;
+    let z = x + y;
+    assert (z == -2);
+}
+```
+
+The bit size determines the maximum and minimum range of value the integer type can store. For example, an `i8` variable can store a value in the range of -128 to 127 (i.e. $\\-2^{7}\\$ to $\\2^{7}-1\\$).
+
+## 128 bits Unsigned Integers
+
+The built-in structure `U128` allows you to use 128-bit unsigned integers almost like a native integer type. However, there are some differences to keep in mind:
+- You cannot cast between a native integer and `U128`
+- There is a higher performance cost when using `U128`, compared to a native type.
+
+Conversion between unsigned integer types and U128 are done through the use of `from_integer` and `to_integer` functions. `from_integer` also accepts the `Field` type as input.
+
+```rust
+fn main() {
+    let x = U128::from_integer(23);
+    let y = U128::from_hex("0x7");
+    let z = x + y;
+    assert(z.to_integer() == 30);
+}
+```
+
+`U128` is implemented with two 64 bits limbs, representing the low and high bits, which explains the performance cost. You should expect `U128` to be twice more costly for addition and four times more costly for multiplication.
+You can construct a U128 from its limbs:
+```rust
+fn main(x: u64, y: u64) {
+    let x = U128::from_u64s_be(x,y);
+    assert(z.hi == x as Field);
+    assert(z.lo == y as Field);
+}
+```
+
+Note that the limbs are stored as Field elements in order to avoid unnecessary conversions.
+Apart from this, most operations will work as usual:
+
+```rust
+fn main(x: U128, y: U128) {
+    // multiplication
+    let c = x * y;
+    // addition and subtraction
+    let c = c - x + y;
+    // division
+    let c = x / y;
+    // bit operation;
+    let c = x & y | y;
+    // bit shift
+    let c = x << y;
+    // comparisons;
+    let c = x < y;
+    let c = x == y;
+}
+```
+
+## Overflows
+
+Computations that exceed the type boundaries will result in overflow errors. This happens with both signed and unsigned integers. For example, attempting to prove:
+
+```rust
+fn main(x: u8, y: u8) {
+    let z = x + y;
+}
+```
+
+With:
+
+```toml
+x = "255"
+y = "1"
+```
+
+Would result in:
+
+```
+$ nargo execute
+error: Assertion failed: 'attempt to add with overflow'
+┌─ ~/src/main.nr:9:13
+│
+│     let z = x + y;
+│             -----
+│
+= Call stack:
+  ...
+```
+
+A similar error would happen with signed integers:
+
+```rust
+fn main() {
+    let x: i8 = -118;
+    let y: i8 = -11;
+    let z = x + y;
+}
+```
+
+### Wrapping methods
+
+Although integer overflow is expected to error, some use-cases rely on wrapping. For these use-cases, the standard library provides `wrapping` variants of certain common operations:
+
+```rust
+fn wrapping_add<T>(x: T, y: T) -> T;
+fn wrapping_sub<T>(x: T, y: T) -> T;
+fn wrapping_mul<T>(x: T, y: T) -> T;
+```
+
+Example of how it is used:
+
+```rust
+
+fn main(x: u8, y: u8) -> pub u8 {
+    std::wrapping_add(x, y)
+}
+```
diff --git a/docs/versioned_docs/version-v0.35.0/noir/concepts/data_types/references.md b/docs/versioned_docs/version-v0.35.0/noir/concepts/data_types/references.md
new file mode 100644
index 00000000000..a5293d11cfb
--- /dev/null
+++ b/docs/versioned_docs/version-v0.35.0/noir/concepts/data_types/references.md
@@ -0,0 +1,23 @@
+---
+title: References
+sidebar_position: 9
+---
+
+Noir supports first-class references. References are a bit like pointers: they point to a specific address that can be followed to access the data stored at that address. You can use Rust-like syntax to use pointers in Noir: the `&` operator references the variable, the `*` operator dereferences it.
+
+Example:
+
+```rust
+fn main() {
+    let mut x = 2;
+
+    // you can reference x as &mut and pass it to multiplyBy2
+    multiplyBy2(&mut x);
+}
+
+// you can access &mut here
+fn multiplyBy2(x: &mut Field) {
+    // and dereference it with *
+    *x = *x * 2;
+}
+```
diff --git a/docs/versioned_docs/version-v0.35.0/noir/concepts/data_types/slices.mdx b/docs/versioned_docs/version-v0.35.0/noir/concepts/data_types/slices.mdx
new file mode 100644
index 00000000000..cfee564a302
--- /dev/null
+++ b/docs/versioned_docs/version-v0.35.0/noir/concepts/data_types/slices.mdx
@@ -0,0 +1,358 @@
+---
+title: Slices
+description: Explore the Slice data type in Noir. Understand its methods, see real-world examples, and learn how to effectively use Slices in your Noir programs.
+keywords: [noir, slice type, methods, examples, subarrays]
+sidebar_position: 5
+---
+
+import Experimental from '@site/src/components/Notes/_experimental.mdx';
+
+<Experimental />
+
+A slice is a dynamically-sized view into a sequence of elements. They can be resized at runtime, but because they don't own the data, they cannot be returned from a circuit. You can treat slices as arrays without a constrained size.
+
+```rust
+fn main() -> pub u32 {
+    let mut slice: [Field] = &[0; 2];
+
+    let mut new_slice = slice.push_back(6);
+    new_slice.len()
+}
+```
+
+To write a slice literal, use a preceding ampersand as in: `&[0; 2]` or
+`&[1, 2, 3]`.
+
+It is important to note that slices are not references to arrays. In Noir,
+`&[..]` is more similar to an immutable, growable vector.
+
+View the corresponding test file [here][test-file].
+
+[test-file]: https://github.com/noir-lang/noir/blob/f387ec1475129732f72ba294877efdf6857135ac/crates/nargo_cli/tests/test_data_ssa_refactor/slices/src/main.nr
+
+## Methods
+
+For convenience, the STD provides some ready-to-use, common methods for slices:
+
+### push_back
+
+Pushes a new element to the end of the slice, returning a new slice with a length one greater than the original unmodified slice.
+
+```rust
+fn push_back<T>(_self: [T], _elem: T) -> [T]
+```
+
+example:
+
+```rust
+fn main() -> pub Field {
+    let mut slice: [Field] = &[0; 2];
+
+    let mut new_slice = slice.push_back(6);
+    new_slice.len()
+}
+```
+
+View the corresponding test file [here][test-file].
+
+### push_front
+
+Returns a new array with the specified element inserted at index 0. The existing elements indexes are incremented by 1.
+
+```rust
+fn push_front(_self: Self, _elem: T) -> Self
+```
+
+Example:
+
+```rust
+let mut new_slice: [Field] = &[];
+new_slice = new_slice.push_front(20);
+assert(new_slice[0] == 20); // returns true
+```
+
+View the corresponding test file [here][test-file].
+
+### pop_front
+
+Returns a tuple of two items, the first element of the array and the rest of the array.
+
+```rust
+fn pop_front(_self: Self) -> (T, Self)
+```
+
+Example:
+
+```rust
+let (first_elem, rest_of_slice) = slice.pop_front();
+```
+
+View the corresponding test file [here][test-file].
+
+### pop_back
+
+Returns a tuple of two items, the beginning of the array with the last element omitted and the last element.
+
+```rust
+fn pop_back(_self: Self) -> (Self, T)
+```
+
+Example:
+
+```rust
+let (popped_slice, last_elem) = slice.pop_back();
+```
+
+View the corresponding test file [here][test-file].
+
+### append
+
+Loops over a slice and adds it to the end of another.
+
+```rust
+fn append(mut self, other: Self) -> Self
+```
+
+Example:
+
+```rust
+let append = &[1, 2].append(&[3, 4, 5]);
+```
+
+### insert
+
+Inserts an element at a specified index and shifts all following elements by 1.
+
+```rust
+fn insert(_self: Self, _index: Field, _elem: T) -> Self
+```
+
+Example:
+
+```rust
+new_slice = rest_of_slice.insert(2, 100);
+assert(new_slice[2] == 100);
+```
+
+View the corresponding test file [here][test-file].
+
+### remove
+
+Remove an element at a specified index, shifting all elements after it to the left, returning the altered slice and the removed element.
+
+```rust
+fn remove(_self: Self, _index: Field) -> (Self, T)
+```
+
+Example:
+
+```rust
+let (remove_slice, removed_elem) = slice.remove(3);
+```
+
+### len
+
+Returns the length of a slice
+
+```rust
+fn len(self) -> Field
+```
+
+Example:
+
+```rust
+fn main() {
+    let slice = &[42, 42];
+    assert(slice.len() == 2);
+}
+```
+
+### as_array
+
+Converts this slice into an array.
+
+Make sure to specify the size of the resulting array.
+Panics if the resulting array length is different than the slice's length.
+
+```rust
+fn as_array<let N: u32>(self) -> [T; N]
+```
+
+Example:
+
+```rust
+fn main() {
+    let slice = &[5, 6];
+
+    // Always specify the length of the resulting array!
+    let array: [Field; 2] = slice.as_array();
+
+    assert(array[0] == slice[0]);
+    assert(array[1] == slice[1]);
+}
+```
+
+### map
+
+Applies a function to each element of the slice, returning a new slice containing the mapped elements.
+
+```rust
+fn map<U, Env>(self, f: fn[Env](T) -> U) -> [U]
+```
+
+example
+
+```rust
+let a = &[1, 2, 3];
+let b = a.map(|a| a * 2); // b is now &[2, 4, 6]
+```
+
+### fold
+
+Applies a function to each element of the slice, returning the final accumulated value. The first
+parameter is the initial value.
+
+```rust
+fn fold<U, Env>(self, mut accumulator: U, f: fn[Env](U, T) -> U) -> U
+```
+
+This is a left fold, so the given function will be applied to the accumulator and first element of
+the slice, then the second, and so on. For a given call the expected result would be equivalent to:
+
+```rust
+let a1 = &[1];
+let a2 = &[1, 2];
+let a3 = &[1, 2, 3];
+
+let f = |a, b| a - b;
+a1.fold(10, f)  //=> f(10, 1)
+a2.fold(10, f)  //=> f(f(10, 1), 2)
+a3.fold(10, f)  //=> f(f(f(10, 1), 2), 3)
+```
+
+example:
+
+```rust
+
+fn main() {
+    let slice = &[2, 2, 2, 2, 2];
+    let folded = slice.fold(0, |a, b| a + b);
+    assert(folded == 10);
+}
+
+```
+
+### reduce
+
+Same as fold, but uses the first element as the starting element.
+
+```rust
+fn reduce<Env>(self, f: fn[Env](T, T) -> T) -> T
+```
+
+example:
+
+```rust
+fn main() {
+    let slice = &[2, 2, 2, 2, 2];
+    let reduced = slice.reduce(|a, b| a + b);
+    assert(reduced == 10);
+}
+```
+
+### filter
+
+Returns a new slice containing only elements for which the given predicate returns true.
+
+```rust
+fn filter<Env>(self, f: fn[Env](T) -> bool) -> Self
+```
+
+example:
+
+```rust
+fn main() {
+    let slice = &[1, 2, 3, 4, 5];
+    let odds = slice.filter(|x| x % 2 == 1);
+    assert_eq(odds, &[1, 3, 5]);
+}
+```
+
+### join
+
+Flatten each element in the slice into one value, separated by `separator`.
+
+Note that although slices implement `Append`, `join` cannot be used on slice
+elements since nested slices are prohibited.
+
+```rust
+fn join(self, separator: T) -> T where T: Append
+```
+
+example:
+
+```rust
+struct Accumulator {
+    total: Field,
+}
+
+// "Append" two accumulators by adding them
+impl Append for Accumulator {
+    fn empty() -> Self {
+        Self { total: 0 }
+    }
+
+    fn append(self, other: Self) -> Self {
+        Self { total: self.total + other.total }
+    }
+}
+
+fn main() {
+    let slice = &[1, 2, 3, 4, 5].map(|total| Accumulator { total });
+
+    let result = slice.join(Accumulator::empty());
+    assert_eq(result, Accumulator { total: 15 });
+
+    // We can use a non-empty separator to insert additional elements to sum:
+    let separator = Accumulator { total: 10 };
+    let result = slice.join(separator);
+    assert_eq(result, Accumulator { total: 55 });
+}
+```
+
+### all
+
+Returns true if all the elements satisfy the given predicate
+
+```rust
+fn all<Env>(self, predicate: fn[Env](T) -> bool) -> bool
+```
+
+example:
+
+```rust
+fn main() {
+    let slice = &[2, 2, 2, 2, 2];
+    let all = slice.all(|a| a == 2);
+    assert(all);
+}
+```
+
+### any
+
+Returns true if any of the elements satisfy the given predicate
+
+```rust
+fn any<Env>(self, predicate: fn[Env](T) -> bool) -> bool
+```
+
+example:
+
+```rust
+fn main() {
+    let slice = &[2, 2, 2, 2, 5];
+    let any = slice.any(|a| a == 5);
+    assert(any);
+}
+
+```
diff --git a/docs/versioned_docs/version-v0.35.0/noir/concepts/data_types/strings.md b/docs/versioned_docs/version-v0.35.0/noir/concepts/data_types/strings.md
new file mode 100644
index 00000000000..1fdee42425e
--- /dev/null
+++ b/docs/versioned_docs/version-v0.35.0/noir/concepts/data_types/strings.md
@@ -0,0 +1,79 @@
+---
+title: Strings
+description:
+  Discover the String data type in Noir. Learn about its methods, see real-world examples, and understand how to effectively manipulate and use Strings in Noir.
+keywords:
+  [
+    noir,
+    string type,
+    methods,
+    examples,
+    concatenation,
+  ]
+sidebar_position: 3
+---
+
+
+The string type is a fixed length value defined with `str<N>`.
+
+You can use strings in `assert()` functions or print them with
+`println()`. See more about [Logging](../../standard_library/logging.md).
+
+```rust
+
+fn main(message : pub str<11>, hex_as_string : str<4>) {
+    println(message);
+    assert(message == "hello world");
+    assert(hex_as_string == "0x41");
+}
+```
+
+You can convert a `str<N>` to a byte array by calling `as_bytes()`
+or a vector by calling `as_bytes_vec()`.
+
+```rust
+fn main() {
+    let message = "hello world";
+    let message_bytes = message.as_bytes();
+    let mut message_vec = message.as_bytes_vec();
+    assert(message_bytes.len() == 11);
+    assert(message_bytes[0] == 104);
+    assert(message_bytes[0] == message_vec.get(0));
+}
+```
+
+## Escape characters
+
+You can use escape characters for your strings:
+
+| Escape Sequence | Description     |
+|-----------------|-----------------|
+| `\r`            | Carriage Return |
+| `\n`            | Newline         |
+| `\t`            | Tab             |
+| `\0`            | Null Character  |
+| `\"`            | Double Quote    |
+| `\\`            | Backslash       |
+
+Example:
+
+```rust
+let s = "Hello \"world" // prints "Hello "world"
+let s = "hey \tyou"; // prints "hey   you"
+```
+
+## Raw strings
+
+A raw string begins with the letter `r` and is optionally delimited by a number of hashes `#`.
+
+Escape characters are *not* processed within raw strings. All contents are interpreted literally.
+
+Example:
+
+```rust
+let s = r"Hello world";
+let s = r#"Simon says "hello world""#;
+
+// Any number of hashes may be used (>= 1) as long as the string also terminates with the same number of hashes
+let s = r#####"One "#, Two "##, Three "###, Four "####, Five will end the string."#####; 
+```
diff --git a/docs/versioned_docs/version-v0.35.0/noir/concepts/data_types/structs.md b/docs/versioned_docs/version-v0.35.0/noir/concepts/data_types/structs.md
new file mode 100644
index 00000000000..e529347f27d
--- /dev/null
+++ b/docs/versioned_docs/version-v0.35.0/noir/concepts/data_types/structs.md
@@ -0,0 +1,82 @@
+---
+title: Structs
+description:
+  Explore the Struct data type in Noir. Learn about its methods, see real-world examples, and grasp how to effectively define and use Structs in your Noir programs.
+keywords:
+  [
+    noir,
+    struct type,
+    methods,
+    examples,
+    data structures,
+  ]
+sidebar_position: 8
+---
+
+A struct also allows for grouping multiple values of different types. Unlike tuples, we can also
+name each field.
+
+> **Note:** The usage of _field_ here refers to each element of the struct and is unrelated to the
+> field type of Noir.
+
+Defining a struct requires giving it a name and listing each field within as `<Key>: <Type>` pairs:
+
+```rust
+struct Animal {
+    hands: Field,
+    legs: Field,
+    eyes: u8,
+}
+```
+
+An instance of a struct can then be created with actual values in `<Key>: <Value>` pairs in any
+order. Struct fields are accessible using their given names:
+
+```rust
+fn main() {
+    let legs = 4;
+
+    let dog = Animal {
+        eyes: 2,
+        hands: 0,
+        legs,
+    };
+
+    let zero = dog.hands;
+}
+```
+
+Structs can also be destructured in a pattern, binding each field to a new variable:
+
+```rust
+fn main() {
+    let Animal { hands, legs: feet, eyes } = get_octopus();
+
+    let ten = hands + feet + eyes as u8;
+}
+
+fn get_octopus() -> Animal {
+    let octopus = Animal {
+        hands: 0,
+        legs: 8,
+        eyes: 2,
+    };
+
+    octopus
+}
+```
+
+The new variables can be bound with names different from the original struct field names, as
+showcased in the `legs --> feet` binding in the example above.
+
+By default, like functions, structs are private to the module the exist in. You can use `pub`
+to make the struct public or `pub(crate)` to make it public to just its crate:
+
+```rust
+// This struct is now public
+pub struct Animal {
+    hands: Field,
+    legs: Field,
+    eyes: u8,
+}
+```
\ No newline at end of file
diff --git a/docs/versioned_docs/version-v0.35.0/noir/concepts/data_types/tuples.md b/docs/versioned_docs/version-v0.35.0/noir/concepts/data_types/tuples.md
new file mode 100644
index 00000000000..2ec5c9c4113
--- /dev/null
+++ b/docs/versioned_docs/version-v0.35.0/noir/concepts/data_types/tuples.md
@@ -0,0 +1,48 @@
+---
+title: Tuples
+description:
+  Dive into the Tuple data type in Noir. Understand its methods, practical examples, and best practices for efficiently using Tuples in your Noir code.
+keywords:
+  [
+    noir,
+    tuple type,
+    methods,
+    examples,
+    multi-value containers,
+  ]
+sidebar_position: 7
+---
+
+A tuple collects multiple values like an array, but with the added ability to collect values of
+different types:
+
+```rust
+fn main() {
+    let tup: (u8, u64, Field) = (255, 500, 1000);
+}
+```
+
+One way to access tuple elements is via destructuring using pattern matching:
+
+```rust
+fn main() {
+    let tup = (1, 2);
+
+    let (one, two) = tup;
+
+    let three = one + two;
+}
+```
+
+Another way to access tuple elements is via direct member access, using a period (`.`) followed by
+the index of the element we want to access. Index `0` corresponds to the first tuple element, `1` to
+the second and so on:
+
+```rust
+fn main() {
+    let tup = (5, 6, 7, 8);
+
+    let five = tup.0;
+    let eight = tup.3;
+}
+```
diff --git a/docs/versioned_docs/version-v0.35.0/noir/concepts/functions.md b/docs/versioned_docs/version-v0.35.0/noir/concepts/functions.md
new file mode 100644
index 00000000000..f656cdfd97a
--- /dev/null
+++ b/docs/versioned_docs/version-v0.35.0/noir/concepts/functions.md
@@ -0,0 +1,226 @@
+---
+title: Functions
+description:
+  Learn how to declare functions and methods in Noir, a programming language with Rust semantics.
+  This guide covers parameter declaration, return types, call expressions, and more.
+keywords: [Noir, Rust, functions, methods, parameter declaration, return types, call expressions]
+sidebar_position: 1
+---
+
+Functions in Noir follow the same semantics of Rust, though Noir does not support early returns.
+
+To declare a function the `fn` keyword is used.
+
+```rust
+fn foo() {}
+```
+
+By default, functions are visible only within the package they are defined. To make them visible outside of that package (for example, as part of a [library](../modules_packages_crates/crates_and_packages.md#libraries)), you should mark them as `pub`:
+
+```rust
+pub fn foo() {}
+```
+
+You can also restrict the visibility of the function to only the crate it was defined in, by specifying `pub(crate)`:
+
+```rust
+pub(crate) fn foo() {}  //foo can only be called within its crate
+```
+
+All parameters in a function must have a type and all types are known at compile time. The parameter
+is pre-pended with a colon and the parameter type. Multiple parameters are separated using a comma.
+
+```rust
+fn foo(x : Field, y : Field){}
+```
+
+The return type of a function can be stated by using the `->` arrow notation. The function below
+states that the foo function must return a `Field`. If the function returns no value, then the arrow
+is omitted.
+
+```rust
+fn foo(x : Field, y : Field) -> Field {
+    x + y
+}
+```
+
+Note that a `return` keyword is unneeded in this case - the last expression in a function's body is
+returned.
+
+## Main function
+
+If you're writing a binary, the `main` function is the starting point of your program. You can pass all types of expressions to it, as long as they have a fixed size at compile time:
+
+```rust
+fn main(x : Field) // this is fine: passing a Field
+fn main(x : [Field; 2]) // this is also fine: passing a Field with known size at compile-time
+fn main(x : (Field, bool)) // 👌: passing a (Field, bool) tuple means size 2
+fn main(x : str<5>) // this is fine, as long as you pass a string of size 5
+
+fn main(x : Vec<Field>) // can't compile, has variable size
+fn main(x : [Field]) // can't compile, has variable size
+fn main(....// i think you got it by now
+```
+
+Keep in mind [tests](../../tooling/testing.md) don't differentiate between `main` and any other function. The following snippet passes tests, but won't compile or prove:
+
+```rust
+fn main(x : [Field]) {
+    assert(x[0] == 1);
+}
+
+#[test]
+fn test_one() {
+    main(&[1, 2]);
+}
+```
+
+```bash
+$ nargo test
+[testing] Running 1 test functions
+[testing] Testing test_one... ok
+[testing] All tests passed
+
+$ nargo check
+The application panicked (crashed).
+Message:  Cannot have variable sized arrays as a parameter to main
+```
+
+## Call Expressions
+
+Calling a function in Noir is executed by using the function name and passing in the necessary
+arguments.
+
+Below we show how to call the `foo` function from the `main` function using a call expression:
+
+```rust
+fn main(x : Field, y : Field) {
+    let z = foo(x);
+}
+
+fn foo(x : Field) -> Field {
+    x + x
+}
+```
+
+## Methods
+
+You can define methods in Noir on any struct type in scope.
+
+```rust
+struct MyStruct {
+    foo: Field,
+    bar: Field,
+}
+
+impl MyStruct {
+    fn new(foo: Field) -> MyStruct {
+        MyStruct {
+            foo,
+            bar: 2,
+        }
+    }
+
+    fn sum(self) -> Field {
+        self.foo + self.bar
+    }
+}
+
+fn main() {
+    let s = MyStruct::new(40);
+    assert(s.sum() == 42);
+}
+```
+
+Methods are just syntactic sugar for functions, so if we wanted to we could also call `sum` as
+follows:
+
+```rust
+assert(MyStruct::sum(s) == 42);
+```
+
+It is also possible to specialize which method is chosen depending on the [generic](./generics.md) type that is used. In this example, the `foo` function returns different values depending on its type:
+
+```rust
+struct Foo<T> {}
+
+impl Foo<u32> {
+    fn foo(self) -> Field { 1 }
+}
+
+impl Foo<u64> {
+    fn foo(self) -> Field { 2 }
+}
+
+fn main() {
+    let f1: Foo<u32> = Foo{};
+    let f2: Foo<u64> = Foo{};
+    assert(f1.foo() + f2.foo() == 3);
+}
+```
+
+Also note that impls with the same method name defined in them cannot overlap. For example, if we already have `foo` defined for `Foo<u32>` and `Foo<u64>` like we do above, we cannot also define `foo` in an `impl<T> Foo<T>` since it would be ambiguous which version of `foo` to choose.
+
+```rust
+// Including this impl in the same project as the above snippet would
+// cause an overlapping impls error
+impl<T> Foo<T> {
+    fn foo(self) -> Field { 3 }
+}
+```
+
+## Lambdas
+
+Lambdas are anonymous functions. They follow the syntax of Rust - `|arg1, arg2, ..., argN| return_expression`.
+
+```rust
+let add_50 = |val| val + 50;
+assert(add_50(100) == 150);
+```
+
+See [Lambdas](./lambdas.md) for more details.
+
+## Attributes
+
+Attributes are metadata that can be applied to a function, using the following syntax: `#[attribute(value)]`.
+
+Supported attributes include:
+
+- **builtin**: the function is implemented by the compiler, for efficiency purposes.
+- **deprecated**: mark the function as _deprecated_. Calling the function will generate a warning: `warning: use of deprecated function`
+- **field**: Used to enable conditional compilation of code depending on the field size. See below for more details
+- **oracle**: mark the function as _oracle_; meaning it is an external unconstrained function, implemented in noir_js. See [Unconstrained](./unconstrained.md) and [NoirJS](../../reference/NoirJS/noir_js/index.md) for more details.
+- **test**: mark the function as unit tests. See [Tests](../../tooling/testing.md) for more details
+
+### Field Attribute
+
+The field attribute defines which field the function is compatible for. The function is conditionally compiled, under the condition that the field attribute matches the Noir native field.
+The field can be defined implicitly, by using the name of the elliptic curve usually associated to it - for instance bn254, bls12_381 - or explicitly by using the field (prime) order, in decimal or hexadecimal form.
+As a result, it is possible to define multiple versions of a function with each version specialized for a different field attribute. This can be useful when a function requires different parameters depending on the underlying elliptic curve.
+
+Example: we define the function `foo()` three times below. Once for the default Noir bn254 curve, once for the field $\mathbb F_{23}$, which will normally never be used by Noir, and once again for the bls12_381 curve.
+
+```rust
+#[field(bn254)]
+fn foo() -> u32 {
+    1
+}
+
+#[field(23)]
+fn foo() -> u32 {
+    2
+}
+
+// This commented code would not compile as foo would be defined twice because it is the same field as bn254
+// #[field(21888242871839275222246405745257275088548364400416034343698204186575808495617)]
+// fn foo() -> u32 {
+//     2
+// }
+
+#[field(bls12_381)]
+fn foo() -> u32 {
+    3
+}
+```
+
+If the field name is not known to Noir, it will discard the function. Field names are case insensitive.
diff --git a/docs/versioned_docs/version-v0.35.0/noir/concepts/generics.md b/docs/versioned_docs/version-v0.35.0/noir/concepts/generics.md
new file mode 100644
index 00000000000..c180a0ce7e6
--- /dev/null
+++ b/docs/versioned_docs/version-v0.35.0/noir/concepts/generics.md
@@ -0,0 +1,251 @@
+---
+title: Generics
+description: Learn how to use Generics in Noir
+keywords: [Noir, Rust, generics, functions, structs]
+sidebar_position: 7
+---
+
+Generics allow you to use the same functions with multiple different concrete data types. You can
+read more about the concept of generics in the Rust documentation
+[here](https://doc.rust-lang.org/book/ch10-01-syntax.html).
+
+Here is a trivial example showing the identity function that supports any type. In Rust, it is
+common to refer to the most general type as `T`. We follow the same convention in Noir.
+
+```rust
+fn id<T>(x: T) -> T  {
+    x
+}
+```
+
+## Numeric Generics
+
+If we want to be generic over array lengths (which are type-level integers), we can use numeric
+generics. Using these looks similar to using regular generics, but introducing them into scope
+requires declaring them with `let MyGenericName: IntegerType`. This can be done anywhere a normal
+generic is declared. Instead of types, these generics resolve to integers at compile-time.
+Here's an example of a struct that is generic over the size of the array it contains internally:
+
+```rust
+struct BigInt<let N: u32> {
+    limbs: [u32; N],
+}
+
+impl<let N: u32> BigInt<N> {
+    // `N` is in scope of all methods in the impl
+    fn first(first: BigInt<N>, second: BigInt<N>) -> Self {
+        assert(first.limbs != second.limbs);
+        first
+
+    fn second(first: BigInt<N>, second: Self) -> Self {
+        assert(first.limbs != second.limbs);
+        second
+    }
+}
+```
+
+## In Structs
+
+Generics are useful for specifying types in structs. For example, we can specify that a field in a
+struct will be of a certain generic type. In this case `value` is of type `T`.
+
+```rust
+struct RepeatedValue<T> {
+    value: T,
+    count: Field,
+}
+
+impl<T> RepeatedValue<T> {
+    fn print(self) {
+        for _i in 0 .. self.count {
+            println(self.value);
+        }
+    }
+}
+
+fn main() {
+    let repeated = RepeatedValue { value: "Hello!", count: 2 };
+    repeated.print();
+}
+```
+
+The `print` function will print `Hello!` an arbitrary number of times, twice in this case.
+
+## Calling functions on generic parameters
+
+Since a generic type `T` can represent any type, how can we call functions on the underlying type?
+In other words, how can we go from "any type `T`" to "any type `T` that has certain methods available?"
+
+This is what [traits](../concepts/traits.md) are for in Noir. Here's an example of a function generic over
+any type `T` that implements the `Eq` trait for equality:
+
+```rust
+fn first_element_is_equal<T, let N: u32>(array1: [T; N], array2: [T; N]) -> bool 
+    where T: Eq
+{
+    if (array1.len() == 0) | (array2.len() == 0) {
+        true
+    } else {
+        array1[0] == array2[0]
+    }
+}
+
+fn main() {
+    assert(first_element_is_equal([1, 2, 3], [1, 5, 6]));
+
+    // We can use first_element_is_equal for arrays of any type
+    // as long as we have an Eq impl for the types we pass in
+    let array = [MyStruct::new(), MyStruct::new()];
+    assert(array_eq(array, array, MyStruct::eq));
+}
+
+impl Eq for MyStruct {
+    fn eq(self, other: MyStruct) -> bool {
+        self.foo == other.foo
+    }
+}
+```
+
+You can find more details on traits and trait implementations on the [traits page](../concepts/traits.md).
+
+## Manually Specifying Generics with the Turbofish Operator
+
+There are times when the compiler cannot reasonably infer what type should be used for a generic, or when the developer themselves may want to manually distinguish generic type parameters. This is where the `::<>` turbofish operator comes into play.
+
+The `::<>` operator can follow a variable or path and can be used to manually specify generic arguments within the angle brackets.
+The name "turbofish" comes from that `::<>` looks like a little fish.
+
+Examples:
+```rust
+fn main() {
+    let mut slice = [];
+    slice = slice.push_back(1);
+    slice = slice.push_back(2);
+    // Without turbofish a type annotation would be needed on the left hand side
+    let array = slice.as_array::<2>();
+}
+```
+
+
+```rust
+trait MyTrait {
+    fn ten() -> Self;
+}
+
+impl MyTrait for Field {
+    fn ten() -> Self { 10 }
+}
+
+struct Foo<T> {
+    inner: T
+}
+        
+impl<T> Foo<T> {
+    fn generic_method<U>(_self: Self) -> U where U: MyTrait {
+        U::ten()
+    }
+}
+        
+fn example() {
+    let foo: Foo<Field> = Foo { inner: 1 };
+    // Using a type other than `Field` here (e.g. u32) would fail as 
+    // there is no matching impl for `u32: MyTrait`. 
+    //
+    // Substituting the `10` on the left hand side of this assert
+    // with `10 as u32` would also fail with a type mismatch as we 
+    // are expecting a `Field` from the right hand side.
+    assert(10 as u32 == foo.generic_method::<Field>());
+}
+```
+
+## Arithmetic Generics
+
+In addition to numeric generics, Noir also allows a limited form of arithmetic on generics.
+When you have a numeric generic such as `N`, you can use the following operators on it in a
+type position: `+`, `-`, `*`, `/`, and `%`.
+
+Note that type checking arithmetic generics is a best effort guess from the compiler and there
+are many cases of types that are equal that the compiler may not see as such. For example,
+we know that `T * (N + M)` should be equal to `T*N + T*M` but the compiler does not currently
+apply the distributive law and thus sees these as different types.
+
+Even with this limitation though, the compiler can handle common cases decently well:
+
+```rust
+trait Serialize<let N: u32> {
+    fn serialize(self) -> [Field; N];
+}
+
+impl Serialize<1> for Field {
+    fn serialize(self) -> [Field; 1] {
+        [self]
+    }
+}
+
+impl<T, let N: u32, let M: u32> Serialize<N * M> for [T; N]
+    where T: Serialize<M> { .. }
+
+impl<T, U, let N: u32, let M: u32> Serialize<N + M> for (T, U)
+    where T: Serialize<N>, U: Serialize<M> { .. }
+
+fn main() {
+    let data = (1, [2, 3, 4]);
+    assert_eq(data.serialize().len(), 4);
+}
+```
+
+Note that if there is any over or underflow the types will fail to unify:
+
+```rust title="underflow-example" showLineNumbers 
+fn pop<let N: u32>(array: [Field; N]) -> [Field; N - 1] {
+    let mut result: [Field; N - 1] = std::mem::zeroed();
+    for i in 0..N - 1 {
+        result[i] = array[i];
+    }
+    result
+}
+
+fn main() {
+    // error: Could not determine array length `(0 - 1)`
+    pop([]);
+}
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/test_programs/compile_failure/arithmetic_generics_underflow/src/main.nr#L1-L14" target="_blank" rel="noopener noreferrer">Source code: test_programs/compile_failure/arithmetic_generics_underflow/src/main.nr#L1-L14</a></sub></sup>
+
+
+This also applies if there is underflow in an intermediate calculation:
+
+```rust title="intermediate-underflow-example" showLineNumbers 
+fn main() {
+    // From main it looks like there's nothing sketchy going on
+    seems_fine([]);
+}
+
+// Since `seems_fine` says it can receive and return any length N
+fn seems_fine<let N: u32>(array: [Field; N]) -> [Field; N] {
+    // But inside `seems_fine` we pop from the array which
+    // requires the length to be greater than zero.
+
+    // error: Could not determine array length `(0 - 1)`
+    push_zero(pop(array))
+}
+
+fn pop<let N: u32>(array: [Field; N]) -> [Field; N - 1] {
+    let mut result: [Field; N - 1] = std::mem::zeroed();
+    for i in 0..N - 1 {
+        result[i] = array[i];
+    }
+    result
+}
+
+fn push_zero<let N: u32>(array: [Field; N]) -> [Field; N + 1] {
+    let mut result: [Field; N + 1] = std::mem::zeroed();
+    for i in 0..N {
+        result[i] = array[i];
+    }
+    // index N is already zeroed
+    result
+}
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/test_programs/compile_failure/arithmetic_generics_intermediate_underflow/src/main.nr#L1-L32" target="_blank" rel="noopener noreferrer">Source code: test_programs/compile_failure/arithmetic_generics_intermediate_underflow/src/main.nr#L1-L32</a></sub></sup>
+
diff --git a/docs/versioned_docs/version-v0.35.0/noir/concepts/globals.md b/docs/versioned_docs/version-v0.35.0/noir/concepts/globals.md
new file mode 100644
index 00000000000..1145c55dfc7
--- /dev/null
+++ b/docs/versioned_docs/version-v0.35.0/noir/concepts/globals.md
@@ -0,0 +1,82 @@
+---
+title: Global Variables
+description:
+  Learn about global variables in Noir. Discover how
+  to declare, modify, and use them in your programs.
+keywords: [noir programming language, globals, global variables, constants]
+sidebar_position: 8
+---
+
+## Globals
+
+
+Noir supports global variables. The global's type can be inferred by the compiler entirely:
+
+```rust
+global N = 5; // Same as `global N: Field = 5`
+
+global TUPLE = (3, 2);
+
+fn main() {
+    assert(N == 5);
+    assert(N == TUPLE.0 + TUPLE.1);
+}
+```
+
+:::info
+
+Globals can be defined as any expression, so long as they don't depend on themselves - otherwise there would be a dependency cycle! For example:
+
+```rust
+global T = foo(T); // dependency error
+```
+
+:::
+
+
+If they are initialized to a literal integer, globals can be used to specify an array's length:
+
+```rust
+global N: u32 = 2;
+
+fn main(y : [Field; N]) {
+    assert(y[0] == y[1])
+}
+```
+
+A global from another module can be imported or referenced externally like any other name:
+
+```rust
+global N = 20;
+
+fn main() {
+    assert(my_submodule::N != N);
+}
+
+mod my_submodule {
+    global N: Field = 10;
+}
+```
+
+When a global is used, Noir replaces the name with its definition on each occurrence.
+This means globals defined using function calls will repeat the call each time they're used:
+
+```rust
+global RESULT = foo();
+
+fn foo() -> [Field; 100] { ... }
+```
+
+This is usually fine since Noir will generally optimize any function call that does not
+refer to a program input into a constant. It should be kept in mind however, if the called
+function performs side-effects like `println`, as these will still occur on each use.
+
+### Visibility
+
+By default, like functions, globals are private to the module the exist in. You can use `pub`
+to make the global public or `pub(crate)` to make it public to just its crate:
+
+```rust
+// This global is now public
+pub global N = 5;
+```
\ No newline at end of file
diff --git a/docs/versioned_docs/version-v0.35.0/noir/concepts/lambdas.md b/docs/versioned_docs/version-v0.35.0/noir/concepts/lambdas.md
new file mode 100644
index 00000000000..be3c7e0b5ca
--- /dev/null
+++ b/docs/versioned_docs/version-v0.35.0/noir/concepts/lambdas.md
@@ -0,0 +1,81 @@
+---
+title: Lambdas
+description: Learn how to use anonymous functions in Noir programming language.
+keywords: [Noir programming language, lambda, closure, function, anonymous function]
+sidebar_position: 9
+---
+
+## Introduction
+
+Lambdas are anonymous functions. The syntax is `|arg1, arg2, ..., argN| return_expression`.
+
+```rust
+let add_50 = |val| val + 50;
+assert(add_50(100) == 150);
+```
+
+A block can be used as the body of a lambda, allowing you to declare local variables inside it:
+
+```rust
+let cool = || {
+  let x = 100;
+  let y = 100;
+  x + y
+}
+
+assert(cool() == 200);
+```
+
+## Closures
+
+Inside the body of a lambda, you can use variables defined in the enclosing function. Such lambdas are called **closures**. In this example `x` is defined inside `main` and is accessed from within the lambda:
+
+```rust
+fn main() {
+  let x = 100;
+  let closure = || x + 150;
+  assert(closure() == 250);
+}
+```
+
+## Passing closures to higher-order functions
+
+It may catch you by surprise that the following code fails to compile:
+
+```rust
+fn foo(f: fn () -> Field) -> Field {
+ f()
+}
+
+fn main() {
+  let (x, y) = (50, 50);
+  assert(foo(|| x + y) == 100); // error :(
+}
+```
+
+The reason is that the closure's capture environment affects its type - we have a closure that captures two Fields and `foo`
+expects a regular function as an argument - those are incompatible.
+:::note
+
+Variables contained within the `||` are the closure's parameters, and the expression that follows it is the closure's body. The capture environment is comprised of any variables used in the closure's body that are not parameters.
+
+E.g. in |x| x + y, y would be a captured variable, but x would not be, since it is a parameter of the closure.
+
+:::
+The syntax for the type of a closure is `fn[env](args) -> ret_type`, where `env` is the capture environment of the closure -
+in this example that's `(Field, Field)`.
+
+The best solution in our case is to make `foo` generic over the environment type of its parameter, so that it can be called
+with closures with any environment, as well as with regular functions:
+
+```rust
+fn foo<Env>(f: fn[Env]() -> Field) -> Field {
+ f()
+}
+
+fn main() {
+  let (x, y) = (50, 50);
+  assert(foo(|| x + y) == 100); // compiles fine
+  assert(foo(|| 60) == 60);     // compiles fine
+}
+```
diff --git a/docs/versioned_docs/version-v0.35.0/noir/concepts/mutability.md b/docs/versioned_docs/version-v0.35.0/noir/concepts/mutability.md
new file mode 100644
index 00000000000..fdeef6a87c5
--- /dev/null
+++ b/docs/versioned_docs/version-v0.35.0/noir/concepts/mutability.md
@@ -0,0 +1,121 @@
+---
+title: Mutability
+description:
+  Learn about mutable variables in Noir. Discover how
+  to declare, modify, and use them in your programs.
+keywords: [noir programming language, mutability in noir, mutable variables]
+sidebar_position: 8
+---
+
+Variables in noir can be declared mutable via the `mut` keyword. Mutable variables can be reassigned
+to via an assignment expression.
+
+```rust
+let x = 2;
+x = 3; // error: x must be mutable to be assigned to
+
+let mut y = 3;
+let y = 4; // OK
+```
+
+The `mut` modifier can also apply to patterns:
+
+```rust
+let (a, mut b) = (1, 2);
+a = 11; // error: a must be mutable to be assigned to
+b = 12; // OK
+
+let mut (c, d) = (3, 4);
+c = 13; // OK
+d = 14; // OK
+
+// etc.
+let MyStruct { x: mut y } = MyStruct { x: a };
+// y is now in scope
+```
+
+Note that mutability in noir is local and everything is passed by value, so if a called function
+mutates its parameters then the parent function will keep the old value of the parameters.
+
+```rust
+fn main() -> pub Field {
+    let x = 3;
+    helper(x);
+    x // x is still 3
+}
+
+fn helper(mut x: i32) {
+    x = 4;
+}
+```
+
+## Non-local mutability
+
+Non-local mutability can be achieved through the mutable reference type `&mut T`:
+
+```rust
+fn set_to_zero(x: &mut Field) {
+    *x = 0;
+}
+
+fn main() {
+    let mut y = 42;
+    set_to_zero(&mut y);
+    assert(*y == 0);
+}
+```
+
+When creating a mutable reference, the original variable being referred to (`y` in this
+example) must also be mutable. Since mutable references are a reference type, they must
+be explicitly dereferenced via `*` to retrieve the underlying value. Note that this yields
+a copy of the value, so mutating this copy will not change the original value behind the
+reference:
+
+```rust
+fn main() {
+    let mut x = 1;
+    let x_ref = &mut x;
+
+    let mut y = *x_ref;
+    let y_ref = &mut y;
+
+    x = 2;
+    *x_ref = 3;
+
+    y = 4;
+    *y_ref = 5;
+
+    assert(x == 3);
+    assert(*x_ref == 3);
+    assert(y == 5);
+    assert(*y_ref == 5);
+}
+```
+
+Note that types in Noir are actually deeply immutable so the copy that occurs when
+dereferencing is only a conceptual copy - no additional constraints will occur.
+
+Mutable references can also be stored within structs. Note that there is also
+no lifetime parameter on these unlike rust. This is because the allocated memory
+always lasts the entire program - as if it were an array of one element.
+
+```rust
+struct Foo {
+    x: &mut Field
+}
+
+impl Foo {
+    fn incr(mut self) {
+        *self.x += 1;
+    }
+}
+
+fn main() {
+    let foo = Foo { x: &mut 0 };
+    foo.incr();
+    assert(*foo.x == 1);
+}
+```
+
+In general, you should avoid non-local & shared mutability unless it is needed. Sticking
+to only local mutability will improve readability and potentially improve compiler optimizations as well.
diff --git a/docs/versioned_docs/version-v0.35.0/noir/concepts/ops.md b/docs/versioned_docs/version-v0.35.0/noir/concepts/ops.md
new file mode 100644
index 00000000000..c35c36c38a9
--- /dev/null
+++ b/docs/versioned_docs/version-v0.35.0/noir/concepts/ops.md
@@ -0,0 +1,98 @@
+---
+title: Logical Operations
+description:
+  Learn about the supported arithmetic and logical operations in the Noir programming language.
+  Discover how to perform operations on private input types, integers, and booleans.
+keywords:
+  [
+    Noir programming language,
+    supported operations,
+    arithmetic operations,
+    logical operations,
+    predicate operators,
+    bitwise operations,
+    short-circuiting,
+    backend,
+  ]
+sidebar_position: 3
+---
+
+# Operations
+
+## Table of Supported Operations
+
+| Operation |                          Description                           |                           Requirements |
+| :-------- | :------------------------------------------------------------: | -------------------------------------: |
+| +         |             Adds two private input types together              |            Types must be private input |
+| -         |           Subtracts two private input types together           |            Types must be private input |
+| \*        |          Multiplies two private input types together           |            Types must be private input |
+| /         |            Divides two private input types together            |            Types must be private input |
+| ^         |              XOR two private input types together              |                  Types must be integer |
+| &         |              AND two private input types together              |                  Types must be integer |
+| \|        |              OR two private input types together               |                  Types must be integer |
+| \<\<        |        Left shift an integer by another integer amount         | Types must be integer, shift must be u8 |
+| >>        |        Right shift an integer by another integer amount        | Types must be integer, shift must be u8 |
+| !         |                     Bitwise not of a value                     |        Type must be integer or boolean |
+| \<         |       returns a bool if one value is less than the other       | Upper bound must have a known bit size |
+| \<=        | returns a bool if one value is less than or equal to the other | Upper bound must have a known bit size |
+| >         |       returns a bool if one value is more than the other       | Upper bound must have a known bit size |
+| >=        | returns a bool if one value is more than or equal to the other | Upper bound must have a known bit size |
+| ==        |       returns a bool if one value is equal to the other        |       Both types must not be constants |
+| !=        |     returns a bool if one value is not equal to the other      |       Both types must not be constants |
+
+### Predicate Operators
+
+`<,<=, !=, == , >, >=` are known as predicate/comparison operations because they compare two values.
+This differs from the operations such as `+` where the operands are used in _computation_.
+
+### Bitwise Operations Example
+
+```rust
+fn main(x : Field) {
+    let y = x as u32;
+    let z = y & y;
+}
+```
+
+`z` is implicitly constrained to be the result of `y & y`. The `&` operand is used to denote bitwise
+`&`.
+
+> `x & x` would not compile as `x` is a `Field` and not an integer type.
+
+### Logical Operators
+
+Noir has no support for the logical operators `||` and `&&`. This is because encoding the
+short-circuiting that these operators require can be inefficient for Noir's backend. Instead you can
+use the bitwise operators `|` and `&` which operate identically for booleans, just without the
+short-circuiting.
+
+```rust
+let my_val = 5;
+
+let mut flag = 1;
+if (my_val > 6) | (my_val == 0) {
+    flag = 0;
+}
+assert(flag == 1);
+
+if (my_val != 10) & (my_val < 50) {
+    flag = 0;
+}
+assert(flag == 0);
+```
+
+### Shorthand operators
+
+Noir shorthand operators for most of the above operators, namely `+=, -=, *=, /=, %=, &=, |=, ^=, <<=`, and `>>=`. These allow for more concise syntax. For example:
+
+```rust
+let mut i = 0;
+i = i + 1;
+```
+
+could be written as:
+
+```rust
+let mut i = 0;
+i += 1;
+```
diff --git a/docs/versioned_docs/version-v0.35.0/noir/concepts/oracles.mdx b/docs/versioned_docs/version-v0.35.0/noir/concepts/oracles.mdx
new file mode 100644
index 00000000000..77a2ac1550a
--- /dev/null
+++ b/docs/versioned_docs/version-v0.35.0/noir/concepts/oracles.mdx
@@ -0,0 +1,29 @@
+---
+title: Oracles
+description: Dive into how Noir supports Oracles via RPC calls, and learn how to declare an Oracle in Noir with our comprehensive guide.
+keywords:
+  - Noir
+  - Oracles
+  - RPC Calls
+  - Unconstrained Functions
+  - Programming
+  - Blockchain
+sidebar_position: 6
+---
+
+import Experimental from '@site/src/components/Notes/_experimental.mdx';
+
+<Experimental />
+
+Noir has support for Oracles via RPC calls. This means Noir will make an RPC call and use the return value for proof generation.
+
+Since Oracles are not resolved by Noir, they are [`unconstrained` functions](./unconstrained.md)
+
+You can declare an Oracle through the `#[oracle(<name>)]` flag. Example:
+
+```rust
+#[oracle(get_number_sequence)]
+unconstrained fn get_number_sequence(_size: Field) -> [Field] {}
+```
+
+The timeout for when using an external RPC oracle resolver can be set with the `NARGO_FOREIGN_CALL_TIMEOUT` environment variable. This timeout is in units of milliseconds.
diff --git a/docs/versioned_docs/version-v0.35.0/noir/concepts/shadowing.md b/docs/versioned_docs/version-v0.35.0/noir/concepts/shadowing.md
new file mode 100644
index 00000000000..5ce6130d201
--- /dev/null
+++ b/docs/versioned_docs/version-v0.35.0/noir/concepts/shadowing.md
@@ -0,0 +1,44 @@
+---
+title: Shadowing
+sidebar_position: 12
+---
+
+Noir allows for inheriting variables' values and re-declaring them with the same name similar to Rust, known as shadowing.
+
+For example, the following function is valid in Noir:
+
+```rust
+fn main() {
+    let x = 5;
+
+    {
+        let x = x * 2;
+        assert (x == 10);
+    }
+
+    assert (x == 5);
+}
+```
+
+In this example, a variable x is first defined with the value 5.
+
+The local scope that follows shadows the original x, i.e. creates a local mutable x based on the value of the original x. It is given a value of 2 times the original x.
+
+When we return to the main scope, x once again refers to just the original x, which stays at the value of 5.
+
+## Temporal mutability
+
+One way that shadowing is useful, in addition to ergonomics across scopes, is for temporarily mutating variables.
+
+```rust
+fn main() {
+    let age = 30;
+    // age = age + 5; // Would error as `age` is immutable by default.
+
+    let mut age = age + 5; // Temporarily mutates `age` with a new value.
+
+    let age = age; // Locks `age`'s mutability again.
+
+    assert (age == 35);
+}
+```
diff --git a/docs/versioned_docs/version-v0.35.0/noir/concepts/traits.md b/docs/versioned_docs/version-v0.35.0/noir/concepts/traits.md
new file mode 100644
index 00000000000..5d07e0c68f0
--- /dev/null
+++ b/docs/versioned_docs/version-v0.35.0/noir/concepts/traits.md
@@ -0,0 +1,475 @@
+---
+title: Traits
+description:
+  Traits in Noir can be used to abstract out a common interface for functions across
+  several data types.
+keywords: [noir programming language, traits, interfaces, generic, protocol]
+sidebar_position: 14
+---
+
+## Overview
+
+Traits in Noir are a useful abstraction similar to interfaces or protocols in other languages. Each trait defines
+the interface of several methods contained within the trait. Types can then implement this trait by providing
+implementations for these methods. For example in the program:
+
+```rust
+struct Rectangle {
+    width: Field,
+    height: Field,
+}
+
+impl Rectangle {
+    fn area(self) -> Field {
+        self.width * self.height
+    }
+}
+
+fn log_area(r: Rectangle) {
+    println(r.area());
+}
+```
+
+We have a function `log_area` to log the area of a `Rectangle`. Now how should we change the program if we want this
+function to work on `Triangle`s as well?:
+
+```rust
+struct Triangle {
+    width: Field,
+    height: Field,
+}
+
+impl Triangle {
+    fn area(self) -> Field {
+        self.width * self.height / 2
+    }
+}
+```
+
+Making `log_area` generic over all types `T` would be invalid since not all types have an `area` method. Instead, we can
+introduce a new `Area` trait and make `log_area` generic over all types `T` that implement `Area`:
+
+```rust
+trait Area {
+    fn area(self) -> Field;
+}
+
+fn log_area<T>(shape: T) where T: Area {
+    println(shape.area());
+}
+```
+
+We also need to explicitly implement `Area` for `Rectangle` and `Triangle`. We can do that by changing their existing
+impls slightly. Note that the parameter types and return type of each of our `area` methods must match those defined
+by the `Area` trait.
+
+```rust
+impl Area for Rectangle {
+    fn area(self) -> Field {
+        self.width * self.height
+    }
+}
+
+impl Area for Triangle {
+    fn area(self) -> Field {
+        self.width * self.height / 2
+    }
+}
+```
+
+Now we have a working program that is generic over any type of Shape that is used! Others can even use this program
+as a library with their own types - such as `Circle` - as long as they also implement `Area` for these types.
+
+## Where Clauses
+
+As seen in `log_area` above, when we want to create a function or method that is generic over any type that implements
+a trait, we can add a where clause to the generic function.
+
+```rust
+fn log_area<T>(shape: T) where T: Area {
+    println(shape.area());
+}
+```
+
+It is also possible to apply multiple trait constraints on the same variable at once by combining traits with the `+`
+operator. Similarly, we can have multiple trait constraints by separating each with a comma:
+
+```rust
+fn foo<T, U>(elements: [T], thing: U) where
+    T: Default + Add + Eq,
+    U: Bar,
+{
+    let mut sum = T::default();
+
+    for element in elements {
+        sum += element;
+    }
+
+    if sum == T::default() {
+        thing.bar();
+    }
+}
+```
+
+## Generic Implementations
+
+You can add generics to a trait implementation by adding the generic list after the `impl` keyword:
+
+```rust
+trait Second {
+    fn second(self) -> Field;
+}
+
+impl<T> Second for (T, Field) {
+    fn second(self) -> Field {
+        self.1
+    }
+}
+```
+
+You can also implement a trait for every type this way:
+
+```rust
+trait Debug {
+    fn debug(self);
+}
+
+impl<T> Debug for T {
+    fn debug(self) {
+        println(self);
+    }
+}
+
+fn main() {
+    1.debug();
+}
+```
+
+### Generic Trait Implementations With Where Clauses
+
+Where clauses can be placed on trait implementations themselves to restrict generics in a similar way.
+For example, while `impl<T> Foo for T` implements the trait `Foo` for every type, `impl<T> Foo for T where T: Bar`
+will implement `Foo` only for types that also implement `Bar`. This is often used for implementing generic types.
+For example, here is the implementation for array equality:
+
+```rust
+impl<T, let N: u32> Eq for [T; let N: u32] where T: Eq {
+    // Test if two arrays have the same elements.
+    // Because both arrays must have length N, we know their lengths already match.
+    fn eq(self, other: Self) -> bool {
+        let mut result = true;
+
+        for i in 0 .. self.len() {
+            // The T: Eq constraint is needed to call == on the array elements here
+            result &= self[i] == other[i];
+        }
+
+        result
+    }
+}
+```
+
+Where clauses can also be placed on struct implementations. 
+For example, here is a method utilizing a generic type that implements the equality trait.
+
+```rust
+struct Foo<T> {
+    a: u32,
+    b: T,
+}
+
+impl<T> Foo<T> where T: Eq {
+    fn eq(self, other: Self) -> bool {
+        (self.a == other.a) & self.b.eq(other.b)
+    }
+}
+```
+
+## Generic Traits
+
+Traits themselves can also be generic by placing the generic arguments after the trait name. These generics are in
+scope of every item within the trait.
+
+```rust
+trait Into<T> {
+    // Convert `self` to type `T`
+    fn into(self) -> T;
+}
+```
+
+When implementing generic traits the generic arguments of the trait must be specified. This is also true anytime
+when referencing a generic trait (e.g. in a `where` clause).
+
+```rust
+struct MyStruct {
+    array: [Field; 2],
+}
+
+impl Into<[Field; 2]> for MyStruct {
+    fn into(self) -> [Field; 2] {
+        self.array
+    }
+}
+
+fn as_array<T>(x: T) -> [Field; 2] 
+    where T: Into<[Field; 2]>
+{
+    x.into()
+}
+
+fn main() {
+    let array = [1, 2];
+    let my_struct = MyStruct { array };
+
+    assert_eq(as_array(my_struct), array);
+}
+```
+
+### Associated Types and Constants
+
+Traits also support associated types and constraints which can be thought of as additional generics that are referred to by name.
+
+Here's an example of a trait with an associated type `Foo` and a constant `Bar`:
+
+```rust
+trait MyTrait {
+    type Foo;
+
+    let Bar: u32;
+}
+```
+
+Now when we're implementing `MyTrait` we also have to provide values for `Foo` and `Bar`:
+
+```rust
+impl MyTrait for Field {
+    type Foo = i32;
+
+    let Bar: u32 = 11;
+}
+```
+
+Since associated constants can also be used in a type position, its values are limited to only other
+expression kinds allowed in numeric generics.
+
+Note that currently all associated types and constants must be explicitly specified in a trait constraint.
+If we leave out any, we'll get an error that we're missing one:
+
+```rust
+// Error! Constraint is missing associated constant for `Bar`
+fn foo<T>(x: T) where T: MyTrait<Foo = i32> {
+    ...
+}
+```
+
+Because all associated types and constants must be explicitly specified, they are essentially named generics,
+although this is set to change in the future. Future versions of Noir will allow users to elide associated types
+in trait constraints similar to Rust. When this is done, you may still refer to their value with the `<Type as Trait>::AssociatedType`
+syntax:
+
+```rust
+// Only valid in future versions of Noir:
+fn foo<T>(x: T) where T: MyTrait {
+    let _: <T as MyTrait>::Foo = ...;
+}
+```
+
+The type as trait syntax is possible in Noir today but is less useful when each type must be explicitly specified anyway:
+
+```rust
+fn foo<T, F, let B: u32>(x: T) where T: MyTrait<Foo = F, Bar = B> {
+    // Works, but could just use F directly
+    let _: <T as MyTrait<Foo = F, Bar = B>>::Foo = ...;
+
+    let _: F = ...;
+}
+```
+
+## Trait Methods With No `self`
+
+A trait can contain any number of methods, each of which have access to the `Self` type which represents each type
+that eventually implements the trait. Similarly, the `self` variable is available as well but is not required to be used.
+For example, we can define a trait to create a default value for a type. This trait will need to return the `Self` type
+but doesn't need to take any parameters:
+
+```rust
+trait Default {
+    fn default() -> Self;
+}
+```
+
+Implementing this trait can be done similarly to any other trait:
+
+```rust
+impl Default for Field {
+    fn default() -> Field {
+        0
+    }
+}
+
+struct MyType {}
+
+impl Default for MyType {
+    fn default() -> Field {
+        MyType {}
+    }
+}
+```
+
+However, since there is no `self` parameter, we cannot call it via the method call syntax `object.method()`.
+Instead, we'll need to refer to the function directly. This can be done either by referring to the
+specific impl `MyType::default()` or referring to the trait itself `Default::default()`. In the later
+case, type inference determines the impl that is selected.
+
+```rust
+let my_struct = MyStruct::default();
+
+let x: Field = Default::default();
+let result = x + Default::default();
+```
+
+:::warning
+
+```rust
+let _ = Default::default();
+```
+
+If type inference cannot select which impl to use because of an ambiguous `Self` type, an impl will be
+arbitrarily selected. This occurs most often when the result of a trait function call with no parameters
+is unused. To avoid this, when calling a trait function with no `self` or `Self` parameters or return type,
+always refer to it via the implementation type's namespace - e.g. `MyType::default()`.
+This is set to change to an error in future Noir versions.
+
+:::
+
+## Default Method Implementations
+
+A trait can also have default implementations of its methods by giving a body to the desired functions.
+Note that this body must be valid for all types that may implement the trait. As a result, the only
+valid operations on `self` will be operations valid for any type or other operations on the trait itself.
+
+```rust
+trait Numeric {
+    fn add(self, other: Self) -> Self;
+
+    // Default implementation of double is (self + self)
+    fn double(self) -> Self {
+        self.add(self)
+    }
+}
+```
+
+When implementing a trait with default functions, a type may choose to implement only the required functions:
+
+```rust
+impl Numeric for Field {
+    fn add(self, other: Field) -> Field {
+        self + other
+    }
+}
+```
+
+Or it may implement the optional methods as well:
+
+```rust
+impl Numeric for u32 {
+    fn add(self, other: u32) -> u32 {
+        self + other
+    }
+
+    fn double(self) -> u32 {
+        self * 2
+    }
+}
+```
+
+## Impl Specialization
+
+When implementing traits for a generic type it is possible to implement the trait for only a certain combination
+of generics. This can be either as an optimization or because those specific generics are required to implement the trait.
+
+```rust
+trait Sub {
+    fn sub(self, other: Self) -> Self;
+}
+
+struct NonZero<T> {
+    value: T,
+}
+
+impl Sub for NonZero<Field> {
+    fn sub(self, other: Self) -> Self {
+        let value = self.value - other.value;
+        assert(value != 0);
+        NonZero { value }
+    }
+}
+```
+
+## Overlapping Implementations
+
+Overlapping implementations are disallowed by Noir to ensure Noir's decision on which impl to select is never ambiguous.
+This means if a trait `Foo` is already implemented
+by a type `Bar<T>` for all `T`, then we cannot also have a separate impl for `Bar<Field>` (or any other
+type argument). Similarly, if there is an impl for all `T` such as `impl<T> Debug for T`, we cannot create
+any more impls to `Debug` for other types since it would be ambiguous which impl to choose for any given
+method call.
+
+```rust
+trait Trait {}
+
+// Previous impl defined here
+impl<A, B> Trait for (A, B) {}
+
+// error: Impl for type `(Field, Field)` overlaps with existing impl
+impl Trait for (Field, Field) {}
+```
+
+## Trait Coherence
+
+Another restriction on trait implementations is coherence. This restriction ensures other crates cannot create
+impls that may overlap with other impls, even if several unrelated crates are used as dependencies in the same
+program.
+
+The coherence restriction is: to implement a trait, either the trait itself or the object type must be declared
+in the crate the impl is in.
+
+In practice this often comes up when using types provided by libraries. If a library provides a type `Foo` that does
+not implement a trait in the standard library such as `Default`, you may not `impl Default for Foo` in your own crate.
+While restrictive, this prevents later issues or silent changes in the program if the `Foo` library later added its
+own impl for `Default`. If you are a user of the `Foo` library in this scenario and need a trait not implemented by the
+library your choices are to either submit a patch to the library or use the newtype pattern.
+
+### The Newtype Pattern
+
+The newtype pattern gets around the coherence restriction by creating a new wrapper type around the library type
+that we cannot create `impl`s for. Since the new wrapper type is defined in our current crate, we can create
+impls for any trait we need on it.
+
+```rust
+struct Wrapper {
+    foo: some_library::Foo,
+}
+
+impl Default for Wrapper {
+    fn default() -> Wrapper {
+        Wrapper {
+            foo: some_library::Foo::new(),
+        }
+    }
+}
+```
+
+Since we have an impl for our own type, the behavior of this code will not change even if `some_library` is updated
+to provide its own `impl Default for Foo`. The downside of this pattern is that it requires extra wrapping and
+unwrapping of values when converting to and from the `Wrapper` and `Foo` types.
+
+### Visibility
+
+By default, like functions, traits are private to the module the exist in. You can use `pub`
+to make the trait public or `pub(crate)` to make it public to just its crate:
+
+```rust
+// This trait is now public
+pub trait Trait {}
+```
\ No newline at end of file
diff --git a/docs/versioned_docs/version-v0.35.0/noir/concepts/unconstrained.md b/docs/versioned_docs/version-v0.35.0/noir/concepts/unconstrained.md
new file mode 100644
index 00000000000..b5221b8d2dd
--- /dev/null
+++ b/docs/versioned_docs/version-v0.35.0/noir/concepts/unconstrained.md
@@ -0,0 +1,104 @@
+---
+title: Unconstrained Functions
+description: "Learn about what unconstrained functions in Noir are, how to use them and when you'd want to."
+
+keywords: [Noir programming language, unconstrained, open]
+sidebar_position: 5
+---
+
+Unconstrained functions are functions which do not constrain any of the included computation and allow for non-deterministic computation.
+
+## Why?
+
+Zero-knowledge (ZK) domain-specific languages (DSL) enable developers to generate ZK proofs from their programs by compiling code down to the constraints of an NP complete language (such as R1CS or PLONKish languages). However, the hard bounds of a constraint system can be very limiting to the functionality of a ZK DSL.
+
+Enabling a circuit language to perform unconstrained execution is a powerful tool. Said another way, unconstrained execution lets developers generate witnesses from code that does not generate any constraints. Being able to execute logic outside of a circuit is critical for both circuit performance and constructing proofs on information that is external to a circuit.
+
+Fetching information from somewhere external to a circuit can also be used to enable developers to improve circuit efficiency.
+
+A ZK DSL does not just prove computation, but proves that some computation was handled correctly. Thus, it is necessary that when we switch from performing some operation directly inside of a circuit to inside of an unconstrained environment that the appropriate constraints are still laid down elsewhere in the circuit.
+
+## Example
+
+An in depth example might help drive the point home. This example comes from the excellent [post](https://discord.com/channels/1113924620781883405/1124022445054111926/1128747641853972590) by Tom in the Noir Discord.
+
+Let's look at how we can optimize a function to turn a `u72` into an array of `u8`s.
+
+```rust
+fn main(num: u72) -> pub [u8; 8] {
+    let mut out: [u8; 8] = [0; 8];
+    for i in 0..8 {
+        out[i] = (num >> (56 - (i * 8)) as u72 & 0xff) as u8;
+    }
+
+    out
+}
+```
+
+```
+Total ACIR opcodes generated for language PLONKCSat { width: 3 }: 91
+Backend circuit size: 3619
+```
+
+A lot of the operations in this function are optimized away by the compiler (all the bit-shifts turn into divisions by constants). However we can save a bunch of gates by casting to u8 a bit earlier. This automatically truncates the bit-shifted value to fit in a u8 which allows us to remove the AND against 0xff. This saves us ~480 gates in total.
+
+```rust
+fn main(num: u72) -> pub [u8; 8] {
+    let mut out: [u8; 8] = [0; 8];
+    for i in 0..8 {
+        out[i] = (num >> (56 - (i * 8)) as u8;
+    }
+
+    out
+}
+```
+
+```
+Total ACIR opcodes generated for language PLONKCSat { width: 3 }: 75
+Backend circuit size: 3143
+```
+
+Those are some nice savings already but we can do better. This code is all constrained so we're proving every step of calculating out using num, but we don't actually care about how we calculate this, just that it's correct. This is where brillig comes in.
+
+It turns out that truncating a u72 into a u8 is hard to do inside a snark, each time we do as u8 we lay down 4 ACIR opcodes which get converted into multiple gates. It's actually much easier to calculate num from out than the other way around. All we need to do is multiply each element of out by a constant and add them all together, both relatively easy operations inside a snark.
+
+We can then run `u72_to_u8` as unconstrained brillig code in order to calculate out, then use that result in our constrained function and assert that if we were to do the reverse calculation we'd get back num. This looks a little like the below:
+
+```rust
+fn main(num: u72) -> pub [u8; 8] {
+    let out = unsafe { 
+        u72_to_u8(num) 
+    };
+
+    let mut reconstructed_num: u72 = 0;
+    for i in 0..8 {
+        reconstructed_num += (out[i] as u72 << (56 - (8 * i)));
+    }
+    assert(num == reconstructed_num);
+    out
+}
+
+unconstrained fn u72_to_u8(num: u72) -> [u8; 8] {
+    let mut out: [u8; 8] = [0; 8];
+    for i in 0..8 {
+        out[i] = (num >> (56 - (i * 8))) as u8;
+    }
+    out
+}
+```
+
+```
+Total ACIR opcodes generated for language PLONKCSat { width: 3 }: 78
+Backend circuit size: 2902
+```
+
+This ends up taking off another ~250 gates from our circuit! We've ended up with more ACIR opcodes than before but they're easier for the backend to prove (resulting in fewer gates).
+
+Note that in order to invoke unconstrained functions we need to wrap them in an `unsafe` block,
+to make it clear that the call is unconstrained.
+
+Generally we want to use brillig whenever there's something that's easy to verify but hard to compute within the circuit. For example, if you wanted to calculate a square root of a number it'll be a much better idea to calculate this in brillig and then assert that if you square the result you get back your number.
+
+## Break and Continue
+
+In addition to loops over runtime bounds, `break` and `continue` are also available in unconstrained code. See [break and continue](../concepts/control_flow.md#break-and-continue)
diff --git a/docs/versioned_docs/version-v0.35.0/noir/modules_packages_crates/_category_.json b/docs/versioned_docs/version-v0.35.0/noir/modules_packages_crates/_category_.json
new file mode 100644
index 00000000000..1debcfe7675
--- /dev/null
+++ b/docs/versioned_docs/version-v0.35.0/noir/modules_packages_crates/_category_.json
@@ -0,0 +1,6 @@
+{
+    "label": "Modules, Packages and Crates",
+    "position": 2,
+    "collapsible": true,
+    "collapsed": true
+}
diff --git a/docs/versioned_docs/version-v0.35.0/noir/modules_packages_crates/crates_and_packages.md b/docs/versioned_docs/version-v0.35.0/noir/modules_packages_crates/crates_and_packages.md
new file mode 100644
index 00000000000..95ee9f52ab2
--- /dev/null
+++ b/docs/versioned_docs/version-v0.35.0/noir/modules_packages_crates/crates_and_packages.md
@@ -0,0 +1,43 @@
+---
+title: Crates and Packages
+description: Learn how to use Crates and Packages in your Noir project
+keywords: [Nargo, dependencies, package management, crates, package]
+sidebar_position: 0
+---
+
+## Crates
+
+A crate is the smallest amount of code that the Noir compiler considers at a time.
+Crates can contain modules, and the modules may be defined in other files that get compiled with the crate, as we’ll see in the coming sections.
+
+### Crate Types
+
+A Noir crate can come in several forms: binaries, libraries or contracts.
+
+#### Binaries
+
+_Binary crates_ are programs which you can compile to an ACIR circuit which you can then create proofs against. Each must have a function called `main` that defines the ACIR circuit which is to be proved.
+
+#### Libraries
+
+_Library crates_ don't have a `main` function and they don't compile down to ACIR. Instead they define functionality intended to be shared with multiple projects, and eventually included in a binary crate.
+
+#### Contracts
+
+Contract crates are similar to binary crates in that they compile to ACIR which you can create proofs against. They are different in that they do not have a single `main` function, but are a collection of functions to be deployed to the [Aztec network](https://aztec.network). You can learn more about the technical details of Aztec in the [monorepo](https://github.com/AztecProtocol/aztec-packages) or contract [examples](https://github.com/AztecProtocol/aztec-packages/tree/master/noir-projects/noir-contracts/contracts).
+
+### Crate Root
+
+Every crate has a root, which is the source file that the compiler starts, this is also known as the root module. The Noir compiler does not enforce any conditions on the name of the file which is the crate root, however if you are compiling via Nargo the crate root must be called `lib.nr` or `main.nr` for library or binary crates respectively.
+
+## Packages
+
+A Nargo _package_ is a collection of one of more crates that provides a set of functionality. A package must include a Nargo.toml file.
+
+A package _must_ contain either a library or a binary crate, but not both.
+
+### Differences from Cargo Packages
+
+One notable difference between Rust's Cargo and Noir's Nargo is that while Cargo allows a package to contain an unlimited number of binary crates and a single library crate, Nargo currently only allows a package to contain a single crate.
+
+In future this restriction may be lifted to allow a Nargo package to contain both a binary and library crate or multiple binary crates.
diff --git a/docs/versioned_docs/version-v0.35.0/noir/modules_packages_crates/dependencies.md b/docs/versioned_docs/version-v0.35.0/noir/modules_packages_crates/dependencies.md
new file mode 100644
index 00000000000..24e02de08fe
--- /dev/null
+++ b/docs/versioned_docs/version-v0.35.0/noir/modules_packages_crates/dependencies.md
@@ -0,0 +1,124 @@
+---
+title: Dependencies
+description:
+  Learn how to specify and manage dependencies in Nargo, allowing you to upload packages to GitHub
+  and use them easily in your project.
+keywords: [Nargo, dependencies, GitHub, package management, versioning]
+sidebar_position: 1
+---
+
+Nargo allows you to upload packages to GitHub and use them as dependencies.
+
+## Specifying a dependency
+
+Specifying a dependency requires a tag to a specific commit and the git url to the url containing
+the package.
+
+Currently, there are no requirements on the tag contents. If requirements are added, it would follow
+semver 2.0 guidelines.
+
+> Note: Without a `tag` , there would be no versioning and dependencies would change each time you
+> compile your project.
+
+For example, to add the [ecrecover-noir library](https://github.com/colinnielsen/ecrecover-noir) to your project, add it to `Nargo.toml`:
+
+```toml
+# Nargo.toml
+
+[dependencies]
+ecrecover = {tag = "v0.8.0", git = "https://github.com/colinnielsen/ecrecover-noir"}
+```
+
+If the module is in a subdirectory, you can define a subdirectory in your git repository, for example:
+
+```toml
+# Nargo.toml
+
+[dependencies]
+easy_private_token_contract = {tag ="v0.1.0-alpha62", git = "https://github.com/AztecProtocol/aztec-packages", directory = "noir-contracts/contracts/easy_private_token_contract"}
+```
+
+## Specifying a local dependency
+
+You can also specify dependencies that are local to your machine.
+
+For example, this file structure has a library and binary crate
+
+```tree
+├── binary_crate
+│   ├── Nargo.toml
+│   └── src
+│       └── main.nr
+└── lib_a
+    ├── Nargo.toml
+    └── src
+        └── lib.nr
+```
+
+Inside of the binary crate, you can specify:
+
+```toml
+# Nargo.toml
+
+[dependencies]
+lib_a = { path = "../lib_a" }
+```
+
+## Importing dependencies
+
+You can import a dependency to a Noir file using the following syntax. For example, to import the
+ecrecover-noir library and local lib_a referenced above:
+
+```rust
+use ecrecover;
+use lib_a;
+```
+
+You can also import only the specific parts of dependency that you want to use, like so:
+
+```rust
+use std::hash::sha256;
+use std::scalar_mul::fixed_base_embedded_curve;
+```
+
+Lastly, as demonstrated in the
+[elliptic curve example](../standard_library/cryptographic_primitives/ec_primitives.md#examples), you
+can import multiple items in the same line by enclosing them in curly braces:
+
+```rust
+use std::ec::tecurve::affine::{Curve, Point};
+```
+
+We don't have a way to consume libraries from inside a [workspace](./workspaces.md) as external dependencies right now.
+
+Inside a workspace, these are consumed as `{ path = "../to_lib" }` dependencies in Nargo.toml.
+
+## Dependencies of Dependencies
+
+Note that when you import a dependency, you also get access to all of the dependencies of that package.
+
+For example, the [phy_vector](https://github.com/resurgencelabs/phy_vector) library imports an [fraction](https://github.com/resurgencelabs/fraction) library. If you're importing the phy_vector library, then you can access the functions in fractions library like so:
+
+```rust
+use phy_vector;
+
+fn main(x : Field, y : pub Field) {
+  //...
+  let f = phy_vector::fraction::toFraction(true, 2, 1);
+  //...
+}
+```
+
+## Available Libraries
+
+Noir does not currently have an official package manager. You can find a list of available Noir libraries in the [awesome-noir repo here](https://github.com/noir-lang/awesome-noir#libraries).
+
+Some libraries that are available today include:
+
+- [Standard Library](https://github.com/noir-lang/noir/tree/master/noir_stdlib) - the Noir Standard Library
+- [Ethereum Storage Proof Verification](https://github.com/aragonzkresearch/noir-trie-proofs) - a library that contains the primitives necessary for RLP decoding (in the form of look-up table construction) and Ethereum state and storage proof verification (or verification of any trie proof involving 32-byte long keys)
+- [BigInt](https://github.com/shuklaayush/noir-bigint) - a library that provides a custom BigUint56 data type, allowing for computations on large unsigned integers
+- [ECrecover](https://github.com/colinnielsen/ecrecover-noir/tree/main) - a library to verify an ECDSA signature and return the source Ethereum address
+- [Sparse Merkle Tree Verifier](https://github.com/vocdoni/smtverifier-noir/tree/main) - a library for verification of sparse Merkle trees
+- [Signed Int](https://github.com/resurgencelabs/signed_int) - a library for accessing a custom Signed Integer data type, allowing access to negative numbers on Noir
+- [Fraction](https://github.com/resurgencelabs/fraction) - a library for accessing fractional number data type in Noir, allowing results that aren't whole numbers
diff --git a/docs/versioned_docs/version-v0.35.0/noir/modules_packages_crates/modules.md b/docs/versioned_docs/version-v0.35.0/noir/modules_packages_crates/modules.md
new file mode 100644
index 00000000000..05399c38b4c
--- /dev/null
+++ b/docs/versioned_docs/version-v0.35.0/noir/modules_packages_crates/modules.md
@@ -0,0 +1,221 @@
+---
+title: Modules
+description:
+  Learn how to organize your files using modules in Noir, following the same convention as Rust's
+  module system. Examples included.
+keywords: [Noir, Rust, modules, organizing files, sub-modules]
+sidebar_position: 2
+---
+
+Noir's module system follows the same convention as the _newer_ version of Rust's module system.
+
+## Purpose of Modules
+
+Modules are used to organize files. Without modules all of your code would need to live in a single
+file. In Noir, the compiler does not automatically scan all of your files to detect modules. This
+must be done explicitly by the developer.
+
+## Examples
+
+### Importing a module in the crate root
+
+Filename : `src/main.nr`
+
+```rust
+mod foo;
+
+fn main() {
+    foo::hello_world();
+}
+```
+
+Filename : `src/foo.nr`
+
+```rust
+fn from_foo() {}
+```
+
+In the above snippet, the crate root is the `src/main.nr` file. The compiler sees the module
+declaration `mod foo` which prompts it to look for a foo.nr file.
+
+Visually this module hierarchy looks like the following :
+
+```
+crate
+ ├── main
+ │
+ └── foo
+      └── from_foo
+
+```
+
+The module filename may also be the name of the module as a directory with the contents in a 
+file named `mod.nr` within that directory. The above example can alternatively be expressed like this:
+
+Filename : `src/main.nr`
+
+```rust
+mod foo;
+
+fn main() {
+    foo::hello_world();
+}
+```
+
+Filename : `src/foo/mod.nr`
+
+```rust
+fn from_foo() {}
+```
+
+Note that it's an error to have both files `src/foo.nr` and `src/foo/mod.nr` in the filesystem.
+
+### Importing a module throughout the tree
+
+All modules are accessible from the `crate::` namespace.
+
+```
+crate
+ ├── bar
+ ├── foo
+ └── main
+
+```
+
+In the above snippet, if `bar` would like to use functions in `foo`, it can do so by `use crate::foo::function_name`.
+
+### Sub-modules
+
+Filename : `src/main.nr`
+
+```rust
+mod foo;
+
+fn main() {
+    foo::from_foo();
+}
+```
+
+Filename : `src/foo.nr`
+
+```rust
+mod bar;
+fn from_foo() {}
+```
+
+Filename : `src/foo/bar.nr`
+
+```rust
+fn from_bar() {}
+```
+
+In the above snippet, we have added an extra module to the module tree; `bar`. `bar` is a submodule
+of `foo` hence we declare bar in `foo.nr` with `mod bar`. Since `foo` is not the crate root, the
+compiler looks for the file associated with the `bar` module in `src/foo/bar.nr`
+
+Visually the module hierarchy looks as follows:
+
+```
+crate
+ ├── main
+ │
+ └── foo
+      ├── from_foo
+      └── bar
+           └── from_bar
+```
+
+Similar to importing a module in the crate root, modules can be placed in a `mod.nr` file, like this:
+
+Filename : `src/main.nr`
+
+```rust
+mod foo;
+
+fn main() {
+    foo::from_foo();
+}
+```
+
+Filename : `src/foo/mod.nr`
+
+```rust
+mod bar;
+fn from_foo() {}
+```
+
+Filename : `src/foo/bar/mod.nr`
+
+```rust
+fn from_bar() {}
+```
+
+### Referencing a parent module 
+
+Given a submodule, you can refer to its parent module using the `super` keyword.
+
+Filename : `src/main.nr`
+
+```rust
+mod foo;
+
+fn main() {
+    foo::from_foo();
+}
+```
+
+Filename : `src/foo.nr`
+
+```rust
+mod bar;
+
+fn from_foo() {}
+```
+
+Filename : `src/foo/bar.nr`
+
+```rust
+// Same as bar::from_foo
+use super::from_foo; 
+
+fn from_bar() {
+    from_foo();        // invokes super::from_foo(), which is bar::from_foo()
+    super::from_foo(); // also invokes bar::from_foo()
+}
+```
+
+### `use` visibility
+
+`use` declarations are private to the containing module, by default. However, like functions, 
+they can be marked as `pub` or `pub(crate)`. Such a use declaration serves to _re-export_ a name. 
+A public `use` declaration can therefore redirect some public name to a different target definition: 
+even a definition with a private canonical path, inside a different module.
+
+An example of re-exporting:
+
+```rust
+mod some_module {
+    pub use foo::{bar, baz};
+    mod foo {
+        pub fn bar() {}
+        pub fn baz() {}
+    }
+}
+
+fn main() {
+    some_module::bar();
+    some_module::baz();
+}
+```
+
+In this example, the module `some_module` re-exports two public names defined in `foo`.
+
+### Visibility
+
+By default, like functions, modules are private to the module (or crate) the exist in. You can use `pub`
+to make the module public or `pub(crate)` to make it public to just its crate:
+
+```rust
+// This module is now public and can be seen by other crates.
+pub mod foo;
+```
\ No newline at end of file
diff --git a/docs/versioned_docs/version-v0.35.0/noir/modules_packages_crates/workspaces.md b/docs/versioned_docs/version-v0.35.0/noir/modules_packages_crates/workspaces.md
new file mode 100644
index 00000000000..513497f12bf
--- /dev/null
+++ b/docs/versioned_docs/version-v0.35.0/noir/modules_packages_crates/workspaces.md
@@ -0,0 +1,42 @@
+---
+title: Workspaces
+sidebar_position: 3
+---
+
+Workspaces are a feature of nargo that allow you to manage multiple related Noir packages in a single repository. A workspace is essentially a group of related projects that share common build output directories and configurations.
+
+Each Noir project (with it's own Nargo.toml file) can be thought of as a package. Each package is expected to contain exactly one "named circuit", being the "name" defined in Nargo.toml with the program logic defined in `./src/main.nr`.
+
+For a project with the following structure:
+
+```tree
+├── crates
+│   ├── a
+│   │   ├── Nargo.toml
+│   │   └── Prover.toml
+│   │   └── src
+│   │       └── main.nr
+│   └── b
+│       ├── Nargo.toml
+│       └── Prover.toml
+│       └── src
+│           └── main.nr
+│
+└── Nargo.toml
+```
+
+You can define a workspace in Nargo.toml like so:
+
+```toml
+[workspace]
+members = ["crates/a", "crates/b"]
+default-member = "crates/a"
+```
+
+`members` indicates which packages are included in the workspace. As such, all member packages of a workspace will be processed when the `--workspace` flag is used with various commands or if a `default-member` is not specified.
+
+`default-member` indicates which package various commands process by default.
+
+Libraries can be defined in a workspace. Inside a workspace, these are consumed as `{ path = "../to_lib" }` dependencies in Nargo.toml.
+
+Inside a workspace, these are consumed as `{ path = "../to_lib" }` dependencies in Nargo.toml.
diff --git a/docs/versioned_docs/version-v0.35.0/noir/standard_library/_category_.json b/docs/versioned_docs/version-v0.35.0/noir/standard_library/_category_.json
new file mode 100644
index 00000000000..af04c0933fd
--- /dev/null
+++ b/docs/versioned_docs/version-v0.35.0/noir/standard_library/_category_.json
@@ -0,0 +1,6 @@
+{
+    "label": "Standard Library",
+    "position": 1,
+    "collapsible": true,
+    "collapsed": true
+}
diff --git a/docs/versioned_docs/version-v0.35.0/noir/standard_library/bigint.md b/docs/versioned_docs/version-v0.35.0/noir/standard_library/bigint.md
new file mode 100644
index 00000000000..b16fed4ed96
--- /dev/null
+++ b/docs/versioned_docs/version-v0.35.0/noir/standard_library/bigint.md
@@ -0,0 +1,127 @@
+---
+title: Big Integers
+description: How to use big integers from Noir standard library
+keywords:
+  [
+    Big Integer,
+    Noir programming language,
+    Noir libraries,
+  ]
+---
+
+The BigInt module in the standard library exposes some class of integers which do not fit (well) into a Noir native field. It implements modulo arithmetic, modulo a 'big' prime number.
+
+:::note
+
+The module can currently be considered as `Field`s with fixed modulo sizes used by a set of elliptic curves, in addition to just the native curve. [More work](https://github.com/noir-lang/noir/issues/510) is needed to achieve arbitrarily sized big integers.
+
+:::note
+
+`nargo` can be built with `--profile release-pedantic` to enable extra overflow checks which may affect `BigInt` results in some cases.
+Consider the [`noir-bignum`](https://github.com/noir-lang/noir-bignum) library for an optimized alternative approach.
+
+:::
+
+Currently 6 classes of integers (i.e 'big' prime numbers) are available in the module, namely:
+
+- BN254 Fq: Bn254Fq
+- BN254 Fr: Bn254Fr
+- Secp256k1 Fq: Secpk1Fq
+- Secp256k1 Fr: Secpk1Fr
+- Secp256r1 Fr: Secpr1Fr
+- Secp256r1 Fq: Secpr1Fq
+
+Where XXX Fq and XXX Fr denote respectively the order of the base and scalar field of the (usual) elliptic curve XXX.
+For instance the big integer 'Secpk1Fq' in the standard library refers to integers modulo $2^{256}-2^{32}-977$.
+
+Feel free to explore the source code for the other primes:
+
+```rust title="big_int_definition" showLineNumbers 
+pub struct BigInt {
+    pointer: u32,
+    modulus: u32,
+}
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/bigint.nr#L14-L19" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/bigint.nr#L14-L19</a></sub></sup>
+
+
+## Example usage
+
+A common use-case is when constructing a big integer from its bytes representation, and performing arithmetic operations on it:
+
+```rust title="big_int_example" showLineNumbers 
+fn big_int_example(x: u8, y: u8) {
+    let a = Secpk1Fq::from_le_bytes(&[x, y, 0, 45, 2]);
+    let b = Secpk1Fq::from_le_bytes(&[y, x, 9]);
+    let c = (a + b) * b / a;
+    let d = c.to_le_bytes();
+    println(d[0]);
+}
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/test_programs/execution_success/bigint/src/main.nr#L72-L80" target="_blank" rel="noopener noreferrer">Source code: test_programs/execution_success/bigint/src/main.nr#L72-L80</a></sub></sup>
+
+
+## Methods
+
+The available operations for each big integer are:
+
+### from_le_bytes
+
+Construct a big integer from its little-endian bytes representation. Example:
+
+```rust
+ // Construct a big integer from a slice of bytes
+ let a = Secpk1Fq::from_le_bytes(&[x, y, 0, 45, 2]);
+ // Construct a big integer from an array of 32 bytes
+ let a = Secpk1Fq::from_le_bytes_32([1;32]);
+ ```
+
+Sure, here's the formatted version of the remaining methods:
+
+### to_le_bytes
+
+Return the little-endian bytes representation of a big integer. Example:
+
+```rust
+let bytes = a.to_le_bytes();
+```
+
+### add
+
+Add two big integers. Example:
+
+```rust
+let sum = a + b;
+```
+
+### sub
+
+Subtract two big integers. Example:
+
+```rust
+let difference = a - b;
+```
+
+### mul
+
+Multiply two big integers. Example:
+
+```rust
+let product = a * b;
+```
+
+### div
+
+Divide two big integers. Note that division is field division and not euclidean division. Example:
+
+```rust
+let quotient = a / b;
+```
+
+### eq
+
+Compare two big integers. Example:
+
+```rust
+let are_equal = a == b;
+```
diff --git a/docs/versioned_docs/version-v0.35.0/noir/standard_library/black_box_fns.md b/docs/versioned_docs/version-v0.35.0/noir/standard_library/black_box_fns.md
new file mode 100644
index 00000000000..d6079ab182c
--- /dev/null
+++ b/docs/versioned_docs/version-v0.35.0/noir/standard_library/black_box_fns.md
@@ -0,0 +1,32 @@
+---
+title: Black Box Functions
+description: Black box functions are functions in Noir that rely on backends implementing support for specialized constraints.
+keywords: [noir, black box functions]
+---
+
+Black box functions are functions in Noir that rely on backends implementing support for specialized constraints. This makes certain zk-snark unfriendly computations cheaper than if they were implemented in Noir.
+
+The ACVM spec defines a set of blackbox functions which backends will be expected to implement. This allows backends to use optimized implementations of these constraints if they have them, however they may also fallback to less efficient naive implementations if not.
+
+## Function list
+
+Here is a list of the current black box functions:
+
+- [AES128](./cryptographic_primitives/ciphers.mdx#aes128)
+- [SHA256](./cryptographic_primitives/hashes.mdx#sha256)
+- [Schnorr signature verification](./cryptographic_primitives/schnorr.mdx)
+- [Blake2s](./cryptographic_primitives/hashes.mdx#blake2s)
+- [Blake3](./cryptographic_primitives/hashes.mdx#blake3)
+- [Pedersen Hash](./cryptographic_primitives/hashes.mdx#pedersen_hash)
+- [Pedersen Commitment](./cryptographic_primitives/hashes.mdx#pedersen_commitment)
+- [ECDSA signature verification](./cryptographic_primitives/ecdsa_sig_verification.mdx)
+- [Embedded curve operations (MSM, addition, ...)](./cryptographic_primitives/embedded_curve_ops.mdx)
+- AND
+- XOR
+- RANGE
+- [Keccak256](./cryptographic_primitives/hashes.mdx#keccak256)
+- [Recursive proof verification](./recursion.mdx)
+
+Most black box functions are included as part of the Noir standard library, however `AND`, `XOR` and `RANGE` are used as part of the Noir language syntax. For instance, using the bitwise operator `&` will invoke the `AND` black box function.
+
+You can view the black box functions defined in the ACVM code [here](https://github.com/noir-lang/noir/blob/master/acvm-repo/acir/src/circuit/black_box_functions.rs).
diff --git a/docs/versioned_docs/version-v0.35.0/noir/standard_library/bn254.md b/docs/versioned_docs/version-v0.35.0/noir/standard_library/bn254.md
new file mode 100644
index 00000000000..3294f005dbb
--- /dev/null
+++ b/docs/versioned_docs/version-v0.35.0/noir/standard_library/bn254.md
@@ -0,0 +1,46 @@
+---
+title: Bn254 Field Library
+---
+
+Noir provides a module in standard library with some optimized functions for bn254 Fr in `std::field::bn254`.
+
+## decompose
+
+```rust
+fn decompose(x: Field) -> (Field, Field) {}
+```
+
+Decomposes a single field into two fields, low and high. The low field contains the lower 16 bytes of the input field and the high field contains the upper 16 bytes of the input field. Both field results are range checked to 128 bits.
+
+
+## assert_gt
+
+```rust
+fn assert_gt(a: Field, b: Field) {}
+```
+
+Asserts that a > b. This will generate less constraints than using `assert(gt(a, b))`.
+
+## assert_lt
+
+```rust
+fn assert_lt(a: Field, b: Field) {}
+```
+
+Asserts that a < b. This will generate less constraints than using `assert(lt(a, b))`.
+
+## gt
+
+```rust
+fn gt(a: Field, b: Field) -> bool  {}
+```
+
+Returns true if a > b.
+
+## lt
+
+```rust
+fn lt(a: Field, b: Field) -> bool  {}
+```
+
+Returns true if a < b.
\ No newline at end of file
diff --git a/docs/versioned_docs/version-v0.35.0/noir/standard_library/containers/boundedvec.md b/docs/versioned_docs/version-v0.35.0/noir/standard_library/containers/boundedvec.md
new file mode 100644
index 00000000000..b20b49f863c
--- /dev/null
+++ b/docs/versioned_docs/version-v0.35.0/noir/standard_library/containers/boundedvec.md
@@ -0,0 +1,419 @@
+---
+title: Bounded Vectors
+keywords: [noir, vector, bounded vector, slice]
+sidebar_position: 1
+---
+
+A `BoundedVec<T, MaxLen>` is a growable storage similar to a `Vec<T>` except that it
+is bounded with a maximum possible length. Unlike `Vec`, `BoundedVec` is not implemented
+via slices and thus is not subject to the same restrictions slices are (notably, nested
+slices - and thus nested vectors as well - are disallowed).
+
+Since a BoundedVec is backed by a normal array under the hood, growing the BoundedVec by
+pushing an additional element is also more efficient - the length only needs to be increased
+by one.
+
+For these reasons `BoundedVec<T, N>` should generally be preferred over `Vec<T>` when there
+is a reasonable maximum bound that can be placed on the vector.
+
+Example:
+
+```rust
+let mut vector: BoundedVec<Field, 10> = BoundedVec::new();
+for i in 0..5 {
+    vector.push(i);
+}
+assert(vector.len() == 5);
+assert(vector.max_len() == 10);
+```
+
+## Methods
+
+### new
+
+```rust
+pub fn new() -> Self
+```
+
+Creates a new, empty vector of length zero.
+
+Since this container is backed by an array internally, it still needs an initial value
+to give each element. To resolve this, each element is zeroed internally. This value
+is guaranteed to be inaccessible unless `get_unchecked` is used.
+
+Example:
+
+```rust
+let empty_vector: BoundedVec<Field, 10> = BoundedVec::new();
+assert(empty_vector.len() == 0);
+```
+
+Note that whenever calling `new` the maximum length of the vector should always be specified
+via a type signature:
+
+```rust title="new_example" showLineNumbers 
+fn good() -> BoundedVec<Field, 10> {
+    // Ok! MaxLen is specified with a type annotation
+    let v1: BoundedVec<Field, 3> = BoundedVec::new();
+    let v2 = BoundedVec::new();
+
+    // Ok! MaxLen is known from the type of `good`'s return value
+    v2
+}
+
+fn bad() {
+    // Error: Type annotation needed
+    // The compiler can't infer `MaxLen` from this code.
+    let mut v3 = BoundedVec::new();
+    v3.push(5);
+}
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/test_programs/noir_test_success/bounded_vec/src/main.nr#L11-L27" target="_blank" rel="noopener noreferrer">Source code: test_programs/noir_test_success/bounded_vec/src/main.nr#L11-L27</a></sub></sup>
+
+
+This defaulting of `MaxLen` (and numeric generics in general) to zero may change in future noir versions
+but for now make sure to use type annotations when using bounded vectors. Otherwise, you will receive a constraint failure at runtime when the vec is pushed to.
+
+### get
+
+```rust
+pub fn get(self, index: u64) -> T {
+```
+
+Retrieves an element from the vector at the given index, starting from zero.
+
+If the given index is equal to or greater than the length of the vector, this
+will issue a constraint failure.
+
+Example:
+
+```rust
+fn foo<N>(v: BoundedVec<u32, N>) {
+    let first = v.get(0);
+    let last = v.get(v.len() - 1);
+    assert(first != last);
+}
+```
+
+### get_unchecked
+
+```rust
+pub fn get_unchecked(self, index: u64) -> T {
+```
+
+Retrieves an element from the vector at the given index, starting from zero, without
+performing a bounds check.
+
+Since this function does not perform a bounds check on length before accessing the element,
+it is unsafe! Use at your own risk!
+
+Example:
+
+```rust title="get_unchecked_example" showLineNumbers 
+fn sum_of_first_three<let N: u32>(v: BoundedVec<u32, N>) -> u32 {
+    // Always ensure the length is larger than the largest
+    // index passed to get_unchecked
+    assert(v.len() > 2);
+    let first = v.get_unchecked(0);
+    let second = v.get_unchecked(1);
+    let third = v.get_unchecked(2);
+    first + second + third
+}
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/test_programs/noir_test_success/bounded_vec/src/main.nr#L54-L64" target="_blank" rel="noopener noreferrer">Source code: test_programs/noir_test_success/bounded_vec/src/main.nr#L54-L64</a></sub></sup>
+
+
+### set
+
+```rust
+pub fn set(&mut self: Self, index: u64, value: T) {
+```
+
+Writes an element to the vector at the given index, starting from zero.
+
+If the given index is equal to or greater than the length of the vector, this will issue a constraint failure.
+
+Example:
+
+```rust
+fn foo<N>(v: BoundedVec<u32, N>) {
+    let first = v.get(0);
+    assert(first != 42);
+    v.set(0, 42);
+    let new_first = v.get(0);
+    assert(new_first == 42);
+}
+```
+
+### set_unchecked
+
+```rust
+pub fn set_unchecked(&mut self: Self, index: u64, value: T) -> T {
+```
+
+Writes an element to the vector at the given index, starting from zero, without performing a bounds check.
+
+Since this function does not perform a bounds check on length before accessing the element, it is unsafe! Use at your own risk!
+
+Example:
+
+```rust title="set_unchecked_example" showLineNumbers 
+fn set_unchecked_example() {
+    let mut vec: BoundedVec<u32, 5> = BoundedVec::new();
+    vec.extend_from_array([1, 2]);
+
+    // Here we're safely writing within the valid range of `vec`
+    // `vec` now has the value [42, 2]
+    vec.set_unchecked(0, 42);
+
+    // We can then safely read this value back out of `vec`.
+    // Notice that we use the checked version of `get` which would prevent reading unsafe values.
+    assert_eq(vec.get(0), 42);
+
+    // We've now written past the end of `vec`.
+    // As this index is still within the maximum potential length of `v`,
+    // it won't cause a constraint failure. 
+    vec.set_unchecked(2, 42);
+    println(vec);
+
+    // This will write past the end of the maximum potential length of `vec`,
+    // it will then trigger a constraint failure.
+    vec.set_unchecked(5, 42);
+    println(vec);
+}
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/test_programs/noir_test_success/bounded_vec/src/main.nr#L67-L91" target="_blank" rel="noopener noreferrer">Source code: test_programs/noir_test_success/bounded_vec/src/main.nr#L67-L91</a></sub></sup>
+
+
+
+### push
+
+```rust
+pub fn push(&mut self, elem: T) {
+```
+
+Pushes an element to the end of the vector. This increases the length
+of the vector by one.
+
+Panics if the new length of the vector will be greater than the max length.
+
+Example:
+
+```rust title="bounded-vec-push-example" showLineNumbers 
+let mut v: BoundedVec<Field, 2> = BoundedVec::new();
+
+    v.push(1);
+    v.push(2);
+
+    // Panics with failed assertion "push out of bounds"
+    v.push(3);
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/test_programs/noir_test_success/bounded_vec/src/main.nr#L95-L103" target="_blank" rel="noopener noreferrer">Source code: test_programs/noir_test_success/bounded_vec/src/main.nr#L95-L103</a></sub></sup>
+
+
+### pop
+
+```rust
+pub fn pop(&mut self) -> T
+```
+
+Pops the element at the end of the vector. This will decrease the length
+of the vector by one.
+
+Panics if the vector is empty.
+
+Example:
+
+```rust title="bounded-vec-pop-example" showLineNumbers 
+let mut v: BoundedVec<Field, 2> = BoundedVec::new();
+    v.push(1);
+    v.push(2);
+
+    let two = v.pop();
+    let one = v.pop();
+
+    assert(two == 2);
+    assert(one == 1);
+    // error: cannot pop from an empty vector
+    // let _ = v.pop();
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/test_programs/noir_test_success/bounded_vec/src/main.nr#L108-L120" target="_blank" rel="noopener noreferrer">Source code: test_programs/noir_test_success/bounded_vec/src/main.nr#L108-L120</a></sub></sup>
+
+
+### len
+
+```rust
+pub fn len(self) -> u64 {
+```
+
+Returns the current length of this vector
+
+Example:
+
+```rust title="bounded-vec-len-example" showLineNumbers 
+let mut v: BoundedVec<Field, 4> = BoundedVec::new();
+    assert(v.len() == 0);
+
+    v.push(100);
+    assert(v.len() == 1);
+
+    v.push(200);
+    v.push(300);
+    v.push(400);
+    assert(v.len() == 4);
+
+    let _ = v.pop();
+    let _ = v.pop();
+    assert(v.len() == 2);
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/test_programs/noir_test_success/bounded_vec/src/main.nr#L125-L140" target="_blank" rel="noopener noreferrer">Source code: test_programs/noir_test_success/bounded_vec/src/main.nr#L125-L140</a></sub></sup>
+
+
+### max_len
+
+```rust
+pub fn max_len(_self: BoundedVec<T, MaxLen>) -> u64 {
+```
+
+Returns the maximum length of this vector. This is always
+equal to the `MaxLen` parameter this vector was initialized with.
+
+Example:
+
+```rust title="bounded-vec-max-len-example" showLineNumbers 
+let mut v: BoundedVec<Field, 5> = BoundedVec::new();
+
+    assert(v.max_len() == 5);
+    v.push(10);
+    assert(v.max_len() == 5);
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/test_programs/noir_test_success/bounded_vec/src/main.nr#L145-L151" target="_blank" rel="noopener noreferrer">Source code: test_programs/noir_test_success/bounded_vec/src/main.nr#L145-L151</a></sub></sup>
+
+
+### storage
+
+```rust
+pub fn storage(self) -> [T; MaxLen] {
+```
+
+Returns the internal array within this vector.
+Since arrays in Noir are immutable, mutating the returned storage array will not mutate
+the storage held internally by this vector.
+
+Note that uninitialized elements may be zeroed out!
+
+Example:
+
+```rust title="bounded-vec-storage-example" showLineNumbers 
+let mut v: BoundedVec<Field, 5> = BoundedVec::new();
+
+    assert(v.storage() == [0, 0, 0, 0, 0]);
+
+    v.push(57);
+    assert(v.storage() == [57, 0, 0, 0, 0]);
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/test_programs/noir_test_success/bounded_vec/src/main.nr#L156-L163" target="_blank" rel="noopener noreferrer">Source code: test_programs/noir_test_success/bounded_vec/src/main.nr#L156-L163</a></sub></sup>
+
+
+### extend_from_array
+
+```rust
+pub fn extend_from_array<Len>(&mut self, array: [T; Len])
+```
+
+Pushes each element from the given array to this vector.
+
+Panics if pushing each element would cause the length of this vector
+to exceed the maximum length.
+
+Example:
+
+```rust title="bounded-vec-extend-from-array-example" showLineNumbers 
+let mut vec: BoundedVec<Field, 3> = BoundedVec::new();
+    vec.extend_from_array([2, 4]);
+
+    assert(vec.len == 2);
+    assert(vec.get(0) == 2);
+    assert(vec.get(1) == 4);
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/test_programs/noir_test_success/bounded_vec/src/main.nr#L168-L175" target="_blank" rel="noopener noreferrer">Source code: test_programs/noir_test_success/bounded_vec/src/main.nr#L168-L175</a></sub></sup>
+
+
+### extend_from_bounded_vec
+
+```rust
+pub fn extend_from_bounded_vec<Len>(&mut self, vec: BoundedVec<T, Len>)
+```
+
+Pushes each element from the other vector to this vector. The length of
+the other vector is left unchanged.
+
+Panics if pushing each element would cause the length of this vector
+to exceed the maximum length.
+
+Example:
+
+```rust title="bounded-vec-extend-from-bounded-vec-example" showLineNumbers 
+let mut v1: BoundedVec<Field, 5> = BoundedVec::new();
+    let mut v2: BoundedVec<Field, 7> = BoundedVec::new();
+
+    v2.extend_from_array([1, 2, 3]);
+    v1.extend_from_bounded_vec(v2);
+
+    assert(v1.storage() == [1, 2, 3, 0, 0]);
+    assert(v2.storage() == [1, 2, 3, 0, 0, 0, 0]);
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/test_programs/noir_test_success/bounded_vec/src/main.nr#L180-L189" target="_blank" rel="noopener noreferrer">Source code: test_programs/noir_test_success/bounded_vec/src/main.nr#L180-L189</a></sub></sup>
+
+
+### from_array
+
+```rust
+pub fn from_array<Len>(array: [T; Len]) -> Self
+```
+
+Creates a new vector, populating it with values derived from an array input. 
+The maximum length of the vector is determined based on the type signature.
+
+Example:
+```rust
+let bounded_vec: BoundedVec<Field, 10> = BoundedVec::from_array([1, 2, 3])
+```
+
+### map
+
+```rust
+pub fn map<U, Env>(self, f: fn[Env](T) -> U) -> BoundedVec<U, MaxLen>
+```
+
+Creates a new vector of equal size by calling a closure on each element in this vector.  
+
+Example:
+
+```rust title="bounded-vec-map-example" showLineNumbers 
+let vec: BoundedVec<u32, 4> = BoundedVec::from_array([1, 2, 3, 4]);
+            let result = vec.map(|value| value * 2);
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/collections/bounded_vec.nr#L493-L496" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/collections/bounded_vec.nr#L493-L496</a></sub></sup>
+
+
+### any
+
+```rust
+pub fn any<Env>(self, predicate: fn[Env](T) -> bool) -> bool
+```
+
+Returns true if the given predicate returns true for any element
+in this vector.
+
+Example:
+
+```rust title="bounded-vec-any-example" showLineNumbers 
+let mut v: BoundedVec<u32, 3> = BoundedVec::new();
+    v.extend_from_array([2, 4, 6]);
+
+    let all_even = !v.any(|elem: u32| elem % 2 != 0);
+    assert(all_even);
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/test_programs/noir_test_success/bounded_vec/src/main.nr#L256-L262" target="_blank" rel="noopener noreferrer">Source code: test_programs/noir_test_success/bounded_vec/src/main.nr#L256-L262</a></sub></sup>
+
diff --git a/docs/versioned_docs/version-v0.35.0/noir/standard_library/containers/hashmap.md b/docs/versioned_docs/version-v0.35.0/noir/standard_library/containers/hashmap.md
new file mode 100644
index 00000000000..39f1ae9b32c
--- /dev/null
+++ b/docs/versioned_docs/version-v0.35.0/noir/standard_library/containers/hashmap.md
@@ -0,0 +1,594 @@
+---
+title: HashMap
+keywords: [noir, map, hash, hashmap]
+sidebar_position: 1
+---
+
+`HashMap<Key, Value, MaxLen, Hasher>` is used to efficiently store and look up key-value pairs.
+
+`HashMap` is a bounded type which can store anywhere from zero to `MaxLen` total elements.
+Note that due to hash collisions, the actual maximum number of elements stored by any particular
+hashmap is likely lower than `MaxLen`. This is true even with cryptographic hash functions since
+every hash value will be performed modulo `MaxLen`.
+
+Example:
+
+```rust
+// Create a mapping from Fields to u32s with a maximum length of 12
+// using a poseidon2 hasher
+use std::hash::poseidon2::Poseidon2Hasher;
+let mut map: HashMap<Field, u32, 12, BuildHasherDefault<Poseidon2Hasher>> = HashMap::default();
+
+map.insert(1, 2);
+map.insert(3, 4);
+
+let two = map.get(1).unwrap();
+```
+
+## Methods
+
+### default
+
+```rust title="default" showLineNumbers 
+impl<K, V, let N: u32, B, H> Default for HashMap<K, V, N, B>
+where
+    B: BuildHasher<H> + Default,
+    H: Hasher + Default {
+    /// Constructs an empty HashMap.
+    /// 
+    /// Example:
+    /// 
+    /// ```noir
+    /// let hashmap: HashMap<u8, u32, 10, BuildHasherDefault<Poseidon2Hasher>> = HashMap::default();
+    /// assert(hashmap.is_empty());
+    /// ``` 
+    fn default() -> Self {
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/collections/map.nr#L694-L708" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/collections/map.nr#L694-L708</a></sub></sup>
+
+
+Creates a fresh, empty HashMap.
+
+When using this function, always make sure to specify the maximum size of the hash map.
+
+This is the same `default` from the `Default` implementation given further below. It is
+repeated here for convenience since it is the recommended way to create a hashmap.
+
+Example:
+
+```rust title="default_example" showLineNumbers 
+let hashmap: HashMap<u8, u32, 10, BuildHasherDefault<Poseidon2Hasher>> = HashMap::default();
+    assert(hashmap.is_empty());
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/test_programs/execution_success/hashmap/src/main.nr#L201-L204" target="_blank" rel="noopener noreferrer">Source code: test_programs/execution_success/hashmap/src/main.nr#L201-L204</a></sub></sup>
+
+
+Because `HashMap` has so many generic arguments that are likely to be the same throughout
+your program, it may be helpful to create a type alias:
+
+```rust title="type_alias" showLineNumbers 
+type MyMap = HashMap<u8, u32, 10, BuildHasherDefault<Poseidon2Hasher>>;
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/test_programs/execution_success/hashmap/src/main.nr#L195-L197" target="_blank" rel="noopener noreferrer">Source code: test_programs/execution_success/hashmap/src/main.nr#L195-L197</a></sub></sup>
+
+
+### with_hasher
+
+```rust title="with_hasher" showLineNumbers 
+pub fn with_hasher<H>(_build_hasher: B) -> Self
+    where
+        B: BuildHasher<H> {
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/collections/map.nr#L103-L107" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/collections/map.nr#L103-L107</a></sub></sup>
+
+
+Creates a hashmap with an existing `BuildHasher`. This can be used to ensure multiple
+hashmaps are created with the same hasher instance.
+
+Example:
+
+```rust title="with_hasher_example" showLineNumbers 
+let my_hasher: BuildHasherDefault<Poseidon2Hasher> = Default::default();
+    let hashmap: HashMap<u8, u32, 10, BuildHasherDefault<Poseidon2Hasher>> = HashMap::with_hasher(my_hasher);
+    assert(hashmap.is_empty());
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/test_programs/execution_success/hashmap/src/main.nr#L206-L210" target="_blank" rel="noopener noreferrer">Source code: test_programs/execution_success/hashmap/src/main.nr#L206-L210</a></sub></sup>
+
+
+### get
+
+```rust title="get" showLineNumbers 
+pub fn get<H>(
+        self,
+        key: K
+    ) -> Option<V>
+    where
+        K: Eq + Hash,
+        B: BuildHasher<H>,
+        H: Hasher {
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/collections/map.nr#L470-L479" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/collections/map.nr#L470-L479</a></sub></sup>
+
+
+Retrieves a value from the hashmap, returning `Option::none()` if it was not found.
+
+Example:
+
+```rust title="get_example" showLineNumbers 
+fn get_example(map: HashMap<Field, Field, 5, BuildHasherDefault<Poseidon2Hasher>>) {
+    let x = map.get(12);
+
+    if x.is_some() {
+        assert(x.unwrap() == 42);
+    }
+}
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/test_programs/execution_success/hashmap/src/main.nr#L298-L306" target="_blank" rel="noopener noreferrer">Source code: test_programs/execution_success/hashmap/src/main.nr#L298-L306</a></sub></sup>
+
+
+### insert
+
+```rust title="insert" showLineNumbers 
+pub fn insert<H>(
+        &mut self,
+        key: K,
+        value: V
+    )
+    where
+        K: Eq + Hash,
+        B: BuildHasher<H>,
+        H: Hasher {
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/collections/map.nr#L514-L524" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/collections/map.nr#L514-L524</a></sub></sup>
+
+
+Inserts a new key-value pair into the map. If the key was already in the map, its
+previous value will be overridden with the newly provided one.
+
+Example:
+
+```rust title="insert_example" showLineNumbers 
+let mut map: HashMap<Field, Field, 5, BuildHasherDefault<Poseidon2Hasher>> = HashMap::default();
+    map.insert(12, 42);
+    assert(map.len() == 1);
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/test_programs/execution_success/hashmap/src/main.nr#L212-L216" target="_blank" rel="noopener noreferrer">Source code: test_programs/execution_success/hashmap/src/main.nr#L212-L216</a></sub></sup>
+
+
+### remove
+
+```rust title="remove" showLineNumbers 
+pub fn remove<H>(
+        &mut self,
+        key: K
+    )
+    where
+        K: Eq + Hash,
+        B: BuildHasher<H>,
+        H: Hasher {
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/collections/map.nr#L573-L582" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/collections/map.nr#L573-L582</a></sub></sup>
+
+
+Removes the given key-value pair from the map. If the key was not already present
+in the map, this does nothing.
+
+Example:
+
+```rust title="remove_example" showLineNumbers 
+map.remove(12);
+    assert(map.is_empty());
+
+    // If a key was not present in the map, remove does nothing
+    map.remove(12);
+    assert(map.is_empty());
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/test_programs/execution_success/hashmap/src/main.nr#L220-L227" target="_blank" rel="noopener noreferrer">Source code: test_programs/execution_success/hashmap/src/main.nr#L220-L227</a></sub></sup>
+
+
+### is_empty
+
+```rust title="is_empty" showLineNumbers 
+pub fn is_empty(self) -> bool {
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/collections/map.nr#L168-L170" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/collections/map.nr#L168-L170</a></sub></sup>
+
+
+True if the length of the hash map is empty.
+
+Example:
+
+```rust title="is_empty_example" showLineNumbers 
+assert(map.is_empty());
+
+    map.insert(1, 2);
+    assert(!map.is_empty());
+
+    map.remove(1);
+    assert(map.is_empty());
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/test_programs/execution_success/hashmap/src/main.nr#L229-L237" target="_blank" rel="noopener noreferrer">Source code: test_programs/execution_success/hashmap/src/main.nr#L229-L237</a></sub></sup>
+
+
+### len
+
+```rust title="len" showLineNumbers 
+pub fn len(self) -> u32 {
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/collections/map.nr#L429-L431" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/collections/map.nr#L429-L431</a></sub></sup>
+
+
+Returns the current length of this hash map.
+
+Example:
+
+```rust title="len_example" showLineNumbers 
+// This is equivalent to checking map.is_empty()
+    assert(map.len() == 0);
+
+    map.insert(1, 2);
+    map.insert(3, 4);
+    map.insert(5, 6);
+    assert(map.len() == 3);
+
+    // 3 was already present as a key in the hash map, so the length is unchanged
+    map.insert(3, 7);
+    assert(map.len() == 3);
+
+    map.remove(1);
+    assert(map.len() == 2);
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/test_programs/execution_success/hashmap/src/main.nr#L239-L254" target="_blank" rel="noopener noreferrer">Source code: test_programs/execution_success/hashmap/src/main.nr#L239-L254</a></sub></sup>
+
+
+### capacity
+
+```rust title="capacity" showLineNumbers 
+pub fn capacity(_self: Self) -> u32 {
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/collections/map.nr#L451-L453" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/collections/map.nr#L451-L453</a></sub></sup>
+
+
+Returns the maximum capacity of this hashmap. This is always equal to the capacity
+specified in the hashmap's type.
+
+Unlike hashmaps in general purpose programming languages, hashmaps in Noir have a
+static capacity that does not increase as the map grows larger. Thus, this capacity
+is also the maximum possible element count that can be inserted into the hashmap.
+Due to hash collisions (modulo the hashmap length), it is likely the actual maximum
+element count will be lower than the full capacity.
+
+Example:
+
+```rust title="capacity_example" showLineNumbers 
+let empty_map: HashMap<Field, Field, 42, BuildHasherDefault<Poseidon2Hasher>> = HashMap::default();
+    assert(empty_map.len() == 0);
+    assert(empty_map.capacity() == 42);
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/test_programs/execution_success/hashmap/src/main.nr#L256-L260" target="_blank" rel="noopener noreferrer">Source code: test_programs/execution_success/hashmap/src/main.nr#L256-L260</a></sub></sup>
+
+
+### clear
+
+```rust title="clear" showLineNumbers 
+pub fn clear(&mut self) {
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/collections/map.nr#L122-L124" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/collections/map.nr#L122-L124</a></sub></sup>
+
+
+Clears the hashmap, removing all key-value pairs from it.
+
+Example:
+
+```rust title="clear_example" showLineNumbers 
+assert(!map.is_empty());
+    map.clear();
+    assert(map.is_empty());
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/test_programs/execution_success/hashmap/src/main.nr#L262-L266" target="_blank" rel="noopener noreferrer">Source code: test_programs/execution_success/hashmap/src/main.nr#L262-L266</a></sub></sup>
+
+
+### contains_key
+
+```rust title="contains_key" showLineNumbers 
+pub fn contains_key<H>(
+        self,
+        key: K
+    ) -> bool
+    where
+        K: Hash + Eq,
+        B: BuildHasher<H>,
+        H: Hasher {
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/collections/map.nr#L142-L151" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/collections/map.nr#L142-L151</a></sub></sup>
+
+
+True if the hashmap contains the given key. Unlike `get`, this will not also return
+the value associated with the key.
+
+Example:
+
+```rust title="contains_key_example" showLineNumbers 
+if map.contains_key(7) {
+        let value = map.get(7);
+        assert(value.is_some());
+    } else {
+        println("No value for key 7!");
+    }
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/test_programs/execution_success/hashmap/src/main.nr#L268-L275" target="_blank" rel="noopener noreferrer">Source code: test_programs/execution_success/hashmap/src/main.nr#L268-L275</a></sub></sup>
+
+
+### entries
+
+```rust title="entries" showLineNumbers 
+pub fn entries(self) -> BoundedVec<(K, V), N> {
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/collections/map.nr#L192-L194" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/collections/map.nr#L192-L194</a></sub></sup>
+
+
+Returns a vector of each key-value pair present in the hashmap.
+
+The length of the returned vector is always equal to the length of the hashmap.
+
+Example:
+
+```rust title="entries_example" showLineNumbers 
+let entries = map.entries();
+
+    // The length of a hashmap may not be compile-time known, so we
+    // need to loop over its capacity instead
+    for i in 0..map.capacity() {
+        if i < entries.len() {
+            let (key, value) = entries.get(i);
+            println(f"{key} -> {value}");
+        }
+    }
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/test_programs/execution_success/hashmap/src/main.nr#L309-L320" target="_blank" rel="noopener noreferrer">Source code: test_programs/execution_success/hashmap/src/main.nr#L309-L320</a></sub></sup>
+
+
+### keys
+
+```rust title="keys" showLineNumbers 
+pub fn keys(self) -> BoundedVec<K, N> {
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/collections/map.nr#L228-L230" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/collections/map.nr#L228-L230</a></sub></sup>
+
+
+Returns a vector of each key present in the hashmap.
+
+The length of the returned vector is always equal to the length of the hashmap.
+
+Example:
+
+```rust title="keys_example" showLineNumbers 
+let keys = map.keys();
+
+    for i in 0..keys.max_len() {
+        if i < keys.len() {
+            let key = keys.get_unchecked(i);
+            let value = map.get(key).unwrap_unchecked();
+            println(f"{key} -> {value}");
+        }
+    }
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/test_programs/execution_success/hashmap/src/main.nr#L322-L332" target="_blank" rel="noopener noreferrer">Source code: test_programs/execution_success/hashmap/src/main.nr#L322-L332</a></sub></sup>
+
+
+### values
+
+```rust title="values" showLineNumbers 
+pub fn values(self) -> BoundedVec<V, N> {
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/collections/map.nr#L262-L264" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/collections/map.nr#L262-L264</a></sub></sup>
+
+
+Returns a vector of each value present in the hashmap.
+
+The length of the returned vector is always equal to the length of the hashmap.
+
+Example:
+
+```rust title="values_example" showLineNumbers 
+let values = map.values();
+
+    for i in 0..values.max_len() {
+        if i < values.len() {
+            let value = values.get_unchecked(i);
+            println(f"Found value {value}");
+        }
+    }
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/test_programs/execution_success/hashmap/src/main.nr#L334-L343" target="_blank" rel="noopener noreferrer">Source code: test_programs/execution_success/hashmap/src/main.nr#L334-L343</a></sub></sup>
+
+
+### iter_mut
+
+```rust title="iter_mut" showLineNumbers 
+pub fn iter_mut<H>(
+        &mut self,
+        f: fn(K, V) -> (K, V)
+    )
+    where
+        K: Eq + Hash,
+        B: BuildHasher<H>,
+        H: Hasher {
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/collections/map.nr#L298-L307" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/collections/map.nr#L298-L307</a></sub></sup>
+
+
+Iterates through each key-value pair of the HashMap, setting each key-value pair to the
+result returned from the given function.
+
+Note that since keys can be mutated, the HashMap needs to be rebuilt as it is iterated
+through. If this is not desired, use `iter_values_mut` if only values need to be mutated,
+or `entries` if neither keys nor values need to be mutated.
+
+The iteration order is left unspecified. As a result, if two keys are mutated to become
+equal, which of the two values that will be present for the key in the resulting map is also unspecified.
+
+Example:
+
+```rust title="iter_mut_example" showLineNumbers 
+// Add 1 to each key in the map, and double the value associated with that key.
+    map.iter_mut(|k, v| (k + 1, v * 2));
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/test_programs/execution_success/hashmap/src/main.nr#L347-L350" target="_blank" rel="noopener noreferrer">Source code: test_programs/execution_success/hashmap/src/main.nr#L347-L350</a></sub></sup>
+
+
+### iter_keys_mut
+
+```rust title="iter_keys_mut" showLineNumbers 
+pub fn iter_keys_mut<H>(
+        &mut self,
+        f: fn(K) -> K
+    ) 
+    where
+        K: Eq + Hash,
+        B: BuildHasher<H>,
+        H: Hasher {
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/collections/map.nr#L338-L347" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/collections/map.nr#L338-L347</a></sub></sup>
+
+
+Iterates through the HashMap, mutating each key to the result returned from
+the given function.
+
+Note that since keys can be mutated, the HashMap needs to be rebuilt as it is iterated
+through. If only iteration is desired and the keys are not intended to be mutated,
+prefer using `entries` instead.
+
+The iteration order is left unspecified. As a result, if two keys are mutated to become
+equal, which of the two values that will be present for the key in the resulting map is also unspecified.
+
+Example:
+
+```rust title="iter_keys_mut_example" showLineNumbers 
+// Double each key, leaving the value associated with that key untouched
+    map.iter_keys_mut(|k| k * 2);
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/test_programs/execution_success/hashmap/src/main.nr#L352-L355" target="_blank" rel="noopener noreferrer">Source code: test_programs/execution_success/hashmap/src/main.nr#L352-L355</a></sub></sup>
+
+
+### iter_values_mut
+
+```rust title="iter_values_mut" showLineNumbers 
+pub fn iter_values_mut(&mut self, f: fn(V) -> V) {
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/collections/map.nr#L372-L374" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/collections/map.nr#L372-L374</a></sub></sup>
+
+
+Iterates through the HashMap, applying the given function to each value and mutating the
+value to equal the result. This function is more efficient than `iter_mut` and `iter_keys_mut`
+because the keys are untouched and the underlying hashmap thus does not need to be reordered.
+
+Example:
+
+```rust title="iter_values_mut_example" showLineNumbers 
+// Halve each value
+    map.iter_values_mut(|v| v / 2);
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/test_programs/execution_success/hashmap/src/main.nr#L357-L360" target="_blank" rel="noopener noreferrer">Source code: test_programs/execution_success/hashmap/src/main.nr#L357-L360</a></sub></sup>
+
+
+### retain
+
+```rust title="retain" showLineNumbers 
+pub fn retain(&mut self, f: fn(K, V) -> bool) {
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/collections/map.nr#L393-L395" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/collections/map.nr#L393-L395</a></sub></sup>
+
+
+Retains only the key-value pairs for which the given function returns true.
+Any key-value pairs for which the function returns false will be removed from the map.
+
+Example:
+
+```rust title="retain_example" showLineNumbers 
+map.retain(|k, v| (k != 0) & (v != 0));
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/test_programs/execution_success/hashmap/src/main.nr#L280-L282" target="_blank" rel="noopener noreferrer">Source code: test_programs/execution_success/hashmap/src/main.nr#L280-L282</a></sub></sup>
+
+
+## Trait Implementations
+
+### default
+
+```rust title="default" showLineNumbers 
+impl<K, V, let N: u32, B, H> Default for HashMap<K, V, N, B>
+where
+    B: BuildHasher<H> + Default,
+    H: Hasher + Default {
+    /// Constructs an empty HashMap.
+    /// 
+    /// Example:
+    /// 
+    /// ```noir
+    /// let hashmap: HashMap<u8, u32, 10, BuildHasherDefault<Poseidon2Hasher>> = HashMap::default();
+    /// assert(hashmap.is_empty());
+    /// ``` 
+    fn default() -> Self {
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/collections/map.nr#L694-L708" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/collections/map.nr#L694-L708</a></sub></sup>
+
+
+Constructs an empty HashMap.
+
+Example:
+
+```rust title="default_example" showLineNumbers 
+let hashmap: HashMap<u8, u32, 10, BuildHasherDefault<Poseidon2Hasher>> = HashMap::default();
+    assert(hashmap.is_empty());
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/test_programs/execution_success/hashmap/src/main.nr#L201-L204" target="_blank" rel="noopener noreferrer">Source code: test_programs/execution_success/hashmap/src/main.nr#L201-L204</a></sub></sup>
+
+
+### eq
+
+```rust title="eq" showLineNumbers 
+impl<K, V, let N: u32, B, H> Eq for HashMap<K, V, N, B>
+where
+    K: Eq + Hash,
+    V: Eq,
+    B: BuildHasher<H>,
+    H: Hasher {
+    /// Checks if two HashMaps are equal.
+    /// 
+    /// Example:
+    /// 
+    /// ```noir
+    /// let mut map1: HashMap<Field, u64, 4, BuildHasherDefault<Poseidon2Hasher>> = HashMap::default();
+    /// let mut map2: HashMap<Field, u64, 4, BuildHasherDefault<Poseidon2Hasher>> = HashMap::default();
+    /// 
+    /// map1.insert(1, 2);
+    /// map1.insert(3, 4);
+    /// 
+    /// map2.insert(3, 4);
+    /// map2.insert(1, 2);
+    /// 
+    /// assert(map1 == map2);
+    /// ```
+    fn eq(self, other: HashMap<K, V, N, B>) -> bool {
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/collections/map.nr#L643-L667" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/collections/map.nr#L643-L667</a></sub></sup>
+
+
+Checks if two HashMaps are equal.
+
+Example:
+
+```rust title="eq_example" showLineNumbers 
+let mut map1: HashMap<Field, u64, 4, BuildHasherDefault<Poseidon2Hasher>> = HashMap::default();
+    let mut map2: HashMap<Field, u64, 4, BuildHasherDefault<Poseidon2Hasher>> = HashMap::default();
+
+    map1.insert(1, 2);
+    map1.insert(3, 4);
+
+    map2.insert(3, 4);
+    map2.insert(1, 2);
+
+    assert(map1 == map2);
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/test_programs/execution_success/hashmap/src/main.nr#L284-L295" target="_blank" rel="noopener noreferrer">Source code: test_programs/execution_success/hashmap/src/main.nr#L284-L295</a></sub></sup>
+
diff --git a/docs/versioned_docs/version-v0.35.0/noir/standard_library/containers/index.md b/docs/versioned_docs/version-v0.35.0/noir/standard_library/containers/index.md
new file mode 100644
index 00000000000..ea84c6d5c21
--- /dev/null
+++ b/docs/versioned_docs/version-v0.35.0/noir/standard_library/containers/index.md
@@ -0,0 +1,5 @@
+---
+title: Containers
+description: Container types provided by Noir's standard library for storing and retrieving data
+keywords: [containers, data types, vec, hashmap]
+---
diff --git a/docs/versioned_docs/version-v0.35.0/noir/standard_library/containers/vec.mdx b/docs/versioned_docs/version-v0.35.0/noir/standard_library/containers/vec.mdx
new file mode 100644
index 00000000000..475011922f8
--- /dev/null
+++ b/docs/versioned_docs/version-v0.35.0/noir/standard_library/containers/vec.mdx
@@ -0,0 +1,170 @@
+---
+title: Vectors
+description: Delve into the Vec data type in Noir. Learn about its methods, practical examples, and best practices for using Vectors in your Noir code.
+keywords: [noir, vector type, methods, examples, dynamic arrays]
+sidebar_position: 6
+---
+
+import Experimental from '@site/src/components/Notes/_experimental.mdx';
+
+<Experimental />
+
+A vector is a collection type similar to Rust's `Vec<T>` type. In Noir, it is a convenient way to use slices as mutable arrays.
+
+Example:
+
+```rust
+let mut vector: Vec<Field> = Vec::new();
+for i in 0..5 {
+    vector.push(i);
+}
+assert(vector.len() == 5);
+```
+
+## Methods
+
+### new
+
+Creates a new, empty vector.
+
+```rust
+pub fn new() -> Self
+```
+
+Example:
+
+```rust
+let empty_vector: Vec<Field> = Vec::new();
+assert(empty_vector.len() == 0);
+```
+
+### from_slice
+
+Creates a vector containing each element from a given slice. Mutations to the resulting vector will not affect the original slice.
+
+```rust
+pub fn from_slice(slice: [T]) -> Self
+```
+
+Example:
+
+```rust
+let slice: [Field] = &[1, 2, 3];
+let vector_from_slice = Vec::from_slice(slice);
+assert(vector_from_slice.len() == 3);
+```
+
+### len
+
+Returns the number of elements in the vector.
+
+```rust
+pub fn len(self) -> Field
+```
+
+Example:
+
+```rust
+let empty_vector: Vec<Field> = Vec::new();
+assert(empty_vector.len() == 0);
+```
+
+### get
+
+Retrieves an element from the vector at a given index. Panics if the index points beyond the vector's end.
+
+```rust
+pub fn get(self, index: Field) -> T
+```
+
+Example:
+
+```rust
+let vector: Vec<Field> = Vec::from_slice(&[10, 20, 30]);
+assert(vector.get(1) == 20);
+```
+
+### set
+
+```rust
+pub fn set(&mut self: Self, index: u64, value: T) {
+```
+
+Writes an element to the vector at the given index, starting from zero.
+
+Panics if the index points beyond the vector's end.
+
+Example:
+
+```rust
+let vector: Vec<Field> = Vec::from_slice(&[10, 20, 30]);
+assert(vector.get(1) == 20);
+vector.set(1, 42);
+assert(vector.get(1) == 42);
+```
+
+### push
+
+Adds a new element to the vector's end, returning a new vector with a length one greater than the original unmodified vector.
+
+```rust
+pub fn push(&mut self, elem: T)
+```
+
+Example:
+
+```rust
+let mut vector: Vec<Field> = Vec::new();
+vector.push(10);
+assert(vector.len() == 1);
+```
+
+### pop
+
+Removes an element from the vector's end, returning a new vector with a length one less than the original vector, along with the removed element. Panics if the vector's length is zero.
+
+```rust
+pub fn pop(&mut self) -> T
+```
+
+Example:
+
+```rust
+let mut vector = Vec::from_slice(&[10, 20]);
+let popped_elem = vector.pop();
+assert(popped_elem == 20);
+assert(vector.len() == 1);
+```
+
+### insert
+
+Inserts an element at a specified index, shifting subsequent elements to the right.
+
+```rust
+pub fn insert(&mut self, index: Field, elem: T)
+```
+
+Example:
+
+```rust
+let mut vector = Vec::from_slice(&[10, 30]);
+vector.insert(1, 20);
+assert(vector.get(1) == 20);
+```
+
+### remove
+
+Removes an element at a specified index, shifting subsequent elements to the left, and returns the removed element.
+
+```rust
+pub fn remove(&mut self, index: Field) -> T
+```
+
+Example:
+
+```rust
+let mut vector = Vec::from_slice(&[10, 20, 30]);
+let removed_elem = vector.remove(1);
+assert(removed_elem == 20);
+assert(vector.len() == 2);
+```
diff --git a/docs/versioned_docs/version-v0.35.0/noir/standard_library/cryptographic_primitives/_category_.json b/docs/versioned_docs/version-v0.35.0/noir/standard_library/cryptographic_primitives/_category_.json
new file mode 100644
index 00000000000..5d694210bbf
--- /dev/null
+++ b/docs/versioned_docs/version-v0.35.0/noir/standard_library/cryptographic_primitives/_category_.json
@@ -0,0 +1,5 @@
+{
+    "position": 0,
+    "collapsible": true,
+    "collapsed": true
+}
diff --git a/docs/versioned_docs/version-v0.35.0/noir/standard_library/cryptographic_primitives/ciphers.mdx b/docs/versioned_docs/version-v0.35.0/noir/standard_library/cryptographic_primitives/ciphers.mdx
new file mode 100644
index 00000000000..d6a5e1a79eb
--- /dev/null
+++ b/docs/versioned_docs/version-v0.35.0/noir/standard_library/cryptographic_primitives/ciphers.mdx
@@ -0,0 +1,32 @@
+---
+title: Ciphers
+description:
+  Learn about the implemented ciphers ready to use for any Noir project
+keywords:
+  [ciphers, Noir project, aes128, encrypt]
+sidebar_position: 0
+---
+
+import BlackBoxInfo from '@site/src/components/Notes/_blackbox';
+
+## aes128
+
+Given a plaintext as an array of bytes, returns the corresponding aes128 ciphertext (CBC mode). Input padding is automatically performed using PKCS#7, so that the output length is `input.len() + (16 - input.len() % 16)`.
+
+```rust title="aes128" showLineNumbers 
+pub fn aes128_encrypt<let N: u32>(input: [u8; N], iv: [u8; 16], key: [u8; 16]) -> [u8] {}
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/aes128.nr#L2-L4" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/aes128.nr#L2-L4</a></sub></sup>
+
+
+```rust
+fn main() {
+    let input: [u8; 4] = [0, 12, 3, 15] // Random bytes, will be padded to 16 bytes.
+    let iv: [u8; 16] = [0; 16]; // Initialisation vector
+    let key: [u8; 16] = [0; 16] // AES key
+    let ciphertext = std::aes128::aes128_encrypt(inputs.as_bytes(), iv.as_bytes(), key.as_bytes()); // In this case, the output length will be 16 bytes.
+}
+```
+
+
+<BlackBoxInfo to="../black_box_fns"/>
\ No newline at end of file
diff --git a/docs/docs/noir/standard_library/cryptographic_primitives/ec_primitives.md b/docs/versioned_docs/version-v0.35.0/noir/standard_library/cryptographic_primitives/ec_primitives.md
similarity index 100%
rename from docs/docs/noir/standard_library/cryptographic_primitives/ec_primitives.md
rename to docs/versioned_docs/version-v0.35.0/noir/standard_library/cryptographic_primitives/ec_primitives.md
diff --git a/docs/versioned_docs/version-v0.35.0/noir/standard_library/cryptographic_primitives/ecdsa_sig_verification.mdx b/docs/versioned_docs/version-v0.35.0/noir/standard_library/cryptographic_primitives/ecdsa_sig_verification.mdx
new file mode 100644
index 00000000000..12bf5ae8aaf
--- /dev/null
+++ b/docs/versioned_docs/version-v0.35.0/noir/standard_library/cryptographic_primitives/ecdsa_sig_verification.mdx
@@ -0,0 +1,98 @@
+---
+title: ECDSA Signature Verification
+description: Learn about the cryptographic primitives regarding ECDSA over the secp256k1 and secp256r1 curves
+keywords: [cryptographic primitives, Noir project, ecdsa, secp256k1, secp256r1, signatures]
+sidebar_position: 3
+---
+
+import BlackBoxInfo from '@site/src/components/Notes/_blackbox';
+
+Noir supports ECDSA signatures verification over the secp256k1 and secp256r1 curves.
+
+## ecdsa_secp256k1::verify_signature
+
+Verifier for ECDSA Secp256k1 signatures.
+See ecdsa_secp256k1::verify_signature_slice for a version that accepts slices directly.
+
+```rust title="ecdsa_secp256k1" showLineNumbers 
+pub fn verify_signature<let N: u32>(
+    public_key_x: [u8; 32],
+    public_key_y: [u8; 32],
+    signature: [u8; 64],
+    message_hash: [u8; N]
+) -> bool
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/ecdsa_secp256k1.nr#L2-L9" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/ecdsa_secp256k1.nr#L2-L9</a></sub></sup>
+
+
+example:
+
+```rust
+fn main(hashed_message : [u8;32], pub_key_x : [u8;32], pub_key_y : [u8;32], signature : [u8;64]) {
+     let valid_signature = std::ecdsa_secp256k1::verify_signature(pub_key_x, pub_key_y, signature, hashed_message);
+     assert(valid_signature);
+}
+```
+
+<BlackBoxInfo to="../black_box_fns" />
+
+## ecdsa_secp256k1::verify_signature_slice
+
+Verifier for ECDSA Secp256k1 signatures where the message is a slice.
+
+```rust title="ecdsa_secp256k1_slice" showLineNumbers 
+pub fn verify_signature_slice(
+    public_key_x: [u8; 32],
+    public_key_y: [u8; 32],
+    signature: [u8; 64],
+    message_hash: [u8]
+) -> bool
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/ecdsa_secp256k1.nr#L13-L20" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/ecdsa_secp256k1.nr#L13-L20</a></sub></sup>
+
+
+<BlackBoxInfo to="../black_box_fns"/>
+
+## ecdsa_secp256r1::verify_signature
+
+Verifier for ECDSA Secp256r1 signatures.
+See ecdsa_secp256r1::verify_signature_slice for a version that accepts slices directly.
+
+```rust title="ecdsa_secp256r1" showLineNumbers 
+pub fn verify_signature<let N: u32>(
+    public_key_x: [u8; 32],
+    public_key_y: [u8; 32],
+    signature: [u8; 64],
+    message_hash: [u8; N]
+) -> bool
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/ecdsa_secp256r1.nr#L2-L9" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/ecdsa_secp256r1.nr#L2-L9</a></sub></sup>
+
+
+example:
+
+```rust
+fn main(hashed_message : [u8;32], pub_key_x : [u8;32], pub_key_y : [u8;32], signature : [u8;64]) {
+     let valid_signature = std::ecdsa_secp256r1::verify_signature(pub_key_x, pub_key_y, signature, hashed_message);
+     assert(valid_signature);
+}
+```
+
+<BlackBoxInfo to="../black_box_fns"/>
+
+## ecdsa_secp256r1::verify_signature
+
+Verifier for ECDSA Secp256r1 signatures where the message is a slice.
+
+```rust title="ecdsa_secp256r1_slice" showLineNumbers 
+pub fn verify_signature_slice(
+    public_key_x: [u8; 32],
+    public_key_y: [u8; 32],
+    signature: [u8; 64],
+    message_hash: [u8]
+) -> bool
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/ecdsa_secp256r1.nr#L13-L20" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/ecdsa_secp256r1.nr#L13-L20</a></sub></sup>
+
+
+<BlackBoxInfo to="../black_box_fns"/>
diff --git a/docs/docs/noir/standard_library/cryptographic_primitives/eddsa.mdx b/docs/versioned_docs/version-v0.35.0/noir/standard_library/cryptographic_primitives/eddsa.mdx
similarity index 90%
rename from docs/docs/noir/standard_library/cryptographic_primitives/eddsa.mdx
rename to docs/versioned_docs/version-v0.35.0/noir/standard_library/cryptographic_primitives/eddsa.mdx
index 1ad42a5ac96..b283de693c8 100644
--- a/docs/docs/noir/standard_library/cryptographic_primitives/eddsa.mdx
+++ b/docs/versioned_docs/version-v0.35.0/noir/standard_library/cryptographic_primitives/eddsa.mdx
@@ -5,7 +5,7 @@ keywords: [cryptographic primitives, Noir project, eddsa, signatures]
 sidebar_position: 5
 ---
 
-import BlackBoxInfo from '@site/src/components/Notes/_blackbox.mdx';
+import BlackBoxInfo from '@site/src/components/Notes/_blackbox';
 
 ## eddsa::eddsa_poseidon_verify
 
@@ -23,7 +23,7 @@ use std::hash::poseidon2::Poseidon2Hasher;
 eddsa_verify::<Poseidon2Hasher>(pub_key_a.x, pub_key_a.y, s_a, r8_a.x, r8_a.y, msg);
 ```
 
-<BlackBoxInfo />
+<BlackBoxInfo to="../black_box_fns"/>
 
 ## eddsa::eddsa_to_pub
 
diff --git a/docs/versioned_docs/version-v0.35.0/noir/standard_library/cryptographic_primitives/embedded_curve_ops.mdx b/docs/versioned_docs/version-v0.35.0/noir/standard_library/cryptographic_primitives/embedded_curve_ops.mdx
new file mode 100644
index 00000000000..9507f16322c
--- /dev/null
+++ b/docs/versioned_docs/version-v0.35.0/noir/standard_library/cryptographic_primitives/embedded_curve_ops.mdx
@@ -0,0 +1,92 @@
+---
+title: Scalar multiplication
+description: See how you can perform scalar multiplication in Noir
+keywords: [cryptographic primitives, Noir project, scalar multiplication]
+sidebar_position: 1
+---
+
+import BlackBoxInfo from '@site/src/components/Notes/_blackbox';
+
+The following functions perform operations over the embedded curve whose coordinates are defined by the configured noir field.
+For the BN254 scalar field, this is BabyJubJub or Grumpkin.
+
+:::note
+Suffixes `_low` and `_high` denote low and high limbs of a scalar.
+:::
+
+## embedded_curve_ops::multi_scalar_mul
+
+Performs multi scalar multiplication over the embedded curve.
+The function accepts arbitrary amount of point-scalar pairs on the input, it multiplies the individual pairs over
+the curve and returns a sum of the resulting points.
+
+Points represented as x and y coordinates [x1, y1, x2, y2, ...], scalars as low and high limbs [low1, high1, low2, high2, ...].
+
+```rust title="multi_scalar_mul" showLineNumbers 
+pub fn multi_scalar_mul<let N: u32>(
+    points: [EmbeddedCurvePoint; N],
+    scalars: [EmbeddedCurveScalar; N]
+) -> EmbeddedCurvePoint
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/embedded_curve_ops.nr#L103-L108" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/embedded_curve_ops.nr#L103-L108</a></sub></sup>
+
+
+example
+
+```rust
+fn main(point_x: Field, point_y: Field, scalar_low: Field, scalar_high: Field) {
+    let point = std::embedded_curve_ops::multi_scalar_mul([point_x, point_y], [scalar_low, scalar_high]);
+    println(point);
+}
+```
+
+## embedded_curve_ops::fixed_base_scalar_mul
+
+Performs fixed base scalar multiplication over the embedded curve (multiplies input scalar with a generator point).
+The function accepts a single scalar on the input represented as 2 fields.
+
+```rust title="fixed_base_scalar_mul" showLineNumbers 
+pub fn fixed_base_scalar_mul(scalar: EmbeddedCurveScalar) -> EmbeddedCurvePoint
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/embedded_curve_ops.nr#L120-L122" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/embedded_curve_ops.nr#L120-L122</a></sub></sup>
+
+
+example
+
+```rust
+fn main(scalar_low: Field, scalar_high: Field) {
+    let point = std::embedded_curve_ops::fixed_base_scalar_mul(scalar_low, scalar_high);
+    println(point);
+}
+```
+
+## embedded_curve_ops::embedded_curve_add
+
+Adds two points on the embedded curve.
+This function takes two `EmbeddedCurvePoint` structures as parameters, representing points on the curve, and returns a new `EmbeddedCurvePoint` structure that represents their sum.
+
+### Parameters:
+- `point1` (`EmbeddedCurvePoint`): The first point to add.
+- `point2` (`EmbeddedCurvePoint`): The second point to add.
+
+### Returns:
+- `EmbeddedCurvePoint`: The resulting point after the addition of `point1` and `point2`.
+
+```rust title="embedded_curve_add" showLineNumbers 
+pub fn embedded_curve_add(point1: EmbeddedCurvePoint, point2: EmbeddedCurvePoint) -> EmbeddedCurvePoint {
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/embedded_curve_ops.nr#L132-L134" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/embedded_curve_ops.nr#L132-L134</a></sub></sup>
+
+
+example
+
+```rust
+fn main() {
+    let point1 = EmbeddedCurvePoint { x: 1, y: 2 };
+    let point2 = EmbeddedCurvePoint { x: 3, y: 4 };
+    let result = std::embedded_curve_ops::embedded_curve_add(point1, point2);
+    println!("Resulting Point: ({}, {})", result.x, result.y);
+}
+```
+
+<BlackBoxInfo to="../black_box_fns"/>
diff --git a/docs/versioned_docs/version-v0.35.0/noir/standard_library/cryptographic_primitives/hashes.mdx b/docs/versioned_docs/version-v0.35.0/noir/standard_library/cryptographic_primitives/hashes.mdx
new file mode 100644
index 00000000000..33601bae22b
--- /dev/null
+++ b/docs/versioned_docs/version-v0.35.0/noir/standard_library/cryptographic_primitives/hashes.mdx
@@ -0,0 +1,253 @@
+---
+title: Hash methods
+description:
+  Learn about the cryptographic primitives ready to use for any Noir project, including sha256,
+  blake2s, pedersen, mimc_bn254 and mimc
+keywords:
+  [cryptographic primitives, Noir project, sha256, blake2s, pedersen, mimc_bn254, mimc, hash]
+sidebar_position: 0
+---
+
+import BlackBoxInfo from '@site/src/components/Notes/_blackbox';
+
+## sha256
+
+Given an array of bytes, returns the resulting sha256 hash.
+Specify a message_size to hash only the first `message_size` bytes of the input.
+
+```rust title="sha256" showLineNumbers 
+pub fn sha256<let N: u32>(input: [u8; N]) -> [u8; 32]
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/hash/sha256.nr#L7-L9" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/hash/sha256.nr#L7-L9</a></sub></sup>
+
+
+example:
+```rust title="sha256_var" showLineNumbers 
+let digest = std::hash::sha256_var([x as u8], 1);
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/test_programs/execution_success/sha256/src/main.nr#L16-L18" target="_blank" rel="noopener noreferrer">Source code: test_programs/execution_success/sha256/src/main.nr#L16-L18</a></sub></sup>
+
+
+```rust
+fn main() {
+    let x = [163, 117, 178, 149]; // some random bytes
+    let hash = std::sha256::sha256_var(x, 4);
+}
+```
+
+
+<BlackBoxInfo to="../black_box_fns"/>
+
+## blake2s
+
+Given an array of bytes, returns an array with the Blake2 hash
+
+```rust title="blake2s" showLineNumbers 
+pub fn blake2s<let N: u32>(input: [u8; N]) -> [u8; 32]
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/hash/mod.nr#L18-L20" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/hash/mod.nr#L18-L20</a></sub></sup>
+
+
+example:
+
+```rust
+fn main() {
+    let x = [163, 117, 178, 149]; // some random bytes
+    let hash = std::hash::blake2s(x);
+}
+```
+
+<BlackBoxInfo to="../black_box_fns"/>
+
+## blake3
+
+Given an array of bytes, returns an array with the Blake3 hash
+
+```rust title="blake3" showLineNumbers 
+pub fn blake3<let N: u32>(input: [u8; N]) -> [u8; 32]
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/hash/mod.nr#L24-L26" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/hash/mod.nr#L24-L26</a></sub></sup>
+
+
+example:
+
+```rust
+fn main() {
+    let x = [163, 117, 178, 149]; // some random bytes
+    let hash = std::hash::blake3(x);
+}
+```
+
+<BlackBoxInfo to="../black_box_fns"/>
+
+## pedersen_hash
+
+Given an array of Fields, returns the Pedersen hash.
+
+```rust title="pedersen_hash" showLineNumbers 
+pub fn pedersen_hash<let N: u32>(input: [Field; N]) -> Field
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/hash/mod.nr#L77-L79" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/hash/mod.nr#L77-L79</a></sub></sup>
+
+
+example:
+
+```rust title="pedersen-hash" showLineNumbers 
+fn main(x: Field, y: Field, expected_hash: Field) {
+    let hash = std::hash::pedersen_hash([x, y]);
+    assert_eq(hash, expected_hash);
+}
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/test_programs/execution_success/pedersen_hash/src/main.nr#L1-L7" target="_blank" rel="noopener noreferrer">Source code: test_programs/execution_success/pedersen_hash/src/main.nr#L1-L7</a></sub></sup>
+
+
+<BlackBoxInfo to="../black_box_fns" />
+
+## pedersen_commitment
+
+Given an array of Fields, returns the Pedersen commitment.
+
+```rust title="pedersen_commitment" showLineNumbers 
+pub fn pedersen_commitment<let N: u32>(input: [Field; N]) -> EmbeddedCurvePoint {
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/hash/mod.nr#L29-L31" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/hash/mod.nr#L29-L31</a></sub></sup>
+
+
+example:
+
+```rust title="pedersen-commitment" showLineNumbers 
+fn main(x: Field, y: Field, expected_commitment: std::embedded_curve_ops::EmbeddedCurvePoint) {
+    let commitment = std::hash::pedersen_commitment([x, y]);
+    assert_eq(commitment.x, expected_commitment.x);
+    assert_eq(commitment.y, expected_commitment.y);
+}
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/test_programs/execution_success/pedersen_commitment/src/main.nr#L1-L8" target="_blank" rel="noopener noreferrer">Source code: test_programs/execution_success/pedersen_commitment/src/main.nr#L1-L8</a></sub></sup>
+
+
+<BlackBoxInfo to="../black_box_fns"/>
+
+## keccak256
+
+Given an array of bytes (`u8`), returns the resulting keccak hash as an array of
+32 bytes (`[u8; 32]`). Specify a message_size to hash only the first
+`message_size` bytes of the input.
+
+```rust title="keccak256" showLineNumbers 
+pub fn keccak256<let N: u32>(input: [u8; N], message_size: u32) -> [u8; 32]
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/hash/mod.nr#L125-L127" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/hash/mod.nr#L125-L127</a></sub></sup>
+
+
+example:
+
+```rust title="keccak256" showLineNumbers 
+fn main(x: Field, result: [u8; 32]) {
+    // We use the `as` keyword here to denote the fact that we want to take just the first byte from the x Field
+    // The padding is taken care of by the program
+    let digest = std::hash::keccak256([x as u8], 1);
+    assert(digest == result);
+
+    //#1399: variable message size
+    let message_size = 4;
+    let hash_a = std::hash::keccak256([1, 2, 3, 4], message_size);
+    let hash_b = std::hash::keccak256([1, 2, 3, 4, 0, 0, 0, 0], message_size);
+
+    assert(hash_a == hash_b);
+
+    let message_size_big = 8;
+    let hash_c = std::hash::keccak256([1, 2, 3, 4, 0, 0, 0, 0], message_size_big);
+
+    assert(hash_a != hash_c);
+}
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/test_programs/execution_success/keccak256/src/main.nr#L1-L21" target="_blank" rel="noopener noreferrer">Source code: test_programs/execution_success/keccak256/src/main.nr#L1-L21</a></sub></sup>
+
+
+<BlackBoxInfo to="../black_box_fns"/>
+
+## poseidon
+
+Given an array of Fields, returns a new Field with the Poseidon Hash. Mind that you need to specify
+how many inputs are there to your Poseidon function.
+
+```rust
+// example for hash_1, hash_2 accepts an array of length 2, etc
+fn hash_1(input: [Field; 1]) -> Field
+```
+
+example:
+
+```rust title="poseidon" showLineNumbers 
+use std::hash::poseidon;
+
+fn main(x1: [Field; 2], y1: pub Field, x2: [Field; 4], y2: pub Field) {
+    let hash1 = poseidon::bn254::hash_2(x1);
+    assert(hash1 == y1);
+
+    let hash2 = poseidon::bn254::hash_4(x2);
+    assert(hash2 == y2);
+}
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/test_programs/execution_success/poseidon_bn254_hash/src/main.nr#L1-L11" target="_blank" rel="noopener noreferrer">Source code: test_programs/execution_success/poseidon_bn254_hash/src/main.nr#L1-L11</a></sub></sup>
+
+
+## poseidon 2
+
+Given an array of Fields, returns a new Field with the Poseidon2 Hash. Contrary to the Poseidon
+function, there is only one hash and you can specify a message_size to hash only the first 
+`message_size` bytes of the input,
+
+```rust
+// example for hashing the first three elements of the input
+Poseidon2::hash(input, 3);
+```
+
+example:
+
+```rust title="poseidon2" showLineNumbers 
+use std::hash::poseidon2;
+
+fn main(inputs: [Field; 4], expected_hash: Field) {
+    let hash = poseidon2::Poseidon2::hash(inputs, inputs.len());
+    assert_eq(hash, expected_hash);
+}
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/test_programs/execution_success/poseidon2/src/main.nr#L1-L8" target="_blank" rel="noopener noreferrer">Source code: test_programs/execution_success/poseidon2/src/main.nr#L1-L8</a></sub></sup>
+
+
+## mimc_bn254 and mimc
+
+`mimc_bn254` is `mimc`, but with hardcoded parameters for the BN254 curve. You can use it by
+providing an array of Fields, and it returns a Field with the hash. You can use the `mimc` method if
+you're willing to input your own constants:
+
+```rust
+fn mimc<N>(x: Field, k: Field, constants: [Field; N], exp : Field) -> Field
+```
+
+otherwise, use the `mimc_bn254` method:
+
+```rust
+fn mimc_bn254<let N: u32>(array: [Field; N]) -> Field
+```
+
+example:
+
+```rust
+
+fn main() {
+    let x = [163, 117, 178, 149]; // some random bytes
+    let hash = std::hash::mimc::mimc_bn254(x);
+}
+```
+
+## hash_to_field
+
+```rust
+fn hash_to_field(_input : [Field]) -> Field {}
+```
+
+Calculates the `blake2s` hash of the inputs and returns the hash modulo the field modulus to return
+a value which can be represented as a `Field`.
+
diff --git a/docs/versioned_docs/version-v0.35.0/noir/standard_library/cryptographic_primitives/index.md b/docs/versioned_docs/version-v0.35.0/noir/standard_library/cryptographic_primitives/index.md
new file mode 100644
index 00000000000..650f30165d5
--- /dev/null
+++ b/docs/versioned_docs/version-v0.35.0/noir/standard_library/cryptographic_primitives/index.md
@@ -0,0 +1,14 @@
+---
+title: Cryptographic Primitives
+description:
+  Learn about the cryptographic primitives ready to use for any Noir project
+keywords:
+  [
+    cryptographic primitives,
+    Noir project,
+  ]
+---
+
+The Noir team is progressively adding new cryptographic primitives to the standard library. Reach out for news or if you would be interested in adding more of these calculations in Noir.
+
+Some methods are available thanks to the Aztec backend, not being performed using Noir. When using other backends, these methods may or may not be supplied.
diff --git a/docs/docs/noir/standard_library/cryptographic_primitives/schnorr.mdx b/docs/versioned_docs/version-v0.35.0/noir/standard_library/cryptographic_primitives/schnorr.mdx
similarity index 54%
rename from docs/docs/noir/standard_library/cryptographic_primitives/schnorr.mdx
rename to docs/versioned_docs/version-v0.35.0/noir/standard_library/cryptographic_primitives/schnorr.mdx
index 2c9eb18cd34..0058c0c0c98 100644
--- a/docs/docs/noir/standard_library/cryptographic_primitives/schnorr.mdx
+++ b/docs/versioned_docs/version-v0.35.0/noir/standard_library/cryptographic_primitives/schnorr.mdx
@@ -5,14 +5,23 @@ keywords: [cryptographic primitives, Noir project, schnorr, signatures]
 sidebar_position: 2
 ---
 
-import BlackBoxInfo from '@site/src/components/Notes/_blackbox.mdx';
+import BlackBoxInfo from '@site/src/components/Notes/_blackbox';
 
 ## schnorr::verify_signature
 
 Verifier for Schnorr signatures over the embedded curve (for BN254 it is Grumpkin).
 See schnorr::verify_signature_slice for a version that works directly on slices.
 
-#include_code schnorr_verify noir_stdlib/src/schnorr.nr rust
+```rust title="schnorr_verify" showLineNumbers 
+pub fn verify_signature<let N: u32>(
+    public_key_x: Field,
+    public_key_y: Field,
+    signature: [u8; 64],
+    message: [u8; N]
+) -> bool
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/schnorr.nr#L4-L11" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/schnorr.nr#L4-L11</a></sub></sup>
+
 
 where `_signature` can be generated like so using the npm package
 [@noir-lang/barretenberg](https://www.npmjs.com/package/@noir-lang/barretenberg)
@@ -34,13 +43,22 @@ const signature = Array.from(
 ...
 ```
 
-<BlackBoxInfo />
+<BlackBoxInfo to="../black_box_fns"/>
 
 ## schnorr::verify_signature_slice
 
 Verifier for Schnorr signatures over the embedded curve (for BN254 it is Grumpkin)
 where the message is a slice. 
 
-#include_code schnorr_verify_slice noir_stdlib/src/schnorr.nr rust
+```rust title="schnorr_verify_slice" showLineNumbers 
+pub fn verify_signature_slice(
+    public_key_x: Field,
+    public_key_y: Field,
+    signature: [u8; 64],
+    message: [u8]
+) -> bool
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/schnorr.nr#L15-L22" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/schnorr.nr#L15-L22</a></sub></sup>
+
 
-<BlackBoxInfo />
+<BlackBoxInfo to="../black_box_fns"/>
diff --git a/docs/versioned_docs/version-v0.35.0/noir/standard_library/fmtstr.md b/docs/versioned_docs/version-v0.35.0/noir/standard_library/fmtstr.md
new file mode 100644
index 00000000000..65a7da9996d
--- /dev/null
+++ b/docs/versioned_docs/version-v0.35.0/noir/standard_library/fmtstr.md
@@ -0,0 +1,17 @@
+---
+title: fmtstr
+---
+
+`fmtstr<N, T>` is the type resulting from using format string (`f"..."`).
+
+## Methods
+
+### quoted_contents
+
+```rust title="quoted_contents" showLineNumbers 
+comptime fn quoted_contents(self) -> Quoted {}
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/meta/format_string.nr#L3-L5" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/meta/format_string.nr#L3-L5</a></sub></sup>
+
+
+Returns the format string contents (that is, without the leading and trailing double quotes) as a `Quoted` value.
\ No newline at end of file
diff --git a/docs/versioned_docs/version-v0.35.0/noir/standard_library/is_unconstrained.md b/docs/versioned_docs/version-v0.35.0/noir/standard_library/is_unconstrained.md
new file mode 100644
index 00000000000..51bb1bda8f1
--- /dev/null
+++ b/docs/versioned_docs/version-v0.35.0/noir/standard_library/is_unconstrained.md
@@ -0,0 +1,69 @@
+---
+title: Is Unconstrained Function
+description:
+  The is_unconstrained function returns wether the context at that point of the program is unconstrained or not.
+keywords:
+  [
+    unconstrained
+  ]
+---
+
+It's very common for functions in circuits to take unconstrained hints of an expensive computation and then verify it. This is done by running the hint in an unconstrained context and then verifying the result in a constrained context.
+
+When a function is marked as unconstrained, any subsequent functions that it calls will also be run in an unconstrained context. However, if we are implementing a library function, other users might call it within an unconstrained context or a constrained one. Generally, in an unconstrained context we prefer just computing the result instead of taking a hint of it and verifying it, since that'd mean doing the same computation twice:
+
+```rust 
+
+fn my_expensive_computation(){
+  ...
+}
+
+unconstrained fn my_expensive_computation_hint(){
+  my_expensive_computation()
+}
+
+pub fn external_interface(){
+  my_expensive_computation_hint();
+  // verify my_expensive_computation: If external_interface is called from unconstrained, this is redundant
+  ...
+}
+
+```
+
+In order to improve the performance in an unconstrained context you can use the function at `std::runtime::is_unconstrained() -> bool`:
+
+
+```rust 
+use dep::std::runtime::is_unconstrained;
+
+fn my_expensive_computation(){
+  ...
+}
+
+unconstrained fn my_expensive_computation_hint(){
+  my_expensive_computation()
+}
+
+pub fn external_interface(){
+  if is_unconstrained() {
+    my_expensive_computation();
+  } else {
+    my_expensive_computation_hint();
+    // verify my_expensive_computation
+    ...
+  }
+}
+
+```
+
+The is_unconstrained result is resolved at compile time, so in unconstrained contexts the compiler removes the else branch, and in constrained contexts the compiler removes the if branch, reducing the amount of compute necessary to run external_interface.
+
+Note that using `is_unconstrained` in a `comptime` context will also return `true`:
+
+```
+fn main() {
+    comptime {
+        assert(is_unconstrained());
+    }
+}
+```
diff --git a/docs/versioned_docs/version-v0.35.0/noir/standard_library/logging.md b/docs/versioned_docs/version-v0.35.0/noir/standard_library/logging.md
new file mode 100644
index 00000000000..db75ef9f86f
--- /dev/null
+++ b/docs/versioned_docs/version-v0.35.0/noir/standard_library/logging.md
@@ -0,0 +1,78 @@
+---
+title: Logging
+description:
+  Learn how to use the println statement for debugging in Noir with this tutorial. Understand the
+  basics of logging in Noir and how to implement it in your code.
+keywords:
+  [
+    noir logging,
+    println statement,
+    print statement,
+    debugging in noir,
+    noir std library,
+    logging tutorial,
+    basic logging in noir,
+    noir logging implementation,
+    noir debugging techniques,
+    rust,
+  ]
+---
+
+The standard library provides two familiar statements you can use: `println` and `print`. Despite being a limited implementation of rust's `println!` and `print!` macros, these constructs can be useful for debugging.
+
+You can print the output of both statements in your Noir code by using the `nargo execute` command or the `--show-output` flag when using `nargo test` (provided there are print statements in your tests).
+
+It is recommended to use `nargo execute` if you want to debug failing constraints with `println` or `print` statements. This is due to every input in a test being a constant rather than a witness, so we issue an error during compilation while we only print during execution (which comes after compilation). Neither `println`, nor `print` are callable for failed constraints caught at compile time.
+
+Both `print` and `println` are generic functions which can work on integers, fields, strings, and even structs or expressions. Note however, that slices are currently unsupported. For example:
+
+```rust
+struct Person {
+    age: Field,
+    height: Field,
+}
+
+fn main(age: Field, height: Field) {
+    let person = Person {
+        age: age,
+        height: height,
+    };
+    println(person);
+    println(age + height);
+    println("Hello world!");
+}
+```
+
+You can print different types in the same statement (including strings) with a type called `fmtstr`. It can be specified in the same way as a normal string, just prepended with an "f" character:
+
+```rust
+  let fmt_str = f"i: {i}, j: {j}";
+  println(fmt_str);
+
+  let s = myStruct { y: x, x: y };
+  println(s);
+
+  println(f"i: {i}, s: {s}");
+
+  println(x);
+  println([x, y]);
+
+  let foo = fooStruct { my_struct: s, foo: 15 };
+  println(f"s: {s}, foo: {foo}");
+
+  println(15);       // prints 0x0f, implicit Field
+  println(-1 as u8); // prints 255
+  println(-1 as i8); // prints -1
+```
+
+Examples shown above are interchangeable between the two `print` statements:
+
+```rust
+let person = Person { age : age, height : height };
+
+println(person);
+print(person);
+
+println("Hello world!"); // Prints with a newline at the end of the input
+print("Hello world!");   // Prints the input and keeps cursor on the same line
+```
diff --git a/docs/versioned_docs/version-v0.35.0/noir/standard_library/merkle_trees.md b/docs/versioned_docs/version-v0.35.0/noir/standard_library/merkle_trees.md
new file mode 100644
index 00000000000..6a9ebf72ada
--- /dev/null
+++ b/docs/versioned_docs/version-v0.35.0/noir/standard_library/merkle_trees.md
@@ -0,0 +1,58 @@
+---
+title: Merkle Trees
+description: Learn about Merkle Trees in Noir with this tutorial. Explore the basics of computing a merkle root using a proof, with examples.
+keywords:
+  [
+    Merkle trees in Noir,
+    Noir programming language,
+    check membership,
+    computing root from leaf,
+    Noir Merkle tree implementation,
+    Merkle tree tutorial,
+    Merkle tree code examples,
+    Noir libraries,
+    pedersen hash.,
+  ]
+---
+
+## compute_merkle_root
+
+Returns the root of the tree from the provided leaf and its hash path, using a [Pedersen hash](./cryptographic_primitives/hashes.mdx#pedersen_hash).
+
+```rust
+fn compute_merkle_root(leaf : Field, index : Field, hash_path: [Field]) -> Field
+```
+
+example:
+
+```rust
+/**
+    // these values are for this example only
+    index = "0"
+    priv_key = "0x000000000000000000000000000000000000000000000000000000616c696365"
+    secret = "0x1929ea3ab8d9106a899386883d9428f8256cfedb3c4f6b66bf4aa4d28a79988f"
+    note_hash_path = [
+    "0x1e61bdae0f027b1b2159e1f9d3f8d00fa668a952dddd822fda80dc745d6f65cc",
+    "0x0e4223f3925f98934393c74975142bd73079ab0621f4ee133cee050a3c194f1a",
+    "0x2fd7bb412155bf8693a3bd2a3e7581a679c95c68a052f835dddca85fa1569a40"
+    ]
+ */
+fn main(index: Field, priv_key: Field, secret: Field, note_hash_path: [Field; 3]) {
+
+    let pubkey = std::scalar_mul::fixed_base_embedded_curve(priv_key);
+    let pubkey_x = pubkey[0];
+    let pubkey_y = pubkey[1];
+    let note_commitment = std::hash::pedersen(&[pubkey_x, pubkey_y, secret]);
+
+    let root = std::merkle::compute_merkle_root(note_commitment[0], index, note_hash_path.as_slice());
+    println(root);
+}
+```
+
+To check merkle tree membership:
+
+1. Include a merkle root as a program input.
+2. Compute the merkle root of a given leaf, index and hash path.
+3. Assert the merkle roots are equal.
+
+For more info about merkle trees, see the Wikipedia [page](https://en.wikipedia.org/wiki/Merkle_tree).
diff --git a/docs/versioned_docs/version-v0.35.0/noir/standard_library/meta/ctstring.md b/docs/versioned_docs/version-v0.35.0/noir/standard_library/meta/ctstring.md
new file mode 100644
index 00000000000..0be9bbced4e
--- /dev/null
+++ b/docs/versioned_docs/version-v0.35.0/noir/standard_library/meta/ctstring.md
@@ -0,0 +1,100 @@
+---
+title: CtString
+---
+
+`std::meta::ctstring` contains methods on the built-in `CtString` type which is
+a compile-time, dynamically-sized string type. Compared to `str<N>` and `fmtstr<N, T>`,
+`CtString` is useful because its size does not need to be specified in its type. This
+can be used for formatting items at compile-time or general string handling in `comptime`
+code.
+
+Since `fmtstr`s can be converted into `CtString`s, you can make use of their formatting
+abilities in CtStrings by formatting in `fmtstr`s then converting the result to a CtString
+afterward.
+
+## Traits
+
+### AsCtString
+
+```rust title="as-ctstring" showLineNumbers 
+pub trait AsCtString {
+    comptime fn as_ctstring(self) -> CtString;
+}
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/meta/ctstring.nr#L43-L47" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/meta/ctstring.nr#L43-L47</a></sub></sup>
+
+
+Converts an object into a compile-time string.
+
+Implementations:
+
+```rust
+impl<let N: u32> AsCtString for str<N> { ... }
+impl<let N: u32, T> AsCtString for fmtstr<N, T> { ... }
+```
+
+## Methods
+
+### new
+
+```rust title="new" showLineNumbers 
+comptime fn new() -> Self {
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/meta/ctstring.nr#L4-L6" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/meta/ctstring.nr#L4-L6</a></sub></sup>
+
+
+Creates an empty `CtString`.
+
+### append_str
+
+```rust title="append_str" showLineNumbers 
+comptime fn append_str<let N: u32>(self, s: str<N>) -> Self {
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/meta/ctstring.nr#L11-L13" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/meta/ctstring.nr#L11-L13</a></sub></sup>
+
+
+Returns a new CtString with the given str appended onto the end.
+
+### append_fmtstr
+
+```rust title="append_fmtstr" showLineNumbers 
+comptime fn append_fmtstr<let N: u32, T>(self, s: fmtstr<N, T>) -> Self {
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/meta/ctstring.nr#L17-L19" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/meta/ctstring.nr#L17-L19</a></sub></sup>
+
+
+Returns a new CtString with the given fmtstr appended onto the end.
+
+### as_quoted_str
+
+```rust title="as_quoted_str" showLineNumbers 
+comptime fn as_quoted_str(self) -> Quoted {
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/meta/ctstring.nr#L26-L28" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/meta/ctstring.nr#L26-L28</a></sub></sup>
+
+
+Returns a quoted string literal from this string's contents.
+
+There is no direct conversion from a `CtString` to a `str<N>` since
+the size would not be known. To get around this, this function can
+be used in combination with macro insertion (`!`) to insert this string
+literal at this function's call site.
+
+Example:
+
+```rust title="as_quoted_str_example" showLineNumbers 
+let my_ctstring = "foo bar".as_ctstring();
+            let my_str = my_ctstring.as_quoted_str!();
+
+            assert_eq(crate::meta::type_of(my_str), quote { str<7> }.as_type());
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/meta/ctstring.nr#L90-L95" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/meta/ctstring.nr#L90-L95</a></sub></sup>
+
+
+## Trait Implementations
+
+```rust
+impl Eq for CtString
+impl Hash for CtString
+impl Append for CtString
+```
diff --git a/docs/versioned_docs/version-v0.35.0/noir/standard_library/meta/expr.md b/docs/versioned_docs/version-v0.35.0/noir/standard_library/meta/expr.md
new file mode 100644
index 00000000000..1da32b0bc09
--- /dev/null
+++ b/docs/versioned_docs/version-v0.35.0/noir/standard_library/meta/expr.md
@@ -0,0 +1,378 @@
+---
+title: Expr
+---
+
+`std::meta::expr` contains methods on the built-in `Expr` type for quoted, syntactically valid expressions.
+
+## Methods
+
+### as_array
+
+```rust title="as_array" showLineNumbers 
+comptime fn as_array(self) -> Option<[Expr]> {}
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/meta/expr.nr#L10-L12" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/meta/expr.nr#L10-L12</a></sub></sup>
+
+
+If this expression is an array, this returns a slice of each element in the array.
+
+### as_assert
+
+```rust title="as_assert" showLineNumbers 
+comptime fn as_assert(self) -> Option<(Expr, Option<Expr>)> {}
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/meta/expr.nr#L16-L18" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/meta/expr.nr#L16-L18</a></sub></sup>
+
+
+If this expression is an assert, this returns the assert expression and the optional message.
+
+### as_assert_eq
+
+```rust title="as_assert_eq" showLineNumbers 
+comptime fn as_assert_eq(self) -> Option<(Expr, Expr, Option<Expr>)> {}
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/meta/expr.nr#L23-L25" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/meta/expr.nr#L23-L25</a></sub></sup>
+
+
+If this expression is an assert_eq, this returns the left-hand-side and right-hand-side
+expressions, together with the optional message.
+
+### as_assign
+
+```rust title="as_assign" showLineNumbers 
+comptime fn as_assign(self) -> Option<(Expr, Expr)> {}
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/meta/expr.nr#L30-L32" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/meta/expr.nr#L30-L32</a></sub></sup>
+
+
+If this expression is an assignment, this returns a tuple with the left hand side
+and right hand side in order.
+
+### as_binary_op
+
+```rust title="as_binary_op" showLineNumbers 
+comptime fn as_binary_op(self) -> Option<(Expr, BinaryOp, Expr)> {}
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/meta/expr.nr#L37-L39" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/meta/expr.nr#L37-L39</a></sub></sup>
+
+
+If this expression is a binary operator operation `<lhs> <op> <rhs>`,
+return the left-hand side, operator, and the right-hand side of the operation.
+
+### as_block
+
+```rust title="as_block" showLineNumbers 
+comptime fn as_block(self) -> Option<[Expr]> {}
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/meta/expr.nr#L44-L46" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/meta/expr.nr#L44-L46</a></sub></sup>
+
+
+If this expression is a block `{ stmt1; stmt2; ...; stmtN }`, return
+a slice containing each statement.
+
+### as_bool
+
+```rust title="as_bool" showLineNumbers 
+comptime fn as_bool(self) -> Option<bool> {}
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/meta/expr.nr#L50-L52" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/meta/expr.nr#L50-L52</a></sub></sup>
+
+
+If this expression is a boolean literal, return that literal.
+
+### as_cast
+
+```rust title="as_cast" showLineNumbers 
+#[builtin(expr_as_cast)]
+    comptime fn as_cast(self) -> Option<(Expr, UnresolvedType)> {}
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/meta/expr.nr#L56-L59" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/meta/expr.nr#L56-L59</a></sub></sup>
+
+
+If this expression is a cast expression (`expr as type`), returns the casted
+expression and the type to cast to.
+
+### as_comptime
+
+```rust title="as_comptime" showLineNumbers 
+comptime fn as_comptime(self) -> Option<[Expr]> {}
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/meta/expr.nr#L64-L66" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/meta/expr.nr#L64-L66</a></sub></sup>
+
+
+If this expression is a `comptime { stmt1; stmt2; ...; stmtN }` block,
+return each statement in the block.
+
+### as_constructor
+
+```rust title="as_constructor" showLineNumbers 
+comptime fn as_constructor(self) -> Option<(UnresolvedType, [(Quoted, Expr)])> {}
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/meta/expr.nr#L71-L73" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/meta/expr.nr#L71-L73</a></sub></sup>
+
+
+If this expression is a constructor `Type { field1: expr1, ..., fieldN: exprN }`,
+return the type and the fields.
+
+### as_for
+
+```rust title="as_for" showLineNumbers 
+comptime fn as_for(self) -> Option<(Quoted, Expr, Expr)> {}
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/meta/expr.nr#L78-L80" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/meta/expr.nr#L78-L80</a></sub></sup>
+
+
+If this expression is a for statement over a single expression, return the identifier,
+the expression and the for loop body.
+
+### as_for_range
+
+```rust title="as_for" showLineNumbers 
+comptime fn as_for(self) -> Option<(Quoted, Expr, Expr)> {}
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/meta/expr.nr#L78-L80" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/meta/expr.nr#L78-L80</a></sub></sup>
+
+
+If this expression is a for statement over a range, return the identifier,
+the range start, the range end and the for loop body.
+
+### as_function_call
+
+```rust title="as_function_call" showLineNumbers 
+comptime fn as_function_call(self) -> Option<(Expr, [Expr])> {}
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/meta/expr.nr#L92-L94" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/meta/expr.nr#L92-L94</a></sub></sup>
+
+
+If this expression is a function call `foo(arg1, ..., argN)`, return
+the function and a slice of each argument.
+
+### as_if
+
+```rust title="as_if" showLineNumbers 
+comptime fn as_if(self) -> Option<(Expr, Expr, Option<Expr>)> {}
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/meta/expr.nr#L100-L102" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/meta/expr.nr#L100-L102</a></sub></sup>
+
+
+If this expression is an `if condition { then_branch } else { else_branch }`,
+return the condition, then branch, and else branch. If there is no else branch,
+`None` is returned for that branch instead.
+
+### as_index
+
+```rust title="as_index" showLineNumbers 
+comptime fn as_index(self) -> Option<(Expr, Expr)> {}
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/meta/expr.nr#L107-L109" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/meta/expr.nr#L107-L109</a></sub></sup>
+
+
+If this expression is an index into an array `array[index]`, return the
+array and the index.
+
+### as_integer
+
+```rust title="as_integer" showLineNumbers 
+comptime fn as_integer(self) -> Option<(Field, bool)> {}
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/meta/expr.nr#L114-L116" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/meta/expr.nr#L114-L116</a></sub></sup>
+
+
+If this expression is an integer literal, return the integer as a field
+as well as whether the integer is negative (true) or not (false).
+
+### as_lambda
+
+```rust title="as_lambda" showLineNumbers 
+comptime fn as_lambda(self) -> Option<([(Expr, Option<UnresolvedType>)], Option<UnresolvedType>, Expr)> {}
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/meta/expr.nr#L120-L122" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/meta/expr.nr#L120-L122</a></sub></sup>
+
+
+If this expression is a lambda, returns the parameters, return type and body.
+
+### as_let
+
+```rust title="as_let" showLineNumbers 
+comptime fn as_let(self) -> Option<(Expr, Option<UnresolvedType>, Expr)> {}
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/meta/expr.nr#L127-L129" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/meta/expr.nr#L127-L129</a></sub></sup>
+
+
+If this expression is a let statement, returns the let pattern as an `Expr`,
+the optional type annotation, and the assigned expression.
+
+### as_member_access
+
+```rust title="as_member_access" showLineNumbers 
+comptime fn as_member_access(self) -> Option<(Expr, Quoted)> {}
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/meta/expr.nr#L134-L136" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/meta/expr.nr#L134-L136</a></sub></sup>
+
+
+If this expression is a member access `foo.bar`, return the struct/tuple
+expression and the field. The field will be represented as a quoted value.
+
+### as_method_call
+
+```rust title="as_method_call" showLineNumbers 
+comptime fn as_method_call(self) -> Option<(Expr, Quoted, [UnresolvedType], [Expr])> {}
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/meta/expr.nr#L141-L143" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/meta/expr.nr#L141-L143</a></sub></sup>
+
+
+If this expression is a method call `foo.bar::<generic1, ..., genericM>(arg1, ..., argN)`, return
+the receiver, method name, a slice of each generic argument, and a slice of each argument.
+
+### as_repeated_element_array
+
+```rust title="as_repeated_element_array" showLineNumbers 
+comptime fn as_repeated_element_array(self) -> Option<(Expr, Expr)> {}
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/meta/expr.nr#L148-L150" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/meta/expr.nr#L148-L150</a></sub></sup>
+
+
+If this expression is a repeated element array `[elem; length]`, return
+the repeated element and the length expressions.
+
+### as_repeated_element_slice
+
+```rust title="as_repeated_element_slice" showLineNumbers 
+comptime fn as_repeated_element_slice(self) -> Option<(Expr, Expr)> {}
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/meta/expr.nr#L155-L157" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/meta/expr.nr#L155-L157</a></sub></sup>
+
+
+If this expression is a repeated element slice `[elem; length]`, return
+the repeated element and the length expressions.
+
+### as_slice
+
+```rust title="as_slice" showLineNumbers 
+comptime fn as_slice(self) -> Option<[Expr]> {}
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/meta/expr.nr#L162-L164" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/meta/expr.nr#L162-L164</a></sub></sup>
+
+
+If this expression is a slice literal `&[elem1, ..., elemN]`,
+return each element of the slice.
+
+### as_tuple
+
+```rust title="as_tuple" showLineNumbers 
+comptime fn as_tuple(self) -> Option<[Expr]> {}
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/meta/expr.nr#L169-L171" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/meta/expr.nr#L169-L171</a></sub></sup>
+
+
+If this expression is a tuple `(field1, ..., fieldN)`,
+return each element of the tuple.
+
+### as_unary_op
+
+```rust title="as_unary_op" showLineNumbers 
+comptime fn as_unary_op(self) -> Option<(UnaryOp, Expr)> {}
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/meta/expr.nr#L176-L178" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/meta/expr.nr#L176-L178</a></sub></sup>
+
+
+If this expression is a unary operation `<op> <rhs>`,
+return the unary operator as well as the right-hand side expression.
+
+### as_unsafe
+
+```rust title="as_unsafe" showLineNumbers 
+comptime fn as_unsafe(self) -> Option<[Expr]> {}
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/meta/expr.nr#L183-L185" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/meta/expr.nr#L183-L185</a></sub></sup>
+
+
+If this expression is an `unsafe { stmt1; ...; stmtN }` block,
+return each statement inside in a slice.
+
+### has_semicolon
+
+```rust title="has_semicolon" showLineNumbers 
+comptime fn has_semicolon(self) -> bool {}
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/meta/expr.nr#L204-L206" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/meta/expr.nr#L204-L206</a></sub></sup>
+
+
+`true` if this expression is trailed by a semicolon. E.g.
+
+```
+comptime {
+    let expr1 = quote { 1 + 2 }.as_expr().unwrap();
+    let expr2 = quote { 1 + 2; }.as_expr().unwrap();
+
+    assert(expr1.as_binary_op().is_some());
+    assert(expr2.as_binary_op().is_some());
+
+    assert(!expr1.has_semicolon());
+    assert(expr2.has_semicolon());
+}
+```
+
+### is_break
+
+```rust title="is_break" showLineNumbers 
+comptime fn is_break(self) -> bool {}
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/meta/expr.nr#L210-L212" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/meta/expr.nr#L210-L212</a></sub></sup>
+
+
+`true` if this expression is `break`.
+
+### is_continue
+
+```rust title="is_continue" showLineNumbers 
+comptime fn is_continue(self) -> bool {}
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/meta/expr.nr#L216-L218" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/meta/expr.nr#L216-L218</a></sub></sup>
+
+
+`true` if this expression is `continue`.
+
+### modify
+
+```rust title="modify" showLineNumbers 
+comptime fn modify<Env>(self, f: fn[Env](Expr) -> Option<Expr>) -> Expr {
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/meta/expr.nr#L227-L229" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/meta/expr.nr#L227-L229</a></sub></sup>
+
+
+Applies a mapping function to this expression and to all of its sub-expressions.
+`f` will be applied to each sub-expression first, then applied to the expression itself.
+
+This happens recursively for every expression within `self`.
+
+For example, calling `modify` on `(&[1], &[2, 3])` with an `f` that returns `Option::some`
+for expressions that are integers, doubling them, would return `(&[2], &[4, 6])`.
+
+### quoted
+
+```rust title="quoted" showLineNumbers 
+comptime fn quoted(self) -> Quoted {
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/meta/expr.nr#L264-L266" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/meta/expr.nr#L264-L266</a></sub></sup>
+
+
+Returns this expression as a `Quoted` value. It's the same as `quote { $self }`.
+
+### resolve
+
+```rust title="resolve" showLineNumbers 
+comptime fn resolve(self, in_function: Option<FunctionDefinition>) -> TypedExpr {}
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/meta/expr.nr#L280-L282" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/meta/expr.nr#L280-L282</a></sub></sup>
+
+
+Resolves and type-checks this expression and returns the result as a `TypedExpr`. 
+
+The `in_function` argument specifies where the expression is resolved:
+- If it's `none`, the expression is resolved in the function where `resolve` was called
+- If it's `some`, the expression is resolved in the given function
+
+If any names used by this expression are not in scope or if there are any type errors, 
+this will give compiler errors as if the expression was written directly into 
+the current `comptime` function.
\ No newline at end of file
diff --git a/docs/versioned_docs/version-v0.35.0/noir/standard_library/meta/function_def.md b/docs/versioned_docs/version-v0.35.0/noir/standard_library/meta/function_def.md
new file mode 100644
index 00000000000..e490af68f7f
--- /dev/null
+++ b/docs/versioned_docs/version-v0.35.0/noir/standard_library/meta/function_def.md
@@ -0,0 +1,166 @@
+---
+title: FunctionDefinition
+---
+
+`std::meta::function_def` contains methods on the built-in `FunctionDefinition` type representing
+a function definition in the source program.
+
+## Methods
+
+### add_attribute
+
+```rust title="add_attribute" showLineNumbers 
+comptime fn add_attribute<let N: u32>(self, attribute: str<N>) {}
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/meta/function_def.nr#L3-L5" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/meta/function_def.nr#L3-L5</a></sub></sup>
+
+
+Adds an attribute to the function. This is only valid
+on functions in the current crate which have not yet been resolved.
+This means any functions called at compile-time are invalid targets for this method.
+
+### body
+
+```rust title="body" showLineNumbers 
+comptime fn body(self) -> Expr {}
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/meta/function_def.nr#L8-L10" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/meta/function_def.nr#L8-L10</a></sub></sup>
+
+
+Returns the body of the function as an expression. This is only valid
+on functions in the current crate which have not yet been resolved.
+This means any functions called at compile-time are invalid targets for this method.
+
+### has_named_attribute
+
+```rust title="has_named_attribute" showLineNumbers 
+comptime fn has_named_attribute<let N: u32>(self, name: str<N>) -> bool {}
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/meta/function_def.nr#L13-L15" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/meta/function_def.nr#L13-L15</a></sub></sup>
+
+
+Returns true if this function has a custom attribute with the given name.
+
+### is_unconstrained
+
+```rust title="is_unconstrained" showLineNumbers 
+comptime fn is_unconstrained(self) -> bool {}
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/meta/function_def.nr#L18-L20" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/meta/function_def.nr#L18-L20</a></sub></sup>
+
+
+Returns true if this function is unconstrained.
+
+### module
+
+```rust title="module" showLineNumbers 
+comptime fn module(self) -> Module {}
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/meta/function_def.nr#L23-L25" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/meta/function_def.nr#L23-L25</a></sub></sup>
+
+
+Returns the module where the function is defined.
+
+### name
+
+```rust title="name" showLineNumbers 
+comptime fn name(self) -> Quoted {}
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/meta/function_def.nr#L28-L30" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/meta/function_def.nr#L28-L30</a></sub></sup>
+
+
+Returns the name of the function.
+
+### parameters
+
+```rust title="parameters" showLineNumbers 
+comptime fn parameters(self) -> [(Quoted, Type)] {}
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/meta/function_def.nr#L33-L35" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/meta/function_def.nr#L33-L35</a></sub></sup>
+
+
+Returns each parameter of the function as a tuple of (parameter pattern, parameter type).
+
+### return_type
+
+```rust title="return_type" showLineNumbers 
+comptime fn return_type(self) -> Type {}
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/meta/function_def.nr#L38-L40" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/meta/function_def.nr#L38-L40</a></sub></sup>
+
+
+The return type of the function.
+
+### set_body
+
+```rust title="set_body" showLineNumbers 
+comptime fn set_body(self, body: Expr) {}
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/meta/function_def.nr#L43-L45" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/meta/function_def.nr#L43-L45</a></sub></sup>
+
+
+Mutate the function body to a new expression. This is only valid
+on functions in the current crate which have not yet been resolved.
+This means any functions called at compile-time are invalid targets for this method.
+
+### set_parameters
+
+```rust title="set_parameters" showLineNumbers 
+comptime fn set_parameters(self, parameters: [(Quoted, Type)]) {}
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/meta/function_def.nr#L48-L50" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/meta/function_def.nr#L48-L50</a></sub></sup>
+
+
+Mutates the function's parameters to a new set of parameters. This is only valid
+on functions in the current crate which have not yet been resolved.
+This means any functions called at compile-time are invalid targets for this method.
+
+Expects a slice of (parameter pattern, parameter type) for each parameter. Requires
+each parameter pattern to be a syntactically valid parameter.
+
+### set_return_type
+
+```rust title="set_return_type" showLineNumbers 
+comptime fn set_return_type(self, return_type: Type) {}
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/meta/function_def.nr#L53-L55" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/meta/function_def.nr#L53-L55</a></sub></sup>
+
+
+Mutates the function's return type to a new type. This is only valid
+on functions in the current crate which have not yet been resolved.
+This means any functions called at compile-time are invalid targets for this method.
+
+### set_return_public
+
+```rust title="set_return_public" showLineNumbers 
+comptime fn set_return_public(self, public: bool) {}
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/meta/function_def.nr#L58-L60" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/meta/function_def.nr#L58-L60</a></sub></sup>
+
+
+Mutates the function's return visibility to public (if `true` is given) or private (if `false` is given).
+This is only valid on functions in the current crate which have not yet been resolved.
+This means any functions called at compile-time are invalid targets for this method.
+
+### set_unconstrained
+
+```rust title="set_unconstrained" showLineNumbers 
+comptime fn set_unconstrained(self, value: bool) {}
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/meta/function_def.nr#L63-L65" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/meta/function_def.nr#L63-L65</a></sub></sup>
+
+
+Mutates the function to be unconstrained (if `true` is given) or not (if `false` is given).
+This is only valid on functions in the current crate which have not yet been resolved.
+This means any functions called at compile-time are invalid targets for this method.
+
+## Trait Implementations
+
+```rust
+impl Eq for FunctionDefinition
+impl Hash for FunctionDefinition
+```
+
+Note that each function is assigned a unique ID internally and this is what is used for
+equality and hashing. So even functions with identical signatures and bodies may not
+be equal in this sense if they were originally different items in the source program.
diff --git a/docs/versioned_docs/version-v0.35.0/noir/standard_library/meta/index.md b/docs/versioned_docs/version-v0.35.0/noir/standard_library/meta/index.md
new file mode 100644
index 00000000000..f81c89e05ae
--- /dev/null
+++ b/docs/versioned_docs/version-v0.35.0/noir/standard_library/meta/index.md
@@ -0,0 +1,210 @@
+---
+title: Metaprogramming
+description: Noir's Metaprogramming API
+keywords: [metaprogramming, comptime, macros, macro, quote, unquote]
+---
+
+`std::meta` is the entry point for Noir's metaprogramming API. This consists of `comptime` functions
+and types used for inspecting and modifying Noir programs.
+
+## Functions
+
+### type_of
+
+```rust title="type_of" showLineNumbers 
+pub comptime fn type_of<T>(x: T) -> Type {}
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/meta/mod.nr#L27-L29" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/meta/mod.nr#L27-L29</a></sub></sup>
+
+
+Returns the type of a variable at compile-time.
+
+Example:
+```rust
+comptime {
+    let x: i32 = 1;
+    let x_type: Type = std::meta::type_of(x);
+
+    assert_eq(x_type, quote { i32 }.as_type());
+}
+```
+
+### unquote
+
+```rust title="unquote" showLineNumbers 
+pub comptime fn unquote(code: Quoted) -> Quoted {
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/meta/mod.nr#L19-L21" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/meta/mod.nr#L19-L21</a></sub></sup>
+
+
+Unquotes the passed-in token stream where this function was called.
+
+Example:
+```rust
+comptime {
+    let code = quote { 1 + 2 };
+
+    // let x = 1 + 2;
+    let x = unquote!(code);
+}
+```
+
+### derive
+
+```rust title="derive" showLineNumbers 
+#[varargs]
+pub comptime fn derive(s: StructDefinition, traits: [TraitDefinition]) -> Quoted {
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/meta/mod.nr#L47-L50" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/meta/mod.nr#L47-L50</a></sub></sup>
+
+
+Attribute placed on struct definitions.
+
+Creates a trait impl for each trait passed in as an argument.
+To do this, the trait must have a derive handler registered
+with `derive_via` beforehand. The traits in the stdlib that
+can be derived this way are `Eq`, `Ord`, `Default`, and `Hash`.
+
+Example:
+```rust
+#[derive(Eq, Default)]
+struct Foo<T> {
+    x: i32,
+    y: T,
+}
+
+fn main() {
+    let foo1 = Foo::default();
+    let foo2 = Foo { x: 0, y: &[0] };
+    assert_eq(foo1, foo2);
+}
+```
+
+### derive_via
+
+```rust title="derive_via_signature" showLineNumbers 
+pub comptime fn derive_via(t: TraitDefinition, f: DeriveFunction) {
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/meta/mod.nr#L69-L71" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/meta/mod.nr#L69-L71</a></sub></sup>
+
+
+Attribute placed on trait definitions.
+
+Registers a function to create impls for the given trait
+when the trait is used in a `derive` call. Users may use
+this to register their own functions to enable their traits
+to be derived by `derive`.
+
+Because this function requires a function as an argument which
+should produce a trait impl for any given struct, users may find
+it helpful to use a function like `std::meta::make_trait_impl` to
+help creating these impls.
+
+Example:
+```rust
+#[derive_via(derive_do_nothing)]
+trait DoNothing {
+    fn do_nothing(self);
+}
+
+comptime fn derive_do_nothing(s: StructDefinition) -> Quoted {
+    let typ = s.as_type();
+    quote {
+        impl DoNothing for $typ {
+            fn do_nothing(self) {
+                println("Nothing");
+            }
+        }
+    }
+}
+```
+
+As another example, `derive_eq` in the stdlib is used to derive the `Eq`
+trait for any struct. It makes use of `make_trait_impl` to do this:
+
+```rust title="derive_eq" showLineNumbers 
+comptime fn derive_eq(s: StructDefinition) -> Quoted {
+    let signature = quote { fn eq(_self: Self, _other: Self) -> bool };
+    let for_each_field = |name| quote { (_self.$name == _other.$name) };
+    let body = |fields| {
+        if s.fields().len() == 0 {
+            quote { true }
+        } else {
+            fields
+        }
+    };
+    crate::meta::make_trait_impl(s, quote { Eq }, signature, for_each_field, quote { & }, body)
+}
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/cmp.nr#L10-L23" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/cmp.nr#L10-L23</a></sub></sup>
+
+
+### make_trait_impl
+
+```rust title="make_trait_impl" showLineNumbers 
+pub comptime fn make_trait_impl<Env1, Env2>(
+    s: StructDefinition,
+    trait_name: Quoted,
+    function_signature: Quoted,
+    for_each_field: fn[Env1](Quoted) -> Quoted,
+    join_fields_with: Quoted,
+    body: fn[Env2](Quoted) -> Quoted
+) -> Quoted {
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/meta/mod.nr#L88-L97" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/meta/mod.nr#L88-L97</a></sub></sup>
+
+
+A helper function to more easily create trait impls while deriving traits.
+
+Note that this function only works for traits which:
+1. Have only one method
+2. Have no generics on the trait itself.
+  - E.g. Using this on a trait such as `trait Foo<T> { ... }` will result in the
+    generated impl incorrectly missing the `T` generic.
+
+If your trait fits these criteria then `make_trait_impl` is likely the easiest
+way to write your derive handler. The arguments are as follows:
+
+- `s`: The struct to make the impl for
+- `trait_name`: The name of the trait to derive. E.g. `quote { Eq }`.
+- `function_signature`: The signature of the trait method to derive. E.g. `fn eq(self, other: Self) -> bool`.
+- `for_each_field`: An operation to be performed on each field. E.g. `|name| quote { (self.$name == other.$name) }`.
+- `join_fields_with`: A separator to join each result of `for_each_field` with.
+  E.g. `quote { & }`. You can also use an empty `quote {}` for no separator.
+- `body`: The result of the field operations are passed into this function for any final processing.
+  This is the place to insert any setup/teardown code the trait requires. If the trait doesn't require
+  any such code, you can return the body as-is: `|body| body`.
+
+Example deriving `Hash`:
+
+```rust title="derive_hash" showLineNumbers 
+comptime fn derive_hash(s: StructDefinition) -> Quoted {
+    let name = quote { Hash };
+    let signature = quote { fn hash<H>(_self: Self, _state: &mut H) where H: std::hash::Hasher };
+    let for_each_field = |name| quote { _self.$name.hash(_state); };
+    crate::meta::make_trait_impl(s, name, signature, for_each_field, quote {}, |fields| fields)
+}
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/hash/mod.nr#L144-L151" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/hash/mod.nr#L144-L151</a></sub></sup>
+
+
+Example deriving `Ord`:
+
+```rust title="derive_ord" showLineNumbers 
+comptime fn derive_ord(s: StructDefinition) -> Quoted {
+    let signature = quote { fn cmp(_self: Self, _other: Self) -> std::cmp::Ordering };
+    let for_each_field = |name| quote {
+        if result == std::cmp::Ordering::equal() {
+            result = _self.$name.cmp(_other.$name);
+        }
+    };
+    let body = |fields| quote {
+        let mut result = std::cmp::Ordering::equal();
+        $fields
+        result
+    };
+    crate::meta::make_trait_impl(s, quote { Ord }, signature, for_each_field, quote {}, body)
+}
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/cmp.nr#L181-L196" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/cmp.nr#L181-L196</a></sub></sup>
+
diff --git a/docs/versioned_docs/version-v0.35.0/noir/standard_library/meta/module.md b/docs/versioned_docs/version-v0.35.0/noir/standard_library/meta/module.md
new file mode 100644
index 00000000000..efd3e61e125
--- /dev/null
+++ b/docs/versioned_docs/version-v0.35.0/noir/standard_library/meta/module.md
@@ -0,0 +1,82 @@
+---
+title: Module
+---
+
+`std::meta::module` contains methods on the built-in `Module` type which represents a module in the source program.
+Note that this type represents a module generally, it isn't limited to only `mod my_submodule { ... }`
+declarations in the source program.
+
+## Methods
+
+### add_item
+
+```rust title="add_item" showLineNumbers 
+comptime fn add_item(self, item: Quoted) {}
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/meta/module.nr#L3-L5" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/meta/module.nr#L3-L5</a></sub></sup>
+
+
+Adds a top-level item (a function, a struct, a global, etc.) to the module. 
+Adding multiple items in one go is also valid if the `Quoted` value has multiple items in it.  
+Note that the items are type-checked as if they are inside the module they are being added to.
+
+### functions
+
+```rust title="functions" showLineNumbers 
+comptime fn functions(self) -> [FunctionDefinition] {}
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/meta/module.nr#L18-L20" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/meta/module.nr#L18-L20</a></sub></sup>
+
+
+Returns each function defined in the module.
+
+### has_named_attribute
+
+```rust title="has_named_attribute" showLineNumbers 
+comptime fn has_named_attribute<let N: u32>(self, name: str<N>) -> bool {}
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/meta/module.nr#L8-L10" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/meta/module.nr#L8-L10</a></sub></sup>
+
+
+Returns true if this module has a custom attribute with the given name.
+
+### is_contract
+
+```rust title="is_contract" showLineNumbers 
+comptime fn is_contract(self) -> bool {}
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/meta/module.nr#L13-L15" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/meta/module.nr#L13-L15</a></sub></sup>
+
+
+`true` if this module is a contract module (was declared via `contract foo { ... }`).
+
+### name
+
+```rust title="name" showLineNumbers 
+comptime fn name(self) -> Quoted {}
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/meta/module.nr#L28-L30" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/meta/module.nr#L28-L30</a></sub></sup>
+
+
+Returns the name of the module.
+
+### structs
+
+```rust title="structs" showLineNumbers 
+comptime fn structs(self) -> [StructDefinition] {}
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/meta/module.nr#L23-L25" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/meta/module.nr#L23-L25</a></sub></sup>
+
+
+Returns each struct defined in the module.
+
+## Trait Implementations
+
+```rust
+impl Eq for Module
+impl Hash for Module
+```
+
+Note that each module is assigned a unique ID internally and this is what is used for
+equality and hashing. So even modules with identical names and contents may not
+be equal in this sense if they were originally different items in the source program.
diff --git a/docs/versioned_docs/version-v0.35.0/noir/standard_library/meta/op.md b/docs/versioned_docs/version-v0.35.0/noir/standard_library/meta/op.md
new file mode 100644
index 00000000000..18d1f0768fd
--- /dev/null
+++ b/docs/versioned_docs/version-v0.35.0/noir/standard_library/meta/op.md
@@ -0,0 +1,244 @@
+---
+title: UnaryOp and BinaryOp
+---
+
+`std::meta::op` contains the `UnaryOp` and `BinaryOp` types as well as methods on them.
+These types are used to represent a unary or binary operator respectively in Noir source code.
+
+## Types
+
+### UnaryOp
+
+Represents a unary operator. One of `-`, `!`, `&mut`, or `*`.
+
+### Methods
+
+#### is_minus
+
+```rust title="is_minus" showLineNumbers 
+pub fn is_minus(self) -> bool {
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/meta/op.nr#L7-L9" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/meta/op.nr#L7-L9</a></sub></sup>
+
+
+Returns `true` if this operator is `-`.
+
+#### is_not
+
+```rust title="is_not" showLineNumbers 
+pub fn is_not(self) -> bool {
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/meta/op.nr#L13-L15" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/meta/op.nr#L13-L15</a></sub></sup>
+
+
+`true` if this operator is `!`
+
+#### is_mutable_reference
+
+```rust title="is_mutable_reference" showLineNumbers 
+pub fn is_mutable_reference(self) -> bool {
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/meta/op.nr#L19-L21" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/meta/op.nr#L19-L21</a></sub></sup>
+
+
+`true` if this operator is `&mut`
+
+#### is_dereference
+
+```rust title="is_dereference" showLineNumbers 
+pub fn is_dereference(self) -> bool {
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/meta/op.nr#L25-L27" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/meta/op.nr#L25-L27</a></sub></sup>
+
+
+`true` if this operator is `*`
+
+#### quoted
+
+```rust title="unary_quoted" showLineNumbers 
+pub comptime fn quoted(self) -> Quoted {
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/meta/op.nr#L31-L33" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/meta/op.nr#L31-L33</a></sub></sup>
+
+
+Returns this operator as a `Quoted` value.
+
+### Trait Implementations
+
+```rust
+impl Eq for UnaryOp
+impl Hash for UnaryOp
+```
+
+### BinaryOp
+
+Represents a binary operator. One of `+`, `-`, `*`, `/`, `%`, `==`, `!=`, `<`, `<=`, `>`, `>=`, `&`, `|`, `^`, `>>`, or `<<`.
+
+### Methods
+
+#### is_add
+
+```rust title="is_add" showLineNumbers 
+pub fn is_add(self) -> bool {
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/meta/op.nr#L55-L57" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/meta/op.nr#L55-L57</a></sub></sup>
+
+
+`true` if this operator is `+`
+
+#### is_subtract
+
+```rust title="is_subtract" showLineNumbers 
+pub fn is_subtract(self) -> bool {
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/meta/op.nr#L61-L63" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/meta/op.nr#L61-L63</a></sub></sup>
+
+
+`true` if this operator is `-`
+
+#### is_multiply
+
+```rust title="is_multiply" showLineNumbers 
+pub fn is_multiply(self) -> bool {
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/meta/op.nr#L67-L69" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/meta/op.nr#L67-L69</a></sub></sup>
+
+
+`true` if this operator is `*`
+
+#### is_divide
+
+```rust title="is_divide" showLineNumbers 
+pub fn is_divide(self) -> bool {
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/meta/op.nr#L73-L75" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/meta/op.nr#L73-L75</a></sub></sup>
+
+
+`true` if this operator is `/`
+
+#### is_modulo
+
+```rust title="is_modulo" showLineNumbers 
+pub fn is_modulo(self) -> bool {
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/meta/op.nr#L145-L147" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/meta/op.nr#L145-L147</a></sub></sup>
+
+
+`true` if this operator is `%`
+
+#### is_equal
+
+```rust title="is_equal" showLineNumbers 
+pub fn is_equal(self) -> bool {
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/meta/op.nr#L79-L81" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/meta/op.nr#L79-L81</a></sub></sup>
+
+
+`true` if this operator is `==`
+
+#### is_not_equal
+
+```rust title="is_not_equal" showLineNumbers 
+pub fn is_not_equal(self) -> bool {
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/meta/op.nr#L85-L87" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/meta/op.nr#L85-L87</a></sub></sup>
+
+
+`true` if this operator is `!=`
+
+#### is_less_than
+
+```rust title="is_less_than" showLineNumbers 
+pub fn is_less_than(self) -> bool {
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/meta/op.nr#L91-L93" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/meta/op.nr#L91-L93</a></sub></sup>
+
+
+`true` if this operator is `<`
+
+#### is_less_than_or_equal
+
+```rust title="is_less_than_or_equal" showLineNumbers 
+pub fn is_less_than_or_equal(self) -> bool {
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/meta/op.nr#L97-L99" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/meta/op.nr#L97-L99</a></sub></sup>
+
+
+`true` if this operator is `<=`
+
+#### is_greater_than
+
+```rust title="is_greater_than" showLineNumbers 
+pub fn is_greater_than(self) -> bool {
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/meta/op.nr#L103-L105" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/meta/op.nr#L103-L105</a></sub></sup>
+
+
+`true` if this operator is `>`
+
+#### is_greater_than_or_equal
+
+```rust title="is_greater_than_or_equal" showLineNumbers 
+pub fn is_greater_than_or_equal(self) -> bool {
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/meta/op.nr#L109-L111" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/meta/op.nr#L109-L111</a></sub></sup>
+
+
+`true` if this operator is `>=`
+
+#### is_and
+
+```rust title="is_and" showLineNumbers 
+pub fn is_and(self) -> bool {
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/meta/op.nr#L115-L117" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/meta/op.nr#L115-L117</a></sub></sup>
+
+
+`true` if this operator is `&`
+
+#### is_or
+
+```rust title="is_or" showLineNumbers 
+pub fn is_or(self) -> bool {
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/meta/op.nr#L121-L123" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/meta/op.nr#L121-L123</a></sub></sup>
+
+
+`true` if this operator is `|`
+
+#### is_shift_right
+
+```rust title="is_shift_right" showLineNumbers 
+pub fn is_shift_right(self) -> bool {
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/meta/op.nr#L133-L135" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/meta/op.nr#L133-L135</a></sub></sup>
+
+
+`true` if this operator is `>>`
+
+#### is_shift_left
+
+```rust title="is_shift_right" showLineNumbers 
+pub fn is_shift_right(self) -> bool {
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/meta/op.nr#L133-L135" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/meta/op.nr#L133-L135</a></sub></sup>
+
+
+`true` if this operator is `<<`
+
+#### quoted
+
+```rust title="binary_quoted" showLineNumbers 
+pub comptime fn quoted(self) -> Quoted {
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/meta/op.nr#L151-L153" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/meta/op.nr#L151-L153</a></sub></sup>
+
+
+Returns this operator as a `Quoted` value.
+
+### Trait Implementations
+
+```rust
+impl Eq for BinaryOp
+impl Hash for BinaryOp
+```
diff --git a/docs/versioned_docs/version-v0.35.0/noir/standard_library/meta/quoted.md b/docs/versioned_docs/version-v0.35.0/noir/standard_library/meta/quoted.md
new file mode 100644
index 00000000000..cb779bca98f
--- /dev/null
+++ b/docs/versioned_docs/version-v0.35.0/noir/standard_library/meta/quoted.md
@@ -0,0 +1,138 @@
+---
+title: Quoted
+---
+
+`std::meta::quoted` contains methods on the built-in `Quoted` type which represents
+quoted token streams and is the result of the `quote { ... }` expression.
+
+## Methods
+
+### as_expr
+
+```rust title="as_expr" showLineNumbers 
+comptime fn as_expr(self) -> Option<Expr> {}
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/meta/quoted.nr#L6-L8" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/meta/quoted.nr#L6-L8</a></sub></sup>
+
+
+Parses the quoted token stream as an expression. Returns `Option::none()` if
+the expression failed to parse.
+
+Example:
+
+```rust title="as_expr_example" showLineNumbers 
+#[test]
+    fn test_expr_as_function_call() {
+        comptime
+        {
+            let expr = quote { foo(42) }.as_expr().unwrap();
+            let (_function, args) = expr.as_function_call().unwrap();
+            assert_eq(args.len(), 1);
+            assert_eq(args[0].as_integer().unwrap(), (42, false));
+        }
+    }
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/test_programs/noir_test_success/comptime_expr/src/main.nr#L360-L371" target="_blank" rel="noopener noreferrer">Source code: test_programs/noir_test_success/comptime_expr/src/main.nr#L360-L371</a></sub></sup>
+
+
+### as_module
+
+```rust title="as_module" showLineNumbers 
+comptime fn as_module(self) -> Option<Module> {}
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/meta/quoted.nr#L11-L13" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/meta/quoted.nr#L11-L13</a></sub></sup>
+
+
+Interprets this token stream as a module path leading to the name of a module.
+Returns `Option::none()` if the module isn't found or this token stream cannot be parsed as a path.
+
+Example:
+
+```rust title="as_module_example" showLineNumbers 
+mod baz {
+    pub mod qux {}
+}
+
+#[test]
+fn as_module_test() {
+    comptime
+    {
+        let my_mod = quote { baz::qux }.as_module().unwrap();
+        assert_eq(my_mod.name(), quote { qux });
+    }
+}
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/test_programs/compile_success_empty/comptime_module/src/main.nr#L116-L129" target="_blank" rel="noopener noreferrer">Source code: test_programs/compile_success_empty/comptime_module/src/main.nr#L116-L129</a></sub></sup>
+
+
+### as_trait_constraint
+
+```rust title="as_trait_constraint" showLineNumbers 
+comptime fn as_trait_constraint(self) -> TraitConstraint {}
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/meta/quoted.nr#L16-L18" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/meta/quoted.nr#L16-L18</a></sub></sup>
+
+
+Interprets this token stream as a trait constraint (without an object type).
+Note that this function panics instead of returning `Option::none()` if the token
+stream does not parse and resolve to a valid trait constraint.
+
+Example:
+
+```rust title="implements_example" showLineNumbers 
+fn function_with_where<T>(_x: T) where T: SomeTrait<i32> {
+    comptime
+    {
+        let t = quote { T }.as_type();
+        let some_trait_i32 = quote { SomeTrait<i32> }.as_trait_constraint();
+        assert(t.implements(some_trait_i32));
+
+        assert(t.get_trait_impl(some_trait_i32).is_none());
+    }
+}
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/test_programs/compile_success_empty/comptime_type/src/main.nr#L154-L165" target="_blank" rel="noopener noreferrer">Source code: test_programs/compile_success_empty/comptime_type/src/main.nr#L154-L165</a></sub></sup>
+
+
+### as_type
+
+```rust title="as_type" showLineNumbers 
+comptime fn as_type(self) -> Type {}
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/meta/quoted.nr#L21-L23" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/meta/quoted.nr#L21-L23</a></sub></sup>
+
+
+Interprets this token stream as a resolved type. Panics if the token
+stream doesn't parse to a type or if the type isn't a valid type in scope.
+
+```rust title="implements_example" showLineNumbers 
+fn function_with_where<T>(_x: T) where T: SomeTrait<i32> {
+    comptime
+    {
+        let t = quote { T }.as_type();
+        let some_trait_i32 = quote { SomeTrait<i32> }.as_trait_constraint();
+        assert(t.implements(some_trait_i32));
+
+        assert(t.get_trait_impl(some_trait_i32).is_none());
+    }
+}
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/test_programs/compile_success_empty/comptime_type/src/main.nr#L154-L165" target="_blank" rel="noopener noreferrer">Source code: test_programs/compile_success_empty/comptime_type/src/main.nr#L154-L165</a></sub></sup>
+
+
+### tokens
+
+```rust title="tokens" showLineNumbers 
+comptime fn tokens(self) -> [Quoted] {}
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/meta/quoted.nr#L26-L28" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/meta/quoted.nr#L26-L28</a></sub></sup>
+
+
+Returns a slice of the individual tokens that form this token stream.
+
+## Trait Implementations
+
+```rust
+impl Eq for Quoted
+impl Hash for Quoted
+```
diff --git a/docs/versioned_docs/version-v0.35.0/noir/standard_library/meta/struct_def.md b/docs/versioned_docs/version-v0.35.0/noir/standard_library/meta/struct_def.md
new file mode 100644
index 00000000000..212c636d12a
--- /dev/null
+++ b/docs/versioned_docs/version-v0.35.0/noir/standard_library/meta/struct_def.md
@@ -0,0 +1,177 @@
+---
+title: StructDefinition
+---
+
+`std::meta::struct_def` contains methods on the built-in `StructDefinition` type.
+This type corresponds to `struct Name { field1: Type1, ... }` items in the source program.
+
+## Methods
+
+### add_attribute
+
+```rust title="add_attribute" showLineNumbers 
+comptime fn add_attribute<let N: u32>(self, attribute: str<N>) {}
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/meta/struct_def.nr#L3-L5" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/meta/struct_def.nr#L3-L5</a></sub></sup>
+
+
+Adds an attribute to the struct.
+
+### add_generic
+
+```rust title="add_generic" showLineNumbers 
+comptime fn add_generic<let N: u32>(self, generic_name: str<N>) -> Type {}
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/meta/struct_def.nr#L8-L10" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/meta/struct_def.nr#L8-L10</a></sub></sup>
+
+
+Adds an generic to the struct. Returns the new generic type.
+Errors if the given generic name isn't a single identifier or if
+the struct already has a generic with the same name.
+
+This method should be used carefully, if there is existing code referring
+to the struct type it may be checked before this function is called and
+see the struct with the original number of generics. This method should
+thus be preferred to use on code generated from other macros and structs
+that are not used in function signatures.
+
+Example:
+
+```rust title="add-generic-example" showLineNumbers 
+comptime fn add_generic(s: StructDefinition) {
+        assert_eq(s.generics().len(), 0);
+        let new_generic = s.add_generic("T");
+
+        let generics = s.generics();
+        assert_eq(generics.len(), 1);
+        assert_eq(generics[0], new_generic);
+    }
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/test_programs/compile_success_empty/comptime_struct_definition/src/main.nr#L38-L47" target="_blank" rel="noopener noreferrer">Source code: test_programs/compile_success_empty/comptime_struct_definition/src/main.nr#L38-L47</a></sub></sup>
+
+
+### as_type
+
+```rust title="as_type" showLineNumbers 
+comptime fn as_type(self) -> Type {}
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/meta/struct_def.nr#L15-L17" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/meta/struct_def.nr#L15-L17</a></sub></sup>
+
+
+Returns this struct as a type in the source program. If this struct has
+any generics, the generics are also included as-is.
+
+### generics
+
+```rust title="generics" showLineNumbers 
+comptime fn generics(self) -> [Type] {}
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/meta/struct_def.nr#L26-L28" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/meta/struct_def.nr#L26-L28</a></sub></sup>
+
+
+Returns each generic on this struct.
+
+Example:
+
+```
+#[example]
+struct Foo<T, U> {
+    bar: [T; 2],
+    baz: Baz<U, U>,
+}
+
+comptime fn example(foo: StructDefinition) {
+    assert_eq(foo.generics().len(), 2);
+
+    // Fails because `T` isn't in scope
+    // let t = quote { T }.as_type();
+    // assert_eq(foo.generics()[0], t);
+}
+```
+
+### fields
+
+```rust title="fields" showLineNumbers 
+comptime fn fields(self) -> [(Quoted, Type)] {}
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/meta/struct_def.nr#L33-L35" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/meta/struct_def.nr#L33-L35</a></sub></sup>
+
+
+Returns each field of this struct as a pair of (field name, field type).
+
+### has_named_attribute
+
+```rust title="has_named_attribute" showLineNumbers 
+comptime fn has_named_attribute<let N: u32>(self, name: str<N>) -> bool {}
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/meta/struct_def.nr#L20-L22" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/meta/struct_def.nr#L20-L22</a></sub></sup>
+
+
+Returns true if this struct has a custom attribute with the given name.
+
+### module
+
+```rust title="module" showLineNumbers 
+comptime fn module(self) -> Module {}
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/meta/struct_def.nr#L38-L40" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/meta/struct_def.nr#L38-L40</a></sub></sup>
+
+
+Returns the module where the struct is defined.
+
+### name
+
+```rust title="name" showLineNumbers 
+comptime fn name(self) -> Quoted {}
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/meta/struct_def.nr#L43-L45" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/meta/struct_def.nr#L43-L45</a></sub></sup>
+
+
+Returns the name of this struct
+
+Note that the returned quoted value will be just the struct name, it will
+not be the full path to the struct, nor will it include any generics.
+
+### set_fields
+
+```rust title="set_fields" showLineNumbers 
+comptime fn set_fields(self, new_fields: [(Quoted, Type)]) {}
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/meta/struct_def.nr#L52-L54" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/meta/struct_def.nr#L52-L54</a></sub></sup>
+
+
+Sets the fields of this struct to the given fields list where each element
+is a pair of the field's name and the field's type. Expects each field name
+to be a single identifier. Note that this will override any previous fields
+on this struct. If those should be preserved, use `.fields()` to retrieve the
+current fields on the struct type and append the new fields from there.
+
+Example:
+
+```rust
+// Change this struct to:
+// struct Foo {
+//     a: u32,
+//     b: i8,
+// }
+#[mangle_fields]
+struct Foo { x: Field }
+
+comptime fn mangle_fields(s: StructDefinition) {
+    s.set_fields(&[
+        (quote { a }, quote { u32 }.as_type()),
+        (quote { b }, quote { i8 }.as_type()),
+    ]);
+}
+```
+
+## Trait Implementations
+
+```rust
+impl Eq for StructDefinition
+impl Hash for StructDefinition
+```
+
+Note that each struct is assigned a unique ID internally and this is what is used for
+equality and hashing. So even structs with identical generics and fields may not
+be equal in this sense if they were originally different items in the source program.
diff --git a/docs/versioned_docs/version-v0.35.0/noir/standard_library/meta/trait_constraint.md b/docs/versioned_docs/version-v0.35.0/noir/standard_library/meta/trait_constraint.md
new file mode 100644
index 00000000000..3106f732b5a
--- /dev/null
+++ b/docs/versioned_docs/version-v0.35.0/noir/standard_library/meta/trait_constraint.md
@@ -0,0 +1,17 @@
+---
+title: TraitConstraint
+---
+
+`std::meta::trait_constraint` contains methods on the built-in `TraitConstraint` type which represents
+a trait constraint that can be used to search for a trait implementation. This is similar
+syntactically to just the trait itself, but can also contain generic arguments. E.g. `Eq`, `Default`,
+`BuildHasher<Poseidon2Hasher>`.
+
+This type currently has no public methods but it can be used alongside `Type` in `implements` or `get_trait_impl`.
+
+## Trait Implementations
+
+```rust
+impl Eq for TraitConstraint
+impl Hash for TraitConstraint
+```
diff --git a/docs/versioned_docs/version-v0.35.0/noir/standard_library/meta/trait_def.md b/docs/versioned_docs/version-v0.35.0/noir/standard_library/meta/trait_def.md
new file mode 100644
index 00000000000..a1f363d46ff
--- /dev/null
+++ b/docs/versioned_docs/version-v0.35.0/noir/standard_library/meta/trait_def.md
@@ -0,0 +1,26 @@
+---
+title: TraitDefinition
+---
+
+`std::meta::trait_def` contains methods on the built-in `TraitDefinition` type. This type
+represents trait definitions such as `trait Foo { .. }` at the top-level of a program.
+
+## Methods
+
+### as_trait_constraint
+
+```rust title="as_trait_constraint" showLineNumbers 
+comptime fn as_trait_constraint(_self: Self) -> TraitConstraint {}
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/meta/trait_def.nr#L6-L8" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/meta/trait_def.nr#L6-L8</a></sub></sup>
+
+
+Converts this trait into a trait constraint. If there are any generics on this
+trait, they will be kept as-is without instantiating or replacing them.
+
+## Trait Implementations
+
+```rust
+impl Eq for TraitDefinition
+impl Hash for TraitDefinition
+```
diff --git a/docs/versioned_docs/version-v0.35.0/noir/standard_library/meta/trait_impl.md b/docs/versioned_docs/version-v0.35.0/noir/standard_library/meta/trait_impl.md
new file mode 100644
index 00000000000..66d31ed2560
--- /dev/null
+++ b/docs/versioned_docs/version-v0.35.0/noir/standard_library/meta/trait_impl.md
@@ -0,0 +1,60 @@
+---
+title: TraitImpl
+---
+
+`std::meta::trait_impl` contains methods on the built-in `TraitImpl` type which represents a trait
+implementation such as `impl Foo for Bar { ... }`.
+
+## Methods
+
+### trait_generic_args
+
+```rust title="trait_generic_args" showLineNumbers 
+comptime fn trait_generic_args(self) -> [Type] {}
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/meta/trait_impl.nr#L3-L5" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/meta/trait_impl.nr#L3-L5</a></sub></sup>
+
+
+Returns any generic arguments on the trait of this trait implementation, if any.
+
+```rs
+impl Foo<i32, Field> for Bar { ... }
+
+comptime {
+    let bar_type = quote { Bar }.as_type();
+    let foo = quote { Foo<i32, Field> }.as_trait_constraint();
+
+    let my_impl: TraitImpl = bar_type.get_trait_impl(foo).unwrap();
+
+    let generics = my_impl.trait_generic_args();
+    assert_eq(generics.len(), 2);
+
+    assert_eq(generics[0], quote { i32 }.as_type());
+    assert_eq(generics[1], quote { Field }.as_type());
+}
+```
+
+### methods
+
+```rust title="methods" showLineNumbers 
+comptime fn methods(self) -> [FunctionDefinition] {}
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/meta/trait_impl.nr#L8-L10" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/meta/trait_impl.nr#L8-L10</a></sub></sup>
+
+
+Returns each method in this trait impl.
+
+Example:
+
+```rs
+comptime {
+    let i32_type = quote { i32 }.as_type();
+    let eq = quote { Eq }.as_trait_constraint();
+
+    let impl_eq_for_i32: TraitImpl = i32_type.get_trait_impl(eq).unwrap();
+    let methods = impl_eq_for_i32.methods();
+
+    assert_eq(methods.len(), 1);
+    assert_eq(methods[0].name(), quote { eq });
+}
+```
diff --git a/docs/versioned_docs/version-v0.35.0/noir/standard_library/meta/typ.md b/docs/versioned_docs/version-v0.35.0/noir/standard_library/meta/typ.md
new file mode 100644
index 00000000000..6c9f4b8d087
--- /dev/null
+++ b/docs/versioned_docs/version-v0.35.0/noir/standard_library/meta/typ.md
@@ -0,0 +1,239 @@
+---
+title: Type
+---
+
+`std::meta::typ` contains methods on the built-in `Type` type used for representing
+a type in the source program.
+
+## Functions
+
+```rust title="fresh_type_variable" showLineNumbers 
+pub comptime fn fresh_type_variable() -> Type {}
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/meta/typ.nr#L5-L7" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/meta/typ.nr#L5-L7</a></sub></sup>
+
+
+Creates and returns an unbound type variable. This is a special kind of type internal
+to type checking which will type check with any other type. When it is type checked
+against another type it will also be set to that type. For example, if `a` is a type
+variable and we have the type equality `(a, i32) = (u8, i32)`, the compiler will set
+`a` equal to `u8`.
+
+Unbound type variables will often be rendered as `_` while printing them. Bound type
+variables will appear as the type they are bound to.
+
+This can be used in conjunction with functions which internally perform type checks
+such as `Type::implements` or `Type::get_trait_impl` to potentially grab some of the types used.
+
+Note that calling `Type::implements` or `Type::get_trait_impl` on a type variable will always
+fail.
+
+Example:
+
+```rust title="serialize-setup" showLineNumbers 
+trait Serialize<let N: u32> {}
+
+impl Serialize<1> for Field {}
+
+impl<T, let N: u32, let M: u32> Serialize<N * M> for [T; N]
+    where T: Serialize<M> {}
+
+impl<T, U, let N: u32, let M: u32> Serialize<N + M> for (T, U)
+    where T: Serialize<N>, U: Serialize<M> {}
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/test_programs/compile_success_empty/comptime_type/src/main.nr#L20-L30" target="_blank" rel="noopener noreferrer">Source code: test_programs/compile_success_empty/comptime_type/src/main.nr#L20-L30</a></sub></sup>
+
+```rust title="fresh-type-variable-example" showLineNumbers 
+let typevar1 = std::meta::typ::fresh_type_variable();
+        let constraint = quote { Serialize<$typevar1> }.as_trait_constraint();
+        let field_type = quote { Field }.as_type();
+
+        // Search for a trait impl (binding typevar1 to 1 when the impl is found):
+        assert(field_type.implements(constraint));
+
+        // typevar1 should be bound to the "1" generic now:
+        assert_eq(typevar1.as_constant().unwrap(), 1);
+
+        // If we want to do the same with a different type, we need to
+        // create a new type variable now that `typevar1` is bound
+        let typevar2 = std::meta::typ::fresh_type_variable();
+        let constraint = quote { Serialize<$typevar2> }.as_trait_constraint();
+        let array_type = quote { [(Field, Field); 5] }.as_type();
+        assert(array_type.implements(constraint));
+
+        // Now typevar2 should be bound to the serialized pair size 2 times the array length 5
+        assert_eq(typevar2.as_constant().unwrap(), 10);
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/test_programs/compile_success_empty/comptime_type/src/main.nr#L130-L150" target="_blank" rel="noopener noreferrer">Source code: test_programs/compile_success_empty/comptime_type/src/main.nr#L130-L150</a></sub></sup>
+
+
+## Methods
+
+### as_array
+
+```rust title="as_array" showLineNumbers 
+comptime fn as_array(self) -> Option<(Type, Type)> {}
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/meta/typ.nr#L11-L13" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/meta/typ.nr#L11-L13</a></sub></sup>
+
+
+If this type is an array, return a pair of (element type, size type).
+
+Example:
+
+```rust
+comptime {
+    let array_type = quote { [Field; 3] }.as_type();
+    let (field_type, three_type) = array_type.as_array().unwrap();
+
+    assert(field_type.is_field());
+    assert_eq(three_type.as_constant().unwrap(), 3);
+}
+```
+
+### as_constant
+
+```rust title="as_constant" showLineNumbers 
+comptime fn as_constant(self) -> Option<u32> {}
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/meta/typ.nr#L16-L18" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/meta/typ.nr#L16-L18</a></sub></sup>
+
+
+If this type is a constant integer (such as the `3` in the array type `[Field; 3]`),
+return the numeric constant.
+
+### as_integer
+
+```rust title="as_integer" showLineNumbers 
+comptime fn as_integer(self) -> Option<(bool, u8)> {}
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/meta/typ.nr#L21-L23" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/meta/typ.nr#L21-L23</a></sub></sup>
+
+
+If this is an integer type, return a boolean which is `true`
+if the type is signed, as well as the number of bits of this integer type.
+
+### as_slice
+
+```rust title="as_slice" showLineNumbers 
+comptime fn as_slice(self) -> Option<Type> {}
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/meta/typ.nr#L26-L28" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/meta/typ.nr#L26-L28</a></sub></sup>
+
+
+If this is a slice type, return the element type of the slice.
+
+### as_str
+
+```rust title="as_str" showLineNumbers 
+comptime fn as_str(self) -> Option<Type> {}
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/meta/typ.nr#L31-L33" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/meta/typ.nr#L31-L33</a></sub></sup>
+
+
+If this is a `str<N>` type, returns the length `N` as a type.
+
+### as_struct
+
+```rust title="as_struct" showLineNumbers 
+comptime fn as_struct(self) -> Option<(StructDefinition, [Type])> {}
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/meta/typ.nr#L36-L38" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/meta/typ.nr#L36-L38</a></sub></sup>
+
+
+If this is a struct type, returns the struct in addition to
+any generic arguments on this type.
+
+### as_tuple
+
+```rust title="as_tuple" showLineNumbers 
+comptime fn as_tuple(self) -> Option<[Type]> {}
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/meta/typ.nr#L41-L43" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/meta/typ.nr#L41-L43</a></sub></sup>
+
+
+If this is a tuple type, returns each element type of the tuple.
+
+### get_trait_impl
+
+```rust title="get_trait_impl" showLineNumbers 
+comptime fn get_trait_impl(self, constraint: TraitConstraint) -> Option<TraitImpl> {}
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/meta/typ.nr#L46-L48" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/meta/typ.nr#L46-L48</a></sub></sup>
+
+
+Retrieves the trait implementation that implements the given
+trait constraint for this type. If the trait constraint is not
+found, `None` is returned. Note that since the concrete trait implementation
+for a trait constraint specified from a `where` clause is unknown,
+this function will return `None` in these cases. If you only want to know
+whether a type implements a trait, use `implements` instead.
+
+Example:
+
+```rust
+comptime {
+    let field_type = quote { Field }.as_type();
+    let default = quote { Default }.as_trait_constraint();
+
+    let the_impl: TraitImpl = field_type.get_trait_impl(default).unwrap();
+    assert(the_impl.methods().len(), 1);
+}
+```
+
+### implements
+
+```rust title="implements" showLineNumbers 
+comptime fn implements(self, constraint: TraitConstraint) -> bool {}
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/meta/typ.nr#L51-L53" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/meta/typ.nr#L51-L53</a></sub></sup>
+
+
+`true` if this type implements the given trait. Note that unlike
+`get_trait_impl` this will also return true for any `where` constraints
+in scope.
+
+Example:
+
+```rust
+fn foo<T>() where T: Default {
+    comptime {
+        let field_type = quote { Field }.as_type();
+        let default = quote { Default }.as_trait_constraint();
+        assert(field_type.implements(default));
+
+        let t = quote { T }.as_type();
+        assert(t.implements(default));
+    }
+}
+```
+
+### is_bool
+
+```rust title="is_bool" showLineNumbers 
+comptime fn is_bool(self) -> bool {}
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/meta/typ.nr#L56-L58" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/meta/typ.nr#L56-L58</a></sub></sup>
+
+
+`true` if this type is `bool`.
+
+### is_field
+
+```rust title="is_field" showLineNumbers 
+comptime fn is_field(self) -> bool {}
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/meta/typ.nr#L61-L63" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/meta/typ.nr#L61-L63</a></sub></sup>
+
+
+`true` if this type is `Field`.
+
+## Trait Implementations
+
+```rust
+impl Eq for Type
+impl Hash for Type
+```
+Note that this is syntactic equality, this is not the same as whether two types will type check
+to be the same type. Unless type inference or generics are being used however, users should not
+typically have to worry about this distinction unless `std::meta::typ::fresh_type_variable` is used.
diff --git a/docs/versioned_docs/version-v0.35.0/noir/standard_library/meta/typed_expr.md b/docs/versioned_docs/version-v0.35.0/noir/standard_library/meta/typed_expr.md
new file mode 100644
index 00000000000..1ee71c8b064
--- /dev/null
+++ b/docs/versioned_docs/version-v0.35.0/noir/standard_library/meta/typed_expr.md
@@ -0,0 +1,27 @@
+---
+title: TypedExpr
+---
+
+`std::meta::typed_expr` contains methods on the built-in `TypedExpr` type for resolved and type-checked expressions.
+
+## Methods
+
+### get_type
+
+```rust title="as_function_definition" showLineNumbers 
+comptime fn as_function_definition(self) -> Option<FunctionDefinition> {}
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/meta/typed_expr.nr#L7-L9" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/meta/typed_expr.nr#L7-L9</a></sub></sup>
+
+
+If this expression refers to a function definitions, returns it. Otherwise returns `Option::none()`.
+
+### get_type
+
+```rust title="get_type" showLineNumbers 
+comptime fn get_type(self) -> Option<Type> {}
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/meta/typed_expr.nr#L13-L15" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/meta/typed_expr.nr#L13-L15</a></sub></sup>
+
+
+Returns the type of the expression, or `Option::none()` if there were errors when the expression was previously resolved.
\ No newline at end of file
diff --git a/docs/versioned_docs/version-v0.35.0/noir/standard_library/meta/unresolved_type.md b/docs/versioned_docs/version-v0.35.0/noir/standard_library/meta/unresolved_type.md
new file mode 100644
index 00000000000..d6f2b1494bb
--- /dev/null
+++ b/docs/versioned_docs/version-v0.35.0/noir/standard_library/meta/unresolved_type.md
@@ -0,0 +1,17 @@
+---
+title: UnresolvedType
+---
+
+`std::meta::unresolved_type` contains methods on the built-in `UnresolvedType` type for the syntax of types.
+
+## Methods
+
+### is_field
+
+```rust title="is_field" showLineNumbers 
+comptime fn is_field(self) -> bool {}
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/meta/unresolved_type.nr#L3-L5" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/meta/unresolved_type.nr#L3-L5</a></sub></sup>
+
+
+Returns true if this type refers to the Field type.
diff --git a/docs/versioned_docs/version-v0.35.0/noir/standard_library/options.md b/docs/versioned_docs/version-v0.35.0/noir/standard_library/options.md
new file mode 100644
index 00000000000..a1bd4e1de5f
--- /dev/null
+++ b/docs/versioned_docs/version-v0.35.0/noir/standard_library/options.md
@@ -0,0 +1,101 @@
+---
+title: Option<T> Type
+---
+
+The `Option<T>` type is a way to express that a value might be present (`Some(T))` or absent (`None`). It's a safer way to handle potential absence of values, compared to using nulls in many other languages.
+
+```rust
+struct Option<T> {
+    None,
+    Some(T),
+}
+```
+
+The `Option` type, already imported into your Noir program, can be used directly:
+
+```rust
+fn main() {
+    let none = Option::none();
+    let some = Option::some(3);
+}
+```
+
+See [this test](https://github.com/noir-lang/noir/blob/5cbfb9c4a06c8865c98ff2b594464b037d821a5c/crates/nargo_cli/tests/test_data/option/src/main.nr) for a more comprehensive set of examples of each of the methods described below.
+
+## Methods
+
+### none
+
+Constructs a none value.
+
+### some
+
+Constructs a some wrapper around a given value.
+
+### is_none
+
+Returns true if the Option is None.
+
+### is_some
+
+Returns true of the Option is Some.
+
+### unwrap
+
+Asserts `self.is_some()` and returns the wrapped value.
+
+### unwrap_unchecked
+
+Returns the inner value without asserting `self.is_some()`. This method can be useful within an if condition when we already know that `option.is_some()`. If the option is None, there is no guarantee what value will be returned, only that it will be of type T for an `Option<T>`.
+
+### unwrap_or
+
+Returns the wrapped value if `self.is_some()`. Otherwise, returns the given default value.
+
+### unwrap_or_else
+
+Returns the wrapped value if `self.is_some()`. Otherwise, calls the given function to return a default value.
+
+### expect
+
+Asserts `self.is_some()` with a provided custom message and returns the contained `Some` value. The custom message is expected to be a format string.
+
+### map
+
+If self is `Some(x)`, this returns `Some(f(x))`. Otherwise, this returns `None`.
+
+### map_or
+
+If self is `Some(x)`, this returns `f(x)`. Otherwise, this returns the given default value.
+
+### map_or_else
+
+If self is `Some(x)`, this returns `f(x)`. Otherwise, this returns `default()`.
+
+### and
+
+Returns None if self is None. Otherwise, this returns `other`.
+
+### and_then
+
+If self is None, this returns None. Otherwise, this calls the given function with the Some value contained within self, and returns the result of that call. In some languages this function is called `flat_map` or `bind`.
+
+### or
+
+If self is Some, return self. Otherwise, return `other`.
+
+### or_else
+
+If self is Some, return self. Otherwise, return `default()`.
+
+### xor
+
+If only one of the two Options is Some, return that option. Otherwise, if both options are Some or both are None, None is returned.
+
+### filter
+
+Returns `Some(x)` if self is `Some(x)` and `predicate(x)` is true. Otherwise, this returns `None`.
+
+### flatten
+
+Flattens an `Option<Option<T>>` into a `Option<T>`. This returns `None` if the outer Option is None. Otherwise, this returns the inner Option.
diff --git a/docs/versioned_docs/version-v0.34.0/noir/standard_library/recursion.md b/docs/versioned_docs/version-v0.35.0/noir/standard_library/recursion.mdx
similarity index 96%
rename from docs/versioned_docs/version-v0.34.0/noir/standard_library/recursion.md
rename to docs/versioned_docs/version-v0.35.0/noir/standard_library/recursion.mdx
index 7f4dcebf084..60414a2fa51 100644
--- a/docs/versioned_docs/version-v0.34.0/noir/standard_library/recursion.md
+++ b/docs/versioned_docs/version-v0.35.0/noir/standard_library/recursion.mdx
@@ -4,7 +4,7 @@ description: Learn about how to write recursive proofs in Noir.
 keywords: [recursion, recursive proofs, verification_key, verify_proof]
 ---
 
-import BlackBoxInfo from '@site/src/components/Notes/_blackbox.mdx';
+import BlackBoxInfo from '@site/src/components/Notes/_blackbox';
 
 Noir supports recursively verifying proofs, meaning you verify the proof of a Noir program in another Noir program. This enables creating proofs of arbitrary size by doing step-wise verification of smaller components of a large proof.
 
@@ -35,7 +35,7 @@ By incorporating this attribute directly in the circuit's definition, tooling li
 pub fn verify_proof(verification_key: [Field], proof: [Field], public_inputs: [Field], key_hash: Field) {}
 ```
 
-<BlackBoxInfo />
+<BlackBoxInfo to="black_box_fns"/>
 
 ## Example usage
 
diff --git a/docs/versioned_docs/version-v0.35.0/noir/standard_library/traits.md b/docs/versioned_docs/version-v0.35.0/noir/standard_library/traits.md
new file mode 100644
index 00000000000..74ed6276234
--- /dev/null
+++ b/docs/versioned_docs/version-v0.35.0/noir/standard_library/traits.md
@@ -0,0 +1,625 @@
+---
+title: Traits
+description: Noir's stdlib provides a few commonly used traits.
+keywords: [traits, trait, interface, protocol, default, add, eq]
+---
+
+## `std::default`
+
+### `std::default::Default`
+
+```rust title="default-trait" showLineNumbers 
+pub trait Default {
+    fn default() -> Self;
+}
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/default.nr#L4-L8" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/default.nr#L4-L8</a></sub></sup>
+
+
+Constructs a default value of a type.
+
+Implementations:
+```rust
+impl Default for Field { .. }
+
+impl Default for i8 { .. }
+impl Default for i16 { .. }
+impl Default for i32 { .. }
+impl Default for i64 { .. }
+
+impl Default for u8 { .. }
+impl Default for u16 { .. }
+impl Default for u32 { .. }
+impl Default for u64 { .. }
+
+impl Default for () { .. }
+impl Default for bool { .. }
+
+impl<T, N> Default for [T; N]
+    where T: Default { .. }
+
+impl<T> Default for [T] { .. }
+
+impl<A, B> Default for (A, B)
+    where A: Default, B: Default { .. }
+
+impl<A, B, C> Default for (A, B, C)
+    where A: Default, B: Default, C: Default { .. }
+
+impl<A, B, C, D> Default for (A, B, C, D)
+    where A: Default, B: Default, C: Default, D: Default { .. }
+
+impl<A, B, C, D, E> Default for (A, B, C, D, E)
+    where A: Default, B: Default, C: Default, D: Default, E: Default { .. }
+```
+
+For primitive integer types, the return value of `default` is `0`. Container
+types such as arrays are filled with default values of their element type,
+except slices whose length is unknown and thus defaulted to zero.
+
+---
+
+## `std::convert`
+
+### `std::convert::From`
+
+```rust title="from-trait" showLineNumbers 
+pub trait From<T> {
+    fn from(input: T) -> Self;
+}
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/convert.nr#L1-L5" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/convert.nr#L1-L5</a></sub></sup>
+
+
+The `From` trait defines how to convert from a given type `T` to the type on which the trait is implemented.
+
+The Noir standard library provides a number of implementations of `From` between primitive types.
+```rust title="from-impls" showLineNumbers 
+// Unsigned integers
+
+impl From<u8> for u32 {
+    fn from(value: u8) -> u32 {
+        value as u32
+    }
+}
+
+impl From<u8> for u64 {
+    fn from(value: u8) -> u64 {
+        value as u64
+    }
+}
+impl From<u32> for u64 {
+    fn from(value: u32) -> u64 {
+        value as u64
+    }
+}
+
+impl From<u8> for Field {
+    fn from(value: u8) -> Field {
+        value as Field
+    }
+}
+impl From<u32> for Field {
+    fn from(value: u32) -> Field {
+        value as Field
+    }
+}
+impl From<u64> for Field {
+    fn from(value: u64) -> Field {
+        value as Field
+    }
+}
+
+// Signed integers
+
+impl From<i8> for i32 {
+    fn from(value: i8) -> i32 {
+        value as i32
+    }
+}
+
+impl From<i8> for i64 {
+    fn from(value: i8) -> i64 {
+        value as i64
+    }
+}
+impl From<i32> for i64 {
+    fn from(value: i32) -> i64 {
+        value as i64
+    }
+}
+
+// Booleans
+impl From<bool> for u8 {
+    fn from(value: bool) -> u8 {
+        value as u8
+    }
+}
+impl From<bool> for u32 {
+    fn from(value: bool) -> u32 {
+        value as u32
+    }
+}
+impl From<bool> for u64 {
+    fn from(value: bool) -> u64 {
+        value as u64
+    }
+}
+impl From<bool> for i8 {
+    fn from(value: bool) -> i8 {
+        value as i8
+    }
+}
+impl From<bool> for i32 {
+    fn from(value: bool) -> i32 {
+        value as i32
+    }
+}
+impl From<bool> for i64 {
+    fn from(value: bool) -> i64 {
+        value as i64
+    }
+}
+impl From<bool> for Field {
+    fn from(value: bool) -> Field {
+        value as Field
+    }
+}
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/convert.nr#L25-L116" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/convert.nr#L25-L116</a></sub></sup>
+
+
+#### When to implement `From`
+
+As a general rule of thumb, `From` may be implemented in the [situations where it would be suitable in Rust](https://doc.rust-lang.org/std/convert/trait.From.html#when-to-implement-from):
+
+- The conversion is *infallible*: Noir does not provide an equivalent to Rust's `TryFrom`, if the conversion can fail then provide a named method instead.
+- The conversion is *lossless*: semantically, it should not lose or discard information. For example, `u32: From<u16>` can losslessly convert any `u16` into a valid `u32` such that the original `u16` can be recovered. On the other hand, `u16: From<u32>` should not be implemented as `2**16` is a `u32` which cannot be losslessly converted into a `u16`.
+- The conversion is *value-preserving*: the conceptual kind and meaning of the resulting value is the same, even though the Noir type and technical representation might be different. While it's possible to infallibly and losslessly convert a `u8` into a `str<2>` hex representation, `4u8` and `"04"` are too different for `str<2>: From<u8>` to be implemented.
+- The conversion is *obvious*: it's the only reasonable conversion between the two types. If there's ambiguity on how to convert between them such that the same input could potentially map to two different values then a named method should be used. For instance rather than implementing `U128: From<[u8; 16]>`, the methods `U128::from_le_bytes` and `U128::from_be_bytes` are used as otherwise the endianness of the array would be ambiguous, resulting in two potential values of `U128` from the same byte array.
+
+One additional recommendation specific to Noir is:
+- The conversion is *efficient*: it's relatively cheap to convert between the two types. Due to being a ZK DSL, it's more important to avoid unnecessary computation compared to Rust. If the implementation of `From` would encourage users to perform unnecessary conversion, resulting in additional proving time, then it may be preferable to expose functionality such that this conversion may be avoided.
+
+### `std::convert::Into`
+
+The `Into` trait is defined as the reciprocal of `From`. It should be easy to convince yourself that if we can convert to type `A` from type `B`, then it's possible to convert type `B` into type `A`.
+
+For this reason, implementing `From` on a type will automatically generate a matching `Into` implementation. One should always prefer implementing `From` over `Into` as implementing `Into` will not generate a matching `From` implementation.
+
+```rust title="into-trait" showLineNumbers 
+pub trait Into<T> {
+    fn into(self) -> T;
+}
+
+impl<T, U> Into<T> for U where T: From<U> {
+    fn into(self) -> T {
+        T::from(self)
+    }
+}
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/convert.nr#L13-L23" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/convert.nr#L13-L23</a></sub></sup>
+
+
+`Into` is most useful when passing function arguments where the types don't quite match up with what the function expects. In this case, the compiler has enough type information to perform the necessary conversion by just appending `.into()` onto the arguments in question.
+
+---
+
+## `std::cmp`
+
+### `std::cmp::Eq`
+
+```rust title="eq-trait" showLineNumbers 
+pub trait Eq {
+    fn eq(self, other: Self) -> bool;
+}
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/cmp.nr#L4-L8" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/cmp.nr#L4-L8</a></sub></sup>
+
+
+Returns `true` if `self` is equal to `other`. Implementing this trait on a type
+allows the type to be used with `==` and `!=`.
+
+Implementations:
+```rust
+impl Eq for Field { .. }
+
+impl Eq for i8 { .. }
+impl Eq for i16 { .. }
+impl Eq for i32 { .. }
+impl Eq for i64 { .. }
+
+impl Eq for u8 { .. }
+impl Eq for u16 { .. }
+impl Eq for u32 { .. }
+impl Eq for u64 { .. }
+
+impl Eq for () { .. }
+impl Eq for bool { .. }
+
+impl<T, N> Eq for [T; N]
+    where T: Eq { .. }
+
+impl<T> Eq for [T]
+    where T: Eq { .. }
+
+impl<A, B> Eq for (A, B)
+    where A: Eq, B: Eq { .. }
+
+impl<A, B, C> Eq for (A, B, C)
+    where A: Eq, B: Eq, C: Eq { .. }
+
+impl<A, B, C, D> Eq for (A, B, C, D)
+    where A: Eq, B: Eq, C: Eq, D: Eq { .. }
+
+impl<A, B, C, D, E> Eq for (A, B, C, D, E)
+    where A: Eq, B: Eq, C: Eq, D: Eq, E: Eq { .. }
+```
+
+### `std::cmp::Ord`
+
+```rust title="ord-trait" showLineNumbers 
+pub trait Ord {
+    fn cmp(self, other: Self) -> Ordering;
+}
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/cmp.nr#L175-L179" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/cmp.nr#L175-L179</a></sub></sup>
+
+
+`a.cmp(b)` compares two values returning `Ordering::less()` if `a < b`,
+`Ordering::equal()` if `a == b`, or `Ordering::greater()` if `a > b`.
+Implementing this trait on a type allows `<`, `<=`, `>`, and `>=` to be
+used on values of the type.
+
+`std::cmp` also provides `max` and `min` functions for any type which implements the `Ord` trait.
+
+Implementations:
+
+```rust
+impl Ord for u8 { .. }
+impl Ord for u16 { .. }
+impl Ord for u32 { .. }
+impl Ord for u64 { .. }
+
+impl Ord for i8 { .. }
+impl Ord for i16 { .. }
+impl Ord for i32 { .. }
+
+impl Ord for i64 { .. }
+
+impl Ord for () { .. }
+impl Ord for bool { .. }
+
+impl<T, N> Ord for [T; N]
+    where T: Ord { .. }
+
+impl<T> Ord for [T]
+    where T: Ord { .. }
+
+impl<A, B> Ord for (A, B)
+    where A: Ord, B: Ord { .. }
+
+impl<A, B, C> Ord for (A, B, C)
+    where A: Ord, B: Ord, C: Ord { .. }
+
+impl<A, B, C, D> Ord for (A, B, C, D)
+    where A: Ord, B: Ord, C: Ord, D: Ord { .. }
+
+impl<A, B, C, D, E> Ord for (A, B, C, D, E)
+    where A: Ord, B: Ord, C: Ord, D: Ord, E: Ord { .. }
+```
+
+---
+
+## `std::ops`
+
+### `std::ops::Add`, `std::ops::Sub`, `std::ops::Mul`, and `std::ops::Div`
+
+These traits abstract over addition, subtraction, multiplication, and division respectively.
+Implementing these traits for a given type will also allow that type to be used with the corresponding operator
+for that trait (`+` for Add, etc) in addition to the normal method names.
+
+```rust title="add-trait" showLineNumbers 
+pub trait Add {
+    fn add(self, other: Self) -> Self;
+}
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/ops/arith.nr#L1-L5" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/ops/arith.nr#L1-L5</a></sub></sup>
+
+```rust title="sub-trait" showLineNumbers 
+pub trait Sub {
+    fn sub(self, other: Self) -> Self;
+}
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/ops/arith.nr#L60-L64" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/ops/arith.nr#L60-L64</a></sub></sup>
+
+```rust title="mul-trait" showLineNumbers 
+pub trait Mul {
+    fn mul(self, other: Self) -> Self;
+}
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/ops/arith.nr#L119-L123" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/ops/arith.nr#L119-L123</a></sub></sup>
+
+```rust title="div-trait" showLineNumbers 
+pub trait Div {
+    fn div(self, other: Self) -> Self;
+}
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/ops/arith.nr#L178-L182" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/ops/arith.nr#L178-L182</a></sub></sup>
+
+
+The implementations block below is given for the `Add` trait, but the same types that implement
+`Add` also implement `Sub`, `Mul`, and `Div`.
+
+Implementations:
+```rust
+impl Add for Field { .. }
+
+impl Add for i8 { .. }
+impl Add for i16 { .. }
+impl Add for i32 { .. }
+impl Add for i64 { .. }
+
+impl Add for u8 { .. }
+impl Add for u16 { .. }
+impl Add for u32 { .. }
+impl Add for u64 { .. }
+```
+
+### `std::ops::Rem`
+
+```rust title="rem-trait" showLineNumbers 
+pub trait Rem {
+    fn rem(self, other: Self) -> Self;
+}
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/ops/arith.nr#L237-L241" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/ops/arith.nr#L237-L241</a></sub></sup>
+
+
+`Rem::rem(a, b)` is the remainder function returning the result of what is
+left after dividing `a` and `b`. Implementing `Rem` allows the `%` operator
+to be used with the implementation type.
+
+Unlike other numeric traits, `Rem` is not implemented for `Field`.
+
+Implementations:
+```rust
+impl Rem for u8 { fn rem(self, other: u8) -> u8 { self % other } }
+impl Rem for u16 { fn rem(self, other: u16) -> u16 { self % other } }
+impl Rem for u32 { fn rem(self, other: u32) -> u32 { self % other } }
+impl Rem for u64 { fn rem(self, other: u64) -> u64 { self % other } }
+
+impl Rem for i8 { fn rem(self, other: i8) -> i8 { self % other } }
+impl Rem for i16 { fn rem(self, other: i16) -> i16 { self % other } }
+impl Rem for i32 { fn rem(self, other: i32) -> i32 { self % other } }
+impl Rem for i64 { fn rem(self, other: i64) -> i64 { self % other } }
+```
+
+### `std::ops::Neg`
+
+```rust title="neg-trait" showLineNumbers 
+pub trait Neg {
+    fn neg(self) -> Self;
+}
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/ops/arith.nr#L290-L294" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/ops/arith.nr#L290-L294</a></sub></sup>
+
+
+`Neg::neg` is equivalent to the unary negation operator `-`.
+
+Implementations:
+```rust title="neg-trait-impls" showLineNumbers 
+impl Neg for Field {
+    fn neg(self) -> Field {
+        -self
+    }
+}
+
+impl Neg for i8 {
+    fn neg(self) -> i8 {
+        -self
+    }
+}
+impl Neg for i16 {
+    fn neg(self) -> i16 {
+        -self
+    }
+}
+impl Neg for i32 {
+    fn neg(self) -> i32 {
+        -self
+    }
+}
+impl Neg for i64 {
+    fn neg(self) -> i64 {
+        -self
+    }
+}
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/ops/arith.nr#L296-L323" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/ops/arith.nr#L296-L323</a></sub></sup>
+
+
+### `std::ops::Not`
+
+```rust title="not-trait" showLineNumbers 
+pub trait Not {
+    fn not(self: Self) -> Self;
+}
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/ops/bit.nr#L1-L5" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/ops/bit.nr#L1-L5</a></sub></sup>
+
+
+`Not::not` is equivalent to the unary bitwise NOT operator `!`.
+
+Implementations:
+```rust title="not-trait-impls" showLineNumbers 
+impl Not for bool {
+    fn not(self) -> bool {
+        !self
+    }
+}
+
+impl Not for u64 {
+    fn not(self) -> u64 {
+        !self
+    }
+}
+impl Not for u32 {
+    fn not(self) -> u32 {
+        !self
+    }
+}
+impl Not for u16 {
+    fn not(self) -> u16 {
+        !self
+    }
+}
+impl Not for u8 {
+    fn not(self) -> u8 {
+        !self
+    }
+}
+impl Not for u1 {
+    fn not(self) -> u1 {
+        !self
+    }
+}
+
+impl Not for i8 {
+    fn not(self) -> i8 {
+        !self
+    }
+}
+impl Not for i16 {
+    fn not(self) -> i16 {
+        !self
+    }
+}
+impl Not for i32 {
+    fn not(self) -> i32 {
+        !self
+    }
+}
+impl Not for i64 {
+    fn not(self) -> i64 {
+        !self
+    }
+}
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/ops/bit.nr#L7-L60" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/ops/bit.nr#L7-L60</a></sub></sup>
+
+
+### `std::ops::{ BitOr, BitAnd, BitXor }`
+
+```rust title="bitor-trait" showLineNumbers 
+pub trait BitOr {
+    fn bitor(self, other: Self) -> Self;
+}
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/ops/bit.nr#L62-L66" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/ops/bit.nr#L62-L66</a></sub></sup>
+
+```rust title="bitand-trait" showLineNumbers 
+pub trait BitAnd {
+    fn bitand(self, other: Self) -> Self;
+}
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/ops/bit.nr#L121-L125" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/ops/bit.nr#L121-L125</a></sub></sup>
+
+```rust title="bitxor-trait" showLineNumbers 
+pub trait BitXor {
+    fn bitxor(self, other: Self) -> Self;
+}
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/ops/bit.nr#L180-L184" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/ops/bit.nr#L180-L184</a></sub></sup>
+
+
+Traits for the bitwise operations `|`, `&`, and `^`.
+
+Implementing `BitOr`, `BitAnd` or `BitXor` for a type allows the `|`, `&`, or `^` operator respectively
+to be used with the type.
+
+The implementations block below is given for the `BitOr` trait, but the same types that implement
+`BitOr` also implement `BitAnd` and `BitXor`.
+
+Implementations:
+```rust
+impl BitOr for bool { fn bitor(self, other: bool) -> bool { self | other } }
+
+impl BitOr for u8 { fn bitor(self, other: u8) -> u8 { self | other } }
+impl BitOr for u16 { fn bitor(self, other: u16) -> u16 { self | other } }
+impl BitOr for u32 { fn bitor(self, other: u32) -> u32 { self | other } }
+impl BitOr for u64 { fn bitor(self, other: u64) -> u64 { self | other } }
+
+impl BitOr for i8 { fn bitor(self, other: i8) -> i8 { self | other } }
+impl BitOr for i16 { fn bitor(self, other: i16) -> i16 { self | other } }
+impl BitOr for i32 { fn bitor(self, other: i32) -> i32 { self | other } }
+impl BitOr for i64 { fn bitor(self, other: i64) -> i64 { self | other } }
+```
+
+### `std::ops::{ Shl, Shr }`
+
+```rust title="shl-trait" showLineNumbers 
+pub trait Shl {
+    fn shl(self, other: u8) -> Self;
+}
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/ops/bit.nr#L239-L243" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/ops/bit.nr#L239-L243</a></sub></sup>
+
+```rust title="shr-trait" showLineNumbers 
+pub trait Shr {
+    fn shr(self, other: u8) -> Self;
+}
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/ops/bit.nr#L292-L296" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/ops/bit.nr#L292-L296</a></sub></sup>
+
+
+Traits for a bit shift left and bit shift right.
+
+Implementing `Shl` for a type allows the left shift operator (`<<`) to be used with the implementation type.
+Similarly, implementing `Shr` allows the right shift operator (`>>`) to be used with the type.
+
+Note that bit shifting is not currently implemented for signed types.
+
+The implementations block below is given for the `Shl` trait, but the same types that implement
+`Shl` also implement `Shr`.
+
+Implementations:
+```rust
+impl Shl for u8 { fn shl(self, other: u8) -> u8 { self << other } }
+impl Shl for u16 { fn shl(self, other: u16) -> u16 { self << other } }
+impl Shl for u32 { fn shl(self, other: u32) -> u32 { self << other } }
+impl Shl for u64 { fn shl(self, other: u64) -> u64 { self << other } }
+```
+
+---
+
+## `std::append`
+
+### `std::append::Append`
+
+`Append` can abstract over types that can be appended to - usually container types:
+
+```rust title="append-trait" showLineNumbers 
+pub trait Append {
+    fn empty() -> Self;
+    fn append(self, other: Self) -> Self;
+}
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/append.nr#L9-L14" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/append.nr#L9-L14</a></sub></sup>
+
+
+`Append` requires two methods:
+
+- `empty`: Constructs an empty value of `Self`.
+- `append`: Append two values together, returning the result.
+
+Additionally, it is expected that for any implementation:
+
+- `T::empty().append(x) == x`
+- `x.append(T::empty()) == x`
+
+Implementations:
+```rust
+impl<T> Append for [T]
+impl Append for Quoted
+```
diff --git a/docs/docs/noir/standard_library/zeroed.md b/docs/versioned_docs/version-v0.35.0/noir/standard_library/zeroed.md
similarity index 100%
rename from docs/docs/noir/standard_library/zeroed.md
rename to docs/versioned_docs/version-v0.35.0/noir/standard_library/zeroed.md
diff --git a/docs/versioned_docs/version-v0.35.0/reference/NoirJS/backend_barretenberg/.nojekyll b/docs/versioned_docs/version-v0.35.0/reference/NoirJS/backend_barretenberg/.nojekyll
new file mode 100644
index 00000000000..e2ac6616add
--- /dev/null
+++ b/docs/versioned_docs/version-v0.35.0/reference/NoirJS/backend_barretenberg/.nojekyll
@@ -0,0 +1 @@
+TypeDoc added this file to prevent GitHub Pages from using Jekyll. You can turn off this behavior by setting the `githubPages` option to false.
\ No newline at end of file
diff --git a/docs/versioned_docs/version-v0.35.0/reference/NoirJS/backend_barretenberg/classes/BarretenbergBackend.md b/docs/versioned_docs/version-v0.35.0/reference/NoirJS/backend_barretenberg/classes/BarretenbergBackend.md
new file mode 100644
index 00000000000..252d72a0b71
--- /dev/null
+++ b/docs/versioned_docs/version-v0.35.0/reference/NoirJS/backend_barretenberg/classes/BarretenbergBackend.md
@@ -0,0 +1,138 @@
+# BarretenbergBackend
+
+## Implements
+
+- [`Backend`](../index.md#backend)
+- [`Backend`](../index.md#backend)
+
+## Constructors
+
+### new BarretenbergBackend(acirCircuit, options)
+
+```ts
+new BarretenbergBackend(acirCircuit, options): BarretenbergBackend
+```
+
+#### Parameters
+
+| Parameter | Type |
+| :------ | :------ |
+| `acirCircuit` | `CompiledCircuit` |
+| `options` | [`BackendOptions`](../type-aliases/BackendOptions.md) |
+
+#### Returns
+
+[`BarretenbergBackend`](BarretenbergBackend.md)
+
+## Properties
+
+| Property | Type | Description |
+| :------ | :------ | :------ |
+| `backend` | `UltraPlonkBackend` | - |
+
+## Methods
+
+### destroy()
+
+```ts
+destroy(): Promise<void>
+```
+
+#### Returns
+
+`Promise`\<`void`\>
+
+***
+
+### generateProof()
+
+```ts
+generateProof(compressedWitness): Promise<ProofData>
+```
+
+#### Parameters
+
+| Parameter | Type |
+| :------ | :------ |
+| `compressedWitness` | `Uint8Array` |
+
+#### Returns
+
+`Promise`\<`ProofData`\>
+
+#### Description
+
+Generates a proof
+
+***
+
+### generateRecursiveProofArtifacts()
+
+```ts
+generateRecursiveProofArtifacts(proofData, numOfPublicInputs): Promise<object>
+```
+
+Generates artifacts that will be passed to a circuit that will verify this proof.
+
+Instead of passing the proof and verification key as a byte array, we pass them
+as fields which makes it cheaper to verify in a circuit.
+
+The proof that is passed here will have been created using a circuit
+that has the #[recursive] attribute on its `main` method.
+
+The number of public inputs denotes how many public inputs are in the inner proof.
+
+#### Parameters
+
+| Parameter | Type | Default value |
+| :------ | :------ | :------ |
+| `proofData` | `ProofData` | `undefined` |
+| `numOfPublicInputs` | `number` | `0` |
+
+#### Returns
+
+`Promise`\<`object`\>
+
+#### Example
+
+```typescript
+const artifacts = await backend.generateRecursiveProofArtifacts(proof, numOfPublicInputs);
+```
+
+***
+
+### getVerificationKey()
+
+```ts
+getVerificationKey(): Promise<Uint8Array>
+```
+
+#### Returns
+
+`Promise`\<`Uint8Array`\>
+
+***
+
+### verifyProof()
+
+```ts
+verifyProof(proofData): Promise<boolean>
+```
+
+#### Parameters
+
+| Parameter | Type |
+| :------ | :------ |
+| `proofData` | `ProofData` |
+
+#### Returns
+
+`Promise`\<`boolean`\>
+
+#### Description
+
+Verifies a proof
+
+***
+
+Generated using [typedoc-plugin-markdown](https://www.npmjs.com/package/typedoc-plugin-markdown) and [TypeDoc](https://typedoc.org/)
diff --git a/docs/versioned_docs/version-v0.35.0/reference/NoirJS/backend_barretenberg/classes/BarretenbergVerifier.md b/docs/versioned_docs/version-v0.35.0/reference/NoirJS/backend_barretenberg/classes/BarretenbergVerifier.md
new file mode 100644
index 00000000000..500276ea748
--- /dev/null
+++ b/docs/versioned_docs/version-v0.35.0/reference/NoirJS/backend_barretenberg/classes/BarretenbergVerifier.md
@@ -0,0 +1,58 @@
+# BarretenbergVerifier
+
+## Constructors
+
+### new BarretenbergVerifier(options)
+
+```ts
+new BarretenbergVerifier(options): BarretenbergVerifier
+```
+
+#### Parameters
+
+| Parameter | Type |
+| :------ | :------ |
+| `options` | [`BackendOptions`](../type-aliases/BackendOptions.md) |
+
+#### Returns
+
+[`BarretenbergVerifier`](BarretenbergVerifier.md)
+
+## Methods
+
+### destroy()
+
+```ts
+destroy(): Promise<void>
+```
+
+#### Returns
+
+`Promise`\<`void`\>
+
+***
+
+### verifyProof()
+
+```ts
+verifyProof(proofData, verificationKey): Promise<boolean>
+```
+
+#### Parameters
+
+| Parameter | Type |
+| :------ | :------ |
+| `proofData` | `ProofData` |
+| `verificationKey` | `Uint8Array` |
+
+#### Returns
+
+`Promise`\<`boolean`\>
+
+#### Description
+
+Verifies a proof
+
+***
+
+Generated using [typedoc-plugin-markdown](https://www.npmjs.com/package/typedoc-plugin-markdown) and [TypeDoc](https://typedoc.org/)
diff --git a/docs/versioned_docs/version-v0.35.0/reference/NoirJS/backend_barretenberg/classes/UltraHonkBackend.md b/docs/versioned_docs/version-v0.35.0/reference/NoirJS/backend_barretenberg/classes/UltraHonkBackend.md
new file mode 100644
index 00000000000..204aaa18db6
--- /dev/null
+++ b/docs/versioned_docs/version-v0.35.0/reference/NoirJS/backend_barretenberg/classes/UltraHonkBackend.md
@@ -0,0 +1,114 @@
+# UltraHonkBackend
+
+## Implements
+
+- [`Backend`](../index.md#backend)
+- [`Backend`](../index.md#backend)
+
+## Constructors
+
+### new UltraHonkBackend(acirCircuit, options)
+
+```ts
+new UltraHonkBackend(acirCircuit, options): UltraHonkBackend
+```
+
+#### Parameters
+
+| Parameter | Type |
+| :------ | :------ |
+| `acirCircuit` | `CompiledCircuit` |
+| `options` | [`BackendOptions`](../type-aliases/BackendOptions.md) |
+
+#### Returns
+
+[`UltraHonkBackend`](UltraHonkBackend.md)
+
+## Properties
+
+| Property | Type | Description |
+| :------ | :------ | :------ |
+| `backend` | `UltraHonkBackend` | - |
+
+## Methods
+
+### destroy()
+
+```ts
+destroy(): Promise<void>
+```
+
+#### Returns
+
+`Promise`\<`void`\>
+
+***
+
+### generateProof()
+
+```ts
+generateProof(compressedWitness): Promise<ProofData>
+```
+
+#### Parameters
+
+| Parameter | Type |
+| :------ | :------ |
+| `compressedWitness` | `Uint8Array` |
+
+#### Returns
+
+`Promise`\<`ProofData`\>
+
+***
+
+### generateRecursiveProofArtifacts()
+
+```ts
+generateRecursiveProofArtifacts(proofData, numOfPublicInputs): Promise<object>
+```
+
+#### Parameters
+
+| Parameter | Type |
+| :------ | :------ |
+| `proofData` | `ProofData` |
+| `numOfPublicInputs` | `number` |
+
+#### Returns
+
+`Promise`\<`object`\>
+
+***
+
+### getVerificationKey()
+
+```ts
+getVerificationKey(): Promise<Uint8Array>
+```
+
+#### Returns
+
+`Promise`\<`Uint8Array`\>
+
+***
+
+### verifyProof()
+
+```ts
+verifyProof(proofData): Promise<boolean>
+```
+
+#### Parameters
+
+| Parameter | Type |
+| :------ | :------ |
+| `proofData` | `ProofData` |
+
+#### Returns
+
+`Promise`\<`boolean`\>
+
+***
+
+Generated using [typedoc-plugin-markdown](https://www.npmjs.com/package/typedoc-plugin-markdown) and [TypeDoc](https://typedoc.org/)
diff --git a/docs/versioned_docs/version-v0.35.0/reference/NoirJS/backend_barretenberg/classes/UltraHonkVerifier.md b/docs/versioned_docs/version-v0.35.0/reference/NoirJS/backend_barretenberg/classes/UltraHonkVerifier.md
new file mode 100644
index 00000000000..aee9460153f
--- /dev/null
+++ b/docs/versioned_docs/version-v0.35.0/reference/NoirJS/backend_barretenberg/classes/UltraHonkVerifier.md
@@ -0,0 +1,58 @@
+# UltraHonkVerifier
+
+## Constructors
+
+### new UltraHonkVerifier(options)
+
+```ts
+new UltraHonkVerifier(options): UltraHonkVerifier
+```
+
+#### Parameters
+
+| Parameter | Type |
+| :------ | :------ |
+| `options` | [`BackendOptions`](../type-aliases/BackendOptions.md) |
+
+#### Returns
+
+[`UltraHonkVerifier`](UltraHonkVerifier.md)
+
+## Methods
+
+### destroy()
+
+```ts
+destroy(): Promise<void>
+```
+
+#### Returns
+
+`Promise`\<`void`\>
+
+***
+
+### verifyProof()
+
+```ts
+verifyProof(proofData, verificationKey): Promise<boolean>
+```
+
+#### Parameters
+
+| Parameter | Type |
+| :------ | :------ |
+| `proofData` | `ProofData` |
+| `verificationKey` | `Uint8Array` |
+
+#### Returns
+
+`Promise`\<`boolean`\>
+
+#### Description
+
+Verifies a proof
+
+***
+
+Generated using [typedoc-plugin-markdown](https://www.npmjs.com/package/typedoc-plugin-markdown) and [TypeDoc](https://typedoc.org/)
diff --git a/docs/versioned_docs/version-v0.35.0/reference/NoirJS/backend_barretenberg/index.md b/docs/versioned_docs/version-v0.35.0/reference/NoirJS/backend_barretenberg/index.md
new file mode 100644
index 00000000000..4699e16dee6
--- /dev/null
+++ b/docs/versioned_docs/version-v0.35.0/reference/NoirJS/backend_barretenberg/index.md
@@ -0,0 +1,42 @@
+# backend_barretenberg
+
+## Exports
+
+### Classes
+
+| Class | Description |
+| :------ | :------ |
+| [BarretenbergBackend](classes/BarretenbergBackend.md) | - |
+| [BarretenbergVerifier](classes/BarretenbergVerifier.md) | - |
+| [UltraHonkBackend](classes/UltraHonkBackend.md) | - |
+| [UltraHonkVerifier](classes/UltraHonkVerifier.md) | - |
+
+### Type Aliases
+
+| Type alias | Description |
+| :------ | :------ |
+| [BackendOptions](type-aliases/BackendOptions.md) | - |
+
+## References
+
+### CompiledCircuit
+
+Renames and re-exports [Backend](index.md#backend)
+
+***
+
+### ProofData
+
+Renames and re-exports [Backend](index.md#backend)
+
+## Variables
+
+### Backend
+
+```ts
+Backend: any;
+```
+
+***
+
+Generated using [typedoc-plugin-markdown](https://www.npmjs.com/package/typedoc-plugin-markdown) and [TypeDoc](https://typedoc.org/)
diff --git a/docs/versioned_docs/version-v0.35.0/reference/NoirJS/backend_barretenberg/type-aliases/BackendOptions.md b/docs/versioned_docs/version-v0.35.0/reference/NoirJS/backend_barretenberg/type-aliases/BackendOptions.md
new file mode 100644
index 00000000000..99ade2ce6f7
--- /dev/null
+++ b/docs/versioned_docs/version-v0.35.0/reference/NoirJS/backend_barretenberg/type-aliases/BackendOptions.md
@@ -0,0 +1,18 @@
+# BackendOptions
+
+```ts
+type BackendOptions: object;
+```
+
+## Type declaration
+
+| Member | Type | Description |
+| :------ | :------ | :------ |
+| `memory` | `object` | - |
+| `memory.initial` | `number` | - |
+| `memory.maximum` | `number` | - |
+| `threads` | `number` | - |
+
+***
+
+Generated using [typedoc-plugin-markdown](https://www.npmjs.com/package/typedoc-plugin-markdown) and [TypeDoc](https://typedoc.org/)
diff --git a/docs/versioned_docs/version-v0.35.0/reference/NoirJS/backend_barretenberg/typedoc-sidebar.cjs b/docs/versioned_docs/version-v0.35.0/reference/NoirJS/backend_barretenberg/typedoc-sidebar.cjs
new file mode 100644
index 00000000000..8ecf05c0163
--- /dev/null
+++ b/docs/versioned_docs/version-v0.35.0/reference/NoirJS/backend_barretenberg/typedoc-sidebar.cjs
@@ -0,0 +1,4 @@
+// @ts-check
+/** @type {import('@docusaurus/plugin-content-docs').SidebarsConfig} */
+const typedocSidebar = { items: [{"type":"category","label":"Classes","items":[{"type":"doc","id":"reference/NoirJS/backend_barretenberg/classes/BarretenbergBackend","label":"BarretenbergBackend"},{"type":"doc","id":"reference/NoirJS/backend_barretenberg/classes/BarretenbergVerifier","label":"BarretenbergVerifier"},{"type":"doc","id":"reference/NoirJS/backend_barretenberg/classes/UltraHonkBackend","label":"UltraHonkBackend"},{"type":"doc","id":"reference/NoirJS/backend_barretenberg/classes/UltraHonkVerifier","label":"UltraHonkVerifier"}]},{"type":"category","label":"Type Aliases","items":[{"type":"doc","id":"reference/NoirJS/backend_barretenberg/type-aliases/BackendOptions","label":"BackendOptions"}]}]};
+module.exports = typedocSidebar.items;
\ No newline at end of file
diff --git a/docs/versioned_docs/version-v0.35.0/reference/NoirJS/noir_js/.nojekyll b/docs/versioned_docs/version-v0.35.0/reference/NoirJS/noir_js/.nojekyll
new file mode 100644
index 00000000000..e2ac6616add
--- /dev/null
+++ b/docs/versioned_docs/version-v0.35.0/reference/NoirJS/noir_js/.nojekyll
@@ -0,0 +1 @@
+TypeDoc added this file to prevent GitHub Pages from using Jekyll. You can turn off this behavior by setting the `githubPages` option to false.
\ No newline at end of file
diff --git a/docs/versioned_docs/version-v0.35.0/reference/NoirJS/noir_js/classes/Noir.md b/docs/versioned_docs/version-v0.35.0/reference/NoirJS/noir_js/classes/Noir.md
new file mode 100644
index 00000000000..ead255bc504
--- /dev/null
+++ b/docs/versioned_docs/version-v0.35.0/reference/NoirJS/noir_js/classes/Noir.md
@@ -0,0 +1,52 @@
+# Noir
+
+## Constructors
+
+### new Noir(circuit)
+
+```ts
+new Noir(circuit): Noir
+```
+
+#### Parameters
+
+| Parameter | Type |
+| :------ | :------ |
+| `circuit` | `CompiledCircuit` |
+
+#### Returns
+
+[`Noir`](Noir.md)
+
+## Methods
+
+### execute()
+
+```ts
+execute(inputs, foreignCallHandler?): Promise<object>
+```
+
+#### Parameters
+
+| Parameter | Type |
+| :------ | :------ |
+| `inputs` | `InputMap` |
+| `foreignCallHandler`? | [`ForeignCallHandler`](../type-aliases/ForeignCallHandler.md) |
+
+#### Returns
+
+`Promise`\<`object`\>
+
+#### Description
+
+Allows to execute a circuit to get its witness and return value.
+
+#### Example
+
+```typescript
+async execute(inputs)
+```
+
+***
+
+Generated using [typedoc-plugin-markdown](https://www.npmjs.com/package/typedoc-plugin-markdown) and [TypeDoc](https://typedoc.org/)
diff --git a/docs/versioned_docs/version-v0.35.0/reference/NoirJS/noir_js/functions/and.md b/docs/versioned_docs/version-v0.35.0/reference/NoirJS/noir_js/functions/and.md
new file mode 100644
index 00000000000..c783283e396
--- /dev/null
+++ b/docs/versioned_docs/version-v0.35.0/reference/NoirJS/noir_js/functions/and.md
@@ -0,0 +1,22 @@
+# and()
+
+```ts
+and(lhs, rhs): string
+```
+
+Performs a bitwise AND operation between `lhs` and `rhs`
+
+## Parameters
+
+| Parameter | Type | Description |
+| :------ | :------ | :------ |
+| `lhs` | `string` |  |
+| `rhs` | `string` |  |
+
+## Returns
+
+`string`
+
+***
+
+Generated using [typedoc-plugin-markdown](https://www.npmjs.com/package/typedoc-plugin-markdown) and [TypeDoc](https://typedoc.org/)
diff --git a/docs/versioned_docs/version-v0.35.0/reference/NoirJS/noir_js/functions/blake2s256.md b/docs/versioned_docs/version-v0.35.0/reference/NoirJS/noir_js/functions/blake2s256.md
new file mode 100644
index 00000000000..7882d0da8d5
--- /dev/null
+++ b/docs/versioned_docs/version-v0.35.0/reference/NoirJS/noir_js/functions/blake2s256.md
@@ -0,0 +1,21 @@
+# blake2s256()
+
+```ts
+blake2s256(inputs): Uint8Array
+```
+
+Calculates the Blake2s256 hash of the input bytes
+
+## Parameters
+
+| Parameter | Type | Description |
+| :------ | :------ | :------ |
+| `inputs` | `Uint8Array` |  |
+
+## Returns
+
+`Uint8Array`
+
+***
+
+Generated using [typedoc-plugin-markdown](https://www.npmjs.com/package/typedoc-plugin-markdown) and [TypeDoc](https://typedoc.org/)
diff --git a/docs/versioned_docs/version-v0.35.0/reference/NoirJS/noir_js/functions/ecdsa_secp256k1_verify.md b/docs/versioned_docs/version-v0.35.0/reference/NoirJS/noir_js/functions/ecdsa_secp256k1_verify.md
new file mode 100644
index 00000000000..5e3cd53e9d3
--- /dev/null
+++ b/docs/versioned_docs/version-v0.35.0/reference/NoirJS/noir_js/functions/ecdsa_secp256k1_verify.md
@@ -0,0 +1,28 @@
+# ecdsa\_secp256k1\_verify()
+
+```ts
+ecdsa_secp256k1_verify(
+   hashed_msg, 
+   public_key_x_bytes, 
+   public_key_y_bytes, 
+   signature): boolean
+```
+
+Verifies a ECDSA signature over the secp256k1 curve.
+
+## Parameters
+
+| Parameter | Type | Description |
+| :------ | :------ | :------ |
+| `hashed_msg` | `Uint8Array` |  |
+| `public_key_x_bytes` | `Uint8Array` |  |
+| `public_key_y_bytes` | `Uint8Array` |  |
+| `signature` | `Uint8Array` |  |
+
+## Returns
+
+`boolean`
+
+***
+
+Generated using [typedoc-plugin-markdown](https://www.npmjs.com/package/typedoc-plugin-markdown) and [TypeDoc](https://typedoc.org/)
diff --git a/docs/versioned_docs/version-v0.35.0/reference/NoirJS/noir_js/functions/ecdsa_secp256r1_verify.md b/docs/versioned_docs/version-v0.35.0/reference/NoirJS/noir_js/functions/ecdsa_secp256r1_verify.md
new file mode 100644
index 00000000000..0b20ff68957
--- /dev/null
+++ b/docs/versioned_docs/version-v0.35.0/reference/NoirJS/noir_js/functions/ecdsa_secp256r1_verify.md
@@ -0,0 +1,28 @@
+# ecdsa\_secp256r1\_verify()
+
+```ts
+ecdsa_secp256r1_verify(
+   hashed_msg, 
+   public_key_x_bytes, 
+   public_key_y_bytes, 
+   signature): boolean
+```
+
+Verifies a ECDSA signature over the secp256r1 curve.
+
+## Parameters
+
+| Parameter | Type | Description |
+| :------ | :------ | :------ |
+| `hashed_msg` | `Uint8Array` |  |
+| `public_key_x_bytes` | `Uint8Array` |  |
+| `public_key_y_bytes` | `Uint8Array` |  |
+| `signature` | `Uint8Array` |  |
+
+## Returns
+
+`boolean`
+
+***
+
+Generated using [typedoc-plugin-markdown](https://www.npmjs.com/package/typedoc-plugin-markdown) and [TypeDoc](https://typedoc.org/)
diff --git a/docs/versioned_docs/version-v0.35.0/reference/NoirJS/noir_js/functions/keccak256.md b/docs/versioned_docs/version-v0.35.0/reference/NoirJS/noir_js/functions/keccak256.md
new file mode 100644
index 00000000000..d10f155ce86
--- /dev/null
+++ b/docs/versioned_docs/version-v0.35.0/reference/NoirJS/noir_js/functions/keccak256.md
@@ -0,0 +1,21 @@
+# keccak256()
+
+```ts
+keccak256(inputs): Uint8Array
+```
+
+Calculates the Keccak256 hash of the input bytes
+
+## Parameters
+
+| Parameter | Type | Description |
+| :------ | :------ | :------ |
+| `inputs` | `Uint8Array` |  |
+
+## Returns
+
+`Uint8Array`
+
+***
+
+Generated using [typedoc-plugin-markdown](https://www.npmjs.com/package/typedoc-plugin-markdown) and [TypeDoc](https://typedoc.org/)
diff --git a/docs/versioned_docs/version-v0.35.0/reference/NoirJS/noir_js/functions/xor.md b/docs/versioned_docs/version-v0.35.0/reference/NoirJS/noir_js/functions/xor.md
new file mode 100644
index 00000000000..8d762b895d3
--- /dev/null
+++ b/docs/versioned_docs/version-v0.35.0/reference/NoirJS/noir_js/functions/xor.md
@@ -0,0 +1,22 @@
+# xor()
+
+```ts
+xor(lhs, rhs): string
+```
+
+Performs a bitwise XOR operation between `lhs` and `rhs`
+
+## Parameters
+
+| Parameter | Type | Description |
+| :------ | :------ | :------ |
+| `lhs` | `string` |  |
+| `rhs` | `string` |  |
+
+## Returns
+
+`string`
+
+***
+
+Generated using [typedoc-plugin-markdown](https://www.npmjs.com/package/typedoc-plugin-markdown) and [TypeDoc](https://typedoc.org/)
diff --git a/docs/versioned_docs/version-v0.35.0/reference/NoirJS/noir_js/index.md b/docs/versioned_docs/version-v0.35.0/reference/NoirJS/noir_js/index.md
new file mode 100644
index 00000000000..b65a44865ee
--- /dev/null
+++ b/docs/versioned_docs/version-v0.35.0/reference/NoirJS/noir_js/index.md
@@ -0,0 +1,48 @@
+# noir_js
+
+## Exports
+
+### Classes
+
+| Class | Description |
+| :------ | :------ |
+| [Noir](classes/Noir.md) | - |
+
+### Type Aliases
+
+| Type alias | Description |
+| :------ | :------ |
+| [ErrorWithPayload](type-aliases/ErrorWithPayload.md) | - |
+| [ForeignCallHandler](type-aliases/ForeignCallHandler.md) | A callback which performs an foreign call and returns the response. |
+| [ForeignCallInput](type-aliases/ForeignCallInput.md) | - |
+| [ForeignCallOutput](type-aliases/ForeignCallOutput.md) | - |
+| [WitnessMap](type-aliases/WitnessMap.md) | - |
+
+### Functions
+
+| Function | Description |
+| :------ | :------ |
+| [and](functions/and.md) | Performs a bitwise AND operation between `lhs` and `rhs` |
+| [blake2s256](functions/blake2s256.md) | Calculates the Blake2s256 hash of the input bytes |
+| [ecdsa\_secp256k1\_verify](functions/ecdsa_secp256k1_verify.md) | Verifies a ECDSA signature over the secp256k1 curve. |
+| [ecdsa\_secp256r1\_verify](functions/ecdsa_secp256r1_verify.md) | Verifies a ECDSA signature over the secp256r1 curve. |
+| [keccak256](functions/keccak256.md) | Calculates the Keccak256 hash of the input bytes |
+| [xor](functions/xor.md) | Performs a bitwise XOR operation between `lhs` and `rhs` |
+
+## References
+
+### CompiledCircuit
+
+Renames and re-exports [InputMap](index.md#inputmap)
+
+## Variables
+
+### InputMap
+
+```ts
+InputMap: any;
+```
+
+***
+
+Generated using [typedoc-plugin-markdown](https://www.npmjs.com/package/typedoc-plugin-markdown) and [TypeDoc](https://typedoc.org/)
diff --git a/docs/versioned_docs/version-v0.35.0/reference/NoirJS/noir_js/type-aliases/ErrorWithPayload.md b/docs/versioned_docs/version-v0.35.0/reference/NoirJS/noir_js/type-aliases/ErrorWithPayload.md
new file mode 100644
index 00000000000..e8c2f4aef3d
--- /dev/null
+++ b/docs/versioned_docs/version-v0.35.0/reference/NoirJS/noir_js/type-aliases/ErrorWithPayload.md
@@ -0,0 +1,15 @@
+# ErrorWithPayload
+
+```ts
+type ErrorWithPayload: ExecutionError & object;
+```
+
+## Type declaration
+
+| Member | Type | Description |
+| :------ | :------ | :------ |
+| `decodedAssertionPayload` | `any` | - |
+
+***
+
+Generated using [typedoc-plugin-markdown](https://www.npmjs.com/package/typedoc-plugin-markdown) and [TypeDoc](https://typedoc.org/)
diff --git a/docs/versioned_docs/version-v0.35.0/reference/NoirJS/noir_js/type-aliases/ForeignCallHandler.md b/docs/versioned_docs/version-v0.35.0/reference/NoirJS/noir_js/type-aliases/ForeignCallHandler.md
new file mode 100644
index 00000000000..812b8b16481
--- /dev/null
+++ b/docs/versioned_docs/version-v0.35.0/reference/NoirJS/noir_js/type-aliases/ForeignCallHandler.md
@@ -0,0 +1,24 @@
+# ForeignCallHandler
+
+```ts
+type ForeignCallHandler: (name, inputs) => Promise<ForeignCallOutput[]>;
+```
+
+A callback which performs an foreign call and returns the response.
+
+## Parameters
+
+| Parameter | Type | Description |
+| :------ | :------ | :------ |
+| `name` | `string` | The identifier for the type of foreign call being performed. |
+| `inputs` | [`ForeignCallInput`](ForeignCallInput.md)[] | An array of hex encoded inputs to the foreign call. |
+
+## Returns
+
+`Promise`\<[`ForeignCallOutput`](ForeignCallOutput.md)[]\>
+
+outputs - An array of hex encoded outputs containing the results of the foreign call.
+
+***
+
+Generated using [typedoc-plugin-markdown](https://www.npmjs.com/package/typedoc-plugin-markdown) and [TypeDoc](https://typedoc.org/)
diff --git a/docs/versioned_docs/version-v0.35.0/reference/NoirJS/noir_js/type-aliases/ForeignCallInput.md b/docs/versioned_docs/version-v0.35.0/reference/NoirJS/noir_js/type-aliases/ForeignCallInput.md
new file mode 100644
index 00000000000..dd95809186a
--- /dev/null
+++ b/docs/versioned_docs/version-v0.35.0/reference/NoirJS/noir_js/type-aliases/ForeignCallInput.md
@@ -0,0 +1,9 @@
+# ForeignCallInput
+
+```ts
+type ForeignCallInput: string[];
+```
+
+***
+
+Generated using [typedoc-plugin-markdown](https://www.npmjs.com/package/typedoc-plugin-markdown) and [TypeDoc](https://typedoc.org/)
diff --git a/docs/versioned_docs/version-v0.35.0/reference/NoirJS/noir_js/type-aliases/ForeignCallOutput.md b/docs/versioned_docs/version-v0.35.0/reference/NoirJS/noir_js/type-aliases/ForeignCallOutput.md
new file mode 100644
index 00000000000..b71fb78a946
--- /dev/null
+++ b/docs/versioned_docs/version-v0.35.0/reference/NoirJS/noir_js/type-aliases/ForeignCallOutput.md
@@ -0,0 +1,9 @@
+# ForeignCallOutput
+
+```ts
+type ForeignCallOutput: string | string[];
+```
+
+***
+
+Generated using [typedoc-plugin-markdown](https://www.npmjs.com/package/typedoc-plugin-markdown) and [TypeDoc](https://typedoc.org/)
diff --git a/docs/versioned_docs/version-v0.35.0/reference/NoirJS/noir_js/type-aliases/WitnessMap.md b/docs/versioned_docs/version-v0.35.0/reference/NoirJS/noir_js/type-aliases/WitnessMap.md
new file mode 100644
index 00000000000..258c46f9d0c
--- /dev/null
+++ b/docs/versioned_docs/version-v0.35.0/reference/NoirJS/noir_js/type-aliases/WitnessMap.md
@@ -0,0 +1,9 @@
+# WitnessMap
+
+```ts
+type WitnessMap: Map<number, string>;
+```
+
+***
+
+Generated using [typedoc-plugin-markdown](https://www.npmjs.com/package/typedoc-plugin-markdown) and [TypeDoc](https://typedoc.org/)
diff --git a/docs/versioned_docs/version-v0.35.0/reference/NoirJS/noir_js/typedoc-sidebar.cjs b/docs/versioned_docs/version-v0.35.0/reference/NoirJS/noir_js/typedoc-sidebar.cjs
new file mode 100644
index 00000000000..9c7fc4a353f
--- /dev/null
+++ b/docs/versioned_docs/version-v0.35.0/reference/NoirJS/noir_js/typedoc-sidebar.cjs
@@ -0,0 +1,4 @@
+// @ts-check
+/** @type {import('@docusaurus/plugin-content-docs').SidebarsConfig} */
+const typedocSidebar = { items: [{"type":"category","label":"Classes","items":[{"type":"doc","id":"reference/NoirJS/noir_js/classes/Noir","label":"Noir"}]},{"type":"category","label":"Type Aliases","items":[{"type":"doc","id":"reference/NoirJS/noir_js/type-aliases/ErrorWithPayload","label":"ErrorWithPayload"},{"type":"doc","id":"reference/NoirJS/noir_js/type-aliases/ForeignCallHandler","label":"ForeignCallHandler"},{"type":"doc","id":"reference/NoirJS/noir_js/type-aliases/ForeignCallInput","label":"ForeignCallInput"},{"type":"doc","id":"reference/NoirJS/noir_js/type-aliases/ForeignCallOutput","label":"ForeignCallOutput"},{"type":"doc","id":"reference/NoirJS/noir_js/type-aliases/WitnessMap","label":"WitnessMap"}]},{"type":"category","label":"Functions","items":[{"type":"doc","id":"reference/NoirJS/noir_js/functions/and","label":"and"},{"type":"doc","id":"reference/NoirJS/noir_js/functions/blake2s256","label":"blake2s256"},{"type":"doc","id":"reference/NoirJS/noir_js/functions/ecdsa_secp256k1_verify","label":"ecdsa_secp256k1_verify"},{"type":"doc","id":"reference/NoirJS/noir_js/functions/ecdsa_secp256r1_verify","label":"ecdsa_secp256r1_verify"},{"type":"doc","id":"reference/NoirJS/noir_js/functions/keccak256","label":"keccak256"},{"type":"doc","id":"reference/NoirJS/noir_js/functions/xor","label":"xor"}]}]};
+module.exports = typedocSidebar.items;
\ No newline at end of file
diff --git a/docs/versioned_docs/version-v0.35.0/reference/NoirJS/noir_wasm/.nojekyll b/docs/versioned_docs/version-v0.35.0/reference/NoirJS/noir_wasm/.nojekyll
new file mode 100644
index 00000000000..e2ac6616add
--- /dev/null
+++ b/docs/versioned_docs/version-v0.35.0/reference/NoirJS/noir_wasm/.nojekyll
@@ -0,0 +1 @@
+TypeDoc added this file to prevent GitHub Pages from using Jekyll. You can turn off this behavior by setting the `githubPages` option to false.
\ No newline at end of file
diff --git a/docs/versioned_docs/version-v0.35.0/reference/NoirJS/noir_wasm/functions/compile.md b/docs/versioned_docs/version-v0.35.0/reference/NoirJS/noir_wasm/functions/compile.md
new file mode 100644
index 00000000000..6faf763b37f
--- /dev/null
+++ b/docs/versioned_docs/version-v0.35.0/reference/NoirJS/noir_wasm/functions/compile.md
@@ -0,0 +1,51 @@
+# compile()
+
+```ts
+compile(
+   fileManager, 
+   projectPath?, 
+   logFn?, 
+debugLogFn?): Promise<ProgramCompilationArtifacts>
+```
+
+Compiles a Noir project
+
+## Parameters
+
+| Parameter | Type | Description |
+| :------ | :------ | :------ |
+| `fileManager` | `FileManager` | The file manager to use |
+| `projectPath`? | `string` | The path to the project inside the file manager. Defaults to the root of the file manager |
+| `logFn`? | `LogFn` | A logging function. If not provided, console.log will be used |
+| `debugLogFn`? | `LogFn` | A debug logging function. If not provided, logFn will be used |
+
+## Returns
+
+`Promise`\<[`ProgramCompilationArtifacts`](../index.md#programcompilationartifacts)\>
+
+## Example
+
+```typescript
+// Node.js
+
+import { compile_program, createFileManager } from '@noir-lang/noir_wasm';
+
+const fm = createFileManager(myProjectPath);
+const myCompiledCode = await compile_program(fm);
+```
+
+```typescript
+// Browser
+
+import { compile_program, createFileManager } from '@noir-lang/noir_wasm';
+
+const fm = createFileManager('/');
+for (const path of files) {
+  await fm.writeFile(path, await getFileAsStream(path));
+}
+const myCompiledCode = await compile_program(fm);
+```
+
+***
+
+Generated using [typedoc-plugin-markdown](https://www.npmjs.com/package/typedoc-plugin-markdown) and [TypeDoc](https://typedoc.org/)
diff --git a/docs/versioned_docs/version-v0.35.0/reference/NoirJS/noir_wasm/functions/compile_contract.md b/docs/versioned_docs/version-v0.35.0/reference/NoirJS/noir_wasm/functions/compile_contract.md
new file mode 100644
index 00000000000..7d0b39a43ef
--- /dev/null
+++ b/docs/versioned_docs/version-v0.35.0/reference/NoirJS/noir_wasm/functions/compile_contract.md
@@ -0,0 +1,51 @@
+# compile\_contract()
+
+```ts
+compile_contract(
+   fileManager, 
+   projectPath?, 
+   logFn?, 
+debugLogFn?): Promise<ContractCompilationArtifacts>
+```
+
+Compiles a Noir project
+
+## Parameters
+
+| Parameter | Type | Description |
+| :------ | :------ | :------ |
+| `fileManager` | `FileManager` | The file manager to use |
+| `projectPath`? | `string` | The path to the project inside the file manager. Defaults to the root of the file manager |
+| `logFn`? | `LogFn` | A logging function. If not provided, console.log will be used |
+| `debugLogFn`? | `LogFn` | A debug logging function. If not provided, logFn will be used |
+
+## Returns
+
+`Promise`\<[`ContractCompilationArtifacts`](../index.md#contractcompilationartifacts)\>
+
+## Example
+
+```typescript
+// Node.js
+
+import { compile_contract, createFileManager } from '@noir-lang/noir_wasm';
+
+const fm = createFileManager(myProjectPath);
+const myCompiledCode = await compile_contract(fm);
+```
+
+```typescript
+// Browser
+
+import { compile_contract, createFileManager } from '@noir-lang/noir_wasm';
+
+const fm = createFileManager('/');
+for (const path of files) {
+  await fm.writeFile(path, await getFileAsStream(path));
+}
+const myCompiledCode = await compile_contract(fm);
+```
+
+***
+
+Generated using [typedoc-plugin-markdown](https://www.npmjs.com/package/typedoc-plugin-markdown) and [TypeDoc](https://typedoc.org/)
diff --git a/docs/versioned_docs/version-v0.35.0/reference/NoirJS/noir_wasm/functions/createFileManager.md b/docs/versioned_docs/version-v0.35.0/reference/NoirJS/noir_wasm/functions/createFileManager.md
new file mode 100644
index 00000000000..7e65c1d69c7
--- /dev/null
+++ b/docs/versioned_docs/version-v0.35.0/reference/NoirJS/noir_wasm/functions/createFileManager.md
@@ -0,0 +1,21 @@
+# createFileManager()
+
+```ts
+createFileManager(dataDir): FileManager
+```
+
+Creates a new FileManager instance based on fs in node and memfs in the browser (via webpack alias)
+
+## Parameters
+
+| Parameter | Type | Description |
+| :------ | :------ | :------ |
+| `dataDir` | `string` | root of the file system |
+
+## Returns
+
+`FileManager`
+
+***
+
+Generated using [typedoc-plugin-markdown](https://www.npmjs.com/package/typedoc-plugin-markdown) and [TypeDoc](https://typedoc.org/)
diff --git a/docs/versioned_docs/version-v0.35.0/reference/NoirJS/noir_wasm/functions/inflateDebugSymbols.md b/docs/versioned_docs/version-v0.35.0/reference/NoirJS/noir_wasm/functions/inflateDebugSymbols.md
new file mode 100644
index 00000000000..fcea9275341
--- /dev/null
+++ b/docs/versioned_docs/version-v0.35.0/reference/NoirJS/noir_wasm/functions/inflateDebugSymbols.md
@@ -0,0 +1,21 @@
+# inflateDebugSymbols()
+
+```ts
+inflateDebugSymbols(debugSymbols): any
+```
+
+Decompresses and decodes the debug symbols
+
+## Parameters
+
+| Parameter | Type | Description |
+| :------ | :------ | :------ |
+| `debugSymbols` | `string` | The base64 encoded debug symbols |
+
+## Returns
+
+`any`
+
+***
+
+Generated using [typedoc-plugin-markdown](https://www.npmjs.com/package/typedoc-plugin-markdown) and [TypeDoc](https://typedoc.org/)
diff --git a/docs/versioned_docs/version-v0.35.0/reference/NoirJS/noir_wasm/index.md b/docs/versioned_docs/version-v0.35.0/reference/NoirJS/noir_wasm/index.md
new file mode 100644
index 00000000000..b6e0f9d1bc0
--- /dev/null
+++ b/docs/versioned_docs/version-v0.35.0/reference/NoirJS/noir_wasm/index.md
@@ -0,0 +1,49 @@
+# noir_wasm
+
+## Exports
+
+### Functions
+
+| Function | Description |
+| :------ | :------ |
+| [compile](functions/compile.md) | Compiles a Noir project |
+| [compile\_contract](functions/compile_contract.md) | Compiles a Noir project |
+| [createFileManager](functions/createFileManager.md) | Creates a new FileManager instance based on fs in node and memfs in the browser (via webpack alias) |
+| [inflateDebugSymbols](functions/inflateDebugSymbols.md) | Decompresses and decodes the debug symbols |
+
+## References
+
+### compile\_program
+
+Renames and re-exports [compile](functions/compile.md)
+
+## Interfaces
+
+### ContractCompilationArtifacts
+
+The compilation artifacts of a given contract.
+
+#### Properties
+
+| Property | Type | Description |
+| :------ | :------ | :------ |
+| `contract` | `ContractArtifact` | The compiled contract. |
+| `warnings` | `unknown`[] | Compilation warnings. |
+
+***
+
+### ProgramCompilationArtifacts
+
+The compilation artifacts of a given program.
+
+#### Properties
+
+| Property | Type | Description |
+| :------ | :------ | :------ |
+| `name` | `string` | not part of the compilation output, injected later |
+| `program` | `ProgramArtifact` | The compiled contract. |
+| `warnings` | `unknown`[] | Compilation warnings. |
+
+***
+
+Generated using [typedoc-plugin-markdown](https://www.npmjs.com/package/typedoc-plugin-markdown) and [TypeDoc](https://typedoc.org/)
diff --git a/docs/versioned_docs/version-v0.35.0/reference/NoirJS/noir_wasm/typedoc-sidebar.cjs b/docs/versioned_docs/version-v0.35.0/reference/NoirJS/noir_wasm/typedoc-sidebar.cjs
new file mode 100644
index 00000000000..e0870710349
--- /dev/null
+++ b/docs/versioned_docs/version-v0.35.0/reference/NoirJS/noir_wasm/typedoc-sidebar.cjs
@@ -0,0 +1,4 @@
+// @ts-check
+/** @type {import('@docusaurus/plugin-content-docs').SidebarsConfig} */
+const typedocSidebar = { items: [{"type":"doc","id":"reference/NoirJS/noir_wasm/index","label":"API"},{"type":"category","label":"Functions","items":[{"type":"doc","id":"reference/NoirJS/noir_wasm/functions/compile","label":"compile"},{"type":"doc","id":"reference/NoirJS/noir_wasm/functions/compile_contract","label":"compile_contract"},{"type":"doc","id":"reference/NoirJS/noir_wasm/functions/createFileManager","label":"createFileManager"},{"type":"doc","id":"reference/NoirJS/noir_wasm/functions/inflateDebugSymbols","label":"inflateDebugSymbols"}]}]};
+module.exports = typedocSidebar.items;
\ No newline at end of file
diff --git a/docs/versioned_docs/version-v0.35.0/reference/_category_.json b/docs/versioned_docs/version-v0.35.0/reference/_category_.json
new file mode 100644
index 00000000000..5b6a20a609a
--- /dev/null
+++ b/docs/versioned_docs/version-v0.35.0/reference/_category_.json
@@ -0,0 +1,5 @@
+{
+    "position": 4,
+    "collapsible": true,
+    "collapsed": true
+}
diff --git a/docs/versioned_docs/version-v0.35.0/reference/debugger/_category_.json b/docs/versioned_docs/version-v0.35.0/reference/debugger/_category_.json
new file mode 100644
index 00000000000..27869205ad3
--- /dev/null
+++ b/docs/versioned_docs/version-v0.35.0/reference/debugger/_category_.json
@@ -0,0 +1,6 @@
+{
+    "label": "Debugger",
+    "position": 1,
+    "collapsible": true,
+    "collapsed": true
+}
diff --git a/docs/versioned_docs/version-v0.35.0/reference/debugger/debugger_known_limitations.md b/docs/versioned_docs/version-v0.35.0/reference/debugger/debugger_known_limitations.md
new file mode 100644
index 00000000000..936d416ac4b
--- /dev/null
+++ b/docs/versioned_docs/version-v0.35.0/reference/debugger/debugger_known_limitations.md
@@ -0,0 +1,59 @@
+---
+title: Known limitations
+description:
+  An overview of known limitations of the current version of the Noir debugger
+keywords:
+  [
+    Nargo,
+    Noir Debugger,
+    VS Code,
+  ]
+sidebar_position: 2
+---
+
+# Debugger Known Limitations
+
+There are currently some limits to what the debugger can observe. 
+
+## Mutable references
+
+The debugger is currently blind to any state mutated via a mutable reference. For example, in:
+
+```
+let mut x = 1;
+let y = &mut x;
+*y = 2;
+```
+
+The update on `x` will not be observed by the debugger. That means, when running `vars` from the debugger REPL, or inspecting the _local variables_ pane in the VS Code debugger, `x` will appear with value 1 despite having executed `*y = 2;`.
+
+## Variables of type function or mutable references are opaque
+
+When inspecting variables, any variable of type `Function` or `MutableReference` will render its value as `<<function>>` or `<<mutable ref>>`.
+
+## Debugger instrumentation affects resulting ACIR
+                      
+In order to make the state of local variables observable, the debugger compiles Noir circuits interleaving foreign calls that track any mutations to them. While this works (except in the cases described above) and doesn't introduce any behavior changes, it does as a side effect produce bigger bytecode. In particular, when running the command `opcodes` on the REPL debugger, you will notice Unconstrained VM blocks that look like this:
+
+```
+...
+5    BRILLIG inputs=[Single(Expression { mul_terms: [], linear_combinations: [], q_c: 2 }), Single(Expression { mul_terms: [], linear_combinations: [(1, Witness(2))], q_c: 0 })]
+       |       outputs=[]
+  5.0  |   Mov { destination: RegisterIndex(2), source: RegisterIndex(0) }
+  5.1  |   Mov { destination: RegisterIndex(3), source: RegisterIndex(1) }
+  5.2  |   Const { destination: RegisterIndex(0), value: Value { inner: 0 } }
+  5.3  |   Const { destination: RegisterIndex(1), value: Value { inner: 0 } }
+  5.4  |   Mov { destination: RegisterIndex(2), source: RegisterIndex(2) }
+  5.5  |   Mov { destination: RegisterIndex(3), source: RegisterIndex(3) }
+  5.6  |   Call { location: 8 }
+  5.7  |   Stop
+  5.8  |   ForeignCall { function: "__debug_var_assign", destinations: [], inputs: [RegisterIndex(RegisterIndex(2)), RegisterIndex(RegisterIndex(3))] }
+...
+```               
+                                    
+If you are interested in debugging/inspecting compiled ACIR without these synthetic changes, you can invoke the REPL debugger with the `--skip-instrumentation` flag or launch the VS Code debugger with the `skipConfiguration` property set to true in its launch configuration. You can find more details about those in the [Debugger REPL reference](debugger_repl.md) and the [VS Code Debugger reference](debugger_vscode.md).
+
+:::note
+Skipping debugger instrumentation means you won't be able to inspect values of local variables.
+:::
+
diff --git a/docs/versioned_docs/version-v0.35.0/reference/debugger/debugger_repl.md b/docs/versioned_docs/version-v0.35.0/reference/debugger/debugger_repl.md
new file mode 100644
index 00000000000..46e2011304e
--- /dev/null
+++ b/docs/versioned_docs/version-v0.35.0/reference/debugger/debugger_repl.md
@@ -0,0 +1,360 @@
+---
+title: REPL Debugger
+description:
+  Noir Debugger REPL options and commands. 
+keywords:
+  [
+    Nargo,
+    Noir CLI,
+    Noir Debugger,
+    REPL,
+  ]
+sidebar_position: 1
+---
+
+## Running the REPL debugger
+
+`nargo debug [OPTIONS] [WITNESS_NAME]`
+
+Runs the Noir REPL debugger. If a `WITNESS_NAME` is provided the debugger writes the resulting execution witness to a `WITNESS_NAME` file.
+
+### Options
+
+| Option                | Description                                                  |
+| --------------------- | ------------------------------------------------------------ |
+| `-p, --prover-name <PROVER_NAME>` | The name of the toml file which contains the inputs for the prover [default: Prover]|
+| `--package <PACKAGE>` | The name of the package to debug                             |
+| `--print-acir`        | Display the ACIR for compiled circuit                        |
+| `--deny-warnings`     | Treat all warnings as errors                                 |
+| `--silence-warnings`  | Suppress warnings                                            |
+| `-h, --help`          | Print help                                                   |
+
+None of these options are required.
+
+:::note
+Since the debugger starts by compiling the target package, all Noir compiler options are also available. Check out the [compiler reference](../nargo_commands.md#nargo-compile) to learn more about the compiler options.
+:::
+
+## REPL commands
+
+Once the debugger is running, it accepts the following commands.
+
+#### `help` (h)
+
+Displays the menu of available commands.
+
+```
+> help
+Available commands:
+
+  opcodes                          display ACIR opcodes
+  into                             step into to the next opcode
+  next                             step until a new source location is reached
+  out                              step until a new source location is reached
+                                   and the current stack frame is finished
+  break LOCATION:OpcodeLocation    add a breakpoint at an opcode location
+  over                             step until a new source location is reached
+                                   without diving into function calls
+  restart                          restart the debugging session
+  delete LOCATION:OpcodeLocation   delete breakpoint at an opcode location
+  witness                          show witness map
+  witness index:u32                display a single witness from the witness map
+  witness index:u32 value:String   update a witness with the given value
+  memset index:usize value:String  update a memory cell with the given
+                                   value
+  continue                         continue execution until the end of the
+                                   program
+  vars                             show variable values available at this point
+                                   in execution
+  stacktrace                       display the current stack trace
+  memory                           show memory (valid when executing unconstrained code)                                 value
+  step                             step to the next ACIR opcode
+
+Other commands:
+
+  help  Show this help message
+  quit  Quit repl
+
+```
+
+### Stepping through programs
+
+#### `next` (n)
+
+Step until the next Noir source code location. While other commands, such as [`into`](#into-i) and [`step`](#step-s), allow for finer grained control of the program's execution at the opcode level, `next` is source code centric. For example:
+
+```
+3    ...
+4    fn main(x: u32) {
+5        assert(entry_point(x) == 2);
+6        swap_entry_point(x, x + 1);
+7 ->     assert(deep_entry_point(x) == 4);
+8        multiple_values_entry_point(x);
+9    }
+```
+
+
+Using `next` here would cause the debugger to jump to the definition of `deep_entry_point` (if available). 
+
+If you want to step over `deep_entry_point` and go straight to line 8, use [the `over` command](#over) instead.
+
+#### `over`
+
+Step until the next source code location, without diving into function calls. For example:
+
+```
+3    ...
+4    fn main(x: u32) {
+5        assert(entry_point(x) == 2);
+6        swap_entry_point(x, x + 1);
+7 ->     assert(deep_entry_point(x) == 4);
+8        multiple_values_entry_point(x);
+9    }
+```
+
+
+Using `over` here would cause the debugger to execute until line 8 (`multiple_values_entry_point(x);`).
+
+If you want to step into `deep_entry_point` instead, use [the `next` command](#next-n).
+
+#### `out`
+
+Step until the end of the current function call. For example:
+
+```
+  3    ...
+  4    fn main(x: u32) {
+  5        assert(entry_point(x) == 2);
+  6        swap_entry_point(x, x + 1);
+  7 ->     assert(deep_entry_point(x) == 4);
+  8        multiple_values_entry_point(x);
+  9    }
+ 10    
+ 11    unconstrained fn returns_multiple_values(x: u32) -> (u32, u32, u32, u32) {
+ 12    ...
+ ...
+ 55    
+ 56    unconstrained fn deep_entry_point(x: u32) -> u32 {
+ 57 ->     level_1(x + 1)
+ 58    }
+
+```
+
+Running `out` here will resume execution until line 8.
+
+#### `step` (s)
+
+Skips to the next ACIR code. A compiled Noir program is a sequence of ACIR opcodes. However, an unconstrained VM opcode denotes the start of an unconstrained code block, to be executed by the unconstrained VM. For example (redacted for brevity):
+
+```
+0  BLACKBOX::RANGE [(_0, num_bits: 32)] [ ]
+1 ->  BRILLIG inputs=[Single(Expression { mul_terms: [], linear_combinations: [(1, Witness(0))], q_c: 0 })] outputs=[Simple(Witness(1))]
+	1.0  |   Mov { destination: RegisterIndex(2), source: RegisterIndex(0) }
+	1.1  |   Const { destination: RegisterIndex(0), value: Value { inner: 0 } }
+	1.2  |   Const { destination: RegisterIndex(1), value: Value { inner: 0 } }
+	1.3  |   Mov { destination: RegisterIndex(2), source: RegisterIndex(2) }
+	1.4  |   Call { location: 7 }
+	...
+	1.43 |   Return
+2    EXPR [ (1, _1) -2 ]
+```
+
+The `->` here shows the debugger paused at an ACIR opcode: `BRILLIG`, at index 1, which denotes an unconstrained code block is about to start.
+
+Using the `step` command at this point would result in the debugger stopping at ACIR opcode 2, `EXPR`, skipping unconstrained computation steps.
+
+Use [the `into` command](#into-i) instead if you want to follow unconstrained computation step by step.
+
+#### `into` (i)
+
+Steps into the next opcode. A compiled Noir program is a sequence of ACIR opcodes. However, a BRILLIG opcode denotes the start of an unconstrained code block, to be executed by the unconstrained VM. For example (redacted for brevity):
+
+```
+0  BLACKBOX::RANGE [(_0, num_bits: 32)] [ ]
+1 ->  BRILLIG inputs=[Single(Expression { mul_terms: [], linear_combinations: [(1, Witness(0))], q_c: 0 })] outputs=[Simple(Witness(1))]
+	1.0  |   Mov { destination: RegisterIndex(2), source: RegisterIndex(0) }
+	1.1  |   Const { destination: RegisterIndex(0), value: Value { inner: 0 } }
+	1.2  |   Const { destination: RegisterIndex(1), value: Value { inner: 0 } }
+	1.3  |   Mov { destination: RegisterIndex(2), source: RegisterIndex(2) }
+	1.4  |   Call { location: 7 }
+	...
+	1.43 |   Return
+2    EXPR [ (1, _1) -2 ]
+``` 
+
+The `->` here shows the debugger paused at an ACIR opcode: `BRILLIG`, at index 1, which denotes an unconstrained code block is about to start.
+
+Using the `into` command at this point would result in the debugger stopping at opcode 1.0, `Mov ...`, allowing the debugger user to follow unconstrained computation step by step.
+
+Use [the `step` command](#step-s) instead if you want to skip to the next ACIR code directly.
+
+#### `continue` (c)
+
+Continues execution until the next breakpoint, or the end of the program.
+
+#### `restart` (res)
+
+Interrupts execution, and restarts a new debugging session from scratch.
+
+#### `opcodes` (o)
+
+Display the program's ACIR opcode sequence. For example:
+
+```
+0  BLACKBOX::RANGE [(_0, num_bits: 32)] [ ]
+1 ->  BRILLIG inputs=[Single(Expression { mul_terms: [], linear_combinations: [(1, Witness(0))], q_c: 0 })] outputs=[Simple(Witness(1))]
+	1.0  |   Mov { destination: RegisterIndex(2), source: RegisterIndex(0) }
+	1.1  |   Const { destination: RegisterIndex(0), value: Value { inner: 0 } }
+	1.2  |   Const { destination: RegisterIndex(1), value: Value { inner: 0 } }
+	1.3  |   Mov { destination: RegisterIndex(2), source: RegisterIndex(2) }
+	1.4  |   Call { location: 7 }
+	...
+	1.43 |   Return
+2     EXPR [ (1, _1) -2 ]
+```
+
+### Breakpoints
+
+#### `break [Opcode]` (or shorthand `b [Opcode]`)
+
+Sets a breakpoint on the specified opcode index. To get a list of the program opcode numbers, see [the `opcode` command](#opcodes-o). For example:
+
+```
+0  BLACKBOX::RANGE [(_0, num_bits: 32)] [ ]
+1 ->  BRILLIG inputs=[Single(Expression { mul_terms: [], linear_combinations: [(1, Witness(0))], q_c: 0 })] outputs=[Simple(Witness(1))]
+	1.0  |   Mov { destination: RegisterIndex(2), source: RegisterIndex(0) }
+	1.1  |   Const { destination: RegisterIndex(0), value: Value { inner: 0 } }
+	1.2  |   Const { destination: RegisterIndex(1), value: Value { inner: 0 } }
+	1.3  |   Mov { destination: RegisterIndex(2), source: RegisterIndex(2) }
+	1.4  |   Call { location: 7 }
+	...
+	1.43 |   Return
+2    EXPR [ (1, _1) -2 ]
+```
+
+In this example, issuing a `break 1.2` command adds break on opcode 1.2, as denoted by the `*` character:
+
+```
+0  BLACKBOX::RANGE [(_0, num_bits: 32)] [ ]
+1 ->  BRILLIG inputs=[Single(Expression { mul_terms: [], linear_combinations: [(1, Witness(0))], q_c: 0 })] outputs=[Simple(Witness(1))]
+	1.0  |   Mov { destination: RegisterIndex(2), source: RegisterIndex(0) }
+	1.1  |   Const { destination: RegisterIndex(0), value: Value { inner: 0 } }
+	1.2  | * Const { destination: RegisterIndex(1), value: Value { inner: 0 } }
+	1.3  |   Mov { destination: RegisterIndex(2), source: RegisterIndex(2) }
+	1.4  |   Call { location: 7 }
+	...
+	1.43 |   Return
+2    EXPR [ (1, _1) -2 ]
+```
+
+Running [the `continue` command](#continue-c) at this point would cause the debugger to execute the program until opcode 1.2.
+
+#### `delete [Opcode]` (or shorthand `d [Opcode]`)
+
+Deletes a breakpoint at an opcode location. Usage is analogous to [the `break` command](#).
+
+### Variable inspection
+
+#### vars
+
+Show variable values available at this point in execution.
+
+:::note
+The ability to inspect variable values from the debugger depends on compilation to be run in a special debug instrumentation mode. This instrumentation weaves variable tracing code with the original source code. 
+
+So variable value inspection comes at the expense of making the resulting ACIR bytecode bigger and harder to understand and optimize.
+
+If you find this compromise unacceptable, you can run the debugger with the flag `--skip-debug-instrumentation`. This will compile your circuit without any additional debug information, so the resulting ACIR bytecode will be identical to the one produced by standard Noir compilation. However, if you opt for this, the `vars` command will not be available while debugging.
+:::
+
+
+### Stacktrace
+
+#### `stacktrace`
+
+Displays the current stack trace.
+
+
+### Witness map
+
+#### `witness` (w)
+
+Show witness map. For example:
+
+```
+_0 = 0
+_1 = 2
+_2 = 1
+```
+
+#### `witness [Witness Index]`
+
+Display a single witness from the witness map. For example:
+
+```
+> witness 1
+_1 = 2
+```
+
+#### `witness [Witness Index] [New value]`
+
+Overwrite the given index with a new value. For example:
+
+```
+> witness 1 3
+_1 = 3
+```
+
+
+### Unconstrained VM memory
+
+#### `memory`
+
+Show unconstrained VM memory state. For example:
+
+```
+> memory
+At opcode 1.13: Store { destination_pointer: RegisterIndex(0), source: RegisterIndex(3) }
+...
+> registers
+0 = 0
+1 = 10
+2 = 0
+3 = 1
+4 = 1
+5 = 2³²
+6 = 1
+> into
+At opcode 1.14: Const { destination: RegisterIndex(5), value: Value { inner: 1 } }
+...
+> memory
+0 = 1
+>
+```
+
+In the example above: we start with clean memory, then step through a `Store` opcode which stores the value of register 3 (1) into the memory address stored in register 0 (0). Thus now `memory` shows memory address 0 contains value 1.
+
+:::note
+This command is only functional while the debugger is executing unconstrained code.
+:::
+
+#### `memset [Memory address] [New value]`
+
+Update a memory cell with the given value. For example:
+
+```
+> memory
+0 = 1
+> memset 0 2
+> memory
+0 = 2
+> memset 1 4
+> memory
+0 = 2
+1 = 4
+>
+```
+
+:::note
+This command is only functional while the debugger is executing unconstrained code.
+:::
\ No newline at end of file
diff --git a/docs/versioned_docs/version-v0.35.0/reference/debugger/debugger_vscode.md b/docs/versioned_docs/version-v0.35.0/reference/debugger/debugger_vscode.md
new file mode 100644
index 00000000000..c027332b3b0
--- /dev/null
+++ b/docs/versioned_docs/version-v0.35.0/reference/debugger/debugger_vscode.md
@@ -0,0 +1,82 @@
+---
+title: VS Code Debugger
+description:
+  VS Code Debugger configuration and features.
+keywords:
+  [
+    Nargo,
+    Noir CLI,
+    Noir Debugger,
+    VS Code,
+    IDE,
+  ]
+sidebar_position: 0
+---
+
+# VS Code Noir Debugger Reference
+
+The Noir debugger enabled by the vscode-noir extension ships with default settings such that the most common scenario should run without any additional configuration steps.
+
+These defaults can nevertheless be overridden by defining a launch configuration file. This page provides a reference for the properties you can override via a launch configuration file, as well as documenting the Nargo `dap` command, which is a dependency of the VS Code Noir debugger. 
+
+
+## Creating and editing launch configuration files
+
+To create a launch configuration file from VS Code, open the _debug pane_, and click on _create a launch.json file_. 
+
+![Creating a launch configuration file](@site/static/img/debugger/ref1-create-launch.png)
+
+A `launch.json` file will be created, populated with basic defaults. 
+
+### Noir Debugger launch.json properties
+
+#### projectFolder
+
+_String, optional._
+
+Absolute path to the Nargo project to debug. By default, it is dynamically determined by looking for the nearest `Nargo.toml` file to the active file at the moment of launching the debugger. 
+
+#### proverName
+
+_String, optional._
+
+Name of the prover input to use. Defaults to `Prover`, which looks for a file named `Prover.toml` at the `projectFolder`.
+
+#### generateAcir
+
+_Boolean, optional._
+
+If true, generate ACIR opcodes instead of unconstrained opcodes which will be closer to release binaries but less convenient for debugging. Defaults to `false`.
+                
+#### skipInstrumentation
+
+_Boolean, optional._
+
+Skips variables debugging instrumentation of code, making debugging less convenient but the resulting binary smaller and closer to production. Defaults to `false`.
+
+:::note
+Skipping instrumentation causes the debugger to be unable to inspect local variables.
+:::
+
+## `nargo dap [OPTIONS]`
+
+When run without any option flags, it starts the Nargo Debug Adapter Protocol server, which acts as the debugging backend for the VS Code Noir Debugger. 
+
+All option flags are related to preflight checks. The Debug Adapter Protocol specifies how errors are to be informed from a running DAP server, but it doesn't specify mechanisms to communicate server initialization errors between the DAP server and its client IDE. 
+
+Thus `nargo dap` ships with a _preflight check_ mode. If flag `--preflight-check` and the rest of the `--preflight-*` flags are provided, Nargo will run the same initialization routine except it will not start the DAP server.
+
+`vscode-noir` will then run `nargo dap` in preflight check mode first before a debugging session starts. If the preflight check ends in error, vscode-noir will present stderr and stdout output from this process through its own Output pane in VS Code. This makes it possible for users to diagnose what pieces of configuration might be wrong or missing in case of initialization errors.
+
+If the preflight check succeeds, `vscode-noir` proceeds to start the DAP server normally but running `nargo dap` without any additional flags.
+
+### Options
+
+| Option                                  | Description                                                                         |
+| --------------------------------------------------------- | --------------------------------------------------------------------------------------------------------- |
+| `--preflight-check`                     | If present, dap runs in preflight check mode.                               |
+| `--preflight-project-folder <PREFLIGHT_PROJECT_FOLDER>`   | Absolute path to the project to debug for preflight check.                        |
+| `--preflight-prover-name <PREFLIGHT_PROVER_NAME>`       | Name of prover file to use for preflight check                              |
+| `--preflight-generate-acir`                 | Optional. If present, compile in ACIR mode while running preflight check.                                 |
+| `--preflight-skip-instrumentation`            | Optional. If present, compile without introducing debug instrumentation while running preflight check.  |
+| `-h, --help`                            | Print help.                                               |
diff --git a/docs/versioned_docs/version-v0.35.0/reference/nargo_commands.md b/docs/versioned_docs/version-v0.35.0/reference/nargo_commands.md
new file mode 100644
index 00000000000..db1884afee2
--- /dev/null
+++ b/docs/versioned_docs/version-v0.35.0/reference/nargo_commands.md
@@ -0,0 +1,297 @@
+---
+title: Nargo
+description:
+  Noir CLI Commands for Noir Prover and Verifier to create, execute, prove and verify programs,
+  generate Solidity verifier smart contract and compile into JSON file containing ACIR
+  representation and ABI of circuit.
+keywords:
+  [
+    Nargo,
+    Noir CLI,
+    Noir Prover,
+    Noir Verifier,
+    generate Solidity verifier,
+    compile JSON file,
+    ACIR representation,
+    ABI of circuit,
+    TypeScript,
+  ]
+sidebar_position: 0
+---
+
+# Command-Line Help for `nargo`
+
+This document contains the help content for the `nargo` command-line program.
+
+**Command Overview:**
+
+* [`nargo`↴](#nargo)
+* [`nargo check`↴](#nargo-check)
+* [`nargo fmt`↴](#nargo-fmt)
+* [`nargo compile`↴](#nargo-compile)
+* [`nargo new`↴](#nargo-new)
+* [`nargo init`↴](#nargo-init)
+* [`nargo execute`↴](#nargo-execute)
+* [`nargo debug`↴](#nargo-debug)
+* [`nargo test`↴](#nargo-test)
+* [`nargo info`↴](#nargo-info)
+* [`nargo lsp`↴](#nargo-lsp)
+
+## `nargo`
+
+Noir's package manager
+
+**Usage:** `nargo <COMMAND>`
+
+###### **Subcommands:**
+
+* `check` — Checks the constraint system for errors
+* `fmt` — Format the Noir files in a workspace
+* `compile` — Compile the program and its secret execution trace into ACIR format
+* `new` — Create a Noir project in a new directory
+* `init` — Create a Noir project in the current directory
+* `execute` — Executes a circuit to calculate its return value
+* `debug` — Executes a circuit in debug mode
+* `test` — Run the tests for this program
+* `info` — Provides detailed information on each of a program's function (represented by a single circuit)
+* `lsp` — Starts the Noir LSP server
+
+###### **Options:**
+
+
+
+
+## `nargo check`
+
+Checks the constraint system for errors
+
+**Usage:** `nargo check [OPTIONS]`
+
+###### **Options:**
+
+* `--package <PACKAGE>` — The name of the package to check
+* `--workspace` — Check all packages in the workspace
+* `--overwrite` — Force overwrite of existing files
+* `--expression-width <EXPRESSION_WIDTH>` — Specify the backend expression width that should be targeted
+* `--bounded-codegen` — Generate ACIR with the target backend expression width. The default is to generate ACIR without a bound and split expressions after code generation. Activating this flag can sometimes provide optimizations for certain programs
+
+  Default value: `false`
+* `--force` — Force a full recompilation
+* `--print-acir` — Display the ACIR for compiled circuit
+* `--deny-warnings` — Treat all warnings as errors
+* `--silence-warnings` — Suppress warnings
+* `--debug-comptime-in-file <DEBUG_COMPTIME_IN_FILE>` — Enable printing results of comptime evaluation: provide a path suffix for the module to debug, e.g. "package_name/src/main.nr"
+* `--skip-underconstrained-check` — Flag to turn off the compiler check for under constrained values. Warning: This can improve compilation speed but can also lead to correctness errors. This check should always be run on production code
+
+
+
+## `nargo fmt`
+
+Format the Noir files in a workspace
+
+**Usage:** `nargo fmt [OPTIONS]`
+
+###### **Options:**
+
+* `--check` — Run noirfmt in check mode
+
+
+
+## `nargo compile`
+
+Compile the program and its secret execution trace into ACIR format
+
+**Usage:** `nargo compile [OPTIONS]`
+
+###### **Options:**
+
+* `--package <PACKAGE>` — The name of the package to compile
+* `--workspace` — Compile all packages in the workspace
+* `--expression-width <EXPRESSION_WIDTH>` — Specify the backend expression width that should be targeted
+* `--bounded-codegen` — Generate ACIR with the target backend expression width. The default is to generate ACIR without a bound and split expressions after code generation. Activating this flag can sometimes provide optimizations for certain programs
+
+  Default value: `false`
+* `--force` — Force a full recompilation
+* `--print-acir` — Display the ACIR for compiled circuit
+* `--deny-warnings` — Treat all warnings as errors
+* `--silence-warnings` — Suppress warnings
+* `--debug-comptime-in-file <DEBUG_COMPTIME_IN_FILE>` — Enable printing results of comptime evaluation: provide a path suffix for the module to debug, e.g. "package_name/src/main.nr"
+* `--skip-underconstrained-check` — Flag to turn off the compiler check for under constrained values. Warning: This can improve compilation speed but can also lead to correctness errors. This check should always be run on production code
+
+
+
+## `nargo new`
+
+Create a Noir project in a new directory
+
+**Usage:** `nargo new [OPTIONS] <PATH>`
+
+###### **Arguments:**
+
+* `<PATH>` — The path to save the new project
+
+###### **Options:**
+
+* `--name <NAME>` — Name of the package [default: package directory name]
+* `--lib` — Use a library template
+* `--bin` — Use a binary template [default]
+* `--contract` — Use a contract template
+
+
+
+## `nargo init`
+
+Create a Noir project in the current directory
+
+**Usage:** `nargo init [OPTIONS]`
+
+###### **Options:**
+
+* `--name <NAME>` — Name of the package [default: current directory name]
+* `--lib` — Use a library template
+* `--bin` — Use a binary template [default]
+* `--contract` — Use a contract template
+
+
+
+## `nargo execute`
+
+Executes a circuit to calculate its return value
+
+**Usage:** `nargo execute [OPTIONS] [WITNESS_NAME]`
+
+###### **Arguments:**
+
+* `<WITNESS_NAME>` — Write the execution witness to named file
+
+Defaults to the name of the package being executed.
+
+###### **Options:**
+
+* `-p`, `--prover-name <PROVER_NAME>` — The name of the toml file which contains the inputs for the prover
+
+  Default value: `Prover`
+* `--package <PACKAGE>` — The name of the package to execute
+* `--workspace` — Execute all packages in the workspace
+* `--expression-width <EXPRESSION_WIDTH>` — Specify the backend expression width that should be targeted
+* `--bounded-codegen` — Generate ACIR with the target backend expression width. The default is to generate ACIR without a bound and split expressions after code generation. Activating this flag can sometimes provide optimizations for certain programs
+
+  Default value: `false`
+* `--force` — Force a full recompilation
+* `--print-acir` — Display the ACIR for compiled circuit
+* `--deny-warnings` — Treat all warnings as errors
+* `--silence-warnings` — Suppress warnings
+* `--debug-comptime-in-file <DEBUG_COMPTIME_IN_FILE>` — Enable printing results of comptime evaluation: provide a path suffix for the module to debug, e.g. "package_name/src/main.nr"
+* `--skip-underconstrained-check` — Flag to turn off the compiler check for under constrained values. Warning: This can improve compilation speed but can also lead to correctness errors. This check should always be run on production code
+* `--oracle-resolver <ORACLE_RESOLVER>` — JSON RPC url to solve oracle calls
+
+
+
+## `nargo debug`
+
+Executes a circuit in debug mode
+
+**Usage:** `nargo debug [OPTIONS] [WITNESS_NAME]`
+
+###### **Arguments:**
+
+* `<WITNESS_NAME>` — Write the execution witness to named file
+
+###### **Options:**
+
+* `-p`, `--prover-name <PROVER_NAME>` — The name of the toml file which contains the inputs for the prover
+
+  Default value: `Prover`
+* `--package <PACKAGE>` — The name of the package to execute
+* `--expression-width <EXPRESSION_WIDTH>` — Specify the backend expression width that should be targeted
+* `--bounded-codegen` — Generate ACIR with the target backend expression width. The default is to generate ACIR without a bound and split expressions after code generation. Activating this flag can sometimes provide optimizations for certain programs
+
+  Default value: `false`
+* `--force` — Force a full recompilation
+* `--print-acir` — Display the ACIR for compiled circuit
+* `--deny-warnings` — Treat all warnings as errors
+* `--silence-warnings` — Suppress warnings
+* `--debug-comptime-in-file <DEBUG_COMPTIME_IN_FILE>` — Enable printing results of comptime evaluation: provide a path suffix for the module to debug, e.g. "package_name/src/main.nr"
+* `--skip-underconstrained-check` — Flag to turn off the compiler check for under constrained values. Warning: This can improve compilation speed but can also lead to correctness errors. This check should always be run on production code
+* `--acir-mode` — Force ACIR output (disabling instrumentation)
+* `--skip-instrumentation <SKIP_INSTRUMENTATION>` — Disable vars debug instrumentation (enabled by default)
+
+  Possible values: `true`, `false`
+
+
+
+
+## `nargo test`
+
+Run the tests for this program
+
+**Usage:** `nargo test [OPTIONS] [TEST_NAME]`
+
+###### **Arguments:**
+
+* `<TEST_NAME>` — If given, only tests with names containing this string will be run
+
+###### **Options:**
+
+* `--show-output` — Display output of `println` statements
+* `--exact` — Only run tests that match exactly
+* `--package <PACKAGE>` — The name of the package to test
+* `--workspace` — Test all packages in the workspace
+* `--expression-width <EXPRESSION_WIDTH>` — Specify the backend expression width that should be targeted
+* `--bounded-codegen` — Generate ACIR with the target backend expression width. The default is to generate ACIR without a bound and split expressions after code generation. Activating this flag can sometimes provide optimizations for certain programs
+
+  Default value: `false`
+* `--force` — Force a full recompilation
+* `--print-acir` — Display the ACIR for compiled circuit
+* `--deny-warnings` — Treat all warnings as errors
+* `--silence-warnings` — Suppress warnings
+* `--debug-comptime-in-file <DEBUG_COMPTIME_IN_FILE>` — Enable printing results of comptime evaluation: provide a path suffix for the module to debug, e.g. "package_name/src/main.nr"
+* `--skip-underconstrained-check` — Flag to turn off the compiler check for under constrained values. Warning: This can improve compilation speed but can also lead to correctness errors. This check should always be run on production code
+* `--oracle-resolver <ORACLE_RESOLVER>` — JSON RPC url to solve oracle calls
+
+
+
+## `nargo info`
+
+Provides detailed information on each of a program's function (represented by a single circuit)
+
+Current information provided per circuit: 1. The number of ACIR opcodes 2. Counts the final number gates in the circuit used by a backend
+
+**Usage:** `nargo info [OPTIONS]`
+
+###### **Options:**
+
+* `--package <PACKAGE>` — The name of the package to detail
+* `--workspace` — Detail all packages in the workspace
+* `--expression-width <EXPRESSION_WIDTH>` — Specify the backend expression width that should be targeted
+* `--bounded-codegen` — Generate ACIR with the target backend expression width. The default is to generate ACIR without a bound and split expressions after code generation. Activating this flag can sometimes provide optimizations for certain programs
+
+  Default value: `false`
+* `--force` — Force a full recompilation
+* `--print-acir` — Display the ACIR for compiled circuit
+* `--deny-warnings` — Treat all warnings as errors
+* `--silence-warnings` — Suppress warnings
+* `--debug-comptime-in-file <DEBUG_COMPTIME_IN_FILE>` — Enable printing results of comptime evaluation: provide a path suffix for the module to debug, e.g. "package_name/src/main.nr"
+* `--skip-underconstrained-check` — Flag to turn off the compiler check for under constrained values. Warning: This can improve compilation speed but can also lead to correctness errors. This check should always be run on production code
+
+
+
+## `nargo lsp`
+
+Starts the Noir LSP server
+
+Starts an LSP server which allows IDEs such as VS Code to display diagnostics in Noir source.
+
+VS Code Noir Language Support: https://marketplace.visualstudio.com/items?itemName=noir-lang.vscode-noir
+
+**Usage:** `nargo lsp`
+
+
+
+<hr/>
+
+<small><i>
+    This document was generated automatically by
+    <a href="https://crates.io/crates/clap-markdown"><code>clap-markdown</code></a>.
+</i></small>
+
diff --git a/docs/versioned_docs/version-v0.35.0/reference/noir_codegen.md b/docs/versioned_docs/version-v0.35.0/reference/noir_codegen.md
new file mode 100644
index 00000000000..db8f07dc22e
--- /dev/null
+++ b/docs/versioned_docs/version-v0.35.0/reference/noir_codegen.md
@@ -0,0 +1,114 @@
+---
+title: Noir Codegen for TypeScript
+description: Learn how to use Noir codegen to generate TypeScript bindings 
+keywords: [Nargo, Noir, compile, TypeScript]
+sidebar_position: 3
+---
+
+When using TypeScript, it is extra work to interpret Noir program outputs in a type-safe way. Third party libraries may exist for popular Noir programs, but they are either hard to find or unmaintained.
+
+Now you can generate TypeScript bindings for your Noir programs in two steps: 
+1. Exporting Noir functions using `nargo export`
+2. Using the TypeScript module `noir_codegen` to generate TypeScript binding
+
+**Note:** you can only export functions from a Noir *library* (not binary or contract program types).
+
+## Installation
+
+### Your TypeScript project
+
+If you don't already have a TypeScript project you can add the module with `yarn` (or `npm`), then initialize it:
+
+```bash
+yarn add typescript -D
+npx tsc --init
+```
+
+### Add TypeScript module - `noir_codegen`
+
+The following command will add the module to your project's devDependencies:
+
+```bash
+yarn add @noir-lang/noir_codegen -D
+```
+
+### Nargo library
+Make sure you have Nargo, v0.25.0 or greater, installed. If you don't, follow the [installation guide](../getting_started/installation/index.md). 
+
+If you're in a new project, make a `circuits` folder and create a new Noir library:
+
+```bash
+mkdir circuits && cd circuits
+nargo new --lib myNoirLib
+```
+
+## Usage
+
+### Export ABI of specified functions
+
+First go to the `.nr` files in your Noir library, and add the `#[export]` macro to each function that you want to use in TypeScript.
+
+```rust
+#[export]
+fn your_function(...
+```
+
+From your Noir library (where `Nargo.toml` is), run the following command:
+
+```bash
+nargo export
+```
+
+You will now have an `export` directory with a .json file per exported function.
+
+You can also specify the directory of Noir programs using `--program-dir`, for example:
+
+```bash
+nargo export --program-dir=./circuits/myNoirLib
+```
+
+### Generate TypeScript bindings from exported functions
+
+To use the `noir-codegen` package we added to the TypeScript project:
+
+```bash
+yarn noir-codegen ./export/your_function.json
+```
+
+This creates an `exports` directory with an `index.ts` file containing all exported functions.
+
+**Note:** adding `--out-dir` allows you to specify an output dir for your TypeScript bindings to go. Eg:
+
+```bash
+yarn noir-codegen ./export/*.json --out-dir ./path/to/output/dir
+```
+
+## Example .nr function to .ts output
+
+Consider a Noir library with this function:
+
+```rust
+#[export]
+fn not_equal(x: Field, y: Field) -> bool {
+    x != y
+}
+```
+
+After the export and codegen steps, you should have an `index.ts` like:
+
+```typescript
+export type Field = string;
+
+
+export const is_equal_circuit: CompiledCircuit = 
+{"abi":{"parameters":[{"name":"x","type":{"kind":"field"},"visibility":"private"},{"name":"y","type":{"kind":"field"},"visibility":"private"}],"return_type":{"abi_type":{"kind":"boolean"},"visibility":"private"}},"bytecode":"H4sIAAAAAAAA/7WUMQ7DIAxFQ0Krrr2JjSGYLVcpKrn/CaqqDQN12WK+hPBgmWd/wEyHbF1SS923uhOs3pfoChI+wKXMAXzIKyNj4PB0TFTYc0w5RUjoqeAeEu1wqK0F54RGkWvW44LPzExnlkbMEs4JNZmN8PxS42uHv82T8a3Jeyn2Ks+VLPcO558HmyLMCDOXAXXtpPt4R/Rt9T36ss6dS9HGPx/eG17nGegKBQAA"};
+
+export async function is_equal(x: Field, y: Field, foreignCallHandler?: ForeignCallHandler): Promise<boolean> {
+  const program = new Noir(is_equal_circuit);
+  const args: InputMap = { x, y };
+  const { returnValue } = await program.execute(args, foreignCallHandler);
+  return returnValue as boolean;
+}
+```
+
+Now the `is_equal()` function and relevant types are readily available for use in TypeScript.
diff --git a/docs/versioned_docs/version-v0.35.0/tooling/debugger.md b/docs/versioned_docs/version-v0.35.0/tooling/debugger.md
new file mode 100644
index 00000000000..9b7565ba9ff
--- /dev/null
+++ b/docs/versioned_docs/version-v0.35.0/tooling/debugger.md
@@ -0,0 +1,26 @@
+---
+title: Debugger
+description: Learn about the Noir Debugger, in its REPL or VS Code versions.
+keywords: [Nargo, VSCode, Visual Studio Code, REPL, Debugger]
+sidebar_position: 2
+---
+
+# Noir Debugger
+
+There are currently two ways of debugging Noir programs:
+
+1. From VS Code, via the [vscode-noir](https://github.com/noir-lang/vscode-noir) extension. You can install it via the [Visual Studio Marketplace](https://marketplace.visualstudio.com/items?itemName=noir-lang.vscode-noir).
+2. Via the REPL debugger, which ships with Nargo.
+
+In order to use either version of the debugger, you will need to install recent enough versions of Noir, [Nargo](../getting_started/installation/index.md) and vscode-noir:
+
+- Noir & Nargo ≥0.28.0
+- Noir's VS Code extension ≥0.0.11
+
+:::info
+At the moment, the debugger supports debugging binary projects, but not contracts.
+:::
+
+We cover the VS Code Noir debugger more in depth in [its VS Code debugger how-to guide](../how_to/debugger/debugging_with_vs_code.md) and [the reference](../reference/debugger/debugger_vscode.md).
+
+The REPL debugger is discussed at length in [the REPL debugger how-to guide](../how_to/debugger/debugging_with_the_repl.md) and [the reference](../reference/debugger/debugger_repl.md).
diff --git a/docs/versioned_docs/version-v0.35.0/tooling/language_server.md b/docs/versioned_docs/version-v0.35.0/tooling/language_server.md
new file mode 100644
index 00000000000..81e0356ef8a
--- /dev/null
+++ b/docs/versioned_docs/version-v0.35.0/tooling/language_server.md
@@ -0,0 +1,43 @@
+---
+title: Language Server
+description: Learn about the Noir Language Server, how to install the components, and configuration that may be required.
+keywords: [Nargo, Language Server, LSP, VSCode, Visual Studio Code]
+sidebar_position: 0
+---
+
+This section helps you install and configure the Noir Language Server.
+
+The Language Server Protocol (LSP) has two components, the [Server](#language-server) and the [Client](#language-client). Below we describe each in the context of Noir.
+
+## Language Server
+
+The Server component is provided by the Nargo command line tool that you installed at the beginning of this guide.
+As long as Nargo is installed and you've used it to run other commands in this guide, it should be good to go!
+
+If you'd like to verify that the `nargo lsp` command is available, you can run `nargo --help` and look for `lsp` in the list of commands. If you see it, you're using a version of Noir with LSP support.
+
+## Language Client
+
+The Client component is usually an editor plugin that launches the Server. It communicates LSP messages between the editor and the Server. For example, when you save a file, the Client will alert the Server, so it can try to compile the project and report any errors.
+
+Currently, Noir provides a Language Client for Visual Studio Code via the [vscode-noir](https://github.com/noir-lang/vscode-noir) extension. You can install it via the [Visual Studio Marketplace](https://marketplace.visualstudio.com/items?itemName=noir-lang.vscode-noir).
+
+> **Note:** Noir's Language Server Protocol support currently assumes users' VSCode workspace root to be the same as users' Noir project root (i.e. where Nargo.toml lies).
+>
+> If LSP features seem to be missing / malfunctioning, make sure you are opening your Noir project directly (instead of as a sub-folder) in your VSCode instance.
+
+When your language server is running correctly and the VSCode plugin is installed, you should see handy codelens buttons for compilation, measuring circuit size, execution, and tests:
+
+![Compile and Execute](@site/static/img/codelens_compile_execute.png)
+![Run test](@site/static/img/codelens_run_test.png)
+
+You should also see your tests in the `testing` panel:
+
+![Testing panel](@site/static/img/codelens_testing_panel.png)
+
+### Configuration
+
+- **Noir: Enable LSP** - If checked, the extension will launch the Language Server via `nargo lsp` and communicate with it.
+- **Noir: Nargo Flags** - Additional flags may be specified if you require them to be added when the extension calls `nargo lsp`.
+- **Noir: Nargo Path** - An absolute path to a Nargo binary with the `lsp` command. This may be useful if Nargo is not within the `PATH` of your editor.
+- **Noir > Trace: Server** - Setting this to `"messages"` or `"verbose"` will log LSP messages between the Client and Server. Useful for debugging.
diff --git a/docs/versioned_docs/version-v0.35.0/tooling/testing.md b/docs/versioned_docs/version-v0.35.0/tooling/testing.md
new file mode 100644
index 00000000000..866677da567
--- /dev/null
+++ b/docs/versioned_docs/version-v0.35.0/tooling/testing.md
@@ -0,0 +1,79 @@
+---
+title: Testing in Noir
+description: Learn how to use Nargo to test your Noir program in a quick and easy way
+keywords: [Nargo, testing, Noir, compile, test]
+sidebar_position: 1
+---
+
+You can test your Noir programs using Noir circuits.
+
+Nargo will automatically compile and run any functions which have the decorator `#[test]` on them if
+you run `nargo test`.
+
+For example if you have a program like:
+
+```rust
+fn add(x: u64, y: u64) -> u64 {
+    x + y
+}
+#[test]
+fn test_add() {
+    assert(add(2,2) == 4);
+    assert(add(0,1) == 1);
+    assert(add(1,0) == 1);
+}
+```
+
+Running `nargo test` will test that the `test_add` function can be executed while satisfying all
+the constraints which allows you to test that add returns the expected values. Test functions can't
+have any arguments currently.
+
+### Test fail
+
+You can write tests that are expected to fail by using the decorator `#[test(should_fail)]`. For example:
+
+```rust
+fn add(x: u64, y: u64) -> u64 {
+    x + y
+}
+#[test(should_fail)]
+fn test_add() {
+    assert(add(2,2) == 5);
+}
+```
+
+You can be more specific and make it fail with a specific reason by using `should_fail_with = "<the reason for failure>"`:
+
+```rust
+fn main(african_swallow_avg_speed : Field) {
+    assert(african_swallow_avg_speed == 65, "What is the airspeed velocity of an unladen swallow");
+}
+
+#[test]
+fn test_king_arthur() {
+    main(65);
+}
+
+#[test(should_fail_with = "What is the airspeed velocity of an unladen swallow")]
+fn test_bridgekeeper() {
+    main(32);
+}
+```
+
+The string given to `should_fail_with` doesn't need to exactly match the failure reason, it just needs to be a substring of it:
+
+```rust
+fn main(african_swallow_avg_speed : Field) {
+    assert(african_swallow_avg_speed == 65, "What is the airspeed velocity of an unladen swallow");
+}
+
+#[test]
+fn test_king_arthur() {
+    main(65);
+}
+
+#[test(should_fail_with = "airspeed velocity")]
+fn test_bridgekeeper() {
+    main(32);
+}
+```
\ No newline at end of file
diff --git a/docs/versioned_docs/version-v0.35.0/tutorials/noirjs_app.md b/docs/versioned_docs/version-v0.35.0/tutorials/noirjs_app.md
new file mode 100644
index 00000000000..eac28168445
--- /dev/null
+++ b/docs/versioned_docs/version-v0.35.0/tutorials/noirjs_app.md
@@ -0,0 +1,362 @@
+---
+title: Building a web app with NoirJS
+description: Learn how to setup a new app that uses Noir to generate and verify zero-knowledge SNARK proofs in a typescript or javascript environment.
+keywords: [how to, guide, javascript, typescript, noir, barretenberg, zero-knowledge, proofs, app]
+sidebar_position: 0
+pagination_next: noir/concepts/data_types/index
+---
+
+NoirJS is a set of packages meant to work both in a browser and a server environment. In this tutorial, we will build a simple web app using them. From here, you should get an idea on how to proceed with your own Noir projects!
+
+You can find the complete app code for this guide [here](https://github.com/noir-lang/tiny-noirjs-app).
+
+## Setup
+
+:::note
+
+Feel free to use whatever versions, just keep in mind that Nargo and the NoirJS packages are meant to be in sync. For example, Nargo 0.31.x matches `noir_js@0.31.x`, etc.
+
+In this guide, we will be pinned to 0.31.0.
+
+:::
+
+Before we start, we want to make sure we have Node, Nargo and the Barretenberg proving system (`bb`) installed.
+
+We start by opening a terminal and executing `node --version`. If we don't get an output like `v20.10.0`, that means node is not installed. Let's do that by following the handy [nvm guide](https://github.com/nvm-sh/nvm?tab=readme-ov-file#install--update-script).
+
+As for `Nargo`, we can follow the [Nargo guide](../getting_started/installation/index.md) to install it. If you're lazy, just paste this on a terminal and run `noirup`:
+
+```sh
+curl -L https://raw.githubusercontent.com/noir-lang/noirup/main/install | bash
+```
+
+Follow the instructions on [this page](https://github.com/AztecProtocol/aztec-packages/tree/master/barretenberg/cpp/src/barretenberg/bb#installation) to install `bb`. 
+Version 0.41.0 is compatible with `nargo` version 0.31.0, which you can install with `bbup -v 0.41.0` once `bbup` is installed.
+
+Easy enough. Onwards!
+
+## Our project
+
+ZK is a powerful technology. An app that doesn't reveal one of the inputs to _anyone_ is almost unbelievable, yet Noir makes it as easy as a single line of code.
+
+In fact, it's so simple that it comes nicely packaged in `nargo`. Let's do that!
+
+### Nargo
+
+Run:
+
+```bash
+nargo new circuit
+```
+
+And... That's about it. Your program is ready to be compiled and run.
+
+To compile, let's `cd` into the `circuit` folder to enter our project, and call:
+
+```bash
+nargo compile
+```
+
+This compiles our circuit into `json` format and add it to a new `target` folder.
+
+:::info
+
+At this point in the tutorial, your folder structure should look like this:
+
+```tree
+.
+└── circuit <---- our working directory
+    ├── Nargo.toml
+    ├── src
+    │   └── main.nr
+    └── target
+        └── circuit.json
+```
+
+:::
+
+### Node and Vite
+
+If you want to explore Nargo, feel free to go on a side-quest now and follow the steps in the
+[getting started](../getting_started/hello_noir/index.md) guide. However, we want our app to run on the browser, so we need Vite.
+
+Vite is a powerful tool to generate static websites. While it provides all kinds of features, let's just go barebones with some good old vanilla JS.
+
+To do this this, go back to the previous folder (`cd ..`) and create a new vite project by running `npm create vite` and choosing "Vanilla" and "Javascript".
+
+A wild `vite-project` directory should now appear in your root folder! Let's not waste any time and dive right in:
+
+```bash
+cd vite-project
+```
+
+### Setting Up Vite and Configuring the Project
+
+Before we proceed with any coding, let's get our environment tailored for Noir. We'll start by laying down the foundations with a `vite.config.js` file. This little piece of configuration is our secret sauce for making sure everything meshes well with the NoirJS libraries and other special setups we might need, like handling WebAssembly modules. Here’s how you get that going:
+
+#### Creating the vite.config.js
+
+In your freshly minted `vite-project` folder, create a new file named `vite.config.js` and open it in your code editor. Paste the following to set the stage:
+
+```javascript
+import { defineConfig } from 'vite';
+import copy from 'rollup-plugin-copy';
+import fs from 'fs';
+import path from 'path';
+
+const wasmContentTypePlugin = {
+  name: 'wasm-content-type-plugin',
+  configureServer(server) {
+    server.middlewares.use(async (req, res, next) => {
+      if (req.url.endsWith('.wasm')) {
+        res.setHeader('Content-Type', 'application/wasm');
+        const newPath = req.url.replace('deps', 'dist');
+        const targetPath = path.join(__dirname, newPath);
+        const wasmContent = fs.readFileSync(targetPath);
+        return res.end(wasmContent);
+      }
+      next();
+    });
+  },
+};
+
+export default defineConfig(({ command }) => {
+  if (command === 'serve') {
+    return {
+      build: {
+        target: 'esnext',
+        rollupOptions: {
+          external: ['@aztec/bb.js']
+        }
+      },
+      optimizeDeps: {
+        esbuildOptions: {
+          target: 'esnext'
+        }
+      },
+      plugins: [
+        copy({
+          targets: [{ src: 'node_modules/**/*.wasm', dest: 'node_modules/.vite/dist' }],
+          copySync: true,
+          hook: 'buildStart',
+        }),
+        command === 'serve' ? wasmContentTypePlugin : [],
+      ],
+    };
+  }
+
+  return {};
+});
+```
+
+#### Install Dependencies
+
+Now that our stage is set, install the necessary NoirJS packages along with our other dependencies:
+
+```bash
+npm install && npm install @noir-lang/backend_barretenberg@0.31.0 @noir-lang/noir_js@0.31.0
+npm install rollup-plugin-copy --save-dev
+```
+
+:::info
+
+At this point in the tutorial, your folder structure should look like this:
+
+```tree
+.
+└── circuit
+    └── ...etc...
+└── vite-project <---- our working directory
+    └── ...etc...
+```
+
+:::
+
+#### Some cleanup
+
+`npx create vite` is amazing but it creates a bunch of files we don't really need for our simple example. Actually, let's just delete everything except for `vite.config.js`, `index.html`, `main.js` and `package.json`. I feel lighter already.
+
+![my heart is ready for you, noir.js](@site/static/img/memes/titanic.jpeg)
+
+## HTML
+
+Our app won't run like this, of course. We need some working HTML, at least. Let's open our broken-hearted `index.html` and replace everything with this code snippet:
+
+```html
+<!DOCTYPE html>
+<head>
+  <style>
+    .outer {
+        display: flex;
+        justify-content: space-between;
+        width: 100%;
+    }
+    .inner {
+        width: 45%;
+        border: 1px solid black;
+        padding: 10px;
+        word-wrap: break-word;
+    }
+  </style>
+</head>
+<body>
+  <script type="module" src="/main.js"></script>
+  <h1>Noir app</h1>
+  <div class="input-area">
+    <input id="guessInput" type="number" placeholder="Enter your guess" />
+    <button id="submitGuess">Submit Guess</button>
+  </div>
+  <div class="outer">
+    <div id="logs" class="inner"><h2>Logs</h2></div>
+    <div id="results" class="inner"><h2>Proof</h2></div>
+  </div>
+</body>
+</html>
+```
+
+It _could_ be a beautiful UI... Depending on which universe you live in.
+
+## Some good old vanilla Javascript
+
+Our love for Noir needs undivided attention, so let's just open `main.js` and delete everything (this is where the romantic scenery becomes a bit creepy).
+
+Start by pasting in this boilerplate code:
+
+```js
+function display(container, msg) {
+  const c = document.getElementById(container);
+  const p = document.createElement('p');
+  p.textContent = msg;
+  c.appendChild(p);
+}
+
+document.getElementById('submitGuess').addEventListener('click', async () => {
+  try {
+    // here's where love happens
+  } catch (err) {
+    display('logs', 'Oh 💔 Wrong guess');
+  }
+});
+```
+
+The display function doesn't do much. We're simply manipulating our website to see stuff happening. For example, if the proof fails, it will simply log a broken heart 😢
+
+:::info
+
+At this point in the tutorial, your folder structure should look like this:
+
+```tree
+.
+└── circuit
+    └── ...same as above
+└── vite-project
+    ├── vite.config.js
+    ├── main.js
+    ├── package.json
+    └── index.html
+```
+
+You'll see other files and folders showing up (like `package-lock.json`, `node_modules`) but you shouldn't have to care about those.
+
+:::
+
+## Some NoirJS
+
+We're starting with the good stuff now. If you've compiled the circuit as described above, you should have a `json` file we want to import at the very top of our `main.js` file:
+
+```ts
+import circuit from '../circuit/target/circuit.json';
+```
+
+[Noir is backend-agnostic](../index.mdx#whats-new-about-noir). We write Noir, but we also need a proving backend. That's why we need to import and instantiate the two dependencies we installed above: `BarretenbergBackend` and `Noir`. Let's import them right below:
+
+```js
+import { BarretenbergBackend, BarretenbergVerifier as Verifier } from '@noir-lang/backend_barretenberg';
+import { Noir } from '@noir-lang/noir_js';
+```
+
+And instantiate them inside our try-catch block:
+
+```ts
+// try {
+const backend = new BarretenbergBackend(circuit);
+const noir = new Noir(circuit);
+// }
+```
+
+:::note
+
+For the remainder of the tutorial, everything will be happening inside the `try` block
+
+:::
+
+## Our app
+
+Now for the app itself. We're capturing whatever is in the input when people press the submit button. Just add this:
+
+```js
+const x = parseInt(document.getElementById('guessInput').value);
+const input = { x, y: 2 };
+```
+
+Now we're ready to prove stuff! Let's feed some inputs to our circuit and calculate the proof:
+
+```js
+await setup(); // let's squeeze our wasm inits here
+
+display('logs', 'Generating proof... ⌛');
+const { witness } = await noir.execute(input);
+const proof = await backend.generateProof(witness);
+display('logs', 'Generating proof... ✅');
+display('results', proof.proof);
+```
+
+You're probably eager to see stuff happening, so go and run your app now!
+
+From your terminal, run `npm run dev`. If it doesn't open a browser for you, just visit `localhost:5173`. You should now see the worst UI ever, with an ugly input.
+
+![Getting Started 0](@site/static/img/noir_getting_started_1.png)
+
+Now, our circuit says `fn main(x: Field, y: pub Field)`. This means only the `y` value is public, and it's hardcoded above: `input = { x, y: 2 }`. In other words, you won't need to send your secret`x` to the verifier!
+
+By inputting any number other than 2 in the input box and clicking "submit", you should get a valid proof. Otherwise the proof won't even generate correctly. By the way, if you're human, you shouldn't be able to understand anything on the "proof" box. That's OK. We like you, human ❤️.
+
+## Verifying
+
+Time to celebrate, yes! But we shouldn't trust machines so blindly. Let's add these lines to see our proof being verified:
+
+```js
+display('logs', 'Verifying proof... ⌛');
+const isValid = await backend.verifyProof(proof);
+
+// or to cache and use the verification key:
+// const verificationKey = await backend.getVerificationKey();
+// const verifier = new Verifier();
+// const isValid = await verifier.verifyProof(proof, verificationKey);
+
+if (isValid) display('logs', 'Verifying proof... ✅');
+```
+
+You have successfully generated a client-side Noir web app!
+
+![coded app without math knowledge](@site/static/img/memes/flextape.jpeg)
+
+## Further Reading
+
+You can see how noirjs is used in a full stack Next.js hardhat application in the [noir-starter repo here](https://github.com/noir-lang/noir-starter/tree/main/vite-hardhat). The example shows how to calculate a proof in the browser and verify it with a deployed Solidity verifier contract from noirjs.
+
+You should also check out the more advanced examples in the [noir-examples repo](https://github.com/noir-lang/noir-examples), where you'll find reference usage for some cool apps.
+
+## UltraHonk Backend
+
+Barretenberg has recently exposed a new UltraHonk backend. We can use UltraHonk in NoirJS after version 0.33.0. Everything will be the same as the tutorial above, except that the class we need to import will change:
+```js
+import { UltraHonkBackend, UltraHonkVerifier as Verifier } from '@noir-lang/backend_barretenberg';
+```
+The backend will then be instantiated as such:
+```js
+const backend = new UltraHonkBackend(circuit);
+```
+Then all the commands to prove and verify your circuit will be same.
+
+The only feature currently unsupported with UltraHonk are [recursive proofs](../explainers/explainer-recursion.md).
\ No newline at end of file
diff --git a/docs/versioned_docs/version-v0.36.0/explainers/cspell.json b/docs/versioned_docs/version-v0.36.0/explainers/cspell.json
new file mode 100644
index 00000000000..c60b0a597b1
--- /dev/null
+++ b/docs/versioned_docs/version-v0.36.0/explainers/cspell.json
@@ -0,0 +1,5 @@
+{
+    "words": [
+        "Cryptdoku"
+    ]
+}
diff --git a/docs/versioned_docs/version-v0.36.0/explainers/explainer-oracle.md b/docs/versioned_docs/version-v0.36.0/explainers/explainer-oracle.md
new file mode 100644
index 00000000000..821e1f95c04
--- /dev/null
+++ b/docs/versioned_docs/version-v0.36.0/explainers/explainer-oracle.md
@@ -0,0 +1,57 @@
+---
+title: Oracles
+description: This guide provides an in-depth understanding of how Oracles work in Noir programming. Learn how to use outside calculations in your programs, constrain oracles, and understand their uses and limitations.
+keywords:
+  - Noir Programming
+  - Oracles
+  - JSON-RPC
+  - Foreign Call Handlers
+  - Constrained Functions
+  - Blockchain Programming
+sidebar_position: 1
+---
+
+If you've seen "The Matrix" you may recall "The Oracle" as Gloria Foster smoking cigarettes and baking cookies. While she appears to "know things", she is actually providing a calculation of a pre-determined future. Noir Oracles are similar, in a way. They don't calculate the future (yet), but they allow you to use outside calculations in your programs.
+
+![matrix oracle prediction](@site/static/img/memes/matrix_oracle.jpeg)
+
+A Noir program is usually self-contained. You can pass certain inputs to it, and it will generate a deterministic output for those inputs. But what if you wanted to defer some calculation to an outside process or source?
+
+Oracles are functions that provide this feature.
+
+## Use cases
+
+An example usage for Oracles is proving something on-chain. For example, proving that the ETH-USDC quote was below a certain target at a certain block time. Or even making more complex proofs like proving the ownership of an NFT as an anonymous login method.
+
+Another interesting use case is to defer expensive calculations to be made outside of the Noir program, and then constraining the result; similar to the use of [unconstrained functions](../noir/concepts//unconstrained.md).
+
+In short, anything that can be constrained in a Noir program but needs to be fetched from an external source is a great candidate to be used in oracles.
+
+## Constraining oracles
+
+Just like in The Matrix, Oracles are powerful. But with great power, comes great responsibility. Just because you're using them in a Noir program doesn't mean they're true. Noir has no superpowers. If you want to prove that Portugal won the Euro Cup 2016, you're still relying on potentially untrusted information.
+
+To give a concrete example, Alice wants to login to the [NounsDAO](https://nouns.wtf/) forum with her username "noir_nouner" by proving she owns a noun without revealing her ethereum address. Her Noir program could have an oracle call like this:
+
+```rust
+#[oracle(getNoun)]
+unconstrained fn get_noun(address: Field) -> Field
+```
+
+This oracle could naively resolve with the number of Nouns she possesses. However, it is useless as a trusted source, as the oracle could resolve to anything Alice wants. In order to make this oracle call actually useful, Alice would need to constrain the response from the oracle, by proving her address and the noun count belongs to the state tree of the contract.
+
+In short, **Oracles don't prove anything. Your Noir program does.**
+
+:::danger
+
+If you don't constrain the return of your oracle, you could be clearly opening an attack vector on your Noir program. Make double-triple sure that the return of an oracle call is constrained!
+
+:::
+
+## How to use Oracles
+
+On CLI, Nargo resolves oracles by making JSON RPC calls, which means it would require an RPC node to be running.
+
+In JavaScript, NoirJS accepts and resolves arbitrary call handlers (that is, not limited to JSON) as long as they match the expected types the developer defines. Refer to [Foreign Call Handler](../reference/NoirJS/noir_js/type-aliases/ForeignCallHandler.md) to learn more about NoirJS's call handling.
+
+If you want to build using oracles, follow through to the [oracle guide](../how_to/how-to-oracles.md) for a simple example on how to do that.
diff --git a/docs/versioned_docs/version-v0.36.0/explainers/explainer-recursion.md b/docs/versioned_docs/version-v0.36.0/explainers/explainer-recursion.md
new file mode 100644
index 00000000000..df8529ef4e0
--- /dev/null
+++ b/docs/versioned_docs/version-v0.36.0/explainers/explainer-recursion.md
@@ -0,0 +1,176 @@
+---
+title: Recursive proofs
+description: Explore the concept of recursive proofs in Zero-Knowledge programming. Understand how recursion works in Noir, a language for writing smart contracts on the EVM blockchain. Learn through practical examples like Alice and Bob's guessing game, Charlie's recursive merkle tree, and Daniel's reusable components. Discover how to use recursive proofs to optimize computational resources and improve efficiency.
+
+keywords:
+  [
+    "Recursive Proofs",
+    "Zero-Knowledge Programming",
+    "Noir",
+    "EVM Blockchain",
+    "Smart Contracts",
+    "Recursion in Noir",
+    "Alice and Bob Guessing Game",
+    "Recursive Merkle Tree",
+    "Reusable Components",
+    "Optimizing Computational Resources",
+    "Improving Efficiency",
+    "Verification Key",
+    "Aggregation",
+    "Recursive zkSNARK schemes",
+    "PLONK",
+    "Proving and Verification Keys"
+  ]
+sidebar_position: 1
+pagination_next: how_to/how-to-recursion
+---
+
+In programming, we tend to think of recursion as something calling itself. A classic example would be the calculation of the factorial of a number:
+
+```js
+function factorial(n) {
+    if (n === 0 || n === 1) {
+        return 1;
+    } else {
+        return n * factorial(n - 1);
+    }
+}
+```
+
+In this case, while `n` is not `1`, this function will keep calling itself until it hits the base case, bubbling up the result on the call stack:
+
+```md
+        Is `n` 1?  <---------
+           /\               /
+          /  \         n = n -1 
+         /    \           /
+       Yes     No --------
+```
+
+In Zero-Knowledge, recursion has some similarities.
+
+It is not a Noir function calling itself, but a proof being used as an input to another circuit. In short, you verify one proof *inside* another proof, returning the proof that both proofs are valid.
+
+This means that, given enough computational resources, you can prove the correctness of any arbitrary number of proofs in a single proof. This could be useful to design state channels (for which a common example would be [Bitcoin's Lightning Network](https://en.wikipedia.org/wiki/Lightning_Network)), to save on gas costs by settling one proof on-chain, or simply to make business logic less dependent on a consensus mechanism.
+
+## Examples
+
+Let us look at some of these examples
+
+### Alice and Bob - Guessing game
+
+Alice and Bob are friends, and they like guessing games. They want to play a guessing game online, but for that, they need a trusted third-party that knows both of their secrets and finishes the game once someone wins.
+
+So, they use zero-knowledge proofs. Alice tries to guess Bob's number, and Bob will generate a ZK proof stating whether she succeeded or failed.
+
+This ZK proof can go on a smart contract, revealing the winner and even giving prizes. However, this means every turn needs to be verified on-chain. This incurs some cost and waiting time that may simply make the game too expensive or time-consuming to be worth it.
+
+As a solution, Alice proposes the following: "what if Bob generates his proof, and instead of sending it on-chain, I verify it *within* my own proof before playing my own turn?".
+
+She can then generate a proof that she verified his proof, and so on.
+
+```md
+      Did you fail?  <--------------------------
+           / \                                  /
+          /   \                             n = n -1 
+         /     \                              /
+       Yes      No                           /
+        |        |                          /
+        |        |                         /
+        |      You win                    /
+        |                                /
+        |                               /
+Generate proof of that                 /
+        +                             /
+    my own guess     ----------------
+```
+
+### Charlie - Recursive merkle tree
+
+Charlie is a concerned citizen, and wants to be sure his vote in an election is accounted for. He votes with a ZK proof, but he has no way of knowing that his ZK proof was included in the total vote count!
+
+If the vote collector puts all of the votes into a [Merkle tree](https://en.wikipedia.org/wiki/Merkle_tree), everyone can prove the verification of two proofs within one proof, as such:
+
+```md
+                    abcd
+           __________|______________
+          |                         |
+         ab                         cd 
+     _____|_____              ______|______
+    |           |            |             |              
+  alice        bob        charlie        daniel 
+```
+
+Doing this recursively allows us to arrive on a final proof `abcd` which if true, verifies the correctness of all the votes.
+
+### Daniel - Reusable components
+
+Daniel has a big circuit and a big headache. A part of his circuit is a setup phase that finishes with some assertions that need to be made. But that section alone takes most of the proving time, and is largely independent of the rest of the circuit.
+
+He might find it more efficient to generate a proof for that setup phase separately, and verify that proof recursively in the actual business logic section of his circuit. This will allow for parallelization of both proofs, which results in a considerable speedup.
+
+## What params do I need
+
+As you can see in the [recursion reference](noir/standard_library/recursion.mdx), a simple recursive proof requires:
+
+- The proof to verify
+- The Verification Key of the circuit that generated the proof
+- A hash of this verification key, as it's needed for some backends
+- The public inputs for the proof
+
+:::info
+
+Recursive zkSNARK schemes do not necessarily "verify a proof" in the sense that you expect a true or false to be spit out by the verifier. Rather an aggregation object is built over the public inputs.
+
+So, taking the example of Alice and Bob and their guessing game:
+
+- Alice makes her guess. Her proof is *not* recursive: it doesn't verify any proof within it! It's just a standard `assert(x != y)` circuit
+- Bob verifies Alice's proof and makes his own guess. In this circuit, he doesn't exactly *prove* the verification of Alice's proof. Instead, he *aggregates* his proof to Alice's proof. The actual verification is done when the full proof is verified, for example when using `nargo verify` or through the verifier smart contract.
+
+We can imagine recursive proofs a [relay race](https://en.wikipedia.org/wiki/Relay_race). The first runner doesn't have to receive the baton from anyone else, as he/she already starts with it. But when his/her turn is over, the next runner needs to receive it, run a bit more, and pass it along. Even though every runner could theoretically verify the baton mid-run (why not? 🏃🔍), only at the end of the race does the referee verify that the whole race is valid.
+
+:::
+
+## Some architecture
+
+As with everything in computer science, there's no one-size-fits all. But there are some patterns that could help understanding and implementing them. To give three examples:
+
+### Adding some logic to a proof verification
+
+This would be an approach for something like our guessing game, where proofs are sent back and forth and are verified by each opponent. This circuit would be divided in two sections:
+
+- A `recursive verification` section, which would be just the call to `std::verify_proof`, and that would be skipped on the first move (since there's no proof to verify)
+- A `guessing` section, which is basically the logic part where the actual guessing happens
+
+In such a situation, and assuming Alice is first, she would skip the first part and try to guess Bob's number. Bob would then verify her proof on the first section of his run, and try to guess Alice's number on the second part, and so on.
+
+### Aggregating proofs
+
+In some one-way interaction situations, recursion would allow for aggregation of simple proofs that don't need to be immediately verified on-chain or elsewhere.
+
+To give a practical example, a barman wouldn't need to verify a "proof-of-age" on-chain every time he serves alcohol to a customer. Instead, the architecture would comprise two circuits:
+
+- A `main`, non-recursive circuit with some logic
+- A `recursive` circuit meant to verify two proofs in one proof
+
+The customer's proofs would be intermediate, and made on their phones, and the barman could just verify them locally. He would then aggregate them into a final proof sent on-chain (or elsewhere) at the end of the day.
+
+### Recursively verifying different circuits
+
+Nothing prevents you from verifying different circuits in a recursive proof, for example:
+
+- A `circuit1` circuit
+- A `circuit2` circuit
+- A `recursive` circuit
+
+In this example, a regulator could verify that taxes were paid for a specific purchase by aggregating both a `payer` circuit (proving that a purchase was made and taxes were paid), and a `receipt` circuit (proving that the payment was received)
+
+## How fast is it
+
+At the time of writing, verifying recursive proofs is surprisingly fast. This is because most of the time is spent on generating the verification key that will be used to generate the next proof. So you are able to cache the verification key and reuse it later.
+
+Currently, Noir JS packages don't expose the functionality of loading proving and verification keys, but that feature exists in the underlying `bb.js` package.
+
+## How can I try it
+
+Learn more about using recursion in Nargo and NoirJS in the [how-to guide](../how_to/how-to-recursion.md) and see a full example in [noir-examples](https://github.com/noir-lang/noir-examples).
diff --git a/docs/versioned_docs/version-v0.36.0/explainers/explainer-writing-noir.md b/docs/versioned_docs/version-v0.36.0/explainers/explainer-writing-noir.md
new file mode 100644
index 00000000000..3ef6e014a2f
--- /dev/null
+++ b/docs/versioned_docs/version-v0.36.0/explainers/explainer-writing-noir.md
@@ -0,0 +1,177 @@
+---
+title: Writing Performant Noir
+description: Understand new considerations when writing Noir
+keywords: [Noir, programming, rust]
+tags: [Optimization]
+sidebar_position: 0
+---
+
+
+This article intends to set you up with key concepts essential for writing more viable applications that use zero knowledge proofs, namely around efficient circuits.
+
+## Context - 'Efficient' is subjective
+
+When writing a web application for a performant computer with high-speed internet connection, writing efficient code sometimes is seen as an afterthought only if needed. Large multiplications running at the innermost of nested loops may not even be on a dev's radar.
+When writing firmware for a battery-powered microcontroller, you think of cpu cycles as rations to keep within a product's power budget.
+
+> Code is written to create applications that perform specific tasks within specific constraints
+
+And these constraints differ depending on where the compiled code is execute.
+
+### The Ethereum Virtual Machine (EVM)
+
+In scenarios where extremely low gas costs are required for an Ethereum application to be viable/competitive, Ethereum smart contract developers get into what is colloquially known as: "*gas golfing*". Finding the lowest execution cost of their compiled code (EVM bytecode) to achieve a specific task.
+
+The equivalent optimization task when writing zk circuits is affectionately referred to as "*gate golfing*", finding the lowest gate representation of the compiled Noir code.
+
+### Coding for circuits - a paradigm shift
+
+In zero knowledge cryptography, code is compiled to "circuits" consisting of arithmetic gates, and gate count is the significant cost. Depending on the proving system this is linearly proportionate to proving time, and so from a product point this should be kept as low as possible.
+
+Whilst writing efficient code for web apps and Solidity has a few key differences, writing efficient circuits have a different set of considerations. It is a bit of a paradigm shift, like writing code for GPUs for the first time...
+
+For example, drawing a circle at (0, 0) of radius `r`:
+- For a single CPU thread,
+```
+for theta in 0..2*pi {
+  let x = r * cos(theta);
+  let y = r * sin(theta);
+  draw(x, y);
+} // note: would do 0 - pi/2 and draw +ve/-ve x and y.
+```
+
+- For GPUs (simultaneous parallel calls with x, y across image),
+```
+if (x^2 + y^2 = r^2) {
+  draw(x, y);
+}
+```
+
+([Related](https://www.youtube.com/watch?v=-P28LKWTzrI))
+
+Whilst this CPU -> GPU does not translate to circuits exactly, it is intended to exemplify the difference in intuition when coding for different machine capabilities/constraints.
+
+### Context Takeaway
+
+For those coming from a primarily web app background, this article will explain what you need to consider when writing circuits. Furthermore, for those experienced writing efficient machine code, prepare to shift what you think is efficient 😬
+
+## Translating from Rust
+
+For some applications using Noir, existing code might be a convenient starting point to then proceed to optimize the gate count of.
+
+:::note
+Many valuable functions and algorithms have been written in more established languages (C/C++), and converted to modern ones (like Rust).
+:::
+
+Fortunately for Noir developers, when needing a particular function a Rust implementation can be readily compiled into Noir with some key changes. While the compiler does a decent amount of optimizations, it won't be able to change code that has been optimized for clock-cycles into code optimized for arithmetic gates.
+
+A few things to do when converting Rust code to Noir:
+- `println!` is not a macro, use `println` function (same for `assert_eq`)
+- No early `return` in function. Use constrain via assertion instead
+- No passing by reference. Remove `&` operator to pass by value (copy)
+- No boolean operators (`&&`, `||`). Use bitwise operators (`&`, `|`) with boolean values
+- No type `usize`. Use types `u8`, `u32`, `u64`, ... 
+- `main` return must be public, `pub`
+- No `const`, use `global`
+- Noir's LSP is your friend, so error message should be informative enough to resolve syntax issues.
+
+## Writing efficient Noir for performant products
+
+The following points help refine our understanding over time.
+
+:::note
+A Noir program makes a statement that can be verified.
+:::
+
+It compiles to a structure that represents the calculation, and can assert results within the calculation at any stage (via the `constrain` keyword).
+
+A Noir program compiles to an Abstract Circuit Intermediate Representation which is:
+ - Conceptually a tree structure
+ - Leaves (inputs) are the `Field` type
+ - Nodes contain arithmetic operations to combine them (gates)
+ - The root is the final result (return value)
+
+:::tip
+The command `nargo info` shows the programs circuit size, and is useful to compare the value of changes made.
+You can dig deeper and use the `--print-acir` param to take a closer look at individual ACIR opcodes, and the proving backend to see its gate count (eg for barretenberg, `bb gates -b ./target/program.json`).
+:::
+
+### Use the `Field` type
+
+Since the native type of values in circuits are `Field`s, using them for variables in Noir means less gates converting them under the hood.
+Some things to be mindful of when using a Field type for a regular integer value:
+- A variable of type `Field` can be cast `as` an integer type (eg `u8`, `u64`)
+  - Note: this retains only the bits of the integer type. Eg a Field value of 260 as a `u8` becomes 4
+- For Field types arithmetic operations meaningfully overflow/underflow, yet for integer types they are checked according to their size
+- Comparisons and bitwise operations do not exist for `Field`s, cast to an appropriately sized integer type when you need to
+
+:::tip
+Where possible, use `Field` type for values. Using smaller value types, and bit-packing strategies, will result in MORE gates
+:::
+
+
+### Use Arithmetic over non-arithmetic operations
+
+Since circuits are made of arithmetic gates, the cost of arithmetic operations tends to be one gate. Whereas for procedural code, they represent several clock cycles.
+
+Inversely, non-arithmetic operators are achieved with multiple gates, vs 1 clock cycle for procedural code.
+
+| (cost\op)  | arithmetic<br>(`*`, `+`) | bit-wise ops<br>(eg `<`, `\|`, `>>`) |
+| - | - | - |
+| **cycles** | 10+ | 1 |
+| **gates**  | 1 | 10+ |
+
+Bit-wise operations (e.g. bit shifts `<<` and `>>`), albeit commonly used in general programming and especially for clock cycle optimizations, are on the contrary expensive in gates when performed within circuits.
+
+Translate away from bit shifts when writing constrained functions for the best performance.
+
+On the flip side, feel free to use bit shifts in unconstrained functions and tests if necessary, as they are executed outside of circuits and does not induce performance hits.
+
+### Use static over dynamic values
+
+Another general theme that manifests in different ways is that static reads are represented with less gates than dynamic ones.
+
+Reading from read-only memory (ROM) adds less gates than random-access memory (RAM), 2 vs ~3.25 due to the additional bounds checks. Arrays of fixed length (albeit used at a lower capacity), will generate less gates than dynamic storage.
+
+Related to this, if an index used to access an array is not known at compile time (ie unknown until run time), then ROM will be converted to RAM, expanding the gate count.
+
+:::tip
+Use arrays and indices that are known at compile time where possible.
+Using `assert_constant(i);` before an index, `i`, is used in an array will give a compile error if `i` is NOT known at compile time.
+:::
+
+### Leverage unconstrained execution
+
+Constrained verification can leverage unconstrained execution, this is especially useful for operations that are represented by many gates.
+Use an [unconstrained function](../noir/concepts/unconstrained.md) to perform gate-heavy calculations, then verify and constrain the result.
+
+Eg division generates more gates than multiplication, so calculating the quotient in an unconstrained function then constraining the product for the quotient and divisor (+ any remainder) equals the dividend will be more efficient.
+
+Use `  if is_unconstrained() { /`, to conditionally execute code if being called in an unconstrained vs constrained way.
+
+## Advanced
+
+Unless you're well into the depth of gate optimization, this advanced section can be ignored.
+
+### Combine arithmetic operations
+
+A Noir program can be honed further by combining arithmetic operators in a way that makes the most of each constraint of the backend proving system. This is in scenarios where the backend might not be doing this perfectly.
+
+Eg Barretenberg backend (current default for Noir) is a width-4 PLONKish constraint system
+$ w_1*w_2*q_m + w_1*q_1 + w_2*q_2 + w_3*q_3 + w_4*q_4 + q_c = 0 $
+
+Here we see there is one occurrence of witness 1 and 2 ($w_1$, $w_2$) being multiplied together, with addition to witnesses 1-4 ($w_1$ .. $w_4$) multiplied by 4 corresponding circuit constants ($q_1$ .. $q_4$) (plus a final circuit constant, $q_c$).
+
+Use `nargo info --print-acir`, to inspect the ACIR opcodes (and the proving system for gates), and it may present opportunities to amend the order of operations and reduce the number of constraints.
+
+#### Variable as witness vs expression
+
+If you've come this far and really know what you're doing at the equation level, a temporary lever (that will become unnecessary/useless over time) is: `std::as_witness`. This informs the compiler to save a variable as a witness not an expression.
+
+The compiler will mostly be correct and optimal, but this may help some near term edge cases that are yet to optimize.
+Note: When used incorrectly it will create **less** efficient circuits (higher gate count).
+
+## References
+- Guillaume's ["`Cryptdoku`" talk](https://www.youtube.com/watch?v=MrQyzuogxgg) (Jun'23)
+- Tips from Tom, Jake and Zac.
+- [Idiomatic Noir](https://www.vlayer.xyz/blog/idiomatic-noir-part-1-collections) blog post
diff --git a/docs/versioned_docs/version-v0.36.0/getting_started/noir_installation.md b/docs/versioned_docs/version-v0.36.0/getting_started/noir_installation.md
new file mode 100644
index 00000000000..f92fd8dea38
--- /dev/null
+++ b/docs/versioned_docs/version-v0.36.0/getting_started/noir_installation.md
@@ -0,0 +1,102 @@
+---
+title: Standalone Noir Installation
+description: There are different ways to install Nargo, the one-stop shop and command-line tool for developing Noir programs. This guide explains how to specify which version to install when using noirup, and using WSL for windows.
+keywords: [
+    Installation
+    Nargo
+    Noirup
+    Binaries
+    Compiling from Source
+    WSL for Windows
+    macOS
+    Linux
+    Nix
+    Direnv
+    Uninstalling Nargo
+  ]
+sidebar_position: 2
+---
+
+Noirup is the endorsed method for installing Nargo, streamlining the process of fetching binaries or compiling from source. It supports a range of options to cater to your specific needs, from nightly builds and specific versions to compiling from various sources.
+
+### Installing Noirup
+
+First, ensure you have `noirup` installed:
+
+```sh
+curl -L https://raw.githubusercontent.com/noir-lang/noirup/main/install | bash
+```
+
+### Fetching Binaries
+
+With `noirup`, you can easily switch between different Nargo versions, including nightly builds:
+
+- **Nightly Version**: Install the latest nightly build.
+
+  ```sh
+  noirup --version nightly
+  ```
+
+- **Specific Version**: Install a specific version of Nargo.
+
+  ```sh
+  noirup --version <version>
+  ```
+
+### Compiling from Source
+
+`noirup` also enables compiling Nargo from various sources:
+
+- **From a Specific Branch**: Install from the latest commit on a branch.
+
+  ```sh
+  noirup --branch <branch-name>
+  ```
+
+- **From a Fork**: Install from the main branch of a fork.
+
+  ```sh
+  noirup --repo <username/repo>
+  ```
+
+- **From a Specific Branch in a Fork**: Install from a specific branch in a fork.
+
+  ```sh
+  noirup --repo <username/repo> --branch <branch-name>
+  ```
+
+- **From a Specific Pull Request**: Install from a specific PR.
+
+  ```sh
+  noirup --pr <pr-number>
+  ```
+
+- **From a Specific Commit**: Install from a specific commit.
+
+  ```sh
+  noirup -C <commit-hash>
+  ```
+
+- **From Local Source**: Compile and install from a local directory.
+
+  ```sh
+  noirup --path ./path/to/local/source
+  ```
+
+## Installation on Windows
+
+The default backend for Noir (Barretenberg) doesn't provide Windows binaries at this time. For that reason, Noir cannot be installed natively. However, it is available by using Windows Subsystem for Linux (WSL).
+
+Step 1: Follow the instructions [here](https://learn.microsoft.com/en-us/windows/wsl/install) to install and run WSL.
+
+step 2: Follow the [Noirup instructions](#installing-noirup).
+
+## Uninstalling Nargo
+
+If you installed Nargo with `noirup`, you can uninstall Nargo by removing the files in `~/.nargo`, `~/nargo`, and `~/noir_cache`. This ensures that all installed binaries, configurations, and cache related to Nargo are fully removed from your system.
+
+```bash
+rm -r ~/.nargo
+rm -r ~/nargo
+rm -r ~/noir_cache
+```
diff --git a/docs/versioned_docs/version-v0.36.0/getting_started/project_breakdown.md b/docs/versioned_docs/version-v0.36.0/getting_started/project_breakdown.md
new file mode 100644
index 00000000000..e442e377040
--- /dev/null
+++ b/docs/versioned_docs/version-v0.36.0/getting_started/project_breakdown.md
@@ -0,0 +1,159 @@
+---
+title: Project Breakdown
+description:
+  Learn about the anatomy of a Nargo project, including the purpose of the Prover TOML
+  file, and how to prove and verify your program.
+keywords:
+  [Nargo, Nargo project, Prover.toml, proof verification, private asset transfer]
+sidebar_position: 1
+---
+
+This section breaks down our hello world program from the previous section.
+
+## Anatomy of a Nargo Project
+
+Upon creating a new project with `nargo new` and building the in/output files with `nargo check`
+commands, you would get a minimal Nargo project of the following structure:
+
+    - src
+    - Prover.toml
+    - Nargo.toml
+
+The source directory _src_ holds the source code for your Noir program. By default only a _main.nr_
+file will be generated within it.
+
+### Prover.toml
+
+_Prover.toml_ is used for specifying the input values for executing and proving the program. You can specify `toml` files with different names by using the `--prover-name` or `-p` flags, see the [Prover](#provertoml) section below. Optionally you may specify expected output values for prove-time checking as well.
+
+### Nargo.toml
+
+_Nargo.toml_ contains the environmental options of your project. It contains a "package" section and a "dependencies" section.
+
+Example Nargo.toml:
+
+```toml
+[package]
+name = "noir_starter"
+type = "bin"
+authors = ["Alice"]
+compiler_version = "0.9.0"
+description = "Getting started with Noir"
+entry = "circuit/main.nr"
+license = "MIT"
+
+[dependencies]
+ecrecover = {tag = "v0.9.0", git = "https://github.com/colinnielsen/ecrecover-noir.git"}
+```
+
+Nargo.toml for a [workspace](../noir/modules_packages_crates/workspaces.md) will look a bit different. For example:
+
+```toml
+[workspace]
+members = ["crates/a", "crates/b"]
+default-member = "crates/a"
+```
+
+#### Package section
+
+The package section defines a number of fields including:
+
+- `name` (**required**) - the name of the package
+- `type` (**required**) - can be "bin", "lib", or "contract" to specify whether its a binary, library or Aztec contract
+- `authors` (optional) - authors of the project
+- `compiler_version` - specifies the version of the compiler to use. This is enforced by the compiler and follow's [Rust's versioning](https://doc.rust-lang.org/cargo/reference/manifest.html#the-version-field), so a `compiler_version = 0.18.0` will enforce Nargo version 0.18.0, `compiler_version = ^0.18.0` will enforce anything above 0.18.0 but below 0.19.0, etc. For more information, see how [Rust handles these operators](https://docs.rs/semver/latest/semver/enum.Op.html)
+- `description` (optional)
+- `entry` (optional) - a relative filepath to use as the entry point into your package (overrides the default of `src/lib.nr` or `src/main.nr`)
+- `backend` (optional)
+- `license` (optional)
+- `expression_width` (optional) - Sets the default backend expression width. This field will override the default backend expression width specified by the Noir compiler (currently set to width 4).
+
+#### Dependencies section
+
+This is where you will specify any dependencies for your project. See the [Dependencies page](../noir/modules_packages_crates/dependencies.md) for more info.
+
+`./proofs/` and `./contract/` directories will not be immediately visible until you create a proof or
+verifier contract respectively.
+
+### main.nr
+
+The _main.nr_ file contains a `main` method, this method is the entry point into your Noir program.
+
+In our sample program, _main.nr_ looks like this:
+
+```rust
+fn main(x : Field, y : Field) {
+    assert(x != y);
+}
+```
+
+The parameters `x` and `y` can be seen as the API for the program and must be supplied by the prover. Since neither `x` nor `y` is marked as public, the verifier does not supply any inputs, when verifying the proof.
+
+The prover supplies the values for `x` and `y` in the _Prover.toml_ file.
+
+As for the program body, `assert` ensures that the condition to be satisfied (e.g. `x != y`) is constrained by the proof of the execution of said program (i.e. if the condition was not met, the verifier would reject the proof as an invalid proof).
+
+### Prover.toml
+
+The _Prover.toml_ file is a file which the prover uses to supply the inputs to the Noir program (both private and public).
+
+In our hello world program the _Prover.toml_ file looks like this:
+
+```toml
+x = "1"
+y = "2"
+```
+
+When the command `nargo execute` is executed, nargo will execute the Noir program using the inputs specified in `Prover.toml`, aborting if it finds that these do not satisfy the constraints defined by `main`. In this example, `x` and `y` must satisfy the inequality constraint `assert(x != y)`.
+
+If an output name is specified such as `nargo execute foo`, the witness generated by this execution will be written to `./target/foo.gz`. This can then be used to generate a proof of the execution.
+
+#### Arrays of Structs
+
+The following code shows how to pass an array of structs to a Noir program to generate a proof.
+
+```rust
+// main.nr
+struct Foo {
+    bar: Field,
+    baz: Field,
+}
+
+fn main(foos: [Foo; 3]) -> pub Field {
+    foos[2].bar + foos[2].baz
+}
+```
+
+Prover.toml:
+
+```toml
+[[foos]] # foos[0]
+bar = 0
+baz = 0
+
+[[foos]] # foos[1]
+bar = 0
+baz = 0
+
+[[foos]] # foos[2]
+bar = 1
+baz = 2
+```
+
+#### Custom toml files
+
+You can specify a `toml` file with a different name to use for execution by using the `--prover-name` or `-p` flags.
+
+This command looks for proof inputs in the default **Prover.toml** and generates the witness and saves it at `./target/foo.gz`:
+
+```bash
+nargo execute foo
+```
+
+This command looks for proof inputs in the custom **OtherProver.toml** and generates the witness and saves it at `./target/bar.gz`:
+
+```bash
+nargo execute -p OtherProver bar
+```
+
+Now that you understand the concepts, you'll probably want some editor feedback while you are writing more complex code.
diff --git a/docs/versioned_docs/version-v0.36.0/getting_started/quick_start.md b/docs/versioned_docs/version-v0.36.0/getting_started/quick_start.md
new file mode 100644
index 00000000000..3c10086123f
--- /dev/null
+++ b/docs/versioned_docs/version-v0.36.0/getting_started/quick_start.md
@@ -0,0 +1,125 @@
+---
+title: Quick Start
+tags: []
+sidebar_position: 0
+---
+
+## Installation
+
+### Noir
+
+The easiest way to develop with Noir is using Nargo the CLI tool. It provides you the ability to start new projects, compile, execute and test Noir programs from the terminal.
+
+You can use `noirup` the installation script to quickly install and update Nargo:
+
+```bash
+curl -L noirup.dev | bash
+noirup
+```
+
+### Proving backend
+
+After installing Noir, we install a proving backend to work with our Noir programs.
+
+Proving backends provide you the abilities to generate proofs, verify proofs, generate smart contracts and more for your Noir programs.
+
+Different proving backends provide different tools for working with Noir programs, here we will use the [Barretenberg proving backend](https://github.com/AztecProtocol/aztec-packages/tree/master/barretenberg) developed by Aztec Labs as an example.
+
+You can use the `bbup` installation script to quickly install and update BB, Barretenberg's CLI tool:
+
+You can find the full list of proving backends compatible with Noir in Awesome Noir.
+
+```bash
+curl -L bbup.dev | bash
+bbup
+```
+
+For the full list of proving backends compatible with Noir, visit [Awesome Noir](https://github.com/noir-lang/awesome-noir/?tab=readme-ov-file#proving-backends).
+
+## Nargo
+
+Nargo provides the ability to initiate and execute Noir projects. Let's initialize the traditional `hello_world`:
+
+```sh
+nargo new hello_world
+```
+
+Two files will be created.
+
+- `src/main.nr` contains a simple boilerplate circuit
+- `Nargo.toml` contains environmental options, such as name, author, dependencies, and others.
+
+Glancing at _main.nr_ , we can see that inputs in Noir are private by default, but can be labeled public using the keyword `pub`. This means that we will _assert_ that we know a value `x` which is different from `y` without revealing `x`:
+
+```rust
+fn main(x : Field, y : pub Field) {
+    assert(x != y);
+}
+```
+
+To learn more about private and public values, check the [Data Types](../noir/concepts/data_types/index.md) section.
+
+### Compiling and executing
+
+We can now use `nargo` to generate a _Prover.toml_ file, where our input values will be specified:
+
+```sh
+cd hello_world
+nargo check
+```
+
+Let's feed some valid values into this file:
+
+```toml
+x = "1"
+y = "2"
+```
+
+We're now ready to compile and execute our Noir program. By default the `nargo execute` command will do both, and generate the `witness` that we need to feed to our proving backend:
+
+```sh
+nargo execute
+```
+
+The witness corresponding to this execution will then be written to the file _./target/witness-name.gz_.
+
+The command also automatically compiles your Noir program if it was not already / was edited, which you may notice the compiled artifacts being written to the file _./target/hello_world.json_.
+
+With circuit compiled and witness generated, we're ready to prove.
+
+## Proving backend
+
+Different proving backends may provide different tools and commands to work with Noir programs. Here Barretenberg's `bb` CLI tool is used as an example:
+
+```sh
+bb prove -b ./target/hello_world.json -w ./target/hello_world.gz -o ./target/proof
+```
+
+:::tip
+
+Naming can be confusing, specially as you pass them to the `bb` commands. If unsure, it won't hurt to delete the target folder and start anew to make sure you're using the most recent versions of the compiled circuit and witness.
+
+:::
+
+The proof is now generated in the `target` folder. To verify it we first need to compute the verification key from the compiled circuit, and use it to verify:
+
+```sh
+bb write_vk -b ./target/hello_world.json -o ./target/vk
+bb verify -k ./target/vk -p ./target/proof
+```
+
+:::info
+
+Notice that in order to verify a proof, the verifier knows nothing but the circuit, which is compiled and used to generate the verification key. This is obviously quite important: private inputs remain private.
+
+As for the public inputs, you may have noticed they haven't been specified. This behavior varies with each particular backend, but barretenberg typically attaches them to the proof. You can see them by parsing and splitting it. For example for if your public inputs are 32 bytes:
+
+```bash
+head -c 32 ./target/proof | od -An -v -t x1 | tr -d $' \n'
+```
+
+:::
+
+Congratulations, you have now created and verified a proof for your very first Noir program!
+
+In the [next section](./project_breakdown.md), we will go into more detail on each step performed.
diff --git a/docs/versioned_docs/version-v0.36.0/how_to/_category_.json b/docs/versioned_docs/version-v0.36.0/how_to/_category_.json
new file mode 100644
index 00000000000..0b4f367ce53
--- /dev/null
+++ b/docs/versioned_docs/version-v0.36.0/how_to/_category_.json
@@ -0,0 +1,5 @@
+{
+  "position": 1,
+  "collapsible": true,
+  "collapsed": true
+}
diff --git a/docs/versioned_docs/version-v0.36.0/how_to/debugger/_category_.json b/docs/versioned_docs/version-v0.36.0/how_to/debugger/_category_.json
new file mode 100644
index 00000000000..cc2cbb1c253
--- /dev/null
+++ b/docs/versioned_docs/version-v0.36.0/how_to/debugger/_category_.json
@@ -0,0 +1,6 @@
+{
+    "label": "Debugging",
+    "position": 5,
+    "collapsible": true,
+    "collapsed": true
+}
diff --git a/docs/versioned_docs/version-v0.36.0/how_to/debugger/debugging_with_the_repl.md b/docs/versioned_docs/version-v0.36.0/how_to/debugger/debugging_with_the_repl.md
new file mode 100644
index 00000000000..1d64dae3f37
--- /dev/null
+++ b/docs/versioned_docs/version-v0.36.0/how_to/debugger/debugging_with_the_repl.md
@@ -0,0 +1,164 @@
+---
+title: Using the REPL Debugger
+description:
+  Step-by-step guide on how to debug your Noir circuits with the REPL Debugger. 
+keywords:
+  [
+    Nargo,
+    Noir CLI,
+    Noir Debugger,
+    REPL,
+  ]
+sidebar_position: 1
+---
+
+#### Pre-requisites
+
+In order to use the REPL debugger, first you need to install recent enough versions of Nargo and vscode-noir. 
+
+## Debugging a simple circuit
+
+Let's debug a simple circuit:
+
+```rust
+fn main(x : Field, y : pub Field) {
+    assert(x != y);
+}
+```
+
+To start the REPL debugger, using a terminal, go to a Noir circuit's home directory. Then:
+
+`$ nargo debug`
+
+You should be seeing this in your terminal:
+
+```
+[main] Starting debugger
+At ~/noir-examples/recursion/circuits/main/src/main.nr:1:9
+  1 -> fn main(x : Field, y : pub Field) {
+  2        assert(x != y);
+  3    }
+> 
+```
+
+The debugger displays the current Noir code location, and it is now waiting for us to drive it.
+
+Let's first take a look at the available commands. For that we'll use the `help` command.
+
+```
+> help
+Available commands:
+
+  opcodes                          display ACIR opcodes
+  into                             step into to the next opcode
+  next                             step until a new source location is reached
+  out                              step until a new source location is reached
+                                   and the current stack frame is finished
+  break LOCATION:OpcodeLocation    add a breakpoint at an opcode location
+  over                             step until a new source location is reached
+                                   without diving into function calls
+  restart                          restart the debugging session
+  delete LOCATION:OpcodeLocation   delete breakpoint at an opcode location
+  witness                          show witness map
+  witness index:u32                display a single witness from the witness map
+  witness index:u32 value:String   update a witness with the given value
+  memset index:usize value:String  update a memory cell with the given
+                                   value
+  continue                         continue execution until the end of the
+                                   program
+  vars                             show variable values available at this point
+                                   in execution
+  stacktrace                       display the current stack trace
+  memory                           show memory (valid when executing unconstrained code)
+  step                             step to the next ACIR opcode
+
+Other commands:
+
+  help  Show this help message
+  quit  Quit repl
+
+```
+
+Some commands operate only for unconstrained functions, such as `memory` and `memset`. If you try to use them while execution is paused at an ACIR opcode, the debugger will simply inform you that you are not executing unconstrained code:
+
+```
+> memory
+Unconstrained VM memory not available
+> 
+```
+
+Before continuing, we can take a look at the initial witness map:
+
+```
+> witness
+_0 = 1
+_1 = 2
+>
+```
+
+Cool, since `x==1`, `y==2`, and we want to check that `x != y`, our circuit should succeed. At this point we could intervene and use the witness setter command to change one of the witnesses. Let's set `y=3`, then back to 2, so we don't affect the expected result:
+
+```
+> witness
+_0 = 1
+_1 = 2
+> witness 1 3
+_1 = 3
+> witness
+_0 = 1
+_1 = 3
+> witness 1 2
+_1 = 2
+> witness
+_0 = 1
+_1 = 2
+>
+```
+
+Now we can inspect the current state of local variables. For that we use the `vars` command. 
+
+```
+> vars
+>
+```
+
+We currently have no vars in context, since we are at the entry point of the program. Let's use `next` to execute until the next point in the program.
+
+```
+> vars
+> next
+At ~/noir-examples/recursion/circuits/main/src/main.nr:1:20
+  1 -> fn main(x : Field, y : pub Field) {
+  2        assert(x != y);
+  3    }
+> vars
+x:Field = 0x01
+```
+
+As a result of stepping, the variable `x`, whose initial value comes from the witness map, is now in context and returned by `vars`.
+
+```
+> next
+  1    fn main(x : Field, y : pub Field) {
+  2 ->     assert(x != y);
+  3    }
+> vars
+y:Field = 0x02
+x:Field = 0x01
+```
+
+Stepping again we can finally see both variables and their values. And now we can see that the next assertion should succeed.
+
+Let's continue to the end:
+
+```
+> continue
+(Continuing execution...)
+Finished execution
+> q
+[main] Circuit witness successfully solved
+```
+
+Upon quitting the debugger after a solved circuit, the resulting circuit witness gets saved, equivalent to what would happen if we had run the same circuit with `nargo execute`.
+
+We just went through the basics of debugging using Noir REPL debugger. For a comprehensive reference, check out [the reference page](../../reference/debugger/debugger_repl.md).
diff --git a/docs/versioned_docs/version-v0.36.0/how_to/debugger/debugging_with_vs_code.md b/docs/versioned_docs/version-v0.36.0/how_to/debugger/debugging_with_vs_code.md
new file mode 100644
index 00000000000..a5858c1a5eb
--- /dev/null
+++ b/docs/versioned_docs/version-v0.36.0/how_to/debugger/debugging_with_vs_code.md
@@ -0,0 +1,68 @@
+---
+title: Using the VS Code Debugger
+description:
+  Step by step guide on how to debug your Noir circuits with the VS Code Debugger configuration and features.
+keywords:
+  [
+    Nargo,
+    Noir CLI,
+    Noir Debugger,
+    VS Code,
+    IDE,
+  ]
+sidebar_position: 0
+---
+
+This guide will show you how to use VS Code with the vscode-noir extension to debug a Noir project. 
+
+#### Pre-requisites
+
+- Nargo
+- vscode-noir
+- A Noir project with a `Nargo.toml`, `Prover.toml` and at least one Noir (`.nr`) containing an entry point function (typically `main`).
+
+## Running the debugger
+
+The easiest way to start debugging is to open the file you want to debug, and press `F5`. This will cause the debugger to launch, using your `Prover.toml` file as input.
+
+You should see something like this:
+
+![Debugger launched](@site/static/img/debugger/1-started.png)
+
+Let's inspect the state of the program. For that, we open VS Code's _Debug pane_. Look for this icon:
+
+![Debug pane icon](@site/static/img/debugger/2-icon.png)
+
+You will now see two categories of variables: Locals and Witness Map.
+
+![Debug pane expanded](@site/static/img/debugger/3-debug-pane.png)
+
+1. **Locals**: variables of your program. At this point in execution this section is empty, but as we step through the code it will get populated by `x`, `result`, `digest`, etc. 
+
+2. **Witness map**: these are initially populated from your project's `Prover.toml` file. In this example, they will be used to populate `x` and `result` at the beginning of the `main` function.
+
+Most of the time you will probably be focusing mostly on locals, as they represent the high level state of your program. 
+
+You might be interested in inspecting the witness map in case you are trying to solve a really low level issue in the compiler or runtime itself, so this concerns mostly advanced or niche users.
+
+Let's step through the program, by using the debugger buttons or their corresponding keyboard shortcuts.
+
+![Debugger buttons](@site/static/img/debugger/4-debugger-buttons.png)
+
+Now we can see in the variables pane that there's values for `digest`, `result` and `x`.
+
+![Inspecting locals](@site/static/img/debugger/5-assert.png)
+
+We can also inspect the values of variables by directly hovering on them on the code.
+
+![Hover locals](@site/static/img/debugger/6-hover.png)
+
+Let's set a break point at the `keccak256` function, so we can continue execution up to the point when it's first invoked without having to go one step at a time. 
+
+We just need to click the to the right of the line number 18. Once the breakpoint appears, we can click the `continue` button or use its corresponding keyboard shortcut (`F5` by default).
+
+![Breakpoint](@site/static/img/debugger/7-break.png)
+
+Now we are debugging the `keccak256` function, notice the _Call Stack pane_ at the lower right. This lets us inspect the current call stack of our process.
+
+That covers most of the current debugger functionalities. Check out [the reference](../../reference/debugger/debugger_vscode.md) for more details on how to configure the debugger.
\ No newline at end of file
diff --git a/docs/versioned_docs/version-v0.36.0/how_to/how-to-oracles.md b/docs/versioned_docs/version-v0.36.0/how_to/how-to-oracles.md
new file mode 100644
index 00000000000..08ce6ee5476
--- /dev/null
+++ b/docs/versioned_docs/version-v0.36.0/how_to/how-to-oracles.md
@@ -0,0 +1,275 @@
+---
+title: How to use Oracles
+description: Learn how to use oracles in your Noir program with examples in both Nargo and NoirJS. This guide also covers writing a JSON RPC server and providing custom foreign call handlers for NoirJS.
+keywords:
+  - Noir Programming
+  - Oracles
+  - Nargo
+  - NoirJS
+  - JSON RPC Server
+  - Foreign Call Handlers
+sidebar_position: 1
+---
+
+This guide shows you how to use oracles in your Noir program. For the sake of clarity, it assumes that:
+
+- You have read the [explainer on Oracles](../explainers/explainer-oracle.md) and are comfortable with the concept.
+- You have a Noir program to add oracles to. You can create one using the [vite-hardhat starter](https://github.com/noir-lang/noir-starter/tree/main/vite-hardhat) as a boilerplate.
+- You understand the concept of a JSON-RPC server. Visit the [JSON-RPC website](https://www.jsonrpc.org/) if you need a refresher.
+- You are comfortable with server-side JavaScript (e.g. Node.js, managing packages, etc.).
+
+## Rundown
+
+This guide has 3 major steps:
+
+1. How to modify our Noir program to make use of oracle calls as unconstrained functions
+2. How to write a JSON RPC Server to resolve these oracle calls with Nargo
+3. How to use them in Nargo and how to provide a custom resolver in NoirJS
+
+## Step 1 - Modify your Noir program
+
+An oracle is defined in a Noir program by defining two methods:
+
+- An unconstrained method - This tells the compiler that it is executing an [unconstrained functions](../noir/concepts//unconstrained.md).
+- A decorated oracle method - This tells the compiler that this method is an RPC call.
+
+An example of an oracle that returns a `Field` would be:
+
+```rust
+#[oracle(getSqrt)]
+unconstrained fn sqrt(number: Field) -> Field { }
+
+unconstrained fn get_sqrt(number: Field) -> Field {
+    sqrt(number)
+}
+```
+
+In this example, we're wrapping our oracle function in an unconstrained method, and decorating it with `oracle(getSqrt)`. We can then call the unconstrained function as we would call any other function:
+
+```rust
+fn main(input: Field) {
+    let sqrt = get_sqrt(input);
+}
+```
+
+In the next section, we will make this `getSqrt` (defined on the `sqrt` decorator) be a method of the RPC server Noir will use.
+
+:::danger
+
+As explained in the [Oracle Explainer](../explainers/explainer-oracle.md), this `main` function is unsafe unless you constrain its return value. For example:
+
+```rust
+fn main(input: Field) {
+    let sqrt = get_sqrt(input);
+    assert(sqrt.pow_32(2) as u64 == input as u64); // <---- constrain the return of an oracle!
+}
+```
+
+:::
+
+:::info
+
+Currently, oracles only work with single params or array params. For example:
+
+```rust
+#[oracle(getSqrt)]
+unconstrained fn sqrt([Field; 2]) -> [Field; 2] { }
+```
+
+:::
+
+## Step 2 - Write an RPC server
+
+Brillig will call *one* RPC server. Most likely you will have to write your own, and you can do it in whatever language you prefer. In this guide, we will do it in Javascript.
+
+Let's use the above example of an oracle that consumes an array with two `Field` and returns their square roots:
+
+```rust
+#[oracle(getSqrt)]
+unconstrained fn sqrt(input: [Field; 2]) -> [Field; 2] { }
+
+unconstrained fn get_sqrt(input: [Field; 2]) -> [Field; 2] {
+    sqrt(input)
+}
+
+fn main(input: [Field; 2]) {
+    let sqrt = get_sqrt(input);
+    assert(sqrt[0].pow_32(2) as u64 == input[0] as u64);
+    assert(sqrt[1].pow_32(2) as u64 == input[1] as u64);
+}
+
+#[test]
+fn test() {
+    let input = [4, 16];
+    main(input);
+}
+```
+
+:::info
+
+Why square root?
+
+In general, computing square roots is computationally more expensive than multiplications, which takes a toll when speaking about ZK applications. In this case, instead of calculating the square root in Noir, we are using our oracle to offload that computation to be made in plain. In our circuit we can simply multiply the two values.
+
+:::
+
+Now, we should write the correspondent RPC server, starting with the [default JSON-RPC 2.0 boilerplate](https://www.npmjs.com/package/json-rpc-2.0#example):
+
+```js
+import { JSONRPCServer } from "json-rpc-2.0";
+import express from "express";
+import bodyParser from "body-parser";
+
+const app = express();
+app.use(bodyParser.json());
+
+const server = new JSONRPCServer();
+app.post("/", (req, res) => {
+ const jsonRPCRequest = req.body;
+ server.receive(jsonRPCRequest).then((jsonRPCResponse) => {
+  if (jsonRPCResponse) {
+   res.json(jsonRPCResponse);
+  } else {
+   res.sendStatus(204);
+  }
+ });
+});
+
+app.listen(5555);
+```
+
+Now, we will add our `getSqrt` method, as expected by the `#[oracle(getSqrt)]` decorator in our Noir code. It maps through the params array and returns their square roots:
+
+```js
+server.addMethod("resolve_foreign_call", async (params) => {
+    if (params[0].function !== "getSqrt") {
+        throw Error("Unexpected foreign call")
+    };
+    const values = params[0].inputs[0].map((field) => {
+        return `${Math.sqrt(parseInt(field, 16))}`;
+    });
+    return { values: [values] };
+});
+```
+
+If you're using Typescript, the following types may be helpful in understanding the expected return value and making sure they're easy to follow:
+
+```js
+export type ForeignCallSingle = string;
+
+export type ForeignCallArray = string[];
+
+export type ForeignCallResult = {
+  values: (ForeignCallSingle | ForeignCallArray)[];
+};
+```
+
+:::info Multidimensional Arrays
+
+If the Oracle function is returning an array containing other arrays, such as `[['1','2],['3','4']]`, you need to provide the values in JSON as flattened values. In the previous example, it would be `['1', '2', '3', '4']`. In the Noir program, the Oracle signature can use a nested type, the flattened values will be automatically converted to the nested type.
+
+:::
+
+## Step 3 - Usage with Nargo
+
+Using the [`nargo` CLI tool](../reference/nargo_commands.md), you can use oracles in the `nargo test` and `nargo execute`  commands by passing a value to `--oracle-resolver`. For example:
+
+```bash
+nargo test --oracle-resolver http://localhost:5555
+```
+
+This tells `nargo` to use your RPC Server URL whenever it finds an oracle decorator.
+
+## Step 4 - Usage with NoirJS
+
+In a JS environment, an RPC server is not strictly necessary, as you may want to resolve your oracles without needing any JSON call at all. NoirJS simply expects that you pass a callback function when you generate proofs, and that callback function can be anything.
+
+For example, if your Noir program expects the host machine to provide CPU pseudo-randomness, you could simply pass it as the `foreignCallHandler`. You don't strictly need to create an RPC server to serve pseudo-randomness, as you may as well get it directly in your app:
+
+```js
+const foreignCallHandler = (name, inputs) => crypto.randomBytes(16) // etc
+
+await noir.execute(inputs, foreignCallHandler)
+```
+
+As one can see, in NoirJS, the [`foreignCallHandler`](../reference/NoirJS/noir_js/type-aliases/ForeignCallHandler.md) function simply means "a callback function that returns a value of type [`ForeignCallOutput`](../reference/NoirJS/noir_js/type-aliases/ForeignCallOutput.md). It doesn't have to be an RPC call like in the case for Nargo.
+
+:::tip
+
+Does this mean you don't have to write an RPC server like in [Step #2](#step-2---write-an-rpc-server)?
+
+You don't technically have to, but then how would you run `nargo test`? To use both `Nargo` and `NoirJS` in your development flow, you will have to write a JSON RPC server.
+
+:::
+
+In this case, let's make `foreignCallHandler` call the JSON RPC Server we created in [Step #2](#step-2---write-an-rpc-server), by making it a JSON RPC Client.
+
+For example, using the same `getSqrt` program in [Step #1](#step-1---modify-your-noir-program) (comments in the code):
+
+```js
+import { JSONRPCClient } from "json-rpc-2.0";
+
+// declaring the JSONRPCClient
+const client = new JSONRPCClient((jsonRPCRequest) => {
+// hitting the same JSON RPC Server we coded above
+ return fetch("http://localhost:5555", {
+  method: "POST",
+  headers: {
+   "content-type": "application/json",
+  },
+  body: JSON.stringify(jsonRPCRequest),
+ }).then((response) => {
+  if (response.status === 200) {
+   return response
+    .json()
+    .then((jsonRPCResponse) => client.receive(jsonRPCResponse));
+  } else if (jsonRPCRequest.id !== undefined) {
+   return Promise.reject(new Error(response.statusText));
+  }
+ });
+});
+
+// declaring a function that takes the name of the foreign call (getSqrt) and the inputs
+const foreignCallHandler = async (name, input) => {
+  const inputs = input[0].map((i) => i.toString("hex"))
+  // notice that the "inputs" parameter contains *all* the inputs
+  // in this case we to make the RPC request with the first parameter "numbers", which would be input[0]
+  const oracleReturn = await client.request("resolve_foreign_call", [
+    {
+      function: name,
+      inputs: [inputs]
+    },
+  ]);
+  return [oracleReturn.values[0]];
+};
+
+// the rest of your NoirJS code
+const input = { input: [4, 16] };
+const { witness } = await noir.execute(input, foreignCallHandler);
+```
+
+:::tip
+
+If you're in a NoirJS environment running your RPC server together with a frontend app, you'll probably hit a familiar problem in full-stack development: requests being blocked by [CORS](https://developer.mozilla.org/en-US/docs/Web/HTTP/CORS) policy. For development only, you can simply install and use the [`cors` npm package](https://www.npmjs.com/package/cors) to get around the problem:
+
+```bash
+yarn add cors
+```
+
+and use it as a middleware:
+
+```js
+import cors from "cors";
+
+const app = express();
+app.use(cors())
+```
+
+:::
+
+## Conclusion
+
+Hopefully by the end of this guide, you should be able to:
+
+- Write your own logic around Oracles and how to write a JSON RPC server to make them work with your Nargo commands.
+- Provide custom foreign call handlers for NoirJS.
\ No newline at end of file
diff --git a/docs/versioned_docs/version-v0.36.0/how_to/how-to-recursion.md b/docs/versioned_docs/version-v0.36.0/how_to/how-to-recursion.md
new file mode 100644
index 00000000000..c8c4dc9f5b4
--- /dev/null
+++ b/docs/versioned_docs/version-v0.36.0/how_to/how-to-recursion.md
@@ -0,0 +1,180 @@
+---
+title: How to use recursion on NoirJS
+description: Learn how to implement recursion with NoirJS, a powerful tool for creating smart contracts on the EVM blockchain. This guide assumes familiarity with NoirJS, solidity verifiers, and the Barretenberg proving backend. Discover how to generate both final and intermediate proofs using `noir_js` and `backend_barretenberg`.
+keywords:
+  [
+    "NoirJS",
+    "EVM blockchain",
+    "smart contracts",
+    "recursion",
+    "solidity verifiers",
+    "Barretenberg backend",
+    "noir_js",
+    "backend_barretenberg",
+    "intermediate proofs",
+    "final proofs",
+    "nargo compile",
+    "json import",
+    "recursive circuit",
+    "recursive app"
+  ]
+sidebar_position: 1
+---
+
+This guide shows you how to use recursive proofs in your NoirJS app. For the sake of clarity, it is assumed that:
+
+- You already have a NoirJS app. If you don't, please visit the [NoirJS tutorial](../tutorials/noirjs_app.md) and the [reference](../reference/NoirJS/noir_js/index.md).
+- You are familiar with what are recursive proofs and you have read the [recursion explainer](../explainers/explainer-recursion.md)
+- You already built a recursive circuit following [the reference](../noir/standard_library/recursion.mdx), and understand how it works.
+
+It is also assumed that you're not using `noir_wasm` for compilation, and instead you've used [`nargo compile`](../reference/nargo_commands.md) to generate the `json` you're now importing into your project. However, the guide should work just the same if you're using `noir_wasm`.
+
+:::info
+
+As you've read in the [explainer](../explainers/explainer-recursion.md), a recursive proof is an intermediate proof. This means that it doesn't necessarily generate the final step that makes it verifiable in a smart contract. However, it is easy to verify within another circuit.
+
+While "standard" usage of NoirJS packages abstracts final proofs, it currently lacks the necessary interface to abstract away intermediate proofs. This means that these proofs need to be created by using the backend directly.
+
+In short:
+
+- `noir_js` generates *only* final proofs
+- `backend_barretenberg` generates both types of proofs
+
+:::
+
+In a standard recursive app, you're also dealing with at least two circuits. For the purpose of this guide, we will assume the following:
+
+- `main`: a circuit of type `assert(x != y)`, where `main` is marked with a `#[recursive]` attribute. This attribute states that the backend should generate proofs that are friendly for verification within another circuit.
+- `recursive`: a circuit that verifies `main`
+
+For a full example of how recursive proofs work, please refer to the [noir-examples](https://github.com/noir-lang/noir-examples) repository. We will *not* be using it as a reference for this guide.
+
+## Step 1: Setup
+
+In a common NoirJS app, you need to instantiate a backend with something like `const backend = new Backend(circuit)`. Then you feed it to the `noir_js` interface.
+
+For recursion, this doesn't happen, and the only need for `noir_js` is only to `execute` a circuit and get its witness and return value. Everything else is not interfaced, so it needs to happen on the `backend` object.
+
+It is also recommended that you instantiate the backend with as many threads as possible, to allow for maximum concurrency:
+
+```js
+const backend = new Backend(circuit, { threads: 8 })
+```
+
+:::tip
+You can use the [`os.cpus()`](https://nodejs.org/api/os.html#oscpus) object in `nodejs` or [`navigator.hardwareConcurrency`](https://developer.mozilla.org/en-US/docs/Web/API/Navigator/hardwareConcurrency) on the browser to make the most out of those glorious cpu cores
+:::
+
+## Step 2: Generating the witness and the proof for `main`
+
+After instantiating the backend, you should also instantiate `noir_js`. We will use it to execute the circuit and get the witness.
+
+```js
+const noir = new Noir(circuit)
+const { witness } = noir.execute(input)
+```
+
+With this witness, you are now able to generate the intermediate proof for the main circuit:
+
+```js
+const { proof, publicInputs } = await backend.generateProof(witness)
+```
+
+:::warning
+
+Always keep in mind what is actually happening on your development process, otherwise you'll quickly become confused about what circuit we are actually running and why!
+
+In this case, you can imagine that Alice (running the `main` circuit) is proving something to Bob (running the `recursive` circuit), and Bob is verifying her proof within his proof.
+
+With this in mind, it becomes clear that our intermediate proof is the one *meant to be verified within another circuit*, so it must be Alice's. Actually, the only final proof in this theoretical scenario would be the last one, sent on-chain.
+
+:::
+
+## Step 3 - Verification and proof artifacts
+
+Optionally, you are able to verify the intermediate proof:
+
+```js
+const verified = await backend.verifyProof({ proof, publicInputs })
+```
+
+This can be useful to make sure our intermediate proof was correctly generated. But the real goal is to do it within another circuit. For that, we need to generate  recursive proof artifacts that will be passed to the circuit that is verifying the proof we just generated. Instead of passing the proof and verification key as a byte array, we pass them as fields which makes it cheaper to verify in a circuit:
+
+```js
+const { proofAsFields, vkAsFields, vkHash } = await backend.generateRecursiveProofArtifacts( { publicInputs, proof }, publicInputsCount)
+```
+
+This call takes the public inputs and the proof, but also the public inputs count. While this is easily retrievable by simply counting the `publicInputs` length, the backend interface doesn't currently abstract it away.
+
+:::info
+
+The `proofAsFields` has a constant size `[Field; 93]` and verification keys in Barretenberg are always `[Field; 114]`.
+
+:::
+
+:::warning
+
+One common mistake is to forget *who* makes this call.
+
+In a situation where Alice is generating the `main` proof, if she generates the proof artifacts and sends them to Bob, which gladly takes them as true, this would mean Alice could prove anything!
+
+Instead, Bob needs to make sure *he* extracts the proof artifacts, using his own instance of the `main` circuit backend. This way, Alice has to provide a valid proof for the correct `main` circuit.
+
+:::
+
+## Step 4 - Recursive proof generation
+
+With the artifacts, generating a recursive proof is no different from a normal proof. You simply use the `backend` (with the recursive circuit) to generate it:
+
+```js
+const recursiveInputs = {
+    verification_key: vkAsFields, // array of length 114
+    proof: proofAsFields, // array of length 93 + size of public inputs
+    publicInputs: [mainInput.y], // using the example above, where `y` is the only public input
+    key_hash: vkHash,
+}
+
+const { witness, returnValue } = noir.execute(recursiveInputs) // we're executing the recursive circuit now!
+const { proof, publicInputs } = backend.generateProof(witness)
+const verified = backend.verifyProof({ proof, publicInputs })
+```
+
+You can obviously chain this proof into another proof. In fact, if you're using recursive proofs, you're probably interested of using them this way!
+
+:::tip
+
+Managing circuits and "who does what" can be confusing. To make sure your naming is consistent, you can keep them in an object. For example:
+
+```js
+const circuits = {
+  main: mainJSON, 
+  recursive: recursiveJSON
+}
+const backends = {
+  main: new BarretenbergBackend(circuits.main),
+  recursive: new BarretenbergBackend(circuits.recursive)
+}
+const noir_programs = {
+  main: new Noir(circuits.main),
+  recursive: new Noir(circuits.recursive)
+}
+```
+
+This allows you to neatly call exactly the method you want without conflicting names:
+
+```js
+// Alice runs this 👇
+const { witness: mainWitness } = await noir_programs.main.execute(input)
+const proof = await backends.main.generateProof(mainWitness)
+
+// Bob runs this 👇
+const verified = await backends.main.verifyProof(proof)
+const { proofAsFields, vkAsFields, vkHash } = await backends.main.generateRecursiveProofArtifacts(
+    proof,
+    numPublicInputs,
+);
+const { witness: recursiveWitness } = await noir_programs.recursive.execute(recursiveInputs)
+const recursiveProof = await backends.recursive.generateProof(recursiveWitness);
+```
+
+:::
diff --git a/docs/versioned_docs/version-v0.36.0/how_to/how-to-solidity-verifier.md b/docs/versioned_docs/version-v0.36.0/how_to/how-to-solidity-verifier.md
new file mode 100644
index 00000000000..2cc0f8e57ce
--- /dev/null
+++ b/docs/versioned_docs/version-v0.36.0/how_to/how-to-solidity-verifier.md
@@ -0,0 +1,259 @@
+---
+title: Generate a Solidity Verifier
+description:
+  Learn how to run the verifier as a smart contract on the blockchain. Compile a Solidity verifier
+  contract for your Noir program and deploy it on any EVM blockchain acting as a verifier smart
+  contract. Read more to find out
+keywords:
+  [
+    solidity verifier,
+    smart contract,
+    blockchain,
+    compiler,
+    plonk_vk.sol,
+    EVM blockchain,
+    verifying Noir programs,
+    proving backend,
+    Barretenberg,
+  ]
+sidebar_position: 0
+pagination_next: tutorials/noirjs_app
+---
+
+Noir has the ability to generate a verifier contract in Solidity, which can be deployed in many EVM-compatible blockchains such as Ethereum.
+
+This allows for a powerful feature set, as one can make use of the conciseness and the privacy provided by Noir in an immutable ledger. Applications can range from simple P2P guessing games, to complex private DeFi interactions.
+
+This guide shows you how to generate a Solidity Verifier and deploy it on the [Remix IDE](https://remix.ethereum.org/). It is assumed that:
+
+- You are comfortable with the Solidity programming language and understand how contracts are deployed on the Ethereum network
+- You have Noir installed and you have a Noir program. If you don't, [get started](../getting_started/quick_start.md) with Nargo and the example Hello Noir circuit
+- You are comfortable navigating RemixIDE. If you aren't or you need a refresher, you can find some video tutorials [here](https://www.youtube.com/channel/UCjTUPyFEr2xDGN6Cg8nKDaA) that could help you.
+
+## Rundown
+
+Generating a Solidity Verifier contract is actually a one-command process. However, compiling it and deploying it can have some caveats. Here's the rundown of this guide:
+
+1. How to generate a solidity smart contract
+2. How to compile the smart contract in the RemixIDE
+3. How to deploy it to a testnet
+
+## Step 1 - Generate a contract
+
+This is by far the most straightforward step. Just run:
+
+```sh
+nargo compile
+```
+
+This will compile your source code into a Noir build artifact to be stored in the `./target` directory, you can then generate the smart contract using the commands:
+
+```sh
+# Here we pass the path to the newly generated Noir artifact.
+bb write_vk -b ./target/<noir_artifact_name>.json
+bb contract
+```
+
+replacing `<noir_artifact_name>` with the name of your Noir project. A new `contract` folder would then be generated in your project directory, containing the Solidity
+file `contract.sol`. It can be deployed to any EVM blockchain acting as a verifier smart contract.
+
+You can find more information about `bb` and the default Noir proving backend on [this page](../getting_started/quick_start.md#proving-backend).
+
+:::info
+
+It is possible to generate verifier contracts of Noir programs for other smart contract platforms as long as the proving backend supplies an implementation.
+
+Barretenberg, the default proving backend for Nargo, supports generation of verifier contracts, for the time being these are only in Solidity.
+:::
+
+## Step 2 - Compiling
+
+We will mostly skip the details of RemixIDE, as the UI can change from version to version. For now, we can just open
+<a href="https://remix.ethereum.org" target="_blank">Remix</a> and create a blank workspace.
+
+![Create Workspace](@site/static/img/how-tos/solidity_verifier_1.png)
+
+We will create a new file to contain the contract Nargo generated, and copy-paste its content.
+
+:::warning
+
+You'll likely see a warning advising you to not trust pasted code. While it is an important warning, it is irrelevant in the context of this guide and can be ignored. We will not be deploying anywhere near a mainnet.
+
+:::
+
+To compile our the verifier, we can navigate to the compilation tab:
+
+![Compilation Tab](@site/static/img/how-tos/solidity_verifier_2.png)
+
+Remix should automatically match a suitable compiler version. However, hitting the "Compile" button will most likely generate a "Stack too deep" error:
+
+![Stack too deep](@site/static/img/how-tos/solidity_verifier_3.png)
+
+This is due to the verify function needing to put many variables on the stack, but enabling the optimizer resolves the issue. To do this, let's open the "Advanced Configurations" tab and enable optimization. The default 200 runs will suffice.
+
+:::info
+
+This time we will see a warning about an unused function parameter. This is expected, as the `verify` function doesn't use the `_proof` parameter inside a solidity block, it is loaded from calldata and used in assembly.
+
+:::
+
+![Compilation success](@site/static/img/how-tos/solidity_verifier_4.png)
+
+## Step 3 - Deploying
+
+At this point we should have a compiled contract ready to deploy. If we navigate to the deploy section in Remix, we will see many different environments we can deploy to. The steps to deploy on each environment would be out-of-scope for this guide, so we will just use the default Remix VM.
+
+Looking closely, we will notice that our "Solidity Verifier" is actually three contracts working together:
+
+- An `UltraVerificationKey` library which simply stores the verification key for our circuit.
+- An abstract contract `BaseUltraVerifier` containing most of the verifying logic.
+- A main `UltraVerifier` contract that inherits from the Base and uses the Key contract.
+
+Remix will take care of the dependencies for us so we can simply deploy the UltraVerifier contract by selecting it and hitting "deploy":
+
+![Deploying UltraVerifier](@site/static/img/how-tos/solidity_verifier_5.png)
+
+A contract will show up in the "Deployed Contracts" section, where we can retrieve the Verification Key Hash. This is particularly useful for double-checking that the deployer contract is the correct one.
+
+:::note
+
+Why "UltraVerifier"?
+
+To be precise, the Noir compiler (`nargo`) doesn't generate the verifier contract directly. It compiles the Noir code into an intermediate language (ACIR), which is then executed by the backend. So it is the backend that returns the verifier smart contract, not Noir.
+
+In this case, the Barretenberg Backend uses the UltraPlonk proving system, hence the "UltraVerifier" name.
+
+:::
+
+## Step 4 - Verifying
+
+To verify a proof using the Solidity verifier contract, we call the `verify` function in this extended contract:
+
+```solidity
+function verify(bytes calldata _proof, bytes32[] calldata _publicInputs) external view returns (bool)
+```
+
+When using the default example in the [Hello Noir](../getting_started/quick_start.md) guide, the easiest way to confirm that the verifier contract is doing its job is by calling the `verify` function via remix with the required parameters. Note that the public inputs must be passed in separately to the rest of the proof so we must split the proof as returned from `bb`.
+
+First generate a proof with `bb` at the location `./proof` using the steps in [get started](../getting_started/quick_start.md), this proof is in a binary format but we want to convert it into a hex string to pass into Remix, this can be done with the
+
+```bash
+# This value must be changed to match the number of public inputs (including return values!) in your program.
+NUM_PUBLIC_INPUTS=1
+PUBLIC_INPUT_BYTES=32*NUM_PUBLIC_INPUTS
+HEX_PUBLIC_INPUTS=$(head -c $PUBLIC_INPUT_BYTES ./proof | od -An -v -t x1 | tr -d $' \n')
+HEX_PROOF=$(tail -c +$(($PUBLIC_INPUT_BYTES + 1)) ./proof | od -An -v -t x1 | tr -d $' \n')
+
+echo "Public inputs:"
+echo $HEX_PUBLIC_INPUTS
+
+echo "Proof:"
+echo "0x$HEX_PROOF"
+```
+
+Remix expects that the public inputs will be split into an array of `bytes32` values so `HEX_PUBLIC_INPUTS` needs to be split up into 32 byte chunks which are prefixed with `0x` accordingly.
+
+A programmatic example of how the `verify` function is called can be seen in the example zk voting application [here](https://github.com/noir-lang/noir-examples/blob/33e598c257e2402ea3a6b68dd4c5ad492bce1b0a/foundry-voting/src/zkVote.sol#L35):
+
+```solidity
+function castVote(bytes calldata proof, uint proposalId, uint vote, bytes32 nullifierHash) public returns (bool) {
+  // ...
+  bytes32[] memory publicInputs = new bytes32[](4);
+  publicInputs[0] = merkleRoot;
+  publicInputs[1] = bytes32(proposalId);
+  publicInputs[2] = bytes32(vote);
+  publicInputs[3] = nullifierHash;
+  require(verifier.verify(proof, publicInputs), "Invalid proof");
+```
+
+:::info[Return Values]
+
+A circuit doesn't have the concept of a return value. Return values are just syntactic sugar in Noir.
+
+Under the hood, the return value is passed as an input to the circuit and is checked at the end of the circuit program.
+
+For example, if you have Noir program like this:
+
+```rust
+fn main(
+    // Public inputs
+    pubkey_x: pub Field,
+    pubkey_y: pub Field,
+    // Private inputs
+    priv_key: Field,
+) -> pub Field
+```
+
+the `verify` function will expect the public inputs array (second function parameter) to be of length 3, the two inputs and the return value.
+
+Passing only two inputs will result in an error such as `PUBLIC_INPUT_COUNT_INVALID(3, 2)`.
+
+In this case, the inputs parameter to `verify` would be an array ordered as `[pubkey_x, pubkey_y, return`.
+
+:::
+
+:::tip[Structs]
+
+You can pass structs to the verifier contract. They will be flattened so that the array of inputs is 1-dimensional array.
+
+For example, consider the following program:
+
+```rust
+struct Type1 {
+  val1: Field,
+  val2: Field,
+}
+
+struct Nested {
+  t1: Type1,
+  is_true: bool,
+}
+
+fn main(x: pub Field, nested: pub Nested, y: pub Field) {
+  //...
+}
+```
+
+The order of these inputs would be flattened to: `[x, nested.t1.val1, nested.t1.val2, nested.is_true, y]`
+
+:::
+
+The other function you can call is our entrypoint `verify` function, as defined above.
+
+:::tip
+
+It's worth noticing that the `verify` function is actually a `view` function. A `view` function does not alter the blockchain state, so it doesn't need to be distributed (i.e. it will run only on the executing node), and therefore doesn't cost any gas.
+
+This can be particularly useful in some situations. If Alice generated a proof and wants Bob to verify its correctness, Bob doesn't need to run Nargo, NoirJS, or any Noir specific infrastructure. He can simply make a call to the blockchain with the proof and verify it is correct without paying any gas.
+
+It would be incorrect to say that a Noir proof verification costs any gas at all. However, most of the time the result of `verify` is used to modify state (for example, to update a balance, a game state, etc). In that case the whole network needs to execute it, which does incur gas costs (calldata and execution, but not storage).
+
+:::
+
+## A Note on EVM chains
+
+Noir proof verification requires the ecMul, ecAdd and ecPairing precompiles. Not all EVM chains support EC Pairings, notably some of the ZK-EVMs. This means that you won't be able to use the verifier contract in all of them. You can find an incomplete list of which EVM chains support these precompiles [here](https://www.evmdiff.com/features?feature=precompiles).
+
+For example, chains like `zkSync ERA` and `Polygon zkEVM` do not currently support these precompiles, so proof verification via Solidity verifier contracts won't work. Here's a quick list of EVM chains that have been tested and are known to work:
+
+- Optimism
+- Arbitrum
+- Polygon PoS
+- Scroll
+- Celo
+- BSC
+- Blast L2
+- Avalanche C-Chain
+- Mode
+- Linea
+- Moonbeam
+
+If you test any other chains, please open a PR on this page to update the list. See [this doc](https://github.com/noir-lang/noir-starter/tree/main/with-foundry#testing-on-chain) for more info about testing verifier contracts on different EVM chains.
+
+## What's next
+
+Now that you know how to call a Noir Solidity Verifier on a smart contract using Remix, you should be comfortable with using it with some programmatic frameworks, such as [hardhat](https://github.com/noir-lang/noir-starter/tree/main/vite-hardhat) and [foundry](https://github.com/noir-lang/noir-starter/tree/main/with-foundry).
+
+You can find other tools, examples, boilerplates and libraries in the [awesome-noir](https://github.com/noir-lang/awesome-noir) repository.
+
+You should also be ready to write and deploy your first NoirJS app and start generating proofs on websites, phones, and NodeJS environments! Head on to the [NoirJS tutorial](../tutorials/noirjs_app.md) to learn how to do that.
diff --git a/docs/versioned_docs/version-v0.36.0/how_to/merkle-proof.mdx b/docs/versioned_docs/version-v0.36.0/how_to/merkle-proof.mdx
new file mode 100644
index 00000000000..0a128adb2de
--- /dev/null
+++ b/docs/versioned_docs/version-v0.36.0/how_to/merkle-proof.mdx
@@ -0,0 +1,48 @@
+---
+title: Prove Merkle Tree Membership
+description:
+  Learn how to use merkle membership proof in Noir to prove that a given leaf is a member of a
+  merkle tree with a specified root, at a given index.
+keywords:
+  [merkle proof, merkle membership proof, Noir, rust, hash function, Pedersen, sha256, merkle tree]
+sidebar_position: 4
+---
+
+Let's walk through an example of a merkle membership proof in Noir that proves that a given leaf is
+in a merkle tree.
+
+```rust
+
+fn main(message : [Field; 62], index : Field, hashpath : [Field; 40], root : Field) {
+    let leaf = std::hash::hash_to_field(message.as_slice());
+    let merkle_root = std::merkle::compute_merkle_root(leaf, index, hashpath);
+    assert(merkle_root == root);
+}
+
+```
+
+The message is hashed using `hash_to_field`. The specific hash function that is being used is chosen
+by the backend. The only requirement is that this hash function can heuristically be used as a
+random oracle. If only collision resistance is needed, then one can call `std::hash::pedersen_hash`
+instead.
+
+```rust
+let leaf = std::hash::hash_to_field(message.as_slice());
+```
+
+The leaf is then passed to a compute_merkle_root function with the root, index and hashpath. The returned root can then be asserted to be the same as the provided root.
+
+```rust
+let merkle_root = std::merkle::compute_merkle_root(leaf, index, hashpath);
+assert (merkle_root == root);
+```
+
+> **Note:** It is possible to re-implement the merkle tree implementation without standard library.
+> However, for most usecases, it is enough. In general, the standard library will always opt to be
+> as conservative as possible, while striking a balance with efficiency.
+
+An example, the merkle membership proof, only requires a hash function that has collision
+resistance, hence a hash function like Pedersen is allowed, which in most cases is more efficient
+than the even more conservative sha256.
+
+[View an example on the starter repo](https://github.com/noir-lang/noir-examples/blob/3ea09545cabfa464124ec2f3ea8e60c608abe6df/stealthdrop/circuits/src/main.nr#L20)
diff --git a/docs/versioned_docs/version-v0.36.0/how_to/using-devcontainers.mdx b/docs/versioned_docs/version-v0.36.0/how_to/using-devcontainers.mdx
new file mode 100644
index 00000000000..727ec6ca667
--- /dev/null
+++ b/docs/versioned_docs/version-v0.36.0/how_to/using-devcontainers.mdx
@@ -0,0 +1,110 @@
+---
+title: Developer Containers and Codespaces
+description: "Learn how to set up a devcontainer in your GitHub repository for a seamless coding experience with Codespaces. Follow our easy 8-step guide to create your own Noir environment without installing Nargo locally."
+keywords: ["Devcontainer", "Codespaces", "GitHub", "Noir Environment", "Docker Image", "Development Environment", "Remote Coding", "GitHub Codespaces", "Noir Programming", "Nargo", "VSCode Extensions", "Noirup"]
+sidebar_position: 1
+---
+
+Adding a developer container configuration file to your Noir project is one of the easiest way to unlock coding in browser.
+
+## What's a devcontainer after all?
+
+A [Developer Container](https://containers.dev/) (devcontainer for short) is a Docker image that comes preloaded with tools, extensions, and other tools you need to quickly get started or continue a project, without having to install Nargo locally. Think of it as a development environment in a box.
+
+There are many advantages to this:
+
+- It's platform and architecture agnostic
+- You don't need to have an IDE installed, or Nargo, or use a terminal at all
+- It's safer for using on a public machine or public network
+
+One of the best ways of using devcontainers is... not using your machine at all, for maximum control, performance, and ease of use.
+Enter Codespaces.
+
+## Codespaces
+
+If a devcontainer is just a Docker image, then what stops you from provisioning a `p3dn.24xlarge` AWS EC2 instance with 92 vCPUs and 768 GiB RAM and using it to prove your 10-gate SNARK proof? 
+
+Nothing! Except perhaps the 30-40$ per hour it will cost you. 
+
+The problem is that provisioning takes time, and I bet you don't want to see the AWS console every time you want to code something real quick.
+
+Fortunately, there's an easy and free way to get a decent remote machine ready and loaded in less than 2 minutes: Codespaces. [Codespaces is a Github feature](https://github.com/features/codespaces) that allows you to code in a remote machine by using devcontainers, and it's pretty cool:
+
+- You can start coding Noir in less than a minute
+- It uses the resources of a remote machine, so you can code on your grandma's phone if needed be
+- It makes it easy to share work with your frens
+- It's fully reusable, you can stop and restart whenever you need to
+
+:::info
+
+Don't take out your wallet just yet. Free GitHub accounts get about [15-60 hours of coding](https://github.com/features/codespaces) for free per month, depending on the size of your provisioned machine.
+
+:::
+
+## Tell me it's _actually_ easy
+
+It is!
+
+Github comes with a default codespace and you can use it to code your own devcontainer. That's exactly what we will be doing in this guide.
+
+<video width="100%" height="auto" controls>
+  <source src={require('@site/static/video/how-tos/devcontainer.mp4').default} type="video/mp4" />
+  Your browser does not support the video tag.
+</video>
+
+8 simple steps:
+
+#### 1. <a href="https://github.com/new" target="_blank">Create a new repository</a> on GitHub.
+
+#### 2. Click "Start coding with Codespaces". This will use the default image.
+
+#### 3. Create a folder called `.devcontainer` in the root of your repository.
+
+#### 4. Create a Dockerfile in that folder, and paste the following code:
+
+```docker
+FROM --platform=linux/amd64 node:lts-bookworm-slim
+SHELL ["/bin/bash", "-c"]
+RUN apt update && apt install -y curl bash git tar gzip libc++-dev
+RUN curl -L https://raw.githubusercontent.com/noir-lang/noirup/main/install | bash
+ENV PATH="/root/.nargo/bin:$PATH"
+RUN noirup
+ENTRYPOINT ["nargo"]
+```
+#### 5. Create a file called `devcontainer.json` in the same folder, and paste the following code:
+
+```json
+{
+ "name": "Noir on Codespaces",
+ "build": {
+    "context": ".",
+    "dockerfile": "Dockerfile"
+  },
+  "customizations": {
+    "vscode": {
+      "extensions": ["noir-lang.vscode-noir"]
+    }
+  }
+}
+```
+#### 6. Commit and push your changes
+
+This will pull the new image and build it, so it could take a minute or so
+
+#### 8. Done! 
+Just wait for the build to finish, and there's your easy Noir environment.
+
+
+Refer to [noir-starter](https://github.com/noir-lang/noir-starter/) as an example of how devcontainers can be used together with codespaces.
+
+
+
+## How do I use it?
+
+Using the codespace is obviously much easier than setting it up. 
+Just navigate to your repository and click "Code" -> "Open with Codespaces". It should take a few seconds to load, and you're ready to go.
+
+:::info
+
+If you really like the experience, you can add a badge to your readme, links to existing codespaces, and more. 
+Check out the [official docs](https://docs.github.com/en/codespaces/setting-up-your-project-for-codespaces/setting-up-your-repository/facilitating-quick-creation-and-resumption-of-codespaces) for more info.
diff --git a/docs/versioned_docs/version-v0.36.0/index.mdx b/docs/versioned_docs/version-v0.36.0/index.mdx
new file mode 100644
index 00000000000..5c116a73b3f
--- /dev/null
+++ b/docs/versioned_docs/version-v0.36.0/index.mdx
@@ -0,0 +1,76 @@
+---
+title: Noir Lang
+hide_title: true
+description:
+  Learn about the public alpha release of Noir, a domain specific language heavily influenced by Rust that compiles to
+  an intermediate language which can be compiled to an arithmetic circuit or a rank-1 constraint system.
+keywords:
+    [Noir,
+    Domain Specific Language,
+    Rust,
+    Intermediate Language,
+    Arithmetic Circuit,
+    Rank-1 Constraint System,
+    Ethereum Developers,
+    Protocol Developers,
+    Blockchain Developers,
+    Proving System,
+    Smart Contract Language]
+sidebar_position: 0
+---
+
+import Tabs from '@theme/Tabs';
+import TabItem from '@theme/TabItem';
+import ThemedImage from '@theme/ThemedImage';
+import useBaseUrl from '@docusaurus/useBaseUrl';
+
+<ThemedImage
+  sources={{
+    light: useBaseUrl("/img/logoDark.png"),
+    dark: useBaseUrl("/img/logo.png"),
+  }}
+  style={{display: "block", width: "50%", margin: "2rem auto"}} 
+  alt="Noir Logo" 
+/>
+
+Noir is an open-source Domain-Specific Language for safe and seamless construction of privacy-preserving Zero-Knowledge programs, requiring no previous knowledge on the underlying mathematics or cryptography.
+
+ZK programs are programs that can generate short proofs of statements without revealing all inputs to the statements. You can read more about Zero-Knowledge Proofs [here](https://dev.to/spalladino/a-beginners-intro-to-coding-zero-knowledge-proofs-c56).
+
+## What's new about Noir?
+
+Noir works differently from most ZK languages by taking a two-pronged path. First, it compiles the program to an adaptable intermediate language known as ACIR. From there, depending on a given project's needs, ACIR can be further compiled into an arithmetic circuit for integration with the proving backend.
+
+:::info
+
+Noir is backend agnostic, which means it makes no assumptions on which proving backend powers the ZK proof. Being the language that powers [Aztec Contracts](https://docs.aztec.network/developers/contracts/main), it defaults to Aztec's Barretenberg proving backend.
+
+However, the ACIR output can be transformed to be compatible with other PLONK-based backends, or into a [rank-1 constraint system](https://www.rareskills.io/post/rank-1-constraint-system) suitable for backends such as Arkwork's Marlin.
+
+:::
+
+## Who is Noir for?
+
+Noir can be used both in complex cloud-based backends and in user's smartphones, requiring no knowledge on the underlying math or cryptography. From authorization systems that keep a password in the user's device, to complex on-chain verification of recursive proofs, Noir is designed to abstract away complexity without any significant overhead. Here are some examples of situations where Noir can be used:
+
+<Tabs>
+  <TabItem value="Aztec Contracts" label="Aztec Contracts" default>
+    <img src={require("@site/static/img/aztec_logo.png").default} style={{display: "block", width: "50%", margin: "2rem auto"}} alt="Noir Logo"  />
+    
+    Aztec Contracts leverage Noir to allow for the storage and execution of private information. Writing an Aztec Contract is as easy as writing Noir, and Aztec developers can easily interact with the network storage and execution through the [Aztec.nr](https://docs.aztec.network/developers/contracts/main) library.
+  </TabItem>
+  <TabItem value="Solidity Verifiers" label="Solidity Verifiers">
+    <img src={require("@site/static/img/solidity_verifier_ex.png").default} style={{display: "block", margin: "2rem auto"}} alt="Soliditry Verifier Example"  />
+    Noir can auto-generate Solidity verifier contracts that verify Noir proofs. This allows for non-interactive verification of proofs containing private information in an immutable system. This feature powers a multitude of use-case scenarios, from P2P chess tournaments, to [Aztec Layer-2 Blockchain](https://docs.aztec.network/)
+  </TabItem>
+  <TabItem value="Full-Stack Development" label="Full-Stack Development">
+    Aztec Labs developed NoirJS, an easy interface to generate and verify Noir proofs in a Javascript environment. This allows for Noir to be used in webpages, mobile apps, games, and any other environment supporting JS execution in a standalone manner.
+  </TabItem>
+</Tabs>
+
+
+## Libraries
+
+Noir is meant to be easy to extend by simply importing Noir libraries just like in Rust. 
+The [awesome-noir repo](https://github.com/noir-lang/awesome-noir#libraries) is a collection of libraries developed by the Noir community.
+Writing a new library is easy and makes code be composable and easy to reuse. See the section on [dependencies](noir/modules_packages_crates/dependencies.md) for more information.
diff --git a/docs/versioned_docs/version-v0.36.0/migration_notes.md b/docs/versioned_docs/version-v0.36.0/migration_notes.md
new file mode 100644
index 00000000000..6bd740024e5
--- /dev/null
+++ b/docs/versioned_docs/version-v0.36.0/migration_notes.md
@@ -0,0 +1,105 @@
+---
+title: Migration notes
+description: Read about migration notes from previous versions, which could solve problems while updating
+keywords: [Noir, notes, migration, updating, upgrading]
+---
+
+Noir is in full-speed development. Things break fast, wild, and often. This page attempts to leave some notes on errors you might encounter when upgrading and how to resolve them until proper patches are built.
+
+### `backend encountered an error: libc++.so.1`
+
+Depending on your OS, you may encounter the following error when running `nargo prove` for the first time:
+
+```text
+The backend encountered an error: "/home/codespace/.nargo/backends/acvm-backend-barretenberg/backend_binary: error while loading shared libraries: libc++.so.1: cannot open shared object file: No such file or directory\n"
+```
+
+Install the `libc++-dev` library with:
+
+```bash
+sudo apt install libc++-dev
+```
+
+## ≥0.19
+
+### Enforcing `compiler_version`
+
+From this version on, the compiler will check for the `compiler_version` field in `Nargo.toml`, and will error if it doesn't match the current Nargo version in use.
+
+To update, please make sure this field in `Nargo.toml` matches the output of `nargo --version`.
+
+## ≥0.14
+
+The index of the [for loops](noir/concepts/control_flow.md#loops) is now of type `u64` instead of `Field`. An example refactor would be:
+
+```rust
+for i in 0..10 {
+    let i = i as Field;
+}
+```
+
+## ≥v0.11.0 and Nargo backend
+
+From this version onwards, Nargo starts managing backends through the `nargo backend` command. Upgrading to the versions per usual steps might lead to:
+
+### `backend encountered an error`
+
+This is likely due to the existing locally installed version of proving backend (e.g. barretenberg) is incompatible with the version of Nargo in use.
+
+To fix the issue:
+
+1. Uninstall the existing backend
+
+```bash
+nargo backend uninstall acvm-backend-barretenberg
+```
+
+You may replace _acvm-backend-barretenberg_ with the name of your backend listed in `nargo backend ls` or in ~/.nargo/backends.
+
+2. Reinstall a compatible version of the proving backend.
+
+If you are using the default barretenberg backend, simply run:
+
+```
+nargo prove
+```
+
+with your Noir program.
+
+This will trigger the download and installation of the latest version of barretenberg compatible with your Nargo in use.
+
+### `backend encountered an error: illegal instruction`
+
+On certain Intel-based systems, an `illegal instruction` error may arise due to incompatibility of barretenberg with certain CPU instructions.
+
+To fix the issue:
+
+1. Uninstall the existing backend
+
+```bash
+nargo backend uninstall acvm-backend-barretenberg
+```
+
+You may replace _acvm-backend-barretenberg_ with the name of your backend listed in `nargo backend ls` or in ~/.nargo/backends.
+
+2. Reinstall a compatible version of the proving backend.
+
+If you are using the default barretenberg backend, simply run:
+
+```
+nargo backend install acvm-backend-barretenberg https://github.com/noir-lang/barretenberg-js-binary/raw/master/run-bb.tar.gz
+```
+
+This downloads and installs a specific bb.js based version of barretenberg binary from GitHub.
+
+The gzipped file is running [this bash script](https://github.com/noir-lang/barretenberg-js-binary/blob/master/run-bb-js.sh), where we need to gzip it as the Nargo currently expect the backend to be zipped up.
+
+Then run:
+
+```
+DESIRED_BINARY_VERSION=0.8.1 nargo info
+```
+
+This overrides the bb native binary with a bb.js node application instead, which should be compatible with most if not all hardware. This does come with the drawback of being generally slower than native binary.
+
+0.8.1 indicates bb.js version 0.8.1, so if you change that it will update to a different version or the default version in the script if none was supplied.
diff --git a/docs/versioned_docs/version-v0.36.0/noir/concepts/_category_.json b/docs/versioned_docs/version-v0.36.0/noir/concepts/_category_.json
new file mode 100644
index 00000000000..7da08f8a8c5
--- /dev/null
+++ b/docs/versioned_docs/version-v0.36.0/noir/concepts/_category_.json
@@ -0,0 +1,6 @@
+{
+    "label": "Concepts",
+    "position": 0,
+    "collapsible": true,
+    "collapsed": true
+}
\ No newline at end of file
diff --git a/docs/versioned_docs/version-v0.36.0/noir/concepts/assert.md b/docs/versioned_docs/version-v0.36.0/noir/concepts/assert.md
new file mode 100644
index 00000000000..2132de42072
--- /dev/null
+++ b/docs/versioned_docs/version-v0.36.0/noir/concepts/assert.md
@@ -0,0 +1,78 @@
+---
+title: Assert Function
+description:
+  Learn about the `assert` and `static_assert` functions in Noir, which can be used to explicitly
+  constrain the predicate or comparison expression that follows to be true, and what happens if
+  the expression is false at runtime or compile-time, respectively.
+keywords: [Noir programming language, assert statement, predicate expression, comparison expression]
+sidebar_position: 4
+---
+
+Noir includes a special `assert` function which will explicitly constrain the predicate/comparison
+expression that follows to be true. If this expression is false at runtime, the program will fail to
+be proven. Example:
+
+```rust
+fn main(x : Field, y : Field) {
+    assert(x == y);
+}
+```
+
+> Assertions only work for predicate operations, such as `==`. If there's any ambiguity on the operation, the program will fail to compile. For example, it is unclear if `assert(x + y)` would check for `x + y == 0` or simply would return `true`.
+
+You can optionally provide a message to be logged when the assertion fails:
+
+```rust
+assert(x == y, "x and y are not equal");
+```
+
+Aside string literals, the optional message can be a format string or any other type supported as input for Noir's [print](../standard_library/logging.md) functions. This feature lets you incorporate runtime variables into your failed assertion logs:
+
+```rust
+assert(x == y, f"Expected x == y, but got {x} == {y}");
+```
+
+Using a variable as an assertion message directly:
+
+```rust
+struct myStruct {
+  myField: Field
+}
+
+let s = myStruct { myField: y };
+assert(s.myField == x, s);
+```
+
+There is also a special `static_assert` function that behaves like `assert`,
+but that runs at compile-time.
+
+```rust
+fn main(xs: [Field; 3]) {
+    let x = 2 + 2;
+    let y = 4;
+    static_assert(x == y, "expected 2 + 2 to equal 4");
+
+    // This passes since the length of `xs` is known at compile-time
+    static_assert(xs.len() == 3, "expected the input to have 3 elements");
+}
+```
+
+This function fails when passed a dynamic (run-time) argument:
+
+```rust
+fn main(x : Field, y : Field) {
+    // this fails because `x` is not known at compile-time
+    static_assert(x == 2, "expected x to be known at compile-time and equal to 2");
+
+    let mut example_slice = &[];
+    if y == 4 {
+        example_slice = example_slice.push_back(0);
+    }
+
+    // This fails because the length of `example_slice` is not known at
+    // compile-time
+    let error_message = "expected an empty slice, known at compile-time";
+    static_assert(example_slice.len() == 0, error_message);
+}
+```
+
diff --git a/docs/versioned_docs/version-v0.36.0/noir/concepts/comments.md b/docs/versioned_docs/version-v0.36.0/noir/concepts/comments.md
new file mode 100644
index 00000000000..b51a85f5c94
--- /dev/null
+++ b/docs/versioned_docs/version-v0.36.0/noir/concepts/comments.md
@@ -0,0 +1,33 @@
+---
+title: Comments
+description:
+  Learn how to write comments in Noir programming language. A comment is a line of code that is
+  ignored by the compiler, but it can be read by programmers. Single-line and multi-line comments
+  are supported in Noir.
+keywords: [Noir programming language, comments, single-line comments, multi-line comments]
+sidebar_position: 10
+---
+
+A comment is a line in your codebase which the compiler ignores, however it can be read by
+programmers.
+
+Here is a single line comment:
+
+```rust
+// This is a comment and is ignored
+```
+
+`//` is used to tell the compiler to ignore the rest of the line.
+
+Noir also supports multi-line block comments. Start a block comment with `/*` and end the block with `*/`.
+
+Noir does not natively support doc comments. You may be able to use [Rust doc comments](https://doc.rust-lang.org/reference/comments.html) in your code to leverage some Rust documentation build tools with Noir code.
+
+```rust
+/*
+  This is a block comment describing a complex function.
+*/
+fn main(x : Field, y : pub Field) {
+    assert(x != y);
+}
+```
diff --git a/docs/versioned_docs/version-v0.36.0/noir/concepts/comptime.md b/docs/versioned_docs/version-v0.36.0/noir/concepts/comptime.md
new file mode 100644
index 00000000000..ba837174639
--- /dev/null
+++ b/docs/versioned_docs/version-v0.36.0/noir/concepts/comptime.md
@@ -0,0 +1,445 @@
+---
+title: Compile-time Code & Metaprogramming
+description: Learn how to use metaprogramming in Noir to create macros or derive your own traits
+keywords: [Noir, comptime, compile-time, metaprogramming, macros, quote, unquote]
+sidebar_position: 15
+---
+
+# Overview
+
+Metaprogramming in Noir is comprised of three parts:
+1. `comptime` code
+2. Quoting and unquoting
+3. The metaprogramming API in `std::meta`
+
+Each of these are explained in more detail in the next sections but the wide picture is that
+`comptime` allows us to write code which runs at compile-time. In this `comptime` code we
+can quote and unquote snippets of the program, manipulate them, and insert them in other
+parts of the program. Comptime functions which do this are said to be macros. Additionally,
+there's a compile-time API of built-in types and functions provided by the compiler which allows
+for greater analysis and modification of programs.
+
+---
+
+# Comptime
+
+`comptime` is a new keyword in Noir which marks an item as executing or existing at compile-time. It can be used in several ways:
+
+- `comptime fn` to define functions which execute exclusively during compile-time.
+- `comptime global` to define a global variable which is evaluated at compile-time.
+  - Unlike runtime globals, `comptime global`s can be mutable.
+- `comptime { ... }` to execute a block of statements during compile-time.
+- `comptime let` to define a variable whose value is evaluated at compile-time.
+- `comptime for` to run a for loop at compile-time. Syntax sugar for `comptime { for .. }`.
+
+## Scoping
+
+Note that while in a `comptime` context, any runtime variables _local to the current function_ are never visible.
+
+## Evaluating
+
+Evaluation rules of `comptime` follows the normal unconstrained evaluation rules for other Noir code. There are a few things to note though:
+
+- Certain built-in functions may not be available, although more may be added over time.
+- Evaluation order of global items is currently unspecified. For example, given the following two functions we can't guarantee
+which `println` will execute first. The ordering of the two printouts will be arbitrary, but should be stable across multiple compilations with the same `nargo` version as long as the program is also unchanged.
+
+```rust
+fn one() {
+    comptime { println("one"); }
+}
+
+fn two() {
+    comptime { println("two"); }
+}
+```
+
+- Since evaluation order is unspecified, care should be taken when using mutable globals so that they do not rely on a particular ordering.
+For example, using globals to generate unique ids should be fine but relying on certain ids always being produced (especially after edits to the program) should be avoided.
+- Although most ordering of globals is unspecified, two are:
+  - Dependencies of a crate will always be evaluated before the dependent crate.
+  - Any annotations on a function will be run before the function itself is resolved. This is to allow the annotation to modify the function if necessary. Note that if the
+    function itself was called at compile-time previously, it will already be resolved and cannot be modified. To prevent accidentally calling functions you wish to modify
+    at compile-time, it may be helpful to sort your `comptime` annotation functions into a different crate along with any dependencies they require.
+
+## Lowering
+
+When a `comptime` value is used in runtime code it must be lowered into a runtime value. This means replacing the expression with the literal that it evaluated to. For example, the code:
+
+```rust
+struct Foo { array: [Field; 2], len: u32 }
+
+fn main() {
+    println(comptime {
+        let mut foo = std::mem::zeroed::<Foo>();
+        foo.array[0] = 4;
+        foo.len = 1;
+        foo
+    });
+}
+```
+
+will be converted to the following after `comptime` expressions are evaluated:
+
+```rust
+struct Foo { array: [Field; 2], len: u32 }
+
+fn main() {
+    println(Foo { array: [4, 0], len: 1 });
+}
+```
+
+Not all types of values can be lowered. For example, `Type`s and `TypeDefinition`s (among other types) cannot be lowered at all.
+
+```rust
+fn main() {
+    // There's nothing we could inline here to create a Type value at runtime
+    // let _ = get_type!();
+}
+
+comptime fn get_type() -> Type { ... }
+```
+
+---
+
+# (Quasi) Quote
+
+Macros in Noir are `comptime` functions which return code as a value which is inserted into the call site when it is lowered there.
+A code value in this case is of type `Quoted` and can be created by a `quote { ... }` expression.
+More specifically, the code value `quote` creates is a token stream - a representation of source code as a series of words, numbers, string literals, or operators.
+For example, the expression `quote { Hi "there reader"! }` would quote three tokens: the word "hi", the string "there reader", and an exclamation mark.
+You'll note that snippets that would otherwise be invalid syntax can still be quoted.
+
+When a `Quoted` value is used in runtime code, it is lowered into a `quote { ... }` expression. Since this expression is only valid
+in compile-time code however, we'd get an error if we tried this. Instead, we can use macro insertion to insert each token into the
+program at that point, and parse it as an expression. To do this, we have to add a `!` after the function name returning the `Quoted` value.
+If the value was created locally and there is no function returning it, `std::meta::unquote!(_)` can be used instead.
+Calling such a function at compile-time without `!` will just return the `Quoted` value to be further manipulated. For example:
+
+```rust title="quote-example" showLineNumbers 
+comptime fn quote_one() -> Quoted {
+        quote { 1 }
+    }
+
+    #[test]
+    fn returning_versus_macro_insertion() {
+        comptime {
+            // let _a: Quoted = quote { 1 };
+            let _a: Quoted = quote_one();
+
+            // let _b: Field = 1;
+            let _b: Field = quote_one!();
+
+            // Since integers default to fields, if we
+            // want a different type we have to explicitly cast
+            // let _c: i32 = 1 as i32;
+            let _c: i32 = quote_one!() as i32;
+        }
+    }
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/meta/mod.nr#L120-L140" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/meta/mod.nr#L120-L140</a></sub></sup>
+
+
+For those familiar with quoting from other languages (primarily lisps), Noir's `quote` is actually a _quasiquote_.
+This means we can escape the quoting by using the unquote operator to splice values in the middle of quoted code.
+
+# Unquote
+
+The unquote operator `$` is usable within a `quote` expression.
+It takes a variable as an argument, evaluates the variable, and splices the resulting value into the quoted token stream at that point. For example,
+
+```rust
+comptime {
+    let x = 1 + 2;
+    let y = quote { $x + 4 };
+}
+```
+
+The value of `y` above will be the token stream containing `3`, `+`, and `4`. We can also use this to combine `Quoted` values into larger token streams:
+
+```rust
+comptime {
+    let x = quote { 1 + 2 };
+    let y = quote { $x + 4 };
+}
+```
+
+The value of `y` above is now the token stream containing five tokens: `1 + 2 + 4`.
+
+Note that to unquote something, a variable name _must_ follow the `$` operator in a token stream.
+If it is an expression (even a parenthesized one), it will do nothing. Most likely a parse error will be given when the macro is later unquoted.
+
+Unquoting can also be avoided by escaping the `$` with a backslash:
+
+```
+comptime {
+    let x = quote { 1 + 2 };
+
+    // y contains the four tokens: `$x + 4`
+    let y = quote { \$x + 4 };
+}
+```
+
+---
+
+# Annotations
+
+Annotations provide a way to run a `comptime` function on an item in the program.
+When you use an annotation, the function with the same name will be called with that item as an argument:
+
+```rust
+#[my_struct_annotation]
+struct Foo {}
+
+comptime fn my_struct_annotation(s: StructDefinition) {
+    println("Called my_struct_annotation!");
+}
+
+#[my_function_annotation]
+fn foo() {}
+
+comptime fn my_function_annotation(f: FunctionDefinition) {
+    println("Called my_function_annotation!");
+}
+```
+
+Anything returned from one of these functions will be inserted at top-level along with the original item.
+Note that expressions are not valid at top-level so you'll get an error trying to return `3` or similar just as if you tried to write a program containing `3; struct Foo {}`.
+You can insert other top-level items such as trait impls, structs, or functions this way though.
+For example, this is the mechanism used to insert additional trait implementations into the program when deriving a trait impl from a struct:
+
+```rust title="derive-field-count-example" showLineNumbers 
+trait FieldCount {
+        fn field_count() -> u32;
+    }
+
+    #[derive_field_count]
+    struct Bar {
+        x: Field,
+        y: [Field; 2],
+    }
+
+    comptime fn derive_field_count(s: StructDefinition) -> Quoted {
+        let typ = s.as_type();
+        let field_count = s.fields().len();
+        quote {
+            impl FieldCount for $typ {
+                fn field_count() -> u32 {
+                    $field_count
+                }
+            }
+        }
+    }
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/meta/mod.nr#L142-L164" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/meta/mod.nr#L142-L164</a></sub></sup>
+
+
+## Calling annotations with additional arguments
+
+Arguments may optionally be given to annotations.
+When this is done, these additional arguments are passed to the annotation function after the item argument.
+
+```rust title="annotation-arguments-example" showLineNumbers 
+#[assert_field_is_type(quote { i32 }.as_type())]
+    struct MyStruct {
+        my_field: i32,
+    }
+
+    comptime fn assert_field_is_type(s: StructDefinition, typ: Type) {
+        // Assert the first field in `s` has type `typ`
+        let fields = s.fields();
+        assert_eq(fields[0].1, typ);
+    }
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/meta/mod.nr#L166-L177" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/meta/mod.nr#L166-L177</a></sub></sup>
+
+
+We can also take any number of arguments by adding the `varargs` annotation:
+
+```rust title="annotation-varargs-example" showLineNumbers 
+#[assert_three_args(1, 2, 3)]
+    struct MyOtherStruct {
+        my_other_field: u32,
+    }
+
+    #[varargs]
+    comptime fn assert_three_args(_s: StructDefinition, args: [Field]) {
+        assert_eq(args.len(), 3);
+    }
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/meta/mod.nr#L179-L189" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/meta/mod.nr#L179-L189</a></sub></sup>
+
+
+---
+
+# Comptime API
+
+Although `comptime`, `quote`, and unquoting provide a flexible base for writing macros,
+Noir's true metaprogramming ability comes from being able to interact with the compiler through a compile-time API.
+This API can be accessed through built-in functions in `std::meta` as well as on methods of several `comptime` types.
+
+The following is an incomplete list of some `comptime` types along with some useful methods on them.
+
+- `Quoted`: A token stream
+- `Type`: The type of a Noir type
+  - `fn implements(self, constraint: TraitConstraint) -> bool`
+    - Returns true if `self` implements the given trait constraint
+- `Expr`: A syntactically valid expression. Can be used to recur on a program's parse tree to inspect how it is structured.
+  - Methods:
+    - `fn as_function_call(self) -> Option<(Expr, [Expr])>`
+      - If this is a function call expression, return `(function, arguments)`
+    - `fn as_block(self) -> Option<[Expr]>`
+      - If this is a block, return each statement in the block
+- `FunctionDefinition`: A function definition
+  - Methods:
+    - `fn parameters(self) -> [(Quoted, Type)]`
+      - Returns a slice of `(name, type)` pairs for each parameter
+- `StructDefinition`: A struct definition
+  - Methods:
+    - `fn as_type(self) -> Type`
+      - Returns this `StructDefinition` as a `Type`. Any generics are kept as-is
+    - `fn generics(self) -> [Quoted]`
+      - Return the name of each generic on this struct
+    - `fn fields(self) -> [(Quoted, Type)]`
+      - Return the name and type of each field
+- `TraitConstraint`: A trait constraint such as `From<Field>`
+- `TypedExpr`: A type-checked expression.
+- `UnresolvedType`: A syntactic notation that refers to a Noir type that hasn't been resolved yet
+
+There are many more functions available by exploring the `std::meta` module and its submodules.
+Using these methods is the key to writing powerful metaprogramming libraries.
+
+## `#[use_callers_scope]`
+
+Since certain functions such as `Quoted::as_type`, `Expression::as_type`, or `Quoted::as_trait_constraint` will attempt
+to resolve their contents in a particular scope - it can be useful to change the scope they resolve in. By default
+these functions will resolve in the current function's scope which is usually the attribute function they are called in.
+If you're working on a library however, this may be a completely different module or crate to the item you're trying to
+use the attribute on. If you want to be able to use `Quoted::as_type` to refer to types local to the caller's scope for
+example, you can annotate your attribute function with `#[use_callers_scope]`. This will ensure your attribute, and any
+closures it uses, can refer to anything in the caller's scope. `#[use_callers_scope]` also works recursively. So if both
+your attribute function and a helper function it calls use it, then they can both refer to the same original caller.
+
+---
+
+# Example: Derive
+
+Using all of the above, we can write a `derive` macro that behaves similarly to Rust's but is not built into the language.
+From the user's perspective it will look like this:
+
+```rust
+// Example usage
+#[derive(Default, Eq, Ord)]
+struct MyStruct { my_field: u32 }
+```
+
+To implement `derive` we'll have to create a `comptime` function that accepts
+a variable amount of traits.
+
+```rust title="derive_example" showLineNumbers 
+// These are needed for the unconstrained hashmap we're using to store derive functions
+use crate::collections::umap::UHashMap;
+use crate::hash::BuildHasherDefault;
+use crate::hash::poseidon2::Poseidon2Hasher;
+
+// A derive function is one that given a struct definition can
+// create us a quoted trait impl from it.
+pub type DeriveFunction = fn(StructDefinition) -> Quoted;
+
+// We'll keep a global HANDLERS map to keep track of the derive handler for each trait
+comptime mut global HANDLERS: UHashMap<TraitDefinition, DeriveFunction, BuildHasherDefault<Poseidon2Hasher>> =
+    UHashMap::default();
+
+// Given a struct and a slice of traits to derive, create trait impls for each.
+// This function is as simple as iterating over the slice, checking if we have a trait
+// handler registered for the given trait, calling it, and appending the result.
+#[varargs]
+pub comptime fn derive(s: StructDefinition, traits: [TraitDefinition]) -> Quoted {
+    let mut result = quote {};
+
+    for trait_to_derive in traits {
+        let handler = unsafe { HANDLERS.get(trait_to_derive) };
+        assert(handler.is_some(), f"No derive function registered for `{trait_to_derive}`");
+
+        let trait_impl = handler.unwrap()(s);
+        result = quote { $result $trait_impl };
+    }
+
+    result
+}
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/meta/mod.nr#L31-L64" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/meta/mod.nr#L31-L64</a></sub></sup>
+
+
+Registering a derive function could be done as follows:
+
+```rust title="derive_via" showLineNumbers 
+// To register a handler for a trait, just add it to our handlers map
+pub comptime fn derive_via(t: TraitDefinition, f: DeriveFunction) {
+    HANDLERS.insert(t, f);
+}
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/meta/mod.nr#L66-L73" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/meta/mod.nr#L66-L73</a></sub></sup>
+
+
+```rust title="big-derive-usage-example" showLineNumbers 
+// Finally, to register a handler we call the above function as an annotation
+    // with our handler function.
+    #[derive_via(derive_do_nothing)]
+    trait DoNothing {
+        fn do_nothing(self);
+    }
+
+    comptime fn derive_do_nothing(s: StructDefinition) -> Quoted {
+        // This is simplified since we don't handle generics or where clauses!
+        // In a real example we'd likely also need to introduce each of
+        // `s.generics()` as well as a trait constraint for each generic
+        // to ensure they also implement the trait.
+        let typ = s.as_type();
+        quote {
+            impl DoNothing for $typ {
+                fn do_nothing(self) {
+                    // Traits can't tell us what to do
+                    println("something");
+                }
+            }
+        }
+    }
+
+    // Since `DoNothing` is a simple trait which:
+    // 1. Only has one method
+    // 2. Does not have any generics on the trait itself
+    // We can use `std::meta::make_trait_impl` to help us out.
+    // This helper function will generate our impl for us along with any
+    // necessary where clauses and still provides a flexible interface
+    // for us to work on each field on the struct.
+    comptime fn derive_do_nothing_alt(s: StructDefinition) -> Quoted {
+        let trait_name = quote { DoNothing };
+        let method_signature = quote { fn do_nothing(self) };
+
+        // Call `do_nothing` recursively on each field in the struct
+        let for_each_field = |field_name| quote { self.$field_name.do_nothing(); };
+
+        // Some traits like Eq want to join each field expression with something like `&`.
+        // We don't need that here
+        let join_fields_with = quote {};
+
+        // The body function is a spot to insert any extra setup/teardown needed.
+        // We'll insert our println here. Since we recur on each field, we should see
+        // one println for the struct itself, followed by a println for every field (recursively).
+        let body = |body| quote {
+            println("something");
+            $body
+        };
+        crate::meta::make_trait_impl(
+            s,
+            trait_name,
+            method_signature,
+            for_each_field,
+            join_fields_with,
+            body,
+        )
+    }
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/meta/mod.nr#L191-L249" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/meta/mod.nr#L191-L249</a></sub></sup>
+
diff --git a/docs/versioned_docs/version-v0.36.0/noir/concepts/control_flow.md b/docs/versioned_docs/version-v0.36.0/noir/concepts/control_flow.md
new file mode 100644
index 00000000000..b365bb22728
--- /dev/null
+++ b/docs/versioned_docs/version-v0.36.0/noir/concepts/control_flow.md
@@ -0,0 +1,79 @@
+---
+title: Control Flow
+description:
+  Learn how to use loops and if expressions in the Noir programming language. Discover the syntax
+  and examples for for loops and if-else statements.
+keywords: [Noir programming language, loops, for loop, if-else statements, Rust syntax]
+sidebar_position: 2
+---
+
+## If Expressions
+
+Noir supports `if-else` statements. The syntax is most similar to Rust's where it is not required
+for the statement's conditional to be surrounded by parentheses.
+
+```rust
+let a = 0;
+let mut x: u32 = 0;
+
+if a == 0 {
+    if a != 0 {
+        x = 6;
+    } else {
+        x = 2;
+    }
+} else {
+    x = 5;
+    assert(x == 5);
+}
+assert(x == 2);
+```
+
+## Loops
+
+Noir has one kind of loop: the `for` loop. `for` loops allow you to repeat a block of code multiple
+times.
+
+The following block of code between the braces is run 10 times.
+
+```rust
+for i in 0..10 {
+    // do something
+}
+```
+
+Alternatively, `start..=end` can be used for a range that is inclusive on both ends.
+
+The index for loops is of type `u64`.
+
+### Break and Continue
+
+In unconstrained code, `break` and `continue` are also allowed in `for` loops. These are only allowed
+in unconstrained code since normal constrained code requires that Noir knows exactly how many iterations
+a loop may have. `break` and `continue` can be used like so:
+
+```rust
+for i in 0 .. 10 {
+    println("Iteration start")
+
+    if i == 2 {
+        continue;
+    }
+
+    if i == 5 {
+        break;
+    }
+
+    println(i);
+}
+println("Loop end")
+```
+
+When used, `break` will end the current loop early and jump to the statement after the for loop. In the example
+above, the `break` will stop the loop and jump to the `println("Loop end")`.
+
+`continue` will stop the current iteration of the loop, and jump to the start of the next iteration. In the example
+above, `continue` will jump to `println("Iteration start")` when used. Note that the loop continues as normal after this.
+The iteration variable `i` is still increased by one as normal when `continue` is used.
+
+`break` and `continue` cannot currently be used to jump out of more than a single loop at a time.
diff --git a/docs/versioned_docs/version-v0.36.0/noir/concepts/data_bus.mdx b/docs/versioned_docs/version-v0.36.0/noir/concepts/data_bus.mdx
new file mode 100644
index 00000000000..e55e58622ce
--- /dev/null
+++ b/docs/versioned_docs/version-v0.36.0/noir/concepts/data_bus.mdx
@@ -0,0 +1,23 @@
+---
+title: Data Bus
+sidebar_position: 13
+---
+import Experimental from '@site/src/components/Notes/_experimental.mdx';
+
+<Experimental />
+
+The data bus is an optimization that the backend can use to make recursion more efficient.
+In order to use it, you must define some inputs of the program entry points (usually the `main()`
+function) with the `call_data` modifier, and the return values with the `return_data` modifier.
+These modifiers are incompatible with `pub` and `mut` modifiers.
+
+## Example
+
+```rust
+fn main(mut x: u32, y: call_data u32, z: call_data [u32;4] ) -> return_data u32 {
+  let a = z[x];
+  a+y
+}
+```
+
+As a result, both call_data and return_data will be treated as private inputs and encapsulated into a read-only array each, for the backend to process.
diff --git a/docs/versioned_docs/version-v0.36.0/noir/concepts/data_types/_category_.json b/docs/versioned_docs/version-v0.36.0/noir/concepts/data_types/_category_.json
new file mode 100644
index 00000000000..5d694210bbf
--- /dev/null
+++ b/docs/versioned_docs/version-v0.36.0/noir/concepts/data_types/_category_.json
@@ -0,0 +1,5 @@
+{
+    "position": 0,
+    "collapsible": true,
+    "collapsed": true
+}
diff --git a/docs/versioned_docs/version-v0.36.0/noir/concepts/data_types/arrays.md b/docs/versioned_docs/version-v0.36.0/noir/concepts/data_types/arrays.md
new file mode 100644
index 00000000000..289145a8c4d
--- /dev/null
+++ b/docs/versioned_docs/version-v0.36.0/noir/concepts/data_types/arrays.md
@@ -0,0 +1,276 @@
+---
+title: Arrays
+description:
+  Dive into the Array data type in Noir. Grasp its methods, practical examples, and best practices for efficiently using Arrays in your Noir code.
+keywords:
+  [
+    noir,
+    array type,
+    methods,
+    examples,
+    indexing,
+  ]
+sidebar_position: 4
+---
+
+An array is one way of grouping together values into one compound type. Array types can be inferred
+or explicitly specified via the syntax `[<Type>; <Size>]`:
+
+```rust
+fn main(x : Field, y : Field) {
+    let my_arr = [x, y];
+    let your_arr: [Field; 2] = [x, y];
+}
+```
+
+Here, both `my_arr` and `your_arr` are instantiated as an array containing two `Field` elements.
+
+Array elements can be accessed using indexing:
+
+```rust
+fn main() {
+    let a = [1, 2, 3, 4, 5];
+
+    let first = a[0];
+    let second = a[1];
+}
+```
+
+All elements in an array must be of the same type (i.e. homogeneous). That is, an array cannot group
+a `Field` value and a `u8` value together for example.
+
+You can write mutable arrays, like:
+
+```rust
+fn main() {
+    let mut arr = [1, 2, 3, 4, 5];
+    assert(arr[0] == 1);
+
+    arr[0] = 42;
+    assert(arr[0] == 42);
+}
+```
+
+You can instantiate a new array of a fixed size with the same value repeated for each element. The following example instantiates an array of length 32 where each element is of type Field and has the value 0.
+
+```rust
+let array: [Field; 32] = [0; 32];
+```
+
+Like in Rust, arrays in Noir are a fixed size. However, if you wish to convert an array to a [slice](./slices.mdx), you can just call `as_slice` on your array:
+
+```rust
+let array: [Field; 32] = [0; 32];
+let sl = array.as_slice()
+```
+
+You can define multidimensional arrays:
+
+```rust
+let array : [[Field; 2]; 2];
+let element = array[0][0];
+```
+
+However, multidimensional slices are not supported. For example, the following code will error at compile time:
+
+```rust
+let slice : [[Field]] = &[];
+```
+
+## Types
+
+You can create arrays of primitive types or structs. There is not yet support for nested arrays
+(arrays of arrays) or arrays of structs that contain arrays.
+
+## Methods
+
+For convenience, the STD provides some ready-to-use, common methods for arrays.
+Each of these functions are located within the generic impl `impl<T, N> [T; N] {`.
+So anywhere `self` appears, it refers to the variable `self: [T; N]`.
+
+### len
+
+Returns the length of an array
+
+```rust
+fn len(self) -> Field
+```
+
+example
+
+```rust
+fn main() {
+    let array = [42, 42];
+    assert(array.len() == 2);
+}
+```
+
+### sort
+
+Returns a new sorted array. The original array remains untouched. Notice that this function will
+only work for arrays of fields or integers, not for any arbitrary type. This is because the sorting
+logic it uses internally is optimized specifically for these values. If you need a sort function to
+sort any type, you should use the function `sort_via` described below.
+
+```rust
+fn sort(self) -> [T; N]
+```
+
+example
+
+```rust
+fn main() {
+    let arr = [42, 32];
+    let sorted = arr.sort();
+    assert(sorted == [32, 42]);
+}
+```
+
+### sort_via
+
+Sorts the array with a custom comparison function. The ordering function must return true if the first argument should be sorted to be before the second argument or is equal to the second argument.
+
+Using this method with an operator like `<` that does not return `true` for equal values will result in an assertion failure for arrays with equal elements.
+
+```rust
+fn sort_via(self, ordering: fn(T, T) -> bool) -> [T; N]
+```
+
+example
+
+```rust
+fn main() {
+    let arr = [42, 32]
+    let sorted_ascending = arr.sort_via(|a, b| a <= b);
+    assert(sorted_ascending == [32, 42]); // verifies
+
+    let sorted_descending = arr.sort_via(|a, b| a >= b);
+    assert(sorted_descending == [32, 42]); // does not verify
+}
+```
+
+### map
+
+Applies a function to each element of the array, returning a new array containing the mapped elements.
+
+```rust
+fn map<U>(self, f: fn(T) -> U) -> [U; N]
+```
+
+example
+
+```rust
+let a = [1, 2, 3];
+let b = a.map(|a| a * 2); // b is now [2, 4, 6]
+```
+
+### fold
+
+Applies a function to each element of the array, returning the final accumulated value. The first
+parameter is the initial value.
+
+```rust
+fn fold<U>(self, mut accumulator: U, f: fn(U, T) -> U) -> U
+```
+
+This is a left fold, so the given function will be applied to the accumulator and first element of
+the array, then the second, and so on. For a given call the expected result would be equivalent to:
+
+```rust
+let a1 = [1];
+let a2 = [1, 2];
+let a3 = [1, 2, 3];
+
+let f = |a, b| a - b;
+a1.fold(10, f)  //=> f(10, 1)
+a2.fold(10, f)  //=> f(f(10, 1), 2)
+a3.fold(10, f)  //=> f(f(f(10, 1), 2), 3)
+```
+
+example:
+
+```rust
+
+fn main() {
+    let arr = [2, 2, 2, 2, 2];
+    let folded = arr.fold(0, |a, b| a + b);
+    assert(folded == 10);
+}
+
+```
+
+### reduce
+
+Same as fold, but uses the first element as the starting element.
+
+Requires `self` to be non-empty.
+
+```rust
+fn reduce(self, f: fn(T, T) -> T) -> T
+```
+
+example:
+
+```rust
+fn main() {
+    let arr = [2, 2, 2, 2, 2];
+    let reduced = arr.reduce(|a, b| a + b);
+    assert(reduced == 10);
+}
+```
+
+### all
+
+Returns true if all the elements satisfy the given predicate
+
+```rust
+fn all(self, predicate: fn(T) -> bool) -> bool
+```
+
+example:
+
+```rust
+fn main() {
+    let arr = [2, 2, 2, 2, 2];
+    let all = arr.all(|a| a == 2);
+    assert(all);
+}
+```
+
+### any
+
+Returns true if any of the elements satisfy the given predicate
+
+```rust
+fn any(self, predicate: fn(T) -> bool) -> bool
+```
+
+example:
+
+```rust
+fn main() {
+    let arr = [2, 2, 2, 2, 5];
+    let any = arr.any(|a| a == 5);
+    assert(any);
+}
+```
+
+### as_str_unchecked
+
+Converts a byte array of type `[u8; N]` to a string. Note that this performs no UTF-8 validation -
+the given array is interpreted as-is as a string.
+
+```rust
+impl<let N: u32> [u8; N] {
+    pub fn as_str_unchecked(self) -> str<N>
+}
+```
+
+example:
+
+```rust
+fn main() {
+    let hi = [104, 105].as_str_unchecked();
+    assert_eq(hi, "hi");
+}
+```
diff --git a/docs/versioned_docs/version-v0.36.0/noir/concepts/data_types/booleans.md b/docs/versioned_docs/version-v0.36.0/noir/concepts/data_types/booleans.md
new file mode 100644
index 00000000000..2507af710e7
--- /dev/null
+++ b/docs/versioned_docs/version-v0.36.0/noir/concepts/data_types/booleans.md
@@ -0,0 +1,28 @@
+---
+title: Booleans
+description:
+  Delve into the Boolean data type in Noir. Understand its methods, practical examples, and best practices for using Booleans in your Noir programs.
+keywords:
+  [
+    noir,
+    boolean type,
+    methods,
+    examples,
+    logical operations,
+  ]
+sidebar_position: 2
+---
+
+
+The `bool` type in Noir has two possible values: `true` and `false`:
+
+```rust
+fn main() {
+    let t = true;
+    let f: bool = false;
+}
+```
+
+The boolean type is most commonly used in conditionals like `if` expressions and `assert`
+statements. More about conditionals is covered in the [Control Flow](../control_flow.md) and
+[Assert Function](../assert.md) sections.
diff --git a/docs/versioned_docs/version-v0.36.0/noir/concepts/data_types/fields.md b/docs/versioned_docs/version-v0.36.0/noir/concepts/data_types/fields.md
new file mode 100644
index 00000000000..f8b1e727816
--- /dev/null
+++ b/docs/versioned_docs/version-v0.36.0/noir/concepts/data_types/fields.md
@@ -0,0 +1,246 @@
+---
+title: Fields
+description:
+  Dive deep into the Field data type in Noir. Understand its methods, practical examples, and best practices to effectively use Fields in your Noir programs.
+keywords:
+  [
+    noir,
+    field type,
+    methods,
+    examples,
+    best practices,
+  ]
+sidebar_position: 0
+---
+
+The field type corresponds to the native field type of the proving backend.
+
+The size of a Noir field depends on the elliptic curve's finite field for the proving backend
+adopted. For example, a field would be a 254-bit integer when paired with the default backend that
+spans the Grumpkin curve.
+
+Fields support integer arithmetic and are often used as the default numeric type in Noir:
+
+```rust
+fn main(x : Field, y : Field)  {
+    let z = x + y;
+}
+```
+
+`x`, `y` and `z` are all private fields in this example. Using the `let` keyword we defined a new
+private value `z` constrained to be equal to `x + y`.
+
+If proving efficiency is of priority, fields should be used as a default for solving problems.
+Smaller integer types (e.g. `u64`) incur extra range constraints.
+
+## Methods
+
+After declaring a Field, you can use these common methods on it:
+
+### to_le_bits
+
+Transforms the field into an array of bits, Little Endian.
+
+```rust title="to_le_bits" showLineNumbers 
+pub fn to_le_bits<let N: u32>(self: Self) -> [u1; N] {}
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/field/mod.nr#L32-L34" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/field/mod.nr#L32-L34</a></sub></sup>
+
+
+example:
+
+```rust title="to_le_bits_example" showLineNumbers 
+fn test_to_le_bits() {
+        let field = 2;
+        let bits: [u1; 8] = field.to_le_bits();
+        assert_eq(bits, [0, 1, 0, 0, 0, 0, 0, 0]);
+    }
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/field/mod.nr#L260-L266" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/field/mod.nr#L260-L266</a></sub></sup>
+
+
+
+### to_be_bits
+
+Transforms the field into an array of bits, Big Endian.
+
+```rust title="to_be_bits" showLineNumbers 
+pub fn to_be_bits<let N: u32>(self: Self) -> [u1; N] {}
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/field/mod.nr#L48-L50" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/field/mod.nr#L48-L50</a></sub></sup>
+
+
+example:
+
+```rust title="to_be_bits_example" showLineNumbers 
+fn test_to_be_bits() {
+        let field = 2;
+        let bits: [u1; 8] = field.to_be_bits();
+        assert_eq(bits, [0, 0, 0, 0, 0, 0, 1, 0]);
+    }
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/field/mod.nr#L251-L257" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/field/mod.nr#L251-L257</a></sub></sup>
+
+
+
+### to_le_bytes
+
+Transforms into an array of bytes, Little Endian
+
+```rust title="to_le_bytes" showLineNumbers 
+pub fn to_le_bytes<let N: u32>(self: Self) -> [u8; N] {
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/field/mod.nr#L61-L63" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/field/mod.nr#L61-L63</a></sub></sup>
+
+
+example:
+
+```rust title="to_le_bytes_example" showLineNumbers 
+fn test_to_le_bytes() {
+        let field = 2;
+        let bits: [u8; 8] = field.to_le_bytes();
+        assert_eq(bits, [2, 0, 0, 0, 0, 0, 0, 0]);
+        assert_eq(Field::from_le_bytes::<8>(bits), field);
+    }
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/field/mod.nr#L279-L286" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/field/mod.nr#L279-L286</a></sub></sup>
+
+
+### to_be_bytes
+
+Transforms into an array of bytes, Big Endian
+
+```rust title="to_be_bytes" showLineNumbers 
+pub fn to_be_bytes<let N: u32>(self: Self) -> [u8; N] {
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/field/mod.nr#L94-L96" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/field/mod.nr#L94-L96</a></sub></sup>
+
+
+example:
+
+```rust title="to_be_bytes_example" showLineNumbers 
+fn test_to_be_bytes() {
+        let field = 2;
+        let bits: [u8; 8] = field.to_be_bytes();
+        assert_eq(bits, [0, 0, 0, 0, 0, 0, 0, 2]);
+        assert_eq(Field::from_be_bytes::<8>(bits), field);
+    }
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/field/mod.nr#L269-L276" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/field/mod.nr#L269-L276</a></sub></sup>
+
+
+
+### to_le_radix
+
+Decomposes into an array over the specified base, Little Endian
+
+```rust title="to_le_radix" showLineNumbers 
+pub fn to_le_radix<let N: u32>(self: Self, radix: u32) -> [u8; N] {
+        // Brillig does not need an immediate radix
+        if !crate::runtime::is_unconstrained() {
+            crate::assert_constant(radix);
+        }
+        self.__to_le_radix(radix)
+    }
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/field/mod.nr#L118-L126" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/field/mod.nr#L118-L126</a></sub></sup>
+
+
+
+example:
+
+```rust title="to_le_radix_example" showLineNumbers 
+fn test_to_le_radix() {
+        let field = 2;
+        let bits: [u8; 8] = field.to_le_radix(256);
+        assert_eq(bits, [2, 0, 0, 0, 0, 0, 0, 0]);
+        assert_eq(Field::from_le_bytes::<8>(bits), field);
+    }
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/field/mod.nr#L299-L306" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/field/mod.nr#L299-L306</a></sub></sup>
+
+
+
+### to_be_radix
+
+Decomposes into an array over the specified base, Big Endian
+
+```rust title="to_be_radix" showLineNumbers 
+pub fn to_be_radix<let N: u32>(self: Self, radix: u32) -> [u8; N] {
+        // Brillig does not need an immediate radix
+        if !crate::runtime::is_unconstrained() {
+            crate::assert_constant(radix);
+        }
+        self.__to_be_radix(radix)
+    }
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/field/mod.nr#L128-L136" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/field/mod.nr#L128-L136</a></sub></sup>
+
+
+example:
+
+```rust title="to_be_radix_example" showLineNumbers 
+fn test_to_be_radix() {
+        let field = 2;
+        let bits: [u8; 8] = field.to_be_radix(256);
+        assert_eq(bits, [0, 0, 0, 0, 0, 0, 0, 2]);
+        assert_eq(Field::from_be_bytes::<8>(bits), field);
+    }
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/field/mod.nr#L289-L296" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/field/mod.nr#L289-L296</a></sub></sup>
+
+
+
+### pow_32
+
+Returns the value to the power of the specified exponent
+
+```rust
+fn pow_32(self, exponent: Field) -> Field
+```
+
+example:
+
+```rust
+fn main() {
+    let field = 2
+    let pow = field.pow_32(4);
+    assert(pow == 16);
+}
+```
+
+### assert_max_bit_size
+
+Adds a constraint to specify that the field can be represented with `bit_size` number of bits
+
+```rust title="assert_max_bit_size" showLineNumbers 
+pub fn assert_max_bit_size<let BIT_SIZE: u32>(self) {
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/field/mod.nr#L10-L12" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/field/mod.nr#L10-L12</a></sub></sup>
+
+
+example:
+
+```rust
+fn main() {
+    let field = 2
+    field.assert_max_bit_size(32);
+}
+```
+
+### sgn0
+
+Parity of (prime) Field element, i.e. sgn0(x mod p) = 0 if x ∈ \{0, ..., p-1\} is even, otherwise sgn0(x mod p) = 1.
+
+```rust
+fn sgn0(self) -> u1
+```
+
+
+### lt
+
+Returns true if the field is less than the other field
+
+```rust
+pub fn lt(self, another: Field) -> bool
+```
diff --git a/docs/versioned_docs/version-v0.36.0/noir/concepts/data_types/function_types.md b/docs/versioned_docs/version-v0.36.0/noir/concepts/data_types/function_types.md
new file mode 100644
index 00000000000..f6121af17e2
--- /dev/null
+++ b/docs/versioned_docs/version-v0.36.0/noir/concepts/data_types/function_types.md
@@ -0,0 +1,26 @@
+---
+title: Function types
+sidebar_position: 10
+---
+
+Noir supports higher-order functions. The syntax for a function type is as follows:
+
+```rust
+fn(arg1_type, arg2_type, ...) -> return_type
+```
+
+Example:
+
+```rust
+fn assert_returns_100(f: fn() -> Field) { // f takes no args and returns a Field
+    assert(f() == 100);
+}
+
+fn main() {
+    assert_returns_100(|| 100); // ok
+    assert_returns_100(|| 150); // fails
+}
+```
+
+A function type also has an optional capture environment - this is necessary to support closures.
+See [Lambdas](../lambdas.md) for more details.
diff --git a/docs/versioned_docs/version-v0.36.0/noir/concepts/data_types/index.md b/docs/versioned_docs/version-v0.36.0/noir/concepts/data_types/index.md
new file mode 100644
index 00000000000..0f2db2b2d75
--- /dev/null
+++ b/docs/versioned_docs/version-v0.36.0/noir/concepts/data_types/index.md
@@ -0,0 +1,126 @@
+---
+title: Data Types
+description:
+  Get a clear understanding of the two categories of Noir data types - primitive types and compound
+  types. Learn about their characteristics, differences, and how to use them in your Noir
+  programming.
+keywords:
+  [
+    noir,
+    data types,
+    primitive types,
+    compound types,
+    private types,
+    public types,
+  ]
+---
+
+Every value in Noir has a type, which determines which operations are valid for it.
+
+All values in Noir are fundamentally composed of `Field` elements. For a more approachable
+developing experience, abstractions are added on top to introduce different data types in Noir.
+
+Noir has two category of data types: primitive types (e.g. `Field`, integers, `bool`) and compound
+types that group primitive types (e.g. arrays, tuples, structs). Each value can either be private or
+public.
+
+## Private & Public Types
+
+A **private value** is known only to the Prover, while a **public value** is known by both the
+Prover and Verifier. Mark values as `private` when the value should only be known to the prover. All
+primitive types (including individual fields of compound types) in Noir are private by default, and
+can be marked public when certain values are intended to be revealed to the Verifier.
+
+> **Note:** For public values defined in Noir programs paired with smart contract verifiers, once
+> the proofs are verified on-chain the values can be considered known to everyone that has access to
+> that blockchain.
+
+Public data types are treated no differently to private types apart from the fact that their values
+will be revealed in proofs generated. Simply changing the value of a public type will not change the
+circuit (where the same goes for changing values of private types as well).
+
+_Private values_ are also referred to as _witnesses_ sometimes.
+
+> **Note:** The terms private and public when applied to a type (e.g. `pub Field`) have a different
+> meaning than when applied to a function (e.g. `pub fn foo() {}`).
+>
+> The former is a visibility modifier for the Prover to interpret if a value should be made known to
+> the Verifier, while the latter is a visibility modifier for the compiler to interpret if a
+> function should be made accessible to external Noir programs like in other languages.
+
+### pub Modifier
+
+All data types in Noir are private by default. Types are explicitly declared as public using the
+`pub` modifier:
+
+```rust
+fn main(x : Field, y : pub Field) -> pub Field {
+    x + y
+}
+```
+
+In this example, `x` is **private** while `y` and `x + y` (the return value) are **public**. Note
+that visibility is handled **per variable**, so it is perfectly valid to have one input that is
+private and another that is public.
+
+> **Note:** Public types can only be declared through parameters on `main`.
+
+## Type Aliases
+
+A type alias is a new name for an existing type. Type aliases are declared with the keyword `type`:
+
+```rust
+type Id = u8;
+
+fn main() {
+    let id: Id = 1;
+    let zero: u8 = 0;
+    assert(zero + 1 == id);
+}
+```
+
+Type aliases can also be used with [generics](../generics.md):
+
+```rust
+type Id<Size> = Size;
+
+fn main() {
+    let id: Id<u32> = 1;
+    let zero: u32 = 0;
+    assert(zero + 1 == id);
+}
+```
+
+Type aliases can even refer to other aliases. An error will be issued if they form a cycle:
+
+```rust
+// Ok!
+type A = B;
+type B = Field;
+
+type Bad1 = Bad2;
+
+// error: Dependency cycle found
+type Bad2 = Bad1;
+//   ^^^^^^^^^^^ 'Bad2' recursively depends on itself: Bad2 -> Bad1 -> Bad2
+```
+
+By default, like functions, type aliases are private to the module they exist in. You can use `pub`
+to make the type alias public or `pub(crate)` to make it public to just its crate:
+
+```rust
+// This type alias is now public
+pub type Id = u8;
+```
+
+## Wildcard Type
+Noir can usually infer the type of the variable from the context, so specifying the type of a variable is only required when it cannot be inferred. However, specifying a complex type can be tedious, especially when it has multiple generic arguments. Often some of the generic types can be inferred from the context, and Noir only needs a hint to properly infer the other types. We can partially specify a variable's type by using `_` as a marker, indicating where we still want the compiler to infer the type.
+
+```rust
+let a: [_; 4] = foo(b);
+```
+ 
+
+### BigInt
+
+You can achieve BigInt functionality using the [Noir BigInt](https://github.com/shuklaayush/noir-bigint) library.
diff --git a/docs/versioned_docs/version-v0.36.0/noir/concepts/data_types/integers.md b/docs/versioned_docs/version-v0.36.0/noir/concepts/data_types/integers.md
new file mode 100644
index 00000000000..a1d59bf3166
--- /dev/null
+++ b/docs/versioned_docs/version-v0.36.0/noir/concepts/data_types/integers.md
@@ -0,0 +1,156 @@
+---
+title: Integers
+description: Explore the Integer data type in Noir. Learn about its methods, see real-world examples, and grasp how to efficiently use Integers in your Noir code.
+keywords: [noir, integer types, methods, examples, arithmetic]
+sidebar_position: 1
+---
+
+An integer type is a range constrained field type.
+The Noir frontend supports both unsigned and signed integer types.
+The allowed sizes are 1, 8, 16, 32 and 64 bits.
+
+:::info
+
+When an integer is defined in Noir without a specific type, it will default to `Field`.
+
+The one exception is for loop indices which default to `u64` since comparisons on `Field`s are not possible.
+
+:::
+
+## Unsigned Integers
+
+An unsigned integer type is specified first with the letter `u` (indicating its unsigned nature) followed by its bit size (e.g. `8`):
+
+```rust
+fn main() {
+    let x: u8 = 1;
+    let y: u8 = 1;
+    let z = x + y;
+    assert (z == 2);
+}
+```
+
+The bit size determines the maximum value the integer type can store. For example, a `u8` variable can store a value in the range of 0 to 255 (i.e. $\\2^{8}-1\\$).
+
+## Signed Integers
+
+A signed integer type is specified first with the letter `i` (which stands for integer) followed by its bit size (e.g. `8`):
+
+```rust
+fn main() {
+    let x: i8 = -1;
+    let y: i8 = -1;
+    let z = x + y;
+    assert (z == -2);
+}
+```
+
+The bit size determines the maximum and minimum range of value the integer type can store. For example, an `i8` variable can store a value in the range of -128 to 127 (i.e. $\\-2^{7}\\$ to $\\2^{7}-1\\$).
+
+## 128 bits Unsigned Integers
+
+The built-in structure `U128` allows you to use 128-bit unsigned integers almost like a native integer type. However, there are some differences to keep in mind:
+- You cannot cast between a native integer and `U128`
+- There is a higher performance cost when using `U128`, compared to a native type.
+
+Conversion between unsigned integer types and U128 are done through the use of `from_integer` and `to_integer` functions. `from_integer` also accepts the `Field` type as input.
+
+```rust
+fn main() {
+    let x = U128::from_integer(23);
+    let y = U128::from_hex("0x7");
+    let z = x + y;
+    assert(z.to_integer() == 30);
+}
+```
+
+`U128` is implemented with two 64 bits limbs, representing the low and high bits, which explains the performance cost. You should expect `U128` to be twice more costly for addition and four times more costly for multiplication.
+You can construct a U128 from its limbs:
+```rust
+fn main(x: u64, y: u64) {
+    let x = U128::from_u64s_be(x,y);
+    assert(z.hi == x as Field);
+    assert(z.lo == y as Field);
+}
+```
+
+Note that the limbs are stored as Field elements in order to avoid unnecessary conversions.
+Apart from this, most operations will work as usual:
+
+```rust
+fn main(x: U128, y: U128) {
+    // multiplication
+    let c = x * y;
+    // addition and subtraction
+    let c = c - x + y;
+    // division
+    let c = x / y;
+    // bit operation;
+    let c = x & y | y;
+    // bit shift
+    let c = x << y;
+    // comparisons;
+    let c = x < y;
+    let c = x == y;
+}
+```
+
+## Overflows
+
+Computations that exceed the type boundaries will result in overflow errors. This happens with both signed and unsigned integers. For example, attempting to prove:
+
+```rust
+fn main(x: u8, y: u8) {
+    let z = x + y;
+}
+```
+
+With:
+
+```toml
+x = "255"
+y = "1"
+```
+
+Would result in:
+
+```
+$ nargo execute
+error: Assertion failed: 'attempt to add with overflow'
+┌─ ~/src/main.nr:9:13
+│
+│     let z = x + y;
+│             -----
+│
+= Call stack:
+  ...
+```
+
+A similar error would happen with signed integers:
+
+```rust
+fn main() {
+    let x: i8 = -118;
+    let y: i8 = -11;
+    let z = x + y;
+}
+```
+
+### Wrapping methods
+
+Although integer overflow is expected to error, some use-cases rely on wrapping. For these use-cases, the standard library provides `wrapping` variants of certain common operations:
+
+```rust
+fn wrapping_add<T>(x: T, y: T) -> T;
+fn wrapping_sub<T>(x: T, y: T) -> T;
+fn wrapping_mul<T>(x: T, y: T) -> T;
+```
+
+Example of how it is used:
+
+```rust
+
+fn main(x: u8, y: u8) -> pub u8 {
+    std::wrapping_add(x, y)
+}
+```
diff --git a/docs/versioned_docs/version-v0.36.0/noir/concepts/data_types/references.md b/docs/versioned_docs/version-v0.36.0/noir/concepts/data_types/references.md
new file mode 100644
index 00000000000..a5293d11cfb
--- /dev/null
+++ b/docs/versioned_docs/version-v0.36.0/noir/concepts/data_types/references.md
@@ -0,0 +1,23 @@
+---
+title: References
+sidebar_position: 9
+---
+
+Noir supports first-class references. References are a bit like pointers: they point to a specific address that can be followed to access the data stored at that address. You can use Rust-like syntax to use pointers in Noir: the `&` operator references the variable, the `*` operator dereferences it.
+
+Example:
+
+```rust
+fn main() {
+    let mut x = 2;
+
+    // you can reference x as &mut and pass it to multiplyBy2
+    multiplyBy2(&mut x);
+}
+
+// you can access &mut here
+fn multiplyBy2(x: &mut Field) {
+    // and dereference it with *
+    *x = *x * 2;
+}
+```
diff --git a/docs/versioned_docs/version-v0.36.0/noir/concepts/data_types/slices.mdx b/docs/versioned_docs/version-v0.36.0/noir/concepts/data_types/slices.mdx
new file mode 100644
index 00000000000..cfee564a302
--- /dev/null
+++ b/docs/versioned_docs/version-v0.36.0/noir/concepts/data_types/slices.mdx
@@ -0,0 +1,358 @@
+---
+title: Slices
+description: Explore the Slice data type in Noir. Understand its methods, see real-world examples, and learn how to effectively use Slices in your Noir programs.
+keywords: [noir, slice type, methods, examples, subarrays]
+sidebar_position: 5
+---
+
+import Experimental from '@site/src/components/Notes/_experimental.mdx';
+
+<Experimental />
+
+A slice is a dynamically-sized view into a sequence of elements. They can be resized at runtime, but because they don't own the data, they cannot be returned from a circuit. You can treat slices as arrays without a constrained size.
+
+```rust
+fn main() -> pub u32 {
+    let mut slice: [Field] = &[0; 2];
+
+    let mut new_slice = slice.push_back(6);
+    new_slice.len()
+}
+```
+
+To write a slice literal, use a preceding ampersand as in: `&[0; 2]` or
+`&[1, 2, 3]`.
+
+It is important to note that slices are not references to arrays. In Noir,
+`&[..]` is more similar to an immutable, growable vector.
+
+View the corresponding test file [here][test-file].
+
+[test-file]: https://github.com/noir-lang/noir/blob/f387ec1475129732f72ba294877efdf6857135ac/crates/nargo_cli/tests/test_data_ssa_refactor/slices/src/main.nr
+
+## Methods
+
+For convenience, the STD provides some ready-to-use, common methods for slices:
+
+### push_back
+
+Pushes a new element to the end of the slice, returning a new slice with a length one greater than the original unmodified slice.
+
+```rust
+fn push_back<T>(_self: [T], _elem: T) -> [T]
+```
+
+example:
+
+```rust
+fn main() -> pub Field {
+    let mut slice: [Field] = &[0; 2];
+
+    let mut new_slice = slice.push_back(6);
+    new_slice.len()
+}
+```
+
+View the corresponding test file [here][test-file].
+
+### push_front
+
+Returns a new array with the specified element inserted at index 0. The existing elements indexes are incremented by 1.
+
+```rust
+fn push_front(_self: Self, _elem: T) -> Self
+```
+
+Example:
+
+```rust
+let mut new_slice: [Field] = &[];
+new_slice = new_slice.push_front(20);
+assert(new_slice[0] == 20); // returns true
+```
+
+View the corresponding test file [here][test-file].
+
+### pop_front
+
+Returns a tuple of two items, the first element of the array and the rest of the array.
+
+```rust
+fn pop_front(_self: Self) -> (T, Self)
+```
+
+Example:
+
+```rust
+let (first_elem, rest_of_slice) = slice.pop_front();
+```
+
+View the corresponding test file [here][test-file].
+
+### pop_back
+
+Returns a tuple of two items, the beginning of the array with the last element omitted and the last element.
+
+```rust
+fn pop_back(_self: Self) -> (Self, T)
+```
+
+Example:
+
+```rust
+let (popped_slice, last_elem) = slice.pop_back();
+```
+
+View the corresponding test file [here][test-file].
+
+### append
+
+Loops over a slice and adds it to the end of another.
+
+```rust
+fn append(mut self, other: Self) -> Self
+```
+
+Example:
+
+```rust
+let append = &[1, 2].append(&[3, 4, 5]);
+```
+
+### insert
+
+Inserts an element at a specified index and shifts all following elements by 1.
+
+```rust
+fn insert(_self: Self, _index: Field, _elem: T) -> Self
+```
+
+Example:
+
+```rust
+new_slice = rest_of_slice.insert(2, 100);
+assert(new_slice[2] == 100);
+```
+
+View the corresponding test file [here][test-file].
+
+### remove
+
+Remove an element at a specified index, shifting all elements after it to the left, returning the altered slice and the removed element.
+
+```rust
+fn remove(_self: Self, _index: Field) -> (Self, T)
+```
+
+Example:
+
+```rust
+let (remove_slice, removed_elem) = slice.remove(3);
+```
+
+### len
+
+Returns the length of a slice
+
+```rust
+fn len(self) -> Field
+```
+
+Example:
+
+```rust
+fn main() {
+    let slice = &[42, 42];
+    assert(slice.len() == 2);
+}
+```
+
+### as_array
+
+Converts this slice into an array.
+
+Make sure to specify the size of the resulting array.
+Panics if the resulting array length is different than the slice's length.
+
+```rust
+fn as_array<let N: u32>(self) -> [T; N]
+```
+
+Example:
+
+```rust
+fn main() {
+    let slice = &[5, 6];
+
+    // Always specify the length of the resulting array!
+    let array: [Field; 2] = slice.as_array();
+
+    assert(array[0] == slice[0]);
+    assert(array[1] == slice[1]);
+}
+```
+
+### map
+
+Applies a function to each element of the slice, returning a new slice containing the mapped elements.
+
+```rust
+fn map<U, Env>(self, f: fn[Env](T) -> U) -> [U]
+```
+
+example
+
+```rust
+let a = &[1, 2, 3];
+let b = a.map(|a| a * 2); // b is now &[2, 4, 6]
+```
+
+### fold
+
+Applies a function to each element of the slice, returning the final accumulated value. The first
+parameter is the initial value.
+
+```rust
+fn fold<U, Env>(self, mut accumulator: U, f: fn[Env](U, T) -> U) -> U
+```
+
+This is a left fold, so the given function will be applied to the accumulator and first element of
+the slice, then the second, and so on. For a given call the expected result would be equivalent to:
+
+```rust
+let a1 = &[1];
+let a2 = &[1, 2];
+let a3 = &[1, 2, 3];
+
+let f = |a, b| a - b;
+a1.fold(10, f)  //=> f(10, 1)
+a2.fold(10, f)  //=> f(f(10, 1), 2)
+a3.fold(10, f)  //=> f(f(f(10, 1), 2), 3)
+```
+
+example:
+
+```rust
+
+fn main() {
+    let slice = &[2, 2, 2, 2, 2];
+    let folded = slice.fold(0, |a, b| a + b);
+    assert(folded == 10);
+}
+
+```
+
+### reduce
+
+Same as fold, but uses the first element as the starting element.
+
+```rust
+fn reduce<Env>(self, f: fn[Env](T, T) -> T) -> T
+```
+
+example:
+
+```rust
+fn main() {
+    let slice = &[2, 2, 2, 2, 2];
+    let reduced = slice.reduce(|a, b| a + b);
+    assert(reduced == 10);
+}
+```
+
+### filter
+
+Returns a new slice containing only elements for which the given predicate returns true.
+
+```rust
+fn filter<Env>(self, f: fn[Env](T) -> bool) -> Self
+```
+
+example:
+
+```rust
+fn main() {
+    let slice = &[1, 2, 3, 4, 5];
+    let odds = slice.filter(|x| x % 2 == 1);
+    assert_eq(odds, &[1, 3, 5]);
+}
+```
+
+### join
+
+Flatten each element in the slice into one value, separated by `separator`.
+
+Note that although slices implement `Append`, `join` cannot be used on slice
+elements since nested slices are prohibited.
+
+```rust
+fn join(self, separator: T) -> T where T: Append
+```
+
+example:
+
+```rust
+struct Accumulator {
+    total: Field,
+}
+
+// "Append" two accumulators by adding them
+impl Append for Accumulator {
+    fn empty() -> Self {
+        Self { total: 0 }
+    }
+
+    fn append(self, other: Self) -> Self {
+        Self { total: self.total + other.total }
+    }
+}
+
+fn main() {
+    let slice = &[1, 2, 3, 4, 5].map(|total| Accumulator { total });
+
+    let result = slice.join(Accumulator::empty());
+    assert_eq(result, Accumulator { total: 15 });
+
+    // We can use a non-empty separator to insert additional elements to sum:
+    let separator = Accumulator { total: 10 };
+    let result = slice.join(separator);
+    assert_eq(result, Accumulator { total: 55 });
+}
+```
+
+### all
+
+Returns true if all the elements satisfy the given predicate
+
+```rust
+fn all<Env>(self, predicate: fn[Env](T) -> bool) -> bool
+```
+
+example:
+
+```rust
+fn main() {
+    let slice = &[2, 2, 2, 2, 2];
+    let all = slice.all(|a| a == 2);
+    assert(all);
+}
+```
+
+### any
+
+Returns true if any of the elements satisfy the given predicate
+
+```rust
+fn any<Env>(self, predicate: fn[Env](T) -> bool) -> bool
+```
+
+example:
+
+```rust
+fn main() {
+    let slice = &[2, 2, 2, 2, 5];
+    let any = slice.any(|a| a == 5);
+    assert(any);
+}
+
+```
diff --git a/docs/versioned_docs/version-v0.36.0/noir/concepts/data_types/strings.md b/docs/versioned_docs/version-v0.36.0/noir/concepts/data_types/strings.md
new file mode 100644
index 00000000000..1fdee42425e
--- /dev/null
+++ b/docs/versioned_docs/version-v0.36.0/noir/concepts/data_types/strings.md
@@ -0,0 +1,79 @@
+---
+title: Strings
+description:
+  Discover the String data type in Noir. Learn about its methods, see real-world examples, and understand how to effectively manipulate and use Strings in Noir.
+keywords:
+  [
+    noir,
+    string type,
+    methods,
+    examples,
+    concatenation,
+  ]
+sidebar_position: 3
+---
+
+
+The string type is a fixed length value defined with `str<N>`.
+
+You can use strings in `assert()` functions or print them with
+`println()`. See more about [Logging](../../standard_library/logging.md).
+
+```rust
+
+fn main(message : pub str<11>, hex_as_string : str<4>) {
+    println(message);
+    assert(message == "hello world");
+    assert(hex_as_string == "0x41");
+}
+```
+
+You can convert a `str<N>` to a byte array by calling `as_bytes()`
+or a vector by calling `as_bytes_vec()`.
+
+```rust
+fn main() {
+    let message = "hello world";
+    let message_bytes = message.as_bytes();
+    let mut message_vec = message.as_bytes_vec();
+    assert(message_bytes.len() == 11);
+    assert(message_bytes[0] == 104);
+    assert(message_bytes[0] == message_vec.get(0));
+}
+```
+
+## Escape characters
+
+You can use escape characters for your strings:
+
+| Escape Sequence | Description     |
+|-----------------|-----------------|
+| `\r`            | Carriage Return |
+| `\n`            | Newline         |
+| `\t`            | Tab             |
+| `\0`            | Null Character  |
+| `\"`            | Double Quote    |
+| `\\`            | Backslash       |
+
+Example:
+
+```rust
+let s = "Hello \"world" // prints "Hello "world"
+let s = "hey \tyou"; // prints "hey   you"
+```
+
+## Raw strings
+
+A raw string begins with the letter `r` and is optionally delimited by a number of hashes `#`.
+
+Escape characters are *not* processed within raw strings. All contents are interpreted literally.
+
+Example:
+
+```rust
+let s = r"Hello world";
+let s = r#"Simon says "hello world""#;
+
+// Any number of hashes may be used (>= 1) as long as the string also terminates with the same number of hashes
+let s = r#####"One "#, Two "##, Three "###, Four "####, Five will end the string."#####; 
+```
diff --git a/docs/versioned_docs/version-v0.36.0/noir/concepts/data_types/structs.md b/docs/versioned_docs/version-v0.36.0/noir/concepts/data_types/structs.md
new file mode 100644
index 00000000000..29951ae843a
--- /dev/null
+++ b/docs/versioned_docs/version-v0.36.0/noir/concepts/data_types/structs.md
@@ -0,0 +1,96 @@
+---
+title: Structs
+description:
+  Explore the Struct data type in Noir. Learn about its methods, see real-world examples, and grasp how to effectively define and use Structs in your Noir programs.
+keywords:
+  [
+    noir,
+    struct type,
+    methods,
+    examples,
+    data structures,
+  ]
+sidebar_position: 8
+---
+
+A struct also allows for grouping multiple values of different types. Unlike tuples, we can also
+name each field.
+
+> **Note:** The usage of _field_ here refers to each element of the struct and is unrelated to the
+> field type of Noir.
+
+Defining a struct requires giving it a name and listing each field within as `<Key>: <Type>` pairs:
+
+```rust
+struct Animal {
+    hands: Field,
+    legs: Field,
+    eyes: u8,
+}
+```
+
+An instance of a struct can then be created with actual values in `<Key>: <Value>` pairs in any
+order. Struct fields are accessible using their given names:
+
+```rust
+fn main() {
+    let legs = 4;
+
+    let dog = Animal {
+        eyes: 2,
+        hands: 0,
+        legs,
+    };
+
+    let zero = dog.hands;
+}
+```
+
+Structs can also be destructured in a pattern, binding each field to a new variable:
+
+```rust
+fn main() {
+    let Animal { hands, legs: feet, eyes } = get_octopus();
+
+    let ten = hands + feet + eyes as u8;
+}
+
+fn get_octopus() -> Animal {
+    let octopus = Animal {
+        hands: 0,
+        legs: 8,
+        eyes: 2,
+    };
+
+    octopus
+}
+```
+
+The new variables can be bound with names different from the original struct field names, as
+showcased in the `legs --> feet` binding in the example above.
+
+### Visibility
+
+By default, like functions, structs are private to the module they exist in. You can use `pub`
+to make the struct public or `pub(crate)` to make it public to just its crate:
+
+```rust
+// This struct is now public
+pub struct Animal {
+    hands: Field,
+    legs: Field,
+    eyes: u8,
+}
+```
+
+The same applies to struct fields: by default they are private to the module they exist in,
+but they can be made `pub` or `pub(crate)`:
+
+```rust
+// This struct is now public
+pub struct Animal {
+    hands: Field,           // private to its module
+    pub(crate) legs: Field, // accessible from the entire crate
+    pub eyes: u8,           // accessible from anywhere
+}
+```
\ No newline at end of file
diff --git a/docs/versioned_docs/version-v0.36.0/noir/concepts/data_types/tuples.md b/docs/versioned_docs/version-v0.36.0/noir/concepts/data_types/tuples.md
new file mode 100644
index 00000000000..2ec5c9c4113
--- /dev/null
+++ b/docs/versioned_docs/version-v0.36.0/noir/concepts/data_types/tuples.md
@@ -0,0 +1,48 @@
+---
+title: Tuples
+description:
+  Dive into the Tuple data type in Noir. Understand its methods, practical examples, and best practices for efficiently using Tuples in your Noir code.
+keywords:
+  [
+    noir,
+    tuple type,
+    methods,
+    examples,
+    multi-value containers,
+  ]
+sidebar_position: 7
+---
+
+A tuple collects multiple values like an array, but with the added ability to collect values of
+different types:
+
+```rust
+fn main() {
+    let tup: (u8, u64, Field) = (255, 500, 1000);
+}
+```
+
+One way to access tuple elements is via destructuring using pattern matching:
+
+```rust
+fn main() {
+    let tup = (1, 2);
+
+    let (one, two) = tup;
+
+    let three = one + two;
+}
+```
+
+Another way to access tuple elements is via direct member access, using a period (`.`) followed by
+the index of the element we want to access. Index `0` corresponds to the first tuple element, `1` to
+the second and so on:
+
+```rust
+fn main() {
+    let tup = (5, 6, 7, 8);
+
+    let five = tup.0;
+    let eight = tup.3;
+}
+```
diff --git a/docs/versioned_docs/version-v0.36.0/noir/concepts/functions.md b/docs/versioned_docs/version-v0.36.0/noir/concepts/functions.md
new file mode 100644
index 00000000000..f656cdfd97a
--- /dev/null
+++ b/docs/versioned_docs/version-v0.36.0/noir/concepts/functions.md
@@ -0,0 +1,226 @@
+---
+title: Functions
+description:
+  Learn how to declare functions and methods in Noir, a programming language with Rust semantics.
+  This guide covers parameter declaration, return types, call expressions, and more.
+keywords: [Noir, Rust, functions, methods, parameter declaration, return types, call expressions]
+sidebar_position: 1
+---
+
+Functions in Noir follow the same semantics of Rust, though Noir does not support early returns.
+
+To declare a function the `fn` keyword is used.
+
+```rust
+fn foo() {}
+```
+
+By default, functions are visible only within the package they are defined. To make them visible outside of that package (for example, as part of a [library](../modules_packages_crates/crates_and_packages.md#libraries)), you should mark them as `pub`:
+
+```rust
+pub fn foo() {}
+```
+
+You can also restrict the visibility of the function to only the crate it was defined in, by specifying `pub(crate)`:
+
+```rust
+pub(crate) fn foo() {}  //foo can only be called within its crate
+```
+
+All parameters in a function must have a type and all types are known at compile time. The parameter
+is pre-pended with a colon and the parameter type. Multiple parameters are separated using a comma.
+
+```rust
+fn foo(x : Field, y : Field){}
+```
+
+The return type of a function can be stated by using the `->` arrow notation. The function below
+states that the foo function must return a `Field`. If the function returns no value, then the arrow
+is omitted.
+
+```rust
+fn foo(x : Field, y : Field) -> Field {
+    x + y
+}
+```
+
+Note that a `return` keyword is unneeded in this case - the last expression in a function's body is
+returned.
+
+## Main function
+
+If you're writing a binary, the `main` function is the starting point of your program. You can pass all types of expressions to it, as long as they have a fixed size at compile time:
+
+```rust
+fn main(x : Field) // this is fine: passing a Field
+fn main(x : [Field; 2]) // this is also fine: passing a Field with known size at compile-time
+fn main(x : (Field, bool)) // 👌: passing a (Field, bool) tuple means size 2
+fn main(x : str<5>) // this is fine, as long as you pass a string of size 5
+
+fn main(x : Vec<Field>) // can't compile, has variable size
+fn main(x : [Field]) // can't compile, has variable size
+fn main(....// i think you got it by now
+```
+
+Keep in mind [tests](../../tooling/testing.md) don't differentiate between `main` and any other function. The following snippet passes tests, but won't compile or prove:
+
+```rust
+fn main(x : [Field]) {
+    assert(x[0] == 1);
+}
+
+#[test]
+fn test_one() {
+    main(&[1, 2]);
+}
+```
+
+```bash
+$ nargo test
+[testing] Running 1 test functions
+[testing] Testing test_one... ok
+[testing] All tests passed
+
+$ nargo check
+The application panicked (crashed).
+Message:  Cannot have variable sized arrays as a parameter to main
+```
+
+## Call Expressions
+
+Calling a function in Noir is executed by using the function name and passing in the necessary
+arguments.
+
+Below we show how to call the `foo` function from the `main` function using a call expression:
+
+```rust
+fn main(x : Field, y : Field) {
+    let z = foo(x);
+}
+
+fn foo(x : Field) -> Field {
+    x + x
+}
+```
+
+## Methods
+
+You can define methods in Noir on any struct type in scope.
+
+```rust
+struct MyStruct {
+    foo: Field,
+    bar: Field,
+}
+
+impl MyStruct {
+    fn new(foo: Field) -> MyStruct {
+        MyStruct {
+            foo,
+            bar: 2,
+        }
+    }
+
+    fn sum(self) -> Field {
+        self.foo + self.bar
+    }
+}
+
+fn main() {
+    let s = MyStruct::new(40);
+    assert(s.sum() == 42);
+}
+```
+
+Methods are just syntactic sugar for functions, so if we wanted to we could also call `sum` as
+follows:
+
+```rust
+assert(MyStruct::sum(s) == 42);
+```
+
+It is also possible to specialize which method is chosen depending on the [generic](./generics.md) type that is used. In this example, the `foo` function returns different values depending on its type:
+
+```rust
+struct Foo<T> {}
+
+impl Foo<u32> {
+    fn foo(self) -> Field { 1 }
+}
+
+impl Foo<u64> {
+    fn foo(self) -> Field { 2 }
+}
+
+fn main() {
+    let f1: Foo<u32> = Foo{};
+    let f2: Foo<u64> = Foo{};
+    assert(f1.foo() + f2.foo() == 3);
+}
+```
+
+Also note that impls with the same method name defined in them cannot overlap. For example, if we already have `foo` defined for `Foo<u32>` and `Foo<u64>` like we do above, we cannot also define `foo` in an `impl<T> Foo<T>` since it would be ambiguous which version of `foo` to choose.
+
+```rust
+// Including this impl in the same project as the above snippet would
+// cause an overlapping impls error
+impl<T> Foo<T> {
+    fn foo(self) -> Field { 3 }
+}
+```
+
+## Lambdas
+
+Lambdas are anonymous functions. They follow the syntax of Rust - `|arg1, arg2, ..., argN| return_expression`.
+
+```rust
+let add_50 = |val| val + 50;
+assert(add_50(100) == 150);
+```
+
+See [Lambdas](./lambdas.md) for more details.
+
+## Attributes
+
+Attributes are metadata that can be applied to a function, using the following syntax: `#[attribute(value)]`.
+
+Supported attributes include:
+
+- **builtin**: the function is implemented by the compiler, for efficiency purposes.
+- **deprecated**: mark the function as _deprecated_. Calling the function will generate a warning: `warning: use of deprecated function`
+- **field**: Used to enable conditional compilation of code depending on the field size. See below for more details
+- **oracle**: mark the function as _oracle_; meaning it is an external unconstrained function, implemented in noir_js. See [Unconstrained](./unconstrained.md) and [NoirJS](../../reference/NoirJS/noir_js/index.md) for more details.
+- **test**: mark the function as unit tests. See [Tests](../../tooling/testing.md) for more details
+
+### Field Attribute
+
+The field attribute defines which field the function is compatible for. The function is conditionally compiled, under the condition that the field attribute matches the Noir native field.
+The field can be defined implicitly, by using the name of the elliptic curve usually associated to it - for instance bn254, bls12_381 - or explicitly by using the field (prime) order, in decimal or hexadecimal form.
+As a result, it is possible to define multiple versions of a function with each version specialized for a different field attribute. This can be useful when a function requires different parameters depending on the underlying elliptic curve.
+
+Example: we define the function `foo()` three times below. Once for the default Noir bn254 curve, once for the field $\mathbb F_{23}$, which will normally never be used by Noir, and once again for the bls12_381 curve.
+
+```rust
+#[field(bn254)]
+fn foo() -> u32 {
+    1
+}
+
+#[field(23)]
+fn foo() -> u32 {
+    2
+}
+
+// This commented code would not compile as foo would be defined twice because it is the same field as bn254
+// #[field(21888242871839275222246405745257275088548364400416034343698204186575808495617)]
+// fn foo() -> u32 {
+//     2
+// }
+
+#[field(bls12_381)]
+fn foo() -> u32 {
+    3
+}
+```
+
+If the field name is not known to Noir, it will discard the function. Field names are case insensitive.
diff --git a/docs/versioned_docs/version-v0.36.0/noir/concepts/generics.md b/docs/versioned_docs/version-v0.36.0/noir/concepts/generics.md
new file mode 100644
index 00000000000..c180a0ce7e6
--- /dev/null
+++ b/docs/versioned_docs/version-v0.36.0/noir/concepts/generics.md
@@ -0,0 +1,251 @@
+---
+title: Generics
+description: Learn how to use Generics in Noir
+keywords: [Noir, Rust, generics, functions, structs]
+sidebar_position: 7
+---
+
+Generics allow you to use the same functions with multiple different concrete data types. You can
+read more about the concept of generics in the Rust documentation
+[here](https://doc.rust-lang.org/book/ch10-01-syntax.html).
+
+Here is a trivial example showing the identity function that supports any type. In Rust, it is
+common to refer to the most general type as `T`. We follow the same convention in Noir.
+
+```rust
+fn id<T>(x: T) -> T  {
+    x
+}
+```
+
+## Numeric Generics
+
+If we want to be generic over array lengths (which are type-level integers), we can use numeric
+generics. Using these looks similar to using regular generics, but introducing them into scope
+requires declaring them with `let MyGenericName: IntegerType`. This can be done anywhere a normal
+generic is declared. Instead of types, these generics resolve to integers at compile-time.
+Here's an example of a struct that is generic over the size of the array it contains internally:
+
+```rust
+struct BigInt<let N: u32> {
+    limbs: [u32; N],
+}
+
+impl<let N: u32> BigInt<N> {
+    // `N` is in scope of all methods in the impl
+    fn first(first: BigInt<N>, second: BigInt<N>) -> Self {
+        assert(first.limbs != second.limbs);
+        first
+
+    fn second(first: BigInt<N>, second: Self) -> Self {
+        assert(first.limbs != second.limbs);
+        second
+    }
+}
+```
+
+## In Structs
+
+Generics are useful for specifying types in structs. For example, we can specify that a field in a
+struct will be of a certain generic type. In this case `value` is of type `T`.
+
+```rust
+struct RepeatedValue<T> {
+    value: T,
+    count: Field,
+}
+
+impl<T> RepeatedValue<T> {
+    fn print(self) {
+        for _i in 0 .. self.count {
+            println(self.value);
+        }
+    }
+}
+
+fn main() {
+    let repeated = RepeatedValue { value: "Hello!", count: 2 };
+    repeated.print();
+}
+```
+
+The `print` function will print `Hello!` an arbitrary number of times, twice in this case.
+
+## Calling functions on generic parameters
+
+Since a generic type `T` can represent any type, how can we call functions on the underlying type?
+In other words, how can we go from "any type `T`" to "any type `T` that has certain methods available?"
+
+This is what [traits](../concepts/traits.md) are for in Noir. Here's an example of a function generic over
+any type `T` that implements the `Eq` trait for equality:
+
+```rust
+fn first_element_is_equal<T, let N: u32>(array1: [T; N], array2: [T; N]) -> bool 
+    where T: Eq
+{
+    if (array1.len() == 0) | (array2.len() == 0) {
+        true
+    } else {
+        array1[0] == array2[0]
+    }
+}
+
+fn main() {
+    assert(first_element_is_equal([1, 2, 3], [1, 5, 6]));
+
+    // We can use first_element_is_equal for arrays of any type
+    // as long as we have an Eq impl for the types we pass in
+    let array = [MyStruct::new(), MyStruct::new()];
+    assert(array_eq(array, array, MyStruct::eq));
+}
+
+impl Eq for MyStruct {
+    fn eq(self, other: MyStruct) -> bool {
+        self.foo == other.foo
+    }
+}
+```
+
+You can find more details on traits and trait implementations on the [traits page](../concepts/traits.md).
+
+## Manually Specifying Generics with the Turbofish Operator
+
+There are times when the compiler cannot reasonably infer what type should be used for a generic, or when the developer themselves may want to manually distinguish generic type parameters. This is where the `::<>` turbofish operator comes into play.
+
+The `::<>` operator can follow a variable or path and can be used to manually specify generic arguments within the angle brackets.
+The name "turbofish" comes from that `::<>` looks like a little fish.
+
+Examples:
+```rust
+fn main() {
+    let mut slice = [];
+    slice = slice.push_back(1);
+    slice = slice.push_back(2);
+    // Without turbofish a type annotation would be needed on the left hand side
+    let array = slice.as_array::<2>();
+}
+```
+
+
+```rust
+trait MyTrait {
+    fn ten() -> Self;
+}
+
+impl MyTrait for Field {
+    fn ten() -> Self { 10 }
+}
+
+struct Foo<T> {
+    inner: T
+}
+        
+impl<T> Foo<T> {
+    fn generic_method<U>(_self: Self) -> U where U: MyTrait {
+        U::ten()
+    }
+}
+        
+fn example() {
+    let foo: Foo<Field> = Foo { inner: 1 };
+    // Using a type other than `Field` here (e.g. u32) would fail as 
+    // there is no matching impl for `u32: MyTrait`. 
+    //
+    // Substituting the `10` on the left hand side of this assert
+    // with `10 as u32` would also fail with a type mismatch as we 
+    // are expecting a `Field` from the right hand side.
+    assert(10 as u32 == foo.generic_method::<Field>());
+}
+```
+
+## Arithmetic Generics
+
+In addition to numeric generics, Noir also allows a limited form of arithmetic on generics.
+When you have a numeric generic such as `N`, you can use the following operators on it in a
+type position: `+`, `-`, `*`, `/`, and `%`.
+
+Note that type checking arithmetic generics is a best effort guess from the compiler and there
+are many cases of types that are equal that the compiler may not see as such. For example,
+we know that `T * (N + M)` should be equal to `T*N + T*M` but the compiler does not currently
+apply the distributive law and thus sees these as different types.
+
+Even with this limitation though, the compiler can handle common cases decently well:
+
+```rust
+trait Serialize<let N: u32> {
+    fn serialize(self) -> [Field; N];
+}
+
+impl Serialize<1> for Field {
+    fn serialize(self) -> [Field; 1] {
+        [self]
+    }
+}
+
+impl<T, let N: u32, let M: u32> Serialize<N * M> for [T; N]
+    where T: Serialize<M> { .. }
+
+impl<T, U, let N: u32, let M: u32> Serialize<N + M> for (T, U)
+    where T: Serialize<N>, U: Serialize<M> { .. }
+
+fn main() {
+    let data = (1, [2, 3, 4]);
+    assert_eq(data.serialize().len(), 4);
+}
+```
+
+Note that if there is any over or underflow the types will fail to unify:
+
+```rust title="underflow-example" showLineNumbers 
+fn pop<let N: u32>(array: [Field; N]) -> [Field; N - 1] {
+    let mut result: [Field; N - 1] = std::mem::zeroed();
+    for i in 0..N - 1 {
+        result[i] = array[i];
+    }
+    result
+}
+
+fn main() {
+    // error: Could not determine array length `(0 - 1)`
+    pop([]);
+}
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/test_programs/compile_failure/arithmetic_generics_underflow/src/main.nr#L1-L14" target="_blank" rel="noopener noreferrer">Source code: test_programs/compile_failure/arithmetic_generics_underflow/src/main.nr#L1-L14</a></sub></sup>
+
+
+This also applies if there is underflow in an intermediate calculation:
+
+```rust title="intermediate-underflow-example" showLineNumbers 
+fn main() {
+    // From main it looks like there's nothing sketchy going on
+    seems_fine([]);
+}
+
+// Since `seems_fine` says it can receive and return any length N
+fn seems_fine<let N: u32>(array: [Field; N]) -> [Field; N] {
+    // But inside `seems_fine` we pop from the array which
+    // requires the length to be greater than zero.
+
+    // error: Could not determine array length `(0 - 1)`
+    push_zero(pop(array))
+}
+
+fn pop<let N: u32>(array: [Field; N]) -> [Field; N - 1] {
+    let mut result: [Field; N - 1] = std::mem::zeroed();
+    for i in 0..N - 1 {
+        result[i] = array[i];
+    }
+    result
+}
+
+fn push_zero<let N: u32>(array: [Field; N]) -> [Field; N + 1] {
+    let mut result: [Field; N + 1] = std::mem::zeroed();
+    for i in 0..N {
+        result[i] = array[i];
+    }
+    // index N is already zeroed
+    result
+}
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/test_programs/compile_failure/arithmetic_generics_intermediate_underflow/src/main.nr#L1-L32" target="_blank" rel="noopener noreferrer">Source code: test_programs/compile_failure/arithmetic_generics_intermediate_underflow/src/main.nr#L1-L32</a></sub></sup>
+
diff --git a/docs/versioned_docs/version-v0.36.0/noir/concepts/globals.md b/docs/versioned_docs/version-v0.36.0/noir/concepts/globals.md
new file mode 100644
index 00000000000..6b8314399a2
--- /dev/null
+++ b/docs/versioned_docs/version-v0.36.0/noir/concepts/globals.md
@@ -0,0 +1,82 @@
+---
+title: Global Variables
+description:
+  Learn about global variables in Noir. Discover how
+  to declare, modify, and use them in your programs.
+keywords: [noir programming language, globals, global variables, constants]
+sidebar_position: 8
+---
+
+## Globals
+
+
+Noir supports global variables. The global's type can be inferred by the compiler entirely:
+
+```rust
+global N = 5; // Same as `global N: Field = 5`
+
+global TUPLE = (3, 2);
+
+fn main() {
+    assert(N == 5);
+    assert(N == TUPLE.0 + TUPLE.1);
+}
+```
+
+:::info
+
+Globals can be defined as any expression, so long as they don't depend on themselves - otherwise there would be a dependency cycle! For example:
+
+```rust
+global T = foo(T); // dependency error
+```
+
+:::
+
+
+If they are initialized to a literal integer, globals can be used to specify an array's length:
+
+```rust
+global N: u32 = 2;
+
+fn main(y : [Field; N]) {
+    assert(y[0] == y[1])
+}
+```
+
+A global from another module can be imported or referenced externally like any other name:
+
+```rust
+global N = 20;
+
+fn main() {
+    assert(my_submodule::N != N);
+}
+
+mod my_submodule {
+    global N: Field = 10;
+}
+```
+
+When a global is used, Noir replaces the name with its definition on each occurrence.
+This means globals defined using function calls will repeat the call each time they're used:
+
+```rust
+global RESULT = foo();
+
+fn foo() -> [Field; 100] { ... }
+```
+
+This is usually fine since Noir will generally optimize any function call that does not
+refer to a program input into a constant. It should be kept in mind however, if the called
+function performs side-effects like `println`, as these will still occur on each use.
+
+### Visibility
+
+By default, like functions, globals are private to the module they exist in. You can use `pub`
+to make the global public or `pub(crate)` to make it public to just its crate:
+
+```rust
+// This global is now public
+pub global N = 5;
+```
\ No newline at end of file
diff --git a/docs/versioned_docs/version-v0.36.0/noir/concepts/lambdas.md b/docs/versioned_docs/version-v0.36.0/noir/concepts/lambdas.md
new file mode 100644
index 00000000000..be3c7e0b5ca
--- /dev/null
+++ b/docs/versioned_docs/version-v0.36.0/noir/concepts/lambdas.md
@@ -0,0 +1,81 @@
+---
+title: Lambdas
+description: Learn how to use anonymous functions in Noir programming language.
+keywords: [Noir programming language, lambda, closure, function, anonymous function]
+sidebar_position: 9
+---
+
+## Introduction
+
+Lambdas are anonymous functions. The syntax is `|arg1, arg2, ..., argN| return_expression`.
+
+```rust
+let add_50 = |val| val + 50;
+assert(add_50(100) == 150);
+```
+
+A block can be used as the body of a lambda, allowing you to declare local variables inside it:
+
+```rust
+let cool = || {
+  let x = 100;
+  let y = 100;
+  x + y
+}
+
+assert(cool() == 200);
+```
+
+## Closures
+
+Inside the body of a lambda, you can use variables defined in the enclosing function. Such lambdas are called **closures**. In this example `x` is defined inside `main` and is accessed from within the lambda:
+
+```rust
+fn main() {
+  let x = 100;
+  let closure = || x + 150;
+  assert(closure() == 250);
+}
+```
+
+## Passing closures to higher-order functions
+
+It may catch you by surprise that the following code fails to compile:
+
+```rust
+fn foo(f: fn () -> Field) -> Field {
+ f()
+}
+
+fn main() {
+  let (x, y) = (50, 50);
+  assert(foo(|| x + y) == 100); // error :(
+}
+```
+
+The reason is that the closure's capture environment affects its type - we have a closure that captures two Fields and `foo`
+expects a regular function as an argument - those are incompatible.
+:::note
+
+Variables contained within the `||` are the closure's parameters, and the expression that follows it is the closure's body. The capture environment is comprised of any variables used in the closure's body that are not parameters.
+
+E.g. in |x| x + y, y would be a captured variable, but x would not be, since it is a parameter of the closure.
+
+:::
+The syntax for the type of a closure is `fn[env](args) -> ret_type`, where `env` is the capture environment of the closure -
+in this example that's `(Field, Field)`.
+
+The best solution in our case is to make `foo` generic over the environment type of its parameter, so that it can be called
+with closures with any environment, as well as with regular functions:
+
+```rust
+fn foo<Env>(f: fn[Env]() -> Field) -> Field {
+ f()
+}
+
+fn main() {
+  let (x, y) = (50, 50);
+  assert(foo(|| x + y) == 100); // compiles fine
+  assert(foo(|| 60) == 60);     // compiles fine
+}
+```
diff --git a/docs/versioned_docs/version-v0.36.0/noir/concepts/mutability.md b/docs/versioned_docs/version-v0.36.0/noir/concepts/mutability.md
new file mode 100644
index 00000000000..fdeef6a87c5
--- /dev/null
+++ b/docs/versioned_docs/version-v0.36.0/noir/concepts/mutability.md
@@ -0,0 +1,121 @@
+---
+title: Mutability
+description:
+  Learn about mutable variables in Noir. Discover how
+  to declare, modify, and use them in your programs.
+keywords: [noir programming language, mutability in noir, mutable variables]
+sidebar_position: 8
+---
+
+Variables in noir can be declared mutable via the `mut` keyword. Mutable variables can be reassigned
+to via an assignment expression.
+
+```rust
+let x = 2;
+x = 3; // error: x must be mutable to be assigned to
+
+let mut y = 3;
+let y = 4; // OK
+```
+
+The `mut` modifier can also apply to patterns:
+
+```rust
+let (a, mut b) = (1, 2);
+a = 11; // error: a must be mutable to be assigned to
+b = 12; // OK
+
+let mut (c, d) = (3, 4);
+c = 13; // OK
+d = 14; // OK
+
+// etc.
+let MyStruct { x: mut y } = MyStruct { x: a };
+// y is now in scope
+```
+
+Note that mutability in noir is local and everything is passed by value, so if a called function
+mutates its parameters then the parent function will keep the old value of the parameters.
+
+```rust
+fn main() -> pub Field {
+    let x = 3;
+    helper(x);
+    x // x is still 3
+}
+
+fn helper(mut x: i32) {
+    x = 4;
+}
+```
+
+## Non-local mutability
+
+Non-local mutability can be achieved through the mutable reference type `&mut T`:
+
+```rust
+fn set_to_zero(x: &mut Field) {
+    *x = 0;
+}
+
+fn main() {
+    let mut y = 42;
+    set_to_zero(&mut y);
+    assert(*y == 0);
+}
+```
+
+When creating a mutable reference, the original variable being referred to (`y` in this
+example) must also be mutable. Since mutable references are a reference type, they must
+be explicitly dereferenced via `*` to retrieve the underlying value. Note that this yields
+a copy of the value, so mutating this copy will not change the original value behind the
+reference:
+
+```rust
+fn main() {
+    let mut x = 1;
+    let x_ref = &mut x;
+
+    let mut y = *x_ref;
+    let y_ref = &mut y;
+
+    x = 2;
+    *x_ref = 3;
+
+    y = 4;
+    *y_ref = 5;
+
+    assert(x == 3);
+    assert(*x_ref == 3);
+    assert(y == 5);
+    assert(*y_ref == 5);
+}
+```
+
+Note that types in Noir are actually deeply immutable so the copy that occurs when
+dereferencing is only a conceptual copy - no additional constraints will occur.
+
+Mutable references can also be stored within structs. Note that there is also
+no lifetime parameter on these unlike rust. This is because the allocated memory
+always lasts the entire program - as if it were an array of one element.
+
+```rust
+struct Foo {
+    x: &mut Field
+}
+
+impl Foo {
+    fn incr(mut self) {
+        *self.x += 1;
+    }
+}
+
+fn main() {
+    let foo = Foo { x: &mut 0 };
+    foo.incr();
+    assert(*foo.x == 1);
+}
+```
+
+In general, you should avoid non-local & shared mutability unless it is needed. Sticking
+to only local mutability will improve readability and potentially improve compiler optimizations as well.
diff --git a/docs/versioned_docs/version-v0.36.0/noir/concepts/ops.md b/docs/versioned_docs/version-v0.36.0/noir/concepts/ops.md
new file mode 100644
index 00000000000..c35c36c38a9
--- /dev/null
+++ b/docs/versioned_docs/version-v0.36.0/noir/concepts/ops.md
@@ -0,0 +1,98 @@
+---
+title: Logical Operations
+description:
+  Learn about the supported arithmetic and logical operations in the Noir programming language.
+  Discover how to perform operations on private input types, integers, and booleans.
+keywords:
+  [
+    Noir programming language,
+    supported operations,
+    arithmetic operations,
+    logical operations,
+    predicate operators,
+    bitwise operations,
+    short-circuiting,
+    backend,
+  ]
+sidebar_position: 3
+---
+
+# Operations
+
+## Table of Supported Operations
+
+| Operation |                          Description                           |                           Requirements |
+| :-------- | :------------------------------------------------------------: | -------------------------------------: |
+| +         |             Adds two private input types together              |            Types must be private input |
+| -         |           Subtracts two private input types together           |            Types must be private input |
+| \*        |          Multiplies two private input types together           |            Types must be private input |
+| /         |            Divides two private input types together            |            Types must be private input |
+| ^         |              XOR two private input types together              |                  Types must be integer |
+| &         |              AND two private input types together              |                  Types must be integer |
+| \|        |              OR two private input types together               |                  Types must be integer |
+| \<\<        |        Left shift an integer by another integer amount         | Types must be integer, shift must be u8 |
+| >>        |        Right shift an integer by another integer amount        | Types must be integer, shift must be u8 |
+| !         |                     Bitwise not of a value                     |        Type must be integer or boolean |
+| \<         |       returns a bool if one value is less than the other       | Upper bound must have a known bit size |
+| \<=        | returns a bool if one value is less than or equal to the other | Upper bound must have a known bit size |
+| >         |       returns a bool if one value is more than the other       | Upper bound must have a known bit size |
+| >=        | returns a bool if one value is more than or equal to the other | Upper bound must have a known bit size |
+| ==        |       returns a bool if one value is equal to the other        |       Both types must not be constants |
+| !=        |     returns a bool if one value is not equal to the other      |       Both types must not be constants |
+
+### Predicate Operators
+
+`<,<=, !=, == , >, >=` are known as predicate/comparison operations because they compare two values.
+This differs from the operations such as `+` where the operands are used in _computation_.
+
+### Bitwise Operations Example
+
+```rust
+fn main(x : Field) {
+    let y = x as u32;
+    let z = y & y;
+}
+```
+
+`z` is implicitly constrained to be the result of `y & y`. The `&` operand is used to denote bitwise
+`&`.
+
+> `x & x` would not compile as `x` is a `Field` and not an integer type.
+
+### Logical Operators
+
+Noir has no support for the logical operators `||` and `&&`. This is because encoding the
+short-circuiting that these operators require can be inefficient for Noir's backend. Instead you can
+use the bitwise operators `|` and `&` which operate identically for booleans, just without the
+short-circuiting.
+
+```rust
+let my_val = 5;
+
+let mut flag = 1;
+if (my_val > 6) | (my_val == 0) {
+    flag = 0;
+}
+assert(flag == 1);
+
+if (my_val != 10) & (my_val < 50) {
+    flag = 0;
+}
+assert(flag == 0);
+```
+
+### Shorthand operators
+
+Noir shorthand operators for most of the above operators, namely `+=, -=, *=, /=, %=, &=, |=, ^=, <<=`, and `>>=`. These allow for more concise syntax. For example:
+
+```rust
+let mut i = 0;
+i = i + 1;
+```
+
+could be written as:
+
+```rust
+let mut i = 0;
+i += 1;
+```
diff --git a/docs/versioned_docs/version-v0.36.0/noir/concepts/oracles.mdx b/docs/versioned_docs/version-v0.36.0/noir/concepts/oracles.mdx
new file mode 100644
index 00000000000..77a2ac1550a
--- /dev/null
+++ b/docs/versioned_docs/version-v0.36.0/noir/concepts/oracles.mdx
@@ -0,0 +1,29 @@
+---
+title: Oracles
+description: Dive into how Noir supports Oracles via RPC calls, and learn how to declare an Oracle in Noir with our comprehensive guide.
+keywords:
+  - Noir
+  - Oracles
+  - RPC Calls
+  - Unconstrained Functions
+  - Programming
+  - Blockchain
+sidebar_position: 6
+---
+
+import Experimental from '@site/src/components/Notes/_experimental.mdx';
+
+<Experimental />
+
+Noir has support for Oracles via RPC calls. This means Noir will make an RPC call and use the return value for proof generation.
+
+Since Oracles are not resolved by Noir, they are [`unconstrained` functions](./unconstrained.md)
+
+You can declare an Oracle through the `#[oracle(<name>)]` flag. Example:
+
+```rust
+#[oracle(get_number_sequence)]
+unconstrained fn get_number_sequence(_size: Field) -> [Field] {}
+```
+
+The timeout for when using an external RPC oracle resolver can be set with the `NARGO_FOREIGN_CALL_TIMEOUT` environment variable. This timeout is in units of milliseconds.
diff --git a/docs/versioned_docs/version-v0.36.0/noir/concepts/shadowing.md b/docs/versioned_docs/version-v0.36.0/noir/concepts/shadowing.md
new file mode 100644
index 00000000000..5ce6130d201
--- /dev/null
+++ b/docs/versioned_docs/version-v0.36.0/noir/concepts/shadowing.md
@@ -0,0 +1,44 @@
+---
+title: Shadowing
+sidebar_position: 12
+---
+
+Noir allows for inheriting variables' values and re-declaring them with the same name similar to Rust, known as shadowing.
+
+For example, the following function is valid in Noir:
+
+```rust
+fn main() {
+    let x = 5;
+
+    {
+        let x = x * 2;
+        assert (x == 10);
+    }
+
+    assert (x == 5);
+}
+```
+
+In this example, a variable x is first defined with the value 5.
+
+The local scope that follows shadows the original x, i.e. creates a local mutable x based on the value of the original x. It is given a value of 2 times the original x.
+
+When we return to the main scope, x once again refers to just the original x, which stays at the value of 5.
+
+## Temporal mutability
+
+One way that shadowing is useful, in addition to ergonomics across scopes, is for temporarily mutating variables.
+
+```rust
+fn main() {
+    let age = 30;
+    // age = age + 5; // Would error as `age` is immutable by default.
+
+    let mut age = age + 5; // Temporarily mutates `age` with a new value.
+
+    let age = age; // Locks `age`'s mutability again.
+
+    assert (age == 35);
+}
+```
diff --git a/docs/versioned_docs/version-v0.36.0/noir/concepts/traits.md b/docs/versioned_docs/version-v0.36.0/noir/concepts/traits.md
new file mode 100644
index 00000000000..9da00a77587
--- /dev/null
+++ b/docs/versioned_docs/version-v0.36.0/noir/concepts/traits.md
@@ -0,0 +1,501 @@
+---
+title: Traits
+description:
+  Traits in Noir can be used to abstract out a common interface for functions across
+  several data types.
+keywords: [noir programming language, traits, interfaces, generic, protocol]
+sidebar_position: 14
+---
+
+## Overview
+
+Traits in Noir are a useful abstraction similar to interfaces or protocols in other languages. Each trait defines
+the interface of several methods contained within the trait. Types can then implement this trait by providing
+implementations for these methods. For example in the program:
+
+```rust
+struct Rectangle {
+    width: Field,
+    height: Field,
+}
+
+impl Rectangle {
+    fn area(self) -> Field {
+        self.width * self.height
+    }
+}
+
+fn log_area(r: Rectangle) {
+    println(r.area());
+}
+```
+
+We have a function `log_area` to log the area of a `Rectangle`. Now how should we change the program if we want this
+function to work on `Triangle`s as well?:
+
+```rust
+struct Triangle {
+    width: Field,
+    height: Field,
+}
+
+impl Triangle {
+    fn area(self) -> Field {
+        self.width * self.height / 2
+    }
+}
+```
+
+Making `log_area` generic over all types `T` would be invalid since not all types have an `area` method. Instead, we can
+introduce a new `Area` trait and make `log_area` generic over all types `T` that implement `Area`:
+
+```rust
+trait Area {
+    fn area(self) -> Field;
+}
+
+fn log_area<T>(shape: T) where T: Area {
+    println(shape.area());
+}
+```
+
+We also need to explicitly implement `Area` for `Rectangle` and `Triangle`. We can do that by changing their existing
+impls slightly. Note that the parameter types and return type of each of our `area` methods must match those defined
+by the `Area` trait.
+
+```rust
+impl Area for Rectangle {
+    fn area(self) -> Field {
+        self.width * self.height
+    }
+}
+
+impl Area for Triangle {
+    fn area(self) -> Field {
+        self.width * self.height / 2
+    }
+}
+```
+
+Now we have a working program that is generic over any type of Shape that is used! Others can even use this program
+as a library with their own types - such as `Circle` - as long as they also implement `Area` for these types.
+
+## Where Clauses
+
+As seen in `log_area` above, when we want to create a function or method that is generic over any type that implements
+a trait, we can add a where clause to the generic function.
+
+```rust
+fn log_area<T>(shape: T) where T: Area {
+    println(shape.area());
+}
+```
+
+It is also possible to apply multiple trait constraints on the same variable at once by combining traits with the `+`
+operator. Similarly, we can have multiple trait constraints by separating each with a comma:
+
+```rust
+fn foo<T, U>(elements: [T], thing: U) where
+    T: Default + Add + Eq,
+    U: Bar,
+{
+    let mut sum = T::default();
+
+    for element in elements {
+        sum += element;
+    }
+
+    if sum == T::default() {
+        thing.bar();
+    }
+}
+```
+
+## Generic Implementations
+
+You can add generics to a trait implementation by adding the generic list after the `impl` keyword:
+
+```rust
+trait Second {
+    fn second(self) -> Field;
+}
+
+impl<T> Second for (T, Field) {
+    fn second(self) -> Field {
+        self.1
+    }
+}
+```
+
+You can also implement a trait for every type this way:
+
+```rust
+trait Debug {
+    fn debug(self);
+}
+
+impl<T> Debug for T {
+    fn debug(self) {
+        println(self);
+    }
+}
+
+fn main() {
+    1.debug();
+}
+```
+
+### Generic Trait Implementations With Where Clauses
+
+Where clauses can be placed on trait implementations themselves to restrict generics in a similar way.
+For example, while `impl<T> Foo for T` implements the trait `Foo` for every type, `impl<T> Foo for T where T: Bar`
+will implement `Foo` only for types that also implement `Bar`. This is often used for implementing generic types.
+For example, here is the implementation for array equality:
+
+```rust
+impl<T, let N: u32> Eq for [T; let N: u32] where T: Eq {
+    // Test if two arrays have the same elements.
+    // Because both arrays must have length N, we know their lengths already match.
+    fn eq(self, other: Self) -> bool {
+        let mut result = true;
+
+        for i in 0 .. self.len() {
+            // The T: Eq constraint is needed to call == on the array elements here
+            result &= self[i] == other[i];
+        }
+
+        result
+    }
+}
+```
+
+Where clauses can also be placed on struct implementations. 
+For example, here is a method utilizing a generic type that implements the equality trait.
+
+```rust
+struct Foo<T> {
+    a: u32,
+    b: T,
+}
+
+impl<T> Foo<T> where T: Eq {
+    fn eq(self, other: Self) -> bool {
+        (self.a == other.a) & self.b.eq(other.b)
+    }
+}
+```
+
+## Generic Traits
+
+Traits themselves can also be generic by placing the generic arguments after the trait name. These generics are in
+scope of every item within the trait.
+
+```rust
+trait Into<T> {
+    // Convert `self` to type `T`
+    fn into(self) -> T;
+}
+```
+
+When implementing generic traits the generic arguments of the trait must be specified. This is also true anytime
+when referencing a generic trait (e.g. in a `where` clause).
+
+```rust
+struct MyStruct {
+    array: [Field; 2],
+}
+
+impl Into<[Field; 2]> for MyStruct {
+    fn into(self) -> [Field; 2] {
+        self.array
+    }
+}
+
+fn as_array<T>(x: T) -> [Field; 2] 
+    where T: Into<[Field; 2]>
+{
+    x.into()
+}
+
+fn main() {
+    let array = [1, 2];
+    let my_struct = MyStruct { array };
+
+    assert_eq(as_array(my_struct), array);
+}
+```
+
+### Associated Types and Constants
+
+Traits also support associated types and constraints which can be thought of as additional generics that are referred to by name.
+
+Here's an example of a trait with an associated type `Foo` and a constant `Bar`:
+
+```rust
+trait MyTrait {
+    type Foo;
+
+    let Bar: u32;
+}
+```
+
+Now when we're implementing `MyTrait` we also have to provide values for `Foo` and `Bar`:
+
+```rust
+impl MyTrait for Field {
+    type Foo = i32;
+
+    let Bar: u32 = 11;
+}
+```
+
+Since associated constants can also be used in a type position, its values are limited to only other
+expression kinds allowed in numeric generics.
+
+Note that currently all associated types and constants must be explicitly specified in a trait constraint.
+If we leave out any, we'll get an error that we're missing one:
+
+```rust
+// Error! Constraint is missing associated constant for `Bar`
+fn foo<T>(x: T) where T: MyTrait<Foo = i32> {
+    ...
+}
+```
+
+Because all associated types and constants must be explicitly specified, they are essentially named generics,
+although this is set to change in the future. Future versions of Noir will allow users to elide associated types
+in trait constraints similar to Rust. When this is done, you may still refer to their value with the `<Type as Trait>::AssociatedType`
+syntax:
+
+```rust
+// Only valid in future versions of Noir:
+fn foo<T>(x: T) where T: MyTrait {
+    let _: <T as MyTrait>::Foo = ...;
+}
+```
+
+The type as trait syntax is possible in Noir today but is less useful when each type must be explicitly specified anyway:
+
+```rust
+fn foo<T, F, let B: u32>(x: T) where T: MyTrait<Foo = F, Bar = B> {
+    // Works, but could just use F directly
+    let _: <T as MyTrait<Foo = F, Bar = B>>::Foo = ...;
+
+    let _: F = ...;
+}
+```
+
+## Trait Methods With No `self`
+
+A trait can contain any number of methods, each of which have access to the `Self` type which represents each type
+that eventually implements the trait. Similarly, the `self` variable is available as well but is not required to be used.
+For example, we can define a trait to create a default value for a type. This trait will need to return the `Self` type
+but doesn't need to take any parameters:
+
+```rust
+trait Default {
+    fn default() -> Self;
+}
+```
+
+Implementing this trait can be done similarly to any other trait:
+
+```rust
+impl Default for Field {
+    fn default() -> Field {
+        0
+    }
+}
+
+struct MyType {}
+
+impl Default for MyType {
+    fn default() -> Field {
+        MyType {}
+    }
+}
+```
+
+However, since there is no `self` parameter, we cannot call it via the method call syntax `object.method()`.
+Instead, we'll need to refer to the function directly. This can be done either by referring to the
+specific impl `MyType::default()` or referring to the trait itself `Default::default()`. In the later
+case, type inference determines the impl that is selected.
+
+```rust
+let my_struct = MyStruct::default();
+
+let x: Field = Default::default();
+let result = x + Default::default();
+```
+
+:::warning
+
+```rust
+let _ = Default::default();
+```
+
+If type inference cannot select which impl to use because of an ambiguous `Self` type, an impl will be
+arbitrarily selected. This occurs most often when the result of a trait function call with no parameters
+is unused. To avoid this, when calling a trait function with no `self` or `Self` parameters or return type,
+always refer to it via the implementation type's namespace - e.g. `MyType::default()`.
+This is set to change to an error in future Noir versions.
+
+:::
+
+## Default Method Implementations
+
+A trait can also have default implementations of its methods by giving a body to the desired functions.
+Note that this body must be valid for all types that may implement the trait. As a result, the only
+valid operations on `self` will be operations valid for any type or other operations on the trait itself.
+
+```rust
+trait Numeric {
+    fn add(self, other: Self) -> Self;
+
+    // Default implementation of double is (self + self)
+    fn double(self) -> Self {
+        self.add(self)
+    }
+}
+```
+
+When implementing a trait with default functions, a type may choose to implement only the required functions:
+
+```rust
+impl Numeric for Field {
+    fn add(self, other: Field) -> Field {
+        self + other
+    }
+}
+```
+
+Or it may implement the optional methods as well:
+
+```rust
+impl Numeric for u32 {
+    fn add(self, other: u32) -> u32 {
+        self + other
+    }
+
+    fn double(self) -> u32 {
+        self * 2
+    }
+}
+```
+
+## Impl Specialization
+
+When implementing traits for a generic type it is possible to implement the trait for only a certain combination
+of generics. This can be either as an optimization or because those specific generics are required to implement the trait.
+
+```rust
+trait Sub {
+    fn sub(self, other: Self) -> Self;
+}
+
+struct NonZero<T> {
+    value: T,
+}
+
+impl Sub for NonZero<Field> {
+    fn sub(self, other: Self) -> Self {
+        let value = self.value - other.value;
+        assert(value != 0);
+        NonZero { value }
+    }
+}
+```
+
+## Overlapping Implementations
+
+Overlapping implementations are disallowed by Noir to ensure Noir's decision on which impl to select is never ambiguous.
+This means if a trait `Foo` is already implemented
+by a type `Bar<T>` for all `T`, then we cannot also have a separate impl for `Bar<Field>` (or any other
+type argument). Similarly, if there is an impl for all `T` such as `impl<T> Debug for T`, we cannot create
+any more impls to `Debug` for other types since it would be ambiguous which impl to choose for any given
+method call.
+
+```rust
+trait Trait {}
+
+// Previous impl defined here
+impl<A, B> Trait for (A, B) {}
+
+// error: Impl for type `(Field, Field)` overlaps with existing impl
+impl Trait for (Field, Field) {}
+```
+
+## Trait Coherence
+
+Another restriction on trait implementations is coherence. This restriction ensures other crates cannot create
+impls that may overlap with other impls, even if several unrelated crates are used as dependencies in the same
+program.
+
+The coherence restriction is: to implement a trait, either the trait itself or the object type must be declared
+in the crate the impl is in.
+
+In practice this often comes up when using types provided by libraries. If a library provides a type `Foo` that does
+not implement a trait in the standard library such as `Default`, you may not `impl Default for Foo` in your own crate.
+While restrictive, this prevents later issues or silent changes in the program if the `Foo` library later added its
+own impl for `Default`. If you are a user of the `Foo` library in this scenario and need a trait not implemented by the
+library your choices are to either submit a patch to the library or use the newtype pattern.
+
+### The Newtype Pattern
+
+The newtype pattern gets around the coherence restriction by creating a new wrapper type around the library type
+that we cannot create `impl`s for. Since the new wrapper type is defined in our current crate, we can create
+impls for any trait we need on it.
+
+```rust
+struct Wrapper {
+    foo: some_library::Foo,
+}
+
+impl Default for Wrapper {
+    fn default() -> Wrapper {
+        Wrapper {
+            foo: some_library::Foo::new(),
+        }
+    }
+}
+```
+
+Since we have an impl for our own type, the behavior of this code will not change even if `some_library` is updated
+to provide its own `impl Default for Foo`. The downside of this pattern is that it requires extra wrapping and
+unwrapping of values when converting to and from the `Wrapper` and `Foo` types.
+
+### Trait Inheritance
+
+Sometimes, you might need one trait to use another trait’s functionality (like "inheritance" in some other languages). In this case, you can specify this relationship by listing any child traits after the parent trait's name and a colon. Now, whenever the parent trait is implemented it will require the child traits to be implemented as well. A parent trait is also called a "super trait."
+
+```rust
+trait Person {
+    fn name(self) -> String;
+}
+
+// Person is a supertrait of Student.
+// Implementing Student requires you to also impl Person.
+trait Student: Person {
+    fn university(self) -> String;
+}
+
+trait Programmer {
+    fn fav_language(self) -> String;
+}
+
+// CompSciStudent (computer science student) is a subtrait of both Programmer 
+// and Student. Implementing CompSciStudent requires you to impl both supertraits.
+trait CompSciStudent: Programmer + Student {
+    fn git_username(self) -> String;
+}
+```
+
+### Visibility
+
+By default, like functions, traits are private to the module they exist in. You can use `pub`
+to make the trait public or `pub(crate)` to make it public to just its crate:
+
+```rust
+// This trait is now public
+pub trait Trait {}
+```
\ No newline at end of file
diff --git a/docs/versioned_docs/version-v0.36.0/noir/concepts/unconstrained.md b/docs/versioned_docs/version-v0.36.0/noir/concepts/unconstrained.md
new file mode 100644
index 00000000000..b5221b8d2dd
--- /dev/null
+++ b/docs/versioned_docs/version-v0.36.0/noir/concepts/unconstrained.md
@@ -0,0 +1,104 @@
+---
+title: Unconstrained Functions
+description: "Learn about what unconstrained functions in Noir are, how to use them and when you'd want to."
+
+keywords: [Noir programming language, unconstrained, open]
+sidebar_position: 5
+---
+
+Unconstrained functions are functions which do not constrain any of the included computation and allow for non-deterministic computation.
+
+## Why?
+
+Zero-knowledge (ZK) domain-specific languages (DSL) enable developers to generate ZK proofs from their programs by compiling code down to the constraints of an NP complete language (such as R1CS or PLONKish languages). However, the hard bounds of a constraint system can be very limiting to the functionality of a ZK DSL.
+
+Enabling a circuit language to perform unconstrained execution is a powerful tool. Said another way, unconstrained execution lets developers generate witnesses from code that does not generate any constraints. Being able to execute logic outside of a circuit is critical for both circuit performance and constructing proofs on information that is external to a circuit.
+
+Fetching information from somewhere external to a circuit can also be used to enable developers to improve circuit efficiency.
+
+A ZK DSL does not just prove computation, but proves that some computation was handled correctly. Thus, it is necessary that when we switch from performing some operation directly inside of a circuit to inside of an unconstrained environment that the appropriate constraints are still laid down elsewhere in the circuit.
+
+## Example
+
+An in depth example might help drive the point home. This example comes from the excellent [post](https://discord.com/channels/1113924620781883405/1124022445054111926/1128747641853972590) by Tom in the Noir Discord.
+
+Let's look at how we can optimize a function to turn a `u72` into an array of `u8`s.
+
+```rust
+fn main(num: u72) -> pub [u8; 8] {
+    let mut out: [u8; 8] = [0; 8];
+    for i in 0..8 {
+        out[i] = (num >> (56 - (i * 8)) as u72 & 0xff) as u8;
+    }
+
+    out
+}
+```
+
+```
+Total ACIR opcodes generated for language PLONKCSat { width: 3 }: 91
+Backend circuit size: 3619
+```
+
+A lot of the operations in this function are optimized away by the compiler (all the bit-shifts turn into divisions by constants). However we can save a bunch of gates by casting to u8 a bit earlier. This automatically truncates the bit-shifted value to fit in a u8 which allows us to remove the AND against 0xff. This saves us ~480 gates in total.
+
+```rust
+fn main(num: u72) -> pub [u8; 8] {
+    let mut out: [u8; 8] = [0; 8];
+    for i in 0..8 {
+        out[i] = (num >> (56 - (i * 8)) as u8;
+    }
+
+    out
+}
+```
+
+```
+Total ACIR opcodes generated for language PLONKCSat { width: 3 }: 75
+Backend circuit size: 3143
+```
+
+Those are some nice savings already but we can do better. This code is all constrained so we're proving every step of calculating out using num, but we don't actually care about how we calculate this, just that it's correct. This is where brillig comes in.
+
+It turns out that truncating a u72 into a u8 is hard to do inside a snark, each time we do as u8 we lay down 4 ACIR opcodes which get converted into multiple gates. It's actually much easier to calculate num from out than the other way around. All we need to do is multiply each element of out by a constant and add them all together, both relatively easy operations inside a snark.
+
+We can then run `u72_to_u8` as unconstrained brillig code in order to calculate out, then use that result in our constrained function and assert that if we were to do the reverse calculation we'd get back num. This looks a little like the below:
+
+```rust
+fn main(num: u72) -> pub [u8; 8] {
+    let out = unsafe { 
+        u72_to_u8(num) 
+    };
+
+    let mut reconstructed_num: u72 = 0;
+    for i in 0..8 {
+        reconstructed_num += (out[i] as u72 << (56 - (8 * i)));
+    }
+    assert(num == reconstructed_num);
+    out
+}
+
+unconstrained fn u72_to_u8(num: u72) -> [u8; 8] {
+    let mut out: [u8; 8] = [0; 8];
+    for i in 0..8 {
+        out[i] = (num >> (56 - (i * 8))) as u8;
+    }
+    out
+}
+```
+
+```
+Total ACIR opcodes generated for language PLONKCSat { width: 3 }: 78
+Backend circuit size: 2902
+```
+
+This ends up taking off another ~250 gates from our circuit! We've ended up with more ACIR opcodes than before but they're easier for the backend to prove (resulting in fewer gates).
+
+Note that in order to invoke unconstrained functions we need to wrap them in an `unsafe` block,
+to make it clear that the call is unconstrained.
+
+Generally we want to use brillig whenever there's something that's easy to verify but hard to compute within the circuit. For example, if you wanted to calculate a square root of a number it'll be a much better idea to calculate this in brillig and then assert that if you square the result you get back your number.
+
+## Break and Continue
+
+In addition to loops over runtime bounds, `break` and `continue` are also available in unconstrained code. See [break and continue](../concepts/control_flow.md#break-and-continue)
diff --git a/docs/versioned_docs/version-v0.36.0/noir/modules_packages_crates/_category_.json b/docs/versioned_docs/version-v0.36.0/noir/modules_packages_crates/_category_.json
new file mode 100644
index 00000000000..1debcfe7675
--- /dev/null
+++ b/docs/versioned_docs/version-v0.36.0/noir/modules_packages_crates/_category_.json
@@ -0,0 +1,6 @@
+{
+    "label": "Modules, Packages and Crates",
+    "position": 2,
+    "collapsible": true,
+    "collapsed": true
+}
diff --git a/docs/versioned_docs/version-v0.36.0/noir/modules_packages_crates/crates_and_packages.md b/docs/versioned_docs/version-v0.36.0/noir/modules_packages_crates/crates_and_packages.md
new file mode 100644
index 00000000000..95ee9f52ab2
--- /dev/null
+++ b/docs/versioned_docs/version-v0.36.0/noir/modules_packages_crates/crates_and_packages.md
@@ -0,0 +1,43 @@
+---
+title: Crates and Packages
+description: Learn how to use Crates and Packages in your Noir project
+keywords: [Nargo, dependencies, package management, crates, package]
+sidebar_position: 0
+---
+
+## Crates
+
+A crate is the smallest amount of code that the Noir compiler considers at a time.
+Crates can contain modules, and the modules may be defined in other files that get compiled with the crate, as we’ll see in the coming sections.
+
+### Crate Types
+
+A Noir crate can come in several forms: binaries, libraries or contracts.
+
+#### Binaries
+
+_Binary crates_ are programs which you can compile to an ACIR circuit which you can then create proofs against. Each must have a function called `main` that defines the ACIR circuit which is to be proved.
+
+#### Libraries
+
+_Library crates_ don't have a `main` function and they don't compile down to ACIR. Instead they define functionality intended to be shared with multiple projects, and eventually included in a binary crate.
+
+#### Contracts
+
+Contract crates are similar to binary crates in that they compile to ACIR which you can create proofs against. They are different in that they do not have a single `main` function, but are a collection of functions to be deployed to the [Aztec network](https://aztec.network). You can learn more about the technical details of Aztec in the [monorepo](https://github.com/AztecProtocol/aztec-packages) or contract [examples](https://github.com/AztecProtocol/aztec-packages/tree/master/noir-projects/noir-contracts/contracts).
+
+### Crate Root
+
+Every crate has a root, which is the source file that the compiler starts, this is also known as the root module. The Noir compiler does not enforce any conditions on the name of the file which is the crate root, however if you are compiling via Nargo the crate root must be called `lib.nr` or `main.nr` for library or binary crates respectively.
+
+## Packages
+
+A Nargo _package_ is a collection of one of more crates that provides a set of functionality. A package must include a Nargo.toml file.
+
+A package _must_ contain either a library or a binary crate, but not both.
+
+### Differences from Cargo Packages
+
+One notable difference between Rust's Cargo and Noir's Nargo is that while Cargo allows a package to contain an unlimited number of binary crates and a single library crate, Nargo currently only allows a package to contain a single crate.
+
+In future this restriction may be lifted to allow a Nargo package to contain both a binary and library crate or multiple binary crates.
diff --git a/docs/versioned_docs/version-v0.36.0/noir/modules_packages_crates/dependencies.md b/docs/versioned_docs/version-v0.36.0/noir/modules_packages_crates/dependencies.md
new file mode 100644
index 00000000000..24e02de08fe
--- /dev/null
+++ b/docs/versioned_docs/version-v0.36.0/noir/modules_packages_crates/dependencies.md
@@ -0,0 +1,124 @@
+---
+title: Dependencies
+description:
+  Learn how to specify and manage dependencies in Nargo, allowing you to upload packages to GitHub
+  and use them easily in your project.
+keywords: [Nargo, dependencies, GitHub, package management, versioning]
+sidebar_position: 1
+---
+
+Nargo allows you to upload packages to GitHub and use them as dependencies.
+
+## Specifying a dependency
+
+Specifying a dependency requires a tag to a specific commit and the git url to the url containing
+the package.
+
+Currently, there are no requirements on the tag contents. If requirements are added, it would follow
+semver 2.0 guidelines.
+
+> Note: Without a `tag` , there would be no versioning and dependencies would change each time you
+> compile your project.
+
+For example, to add the [ecrecover-noir library](https://github.com/colinnielsen/ecrecover-noir) to your project, add it to `Nargo.toml`:
+
+```toml
+# Nargo.toml
+
+[dependencies]
+ecrecover = {tag = "v0.8.0", git = "https://github.com/colinnielsen/ecrecover-noir"}
+```
+
+If the module is in a subdirectory, you can define a subdirectory in your git repository, for example:
+
+```toml
+# Nargo.toml
+
+[dependencies]
+easy_private_token_contract = {tag ="v0.1.0-alpha62", git = "https://github.com/AztecProtocol/aztec-packages", directory = "noir-contracts/contracts/easy_private_token_contract"}
+```
+
+## Specifying a local dependency
+
+You can also specify dependencies that are local to your machine.
+
+For example, this file structure has a library and binary crate
+
+```tree
+├── binary_crate
+│   ├── Nargo.toml
+│   └── src
+│       └── main.nr
+└── lib_a
+    ├── Nargo.toml
+    └── src
+        └── lib.nr
+```
+
+Inside of the binary crate, you can specify:
+
+```toml
+# Nargo.toml
+
+[dependencies]
+lib_a = { path = "../lib_a" }
+```
+
+## Importing dependencies
+
+You can import a dependency to a Noir file using the following syntax. For example, to import the
+ecrecover-noir library and local lib_a referenced above:
+
+```rust
+use ecrecover;
+use lib_a;
+```
+
+You can also import only the specific parts of dependency that you want to use, like so:
+
+```rust
+use std::hash::sha256;
+use std::scalar_mul::fixed_base_embedded_curve;
+```
+
+Lastly, as demonstrated in the
+[elliptic curve example](../standard_library/cryptographic_primitives/ec_primitives.md#examples), you
+can import multiple items in the same line by enclosing them in curly braces:
+
+```rust
+use std::ec::tecurve::affine::{Curve, Point};
+```
+
+We don't have a way to consume libraries from inside a [workspace](./workspaces.md) as external dependencies right now.
+
+Inside a workspace, these are consumed as `{ path = "../to_lib" }` dependencies in Nargo.toml.
+
+## Dependencies of Dependencies
+
+Note that when you import a dependency, you also get access to all of the dependencies of that package.
+
+For example, the [phy_vector](https://github.com/resurgencelabs/phy_vector) library imports an [fraction](https://github.com/resurgencelabs/fraction) library. If you're importing the phy_vector library, then you can access the functions in fractions library like so:
+
+```rust
+use phy_vector;
+
+fn main(x : Field, y : pub Field) {
+  //...
+  let f = phy_vector::fraction::toFraction(true, 2, 1);
+  //...
+}
+```
+
+## Available Libraries
+
+Noir does not currently have an official package manager. You can find a list of available Noir libraries in the [awesome-noir repo here](https://github.com/noir-lang/awesome-noir#libraries).
+
+Some libraries that are available today include:
+
+- [Standard Library](https://github.com/noir-lang/noir/tree/master/noir_stdlib) - the Noir Standard Library
+- [Ethereum Storage Proof Verification](https://github.com/aragonzkresearch/noir-trie-proofs) - a library that contains the primitives necessary for RLP decoding (in the form of look-up table construction) and Ethereum state and storage proof verification (or verification of any trie proof involving 32-byte long keys)
+- [BigInt](https://github.com/shuklaayush/noir-bigint) - a library that provides a custom BigUint56 data type, allowing for computations on large unsigned integers
+- [ECrecover](https://github.com/colinnielsen/ecrecover-noir/tree/main) - a library to verify an ECDSA signature and return the source Ethereum address
+- [Sparse Merkle Tree Verifier](https://github.com/vocdoni/smtverifier-noir/tree/main) - a library for verification of sparse Merkle trees
+- [Signed Int](https://github.com/resurgencelabs/signed_int) - a library for accessing a custom Signed Integer data type, allowing access to negative numbers on Noir
+- [Fraction](https://github.com/resurgencelabs/fraction) - a library for accessing fractional number data type in Noir, allowing results that aren't whole numbers
diff --git a/docs/versioned_docs/version-v0.36.0/noir/modules_packages_crates/modules.md b/docs/versioned_docs/version-v0.36.0/noir/modules_packages_crates/modules.md
new file mode 100644
index 00000000000..14aa1f0579a
--- /dev/null
+++ b/docs/versioned_docs/version-v0.36.0/noir/modules_packages_crates/modules.md
@@ -0,0 +1,221 @@
+---
+title: Modules
+description:
+  Learn how to organize your files using modules in Noir, following the same convention as Rust's
+  module system. Examples included.
+keywords: [Noir, Rust, modules, organizing files, sub-modules]
+sidebar_position: 2
+---
+
+Noir's module system follows the same convention as the _newer_ version of Rust's module system.
+
+## Purpose of Modules
+
+Modules are used to organize files. Without modules all of your code would need to live in a single
+file. In Noir, the compiler does not automatically scan all of your files to detect modules. This
+must be done explicitly by the developer.
+
+## Examples
+
+### Importing a module in the crate root
+
+Filename : `src/main.nr`
+
+```rust
+mod foo;
+
+fn main() {
+    foo::hello_world();
+}
+```
+
+Filename : `src/foo.nr`
+
+```rust
+fn from_foo() {}
+```
+
+In the above snippet, the crate root is the `src/main.nr` file. The compiler sees the module
+declaration `mod foo` which prompts it to look for a foo.nr file.
+
+Visually this module hierarchy looks like the following :
+
+```
+crate
+ ├── main
+ │
+ └── foo
+      └── from_foo
+
+```
+
+The module filename may also be the name of the module as a directory with the contents in a 
+file named `mod.nr` within that directory. The above example can alternatively be expressed like this:
+
+Filename : `src/main.nr`
+
+```rust
+mod foo;
+
+fn main() {
+    foo::hello_world();
+}
+```
+
+Filename : `src/foo/mod.nr`
+
+```rust
+fn from_foo() {}
+```
+
+Note that it's an error to have both files `src/foo.nr` and `src/foo/mod.nr` in the filesystem.
+
+### Importing a module throughout the tree
+
+All modules are accessible from the `crate::` namespace.
+
+```
+crate
+ ├── bar
+ ├── foo
+ └── main
+
+```
+
+In the above snippet, if `bar` would like to use functions in `foo`, it can do so by `use crate::foo::function_name`.
+
+### Sub-modules
+
+Filename : `src/main.nr`
+
+```rust
+mod foo;
+
+fn main() {
+    foo::from_foo();
+}
+```
+
+Filename : `src/foo.nr`
+
+```rust
+mod bar;
+fn from_foo() {}
+```
+
+Filename : `src/foo/bar.nr`
+
+```rust
+fn from_bar() {}
+```
+
+In the above snippet, we have added an extra module to the module tree; `bar`. `bar` is a submodule
+of `foo` hence we declare bar in `foo.nr` with `mod bar`. Since `foo` is not the crate root, the
+compiler looks for the file associated with the `bar` module in `src/foo/bar.nr`
+
+Visually the module hierarchy looks as follows:
+
+```
+crate
+ ├── main
+ │
+ └── foo
+      ├── from_foo
+      └── bar
+           └── from_bar
+```
+
+Similar to importing a module in the crate root, modules can be placed in a `mod.nr` file, like this:
+
+Filename : `src/main.nr`
+
+```rust
+mod foo;
+
+fn main() {
+    foo::from_foo();
+}
+```
+
+Filename : `src/foo/mod.nr`
+
+```rust
+mod bar;
+fn from_foo() {}
+```
+
+Filename : `src/foo/bar/mod.nr`
+
+```rust
+fn from_bar() {}
+```
+
+### Referencing a parent module 
+
+Given a submodule, you can refer to its parent module using the `super` keyword.
+
+Filename : `src/main.nr`
+
+```rust
+mod foo;
+
+fn main() {
+    foo::from_foo();
+}
+```
+
+Filename : `src/foo.nr`
+
+```rust
+mod bar;
+
+fn from_foo() {}
+```
+
+Filename : `src/foo/bar.nr`
+
+```rust
+// Same as bar::from_foo
+use super::from_foo; 
+
+fn from_bar() {
+    from_foo();        // invokes super::from_foo(), which is bar::from_foo()
+    super::from_foo(); // also invokes bar::from_foo()
+}
+```
+
+### `use` visibility
+
+`use` declarations are private to the containing module, by default. However, like functions, 
+they can be marked as `pub` or `pub(crate)`. Such a use declaration serves to _re-export_ a name. 
+A public `use` declaration can therefore redirect some public name to a different target definition: 
+even a definition with a private canonical path, inside a different module.
+
+An example of re-exporting:
+
+```rust
+mod some_module {
+    pub use foo::{bar, baz};
+    mod foo {
+        pub fn bar() {}
+        pub fn baz() {}
+    }
+}
+
+fn main() {
+    some_module::bar();
+    some_module::baz();
+}
+```
+
+In this example, the module `some_module` re-exports two public names defined in `foo`.
+
+### Visibility
+
+By default, like functions, modules are private to the module (or crate) they exist in. You can use `pub`
+to make the module public or `pub(crate)` to make it public to just its crate:
+
+```rust
+// This module is now public and can be seen by other crates.
+pub mod foo;
+```
\ No newline at end of file
diff --git a/docs/versioned_docs/version-v0.36.0/noir/modules_packages_crates/workspaces.md b/docs/versioned_docs/version-v0.36.0/noir/modules_packages_crates/workspaces.md
new file mode 100644
index 00000000000..513497f12bf
--- /dev/null
+++ b/docs/versioned_docs/version-v0.36.0/noir/modules_packages_crates/workspaces.md
@@ -0,0 +1,42 @@
+---
+title: Workspaces
+sidebar_position: 3
+---
+
+Workspaces are a feature of nargo that allow you to manage multiple related Noir packages in a single repository. A workspace is essentially a group of related projects that share common build output directories and configurations.
+
+Each Noir project (with it's own Nargo.toml file) can be thought of as a package. Each package is expected to contain exactly one "named circuit", being the "name" defined in Nargo.toml with the program logic defined in `./src/main.nr`.
+
+For a project with the following structure:
+
+```tree
+├── crates
+│   ├── a
+│   │   ├── Nargo.toml
+│   │   └── Prover.toml
+│   │   └── src
+│   │       └── main.nr
+│   └── b
+│       ├── Nargo.toml
+│       └── Prover.toml
+│       └── src
+│           └── main.nr
+│
+└── Nargo.toml
+```
+
+You can define a workspace in Nargo.toml like so:
+
+```toml
+[workspace]
+members = ["crates/a", "crates/b"]
+default-member = "crates/a"
+```
+
+`members` indicates which packages are included in the workspace. As such, all member packages of a workspace will be processed when the `--workspace` flag is used with various commands or if a `default-member` is not specified.
+
+`default-member` indicates which package various commands process by default.
+
+Libraries can be defined in a workspace. Inside a workspace, these are consumed as `{ path = "../to_lib" }` dependencies in Nargo.toml.
+
+Inside a workspace, these are consumed as `{ path = "../to_lib" }` dependencies in Nargo.toml.
diff --git a/docs/versioned_docs/version-v0.36.0/noir/standard_library/_category_.json b/docs/versioned_docs/version-v0.36.0/noir/standard_library/_category_.json
new file mode 100644
index 00000000000..e275f03bc6a
--- /dev/null
+++ b/docs/versioned_docs/version-v0.36.0/noir/standard_library/_category_.json
@@ -0,0 +1,6 @@
+{
+  "label": "Standard Library",
+  "position": 1,
+  "collapsible": true,
+  "collapsed": true
+}
diff --git a/docs/versioned_docs/version-v0.36.0/noir/standard_library/bigint.md b/docs/versioned_docs/version-v0.36.0/noir/standard_library/bigint.md
new file mode 100644
index 00000000000..05c3011634f
--- /dev/null
+++ b/docs/versioned_docs/version-v0.36.0/noir/standard_library/bigint.md
@@ -0,0 +1,127 @@
+---
+title: Big Integers
+description: How to use big integers from Noir standard library
+keywords:
+  [
+    Big Integer,
+    Noir programming language,
+    Noir libraries,
+  ]
+---
+
+The BigInt module in the standard library exposes some class of integers which do not fit (well) into a Noir native field. It implements modulo arithmetic, modulo a 'big' prime number.
+
+:::note
+
+The module can currently be considered as `Field`s with fixed modulo sizes used by a set of elliptic curves, in addition to just the native curve. [More work](https://github.com/noir-lang/noir/issues/510) is needed to achieve arbitrarily sized big integers.
+
+:::note
+
+`nargo` can be built with `--profile release-pedantic` to enable extra overflow checks which may affect `BigInt` results in some cases.
+Consider the [`noir-bignum`](https://github.com/noir-lang/noir-bignum) library for an optimized alternative approach.
+
+:::
+
+Currently 6 classes of integers (i.e 'big' prime numbers) are available in the module, namely:
+
+- BN254 Fq: Bn254Fq
+- BN254 Fr: Bn254Fr
+- Secp256k1 Fq: Secpk1Fq
+- Secp256k1 Fr: Secpk1Fr
+- Secp256r1 Fr: Secpr1Fr
+- Secp256r1 Fq: Secpr1Fq
+
+Where XXX Fq and XXX Fr denote respectively the order of the base and scalar field of the (usual) elliptic curve XXX.
+For instance the big integer 'Secpk1Fq' in the standard library refers to integers modulo $2^{256}-2^{32}-977$.
+
+Feel free to explore the source code for the other primes:
+
+```rust title="big_int_definition" showLineNumbers 
+pub struct BigInt {
+    pointer: u32,
+    modulus: u32,
+}
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/bigint.nr#L28-L33" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/bigint.nr#L28-L33</a></sub></sup>
+
+
+## Example usage
+
+A common use-case is when constructing a big integer from its bytes representation, and performing arithmetic operations on it:
+
+```rust title="big_int_example" showLineNumbers 
+fn big_int_example(x: u8, y: u8) {
+    let a = Secpk1Fq::from_le_bytes(&[x, y, 0, 45, 2]);
+    let b = Secpk1Fq::from_le_bytes(&[y, x, 9]);
+    let c = (a + b) * b / a;
+    let d = c.to_le_bytes();
+    println(d[0]);
+}
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/test_programs/execution_success/bigint/src/main.nr#L74-L82" target="_blank" rel="noopener noreferrer">Source code: test_programs/execution_success/bigint/src/main.nr#L74-L82</a></sub></sup>
+
+
+## Methods
+
+The available operations for each big integer are:
+
+### from_le_bytes
+
+Construct a big integer from its little-endian bytes representation. Example:
+
+```rust
+ // Construct a big integer from a slice of bytes
+ let a = Secpk1Fq::from_le_bytes(&[x, y, 0, 45, 2]);
+ // Construct a big integer from an array of 32 bytes
+ let a = Secpk1Fq::from_le_bytes_32([1;32]);
+ ```
+
+Sure, here's the formatted version of the remaining methods:
+
+### to_le_bytes
+
+Return the little-endian bytes representation of a big integer. Example:
+
+```rust
+let bytes = a.to_le_bytes();
+```
+
+### add
+
+Add two big integers. Example:
+
+```rust
+let sum = a + b;
+```
+
+### sub
+
+Subtract two big integers. Example:
+
+```rust
+let difference = a - b;
+```
+
+### mul
+
+Multiply two big integers. Example:
+
+```rust
+let product = a * b;
+```
+
+### div
+
+Divide two big integers. Note that division is field division and not euclidean division. Example:
+
+```rust
+let quotient = a / b;
+```
+
+### eq
+
+Compare two big integers. Example:
+
+```rust
+let are_equal = a == b;
+```
diff --git a/docs/versioned_docs/version-v0.36.0/noir/standard_library/black_box_fns.md b/docs/versioned_docs/version-v0.36.0/noir/standard_library/black_box_fns.md
new file mode 100644
index 00000000000..d6079ab182c
--- /dev/null
+++ b/docs/versioned_docs/version-v0.36.0/noir/standard_library/black_box_fns.md
@@ -0,0 +1,32 @@
+---
+title: Black Box Functions
+description: Black box functions are functions in Noir that rely on backends implementing support for specialized constraints.
+keywords: [noir, black box functions]
+---
+
+Black box functions are functions in Noir that rely on backends implementing support for specialized constraints. This makes certain zk-snark unfriendly computations cheaper than if they were implemented in Noir.
+
+The ACVM spec defines a set of blackbox functions which backends will be expected to implement. This allows backends to use optimized implementations of these constraints if they have them, however they may also fallback to less efficient naive implementations if not.
+
+## Function list
+
+Here is a list of the current black box functions:
+
+- [AES128](./cryptographic_primitives/ciphers.mdx#aes128)
+- [SHA256](./cryptographic_primitives/hashes.mdx#sha256)
+- [Schnorr signature verification](./cryptographic_primitives/schnorr.mdx)
+- [Blake2s](./cryptographic_primitives/hashes.mdx#blake2s)
+- [Blake3](./cryptographic_primitives/hashes.mdx#blake3)
+- [Pedersen Hash](./cryptographic_primitives/hashes.mdx#pedersen_hash)
+- [Pedersen Commitment](./cryptographic_primitives/hashes.mdx#pedersen_commitment)
+- [ECDSA signature verification](./cryptographic_primitives/ecdsa_sig_verification.mdx)
+- [Embedded curve operations (MSM, addition, ...)](./cryptographic_primitives/embedded_curve_ops.mdx)
+- AND
+- XOR
+- RANGE
+- [Keccak256](./cryptographic_primitives/hashes.mdx#keccak256)
+- [Recursive proof verification](./recursion.mdx)
+
+Most black box functions are included as part of the Noir standard library, however `AND`, `XOR` and `RANGE` are used as part of the Noir language syntax. For instance, using the bitwise operator `&` will invoke the `AND` black box function.
+
+You can view the black box functions defined in the ACVM code [here](https://github.com/noir-lang/noir/blob/master/acvm-repo/acir/src/circuit/black_box_functions.rs).
diff --git a/docs/versioned_docs/version-v0.36.0/noir/standard_library/bn254.md b/docs/versioned_docs/version-v0.36.0/noir/standard_library/bn254.md
new file mode 100644
index 00000000000..3294f005dbb
--- /dev/null
+++ b/docs/versioned_docs/version-v0.36.0/noir/standard_library/bn254.md
@@ -0,0 +1,46 @@
+---
+title: Bn254 Field Library
+---
+
+Noir provides a module in standard library with some optimized functions for bn254 Fr in `std::field::bn254`.
+
+## decompose
+
+```rust
+fn decompose(x: Field) -> (Field, Field) {}
+```
+
+Decomposes a single field into two fields, low and high. The low field contains the lower 16 bytes of the input field and the high field contains the upper 16 bytes of the input field. Both field results are range checked to 128 bits.
+
+
+## assert_gt
+
+```rust
+fn assert_gt(a: Field, b: Field) {}
+```
+
+Asserts that a > b. This will generate less constraints than using `assert(gt(a, b))`.
+
+## assert_lt
+
+```rust
+fn assert_lt(a: Field, b: Field) {}
+```
+
+Asserts that a < b. This will generate less constraints than using `assert(lt(a, b))`.
+
+## gt
+
+```rust
+fn gt(a: Field, b: Field) -> bool  {}
+```
+
+Returns true if a > b.
+
+## lt
+
+```rust
+fn lt(a: Field, b: Field) -> bool  {}
+```
+
+Returns true if a < b.
\ No newline at end of file
diff --git a/docs/versioned_docs/version-v0.36.0/noir/standard_library/containers/boundedvec.md b/docs/versioned_docs/version-v0.36.0/noir/standard_library/containers/boundedvec.md
new file mode 100644
index 00000000000..509b214bf3a
--- /dev/null
+++ b/docs/versioned_docs/version-v0.36.0/noir/standard_library/containers/boundedvec.md
@@ -0,0 +1,419 @@
+---
+title: Bounded Vectors
+keywords: [noir, vector, bounded vector, slice]
+sidebar_position: 1
+---
+
+A `BoundedVec<T, MaxLen>` is a growable storage similar to a `Vec<T>` except that it
+is bounded with a maximum possible length. Unlike `Vec`, `BoundedVec` is not implemented
+via slices and thus is not subject to the same restrictions slices are (notably, nested
+slices - and thus nested vectors as well - are disallowed).
+
+Since a BoundedVec is backed by a normal array under the hood, growing the BoundedVec by
+pushing an additional element is also more efficient - the length only needs to be increased
+by one.
+
+For these reasons `BoundedVec<T, N>` should generally be preferred over `Vec<T>` when there
+is a reasonable maximum bound that can be placed on the vector.
+
+Example:
+
+```rust
+let mut vector: BoundedVec<Field, 10> = BoundedVec::new();
+for i in 0..5 {
+    vector.push(i);
+}
+assert(vector.len() == 5);
+assert(vector.max_len() == 10);
+```
+
+## Methods
+
+### new
+
+```rust
+pub fn new() -> Self
+```
+
+Creates a new, empty vector of length zero.
+
+Since this container is backed by an array internally, it still needs an initial value
+to give each element. To resolve this, each element is zeroed internally. This value
+is guaranteed to be inaccessible unless `get_unchecked` is used.
+
+Example:
+
+```rust
+let empty_vector: BoundedVec<Field, 10> = BoundedVec::new();
+assert(empty_vector.len() == 0);
+```
+
+Note that whenever calling `new` the maximum length of the vector should always be specified
+via a type signature:
+
+```rust title="new_example" showLineNumbers 
+fn good() -> BoundedVec<Field, 10> {
+    // Ok! MaxLen is specified with a type annotation
+    let v1: BoundedVec<Field, 3> = BoundedVec::new();
+    let v2 = BoundedVec::new();
+
+    // Ok! MaxLen is known from the type of `good`'s return value
+    v2
+}
+
+fn bad() {
+    // Error: Type annotation needed
+    // The compiler can't infer `MaxLen` from this code.
+    let mut v3 = BoundedVec::new();
+    v3.push(5);
+}
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/test_programs/noir_test_success/bounded_vec/src/main.nr#L11-L27" target="_blank" rel="noopener noreferrer">Source code: test_programs/noir_test_success/bounded_vec/src/main.nr#L11-L27</a></sub></sup>
+
+
+This defaulting of `MaxLen` (and numeric generics in general) to zero may change in future noir versions
+but for now make sure to use type annotations when using bounded vectors. Otherwise, you will receive a constraint failure at runtime when the vec is pushed to.
+
+### get
+
+```rust
+pub fn get(self, index: u64) -> T {
+```
+
+Retrieves an element from the vector at the given index, starting from zero.
+
+If the given index is equal to or greater than the length of the vector, this
+will issue a constraint failure.
+
+Example:
+
+```rust
+fn foo<N>(v: BoundedVec<u32, N>) {
+    let first = v.get(0);
+    let last = v.get(v.len() - 1);
+    assert(first != last);
+}
+```
+
+### get_unchecked
+
+```rust
+pub fn get_unchecked(self, index: u64) -> T {
+```
+
+Retrieves an element from the vector at the given index, starting from zero, without
+performing a bounds check.
+
+Since this function does not perform a bounds check on length before accessing the element,
+it is unsafe! Use at your own risk!
+
+Example:
+
+```rust title="get_unchecked_example" showLineNumbers 
+fn sum_of_first_three<let N: u32>(v: BoundedVec<u32, N>) -> u32 {
+    // Always ensure the length is larger than the largest
+    // index passed to get_unchecked
+    assert(v.len() > 2);
+    let first = v.get_unchecked(0);
+    let second = v.get_unchecked(1);
+    let third = v.get_unchecked(2);
+    first + second + third
+}
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/test_programs/noir_test_success/bounded_vec/src/main.nr#L54-L64" target="_blank" rel="noopener noreferrer">Source code: test_programs/noir_test_success/bounded_vec/src/main.nr#L54-L64</a></sub></sup>
+
+
+### set
+
+```rust
+pub fn set(&mut self: Self, index: u64, value: T) {
+```
+
+Writes an element to the vector at the given index, starting from zero.
+
+If the given index is equal to or greater than the length of the vector, this will issue a constraint failure.
+
+Example:
+
+```rust
+fn foo<N>(v: BoundedVec<u32, N>) {
+    let first = v.get(0);
+    assert(first != 42);
+    v.set(0, 42);
+    let new_first = v.get(0);
+    assert(new_first == 42);
+}
+```
+
+### set_unchecked
+
+```rust
+pub fn set_unchecked(&mut self: Self, index: u64, value: T) -> T {
+```
+
+Writes an element to the vector at the given index, starting from zero, without performing a bounds check.
+
+Since this function does not perform a bounds check on length before accessing the element, it is unsafe! Use at your own risk!
+
+Example:
+
+```rust title="set_unchecked_example" showLineNumbers 
+fn set_unchecked_example() {
+    let mut vec: BoundedVec<u32, 5> = BoundedVec::new();
+    vec.extend_from_array([1, 2]);
+
+    // Here we're safely writing within the valid range of `vec`
+    // `vec` now has the value [42, 2]
+    vec.set_unchecked(0, 42);
+
+    // We can then safely read this value back out of `vec`.
+    // Notice that we use the checked version of `get` which would prevent reading unsafe values.
+    assert_eq(vec.get(0), 42);
+
+    // We've now written past the end of `vec`.
+    // As this index is still within the maximum potential length of `v`,
+    // it won't cause a constraint failure.
+    vec.set_unchecked(2, 42);
+    println(vec);
+
+    // This will write past the end of the maximum potential length of `vec`,
+    // it will then trigger a constraint failure.
+    vec.set_unchecked(5, 42);
+    println(vec);
+}
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/test_programs/noir_test_success/bounded_vec/src/main.nr#L67-L91" target="_blank" rel="noopener noreferrer">Source code: test_programs/noir_test_success/bounded_vec/src/main.nr#L67-L91</a></sub></sup>
+
+
+
+### push
+
+```rust
+pub fn push(&mut self, elem: T) {
+```
+
+Pushes an element to the end of the vector. This increases the length
+of the vector by one.
+
+Panics if the new length of the vector will be greater than the max length.
+
+Example:
+
+```rust title="bounded-vec-push-example" showLineNumbers 
+let mut v: BoundedVec<Field, 2> = BoundedVec::new();
+
+    v.push(1);
+    v.push(2);
+
+    // Panics with failed assertion "push out of bounds"
+    v.push(3);
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/test_programs/noir_test_success/bounded_vec/src/main.nr#L95-L103" target="_blank" rel="noopener noreferrer">Source code: test_programs/noir_test_success/bounded_vec/src/main.nr#L95-L103</a></sub></sup>
+
+
+### pop
+
+```rust
+pub fn pop(&mut self) -> T
+```
+
+Pops the element at the end of the vector. This will decrease the length
+of the vector by one.
+
+Panics if the vector is empty.
+
+Example:
+
+```rust title="bounded-vec-pop-example" showLineNumbers 
+let mut v: BoundedVec<Field, 2> = BoundedVec::new();
+    v.push(1);
+    v.push(2);
+
+    let two = v.pop();
+    let one = v.pop();
+
+    assert(two == 2);
+    assert(one == 1);
+    // error: cannot pop from an empty vector
+    // let _ = v.pop();
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/test_programs/noir_test_success/bounded_vec/src/main.nr#L108-L120" target="_blank" rel="noopener noreferrer">Source code: test_programs/noir_test_success/bounded_vec/src/main.nr#L108-L120</a></sub></sup>
+
+
+### len
+
+```rust
+pub fn len(self) -> u64 {
+```
+
+Returns the current length of this vector
+
+Example:
+
+```rust title="bounded-vec-len-example" showLineNumbers 
+let mut v: BoundedVec<Field, 4> = BoundedVec::new();
+    assert(v.len() == 0);
+
+    v.push(100);
+    assert(v.len() == 1);
+
+    v.push(200);
+    v.push(300);
+    v.push(400);
+    assert(v.len() == 4);
+
+    let _ = v.pop();
+    let _ = v.pop();
+    assert(v.len() == 2);
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/test_programs/noir_test_success/bounded_vec/src/main.nr#L125-L140" target="_blank" rel="noopener noreferrer">Source code: test_programs/noir_test_success/bounded_vec/src/main.nr#L125-L140</a></sub></sup>
+
+
+### max_len
+
+```rust
+pub fn max_len(_self: BoundedVec<T, MaxLen>) -> u64 {
+```
+
+Returns the maximum length of this vector. This is always
+equal to the `MaxLen` parameter this vector was initialized with.
+
+Example:
+
+```rust title="bounded-vec-max-len-example" showLineNumbers 
+let mut v: BoundedVec<Field, 5> = BoundedVec::new();
+
+    assert(v.max_len() == 5);
+    v.push(10);
+    assert(v.max_len() == 5);
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/test_programs/noir_test_success/bounded_vec/src/main.nr#L145-L151" target="_blank" rel="noopener noreferrer">Source code: test_programs/noir_test_success/bounded_vec/src/main.nr#L145-L151</a></sub></sup>
+
+
+### storage
+
+```rust
+pub fn storage(self) -> [T; MaxLen] {
+```
+
+Returns the internal array within this vector.
+Since arrays in Noir are immutable, mutating the returned storage array will not mutate
+the storage held internally by this vector.
+
+Note that uninitialized elements may be zeroed out!
+
+Example:
+
+```rust title="bounded-vec-storage-example" showLineNumbers 
+let mut v: BoundedVec<Field, 5> = BoundedVec::new();
+
+    assert(v.storage() == [0, 0, 0, 0, 0]);
+
+    v.push(57);
+    assert(v.storage() == [57, 0, 0, 0, 0]);
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/test_programs/noir_test_success/bounded_vec/src/main.nr#L156-L163" target="_blank" rel="noopener noreferrer">Source code: test_programs/noir_test_success/bounded_vec/src/main.nr#L156-L163</a></sub></sup>
+
+
+### extend_from_array
+
+```rust
+pub fn extend_from_array<Len>(&mut self, array: [T; Len])
+```
+
+Pushes each element from the given array to this vector.
+
+Panics if pushing each element would cause the length of this vector
+to exceed the maximum length.
+
+Example:
+
+```rust title="bounded-vec-extend-from-array-example" showLineNumbers 
+let mut vec: BoundedVec<Field, 3> = BoundedVec::new();
+    vec.extend_from_array([2, 4]);
+
+    assert(vec.len == 2);
+    assert(vec.get(0) == 2);
+    assert(vec.get(1) == 4);
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/test_programs/noir_test_success/bounded_vec/src/main.nr#L168-L175" target="_blank" rel="noopener noreferrer">Source code: test_programs/noir_test_success/bounded_vec/src/main.nr#L168-L175</a></sub></sup>
+
+
+### extend_from_bounded_vec
+
+```rust
+pub fn extend_from_bounded_vec<Len>(&mut self, vec: BoundedVec<T, Len>)
+```
+
+Pushes each element from the other vector to this vector. The length of
+the other vector is left unchanged.
+
+Panics if pushing each element would cause the length of this vector
+to exceed the maximum length.
+
+Example:
+
+```rust title="bounded-vec-extend-from-bounded-vec-example" showLineNumbers 
+let mut v1: BoundedVec<Field, 5> = BoundedVec::new();
+    let mut v2: BoundedVec<Field, 7> = BoundedVec::new();
+
+    v2.extend_from_array([1, 2, 3]);
+    v1.extend_from_bounded_vec(v2);
+
+    assert(v1.storage() == [1, 2, 3, 0, 0]);
+    assert(v2.storage() == [1, 2, 3, 0, 0, 0, 0]);
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/test_programs/noir_test_success/bounded_vec/src/main.nr#L180-L189" target="_blank" rel="noopener noreferrer">Source code: test_programs/noir_test_success/bounded_vec/src/main.nr#L180-L189</a></sub></sup>
+
+
+### from_array
+
+```rust
+pub fn from_array<Len>(array: [T; Len]) -> Self
+```
+
+Creates a new vector, populating it with values derived from an array input. 
+The maximum length of the vector is determined based on the type signature.
+
+Example:
+```rust
+let bounded_vec: BoundedVec<Field, 10> = BoundedVec::from_array([1, 2, 3])
+```
+
+### map
+
+```rust
+pub fn map<U, Env>(self, f: fn[Env](T) -> U) -> BoundedVec<U, MaxLen>
+```
+
+Creates a new vector of equal size by calling a closure on each element in this vector.  
+
+Example:
+
+```rust title="bounded-vec-map-example" showLineNumbers 
+let vec: BoundedVec<u32, 4> = BoundedVec::from_array([1, 2, 3, 4]);
+            let result = vec.map(|value| value * 2);
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/collections/bounded_vec.nr#L495-L498" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/collections/bounded_vec.nr#L495-L498</a></sub></sup>
+
+
+### any
+
+```rust
+pub fn any<Env>(self, predicate: fn[Env](T) -> bool) -> bool
+```
+
+Returns true if the given predicate returns true for any element
+in this vector.
+
+Example:
+
+```rust title="bounded-vec-any-example" showLineNumbers 
+let mut v: BoundedVec<u32, 3> = BoundedVec::new();
+    v.extend_from_array([2, 4, 6]);
+
+    let all_even = !v.any(|elem: u32| elem % 2 != 0);
+    assert(all_even);
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/test_programs/noir_test_success/bounded_vec/src/main.nr#L256-L262" target="_blank" rel="noopener noreferrer">Source code: test_programs/noir_test_success/bounded_vec/src/main.nr#L256-L262</a></sub></sup>
+
diff --git a/docs/versioned_docs/version-v0.36.0/noir/standard_library/containers/hashmap.md b/docs/versioned_docs/version-v0.36.0/noir/standard_library/containers/hashmap.md
new file mode 100644
index 00000000000..395cc312705
--- /dev/null
+++ b/docs/versioned_docs/version-v0.36.0/noir/standard_library/containers/hashmap.md
@@ -0,0 +1,587 @@
+---
+title: HashMap
+keywords: [noir, map, hash, hashmap]
+sidebar_position: 1
+---
+
+`HashMap<Key, Value, MaxLen, Hasher>` is used to efficiently store and look up key-value pairs.
+
+`HashMap` is a bounded type which can store anywhere from zero to `MaxLen` total elements.
+Note that due to hash collisions, the actual maximum number of elements stored by any particular
+hashmap is likely lower than `MaxLen`. This is true even with cryptographic hash functions since
+every hash value will be performed modulo `MaxLen`.
+
+Example:
+
+```rust
+// Create a mapping from Fields to u32s with a maximum length of 12
+// using a poseidon2 hasher
+use std::hash::poseidon2::Poseidon2Hasher;
+let mut map: HashMap<Field, u32, 12, BuildHasherDefault<Poseidon2Hasher>> = HashMap::default();
+
+map.insert(1, 2);
+map.insert(3, 4);
+
+let two = map.get(1).unwrap();
+```
+
+## Methods
+
+### default
+
+```rust title="default" showLineNumbers 
+impl<K, V, let N: u32, B, H> Default for HashMap<K, V, N, B>
+where
+    B: BuildHasher<H> + Default,
+    H: Hasher + Default,
+{
+    /// Constructs an empty HashMap.
+    ///
+    /// Example:
+    ///
+    /// ```noir
+    /// let hashmap: HashMap<u8, u32, 10, BuildHasherDefault<Poseidon2Hasher>> = HashMap::default();
+    /// assert(hashmap.is_empty());
+    /// ```
+    fn default() -> Self {
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/collections/map.nr#L681-L696" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/collections/map.nr#L681-L696</a></sub></sup>
+
+
+Creates a fresh, empty HashMap.
+
+When using this function, always make sure to specify the maximum size of the hash map.
+
+This is the same `default` from the `Default` implementation given further below. It is
+repeated here for convenience since it is the recommended way to create a hashmap.
+
+Example:
+
+```rust title="default_example" showLineNumbers 
+let hashmap: HashMap<u8, u32, 10, BuildHasherDefault<Poseidon2Hasher>> = HashMap::default();
+    assert(hashmap.is_empty());
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/test_programs/execution_success/hashmap/src/main.nr#L207-L210" target="_blank" rel="noopener noreferrer">Source code: test_programs/execution_success/hashmap/src/main.nr#L207-L210</a></sub></sup>
+
+
+Because `HashMap` has so many generic arguments that are likely to be the same throughout
+your program, it may be helpful to create a type alias:
+
+```rust title="type_alias" showLineNumbers 
+type MyMap = HashMap<u8, u32, 10, BuildHasherDefault<Poseidon2Hasher>>;
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/test_programs/execution_success/hashmap/src/main.nr#L201-L203" target="_blank" rel="noopener noreferrer">Source code: test_programs/execution_success/hashmap/src/main.nr#L201-L203</a></sub></sup>
+
+
+### with_hasher
+
+```rust title="with_hasher" showLineNumbers 
+pub fn with_hasher<H>(_build_hasher: B) -> Self
+    where
+        B: BuildHasher<H>,
+    {
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/collections/map.nr#L103-L108" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/collections/map.nr#L103-L108</a></sub></sup>
+
+
+Creates a hashmap with an existing `BuildHasher`. This can be used to ensure multiple
+hashmaps are created with the same hasher instance.
+
+Example:
+
+```rust title="with_hasher_example" showLineNumbers 
+let my_hasher: BuildHasherDefault<Poseidon2Hasher> = Default::default();
+    let hashmap: HashMap<u8, u32, 10, BuildHasherDefault<Poseidon2Hasher>> =
+        HashMap::with_hasher(my_hasher);
+    assert(hashmap.is_empty());
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/test_programs/execution_success/hashmap/src/main.nr#L211-L216" target="_blank" rel="noopener noreferrer">Source code: test_programs/execution_success/hashmap/src/main.nr#L211-L216</a></sub></sup>
+
+
+### get
+
+```rust title="get" showLineNumbers 
+pub fn get<H>(self, key: K) -> Option<V>
+    where
+        K: Eq + Hash,
+        B: BuildHasher<H>,
+        H: Hasher,
+    {
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/collections/map.nr#L465-L472" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/collections/map.nr#L465-L472</a></sub></sup>
+
+
+Retrieves a value from the hashmap, returning `Option::none()` if it was not found.
+
+Example:
+
+```rust title="get_example" showLineNumbers 
+fn get_example(map: HashMap<Field, Field, 5, BuildHasherDefault<Poseidon2Hasher>>) {
+    let x = map.get(12);
+
+    if x.is_some() {
+        assert(x.unwrap() == 42);
+    }
+}
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/test_programs/execution_success/hashmap/src/main.nr#L296-L304" target="_blank" rel="noopener noreferrer">Source code: test_programs/execution_success/hashmap/src/main.nr#L296-L304</a></sub></sup>
+
+
+### insert
+
+```rust title="insert" showLineNumbers 
+pub fn insert<H>(&mut self, key: K, value: V)
+    where
+        K: Eq + Hash,
+        B: BuildHasher<H>,
+        H: Hasher,
+    {
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/collections/map.nr#L507-L514" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/collections/map.nr#L507-L514</a></sub></sup>
+
+
+Inserts a new key-value pair into the map. If the key was already in the map, its
+previous value will be overridden with the newly provided one.
+
+Example:
+
+```rust title="insert_example" showLineNumbers 
+let mut map: HashMap<Field, Field, 5, BuildHasherDefault<Poseidon2Hasher>> = HashMap::default();
+    map.insert(12, 42);
+    assert(map.len() == 1);
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/test_programs/execution_success/hashmap/src/main.nr#L217-L221" target="_blank" rel="noopener noreferrer">Source code: test_programs/execution_success/hashmap/src/main.nr#L217-L221</a></sub></sup>
+
+
+### remove
+
+```rust title="remove" showLineNumbers 
+pub fn remove<H>(&mut self, key: K)
+    where
+        K: Eq + Hash,
+        B: BuildHasher<H>,
+        H: Hasher,
+    {
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/collections/map.nr#L563-L570" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/collections/map.nr#L563-L570</a></sub></sup>
+
+
+Removes the given key-value pair from the map. If the key was not already present
+in the map, this does nothing.
+
+Example:
+
+```rust title="remove_example" showLineNumbers 
+map.remove(12);
+    assert(map.is_empty());
+
+    // If a key was not present in the map, remove does nothing
+    map.remove(12);
+    assert(map.is_empty());
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/test_programs/execution_success/hashmap/src/main.nr#L224-L231" target="_blank" rel="noopener noreferrer">Source code: test_programs/execution_success/hashmap/src/main.nr#L224-L231</a></sub></sup>
+
+
+### is_empty
+
+```rust title="is_empty" showLineNumbers 
+pub fn is_empty(self) -> bool {
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/collections/map.nr#L167-L169" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/collections/map.nr#L167-L169</a></sub></sup>
+
+
+True if the length of the hash map is empty.
+
+Example:
+
+```rust title="is_empty_example" showLineNumbers 
+assert(map.is_empty());
+
+    map.insert(1, 2);
+    assert(!map.is_empty());
+
+    map.remove(1);
+    assert(map.is_empty());
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/test_programs/execution_success/hashmap/src/main.nr#L232-L240" target="_blank" rel="noopener noreferrer">Source code: test_programs/execution_success/hashmap/src/main.nr#L232-L240</a></sub></sup>
+
+
+### len
+
+```rust title="len" showLineNumbers 
+pub fn len(self) -> u32 {
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/collections/map.nr#L424-L426" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/collections/map.nr#L424-L426</a></sub></sup>
+
+
+Returns the current length of this hash map.
+
+Example:
+
+```rust title="len_example" showLineNumbers 
+// This is equivalent to checking map.is_empty()
+    assert(map.len() == 0);
+
+    map.insert(1, 2);
+    map.insert(3, 4);
+    map.insert(5, 6);
+    assert(map.len() == 3);
+
+    // 3 was already present as a key in the hash map, so the length is unchanged
+    map.insert(3, 7);
+    assert(map.len() == 3);
+
+    map.remove(1);
+    assert(map.len() == 2);
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/test_programs/execution_success/hashmap/src/main.nr#L241-L256" target="_blank" rel="noopener noreferrer">Source code: test_programs/execution_success/hashmap/src/main.nr#L241-L256</a></sub></sup>
+
+
+### capacity
+
+```rust title="capacity" showLineNumbers 
+pub fn capacity(_self: Self) -> u32 {
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/collections/map.nr#L446-L448" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/collections/map.nr#L446-L448</a></sub></sup>
+
+
+Returns the maximum capacity of this hashmap. This is always equal to the capacity
+specified in the hashmap's type.
+
+Unlike hashmaps in general purpose programming languages, hashmaps in Noir have a
+static capacity that does not increase as the map grows larger. Thus, this capacity
+is also the maximum possible element count that can be inserted into the hashmap.
+Due to hash collisions (modulo the hashmap length), it is likely the actual maximum
+element count will be lower than the full capacity.
+
+Example:
+
+```rust title="capacity_example" showLineNumbers 
+let empty_map: HashMap<Field, Field, 42, BuildHasherDefault<Poseidon2Hasher>> =
+        HashMap::default();
+    assert(empty_map.len() == 0);
+    assert(empty_map.capacity() == 42);
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/test_programs/execution_success/hashmap/src/main.nr#L257-L262" target="_blank" rel="noopener noreferrer">Source code: test_programs/execution_success/hashmap/src/main.nr#L257-L262</a></sub></sup>
+
+
+### clear
+
+```rust title="clear" showLineNumbers 
+pub fn clear(&mut self) {
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/collections/map.nr#L123-L125" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/collections/map.nr#L123-L125</a></sub></sup>
+
+
+Clears the hashmap, removing all key-value pairs from it.
+
+Example:
+
+```rust title="clear_example" showLineNumbers 
+assert(!map.is_empty());
+    map.clear();
+    assert(map.is_empty());
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/test_programs/execution_success/hashmap/src/main.nr#L263-L267" target="_blank" rel="noopener noreferrer">Source code: test_programs/execution_success/hashmap/src/main.nr#L263-L267</a></sub></sup>
+
+
+### contains_key
+
+```rust title="contains_key" showLineNumbers 
+pub fn contains_key<H>(self, key: K) -> bool
+    where
+        K: Hash + Eq,
+        B: BuildHasher<H>,
+        H: Hasher,
+    {
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/collections/map.nr#L143-L150" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/collections/map.nr#L143-L150</a></sub></sup>
+
+
+True if the hashmap contains the given key. Unlike `get`, this will not also return
+the value associated with the key.
+
+Example:
+
+```rust title="contains_key_example" showLineNumbers 
+if map.contains_key(7) {
+        let value = map.get(7);
+        assert(value.is_some());
+    } else {
+        println("No value for key 7!");
+    }
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/test_programs/execution_success/hashmap/src/main.nr#L268-L275" target="_blank" rel="noopener noreferrer">Source code: test_programs/execution_success/hashmap/src/main.nr#L268-L275</a></sub></sup>
+
+
+### entries
+
+```rust title="entries" showLineNumbers 
+pub fn entries(self) -> BoundedVec<(K, V), N> {
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/collections/map.nr#L191-L193" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/collections/map.nr#L191-L193</a></sub></sup>
+
+
+Returns a vector of each key-value pair present in the hashmap.
+
+The length of the returned vector is always equal to the length of the hashmap.
+
+Example:
+
+```rust title="entries_example" showLineNumbers 
+let entries = map.entries();
+
+    // The length of a hashmap may not be compile-time known, so we
+    // need to loop over its capacity instead
+    for i in 0..map.capacity() {
+        if i < entries.len() {
+            let (key, value) = entries.get(i);
+            println(f"{key} -> {value}");
+        }
+    }
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/test_programs/execution_success/hashmap/src/main.nr#L307-L318" target="_blank" rel="noopener noreferrer">Source code: test_programs/execution_success/hashmap/src/main.nr#L307-L318</a></sub></sup>
+
+
+### keys
+
+```rust title="keys" showLineNumbers 
+pub fn keys(self) -> BoundedVec<K, N> {
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/collections/map.nr#L227-L229" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/collections/map.nr#L227-L229</a></sub></sup>
+
+
+Returns a vector of each key present in the hashmap.
+
+The length of the returned vector is always equal to the length of the hashmap.
+
+Example:
+
+```rust title="keys_example" showLineNumbers 
+let keys = map.keys();
+
+    for i in 0..keys.max_len() {
+        if i < keys.len() {
+            let key = keys.get_unchecked(i);
+            let value = map.get(key).unwrap_unchecked();
+            println(f"{key} -> {value}");
+        }
+    }
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/test_programs/execution_success/hashmap/src/main.nr#L319-L329" target="_blank" rel="noopener noreferrer">Source code: test_programs/execution_success/hashmap/src/main.nr#L319-L329</a></sub></sup>
+
+
+### values
+
+```rust title="values" showLineNumbers 
+pub fn values(self) -> BoundedVec<V, N> {
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/collections/map.nr#L262-L264" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/collections/map.nr#L262-L264</a></sub></sup>
+
+
+Returns a vector of each value present in the hashmap.
+
+The length of the returned vector is always equal to the length of the hashmap.
+
+Example:
+
+```rust title="values_example" showLineNumbers 
+let values = map.values();
+
+    for i in 0..values.max_len() {
+        if i < values.len() {
+            let value = values.get_unchecked(i);
+            println(f"Found value {value}");
+        }
+    }
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/test_programs/execution_success/hashmap/src/main.nr#L330-L339" target="_blank" rel="noopener noreferrer">Source code: test_programs/execution_success/hashmap/src/main.nr#L330-L339</a></sub></sup>
+
+
+### iter_mut
+
+```rust title="iter_mut" showLineNumbers 
+pub fn iter_mut<H>(&mut self, f: fn(K, V) -> (K, V))
+    where
+        K: Eq + Hash,
+        B: BuildHasher<H>,
+        H: Hasher,
+    {
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/collections/map.nr#L297-L304" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/collections/map.nr#L297-L304</a></sub></sup>
+
+
+Iterates through each key-value pair of the HashMap, setting each key-value pair to the
+result returned from the given function.
+
+Note that since keys can be mutated, the HashMap needs to be rebuilt as it is iterated
+through. If this is not desired, use `iter_values_mut` if only values need to be mutated,
+or `entries` if neither keys nor values need to be mutated.
+
+The iteration order is left unspecified. As a result, if two keys are mutated to become
+equal, which of the two values that will be present for the key in the resulting map is also unspecified.
+
+Example:
+
+```rust title="iter_mut_example" showLineNumbers 
+// Add 1 to each key in the map, and double the value associated with that key.
+    map.iter_mut(|k, v| (k + 1, v * 2));
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/test_programs/execution_success/hashmap/src/main.nr#L343-L346" target="_blank" rel="noopener noreferrer">Source code: test_programs/execution_success/hashmap/src/main.nr#L343-L346</a></sub></sup>
+
+
+### iter_keys_mut
+
+```rust title="iter_keys_mut" showLineNumbers 
+pub fn iter_keys_mut<H>(&mut self, f: fn(K) -> K)
+    where
+        K: Eq + Hash,
+        B: BuildHasher<H>,
+        H: Hasher,
+    {
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/collections/map.nr#L335-L342" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/collections/map.nr#L335-L342</a></sub></sup>
+
+
+Iterates through the HashMap, mutating each key to the result returned from
+the given function.
+
+Note that since keys can be mutated, the HashMap needs to be rebuilt as it is iterated
+through. If only iteration is desired and the keys are not intended to be mutated,
+prefer using `entries` instead.
+
+The iteration order is left unspecified. As a result, if two keys are mutated to become
+equal, which of the two values that will be present for the key in the resulting map is also unspecified.
+
+Example:
+
+```rust title="iter_keys_mut_example" showLineNumbers 
+// Double each key, leaving the value associated with that key untouched
+    map.iter_keys_mut(|k| k * 2);
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/test_programs/execution_success/hashmap/src/main.nr#L347-L350" target="_blank" rel="noopener noreferrer">Source code: test_programs/execution_success/hashmap/src/main.nr#L347-L350</a></sub></sup>
+
+
+### iter_values_mut
+
+```rust title="iter_values_mut" showLineNumbers 
+pub fn iter_values_mut(&mut self, f: fn(V) -> V) {
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/collections/map.nr#L367-L369" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/collections/map.nr#L367-L369</a></sub></sup>
+
+
+Iterates through the HashMap, applying the given function to each value and mutating the
+value to equal the result. This function is more efficient than `iter_mut` and `iter_keys_mut`
+because the keys are untouched and the underlying hashmap thus does not need to be reordered.
+
+Example:
+
+```rust title="iter_values_mut_example" showLineNumbers 
+// Halve each value
+    map.iter_values_mut(|v| v / 2);
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/test_programs/execution_success/hashmap/src/main.nr#L351-L354" target="_blank" rel="noopener noreferrer">Source code: test_programs/execution_success/hashmap/src/main.nr#L351-L354</a></sub></sup>
+
+
+### retain
+
+```rust title="retain" showLineNumbers 
+pub fn retain(&mut self, f: fn(K, V) -> bool) {
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/collections/map.nr#L388-L390" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/collections/map.nr#L388-L390</a></sub></sup>
+
+
+Retains only the key-value pairs for which the given function returns true.
+Any key-value pairs for which the function returns false will be removed from the map.
+
+Example:
+
+```rust title="retain_example" showLineNumbers 
+map.retain(|k, v| (k != 0) & (v != 0));
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/test_programs/execution_success/hashmap/src/main.nr#L279-L281" target="_blank" rel="noopener noreferrer">Source code: test_programs/execution_success/hashmap/src/main.nr#L279-L281</a></sub></sup>
+
+
+## Trait Implementations
+
+### default
+
+```rust title="default" showLineNumbers 
+impl<K, V, let N: u32, B, H> Default for HashMap<K, V, N, B>
+where
+    B: BuildHasher<H> + Default,
+    H: Hasher + Default,
+{
+    /// Constructs an empty HashMap.
+    ///
+    /// Example:
+    ///
+    /// ```noir
+    /// let hashmap: HashMap<u8, u32, 10, BuildHasherDefault<Poseidon2Hasher>> = HashMap::default();
+    /// assert(hashmap.is_empty());
+    /// ```
+    fn default() -> Self {
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/collections/map.nr#L681-L696" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/collections/map.nr#L681-L696</a></sub></sup>
+
+
+Constructs an empty HashMap.
+
+Example:
+
+```rust title="default_example" showLineNumbers 
+let hashmap: HashMap<u8, u32, 10, BuildHasherDefault<Poseidon2Hasher>> = HashMap::default();
+    assert(hashmap.is_empty());
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/test_programs/execution_success/hashmap/src/main.nr#L207-L210" target="_blank" rel="noopener noreferrer">Source code: test_programs/execution_success/hashmap/src/main.nr#L207-L210</a></sub></sup>
+
+
+### eq
+
+```rust title="eq" showLineNumbers 
+impl<K, V, let N: u32, B, H> Eq for HashMap<K, V, N, B>
+where
+    K: Eq + Hash,
+    V: Eq,
+    B: BuildHasher<H>,
+    H: Hasher,
+{
+    /// Checks if two HashMaps are equal.
+    ///
+    /// Example:
+    ///
+    /// ```noir
+    /// let mut map1: HashMap<Field, u64, 4, BuildHasherDefault<Poseidon2Hasher>> = HashMap::default();
+    /// let mut map2: HashMap<Field, u64, 4, BuildHasherDefault<Poseidon2Hasher>> = HashMap::default();
+    ///
+    /// map1.insert(1, 2);
+    /// map1.insert(3, 4);
+    ///
+    /// map2.insert(3, 4);
+    /// map2.insert(1, 2);
+    ///
+    /// assert(map1 == map2);
+    /// ```
+    fn eq(self, other: HashMap<K, V, N, B>) -> bool {
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/collections/map.nr#L629-L654" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/collections/map.nr#L629-L654</a></sub></sup>
+
+
+Checks if two HashMaps are equal.
+
+Example:
+
+```rust title="eq_example" showLineNumbers 
+let mut map1: HashMap<Field, u64, 4, BuildHasherDefault<Poseidon2Hasher>> = HashMap::default();
+    let mut map2: HashMap<Field, u64, 4, BuildHasherDefault<Poseidon2Hasher>> = HashMap::default();
+
+    map1.insert(1, 2);
+    map1.insert(3, 4);
+
+    map2.insert(3, 4);
+    map2.insert(1, 2);
+
+    assert(map1 == map2);
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/test_programs/execution_success/hashmap/src/main.nr#L282-L293" target="_blank" rel="noopener noreferrer">Source code: test_programs/execution_success/hashmap/src/main.nr#L282-L293</a></sub></sup>
+
diff --git a/docs/versioned_docs/version-v0.36.0/noir/standard_library/containers/index.md b/docs/versioned_docs/version-v0.36.0/noir/standard_library/containers/index.md
new file mode 100644
index 00000000000..ea84c6d5c21
--- /dev/null
+++ b/docs/versioned_docs/version-v0.36.0/noir/standard_library/containers/index.md
@@ -0,0 +1,5 @@
+---
+title: Containers
+description: Container types provided by Noir's standard library for storing and retrieving data
+keywords: [containers, data types, vec, hashmap]
+---
diff --git a/docs/versioned_docs/version-v0.36.0/noir/standard_library/containers/vec.mdx b/docs/versioned_docs/version-v0.36.0/noir/standard_library/containers/vec.mdx
new file mode 100644
index 00000000000..475011922f8
--- /dev/null
+++ b/docs/versioned_docs/version-v0.36.0/noir/standard_library/containers/vec.mdx
@@ -0,0 +1,170 @@
+---
+title: Vectors
+description: Delve into the Vec data type in Noir. Learn about its methods, practical examples, and best practices for using Vectors in your Noir code.
+keywords: [noir, vector type, methods, examples, dynamic arrays]
+sidebar_position: 6
+---
+
+import Experimental from '@site/src/components/Notes/_experimental.mdx';
+
+<Experimental />
+
+A vector is a collection type similar to Rust's `Vec<T>` type. In Noir, it is a convenient way to use slices as mutable arrays.
+
+Example:
+
+```rust
+let mut vector: Vec<Field> = Vec::new();
+for i in 0..5 {
+    vector.push(i);
+}
+assert(vector.len() == 5);
+```
+
+## Methods
+
+### new
+
+Creates a new, empty vector.
+
+```rust
+pub fn new() -> Self
+```
+
+Example:
+
+```rust
+let empty_vector: Vec<Field> = Vec::new();
+assert(empty_vector.len() == 0);
+```
+
+### from_slice
+
+Creates a vector containing each element from a given slice. Mutations to the resulting vector will not affect the original slice.
+
+```rust
+pub fn from_slice(slice: [T]) -> Self
+```
+
+Example:
+
+```rust
+let slice: [Field] = &[1, 2, 3];
+let vector_from_slice = Vec::from_slice(slice);
+assert(vector_from_slice.len() == 3);
+```
+
+### len
+
+Returns the number of elements in the vector.
+
+```rust
+pub fn len(self) -> Field
+```
+
+Example:
+
+```rust
+let empty_vector: Vec<Field> = Vec::new();
+assert(empty_vector.len() == 0);
+```
+
+### get
+
+Retrieves an element from the vector at a given index. Panics if the index points beyond the vector's end.
+
+```rust
+pub fn get(self, index: Field) -> T
+```
+
+Example:
+
+```rust
+let vector: Vec<Field> = Vec::from_slice(&[10, 20, 30]);
+assert(vector.get(1) == 20);
+```
+
+### set
+
+```rust
+pub fn set(&mut self: Self, index: u64, value: T) {
+```
+
+Writes an element to the vector at the given index, starting from zero.
+
+Panics if the index points beyond the vector's end.
+
+Example:
+
+```rust
+let vector: Vec<Field> = Vec::from_slice(&[10, 20, 30]);
+assert(vector.get(1) == 20);
+vector.set(1, 42);
+assert(vector.get(1) == 42);
+```
+
+### push
+
+Adds a new element to the vector's end, returning a new vector with a length one greater than the original unmodified vector.
+
+```rust
+pub fn push(&mut self, elem: T)
+```
+
+Example:
+
+```rust
+let mut vector: Vec<Field> = Vec::new();
+vector.push(10);
+assert(vector.len() == 1);
+```
+
+### pop
+
+Removes an element from the vector's end, returning a new vector with a length one less than the original vector, along with the removed element. Panics if the vector's length is zero.
+
+```rust
+pub fn pop(&mut self) -> T
+```
+
+Example:
+
+```rust
+let mut vector = Vec::from_slice(&[10, 20]);
+let popped_elem = vector.pop();
+assert(popped_elem == 20);
+assert(vector.len() == 1);
+```
+
+### insert
+
+Inserts an element at a specified index, shifting subsequent elements to the right.
+
+```rust
+pub fn insert(&mut self, index: Field, elem: T)
+```
+
+Example:
+
+```rust
+let mut vector = Vec::from_slice(&[10, 30]);
+vector.insert(1, 20);
+assert(vector.get(1) == 20);
+```
+
+### remove
+
+Removes an element at a specified index, shifting subsequent elements to the left, and returns the removed element.
+
+```rust
+pub fn remove(&mut self, index: Field) -> T
+```
+
+Example:
+
+```rust
+let mut vector = Vec::from_slice(&[10, 20, 30]);
+let removed_elem = vector.remove(1);
+assert(removed_elem == 20);
+assert(vector.len() == 2);
+```
diff --git a/docs/versioned_docs/version-v0.36.0/noir/standard_library/cryptographic_primitives/_category_.json b/docs/versioned_docs/version-v0.36.0/noir/standard_library/cryptographic_primitives/_category_.json
new file mode 100644
index 00000000000..5d694210bbf
--- /dev/null
+++ b/docs/versioned_docs/version-v0.36.0/noir/standard_library/cryptographic_primitives/_category_.json
@@ -0,0 +1,5 @@
+{
+    "position": 0,
+    "collapsible": true,
+    "collapsed": true
+}
diff --git a/docs/versioned_docs/version-v0.36.0/noir/standard_library/cryptographic_primitives/ciphers.mdx b/docs/versioned_docs/version-v0.36.0/noir/standard_library/cryptographic_primitives/ciphers.mdx
new file mode 100644
index 00000000000..d6a5e1a79eb
--- /dev/null
+++ b/docs/versioned_docs/version-v0.36.0/noir/standard_library/cryptographic_primitives/ciphers.mdx
@@ -0,0 +1,32 @@
+---
+title: Ciphers
+description:
+  Learn about the implemented ciphers ready to use for any Noir project
+keywords:
+  [ciphers, Noir project, aes128, encrypt]
+sidebar_position: 0
+---
+
+import BlackBoxInfo from '@site/src/components/Notes/_blackbox';
+
+## aes128
+
+Given a plaintext as an array of bytes, returns the corresponding aes128 ciphertext (CBC mode). Input padding is automatically performed using PKCS#7, so that the output length is `input.len() + (16 - input.len() % 16)`.
+
+```rust title="aes128" showLineNumbers 
+pub fn aes128_encrypt<let N: u32>(input: [u8; N], iv: [u8; 16], key: [u8; 16]) -> [u8] {}
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/aes128.nr#L2-L4" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/aes128.nr#L2-L4</a></sub></sup>
+
+
+```rust
+fn main() {
+    let input: [u8; 4] = [0, 12, 3, 15] // Random bytes, will be padded to 16 bytes.
+    let iv: [u8; 16] = [0; 16]; // Initialisation vector
+    let key: [u8; 16] = [0; 16] // AES key
+    let ciphertext = std::aes128::aes128_encrypt(inputs.as_bytes(), iv.as_bytes(), key.as_bytes()); // In this case, the output length will be 16 bytes.
+}
+```
+
+
+<BlackBoxInfo to="../black_box_fns"/>
\ No newline at end of file
diff --git a/docs/versioned_docs/version-v0.36.0/noir/standard_library/cryptographic_primitives/ec_primitives.md b/docs/versioned_docs/version-v0.36.0/noir/standard_library/cryptographic_primitives/ec_primitives.md
new file mode 100644
index 00000000000..f262d8160d6
--- /dev/null
+++ b/docs/versioned_docs/version-v0.36.0/noir/standard_library/cryptographic_primitives/ec_primitives.md
@@ -0,0 +1,102 @@
+---
+title: Elliptic Curve Primitives
+keywords: [cryptographic primitives, Noir project]
+sidebar_position: 4
+---
+
+Data structures and methods on them that allow you to carry out computations involving elliptic
+curves over the (mathematical) field corresponding to `Field`. For the field currently at our
+disposal, applications would involve a curve embedded in BN254, e.g. the
+[Baby Jubjub curve](https://eips.ethereum.org/EIPS/eip-2494).
+
+## Data structures
+
+### Elliptic curve configurations
+
+(`std::ec::{tecurve,montcurve,swcurve}::{affine,curvegroup}::Curve`), i.e. the specific elliptic
+curve you want to use, which would be specified using any one of the methods
+`std::ec::{tecurve,montcurve,swcurve}::{affine,curvegroup}::new` which take the coefficients in the
+defining equation together with a generator point as parameters. You can find more detail in the
+comments in
+[`noir_stdlib/src/ec/mod.nr`](https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/ec/mod.nr), but
+the gist of it is that the elliptic curves of interest are usually expressed in one of the standard
+forms implemented here (Twisted Edwards, Montgomery and Short Weierstraß), and in addition to that,
+you could choose to use `affine` coordinates (Cartesian coordinates - the usual (x,y) - possibly
+together with a point at infinity) or `curvegroup` coordinates (some form of projective coordinates
+requiring more coordinates but allowing for more efficient implementations of elliptic curve
+operations). Conversions between all of these forms are provided, and under the hood these
+conversions are done whenever an operation is more efficient in a different representation (or a
+mixed coordinate representation is employed).
+
+### Points
+
+(`std::ec::{tecurve,montcurve,swcurve}::{affine,curvegroup}::Point`), i.e. points lying on the
+elliptic curve. For a curve configuration `c` and a point `p`, it may be checked that `p`
+does indeed lie on `c` by calling `c.contains(p1)`.
+
+## Methods
+
+(given a choice of curve representation, e.g. use `std::ec::tecurve::affine::Curve` and use
+`std::ec::tecurve::affine::Point`)
+
+- The **zero element** is given by `Point::zero()`, and we can verify whether a point `p: Point` is
+  zero by calling `p.is_zero()`.
+- **Equality**: Points `p1: Point` and `p2: Point` may be checked for equality by calling
+  `p1.eq(p2)`.
+- **Addition**: For `c: Curve` and points `p1: Point` and `p2: Point` on the curve, adding these two
+  points is accomplished by calling `c.add(p1,p2)`.
+- **Negation**: For a point `p: Point`, `p.negate()` is its negation.
+- **Subtraction**: For `c` and `p1`, `p2` as above, subtracting `p2` from `p1` is accomplished by
+  calling `c.subtract(p1,p2)`.
+- **Scalar multiplication**: For `c` as above, `p: Point` a point on the curve and `n: Field`,
+  scalar multiplication is given by `c.mul(n,p)`. If instead `n :: [u1; N]`, i.e. `n` is a bit
+  array, the `bit_mul` method may be used instead: `c.bit_mul(n,p)`
+- **Multi-scalar multiplication**: For `c` as above and arrays `n: [Field; N]` and `p: [Point; N]`,
+  multi-scalar multiplication is given by `c.msm(n,p)`.
+- **Coordinate representation conversions**: The `into_group` method converts a point or curve
+  configuration in the affine representation to one in the CurveGroup representation, and
+  `into_affine` goes in the other direction.
+- **Curve representation conversions**: `tecurve` and `montcurve` curves and points are equivalent
+  and may be converted between one another by calling `into_montcurve` or `into_tecurve` on their
+  configurations or points. `swcurve` is more general and a curve c of one of the other two types
+  may be converted to this representation by calling `c.into_swcurve()`, whereas a point `p` lying
+  on the curve given by `c` may be mapped to its corresponding `swcurve` point by calling
+  `c.map_into_swcurve(p)`.
+- **Map-to-curve methods**: The Elligator 2 method of mapping a field element `n: Field` into a
+  `tecurve` or `montcurve` with configuration `c` may be called as `c.elligator2_map(n)`. For all of
+  the curve configurations, the SWU map-to-curve method may be called as `c.swu_map(z,n)`, where
+  `z: Field` depends on `Field` and `c` and must be chosen by the user (the conditions it needs to
+  satisfy are specified in the comments
+  [here](https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/ec/mod.nr)).
+
+## Examples
+
+The
+[ec_baby_jubjub test](https://github.com/noir-lang/noir/blob/master/test_programs/compile_success_empty/ec_baby_jubjub/src/main.nr)
+illustrates all of the above primitives on various forms of the Baby Jubjub curve. A couple of more
+interesting examples in Noir would be:
+
+Public-key cryptography: Given an elliptic curve and a 'base point' on it, determine the public key
+from the private key. This is a matter of using scalar multiplication. In the case of Baby Jubjub,
+for example, this code would do:
+
+```rust
+use std::ec::tecurve::affine::{Curve, Point};
+
+fn bjj_pub_key(priv_key: Field) -> Point
+{
+
+ let bjj = Curve::new(168700, 168696, G::new(995203441582195749578291179787384436505546430278305826713579947235728471134,5472060717959818805561601436314318772137091100104008585924551046643952123905));
+
+ let base_pt = Point::new(5299619240641551281634865583518297030282874472190772894086521144482721001553, 16950150798460657717958625567821834550301663161624707787222815936182638968203);
+
+ bjj.mul(priv_key,base_pt)
+}
+```
+
+This would come in handy in a Merkle proof.
+
+- EdDSA signature verification: This is a matter of combining these primitives with a suitable hash
+  function. See
+  [feat(stdlib): EdDSA sig verification noir#1136](https://github.com/noir-lang/noir/pull/1136) for
+  the case of Baby Jubjub and the Poseidon hash function.
diff --git a/docs/versioned_docs/version-v0.36.0/noir/standard_library/cryptographic_primitives/ecdsa_sig_verification.mdx b/docs/versioned_docs/version-v0.36.0/noir/standard_library/cryptographic_primitives/ecdsa_sig_verification.mdx
new file mode 100644
index 00000000000..8d96027b42c
--- /dev/null
+++ b/docs/versioned_docs/version-v0.36.0/noir/standard_library/cryptographic_primitives/ecdsa_sig_verification.mdx
@@ -0,0 +1,98 @@
+---
+title: ECDSA Signature Verification
+description: Learn about the cryptographic primitives regarding ECDSA over the secp256k1 and secp256r1 curves
+keywords: [cryptographic primitives, Noir project, ecdsa, secp256k1, secp256r1, signatures]
+sidebar_position: 3
+---
+
+import BlackBoxInfo from '@site/src/components/Notes/_blackbox';
+
+Noir supports ECDSA signatures verification over the secp256k1 and secp256r1 curves.
+
+## ecdsa_secp256k1::verify_signature
+
+Verifier for ECDSA Secp256k1 signatures.
+See ecdsa_secp256k1::verify_signature_slice for a version that accepts slices directly.
+
+```rust title="ecdsa_secp256k1" showLineNumbers 
+pub fn verify_signature<let N: u32>(
+    public_key_x: [u8; 32],
+    public_key_y: [u8; 32],
+    signature: [u8; 64],
+    message_hash: [u8; N],
+) -> bool
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/ecdsa_secp256k1.nr#L2-L9" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/ecdsa_secp256k1.nr#L2-L9</a></sub></sup>
+
+
+example:
+
+```rust
+fn main(hashed_message : [u8;32], pub_key_x : [u8;32], pub_key_y : [u8;32], signature : [u8;64]) {
+     let valid_signature = std::ecdsa_secp256k1::verify_signature(pub_key_x, pub_key_y, signature, hashed_message);
+     assert(valid_signature);
+}
+```
+
+<BlackBoxInfo to="../black_box_fns" />
+
+## ecdsa_secp256k1::verify_signature_slice
+
+Verifier for ECDSA Secp256k1 signatures where the message is a slice.
+
+```rust title="ecdsa_secp256k1_slice" showLineNumbers 
+pub fn verify_signature_slice(
+    public_key_x: [u8; 32],
+    public_key_y: [u8; 32],
+    signature: [u8; 64],
+    message_hash: [u8],
+) -> bool
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/ecdsa_secp256k1.nr#L13-L20" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/ecdsa_secp256k1.nr#L13-L20</a></sub></sup>
+
+
+<BlackBoxInfo to="../black_box_fns"/>
+
+## ecdsa_secp256r1::verify_signature
+
+Verifier for ECDSA Secp256r1 signatures.
+See ecdsa_secp256r1::verify_signature_slice for a version that accepts slices directly.
+
+```rust title="ecdsa_secp256r1" showLineNumbers 
+pub fn verify_signature<let N: u32>(
+    public_key_x: [u8; 32],
+    public_key_y: [u8; 32],
+    signature: [u8; 64],
+    message_hash: [u8; N],
+) -> bool
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/ecdsa_secp256r1.nr#L2-L9" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/ecdsa_secp256r1.nr#L2-L9</a></sub></sup>
+
+
+example:
+
+```rust
+fn main(hashed_message : [u8;32], pub_key_x : [u8;32], pub_key_y : [u8;32], signature : [u8;64]) {
+     let valid_signature = std::ecdsa_secp256r1::verify_signature(pub_key_x, pub_key_y, signature, hashed_message);
+     assert(valid_signature);
+}
+```
+
+<BlackBoxInfo to="../black_box_fns"/>
+
+## ecdsa_secp256r1::verify_signature
+
+Verifier for ECDSA Secp256r1 signatures where the message is a slice.
+
+```rust title="ecdsa_secp256r1_slice" showLineNumbers 
+pub fn verify_signature_slice(
+    public_key_x: [u8; 32],
+    public_key_y: [u8; 32],
+    signature: [u8; 64],
+    message_hash: [u8],
+) -> bool
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/ecdsa_secp256r1.nr#L13-L20" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/ecdsa_secp256r1.nr#L13-L20</a></sub></sup>
+
+
+<BlackBoxInfo to="../black_box_fns"/>
diff --git a/docs/versioned_docs/version-v0.36.0/noir/standard_library/cryptographic_primitives/eddsa.mdx b/docs/versioned_docs/version-v0.36.0/noir/standard_library/cryptographic_primitives/eddsa.mdx
new file mode 100644
index 00000000000..b283de693c8
--- /dev/null
+++ b/docs/versioned_docs/version-v0.36.0/noir/standard_library/cryptographic_primitives/eddsa.mdx
@@ -0,0 +1,37 @@
+---
+title: EdDSA Verification
+description: Learn about the cryptographic primitives regarding EdDSA
+keywords: [cryptographic primitives, Noir project, eddsa, signatures]
+sidebar_position: 5
+---
+
+import BlackBoxInfo from '@site/src/components/Notes/_blackbox';
+
+## eddsa::eddsa_poseidon_verify
+
+Verifier for EdDSA signatures
+
+```rust
+fn eddsa_poseidon_verify(public_key_x : Field, public_key_y : Field, signature_s: Field, signature_r8_x: Field, signature_r8_y: Field, message: Field) -> bool
+```
+
+It is also possible to specify the hash algorithm used for the signature by using the `eddsa_verify` function by passing a type implementing the Hasher trait with the turbofish operator. 
+For instance, if you want to use Poseidon2 instead, you can do the following:
+```rust
+use std::hash::poseidon2::Poseidon2Hasher;
+
+eddsa_verify::<Poseidon2Hasher>(pub_key_a.x, pub_key_a.y, s_a, r8_a.x, r8_a.y, msg);
+```
+
+<BlackBoxInfo to="../black_box_fns"/>
+
+## eddsa::eddsa_to_pub
+
+Private to public key conversion.
+
+Returns `(pub_key_x, pub_key_y)`
+
+```rust
+fn eddsa_to_pub(secret : Field) -> (Field, Field)
+```
+
diff --git a/docs/versioned_docs/version-v0.36.0/noir/standard_library/cryptographic_primitives/embedded_curve_ops.mdx b/docs/versioned_docs/version-v0.36.0/noir/standard_library/cryptographic_primitives/embedded_curve_ops.mdx
new file mode 100644
index 00000000000..4b5bba7802e
--- /dev/null
+++ b/docs/versioned_docs/version-v0.36.0/noir/standard_library/cryptographic_primitives/embedded_curve_ops.mdx
@@ -0,0 +1,95 @@
+---
+title: Scalar multiplication
+description: See how you can perform scalar multiplication in Noir
+keywords: [cryptographic primitives, Noir project, scalar multiplication]
+sidebar_position: 1
+---
+
+import BlackBoxInfo from '@site/src/components/Notes/_blackbox';
+
+The following functions perform operations over the embedded curve whose coordinates are defined by the configured noir field.
+For the BN254 scalar field, this is BabyJubJub or Grumpkin.
+
+:::note
+Suffixes `_low` and `_high` denote low and high limbs of a scalar.
+:::
+
+## embedded_curve_ops::multi_scalar_mul
+
+Performs multi scalar multiplication over the embedded curve.
+The function accepts arbitrary amount of point-scalar pairs on the input, it multiplies the individual pairs over
+the curve and returns a sum of the resulting points.
+
+Points represented as x and y coordinates [x1, y1, x2, y2, ...], scalars as low and high limbs [low1, high1, low2, high2, ...].
+
+```rust title="multi_scalar_mul" showLineNumbers 
+pub fn multi_scalar_mul<let N: u32>(
+    points: [EmbeddedCurvePoint; N],
+    scalars: [EmbeddedCurveScalar; N],
+) -> EmbeddedCurvePoint
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/embedded_curve_ops.nr#L103-L108" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/embedded_curve_ops.nr#L103-L108</a></sub></sup>
+
+
+example
+
+```rust
+fn main(point_x: Field, point_y: Field, scalar_low: Field, scalar_high: Field) {
+    let point = std::embedded_curve_ops::multi_scalar_mul([point_x, point_y], [scalar_low, scalar_high]);
+    println(point);
+}
+```
+
+## embedded_curve_ops::fixed_base_scalar_mul
+
+Performs fixed base scalar multiplication over the embedded curve (multiplies input scalar with a generator point).
+The function accepts a single scalar on the input represented as 2 fields.
+
+```rust title="fixed_base_scalar_mul" showLineNumbers 
+pub fn fixed_base_scalar_mul(scalar: EmbeddedCurveScalar) -> EmbeddedCurvePoint
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/embedded_curve_ops.nr#L126-L128" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/embedded_curve_ops.nr#L126-L128</a></sub></sup>
+
+
+example
+
+```rust
+fn main(scalar_low: Field, scalar_high: Field) {
+    let point = std::embedded_curve_ops::fixed_base_scalar_mul(scalar_low, scalar_high);
+    println(point);
+}
+```
+
+## embedded_curve_ops::embedded_curve_add
+
+Adds two points on the embedded curve.
+This function takes two `EmbeddedCurvePoint` structures as parameters, representing points on the curve, and returns a new `EmbeddedCurvePoint` structure that represents their sum.
+
+### Parameters:
+- `point1` (`EmbeddedCurvePoint`): The first point to add.
+- `point2` (`EmbeddedCurvePoint`): The second point to add.
+
+### Returns:
+- `EmbeddedCurvePoint`: The resulting point after the addition of `point1` and `point2`.
+
+```rust title="embedded_curve_add" showLineNumbers 
+pub fn embedded_curve_add(
+    point1: EmbeddedCurvePoint,
+    point2: EmbeddedCurvePoint,
+) -> EmbeddedCurvePoint {
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/embedded_curve_ops.nr#L142-L147" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/embedded_curve_ops.nr#L142-L147</a></sub></sup>
+
+
+example
+
+```rust
+fn main() {
+    let point1 = EmbeddedCurvePoint { x: 1, y: 2 };
+    let point2 = EmbeddedCurvePoint { x: 3, y: 4 };
+    let result = std::embedded_curve_ops::embedded_curve_add(point1, point2);
+    println!("Resulting Point: ({}, {})", result.x, result.y);
+}
+```
+
+<BlackBoxInfo to="../black_box_fns"/>
diff --git a/docs/versioned_docs/version-v0.36.0/noir/standard_library/cryptographic_primitives/hashes.mdx b/docs/versioned_docs/version-v0.36.0/noir/standard_library/cryptographic_primitives/hashes.mdx
new file mode 100644
index 00000000000..7cb95779586
--- /dev/null
+++ b/docs/versioned_docs/version-v0.36.0/noir/standard_library/cryptographic_primitives/hashes.mdx
@@ -0,0 +1,253 @@
+---
+title: Hash methods
+description:
+  Learn about the cryptographic primitives ready to use for any Noir project, including sha256,
+  blake2s, pedersen, mimc_bn254 and mimc
+keywords:
+  [cryptographic primitives, Noir project, sha256, blake2s, pedersen, mimc_bn254, mimc, hash]
+sidebar_position: 0
+---
+
+import BlackBoxInfo from '@site/src/components/Notes/_blackbox';
+
+## sha256
+
+Given an array of bytes, returns the resulting sha256 hash.
+Specify a message_size to hash only the first `message_size` bytes of the input.
+
+```rust title="sha256" showLineNumbers 
+pub fn sha256<let N: u32>(input: [u8; N]) -> [u8; 32]
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/hash/sha256.nr#L7-L9" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/hash/sha256.nr#L7-L9</a></sub></sup>
+
+
+example:
+```rust title="sha256_var" showLineNumbers 
+let digest = std::hash::sha256_var([x as u8], 1);
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/test_programs/execution_success/sha256/src/main.nr#L15-L17" target="_blank" rel="noopener noreferrer">Source code: test_programs/execution_success/sha256/src/main.nr#L15-L17</a></sub></sup>
+
+
+```rust
+fn main() {
+    let x = [163, 117, 178, 149]; // some random bytes
+    let hash = std::sha256::sha256_var(x, 4);
+}
+```
+
+
+<BlackBoxInfo to="../black_box_fns"/>
+
+## blake2s
+
+Given an array of bytes, returns an array with the Blake2 hash
+
+```rust title="blake2s" showLineNumbers 
+pub fn blake2s<let N: u32>(input: [u8; N]) -> [u8; 32]
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/hash/mod.nr#L20-L22" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/hash/mod.nr#L20-L22</a></sub></sup>
+
+
+example:
+
+```rust
+fn main() {
+    let x = [163, 117, 178, 149]; // some random bytes
+    let hash = std::hash::blake2s(x);
+}
+```
+
+<BlackBoxInfo to="../black_box_fns"/>
+
+## blake3
+
+Given an array of bytes, returns an array with the Blake3 hash
+
+```rust title="blake3" showLineNumbers 
+pub fn blake3<let N: u32>(input: [u8; N]) -> [u8; 32]
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/hash/mod.nr#L26-L28" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/hash/mod.nr#L26-L28</a></sub></sup>
+
+
+example:
+
+```rust
+fn main() {
+    let x = [163, 117, 178, 149]; // some random bytes
+    let hash = std::hash::blake3(x);
+}
+```
+
+<BlackBoxInfo to="../black_box_fns"/>
+
+## pedersen_hash
+
+Given an array of Fields, returns the Pedersen hash.
+
+```rust title="pedersen_hash" showLineNumbers 
+pub fn pedersen_hash<let N: u32>(input: [Field; N]) -> Field
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/hash/mod.nr#L51-L53" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/hash/mod.nr#L51-L53</a></sub></sup>
+
+
+example:
+
+```rust title="pedersen-hash" showLineNumbers 
+fn main(x: Field, y: Field, expected_hash: Field) {
+    let hash = std::hash::pedersen_hash([x, y]);
+    assert_eq(hash, expected_hash);
+}
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/test_programs/execution_success/pedersen_hash/src/main.nr#L1-L6" target="_blank" rel="noopener noreferrer">Source code: test_programs/execution_success/pedersen_hash/src/main.nr#L1-L6</a></sub></sup>
+
+
+<BlackBoxInfo to="../black_box_fns" />
+
+## pedersen_commitment
+
+Given an array of Fields, returns the Pedersen commitment.
+
+```rust title="pedersen_commitment" showLineNumbers 
+pub fn pedersen_commitment<let N: u32>(input: [Field; N]) -> EmbeddedCurvePoint {
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/hash/mod.nr#L31-L33" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/hash/mod.nr#L31-L33</a></sub></sup>
+
+
+example:
+
+```rust title="pedersen-commitment" showLineNumbers 
+fn main(x: Field, y: Field, expected_commitment: std::embedded_curve_ops::EmbeddedCurvePoint) {
+    let commitment = std::hash::pedersen_commitment([x, y]);
+    assert_eq(commitment.x, expected_commitment.x);
+    assert_eq(commitment.y, expected_commitment.y);
+}
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/test_programs/execution_success/pedersen_commitment/src/main.nr#L1-L7" target="_blank" rel="noopener noreferrer">Source code: test_programs/execution_success/pedersen_commitment/src/main.nr#L1-L7</a></sub></sup>
+
+
+<BlackBoxInfo to="../black_box_fns"/>
+
+## keccak256
+
+Given an array of bytes (`u8`), returns the resulting keccak hash as an array of
+32 bytes (`[u8; 32]`). Specify a message_size to hash only the first
+`message_size` bytes of the input.
+
+```rust title="keccak256" showLineNumbers 
+pub fn keccak256<let N: u32>(input: [u8; N], message_size: u32) -> [u8; 32]
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/hash/mod.nr#L117-L119" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/hash/mod.nr#L117-L119</a></sub></sup>
+
+
+example:
+
+```rust title="keccak256" showLineNumbers 
+fn main(x: Field, result: [u8; 32]) {
+    // We use the `as` keyword here to denote the fact that we want to take just the first byte from the x Field
+    // The padding is taken care of by the program
+    let digest = std::hash::keccak256([x as u8], 1);
+    assert(digest == result);
+
+    //#1399: variable message size
+    let message_size = 4;
+    let hash_a = std::hash::keccak256([1, 2, 3, 4], message_size);
+    let hash_b = std::hash::keccak256([1, 2, 3, 4, 0, 0, 0, 0], message_size);
+
+    assert(hash_a == hash_b);
+
+    let message_size_big = 8;
+    let hash_c = std::hash::keccak256([1, 2, 3, 4, 0, 0, 0, 0], message_size_big);
+
+    assert(hash_a != hash_c);
+}
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/test_programs/execution_success/keccak256/src/main.nr#L1-L20" target="_blank" rel="noopener noreferrer">Source code: test_programs/execution_success/keccak256/src/main.nr#L1-L20</a></sub></sup>
+
+
+<BlackBoxInfo to="../black_box_fns"/>
+
+## poseidon
+
+Given an array of Fields, returns a new Field with the Poseidon Hash. Mind that you need to specify
+how many inputs are there to your Poseidon function.
+
+```rust
+// example for hash_1, hash_2 accepts an array of length 2, etc
+fn hash_1(input: [Field; 1]) -> Field
+```
+
+example:
+
+```rust title="poseidon" showLineNumbers 
+use std::hash::poseidon;
+
+fn main(x1: [Field; 2], y1: pub Field, x2: [Field; 4], y2: pub Field) {
+    let hash1 = poseidon::bn254::hash_2(x1);
+    assert(hash1 == y1);
+
+    let hash2 = poseidon::bn254::hash_4(x2);
+    assert(hash2 == y2);
+}
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/test_programs/execution_success/poseidon_bn254_hash/src/main.nr#L1-L11" target="_blank" rel="noopener noreferrer">Source code: test_programs/execution_success/poseidon_bn254_hash/src/main.nr#L1-L11</a></sub></sup>
+
+
+## poseidon 2
+
+Given an array of Fields, returns a new Field with the Poseidon2 Hash. Contrary to the Poseidon
+function, there is only one hash and you can specify a message_size to hash only the first 
+`message_size` bytes of the input,
+
+```rust
+// example for hashing the first three elements of the input
+Poseidon2::hash(input, 3);
+```
+
+example:
+
+```rust title="poseidon2" showLineNumbers 
+use std::hash::poseidon2;
+
+fn main(inputs: [Field; 4], expected_hash: Field) {
+    let hash = poseidon2::Poseidon2::hash(inputs, inputs.len());
+    assert_eq(hash, expected_hash);
+}
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/test_programs/execution_success/poseidon2/src/main.nr#L1-L8" target="_blank" rel="noopener noreferrer">Source code: test_programs/execution_success/poseidon2/src/main.nr#L1-L8</a></sub></sup>
+
+
+## mimc_bn254 and mimc
+
+`mimc_bn254` is `mimc`, but with hardcoded parameters for the BN254 curve. You can use it by
+providing an array of Fields, and it returns a Field with the hash. You can use the `mimc` method if
+you're willing to input your own constants:
+
+```rust
+fn mimc<N>(x: Field, k: Field, constants: [Field; N], exp : Field) -> Field
+```
+
+otherwise, use the `mimc_bn254` method:
+
+```rust
+fn mimc_bn254<let N: u32>(array: [Field; N]) -> Field
+```
+
+example:
+
+```rust
+
+fn main() {
+    let x = [163, 117, 178, 149]; // some random bytes
+    let hash = std::hash::mimc::mimc_bn254(x);
+}
+```
+
+## hash_to_field
+
+```rust
+fn hash_to_field(_input : [Field]) -> Field {}
+```
+
+Calculates the `blake2s` hash of the inputs and returns the hash modulo the field modulus to return
+a value which can be represented as a `Field`.
+
diff --git a/docs/versioned_docs/version-v0.36.0/noir/standard_library/cryptographic_primitives/index.md b/docs/versioned_docs/version-v0.36.0/noir/standard_library/cryptographic_primitives/index.md
new file mode 100644
index 00000000000..650f30165d5
--- /dev/null
+++ b/docs/versioned_docs/version-v0.36.0/noir/standard_library/cryptographic_primitives/index.md
@@ -0,0 +1,14 @@
+---
+title: Cryptographic Primitives
+description:
+  Learn about the cryptographic primitives ready to use for any Noir project
+keywords:
+  [
+    cryptographic primitives,
+    Noir project,
+  ]
+---
+
+The Noir team is progressively adding new cryptographic primitives to the standard library. Reach out for news or if you would be interested in adding more of these calculations in Noir.
+
+Some methods are available thanks to the Aztec backend, not being performed using Noir. When using other backends, these methods may or may not be supplied.
diff --git a/docs/versioned_docs/version-v0.36.0/noir/standard_library/cryptographic_primitives/schnorr.mdx b/docs/versioned_docs/version-v0.36.0/noir/standard_library/cryptographic_primitives/schnorr.mdx
new file mode 100644
index 00000000000..030452645c5
--- /dev/null
+++ b/docs/versioned_docs/version-v0.36.0/noir/standard_library/cryptographic_primitives/schnorr.mdx
@@ -0,0 +1,64 @@
+---
+title: Schnorr Signatures
+description: Learn how you can verify Schnorr signatures using Noir
+keywords: [cryptographic primitives, Noir project, schnorr, signatures]
+sidebar_position: 2
+---
+
+import BlackBoxInfo from '@site/src/components/Notes/_blackbox';
+
+## schnorr::verify_signature
+
+Verifier for Schnorr signatures over the embedded curve (for BN254 it is Grumpkin).
+See schnorr::verify_signature_slice for a version that works directly on slices.
+
+```rust title="schnorr_verify" showLineNumbers 
+pub fn verify_signature<let N: u32>(
+    public_key_x: Field,
+    public_key_y: Field,
+    signature: [u8; 64],
+    message: [u8; N],
+) -> bool
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/schnorr.nr#L4-L11" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/schnorr.nr#L4-L11</a></sub></sup>
+
+
+where `_signature` can be generated like so using the npm package
+[@noir-lang/barretenberg](https://www.npmjs.com/package/@noir-lang/barretenberg)
+
+```js
+const { BarretenbergWasm } = require('@noir-lang/barretenberg/dest/wasm');
+const { Schnorr } = require('@noir-lang/barretenberg/dest/crypto/schnorr');
+
+...
+
+const barretenberg = await BarretenbergWasm.new();
+const schnorr = new Schnorr(barretenberg);
+const pubKey = schnorr.computePublicKey(privateKey);
+const message = ...
+const signature = Array.from(
+    schnorr.constructSignature(hash, privateKey).toBuffer()
+);
+
+...
+```
+
+<BlackBoxInfo to="../black_box_fns"/>
+
+## schnorr::verify_signature_slice
+
+Verifier for Schnorr signatures over the embedded curve (for BN254 it is Grumpkin)
+where the message is a slice. 
+
+```rust title="schnorr_verify_slice" showLineNumbers 
+pub fn verify_signature_slice(
+    public_key_x: Field,
+    public_key_y: Field,
+    signature: [u8; 64],
+    message: [u8],
+) -> bool
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/schnorr.nr#L15-L22" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/schnorr.nr#L15-L22</a></sub></sup>
+
+
+<BlackBoxInfo to="../black_box_fns"/>
diff --git a/docs/versioned_docs/version-v0.36.0/noir/standard_library/fmtstr.md b/docs/versioned_docs/version-v0.36.0/noir/standard_library/fmtstr.md
new file mode 100644
index 00000000000..19809d60261
--- /dev/null
+++ b/docs/versioned_docs/version-v0.36.0/noir/standard_library/fmtstr.md
@@ -0,0 +1,17 @@
+---
+title: fmtstr
+---
+
+`fmtstr<N, T>` is the type resulting from using format string (`f"..."`).
+
+## Methods
+
+### quoted_contents
+
+```rust title="quoted_contents" showLineNumbers 
+pub comptime fn quoted_contents(self) -> Quoted {}
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/meta/format_string.nr#L3-L5" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/meta/format_string.nr#L3-L5</a></sub></sup>
+
+
+Returns the format string contents (that is, without the leading and trailing double quotes) as a `Quoted` value.
\ No newline at end of file
diff --git a/docs/versioned_docs/version-v0.36.0/noir/standard_library/is_unconstrained.md b/docs/versioned_docs/version-v0.36.0/noir/standard_library/is_unconstrained.md
new file mode 100644
index 00000000000..51bb1bda8f1
--- /dev/null
+++ b/docs/versioned_docs/version-v0.36.0/noir/standard_library/is_unconstrained.md
@@ -0,0 +1,69 @@
+---
+title: Is Unconstrained Function
+description:
+  The is_unconstrained function returns wether the context at that point of the program is unconstrained or not.
+keywords:
+  [
+    unconstrained
+  ]
+---
+
+It's very common for functions in circuits to take unconstrained hints of an expensive computation and then verify it. This is done by running the hint in an unconstrained context and then verifying the result in a constrained context.
+
+When a function is marked as unconstrained, any subsequent functions that it calls will also be run in an unconstrained context. However, if we are implementing a library function, other users might call it within an unconstrained context or a constrained one. Generally, in an unconstrained context we prefer just computing the result instead of taking a hint of it and verifying it, since that'd mean doing the same computation twice:
+
+```rust 
+
+fn my_expensive_computation(){
+  ...
+}
+
+unconstrained fn my_expensive_computation_hint(){
+  my_expensive_computation()
+}
+
+pub fn external_interface(){
+  my_expensive_computation_hint();
+  // verify my_expensive_computation: If external_interface is called from unconstrained, this is redundant
+  ...
+}
+
+```
+
+In order to improve the performance in an unconstrained context you can use the function at `std::runtime::is_unconstrained() -> bool`:
+
+
+```rust 
+use dep::std::runtime::is_unconstrained;
+
+fn my_expensive_computation(){
+  ...
+}
+
+unconstrained fn my_expensive_computation_hint(){
+  my_expensive_computation()
+}
+
+pub fn external_interface(){
+  if is_unconstrained() {
+    my_expensive_computation();
+  } else {
+    my_expensive_computation_hint();
+    // verify my_expensive_computation
+    ...
+  }
+}
+
+```
+
+The is_unconstrained result is resolved at compile time, so in unconstrained contexts the compiler removes the else branch, and in constrained contexts the compiler removes the if branch, reducing the amount of compute necessary to run external_interface.
+
+Note that using `is_unconstrained` in a `comptime` context will also return `true`:
+
+```
+fn main() {
+    comptime {
+        assert(is_unconstrained());
+    }
+}
+```
diff --git a/docs/versioned_docs/version-v0.36.0/noir/standard_library/logging.md b/docs/versioned_docs/version-v0.36.0/noir/standard_library/logging.md
new file mode 100644
index 00000000000..db75ef9f86f
--- /dev/null
+++ b/docs/versioned_docs/version-v0.36.0/noir/standard_library/logging.md
@@ -0,0 +1,78 @@
+---
+title: Logging
+description:
+  Learn how to use the println statement for debugging in Noir with this tutorial. Understand the
+  basics of logging in Noir and how to implement it in your code.
+keywords:
+  [
+    noir logging,
+    println statement,
+    print statement,
+    debugging in noir,
+    noir std library,
+    logging tutorial,
+    basic logging in noir,
+    noir logging implementation,
+    noir debugging techniques,
+    rust,
+  ]
+---
+
+The standard library provides two familiar statements you can use: `println` and `print`. Despite being a limited implementation of rust's `println!` and `print!` macros, these constructs can be useful for debugging.
+
+You can print the output of both statements in your Noir code by using the `nargo execute` command or the `--show-output` flag when using `nargo test` (provided there are print statements in your tests).
+
+It is recommended to use `nargo execute` if you want to debug failing constraints with `println` or `print` statements. This is due to every input in a test being a constant rather than a witness, so we issue an error during compilation while we only print during execution (which comes after compilation). Neither `println`, nor `print` are callable for failed constraints caught at compile time.
+
+Both `print` and `println` are generic functions which can work on integers, fields, strings, and even structs or expressions. Note however, that slices are currently unsupported. For example:
+
+```rust
+struct Person {
+    age: Field,
+    height: Field,
+}
+
+fn main(age: Field, height: Field) {
+    let person = Person {
+        age: age,
+        height: height,
+    };
+    println(person);
+    println(age + height);
+    println("Hello world!");
+}
+```
+
+You can print different types in the same statement (including strings) with a type called `fmtstr`. It can be specified in the same way as a normal string, just prepended with an "f" character:
+
+```rust
+  let fmt_str = f"i: {i}, j: {j}";
+  println(fmt_str);
+
+  let s = myStruct { y: x, x: y };
+  println(s);
+
+  println(f"i: {i}, s: {s}");
+
+  println(x);
+  println([x, y]);
+
+  let foo = fooStruct { my_struct: s, foo: 15 };
+  println(f"s: {s}, foo: {foo}");
+
+  println(15);       // prints 0x0f, implicit Field
+  println(-1 as u8); // prints 255
+  println(-1 as i8); // prints -1
+```
+
+Examples shown above are interchangeable between the two `print` statements:
+
+```rust
+let person = Person { age : age, height : height };
+
+println(person);
+print(person);
+
+println("Hello world!"); // Prints with a newline at the end of the input
+print("Hello world!");   // Prints the input and keeps cursor on the same line
+```
diff --git a/docs/versioned_docs/version-v0.36.0/noir/standard_library/mem.md b/docs/versioned_docs/version-v0.36.0/noir/standard_library/mem.md
new file mode 100644
index 00000000000..95d36ac2a72
--- /dev/null
+++ b/docs/versioned_docs/version-v0.36.0/noir/standard_library/mem.md
@@ -0,0 +1,52 @@
+---
+title: Memory Module
+description:
+  This module contains functions which manipulate memory in a low-level way
+keywords:
+  [
+    mem, memory, zeroed, transmute, checked_transmute
+  ]
+---
+
+# `std::mem::zeroed`
+
+```rust
+fn zeroed<T>() -> T
+```
+
+Returns a zeroed value of any type.
+This function is generally unsafe to use as the zeroed bit pattern is not guaranteed to be valid for all types.
+It can however, be useful in cases when the value is guaranteed not to be used such as in a BoundedVec library implementing a growable vector, up to a certain length, backed by an array.
+The array can be initialized with zeroed values which are guaranteed to be inaccessible until the vector is pushed to.
+Similarly, enumerations in noir can be implemented using this method by providing zeroed values for the unused variants.
+
+This function currently supports the following types:
+
+- Field
+- Bool
+- Uint
+- Array
+- Slice
+- String
+- Tuple
+- Functions
+  
+Using it on other types could result in unexpected behavior.
+
+# `std::mem::checked_transmute`
+
+```rust
+fn checked_transmute<T, U>(value: T) -> U
+```
+
+Transmutes a value of one type into the same value but with a new type `U`.
+
+This function is safe to use since both types are asserted to be equal later during compilation after the concrete values for generic types become known.
+This function is useful for cases where the compiler may fails a type check that is expected to pass where
+a user knows the two types to be equal. For example, when using arithmetic generics there are cases the compiler
+does not see as equal, such as `[Field; N*(A + B)]` and `[Field; N*A + N*B]`, which users may know to be equal.
+In these cases, `checked_transmute` can be used to cast the value to the desired type while also preserving safety
+by checking this equality once `N`, `A`, `B` are fully resolved.
+
+Note that since this safety check is performed after type checking rather than during, no error is issued if the function
+containing `checked_transmute` is never called.
diff --git a/docs/versioned_docs/version-v0.36.0/noir/standard_library/merkle_trees.md b/docs/versioned_docs/version-v0.36.0/noir/standard_library/merkle_trees.md
new file mode 100644
index 00000000000..6a9ebf72ada
--- /dev/null
+++ b/docs/versioned_docs/version-v0.36.0/noir/standard_library/merkle_trees.md
@@ -0,0 +1,58 @@
+---
+title: Merkle Trees
+description: Learn about Merkle Trees in Noir with this tutorial. Explore the basics of computing a merkle root using a proof, with examples.
+keywords:
+  [
+    Merkle trees in Noir,
+    Noir programming language,
+    check membership,
+    computing root from leaf,
+    Noir Merkle tree implementation,
+    Merkle tree tutorial,
+    Merkle tree code examples,
+    Noir libraries,
+    pedersen hash.,
+  ]
+---
+
+## compute_merkle_root
+
+Returns the root of the tree from the provided leaf and its hash path, using a [Pedersen hash](./cryptographic_primitives/hashes.mdx#pedersen_hash).
+
+```rust
+fn compute_merkle_root(leaf : Field, index : Field, hash_path: [Field]) -> Field
+```
+
+example:
+
+```rust
+/**
+    // these values are for this example only
+    index = "0"
+    priv_key = "0x000000000000000000000000000000000000000000000000000000616c696365"
+    secret = "0x1929ea3ab8d9106a899386883d9428f8256cfedb3c4f6b66bf4aa4d28a79988f"
+    note_hash_path = [
+    "0x1e61bdae0f027b1b2159e1f9d3f8d00fa668a952dddd822fda80dc745d6f65cc",
+    "0x0e4223f3925f98934393c74975142bd73079ab0621f4ee133cee050a3c194f1a",
+    "0x2fd7bb412155bf8693a3bd2a3e7581a679c95c68a052f835dddca85fa1569a40"
+    ]
+ */
+fn main(index: Field, priv_key: Field, secret: Field, note_hash_path: [Field; 3]) {
+
+    let pubkey = std::scalar_mul::fixed_base_embedded_curve(priv_key);
+    let pubkey_x = pubkey[0];
+    let pubkey_y = pubkey[1];
+    let note_commitment = std::hash::pedersen(&[pubkey_x, pubkey_y, secret]);
+
+    let root = std::merkle::compute_merkle_root(note_commitment[0], index, note_hash_path.as_slice());
+    println(root);
+}
+```
+
+To check merkle tree membership:
+
+1. Include a merkle root as a program input.
+2. Compute the merkle root of a given leaf, index and hash path.
+3. Assert the merkle roots are equal.
+
+For more info about merkle trees, see the Wikipedia [page](https://en.wikipedia.org/wiki/Merkle_tree).
diff --git a/docs/versioned_docs/version-v0.36.0/noir/standard_library/meta/ctstring.md b/docs/versioned_docs/version-v0.36.0/noir/standard_library/meta/ctstring.md
new file mode 100644
index 00000000000..b76f873ca03
--- /dev/null
+++ b/docs/versioned_docs/version-v0.36.0/noir/standard_library/meta/ctstring.md
@@ -0,0 +1,100 @@
+---
+title: CtString
+---
+
+`std::meta::ctstring` contains methods on the built-in `CtString` type which is
+a compile-time, dynamically-sized string type. Compared to `str<N>` and `fmtstr<N, T>`,
+`CtString` is useful because its size does not need to be specified in its type. This
+can be used for formatting items at compile-time or general string handling in `comptime`
+code.
+
+Since `fmtstr`s can be converted into `CtString`s, you can make use of their formatting
+abilities in CtStrings by formatting in `fmtstr`s then converting the result to a CtString
+afterward.
+
+## Traits
+
+### AsCtString
+
+```rust title="as-ctstring" showLineNumbers 
+pub trait AsCtString {
+    comptime fn as_ctstring(self) -> CtString;
+}
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/meta/ctstring.nr#L43-L47" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/meta/ctstring.nr#L43-L47</a></sub></sup>
+
+
+Converts an object into a compile-time string.
+
+Implementations:
+
+```rust
+impl<let N: u32> AsCtString for str<N> { ... }
+impl<let N: u32, T> AsCtString for fmtstr<N, T> { ... }
+```
+
+## Methods
+
+### new
+
+```rust title="new" showLineNumbers 
+pub comptime fn new() -> Self {
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/meta/ctstring.nr#L4-L6" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/meta/ctstring.nr#L4-L6</a></sub></sup>
+
+
+Creates an empty `CtString`.
+
+### append_str
+
+```rust title="append_str" showLineNumbers 
+pub comptime fn append_str<let N: u32>(self, s: str<N>) -> Self {
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/meta/ctstring.nr#L11-L13" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/meta/ctstring.nr#L11-L13</a></sub></sup>
+
+
+Returns a new CtString with the given str appended onto the end.
+
+### append_fmtstr
+
+```rust title="append_fmtstr" showLineNumbers 
+pub comptime fn append_fmtstr<let N: u32, T>(self, s: fmtstr<N, T>) -> Self {
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/meta/ctstring.nr#L17-L19" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/meta/ctstring.nr#L17-L19</a></sub></sup>
+
+
+Returns a new CtString with the given fmtstr appended onto the end.
+
+### as_quoted_str
+
+```rust title="as_quoted_str" showLineNumbers 
+pub comptime fn as_quoted_str(self) -> Quoted {
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/meta/ctstring.nr#L26-L28" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/meta/ctstring.nr#L26-L28</a></sub></sup>
+
+
+Returns a quoted string literal from this string's contents.
+
+There is no direct conversion from a `CtString` to a `str<N>` since
+the size would not be known. To get around this, this function can
+be used in combination with macro insertion (`!`) to insert this string
+literal at this function's call site.
+
+Example:
+
+```rust title="as_quoted_str_example" showLineNumbers 
+let my_ctstring = "foo bar".as_ctstring();
+            let my_str = my_ctstring.as_quoted_str!();
+
+            assert_eq(crate::meta::type_of(my_str), quote { str<7> }.as_type());
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/meta/ctstring.nr#L92-L97" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/meta/ctstring.nr#L92-L97</a></sub></sup>
+
+
+## Trait Implementations
+
+```rust
+impl Eq for CtString
+impl Hash for CtString
+impl Append for CtString
+```
diff --git a/docs/versioned_docs/version-v0.36.0/noir/standard_library/meta/expr.md b/docs/versioned_docs/version-v0.36.0/noir/standard_library/meta/expr.md
new file mode 100644
index 00000000000..b6d395c6700
--- /dev/null
+++ b/docs/versioned_docs/version-v0.36.0/noir/standard_library/meta/expr.md
@@ -0,0 +1,380 @@
+---
+title: Expr
+---
+
+`std::meta::expr` contains methods on the built-in `Expr` type for quoted, syntactically valid expressions.
+
+## Methods
+
+### as_array
+
+```rust title="as_array" showLineNumbers 
+pub comptime fn as_array(self) -> Option<[Expr]> {}
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/meta/expr.nr#L10-L12" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/meta/expr.nr#L10-L12</a></sub></sup>
+
+
+If this expression is an array, this returns a slice of each element in the array.
+
+### as_assert
+
+```rust title="as_assert" showLineNumbers 
+pub comptime fn as_assert(self) -> Option<(Expr, Option<Expr>)> {}
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/meta/expr.nr#L16-L18" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/meta/expr.nr#L16-L18</a></sub></sup>
+
+
+If this expression is an assert, this returns the assert expression and the optional message.
+
+### as_assert_eq
+
+```rust title="as_assert_eq" showLineNumbers 
+pub comptime fn as_assert_eq(self) -> Option<(Expr, Expr, Option<Expr>)> {}
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/meta/expr.nr#L23-L25" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/meta/expr.nr#L23-L25</a></sub></sup>
+
+
+If this expression is an assert_eq, this returns the left-hand-side and right-hand-side
+expressions, together with the optional message.
+
+### as_assign
+
+```rust title="as_assign" showLineNumbers 
+pub comptime fn as_assign(self) -> Option<(Expr, Expr)> {}
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/meta/expr.nr#L30-L32" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/meta/expr.nr#L30-L32</a></sub></sup>
+
+
+If this expression is an assignment, this returns a tuple with the left hand side
+and right hand side in order.
+
+### as_binary_op
+
+```rust title="as_binary_op" showLineNumbers 
+pub comptime fn as_binary_op(self) -> Option<(Expr, BinaryOp, Expr)> {}
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/meta/expr.nr#L37-L39" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/meta/expr.nr#L37-L39</a></sub></sup>
+
+
+If this expression is a binary operator operation `<lhs> <op> <rhs>`,
+return the left-hand side, operator, and the right-hand side of the operation.
+
+### as_block
+
+```rust title="as_block" showLineNumbers 
+pub comptime fn as_block(self) -> Option<[Expr]> {}
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/meta/expr.nr#L44-L46" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/meta/expr.nr#L44-L46</a></sub></sup>
+
+
+If this expression is a block `{ stmt1; stmt2; ...; stmtN }`, return
+a slice containing each statement.
+
+### as_bool
+
+```rust title="as_bool" showLineNumbers 
+pub comptime fn as_bool(self) -> Option<bool> {}
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/meta/expr.nr#L50-L52" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/meta/expr.nr#L50-L52</a></sub></sup>
+
+
+If this expression is a boolean literal, return that literal.
+
+### as_cast
+
+```rust title="as_cast" showLineNumbers 
+#[builtin(expr_as_cast)]
+    pub comptime fn as_cast(self) -> Option<(Expr, UnresolvedType)> {}
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/meta/expr.nr#L56-L59" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/meta/expr.nr#L56-L59</a></sub></sup>
+
+
+If this expression is a cast expression (`expr as type`), returns the casted
+expression and the type to cast to.
+
+### as_comptime
+
+```rust title="as_comptime" showLineNumbers 
+pub comptime fn as_comptime(self) -> Option<[Expr]> {}
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/meta/expr.nr#L64-L66" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/meta/expr.nr#L64-L66</a></sub></sup>
+
+
+If this expression is a `comptime { stmt1; stmt2; ...; stmtN }` block,
+return each statement in the block.
+
+### as_constructor
+
+```rust title="as_constructor" showLineNumbers 
+pub comptime fn as_constructor(self) -> Option<(UnresolvedType, [(Quoted, Expr)])> {}
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/meta/expr.nr#L71-L73" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/meta/expr.nr#L71-L73</a></sub></sup>
+
+
+If this expression is a constructor `Type { field1: expr1, ..., fieldN: exprN }`,
+return the type and the fields.
+
+### as_for
+
+```rust title="as_for" showLineNumbers 
+pub comptime fn as_for(self) -> Option<(Quoted, Expr, Expr)> {}
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/meta/expr.nr#L78-L80" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/meta/expr.nr#L78-L80</a></sub></sup>
+
+
+If this expression is a for statement over a single expression, return the identifier,
+the expression and the for loop body.
+
+### as_for_range
+
+```rust title="as_for" showLineNumbers 
+pub comptime fn as_for(self) -> Option<(Quoted, Expr, Expr)> {}
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/meta/expr.nr#L78-L80" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/meta/expr.nr#L78-L80</a></sub></sup>
+
+
+If this expression is a for statement over a range, return the identifier,
+the range start, the range end and the for loop body.
+
+### as_function_call
+
+```rust title="as_function_call" showLineNumbers 
+pub comptime fn as_function_call(self) -> Option<(Expr, [Expr])> {}
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/meta/expr.nr#L92-L94" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/meta/expr.nr#L92-L94</a></sub></sup>
+
+
+If this expression is a function call `foo(arg1, ..., argN)`, return
+the function and a slice of each argument.
+
+### as_if
+
+```rust title="as_if" showLineNumbers 
+pub comptime fn as_if(self) -> Option<(Expr, Expr, Option<Expr>)> {}
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/meta/expr.nr#L100-L102" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/meta/expr.nr#L100-L102</a></sub></sup>
+
+
+If this expression is an `if condition { then_branch } else { else_branch }`,
+return the condition, then branch, and else branch. If there is no else branch,
+`None` is returned for that branch instead.
+
+### as_index
+
+```rust title="as_index" showLineNumbers 
+pub comptime fn as_index(self) -> Option<(Expr, Expr)> {}
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/meta/expr.nr#L107-L109" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/meta/expr.nr#L107-L109</a></sub></sup>
+
+
+If this expression is an index into an array `array[index]`, return the
+array and the index.
+
+### as_integer
+
+```rust title="as_integer" showLineNumbers 
+pub comptime fn as_integer(self) -> Option<(Field, bool)> {}
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/meta/expr.nr#L114-L116" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/meta/expr.nr#L114-L116</a></sub></sup>
+
+
+If this expression is an integer literal, return the integer as a field
+as well as whether the integer is negative (true) or not (false).
+
+### as_lambda
+
+```rust title="as_lambda" showLineNumbers 
+pub comptime fn as_lambda(
+        self,
+    ) -> Option<([(Expr, Option<UnresolvedType>)], Option<UnresolvedType>, Expr)> {}
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/meta/expr.nr#L120-L124" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/meta/expr.nr#L120-L124</a></sub></sup>
+
+
+If this expression is a lambda, returns the parameters, return type and body.
+
+### as_let
+
+```rust title="as_let" showLineNumbers 
+pub comptime fn as_let(self) -> Option<(Expr, Option<UnresolvedType>, Expr)> {}
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/meta/expr.nr#L129-L131" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/meta/expr.nr#L129-L131</a></sub></sup>
+
+
+If this expression is a let statement, returns the let pattern as an `Expr`,
+the optional type annotation, and the assigned expression.
+
+### as_member_access
+
+```rust title="as_member_access" showLineNumbers 
+pub comptime fn as_member_access(self) -> Option<(Expr, Quoted)> {}
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/meta/expr.nr#L136-L138" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/meta/expr.nr#L136-L138</a></sub></sup>
+
+
+If this expression is a member access `foo.bar`, return the struct/tuple
+expression and the field. The field will be represented as a quoted value.
+
+### as_method_call
+
+```rust title="as_method_call" showLineNumbers 
+pub comptime fn as_method_call(self) -> Option<(Expr, Quoted, [UnresolvedType], [Expr])> {}
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/meta/expr.nr#L143-L145" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/meta/expr.nr#L143-L145</a></sub></sup>
+
+
+If this expression is a method call `foo.bar::<generic1, ..., genericM>(arg1, ..., argN)`, return
+the receiver, method name, a slice of each generic argument, and a slice of each argument.
+
+### as_repeated_element_array
+
+```rust title="as_repeated_element_array" showLineNumbers 
+pub comptime fn as_repeated_element_array(self) -> Option<(Expr, Expr)> {}
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/meta/expr.nr#L150-L152" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/meta/expr.nr#L150-L152</a></sub></sup>
+
+
+If this expression is a repeated element array `[elem; length]`, return
+the repeated element and the length expressions.
+
+### as_repeated_element_slice
+
+```rust title="as_repeated_element_slice" showLineNumbers 
+pub comptime fn as_repeated_element_slice(self) -> Option<(Expr, Expr)> {}
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/meta/expr.nr#L157-L159" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/meta/expr.nr#L157-L159</a></sub></sup>
+
+
+If this expression is a repeated element slice `[elem; length]`, return
+the repeated element and the length expressions.
+
+### as_slice
+
+```rust title="as_slice" showLineNumbers 
+pub comptime fn as_slice(self) -> Option<[Expr]> {}
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/meta/expr.nr#L164-L166" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/meta/expr.nr#L164-L166</a></sub></sup>
+
+
+If this expression is a slice literal `&[elem1, ..., elemN]`,
+return each element of the slice.
+
+### as_tuple
+
+```rust title="as_tuple" showLineNumbers 
+pub comptime fn as_tuple(self) -> Option<[Expr]> {}
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/meta/expr.nr#L171-L173" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/meta/expr.nr#L171-L173</a></sub></sup>
+
+
+If this expression is a tuple `(field1, ..., fieldN)`,
+return each element of the tuple.
+
+### as_unary_op
+
+```rust title="as_unary_op" showLineNumbers 
+pub comptime fn as_unary_op(self) -> Option<(UnaryOp, Expr)> {}
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/meta/expr.nr#L178-L180" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/meta/expr.nr#L178-L180</a></sub></sup>
+
+
+If this expression is a unary operation `<op> <rhs>`,
+return the unary operator as well as the right-hand side expression.
+
+### as_unsafe
+
+```rust title="as_unsafe" showLineNumbers 
+pub comptime fn as_unsafe(self) -> Option<[Expr]> {}
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/meta/expr.nr#L185-L187" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/meta/expr.nr#L185-L187</a></sub></sup>
+
+
+If this expression is an `unsafe { stmt1; ...; stmtN }` block,
+return each statement inside in a slice.
+
+### has_semicolon
+
+```rust title="has_semicolon" showLineNumbers 
+pub comptime fn has_semicolon(self) -> bool {}
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/meta/expr.nr#L206-L208" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/meta/expr.nr#L206-L208</a></sub></sup>
+
+
+`true` if this expression is trailed by a semicolon. E.g.
+
+```
+comptime {
+    let expr1 = quote { 1 + 2 }.as_expr().unwrap();
+    let expr2 = quote { 1 + 2; }.as_expr().unwrap();
+
+    assert(expr1.as_binary_op().is_some());
+    assert(expr2.as_binary_op().is_some());
+
+    assert(!expr1.has_semicolon());
+    assert(expr2.has_semicolon());
+}
+```
+
+### is_break
+
+```rust title="is_break" showLineNumbers 
+pub comptime fn is_break(self) -> bool {}
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/meta/expr.nr#L212-L214" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/meta/expr.nr#L212-L214</a></sub></sup>
+
+
+`true` if this expression is `break`.
+
+### is_continue
+
+```rust title="is_continue" showLineNumbers 
+pub comptime fn is_continue(self) -> bool {}
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/meta/expr.nr#L218-L220" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/meta/expr.nr#L218-L220</a></sub></sup>
+
+
+`true` if this expression is `continue`.
+
+### modify
+
+```rust title="modify" showLineNumbers 
+pub comptime fn modify<Env>(self, f: fn[Env](Expr) -> Option<Expr>) -> Expr {
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/meta/expr.nr#L229-L231" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/meta/expr.nr#L229-L231</a></sub></sup>
+
+
+Applies a mapping function to this expression and to all of its sub-expressions.
+`f` will be applied to each sub-expression first, then applied to the expression itself.
+
+This happens recursively for every expression within `self`.
+
+For example, calling `modify` on `(&[1], &[2, 3])` with an `f` that returns `Option::some`
+for expressions that are integers, doubling them, would return `(&[2], &[4, 6])`.
+
+### quoted
+
+```rust title="quoted" showLineNumbers 
+pub comptime fn quoted(self) -> Quoted {
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/meta/expr.nr#L266-L268" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/meta/expr.nr#L266-L268</a></sub></sup>
+
+
+Returns this expression as a `Quoted` value. It's the same as `quote { $self }`.
+
+### resolve
+
+```rust title="resolve" showLineNumbers 
+pub comptime fn resolve(self, in_function: Option<FunctionDefinition>) -> TypedExpr {}
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/meta/expr.nr#L282-L284" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/meta/expr.nr#L282-L284</a></sub></sup>
+
+
+Resolves and type-checks this expression and returns the result as a `TypedExpr`. 
+
+The `in_function` argument specifies where the expression is resolved:
+- If it's `none`, the expression is resolved in the function where `resolve` was called
+- If it's `some`, the expression is resolved in the given function
+
+If any names used by this expression are not in scope or if there are any type errors, 
+this will give compiler errors as if the expression was written directly into 
+the current `comptime` function.
\ No newline at end of file
diff --git a/docs/versioned_docs/version-v0.36.0/noir/standard_library/meta/function_def.md b/docs/versioned_docs/version-v0.36.0/noir/standard_library/meta/function_def.md
new file mode 100644
index 00000000000..b7f2ebdb889
--- /dev/null
+++ b/docs/versioned_docs/version-v0.36.0/noir/standard_library/meta/function_def.md
@@ -0,0 +1,166 @@
+---
+title: FunctionDefinition
+---
+
+`std::meta::function_def` contains methods on the built-in `FunctionDefinition` type representing
+a function definition in the source program.
+
+## Methods
+
+### add_attribute
+
+```rust title="add_attribute" showLineNumbers 
+pub comptime fn add_attribute<let N: u32>(self, attribute: str<N>) {}
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/meta/function_def.nr#L3-L5" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/meta/function_def.nr#L3-L5</a></sub></sup>
+
+
+Adds an attribute to the function. This is only valid
+on functions in the current crate which have not yet been resolved.
+This means any functions called at compile-time are invalid targets for this method.
+
+### body
+
+```rust title="body" showLineNumbers 
+pub comptime fn body(self) -> Expr {}
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/meta/function_def.nr#L8-L10" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/meta/function_def.nr#L8-L10</a></sub></sup>
+
+
+Returns the body of the function as an expression. This is only valid
+on functions in the current crate which have not yet been resolved.
+This means any functions called at compile-time are invalid targets for this method.
+
+### has_named_attribute
+
+```rust title="has_named_attribute" showLineNumbers 
+pub comptime fn has_named_attribute<let N: u32>(self, name: str<N>) -> bool {}
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/meta/function_def.nr#L13-L15" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/meta/function_def.nr#L13-L15</a></sub></sup>
+
+
+Returns true if this function has a custom attribute with the given name.
+
+### is_unconstrained
+
+```rust title="is_unconstrained" showLineNumbers 
+pub comptime fn is_unconstrained(self) -> bool {}
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/meta/function_def.nr#L18-L20" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/meta/function_def.nr#L18-L20</a></sub></sup>
+
+
+Returns true if this function is unconstrained.
+
+### module
+
+```rust title="module" showLineNumbers 
+pub comptime fn module(self) -> Module {}
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/meta/function_def.nr#L23-L25" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/meta/function_def.nr#L23-L25</a></sub></sup>
+
+
+Returns the module where the function is defined.
+
+### name
+
+```rust title="name" showLineNumbers 
+pub comptime fn name(self) -> Quoted {}
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/meta/function_def.nr#L28-L30" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/meta/function_def.nr#L28-L30</a></sub></sup>
+
+
+Returns the name of the function.
+
+### parameters
+
+```rust title="parameters" showLineNumbers 
+pub comptime fn parameters(self) -> [(Quoted, Type)] {}
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/meta/function_def.nr#L33-L35" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/meta/function_def.nr#L33-L35</a></sub></sup>
+
+
+Returns each parameter of the function as a tuple of (parameter pattern, parameter type).
+
+### return_type
+
+```rust title="return_type" showLineNumbers 
+pub comptime fn return_type(self) -> Type {}
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/meta/function_def.nr#L38-L40" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/meta/function_def.nr#L38-L40</a></sub></sup>
+
+
+The return type of the function.
+
+### set_body
+
+```rust title="set_body" showLineNumbers 
+pub comptime fn set_body(self, body: Expr) {}
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/meta/function_def.nr#L43-L45" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/meta/function_def.nr#L43-L45</a></sub></sup>
+
+
+Mutate the function body to a new expression. This is only valid
+on functions in the current crate which have not yet been resolved.
+This means any functions called at compile-time are invalid targets for this method.
+
+### set_parameters
+
+```rust title="set_parameters" showLineNumbers 
+pub comptime fn set_parameters(self, parameters: [(Quoted, Type)]) {}
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/meta/function_def.nr#L48-L50" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/meta/function_def.nr#L48-L50</a></sub></sup>
+
+
+Mutates the function's parameters to a new set of parameters. This is only valid
+on functions in the current crate which have not yet been resolved.
+This means any functions called at compile-time are invalid targets for this method.
+
+Expects a slice of (parameter pattern, parameter type) for each parameter. Requires
+each parameter pattern to be a syntactically valid parameter.
+
+### set_return_type
+
+```rust title="set_return_type" showLineNumbers 
+pub comptime fn set_return_type(self, return_type: Type) {}
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/meta/function_def.nr#L53-L55" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/meta/function_def.nr#L53-L55</a></sub></sup>
+
+
+Mutates the function's return type to a new type. This is only valid
+on functions in the current crate which have not yet been resolved.
+This means any functions called at compile-time are invalid targets for this method.
+
+### set_return_public
+
+```rust title="set_return_public" showLineNumbers 
+pub comptime fn set_return_public(self, public: bool) {}
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/meta/function_def.nr#L58-L60" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/meta/function_def.nr#L58-L60</a></sub></sup>
+
+
+Mutates the function's return visibility to public (if `true` is given) or private (if `false` is given).
+This is only valid on functions in the current crate which have not yet been resolved.
+This means any functions called at compile-time are invalid targets for this method.
+
+### set_unconstrained
+
+```rust title="set_unconstrained" showLineNumbers 
+pub comptime fn set_unconstrained(self, value: bool) {}
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/meta/function_def.nr#L66-L68" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/meta/function_def.nr#L66-L68</a></sub></sup>
+
+
+Mutates the function to be unconstrained (if `true` is given) or not (if `false` is given).
+This is only valid on functions in the current crate which have not yet been resolved.
+This means any functions called at compile-time are invalid targets for this method.
+
+## Trait Implementations
+
+```rust
+impl Eq for FunctionDefinition
+impl Hash for FunctionDefinition
+```
+
+Note that each function is assigned a unique ID internally and this is what is used for
+equality and hashing. So even functions with identical signatures and bodies may not
+be equal in this sense if they were originally different items in the source program.
diff --git a/docs/versioned_docs/version-v0.36.0/noir/standard_library/meta/index.md b/docs/versioned_docs/version-v0.36.0/noir/standard_library/meta/index.md
new file mode 100644
index 00000000000..65572d5e815
--- /dev/null
+++ b/docs/versioned_docs/version-v0.36.0/noir/standard_library/meta/index.md
@@ -0,0 +1,224 @@
+---
+title: Metaprogramming
+description: Noir's Metaprogramming API
+keywords: [metaprogramming, comptime, macros, macro, quote, unquote]
+---
+
+`std::meta` is the entry point for Noir's metaprogramming API. This consists of `comptime` functions
+and types used for inspecting and modifying Noir programs.
+
+## Functions
+
+### type_of
+
+```rust title="type_of" showLineNumbers 
+pub comptime fn type_of<T>(x: T) -> Type {}
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/meta/mod.nr#L27-L29" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/meta/mod.nr#L27-L29</a></sub></sup>
+
+
+Returns the type of a variable at compile-time.
+
+Example:
+```rust
+comptime {
+    let x: i32 = 1;
+    let x_type: Type = std::meta::type_of(x);
+
+    assert_eq(x_type, quote { i32 }.as_type());
+}
+```
+
+### unquote
+
+```rust title="unquote" showLineNumbers 
+pub comptime fn unquote(code: Quoted) -> Quoted {
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/meta/mod.nr#L19-L21" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/meta/mod.nr#L19-L21</a></sub></sup>
+
+
+Unquotes the passed-in token stream where this function was called.
+
+Example:
+```rust
+comptime {
+    let code = quote { 1 + 2 };
+
+    // let x = 1 + 2;
+    let x = unquote!(code);
+}
+```
+
+### derive
+
+```rust title="derive" showLineNumbers 
+#[varargs]
+pub comptime fn derive(s: StructDefinition, traits: [TraitDefinition]) -> Quoted {
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/meta/mod.nr#L48-L51" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/meta/mod.nr#L48-L51</a></sub></sup>
+
+
+Attribute placed on struct definitions.
+
+Creates a trait impl for each trait passed in as an argument.
+To do this, the trait must have a derive handler registered
+with `derive_via` beforehand. The traits in the stdlib that
+can be derived this way are `Eq`, `Ord`, `Default`, and `Hash`.
+
+Example:
+```rust
+#[derive(Eq, Default)]
+struct Foo<T> {
+    x: i32,
+    y: T,
+}
+
+fn main() {
+    let foo1 = Foo::default();
+    let foo2 = Foo { x: 0, y: &[0] };
+    assert_eq(foo1, foo2);
+}
+```
+
+### derive_via
+
+```rust title="derive_via_signature" showLineNumbers 
+pub comptime fn derive_via(t: TraitDefinition, f: DeriveFunction) {
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/meta/mod.nr#L68-L70" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/meta/mod.nr#L68-L70</a></sub></sup>
+
+
+Attribute placed on trait definitions.
+
+Registers a function to create impls for the given trait
+when the trait is used in a `derive` call. Users may use
+this to register their own functions to enable their traits
+to be derived by `derive`.
+
+Because this function requires a function as an argument which
+should produce a trait impl for any given struct, users may find
+it helpful to use a function like `std::meta::make_trait_impl` to
+help creating these impls.
+
+Example:
+```rust
+#[derive_via(derive_do_nothing)]
+trait DoNothing {
+    fn do_nothing(self);
+}
+
+comptime fn derive_do_nothing(s: StructDefinition) -> Quoted {
+    let typ = s.as_type();
+    quote {
+        impl DoNothing for $typ {
+            fn do_nothing(self) {
+                println("Nothing");
+            }
+        }
+    }
+}
+```
+
+As another example, `derive_eq` in the stdlib is used to derive the `Eq`
+trait for any struct. It makes use of `make_trait_impl` to do this:
+
+```rust title="derive_eq" showLineNumbers 
+comptime fn derive_eq(s: StructDefinition) -> Quoted {
+    let signature = quote { fn eq(_self: Self, _other: Self) -> bool };
+    let for_each_field = |name| quote { (_self.$name == _other.$name) };
+    let body = |fields| {
+        if s.fields().len() == 0 {
+            quote { true }
+        } else {
+            fields
+        }
+    };
+    crate::meta::make_trait_impl(
+        s,
+        quote { Eq },
+        signature,
+        for_each_field,
+        quote { & },
+        body,
+    )
+}
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/cmp.nr#L10-L30" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/cmp.nr#L10-L30</a></sub></sup>
+
+
+### make_trait_impl
+
+```rust title="make_trait_impl" showLineNumbers 
+pub comptime fn make_trait_impl<Env1, Env2>(
+    s: StructDefinition,
+    trait_name: Quoted,
+    function_signature: Quoted,
+    for_each_field: fn[Env1](Quoted) -> Quoted,
+    join_fields_with: Quoted,
+    body: fn[Env2](Quoted) -> Quoted,
+) -> Quoted {
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/meta/mod.nr#L87-L96" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/meta/mod.nr#L87-L96</a></sub></sup>
+
+
+A helper function to more easily create trait impls while deriving traits.
+
+Note that this function only works for traits which:
+1. Have only one method
+2. Have no generics on the trait itself.
+  - E.g. Using this on a trait such as `trait Foo<T> { ... }` will result in the
+    generated impl incorrectly missing the `T` generic.
+
+If your trait fits these criteria then `make_trait_impl` is likely the easiest
+way to write your derive handler. The arguments are as follows:
+
+- `s`: The struct to make the impl for
+- `trait_name`: The name of the trait to derive. E.g. `quote { Eq }`.
+- `function_signature`: The signature of the trait method to derive. E.g. `fn eq(self, other: Self) -> bool`.
+- `for_each_field`: An operation to be performed on each field. E.g. `|name| quote { (self.$name == other.$name) }`.
+- `join_fields_with`: A separator to join each result of `for_each_field` with.
+  E.g. `quote { & }`. You can also use an empty `quote {}` for no separator.
+- `body`: The result of the field operations are passed into this function for any final processing.
+  This is the place to insert any setup/teardown code the trait requires. If the trait doesn't require
+  any such code, you can return the body as-is: `|body| body`.
+
+Example deriving `Hash`:
+
+```rust title="derive_hash" showLineNumbers 
+comptime fn derive_hash(s: StructDefinition) -> Quoted {
+    let name = quote { Hash };
+    let signature = quote { fn hash<H>(_self: Self, _state: &mut H) where H: std::hash::Hasher };
+    let for_each_field = |name| quote { _self.$name.hash(_state); };
+    crate::meta::make_trait_impl(
+        s,
+        name,
+        signature,
+        for_each_field,
+        quote {},
+        |fields| fields,
+    )
+}
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/hash/mod.nr#L138-L152" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/hash/mod.nr#L138-L152</a></sub></sup>
+
+
+Example deriving `Ord`:
+
+```rust title="derive_ord" showLineNumbers 
+comptime fn derive_ord(s: StructDefinition) -> Quoted {
+    let signature = quote { fn cmp(_self: Self, _other: Self) -> std::cmp::Ordering };
+    let for_each_field = |name| quote {
+        if result == std::cmp::Ordering::equal() {
+            result = _self.$name.cmp(_other.$name);
+        }
+    };
+    let body = |fields| quote {
+        let mut result = std::cmp::Ordering::equal();
+        $fields
+        result
+    };
+    crate::meta::make_trait_impl(s, quote { Ord }, signature, for_each_field, quote {}, body)
+}
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/cmp.nr#L216-L231" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/cmp.nr#L216-L231</a></sub></sup>
+
diff --git a/docs/versioned_docs/version-v0.36.0/noir/standard_library/meta/module.md b/docs/versioned_docs/version-v0.36.0/noir/standard_library/meta/module.md
new file mode 100644
index 00000000000..f47231972b7
--- /dev/null
+++ b/docs/versioned_docs/version-v0.36.0/noir/standard_library/meta/module.md
@@ -0,0 +1,82 @@
+---
+title: Module
+---
+
+`std::meta::module` contains methods on the built-in `Module` type which represents a module in the source program.
+Note that this type represents a module generally, it isn't limited to only `mod my_submodule { ... }`
+declarations in the source program.
+
+## Methods
+
+### add_item
+
+```rust title="add_item" showLineNumbers 
+pub comptime fn add_item(self, item: Quoted) {}
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/meta/module.nr#L3-L5" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/meta/module.nr#L3-L5</a></sub></sup>
+
+
+Adds a top-level item (a function, a struct, a global, etc.) to the module. 
+Adding multiple items in one go is also valid if the `Quoted` value has multiple items in it.  
+Note that the items are type-checked as if they are inside the module they are being added to.
+
+### functions
+
+```rust title="functions" showLineNumbers 
+pub comptime fn functions(self) -> [FunctionDefinition] {}
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/meta/module.nr#L18-L20" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/meta/module.nr#L18-L20</a></sub></sup>
+
+
+Returns each function defined in the module.
+
+### has_named_attribute
+
+```rust title="has_named_attribute" showLineNumbers 
+pub comptime fn has_named_attribute<let N: u32>(self, name: str<N>) -> bool {}
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/meta/module.nr#L8-L10" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/meta/module.nr#L8-L10</a></sub></sup>
+
+
+Returns true if this module has a custom attribute with the given name.
+
+### is_contract
+
+```rust title="is_contract" showLineNumbers 
+pub comptime fn is_contract(self) -> bool {}
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/meta/module.nr#L13-L15" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/meta/module.nr#L13-L15</a></sub></sup>
+
+
+`true` if this module is a contract module (was declared via `contract foo { ... }`).
+
+### name
+
+```rust title="name" showLineNumbers 
+pub comptime fn name(self) -> Quoted {}
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/meta/module.nr#L28-L30" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/meta/module.nr#L28-L30</a></sub></sup>
+
+
+Returns the name of the module.
+
+### structs
+
+```rust title="structs" showLineNumbers 
+pub comptime fn structs(self) -> [StructDefinition] {}
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/meta/module.nr#L23-L25" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/meta/module.nr#L23-L25</a></sub></sup>
+
+
+Returns each struct defined in the module.
+
+## Trait Implementations
+
+```rust
+impl Eq for Module
+impl Hash for Module
+```
+
+Note that each module is assigned a unique ID internally and this is what is used for
+equality and hashing. So even modules with identical names and contents may not
+be equal in this sense if they were originally different items in the source program.
diff --git a/docs/versioned_docs/version-v0.36.0/noir/standard_library/meta/op.md b/docs/versioned_docs/version-v0.36.0/noir/standard_library/meta/op.md
new file mode 100644
index 00000000000..03ea49ad8ec
--- /dev/null
+++ b/docs/versioned_docs/version-v0.36.0/noir/standard_library/meta/op.md
@@ -0,0 +1,244 @@
+---
+title: UnaryOp and BinaryOp
+---
+
+`std::meta::op` contains the `UnaryOp` and `BinaryOp` types as well as methods on them.
+These types are used to represent a unary or binary operator respectively in Noir source code.
+
+## Types
+
+### UnaryOp
+
+Represents a unary operator. One of `-`, `!`, `&mut`, or `*`.
+
+### Methods
+
+#### is_minus
+
+```rust title="is_minus" showLineNumbers 
+pub fn is_minus(self) -> bool {
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/meta/op.nr#L24-L26" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/meta/op.nr#L24-L26</a></sub></sup>
+
+
+Returns `true` if this operator is `-`.
+
+#### is_not
+
+```rust title="is_not" showLineNumbers 
+pub fn is_not(self) -> bool {
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/meta/op.nr#L30-L32" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/meta/op.nr#L30-L32</a></sub></sup>
+
+
+`true` if this operator is `!`
+
+#### is_mutable_reference
+
+```rust title="is_mutable_reference" showLineNumbers 
+pub fn is_mutable_reference(self) -> bool {
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/meta/op.nr#L36-L38" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/meta/op.nr#L36-L38</a></sub></sup>
+
+
+`true` if this operator is `&mut`
+
+#### is_dereference
+
+```rust title="is_dereference" showLineNumbers 
+pub fn is_dereference(self) -> bool {
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/meta/op.nr#L42-L44" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/meta/op.nr#L42-L44</a></sub></sup>
+
+
+`true` if this operator is `*`
+
+#### quoted
+
+```rust title="unary_quoted" showLineNumbers 
+pub comptime fn quoted(self) -> Quoted {
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/meta/op.nr#L48-L50" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/meta/op.nr#L48-L50</a></sub></sup>
+
+
+Returns this operator as a `Quoted` value.
+
+### Trait Implementations
+
+```rust
+impl Eq for UnaryOp
+impl Hash for UnaryOp
+```
+
+### BinaryOp
+
+Represents a binary operator. One of `+`, `-`, `*`, `/`, `%`, `==`, `!=`, `<`, `<=`, `>`, `>=`, `&`, `|`, `^`, `>>`, or `<<`.
+
+### Methods
+
+#### is_add
+
+```rust title="is_add" showLineNumbers 
+pub fn is_add(self) -> bool {
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/meta/op.nr#L86-L88" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/meta/op.nr#L86-L88</a></sub></sup>
+
+
+`true` if this operator is `+`
+
+#### is_subtract
+
+```rust title="is_subtract" showLineNumbers 
+pub fn is_subtract(self) -> bool {
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/meta/op.nr#L92-L94" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/meta/op.nr#L92-L94</a></sub></sup>
+
+
+`true` if this operator is `-`
+
+#### is_multiply
+
+```rust title="is_multiply" showLineNumbers 
+pub fn is_multiply(self) -> bool {
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/meta/op.nr#L98-L100" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/meta/op.nr#L98-L100</a></sub></sup>
+
+
+`true` if this operator is `*`
+
+#### is_divide
+
+```rust title="is_divide" showLineNumbers 
+pub fn is_divide(self) -> bool {
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/meta/op.nr#L104-L106" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/meta/op.nr#L104-L106</a></sub></sup>
+
+
+`true` if this operator is `/`
+
+#### is_modulo
+
+```rust title="is_modulo" showLineNumbers 
+pub fn is_modulo(self) -> bool {
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/meta/op.nr#L176-L178" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/meta/op.nr#L176-L178</a></sub></sup>
+
+
+`true` if this operator is `%`
+
+#### is_equal
+
+```rust title="is_equal" showLineNumbers 
+pub fn is_equal(self) -> bool {
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/meta/op.nr#L110-L112" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/meta/op.nr#L110-L112</a></sub></sup>
+
+
+`true` if this operator is `==`
+
+#### is_not_equal
+
+```rust title="is_not_equal" showLineNumbers 
+pub fn is_not_equal(self) -> bool {
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/meta/op.nr#L116-L118" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/meta/op.nr#L116-L118</a></sub></sup>
+
+
+`true` if this operator is `!=`
+
+#### is_less_than
+
+```rust title="is_less_than" showLineNumbers 
+pub fn is_less_than(self) -> bool {
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/meta/op.nr#L122-L124" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/meta/op.nr#L122-L124</a></sub></sup>
+
+
+`true` if this operator is `<`
+
+#### is_less_than_or_equal
+
+```rust title="is_less_than_or_equal" showLineNumbers 
+pub fn is_less_than_or_equal(self) -> bool {
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/meta/op.nr#L128-L130" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/meta/op.nr#L128-L130</a></sub></sup>
+
+
+`true` if this operator is `<=`
+
+#### is_greater_than
+
+```rust title="is_greater_than" showLineNumbers 
+pub fn is_greater_than(self) -> bool {
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/meta/op.nr#L134-L136" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/meta/op.nr#L134-L136</a></sub></sup>
+
+
+`true` if this operator is `>`
+
+#### is_greater_than_or_equal
+
+```rust title="is_greater_than_or_equal" showLineNumbers 
+pub fn is_greater_than_or_equal(self) -> bool {
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/meta/op.nr#L140-L142" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/meta/op.nr#L140-L142</a></sub></sup>
+
+
+`true` if this operator is `>=`
+
+#### is_and
+
+```rust title="is_and" showLineNumbers 
+pub fn is_and(self) -> bool {
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/meta/op.nr#L146-L148" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/meta/op.nr#L146-L148</a></sub></sup>
+
+
+`true` if this operator is `&`
+
+#### is_or
+
+```rust title="is_or" showLineNumbers 
+pub fn is_or(self) -> bool {
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/meta/op.nr#L152-L154" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/meta/op.nr#L152-L154</a></sub></sup>
+
+
+`true` if this operator is `|`
+
+#### is_shift_right
+
+```rust title="is_shift_right" showLineNumbers 
+pub fn is_shift_right(self) -> bool {
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/meta/op.nr#L164-L166" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/meta/op.nr#L164-L166</a></sub></sup>
+
+
+`true` if this operator is `>>`
+
+#### is_shift_left
+
+```rust title="is_shift_right" showLineNumbers 
+pub fn is_shift_right(self) -> bool {
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/meta/op.nr#L164-L166" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/meta/op.nr#L164-L166</a></sub></sup>
+
+
+`true` if this operator is `<<`
+
+#### quoted
+
+```rust title="binary_quoted" showLineNumbers 
+pub comptime fn quoted(self) -> Quoted {
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/meta/op.nr#L182-L184" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/meta/op.nr#L182-L184</a></sub></sup>
+
+
+Returns this operator as a `Quoted` value.
+
+### Trait Implementations
+
+```rust
+impl Eq for BinaryOp
+impl Hash for BinaryOp
+```
diff --git a/docs/versioned_docs/version-v0.36.0/noir/standard_library/meta/quoted.md b/docs/versioned_docs/version-v0.36.0/noir/standard_library/meta/quoted.md
new file mode 100644
index 00000000000..d7acf23bc07
--- /dev/null
+++ b/docs/versioned_docs/version-v0.36.0/noir/standard_library/meta/quoted.md
@@ -0,0 +1,141 @@
+---
+title: Quoted
+---
+
+`std::meta::quoted` contains methods on the built-in `Quoted` type which represents
+quoted token streams and is the result of the `quote { ... }` expression.
+
+## Methods
+
+### as_expr
+
+```rust title="as_expr" showLineNumbers 
+pub comptime fn as_expr(self) -> Option<Expr> {}
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/meta/quoted.nr#L6-L8" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/meta/quoted.nr#L6-L8</a></sub></sup>
+
+
+Parses the quoted token stream as an expression. Returns `Option::none()` if
+the expression failed to parse.
+
+Example:
+
+```rust title="as_expr_example" showLineNumbers 
+#[test]
+    fn test_expr_as_function_call() {
+        comptime
+        {
+            let expr = quote { foo(42) }.as_expr().unwrap();
+            let (_function, args) = expr.as_function_call().unwrap();
+            assert_eq(args.len(), 1);
+            assert_eq(args[0].as_integer().unwrap(), (42, false));
+        }
+    }
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/test_programs/noir_test_success/comptime_expr/src/main.nr#L360-L371" target="_blank" rel="noopener noreferrer">Source code: test_programs/noir_test_success/comptime_expr/src/main.nr#L360-L371</a></sub></sup>
+
+
+### as_module
+
+```rust title="as_module" showLineNumbers 
+pub comptime fn as_module(self) -> Option<Module> {}
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/meta/quoted.nr#L11-L13" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/meta/quoted.nr#L11-L13</a></sub></sup>
+
+
+Interprets this token stream as a module path leading to the name of a module.
+Returns `Option::none()` if the module isn't found or this token stream cannot be parsed as a path.
+
+Example:
+
+```rust title="as_module_example" showLineNumbers 
+mod baz {
+    pub mod qux {}
+}
+
+#[test]
+fn as_module_test() {
+    comptime {
+        let my_mod = quote { baz::qux }.as_module().unwrap();
+        assert_eq(my_mod.name(), quote { qux });
+    }
+}
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/test_programs/compile_success_empty/comptime_module/src/main.nr#L115-L127" target="_blank" rel="noopener noreferrer">Source code: test_programs/compile_success_empty/comptime_module/src/main.nr#L115-L127</a></sub></sup>
+
+
+### as_trait_constraint
+
+```rust title="as_trait_constraint" showLineNumbers 
+pub comptime fn as_trait_constraint(self) -> TraitConstraint {}
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/meta/quoted.nr#L16-L18" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/meta/quoted.nr#L16-L18</a></sub></sup>
+
+
+Interprets this token stream as a trait constraint (without an object type).
+Note that this function panics instead of returning `Option::none()` if the token
+stream does not parse and resolve to a valid trait constraint.
+
+Example:
+
+```rust title="implements_example" showLineNumbers 
+pub fn function_with_where<T>(_x: T)
+where
+    T: SomeTrait<i32>,
+{
+    comptime {
+        let t = quote { T }.as_type();
+        let some_trait_i32 = quote { SomeTrait<i32> }.as_trait_constraint();
+        assert(t.implements(some_trait_i32));
+
+        assert(t.get_trait_impl(some_trait_i32).is_none());
+    }
+}
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/test_programs/compile_success_empty/comptime_type/src/main.nr#L160-L173" target="_blank" rel="noopener noreferrer">Source code: test_programs/compile_success_empty/comptime_type/src/main.nr#L160-L173</a></sub></sup>
+
+
+### as_type
+
+```rust title="as_type" showLineNumbers 
+pub comptime fn as_type(self) -> Type {}
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/meta/quoted.nr#L21-L23" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/meta/quoted.nr#L21-L23</a></sub></sup>
+
+
+Interprets this token stream as a resolved type. Panics if the token
+stream doesn't parse to a type or if the type isn't a valid type in scope.
+
+```rust title="implements_example" showLineNumbers 
+pub fn function_with_where<T>(_x: T)
+where
+    T: SomeTrait<i32>,
+{
+    comptime {
+        let t = quote { T }.as_type();
+        let some_trait_i32 = quote { SomeTrait<i32> }.as_trait_constraint();
+        assert(t.implements(some_trait_i32));
+
+        assert(t.get_trait_impl(some_trait_i32).is_none());
+    }
+}
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/test_programs/compile_success_empty/comptime_type/src/main.nr#L160-L173" target="_blank" rel="noopener noreferrer">Source code: test_programs/compile_success_empty/comptime_type/src/main.nr#L160-L173</a></sub></sup>
+
+
+### tokens
+
+```rust title="tokens" showLineNumbers 
+pub comptime fn tokens(self) -> [Quoted] {}
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/meta/quoted.nr#L26-L28" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/meta/quoted.nr#L26-L28</a></sub></sup>
+
+
+Returns a slice of the individual tokens that form this token stream.
+
+## Trait Implementations
+
+```rust
+impl Eq for Quoted
+impl Hash for Quoted
+```
diff --git a/docs/versioned_docs/version-v0.36.0/noir/standard_library/meta/struct_def.md b/docs/versioned_docs/version-v0.36.0/noir/standard_library/meta/struct_def.md
new file mode 100644
index 00000000000..fd609942f4e
--- /dev/null
+++ b/docs/versioned_docs/version-v0.36.0/noir/standard_library/meta/struct_def.md
@@ -0,0 +1,177 @@
+---
+title: StructDefinition
+---
+
+`std::meta::struct_def` contains methods on the built-in `StructDefinition` type.
+This type corresponds to `struct Name { field1: Type1, ... }` items in the source program.
+
+## Methods
+
+### add_attribute
+
+```rust title="add_attribute" showLineNumbers 
+pub comptime fn add_attribute<let N: u32>(self, attribute: str<N>) {}
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/meta/struct_def.nr#L3-L5" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/meta/struct_def.nr#L3-L5</a></sub></sup>
+
+
+Adds an attribute to the struct.
+
+### add_generic
+
+```rust title="add_generic" showLineNumbers 
+pub comptime fn add_generic<let N: u32>(self, generic_name: str<N>) -> Type {}
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/meta/struct_def.nr#L8-L10" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/meta/struct_def.nr#L8-L10</a></sub></sup>
+
+
+Adds an generic to the struct. Returns the new generic type.
+Errors if the given generic name isn't a single identifier or if
+the struct already has a generic with the same name.
+
+This method should be used carefully, if there is existing code referring
+to the struct type it may be checked before this function is called and
+see the struct with the original number of generics. This method should
+thus be preferred to use on code generated from other macros and structs
+that are not used in function signatures.
+
+Example:
+
+```rust title="add-generic-example" showLineNumbers 
+comptime fn add_generic(s: StructDefinition) {
+        assert_eq(s.generics().len(), 0);
+        let new_generic = s.add_generic("T");
+
+        let generics = s.generics();
+        assert_eq(generics.len(), 1);
+        assert_eq(generics[0], new_generic);
+    }
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/test_programs/compile_success_empty/comptime_struct_definition/src/main.nr#L35-L44" target="_blank" rel="noopener noreferrer">Source code: test_programs/compile_success_empty/comptime_struct_definition/src/main.nr#L35-L44</a></sub></sup>
+
+
+### as_type
+
+```rust title="as_type" showLineNumbers 
+pub comptime fn as_type(self) -> Type {}
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/meta/struct_def.nr#L15-L17" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/meta/struct_def.nr#L15-L17</a></sub></sup>
+
+
+Returns this struct as a type in the source program. If this struct has
+any generics, the generics are also included as-is.
+
+### generics
+
+```rust title="generics" showLineNumbers 
+pub comptime fn generics(self) -> [Type] {}
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/meta/struct_def.nr#L26-L28" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/meta/struct_def.nr#L26-L28</a></sub></sup>
+
+
+Returns each generic on this struct.
+
+Example:
+
+```
+#[example]
+struct Foo<T, U> {
+    bar: [T; 2],
+    baz: Baz<U, U>,
+}
+
+comptime fn example(foo: StructDefinition) {
+    assert_eq(foo.generics().len(), 2);
+
+    // Fails because `T` isn't in scope
+    // let t = quote { T }.as_type();
+    // assert_eq(foo.generics()[0], t);
+}
+```
+
+### fields
+
+```rust title="fields" showLineNumbers 
+pub comptime fn fields(self) -> [(Quoted, Type)] {}
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/meta/struct_def.nr#L33-L35" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/meta/struct_def.nr#L33-L35</a></sub></sup>
+
+
+Returns each field of this struct as a pair of (field name, field type).
+
+### has_named_attribute
+
+```rust title="has_named_attribute" showLineNumbers 
+pub comptime fn has_named_attribute<let N: u32>(self, name: str<N>) -> bool {}
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/meta/struct_def.nr#L20-L22" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/meta/struct_def.nr#L20-L22</a></sub></sup>
+
+
+Returns true if this struct has a custom attribute with the given name.
+
+### module
+
+```rust title="module" showLineNumbers 
+pub comptime fn module(self) -> Module {}
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/meta/struct_def.nr#L38-L40" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/meta/struct_def.nr#L38-L40</a></sub></sup>
+
+
+Returns the module where the struct is defined.
+
+### name
+
+```rust title="name" showLineNumbers 
+pub comptime fn name(self) -> Quoted {}
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/meta/struct_def.nr#L43-L45" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/meta/struct_def.nr#L43-L45</a></sub></sup>
+
+
+Returns the name of this struct
+
+Note that the returned quoted value will be just the struct name, it will
+not be the full path to the struct, nor will it include any generics.
+
+### set_fields
+
+```rust title="set_fields" showLineNumbers 
+pub comptime fn set_fields(self, new_fields: [(Quoted, Type)]) {}
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/meta/struct_def.nr#L52-L54" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/meta/struct_def.nr#L52-L54</a></sub></sup>
+
+
+Sets the fields of this struct to the given fields list where each element
+is a pair of the field's name and the field's type. Expects each field name
+to be a single identifier. Note that this will override any previous fields
+on this struct. If those should be preserved, use `.fields()` to retrieve the
+current fields on the struct type and append the new fields from there.
+
+Example:
+
+```rust
+// Change this struct to:
+// struct Foo {
+//     a: u32,
+//     b: i8,
+// }
+#[mangle_fields]
+struct Foo { x: Field }
+
+comptime fn mangle_fields(s: StructDefinition) {
+    s.set_fields(&[
+        (quote { a }, quote { u32 }.as_type()),
+        (quote { b }, quote { i8 }.as_type()),
+    ]);
+}
+```
+
+## Trait Implementations
+
+```rust
+impl Eq for StructDefinition
+impl Hash for StructDefinition
+```
+
+Note that each struct is assigned a unique ID internally and this is what is used for
+equality and hashing. So even structs with identical generics and fields may not
+be equal in this sense if they were originally different items in the source program.
diff --git a/docs/versioned_docs/version-v0.36.0/noir/standard_library/meta/trait_constraint.md b/docs/versioned_docs/version-v0.36.0/noir/standard_library/meta/trait_constraint.md
new file mode 100644
index 00000000000..3106f732b5a
--- /dev/null
+++ b/docs/versioned_docs/version-v0.36.0/noir/standard_library/meta/trait_constraint.md
@@ -0,0 +1,17 @@
+---
+title: TraitConstraint
+---
+
+`std::meta::trait_constraint` contains methods on the built-in `TraitConstraint` type which represents
+a trait constraint that can be used to search for a trait implementation. This is similar
+syntactically to just the trait itself, but can also contain generic arguments. E.g. `Eq`, `Default`,
+`BuildHasher<Poseidon2Hasher>`.
+
+This type currently has no public methods but it can be used alongside `Type` in `implements` or `get_trait_impl`.
+
+## Trait Implementations
+
+```rust
+impl Eq for TraitConstraint
+impl Hash for TraitConstraint
+```
diff --git a/docs/versioned_docs/version-v0.36.0/noir/standard_library/meta/trait_def.md b/docs/versioned_docs/version-v0.36.0/noir/standard_library/meta/trait_def.md
new file mode 100644
index 00000000000..e661d3af7f1
--- /dev/null
+++ b/docs/versioned_docs/version-v0.36.0/noir/standard_library/meta/trait_def.md
@@ -0,0 +1,26 @@
+---
+title: TraitDefinition
+---
+
+`std::meta::trait_def` contains methods on the built-in `TraitDefinition` type. This type
+represents trait definitions such as `trait Foo { .. }` at the top-level of a program.
+
+## Methods
+
+### as_trait_constraint
+
+```rust title="as_trait_constraint" showLineNumbers 
+pub comptime fn as_trait_constraint(_self: Self) -> TraitConstraint {}
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/meta/trait_def.nr#L6-L8" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/meta/trait_def.nr#L6-L8</a></sub></sup>
+
+
+Converts this trait into a trait constraint. If there are any generics on this
+trait, they will be kept as-is without instantiating or replacing them.
+
+## Trait Implementations
+
+```rust
+impl Eq for TraitDefinition
+impl Hash for TraitDefinition
+```
diff --git a/docs/versioned_docs/version-v0.36.0/noir/standard_library/meta/trait_impl.md b/docs/versioned_docs/version-v0.36.0/noir/standard_library/meta/trait_impl.md
new file mode 100644
index 00000000000..a527617c1e6
--- /dev/null
+++ b/docs/versioned_docs/version-v0.36.0/noir/standard_library/meta/trait_impl.md
@@ -0,0 +1,60 @@
+---
+title: TraitImpl
+---
+
+`std::meta::trait_impl` contains methods on the built-in `TraitImpl` type which represents a trait
+implementation such as `impl Foo for Bar { ... }`.
+
+## Methods
+
+### trait_generic_args
+
+```rust title="trait_generic_args" showLineNumbers 
+pub comptime fn trait_generic_args(self) -> [Type] {}
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/meta/trait_impl.nr#L3-L5" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/meta/trait_impl.nr#L3-L5</a></sub></sup>
+
+
+Returns any generic arguments on the trait of this trait implementation, if any.
+
+```rs
+impl Foo<i32, Field> for Bar { ... }
+
+comptime {
+    let bar_type = quote { Bar }.as_type();
+    let foo = quote { Foo<i32, Field> }.as_trait_constraint();
+
+    let my_impl: TraitImpl = bar_type.get_trait_impl(foo).unwrap();
+
+    let generics = my_impl.trait_generic_args();
+    assert_eq(generics.len(), 2);
+
+    assert_eq(generics[0], quote { i32 }.as_type());
+    assert_eq(generics[1], quote { Field }.as_type());
+}
+```
+
+### methods
+
+```rust title="methods" showLineNumbers 
+pub comptime fn methods(self) -> [FunctionDefinition] {}
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/meta/trait_impl.nr#L8-L10" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/meta/trait_impl.nr#L8-L10</a></sub></sup>
+
+
+Returns each method in this trait impl.
+
+Example:
+
+```rs
+comptime {
+    let i32_type = quote { i32 }.as_type();
+    let eq = quote { Eq }.as_trait_constraint();
+
+    let impl_eq_for_i32: TraitImpl = i32_type.get_trait_impl(eq).unwrap();
+    let methods = impl_eq_for_i32.methods();
+
+    assert_eq(methods.len(), 1);
+    assert_eq(methods[0].name(), quote { eq });
+}
+```
diff --git a/docs/versioned_docs/version-v0.36.0/noir/standard_library/meta/typ.md b/docs/versioned_docs/version-v0.36.0/noir/standard_library/meta/typ.md
new file mode 100644
index 00000000000..90222c222f5
--- /dev/null
+++ b/docs/versioned_docs/version-v0.36.0/noir/standard_library/meta/typ.md
@@ -0,0 +1,264 @@
+---
+title: Type
+---
+
+`std::meta::typ` contains methods on the built-in `Type` type used for representing
+a type in the source program.
+
+## Functions
+
+```rust title="fresh_type_variable" showLineNumbers 
+pub comptime fn fresh_type_variable() -> Type {}
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/meta/typ.nr#L57-L59" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/meta/typ.nr#L57-L59</a></sub></sup>
+
+
+Creates and returns an unbound type variable. This is a special kind of type internal
+to type checking which will type check with any other type. When it is type checked
+against another type it will also be set to that type. For example, if `a` is a type
+variable and we have the type equality `(a, i32) = (u8, i32)`, the compiler will set
+`a` equal to `u8`.
+
+Unbound type variables will often be rendered as `_` while printing them. Bound type
+variables will appear as the type they are bound to.
+
+This can be used in conjunction with functions which internally perform type checks
+such as `Type::implements` or `Type::get_trait_impl` to potentially grab some of the types used.
+
+Note that calling `Type::implements` or `Type::get_trait_impl` on a type variable will always
+fail.
+
+Example:
+
+```rust title="serialize-setup" showLineNumbers 
+trait Serialize<let N: u32> {}
+
+impl Serialize<1> for Field {}
+
+impl<T, let N: u32, let M: u32> Serialize<N * M> for [T; N]
+where
+    T: Serialize<M>,
+{}
+
+impl<T, U, let N: u32, let M: u32> Serialize<N + M> for (T, U)
+where
+    T: Serialize<N>,
+    U: Serialize<M>,
+{}
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/test_programs/compile_success_empty/comptime_type/src/main.nr#L14-L29" target="_blank" rel="noopener noreferrer">Source code: test_programs/compile_success_empty/comptime_type/src/main.nr#L14-L29</a></sub></sup>
+
+```rust title="fresh-type-variable-example" showLineNumbers 
+let typevar1 = std::meta::typ::fresh_type_variable();
+        let constraint = quote { Serialize<$typevar1> }.as_trait_constraint();
+        let field_type = quote { Field }.as_type();
+
+        // Search for a trait impl (binding typevar1 to 1 when the impl is found):
+        assert(field_type.implements(constraint));
+
+        // typevar1 should be bound to the "1" generic now:
+        assert_eq(typevar1.as_constant().unwrap(), 1);
+
+        // If we want to do the same with a different type, we need to
+        // create a new type variable now that `typevar1` is bound
+        let typevar2 = std::meta::typ::fresh_type_variable();
+        let constraint = quote { Serialize<$typevar2> }.as_trait_constraint();
+        let array_type = quote { [(Field, Field); 5] }.as_type();
+        assert(array_type.implements(constraint));
+
+        // Now typevar2 should be bound to the serialized pair size 2 times the array length 5
+        assert_eq(typevar2.as_constant().unwrap(), 10);
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/test_programs/compile_success_empty/comptime_type/src/main.nr#L129-L149" target="_blank" rel="noopener noreferrer">Source code: test_programs/compile_success_empty/comptime_type/src/main.nr#L129-L149</a></sub></sup>
+
+
+## Methods
+
+### as_array
+
+```rust title="as_array" showLineNumbers 
+pub comptime fn as_array(self) -> Option<(Type, Type)> {}
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/meta/typ.nr#L76-L78" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/meta/typ.nr#L76-L78</a></sub></sup>
+
+
+If this type is an array, return a pair of (element type, size type).
+
+Example:
+
+```rust
+comptime {
+    let array_type = quote { [Field; 3] }.as_type();
+    let (field_type, three_type) = array_type.as_array().unwrap();
+
+    assert(field_type.is_field());
+    assert_eq(three_type.as_constant().unwrap(), 3);
+}
+```
+
+### as_constant
+
+```rust title="as_constant" showLineNumbers 
+pub comptime fn as_constant(self) -> Option<u32> {}
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/meta/typ.nr#L83-L85" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/meta/typ.nr#L83-L85</a></sub></sup>
+
+
+If this type is a constant integer (such as the `3` in the array type `[Field; 3]`),
+return the numeric constant.
+
+### as_integer
+
+```rust title="as_integer" showLineNumbers 
+pub comptime fn as_integer(self) -> Option<(bool, u8)> {}
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/meta/typ.nr#L90-L92" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/meta/typ.nr#L90-L92</a></sub></sup>
+
+
+If this is an integer type, return a boolean which is `true`
+if the type is signed, as well as the number of bits of this integer type.
+
+### as_mutable_reference
+
+```rust title="as_mutable_reference" showLineNumbers 
+comptime fn as_mutable_reference(self) -> Option<Type> {}
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/meta/typ.nr#L96-L98" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/meta/typ.nr#L96-L98</a></sub></sup>
+
+
+If this is a mutable reference type `&mut T`, returns the mutable type `T`.
+
+### as_slice
+
+```rust title="as_slice" showLineNumbers 
+pub comptime fn as_slice(self) -> Option<Type> {}
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/meta/typ.nr#L102-L104" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/meta/typ.nr#L102-L104</a></sub></sup>
+
+
+If this is a slice type, return the element type of the slice.
+
+### as_str
+
+```rust title="as_str" showLineNumbers 
+pub comptime fn as_str(self) -> Option<Type> {}
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/meta/typ.nr#L108-L110" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/meta/typ.nr#L108-L110</a></sub></sup>
+
+
+If this is a `str<N>` type, returns the length `N` as a type.
+
+### as_struct
+
+```rust title="as_struct" showLineNumbers 
+pub comptime fn as_struct(self) -> Option<(StructDefinition, [Type])> {}
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/meta/typ.nr#L114-L116" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/meta/typ.nr#L114-L116</a></sub></sup>
+
+
+If this is a struct type, returns the struct in addition to
+any generic arguments on this type.
+
+### as_tuple
+
+```rust title="as_tuple" showLineNumbers 
+pub comptime fn as_tuple(self) -> Option<[Type]> {}
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/meta/typ.nr#L120-L122" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/meta/typ.nr#L120-L122</a></sub></sup>
+
+
+If this is a tuple type, returns each element type of the tuple.
+
+### get_trait_impl
+
+```rust title="get_trait_impl" showLineNumbers 
+pub comptime fn get_trait_impl(self, constraint: TraitConstraint) -> Option<TraitImpl> {}
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/meta/typ.nr#L143-L145" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/meta/typ.nr#L143-L145</a></sub></sup>
+
+
+Retrieves the trait implementation that implements the given
+trait constraint for this type. If the trait constraint is not
+found, `None` is returned. Note that since the concrete trait implementation
+for a trait constraint specified from a `where` clause is unknown,
+this function will return `None` in these cases. If you only want to know
+whether a type implements a trait, use `implements` instead.
+
+Example:
+
+```rust
+comptime {
+    let field_type = quote { Field }.as_type();
+    let default = quote { Default }.as_trait_constraint();
+
+    let the_impl: TraitImpl = field_type.get_trait_impl(default).unwrap();
+    assert(the_impl.methods().len(), 1);
+}
+```
+
+### implements
+
+```rust title="implements" showLineNumbers 
+pub comptime fn implements(self, constraint: TraitConstraint) -> bool {}
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/meta/typ.nr#L166-L168" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/meta/typ.nr#L166-L168</a></sub></sup>
+
+
+`true` if this type implements the given trait. Note that unlike
+`get_trait_impl` this will also return true for any `where` constraints
+in scope.
+
+Example:
+
+```rust
+fn foo<T>() where T: Default {
+    comptime {
+        let field_type = quote { Field }.as_type();
+        let default = quote { Default }.as_trait_constraint();
+        assert(field_type.implements(default));
+
+        let t = quote { T }.as_type();
+        assert(t.implements(default));
+    }
+}
+```
+
+### is_bool
+
+```rust title="is_bool" showLineNumbers 
+pub comptime fn is_bool(self) -> bool {}
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/meta/typ.nr#L172-L174" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/meta/typ.nr#L172-L174</a></sub></sup>
+
+
+`true` if this type is `bool`.
+
+### is_field
+
+```rust title="is_field" showLineNumbers 
+pub comptime fn is_field(self) -> bool {}
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/meta/typ.nr#L178-L180" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/meta/typ.nr#L178-L180</a></sub></sup>
+
+
+`true` if this type is `Field`.
+
+### is_unit
+
+```rust title="is_unit" showLineNumbers 
+comptime fn is_unit(self) -> bool {}
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/meta/typ.nr#L184-L186" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/meta/typ.nr#L184-L186</a></sub></sup>
+
+
+`true` if this type is the unit `()` type.
+
+## Trait Implementations
+
+```rust
+impl Eq for Type
+impl Hash for Type
+```
+Note that this is syntactic equality, this is not the same as whether two types will type check
+to be the same type. Unless type inference or generics are being used however, users should not
+typically have to worry about this distinction unless `std::meta::typ::fresh_type_variable` is used.
diff --git a/docs/versioned_docs/version-v0.36.0/noir/standard_library/meta/typed_expr.md b/docs/versioned_docs/version-v0.36.0/noir/standard_library/meta/typed_expr.md
new file mode 100644
index 00000000000..0db7dbfef61
--- /dev/null
+++ b/docs/versioned_docs/version-v0.36.0/noir/standard_library/meta/typed_expr.md
@@ -0,0 +1,27 @@
+---
+title: TypedExpr
+---
+
+`std::meta::typed_expr` contains methods on the built-in `TypedExpr` type for resolved and type-checked expressions.
+
+## Methods
+
+### get_type
+
+```rust title="as_function_definition" showLineNumbers 
+pub comptime fn as_function_definition(self) -> Option<FunctionDefinition> {}
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/meta/typed_expr.nr#L7-L9" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/meta/typed_expr.nr#L7-L9</a></sub></sup>
+
+
+If this expression refers to a function definitions, returns it. Otherwise returns `Option::none()`.
+
+### get_type
+
+```rust title="get_type" showLineNumbers 
+pub comptime fn get_type(self) -> Option<Type> {}
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/meta/typed_expr.nr#L13-L15" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/meta/typed_expr.nr#L13-L15</a></sub></sup>
+
+
+Returns the type of the expression, or `Option::none()` if there were errors when the expression was previously resolved.
\ No newline at end of file
diff --git a/docs/versioned_docs/version-v0.36.0/noir/standard_library/meta/unresolved_type.md b/docs/versioned_docs/version-v0.36.0/noir/standard_library/meta/unresolved_type.md
new file mode 100644
index 00000000000..2826ec5ec0f
--- /dev/null
+++ b/docs/versioned_docs/version-v0.36.0/noir/standard_library/meta/unresolved_type.md
@@ -0,0 +1,57 @@
+---
+title: UnresolvedType
+---
+
+`std::meta::unresolved_type` contains methods on the built-in `UnresolvedType` type for the syntax of types.
+
+## Methods
+
+### as_mutable_reference
+
+```rust title="as_mutable_reference" showLineNumbers 
+comptime fn as_mutable_reference(self) -> Option<UnresolvedType> {}
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/meta/unresolved_type.nr#L8-L10" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/meta/unresolved_type.nr#L8-L10</a></sub></sup>
+
+
+If this is a mutable reference type `&mut T`, returns the mutable type `T`.
+
+### as_slice
+
+```rust title="as_slice" showLineNumbers 
+comptime fn as_slice(self) -> Option<UnresolvedType> {}
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/meta/unresolved_type.nr#L14-L16" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/meta/unresolved_type.nr#L14-L16</a></sub></sup>
+
+
+If this is a slice `&[T]`, returns the element type `T`.
+
+### is_bool
+
+```rust title="is_bool" showLineNumbers 
+comptime fn is_bool(self) -> bool {}
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/meta/unresolved_type.nr#L20-L22" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/meta/unresolved_type.nr#L20-L22</a></sub></sup>
+
+
+Returns `true` if this type is `bool`.
+
+### is_field
+
+```rust title="is_field" showLineNumbers 
+pub comptime fn is_field(self) -> bool {}
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/meta/unresolved_type.nr#L26-L28" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/meta/unresolved_type.nr#L26-L28</a></sub></sup>
+
+
+Returns true if this type refers to the Field type.
+
+### is_unit
+
+```rust title="is_unit" showLineNumbers 
+comptime fn is_unit(self) -> bool {}
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/meta/unresolved_type.nr#L32-L34" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/meta/unresolved_type.nr#L32-L34</a></sub></sup>
+
+
+Returns true if this type is the unit `()` type.
diff --git a/docs/versioned_docs/version-v0.36.0/noir/standard_library/options.md b/docs/versioned_docs/version-v0.36.0/noir/standard_library/options.md
new file mode 100644
index 00000000000..a1bd4e1de5f
--- /dev/null
+++ b/docs/versioned_docs/version-v0.36.0/noir/standard_library/options.md
@@ -0,0 +1,101 @@
+---
+title: Option<T> Type
+---
+
+The `Option<T>` type is a way to express that a value might be present (`Some(T))` or absent (`None`). It's a safer way to handle potential absence of values, compared to using nulls in many other languages.
+
+```rust
+struct Option<T> {
+    None,
+    Some(T),
+}
+```
+
+The `Option` type, already imported into your Noir program, can be used directly:
+
+```rust
+fn main() {
+    let none = Option::none();
+    let some = Option::some(3);
+}
+```
+
+See [this test](https://github.com/noir-lang/noir/blob/5cbfb9c4a06c8865c98ff2b594464b037d821a5c/crates/nargo_cli/tests/test_data/option/src/main.nr) for a more comprehensive set of examples of each of the methods described below.
+
+## Methods
+
+### none
+
+Constructs a none value.
+
+### some
+
+Constructs a some wrapper around a given value.
+
+### is_none
+
+Returns true if the Option is None.
+
+### is_some
+
+Returns true of the Option is Some.
+
+### unwrap
+
+Asserts `self.is_some()` and returns the wrapped value.
+
+### unwrap_unchecked
+
+Returns the inner value without asserting `self.is_some()`. This method can be useful within an if condition when we already know that `option.is_some()`. If the option is None, there is no guarantee what value will be returned, only that it will be of type T for an `Option<T>`.
+
+### unwrap_or
+
+Returns the wrapped value if `self.is_some()`. Otherwise, returns the given default value.
+
+### unwrap_or_else
+
+Returns the wrapped value if `self.is_some()`. Otherwise, calls the given function to return a default value.
+
+### expect
+
+Asserts `self.is_some()` with a provided custom message and returns the contained `Some` value. The custom message is expected to be a format string.
+
+### map
+
+If self is `Some(x)`, this returns `Some(f(x))`. Otherwise, this returns `None`.
+
+### map_or
+
+If self is `Some(x)`, this returns `f(x)`. Otherwise, this returns the given default value.
+
+### map_or_else
+
+If self is `Some(x)`, this returns `f(x)`. Otherwise, this returns `default()`.
+
+### and
+
+Returns None if self is None. Otherwise, this returns `other`.
+
+### and_then
+
+If self is None, this returns None. Otherwise, this calls the given function with the Some value contained within self, and returns the result of that call. In some languages this function is called `flat_map` or `bind`.
+
+### or
+
+If self is Some, return self. Otherwise, return `other`.
+
+### or_else
+
+If self is Some, return self. Otherwise, return `default()`.
+
+### xor
+
+If only one of the two Options is Some, return that option. Otherwise, if both options are Some or both are None, None is returned.
+
+### filter
+
+Returns `Some(x)` if self is `Some(x)` and `predicate(x)` is true. Otherwise, this returns `None`.
+
+### flatten
+
+Flattens an `Option<Option<T>>` into a `Option<T>`. This returns `None` if the outer Option is None. Otherwise, this returns the inner Option.
diff --git a/docs/versioned_docs/version-v0.36.0/noir/standard_library/recursion.mdx b/docs/versioned_docs/version-v0.36.0/noir/standard_library/recursion.mdx
new file mode 100644
index 00000000000..60414a2fa51
--- /dev/null
+++ b/docs/versioned_docs/version-v0.36.0/noir/standard_library/recursion.mdx
@@ -0,0 +1,85 @@
+---
+title: Recursive Proofs
+description: Learn about how to write recursive proofs in Noir.
+keywords: [recursion, recursive proofs, verification_key, verify_proof]
+---
+
+import BlackBoxInfo from '@site/src/components/Notes/_blackbox';
+
+Noir supports recursively verifying proofs, meaning you verify the proof of a Noir program in another Noir program. This enables creating proofs of arbitrary size by doing step-wise verification of smaller components of a large proof.
+
+Read [the explainer on recursion](../../explainers/explainer-recursion.md) to know more about this function and the [guide on how to use it.](../../how_to/how-to-recursion.md)
+
+## The `#[recursive]` Attribute
+
+In Noir, the `#[recursive]` attribute is used to indicate that a circuit is designed for recursive proof generation. When applied, it informs the compiler and the tooling that the circuit should be compiled in a way that makes its proofs suitable for recursive verification. This attribute eliminates the need for manual flagging of recursion at the tooling level, streamlining the proof generation process for recursive circuits.
+
+### Example usage with `#[recursive]`
+
+```rust
+#[recursive]
+fn main(x: Field, y: pub Field) {
+    assert(x == y, "x and y are not equal");
+}
+
+// This marks the circuit as recursion-friendly and indicates that proofs generated from this circuit
+// are intended for recursive verification.
+```
+
+By incorporating this attribute directly in the circuit's definition, tooling like Nargo and NoirJS can automatically execute recursive-specific duties for Noir programs (e.g. recursive-friendly proof artifact generation) without additional flags or configurations.
+
+## Verifying Recursive Proofs
+
+```rust
+#[foreign(recursive_aggregation)]
+pub fn verify_proof(verification_key: [Field], proof: [Field], public_inputs: [Field], key_hash: Field) {}
+```
+
+<BlackBoxInfo to="black_box_fns"/>
+
+## Example usage
+
+```rust
+
+fn main(
+    verification_key : [Field; 114],
+    proof : [Field; 93],
+    public_inputs : [Field; 1],
+    key_hash : Field,
+    proof_b : [Field; 93],
+) {
+    std::verify_proof(
+        verification_key,
+        proof,
+        public_inputs,
+        key_hash
+    );
+
+    std::verify_proof(
+        verification_key,
+        proof_b,
+        public_inputs,
+        key_hash
+    );
+}
+```
+
+You can see a full example of recursive proofs in [this example recursion demo repo](https://github.com/noir-lang/noir-examples/tree/master/recursion).
+
+## Parameters
+
+### `verification_key`
+
+The verification key for the zk program that is being verified.
+
+### `proof`
+
+The proof for the zk program that is being verified.
+
+### `public_inputs`
+
+These represent the public inputs of the proof we are verifying.
+
+### `key_hash`
+
+A key hash is used to check the validity of the verification key. The circuit implementing this opcode can use this hash to ensure that the key provided to the circuit matches the key produced by the circuit creator.
diff --git a/docs/versioned_docs/version-v0.36.0/noir/standard_library/traits.md b/docs/versioned_docs/version-v0.36.0/noir/standard_library/traits.md
new file mode 100644
index 00000000000..ee20f9cd949
--- /dev/null
+++ b/docs/versioned_docs/version-v0.36.0/noir/standard_library/traits.md
@@ -0,0 +1,628 @@
+---
+title: Traits
+description: Noir's stdlib provides a few commonly used traits.
+keywords: [traits, trait, interface, protocol, default, add, eq]
+---
+
+## `std::default`
+
+### `std::default::Default`
+
+```rust title="default-trait" showLineNumbers 
+pub trait Default {
+    fn default() -> Self;
+}
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/default.nr#L4-L8" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/default.nr#L4-L8</a></sub></sup>
+
+
+Constructs a default value of a type.
+
+Implementations:
+```rust
+impl Default for Field { .. }
+
+impl Default for i8 { .. }
+impl Default for i16 { .. }
+impl Default for i32 { .. }
+impl Default for i64 { .. }
+
+impl Default for u8 { .. }
+impl Default for u16 { .. }
+impl Default for u32 { .. }
+impl Default for u64 { .. }
+
+impl Default for () { .. }
+impl Default for bool { .. }
+
+impl<T, N> Default for [T; N]
+    where T: Default { .. }
+
+impl<T> Default for [T] { .. }
+
+impl<A, B> Default for (A, B)
+    where A: Default, B: Default { .. }
+
+impl<A, B, C> Default for (A, B, C)
+    where A: Default, B: Default, C: Default { .. }
+
+impl<A, B, C, D> Default for (A, B, C, D)
+    where A: Default, B: Default, C: Default, D: Default { .. }
+
+impl<A, B, C, D, E> Default for (A, B, C, D, E)
+    where A: Default, B: Default, C: Default, D: Default, E: Default { .. }
+```
+
+For primitive integer types, the return value of `default` is `0`. Container
+types such as arrays are filled with default values of their element type,
+except slices whose length is unknown and thus defaulted to zero.
+
+---
+
+## `std::convert`
+
+### `std::convert::From`
+
+```rust title="from-trait" showLineNumbers 
+pub trait From<T> {
+    fn from(input: T) -> Self;
+}
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/convert.nr#L1-L5" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/convert.nr#L1-L5</a></sub></sup>
+
+
+The `From` trait defines how to convert from a given type `T` to the type on which the trait is implemented.
+
+The Noir standard library provides a number of implementations of `From` between primitive types.
+```rust title="from-impls" showLineNumbers 
+// Unsigned integers
+
+impl From<u8> for u32 {
+    fn from(value: u8) -> u32 {
+        value as u32
+    }
+}
+
+impl From<u8> for u64 {
+    fn from(value: u8) -> u64 {
+        value as u64
+    }
+}
+impl From<u32> for u64 {
+    fn from(value: u32) -> u64 {
+        value as u64
+    }
+}
+
+impl From<u8> for Field {
+    fn from(value: u8) -> Field {
+        value as Field
+    }
+}
+impl From<u32> for Field {
+    fn from(value: u32) -> Field {
+        value as Field
+    }
+}
+impl From<u64> for Field {
+    fn from(value: u64) -> Field {
+        value as Field
+    }
+}
+
+// Signed integers
+
+impl From<i8> for i32 {
+    fn from(value: i8) -> i32 {
+        value as i32
+    }
+}
+
+impl From<i8> for i64 {
+    fn from(value: i8) -> i64 {
+        value as i64
+    }
+}
+impl From<i32> for i64 {
+    fn from(value: i32) -> i64 {
+        value as i64
+    }
+}
+
+// Booleans
+impl From<bool> for u8 {
+    fn from(value: bool) -> u8 {
+        value as u8
+    }
+}
+impl From<bool> for u32 {
+    fn from(value: bool) -> u32 {
+        value as u32
+    }
+}
+impl From<bool> for u64 {
+    fn from(value: bool) -> u64 {
+        value as u64
+    }
+}
+impl From<bool> for i8 {
+    fn from(value: bool) -> i8 {
+        value as i8
+    }
+}
+impl From<bool> for i32 {
+    fn from(value: bool) -> i32 {
+        value as i32
+    }
+}
+impl From<bool> for i64 {
+    fn from(value: bool) -> i64 {
+        value as i64
+    }
+}
+impl From<bool> for Field {
+    fn from(value: bool) -> Field {
+        value as Field
+    }
+}
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/convert.nr#L28-L119" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/convert.nr#L28-L119</a></sub></sup>
+
+
+#### When to implement `From`
+
+As a general rule of thumb, `From` may be implemented in the [situations where it would be suitable in Rust](https://doc.rust-lang.org/std/convert/trait.From.html#when-to-implement-from):
+
+- The conversion is *infallible*: Noir does not provide an equivalent to Rust's `TryFrom`, if the conversion can fail then provide a named method instead.
+- The conversion is *lossless*: semantically, it should not lose or discard information. For example, `u32: From<u16>` can losslessly convert any `u16` into a valid `u32` such that the original `u16` can be recovered. On the other hand, `u16: From<u32>` should not be implemented as `2**16` is a `u32` which cannot be losslessly converted into a `u16`.
+- The conversion is *value-preserving*: the conceptual kind and meaning of the resulting value is the same, even though the Noir type and technical representation might be different. While it's possible to infallibly and losslessly convert a `u8` into a `str<2>` hex representation, `4u8` and `"04"` are too different for `str<2>: From<u8>` to be implemented.
+- The conversion is *obvious*: it's the only reasonable conversion between the two types. If there's ambiguity on how to convert between them such that the same input could potentially map to two different values then a named method should be used. For instance rather than implementing `U128: From<[u8; 16]>`, the methods `U128::from_le_bytes` and `U128::from_be_bytes` are used as otherwise the endianness of the array would be ambiguous, resulting in two potential values of `U128` from the same byte array.
+
+One additional recommendation specific to Noir is:
+- The conversion is *efficient*: it's relatively cheap to convert between the two types. Due to being a ZK DSL, it's more important to avoid unnecessary computation compared to Rust. If the implementation of `From` would encourage users to perform unnecessary conversion, resulting in additional proving time, then it may be preferable to expose functionality such that this conversion may be avoided.
+
+### `std::convert::Into`
+
+The `Into` trait is defined as the reciprocal of `From`. It should be easy to convince yourself that if we can convert to type `A` from type `B`, then it's possible to convert type `B` into type `A`.
+
+For this reason, implementing `From` on a type will automatically generate a matching `Into` implementation. One should always prefer implementing `From` over `Into` as implementing `Into` will not generate a matching `From` implementation.
+
+```rust title="into-trait" showLineNumbers 
+pub trait Into<T> {
+    fn into(self) -> T;
+}
+
+impl<T, U> Into<T> for U
+where
+    T: From<U>,
+{
+    fn into(self) -> T {
+        T::from(self)
+    }
+}
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/convert.nr#L13-L26" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/convert.nr#L13-L26</a></sub></sup>
+
+
+`Into` is most useful when passing function arguments where the types don't quite match up with what the function expects. In this case, the compiler has enough type information to perform the necessary conversion by just appending `.into()` onto the arguments in question.
+
+---
+
+## `std::cmp`
+
+### `std::cmp::Eq`
+
+```rust title="eq-trait" showLineNumbers 
+pub trait Eq {
+    fn eq(self, other: Self) -> bool;
+}
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/cmp.nr#L4-L8" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/cmp.nr#L4-L8</a></sub></sup>
+
+
+Returns `true` if `self` is equal to `other`. Implementing this trait on a type
+allows the type to be used with `==` and `!=`.
+
+Implementations:
+```rust
+impl Eq for Field { .. }
+
+impl Eq for i8 { .. }
+impl Eq for i16 { .. }
+impl Eq for i32 { .. }
+impl Eq for i64 { .. }
+
+impl Eq for u8 { .. }
+impl Eq for u16 { .. }
+impl Eq for u32 { .. }
+impl Eq for u64 { .. }
+
+impl Eq for () { .. }
+impl Eq for bool { .. }
+
+impl<T, N> Eq for [T; N]
+    where T: Eq { .. }
+
+impl<T> Eq for [T]
+    where T: Eq { .. }
+
+impl<A, B> Eq for (A, B)
+    where A: Eq, B: Eq { .. }
+
+impl<A, B, C> Eq for (A, B, C)
+    where A: Eq, B: Eq, C: Eq { .. }
+
+impl<A, B, C, D> Eq for (A, B, C, D)
+    where A: Eq, B: Eq, C: Eq, D: Eq { .. }
+
+impl<A, B, C, D, E> Eq for (A, B, C, D, E)
+    where A: Eq, B: Eq, C: Eq, D: Eq, E: Eq { .. }
+```
+
+### `std::cmp::Ord`
+
+```rust title="ord-trait" showLineNumbers 
+pub trait Ord {
+    fn cmp(self, other: Self) -> Ordering;
+}
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/cmp.nr#L210-L214" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/cmp.nr#L210-L214</a></sub></sup>
+
+
+`a.cmp(b)` compares two values returning `Ordering::less()` if `a < b`,
+`Ordering::equal()` if `a == b`, or `Ordering::greater()` if `a > b`.
+Implementing this trait on a type allows `<`, `<=`, `>`, and `>=` to be
+used on values of the type.
+
+`std::cmp` also provides `max` and `min` functions for any type which implements the `Ord` trait.
+
+Implementations:
+
+```rust
+impl Ord for u8 { .. }
+impl Ord for u16 { .. }
+impl Ord for u32 { .. }
+impl Ord for u64 { .. }
+
+impl Ord for i8 { .. }
+impl Ord for i16 { .. }
+impl Ord for i32 { .. }
+
+impl Ord for i64 { .. }
+
+impl Ord for () { .. }
+impl Ord for bool { .. }
+
+impl<T, N> Ord for [T; N]
+    where T: Ord { .. }
+
+impl<T> Ord for [T]
+    where T: Ord { .. }
+
+impl<A, B> Ord for (A, B)
+    where A: Ord, B: Ord { .. }
+
+impl<A, B, C> Ord for (A, B, C)
+    where A: Ord, B: Ord, C: Ord { .. }
+
+impl<A, B, C, D> Ord for (A, B, C, D)
+    where A: Ord, B: Ord, C: Ord, D: Ord { .. }
+
+impl<A, B, C, D, E> Ord for (A, B, C, D, E)
+    where A: Ord, B: Ord, C: Ord, D: Ord, E: Ord { .. }
+```
+
+---
+
+## `std::ops`
+
+### `std::ops::Add`, `std::ops::Sub`, `std::ops::Mul`, and `std::ops::Div`
+
+These traits abstract over addition, subtraction, multiplication, and division respectively.
+Implementing these traits for a given type will also allow that type to be used with the corresponding operator
+for that trait (`+` for Add, etc) in addition to the normal method names.
+
+```rust title="add-trait" showLineNumbers 
+pub trait Add {
+    fn add(self, other: Self) -> Self;
+}
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/ops/arith.nr#L1-L5" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/ops/arith.nr#L1-L5</a></sub></sup>
+
+```rust title="sub-trait" showLineNumbers 
+pub trait Sub {
+    fn sub(self, other: Self) -> Self;
+}
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/ops/arith.nr#L60-L64" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/ops/arith.nr#L60-L64</a></sub></sup>
+
+```rust title="mul-trait" showLineNumbers 
+pub trait Mul {
+    fn mul(self, other: Self) -> Self;
+}
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/ops/arith.nr#L119-L123" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/ops/arith.nr#L119-L123</a></sub></sup>
+
+```rust title="div-trait" showLineNumbers 
+pub trait Div {
+    fn div(self, other: Self) -> Self;
+}
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/ops/arith.nr#L178-L182" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/ops/arith.nr#L178-L182</a></sub></sup>
+
+
+The implementations block below is given for the `Add` trait, but the same types that implement
+`Add` also implement `Sub`, `Mul`, and `Div`.
+
+Implementations:
+```rust
+impl Add for Field { .. }
+
+impl Add for i8 { .. }
+impl Add for i16 { .. }
+impl Add for i32 { .. }
+impl Add for i64 { .. }
+
+impl Add for u8 { .. }
+impl Add for u16 { .. }
+impl Add for u32 { .. }
+impl Add for u64 { .. }
+```
+
+### `std::ops::Rem`
+
+```rust title="rem-trait" showLineNumbers 
+pub trait Rem {
+    fn rem(self, other: Self) -> Self;
+}
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/ops/arith.nr#L237-L241" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/ops/arith.nr#L237-L241</a></sub></sup>
+
+
+`Rem::rem(a, b)` is the remainder function returning the result of what is
+left after dividing `a` and `b`. Implementing `Rem` allows the `%` operator
+to be used with the implementation type.
+
+Unlike other numeric traits, `Rem` is not implemented for `Field`.
+
+Implementations:
+```rust
+impl Rem for u8 { fn rem(self, other: u8) -> u8 { self % other } }
+impl Rem for u16 { fn rem(self, other: u16) -> u16 { self % other } }
+impl Rem for u32 { fn rem(self, other: u32) -> u32 { self % other } }
+impl Rem for u64 { fn rem(self, other: u64) -> u64 { self % other } }
+
+impl Rem for i8 { fn rem(self, other: i8) -> i8 { self % other } }
+impl Rem for i16 { fn rem(self, other: i16) -> i16 { self % other } }
+impl Rem for i32 { fn rem(self, other: i32) -> i32 { self % other } }
+impl Rem for i64 { fn rem(self, other: i64) -> i64 { self % other } }
+```
+
+### `std::ops::Neg`
+
+```rust title="neg-trait" showLineNumbers 
+pub trait Neg {
+    fn neg(self) -> Self;
+}
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/ops/arith.nr#L290-L294" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/ops/arith.nr#L290-L294</a></sub></sup>
+
+
+`Neg::neg` is equivalent to the unary negation operator `-`.
+
+Implementations:
+```rust title="neg-trait-impls" showLineNumbers 
+impl Neg for Field {
+    fn neg(self) -> Field {
+        -self
+    }
+}
+
+impl Neg for i8 {
+    fn neg(self) -> i8 {
+        -self
+    }
+}
+impl Neg for i16 {
+    fn neg(self) -> i16 {
+        -self
+    }
+}
+impl Neg for i32 {
+    fn neg(self) -> i32 {
+        -self
+    }
+}
+impl Neg for i64 {
+    fn neg(self) -> i64 {
+        -self
+    }
+}
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/ops/arith.nr#L296-L323" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/ops/arith.nr#L296-L323</a></sub></sup>
+
+
+### `std::ops::Not`
+
+```rust title="not-trait" showLineNumbers 
+pub trait Not {
+    fn not(self: Self) -> Self;
+}
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/ops/bit.nr#L1-L5" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/ops/bit.nr#L1-L5</a></sub></sup>
+
+
+`Not::not` is equivalent to the unary bitwise NOT operator `!`.
+
+Implementations:
+```rust title="not-trait-impls" showLineNumbers 
+impl Not for bool {
+    fn not(self) -> bool {
+        !self
+    }
+}
+
+impl Not for u64 {
+    fn not(self) -> u64 {
+        !self
+    }
+}
+impl Not for u32 {
+    fn not(self) -> u32 {
+        !self
+    }
+}
+impl Not for u16 {
+    fn not(self) -> u16 {
+        !self
+    }
+}
+impl Not for u8 {
+    fn not(self) -> u8 {
+        !self
+    }
+}
+impl Not for u1 {
+    fn not(self) -> u1 {
+        !self
+    }
+}
+
+impl Not for i8 {
+    fn not(self) -> i8 {
+        !self
+    }
+}
+impl Not for i16 {
+    fn not(self) -> i16 {
+        !self
+    }
+}
+impl Not for i32 {
+    fn not(self) -> i32 {
+        !self
+    }
+}
+impl Not for i64 {
+    fn not(self) -> i64 {
+        !self
+    }
+}
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/ops/bit.nr#L7-L60" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/ops/bit.nr#L7-L60</a></sub></sup>
+
+
+### `std::ops::{ BitOr, BitAnd, BitXor }`
+
+```rust title="bitor-trait" showLineNumbers 
+pub trait BitOr {
+    fn bitor(self, other: Self) -> Self;
+}
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/ops/bit.nr#L62-L66" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/ops/bit.nr#L62-L66</a></sub></sup>
+
+```rust title="bitand-trait" showLineNumbers 
+pub trait BitAnd {
+    fn bitand(self, other: Self) -> Self;
+}
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/ops/bit.nr#L121-L125" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/ops/bit.nr#L121-L125</a></sub></sup>
+
+```rust title="bitxor-trait" showLineNumbers 
+pub trait BitXor {
+    fn bitxor(self, other: Self) -> Self;
+}
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/ops/bit.nr#L180-L184" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/ops/bit.nr#L180-L184</a></sub></sup>
+
+
+Traits for the bitwise operations `|`, `&`, and `^`.
+
+Implementing `BitOr`, `BitAnd` or `BitXor` for a type allows the `|`, `&`, or `^` operator respectively
+to be used with the type.
+
+The implementations block below is given for the `BitOr` trait, but the same types that implement
+`BitOr` also implement `BitAnd` and `BitXor`.
+
+Implementations:
+```rust
+impl BitOr for bool { fn bitor(self, other: bool) -> bool { self | other } }
+
+impl BitOr for u8 { fn bitor(self, other: u8) -> u8 { self | other } }
+impl BitOr for u16 { fn bitor(self, other: u16) -> u16 { self | other } }
+impl BitOr for u32 { fn bitor(self, other: u32) -> u32 { self | other } }
+impl BitOr for u64 { fn bitor(self, other: u64) -> u64 { self | other } }
+
+impl BitOr for i8 { fn bitor(self, other: i8) -> i8 { self | other } }
+impl BitOr for i16 { fn bitor(self, other: i16) -> i16 { self | other } }
+impl BitOr for i32 { fn bitor(self, other: i32) -> i32 { self | other } }
+impl BitOr for i64 { fn bitor(self, other: i64) -> i64 { self | other } }
+```
+
+### `std::ops::{ Shl, Shr }`
+
+```rust title="shl-trait" showLineNumbers 
+pub trait Shl {
+    fn shl(self, other: u8) -> Self;
+}
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/ops/bit.nr#L239-L243" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/ops/bit.nr#L239-L243</a></sub></sup>
+
+```rust title="shr-trait" showLineNumbers 
+pub trait Shr {
+    fn shr(self, other: u8) -> Self;
+}
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/ops/bit.nr#L292-L296" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/ops/bit.nr#L292-L296</a></sub></sup>
+
+
+Traits for a bit shift left and bit shift right.
+
+Implementing `Shl` for a type allows the left shift operator (`<<`) to be used with the implementation type.
+Similarly, implementing `Shr` allows the right shift operator (`>>`) to be used with the type.
+
+Note that bit shifting is not currently implemented for signed types.
+
+The implementations block below is given for the `Shl` trait, but the same types that implement
+`Shl` also implement `Shr`.
+
+Implementations:
+```rust
+impl Shl for u8 { fn shl(self, other: u8) -> u8 { self << other } }
+impl Shl for u16 { fn shl(self, other: u16) -> u16 { self << other } }
+impl Shl for u32 { fn shl(self, other: u32) -> u32 { self << other } }
+impl Shl for u64 { fn shl(self, other: u64) -> u64 { self << other } }
+```
+
+---
+
+## `std::append`
+
+### `std::append::Append`
+
+`Append` can abstract over types that can be appended to - usually container types:
+
+```rust title="append-trait" showLineNumbers 
+pub trait Append {
+    fn empty() -> Self;
+    fn append(self, other: Self) -> Self;
+}
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/append.nr#L9-L14" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/append.nr#L9-L14</a></sub></sup>
+
+
+`Append` requires two methods:
+
+- `empty`: Constructs an empty value of `Self`.
+- `append`: Append two values together, returning the result.
+
+Additionally, it is expected that for any implementation:
+
+- `T::empty().append(x) == x`
+- `x.append(T::empty()) == x`
+
+Implementations:
+```rust
+impl<T> Append for [T]
+impl Append for Quoted
+```
diff --git a/docs/versioned_docs/version-v0.36.0/reference/NoirJS/backend_barretenberg/.nojekyll b/docs/versioned_docs/version-v0.36.0/reference/NoirJS/backend_barretenberg/.nojekyll
new file mode 100644
index 00000000000..e2ac6616add
--- /dev/null
+++ b/docs/versioned_docs/version-v0.36.0/reference/NoirJS/backend_barretenberg/.nojekyll
@@ -0,0 +1 @@
+TypeDoc added this file to prevent GitHub Pages from using Jekyll. You can turn off this behavior by setting the `githubPages` option to false.
\ No newline at end of file
diff --git a/docs/versioned_docs/version-v0.36.0/reference/NoirJS/backend_barretenberg/classes/BarretenbergBackend.md b/docs/versioned_docs/version-v0.36.0/reference/NoirJS/backend_barretenberg/classes/BarretenbergBackend.md
new file mode 100644
index 00000000000..252d72a0b71
--- /dev/null
+++ b/docs/versioned_docs/version-v0.36.0/reference/NoirJS/backend_barretenberg/classes/BarretenbergBackend.md
@@ -0,0 +1,138 @@
+# BarretenbergBackend
+
+## Implements
+
+- [`Backend`](../index.md#backend)
+- [`Backend`](../index.md#backend)
+
+## Constructors
+
+### new BarretenbergBackend(acirCircuit, options)
+
+```ts
+new BarretenbergBackend(acirCircuit, options): BarretenbergBackend
+```
+
+#### Parameters
+
+| Parameter | Type |
+| :------ | :------ |
+| `acirCircuit` | `CompiledCircuit` |
+| `options` | [`BackendOptions`](../type-aliases/BackendOptions.md) |
+
+#### Returns
+
+[`BarretenbergBackend`](BarretenbergBackend.md)
+
+## Properties
+
+| Property | Type | Description |
+| :------ | :------ | :------ |
+| `backend` | `UltraPlonkBackend` | - |
+
+## Methods
+
+### destroy()
+
+```ts
+destroy(): Promise<void>
+```
+
+#### Returns
+
+`Promise`\<`void`\>
+
+***
+
+### generateProof()
+
+```ts
+generateProof(compressedWitness): Promise<ProofData>
+```
+
+#### Parameters
+
+| Parameter | Type |
+| :------ | :------ |
+| `compressedWitness` | `Uint8Array` |
+
+#### Returns
+
+`Promise`\<`ProofData`\>
+
+#### Description
+
+Generates a proof
+
+***
+
+### generateRecursiveProofArtifacts()
+
+```ts
+generateRecursiveProofArtifacts(proofData, numOfPublicInputs): Promise<object>
+```
+
+Generates artifacts that will be passed to a circuit that will verify this proof.
+
+Instead of passing the proof and verification key as a byte array, we pass them
+as fields which makes it cheaper to verify in a circuit.
+
+The proof that is passed here will have been created using a circuit
+that has the #[recursive] attribute on its `main` method.
+
+The number of public inputs denotes how many public inputs are in the inner proof.
+
+#### Parameters
+
+| Parameter | Type | Default value |
+| :------ | :------ | :------ |
+| `proofData` | `ProofData` | `undefined` |
+| `numOfPublicInputs` | `number` | `0` |
+
+#### Returns
+
+`Promise`\<`object`\>
+
+#### Example
+
+```typescript
+const artifacts = await backend.generateRecursiveProofArtifacts(proof, numOfPublicInputs);
+```
+
+***
+
+### getVerificationKey()
+
+```ts
+getVerificationKey(): Promise<Uint8Array>
+```
+
+#### Returns
+
+`Promise`\<`Uint8Array`\>
+
+***
+
+### verifyProof()
+
+```ts
+verifyProof(proofData): Promise<boolean>
+```
+
+#### Parameters
+
+| Parameter | Type |
+| :------ | :------ |
+| `proofData` | `ProofData` |
+
+#### Returns
+
+`Promise`\<`boolean`\>
+
+#### Description
+
+Verifies a proof
+
+***
+
+Generated using [typedoc-plugin-markdown](https://www.npmjs.com/package/typedoc-plugin-markdown) and [TypeDoc](https://typedoc.org/)
diff --git a/docs/versioned_docs/version-v0.36.0/reference/NoirJS/backend_barretenberg/classes/BarretenbergVerifier.md b/docs/versioned_docs/version-v0.36.0/reference/NoirJS/backend_barretenberg/classes/BarretenbergVerifier.md
new file mode 100644
index 00000000000..500276ea748
--- /dev/null
+++ b/docs/versioned_docs/version-v0.36.0/reference/NoirJS/backend_barretenberg/classes/BarretenbergVerifier.md
@@ -0,0 +1,58 @@
+# BarretenbergVerifier
+
+## Constructors
+
+### new BarretenbergVerifier(options)
+
+```ts
+new BarretenbergVerifier(options): BarretenbergVerifier
+```
+
+#### Parameters
+
+| Parameter | Type |
+| :------ | :------ |
+| `options` | [`BackendOptions`](../type-aliases/BackendOptions.md) |
+
+#### Returns
+
+[`BarretenbergVerifier`](BarretenbergVerifier.md)
+
+## Methods
+
+### destroy()
+
+```ts
+destroy(): Promise<void>
+```
+
+#### Returns
+
+`Promise`\<`void`\>
+
+***
+
+### verifyProof()
+
+```ts
+verifyProof(proofData, verificationKey): Promise<boolean>
+```
+
+#### Parameters
+
+| Parameter | Type |
+| :------ | :------ |
+| `proofData` | `ProofData` |
+| `verificationKey` | `Uint8Array` |
+
+#### Returns
+
+`Promise`\<`boolean`\>
+
+#### Description
+
+Verifies a proof
+
+***
+
+Generated using [typedoc-plugin-markdown](https://www.npmjs.com/package/typedoc-plugin-markdown) and [TypeDoc](https://typedoc.org/)
diff --git a/docs/versioned_docs/version-v0.36.0/reference/NoirJS/backend_barretenberg/classes/UltraHonkBackend.md b/docs/versioned_docs/version-v0.36.0/reference/NoirJS/backend_barretenberg/classes/UltraHonkBackend.md
new file mode 100644
index 00000000000..204aaa18db6
--- /dev/null
+++ b/docs/versioned_docs/version-v0.36.0/reference/NoirJS/backend_barretenberg/classes/UltraHonkBackend.md
@@ -0,0 +1,114 @@
+# UltraHonkBackend
+
+## Implements
+
+- [`Backend`](../index.md#backend)
+- [`Backend`](../index.md#backend)
+
+## Constructors
+
+### new UltraHonkBackend(acirCircuit, options)
+
+```ts
+new UltraHonkBackend(acirCircuit, options): UltraHonkBackend
+```
+
+#### Parameters
+
+| Parameter | Type |
+| :------ | :------ |
+| `acirCircuit` | `CompiledCircuit` |
+| `options` | [`BackendOptions`](../type-aliases/BackendOptions.md) |
+
+#### Returns
+
+[`UltraHonkBackend`](UltraHonkBackend.md)
+
+## Properties
+
+| Property | Type | Description |
+| :------ | :------ | :------ |
+| `backend` | `UltraHonkBackend` | - |
+
+## Methods
+
+### destroy()
+
+```ts
+destroy(): Promise<void>
+```
+
+#### Returns
+
+`Promise`\<`void`\>
+
+***
+
+### generateProof()
+
+```ts
+generateProof(compressedWitness): Promise<ProofData>
+```
+
+#### Parameters
+
+| Parameter | Type |
+| :------ | :------ |
+| `compressedWitness` | `Uint8Array` |
+
+#### Returns
+
+`Promise`\<`ProofData`\>
+
+***
+
+### generateRecursiveProofArtifacts()
+
+```ts
+generateRecursiveProofArtifacts(proofData, numOfPublicInputs): Promise<object>
+```
+
+#### Parameters
+
+| Parameter | Type |
+| :------ | :------ |
+| `proofData` | `ProofData` |
+| `numOfPublicInputs` | `number` |
+
+#### Returns
+
+`Promise`\<`object`\>
+
+***
+
+### getVerificationKey()
+
+```ts
+getVerificationKey(): Promise<Uint8Array>
+```
+
+#### Returns
+
+`Promise`\<`Uint8Array`\>
+
+***
+
+### verifyProof()
+
+```ts
+verifyProof(proofData): Promise<boolean>
+```
+
+#### Parameters
+
+| Parameter | Type |
+| :------ | :------ |
+| `proofData` | `ProofData` |
+
+#### Returns
+
+`Promise`\<`boolean`\>
+
+***
+
+Generated using [typedoc-plugin-markdown](https://www.npmjs.com/package/typedoc-plugin-markdown) and [TypeDoc](https://typedoc.org/)
diff --git a/docs/versioned_docs/version-v0.36.0/reference/NoirJS/backend_barretenberg/classes/UltraHonkVerifier.md b/docs/versioned_docs/version-v0.36.0/reference/NoirJS/backend_barretenberg/classes/UltraHonkVerifier.md
new file mode 100644
index 00000000000..aee9460153f
--- /dev/null
+++ b/docs/versioned_docs/version-v0.36.0/reference/NoirJS/backend_barretenberg/classes/UltraHonkVerifier.md
@@ -0,0 +1,58 @@
+# UltraHonkVerifier
+
+## Constructors
+
+### new UltraHonkVerifier(options)
+
+```ts
+new UltraHonkVerifier(options): UltraHonkVerifier
+```
+
+#### Parameters
+
+| Parameter | Type |
+| :------ | :------ |
+| `options` | [`BackendOptions`](../type-aliases/BackendOptions.md) |
+
+#### Returns
+
+[`UltraHonkVerifier`](UltraHonkVerifier.md)
+
+## Methods
+
+### destroy()
+
+```ts
+destroy(): Promise<void>
+```
+
+#### Returns
+
+`Promise`\<`void`\>
+
+***
+
+### verifyProof()
+
+```ts
+verifyProof(proofData, verificationKey): Promise<boolean>
+```
+
+#### Parameters
+
+| Parameter | Type |
+| :------ | :------ |
+| `proofData` | `ProofData` |
+| `verificationKey` | `Uint8Array` |
+
+#### Returns
+
+`Promise`\<`boolean`\>
+
+#### Description
+
+Verifies a proof
+
+***
+
+Generated using [typedoc-plugin-markdown](https://www.npmjs.com/package/typedoc-plugin-markdown) and [TypeDoc](https://typedoc.org/)
diff --git a/docs/versioned_docs/version-v0.36.0/reference/NoirJS/backend_barretenberg/index.md b/docs/versioned_docs/version-v0.36.0/reference/NoirJS/backend_barretenberg/index.md
new file mode 100644
index 00000000000..4699e16dee6
--- /dev/null
+++ b/docs/versioned_docs/version-v0.36.0/reference/NoirJS/backend_barretenberg/index.md
@@ -0,0 +1,42 @@
+# backend_barretenberg
+
+## Exports
+
+### Classes
+
+| Class | Description |
+| :------ | :------ |
+| [BarretenbergBackend](classes/BarretenbergBackend.md) | - |
+| [BarretenbergVerifier](classes/BarretenbergVerifier.md) | - |
+| [UltraHonkBackend](classes/UltraHonkBackend.md) | - |
+| [UltraHonkVerifier](classes/UltraHonkVerifier.md) | - |
+
+### Type Aliases
+
+| Type alias | Description |
+| :------ | :------ |
+| [BackendOptions](type-aliases/BackendOptions.md) | - |
+
+## References
+
+### CompiledCircuit
+
+Renames and re-exports [Backend](index.md#backend)
+
+***
+
+### ProofData
+
+Renames and re-exports [Backend](index.md#backend)
+
+## Variables
+
+### Backend
+
+```ts
+Backend: any;
+```
+
+***
+
+Generated using [typedoc-plugin-markdown](https://www.npmjs.com/package/typedoc-plugin-markdown) and [TypeDoc](https://typedoc.org/)
diff --git a/docs/versioned_docs/version-v0.36.0/reference/NoirJS/backend_barretenberg/type-aliases/BackendOptions.md b/docs/versioned_docs/version-v0.36.0/reference/NoirJS/backend_barretenberg/type-aliases/BackendOptions.md
new file mode 100644
index 00000000000..1837bd4e205
--- /dev/null
+++ b/docs/versioned_docs/version-v0.36.0/reference/NoirJS/backend_barretenberg/type-aliases/BackendOptions.md
@@ -0,0 +1,19 @@
+# BackendOptions
+
+```ts
+type BackendOptions: object;
+```
+
+## Type declaration
+
+| Member | Type | Description |
+| :------ | :------ | :------ |
+| `crsPath` | `string` | **Description**<br /><br />Path to download CRS files |
+| `memory` | `object` | **Description**<br /><br />Initial and Maximum memory to be alloted to the backend worker |
+| `memory.initial` | `number` | - |
+| `memory.maximum` | `number` | - |
+| `threads` | `number` | **Description**<br /><br />Number of threads to run the backend worker on |
+
+***
+
+Generated using [typedoc-plugin-markdown](https://www.npmjs.com/package/typedoc-plugin-markdown) and [TypeDoc](https://typedoc.org/)
diff --git a/docs/versioned_docs/version-v0.36.0/reference/NoirJS/backend_barretenberg/typedoc-sidebar.cjs b/docs/versioned_docs/version-v0.36.0/reference/NoirJS/backend_barretenberg/typedoc-sidebar.cjs
new file mode 100644
index 00000000000..8ecf05c0163
--- /dev/null
+++ b/docs/versioned_docs/version-v0.36.0/reference/NoirJS/backend_barretenberg/typedoc-sidebar.cjs
@@ -0,0 +1,4 @@
+// @ts-check
+/** @type {import('@docusaurus/plugin-content-docs').SidebarsConfig} */
+const typedocSidebar = { items: [{"type":"category","label":"Classes","items":[{"type":"doc","id":"reference/NoirJS/backend_barretenberg/classes/BarretenbergBackend","label":"BarretenbergBackend"},{"type":"doc","id":"reference/NoirJS/backend_barretenberg/classes/BarretenbergVerifier","label":"BarretenbergVerifier"},{"type":"doc","id":"reference/NoirJS/backend_barretenberg/classes/UltraHonkBackend","label":"UltraHonkBackend"},{"type":"doc","id":"reference/NoirJS/backend_barretenberg/classes/UltraHonkVerifier","label":"UltraHonkVerifier"}]},{"type":"category","label":"Type Aliases","items":[{"type":"doc","id":"reference/NoirJS/backend_barretenberg/type-aliases/BackendOptions","label":"BackendOptions"}]}]};
+module.exports = typedocSidebar.items;
\ No newline at end of file
diff --git a/docs/versioned_docs/version-v0.36.0/reference/NoirJS/noir_js/.nojekyll b/docs/versioned_docs/version-v0.36.0/reference/NoirJS/noir_js/.nojekyll
new file mode 100644
index 00000000000..e2ac6616add
--- /dev/null
+++ b/docs/versioned_docs/version-v0.36.0/reference/NoirJS/noir_js/.nojekyll
@@ -0,0 +1 @@
+TypeDoc added this file to prevent GitHub Pages from using Jekyll. You can turn off this behavior by setting the `githubPages` option to false.
\ No newline at end of file
diff --git a/docs/versioned_docs/version-v0.36.0/reference/NoirJS/noir_js/classes/Noir.md b/docs/versioned_docs/version-v0.36.0/reference/NoirJS/noir_js/classes/Noir.md
new file mode 100644
index 00000000000..ead255bc504
--- /dev/null
+++ b/docs/versioned_docs/version-v0.36.0/reference/NoirJS/noir_js/classes/Noir.md
@@ -0,0 +1,52 @@
+# Noir
+
+## Constructors
+
+### new Noir(circuit)
+
+```ts
+new Noir(circuit): Noir
+```
+
+#### Parameters
+
+| Parameter | Type |
+| :------ | :------ |
+| `circuit` | `CompiledCircuit` |
+
+#### Returns
+
+[`Noir`](Noir.md)
+
+## Methods
+
+### execute()
+
+```ts
+execute(inputs, foreignCallHandler?): Promise<object>
+```
+
+#### Parameters
+
+| Parameter | Type |
+| :------ | :------ |
+| `inputs` | `InputMap` |
+| `foreignCallHandler`? | [`ForeignCallHandler`](../type-aliases/ForeignCallHandler.md) |
+
+#### Returns
+
+`Promise`\<`object`\>
+
+#### Description
+
+Allows to execute a circuit to get its witness and return value.
+
+#### Example
+
+```typescript
+async execute(inputs)
+```
+
+***
+
+Generated using [typedoc-plugin-markdown](https://www.npmjs.com/package/typedoc-plugin-markdown) and [TypeDoc](https://typedoc.org/)
diff --git a/docs/versioned_docs/version-v0.36.0/reference/NoirJS/noir_js/functions/and.md b/docs/versioned_docs/version-v0.36.0/reference/NoirJS/noir_js/functions/and.md
new file mode 100644
index 00000000000..c783283e396
--- /dev/null
+++ b/docs/versioned_docs/version-v0.36.0/reference/NoirJS/noir_js/functions/and.md
@@ -0,0 +1,22 @@
+# and()
+
+```ts
+and(lhs, rhs): string
+```
+
+Performs a bitwise AND operation between `lhs` and `rhs`
+
+## Parameters
+
+| Parameter | Type | Description |
+| :------ | :------ | :------ |
+| `lhs` | `string` |  |
+| `rhs` | `string` |  |
+
+## Returns
+
+`string`
+
+***
+
+Generated using [typedoc-plugin-markdown](https://www.npmjs.com/package/typedoc-plugin-markdown) and [TypeDoc](https://typedoc.org/)
diff --git a/docs/versioned_docs/version-v0.36.0/reference/NoirJS/noir_js/functions/blake2s256.md b/docs/versioned_docs/version-v0.36.0/reference/NoirJS/noir_js/functions/blake2s256.md
new file mode 100644
index 00000000000..7882d0da8d5
--- /dev/null
+++ b/docs/versioned_docs/version-v0.36.0/reference/NoirJS/noir_js/functions/blake2s256.md
@@ -0,0 +1,21 @@
+# blake2s256()
+
+```ts
+blake2s256(inputs): Uint8Array
+```
+
+Calculates the Blake2s256 hash of the input bytes
+
+## Parameters
+
+| Parameter | Type | Description |
+| :------ | :------ | :------ |
+| `inputs` | `Uint8Array` |  |
+
+## Returns
+
+`Uint8Array`
+
+***
+
+Generated using [typedoc-plugin-markdown](https://www.npmjs.com/package/typedoc-plugin-markdown) and [TypeDoc](https://typedoc.org/)
diff --git a/docs/versioned_docs/version-v0.36.0/reference/NoirJS/noir_js/functions/ecdsa_secp256k1_verify.md b/docs/versioned_docs/version-v0.36.0/reference/NoirJS/noir_js/functions/ecdsa_secp256k1_verify.md
new file mode 100644
index 00000000000..5e3cd53e9d3
--- /dev/null
+++ b/docs/versioned_docs/version-v0.36.0/reference/NoirJS/noir_js/functions/ecdsa_secp256k1_verify.md
@@ -0,0 +1,28 @@
+# ecdsa\_secp256k1\_verify()
+
+```ts
+ecdsa_secp256k1_verify(
+   hashed_msg, 
+   public_key_x_bytes, 
+   public_key_y_bytes, 
+   signature): boolean
+```
+
+Verifies a ECDSA signature over the secp256k1 curve.
+
+## Parameters
+
+| Parameter | Type | Description |
+| :------ | :------ | :------ |
+| `hashed_msg` | `Uint8Array` |  |
+| `public_key_x_bytes` | `Uint8Array` |  |
+| `public_key_y_bytes` | `Uint8Array` |  |
+| `signature` | `Uint8Array` |  |
+
+## Returns
+
+`boolean`
+
+***
+
+Generated using [typedoc-plugin-markdown](https://www.npmjs.com/package/typedoc-plugin-markdown) and [TypeDoc](https://typedoc.org/)
diff --git a/docs/versioned_docs/version-v0.36.0/reference/NoirJS/noir_js/functions/ecdsa_secp256r1_verify.md b/docs/versioned_docs/version-v0.36.0/reference/NoirJS/noir_js/functions/ecdsa_secp256r1_verify.md
new file mode 100644
index 00000000000..0b20ff68957
--- /dev/null
+++ b/docs/versioned_docs/version-v0.36.0/reference/NoirJS/noir_js/functions/ecdsa_secp256r1_verify.md
@@ -0,0 +1,28 @@
+# ecdsa\_secp256r1\_verify()
+
+```ts
+ecdsa_secp256r1_verify(
+   hashed_msg, 
+   public_key_x_bytes, 
+   public_key_y_bytes, 
+   signature): boolean
+```
+
+Verifies a ECDSA signature over the secp256r1 curve.
+
+## Parameters
+
+| Parameter | Type | Description |
+| :------ | :------ | :------ |
+| `hashed_msg` | `Uint8Array` |  |
+| `public_key_x_bytes` | `Uint8Array` |  |
+| `public_key_y_bytes` | `Uint8Array` |  |
+| `signature` | `Uint8Array` |  |
+
+## Returns
+
+`boolean`
+
+***
+
+Generated using [typedoc-plugin-markdown](https://www.npmjs.com/package/typedoc-plugin-markdown) and [TypeDoc](https://typedoc.org/)
diff --git a/docs/versioned_docs/version-v0.36.0/reference/NoirJS/noir_js/functions/xor.md b/docs/versioned_docs/version-v0.36.0/reference/NoirJS/noir_js/functions/xor.md
new file mode 100644
index 00000000000..8d762b895d3
--- /dev/null
+++ b/docs/versioned_docs/version-v0.36.0/reference/NoirJS/noir_js/functions/xor.md
@@ -0,0 +1,22 @@
+# xor()
+
+```ts
+xor(lhs, rhs): string
+```
+
+Performs a bitwise XOR operation between `lhs` and `rhs`
+
+## Parameters
+
+| Parameter | Type | Description |
+| :------ | :------ | :------ |
+| `lhs` | `string` |  |
+| `rhs` | `string` |  |
+
+## Returns
+
+`string`
+
+***
+
+Generated using [typedoc-plugin-markdown](https://www.npmjs.com/package/typedoc-plugin-markdown) and [TypeDoc](https://typedoc.org/)
diff --git a/docs/versioned_docs/version-v0.36.0/reference/NoirJS/noir_js/index.md b/docs/versioned_docs/version-v0.36.0/reference/NoirJS/noir_js/index.md
new file mode 100644
index 00000000000..4de7a696991
--- /dev/null
+++ b/docs/versioned_docs/version-v0.36.0/reference/NoirJS/noir_js/index.md
@@ -0,0 +1,47 @@
+# noir_js
+
+## Exports
+
+### Classes
+
+| Class | Description |
+| :------ | :------ |
+| [Noir](classes/Noir.md) | - |
+
+### Type Aliases
+
+| Type alias | Description |
+| :------ | :------ |
+| [ErrorWithPayload](type-aliases/ErrorWithPayload.md) | - |
+| [ForeignCallHandler](type-aliases/ForeignCallHandler.md) | A callback which performs an foreign call and returns the response. |
+| [ForeignCallInput](type-aliases/ForeignCallInput.md) | - |
+| [ForeignCallOutput](type-aliases/ForeignCallOutput.md) | - |
+| [WitnessMap](type-aliases/WitnessMap.md) | - |
+
+### Functions
+
+| Function | Description |
+| :------ | :------ |
+| [and](functions/and.md) | Performs a bitwise AND operation between `lhs` and `rhs` |
+| [blake2s256](functions/blake2s256.md) | Calculates the Blake2s256 hash of the input bytes |
+| [ecdsa\_secp256k1\_verify](functions/ecdsa_secp256k1_verify.md) | Verifies a ECDSA signature over the secp256k1 curve. |
+| [ecdsa\_secp256r1\_verify](functions/ecdsa_secp256r1_verify.md) | Verifies a ECDSA signature over the secp256r1 curve. |
+| [xor](functions/xor.md) | Performs a bitwise XOR operation between `lhs` and `rhs` |
+
+## References
+
+### CompiledCircuit
+
+Renames and re-exports [InputMap](index.md#inputmap)
+
+## Variables
+
+### InputMap
+
+```ts
+InputMap: any;
+```
+
+***
+
+Generated using [typedoc-plugin-markdown](https://www.npmjs.com/package/typedoc-plugin-markdown) and [TypeDoc](https://typedoc.org/)
diff --git a/docs/versioned_docs/version-v0.36.0/reference/NoirJS/noir_js/type-aliases/ErrorWithPayload.md b/docs/versioned_docs/version-v0.36.0/reference/NoirJS/noir_js/type-aliases/ErrorWithPayload.md
new file mode 100644
index 00000000000..e8c2f4aef3d
--- /dev/null
+++ b/docs/versioned_docs/version-v0.36.0/reference/NoirJS/noir_js/type-aliases/ErrorWithPayload.md
@@ -0,0 +1,15 @@
+# ErrorWithPayload
+
+```ts
+type ErrorWithPayload: ExecutionError & object;
+```
+
+## Type declaration
+
+| Member | Type | Description |
+| :------ | :------ | :------ |
+| `decodedAssertionPayload` | `any` | - |
+
+***
+
+Generated using [typedoc-plugin-markdown](https://www.npmjs.com/package/typedoc-plugin-markdown) and [TypeDoc](https://typedoc.org/)
diff --git a/docs/versioned_docs/version-v0.36.0/reference/NoirJS/noir_js/type-aliases/ForeignCallHandler.md b/docs/versioned_docs/version-v0.36.0/reference/NoirJS/noir_js/type-aliases/ForeignCallHandler.md
new file mode 100644
index 00000000000..812b8b16481
--- /dev/null
+++ b/docs/versioned_docs/version-v0.36.0/reference/NoirJS/noir_js/type-aliases/ForeignCallHandler.md
@@ -0,0 +1,24 @@
+# ForeignCallHandler
+
+```ts
+type ForeignCallHandler: (name, inputs) => Promise<ForeignCallOutput[]>;
+```
+
+A callback which performs an foreign call and returns the response.
+
+## Parameters
+
+| Parameter | Type | Description |
+| :------ | :------ | :------ |
+| `name` | `string` | The identifier for the type of foreign call being performed. |
+| `inputs` | [`ForeignCallInput`](ForeignCallInput.md)[] | An array of hex encoded inputs to the foreign call. |
+
+## Returns
+
+`Promise`\<[`ForeignCallOutput`](ForeignCallOutput.md)[]\>
+
+outputs - An array of hex encoded outputs containing the results of the foreign call.
+
+***
+
+Generated using [typedoc-plugin-markdown](https://www.npmjs.com/package/typedoc-plugin-markdown) and [TypeDoc](https://typedoc.org/)
diff --git a/docs/versioned_docs/version-v0.36.0/reference/NoirJS/noir_js/type-aliases/ForeignCallInput.md b/docs/versioned_docs/version-v0.36.0/reference/NoirJS/noir_js/type-aliases/ForeignCallInput.md
new file mode 100644
index 00000000000..dd95809186a
--- /dev/null
+++ b/docs/versioned_docs/version-v0.36.0/reference/NoirJS/noir_js/type-aliases/ForeignCallInput.md
@@ -0,0 +1,9 @@
+# ForeignCallInput
+
+```ts
+type ForeignCallInput: string[];
+```
+
+***
+
+Generated using [typedoc-plugin-markdown](https://www.npmjs.com/package/typedoc-plugin-markdown) and [TypeDoc](https://typedoc.org/)
diff --git a/docs/versioned_docs/version-v0.36.0/reference/NoirJS/noir_js/type-aliases/ForeignCallOutput.md b/docs/versioned_docs/version-v0.36.0/reference/NoirJS/noir_js/type-aliases/ForeignCallOutput.md
new file mode 100644
index 00000000000..b71fb78a946
--- /dev/null
+++ b/docs/versioned_docs/version-v0.36.0/reference/NoirJS/noir_js/type-aliases/ForeignCallOutput.md
@@ -0,0 +1,9 @@
+# ForeignCallOutput
+
+```ts
+type ForeignCallOutput: string | string[];
+```
+
+***
+
+Generated using [typedoc-plugin-markdown](https://www.npmjs.com/package/typedoc-plugin-markdown) and [TypeDoc](https://typedoc.org/)
diff --git a/docs/versioned_docs/version-v0.36.0/reference/NoirJS/noir_js/type-aliases/WitnessMap.md b/docs/versioned_docs/version-v0.36.0/reference/NoirJS/noir_js/type-aliases/WitnessMap.md
new file mode 100644
index 00000000000..258c46f9d0c
--- /dev/null
+++ b/docs/versioned_docs/version-v0.36.0/reference/NoirJS/noir_js/type-aliases/WitnessMap.md
@@ -0,0 +1,9 @@
+# WitnessMap
+
+```ts
+type WitnessMap: Map<number, string>;
+```
+
+***
+
+Generated using [typedoc-plugin-markdown](https://www.npmjs.com/package/typedoc-plugin-markdown) and [TypeDoc](https://typedoc.org/)
diff --git a/docs/versioned_docs/version-v0.36.0/reference/NoirJS/noir_js/typedoc-sidebar.cjs b/docs/versioned_docs/version-v0.36.0/reference/NoirJS/noir_js/typedoc-sidebar.cjs
new file mode 100644
index 00000000000..4796b5abaa8
--- /dev/null
+++ b/docs/versioned_docs/version-v0.36.0/reference/NoirJS/noir_js/typedoc-sidebar.cjs
@@ -0,0 +1,4 @@
+// @ts-check
+/** @type {import('@docusaurus/plugin-content-docs').SidebarsConfig} */
+const typedocSidebar = { items: [{"type":"category","label":"Classes","items":[{"type":"doc","id":"reference/NoirJS/noir_js/classes/Noir","label":"Noir"}]},{"type":"category","label":"Type Aliases","items":[{"type":"doc","id":"reference/NoirJS/noir_js/type-aliases/ErrorWithPayload","label":"ErrorWithPayload"},{"type":"doc","id":"reference/NoirJS/noir_js/type-aliases/ForeignCallHandler","label":"ForeignCallHandler"},{"type":"doc","id":"reference/NoirJS/noir_js/type-aliases/ForeignCallInput","label":"ForeignCallInput"},{"type":"doc","id":"reference/NoirJS/noir_js/type-aliases/ForeignCallOutput","label":"ForeignCallOutput"},{"type":"doc","id":"reference/NoirJS/noir_js/type-aliases/WitnessMap","label":"WitnessMap"}]},{"type":"category","label":"Functions","items":[{"type":"doc","id":"reference/NoirJS/noir_js/functions/and","label":"and"},{"type":"doc","id":"reference/NoirJS/noir_js/functions/blake2s256","label":"blake2s256"},{"type":"doc","id":"reference/NoirJS/noir_js/functions/ecdsa_secp256k1_verify","label":"ecdsa_secp256k1_verify"},{"type":"doc","id":"reference/NoirJS/noir_js/functions/ecdsa_secp256r1_verify","label":"ecdsa_secp256r1_verify"},{"type":"doc","id":"reference/NoirJS/noir_js/functions/xor","label":"xor"}]}]};
+module.exports = typedocSidebar.items;
\ No newline at end of file
diff --git a/docs/versioned_docs/version-v0.36.0/reference/NoirJS/noir_wasm/.nojekyll b/docs/versioned_docs/version-v0.36.0/reference/NoirJS/noir_wasm/.nojekyll
new file mode 100644
index 00000000000..e2ac6616add
--- /dev/null
+++ b/docs/versioned_docs/version-v0.36.0/reference/NoirJS/noir_wasm/.nojekyll
@@ -0,0 +1 @@
+TypeDoc added this file to prevent GitHub Pages from using Jekyll. You can turn off this behavior by setting the `githubPages` option to false.
\ No newline at end of file
diff --git a/docs/versioned_docs/version-v0.36.0/reference/NoirJS/noir_wasm/functions/compile.md b/docs/versioned_docs/version-v0.36.0/reference/NoirJS/noir_wasm/functions/compile.md
new file mode 100644
index 00000000000..6faf763b37f
--- /dev/null
+++ b/docs/versioned_docs/version-v0.36.0/reference/NoirJS/noir_wasm/functions/compile.md
@@ -0,0 +1,51 @@
+# compile()
+
+```ts
+compile(
+   fileManager, 
+   projectPath?, 
+   logFn?, 
+debugLogFn?): Promise<ProgramCompilationArtifacts>
+```
+
+Compiles a Noir project
+
+## Parameters
+
+| Parameter | Type | Description |
+| :------ | :------ | :------ |
+| `fileManager` | `FileManager` | The file manager to use |
+| `projectPath`? | `string` | The path to the project inside the file manager. Defaults to the root of the file manager |
+| `logFn`? | `LogFn` | A logging function. If not provided, console.log will be used |
+| `debugLogFn`? | `LogFn` | A debug logging function. If not provided, logFn will be used |
+
+## Returns
+
+`Promise`\<[`ProgramCompilationArtifacts`](../index.md#programcompilationartifacts)\>
+
+## Example
+
+```typescript
+// Node.js
+
+import { compile_program, createFileManager } from '@noir-lang/noir_wasm';
+
+const fm = createFileManager(myProjectPath);
+const myCompiledCode = await compile_program(fm);
+```
+
+```typescript
+// Browser
+
+import { compile_program, createFileManager } from '@noir-lang/noir_wasm';
+
+const fm = createFileManager('/');
+for (const path of files) {
+  await fm.writeFile(path, await getFileAsStream(path));
+}
+const myCompiledCode = await compile_program(fm);
+```
+
+***
+
+Generated using [typedoc-plugin-markdown](https://www.npmjs.com/package/typedoc-plugin-markdown) and [TypeDoc](https://typedoc.org/)
diff --git a/docs/versioned_docs/version-v0.36.0/reference/NoirJS/noir_wasm/functions/compile_contract.md b/docs/versioned_docs/version-v0.36.0/reference/NoirJS/noir_wasm/functions/compile_contract.md
new file mode 100644
index 00000000000..7d0b39a43ef
--- /dev/null
+++ b/docs/versioned_docs/version-v0.36.0/reference/NoirJS/noir_wasm/functions/compile_contract.md
@@ -0,0 +1,51 @@
+# compile\_contract()
+
+```ts
+compile_contract(
+   fileManager, 
+   projectPath?, 
+   logFn?, 
+debugLogFn?): Promise<ContractCompilationArtifacts>
+```
+
+Compiles a Noir project
+
+## Parameters
+
+| Parameter | Type | Description |
+| :------ | :------ | :------ |
+| `fileManager` | `FileManager` | The file manager to use |
+| `projectPath`? | `string` | The path to the project inside the file manager. Defaults to the root of the file manager |
+| `logFn`? | `LogFn` | A logging function. If not provided, console.log will be used |
+| `debugLogFn`? | `LogFn` | A debug logging function. If not provided, logFn will be used |
+
+## Returns
+
+`Promise`\<[`ContractCompilationArtifacts`](../index.md#contractcompilationartifacts)\>
+
+## Example
+
+```typescript
+// Node.js
+
+import { compile_contract, createFileManager } from '@noir-lang/noir_wasm';
+
+const fm = createFileManager(myProjectPath);
+const myCompiledCode = await compile_contract(fm);
+```
+
+```typescript
+// Browser
+
+import { compile_contract, createFileManager } from '@noir-lang/noir_wasm';
+
+const fm = createFileManager('/');
+for (const path of files) {
+  await fm.writeFile(path, await getFileAsStream(path));
+}
+const myCompiledCode = await compile_contract(fm);
+```
+
+***
+
+Generated using [typedoc-plugin-markdown](https://www.npmjs.com/package/typedoc-plugin-markdown) and [TypeDoc](https://typedoc.org/)
diff --git a/docs/versioned_docs/version-v0.36.0/reference/NoirJS/noir_wasm/functions/createFileManager.md b/docs/versioned_docs/version-v0.36.0/reference/NoirJS/noir_wasm/functions/createFileManager.md
new file mode 100644
index 00000000000..7e65c1d69c7
--- /dev/null
+++ b/docs/versioned_docs/version-v0.36.0/reference/NoirJS/noir_wasm/functions/createFileManager.md
@@ -0,0 +1,21 @@
+# createFileManager()
+
+```ts
+createFileManager(dataDir): FileManager
+```
+
+Creates a new FileManager instance based on fs in node and memfs in the browser (via webpack alias)
+
+## Parameters
+
+| Parameter | Type | Description |
+| :------ | :------ | :------ |
+| `dataDir` | `string` | root of the file system |
+
+## Returns
+
+`FileManager`
+
+***
+
+Generated using [typedoc-plugin-markdown](https://www.npmjs.com/package/typedoc-plugin-markdown) and [TypeDoc](https://typedoc.org/)
diff --git a/docs/versioned_docs/version-v0.36.0/reference/NoirJS/noir_wasm/functions/inflateDebugSymbols.md b/docs/versioned_docs/version-v0.36.0/reference/NoirJS/noir_wasm/functions/inflateDebugSymbols.md
new file mode 100644
index 00000000000..fcea9275341
--- /dev/null
+++ b/docs/versioned_docs/version-v0.36.0/reference/NoirJS/noir_wasm/functions/inflateDebugSymbols.md
@@ -0,0 +1,21 @@
+# inflateDebugSymbols()
+
+```ts
+inflateDebugSymbols(debugSymbols): any
+```
+
+Decompresses and decodes the debug symbols
+
+## Parameters
+
+| Parameter | Type | Description |
+| :------ | :------ | :------ |
+| `debugSymbols` | `string` | The base64 encoded debug symbols |
+
+## Returns
+
+`any`
+
+***
+
+Generated using [typedoc-plugin-markdown](https://www.npmjs.com/package/typedoc-plugin-markdown) and [TypeDoc](https://typedoc.org/)
diff --git a/docs/versioned_docs/version-v0.36.0/reference/NoirJS/noir_wasm/index.md b/docs/versioned_docs/version-v0.36.0/reference/NoirJS/noir_wasm/index.md
new file mode 100644
index 00000000000..b6e0f9d1bc0
--- /dev/null
+++ b/docs/versioned_docs/version-v0.36.0/reference/NoirJS/noir_wasm/index.md
@@ -0,0 +1,49 @@
+# noir_wasm
+
+## Exports
+
+### Functions
+
+| Function | Description |
+| :------ | :------ |
+| [compile](functions/compile.md) | Compiles a Noir project |
+| [compile\_contract](functions/compile_contract.md) | Compiles a Noir project |
+| [createFileManager](functions/createFileManager.md) | Creates a new FileManager instance based on fs in node and memfs in the browser (via webpack alias) |
+| [inflateDebugSymbols](functions/inflateDebugSymbols.md) | Decompresses and decodes the debug symbols |
+
+## References
+
+### compile\_program
+
+Renames and re-exports [compile](functions/compile.md)
+
+## Interfaces
+
+### ContractCompilationArtifacts
+
+The compilation artifacts of a given contract.
+
+#### Properties
+
+| Property | Type | Description |
+| :------ | :------ | :------ |
+| `contract` | `ContractArtifact` | The compiled contract. |
+| `warnings` | `unknown`[] | Compilation warnings. |
+
+***
+
+### ProgramCompilationArtifacts
+
+The compilation artifacts of a given program.
+
+#### Properties
+
+| Property | Type | Description |
+| :------ | :------ | :------ |
+| `name` | `string` | not part of the compilation output, injected later |
+| `program` | `ProgramArtifact` | The compiled contract. |
+| `warnings` | `unknown`[] | Compilation warnings. |
+
+***
+
+Generated using [typedoc-plugin-markdown](https://www.npmjs.com/package/typedoc-plugin-markdown) and [TypeDoc](https://typedoc.org/)
diff --git a/docs/versioned_docs/version-v0.36.0/reference/NoirJS/noir_wasm/typedoc-sidebar.cjs b/docs/versioned_docs/version-v0.36.0/reference/NoirJS/noir_wasm/typedoc-sidebar.cjs
new file mode 100644
index 00000000000..e0870710349
--- /dev/null
+++ b/docs/versioned_docs/version-v0.36.0/reference/NoirJS/noir_wasm/typedoc-sidebar.cjs
@@ -0,0 +1,4 @@
+// @ts-check
+/** @type {import('@docusaurus/plugin-content-docs').SidebarsConfig} */
+const typedocSidebar = { items: [{"type":"doc","id":"reference/NoirJS/noir_wasm/index","label":"API"},{"type":"category","label":"Functions","items":[{"type":"doc","id":"reference/NoirJS/noir_wasm/functions/compile","label":"compile"},{"type":"doc","id":"reference/NoirJS/noir_wasm/functions/compile_contract","label":"compile_contract"},{"type":"doc","id":"reference/NoirJS/noir_wasm/functions/createFileManager","label":"createFileManager"},{"type":"doc","id":"reference/NoirJS/noir_wasm/functions/inflateDebugSymbols","label":"inflateDebugSymbols"}]}]};
+module.exports = typedocSidebar.items;
\ No newline at end of file
diff --git a/docs/versioned_docs/version-v0.36.0/reference/_category_.json b/docs/versioned_docs/version-v0.36.0/reference/_category_.json
new file mode 100644
index 00000000000..5b6a20a609a
--- /dev/null
+++ b/docs/versioned_docs/version-v0.36.0/reference/_category_.json
@@ -0,0 +1,5 @@
+{
+    "position": 4,
+    "collapsible": true,
+    "collapsed": true
+}
diff --git a/docs/versioned_docs/version-v0.36.0/reference/debugger/_category_.json b/docs/versioned_docs/version-v0.36.0/reference/debugger/_category_.json
new file mode 100644
index 00000000000..186aeb3654e
--- /dev/null
+++ b/docs/versioned_docs/version-v0.36.0/reference/debugger/_category_.json
@@ -0,0 +1,6 @@
+{
+  "label": "Debugger",
+  "position": 1,
+  "collapsible": true,
+  "collapsed": true
+}
diff --git a/docs/versioned_docs/version-v0.36.0/reference/debugger/debugger_known_limitations.md b/docs/versioned_docs/version-v0.36.0/reference/debugger/debugger_known_limitations.md
new file mode 100644
index 00000000000..936d416ac4b
--- /dev/null
+++ b/docs/versioned_docs/version-v0.36.0/reference/debugger/debugger_known_limitations.md
@@ -0,0 +1,59 @@
+---
+title: Known limitations
+description:
+  An overview of known limitations of the current version of the Noir debugger
+keywords:
+  [
+    Nargo,
+    Noir Debugger,
+    VS Code,
+  ]
+sidebar_position: 2
+---
+
+# Debugger Known Limitations
+
+There are currently some limits to what the debugger can observe. 
+
+## Mutable references
+
+The debugger is currently blind to any state mutated via a mutable reference. For example, in:
+
+```
+let mut x = 1;
+let y = &mut x;
+*y = 2;
+```
+
+The update on `x` will not be observed by the debugger. That means, when running `vars` from the debugger REPL, or inspecting the _local variables_ pane in the VS Code debugger, `x` will appear with value 1 despite having executed `*y = 2;`.
+
+## Variables of type function or mutable references are opaque
+
+When inspecting variables, any variable of type `Function` or `MutableReference` will render its value as `<<function>>` or `<<mutable ref>>`.
+
+## Debugger instrumentation affects resulting ACIR
+                      
+In order to make the state of local variables observable, the debugger compiles Noir circuits interleaving foreign calls that track any mutations to them. While this works (except in the cases described above) and doesn't introduce any behavior changes, it does as a side effect produce bigger bytecode. In particular, when running the command `opcodes` on the REPL debugger, you will notice Unconstrained VM blocks that look like this:
+
+```
+...
+5    BRILLIG inputs=[Single(Expression { mul_terms: [], linear_combinations: [], q_c: 2 }), Single(Expression { mul_terms: [], linear_combinations: [(1, Witness(2))], q_c: 0 })]
+       |       outputs=[]
+  5.0  |   Mov { destination: RegisterIndex(2), source: RegisterIndex(0) }
+  5.1  |   Mov { destination: RegisterIndex(3), source: RegisterIndex(1) }
+  5.2  |   Const { destination: RegisterIndex(0), value: Value { inner: 0 } }
+  5.3  |   Const { destination: RegisterIndex(1), value: Value { inner: 0 } }
+  5.4  |   Mov { destination: RegisterIndex(2), source: RegisterIndex(2) }
+  5.5  |   Mov { destination: RegisterIndex(3), source: RegisterIndex(3) }
+  5.6  |   Call { location: 8 }
+  5.7  |   Stop
+  5.8  |   ForeignCall { function: "__debug_var_assign", destinations: [], inputs: [RegisterIndex(RegisterIndex(2)), RegisterIndex(RegisterIndex(3))] }
+...
+```               
+                                    
+If you are interested in debugging/inspecting compiled ACIR without these synthetic changes, you can invoke the REPL debugger with the `--skip-instrumentation` flag or launch the VS Code debugger with the `skipConfiguration` property set to true in its launch configuration. You can find more details about those in the [Debugger REPL reference](debugger_repl.md) and the [VS Code Debugger reference](debugger_vscode.md).
+
+:::note
+Skipping debugger instrumentation means you won't be able to inspect values of local variables.
+:::
+
diff --git a/docs/versioned_docs/version-v0.36.0/reference/debugger/debugger_repl.md b/docs/versioned_docs/version-v0.36.0/reference/debugger/debugger_repl.md
new file mode 100644
index 00000000000..46e2011304e
--- /dev/null
+++ b/docs/versioned_docs/version-v0.36.0/reference/debugger/debugger_repl.md
@@ -0,0 +1,360 @@
+---
+title: REPL Debugger
+description:
+  Noir Debugger REPL options and commands. 
+keywords:
+  [
+    Nargo,
+    Noir CLI,
+    Noir Debugger,
+    REPL,
+  ]
+sidebar_position: 1
+---
+
+## Running the REPL debugger
+
+`nargo debug [OPTIONS] [WITNESS_NAME]`
+
+Runs the Noir REPL debugger. If a `WITNESS_NAME` is provided the debugger writes the resulting execution witness to a `WITNESS_NAME` file.
+
+### Options
+
+| Option                | Description                                                  |
+| --------------------- | ------------------------------------------------------------ |
+| `-p, --prover-name <PROVER_NAME>` | The name of the toml file which contains the inputs for the prover [default: Prover]|
+| `--package <PACKAGE>` | The name of the package to debug                             |
+| `--print-acir`        | Display the ACIR for compiled circuit                        |
+| `--deny-warnings`     | Treat all warnings as errors                                 |
+| `--silence-warnings`  | Suppress warnings                                            |
+| `-h, --help`          | Print help                                                   |
+
+None of these options are required.
+
+:::note
+Since the debugger starts by compiling the target package, all Noir compiler options are also available. Check out the [compiler reference](../nargo_commands.md#nargo-compile) to learn more about the compiler options.
+:::
+
+## REPL commands
+
+Once the debugger is running, it accepts the following commands.
+
+#### `help` (h)
+
+Displays the menu of available commands.
+
+```
+> help
+Available commands:
+
+  opcodes                          display ACIR opcodes
+  into                             step into to the next opcode
+  next                             step until a new source location is reached
+  out                              step until a new source location is reached
+                                   and the current stack frame is finished
+  break LOCATION:OpcodeLocation    add a breakpoint at an opcode location
+  over                             step until a new source location is reached
+                                   without diving into function calls
+  restart                          restart the debugging session
+  delete LOCATION:OpcodeLocation   delete breakpoint at an opcode location
+  witness                          show witness map
+  witness index:u32                display a single witness from the witness map
+  witness index:u32 value:String   update a witness with the given value
+  memset index:usize value:String  update a memory cell with the given
+                                   value
+  continue                         continue execution until the end of the
+                                   program
+  vars                             show variable values available at this point
+                                   in execution
+  stacktrace                       display the current stack trace
+  memory                           show memory (valid when executing unconstrained code)                                 value
+  step                             step to the next ACIR opcode
+
+Other commands:
+
+  help  Show this help message
+  quit  Quit repl
+
+```
+
+### Stepping through programs
+
+#### `next` (n)
+
+Step until the next Noir source code location. While other commands, such as [`into`](#into-i) and [`step`](#step-s), allow for finer grained control of the program's execution at the opcode level, `next` is source code centric. For example:
+
+```
+3    ...
+4    fn main(x: u32) {
+5        assert(entry_point(x) == 2);
+6        swap_entry_point(x, x + 1);
+7 ->     assert(deep_entry_point(x) == 4);
+8        multiple_values_entry_point(x);
+9    }
+```
+
+
+Using `next` here would cause the debugger to jump to the definition of `deep_entry_point` (if available). 
+
+If you want to step over `deep_entry_point` and go straight to line 8, use [the `over` command](#over) instead.
+
+#### `over`
+
+Step until the next source code location, without diving into function calls. For example:
+
+```
+3    ...
+4    fn main(x: u32) {
+5        assert(entry_point(x) == 2);
+6        swap_entry_point(x, x + 1);
+7 ->     assert(deep_entry_point(x) == 4);
+8        multiple_values_entry_point(x);
+9    }
+```
+
+
+Using `over` here would cause the debugger to execute until line 8 (`multiple_values_entry_point(x);`).
+
+If you want to step into `deep_entry_point` instead, use [the `next` command](#next-n).
+
+#### `out`
+
+Step until the end of the current function call. For example:
+
+```
+  3    ...
+  4    fn main(x: u32) {
+  5        assert(entry_point(x) == 2);
+  6        swap_entry_point(x, x + 1);
+  7 ->     assert(deep_entry_point(x) == 4);
+  8        multiple_values_entry_point(x);
+  9    }
+ 10    
+ 11    unconstrained fn returns_multiple_values(x: u32) -> (u32, u32, u32, u32) {
+ 12    ...
+ ...
+ 55    
+ 56    unconstrained fn deep_entry_point(x: u32) -> u32 {
+ 57 ->     level_1(x + 1)
+ 58    }
+
+```
+
+Running `out` here will resume execution until line 8.
+
+#### `step` (s)
+
+Skips to the next ACIR code. A compiled Noir program is a sequence of ACIR opcodes. However, an unconstrained VM opcode denotes the start of an unconstrained code block, to be executed by the unconstrained VM. For example (redacted for brevity):
+
+```
+0  BLACKBOX::RANGE [(_0, num_bits: 32)] [ ]
+1 ->  BRILLIG inputs=[Single(Expression { mul_terms: [], linear_combinations: [(1, Witness(0))], q_c: 0 })] outputs=[Simple(Witness(1))]
+	1.0  |   Mov { destination: RegisterIndex(2), source: RegisterIndex(0) }
+	1.1  |   Const { destination: RegisterIndex(0), value: Value { inner: 0 } }
+	1.2  |   Const { destination: RegisterIndex(1), value: Value { inner: 0 } }
+	1.3  |   Mov { destination: RegisterIndex(2), source: RegisterIndex(2) }
+	1.4  |   Call { location: 7 }
+	...
+	1.43 |   Return
+2    EXPR [ (1, _1) -2 ]
+```
+
+The `->` here shows the debugger paused at an ACIR opcode: `BRILLIG`, at index 1, which denotes an unconstrained code block is about to start.
+
+Using the `step` command at this point would result in the debugger stopping at ACIR opcode 2, `EXPR`, skipping unconstrained computation steps.
+
+Use [the `into` command](#into-i) instead if you want to follow unconstrained computation step by step.
+
+#### `into` (i)
+
+Steps into the next opcode. A compiled Noir program is a sequence of ACIR opcodes. However, a BRILLIG opcode denotes the start of an unconstrained code block, to be executed by the unconstrained VM. For example (redacted for brevity):
+
+```
+0  BLACKBOX::RANGE [(_0, num_bits: 32)] [ ]
+1 ->  BRILLIG inputs=[Single(Expression { mul_terms: [], linear_combinations: [(1, Witness(0))], q_c: 0 })] outputs=[Simple(Witness(1))]
+	1.0  |   Mov { destination: RegisterIndex(2), source: RegisterIndex(0) }
+	1.1  |   Const { destination: RegisterIndex(0), value: Value { inner: 0 } }
+	1.2  |   Const { destination: RegisterIndex(1), value: Value { inner: 0 } }
+	1.3  |   Mov { destination: RegisterIndex(2), source: RegisterIndex(2) }
+	1.4  |   Call { location: 7 }
+	...
+	1.43 |   Return
+2    EXPR [ (1, _1) -2 ]
+``` 
+
+The `->` here shows the debugger paused at an ACIR opcode: `BRILLIG`, at index 1, which denotes an unconstrained code block is about to start.
+
+Using the `into` command at this point would result in the debugger stopping at opcode 1.0, `Mov ...`, allowing the debugger user to follow unconstrained computation step by step.
+
+Use [the `step` command](#step-s) instead if you want to skip to the next ACIR code directly.
+
+#### `continue` (c)
+
+Continues execution until the next breakpoint, or the end of the program.
+
+#### `restart` (res)
+
+Interrupts execution, and restarts a new debugging session from scratch.
+
+#### `opcodes` (o)
+
+Display the program's ACIR opcode sequence. For example:
+
+```
+0  BLACKBOX::RANGE [(_0, num_bits: 32)] [ ]
+1 ->  BRILLIG inputs=[Single(Expression { mul_terms: [], linear_combinations: [(1, Witness(0))], q_c: 0 })] outputs=[Simple(Witness(1))]
+	1.0  |   Mov { destination: RegisterIndex(2), source: RegisterIndex(0) }
+	1.1  |   Const { destination: RegisterIndex(0), value: Value { inner: 0 } }
+	1.2  |   Const { destination: RegisterIndex(1), value: Value { inner: 0 } }
+	1.3  |   Mov { destination: RegisterIndex(2), source: RegisterIndex(2) }
+	1.4  |   Call { location: 7 }
+	...
+	1.43 |   Return
+2     EXPR [ (1, _1) -2 ]
+```
+
+### Breakpoints
+
+#### `break [Opcode]` (or shorthand `b [Opcode]`)
+
+Sets a breakpoint on the specified opcode index. To get a list of the program opcode numbers, see [the `opcode` command](#opcodes-o). For example:
+
+```
+0  BLACKBOX::RANGE [(_0, num_bits: 32)] [ ]
+1 ->  BRILLIG inputs=[Single(Expression { mul_terms: [], linear_combinations: [(1, Witness(0))], q_c: 0 })] outputs=[Simple(Witness(1))]
+	1.0  |   Mov { destination: RegisterIndex(2), source: RegisterIndex(0) }
+	1.1  |   Const { destination: RegisterIndex(0), value: Value { inner: 0 } }
+	1.2  |   Const { destination: RegisterIndex(1), value: Value { inner: 0 } }
+	1.3  |   Mov { destination: RegisterIndex(2), source: RegisterIndex(2) }
+	1.4  |   Call { location: 7 }
+	...
+	1.43 |   Return
+2    EXPR [ (1, _1) -2 ]
+```
+
+In this example, issuing a `break 1.2` command adds break on opcode 1.2, as denoted by the `*` character:
+
+```
+0  BLACKBOX::RANGE [(_0, num_bits: 32)] [ ]
+1 ->  BRILLIG inputs=[Single(Expression { mul_terms: [], linear_combinations: [(1, Witness(0))], q_c: 0 })] outputs=[Simple(Witness(1))]
+	1.0  |   Mov { destination: RegisterIndex(2), source: RegisterIndex(0) }
+	1.1  |   Const { destination: RegisterIndex(0), value: Value { inner: 0 } }
+	1.2  | * Const { destination: RegisterIndex(1), value: Value { inner: 0 } }
+	1.3  |   Mov { destination: RegisterIndex(2), source: RegisterIndex(2) }
+	1.4  |   Call { location: 7 }
+	...
+	1.43 |   Return
+2    EXPR [ (1, _1) -2 ]
+```
+
+Running [the `continue` command](#continue-c) at this point would cause the debugger to execute the program until opcode 1.2.
+
+#### `delete [Opcode]` (or shorthand `d [Opcode]`)
+
+Deletes a breakpoint at an opcode location. Usage is analogous to [the `break` command](#).
+
+### Variable inspection
+
+#### vars
+
+Show variable values available at this point in execution.
+
+:::note
+The ability to inspect variable values from the debugger depends on compilation to be run in a special debug instrumentation mode. This instrumentation weaves variable tracing code with the original source code. 
+
+So variable value inspection comes at the expense of making the resulting ACIR bytecode bigger and harder to understand and optimize.
+
+If you find this compromise unacceptable, you can run the debugger with the flag `--skip-debug-instrumentation`. This will compile your circuit without any additional debug information, so the resulting ACIR bytecode will be identical to the one produced by standard Noir compilation. However, if you opt for this, the `vars` command will not be available while debugging.
+:::
+
+
+### Stacktrace
+
+#### `stacktrace`
+
+Displays the current stack trace.
+
+
+### Witness map
+
+#### `witness` (w)
+
+Show witness map. For example:
+
+```
+_0 = 0
+_1 = 2
+_2 = 1
+```
+
+#### `witness [Witness Index]`
+
+Display a single witness from the witness map. For example:
+
+```
+> witness 1
+_1 = 2
+```
+
+#### `witness [Witness Index] [New value]`
+
+Overwrite the given index with a new value. For example:
+
+```
+> witness 1 3
+_1 = 3
+```
+
+
+### Unconstrained VM memory
+
+#### `memory`
+
+Show unconstrained VM memory state. For example:
+
+```
+> memory
+At opcode 1.13: Store { destination_pointer: RegisterIndex(0), source: RegisterIndex(3) }
+...
+> registers
+0 = 0
+1 = 10
+2 = 0
+3 = 1
+4 = 1
+5 = 2³²
+6 = 1
+> into
+At opcode 1.14: Const { destination: RegisterIndex(5), value: Value { inner: 1 } }
+...
+> memory
+0 = 1
+>
+```
+
+In the example above: we start with clean memory, then step through a `Store` opcode which stores the value of register 3 (1) into the memory address stored in register 0 (0). Thus now `memory` shows memory address 0 contains value 1.
+
+:::note
+This command is only functional while the debugger is executing unconstrained code.
+:::
+
+#### `memset [Memory address] [New value]`
+
+Update a memory cell with the given value. For example:
+
+```
+> memory
+0 = 1
+> memset 0 2
+> memory
+0 = 2
+> memset 1 4
+> memory
+0 = 2
+1 = 4
+>
+```
+
+:::note
+This command is only functional while the debugger is executing unconstrained code.
+:::
\ No newline at end of file
diff --git a/docs/versioned_docs/version-v0.36.0/reference/debugger/debugger_vscode.md b/docs/versioned_docs/version-v0.36.0/reference/debugger/debugger_vscode.md
new file mode 100644
index 00000000000..c027332b3b0
--- /dev/null
+++ b/docs/versioned_docs/version-v0.36.0/reference/debugger/debugger_vscode.md
@@ -0,0 +1,82 @@
+---
+title: VS Code Debugger
+description:
+  VS Code Debugger configuration and features.
+keywords:
+  [
+    Nargo,
+    Noir CLI,
+    Noir Debugger,
+    VS Code,
+    IDE,
+  ]
+sidebar_position: 0
+---
+
+# VS Code Noir Debugger Reference
+
+The Noir debugger enabled by the vscode-noir extension ships with default settings such that the most common scenario should run without any additional configuration steps.
+
+These defaults can nevertheless be overridden by defining a launch configuration file. This page provides a reference for the properties you can override via a launch configuration file, as well as documenting the Nargo `dap` command, which is a dependency of the VS Code Noir debugger. 
+
+
+## Creating and editing launch configuration files
+
+To create a launch configuration file from VS Code, open the _debug pane_, and click on _create a launch.json file_. 
+
+![Creating a launch configuration file](@site/static/img/debugger/ref1-create-launch.png)
+
+A `launch.json` file will be created, populated with basic defaults. 
+
+### Noir Debugger launch.json properties
+
+#### projectFolder
+
+_String, optional._
+
+Absolute path to the Nargo project to debug. By default, it is dynamically determined by looking for the nearest `Nargo.toml` file to the active file at the moment of launching the debugger. 
+
+#### proverName
+
+_String, optional._
+
+Name of the prover input to use. Defaults to `Prover`, which looks for a file named `Prover.toml` at the `projectFolder`.
+
+#### generateAcir
+
+_Boolean, optional._
+
+If true, generate ACIR opcodes instead of unconstrained opcodes which will be closer to release binaries but less convenient for debugging. Defaults to `false`.
+                
+#### skipInstrumentation
+
+_Boolean, optional._
+
+Skips variables debugging instrumentation of code, making debugging less convenient but the resulting binary smaller and closer to production. Defaults to `false`.
+
+:::note
+Skipping instrumentation causes the debugger to be unable to inspect local variables.
+:::
+
+## `nargo dap [OPTIONS]`
+
+When run without any option flags, it starts the Nargo Debug Adapter Protocol server, which acts as the debugging backend for the VS Code Noir Debugger. 
+
+All option flags are related to preflight checks. The Debug Adapter Protocol specifies how errors are to be informed from a running DAP server, but it doesn't specify mechanisms to communicate server initialization errors between the DAP server and its client IDE. 
+
+Thus `nargo dap` ships with a _preflight check_ mode. If flag `--preflight-check` and the rest of the `--preflight-*` flags are provided, Nargo will run the same initialization routine except it will not start the DAP server.
+
+`vscode-noir` will then run `nargo dap` in preflight check mode first before a debugging session starts. If the preflight check ends in error, vscode-noir will present stderr and stdout output from this process through its own Output pane in VS Code. This makes it possible for users to diagnose what pieces of configuration might be wrong or missing in case of initialization errors.
+
+If the preflight check succeeds, `vscode-noir` proceeds to start the DAP server normally but running `nargo dap` without any additional flags.
+
+### Options
+
+| Option                                  | Description                                                                         |
+| --------------------------------------------------------- | --------------------------------------------------------------------------------------------------------- |
+| `--preflight-check`                     | If present, dap runs in preflight check mode.                               |
+| `--preflight-project-folder <PREFLIGHT_PROJECT_FOLDER>`   | Absolute path to the project to debug for preflight check.                        |
+| `--preflight-prover-name <PREFLIGHT_PROVER_NAME>`       | Name of prover file to use for preflight check                              |
+| `--preflight-generate-acir`                 | Optional. If present, compile in ACIR mode while running preflight check.                                 |
+| `--preflight-skip-instrumentation`            | Optional. If present, compile without introducing debug instrumentation while running preflight check.  |
+| `-h, --help`                            | Print help.                                               |
diff --git a/docs/versioned_docs/version-v0.36.0/reference/nargo_commands.md b/docs/versioned_docs/version-v0.36.0/reference/nargo_commands.md
new file mode 100644
index 00000000000..db1884afee2
--- /dev/null
+++ b/docs/versioned_docs/version-v0.36.0/reference/nargo_commands.md
@@ -0,0 +1,297 @@
+---
+title: Nargo
+description:
+  Noir CLI Commands for Noir Prover and Verifier to create, execute, prove and verify programs,
+  generate Solidity verifier smart contract and compile into JSON file containing ACIR
+  representation and ABI of circuit.
+keywords:
+  [
+    Nargo,
+    Noir CLI,
+    Noir Prover,
+    Noir Verifier,
+    generate Solidity verifier,
+    compile JSON file,
+    ACIR representation,
+    ABI of circuit,
+    TypeScript,
+  ]
+sidebar_position: 0
+---
+
+# Command-Line Help for `nargo`
+
+This document contains the help content for the `nargo` command-line program.
+
+**Command Overview:**
+
+* [`nargo`↴](#nargo)
+* [`nargo check`↴](#nargo-check)
+* [`nargo fmt`↴](#nargo-fmt)
+* [`nargo compile`↴](#nargo-compile)
+* [`nargo new`↴](#nargo-new)
+* [`nargo init`↴](#nargo-init)
+* [`nargo execute`↴](#nargo-execute)
+* [`nargo debug`↴](#nargo-debug)
+* [`nargo test`↴](#nargo-test)
+* [`nargo info`↴](#nargo-info)
+* [`nargo lsp`↴](#nargo-lsp)
+
+## `nargo`
+
+Noir's package manager
+
+**Usage:** `nargo <COMMAND>`
+
+###### **Subcommands:**
+
+* `check` — Checks the constraint system for errors
+* `fmt` — Format the Noir files in a workspace
+* `compile` — Compile the program and its secret execution trace into ACIR format
+* `new` — Create a Noir project in a new directory
+* `init` — Create a Noir project in the current directory
+* `execute` — Executes a circuit to calculate its return value
+* `debug` — Executes a circuit in debug mode
+* `test` — Run the tests for this program
+* `info` — Provides detailed information on each of a program's function (represented by a single circuit)
+* `lsp` — Starts the Noir LSP server
+
+###### **Options:**
+
+
+
+
+## `nargo check`
+
+Checks the constraint system for errors
+
+**Usage:** `nargo check [OPTIONS]`
+
+###### **Options:**
+
+* `--package <PACKAGE>` — The name of the package to check
+* `--workspace` — Check all packages in the workspace
+* `--overwrite` — Force overwrite of existing files
+* `--expression-width <EXPRESSION_WIDTH>` — Specify the backend expression width that should be targeted
+* `--bounded-codegen` — Generate ACIR with the target backend expression width. The default is to generate ACIR without a bound and split expressions after code generation. Activating this flag can sometimes provide optimizations for certain programs
+
+  Default value: `false`
+* `--force` — Force a full recompilation
+* `--print-acir` — Display the ACIR for compiled circuit
+* `--deny-warnings` — Treat all warnings as errors
+* `--silence-warnings` — Suppress warnings
+* `--debug-comptime-in-file <DEBUG_COMPTIME_IN_FILE>` — Enable printing results of comptime evaluation: provide a path suffix for the module to debug, e.g. "package_name/src/main.nr"
+* `--skip-underconstrained-check` — Flag to turn off the compiler check for under constrained values. Warning: This can improve compilation speed but can also lead to correctness errors. This check should always be run on production code
+
+
+
+## `nargo fmt`
+
+Format the Noir files in a workspace
+
+**Usage:** `nargo fmt [OPTIONS]`
+
+###### **Options:**
+
+* `--check` — Run noirfmt in check mode
+
+
+
+## `nargo compile`
+
+Compile the program and its secret execution trace into ACIR format
+
+**Usage:** `nargo compile [OPTIONS]`
+
+###### **Options:**
+
+* `--package <PACKAGE>` — The name of the package to compile
+* `--workspace` — Compile all packages in the workspace
+* `--expression-width <EXPRESSION_WIDTH>` — Specify the backend expression width that should be targeted
+* `--bounded-codegen` — Generate ACIR with the target backend expression width. The default is to generate ACIR without a bound and split expressions after code generation. Activating this flag can sometimes provide optimizations for certain programs
+
+  Default value: `false`
+* `--force` — Force a full recompilation
+* `--print-acir` — Display the ACIR for compiled circuit
+* `--deny-warnings` — Treat all warnings as errors
+* `--silence-warnings` — Suppress warnings
+* `--debug-comptime-in-file <DEBUG_COMPTIME_IN_FILE>` — Enable printing results of comptime evaluation: provide a path suffix for the module to debug, e.g. "package_name/src/main.nr"
+* `--skip-underconstrained-check` — Flag to turn off the compiler check for under constrained values. Warning: This can improve compilation speed but can also lead to correctness errors. This check should always be run on production code
+
+
+
+## `nargo new`
+
+Create a Noir project in a new directory
+
+**Usage:** `nargo new [OPTIONS] <PATH>`
+
+###### **Arguments:**
+
+* `<PATH>` — The path to save the new project
+
+###### **Options:**
+
+* `--name <NAME>` — Name of the package [default: package directory name]
+* `--lib` — Use a library template
+* `--bin` — Use a binary template [default]
+* `--contract` — Use a contract template
+
+
+
+## `nargo init`
+
+Create a Noir project in the current directory
+
+**Usage:** `nargo init [OPTIONS]`
+
+###### **Options:**
+
+* `--name <NAME>` — Name of the package [default: current directory name]
+* `--lib` — Use a library template
+* `--bin` — Use a binary template [default]
+* `--contract` — Use a contract template
+
+
+
+## `nargo execute`
+
+Executes a circuit to calculate its return value
+
+**Usage:** `nargo execute [OPTIONS] [WITNESS_NAME]`
+
+###### **Arguments:**
+
+* `<WITNESS_NAME>` — Write the execution witness to named file
+
+Defaults to the name of the package being executed.
+
+###### **Options:**
+
+* `-p`, `--prover-name <PROVER_NAME>` — The name of the toml file which contains the inputs for the prover
+
+  Default value: `Prover`
+* `--package <PACKAGE>` — The name of the package to execute
+* `--workspace` — Execute all packages in the workspace
+* `--expression-width <EXPRESSION_WIDTH>` — Specify the backend expression width that should be targeted
+* `--bounded-codegen` — Generate ACIR with the target backend expression width. The default is to generate ACIR without a bound and split expressions after code generation. Activating this flag can sometimes provide optimizations for certain programs
+
+  Default value: `false`
+* `--force` — Force a full recompilation
+* `--print-acir` — Display the ACIR for compiled circuit
+* `--deny-warnings` — Treat all warnings as errors
+* `--silence-warnings` — Suppress warnings
+* `--debug-comptime-in-file <DEBUG_COMPTIME_IN_FILE>` — Enable printing results of comptime evaluation: provide a path suffix for the module to debug, e.g. "package_name/src/main.nr"
+* `--skip-underconstrained-check` — Flag to turn off the compiler check for under constrained values. Warning: This can improve compilation speed but can also lead to correctness errors. This check should always be run on production code
+* `--oracle-resolver <ORACLE_RESOLVER>` — JSON RPC url to solve oracle calls
+
+
+
+## `nargo debug`
+
+Executes a circuit in debug mode
+
+**Usage:** `nargo debug [OPTIONS] [WITNESS_NAME]`
+
+###### **Arguments:**
+
+* `<WITNESS_NAME>` — Write the execution witness to named file
+
+###### **Options:**
+
+* `-p`, `--prover-name <PROVER_NAME>` — The name of the toml file which contains the inputs for the prover
+
+  Default value: `Prover`
+* `--package <PACKAGE>` — The name of the package to execute
+* `--expression-width <EXPRESSION_WIDTH>` — Specify the backend expression width that should be targeted
+* `--bounded-codegen` — Generate ACIR with the target backend expression width. The default is to generate ACIR without a bound and split expressions after code generation. Activating this flag can sometimes provide optimizations for certain programs
+
+  Default value: `false`
+* `--force` — Force a full recompilation
+* `--print-acir` — Display the ACIR for compiled circuit
+* `--deny-warnings` — Treat all warnings as errors
+* `--silence-warnings` — Suppress warnings
+* `--debug-comptime-in-file <DEBUG_COMPTIME_IN_FILE>` — Enable printing results of comptime evaluation: provide a path suffix for the module to debug, e.g. "package_name/src/main.nr"
+* `--skip-underconstrained-check` — Flag to turn off the compiler check for under constrained values. Warning: This can improve compilation speed but can also lead to correctness errors. This check should always be run on production code
+* `--acir-mode` — Force ACIR output (disabling instrumentation)
+* `--skip-instrumentation <SKIP_INSTRUMENTATION>` — Disable vars debug instrumentation (enabled by default)
+
+  Possible values: `true`, `false`
+
+
+
+
+## `nargo test`
+
+Run the tests for this program
+
+**Usage:** `nargo test [OPTIONS] [TEST_NAME]`
+
+###### **Arguments:**
+
+* `<TEST_NAME>` — If given, only tests with names containing this string will be run
+
+###### **Options:**
+
+* `--show-output` — Display output of `println` statements
+* `--exact` — Only run tests that match exactly
+* `--package <PACKAGE>` — The name of the package to test
+* `--workspace` — Test all packages in the workspace
+* `--expression-width <EXPRESSION_WIDTH>` — Specify the backend expression width that should be targeted
+* `--bounded-codegen` — Generate ACIR with the target backend expression width. The default is to generate ACIR without a bound and split expressions after code generation. Activating this flag can sometimes provide optimizations for certain programs
+
+  Default value: `false`
+* `--force` — Force a full recompilation
+* `--print-acir` — Display the ACIR for compiled circuit
+* `--deny-warnings` — Treat all warnings as errors
+* `--silence-warnings` — Suppress warnings
+* `--debug-comptime-in-file <DEBUG_COMPTIME_IN_FILE>` — Enable printing results of comptime evaluation: provide a path suffix for the module to debug, e.g. "package_name/src/main.nr"
+* `--skip-underconstrained-check` — Flag to turn off the compiler check for under constrained values. Warning: This can improve compilation speed but can also lead to correctness errors. This check should always be run on production code
+* `--oracle-resolver <ORACLE_RESOLVER>` — JSON RPC url to solve oracle calls
+
+
+
+## `nargo info`
+
+Provides detailed information on each of a program's function (represented by a single circuit)
+
+Current information provided per circuit: 1. The number of ACIR opcodes 2. Counts the final number gates in the circuit used by a backend
+
+**Usage:** `nargo info [OPTIONS]`
+
+###### **Options:**
+
+* `--package <PACKAGE>` — The name of the package to detail
+* `--workspace` — Detail all packages in the workspace
+* `--expression-width <EXPRESSION_WIDTH>` — Specify the backend expression width that should be targeted
+* `--bounded-codegen` — Generate ACIR with the target backend expression width. The default is to generate ACIR without a bound and split expressions after code generation. Activating this flag can sometimes provide optimizations for certain programs
+
+  Default value: `false`
+* `--force` — Force a full recompilation
+* `--print-acir` — Display the ACIR for compiled circuit
+* `--deny-warnings` — Treat all warnings as errors
+* `--silence-warnings` — Suppress warnings
+* `--debug-comptime-in-file <DEBUG_COMPTIME_IN_FILE>` — Enable printing results of comptime evaluation: provide a path suffix for the module to debug, e.g. "package_name/src/main.nr"
+* `--skip-underconstrained-check` — Flag to turn off the compiler check for under constrained values. Warning: This can improve compilation speed but can also lead to correctness errors. This check should always be run on production code
+
+
+
+## `nargo lsp`
+
+Starts the Noir LSP server
+
+Starts an LSP server which allows IDEs such as VS Code to display diagnostics in Noir source.
+
+VS Code Noir Language Support: https://marketplace.visualstudio.com/items?itemName=noir-lang.vscode-noir
+
+**Usage:** `nargo lsp`
+
+
+
+<hr/>
+
+<small><i>
+    This document was generated automatically by
+    <a href="https://crates.io/crates/clap-markdown"><code>clap-markdown</code></a>.
+</i></small>
+
diff --git a/docs/versioned_docs/version-v0.36.0/reference/noir_codegen.md b/docs/versioned_docs/version-v0.36.0/reference/noir_codegen.md
new file mode 100644
index 00000000000..e4c362f9610
--- /dev/null
+++ b/docs/versioned_docs/version-v0.36.0/reference/noir_codegen.md
@@ -0,0 +1,116 @@
+---
+title: Noir Codegen for TypeScript
+description: Learn how to use Noir codegen to generate TypeScript bindings 
+keywords: [Nargo, Noir, compile, TypeScript]
+sidebar_position: 3
+---
+
+When using TypeScript, it is extra work to interpret Noir program outputs in a type-safe way. Third party libraries may exist for popular Noir programs, but they are either hard to find or unmaintained.
+
+Now you can generate TypeScript bindings for your Noir programs in two steps:
+
+1. Exporting Noir functions using `nargo export`
+2. Using the TypeScript module `noir_codegen` to generate TypeScript binding
+
+**Note:** you can only export functions from a Noir *library* (not binary or contract program types).
+
+## Installation
+
+### Your TypeScript project
+
+If you don't already have a TypeScript project you can add the module with `yarn` (or `npm`), then initialize it:
+
+```bash
+yarn add typescript -D
+npx tsc --init
+```
+
+### Add TypeScript module - `noir_codegen`
+
+The following command will add the module to your project's devDependencies:
+
+```bash
+yarn add @noir-lang/noir_codegen -D
+```
+
+### Nargo library
+
+Make sure you have Nargo, v0.25.0 or greater, installed. If you don't, follow the [installation guide](../getting_started/noir_installation.md).
+
+If you're in a new project, make a `circuits` folder and create a new Noir library:
+
+```bash
+mkdir circuits && cd circuits
+nargo new --lib myNoirLib
+```
+
+## Usage
+
+### Export ABI of specified functions
+
+First go to the `.nr` files in your Noir library, and add the `#[export]` macro to each function that you want to use in TypeScript.
+
+```rust
+#[export]
+fn your_function(...
+```
+
+From your Noir library (where `Nargo.toml` is), run the following command:
+
+```bash
+nargo export
+```
+
+You will now have an `export` directory with a .json file per exported function.
+
+You can also specify the directory of Noir programs using `--program-dir`, for example:
+
+```bash
+nargo export --program-dir=./circuits/myNoirLib
+```
+
+### Generate TypeScript bindings from exported functions
+
+To use the `noir-codegen` package we added to the TypeScript project:
+
+```bash
+yarn noir-codegen ./export/your_function.json
+```
+
+This creates an `exports` directory with an `index.ts` file containing all exported functions.
+
+**Note:** adding `--out-dir` allows you to specify an output dir for your TypeScript bindings to go. Eg:
+
+```bash
+yarn noir-codegen ./export/*.json --out-dir ./path/to/output/dir
+```
+
+## Example .nr function to .ts output
+
+Consider a Noir library with this function:
+
+```rust
+#[export]
+fn not_equal(x: Field, y: Field) -> bool {
+    x != y
+}
+```
+
+After the export and codegen steps, you should have an `index.ts` like:
+
+```typescript
+export type Field = string;
+
+
+export const is_equal_circuit: CompiledCircuit = 
+{"abi":{"parameters":[{"name":"x","type":{"kind":"field"},"visibility":"private"},{"name":"y","type":{"kind":"field"},"visibility":"private"}],"return_type":{"abi_type":{"kind":"boolean"},"visibility":"private"}},"bytecode":"H4sIAAAAAAAA/7WUMQ7DIAxFQ0Krrr2JjSGYLVcpKrn/CaqqDQN12WK+hPBgmWd/wEyHbF1SS923uhOs3pfoChI+wKXMAXzIKyNj4PB0TFTYc0w5RUjoqeAeEu1wqK0F54RGkWvW44LPzExnlkbMEs4JNZmN8PxS42uHv82T8a3Jeyn2Ks+VLPcO558HmyLMCDOXAXXtpPt4R/Rt9T36ss6dS9HGPx/eG17nGegKBQAA"};
+
+export async function is_equal(x: Field, y: Field, foreignCallHandler?: ForeignCallHandler): Promise<boolean> {
+  const program = new Noir(is_equal_circuit);
+  const args: InputMap = { x, y };
+  const { returnValue } = await program.execute(args, foreignCallHandler);
+  return returnValue as boolean;
+}
+```
+
+Now the `is_equal()` function and relevant types are readily available for use in TypeScript.
diff --git a/docs/versioned_docs/version-v0.36.0/tooling/debugger.md b/docs/versioned_docs/version-v0.36.0/tooling/debugger.md
new file mode 100644
index 00000000000..200b5fc423a
--- /dev/null
+++ b/docs/versioned_docs/version-v0.36.0/tooling/debugger.md
@@ -0,0 +1,26 @@
+---
+title: Debugger
+description: Learn about the Noir Debugger, in its REPL or VS Code versions.
+keywords: [Nargo, VSCode, Visual Studio Code, REPL, Debugger]
+sidebar_position: 2
+---
+
+# Noir Debugger
+
+There are currently two ways of debugging Noir programs:
+
+1. From VS Code, via the [vscode-noir](https://github.com/noir-lang/vscode-noir) extension. You can install it via the [Visual Studio Marketplace](https://marketplace.visualstudio.com/items?itemName=noir-lang.vscode-noir).
+2. Via the REPL debugger, which ships with Nargo.
+
+In order to use either version of the debugger, you will need to install recent enough versions of Noir, [Nargo](../getting_started/noir_installation.md) and vscode-noir:
+
+- Noir & Nargo ≥0.28.0
+- Noir's VS Code extension ≥0.0.11
+
+:::info
+At the moment, the debugger supports debugging binary projects, but not contracts.
+:::
+
+We cover the VS Code Noir debugger more in depth in [its VS Code debugger how-to guide](../how_to/debugger/debugging_with_vs_code.md) and [the reference](../reference/debugger/debugger_vscode.md).
+
+The REPL debugger is discussed at length in [the REPL debugger how-to guide](../how_to/debugger/debugging_with_the_repl.md) and [the reference](../reference/debugger/debugger_repl.md).
diff --git a/docs/versioned_docs/version-v0.36.0/tooling/language_server.md b/docs/versioned_docs/version-v0.36.0/tooling/language_server.md
new file mode 100644
index 00000000000..81e0356ef8a
--- /dev/null
+++ b/docs/versioned_docs/version-v0.36.0/tooling/language_server.md
@@ -0,0 +1,43 @@
+---
+title: Language Server
+description: Learn about the Noir Language Server, how to install the components, and configuration that may be required.
+keywords: [Nargo, Language Server, LSP, VSCode, Visual Studio Code]
+sidebar_position: 0
+---
+
+This section helps you install and configure the Noir Language Server.
+
+The Language Server Protocol (LSP) has two components, the [Server](#language-server) and the [Client](#language-client). Below we describe each in the context of Noir.
+
+## Language Server
+
+The Server component is provided by the Nargo command line tool that you installed at the beginning of this guide.
+As long as Nargo is installed and you've used it to run other commands in this guide, it should be good to go!
+
+If you'd like to verify that the `nargo lsp` command is available, you can run `nargo --help` and look for `lsp` in the list of commands. If you see it, you're using a version of Noir with LSP support.
+
+## Language Client
+
+The Client component is usually an editor plugin that launches the Server. It communicates LSP messages between the editor and the Server. For example, when you save a file, the Client will alert the Server, so it can try to compile the project and report any errors.
+
+Currently, Noir provides a Language Client for Visual Studio Code via the [vscode-noir](https://github.com/noir-lang/vscode-noir) extension. You can install it via the [Visual Studio Marketplace](https://marketplace.visualstudio.com/items?itemName=noir-lang.vscode-noir).
+
+> **Note:** Noir's Language Server Protocol support currently assumes users' VSCode workspace root to be the same as users' Noir project root (i.e. where Nargo.toml lies).
+>
+> If LSP features seem to be missing / malfunctioning, make sure you are opening your Noir project directly (instead of as a sub-folder) in your VSCode instance.
+
+When your language server is running correctly and the VSCode plugin is installed, you should see handy codelens buttons for compilation, measuring circuit size, execution, and tests:
+
+![Compile and Execute](@site/static/img/codelens_compile_execute.png)
+![Run test](@site/static/img/codelens_run_test.png)
+
+You should also see your tests in the `testing` panel:
+
+![Testing panel](@site/static/img/codelens_testing_panel.png)
+
+### Configuration
+
+- **Noir: Enable LSP** - If checked, the extension will launch the Language Server via `nargo lsp` and communicate with it.
+- **Noir: Nargo Flags** - Additional flags may be specified if you require them to be added when the extension calls `nargo lsp`.
+- **Noir: Nargo Path** - An absolute path to a Nargo binary with the `lsp` command. This may be useful if Nargo is not within the `PATH` of your editor.
+- **Noir > Trace: Server** - Setting this to `"messages"` or `"verbose"` will log LSP messages between the Client and Server. Useful for debugging.
diff --git a/docs/versioned_docs/version-v0.36.0/tooling/testing.md b/docs/versioned_docs/version-v0.36.0/tooling/testing.md
new file mode 100644
index 00000000000..866677da567
--- /dev/null
+++ b/docs/versioned_docs/version-v0.36.0/tooling/testing.md
@@ -0,0 +1,79 @@
+---
+title: Testing in Noir
+description: Learn how to use Nargo to test your Noir program in a quick and easy way
+keywords: [Nargo, testing, Noir, compile, test]
+sidebar_position: 1
+---
+
+You can test your Noir programs using Noir circuits.
+
+Nargo will automatically compile and run any functions which have the decorator `#[test]` on them if
+you run `nargo test`.
+
+For example if you have a program like:
+
+```rust
+fn add(x: u64, y: u64) -> u64 {
+    x + y
+}
+#[test]
+fn test_add() {
+    assert(add(2,2) == 4);
+    assert(add(0,1) == 1);
+    assert(add(1,0) == 1);
+}
+```
+
+Running `nargo test` will test that the `test_add` function can be executed while satisfying all
+the constraints which allows you to test that add returns the expected values. Test functions can't
+have any arguments currently.
+
+### Test fail
+
+You can write tests that are expected to fail by using the decorator `#[test(should_fail)]`. For example:
+
+```rust
+fn add(x: u64, y: u64) -> u64 {
+    x + y
+}
+#[test(should_fail)]
+fn test_add() {
+    assert(add(2,2) == 5);
+}
+```
+
+You can be more specific and make it fail with a specific reason by using `should_fail_with = "<the reason for failure>"`:
+
+```rust
+fn main(african_swallow_avg_speed : Field) {
+    assert(african_swallow_avg_speed == 65, "What is the airspeed velocity of an unladen swallow");
+}
+
+#[test]
+fn test_king_arthur() {
+    main(65);
+}
+
+#[test(should_fail_with = "What is the airspeed velocity of an unladen swallow")]
+fn test_bridgekeeper() {
+    main(32);
+}
+```
+
+The string given to `should_fail_with` doesn't need to exactly match the failure reason, it just needs to be a substring of it:
+
+```rust
+fn main(african_swallow_avg_speed : Field) {
+    assert(african_swallow_avg_speed == 65, "What is the airspeed velocity of an unladen swallow");
+}
+
+#[test]
+fn test_king_arthur() {
+    main(65);
+}
+
+#[test(should_fail_with = "airspeed velocity")]
+fn test_bridgekeeper() {
+    main(32);
+}
+```
\ No newline at end of file
diff --git a/docs/versioned_docs/version-v0.36.0/tutorials/noirjs_app.md b/docs/versioned_docs/version-v0.36.0/tutorials/noirjs_app.md
new file mode 100644
index 00000000000..6e69ea0bbed
--- /dev/null
+++ b/docs/versioned_docs/version-v0.36.0/tutorials/noirjs_app.md
@@ -0,0 +1,366 @@
+---
+title: Building a web app with NoirJS
+description: Learn how to setup a new app that uses Noir to generate and verify zero-knowledge SNARK proofs in a typescript or javascript environment.
+keywords: [how to, guide, javascript, typescript, noir, barretenberg, zero-knowledge, proofs, app]
+sidebar_position: 0
+pagination_next: noir/concepts/data_types/index
+---
+
+NoirJS is a set of packages meant to work both in a browser and a server environment. In this tutorial, we will build a simple web app using them. From here, you should get an idea on how to proceed with your own Noir projects!
+
+You can find the complete app code for this guide [here](https://github.com/noir-lang/tiny-noirjs-app).
+
+## Setup
+
+:::note
+
+Feel free to use whatever versions, just keep in mind that Nargo and the NoirJS packages are meant to be in sync. For example, Nargo 0.31.x matches `noir_js@0.31.x`, etc.
+
+In this guide, we will be pinned to 0.31.0.
+
+:::
+
+Before we start, we want to make sure we have Node, Nargo and the Barretenberg proving system (`bb`) installed.
+
+We start by opening a terminal and executing `node --version`. If we don't get an output like `v20.10.0`, that means node is not installed. Let's do that by following the handy [nvm guide](https://github.com/nvm-sh/nvm?tab=readme-ov-file#install--update-script).
+
+As for `Nargo`, we can follow the [Nargo guide](../getting_started/quick_start.md) to install it. If you're lazy, just paste this on a terminal and run `noirup`:
+
+```sh
+curl -L https://raw.githubusercontent.com/noir-lang/noirup/main/install | bash
+```
+
+Follow the instructions on [this page](https://github.com/AztecProtocol/aztec-packages/tree/master/barretenberg/cpp/src/barretenberg/bb#installation) to install `bb`.
+Version 0.41.0 is compatible with `nargo` version 0.31.0, which you can install with `bbup -v 0.41.0` once `bbup` is installed.
+
+Easy enough. Onwards!
+
+## Our project
+
+ZK is a powerful technology. An app that doesn't reveal one of the inputs to _anyone_ is almost unbelievable, yet Noir makes it as easy as a single line of code.
+
+In fact, it's so simple that it comes nicely packaged in `nargo`. Let's do that!
+
+### Nargo
+
+Run:
+
+```bash
+nargo new circuit
+```
+
+And... That's about it. Your program is ready to be compiled and run.
+
+To compile, let's `cd` into the `circuit` folder to enter our project, and call:
+
+```bash
+nargo compile
+```
+
+This compiles our circuit into `json` format and add it to a new `target` folder.
+
+:::info
+
+At this point in the tutorial, your folder structure should look like this:
+
+```tree
+.
+└── circuit <---- our working directory
+    ├── Nargo.toml
+    ├── src
+    │   └── main.nr
+    └── target
+        └── circuit.json
+```
+
+:::
+
+### Node and Vite
+
+If you want to explore Nargo, feel free to go on a side-quest now and follow the steps in the
+[getting started](../getting_started/quick_start.md) guide. However, we want our app to run on the browser, so we need Vite.
+
+Vite is a powerful tool to generate static websites. While it provides all kinds of features, let's just go barebones with some good old vanilla JS.
+
+To do this this, go back to the previous folder (`cd ..`) and create a new vite project by running `npm create vite` and choosing "Vanilla" and "Javascript".
+
+A wild `vite-project` directory should now appear in your root folder! Let's not waste any time and dive right in:
+
+```bash
+cd vite-project
+```
+
+### Setting Up Vite and Configuring the Project
+
+Before we proceed with any coding, let's get our environment tailored for Noir. We'll start by laying down the foundations with a `vite.config.js` file. This little piece of configuration is our secret sauce for making sure everything meshes well with the NoirJS libraries and other special setups we might need, like handling WebAssembly modules. Here’s how you get that going:
+
+#### Creating the vite.config.js
+
+In your freshly minted `vite-project` folder, create a new file named `vite.config.js` and open it in your code editor. Paste the following to set the stage:
+
+```javascript
+import { defineConfig } from 'vite';
+import copy from 'rollup-plugin-copy';
+import fs from 'fs';
+import path from 'path';
+
+const wasmContentTypePlugin = {
+  name: 'wasm-content-type-plugin',
+  configureServer(server) {
+    server.middlewares.use(async (req, res, next) => {
+      if (req.url.endsWith('.wasm')) {
+        res.setHeader('Content-Type', 'application/wasm');
+        const newPath = req.url.replace('deps', 'dist');
+        const targetPath = path.join(__dirname, newPath);
+        const wasmContent = fs.readFileSync(targetPath);
+        return res.end(wasmContent);
+      }
+      next();
+    });
+  },
+};
+
+export default defineConfig(({ command }) => {
+  if (command === 'serve') {
+    return {
+      build: {
+        target: 'esnext',
+        rollupOptions: {
+          external: ['@aztec/bb.js']
+        }
+      },
+      optimizeDeps: {
+        esbuildOptions: {
+          target: 'esnext'
+        }
+      },
+      plugins: [
+        copy({
+          targets: [{ src: 'node_modules/**/*.wasm', dest: 'node_modules/.vite/dist' }],
+          copySync: true,
+          hook: 'buildStart',
+        }),
+        command === 'serve' ? wasmContentTypePlugin : [],
+      ],
+    };
+  }
+
+  return {};
+});
+```
+
+#### Install Dependencies
+
+Now that our stage is set, install the necessary NoirJS packages along with our other dependencies:
+
+```bash
+npm install && npm install @noir-lang/backend_barretenberg@0.31.0 @noir-lang/noir_js@0.31.0
+npm install rollup-plugin-copy --save-dev
+```
+
+:::info
+
+At this point in the tutorial, your folder structure should look like this:
+
+```tree
+.
+└── circuit
+    └── ...etc...
+└── vite-project <---- our working directory
+    └── ...etc...
+```
+
+:::
+
+#### Some cleanup
+
+`npx create vite` is amazing but it creates a bunch of files we don't really need for our simple example. Actually, let's just delete everything except for `vite.config.js`, `index.html`, `main.js` and `package.json`. I feel lighter already.
+
+![my heart is ready for you, noir.js](@site/static/img/memes/titanic.jpeg)
+
+## HTML
+
+Our app won't run like this, of course. We need some working HTML, at least. Let's open our broken-hearted `index.html` and replace everything with this code snippet:
+
+```html
+<!DOCTYPE html>
+<head>
+  <style>
+    .outer {
+        display: flex;
+        justify-content: space-between;
+        width: 100%;
+    }
+    .inner {
+        width: 45%;
+        border: 1px solid black;
+        padding: 10px;
+        word-wrap: break-word;
+    }
+  </style>
+</head>
+<body>
+  <script type="module" src="/main.js"></script>
+  <h1>Noir app</h1>
+  <div class="input-area">
+    <input id="guessInput" type="number" placeholder="Enter your guess" />
+    <button id="submitGuess">Submit Guess</button>
+  </div>
+  <div class="outer">
+    <div id="logs" class="inner"><h2>Logs</h2></div>
+    <div id="results" class="inner"><h2>Proof</h2></div>
+  </div>
+</body>
+</html>
+```
+
+It _could_ be a beautiful UI... Depending on which universe you live in.
+
+## Some good old vanilla Javascript
+
+Our love for Noir needs undivided attention, so let's just open `main.js` and delete everything (this is where the romantic scenery becomes a bit creepy).
+
+Start by pasting in this boilerplate code:
+
+```js
+function display(container, msg) {
+  const c = document.getElementById(container);
+  const p = document.createElement('p');
+  p.textContent = msg;
+  c.appendChild(p);
+}
+
+document.getElementById('submitGuess').addEventListener('click', async () => {
+  try {
+    // here's where love happens
+  } catch (err) {
+    display('logs', 'Oh 💔 Wrong guess');
+  }
+});
+```
+
+The display function doesn't do much. We're simply manipulating our website to see stuff happening. For example, if the proof fails, it will simply log a broken heart 😢
+
+:::info
+
+At this point in the tutorial, your folder structure should look like this:
+
+```tree
+.
+└── circuit
+    └── ...same as above
+└── vite-project
+    ├── vite.config.js
+    ├── main.js
+    ├── package.json
+    └── index.html
+```
+
+You'll see other files and folders showing up (like `package-lock.json`, `node_modules`) but you shouldn't have to care about those.
+
+:::
+
+## Some NoirJS
+
+We're starting with the good stuff now. If you've compiled the circuit as described above, you should have a `json` file we want to import at the very top of our `main.js` file:
+
+```ts
+import circuit from '../circuit/target/circuit.json';
+```
+
+[Noir is backend-agnostic](../index.mdx#whats-new-about-noir). We write Noir, but we also need a proving backend. That's why we need to import and instantiate the two dependencies we installed above: `BarretenbergBackend` and `Noir`. Let's import them right below:
+
+```js
+import { BarretenbergBackend, BarretenbergVerifier as Verifier } from '@noir-lang/backend_barretenberg';
+import { Noir } from '@noir-lang/noir_js';
+```
+
+And instantiate them inside our try-catch block:
+
+```ts
+// try {
+const backend = new BarretenbergBackend(circuit);
+const noir = new Noir(circuit);
+// }
+```
+
+:::note
+
+For the remainder of the tutorial, everything will be happening inside the `try` block
+
+:::
+
+## Our app
+
+Now for the app itself. We're capturing whatever is in the input when people press the submit button. Just add this:
+
+```js
+const x = parseInt(document.getElementById('guessInput').value);
+const input = { x, y: 2 };
+```
+
+Now we're ready to prove stuff! Let's feed some inputs to our circuit and calculate the proof:
+
+```js
+await setup(); // let's squeeze our wasm inits here
+
+display('logs', 'Generating proof... ⌛');
+const { witness } = await noir.execute(input);
+const proof = await backend.generateProof(witness);
+display('logs', 'Generating proof... ✅');
+display('results', proof.proof);
+```
+
+You're probably eager to see stuff happening, so go and run your app now!
+
+From your terminal, run `npm run dev`. If it doesn't open a browser for you, just visit `localhost:5173`. You should now see the worst UI ever, with an ugly input.
+
+![Getting Started 0](@site/static/img/noir_getting_started_1.png)
+
+Now, our circuit says `fn main(x: Field, y: pub Field)`. This means only the `y` value is public, and it's hardcoded above: `input = { x, y: 2 }`. In other words, you won't need to send your secret`x` to the verifier!
+
+By inputting any number other than 2 in the input box and clicking "submit", you should get a valid proof. Otherwise the proof won't even generate correctly. By the way, if you're human, you shouldn't be able to understand anything on the "proof" box. That's OK. We like you, human ❤️.
+
+## Verifying
+
+Time to celebrate, yes! But we shouldn't trust machines so blindly. Let's add these lines to see our proof being verified:
+
+```js
+display('logs', 'Verifying proof... ⌛');
+const isValid = await backend.verifyProof(proof);
+
+// or to cache and use the verification key:
+// const verificationKey = await backend.getVerificationKey();
+// const verifier = new Verifier();
+// const isValid = await verifier.verifyProof(proof, verificationKey);
+
+if (isValid) display('logs', 'Verifying proof... ✅');
+```
+
+You have successfully generated a client-side Noir web app!
+
+![coded app without math knowledge](@site/static/img/memes/flextape.jpeg)
+
+## Further Reading
+
+You can see how noirjs is used in a full stack Next.js hardhat application in the [noir-starter repo here](https://github.com/noir-lang/noir-starter/tree/main/vite-hardhat). The example shows how to calculate a proof in the browser and verify it with a deployed Solidity verifier contract from noirjs.
+
+You should also check out the more advanced examples in the [noir-examples repo](https://github.com/noir-lang/noir-examples), where you'll find reference usage for some cool apps.
+
+## UltraHonk Backend
+
+Barretenberg has recently exposed a new UltraHonk backend. We can use UltraHonk in NoirJS after version 0.33.0. Everything will be the same as the tutorial above, except that the class we need to import will change:
+
+```js
+import { UltraHonkBackend, UltraHonkVerifier as Verifier } from '@noir-lang/backend_barretenberg';
+```
+
+The backend will then be instantiated as such:
+
+```js
+const backend = new UltraHonkBackend(circuit);
+```
+
+Then all the commands to prove and verify your circuit will be same.
+
+The only feature currently unsupported with UltraHonk are [recursive proofs](../explainers/explainer-recursion.md).
diff --git a/docs/versioned_docs/version-v0.37.0/explainers/cspell.json b/docs/versioned_docs/version-v0.37.0/explainers/cspell.json
new file mode 100644
index 00000000000..c60b0a597b1
--- /dev/null
+++ b/docs/versioned_docs/version-v0.37.0/explainers/cspell.json
@@ -0,0 +1,5 @@
+{
+    "words": [
+        "Cryptdoku"
+    ]
+}
diff --git a/docs/versioned_docs/version-v0.37.0/explainers/explainer-oracle.md b/docs/versioned_docs/version-v0.37.0/explainers/explainer-oracle.md
new file mode 100644
index 00000000000..821e1f95c04
--- /dev/null
+++ b/docs/versioned_docs/version-v0.37.0/explainers/explainer-oracle.md
@@ -0,0 +1,57 @@
+---
+title: Oracles
+description: This guide provides an in-depth understanding of how Oracles work in Noir programming. Learn how to use outside calculations in your programs, constrain oracles, and understand their uses and limitations.
+keywords:
+  - Noir Programming
+  - Oracles
+  - JSON-RPC
+  - Foreign Call Handlers
+  - Constrained Functions
+  - Blockchain Programming
+sidebar_position: 1
+---
+
+If you've seen "The Matrix" you may recall "The Oracle" as Gloria Foster smoking cigarettes and baking cookies. While she appears to "know things", she is actually providing a calculation of a pre-determined future. Noir Oracles are similar, in a way. They don't calculate the future (yet), but they allow you to use outside calculations in your programs.
+
+![matrix oracle prediction](@site/static/img/memes/matrix_oracle.jpeg)
+
+A Noir program is usually self-contained. You can pass certain inputs to it, and it will generate a deterministic output for those inputs. But what if you wanted to defer some calculation to an outside process or source?
+
+Oracles are functions that provide this feature.
+
+## Use cases
+
+An example usage for Oracles is proving something on-chain. For example, proving that the ETH-USDC quote was below a certain target at a certain block time. Or even making more complex proofs like proving the ownership of an NFT as an anonymous login method.
+
+Another interesting use case is to defer expensive calculations to be made outside of the Noir program, and then constraining the result; similar to the use of [unconstrained functions](../noir/concepts//unconstrained.md).
+
+In short, anything that can be constrained in a Noir program but needs to be fetched from an external source is a great candidate to be used in oracles.
+
+## Constraining oracles
+
+Just like in The Matrix, Oracles are powerful. But with great power, comes great responsibility. Just because you're using them in a Noir program doesn't mean they're true. Noir has no superpowers. If you want to prove that Portugal won the Euro Cup 2016, you're still relying on potentially untrusted information.
+
+To give a concrete example, Alice wants to login to the [NounsDAO](https://nouns.wtf/) forum with her username "noir_nouner" by proving she owns a noun without revealing her ethereum address. Her Noir program could have an oracle call like this:
+
+```rust
+#[oracle(getNoun)]
+unconstrained fn get_noun(address: Field) -> Field
+```
+
+This oracle could naively resolve with the number of Nouns she possesses. However, it is useless as a trusted source, as the oracle could resolve to anything Alice wants. In order to make this oracle call actually useful, Alice would need to constrain the response from the oracle, by proving her address and the noun count belongs to the state tree of the contract.
+
+In short, **Oracles don't prove anything. Your Noir program does.**
+
+:::danger
+
+If you don't constrain the return of your oracle, you could be clearly opening an attack vector on your Noir program. Make double-triple sure that the return of an oracle call is constrained!
+
+:::
+
+## How to use Oracles
+
+On CLI, Nargo resolves oracles by making JSON RPC calls, which means it would require an RPC node to be running.
+
+In JavaScript, NoirJS accepts and resolves arbitrary call handlers (that is, not limited to JSON) as long as they match the expected types the developer defines. Refer to [Foreign Call Handler](../reference/NoirJS/noir_js/type-aliases/ForeignCallHandler.md) to learn more about NoirJS's call handling.
+
+If you want to build using oracles, follow through to the [oracle guide](../how_to/how-to-oracles.md) for a simple example on how to do that.
diff --git a/docs/versioned_docs/version-v0.37.0/explainers/explainer-recursion.md b/docs/versioned_docs/version-v0.37.0/explainers/explainer-recursion.md
new file mode 100644
index 00000000000..df8529ef4e0
--- /dev/null
+++ b/docs/versioned_docs/version-v0.37.0/explainers/explainer-recursion.md
@@ -0,0 +1,176 @@
+---
+title: Recursive proofs
+description: Explore the concept of recursive proofs in Zero-Knowledge programming. Understand how recursion works in Noir, a language for writing smart contracts on the EVM blockchain. Learn through practical examples like Alice and Bob's guessing game, Charlie's recursive merkle tree, and Daniel's reusable components. Discover how to use recursive proofs to optimize computational resources and improve efficiency.
+
+keywords:
+  [
+    "Recursive Proofs",
+    "Zero-Knowledge Programming",
+    "Noir",
+    "EVM Blockchain",
+    "Smart Contracts",
+    "Recursion in Noir",
+    "Alice and Bob Guessing Game",
+    "Recursive Merkle Tree",
+    "Reusable Components",
+    "Optimizing Computational Resources",
+    "Improving Efficiency",
+    "Verification Key",
+    "Aggregation",
+    "Recursive zkSNARK schemes",
+    "PLONK",
+    "Proving and Verification Keys"
+  ]
+sidebar_position: 1
+pagination_next: how_to/how-to-recursion
+---
+
+In programming, we tend to think of recursion as something calling itself. A classic example would be the calculation of the factorial of a number:
+
+```js
+function factorial(n) {
+    if (n === 0 || n === 1) {
+        return 1;
+    } else {
+        return n * factorial(n - 1);
+    }
+}
+```
+
+In this case, while `n` is not `1`, this function will keep calling itself until it hits the base case, bubbling up the result on the call stack:
+
+```md
+        Is `n` 1?  <---------
+           /\               /
+          /  \         n = n -1 
+         /    \           /
+       Yes     No --------
+```
+
+In Zero-Knowledge, recursion has some similarities.
+
+It is not a Noir function calling itself, but a proof being used as an input to another circuit. In short, you verify one proof *inside* another proof, returning the proof that both proofs are valid.
+
+This means that, given enough computational resources, you can prove the correctness of any arbitrary number of proofs in a single proof. This could be useful to design state channels (for which a common example would be [Bitcoin's Lightning Network](https://en.wikipedia.org/wiki/Lightning_Network)), to save on gas costs by settling one proof on-chain, or simply to make business logic less dependent on a consensus mechanism.
+
+## Examples
+
+Let us look at some of these examples
+
+### Alice and Bob - Guessing game
+
+Alice and Bob are friends, and they like guessing games. They want to play a guessing game online, but for that, they need a trusted third-party that knows both of their secrets and finishes the game once someone wins.
+
+So, they use zero-knowledge proofs. Alice tries to guess Bob's number, and Bob will generate a ZK proof stating whether she succeeded or failed.
+
+This ZK proof can go on a smart contract, revealing the winner and even giving prizes. However, this means every turn needs to be verified on-chain. This incurs some cost and waiting time that may simply make the game too expensive or time-consuming to be worth it.
+
+As a solution, Alice proposes the following: "what if Bob generates his proof, and instead of sending it on-chain, I verify it *within* my own proof before playing my own turn?".
+
+She can then generate a proof that she verified his proof, and so on.
+
+```md
+      Did you fail?  <--------------------------
+           / \                                  /
+          /   \                             n = n -1 
+         /     \                              /
+       Yes      No                           /
+        |        |                          /
+        |        |                         /
+        |      You win                    /
+        |                                /
+        |                               /
+Generate proof of that                 /
+        +                             /
+    my own guess     ----------------
+```
+
+### Charlie - Recursive merkle tree
+
+Charlie is a concerned citizen, and wants to be sure his vote in an election is accounted for. He votes with a ZK proof, but he has no way of knowing that his ZK proof was included in the total vote count!
+
+If the vote collector puts all of the votes into a [Merkle tree](https://en.wikipedia.org/wiki/Merkle_tree), everyone can prove the verification of two proofs within one proof, as such:
+
+```md
+                    abcd
+           __________|______________
+          |                         |
+         ab                         cd 
+     _____|_____              ______|______
+    |           |            |             |              
+  alice        bob        charlie        daniel 
+```
+
+Doing this recursively allows us to arrive on a final proof `abcd` which if true, verifies the correctness of all the votes.
+
+### Daniel - Reusable components
+
+Daniel has a big circuit and a big headache. A part of his circuit is a setup phase that finishes with some assertions that need to be made. But that section alone takes most of the proving time, and is largely independent of the rest of the circuit.
+
+He might find it more efficient to generate a proof for that setup phase separately, and verify that proof recursively in the actual business logic section of his circuit. This will allow for parallelization of both proofs, which results in a considerable speedup.
+
+## What params do I need
+
+As you can see in the [recursion reference](noir/standard_library/recursion.mdx), a simple recursive proof requires:
+
+- The proof to verify
+- The Verification Key of the circuit that generated the proof
+- A hash of this verification key, as it's needed for some backends
+- The public inputs for the proof
+
+:::info
+
+Recursive zkSNARK schemes do not necessarily "verify a proof" in the sense that you expect a true or false to be spit out by the verifier. Rather an aggregation object is built over the public inputs.
+
+So, taking the example of Alice and Bob and their guessing game:
+
+- Alice makes her guess. Her proof is *not* recursive: it doesn't verify any proof within it! It's just a standard `assert(x != y)` circuit
+- Bob verifies Alice's proof and makes his own guess. In this circuit, he doesn't exactly *prove* the verification of Alice's proof. Instead, he *aggregates* his proof to Alice's proof. The actual verification is done when the full proof is verified, for example when using `nargo verify` or through the verifier smart contract.
+
+We can imagine recursive proofs a [relay race](https://en.wikipedia.org/wiki/Relay_race). The first runner doesn't have to receive the baton from anyone else, as he/she already starts with it. But when his/her turn is over, the next runner needs to receive it, run a bit more, and pass it along. Even though every runner could theoretically verify the baton mid-run (why not? 🏃🔍), only at the end of the race does the referee verify that the whole race is valid.
+
+:::
+
+## Some architecture
+
+As with everything in computer science, there's no one-size-fits all. But there are some patterns that could help understanding and implementing them. To give three examples:
+
+### Adding some logic to a proof verification
+
+This would be an approach for something like our guessing game, where proofs are sent back and forth and are verified by each opponent. This circuit would be divided in two sections:
+
+- A `recursive verification` section, which would be just the call to `std::verify_proof`, and that would be skipped on the first move (since there's no proof to verify)
+- A `guessing` section, which is basically the logic part where the actual guessing happens
+
+In such a situation, and assuming Alice is first, she would skip the first part and try to guess Bob's number. Bob would then verify her proof on the first section of his run, and try to guess Alice's number on the second part, and so on.
+
+### Aggregating proofs
+
+In some one-way interaction situations, recursion would allow for aggregation of simple proofs that don't need to be immediately verified on-chain or elsewhere.
+
+To give a practical example, a barman wouldn't need to verify a "proof-of-age" on-chain every time he serves alcohol to a customer. Instead, the architecture would comprise two circuits:
+
+- A `main`, non-recursive circuit with some logic
+- A `recursive` circuit meant to verify two proofs in one proof
+
+The customer's proofs would be intermediate, and made on their phones, and the barman could just verify them locally. He would then aggregate them into a final proof sent on-chain (or elsewhere) at the end of the day.
+
+### Recursively verifying different circuits
+
+Nothing prevents you from verifying different circuits in a recursive proof, for example:
+
+- A `circuit1` circuit
+- A `circuit2` circuit
+- A `recursive` circuit
+
+In this example, a regulator could verify that taxes were paid for a specific purchase by aggregating both a `payer` circuit (proving that a purchase was made and taxes were paid), and a `receipt` circuit (proving that the payment was received)
+
+## How fast is it
+
+At the time of writing, verifying recursive proofs is surprisingly fast. This is because most of the time is spent on generating the verification key that will be used to generate the next proof. So you are able to cache the verification key and reuse it later.
+
+Currently, Noir JS packages don't expose the functionality of loading proving and verification keys, but that feature exists in the underlying `bb.js` package.
+
+## How can I try it
+
+Learn more about using recursion in Nargo and NoirJS in the [how-to guide](../how_to/how-to-recursion.md) and see a full example in [noir-examples](https://github.com/noir-lang/noir-examples).
diff --git a/docs/versioned_docs/version-v0.37.0/explainers/explainer-writing-noir.md b/docs/versioned_docs/version-v0.37.0/explainers/explainer-writing-noir.md
new file mode 100644
index 00000000000..3ce4245dc45
--- /dev/null
+++ b/docs/versioned_docs/version-v0.37.0/explainers/explainer-writing-noir.md
@@ -0,0 +1,177 @@
+---
+title: Thinking in Circuits
+description: Considerations when writing Noir programs
+keywords: [Noir, programming, rust]
+tags: [Optimization]
+sidebar_position: 0
+---
+
+
+This article intends to set you up with key concepts essential for writing more viable applications that use zero knowledge proofs, namely around efficient circuits.
+
+## Context - 'Efficient' is subjective
+
+When writing a web application for a performant computer with high-speed internet connection, writing efficient code sometimes is seen as an afterthought only if needed. Large multiplications running at the innermost of nested loops may not even be on a dev's radar.
+When writing firmware for a battery-powered microcontroller, you think of cpu cycles as rations to keep within a product's power budget.
+
+> Code is written to create applications that perform specific tasks within specific constraints
+
+And these constraints differ depending on where the compiled code is execute.
+
+### The Ethereum Virtual Machine (EVM)
+
+In scenarios where extremely low gas costs are required for an Ethereum application to be viable/competitive, Ethereum smart contract developers get into what is colloquially known as: "*gas golfing*". Finding the lowest execution cost of their compiled code (EVM bytecode) to achieve a specific task.
+
+The equivalent optimization task when writing zk circuits is affectionately referred to as "*gate golfing*", finding the lowest gate representation of the compiled Noir code.
+
+### Coding for circuits - a paradigm shift
+
+In zero knowledge cryptography, code is compiled to "circuits" consisting of arithmetic gates, and gate count is the significant cost. Depending on the proving system this is linearly proportionate to proving time, and so from a product point this should be kept as low as possible.
+
+Whilst writing efficient code for web apps and Solidity has a few key differences, writing efficient circuits have a different set of considerations. It is a bit of a paradigm shift, like writing code for GPUs for the first time...
+
+For example, drawing a circle at (0, 0) of radius `r`:
+- For a single CPU thread,
+```
+for theta in 0..2*pi {
+  let x = r * cos(theta);
+  let y = r * sin(theta);
+  draw(x, y);
+} // note: would do 0 - pi/2 and draw +ve/-ve x and y.
+```
+
+- For GPUs (simultaneous parallel calls with x, y across image),
+```
+if (x^2 + y^2 = r^2) {
+  draw(x, y);
+}
+```
+
+([Related](https://www.youtube.com/watch?v=-P28LKWTzrI))
+
+Whilst this CPU -> GPU does not translate to circuits exactly, it is intended to exemplify the difference in intuition when coding for different machine capabilities/constraints.
+
+### Context Takeaway
+
+For those coming from a primarily web app background, this article will explain what you need to consider when writing circuits. Furthermore, for those experienced writing efficient machine code, prepare to shift what you think is efficient 😬
+
+## Translating from Rust
+
+For some applications using Noir, existing code might be a convenient starting point to then proceed to optimize the gate count of.
+
+:::note
+Many valuable functions and algorithms have been written in more established languages (C/C++), and converted to modern ones (like Rust).
+:::
+
+Fortunately for Noir developers, when needing a particular function a Rust implementation can be readily compiled into Noir with some key changes. While the compiler does a decent amount of optimizations, it won't be able to change code that has been optimized for clock-cycles into code optimized for arithmetic gates.
+
+A few things to do when converting Rust code to Noir:
+- `println!` is not a macro, use `println` function (same for `assert_eq`)
+- No early `return` in function. Use constrain via assertion instead
+- No passing by reference. Remove `&` operator to pass by value (copy)
+- No boolean operators (`&&`, `||`). Use bitwise operators (`&`, `|`) with boolean values
+- No type `usize`. Use types `u8`, `u32`, `u64`, ... 
+- `main` return must be public, `pub`
+- No `const`, use `global`
+- Noir's LSP is your friend, so error message should be informative enough to resolve syntax issues.
+
+## Writing efficient Noir for performant products
+
+The following points help refine our understanding over time.
+
+:::note
+A Noir program makes a statement that can be verified.
+:::
+
+It compiles to a structure that represents the calculation, and can assert results within the calculation at any stage (via the `constrain` keyword).
+
+A Noir program compiles to an Abstract Circuit Intermediate Representation which is:
+ - Conceptually a tree structure
+ - Leaves (inputs) are the `Field` type
+ - Nodes contain arithmetic operations to combine them (gates)
+ - The root is the final result (return value)
+
+:::tip
+The command `nargo info` shows the programs circuit size, and is useful to compare the value of changes made.
+You can dig deeper and use the `--print-acir` param to take a closer look at individual ACIR opcodes, and the proving backend to see its gate count (eg for barretenberg, `bb gates -b ./target/program.json`).
+:::
+
+### Use the `Field` type
+
+Since the native type of values in circuits are `Field`s, using them for variables in Noir means less gates converting them under the hood.
+Some things to be mindful of when using a Field type for a regular integer value:
+- A variable of type `Field` can be cast `as` an integer type (eg `u8`, `u64`)
+  - Note: this retains only the bits of the integer type. Eg a Field value of 260 as a `u8` becomes 4
+- For Field types arithmetic operations meaningfully overflow/underflow, yet for integer types they are checked according to their size
+- Comparisons and bitwise operations do not exist for `Field`s, cast to an appropriately sized integer type when you need to
+
+:::tip
+Where possible, use `Field` type for values. Using smaller value types, and bit-packing strategies, will result in MORE gates
+:::
+
+
+### Use Arithmetic over non-arithmetic operations
+
+Since circuits are made of arithmetic gates, the cost of arithmetic operations tends to be one gate. Whereas for procedural code, they represent several clock cycles.
+
+Inversely, non-arithmetic operators are achieved with multiple gates, vs 1 clock cycle for procedural code.
+
+| (cost\op)  | arithmetic<br>(`*`, `+`) | bit-wise ops<br>(eg `<`, `\|`, `>>`) |
+| - | - | - |
+| **cycles** | 10+ | 1 |
+| **gates**  | 1 | 10+ |
+
+Bit-wise operations (e.g. bit shifts `<<` and `>>`), albeit commonly used in general programming and especially for clock cycle optimizations, are on the contrary expensive in gates when performed within circuits.
+
+Translate away from bit shifts when writing constrained functions for the best performance.
+
+On the flip side, feel free to use bit shifts in unconstrained functions and tests if necessary, as they are executed outside of circuits and does not induce performance hits.
+
+### Use static over dynamic values
+
+Another general theme that manifests in different ways is that static reads are represented with less gates than dynamic ones.
+
+Reading from read-only memory (ROM) adds less gates than random-access memory (RAM), 2 vs ~3.25 due to the additional bounds checks. Arrays of fixed length (albeit used at a lower capacity), will generate less gates than dynamic storage.
+
+Related to this, if an index used to access an array is not known at compile time (ie unknown until run time), then ROM will be converted to RAM, expanding the gate count.
+
+:::tip
+Use arrays and indices that are known at compile time where possible.
+Using `assert_constant(i);` before an index, `i`, is used in an array will give a compile error if `i` is NOT known at compile time.
+:::
+
+### Leverage unconstrained execution
+
+Constrained verification can leverage unconstrained execution, this is especially useful for operations that are represented by many gates.
+Use an [unconstrained function](../noir/concepts/unconstrained.md) to perform gate-heavy calculations, then verify and constrain the result.
+
+Eg division generates more gates than multiplication, so calculating the quotient in an unconstrained function then constraining the product for the quotient and divisor (+ any remainder) equals the dividend will be more efficient.
+
+Use `  if is_unconstrained() { /`, to conditionally execute code if being called in an unconstrained vs constrained way.
+
+## Advanced
+
+Unless you're well into the depth of gate optimization, this advanced section can be ignored.
+
+### Combine arithmetic operations
+
+A Noir program can be honed further by combining arithmetic operators in a way that makes the most of each constraint of the backend proving system. This is in scenarios where the backend might not be doing this perfectly.
+
+Eg Barretenberg backend (current default for Noir) is a width-4 PLONKish constraint system
+$ w_1*w_2*q_m + w_1*q_1 + w_2*q_2 + w_3*q_3 + w_4*q_4 + q_c = 0 $
+
+Here we see there is one occurrence of witness 1 and 2 ($w_1$, $w_2$) being multiplied together, with addition to witnesses 1-4 ($w_1$ .. $w_4$) multiplied by 4 corresponding circuit constants ($q_1$ .. $q_4$) (plus a final circuit constant, $q_c$).
+
+Use `nargo info --print-acir`, to inspect the ACIR opcodes (and the proving system for gates), and it may present opportunities to amend the order of operations and reduce the number of constraints.
+
+#### Variable as witness vs expression
+
+If you've come this far and really know what you're doing at the equation level, a temporary lever (that will become unnecessary/useless over time) is: `std::as_witness`. This informs the compiler to save a variable as a witness not an expression.
+
+The compiler will mostly be correct and optimal, but this may help some near term edge cases that are yet to optimize.
+Note: When used incorrectly it will create **less** efficient circuits (higher gate count).
+
+## References
+- Guillaume's ["`Cryptdoku`" talk](https://www.youtube.com/watch?v=MrQyzuogxgg) (Jun'23)
+- Tips from Tom, Jake and Zac.
+- [Idiomatic Noir](https://www.vlayer.xyz/blog/idiomatic-noir-part-1-collections) blog post
diff --git a/docs/versioned_docs/version-v0.37.0/getting_started/noir_installation.md b/docs/versioned_docs/version-v0.37.0/getting_started/noir_installation.md
new file mode 100644
index 00000000000..f92fd8dea38
--- /dev/null
+++ b/docs/versioned_docs/version-v0.37.0/getting_started/noir_installation.md
@@ -0,0 +1,102 @@
+---
+title: Standalone Noir Installation
+description: There are different ways to install Nargo, the one-stop shop and command-line tool for developing Noir programs. This guide explains how to specify which version to install when using noirup, and using WSL for windows.
+keywords: [
+    Installation
+    Nargo
+    Noirup
+    Binaries
+    Compiling from Source
+    WSL for Windows
+    macOS
+    Linux
+    Nix
+    Direnv
+    Uninstalling Nargo
+  ]
+sidebar_position: 2
+---
+
+Noirup is the endorsed method for installing Nargo, streamlining the process of fetching binaries or compiling from source. It supports a range of options to cater to your specific needs, from nightly builds and specific versions to compiling from various sources.
+
+### Installing Noirup
+
+First, ensure you have `noirup` installed:
+
+```sh
+curl -L https://raw.githubusercontent.com/noir-lang/noirup/main/install | bash
+```
+
+### Fetching Binaries
+
+With `noirup`, you can easily switch between different Nargo versions, including nightly builds:
+
+- **Nightly Version**: Install the latest nightly build.
+
+  ```sh
+  noirup --version nightly
+  ```
+
+- **Specific Version**: Install a specific version of Nargo.
+
+  ```sh
+  noirup --version <version>
+  ```
+
+### Compiling from Source
+
+`noirup` also enables compiling Nargo from various sources:
+
+- **From a Specific Branch**: Install from the latest commit on a branch.
+
+  ```sh
+  noirup --branch <branch-name>
+  ```
+
+- **From a Fork**: Install from the main branch of a fork.
+
+  ```sh
+  noirup --repo <username/repo>
+  ```
+
+- **From a Specific Branch in a Fork**: Install from a specific branch in a fork.
+
+  ```sh
+  noirup --repo <username/repo> --branch <branch-name>
+  ```
+
+- **From a Specific Pull Request**: Install from a specific PR.
+
+  ```sh
+  noirup --pr <pr-number>
+  ```
+
+- **From a Specific Commit**: Install from a specific commit.
+
+  ```sh
+  noirup -C <commit-hash>
+  ```
+
+- **From Local Source**: Compile and install from a local directory.
+
+  ```sh
+  noirup --path ./path/to/local/source
+  ```
+
+## Installation on Windows
+
+The default backend for Noir (Barretenberg) doesn't provide Windows binaries at this time. For that reason, Noir cannot be installed natively. However, it is available by using Windows Subsystem for Linux (WSL).
+
+Step 1: Follow the instructions [here](https://learn.microsoft.com/en-us/windows/wsl/install) to install and run WSL.
+
+step 2: Follow the [Noirup instructions](#installing-noirup).
+
+## Uninstalling Nargo
+
+If you installed Nargo with `noirup`, you can uninstall Nargo by removing the files in `~/.nargo`, `~/nargo`, and `~/noir_cache`. This ensures that all installed binaries, configurations, and cache related to Nargo are fully removed from your system.
+
+```bash
+rm -r ~/.nargo
+rm -r ~/nargo
+rm -r ~/noir_cache
+```
diff --git a/docs/versioned_docs/version-v0.37.0/getting_started/project_breakdown.md b/docs/versioned_docs/version-v0.37.0/getting_started/project_breakdown.md
new file mode 100644
index 00000000000..e442e377040
--- /dev/null
+++ b/docs/versioned_docs/version-v0.37.0/getting_started/project_breakdown.md
@@ -0,0 +1,159 @@
+---
+title: Project Breakdown
+description:
+  Learn about the anatomy of a Nargo project, including the purpose of the Prover TOML
+  file, and how to prove and verify your program.
+keywords:
+  [Nargo, Nargo project, Prover.toml, proof verification, private asset transfer]
+sidebar_position: 1
+---
+
+This section breaks down our hello world program from the previous section.
+
+## Anatomy of a Nargo Project
+
+Upon creating a new project with `nargo new` and building the in/output files with `nargo check`
+commands, you would get a minimal Nargo project of the following structure:
+
+    - src
+    - Prover.toml
+    - Nargo.toml
+
+The source directory _src_ holds the source code for your Noir program. By default only a _main.nr_
+file will be generated within it.
+
+### Prover.toml
+
+_Prover.toml_ is used for specifying the input values for executing and proving the program. You can specify `toml` files with different names by using the `--prover-name` or `-p` flags, see the [Prover](#provertoml) section below. Optionally you may specify expected output values for prove-time checking as well.
+
+### Nargo.toml
+
+_Nargo.toml_ contains the environmental options of your project. It contains a "package" section and a "dependencies" section.
+
+Example Nargo.toml:
+
+```toml
+[package]
+name = "noir_starter"
+type = "bin"
+authors = ["Alice"]
+compiler_version = "0.9.0"
+description = "Getting started with Noir"
+entry = "circuit/main.nr"
+license = "MIT"
+
+[dependencies]
+ecrecover = {tag = "v0.9.0", git = "https://github.com/colinnielsen/ecrecover-noir.git"}
+```
+
+Nargo.toml for a [workspace](../noir/modules_packages_crates/workspaces.md) will look a bit different. For example:
+
+```toml
+[workspace]
+members = ["crates/a", "crates/b"]
+default-member = "crates/a"
+```
+
+#### Package section
+
+The package section defines a number of fields including:
+
+- `name` (**required**) - the name of the package
+- `type` (**required**) - can be "bin", "lib", or "contract" to specify whether its a binary, library or Aztec contract
+- `authors` (optional) - authors of the project
+- `compiler_version` - specifies the version of the compiler to use. This is enforced by the compiler and follow's [Rust's versioning](https://doc.rust-lang.org/cargo/reference/manifest.html#the-version-field), so a `compiler_version = 0.18.0` will enforce Nargo version 0.18.0, `compiler_version = ^0.18.0` will enforce anything above 0.18.0 but below 0.19.0, etc. For more information, see how [Rust handles these operators](https://docs.rs/semver/latest/semver/enum.Op.html)
+- `description` (optional)
+- `entry` (optional) - a relative filepath to use as the entry point into your package (overrides the default of `src/lib.nr` or `src/main.nr`)
+- `backend` (optional)
+- `license` (optional)
+- `expression_width` (optional) - Sets the default backend expression width. This field will override the default backend expression width specified by the Noir compiler (currently set to width 4).
+
+#### Dependencies section
+
+This is where you will specify any dependencies for your project. See the [Dependencies page](../noir/modules_packages_crates/dependencies.md) for more info.
+
+`./proofs/` and `./contract/` directories will not be immediately visible until you create a proof or
+verifier contract respectively.
+
+### main.nr
+
+The _main.nr_ file contains a `main` method, this method is the entry point into your Noir program.
+
+In our sample program, _main.nr_ looks like this:
+
+```rust
+fn main(x : Field, y : Field) {
+    assert(x != y);
+}
+```
+
+The parameters `x` and `y` can be seen as the API for the program and must be supplied by the prover. Since neither `x` nor `y` is marked as public, the verifier does not supply any inputs, when verifying the proof.
+
+The prover supplies the values for `x` and `y` in the _Prover.toml_ file.
+
+As for the program body, `assert` ensures that the condition to be satisfied (e.g. `x != y`) is constrained by the proof of the execution of said program (i.e. if the condition was not met, the verifier would reject the proof as an invalid proof).
+
+### Prover.toml
+
+The _Prover.toml_ file is a file which the prover uses to supply the inputs to the Noir program (both private and public).
+
+In our hello world program the _Prover.toml_ file looks like this:
+
+```toml
+x = "1"
+y = "2"
+```
+
+When the command `nargo execute` is executed, nargo will execute the Noir program using the inputs specified in `Prover.toml`, aborting if it finds that these do not satisfy the constraints defined by `main`. In this example, `x` and `y` must satisfy the inequality constraint `assert(x != y)`.
+
+If an output name is specified such as `nargo execute foo`, the witness generated by this execution will be written to `./target/foo.gz`. This can then be used to generate a proof of the execution.
+
+#### Arrays of Structs
+
+The following code shows how to pass an array of structs to a Noir program to generate a proof.
+
+```rust
+// main.nr
+struct Foo {
+    bar: Field,
+    baz: Field,
+}
+
+fn main(foos: [Foo; 3]) -> pub Field {
+    foos[2].bar + foos[2].baz
+}
+```
+
+Prover.toml:
+
+```toml
+[[foos]] # foos[0]
+bar = 0
+baz = 0
+
+[[foos]] # foos[1]
+bar = 0
+baz = 0
+
+[[foos]] # foos[2]
+bar = 1
+baz = 2
+```
+
+#### Custom toml files
+
+You can specify a `toml` file with a different name to use for execution by using the `--prover-name` or `-p` flags.
+
+This command looks for proof inputs in the default **Prover.toml** and generates the witness and saves it at `./target/foo.gz`:
+
+```bash
+nargo execute foo
+```
+
+This command looks for proof inputs in the custom **OtherProver.toml** and generates the witness and saves it at `./target/bar.gz`:
+
+```bash
+nargo execute -p OtherProver bar
+```
+
+Now that you understand the concepts, you'll probably want some editor feedback while you are writing more complex code.
diff --git a/docs/versioned_docs/version-v0.37.0/getting_started/quick_start.md b/docs/versioned_docs/version-v0.37.0/getting_started/quick_start.md
new file mode 100644
index 00000000000..4ce48409818
--- /dev/null
+++ b/docs/versioned_docs/version-v0.37.0/getting_started/quick_start.md
@@ -0,0 +1,124 @@
+---
+title: Quick Start
+tags: []
+sidebar_position: 0
+---
+
+## Installation
+
+### Noir
+
+The easiest way to develop with Noir is using Nargo the CLI tool. It provides you the ability to start new projects, compile, execute and test Noir programs from the terminal.
+
+You can use `noirup` the installation script to quickly install and update Nargo:
+
+```bash
+curl -L noirup.dev | bash
+noirup
+```
+
+### Proving backend
+
+After installing Noir, we install a proving backend to work with our Noir programs.
+
+Proving backends provide you the abilities to generate proofs, verify proofs, generate smart contracts and more for your Noir programs.
+
+Different proving backends provide different tools for working with Noir programs, here we will use the [Barretenberg proving backend](https://github.com/AztecProtocol/aztec-packages/tree/master/barretenberg) developed by Aztec Labs as an example.
+
+You can use the `bbup` installation script to quickly install and update BB, Barretenberg's CLI tool:
+
+You can find the full list of proving backends compatible with Noir in Awesome Noir.
+
+```bash
+curl -L bbup.dev | bash
+bbup
+```
+
+For the full list of proving backends compatible with Noir, visit [Awesome Noir](https://github.com/noir-lang/awesome-noir/?tab=readme-ov-file#proving-backends).
+
+## Nargo
+
+Nargo provides the ability to initiate and execute Noir projects. Let's initialize the traditional `hello_world`:
+
+```sh
+nargo new hello_world
+```
+
+Two files will be created.
+
+- `src/main.nr` contains a simple boilerplate circuit
+- `Nargo.toml` contains environmental options, such as name, author, dependencies, and others.
+
+Glancing at _main.nr_ , we can see that inputs in Noir are private by default, but can be labeled public using the keyword `pub`. This means that we will _assert_ that we know a value `x` which is different from `y` without revealing `x`:
+
+```rust
+fn main(x : Field, y : pub Field) {
+    assert(x != y);
+}
+```
+
+To learn more about private and public values, check the [Data Types](../noir/concepts/data_types/index.md) section.
+
+### Compiling and executing
+
+We can now use `nargo` to generate a _Prover.toml_ file, where our input values will be specified:
+
+```sh
+cd hello_world
+nargo check
+
+Let's feed some valid values into this file:
+
+```toml
+x = "1"
+y = "2"
+```
+
+We're now ready to compile and execute our Noir program. By default the `nargo execute` command will do both, and generate the `witness` that we need to feed to our proving backend:
+
+```sh
+nargo execute
+```
+
+The witness corresponding to this execution will then be written to the file _./target/witness-name.gz_.
+
+The command also automatically compiles your Noir program if it was not already / was edited, which you may notice the compiled artifacts being written to the file _./target/hello_world.json_.
+
+With circuit compiled and witness generated, we're ready to prove.
+
+## Proving backend
+ 
+Different proving backends may provide different tools and commands to work with Noir programs. Here Barretenberg's `bb` CLI tool is used as an example:
+
+```sh
+bb prove -b ./target/hello_world.json -w ./target/hello_world.gz -o ./target/proof
+```
+
+:::tip
+
+Naming can be confusing, specially as you pass them to the `bb` commands. If unsure, it won't hurt to delete the target folder and start anew to make sure you're using the most recent versions of the compiled circuit and witness.
+
+:::
+
+The proof is now generated in the `target` folder. To verify it we first need to compute the verification key from the compiled circuit, and use it to verify:
+
+```sh
+bb write_vk -b ./target/hello_world.json -o ./target/vk
+bb verify -k ./target/vk -p ./target/proof
+```
+
+:::info
+
+Notice that in order to verify a proof, the verifier knows nothing but the circuit, which is compiled and used to generate the verification key. This is obviously quite important: private inputs remain private.
+
+As for the public inputs, you may have noticed they haven't been specified. This behavior varies with each particular backend, but barretenberg typically attaches them to the proof. You can see them by parsing and splitting it. For example for if your public inputs are 32 bytes:
+
+```bash
+head -c 32 ./target/proof | od -An -v -t x1 | tr -d $' \n'
+```
+
+:::
+
+Congratulations, you have now created and verified a proof for your very first Noir program!
+
+In the [next section](./project_breakdown.md), we will go into more detail on each step performed.
diff --git a/docs/versioned_docs/version-v0.37.0/how_to/_category_.json b/docs/versioned_docs/version-v0.37.0/how_to/_category_.json
new file mode 100644
index 00000000000..23b560f610b
--- /dev/null
+++ b/docs/versioned_docs/version-v0.37.0/how_to/_category_.json
@@ -0,0 +1,5 @@
+{
+    "position": 1,
+    "collapsible": true,
+    "collapsed": true
+}
diff --git a/docs/versioned_docs/version-v0.37.0/how_to/debugger/_category_.json b/docs/versioned_docs/version-v0.37.0/how_to/debugger/_category_.json
new file mode 100644
index 00000000000..cc2cbb1c253
--- /dev/null
+++ b/docs/versioned_docs/version-v0.37.0/how_to/debugger/_category_.json
@@ -0,0 +1,6 @@
+{
+    "label": "Debugging",
+    "position": 5,
+    "collapsible": true,
+    "collapsed": true
+}
diff --git a/docs/versioned_docs/version-v0.37.0/how_to/debugger/debugging_with_the_repl.md b/docs/versioned_docs/version-v0.37.0/how_to/debugger/debugging_with_the_repl.md
new file mode 100644
index 00000000000..1d64dae3f37
--- /dev/null
+++ b/docs/versioned_docs/version-v0.37.0/how_to/debugger/debugging_with_the_repl.md
@@ -0,0 +1,164 @@
+---
+title: Using the REPL Debugger
+description:
+  Step-by-step guide on how to debug your Noir circuits with the REPL Debugger. 
+keywords:
+  [
+    Nargo,
+    Noir CLI,
+    Noir Debugger,
+    REPL,
+  ]
+sidebar_position: 1
+---
+
+#### Pre-requisites
+
+In order to use the REPL debugger, first you need to install recent enough versions of Nargo and vscode-noir. 
+
+## Debugging a simple circuit
+
+Let's debug a simple circuit:
+
+```rust
+fn main(x : Field, y : pub Field) {
+    assert(x != y);
+}
+```
+
+To start the REPL debugger, using a terminal, go to a Noir circuit's home directory. Then:
+
+`$ nargo debug`
+
+You should be seeing this in your terminal:
+
+```
+[main] Starting debugger
+At ~/noir-examples/recursion/circuits/main/src/main.nr:1:9
+  1 -> fn main(x : Field, y : pub Field) {
+  2        assert(x != y);
+  3    }
+> 
+```
+
+The debugger displays the current Noir code location, and it is now waiting for us to drive it.
+
+Let's first take a look at the available commands. For that we'll use the `help` command.
+
+```
+> help
+Available commands:
+
+  opcodes                          display ACIR opcodes
+  into                             step into to the next opcode
+  next                             step until a new source location is reached
+  out                              step until a new source location is reached
+                                   and the current stack frame is finished
+  break LOCATION:OpcodeLocation    add a breakpoint at an opcode location
+  over                             step until a new source location is reached
+                                   without diving into function calls
+  restart                          restart the debugging session
+  delete LOCATION:OpcodeLocation   delete breakpoint at an opcode location
+  witness                          show witness map
+  witness index:u32                display a single witness from the witness map
+  witness index:u32 value:String   update a witness with the given value
+  memset index:usize value:String  update a memory cell with the given
+                                   value
+  continue                         continue execution until the end of the
+                                   program
+  vars                             show variable values available at this point
+                                   in execution
+  stacktrace                       display the current stack trace
+  memory                           show memory (valid when executing unconstrained code)
+  step                             step to the next ACIR opcode
+
+Other commands:
+
+  help  Show this help message
+  quit  Quit repl
+
+```
+
+Some commands operate only for unconstrained functions, such as `memory` and `memset`. If you try to use them while execution is paused at an ACIR opcode, the debugger will simply inform you that you are not executing unconstrained code:
+
+```
+> memory
+Unconstrained VM memory not available
+> 
+```
+
+Before continuing, we can take a look at the initial witness map:
+
+```
+> witness
+_0 = 1
+_1 = 2
+>
+```
+
+Cool, since `x==1`, `y==2`, and we want to check that `x != y`, our circuit should succeed. At this point we could intervene and use the witness setter command to change one of the witnesses. Let's set `y=3`, then back to 2, so we don't affect the expected result:
+
+```
+> witness
+_0 = 1
+_1 = 2
+> witness 1 3
+_1 = 3
+> witness
+_0 = 1
+_1 = 3
+> witness 1 2
+_1 = 2
+> witness
+_0 = 1
+_1 = 2
+>
+```
+
+Now we can inspect the current state of local variables. For that we use the `vars` command. 
+
+```
+> vars
+>
+```
+
+We currently have no vars in context, since we are at the entry point of the program. Let's use `next` to execute until the next point in the program.
+
+```
+> vars
+> next
+At ~/noir-examples/recursion/circuits/main/src/main.nr:1:20
+  1 -> fn main(x : Field, y : pub Field) {
+  2        assert(x != y);
+  3    }
+> vars
+x:Field = 0x01
+```
+
+As a result of stepping, the variable `x`, whose initial value comes from the witness map, is now in context and returned by `vars`.
+
+```
+> next
+  1    fn main(x : Field, y : pub Field) {
+  2 ->     assert(x != y);
+  3    }
+> vars
+y:Field = 0x02
+x:Field = 0x01
+```
+
+Stepping again we can finally see both variables and their values. And now we can see that the next assertion should succeed.
+
+Let's continue to the end:
+
+```
+> continue
+(Continuing execution...)
+Finished execution
+> q
+[main] Circuit witness successfully solved
+```
+
+Upon quitting the debugger after a solved circuit, the resulting circuit witness gets saved, equivalent to what would happen if we had run the same circuit with `nargo execute`.
+
+We just went through the basics of debugging using Noir REPL debugger. For a comprehensive reference, check out [the reference page](../../reference/debugger/debugger_repl.md).
diff --git a/docs/versioned_docs/version-v0.37.0/how_to/debugger/debugging_with_vs_code.md b/docs/versioned_docs/version-v0.37.0/how_to/debugger/debugging_with_vs_code.md
new file mode 100644
index 00000000000..a5858c1a5eb
--- /dev/null
+++ b/docs/versioned_docs/version-v0.37.0/how_to/debugger/debugging_with_vs_code.md
@@ -0,0 +1,68 @@
+---
+title: Using the VS Code Debugger
+description:
+  Step by step guide on how to debug your Noir circuits with the VS Code Debugger configuration and features.
+keywords:
+  [
+    Nargo,
+    Noir CLI,
+    Noir Debugger,
+    VS Code,
+    IDE,
+  ]
+sidebar_position: 0
+---
+
+This guide will show you how to use VS Code with the vscode-noir extension to debug a Noir project. 
+
+#### Pre-requisites
+
+- Nargo
+- vscode-noir
+- A Noir project with a `Nargo.toml`, `Prover.toml` and at least one Noir (`.nr`) containing an entry point function (typically `main`).
+
+## Running the debugger
+
+The easiest way to start debugging is to open the file you want to debug, and press `F5`. This will cause the debugger to launch, using your `Prover.toml` file as input.
+
+You should see something like this:
+
+![Debugger launched](@site/static/img/debugger/1-started.png)
+
+Let's inspect the state of the program. For that, we open VS Code's _Debug pane_. Look for this icon:
+
+![Debug pane icon](@site/static/img/debugger/2-icon.png)
+
+You will now see two categories of variables: Locals and Witness Map.
+
+![Debug pane expanded](@site/static/img/debugger/3-debug-pane.png)
+
+1. **Locals**: variables of your program. At this point in execution this section is empty, but as we step through the code it will get populated by `x`, `result`, `digest`, etc. 
+
+2. **Witness map**: these are initially populated from your project's `Prover.toml` file. In this example, they will be used to populate `x` and `result` at the beginning of the `main` function.
+
+Most of the time you will probably be focusing mostly on locals, as they represent the high level state of your program. 
+
+You might be interested in inspecting the witness map in case you are trying to solve a really low level issue in the compiler or runtime itself, so this concerns mostly advanced or niche users.
+
+Let's step through the program, by using the debugger buttons or their corresponding keyboard shortcuts.
+
+![Debugger buttons](@site/static/img/debugger/4-debugger-buttons.png)
+
+Now we can see in the variables pane that there's values for `digest`, `result` and `x`.
+
+![Inspecting locals](@site/static/img/debugger/5-assert.png)
+
+We can also inspect the values of variables by directly hovering on them on the code.
+
+![Hover locals](@site/static/img/debugger/6-hover.png)
+
+Let's set a break point at the `keccak256` function, so we can continue execution up to the point when it's first invoked without having to go one step at a time. 
+
+We just need to click the to the right of the line number 18. Once the breakpoint appears, we can click the `continue` button or use its corresponding keyboard shortcut (`F5` by default).
+
+![Breakpoint](@site/static/img/debugger/7-break.png)
+
+Now we are debugging the `keccak256` function, notice the _Call Stack pane_ at the lower right. This lets us inspect the current call stack of our process.
+
+That covers most of the current debugger functionalities. Check out [the reference](../../reference/debugger/debugger_vscode.md) for more details on how to configure the debugger.
\ No newline at end of file
diff --git a/docs/versioned_docs/version-v0.37.0/how_to/how-to-oracles.md b/docs/versioned_docs/version-v0.37.0/how_to/how-to-oracles.md
new file mode 100644
index 00000000000..08ce6ee5476
--- /dev/null
+++ b/docs/versioned_docs/version-v0.37.0/how_to/how-to-oracles.md
@@ -0,0 +1,275 @@
+---
+title: How to use Oracles
+description: Learn how to use oracles in your Noir program with examples in both Nargo and NoirJS. This guide also covers writing a JSON RPC server and providing custom foreign call handlers for NoirJS.
+keywords:
+  - Noir Programming
+  - Oracles
+  - Nargo
+  - NoirJS
+  - JSON RPC Server
+  - Foreign Call Handlers
+sidebar_position: 1
+---
+
+This guide shows you how to use oracles in your Noir program. For the sake of clarity, it assumes that:
+
+- You have read the [explainer on Oracles](../explainers/explainer-oracle.md) and are comfortable with the concept.
+- You have a Noir program to add oracles to. You can create one using the [vite-hardhat starter](https://github.com/noir-lang/noir-starter/tree/main/vite-hardhat) as a boilerplate.
+- You understand the concept of a JSON-RPC server. Visit the [JSON-RPC website](https://www.jsonrpc.org/) if you need a refresher.
+- You are comfortable with server-side JavaScript (e.g. Node.js, managing packages, etc.).
+
+## Rundown
+
+This guide has 3 major steps:
+
+1. How to modify our Noir program to make use of oracle calls as unconstrained functions
+2. How to write a JSON RPC Server to resolve these oracle calls with Nargo
+3. How to use them in Nargo and how to provide a custom resolver in NoirJS
+
+## Step 1 - Modify your Noir program
+
+An oracle is defined in a Noir program by defining two methods:
+
+- An unconstrained method - This tells the compiler that it is executing an [unconstrained functions](../noir/concepts//unconstrained.md).
+- A decorated oracle method - This tells the compiler that this method is an RPC call.
+
+An example of an oracle that returns a `Field` would be:
+
+```rust
+#[oracle(getSqrt)]
+unconstrained fn sqrt(number: Field) -> Field { }
+
+unconstrained fn get_sqrt(number: Field) -> Field {
+    sqrt(number)
+}
+```
+
+In this example, we're wrapping our oracle function in an unconstrained method, and decorating it with `oracle(getSqrt)`. We can then call the unconstrained function as we would call any other function:
+
+```rust
+fn main(input: Field) {
+    let sqrt = get_sqrt(input);
+}
+```
+
+In the next section, we will make this `getSqrt` (defined on the `sqrt` decorator) be a method of the RPC server Noir will use.
+
+:::danger
+
+As explained in the [Oracle Explainer](../explainers/explainer-oracle.md), this `main` function is unsafe unless you constrain its return value. For example:
+
+```rust
+fn main(input: Field) {
+    let sqrt = get_sqrt(input);
+    assert(sqrt.pow_32(2) as u64 == input as u64); // <---- constrain the return of an oracle!
+}
+```
+
+:::
+
+:::info
+
+Currently, oracles only work with single params or array params. For example:
+
+```rust
+#[oracle(getSqrt)]
+unconstrained fn sqrt([Field; 2]) -> [Field; 2] { }
+```
+
+:::
+
+## Step 2 - Write an RPC server
+
+Brillig will call *one* RPC server. Most likely you will have to write your own, and you can do it in whatever language you prefer. In this guide, we will do it in Javascript.
+
+Let's use the above example of an oracle that consumes an array with two `Field` and returns their square roots:
+
+```rust
+#[oracle(getSqrt)]
+unconstrained fn sqrt(input: [Field; 2]) -> [Field; 2] { }
+
+unconstrained fn get_sqrt(input: [Field; 2]) -> [Field; 2] {
+    sqrt(input)
+}
+
+fn main(input: [Field; 2]) {
+    let sqrt = get_sqrt(input);
+    assert(sqrt[0].pow_32(2) as u64 == input[0] as u64);
+    assert(sqrt[1].pow_32(2) as u64 == input[1] as u64);
+}
+
+#[test]
+fn test() {
+    let input = [4, 16];
+    main(input);
+}
+```
+
+:::info
+
+Why square root?
+
+In general, computing square roots is computationally more expensive than multiplications, which takes a toll when speaking about ZK applications. In this case, instead of calculating the square root in Noir, we are using our oracle to offload that computation to be made in plain. In our circuit we can simply multiply the two values.
+
+:::
+
+Now, we should write the correspondent RPC server, starting with the [default JSON-RPC 2.0 boilerplate](https://www.npmjs.com/package/json-rpc-2.0#example):
+
+```js
+import { JSONRPCServer } from "json-rpc-2.0";
+import express from "express";
+import bodyParser from "body-parser";
+
+const app = express();
+app.use(bodyParser.json());
+
+const server = new JSONRPCServer();
+app.post("/", (req, res) => {
+ const jsonRPCRequest = req.body;
+ server.receive(jsonRPCRequest).then((jsonRPCResponse) => {
+  if (jsonRPCResponse) {
+   res.json(jsonRPCResponse);
+  } else {
+   res.sendStatus(204);
+  }
+ });
+});
+
+app.listen(5555);
+```
+
+Now, we will add our `getSqrt` method, as expected by the `#[oracle(getSqrt)]` decorator in our Noir code. It maps through the params array and returns their square roots:
+
+```js
+server.addMethod("resolve_foreign_call", async (params) => {
+    if (params[0].function !== "getSqrt") {
+        throw Error("Unexpected foreign call")
+    };
+    const values = params[0].inputs[0].map((field) => {
+        return `${Math.sqrt(parseInt(field, 16))}`;
+    });
+    return { values: [values] };
+});
+```
+
+If you're using Typescript, the following types may be helpful in understanding the expected return value and making sure they're easy to follow:
+
+```js
+export type ForeignCallSingle = string;
+
+export type ForeignCallArray = string[];
+
+export type ForeignCallResult = {
+  values: (ForeignCallSingle | ForeignCallArray)[];
+};
+```
+
+:::info Multidimensional Arrays
+
+If the Oracle function is returning an array containing other arrays, such as `[['1','2],['3','4']]`, you need to provide the values in JSON as flattened values. In the previous example, it would be `['1', '2', '3', '4']`. In the Noir program, the Oracle signature can use a nested type, the flattened values will be automatically converted to the nested type.
+
+:::
+
+## Step 3 - Usage with Nargo
+
+Using the [`nargo` CLI tool](../reference/nargo_commands.md), you can use oracles in the `nargo test` and `nargo execute`  commands by passing a value to `--oracle-resolver`. For example:
+
+```bash
+nargo test --oracle-resolver http://localhost:5555
+```
+
+This tells `nargo` to use your RPC Server URL whenever it finds an oracle decorator.
+
+## Step 4 - Usage with NoirJS
+
+In a JS environment, an RPC server is not strictly necessary, as you may want to resolve your oracles without needing any JSON call at all. NoirJS simply expects that you pass a callback function when you generate proofs, and that callback function can be anything.
+
+For example, if your Noir program expects the host machine to provide CPU pseudo-randomness, you could simply pass it as the `foreignCallHandler`. You don't strictly need to create an RPC server to serve pseudo-randomness, as you may as well get it directly in your app:
+
+```js
+const foreignCallHandler = (name, inputs) => crypto.randomBytes(16) // etc
+
+await noir.execute(inputs, foreignCallHandler)
+```
+
+As one can see, in NoirJS, the [`foreignCallHandler`](../reference/NoirJS/noir_js/type-aliases/ForeignCallHandler.md) function simply means "a callback function that returns a value of type [`ForeignCallOutput`](../reference/NoirJS/noir_js/type-aliases/ForeignCallOutput.md). It doesn't have to be an RPC call like in the case for Nargo.
+
+:::tip
+
+Does this mean you don't have to write an RPC server like in [Step #2](#step-2---write-an-rpc-server)?
+
+You don't technically have to, but then how would you run `nargo test`? To use both `Nargo` and `NoirJS` in your development flow, you will have to write a JSON RPC server.
+
+:::
+
+In this case, let's make `foreignCallHandler` call the JSON RPC Server we created in [Step #2](#step-2---write-an-rpc-server), by making it a JSON RPC Client.
+
+For example, using the same `getSqrt` program in [Step #1](#step-1---modify-your-noir-program) (comments in the code):
+
+```js
+import { JSONRPCClient } from "json-rpc-2.0";
+
+// declaring the JSONRPCClient
+const client = new JSONRPCClient((jsonRPCRequest) => {
+// hitting the same JSON RPC Server we coded above
+ return fetch("http://localhost:5555", {
+  method: "POST",
+  headers: {
+   "content-type": "application/json",
+  },
+  body: JSON.stringify(jsonRPCRequest),
+ }).then((response) => {
+  if (response.status === 200) {
+   return response
+    .json()
+    .then((jsonRPCResponse) => client.receive(jsonRPCResponse));
+  } else if (jsonRPCRequest.id !== undefined) {
+   return Promise.reject(new Error(response.statusText));
+  }
+ });
+});
+
+// declaring a function that takes the name of the foreign call (getSqrt) and the inputs
+const foreignCallHandler = async (name, input) => {
+  const inputs = input[0].map((i) => i.toString("hex"))
+  // notice that the "inputs" parameter contains *all* the inputs
+  // in this case we to make the RPC request with the first parameter "numbers", which would be input[0]
+  const oracleReturn = await client.request("resolve_foreign_call", [
+    {
+      function: name,
+      inputs: [inputs]
+    },
+  ]);
+  return [oracleReturn.values[0]];
+};
+
+// the rest of your NoirJS code
+const input = { input: [4, 16] };
+const { witness } = await noir.execute(input, foreignCallHandler);
+```
+
+:::tip
+
+If you're in a NoirJS environment running your RPC server together with a frontend app, you'll probably hit a familiar problem in full-stack development: requests being blocked by [CORS](https://developer.mozilla.org/en-US/docs/Web/HTTP/CORS) policy. For development only, you can simply install and use the [`cors` npm package](https://www.npmjs.com/package/cors) to get around the problem:
+
+```bash
+yarn add cors
+```
+
+and use it as a middleware:
+
+```js
+import cors from "cors";
+
+const app = express();
+app.use(cors())
+```
+
+:::
+
+## Conclusion
+
+Hopefully by the end of this guide, you should be able to:
+
+- Write your own logic around Oracles and how to write a JSON RPC server to make them work with your Nargo commands.
+- Provide custom foreign call handlers for NoirJS.
\ No newline at end of file
diff --git a/docs/versioned_docs/version-v0.37.0/how_to/how-to-recursion.md b/docs/versioned_docs/version-v0.37.0/how_to/how-to-recursion.md
new file mode 100644
index 00000000000..fac79a9cf49
--- /dev/null
+++ b/docs/versioned_docs/version-v0.37.0/how_to/how-to-recursion.md
@@ -0,0 +1,172 @@
+---
+title: How to use recursion on NoirJS
+description: Learn how to implement recursion with NoirJS, a powerful tool for creating smart contracts on the EVM blockchain. This guide assumes familiarity with NoirJS, solidity verifiers, and the Barretenberg proving backend. Discover how to generate both final and intermediate proofs using `noir_js` and `bb.js`.
+keywords:
+  [
+    "NoirJS",
+    "EVM blockchain",
+    "smart contracts",
+    "recursion",
+    "solidity verifiers",
+    "Barretenberg backend",
+    "noir_js",
+    "intermediate proofs",
+    "final proofs",
+    "nargo compile",
+    "json import",
+    "recursive circuit",
+    "recursive app"
+  ]
+sidebar_position: 1
+---
+
+This guide shows you how to use recursive proofs in your NoirJS app. For the sake of clarity, it is assumed that:
+
+- You already have a NoirJS app. If you don't, please visit the [NoirJS tutorial](../tutorials/noirjs_app.md) and the [reference](../reference/NoirJS/noir_js/index.md).
+- You are familiar with what are recursive proofs and you have read the [recursion explainer](../explainers/explainer-recursion.md)
+- You already built a recursive circuit following [the reference](../noir/standard_library/recursion.mdx), and understand how it works.
+
+It is also assumed that you're not using `noir_wasm` for compilation, and instead you've used [`nargo compile`](../reference/nargo_commands.md) to generate the `json` you're now importing into your project. However, the guide should work just the same if you're using `noir_wasm`.
+
+:::info
+
+As you've read in the [explainer](../explainers/explainer-recursion.md), a recursive proof is an intermediate proof. This means that it doesn't necessarily generate the final step that makes it verifiable in a smart contract. However, it is easy to verify within another circuit.
+
+:::
+
+In a standard recursive app, you're also dealing with at least two circuits. For the purpose of this guide, we will assume the following:
+
+- `main`: a circuit of type `assert(x != y)`, where `main` is marked with a `#[recursive]` attribute. This attribute states that the backend should generate proofs that are friendly for verification within another circuit.
+- `recursive`: a circuit that verifies `main`
+
+For a full example of how recursive proofs work, please refer to the [noir-examples](https://github.com/noir-lang/noir-examples) repository. We will *not* be using it as a reference for this guide.
+
+## Step 1: Setup
+
+In a common NoirJS app, you need to instantiate a backend with something like `const backend = new Backend(circuit)`. Then you feed it to the `noir_js` interface.
+
+For recursion, this doesn't happen, and the only need for `noir_js` is only to `execute` a circuit and get its witness and return value. Everything else is not interfaced, so it needs to happen on the `backend` object.
+
+It is also recommended that you instantiate the backend with as many threads as possible, to allow for maximum concurrency:
+
+```js
+const backend = new Backend(circuit, { threads: 8 })
+```
+
+:::tip
+You can use the [`os.cpus()`](https://nodejs.org/api/os.html#oscpus) object in `nodejs` or [`navigator.hardwareConcurrency`](https://developer.mozilla.org/en-US/docs/Web/API/Navigator/hardwareConcurrency) on the browser to make the most out of those glorious cpu cores
+:::
+
+## Step 2: Generating the witness and the proof for `main`
+
+After instantiating the backend, you should also instantiate `noir_js`. We will use it to execute the circuit and get the witness.
+
+```js
+const noir = new Noir(circuit)
+const { witness } = noir.execute(input)
+```
+
+With this witness, you are now able to generate the intermediate proof for the main circuit:
+
+```js
+const { proof, publicInputs } = await backend.generateProof(witness)
+```
+
+:::warning
+
+Always keep in mind what is actually happening on your development process, otherwise you'll quickly become confused about what circuit we are actually running and why!
+
+In this case, you can imagine that Alice (running the `main` circuit) is proving something to Bob (running the `recursive` circuit), and Bob is verifying her proof within his proof.
+
+With this in mind, it becomes clear that our intermediate proof is the one *meant to be verified within another circuit*, so it must be Alice's. Actually, the only final proof in this theoretical scenario would be the last one, sent on-chain.
+
+:::
+
+## Step 3 - Verification and proof artifacts
+
+Optionally, you are able to verify the intermediate proof:
+
+```js
+const verified = await backend.verifyProof({ proof, publicInputs })
+```
+
+This can be useful to make sure our intermediate proof was correctly generated. But the real goal is to do it within another circuit. For that, we need to generate  recursive proof artifacts that will be passed to the circuit that is verifying the proof we just generated. Instead of passing the proof and verification key as a byte array, we pass them as fields which makes it cheaper to verify in a circuit:
+
+```js
+const { proofAsFields, vkAsFields, vkHash } = await backend.generateRecursiveProofArtifacts( { publicInputs, proof }, publicInputsCount)
+```
+
+This call takes the public inputs and the proof, but also the public inputs count. While this is easily retrievable by simply counting the `publicInputs` length, the backend interface doesn't currently abstract it away.
+
+:::info
+
+The `proofAsFields` has a constant size `[Field; 93]` and verification keys in Barretenberg are always `[Field; 114]`.
+
+:::
+
+:::warning
+
+One common mistake is to forget *who* makes this call.
+
+In a situation where Alice is generating the `main` proof, if she generates the proof artifacts and sends them to Bob, which gladly takes them as true, this would mean Alice could prove anything!
+
+Instead, Bob needs to make sure *he* extracts the proof artifacts, using his own instance of the `main` circuit backend. This way, Alice has to provide a valid proof for the correct `main` circuit.
+
+:::
+
+## Step 4 - Recursive proof generation
+
+With the artifacts, generating a recursive proof is no different from a normal proof. You simply use the `backend` (with the recursive circuit) to generate it:
+
+```js
+const recursiveInputs = {
+    verification_key: vkAsFields, // array of length 114
+    proof: proofAsFields, // array of length 93 + size of public inputs
+    publicInputs: [mainInput.y], // using the example above, where `y` is the only public input
+    key_hash: vkHash,
+}
+
+const { witness, returnValue } = noir.execute(recursiveInputs) // we're executing the recursive circuit now!
+const { proof, publicInputs } = backend.generateProof(witness)
+const verified = backend.verifyProof({ proof, publicInputs })
+```
+
+You can obviously chain this proof into another proof. In fact, if you're using recursive proofs, you're probably interested of using them this way!
+
+:::tip
+
+Managing circuits and "who does what" can be confusing. To make sure your naming is consistent, you can keep them in an object. For example:
+
+```js
+const circuits = {
+  main: mainJSON,
+  recursive: recursiveJSON
+}
+const backends = {
+  main: new BarretenbergBackend(circuits.main),
+  recursive: new BarretenbergBackend(circuits.recursive)
+}
+const noir_programs = {
+  main: new Noir(circuits.main),
+  recursive: new Noir(circuits.recursive)
+}
+```
+
+This allows you to neatly call exactly the method you want without conflicting names:
+
+```js
+// Alice runs this 👇
+const { witness: mainWitness } = await noir_programs.main.execute(input)
+const proof = await backends.main.generateProof(mainWitness)
+
+// Bob runs this 👇
+const verified = await backends.main.verifyProof(proof)
+const { proofAsFields, vkAsFields, vkHash } = await backends.main.generateRecursiveProofArtifacts(
+    proof,
+    numPublicInputs,
+);
+const { witness: recursiveWitness } = await noir_programs.recursive.execute(recursiveInputs)
+const recursiveProof = await backends.recursive.generateProof(recursiveWitness);
+```
+
+:::
diff --git a/docs/versioned_docs/version-v0.37.0/how_to/how-to-solidity-verifier.md b/docs/versioned_docs/version-v0.37.0/how_to/how-to-solidity-verifier.md
new file mode 100644
index 00000000000..2cc0f8e57ce
--- /dev/null
+++ b/docs/versioned_docs/version-v0.37.0/how_to/how-to-solidity-verifier.md
@@ -0,0 +1,259 @@
+---
+title: Generate a Solidity Verifier
+description:
+  Learn how to run the verifier as a smart contract on the blockchain. Compile a Solidity verifier
+  contract for your Noir program and deploy it on any EVM blockchain acting as a verifier smart
+  contract. Read more to find out
+keywords:
+  [
+    solidity verifier,
+    smart contract,
+    blockchain,
+    compiler,
+    plonk_vk.sol,
+    EVM blockchain,
+    verifying Noir programs,
+    proving backend,
+    Barretenberg,
+  ]
+sidebar_position: 0
+pagination_next: tutorials/noirjs_app
+---
+
+Noir has the ability to generate a verifier contract in Solidity, which can be deployed in many EVM-compatible blockchains such as Ethereum.
+
+This allows for a powerful feature set, as one can make use of the conciseness and the privacy provided by Noir in an immutable ledger. Applications can range from simple P2P guessing games, to complex private DeFi interactions.
+
+This guide shows you how to generate a Solidity Verifier and deploy it on the [Remix IDE](https://remix.ethereum.org/). It is assumed that:
+
+- You are comfortable with the Solidity programming language and understand how contracts are deployed on the Ethereum network
+- You have Noir installed and you have a Noir program. If you don't, [get started](../getting_started/quick_start.md) with Nargo and the example Hello Noir circuit
+- You are comfortable navigating RemixIDE. If you aren't or you need a refresher, you can find some video tutorials [here](https://www.youtube.com/channel/UCjTUPyFEr2xDGN6Cg8nKDaA) that could help you.
+
+## Rundown
+
+Generating a Solidity Verifier contract is actually a one-command process. However, compiling it and deploying it can have some caveats. Here's the rundown of this guide:
+
+1. How to generate a solidity smart contract
+2. How to compile the smart contract in the RemixIDE
+3. How to deploy it to a testnet
+
+## Step 1 - Generate a contract
+
+This is by far the most straightforward step. Just run:
+
+```sh
+nargo compile
+```
+
+This will compile your source code into a Noir build artifact to be stored in the `./target` directory, you can then generate the smart contract using the commands:
+
+```sh
+# Here we pass the path to the newly generated Noir artifact.
+bb write_vk -b ./target/<noir_artifact_name>.json
+bb contract
+```
+
+replacing `<noir_artifact_name>` with the name of your Noir project. A new `contract` folder would then be generated in your project directory, containing the Solidity
+file `contract.sol`. It can be deployed to any EVM blockchain acting as a verifier smart contract.
+
+You can find more information about `bb` and the default Noir proving backend on [this page](../getting_started/quick_start.md#proving-backend).
+
+:::info
+
+It is possible to generate verifier contracts of Noir programs for other smart contract platforms as long as the proving backend supplies an implementation.
+
+Barretenberg, the default proving backend for Nargo, supports generation of verifier contracts, for the time being these are only in Solidity.
+:::
+
+## Step 2 - Compiling
+
+We will mostly skip the details of RemixIDE, as the UI can change from version to version. For now, we can just open
+<a href="https://remix.ethereum.org" target="_blank">Remix</a> and create a blank workspace.
+
+![Create Workspace](@site/static/img/how-tos/solidity_verifier_1.png)
+
+We will create a new file to contain the contract Nargo generated, and copy-paste its content.
+
+:::warning
+
+You'll likely see a warning advising you to not trust pasted code. While it is an important warning, it is irrelevant in the context of this guide and can be ignored. We will not be deploying anywhere near a mainnet.
+
+:::
+
+To compile our the verifier, we can navigate to the compilation tab:
+
+![Compilation Tab](@site/static/img/how-tos/solidity_verifier_2.png)
+
+Remix should automatically match a suitable compiler version. However, hitting the "Compile" button will most likely generate a "Stack too deep" error:
+
+![Stack too deep](@site/static/img/how-tos/solidity_verifier_3.png)
+
+This is due to the verify function needing to put many variables on the stack, but enabling the optimizer resolves the issue. To do this, let's open the "Advanced Configurations" tab and enable optimization. The default 200 runs will suffice.
+
+:::info
+
+This time we will see a warning about an unused function parameter. This is expected, as the `verify` function doesn't use the `_proof` parameter inside a solidity block, it is loaded from calldata and used in assembly.
+
+:::
+
+![Compilation success](@site/static/img/how-tos/solidity_verifier_4.png)
+
+## Step 3 - Deploying
+
+At this point we should have a compiled contract ready to deploy. If we navigate to the deploy section in Remix, we will see many different environments we can deploy to. The steps to deploy on each environment would be out-of-scope for this guide, so we will just use the default Remix VM.
+
+Looking closely, we will notice that our "Solidity Verifier" is actually three contracts working together:
+
+- An `UltraVerificationKey` library which simply stores the verification key for our circuit.
+- An abstract contract `BaseUltraVerifier` containing most of the verifying logic.
+- A main `UltraVerifier` contract that inherits from the Base and uses the Key contract.
+
+Remix will take care of the dependencies for us so we can simply deploy the UltraVerifier contract by selecting it and hitting "deploy":
+
+![Deploying UltraVerifier](@site/static/img/how-tos/solidity_verifier_5.png)
+
+A contract will show up in the "Deployed Contracts" section, where we can retrieve the Verification Key Hash. This is particularly useful for double-checking that the deployer contract is the correct one.
+
+:::note
+
+Why "UltraVerifier"?
+
+To be precise, the Noir compiler (`nargo`) doesn't generate the verifier contract directly. It compiles the Noir code into an intermediate language (ACIR), which is then executed by the backend. So it is the backend that returns the verifier smart contract, not Noir.
+
+In this case, the Barretenberg Backend uses the UltraPlonk proving system, hence the "UltraVerifier" name.
+
+:::
+
+## Step 4 - Verifying
+
+To verify a proof using the Solidity verifier contract, we call the `verify` function in this extended contract:
+
+```solidity
+function verify(bytes calldata _proof, bytes32[] calldata _publicInputs) external view returns (bool)
+```
+
+When using the default example in the [Hello Noir](../getting_started/quick_start.md) guide, the easiest way to confirm that the verifier contract is doing its job is by calling the `verify` function via remix with the required parameters. Note that the public inputs must be passed in separately to the rest of the proof so we must split the proof as returned from `bb`.
+
+First generate a proof with `bb` at the location `./proof` using the steps in [get started](../getting_started/quick_start.md), this proof is in a binary format but we want to convert it into a hex string to pass into Remix, this can be done with the
+
+```bash
+# This value must be changed to match the number of public inputs (including return values!) in your program.
+NUM_PUBLIC_INPUTS=1
+PUBLIC_INPUT_BYTES=32*NUM_PUBLIC_INPUTS
+HEX_PUBLIC_INPUTS=$(head -c $PUBLIC_INPUT_BYTES ./proof | od -An -v -t x1 | tr -d $' \n')
+HEX_PROOF=$(tail -c +$(($PUBLIC_INPUT_BYTES + 1)) ./proof | od -An -v -t x1 | tr -d $' \n')
+
+echo "Public inputs:"
+echo $HEX_PUBLIC_INPUTS
+
+echo "Proof:"
+echo "0x$HEX_PROOF"
+```
+
+Remix expects that the public inputs will be split into an array of `bytes32` values so `HEX_PUBLIC_INPUTS` needs to be split up into 32 byte chunks which are prefixed with `0x` accordingly.
+
+A programmatic example of how the `verify` function is called can be seen in the example zk voting application [here](https://github.com/noir-lang/noir-examples/blob/33e598c257e2402ea3a6b68dd4c5ad492bce1b0a/foundry-voting/src/zkVote.sol#L35):
+
+```solidity
+function castVote(bytes calldata proof, uint proposalId, uint vote, bytes32 nullifierHash) public returns (bool) {
+  // ...
+  bytes32[] memory publicInputs = new bytes32[](4);
+  publicInputs[0] = merkleRoot;
+  publicInputs[1] = bytes32(proposalId);
+  publicInputs[2] = bytes32(vote);
+  publicInputs[3] = nullifierHash;
+  require(verifier.verify(proof, publicInputs), "Invalid proof");
+```
+
+:::info[Return Values]
+
+A circuit doesn't have the concept of a return value. Return values are just syntactic sugar in Noir.
+
+Under the hood, the return value is passed as an input to the circuit and is checked at the end of the circuit program.
+
+For example, if you have Noir program like this:
+
+```rust
+fn main(
+    // Public inputs
+    pubkey_x: pub Field,
+    pubkey_y: pub Field,
+    // Private inputs
+    priv_key: Field,
+) -> pub Field
+```
+
+the `verify` function will expect the public inputs array (second function parameter) to be of length 3, the two inputs and the return value.
+
+Passing only two inputs will result in an error such as `PUBLIC_INPUT_COUNT_INVALID(3, 2)`.
+
+In this case, the inputs parameter to `verify` would be an array ordered as `[pubkey_x, pubkey_y, return`.
+
+:::
+
+:::tip[Structs]
+
+You can pass structs to the verifier contract. They will be flattened so that the array of inputs is 1-dimensional array.
+
+For example, consider the following program:
+
+```rust
+struct Type1 {
+  val1: Field,
+  val2: Field,
+}
+
+struct Nested {
+  t1: Type1,
+  is_true: bool,
+}
+
+fn main(x: pub Field, nested: pub Nested, y: pub Field) {
+  //...
+}
+```
+
+The order of these inputs would be flattened to: `[x, nested.t1.val1, nested.t1.val2, nested.is_true, y]`
+
+:::
+
+The other function you can call is our entrypoint `verify` function, as defined above.
+
+:::tip
+
+It's worth noticing that the `verify` function is actually a `view` function. A `view` function does not alter the blockchain state, so it doesn't need to be distributed (i.e. it will run only on the executing node), and therefore doesn't cost any gas.
+
+This can be particularly useful in some situations. If Alice generated a proof and wants Bob to verify its correctness, Bob doesn't need to run Nargo, NoirJS, or any Noir specific infrastructure. He can simply make a call to the blockchain with the proof and verify it is correct without paying any gas.
+
+It would be incorrect to say that a Noir proof verification costs any gas at all. However, most of the time the result of `verify` is used to modify state (for example, to update a balance, a game state, etc). In that case the whole network needs to execute it, which does incur gas costs (calldata and execution, but not storage).
+
+:::
+
+## A Note on EVM chains
+
+Noir proof verification requires the ecMul, ecAdd and ecPairing precompiles. Not all EVM chains support EC Pairings, notably some of the ZK-EVMs. This means that you won't be able to use the verifier contract in all of them. You can find an incomplete list of which EVM chains support these precompiles [here](https://www.evmdiff.com/features?feature=precompiles).
+
+For example, chains like `zkSync ERA` and `Polygon zkEVM` do not currently support these precompiles, so proof verification via Solidity verifier contracts won't work. Here's a quick list of EVM chains that have been tested and are known to work:
+
+- Optimism
+- Arbitrum
+- Polygon PoS
+- Scroll
+- Celo
+- BSC
+- Blast L2
+- Avalanche C-Chain
+- Mode
+- Linea
+- Moonbeam
+
+If you test any other chains, please open a PR on this page to update the list. See [this doc](https://github.com/noir-lang/noir-starter/tree/main/with-foundry#testing-on-chain) for more info about testing verifier contracts on different EVM chains.
+
+## What's next
+
+Now that you know how to call a Noir Solidity Verifier on a smart contract using Remix, you should be comfortable with using it with some programmatic frameworks, such as [hardhat](https://github.com/noir-lang/noir-starter/tree/main/vite-hardhat) and [foundry](https://github.com/noir-lang/noir-starter/tree/main/with-foundry).
+
+You can find other tools, examples, boilerplates and libraries in the [awesome-noir](https://github.com/noir-lang/awesome-noir) repository.
+
+You should also be ready to write and deploy your first NoirJS app and start generating proofs on websites, phones, and NodeJS environments! Head on to the [NoirJS tutorial](../tutorials/noirjs_app.md) to learn how to do that.
diff --git a/docs/versioned_docs/version-v0.37.0/how_to/merkle-proof.mdx b/docs/versioned_docs/version-v0.37.0/how_to/merkle-proof.mdx
new file mode 100644
index 00000000000..0a128adb2de
--- /dev/null
+++ b/docs/versioned_docs/version-v0.37.0/how_to/merkle-proof.mdx
@@ -0,0 +1,48 @@
+---
+title: Prove Merkle Tree Membership
+description:
+  Learn how to use merkle membership proof in Noir to prove that a given leaf is a member of a
+  merkle tree with a specified root, at a given index.
+keywords:
+  [merkle proof, merkle membership proof, Noir, rust, hash function, Pedersen, sha256, merkle tree]
+sidebar_position: 4
+---
+
+Let's walk through an example of a merkle membership proof in Noir that proves that a given leaf is
+in a merkle tree.
+
+```rust
+
+fn main(message : [Field; 62], index : Field, hashpath : [Field; 40], root : Field) {
+    let leaf = std::hash::hash_to_field(message.as_slice());
+    let merkle_root = std::merkle::compute_merkle_root(leaf, index, hashpath);
+    assert(merkle_root == root);
+}
+
+```
+
+The message is hashed using `hash_to_field`. The specific hash function that is being used is chosen
+by the backend. The only requirement is that this hash function can heuristically be used as a
+random oracle. If only collision resistance is needed, then one can call `std::hash::pedersen_hash`
+instead.
+
+```rust
+let leaf = std::hash::hash_to_field(message.as_slice());
+```
+
+The leaf is then passed to a compute_merkle_root function with the root, index and hashpath. The returned root can then be asserted to be the same as the provided root.
+
+```rust
+let merkle_root = std::merkle::compute_merkle_root(leaf, index, hashpath);
+assert (merkle_root == root);
+```
+
+> **Note:** It is possible to re-implement the merkle tree implementation without standard library.
+> However, for most usecases, it is enough. In general, the standard library will always opt to be
+> as conservative as possible, while striking a balance with efficiency.
+
+An example, the merkle membership proof, only requires a hash function that has collision
+resistance, hence a hash function like Pedersen is allowed, which in most cases is more efficient
+than the even more conservative sha256.
+
+[View an example on the starter repo](https://github.com/noir-lang/noir-examples/blob/3ea09545cabfa464124ec2f3ea8e60c608abe6df/stealthdrop/circuits/src/main.nr#L20)
diff --git a/docs/versioned_docs/version-v0.37.0/how_to/using-devcontainers.mdx b/docs/versioned_docs/version-v0.37.0/how_to/using-devcontainers.mdx
new file mode 100644
index 00000000000..727ec6ca667
--- /dev/null
+++ b/docs/versioned_docs/version-v0.37.0/how_to/using-devcontainers.mdx
@@ -0,0 +1,110 @@
+---
+title: Developer Containers and Codespaces
+description: "Learn how to set up a devcontainer in your GitHub repository for a seamless coding experience with Codespaces. Follow our easy 8-step guide to create your own Noir environment without installing Nargo locally."
+keywords: ["Devcontainer", "Codespaces", "GitHub", "Noir Environment", "Docker Image", "Development Environment", "Remote Coding", "GitHub Codespaces", "Noir Programming", "Nargo", "VSCode Extensions", "Noirup"]
+sidebar_position: 1
+---
+
+Adding a developer container configuration file to your Noir project is one of the easiest way to unlock coding in browser.
+
+## What's a devcontainer after all?
+
+A [Developer Container](https://containers.dev/) (devcontainer for short) is a Docker image that comes preloaded with tools, extensions, and other tools you need to quickly get started or continue a project, without having to install Nargo locally. Think of it as a development environment in a box.
+
+There are many advantages to this:
+
+- It's platform and architecture agnostic
+- You don't need to have an IDE installed, or Nargo, or use a terminal at all
+- It's safer for using on a public machine or public network
+
+One of the best ways of using devcontainers is... not using your machine at all, for maximum control, performance, and ease of use.
+Enter Codespaces.
+
+## Codespaces
+
+If a devcontainer is just a Docker image, then what stops you from provisioning a `p3dn.24xlarge` AWS EC2 instance with 92 vCPUs and 768 GiB RAM and using it to prove your 10-gate SNARK proof? 
+
+Nothing! Except perhaps the 30-40$ per hour it will cost you. 
+
+The problem is that provisioning takes time, and I bet you don't want to see the AWS console every time you want to code something real quick.
+
+Fortunately, there's an easy and free way to get a decent remote machine ready and loaded in less than 2 minutes: Codespaces. [Codespaces is a Github feature](https://github.com/features/codespaces) that allows you to code in a remote machine by using devcontainers, and it's pretty cool:
+
+- You can start coding Noir in less than a minute
+- It uses the resources of a remote machine, so you can code on your grandma's phone if needed be
+- It makes it easy to share work with your frens
+- It's fully reusable, you can stop and restart whenever you need to
+
+:::info
+
+Don't take out your wallet just yet. Free GitHub accounts get about [15-60 hours of coding](https://github.com/features/codespaces) for free per month, depending on the size of your provisioned machine.
+
+:::
+
+## Tell me it's _actually_ easy
+
+It is!
+
+Github comes with a default codespace and you can use it to code your own devcontainer. That's exactly what we will be doing in this guide.
+
+<video width="100%" height="auto" controls>
+  <source src={require('@site/static/video/how-tos/devcontainer.mp4').default} type="video/mp4" />
+  Your browser does not support the video tag.
+</video>
+
+8 simple steps:
+
+#### 1. <a href="https://github.com/new" target="_blank">Create a new repository</a> on GitHub.
+
+#### 2. Click "Start coding with Codespaces". This will use the default image.
+
+#### 3. Create a folder called `.devcontainer` in the root of your repository.
+
+#### 4. Create a Dockerfile in that folder, and paste the following code:
+
+```docker
+FROM --platform=linux/amd64 node:lts-bookworm-slim
+SHELL ["/bin/bash", "-c"]
+RUN apt update && apt install -y curl bash git tar gzip libc++-dev
+RUN curl -L https://raw.githubusercontent.com/noir-lang/noirup/main/install | bash
+ENV PATH="/root/.nargo/bin:$PATH"
+RUN noirup
+ENTRYPOINT ["nargo"]
+```
+#### 5. Create a file called `devcontainer.json` in the same folder, and paste the following code:
+
+```json
+{
+ "name": "Noir on Codespaces",
+ "build": {
+    "context": ".",
+    "dockerfile": "Dockerfile"
+  },
+  "customizations": {
+    "vscode": {
+      "extensions": ["noir-lang.vscode-noir"]
+    }
+  }
+}
+```
+#### 6. Commit and push your changes
+
+This will pull the new image and build it, so it could take a minute or so
+
+#### 8. Done! 
+Just wait for the build to finish, and there's your easy Noir environment.
+
+
+Refer to [noir-starter](https://github.com/noir-lang/noir-starter/) as an example of how devcontainers can be used together with codespaces.
+
+
+
+## How do I use it?
+
+Using the codespace is obviously much easier than setting it up. 
+Just navigate to your repository and click "Code" -> "Open with Codespaces". It should take a few seconds to load, and you're ready to go.
+
+:::info
+
+If you really like the experience, you can add a badge to your readme, links to existing codespaces, and more. 
+Check out the [official docs](https://docs.github.com/en/codespaces/setting-up-your-project-for-codespaces/setting-up-your-repository/facilitating-quick-creation-and-resumption-of-codespaces) for more info.
diff --git a/docs/versioned_docs/version-v0.37.0/index.mdx b/docs/versioned_docs/version-v0.37.0/index.mdx
new file mode 100644
index 00000000000..5c116a73b3f
--- /dev/null
+++ b/docs/versioned_docs/version-v0.37.0/index.mdx
@@ -0,0 +1,76 @@
+---
+title: Noir Lang
+hide_title: true
+description:
+  Learn about the public alpha release of Noir, a domain specific language heavily influenced by Rust that compiles to
+  an intermediate language which can be compiled to an arithmetic circuit or a rank-1 constraint system.
+keywords:
+    [Noir,
+    Domain Specific Language,
+    Rust,
+    Intermediate Language,
+    Arithmetic Circuit,
+    Rank-1 Constraint System,
+    Ethereum Developers,
+    Protocol Developers,
+    Blockchain Developers,
+    Proving System,
+    Smart Contract Language]
+sidebar_position: 0
+---
+
+import Tabs from '@theme/Tabs';
+import TabItem from '@theme/TabItem';
+import ThemedImage from '@theme/ThemedImage';
+import useBaseUrl from '@docusaurus/useBaseUrl';
+
+<ThemedImage
+  sources={{
+    light: useBaseUrl("/img/logoDark.png"),
+    dark: useBaseUrl("/img/logo.png"),
+  }}
+  style={{display: "block", width: "50%", margin: "2rem auto"}} 
+  alt="Noir Logo" 
+/>
+
+Noir is an open-source Domain-Specific Language for safe and seamless construction of privacy-preserving Zero-Knowledge programs, requiring no previous knowledge on the underlying mathematics or cryptography.
+
+ZK programs are programs that can generate short proofs of statements without revealing all inputs to the statements. You can read more about Zero-Knowledge Proofs [here](https://dev.to/spalladino/a-beginners-intro-to-coding-zero-knowledge-proofs-c56).
+
+## What's new about Noir?
+
+Noir works differently from most ZK languages by taking a two-pronged path. First, it compiles the program to an adaptable intermediate language known as ACIR. From there, depending on a given project's needs, ACIR can be further compiled into an arithmetic circuit for integration with the proving backend.
+
+:::info
+
+Noir is backend agnostic, which means it makes no assumptions on which proving backend powers the ZK proof. Being the language that powers [Aztec Contracts](https://docs.aztec.network/developers/contracts/main), it defaults to Aztec's Barretenberg proving backend.
+
+However, the ACIR output can be transformed to be compatible with other PLONK-based backends, or into a [rank-1 constraint system](https://www.rareskills.io/post/rank-1-constraint-system) suitable for backends such as Arkwork's Marlin.
+
+:::
+
+## Who is Noir for?
+
+Noir can be used both in complex cloud-based backends and in user's smartphones, requiring no knowledge on the underlying math or cryptography. From authorization systems that keep a password in the user's device, to complex on-chain verification of recursive proofs, Noir is designed to abstract away complexity without any significant overhead. Here are some examples of situations where Noir can be used:
+
+<Tabs>
+  <TabItem value="Aztec Contracts" label="Aztec Contracts" default>
+    <img src={require("@site/static/img/aztec_logo.png").default} style={{display: "block", width: "50%", margin: "2rem auto"}} alt="Noir Logo"  />
+    
+    Aztec Contracts leverage Noir to allow for the storage and execution of private information. Writing an Aztec Contract is as easy as writing Noir, and Aztec developers can easily interact with the network storage and execution through the [Aztec.nr](https://docs.aztec.network/developers/contracts/main) library.
+  </TabItem>
+  <TabItem value="Solidity Verifiers" label="Solidity Verifiers">
+    <img src={require("@site/static/img/solidity_verifier_ex.png").default} style={{display: "block", margin: "2rem auto"}} alt="Soliditry Verifier Example"  />
+    Noir can auto-generate Solidity verifier contracts that verify Noir proofs. This allows for non-interactive verification of proofs containing private information in an immutable system. This feature powers a multitude of use-case scenarios, from P2P chess tournaments, to [Aztec Layer-2 Blockchain](https://docs.aztec.network/)
+  </TabItem>
+  <TabItem value="Full-Stack Development" label="Full-Stack Development">
+    Aztec Labs developed NoirJS, an easy interface to generate and verify Noir proofs in a Javascript environment. This allows for Noir to be used in webpages, mobile apps, games, and any other environment supporting JS execution in a standalone manner.
+  </TabItem>
+</Tabs>
+
+
+## Libraries
+
+Noir is meant to be easy to extend by simply importing Noir libraries just like in Rust. 
+The [awesome-noir repo](https://github.com/noir-lang/awesome-noir#libraries) is a collection of libraries developed by the Noir community.
+Writing a new library is easy and makes code be composable and easy to reuse. See the section on [dependencies](noir/modules_packages_crates/dependencies.md) for more information.
diff --git a/docs/versioned_docs/version-v0.37.0/migration_notes.md b/docs/versioned_docs/version-v0.37.0/migration_notes.md
new file mode 100644
index 00000000000..6bd740024e5
--- /dev/null
+++ b/docs/versioned_docs/version-v0.37.0/migration_notes.md
@@ -0,0 +1,105 @@
+---
+title: Migration notes
+description: Read about migration notes from previous versions, which could solve problems while updating
+keywords: [Noir, notes, migration, updating, upgrading]
+---
+
+Noir is in full-speed development. Things break fast, wild, and often. This page attempts to leave some notes on errors you might encounter when upgrading and how to resolve them until proper patches are built.
+
+### `backend encountered an error: libc++.so.1`
+
+Depending on your OS, you may encounter the following error when running `nargo prove` for the first time:
+
+```text
+The backend encountered an error: "/home/codespace/.nargo/backends/acvm-backend-barretenberg/backend_binary: error while loading shared libraries: libc++.so.1: cannot open shared object file: No such file or directory\n"
+```
+
+Install the `libc++-dev` library with:
+
+```bash
+sudo apt install libc++-dev
+```
+
+## ≥0.19
+
+### Enforcing `compiler_version`
+
+From this version on, the compiler will check for the `compiler_version` field in `Nargo.toml`, and will error if it doesn't match the current Nargo version in use.
+
+To update, please make sure this field in `Nargo.toml` matches the output of `nargo --version`.
+
+## ≥0.14
+
+The index of the [for loops](noir/concepts/control_flow.md#loops) is now of type `u64` instead of `Field`. An example refactor would be:
+
+```rust
+for i in 0..10 {
+    let i = i as Field;
+}
+```
+
+## ≥v0.11.0 and Nargo backend
+
+From this version onwards, Nargo starts managing backends through the `nargo backend` command. Upgrading to the versions per usual steps might lead to:
+
+### `backend encountered an error`
+
+This is likely due to the existing locally installed version of proving backend (e.g. barretenberg) is incompatible with the version of Nargo in use.
+
+To fix the issue:
+
+1. Uninstall the existing backend
+
+```bash
+nargo backend uninstall acvm-backend-barretenberg
+```
+
+You may replace _acvm-backend-barretenberg_ with the name of your backend listed in `nargo backend ls` or in ~/.nargo/backends.
+
+2. Reinstall a compatible version of the proving backend.
+
+If you are using the default barretenberg backend, simply run:
+
+```
+nargo prove
+```
+
+with your Noir program.
+
+This will trigger the download and installation of the latest version of barretenberg compatible with your Nargo in use.
+
+### `backend encountered an error: illegal instruction`
+
+On certain Intel-based systems, an `illegal instruction` error may arise due to incompatibility of barretenberg with certain CPU instructions.
+
+To fix the issue:
+
+1. Uninstall the existing backend
+
+```bash
+nargo backend uninstall acvm-backend-barretenberg
+```
+
+You may replace _acvm-backend-barretenberg_ with the name of your backend listed in `nargo backend ls` or in ~/.nargo/backends.
+
+2. Reinstall a compatible version of the proving backend.
+
+If you are using the default barretenberg backend, simply run:
+
+```
+nargo backend install acvm-backend-barretenberg https://github.com/noir-lang/barretenberg-js-binary/raw/master/run-bb.tar.gz
+```
+
+This downloads and installs a specific bb.js based version of barretenberg binary from GitHub.
+
+The gzipped file is running [this bash script](https://github.com/noir-lang/barretenberg-js-binary/blob/master/run-bb-js.sh), where we need to gzip it as the Nargo currently expect the backend to be zipped up.
+
+Then run:
+
+```
+DESIRED_BINARY_VERSION=0.8.1 nargo info
+```
+
+This overrides the bb native binary with a bb.js node application instead, which should be compatible with most if not all hardware. This does come with the drawback of being generally slower than native binary.
+
+0.8.1 indicates bb.js version 0.8.1, so if you change that it will update to a different version or the default version in the script if none was supplied.
diff --git a/docs/versioned_docs/version-v0.37.0/noir/concepts/_category_.json b/docs/versioned_docs/version-v0.37.0/noir/concepts/_category_.json
new file mode 100644
index 00000000000..7da08f8a8c5
--- /dev/null
+++ b/docs/versioned_docs/version-v0.37.0/noir/concepts/_category_.json
@@ -0,0 +1,6 @@
+{
+    "label": "Concepts",
+    "position": 0,
+    "collapsible": true,
+    "collapsed": true
+}
\ No newline at end of file
diff --git a/docs/versioned_docs/version-v0.37.0/noir/concepts/assert.md b/docs/versioned_docs/version-v0.37.0/noir/concepts/assert.md
new file mode 100644
index 00000000000..2132de42072
--- /dev/null
+++ b/docs/versioned_docs/version-v0.37.0/noir/concepts/assert.md
@@ -0,0 +1,78 @@
+---
+title: Assert Function
+description:
+  Learn about the `assert` and `static_assert` functions in Noir, which can be used to explicitly
+  constrain the predicate or comparison expression that follows to be true, and what happens if
+  the expression is false at runtime or compile-time, respectively.
+keywords: [Noir programming language, assert statement, predicate expression, comparison expression]
+sidebar_position: 4
+---
+
+Noir includes a special `assert` function which will explicitly constrain the predicate/comparison
+expression that follows to be true. If this expression is false at runtime, the program will fail to
+be proven. Example:
+
+```rust
+fn main(x : Field, y : Field) {
+    assert(x == y);
+}
+```
+
+> Assertions only work for predicate operations, such as `==`. If there's any ambiguity on the operation, the program will fail to compile. For example, it is unclear if `assert(x + y)` would check for `x + y == 0` or simply would return `true`.
+
+You can optionally provide a message to be logged when the assertion fails:
+
+```rust
+assert(x == y, "x and y are not equal");
+```
+
+Aside string literals, the optional message can be a format string or any other type supported as input for Noir's [print](../standard_library/logging.md) functions. This feature lets you incorporate runtime variables into your failed assertion logs:
+
+```rust
+assert(x == y, f"Expected x == y, but got {x} == {y}");
+```
+
+Using a variable as an assertion message directly:
+
+```rust
+struct myStruct {
+  myField: Field
+}
+
+let s = myStruct { myField: y };
+assert(s.myField == x, s);
+```
+
+There is also a special `static_assert` function that behaves like `assert`,
+but that runs at compile-time.
+
+```rust
+fn main(xs: [Field; 3]) {
+    let x = 2 + 2;
+    let y = 4;
+    static_assert(x == y, "expected 2 + 2 to equal 4");
+
+    // This passes since the length of `xs` is known at compile-time
+    static_assert(xs.len() == 3, "expected the input to have 3 elements");
+}
+```
+
+This function fails when passed a dynamic (run-time) argument:
+
+```rust
+fn main(x : Field, y : Field) {
+    // this fails because `x` is not known at compile-time
+    static_assert(x == 2, "expected x to be known at compile-time and equal to 2");
+
+    let mut example_slice = &[];
+    if y == 4 {
+        example_slice = example_slice.push_back(0);
+    }
+
+    // This fails because the length of `example_slice` is not known at
+    // compile-time
+    let error_message = "expected an empty slice, known at compile-time";
+    static_assert(example_slice.len() == 0, error_message);
+}
+```
+
diff --git a/docs/versioned_docs/version-v0.37.0/noir/concepts/comments.md b/docs/versioned_docs/version-v0.37.0/noir/concepts/comments.md
new file mode 100644
index 00000000000..b51a85f5c94
--- /dev/null
+++ b/docs/versioned_docs/version-v0.37.0/noir/concepts/comments.md
@@ -0,0 +1,33 @@
+---
+title: Comments
+description:
+  Learn how to write comments in Noir programming language. A comment is a line of code that is
+  ignored by the compiler, but it can be read by programmers. Single-line and multi-line comments
+  are supported in Noir.
+keywords: [Noir programming language, comments, single-line comments, multi-line comments]
+sidebar_position: 10
+---
+
+A comment is a line in your codebase which the compiler ignores, however it can be read by
+programmers.
+
+Here is a single line comment:
+
+```rust
+// This is a comment and is ignored
+```
+
+`//` is used to tell the compiler to ignore the rest of the line.
+
+Noir also supports multi-line block comments. Start a block comment with `/*` and end the block with `*/`.
+
+Noir does not natively support doc comments. You may be able to use [Rust doc comments](https://doc.rust-lang.org/reference/comments.html) in your code to leverage some Rust documentation build tools with Noir code.
+
+```rust
+/*
+  This is a block comment describing a complex function.
+*/
+fn main(x : Field, y : pub Field) {
+    assert(x != y);
+}
+```
diff --git a/docs/versioned_docs/version-v0.37.0/noir/concepts/comptime.md b/docs/versioned_docs/version-v0.37.0/noir/concepts/comptime.md
new file mode 100644
index 00000000000..2ceb030c7e1
--- /dev/null
+++ b/docs/versioned_docs/version-v0.37.0/noir/concepts/comptime.md
@@ -0,0 +1,445 @@
+---
+title: Compile-time Code & Metaprogramming
+description: Learn how to use metaprogramming in Noir to create macros or derive your own traits
+keywords: [Noir, comptime, compile-time, metaprogramming, macros, quote, unquote]
+sidebar_position: 15
+---
+
+## Overview
+
+Metaprogramming in Noir is comprised of three parts:
+1. `comptime` code
+2. Quoting and unquoting
+3. The metaprogramming API in `std::meta`
+
+Each of these are explained in more detail in the next sections but the wide picture is that
+`comptime` allows us to write code which runs at compile-time. In this `comptime` code we
+can quote and unquote snippets of the program, manipulate them, and insert them in other
+parts of the program. Comptime functions which do this are said to be macros. Additionally,
+there's a compile-time API of built-in types and functions provided by the compiler which allows
+for greater analysis and modification of programs.
+
+---
+
+## Comptime
+
+`comptime` is a new keyword in Noir which marks an item as executing or existing at compile-time. It can be used in several ways:
+
+- `comptime fn` to define functions which execute exclusively during compile-time.
+- `comptime global` to define a global variable which is evaluated at compile-time.
+  - Unlike runtime globals, `comptime global`s can be mutable.
+- `comptime { ... }` to execute a block of statements during compile-time.
+- `comptime let` to define a variable whose value is evaluated at compile-time.
+- `comptime for` to run a for loop at compile-time. Syntax sugar for `comptime { for .. }`.
+
+### Scoping
+
+Note that while in a `comptime` context, any runtime variables _local to the current function_ are never visible.
+
+### Evaluating
+
+Evaluation rules of `comptime` follows the normal unconstrained evaluation rules for other Noir code. There are a few things to note though:
+
+- Certain built-in functions may not be available, although more may be added over time.
+- Evaluation order of global items is currently unspecified. For example, given the following two functions we can't guarantee
+which `println` will execute first. The ordering of the two printouts will be arbitrary, but should be stable across multiple compilations with the same `nargo` version as long as the program is also unchanged.
+
+```rust
+fn one() {
+    comptime { println("one"); }
+}
+
+fn two() {
+    comptime { println("two"); }
+}
+```
+
+- Since evaluation order is unspecified, care should be taken when using mutable globals so that they do not rely on a particular ordering.
+For example, using globals to generate unique ids should be fine but relying on certain ids always being produced (especially after edits to the program) should be avoided.
+- Although most ordering of globals is unspecified, two are:
+  - Dependencies of a crate will always be evaluated before the dependent crate.
+  - Any annotations on a function will be run before the function itself is resolved. This is to allow the annotation to modify the function if necessary. Note that if the
+    function itself was called at compile-time previously, it will already be resolved and cannot be modified. To prevent accidentally calling functions you wish to modify
+    at compile-time, it may be helpful to sort your `comptime` annotation functions into a different crate along with any dependencies they require.
+
+### Lowering
+
+When a `comptime` value is used in runtime code it must be lowered into a runtime value. This means replacing the expression with the literal that it evaluated to. For example, the code:
+
+```rust
+struct Foo { array: [Field; 2], len: u32 }
+
+fn main() {
+    println(comptime {
+        let mut foo = std::mem::zeroed::<Foo>();
+        foo.array[0] = 4;
+        foo.len = 1;
+        foo
+    });
+}
+```
+
+will be converted to the following after `comptime` expressions are evaluated:
+
+```rust
+struct Foo { array: [Field; 2], len: u32 }
+
+fn main() {
+    println(Foo { array: [4, 0], len: 1 });
+}
+```
+
+Not all types of values can be lowered. For example, `Type`s and `TypeDefinition`s (among other types) cannot be lowered at all.
+
+```rust
+fn main() {
+    // There's nothing we could inline here to create a Type value at runtime
+    // let _ = get_type!();
+}
+
+comptime fn get_type() -> Type { ... }
+```
+
+---
+
+## (Quasi) Quote
+
+Macros in Noir are `comptime` functions which return code as a value which is inserted into the call site when it is lowered there.
+A code value in this case is of type `Quoted` and can be created by a `quote { ... }` expression.
+More specifically, the code value `quote` creates is a token stream - a representation of source code as a series of words, numbers, string literals, or operators.
+For example, the expression `quote { Hi "there reader"! }` would quote three tokens: the word "hi", the string "there reader", and an exclamation mark.
+You'll note that snippets that would otherwise be invalid syntax can still be quoted.
+
+When a `Quoted` value is used in runtime code, it is lowered into a `quote { ... }` expression. Since this expression is only valid
+in compile-time code however, we'd get an error if we tried this. Instead, we can use macro insertion to insert each token into the
+program at that point, and parse it as an expression. To do this, we have to add a `!` after the function name returning the `Quoted` value.
+If the value was created locally and there is no function returning it, `std::meta::unquote!(_)` can be used instead.
+Calling such a function at compile-time without `!` will just return the `Quoted` value to be further manipulated. For example:
+
+```rust title="quote-example" showLineNumbers 
+comptime fn quote_one() -> Quoted {
+        quote { 1 }
+    }
+
+    #[test]
+    fn returning_versus_macro_insertion() {
+        comptime {
+            // let _a: Quoted = quote { 1 };
+            let _a: Quoted = quote_one();
+
+            // let _b: Field = 1;
+            let _b: Field = quote_one!();
+
+            // Since integers default to fields, if we
+            // want a different type we have to explicitly cast
+            // let _c: i32 = 1 as i32;
+            let _c: i32 = quote_one!() as i32;
+        }
+    }
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/meta/mod.nr#L120-L140" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/meta/mod.nr#L120-L140</a></sub></sup>
+
+
+For those familiar with quoting from other languages (primarily lisps), Noir's `quote` is actually a _quasiquote_.
+This means we can escape the quoting by using the unquote operator to splice values in the middle of quoted code.
+
+## Unquote
+
+The unquote operator `$` is usable within a `quote` expression.
+It takes a variable as an argument, evaluates the variable, and splices the resulting value into the quoted token stream at that point. For example,
+
+```rust
+comptime {
+    let x = 1 + 2;
+    let y = quote { $x + 4 };
+}
+```
+
+The value of `y` above will be the token stream containing `3`, `+`, and `4`. We can also use this to combine `Quoted` values into larger token streams:
+
+```rust
+comptime {
+    let x = quote { 1 + 2 };
+    let y = quote { $x + 4 };
+}
+```
+
+The value of `y` above is now the token stream containing five tokens: `1 + 2 + 4`.
+
+Note that to unquote something, a variable name _must_ follow the `$` operator in a token stream.
+If it is an expression (even a parenthesized one), it will do nothing. Most likely a parse error will be given when the macro is later unquoted.
+
+Unquoting can also be avoided by escaping the `$` with a backslash:
+
+```
+comptime {
+    let x = quote { 1 + 2 };
+
+    // y contains the four tokens: `$x + 4`
+    let y = quote { \$x + 4 };
+}
+```
+
+---
+
+## Annotations
+
+Annotations provide a way to run a `comptime` function on an item in the program.
+When you use an annotation, the function with the same name will be called with that item as an argument:
+
+```rust
+#[my_struct_annotation]
+struct Foo {}
+
+comptime fn my_struct_annotation(s: StructDefinition) {
+    println("Called my_struct_annotation!");
+}
+
+#[my_function_annotation]
+fn foo() {}
+
+comptime fn my_function_annotation(f: FunctionDefinition) {
+    println("Called my_function_annotation!");
+}
+```
+
+Anything returned from one of these functions will be inserted at top-level along with the original item.
+Note that expressions are not valid at top-level so you'll get an error trying to return `3` or similar just as if you tried to write a program containing `3; struct Foo {}`.
+You can insert other top-level items such as trait impls, structs, or functions this way though.
+For example, this is the mechanism used to insert additional trait implementations into the program when deriving a trait impl from a struct:
+
+```rust title="derive-field-count-example" showLineNumbers 
+trait FieldCount {
+        fn field_count() -> u32;
+    }
+
+    #[derive_field_count]
+    struct Bar {
+        x: Field,
+        y: [Field; 2],
+    }
+
+    comptime fn derive_field_count(s: StructDefinition) -> Quoted {
+        let typ = s.as_type();
+        let field_count = s.fields().len();
+        quote {
+            impl FieldCount for $typ {
+                fn field_count() -> u32 {
+                    $field_count
+                }
+            }
+        }
+    }
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/meta/mod.nr#L142-L164" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/meta/mod.nr#L142-L164</a></sub></sup>
+
+
+### Calling annotations with additional arguments
+
+Arguments may optionally be given to annotations.
+When this is done, these additional arguments are passed to the annotation function after the item argument.
+
+```rust title="annotation-arguments-example" showLineNumbers 
+#[assert_field_is_type(quote { i32 }.as_type())]
+    struct MyStruct {
+        my_field: i32,
+    }
+
+    comptime fn assert_field_is_type(s: StructDefinition, typ: Type) {
+        // Assert the first field in `s` has type `typ`
+        let fields = s.fields();
+        assert_eq(fields[0].1, typ);
+    }
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/meta/mod.nr#L166-L177" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/meta/mod.nr#L166-L177</a></sub></sup>
+
+
+We can also take any number of arguments by adding the `varargs` annotation:
+
+```rust title="annotation-varargs-example" showLineNumbers 
+#[assert_three_args(1, 2, 3)]
+    struct MyOtherStruct {
+        my_other_field: u32,
+    }
+
+    #[varargs]
+    comptime fn assert_three_args(_s: StructDefinition, args: [Field]) {
+        assert_eq(args.len(), 3);
+    }
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/meta/mod.nr#L179-L189" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/meta/mod.nr#L179-L189</a></sub></sup>
+
+
+---
+
+## Comptime API
+
+Although `comptime`, `quote`, and unquoting provide a flexible base for writing macros,
+Noir's true metaprogramming ability comes from being able to interact with the compiler through a compile-time API.
+This API can be accessed through built-in functions in `std::meta` as well as on methods of several `comptime` types.
+
+The following is an incomplete list of some `comptime` types along with some useful methods on them. You can see more in the standard library [Metaprogramming section](../standard_library/meta).
+
+- `Quoted`: A token stream
+- `Type`: The type of a Noir type
+  - `fn implements(self, constraint: TraitConstraint) -> bool`
+    - Returns true if `self` implements the given trait constraint
+- `Expr`: A syntactically valid expression. Can be used to recur on a program's parse tree to inspect how it is structured.
+  - Methods:
+    - `fn as_function_call(self) -> Option<(Expr, [Expr])>`
+      - If this is a function call expression, return `(function, arguments)`
+    - `fn as_block(self) -> Option<[Expr]>`
+      - If this is a block, return each statement in the block
+- `FunctionDefinition`: A function definition
+  - Methods:
+    - `fn parameters(self) -> [(Quoted, Type)]`
+      - Returns a slice of `(name, type)` pairs for each parameter
+- `StructDefinition`: A struct definition
+  - Methods:
+    - `fn as_type(self) -> Type`
+      - Returns this `StructDefinition` as a `Type`. Any generics are kept as-is
+    - `fn generics(self) -> [Quoted]`
+      - Return the name of each generic on this struct
+    - `fn fields(self) -> [(Quoted, Type)]`
+      - Return the name and type of each field
+- `TraitConstraint`: A trait constraint such as `From<Field>`
+- `TypedExpr`: A type-checked expression.
+- `UnresolvedType`: A syntactic notation that refers to a Noir type that hasn't been resolved yet
+
+There are many more functions available by exploring the `std::meta` module and its submodules.
+Using these methods is the key to writing powerful metaprogramming libraries.
+
+### `#[use_callers_scope]`
+
+Since certain functions such as `Quoted::as_type`, `Expression::as_type`, or `Quoted::as_trait_constraint` will attempt
+to resolve their contents in a particular scope - it can be useful to change the scope they resolve in. By default
+these functions will resolve in the current function's scope which is usually the attribute function they are called in.
+If you're working on a library however, this may be a completely different module or crate to the item you're trying to
+use the attribute on. If you want to be able to use `Quoted::as_type` to refer to types local to the caller's scope for
+example, you can annotate your attribute function with `#[use_callers_scope]`. This will ensure your attribute, and any
+closures it uses, can refer to anything in the caller's scope. `#[use_callers_scope]` also works recursively. So if both
+your attribute function and a helper function it calls use it, then they can both refer to the same original caller.
+
+---
+
+## Example: Derive
+
+Using all of the above, we can write a `derive` macro that behaves similarly to Rust's but is not built into the language.
+From the user's perspective it will look like this:
+
+```rust
+// Example usage
+#[derive(Default, Eq, Ord)]
+struct MyStruct { my_field: u32 }
+```
+
+To implement `derive` we'll have to create a `comptime` function that accepts
+a variable amount of traits.
+
+```rust title="derive_example" showLineNumbers 
+// These are needed for the unconstrained hashmap we're using to store derive functions
+use crate::collections::umap::UHashMap;
+use crate::hash::BuildHasherDefault;
+use crate::hash::poseidon2::Poseidon2Hasher;
+
+// A derive function is one that given a struct definition can
+// create us a quoted trait impl from it.
+pub type DeriveFunction = fn(StructDefinition) -> Quoted;
+
+// We'll keep a global HANDLERS map to keep track of the derive handler for each trait
+comptime mut global HANDLERS: UHashMap<TraitDefinition, DeriveFunction, BuildHasherDefault<Poseidon2Hasher>> =
+    UHashMap::default();
+
+// Given a struct and a slice of traits to derive, create trait impls for each.
+// This function is as simple as iterating over the slice, checking if we have a trait
+// handler registered for the given trait, calling it, and appending the result.
+#[varargs]
+pub comptime fn derive(s: StructDefinition, traits: [TraitDefinition]) -> Quoted {
+    let mut result = quote {};
+
+    for trait_to_derive in traits {
+        let handler = unsafe { HANDLERS.get(trait_to_derive) };
+        assert(handler.is_some(), f"No derive function registered for `{trait_to_derive}`");
+
+        let trait_impl = handler.unwrap()(s);
+        result = quote { $result $trait_impl };
+    }
+
+    result
+}
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/meta/mod.nr#L31-L64" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/meta/mod.nr#L31-L64</a></sub></sup>
+
+
+Registering a derive function could be done as follows:
+
+```rust title="derive_via" showLineNumbers 
+// To register a handler for a trait, just add it to our handlers map
+pub comptime fn derive_via(t: TraitDefinition, f: DeriveFunction) {
+    HANDLERS.insert(t, f);
+}
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/meta/mod.nr#L66-L73" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/meta/mod.nr#L66-L73</a></sub></sup>
+
+
+```rust title="big-derive-usage-example" showLineNumbers 
+// Finally, to register a handler we call the above function as an annotation
+    // with our handler function.
+    #[derive_via(derive_do_nothing)]
+    trait DoNothing {
+        fn do_nothing(self);
+    }
+
+    comptime fn derive_do_nothing(s: StructDefinition) -> Quoted {
+        // This is simplified since we don't handle generics or where clauses!
+        // In a real example we'd likely also need to introduce each of
+        // `s.generics()` as well as a trait constraint for each generic
+        // to ensure they also implement the trait.
+        let typ = s.as_type();
+        quote {
+            impl DoNothing for $typ {
+                fn do_nothing(self) {
+                    // Traits can't tell us what to do
+                    println("something");
+                }
+            }
+        }
+    }
+
+    // Since `DoNothing` is a simple trait which:
+    // 1. Only has one method
+    // 2. Does not have any generics on the trait itself
+    // We can use `std::meta::make_trait_impl` to help us out.
+    // This helper function will generate our impl for us along with any
+    // necessary where clauses and still provides a flexible interface
+    // for us to work on each field on the struct.
+    comptime fn derive_do_nothing_alt(s: StructDefinition) -> Quoted {
+        let trait_name = quote { DoNothing };
+        let method_signature = quote { fn do_nothing(self) };
+
+        // Call `do_nothing` recursively on each field in the struct
+        let for_each_field = |field_name| quote { self.$field_name.do_nothing(); };
+
+        // Some traits like Eq want to join each field expression with something like `&`.
+        // We don't need that here
+        let join_fields_with = quote {};
+
+        // The body function is a spot to insert any extra setup/teardown needed.
+        // We'll insert our println here. Since we recur on each field, we should see
+        // one println for the struct itself, followed by a println for every field (recursively).
+        let body = |body| quote {
+            println("something");
+            $body
+        };
+        crate::meta::make_trait_impl(
+            s,
+            trait_name,
+            method_signature,
+            for_each_field,
+            join_fields_with,
+            body,
+        )
+    }
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/meta/mod.nr#L191-L249" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/meta/mod.nr#L191-L249</a></sub></sup>
+
diff --git a/docs/versioned_docs/version-v0.37.0/noir/concepts/control_flow.md b/docs/versioned_docs/version-v0.37.0/noir/concepts/control_flow.md
new file mode 100644
index 00000000000..b365bb22728
--- /dev/null
+++ b/docs/versioned_docs/version-v0.37.0/noir/concepts/control_flow.md
@@ -0,0 +1,79 @@
+---
+title: Control Flow
+description:
+  Learn how to use loops and if expressions in the Noir programming language. Discover the syntax
+  and examples for for loops and if-else statements.
+keywords: [Noir programming language, loops, for loop, if-else statements, Rust syntax]
+sidebar_position: 2
+---
+
+## If Expressions
+
+Noir supports `if-else` statements. The syntax is most similar to Rust's where it is not required
+for the statement's conditional to be surrounded by parentheses.
+
+```rust
+let a = 0;
+let mut x: u32 = 0;
+
+if a == 0 {
+    if a != 0 {
+        x = 6;
+    } else {
+        x = 2;
+    }
+} else {
+    x = 5;
+    assert(x == 5);
+}
+assert(x == 2);
+```
+
+## Loops
+
+Noir has one kind of loop: the `for` loop. `for` loops allow you to repeat a block of code multiple
+times.
+
+The following block of code between the braces is run 10 times.
+
+```rust
+for i in 0..10 {
+    // do something
+}
+```
+
+Alternatively, `start..=end` can be used for a range that is inclusive on both ends.
+
+The index for loops is of type `u64`.
+
+### Break and Continue
+
+In unconstrained code, `break` and `continue` are also allowed in `for` loops. These are only allowed
+in unconstrained code since normal constrained code requires that Noir knows exactly how many iterations
+a loop may have. `break` and `continue` can be used like so:
+
+```rust
+for i in 0 .. 10 {
+    println("Iteration start")
+
+    if i == 2 {
+        continue;
+    }
+
+    if i == 5 {
+        break;
+    }
+
+    println(i);
+}
+println("Loop end")
+```
+
+When used, `break` will end the current loop early and jump to the statement after the for loop. In the example
+above, the `break` will stop the loop and jump to the `println("Loop end")`.
+
+`continue` will stop the current iteration of the loop, and jump to the start of the next iteration. In the example
+above, `continue` will jump to `println("Iteration start")` when used. Note that the loop continues as normal after this.
+The iteration variable `i` is still increased by one as normal when `continue` is used.
+
+`break` and `continue` cannot currently be used to jump out of more than a single loop at a time.
diff --git a/docs/versioned_docs/version-v0.37.0/noir/concepts/data_bus.mdx b/docs/versioned_docs/version-v0.37.0/noir/concepts/data_bus.mdx
new file mode 100644
index 00000000000..e55e58622ce
--- /dev/null
+++ b/docs/versioned_docs/version-v0.37.0/noir/concepts/data_bus.mdx
@@ -0,0 +1,23 @@
+---
+title: Data Bus
+sidebar_position: 13
+---
+import Experimental from '@site/src/components/Notes/_experimental.mdx';
+
+<Experimental />
+
+The data bus is an optimization that the backend can use to make recursion more efficient.
+In order to use it, you must define some inputs of the program entry points (usually the `main()`
+function) with the `call_data` modifier, and the return values with the `return_data` modifier.
+These modifiers are incompatible with `pub` and `mut` modifiers.
+
+## Example
+
+```rust
+fn main(mut x: u32, y: call_data u32, z: call_data [u32;4] ) -> return_data u32 {
+  let a = z[x];
+  a+y
+}
+```
+
+As a result, both call_data and return_data will be treated as private inputs and encapsulated into a read-only array each, for the backend to process.
diff --git a/docs/versioned_docs/version-v0.37.0/noir/concepts/data_types/_category_.json b/docs/versioned_docs/version-v0.37.0/noir/concepts/data_types/_category_.json
new file mode 100644
index 00000000000..5d694210bbf
--- /dev/null
+++ b/docs/versioned_docs/version-v0.37.0/noir/concepts/data_types/_category_.json
@@ -0,0 +1,5 @@
+{
+    "position": 0,
+    "collapsible": true,
+    "collapsed": true
+}
diff --git a/docs/versioned_docs/version-v0.37.0/noir/concepts/data_types/arrays.md b/docs/versioned_docs/version-v0.37.0/noir/concepts/data_types/arrays.md
new file mode 100644
index 00000000000..289145a8c4d
--- /dev/null
+++ b/docs/versioned_docs/version-v0.37.0/noir/concepts/data_types/arrays.md
@@ -0,0 +1,276 @@
+---
+title: Arrays
+description:
+  Dive into the Array data type in Noir. Grasp its methods, practical examples, and best practices for efficiently using Arrays in your Noir code.
+keywords:
+  [
+    noir,
+    array type,
+    methods,
+    examples,
+    indexing,
+  ]
+sidebar_position: 4
+---
+
+An array is one way of grouping together values into one compound type. Array types can be inferred
+or explicitly specified via the syntax `[<Type>; <Size>]`:
+
+```rust
+fn main(x : Field, y : Field) {
+    let my_arr = [x, y];
+    let your_arr: [Field; 2] = [x, y];
+}
+```
+
+Here, both `my_arr` and `your_arr` are instantiated as an array containing two `Field` elements.
+
+Array elements can be accessed using indexing:
+
+```rust
+fn main() {
+    let a = [1, 2, 3, 4, 5];
+
+    let first = a[0];
+    let second = a[1];
+}
+```
+
+All elements in an array must be of the same type (i.e. homogeneous). That is, an array cannot group
+a `Field` value and a `u8` value together for example.
+
+You can write mutable arrays, like:
+
+```rust
+fn main() {
+    let mut arr = [1, 2, 3, 4, 5];
+    assert(arr[0] == 1);
+
+    arr[0] = 42;
+    assert(arr[0] == 42);
+}
+```
+
+You can instantiate a new array of a fixed size with the same value repeated for each element. The following example instantiates an array of length 32 where each element is of type Field and has the value 0.
+
+```rust
+let array: [Field; 32] = [0; 32];
+```
+
+Like in Rust, arrays in Noir are a fixed size. However, if you wish to convert an array to a [slice](./slices.mdx), you can just call `as_slice` on your array:
+
+```rust
+let array: [Field; 32] = [0; 32];
+let sl = array.as_slice()
+```
+
+You can define multidimensional arrays:
+
+```rust
+let array : [[Field; 2]; 2];
+let element = array[0][0];
+```
+
+However, multidimensional slices are not supported. For example, the following code will error at compile time:
+
+```rust
+let slice : [[Field]] = &[];
+```
+
+## Types
+
+You can create arrays of primitive types or structs. There is not yet support for nested arrays
+(arrays of arrays) or arrays of structs that contain arrays.
+
+## Methods
+
+For convenience, the STD provides some ready-to-use, common methods for arrays.
+Each of these functions are located within the generic impl `impl<T, N> [T; N] {`.
+So anywhere `self` appears, it refers to the variable `self: [T; N]`.
+
+### len
+
+Returns the length of an array
+
+```rust
+fn len(self) -> Field
+```
+
+example
+
+```rust
+fn main() {
+    let array = [42, 42];
+    assert(array.len() == 2);
+}
+```
+
+### sort
+
+Returns a new sorted array. The original array remains untouched. Notice that this function will
+only work for arrays of fields or integers, not for any arbitrary type. This is because the sorting
+logic it uses internally is optimized specifically for these values. If you need a sort function to
+sort any type, you should use the function `sort_via` described below.
+
+```rust
+fn sort(self) -> [T; N]
+```
+
+example
+
+```rust
+fn main() {
+    let arr = [42, 32];
+    let sorted = arr.sort();
+    assert(sorted == [32, 42]);
+}
+```
+
+### sort_via
+
+Sorts the array with a custom comparison function. The ordering function must return true if the first argument should be sorted to be before the second argument or is equal to the second argument.
+
+Using this method with an operator like `<` that does not return `true` for equal values will result in an assertion failure for arrays with equal elements.
+
+```rust
+fn sort_via(self, ordering: fn(T, T) -> bool) -> [T; N]
+```
+
+example
+
+```rust
+fn main() {
+    let arr = [42, 32]
+    let sorted_ascending = arr.sort_via(|a, b| a <= b);
+    assert(sorted_ascending == [32, 42]); // verifies
+
+    let sorted_descending = arr.sort_via(|a, b| a >= b);
+    assert(sorted_descending == [32, 42]); // does not verify
+}
+```
+
+### map
+
+Applies a function to each element of the array, returning a new array containing the mapped elements.
+
+```rust
+fn map<U>(self, f: fn(T) -> U) -> [U; N]
+```
+
+example
+
+```rust
+let a = [1, 2, 3];
+let b = a.map(|a| a * 2); // b is now [2, 4, 6]
+```
+
+### fold
+
+Applies a function to each element of the array, returning the final accumulated value. The first
+parameter is the initial value.
+
+```rust
+fn fold<U>(self, mut accumulator: U, f: fn(U, T) -> U) -> U
+```
+
+This is a left fold, so the given function will be applied to the accumulator and first element of
+the array, then the second, and so on. For a given call the expected result would be equivalent to:
+
+```rust
+let a1 = [1];
+let a2 = [1, 2];
+let a3 = [1, 2, 3];
+
+let f = |a, b| a - b;
+a1.fold(10, f)  //=> f(10, 1)
+a2.fold(10, f)  //=> f(f(10, 1), 2)
+a3.fold(10, f)  //=> f(f(f(10, 1), 2), 3)
+```
+
+example:
+
+```rust
+
+fn main() {
+    let arr = [2, 2, 2, 2, 2];
+    let folded = arr.fold(0, |a, b| a + b);
+    assert(folded == 10);
+}
+
+```
+
+### reduce
+
+Same as fold, but uses the first element as the starting element.
+
+Requires `self` to be non-empty.
+
+```rust
+fn reduce(self, f: fn(T, T) -> T) -> T
+```
+
+example:
+
+```rust
+fn main() {
+    let arr = [2, 2, 2, 2, 2];
+    let reduced = arr.reduce(|a, b| a + b);
+    assert(reduced == 10);
+}
+```
+
+### all
+
+Returns true if all the elements satisfy the given predicate
+
+```rust
+fn all(self, predicate: fn(T) -> bool) -> bool
+```
+
+example:
+
+```rust
+fn main() {
+    let arr = [2, 2, 2, 2, 2];
+    let all = arr.all(|a| a == 2);
+    assert(all);
+}
+```
+
+### any
+
+Returns true if any of the elements satisfy the given predicate
+
+```rust
+fn any(self, predicate: fn(T) -> bool) -> bool
+```
+
+example:
+
+```rust
+fn main() {
+    let arr = [2, 2, 2, 2, 5];
+    let any = arr.any(|a| a == 5);
+    assert(any);
+}
+```
+
+### as_str_unchecked
+
+Converts a byte array of type `[u8; N]` to a string. Note that this performs no UTF-8 validation -
+the given array is interpreted as-is as a string.
+
+```rust
+impl<let N: u32> [u8; N] {
+    pub fn as_str_unchecked(self) -> str<N>
+}
+```
+
+example:
+
+```rust
+fn main() {
+    let hi = [104, 105].as_str_unchecked();
+    assert_eq(hi, "hi");
+}
+```
diff --git a/docs/versioned_docs/version-v0.37.0/noir/concepts/data_types/booleans.md b/docs/versioned_docs/version-v0.37.0/noir/concepts/data_types/booleans.md
new file mode 100644
index 00000000000..2507af710e7
--- /dev/null
+++ b/docs/versioned_docs/version-v0.37.0/noir/concepts/data_types/booleans.md
@@ -0,0 +1,28 @@
+---
+title: Booleans
+description:
+  Delve into the Boolean data type in Noir. Understand its methods, practical examples, and best practices for using Booleans in your Noir programs.
+keywords:
+  [
+    noir,
+    boolean type,
+    methods,
+    examples,
+    logical operations,
+  ]
+sidebar_position: 2
+---
+
+
+The `bool` type in Noir has two possible values: `true` and `false`:
+
+```rust
+fn main() {
+    let t = true;
+    let f: bool = false;
+}
+```
+
+The boolean type is most commonly used in conditionals like `if` expressions and `assert`
+statements. More about conditionals is covered in the [Control Flow](../control_flow.md) and
+[Assert Function](../assert.md) sections.
diff --git a/docs/versioned_docs/version-v0.37.0/noir/concepts/data_types/fields.md b/docs/versioned_docs/version-v0.37.0/noir/concepts/data_types/fields.md
new file mode 100644
index 00000000000..b9b56f7ecc3
--- /dev/null
+++ b/docs/versioned_docs/version-v0.37.0/noir/concepts/data_types/fields.md
@@ -0,0 +1,246 @@
+---
+title: Fields
+description:
+  Dive deep into the Field data type in Noir. Understand its methods, practical examples, and best practices to effectively use Fields in your Noir programs.
+keywords:
+  [
+    noir,
+    field type,
+    methods,
+    examples,
+    best practices,
+  ]
+sidebar_position: 0
+---
+
+The field type corresponds to the native field type of the proving backend.
+
+The size of a Noir field depends on the elliptic curve's finite field for the proving backend
+adopted. For example, a field would be a 254-bit integer when paired with the default backend that
+spans the Grumpkin curve.
+
+Fields support integer arithmetic and are often used as the default numeric type in Noir:
+
+```rust
+fn main(x : Field, y : Field)  {
+    let z = x + y;
+}
+```
+
+`x`, `y` and `z` are all private fields in this example. Using the `let` keyword we defined a new
+private value `z` constrained to be equal to `x + y`.
+
+If proving efficiency is of priority, fields should be used as a default for solving problems.
+Smaller integer types (e.g. `u64`) incur extra range constraints.
+
+## Methods
+
+After declaring a Field, you can use these common methods on it:
+
+### to_le_bits
+
+Transforms the field into an array of bits, Little Endian.
+
+```rust title="to_le_bits" showLineNumbers 
+pub fn to_le_bits<let N: u32>(self: Self) -> [u1; N] {}
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/field/mod.nr#L32-L34" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/field/mod.nr#L32-L34</a></sub></sup>
+
+
+example:
+
+```rust title="to_le_bits_example" showLineNumbers 
+fn test_to_le_bits() {
+        let field = 2;
+        let bits: [u1; 8] = field.to_le_bits();
+        assert_eq(bits, [0, 1, 0, 0, 0, 0, 0, 0]);
+    }
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/field/mod.nr#L276-L282" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/field/mod.nr#L276-L282</a></sub></sup>
+
+
+
+### to_be_bits
+
+Transforms the field into an array of bits, Big Endian.
+
+```rust title="to_be_bits" showLineNumbers 
+pub fn to_be_bits<let N: u32>(self: Self) -> [u1; N] {}
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/field/mod.nr#L48-L50" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/field/mod.nr#L48-L50</a></sub></sup>
+
+
+example:
+
+```rust title="to_be_bits_example" showLineNumbers 
+fn test_to_be_bits() {
+        let field = 2;
+        let bits: [u1; 8] = field.to_be_bits();
+        assert_eq(bits, [0, 0, 0, 0, 0, 0, 1, 0]);
+    }
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/field/mod.nr#L267-L273" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/field/mod.nr#L267-L273</a></sub></sup>
+
+
+
+### to_le_bytes
+
+Transforms into an array of bytes, Little Endian
+
+```rust title="to_le_bytes" showLineNumbers 
+pub fn to_le_bytes<let N: u32>(self: Self) -> [u8; N] {
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/field/mod.nr#L61-L63" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/field/mod.nr#L61-L63</a></sub></sup>
+
+
+example:
+
+```rust title="to_le_bytes_example" showLineNumbers 
+fn test_to_le_bytes() {
+        let field = 2;
+        let bytes: [u8; 8] = field.to_le_bytes();
+        assert_eq(bytes, [2, 0, 0, 0, 0, 0, 0, 0]);
+        assert_eq(Field::from_le_bytes::<8>(bytes), field);
+    }
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/field/mod.nr#L295-L302" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/field/mod.nr#L295-L302</a></sub></sup>
+
+
+### to_be_bytes
+
+Transforms into an array of bytes, Big Endian
+
+```rust title="to_be_bytes" showLineNumbers 
+pub fn to_be_bytes<let N: u32>(self: Self) -> [u8; N] {
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/field/mod.nr#L94-L96" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/field/mod.nr#L94-L96</a></sub></sup>
+
+
+example:
+
+```rust title="to_be_bytes_example" showLineNumbers 
+fn test_to_be_bytes() {
+        let field = 2;
+        let bytes: [u8; 8] = field.to_be_bytes();
+        assert_eq(bytes, [0, 0, 0, 0, 0, 0, 0, 2]);
+        assert_eq(Field::from_be_bytes::<8>(bytes), field);
+    }
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/field/mod.nr#L285-L292" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/field/mod.nr#L285-L292</a></sub></sup>
+
+
+
+### to_le_radix
+
+Decomposes into an array over the specified base, Little Endian
+
+```rust title="to_le_radix" showLineNumbers 
+pub fn to_le_radix<let N: u32>(self: Self, radix: u32) -> [u8; N] {
+        // Brillig does not need an immediate radix
+        if !crate::runtime::is_unconstrained() {
+            crate::assert_constant(radix);
+        }
+        self.__to_le_radix(radix)
+    }
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/field/mod.nr#L118-L126" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/field/mod.nr#L118-L126</a></sub></sup>
+
+
+
+example:
+
+```rust title="to_le_radix_example" showLineNumbers 
+fn test_to_le_radix() {
+        let field = 2;
+        let bytes: [u8; 8] = field.to_le_radix(256);
+        assert_eq(bytes, [2, 0, 0, 0, 0, 0, 0, 0]);
+        assert_eq(Field::from_le_bytes::<8>(bytes), field);
+    }
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/field/mod.nr#L315-L322" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/field/mod.nr#L315-L322</a></sub></sup>
+
+
+
+### to_be_radix
+
+Decomposes into an array over the specified base, Big Endian
+
+```rust title="to_be_radix" showLineNumbers 
+pub fn to_be_radix<let N: u32>(self: Self, radix: u32) -> [u8; N] {
+        // Brillig does not need an immediate radix
+        if !crate::runtime::is_unconstrained() {
+            crate::assert_constant(radix);
+        }
+        self.__to_be_radix(radix)
+    }
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/field/mod.nr#L128-L136" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/field/mod.nr#L128-L136</a></sub></sup>
+
+
+example:
+
+```rust title="to_be_radix_example" showLineNumbers 
+fn test_to_be_radix() {
+        let field = 2;
+        let bytes: [u8; 8] = field.to_be_radix(256);
+        assert_eq(bytes, [0, 0, 0, 0, 0, 0, 0, 2]);
+        assert_eq(Field::from_be_bytes::<8>(bytes), field);
+    }
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/field/mod.nr#L305-L312" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/field/mod.nr#L305-L312</a></sub></sup>
+
+
+
+### pow_32
+
+Returns the value to the power of the specified exponent
+
+```rust
+fn pow_32(self, exponent: Field) -> Field
+```
+
+example:
+
+```rust
+fn main() {
+    let field = 2
+    let pow = field.pow_32(4);
+    assert(pow == 16);
+}
+```
+
+### assert_max_bit_size
+
+Adds a constraint to specify that the field can be represented with `bit_size` number of bits
+
+```rust title="assert_max_bit_size" showLineNumbers 
+pub fn assert_max_bit_size<let BIT_SIZE: u32>(self) {
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/field/mod.nr#L10-L12" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/field/mod.nr#L10-L12</a></sub></sup>
+
+
+example:
+
+```rust
+fn main() {
+    let field = 2
+    field.assert_max_bit_size(32);
+}
+```
+
+### sgn0
+
+Parity of (prime) Field element, i.e. sgn0(x mod p) = 0 if x ∈ \{0, ..., p-1\} is even, otherwise sgn0(x mod p) = 1.
+
+```rust
+fn sgn0(self) -> u1
+```
+
+
+### lt
+
+Returns true if the field is less than the other field
+
+```rust
+pub fn lt(self, another: Field) -> bool
+```
diff --git a/docs/versioned_docs/version-v0.37.0/noir/concepts/data_types/function_types.md b/docs/versioned_docs/version-v0.37.0/noir/concepts/data_types/function_types.md
new file mode 100644
index 00000000000..f6121af17e2
--- /dev/null
+++ b/docs/versioned_docs/version-v0.37.0/noir/concepts/data_types/function_types.md
@@ -0,0 +1,26 @@
+---
+title: Function types
+sidebar_position: 10
+---
+
+Noir supports higher-order functions. The syntax for a function type is as follows:
+
+```rust
+fn(arg1_type, arg2_type, ...) -> return_type
+```
+
+Example:
+
+```rust
+fn assert_returns_100(f: fn() -> Field) { // f takes no args and returns a Field
+    assert(f() == 100);
+}
+
+fn main() {
+    assert_returns_100(|| 100); // ok
+    assert_returns_100(|| 150); // fails
+}
+```
+
+A function type also has an optional capture environment - this is necessary to support closures.
+See [Lambdas](../lambdas.md) for more details.
diff --git a/docs/versioned_docs/version-v0.37.0/noir/concepts/data_types/index.md b/docs/versioned_docs/version-v0.37.0/noir/concepts/data_types/index.md
new file mode 100644
index 00000000000..0f2db2b2d75
--- /dev/null
+++ b/docs/versioned_docs/version-v0.37.0/noir/concepts/data_types/index.md
@@ -0,0 +1,126 @@
+---
+title: Data Types
+description:
+  Get a clear understanding of the two categories of Noir data types - primitive types and compound
+  types. Learn about their characteristics, differences, and how to use them in your Noir
+  programming.
+keywords:
+  [
+    noir,
+    data types,
+    primitive types,
+    compound types,
+    private types,
+    public types,
+  ]
+---
+
+Every value in Noir has a type, which determines which operations are valid for it.
+
+All values in Noir are fundamentally composed of `Field` elements. For a more approachable
+developing experience, abstractions are added on top to introduce different data types in Noir.
+
+Noir has two category of data types: primitive types (e.g. `Field`, integers, `bool`) and compound
+types that group primitive types (e.g. arrays, tuples, structs). Each value can either be private or
+public.
+
+## Private & Public Types
+
+A **private value** is known only to the Prover, while a **public value** is known by both the
+Prover and Verifier. Mark values as `private` when the value should only be known to the prover. All
+primitive types (including individual fields of compound types) in Noir are private by default, and
+can be marked public when certain values are intended to be revealed to the Verifier.
+
+> **Note:** For public values defined in Noir programs paired with smart contract verifiers, once
+> the proofs are verified on-chain the values can be considered known to everyone that has access to
+> that blockchain.
+
+Public data types are treated no differently to private types apart from the fact that their values
+will be revealed in proofs generated. Simply changing the value of a public type will not change the
+circuit (where the same goes for changing values of private types as well).
+
+_Private values_ are also referred to as _witnesses_ sometimes.
+
+> **Note:** The terms private and public when applied to a type (e.g. `pub Field`) have a different
+> meaning than when applied to a function (e.g. `pub fn foo() {}`).
+>
+> The former is a visibility modifier for the Prover to interpret if a value should be made known to
+> the Verifier, while the latter is a visibility modifier for the compiler to interpret if a
+> function should be made accessible to external Noir programs like in other languages.
+
+### pub Modifier
+
+All data types in Noir are private by default. Types are explicitly declared as public using the
+`pub` modifier:
+
+```rust
+fn main(x : Field, y : pub Field) -> pub Field {
+    x + y
+}
+```
+
+In this example, `x` is **private** while `y` and `x + y` (the return value) are **public**. Note
+that visibility is handled **per variable**, so it is perfectly valid to have one input that is
+private and another that is public.
+
+> **Note:** Public types can only be declared through parameters on `main`.
+
+## Type Aliases
+
+A type alias is a new name for an existing type. Type aliases are declared with the keyword `type`:
+
+```rust
+type Id = u8;
+
+fn main() {
+    let id: Id = 1;
+    let zero: u8 = 0;
+    assert(zero + 1 == id);
+}
+```
+
+Type aliases can also be used with [generics](../generics.md):
+
+```rust
+type Id<Size> = Size;
+
+fn main() {
+    let id: Id<u32> = 1;
+    let zero: u32 = 0;
+    assert(zero + 1 == id);
+}
+```
+
+Type aliases can even refer to other aliases. An error will be issued if they form a cycle:
+
+```rust
+// Ok!
+type A = B;
+type B = Field;
+
+type Bad1 = Bad2;
+
+// error: Dependency cycle found
+type Bad2 = Bad1;
+//   ^^^^^^^^^^^ 'Bad2' recursively depends on itself: Bad2 -> Bad1 -> Bad2
+```
+
+By default, like functions, type aliases are private to the module they exist in. You can use `pub`
+to make the type alias public or `pub(crate)` to make it public to just its crate:
+
+```rust
+// This type alias is now public
+pub type Id = u8;
+```
+
+## Wildcard Type
+Noir can usually infer the type of the variable from the context, so specifying the type of a variable is only required when it cannot be inferred. However, specifying a complex type can be tedious, especially when it has multiple generic arguments. Often some of the generic types can be inferred from the context, and Noir only needs a hint to properly infer the other types. We can partially specify a variable's type by using `_` as a marker, indicating where we still want the compiler to infer the type.
+
+```rust
+let a: [_; 4] = foo(b);
+```
+ 
+
+### BigInt
+
+You can achieve BigInt functionality using the [Noir BigInt](https://github.com/shuklaayush/noir-bigint) library.
diff --git a/docs/versioned_docs/version-v0.37.0/noir/concepts/data_types/integers.md b/docs/versioned_docs/version-v0.37.0/noir/concepts/data_types/integers.md
new file mode 100644
index 00000000000..a1d59bf3166
--- /dev/null
+++ b/docs/versioned_docs/version-v0.37.0/noir/concepts/data_types/integers.md
@@ -0,0 +1,156 @@
+---
+title: Integers
+description: Explore the Integer data type in Noir. Learn about its methods, see real-world examples, and grasp how to efficiently use Integers in your Noir code.
+keywords: [noir, integer types, methods, examples, arithmetic]
+sidebar_position: 1
+---
+
+An integer type is a range constrained field type.
+The Noir frontend supports both unsigned and signed integer types.
+The allowed sizes are 1, 8, 16, 32 and 64 bits.
+
+:::info
+
+When an integer is defined in Noir without a specific type, it will default to `Field`.
+
+The one exception is for loop indices which default to `u64` since comparisons on `Field`s are not possible.
+
+:::
+
+## Unsigned Integers
+
+An unsigned integer type is specified first with the letter `u` (indicating its unsigned nature) followed by its bit size (e.g. `8`):
+
+```rust
+fn main() {
+    let x: u8 = 1;
+    let y: u8 = 1;
+    let z = x + y;
+    assert (z == 2);
+}
+```
+
+The bit size determines the maximum value the integer type can store. For example, a `u8` variable can store a value in the range of 0 to 255 (i.e. $\\2^{8}-1\\$).
+
+## Signed Integers
+
+A signed integer type is specified first with the letter `i` (which stands for integer) followed by its bit size (e.g. `8`):
+
+```rust
+fn main() {
+    let x: i8 = -1;
+    let y: i8 = -1;
+    let z = x + y;
+    assert (z == -2);
+}
+```
+
+The bit size determines the maximum and minimum range of value the integer type can store. For example, an `i8` variable can store a value in the range of -128 to 127 (i.e. $\\-2^{7}\\$ to $\\2^{7}-1\\$).
+
+## 128 bits Unsigned Integers
+
+The built-in structure `U128` allows you to use 128-bit unsigned integers almost like a native integer type. However, there are some differences to keep in mind:
+- You cannot cast between a native integer and `U128`
+- There is a higher performance cost when using `U128`, compared to a native type.
+
+Conversion between unsigned integer types and U128 are done through the use of `from_integer` and `to_integer` functions. `from_integer` also accepts the `Field` type as input.
+
+```rust
+fn main() {
+    let x = U128::from_integer(23);
+    let y = U128::from_hex("0x7");
+    let z = x + y;
+    assert(z.to_integer() == 30);
+}
+```
+
+`U128` is implemented with two 64 bits limbs, representing the low and high bits, which explains the performance cost. You should expect `U128` to be twice more costly for addition and four times more costly for multiplication.
+You can construct a U128 from its limbs:
+```rust
+fn main(x: u64, y: u64) {
+    let x = U128::from_u64s_be(x,y);
+    assert(z.hi == x as Field);
+    assert(z.lo == y as Field);
+}
+```
+
+Note that the limbs are stored as Field elements in order to avoid unnecessary conversions.
+Apart from this, most operations will work as usual:
+
+```rust
+fn main(x: U128, y: U128) {
+    // multiplication
+    let c = x * y;
+    // addition and subtraction
+    let c = c - x + y;
+    // division
+    let c = x / y;
+    // bit operation;
+    let c = x & y | y;
+    // bit shift
+    let c = x << y;
+    // comparisons;
+    let c = x < y;
+    let c = x == y;
+}
+```
+
+## Overflows
+
+Computations that exceed the type boundaries will result in overflow errors. This happens with both signed and unsigned integers. For example, attempting to prove:
+
+```rust
+fn main(x: u8, y: u8) {
+    let z = x + y;
+}
+```
+
+With:
+
+```toml
+x = "255"
+y = "1"
+```
+
+Would result in:
+
+```
+$ nargo execute
+error: Assertion failed: 'attempt to add with overflow'
+┌─ ~/src/main.nr:9:13
+│
+│     let z = x + y;
+│             -----
+│
+= Call stack:
+  ...
+```
+
+A similar error would happen with signed integers:
+
+```rust
+fn main() {
+    let x: i8 = -118;
+    let y: i8 = -11;
+    let z = x + y;
+}
+```
+
+### Wrapping methods
+
+Although integer overflow is expected to error, some use-cases rely on wrapping. For these use-cases, the standard library provides `wrapping` variants of certain common operations:
+
+```rust
+fn wrapping_add<T>(x: T, y: T) -> T;
+fn wrapping_sub<T>(x: T, y: T) -> T;
+fn wrapping_mul<T>(x: T, y: T) -> T;
+```
+
+Example of how it is used:
+
+```rust
+
+fn main(x: u8, y: u8) -> pub u8 {
+    std::wrapping_add(x, y)
+}
+```
diff --git a/docs/versioned_docs/version-v0.37.0/noir/concepts/data_types/references.md b/docs/versioned_docs/version-v0.37.0/noir/concepts/data_types/references.md
new file mode 100644
index 00000000000..a5293d11cfb
--- /dev/null
+++ b/docs/versioned_docs/version-v0.37.0/noir/concepts/data_types/references.md
@@ -0,0 +1,23 @@
+---
+title: References
+sidebar_position: 9
+---
+
+Noir supports first-class references. References are a bit like pointers: they point to a specific address that can be followed to access the data stored at that address. You can use Rust-like syntax to use pointers in Noir: the `&` operator references the variable, the `*` operator dereferences it.
+
+Example:
+
+```rust
+fn main() {
+    let mut x = 2;
+
+    // you can reference x as &mut and pass it to multiplyBy2
+    multiplyBy2(&mut x);
+}
+
+// you can access &mut here
+fn multiplyBy2(x: &mut Field) {
+    // and dereference it with *
+    *x = *x * 2;
+}
+```
diff --git a/docs/versioned_docs/version-v0.37.0/noir/concepts/data_types/slices.mdx b/docs/versioned_docs/version-v0.37.0/noir/concepts/data_types/slices.mdx
new file mode 100644
index 00000000000..cfee564a302
--- /dev/null
+++ b/docs/versioned_docs/version-v0.37.0/noir/concepts/data_types/slices.mdx
@@ -0,0 +1,358 @@
+---
+title: Slices
+description: Explore the Slice data type in Noir. Understand its methods, see real-world examples, and learn how to effectively use Slices in your Noir programs.
+keywords: [noir, slice type, methods, examples, subarrays]
+sidebar_position: 5
+---
+
+import Experimental from '@site/src/components/Notes/_experimental.mdx';
+
+<Experimental />
+
+A slice is a dynamically-sized view into a sequence of elements. They can be resized at runtime, but because they don't own the data, they cannot be returned from a circuit. You can treat slices as arrays without a constrained size.
+
+```rust
+fn main() -> pub u32 {
+    let mut slice: [Field] = &[0; 2];
+
+    let mut new_slice = slice.push_back(6);
+    new_slice.len()
+}
+```
+
+To write a slice literal, use a preceding ampersand as in: `&[0; 2]` or
+`&[1, 2, 3]`.
+
+It is important to note that slices are not references to arrays. In Noir,
+`&[..]` is more similar to an immutable, growable vector.
+
+View the corresponding test file [here][test-file].
+
+[test-file]: https://github.com/noir-lang/noir/blob/f387ec1475129732f72ba294877efdf6857135ac/crates/nargo_cli/tests/test_data_ssa_refactor/slices/src/main.nr
+
+## Methods
+
+For convenience, the STD provides some ready-to-use, common methods for slices:
+
+### push_back
+
+Pushes a new element to the end of the slice, returning a new slice with a length one greater than the original unmodified slice.
+
+```rust
+fn push_back<T>(_self: [T], _elem: T) -> [T]
+```
+
+example:
+
+```rust
+fn main() -> pub Field {
+    let mut slice: [Field] = &[0; 2];
+
+    let mut new_slice = slice.push_back(6);
+    new_slice.len()
+}
+```
+
+View the corresponding test file [here][test-file].
+
+### push_front
+
+Returns a new array with the specified element inserted at index 0. The existing elements indexes are incremented by 1.
+
+```rust
+fn push_front(_self: Self, _elem: T) -> Self
+```
+
+Example:
+
+```rust
+let mut new_slice: [Field] = &[];
+new_slice = new_slice.push_front(20);
+assert(new_slice[0] == 20); // returns true
+```
+
+View the corresponding test file [here][test-file].
+
+### pop_front
+
+Returns a tuple of two items, the first element of the array and the rest of the array.
+
+```rust
+fn pop_front(_self: Self) -> (T, Self)
+```
+
+Example:
+
+```rust
+let (first_elem, rest_of_slice) = slice.pop_front();
+```
+
+View the corresponding test file [here][test-file].
+
+### pop_back
+
+Returns a tuple of two items, the beginning of the array with the last element omitted and the last element.
+
+```rust
+fn pop_back(_self: Self) -> (Self, T)
+```
+
+Example:
+
+```rust
+let (popped_slice, last_elem) = slice.pop_back();
+```
+
+View the corresponding test file [here][test-file].
+
+### append
+
+Loops over a slice and adds it to the end of another.
+
+```rust
+fn append(mut self, other: Self) -> Self
+```
+
+Example:
+
+```rust
+let append = &[1, 2].append(&[3, 4, 5]);
+```
+
+### insert
+
+Inserts an element at a specified index and shifts all following elements by 1.
+
+```rust
+fn insert(_self: Self, _index: Field, _elem: T) -> Self
+```
+
+Example:
+
+```rust
+new_slice = rest_of_slice.insert(2, 100);
+assert(new_slice[2] == 100);
+```
+
+View the corresponding test file [here][test-file].
+
+### remove
+
+Remove an element at a specified index, shifting all elements after it to the left, returning the altered slice and the removed element.
+
+```rust
+fn remove(_self: Self, _index: Field) -> (Self, T)
+```
+
+Example:
+
+```rust
+let (remove_slice, removed_elem) = slice.remove(3);
+```
+
+### len
+
+Returns the length of a slice
+
+```rust
+fn len(self) -> Field
+```
+
+Example:
+
+```rust
+fn main() {
+    let slice = &[42, 42];
+    assert(slice.len() == 2);
+}
+```
+
+### as_array
+
+Converts this slice into an array.
+
+Make sure to specify the size of the resulting array.
+Panics if the resulting array length is different than the slice's length.
+
+```rust
+fn as_array<let N: u32>(self) -> [T; N]
+```
+
+Example:
+
+```rust
+fn main() {
+    let slice = &[5, 6];
+
+    // Always specify the length of the resulting array!
+    let array: [Field; 2] = slice.as_array();
+
+    assert(array[0] == slice[0]);
+    assert(array[1] == slice[1]);
+}
+```
+
+### map
+
+Applies a function to each element of the slice, returning a new slice containing the mapped elements.
+
+```rust
+fn map<U, Env>(self, f: fn[Env](T) -> U) -> [U]
+```
+
+example
+
+```rust
+let a = &[1, 2, 3];
+let b = a.map(|a| a * 2); // b is now &[2, 4, 6]
+```
+
+### fold
+
+Applies a function to each element of the slice, returning the final accumulated value. The first
+parameter is the initial value.
+
+```rust
+fn fold<U, Env>(self, mut accumulator: U, f: fn[Env](U, T) -> U) -> U
+```
+
+This is a left fold, so the given function will be applied to the accumulator and first element of
+the slice, then the second, and so on. For a given call the expected result would be equivalent to:
+
+```rust
+let a1 = &[1];
+let a2 = &[1, 2];
+let a3 = &[1, 2, 3];
+
+let f = |a, b| a - b;
+a1.fold(10, f)  //=> f(10, 1)
+a2.fold(10, f)  //=> f(f(10, 1), 2)
+a3.fold(10, f)  //=> f(f(f(10, 1), 2), 3)
+```
+
+example:
+
+```rust
+
+fn main() {
+    let slice = &[2, 2, 2, 2, 2];
+    let folded = slice.fold(0, |a, b| a + b);
+    assert(folded == 10);
+}
+
+```
+
+### reduce
+
+Same as fold, but uses the first element as the starting element.
+
+```rust
+fn reduce<Env>(self, f: fn[Env](T, T) -> T) -> T
+```
+
+example:
+
+```rust
+fn main() {
+    let slice = &[2, 2, 2, 2, 2];
+    let reduced = slice.reduce(|a, b| a + b);
+    assert(reduced == 10);
+}
+```
+
+### filter
+
+Returns a new slice containing only elements for which the given predicate returns true.
+
+```rust
+fn filter<Env>(self, f: fn[Env](T) -> bool) -> Self
+```
+
+example:
+
+```rust
+fn main() {
+    let slice = &[1, 2, 3, 4, 5];
+    let odds = slice.filter(|x| x % 2 == 1);
+    assert_eq(odds, &[1, 3, 5]);
+}
+```
+
+### join
+
+Flatten each element in the slice into one value, separated by `separator`.
+
+Note that although slices implement `Append`, `join` cannot be used on slice
+elements since nested slices are prohibited.
+
+```rust
+fn join(self, separator: T) -> T where T: Append
+```
+
+example:
+
+```rust
+struct Accumulator {
+    total: Field,
+}
+
+// "Append" two accumulators by adding them
+impl Append for Accumulator {
+    fn empty() -> Self {
+        Self { total: 0 }
+    }
+
+    fn append(self, other: Self) -> Self {
+        Self { total: self.total + other.total }
+    }
+}
+
+fn main() {
+    let slice = &[1, 2, 3, 4, 5].map(|total| Accumulator { total });
+
+    let result = slice.join(Accumulator::empty());
+    assert_eq(result, Accumulator { total: 15 });
+
+    // We can use a non-empty separator to insert additional elements to sum:
+    let separator = Accumulator { total: 10 };
+    let result = slice.join(separator);
+    assert_eq(result, Accumulator { total: 55 });
+}
+```
+
+### all
+
+Returns true if all the elements satisfy the given predicate
+
+```rust
+fn all<Env>(self, predicate: fn[Env](T) -> bool) -> bool
+```
+
+example:
+
+```rust
+fn main() {
+    let slice = &[2, 2, 2, 2, 2];
+    let all = slice.all(|a| a == 2);
+    assert(all);
+}
+```
+
+### any
+
+Returns true if any of the elements satisfy the given predicate
+
+```rust
+fn any<Env>(self, predicate: fn[Env](T) -> bool) -> bool
+```
+
+example:
+
+```rust
+fn main() {
+    let slice = &[2, 2, 2, 2, 5];
+    let any = slice.any(|a| a == 5);
+    assert(any);
+}
+
+```
diff --git a/docs/versioned_docs/version-v0.37.0/noir/concepts/data_types/strings.md b/docs/versioned_docs/version-v0.37.0/noir/concepts/data_types/strings.md
new file mode 100644
index 00000000000..1fdee42425e
--- /dev/null
+++ b/docs/versioned_docs/version-v0.37.0/noir/concepts/data_types/strings.md
@@ -0,0 +1,79 @@
+---
+title: Strings
+description:
+  Discover the String data type in Noir. Learn about its methods, see real-world examples, and understand how to effectively manipulate and use Strings in Noir.
+keywords:
+  [
+    noir,
+    string type,
+    methods,
+    examples,
+    concatenation,
+  ]
+sidebar_position: 3
+---
+
+
+The string type is a fixed length value defined with `str<N>`.
+
+You can use strings in `assert()` functions or print them with
+`println()`. See more about [Logging](../../standard_library/logging.md).
+
+```rust
+
+fn main(message : pub str<11>, hex_as_string : str<4>) {
+    println(message);
+    assert(message == "hello world");
+    assert(hex_as_string == "0x41");
+}
+```
+
+You can convert a `str<N>` to a byte array by calling `as_bytes()`
+or a vector by calling `as_bytes_vec()`.
+
+```rust
+fn main() {
+    let message = "hello world";
+    let message_bytes = message.as_bytes();
+    let mut message_vec = message.as_bytes_vec();
+    assert(message_bytes.len() == 11);
+    assert(message_bytes[0] == 104);
+    assert(message_bytes[0] == message_vec.get(0));
+}
+```
+
+## Escape characters
+
+You can use escape characters for your strings:
+
+| Escape Sequence | Description     |
+|-----------------|-----------------|
+| `\r`            | Carriage Return |
+| `\n`            | Newline         |
+| `\t`            | Tab             |
+| `\0`            | Null Character  |
+| `\"`            | Double Quote    |
+| `\\`            | Backslash       |
+
+Example:
+
+```rust
+let s = "Hello \"world" // prints "Hello "world"
+let s = "hey \tyou"; // prints "hey   you"
+```
+
+## Raw strings
+
+A raw string begins with the letter `r` and is optionally delimited by a number of hashes `#`.
+
+Escape characters are *not* processed within raw strings. All contents are interpreted literally.
+
+Example:
+
+```rust
+let s = r"Hello world";
+let s = r#"Simon says "hello world""#;
+
+// Any number of hashes may be used (>= 1) as long as the string also terminates with the same number of hashes
+let s = r#####"One "#, Two "##, Three "###, Four "####, Five will end the string."#####; 
+```
diff --git a/docs/versioned_docs/version-v0.37.0/noir/concepts/data_types/structs.md b/docs/versioned_docs/version-v0.37.0/noir/concepts/data_types/structs.md
new file mode 100644
index 00000000000..29951ae843a
--- /dev/null
+++ b/docs/versioned_docs/version-v0.37.0/noir/concepts/data_types/structs.md
@@ -0,0 +1,96 @@
+---
+title: Structs
+description:
+  Explore the Struct data type in Noir. Learn about its methods, see real-world examples, and grasp how to effectively define and use Structs in your Noir programs.
+keywords:
+  [
+    noir,
+    struct type,
+    methods,
+    examples,
+    data structures,
+  ]
+sidebar_position: 8
+---
+
+A struct also allows for grouping multiple values of different types. Unlike tuples, we can also
+name each field.
+
+> **Note:** The usage of _field_ here refers to each element of the struct and is unrelated to the
+> field type of Noir.
+
+Defining a struct requires giving it a name and listing each field within as `<Key>: <Type>` pairs:
+
+```rust
+struct Animal {
+    hands: Field,
+    legs: Field,
+    eyes: u8,
+}
+```
+
+An instance of a struct can then be created with actual values in `<Key>: <Value>` pairs in any
+order. Struct fields are accessible using their given names:
+
+```rust
+fn main() {
+    let legs = 4;
+
+    let dog = Animal {
+        eyes: 2,
+        hands: 0,
+        legs,
+    };
+
+    let zero = dog.hands;
+}
+```
+
+Structs can also be destructured in a pattern, binding each field to a new variable:
+
+```rust
+fn main() {
+    let Animal { hands, legs: feet, eyes } = get_octopus();
+
+    let ten = hands + feet + eyes as u8;
+}
+
+fn get_octopus() -> Animal {
+    let octopus = Animal {
+        hands: 0,
+        legs: 8,
+        eyes: 2,
+    };
+
+    octopus
+}
+```
+
+The new variables can be bound with names different from the original struct field names, as
+showcased in the `legs --> feet` binding in the example above.
+
+### Visibility
+
+By default, like functions, structs are private to the module they exist in. You can use `pub`
+to make the struct public or `pub(crate)` to make it public to just its crate:
+
+```rust
+// This struct is now public
+pub struct Animal {
+    hands: Field,
+    legs: Field,
+    eyes: u8,
+}
+```
+
+The same applies to struct fields: by default they are private to the module they exist in,
+but they can be made `pub` or `pub(crate)`:
+
+```rust
+// This struct is now public
+pub struct Animal {
+    hands: Field,           // private to its module
+    pub(crate) legs: Field, // accessible from the entire crate
+    pub eyes: u8,           // accessible from anywhere
+}
+```
\ No newline at end of file
diff --git a/docs/versioned_docs/version-v0.37.0/noir/concepts/data_types/tuples.md b/docs/versioned_docs/version-v0.37.0/noir/concepts/data_types/tuples.md
new file mode 100644
index 00000000000..2ec5c9c4113
--- /dev/null
+++ b/docs/versioned_docs/version-v0.37.0/noir/concepts/data_types/tuples.md
@@ -0,0 +1,48 @@
+---
+title: Tuples
+description:
+  Dive into the Tuple data type in Noir. Understand its methods, practical examples, and best practices for efficiently using Tuples in your Noir code.
+keywords:
+  [
+    noir,
+    tuple type,
+    methods,
+    examples,
+    multi-value containers,
+  ]
+sidebar_position: 7
+---
+
+A tuple collects multiple values like an array, but with the added ability to collect values of
+different types:
+
+```rust
+fn main() {
+    let tup: (u8, u64, Field) = (255, 500, 1000);
+}
+```
+
+One way to access tuple elements is via destructuring using pattern matching:
+
+```rust
+fn main() {
+    let tup = (1, 2);
+
+    let (one, two) = tup;
+
+    let three = one + two;
+}
+```
+
+Another way to access tuple elements is via direct member access, using a period (`.`) followed by
+the index of the element we want to access. Index `0` corresponds to the first tuple element, `1` to
+the second and so on:
+
+```rust
+fn main() {
+    let tup = (5, 6, 7, 8);
+
+    let five = tup.0;
+    let eight = tup.3;
+}
+```
diff --git a/docs/versioned_docs/version-v0.37.0/noir/concepts/functions.md b/docs/versioned_docs/version-v0.37.0/noir/concepts/functions.md
new file mode 100644
index 00000000000..f656cdfd97a
--- /dev/null
+++ b/docs/versioned_docs/version-v0.37.0/noir/concepts/functions.md
@@ -0,0 +1,226 @@
+---
+title: Functions
+description:
+  Learn how to declare functions and methods in Noir, a programming language with Rust semantics.
+  This guide covers parameter declaration, return types, call expressions, and more.
+keywords: [Noir, Rust, functions, methods, parameter declaration, return types, call expressions]
+sidebar_position: 1
+---
+
+Functions in Noir follow the same semantics of Rust, though Noir does not support early returns.
+
+To declare a function the `fn` keyword is used.
+
+```rust
+fn foo() {}
+```
+
+By default, functions are visible only within the package they are defined. To make them visible outside of that package (for example, as part of a [library](../modules_packages_crates/crates_and_packages.md#libraries)), you should mark them as `pub`:
+
+```rust
+pub fn foo() {}
+```
+
+You can also restrict the visibility of the function to only the crate it was defined in, by specifying `pub(crate)`:
+
+```rust
+pub(crate) fn foo() {}  //foo can only be called within its crate
+```
+
+All parameters in a function must have a type and all types are known at compile time. The parameter
+is pre-pended with a colon and the parameter type. Multiple parameters are separated using a comma.
+
+```rust
+fn foo(x : Field, y : Field){}
+```
+
+The return type of a function can be stated by using the `->` arrow notation. The function below
+states that the foo function must return a `Field`. If the function returns no value, then the arrow
+is omitted.
+
+```rust
+fn foo(x : Field, y : Field) -> Field {
+    x + y
+}
+```
+
+Note that a `return` keyword is unneeded in this case - the last expression in a function's body is
+returned.
+
+## Main function
+
+If you're writing a binary, the `main` function is the starting point of your program. You can pass all types of expressions to it, as long as they have a fixed size at compile time:
+
+```rust
+fn main(x : Field) // this is fine: passing a Field
+fn main(x : [Field; 2]) // this is also fine: passing a Field with known size at compile-time
+fn main(x : (Field, bool)) // 👌: passing a (Field, bool) tuple means size 2
+fn main(x : str<5>) // this is fine, as long as you pass a string of size 5
+
+fn main(x : Vec<Field>) // can't compile, has variable size
+fn main(x : [Field]) // can't compile, has variable size
+fn main(....// i think you got it by now
+```
+
+Keep in mind [tests](../../tooling/testing.md) don't differentiate between `main` and any other function. The following snippet passes tests, but won't compile or prove:
+
+```rust
+fn main(x : [Field]) {
+    assert(x[0] == 1);
+}
+
+#[test]
+fn test_one() {
+    main(&[1, 2]);
+}
+```
+
+```bash
+$ nargo test
+[testing] Running 1 test functions
+[testing] Testing test_one... ok
+[testing] All tests passed
+
+$ nargo check
+The application panicked (crashed).
+Message:  Cannot have variable sized arrays as a parameter to main
+```
+
+## Call Expressions
+
+Calling a function in Noir is executed by using the function name and passing in the necessary
+arguments.
+
+Below we show how to call the `foo` function from the `main` function using a call expression:
+
+```rust
+fn main(x : Field, y : Field) {
+    let z = foo(x);
+}
+
+fn foo(x : Field) -> Field {
+    x + x
+}
+```
+
+## Methods
+
+You can define methods in Noir on any struct type in scope.
+
+```rust
+struct MyStruct {
+    foo: Field,
+    bar: Field,
+}
+
+impl MyStruct {
+    fn new(foo: Field) -> MyStruct {
+        MyStruct {
+            foo,
+            bar: 2,
+        }
+    }
+
+    fn sum(self) -> Field {
+        self.foo + self.bar
+    }
+}
+
+fn main() {
+    let s = MyStruct::new(40);
+    assert(s.sum() == 42);
+}
+```
+
+Methods are just syntactic sugar for functions, so if we wanted to we could also call `sum` as
+follows:
+
+```rust
+assert(MyStruct::sum(s) == 42);
+```
+
+It is also possible to specialize which method is chosen depending on the [generic](./generics.md) type that is used. In this example, the `foo` function returns different values depending on its type:
+
+```rust
+struct Foo<T> {}
+
+impl Foo<u32> {
+    fn foo(self) -> Field { 1 }
+}
+
+impl Foo<u64> {
+    fn foo(self) -> Field { 2 }
+}
+
+fn main() {
+    let f1: Foo<u32> = Foo{};
+    let f2: Foo<u64> = Foo{};
+    assert(f1.foo() + f2.foo() == 3);
+}
+```
+
+Also note that impls with the same method name defined in them cannot overlap. For example, if we already have `foo` defined for `Foo<u32>` and `Foo<u64>` like we do above, we cannot also define `foo` in an `impl<T> Foo<T>` since it would be ambiguous which version of `foo` to choose.
+
+```rust
+// Including this impl in the same project as the above snippet would
+// cause an overlapping impls error
+impl<T> Foo<T> {
+    fn foo(self) -> Field { 3 }
+}
+```
+
+## Lambdas
+
+Lambdas are anonymous functions. They follow the syntax of Rust - `|arg1, arg2, ..., argN| return_expression`.
+
+```rust
+let add_50 = |val| val + 50;
+assert(add_50(100) == 150);
+```
+
+See [Lambdas](./lambdas.md) for more details.
+
+## Attributes
+
+Attributes are metadata that can be applied to a function, using the following syntax: `#[attribute(value)]`.
+
+Supported attributes include:
+
+- **builtin**: the function is implemented by the compiler, for efficiency purposes.
+- **deprecated**: mark the function as _deprecated_. Calling the function will generate a warning: `warning: use of deprecated function`
+- **field**: Used to enable conditional compilation of code depending on the field size. See below for more details
+- **oracle**: mark the function as _oracle_; meaning it is an external unconstrained function, implemented in noir_js. See [Unconstrained](./unconstrained.md) and [NoirJS](../../reference/NoirJS/noir_js/index.md) for more details.
+- **test**: mark the function as unit tests. See [Tests](../../tooling/testing.md) for more details
+
+### Field Attribute
+
+The field attribute defines which field the function is compatible for. The function is conditionally compiled, under the condition that the field attribute matches the Noir native field.
+The field can be defined implicitly, by using the name of the elliptic curve usually associated to it - for instance bn254, bls12_381 - or explicitly by using the field (prime) order, in decimal or hexadecimal form.
+As a result, it is possible to define multiple versions of a function with each version specialized for a different field attribute. This can be useful when a function requires different parameters depending on the underlying elliptic curve.
+
+Example: we define the function `foo()` three times below. Once for the default Noir bn254 curve, once for the field $\mathbb F_{23}$, which will normally never be used by Noir, and once again for the bls12_381 curve.
+
+```rust
+#[field(bn254)]
+fn foo() -> u32 {
+    1
+}
+
+#[field(23)]
+fn foo() -> u32 {
+    2
+}
+
+// This commented code would not compile as foo would be defined twice because it is the same field as bn254
+// #[field(21888242871839275222246405745257275088548364400416034343698204186575808495617)]
+// fn foo() -> u32 {
+//     2
+// }
+
+#[field(bls12_381)]
+fn foo() -> u32 {
+    3
+}
+```
+
+If the field name is not known to Noir, it will discard the function. Field names are case insensitive.
diff --git a/docs/versioned_docs/version-v0.37.0/noir/concepts/generics.md b/docs/versioned_docs/version-v0.37.0/noir/concepts/generics.md
new file mode 100644
index 00000000000..c180a0ce7e6
--- /dev/null
+++ b/docs/versioned_docs/version-v0.37.0/noir/concepts/generics.md
@@ -0,0 +1,251 @@
+---
+title: Generics
+description: Learn how to use Generics in Noir
+keywords: [Noir, Rust, generics, functions, structs]
+sidebar_position: 7
+---
+
+Generics allow you to use the same functions with multiple different concrete data types. You can
+read more about the concept of generics in the Rust documentation
+[here](https://doc.rust-lang.org/book/ch10-01-syntax.html).
+
+Here is a trivial example showing the identity function that supports any type. In Rust, it is
+common to refer to the most general type as `T`. We follow the same convention in Noir.
+
+```rust
+fn id<T>(x: T) -> T  {
+    x
+}
+```
+
+## Numeric Generics
+
+If we want to be generic over array lengths (which are type-level integers), we can use numeric
+generics. Using these looks similar to using regular generics, but introducing them into scope
+requires declaring them with `let MyGenericName: IntegerType`. This can be done anywhere a normal
+generic is declared. Instead of types, these generics resolve to integers at compile-time.
+Here's an example of a struct that is generic over the size of the array it contains internally:
+
+```rust
+struct BigInt<let N: u32> {
+    limbs: [u32; N],
+}
+
+impl<let N: u32> BigInt<N> {
+    // `N` is in scope of all methods in the impl
+    fn first(first: BigInt<N>, second: BigInt<N>) -> Self {
+        assert(first.limbs != second.limbs);
+        first
+
+    fn second(first: BigInt<N>, second: Self) -> Self {
+        assert(first.limbs != second.limbs);
+        second
+    }
+}
+```
+
+## In Structs
+
+Generics are useful for specifying types in structs. For example, we can specify that a field in a
+struct will be of a certain generic type. In this case `value` is of type `T`.
+
+```rust
+struct RepeatedValue<T> {
+    value: T,
+    count: Field,
+}
+
+impl<T> RepeatedValue<T> {
+    fn print(self) {
+        for _i in 0 .. self.count {
+            println(self.value);
+        }
+    }
+}
+
+fn main() {
+    let repeated = RepeatedValue { value: "Hello!", count: 2 };
+    repeated.print();
+}
+```
+
+The `print` function will print `Hello!` an arbitrary number of times, twice in this case.
+
+## Calling functions on generic parameters
+
+Since a generic type `T` can represent any type, how can we call functions on the underlying type?
+In other words, how can we go from "any type `T`" to "any type `T` that has certain methods available?"
+
+This is what [traits](../concepts/traits.md) are for in Noir. Here's an example of a function generic over
+any type `T` that implements the `Eq` trait for equality:
+
+```rust
+fn first_element_is_equal<T, let N: u32>(array1: [T; N], array2: [T; N]) -> bool 
+    where T: Eq
+{
+    if (array1.len() == 0) | (array2.len() == 0) {
+        true
+    } else {
+        array1[0] == array2[0]
+    }
+}
+
+fn main() {
+    assert(first_element_is_equal([1, 2, 3], [1, 5, 6]));
+
+    // We can use first_element_is_equal for arrays of any type
+    // as long as we have an Eq impl for the types we pass in
+    let array = [MyStruct::new(), MyStruct::new()];
+    assert(array_eq(array, array, MyStruct::eq));
+}
+
+impl Eq for MyStruct {
+    fn eq(self, other: MyStruct) -> bool {
+        self.foo == other.foo
+    }
+}
+```
+
+You can find more details on traits and trait implementations on the [traits page](../concepts/traits.md).
+
+## Manually Specifying Generics with the Turbofish Operator
+
+There are times when the compiler cannot reasonably infer what type should be used for a generic, or when the developer themselves may want to manually distinguish generic type parameters. This is where the `::<>` turbofish operator comes into play.
+
+The `::<>` operator can follow a variable or path and can be used to manually specify generic arguments within the angle brackets.
+The name "turbofish" comes from that `::<>` looks like a little fish.
+
+Examples:
+```rust
+fn main() {
+    let mut slice = [];
+    slice = slice.push_back(1);
+    slice = slice.push_back(2);
+    // Without turbofish a type annotation would be needed on the left hand side
+    let array = slice.as_array::<2>();
+}
+```
+
+
+```rust
+trait MyTrait {
+    fn ten() -> Self;
+}
+
+impl MyTrait for Field {
+    fn ten() -> Self { 10 }
+}
+
+struct Foo<T> {
+    inner: T
+}
+        
+impl<T> Foo<T> {
+    fn generic_method<U>(_self: Self) -> U where U: MyTrait {
+        U::ten()
+    }
+}
+        
+fn example() {
+    let foo: Foo<Field> = Foo { inner: 1 };
+    // Using a type other than `Field` here (e.g. u32) would fail as 
+    // there is no matching impl for `u32: MyTrait`. 
+    //
+    // Substituting the `10` on the left hand side of this assert
+    // with `10 as u32` would also fail with a type mismatch as we 
+    // are expecting a `Field` from the right hand side.
+    assert(10 as u32 == foo.generic_method::<Field>());
+}
+```
+
+## Arithmetic Generics
+
+In addition to numeric generics, Noir also allows a limited form of arithmetic on generics.
+When you have a numeric generic such as `N`, you can use the following operators on it in a
+type position: `+`, `-`, `*`, `/`, and `%`.
+
+Note that type checking arithmetic generics is a best effort guess from the compiler and there
+are many cases of types that are equal that the compiler may not see as such. For example,
+we know that `T * (N + M)` should be equal to `T*N + T*M` but the compiler does not currently
+apply the distributive law and thus sees these as different types.
+
+Even with this limitation though, the compiler can handle common cases decently well:
+
+```rust
+trait Serialize<let N: u32> {
+    fn serialize(self) -> [Field; N];
+}
+
+impl Serialize<1> for Field {
+    fn serialize(self) -> [Field; 1] {
+        [self]
+    }
+}
+
+impl<T, let N: u32, let M: u32> Serialize<N * M> for [T; N]
+    where T: Serialize<M> { .. }
+
+impl<T, U, let N: u32, let M: u32> Serialize<N + M> for (T, U)
+    where T: Serialize<N>, U: Serialize<M> { .. }
+
+fn main() {
+    let data = (1, [2, 3, 4]);
+    assert_eq(data.serialize().len(), 4);
+}
+```
+
+Note that if there is any over or underflow the types will fail to unify:
+
+```rust title="underflow-example" showLineNumbers 
+fn pop<let N: u32>(array: [Field; N]) -> [Field; N - 1] {
+    let mut result: [Field; N - 1] = std::mem::zeroed();
+    for i in 0..N - 1 {
+        result[i] = array[i];
+    }
+    result
+}
+
+fn main() {
+    // error: Could not determine array length `(0 - 1)`
+    pop([]);
+}
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/test_programs/compile_failure/arithmetic_generics_underflow/src/main.nr#L1-L14" target="_blank" rel="noopener noreferrer">Source code: test_programs/compile_failure/arithmetic_generics_underflow/src/main.nr#L1-L14</a></sub></sup>
+
+
+This also applies if there is underflow in an intermediate calculation:
+
+```rust title="intermediate-underflow-example" showLineNumbers 
+fn main() {
+    // From main it looks like there's nothing sketchy going on
+    seems_fine([]);
+}
+
+// Since `seems_fine` says it can receive and return any length N
+fn seems_fine<let N: u32>(array: [Field; N]) -> [Field; N] {
+    // But inside `seems_fine` we pop from the array which
+    // requires the length to be greater than zero.
+
+    // error: Could not determine array length `(0 - 1)`
+    push_zero(pop(array))
+}
+
+fn pop<let N: u32>(array: [Field; N]) -> [Field; N - 1] {
+    let mut result: [Field; N - 1] = std::mem::zeroed();
+    for i in 0..N - 1 {
+        result[i] = array[i];
+    }
+    result
+}
+
+fn push_zero<let N: u32>(array: [Field; N]) -> [Field; N + 1] {
+    let mut result: [Field; N + 1] = std::mem::zeroed();
+    for i in 0..N {
+        result[i] = array[i];
+    }
+    // index N is already zeroed
+    result
+}
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/test_programs/compile_failure/arithmetic_generics_intermediate_underflow/src/main.nr#L1-L32" target="_blank" rel="noopener noreferrer">Source code: test_programs/compile_failure/arithmetic_generics_intermediate_underflow/src/main.nr#L1-L32</a></sub></sup>
+
diff --git a/docs/versioned_docs/version-v0.37.0/noir/concepts/globals.md b/docs/versioned_docs/version-v0.37.0/noir/concepts/globals.md
new file mode 100644
index 00000000000..6b8314399a2
--- /dev/null
+++ b/docs/versioned_docs/version-v0.37.0/noir/concepts/globals.md
@@ -0,0 +1,82 @@
+---
+title: Global Variables
+description:
+  Learn about global variables in Noir. Discover how
+  to declare, modify, and use them in your programs.
+keywords: [noir programming language, globals, global variables, constants]
+sidebar_position: 8
+---
+
+## Globals
+
+
+Noir supports global variables. The global's type can be inferred by the compiler entirely:
+
+```rust
+global N = 5; // Same as `global N: Field = 5`
+
+global TUPLE = (3, 2);
+
+fn main() {
+    assert(N == 5);
+    assert(N == TUPLE.0 + TUPLE.1);
+}
+```
+
+:::info
+
+Globals can be defined as any expression, so long as they don't depend on themselves - otherwise there would be a dependency cycle! For example:
+
+```rust
+global T = foo(T); // dependency error
+```
+
+:::
+
+
+If they are initialized to a literal integer, globals can be used to specify an array's length:
+
+```rust
+global N: u32 = 2;
+
+fn main(y : [Field; N]) {
+    assert(y[0] == y[1])
+}
+```
+
+A global from another module can be imported or referenced externally like any other name:
+
+```rust
+global N = 20;
+
+fn main() {
+    assert(my_submodule::N != N);
+}
+
+mod my_submodule {
+    global N: Field = 10;
+}
+```
+
+When a global is used, Noir replaces the name with its definition on each occurrence.
+This means globals defined using function calls will repeat the call each time they're used:
+
+```rust
+global RESULT = foo();
+
+fn foo() -> [Field; 100] { ... }
+```
+
+This is usually fine since Noir will generally optimize any function call that does not
+refer to a program input into a constant. It should be kept in mind however, if the called
+function performs side-effects like `println`, as these will still occur on each use.
+
+### Visibility
+
+By default, like functions, globals are private to the module they exist in. You can use `pub`
+to make the global public or `pub(crate)` to make it public to just its crate:
+
+```rust
+// This global is now public
+pub global N = 5;
+```
\ No newline at end of file
diff --git a/docs/versioned_docs/version-v0.37.0/noir/concepts/lambdas.md b/docs/versioned_docs/version-v0.37.0/noir/concepts/lambdas.md
new file mode 100644
index 00000000000..be3c7e0b5ca
--- /dev/null
+++ b/docs/versioned_docs/version-v0.37.0/noir/concepts/lambdas.md
@@ -0,0 +1,81 @@
+---
+title: Lambdas
+description: Learn how to use anonymous functions in Noir programming language.
+keywords: [Noir programming language, lambda, closure, function, anonymous function]
+sidebar_position: 9
+---
+
+## Introduction
+
+Lambdas are anonymous functions. The syntax is `|arg1, arg2, ..., argN| return_expression`.
+
+```rust
+let add_50 = |val| val + 50;
+assert(add_50(100) == 150);
+```
+
+A block can be used as the body of a lambda, allowing you to declare local variables inside it:
+
+```rust
+let cool = || {
+  let x = 100;
+  let y = 100;
+  x + y
+}
+
+assert(cool() == 200);
+```
+
+## Closures
+
+Inside the body of a lambda, you can use variables defined in the enclosing function. Such lambdas are called **closures**. In this example `x` is defined inside `main` and is accessed from within the lambda:
+
+```rust
+fn main() {
+  let x = 100;
+  let closure = || x + 150;
+  assert(closure() == 250);
+}
+```
+
+## Passing closures to higher-order functions
+
+It may catch you by surprise that the following code fails to compile:
+
+```rust
+fn foo(f: fn () -> Field) -> Field {
+ f()
+}
+
+fn main() {
+  let (x, y) = (50, 50);
+  assert(foo(|| x + y) == 100); // error :(
+}
+```
+
+The reason is that the closure's capture environment affects its type - we have a closure that captures two Fields and `foo`
+expects a regular function as an argument - those are incompatible.
+:::note
+
+Variables contained within the `||` are the closure's parameters, and the expression that follows it is the closure's body. The capture environment is comprised of any variables used in the closure's body that are not parameters.
+
+E.g. in |x| x + y, y would be a captured variable, but x would not be, since it is a parameter of the closure.
+
+:::
+The syntax for the type of a closure is `fn[env](args) -> ret_type`, where `env` is the capture environment of the closure -
+in this example that's `(Field, Field)`.
+
+The best solution in our case is to make `foo` generic over the environment type of its parameter, so that it can be called
+with closures with any environment, as well as with regular functions:
+
+```rust
+fn foo<Env>(f: fn[Env]() -> Field) -> Field {
+ f()
+}
+
+fn main() {
+  let (x, y) = (50, 50);
+  assert(foo(|| x + y) == 100); // compiles fine
+  assert(foo(|| 60) == 60);     // compiles fine
+}
+```
diff --git a/docs/versioned_docs/version-v0.37.0/noir/concepts/mutability.md b/docs/versioned_docs/version-v0.37.0/noir/concepts/mutability.md
new file mode 100644
index 00000000000..fdeef6a87c5
--- /dev/null
+++ b/docs/versioned_docs/version-v0.37.0/noir/concepts/mutability.md
@@ -0,0 +1,121 @@
+---
+title: Mutability
+description:
+  Learn about mutable variables in Noir. Discover how
+  to declare, modify, and use them in your programs.
+keywords: [noir programming language, mutability in noir, mutable variables]
+sidebar_position: 8
+---
+
+Variables in noir can be declared mutable via the `mut` keyword. Mutable variables can be reassigned
+to via an assignment expression.
+
+```rust
+let x = 2;
+x = 3; // error: x must be mutable to be assigned to
+
+let mut y = 3;
+let y = 4; // OK
+```
+
+The `mut` modifier can also apply to patterns:
+
+```rust
+let (a, mut b) = (1, 2);
+a = 11; // error: a must be mutable to be assigned to
+b = 12; // OK
+
+let mut (c, d) = (3, 4);
+c = 13; // OK
+d = 14; // OK
+
+// etc.
+let MyStruct { x: mut y } = MyStruct { x: a };
+// y is now in scope
+```
+
+Note that mutability in noir is local and everything is passed by value, so if a called function
+mutates its parameters then the parent function will keep the old value of the parameters.
+
+```rust
+fn main() -> pub Field {
+    let x = 3;
+    helper(x);
+    x // x is still 3
+}
+
+fn helper(mut x: i32) {
+    x = 4;
+}
+```
+
+## Non-local mutability
+
+Non-local mutability can be achieved through the mutable reference type `&mut T`:
+
+```rust
+fn set_to_zero(x: &mut Field) {
+    *x = 0;
+}
+
+fn main() {
+    let mut y = 42;
+    set_to_zero(&mut y);
+    assert(*y == 0);
+}
+```
+
+When creating a mutable reference, the original variable being referred to (`y` in this
+example) must also be mutable. Since mutable references are a reference type, they must
+be explicitly dereferenced via `*` to retrieve the underlying value. Note that this yields
+a copy of the value, so mutating this copy will not change the original value behind the
+reference:
+
+```rust
+fn main() {
+    let mut x = 1;
+    let x_ref = &mut x;
+
+    let mut y = *x_ref;
+    let y_ref = &mut y;
+
+    x = 2;
+    *x_ref = 3;
+
+    y = 4;
+    *y_ref = 5;
+
+    assert(x == 3);
+    assert(*x_ref == 3);
+    assert(y == 5);
+    assert(*y_ref == 5);
+}
+```
+
+Note that types in Noir are actually deeply immutable so the copy that occurs when
+dereferencing is only a conceptual copy - no additional constraints will occur.
+
+Mutable references can also be stored within structs. Note that there is also
+no lifetime parameter on these unlike rust. This is because the allocated memory
+always lasts the entire program - as if it were an array of one element.
+
+```rust
+struct Foo {
+    x: &mut Field
+}
+
+impl Foo {
+    fn incr(mut self) {
+        *self.x += 1;
+    }
+}
+
+fn main() {
+    let foo = Foo { x: &mut 0 };
+    foo.incr();
+    assert(*foo.x == 1);
+}
+```
+
+In general, you should avoid non-local & shared mutability unless it is needed. Sticking
+to only local mutability will improve readability and potentially improve compiler optimizations as well.
diff --git a/docs/versioned_docs/version-v0.37.0/noir/concepts/ops.md b/docs/versioned_docs/version-v0.37.0/noir/concepts/ops.md
new file mode 100644
index 00000000000..c35c36c38a9
--- /dev/null
+++ b/docs/versioned_docs/version-v0.37.0/noir/concepts/ops.md
@@ -0,0 +1,98 @@
+---
+title: Logical Operations
+description:
+  Learn about the supported arithmetic and logical operations in the Noir programming language.
+  Discover how to perform operations on private input types, integers, and booleans.
+keywords:
+  [
+    Noir programming language,
+    supported operations,
+    arithmetic operations,
+    logical operations,
+    predicate operators,
+    bitwise operations,
+    short-circuiting,
+    backend,
+  ]
+sidebar_position: 3
+---
+
+# Operations
+
+## Table of Supported Operations
+
+| Operation |                          Description                           |                           Requirements |
+| :-------- | :------------------------------------------------------------: | -------------------------------------: |
+| +         |             Adds two private input types together              |            Types must be private input |
+| -         |           Subtracts two private input types together           |            Types must be private input |
+| \*        |          Multiplies two private input types together           |            Types must be private input |
+| /         |            Divides two private input types together            |            Types must be private input |
+| ^         |              XOR two private input types together              |                  Types must be integer |
+| &         |              AND two private input types together              |                  Types must be integer |
+| \|        |              OR two private input types together               |                  Types must be integer |
+| \<\<        |        Left shift an integer by another integer amount         | Types must be integer, shift must be u8 |
+| >>        |        Right shift an integer by another integer amount        | Types must be integer, shift must be u8 |
+| !         |                     Bitwise not of a value                     |        Type must be integer or boolean |
+| \<         |       returns a bool if one value is less than the other       | Upper bound must have a known bit size |
+| \<=        | returns a bool if one value is less than or equal to the other | Upper bound must have a known bit size |
+| >         |       returns a bool if one value is more than the other       | Upper bound must have a known bit size |
+| >=        | returns a bool if one value is more than or equal to the other | Upper bound must have a known bit size |
+| ==        |       returns a bool if one value is equal to the other        |       Both types must not be constants |
+| !=        |     returns a bool if one value is not equal to the other      |       Both types must not be constants |
+
+### Predicate Operators
+
+`<,<=, !=, == , >, >=` are known as predicate/comparison operations because they compare two values.
+This differs from the operations such as `+` where the operands are used in _computation_.
+
+### Bitwise Operations Example
+
+```rust
+fn main(x : Field) {
+    let y = x as u32;
+    let z = y & y;
+}
+```
+
+`z` is implicitly constrained to be the result of `y & y`. The `&` operand is used to denote bitwise
+`&`.
+
+> `x & x` would not compile as `x` is a `Field` and not an integer type.
+
+### Logical Operators
+
+Noir has no support for the logical operators `||` and `&&`. This is because encoding the
+short-circuiting that these operators require can be inefficient for Noir's backend. Instead you can
+use the bitwise operators `|` and `&` which operate identically for booleans, just without the
+short-circuiting.
+
+```rust
+let my_val = 5;
+
+let mut flag = 1;
+if (my_val > 6) | (my_val == 0) {
+    flag = 0;
+}
+assert(flag == 1);
+
+if (my_val != 10) & (my_val < 50) {
+    flag = 0;
+}
+assert(flag == 0);
+```
+
+### Shorthand operators
+
+Noir shorthand operators for most of the above operators, namely `+=, -=, *=, /=, %=, &=, |=, ^=, <<=`, and `>>=`. These allow for more concise syntax. For example:
+
+```rust
+let mut i = 0;
+i = i + 1;
+```
+
+could be written as:
+
+```rust
+let mut i = 0;
+i += 1;
+```
diff --git a/docs/versioned_docs/version-v0.37.0/noir/concepts/oracles.mdx b/docs/versioned_docs/version-v0.37.0/noir/concepts/oracles.mdx
new file mode 100644
index 00000000000..77a2ac1550a
--- /dev/null
+++ b/docs/versioned_docs/version-v0.37.0/noir/concepts/oracles.mdx
@@ -0,0 +1,29 @@
+---
+title: Oracles
+description: Dive into how Noir supports Oracles via RPC calls, and learn how to declare an Oracle in Noir with our comprehensive guide.
+keywords:
+  - Noir
+  - Oracles
+  - RPC Calls
+  - Unconstrained Functions
+  - Programming
+  - Blockchain
+sidebar_position: 6
+---
+
+import Experimental from '@site/src/components/Notes/_experimental.mdx';
+
+<Experimental />
+
+Noir has support for Oracles via RPC calls. This means Noir will make an RPC call and use the return value for proof generation.
+
+Since Oracles are not resolved by Noir, they are [`unconstrained` functions](./unconstrained.md)
+
+You can declare an Oracle through the `#[oracle(<name>)]` flag. Example:
+
+```rust
+#[oracle(get_number_sequence)]
+unconstrained fn get_number_sequence(_size: Field) -> [Field] {}
+```
+
+The timeout for when using an external RPC oracle resolver can be set with the `NARGO_FOREIGN_CALL_TIMEOUT` environment variable. This timeout is in units of milliseconds.
diff --git a/docs/versioned_docs/version-v0.37.0/noir/concepts/shadowing.md b/docs/versioned_docs/version-v0.37.0/noir/concepts/shadowing.md
new file mode 100644
index 00000000000..5ce6130d201
--- /dev/null
+++ b/docs/versioned_docs/version-v0.37.0/noir/concepts/shadowing.md
@@ -0,0 +1,44 @@
+---
+title: Shadowing
+sidebar_position: 12
+---
+
+Noir allows for inheriting variables' values and re-declaring them with the same name similar to Rust, known as shadowing.
+
+For example, the following function is valid in Noir:
+
+```rust
+fn main() {
+    let x = 5;
+
+    {
+        let x = x * 2;
+        assert (x == 10);
+    }
+
+    assert (x == 5);
+}
+```
+
+In this example, a variable x is first defined with the value 5.
+
+The local scope that follows shadows the original x, i.e. creates a local mutable x based on the value of the original x. It is given a value of 2 times the original x.
+
+When we return to the main scope, x once again refers to just the original x, which stays at the value of 5.
+
+## Temporal mutability
+
+One way that shadowing is useful, in addition to ergonomics across scopes, is for temporarily mutating variables.
+
+```rust
+fn main() {
+    let age = 30;
+    // age = age + 5; // Would error as `age` is immutable by default.
+
+    let mut age = age + 5; // Temporarily mutates `age` with a new value.
+
+    let age = age; // Locks `age`'s mutability again.
+
+    assert (age == 35);
+}
+```
diff --git a/docs/versioned_docs/version-v0.37.0/noir/concepts/traits.md b/docs/versioned_docs/version-v0.37.0/noir/concepts/traits.md
new file mode 100644
index 00000000000..9da00a77587
--- /dev/null
+++ b/docs/versioned_docs/version-v0.37.0/noir/concepts/traits.md
@@ -0,0 +1,501 @@
+---
+title: Traits
+description:
+  Traits in Noir can be used to abstract out a common interface for functions across
+  several data types.
+keywords: [noir programming language, traits, interfaces, generic, protocol]
+sidebar_position: 14
+---
+
+## Overview
+
+Traits in Noir are a useful abstraction similar to interfaces or protocols in other languages. Each trait defines
+the interface of several methods contained within the trait. Types can then implement this trait by providing
+implementations for these methods. For example in the program:
+
+```rust
+struct Rectangle {
+    width: Field,
+    height: Field,
+}
+
+impl Rectangle {
+    fn area(self) -> Field {
+        self.width * self.height
+    }
+}
+
+fn log_area(r: Rectangle) {
+    println(r.area());
+}
+```
+
+We have a function `log_area` to log the area of a `Rectangle`. Now how should we change the program if we want this
+function to work on `Triangle`s as well?:
+
+```rust
+struct Triangle {
+    width: Field,
+    height: Field,
+}
+
+impl Triangle {
+    fn area(self) -> Field {
+        self.width * self.height / 2
+    }
+}
+```
+
+Making `log_area` generic over all types `T` would be invalid since not all types have an `area` method. Instead, we can
+introduce a new `Area` trait and make `log_area` generic over all types `T` that implement `Area`:
+
+```rust
+trait Area {
+    fn area(self) -> Field;
+}
+
+fn log_area<T>(shape: T) where T: Area {
+    println(shape.area());
+}
+```
+
+We also need to explicitly implement `Area` for `Rectangle` and `Triangle`. We can do that by changing their existing
+impls slightly. Note that the parameter types and return type of each of our `area` methods must match those defined
+by the `Area` trait.
+
+```rust
+impl Area for Rectangle {
+    fn area(self) -> Field {
+        self.width * self.height
+    }
+}
+
+impl Area for Triangle {
+    fn area(self) -> Field {
+        self.width * self.height / 2
+    }
+}
+```
+
+Now we have a working program that is generic over any type of Shape that is used! Others can even use this program
+as a library with their own types - such as `Circle` - as long as they also implement `Area` for these types.
+
+## Where Clauses
+
+As seen in `log_area` above, when we want to create a function or method that is generic over any type that implements
+a trait, we can add a where clause to the generic function.
+
+```rust
+fn log_area<T>(shape: T) where T: Area {
+    println(shape.area());
+}
+```
+
+It is also possible to apply multiple trait constraints on the same variable at once by combining traits with the `+`
+operator. Similarly, we can have multiple trait constraints by separating each with a comma:
+
+```rust
+fn foo<T, U>(elements: [T], thing: U) where
+    T: Default + Add + Eq,
+    U: Bar,
+{
+    let mut sum = T::default();
+
+    for element in elements {
+        sum += element;
+    }
+
+    if sum == T::default() {
+        thing.bar();
+    }
+}
+```
+
+## Generic Implementations
+
+You can add generics to a trait implementation by adding the generic list after the `impl` keyword:
+
+```rust
+trait Second {
+    fn second(self) -> Field;
+}
+
+impl<T> Second for (T, Field) {
+    fn second(self) -> Field {
+        self.1
+    }
+}
+```
+
+You can also implement a trait for every type this way:
+
+```rust
+trait Debug {
+    fn debug(self);
+}
+
+impl<T> Debug for T {
+    fn debug(self) {
+        println(self);
+    }
+}
+
+fn main() {
+    1.debug();
+}
+```
+
+### Generic Trait Implementations With Where Clauses
+
+Where clauses can be placed on trait implementations themselves to restrict generics in a similar way.
+For example, while `impl<T> Foo for T` implements the trait `Foo` for every type, `impl<T> Foo for T where T: Bar`
+will implement `Foo` only for types that also implement `Bar`. This is often used for implementing generic types.
+For example, here is the implementation for array equality:
+
+```rust
+impl<T, let N: u32> Eq for [T; let N: u32] where T: Eq {
+    // Test if two arrays have the same elements.
+    // Because both arrays must have length N, we know their lengths already match.
+    fn eq(self, other: Self) -> bool {
+        let mut result = true;
+
+        for i in 0 .. self.len() {
+            // The T: Eq constraint is needed to call == on the array elements here
+            result &= self[i] == other[i];
+        }
+
+        result
+    }
+}
+```
+
+Where clauses can also be placed on struct implementations. 
+For example, here is a method utilizing a generic type that implements the equality trait.
+
+```rust
+struct Foo<T> {
+    a: u32,
+    b: T,
+}
+
+impl<T> Foo<T> where T: Eq {
+    fn eq(self, other: Self) -> bool {
+        (self.a == other.a) & self.b.eq(other.b)
+    }
+}
+```
+
+## Generic Traits
+
+Traits themselves can also be generic by placing the generic arguments after the trait name. These generics are in
+scope of every item within the trait.
+
+```rust
+trait Into<T> {
+    // Convert `self` to type `T`
+    fn into(self) -> T;
+}
+```
+
+When implementing generic traits the generic arguments of the trait must be specified. This is also true anytime
+when referencing a generic trait (e.g. in a `where` clause).
+
+```rust
+struct MyStruct {
+    array: [Field; 2],
+}
+
+impl Into<[Field; 2]> for MyStruct {
+    fn into(self) -> [Field; 2] {
+        self.array
+    }
+}
+
+fn as_array<T>(x: T) -> [Field; 2] 
+    where T: Into<[Field; 2]>
+{
+    x.into()
+}
+
+fn main() {
+    let array = [1, 2];
+    let my_struct = MyStruct { array };
+
+    assert_eq(as_array(my_struct), array);
+}
+```
+
+### Associated Types and Constants
+
+Traits also support associated types and constraints which can be thought of as additional generics that are referred to by name.
+
+Here's an example of a trait with an associated type `Foo` and a constant `Bar`:
+
+```rust
+trait MyTrait {
+    type Foo;
+
+    let Bar: u32;
+}
+```
+
+Now when we're implementing `MyTrait` we also have to provide values for `Foo` and `Bar`:
+
+```rust
+impl MyTrait for Field {
+    type Foo = i32;
+
+    let Bar: u32 = 11;
+}
+```
+
+Since associated constants can also be used in a type position, its values are limited to only other
+expression kinds allowed in numeric generics.
+
+Note that currently all associated types and constants must be explicitly specified in a trait constraint.
+If we leave out any, we'll get an error that we're missing one:
+
+```rust
+// Error! Constraint is missing associated constant for `Bar`
+fn foo<T>(x: T) where T: MyTrait<Foo = i32> {
+    ...
+}
+```
+
+Because all associated types and constants must be explicitly specified, they are essentially named generics,
+although this is set to change in the future. Future versions of Noir will allow users to elide associated types
+in trait constraints similar to Rust. When this is done, you may still refer to their value with the `<Type as Trait>::AssociatedType`
+syntax:
+
+```rust
+// Only valid in future versions of Noir:
+fn foo<T>(x: T) where T: MyTrait {
+    let _: <T as MyTrait>::Foo = ...;
+}
+```
+
+The type as trait syntax is possible in Noir today but is less useful when each type must be explicitly specified anyway:
+
+```rust
+fn foo<T, F, let B: u32>(x: T) where T: MyTrait<Foo = F, Bar = B> {
+    // Works, but could just use F directly
+    let _: <T as MyTrait<Foo = F, Bar = B>>::Foo = ...;
+
+    let _: F = ...;
+}
+```
+
+## Trait Methods With No `self`
+
+A trait can contain any number of methods, each of which have access to the `Self` type which represents each type
+that eventually implements the trait. Similarly, the `self` variable is available as well but is not required to be used.
+For example, we can define a trait to create a default value for a type. This trait will need to return the `Self` type
+but doesn't need to take any parameters:
+
+```rust
+trait Default {
+    fn default() -> Self;
+}
+```
+
+Implementing this trait can be done similarly to any other trait:
+
+```rust
+impl Default for Field {
+    fn default() -> Field {
+        0
+    }
+}
+
+struct MyType {}
+
+impl Default for MyType {
+    fn default() -> Field {
+        MyType {}
+    }
+}
+```
+
+However, since there is no `self` parameter, we cannot call it via the method call syntax `object.method()`.
+Instead, we'll need to refer to the function directly. This can be done either by referring to the
+specific impl `MyType::default()` or referring to the trait itself `Default::default()`. In the later
+case, type inference determines the impl that is selected.
+
+```rust
+let my_struct = MyStruct::default();
+
+let x: Field = Default::default();
+let result = x + Default::default();
+```
+
+:::warning
+
+```rust
+let _ = Default::default();
+```
+
+If type inference cannot select which impl to use because of an ambiguous `Self` type, an impl will be
+arbitrarily selected. This occurs most often when the result of a trait function call with no parameters
+is unused. To avoid this, when calling a trait function with no `self` or `Self` parameters or return type,
+always refer to it via the implementation type's namespace - e.g. `MyType::default()`.
+This is set to change to an error in future Noir versions.
+
+:::
+
+## Default Method Implementations
+
+A trait can also have default implementations of its methods by giving a body to the desired functions.
+Note that this body must be valid for all types that may implement the trait. As a result, the only
+valid operations on `self` will be operations valid for any type or other operations on the trait itself.
+
+```rust
+trait Numeric {
+    fn add(self, other: Self) -> Self;
+
+    // Default implementation of double is (self + self)
+    fn double(self) -> Self {
+        self.add(self)
+    }
+}
+```
+
+When implementing a trait with default functions, a type may choose to implement only the required functions:
+
+```rust
+impl Numeric for Field {
+    fn add(self, other: Field) -> Field {
+        self + other
+    }
+}
+```
+
+Or it may implement the optional methods as well:
+
+```rust
+impl Numeric for u32 {
+    fn add(self, other: u32) -> u32 {
+        self + other
+    }
+
+    fn double(self) -> u32 {
+        self * 2
+    }
+}
+```
+
+## Impl Specialization
+
+When implementing traits for a generic type it is possible to implement the trait for only a certain combination
+of generics. This can be either as an optimization or because those specific generics are required to implement the trait.
+
+```rust
+trait Sub {
+    fn sub(self, other: Self) -> Self;
+}
+
+struct NonZero<T> {
+    value: T,
+}
+
+impl Sub for NonZero<Field> {
+    fn sub(self, other: Self) -> Self {
+        let value = self.value - other.value;
+        assert(value != 0);
+        NonZero { value }
+    }
+}
+```
+
+## Overlapping Implementations
+
+Overlapping implementations are disallowed by Noir to ensure Noir's decision on which impl to select is never ambiguous.
+This means if a trait `Foo` is already implemented
+by a type `Bar<T>` for all `T`, then we cannot also have a separate impl for `Bar<Field>` (or any other
+type argument). Similarly, if there is an impl for all `T` such as `impl<T> Debug for T`, we cannot create
+any more impls to `Debug` for other types since it would be ambiguous which impl to choose for any given
+method call.
+
+```rust
+trait Trait {}
+
+// Previous impl defined here
+impl<A, B> Trait for (A, B) {}
+
+// error: Impl for type `(Field, Field)` overlaps with existing impl
+impl Trait for (Field, Field) {}
+```
+
+## Trait Coherence
+
+Another restriction on trait implementations is coherence. This restriction ensures other crates cannot create
+impls that may overlap with other impls, even if several unrelated crates are used as dependencies in the same
+program.
+
+The coherence restriction is: to implement a trait, either the trait itself or the object type must be declared
+in the crate the impl is in.
+
+In practice this often comes up when using types provided by libraries. If a library provides a type `Foo` that does
+not implement a trait in the standard library such as `Default`, you may not `impl Default for Foo` in your own crate.
+While restrictive, this prevents later issues or silent changes in the program if the `Foo` library later added its
+own impl for `Default`. If you are a user of the `Foo` library in this scenario and need a trait not implemented by the
+library your choices are to either submit a patch to the library or use the newtype pattern.
+
+### The Newtype Pattern
+
+The newtype pattern gets around the coherence restriction by creating a new wrapper type around the library type
+that we cannot create `impl`s for. Since the new wrapper type is defined in our current crate, we can create
+impls for any trait we need on it.
+
+```rust
+struct Wrapper {
+    foo: some_library::Foo,
+}
+
+impl Default for Wrapper {
+    fn default() -> Wrapper {
+        Wrapper {
+            foo: some_library::Foo::new(),
+        }
+    }
+}
+```
+
+Since we have an impl for our own type, the behavior of this code will not change even if `some_library` is updated
+to provide its own `impl Default for Foo`. The downside of this pattern is that it requires extra wrapping and
+unwrapping of values when converting to and from the `Wrapper` and `Foo` types.
+
+### Trait Inheritance
+
+Sometimes, you might need one trait to use another trait’s functionality (like "inheritance" in some other languages). In this case, you can specify this relationship by listing any child traits after the parent trait's name and a colon. Now, whenever the parent trait is implemented it will require the child traits to be implemented as well. A parent trait is also called a "super trait."
+
+```rust
+trait Person {
+    fn name(self) -> String;
+}
+
+// Person is a supertrait of Student.
+// Implementing Student requires you to also impl Person.
+trait Student: Person {
+    fn university(self) -> String;
+}
+
+trait Programmer {
+    fn fav_language(self) -> String;
+}
+
+// CompSciStudent (computer science student) is a subtrait of both Programmer 
+// and Student. Implementing CompSciStudent requires you to impl both supertraits.
+trait CompSciStudent: Programmer + Student {
+    fn git_username(self) -> String;
+}
+```
+
+### Visibility
+
+By default, like functions, traits are private to the module they exist in. You can use `pub`
+to make the trait public or `pub(crate)` to make it public to just its crate:
+
+```rust
+// This trait is now public
+pub trait Trait {}
+```
\ No newline at end of file
diff --git a/docs/versioned_docs/version-v0.37.0/noir/concepts/unconstrained.md b/docs/versioned_docs/version-v0.37.0/noir/concepts/unconstrained.md
new file mode 100644
index 00000000000..b5221b8d2dd
--- /dev/null
+++ b/docs/versioned_docs/version-v0.37.0/noir/concepts/unconstrained.md
@@ -0,0 +1,104 @@
+---
+title: Unconstrained Functions
+description: "Learn about what unconstrained functions in Noir are, how to use them and when you'd want to."
+
+keywords: [Noir programming language, unconstrained, open]
+sidebar_position: 5
+---
+
+Unconstrained functions are functions which do not constrain any of the included computation and allow for non-deterministic computation.
+
+## Why?
+
+Zero-knowledge (ZK) domain-specific languages (DSL) enable developers to generate ZK proofs from their programs by compiling code down to the constraints of an NP complete language (such as R1CS or PLONKish languages). However, the hard bounds of a constraint system can be very limiting to the functionality of a ZK DSL.
+
+Enabling a circuit language to perform unconstrained execution is a powerful tool. Said another way, unconstrained execution lets developers generate witnesses from code that does not generate any constraints. Being able to execute logic outside of a circuit is critical for both circuit performance and constructing proofs on information that is external to a circuit.
+
+Fetching information from somewhere external to a circuit can also be used to enable developers to improve circuit efficiency.
+
+A ZK DSL does not just prove computation, but proves that some computation was handled correctly. Thus, it is necessary that when we switch from performing some operation directly inside of a circuit to inside of an unconstrained environment that the appropriate constraints are still laid down elsewhere in the circuit.
+
+## Example
+
+An in depth example might help drive the point home. This example comes from the excellent [post](https://discord.com/channels/1113924620781883405/1124022445054111926/1128747641853972590) by Tom in the Noir Discord.
+
+Let's look at how we can optimize a function to turn a `u72` into an array of `u8`s.
+
+```rust
+fn main(num: u72) -> pub [u8; 8] {
+    let mut out: [u8; 8] = [0; 8];
+    for i in 0..8 {
+        out[i] = (num >> (56 - (i * 8)) as u72 & 0xff) as u8;
+    }
+
+    out
+}
+```
+
+```
+Total ACIR opcodes generated for language PLONKCSat { width: 3 }: 91
+Backend circuit size: 3619
+```
+
+A lot of the operations in this function are optimized away by the compiler (all the bit-shifts turn into divisions by constants). However we can save a bunch of gates by casting to u8 a bit earlier. This automatically truncates the bit-shifted value to fit in a u8 which allows us to remove the AND against 0xff. This saves us ~480 gates in total.
+
+```rust
+fn main(num: u72) -> pub [u8; 8] {
+    let mut out: [u8; 8] = [0; 8];
+    for i in 0..8 {
+        out[i] = (num >> (56 - (i * 8)) as u8;
+    }
+
+    out
+}
+```
+
+```
+Total ACIR opcodes generated for language PLONKCSat { width: 3 }: 75
+Backend circuit size: 3143
+```
+
+Those are some nice savings already but we can do better. This code is all constrained so we're proving every step of calculating out using num, but we don't actually care about how we calculate this, just that it's correct. This is where brillig comes in.
+
+It turns out that truncating a u72 into a u8 is hard to do inside a snark, each time we do as u8 we lay down 4 ACIR opcodes which get converted into multiple gates. It's actually much easier to calculate num from out than the other way around. All we need to do is multiply each element of out by a constant and add them all together, both relatively easy operations inside a snark.
+
+We can then run `u72_to_u8` as unconstrained brillig code in order to calculate out, then use that result in our constrained function and assert that if we were to do the reverse calculation we'd get back num. This looks a little like the below:
+
+```rust
+fn main(num: u72) -> pub [u8; 8] {
+    let out = unsafe { 
+        u72_to_u8(num) 
+    };
+
+    let mut reconstructed_num: u72 = 0;
+    for i in 0..8 {
+        reconstructed_num += (out[i] as u72 << (56 - (8 * i)));
+    }
+    assert(num == reconstructed_num);
+    out
+}
+
+unconstrained fn u72_to_u8(num: u72) -> [u8; 8] {
+    let mut out: [u8; 8] = [0; 8];
+    for i in 0..8 {
+        out[i] = (num >> (56 - (i * 8))) as u8;
+    }
+    out
+}
+```
+
+```
+Total ACIR opcodes generated for language PLONKCSat { width: 3 }: 78
+Backend circuit size: 2902
+```
+
+This ends up taking off another ~250 gates from our circuit! We've ended up with more ACIR opcodes than before but they're easier for the backend to prove (resulting in fewer gates).
+
+Note that in order to invoke unconstrained functions we need to wrap them in an `unsafe` block,
+to make it clear that the call is unconstrained.
+
+Generally we want to use brillig whenever there's something that's easy to verify but hard to compute within the circuit. For example, if you wanted to calculate a square root of a number it'll be a much better idea to calculate this in brillig and then assert that if you square the result you get back your number.
+
+## Break and Continue
+
+In addition to loops over runtime bounds, `break` and `continue` are also available in unconstrained code. See [break and continue](../concepts/control_flow.md#break-and-continue)
diff --git a/docs/versioned_docs/version-v0.37.0/noir/modules_packages_crates/_category_.json b/docs/versioned_docs/version-v0.37.0/noir/modules_packages_crates/_category_.json
new file mode 100644
index 00000000000..1debcfe7675
--- /dev/null
+++ b/docs/versioned_docs/version-v0.37.0/noir/modules_packages_crates/_category_.json
@@ -0,0 +1,6 @@
+{
+    "label": "Modules, Packages and Crates",
+    "position": 2,
+    "collapsible": true,
+    "collapsed": true
+}
diff --git a/docs/versioned_docs/version-v0.37.0/noir/modules_packages_crates/crates_and_packages.md b/docs/versioned_docs/version-v0.37.0/noir/modules_packages_crates/crates_and_packages.md
new file mode 100644
index 00000000000..95ee9f52ab2
--- /dev/null
+++ b/docs/versioned_docs/version-v0.37.0/noir/modules_packages_crates/crates_and_packages.md
@@ -0,0 +1,43 @@
+---
+title: Crates and Packages
+description: Learn how to use Crates and Packages in your Noir project
+keywords: [Nargo, dependencies, package management, crates, package]
+sidebar_position: 0
+---
+
+## Crates
+
+A crate is the smallest amount of code that the Noir compiler considers at a time.
+Crates can contain modules, and the modules may be defined in other files that get compiled with the crate, as we’ll see in the coming sections.
+
+### Crate Types
+
+A Noir crate can come in several forms: binaries, libraries or contracts.
+
+#### Binaries
+
+_Binary crates_ are programs which you can compile to an ACIR circuit which you can then create proofs against. Each must have a function called `main` that defines the ACIR circuit which is to be proved.
+
+#### Libraries
+
+_Library crates_ don't have a `main` function and they don't compile down to ACIR. Instead they define functionality intended to be shared with multiple projects, and eventually included in a binary crate.
+
+#### Contracts
+
+Contract crates are similar to binary crates in that they compile to ACIR which you can create proofs against. They are different in that they do not have a single `main` function, but are a collection of functions to be deployed to the [Aztec network](https://aztec.network). You can learn more about the technical details of Aztec in the [monorepo](https://github.com/AztecProtocol/aztec-packages) or contract [examples](https://github.com/AztecProtocol/aztec-packages/tree/master/noir-projects/noir-contracts/contracts).
+
+### Crate Root
+
+Every crate has a root, which is the source file that the compiler starts, this is also known as the root module. The Noir compiler does not enforce any conditions on the name of the file which is the crate root, however if you are compiling via Nargo the crate root must be called `lib.nr` or `main.nr` for library or binary crates respectively.
+
+## Packages
+
+A Nargo _package_ is a collection of one of more crates that provides a set of functionality. A package must include a Nargo.toml file.
+
+A package _must_ contain either a library or a binary crate, but not both.
+
+### Differences from Cargo Packages
+
+One notable difference between Rust's Cargo and Noir's Nargo is that while Cargo allows a package to contain an unlimited number of binary crates and a single library crate, Nargo currently only allows a package to contain a single crate.
+
+In future this restriction may be lifted to allow a Nargo package to contain both a binary and library crate or multiple binary crates.
diff --git a/docs/versioned_docs/version-v0.37.0/noir/modules_packages_crates/dependencies.md b/docs/versioned_docs/version-v0.37.0/noir/modules_packages_crates/dependencies.md
new file mode 100644
index 00000000000..24e02de08fe
--- /dev/null
+++ b/docs/versioned_docs/version-v0.37.0/noir/modules_packages_crates/dependencies.md
@@ -0,0 +1,124 @@
+---
+title: Dependencies
+description:
+  Learn how to specify and manage dependencies in Nargo, allowing you to upload packages to GitHub
+  and use them easily in your project.
+keywords: [Nargo, dependencies, GitHub, package management, versioning]
+sidebar_position: 1
+---
+
+Nargo allows you to upload packages to GitHub and use them as dependencies.
+
+## Specifying a dependency
+
+Specifying a dependency requires a tag to a specific commit and the git url to the url containing
+the package.
+
+Currently, there are no requirements on the tag contents. If requirements are added, it would follow
+semver 2.0 guidelines.
+
+> Note: Without a `tag` , there would be no versioning and dependencies would change each time you
+> compile your project.
+
+For example, to add the [ecrecover-noir library](https://github.com/colinnielsen/ecrecover-noir) to your project, add it to `Nargo.toml`:
+
+```toml
+# Nargo.toml
+
+[dependencies]
+ecrecover = {tag = "v0.8.0", git = "https://github.com/colinnielsen/ecrecover-noir"}
+```
+
+If the module is in a subdirectory, you can define a subdirectory in your git repository, for example:
+
+```toml
+# Nargo.toml
+
+[dependencies]
+easy_private_token_contract = {tag ="v0.1.0-alpha62", git = "https://github.com/AztecProtocol/aztec-packages", directory = "noir-contracts/contracts/easy_private_token_contract"}
+```
+
+## Specifying a local dependency
+
+You can also specify dependencies that are local to your machine.
+
+For example, this file structure has a library and binary crate
+
+```tree
+├── binary_crate
+│   ├── Nargo.toml
+│   └── src
+│       └── main.nr
+└── lib_a
+    ├── Nargo.toml
+    └── src
+        └── lib.nr
+```
+
+Inside of the binary crate, you can specify:
+
+```toml
+# Nargo.toml
+
+[dependencies]
+lib_a = { path = "../lib_a" }
+```
+
+## Importing dependencies
+
+You can import a dependency to a Noir file using the following syntax. For example, to import the
+ecrecover-noir library and local lib_a referenced above:
+
+```rust
+use ecrecover;
+use lib_a;
+```
+
+You can also import only the specific parts of dependency that you want to use, like so:
+
+```rust
+use std::hash::sha256;
+use std::scalar_mul::fixed_base_embedded_curve;
+```
+
+Lastly, as demonstrated in the
+[elliptic curve example](../standard_library/cryptographic_primitives/ec_primitives.md#examples), you
+can import multiple items in the same line by enclosing them in curly braces:
+
+```rust
+use std::ec::tecurve::affine::{Curve, Point};
+```
+
+We don't have a way to consume libraries from inside a [workspace](./workspaces.md) as external dependencies right now.
+
+Inside a workspace, these are consumed as `{ path = "../to_lib" }` dependencies in Nargo.toml.
+
+## Dependencies of Dependencies
+
+Note that when you import a dependency, you also get access to all of the dependencies of that package.
+
+For example, the [phy_vector](https://github.com/resurgencelabs/phy_vector) library imports an [fraction](https://github.com/resurgencelabs/fraction) library. If you're importing the phy_vector library, then you can access the functions in fractions library like so:
+
+```rust
+use phy_vector;
+
+fn main(x : Field, y : pub Field) {
+  //...
+  let f = phy_vector::fraction::toFraction(true, 2, 1);
+  //...
+}
+```
+
+## Available Libraries
+
+Noir does not currently have an official package manager. You can find a list of available Noir libraries in the [awesome-noir repo here](https://github.com/noir-lang/awesome-noir#libraries).
+
+Some libraries that are available today include:
+
+- [Standard Library](https://github.com/noir-lang/noir/tree/master/noir_stdlib) - the Noir Standard Library
+- [Ethereum Storage Proof Verification](https://github.com/aragonzkresearch/noir-trie-proofs) - a library that contains the primitives necessary for RLP decoding (in the form of look-up table construction) and Ethereum state and storage proof verification (or verification of any trie proof involving 32-byte long keys)
+- [BigInt](https://github.com/shuklaayush/noir-bigint) - a library that provides a custom BigUint56 data type, allowing for computations on large unsigned integers
+- [ECrecover](https://github.com/colinnielsen/ecrecover-noir/tree/main) - a library to verify an ECDSA signature and return the source Ethereum address
+- [Sparse Merkle Tree Verifier](https://github.com/vocdoni/smtverifier-noir/tree/main) - a library for verification of sparse Merkle trees
+- [Signed Int](https://github.com/resurgencelabs/signed_int) - a library for accessing a custom Signed Integer data type, allowing access to negative numbers on Noir
+- [Fraction](https://github.com/resurgencelabs/fraction) - a library for accessing fractional number data type in Noir, allowing results that aren't whole numbers
diff --git a/docs/versioned_docs/version-v0.37.0/noir/modules_packages_crates/modules.md b/docs/versioned_docs/version-v0.37.0/noir/modules_packages_crates/modules.md
new file mode 100644
index 00000000000..14aa1f0579a
--- /dev/null
+++ b/docs/versioned_docs/version-v0.37.0/noir/modules_packages_crates/modules.md
@@ -0,0 +1,221 @@
+---
+title: Modules
+description:
+  Learn how to organize your files using modules in Noir, following the same convention as Rust's
+  module system. Examples included.
+keywords: [Noir, Rust, modules, organizing files, sub-modules]
+sidebar_position: 2
+---
+
+Noir's module system follows the same convention as the _newer_ version of Rust's module system.
+
+## Purpose of Modules
+
+Modules are used to organize files. Without modules all of your code would need to live in a single
+file. In Noir, the compiler does not automatically scan all of your files to detect modules. This
+must be done explicitly by the developer.
+
+## Examples
+
+### Importing a module in the crate root
+
+Filename : `src/main.nr`
+
+```rust
+mod foo;
+
+fn main() {
+    foo::hello_world();
+}
+```
+
+Filename : `src/foo.nr`
+
+```rust
+fn from_foo() {}
+```
+
+In the above snippet, the crate root is the `src/main.nr` file. The compiler sees the module
+declaration `mod foo` which prompts it to look for a foo.nr file.
+
+Visually this module hierarchy looks like the following :
+
+```
+crate
+ ├── main
+ │
+ └── foo
+      └── from_foo
+
+```
+
+The module filename may also be the name of the module as a directory with the contents in a 
+file named `mod.nr` within that directory. The above example can alternatively be expressed like this:
+
+Filename : `src/main.nr`
+
+```rust
+mod foo;
+
+fn main() {
+    foo::hello_world();
+}
+```
+
+Filename : `src/foo/mod.nr`
+
+```rust
+fn from_foo() {}
+```
+
+Note that it's an error to have both files `src/foo.nr` and `src/foo/mod.nr` in the filesystem.
+
+### Importing a module throughout the tree
+
+All modules are accessible from the `crate::` namespace.
+
+```
+crate
+ ├── bar
+ ├── foo
+ └── main
+
+```
+
+In the above snippet, if `bar` would like to use functions in `foo`, it can do so by `use crate::foo::function_name`.
+
+### Sub-modules
+
+Filename : `src/main.nr`
+
+```rust
+mod foo;
+
+fn main() {
+    foo::from_foo();
+}
+```
+
+Filename : `src/foo.nr`
+
+```rust
+mod bar;
+fn from_foo() {}
+```
+
+Filename : `src/foo/bar.nr`
+
+```rust
+fn from_bar() {}
+```
+
+In the above snippet, we have added an extra module to the module tree; `bar`. `bar` is a submodule
+of `foo` hence we declare bar in `foo.nr` with `mod bar`. Since `foo` is not the crate root, the
+compiler looks for the file associated with the `bar` module in `src/foo/bar.nr`
+
+Visually the module hierarchy looks as follows:
+
+```
+crate
+ ├── main
+ │
+ └── foo
+      ├── from_foo
+      └── bar
+           └── from_bar
+```
+
+Similar to importing a module in the crate root, modules can be placed in a `mod.nr` file, like this:
+
+Filename : `src/main.nr`
+
+```rust
+mod foo;
+
+fn main() {
+    foo::from_foo();
+}
+```
+
+Filename : `src/foo/mod.nr`
+
+```rust
+mod bar;
+fn from_foo() {}
+```
+
+Filename : `src/foo/bar/mod.nr`
+
+```rust
+fn from_bar() {}
+```
+
+### Referencing a parent module 
+
+Given a submodule, you can refer to its parent module using the `super` keyword.
+
+Filename : `src/main.nr`
+
+```rust
+mod foo;
+
+fn main() {
+    foo::from_foo();
+}
+```
+
+Filename : `src/foo.nr`
+
+```rust
+mod bar;
+
+fn from_foo() {}
+```
+
+Filename : `src/foo/bar.nr`
+
+```rust
+// Same as bar::from_foo
+use super::from_foo; 
+
+fn from_bar() {
+    from_foo();        // invokes super::from_foo(), which is bar::from_foo()
+    super::from_foo(); // also invokes bar::from_foo()
+}
+```
+
+### `use` visibility
+
+`use` declarations are private to the containing module, by default. However, like functions, 
+they can be marked as `pub` or `pub(crate)`. Such a use declaration serves to _re-export_ a name. 
+A public `use` declaration can therefore redirect some public name to a different target definition: 
+even a definition with a private canonical path, inside a different module.
+
+An example of re-exporting:
+
+```rust
+mod some_module {
+    pub use foo::{bar, baz};
+    mod foo {
+        pub fn bar() {}
+        pub fn baz() {}
+    }
+}
+
+fn main() {
+    some_module::bar();
+    some_module::baz();
+}
+```
+
+In this example, the module `some_module` re-exports two public names defined in `foo`.
+
+### Visibility
+
+By default, like functions, modules are private to the module (or crate) they exist in. You can use `pub`
+to make the module public or `pub(crate)` to make it public to just its crate:
+
+```rust
+// This module is now public and can be seen by other crates.
+pub mod foo;
+```
\ No newline at end of file
diff --git a/docs/versioned_docs/version-v0.37.0/noir/modules_packages_crates/workspaces.md b/docs/versioned_docs/version-v0.37.0/noir/modules_packages_crates/workspaces.md
new file mode 100644
index 00000000000..513497f12bf
--- /dev/null
+++ b/docs/versioned_docs/version-v0.37.0/noir/modules_packages_crates/workspaces.md
@@ -0,0 +1,42 @@
+---
+title: Workspaces
+sidebar_position: 3
+---
+
+Workspaces are a feature of nargo that allow you to manage multiple related Noir packages in a single repository. A workspace is essentially a group of related projects that share common build output directories and configurations.
+
+Each Noir project (with it's own Nargo.toml file) can be thought of as a package. Each package is expected to contain exactly one "named circuit", being the "name" defined in Nargo.toml with the program logic defined in `./src/main.nr`.
+
+For a project with the following structure:
+
+```tree
+├── crates
+│   ├── a
+│   │   ├── Nargo.toml
+│   │   └── Prover.toml
+│   │   └── src
+│   │       └── main.nr
+│   └── b
+│       ├── Nargo.toml
+│       └── Prover.toml
+│       └── src
+│           └── main.nr
+│
+└── Nargo.toml
+```
+
+You can define a workspace in Nargo.toml like so:
+
+```toml
+[workspace]
+members = ["crates/a", "crates/b"]
+default-member = "crates/a"
+```
+
+`members` indicates which packages are included in the workspace. As such, all member packages of a workspace will be processed when the `--workspace` flag is used with various commands or if a `default-member` is not specified.
+
+`default-member` indicates which package various commands process by default.
+
+Libraries can be defined in a workspace. Inside a workspace, these are consumed as `{ path = "../to_lib" }` dependencies in Nargo.toml.
+
+Inside a workspace, these are consumed as `{ path = "../to_lib" }` dependencies in Nargo.toml.
diff --git a/docs/versioned_docs/version-v0.37.0/noir/standard_library/_category_.json b/docs/versioned_docs/version-v0.37.0/noir/standard_library/_category_.json
new file mode 100644
index 00000000000..af04c0933fd
--- /dev/null
+++ b/docs/versioned_docs/version-v0.37.0/noir/standard_library/_category_.json
@@ -0,0 +1,6 @@
+{
+    "label": "Standard Library",
+    "position": 1,
+    "collapsible": true,
+    "collapsed": true
+}
diff --git a/docs/versioned_docs/version-v0.37.0/noir/standard_library/bigint.md b/docs/versioned_docs/version-v0.37.0/noir/standard_library/bigint.md
new file mode 100644
index 00000000000..05c3011634f
--- /dev/null
+++ b/docs/versioned_docs/version-v0.37.0/noir/standard_library/bigint.md
@@ -0,0 +1,127 @@
+---
+title: Big Integers
+description: How to use big integers from Noir standard library
+keywords:
+  [
+    Big Integer,
+    Noir programming language,
+    Noir libraries,
+  ]
+---
+
+The BigInt module in the standard library exposes some class of integers which do not fit (well) into a Noir native field. It implements modulo arithmetic, modulo a 'big' prime number.
+
+:::note
+
+The module can currently be considered as `Field`s with fixed modulo sizes used by a set of elliptic curves, in addition to just the native curve. [More work](https://github.com/noir-lang/noir/issues/510) is needed to achieve arbitrarily sized big integers.
+
+:::note
+
+`nargo` can be built with `--profile release-pedantic` to enable extra overflow checks which may affect `BigInt` results in some cases.
+Consider the [`noir-bignum`](https://github.com/noir-lang/noir-bignum) library for an optimized alternative approach.
+
+:::
+
+Currently 6 classes of integers (i.e 'big' prime numbers) are available in the module, namely:
+
+- BN254 Fq: Bn254Fq
+- BN254 Fr: Bn254Fr
+- Secp256k1 Fq: Secpk1Fq
+- Secp256k1 Fr: Secpk1Fr
+- Secp256r1 Fr: Secpr1Fr
+- Secp256r1 Fq: Secpr1Fq
+
+Where XXX Fq and XXX Fr denote respectively the order of the base and scalar field of the (usual) elliptic curve XXX.
+For instance the big integer 'Secpk1Fq' in the standard library refers to integers modulo $2^{256}-2^{32}-977$.
+
+Feel free to explore the source code for the other primes:
+
+```rust title="big_int_definition" showLineNumbers 
+pub struct BigInt {
+    pointer: u32,
+    modulus: u32,
+}
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/bigint.nr#L28-L33" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/bigint.nr#L28-L33</a></sub></sup>
+
+
+## Example usage
+
+A common use-case is when constructing a big integer from its bytes representation, and performing arithmetic operations on it:
+
+```rust title="big_int_example" showLineNumbers 
+fn big_int_example(x: u8, y: u8) {
+    let a = Secpk1Fq::from_le_bytes(&[x, y, 0, 45, 2]);
+    let b = Secpk1Fq::from_le_bytes(&[y, x, 9]);
+    let c = (a + b) * b / a;
+    let d = c.to_le_bytes();
+    println(d[0]);
+}
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/test_programs/execution_success/bigint/src/main.nr#L74-L82" target="_blank" rel="noopener noreferrer">Source code: test_programs/execution_success/bigint/src/main.nr#L74-L82</a></sub></sup>
+
+
+## Methods
+
+The available operations for each big integer are:
+
+### from_le_bytes
+
+Construct a big integer from its little-endian bytes representation. Example:
+
+```rust
+ // Construct a big integer from a slice of bytes
+ let a = Secpk1Fq::from_le_bytes(&[x, y, 0, 45, 2]);
+ // Construct a big integer from an array of 32 bytes
+ let a = Secpk1Fq::from_le_bytes_32([1;32]);
+ ```
+
+Sure, here's the formatted version of the remaining methods:
+
+### to_le_bytes
+
+Return the little-endian bytes representation of a big integer. Example:
+
+```rust
+let bytes = a.to_le_bytes();
+```
+
+### add
+
+Add two big integers. Example:
+
+```rust
+let sum = a + b;
+```
+
+### sub
+
+Subtract two big integers. Example:
+
+```rust
+let difference = a - b;
+```
+
+### mul
+
+Multiply two big integers. Example:
+
+```rust
+let product = a * b;
+```
+
+### div
+
+Divide two big integers. Note that division is field division and not euclidean division. Example:
+
+```rust
+let quotient = a / b;
+```
+
+### eq
+
+Compare two big integers. Example:
+
+```rust
+let are_equal = a == b;
+```
diff --git a/docs/versioned_docs/version-v0.37.0/noir/standard_library/black_box_fns.md b/docs/versioned_docs/version-v0.37.0/noir/standard_library/black_box_fns.md
new file mode 100644
index 00000000000..d6079ab182c
--- /dev/null
+++ b/docs/versioned_docs/version-v0.37.0/noir/standard_library/black_box_fns.md
@@ -0,0 +1,32 @@
+---
+title: Black Box Functions
+description: Black box functions are functions in Noir that rely on backends implementing support for specialized constraints.
+keywords: [noir, black box functions]
+---
+
+Black box functions are functions in Noir that rely on backends implementing support for specialized constraints. This makes certain zk-snark unfriendly computations cheaper than if they were implemented in Noir.
+
+The ACVM spec defines a set of blackbox functions which backends will be expected to implement. This allows backends to use optimized implementations of these constraints if they have them, however they may also fallback to less efficient naive implementations if not.
+
+## Function list
+
+Here is a list of the current black box functions:
+
+- [AES128](./cryptographic_primitives/ciphers.mdx#aes128)
+- [SHA256](./cryptographic_primitives/hashes.mdx#sha256)
+- [Schnorr signature verification](./cryptographic_primitives/schnorr.mdx)
+- [Blake2s](./cryptographic_primitives/hashes.mdx#blake2s)
+- [Blake3](./cryptographic_primitives/hashes.mdx#blake3)
+- [Pedersen Hash](./cryptographic_primitives/hashes.mdx#pedersen_hash)
+- [Pedersen Commitment](./cryptographic_primitives/hashes.mdx#pedersen_commitment)
+- [ECDSA signature verification](./cryptographic_primitives/ecdsa_sig_verification.mdx)
+- [Embedded curve operations (MSM, addition, ...)](./cryptographic_primitives/embedded_curve_ops.mdx)
+- AND
+- XOR
+- RANGE
+- [Keccak256](./cryptographic_primitives/hashes.mdx#keccak256)
+- [Recursive proof verification](./recursion.mdx)
+
+Most black box functions are included as part of the Noir standard library, however `AND`, `XOR` and `RANGE` are used as part of the Noir language syntax. For instance, using the bitwise operator `&` will invoke the `AND` black box function.
+
+You can view the black box functions defined in the ACVM code [here](https://github.com/noir-lang/noir/blob/master/acvm-repo/acir/src/circuit/black_box_functions.rs).
diff --git a/docs/versioned_docs/version-v0.37.0/noir/standard_library/bn254.md b/docs/versioned_docs/version-v0.37.0/noir/standard_library/bn254.md
new file mode 100644
index 00000000000..3294f005dbb
--- /dev/null
+++ b/docs/versioned_docs/version-v0.37.0/noir/standard_library/bn254.md
@@ -0,0 +1,46 @@
+---
+title: Bn254 Field Library
+---
+
+Noir provides a module in standard library with some optimized functions for bn254 Fr in `std::field::bn254`.
+
+## decompose
+
+```rust
+fn decompose(x: Field) -> (Field, Field) {}
+```
+
+Decomposes a single field into two fields, low and high. The low field contains the lower 16 bytes of the input field and the high field contains the upper 16 bytes of the input field. Both field results are range checked to 128 bits.
+
+
+## assert_gt
+
+```rust
+fn assert_gt(a: Field, b: Field) {}
+```
+
+Asserts that a > b. This will generate less constraints than using `assert(gt(a, b))`.
+
+## assert_lt
+
+```rust
+fn assert_lt(a: Field, b: Field) {}
+```
+
+Asserts that a < b. This will generate less constraints than using `assert(lt(a, b))`.
+
+## gt
+
+```rust
+fn gt(a: Field, b: Field) -> bool  {}
+```
+
+Returns true if a > b.
+
+## lt
+
+```rust
+fn lt(a: Field, b: Field) -> bool  {}
+```
+
+Returns true if a < b.
\ No newline at end of file
diff --git a/docs/versioned_docs/version-v0.37.0/noir/standard_library/containers/boundedvec.md b/docs/versioned_docs/version-v0.37.0/noir/standard_library/containers/boundedvec.md
new file mode 100644
index 00000000000..509b214bf3a
--- /dev/null
+++ b/docs/versioned_docs/version-v0.37.0/noir/standard_library/containers/boundedvec.md
@@ -0,0 +1,419 @@
+---
+title: Bounded Vectors
+keywords: [noir, vector, bounded vector, slice]
+sidebar_position: 1
+---
+
+A `BoundedVec<T, MaxLen>` is a growable storage similar to a `Vec<T>` except that it
+is bounded with a maximum possible length. Unlike `Vec`, `BoundedVec` is not implemented
+via slices and thus is not subject to the same restrictions slices are (notably, nested
+slices - and thus nested vectors as well - are disallowed).
+
+Since a BoundedVec is backed by a normal array under the hood, growing the BoundedVec by
+pushing an additional element is also more efficient - the length only needs to be increased
+by one.
+
+For these reasons `BoundedVec<T, N>` should generally be preferred over `Vec<T>` when there
+is a reasonable maximum bound that can be placed on the vector.
+
+Example:
+
+```rust
+let mut vector: BoundedVec<Field, 10> = BoundedVec::new();
+for i in 0..5 {
+    vector.push(i);
+}
+assert(vector.len() == 5);
+assert(vector.max_len() == 10);
+```
+
+## Methods
+
+### new
+
+```rust
+pub fn new() -> Self
+```
+
+Creates a new, empty vector of length zero.
+
+Since this container is backed by an array internally, it still needs an initial value
+to give each element. To resolve this, each element is zeroed internally. This value
+is guaranteed to be inaccessible unless `get_unchecked` is used.
+
+Example:
+
+```rust
+let empty_vector: BoundedVec<Field, 10> = BoundedVec::new();
+assert(empty_vector.len() == 0);
+```
+
+Note that whenever calling `new` the maximum length of the vector should always be specified
+via a type signature:
+
+```rust title="new_example" showLineNumbers 
+fn good() -> BoundedVec<Field, 10> {
+    // Ok! MaxLen is specified with a type annotation
+    let v1: BoundedVec<Field, 3> = BoundedVec::new();
+    let v2 = BoundedVec::new();
+
+    // Ok! MaxLen is known from the type of `good`'s return value
+    v2
+}
+
+fn bad() {
+    // Error: Type annotation needed
+    // The compiler can't infer `MaxLen` from this code.
+    let mut v3 = BoundedVec::new();
+    v3.push(5);
+}
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/test_programs/noir_test_success/bounded_vec/src/main.nr#L11-L27" target="_blank" rel="noopener noreferrer">Source code: test_programs/noir_test_success/bounded_vec/src/main.nr#L11-L27</a></sub></sup>
+
+
+This defaulting of `MaxLen` (and numeric generics in general) to zero may change in future noir versions
+but for now make sure to use type annotations when using bounded vectors. Otherwise, you will receive a constraint failure at runtime when the vec is pushed to.
+
+### get
+
+```rust
+pub fn get(self, index: u64) -> T {
+```
+
+Retrieves an element from the vector at the given index, starting from zero.
+
+If the given index is equal to or greater than the length of the vector, this
+will issue a constraint failure.
+
+Example:
+
+```rust
+fn foo<N>(v: BoundedVec<u32, N>) {
+    let first = v.get(0);
+    let last = v.get(v.len() - 1);
+    assert(first != last);
+}
+```
+
+### get_unchecked
+
+```rust
+pub fn get_unchecked(self, index: u64) -> T {
+```
+
+Retrieves an element from the vector at the given index, starting from zero, without
+performing a bounds check.
+
+Since this function does not perform a bounds check on length before accessing the element,
+it is unsafe! Use at your own risk!
+
+Example:
+
+```rust title="get_unchecked_example" showLineNumbers 
+fn sum_of_first_three<let N: u32>(v: BoundedVec<u32, N>) -> u32 {
+    // Always ensure the length is larger than the largest
+    // index passed to get_unchecked
+    assert(v.len() > 2);
+    let first = v.get_unchecked(0);
+    let second = v.get_unchecked(1);
+    let third = v.get_unchecked(2);
+    first + second + third
+}
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/test_programs/noir_test_success/bounded_vec/src/main.nr#L54-L64" target="_blank" rel="noopener noreferrer">Source code: test_programs/noir_test_success/bounded_vec/src/main.nr#L54-L64</a></sub></sup>
+
+
+### set
+
+```rust
+pub fn set(&mut self: Self, index: u64, value: T) {
+```
+
+Writes an element to the vector at the given index, starting from zero.
+
+If the given index is equal to or greater than the length of the vector, this will issue a constraint failure.
+
+Example:
+
+```rust
+fn foo<N>(v: BoundedVec<u32, N>) {
+    let first = v.get(0);
+    assert(first != 42);
+    v.set(0, 42);
+    let new_first = v.get(0);
+    assert(new_first == 42);
+}
+```
+
+### set_unchecked
+
+```rust
+pub fn set_unchecked(&mut self: Self, index: u64, value: T) -> T {
+```
+
+Writes an element to the vector at the given index, starting from zero, without performing a bounds check.
+
+Since this function does not perform a bounds check on length before accessing the element, it is unsafe! Use at your own risk!
+
+Example:
+
+```rust title="set_unchecked_example" showLineNumbers 
+fn set_unchecked_example() {
+    let mut vec: BoundedVec<u32, 5> = BoundedVec::new();
+    vec.extend_from_array([1, 2]);
+
+    // Here we're safely writing within the valid range of `vec`
+    // `vec` now has the value [42, 2]
+    vec.set_unchecked(0, 42);
+
+    // We can then safely read this value back out of `vec`.
+    // Notice that we use the checked version of `get` which would prevent reading unsafe values.
+    assert_eq(vec.get(0), 42);
+
+    // We've now written past the end of `vec`.
+    // As this index is still within the maximum potential length of `v`,
+    // it won't cause a constraint failure.
+    vec.set_unchecked(2, 42);
+    println(vec);
+
+    // This will write past the end of the maximum potential length of `vec`,
+    // it will then trigger a constraint failure.
+    vec.set_unchecked(5, 42);
+    println(vec);
+}
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/test_programs/noir_test_success/bounded_vec/src/main.nr#L67-L91" target="_blank" rel="noopener noreferrer">Source code: test_programs/noir_test_success/bounded_vec/src/main.nr#L67-L91</a></sub></sup>
+
+
+
+### push
+
+```rust
+pub fn push(&mut self, elem: T) {
+```
+
+Pushes an element to the end of the vector. This increases the length
+of the vector by one.
+
+Panics if the new length of the vector will be greater than the max length.
+
+Example:
+
+```rust title="bounded-vec-push-example" showLineNumbers 
+let mut v: BoundedVec<Field, 2> = BoundedVec::new();
+
+    v.push(1);
+    v.push(2);
+
+    // Panics with failed assertion "push out of bounds"
+    v.push(3);
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/test_programs/noir_test_success/bounded_vec/src/main.nr#L95-L103" target="_blank" rel="noopener noreferrer">Source code: test_programs/noir_test_success/bounded_vec/src/main.nr#L95-L103</a></sub></sup>
+
+
+### pop
+
+```rust
+pub fn pop(&mut self) -> T
+```
+
+Pops the element at the end of the vector. This will decrease the length
+of the vector by one.
+
+Panics if the vector is empty.
+
+Example:
+
+```rust title="bounded-vec-pop-example" showLineNumbers 
+let mut v: BoundedVec<Field, 2> = BoundedVec::new();
+    v.push(1);
+    v.push(2);
+
+    let two = v.pop();
+    let one = v.pop();
+
+    assert(two == 2);
+    assert(one == 1);
+    // error: cannot pop from an empty vector
+    // let _ = v.pop();
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/test_programs/noir_test_success/bounded_vec/src/main.nr#L108-L120" target="_blank" rel="noopener noreferrer">Source code: test_programs/noir_test_success/bounded_vec/src/main.nr#L108-L120</a></sub></sup>
+
+
+### len
+
+```rust
+pub fn len(self) -> u64 {
+```
+
+Returns the current length of this vector
+
+Example:
+
+```rust title="bounded-vec-len-example" showLineNumbers 
+let mut v: BoundedVec<Field, 4> = BoundedVec::new();
+    assert(v.len() == 0);
+
+    v.push(100);
+    assert(v.len() == 1);
+
+    v.push(200);
+    v.push(300);
+    v.push(400);
+    assert(v.len() == 4);
+
+    let _ = v.pop();
+    let _ = v.pop();
+    assert(v.len() == 2);
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/test_programs/noir_test_success/bounded_vec/src/main.nr#L125-L140" target="_blank" rel="noopener noreferrer">Source code: test_programs/noir_test_success/bounded_vec/src/main.nr#L125-L140</a></sub></sup>
+
+
+### max_len
+
+```rust
+pub fn max_len(_self: BoundedVec<T, MaxLen>) -> u64 {
+```
+
+Returns the maximum length of this vector. This is always
+equal to the `MaxLen` parameter this vector was initialized with.
+
+Example:
+
+```rust title="bounded-vec-max-len-example" showLineNumbers 
+let mut v: BoundedVec<Field, 5> = BoundedVec::new();
+
+    assert(v.max_len() == 5);
+    v.push(10);
+    assert(v.max_len() == 5);
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/test_programs/noir_test_success/bounded_vec/src/main.nr#L145-L151" target="_blank" rel="noopener noreferrer">Source code: test_programs/noir_test_success/bounded_vec/src/main.nr#L145-L151</a></sub></sup>
+
+
+### storage
+
+```rust
+pub fn storage(self) -> [T; MaxLen] {
+```
+
+Returns the internal array within this vector.
+Since arrays in Noir are immutable, mutating the returned storage array will not mutate
+the storage held internally by this vector.
+
+Note that uninitialized elements may be zeroed out!
+
+Example:
+
+```rust title="bounded-vec-storage-example" showLineNumbers 
+let mut v: BoundedVec<Field, 5> = BoundedVec::new();
+
+    assert(v.storage() == [0, 0, 0, 0, 0]);
+
+    v.push(57);
+    assert(v.storage() == [57, 0, 0, 0, 0]);
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/test_programs/noir_test_success/bounded_vec/src/main.nr#L156-L163" target="_blank" rel="noopener noreferrer">Source code: test_programs/noir_test_success/bounded_vec/src/main.nr#L156-L163</a></sub></sup>
+
+
+### extend_from_array
+
+```rust
+pub fn extend_from_array<Len>(&mut self, array: [T; Len])
+```
+
+Pushes each element from the given array to this vector.
+
+Panics if pushing each element would cause the length of this vector
+to exceed the maximum length.
+
+Example:
+
+```rust title="bounded-vec-extend-from-array-example" showLineNumbers 
+let mut vec: BoundedVec<Field, 3> = BoundedVec::new();
+    vec.extend_from_array([2, 4]);
+
+    assert(vec.len == 2);
+    assert(vec.get(0) == 2);
+    assert(vec.get(1) == 4);
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/test_programs/noir_test_success/bounded_vec/src/main.nr#L168-L175" target="_blank" rel="noopener noreferrer">Source code: test_programs/noir_test_success/bounded_vec/src/main.nr#L168-L175</a></sub></sup>
+
+
+### extend_from_bounded_vec
+
+```rust
+pub fn extend_from_bounded_vec<Len>(&mut self, vec: BoundedVec<T, Len>)
+```
+
+Pushes each element from the other vector to this vector. The length of
+the other vector is left unchanged.
+
+Panics if pushing each element would cause the length of this vector
+to exceed the maximum length.
+
+Example:
+
+```rust title="bounded-vec-extend-from-bounded-vec-example" showLineNumbers 
+let mut v1: BoundedVec<Field, 5> = BoundedVec::new();
+    let mut v2: BoundedVec<Field, 7> = BoundedVec::new();
+
+    v2.extend_from_array([1, 2, 3]);
+    v1.extend_from_bounded_vec(v2);
+
+    assert(v1.storage() == [1, 2, 3, 0, 0]);
+    assert(v2.storage() == [1, 2, 3, 0, 0, 0, 0]);
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/test_programs/noir_test_success/bounded_vec/src/main.nr#L180-L189" target="_blank" rel="noopener noreferrer">Source code: test_programs/noir_test_success/bounded_vec/src/main.nr#L180-L189</a></sub></sup>
+
+
+### from_array
+
+```rust
+pub fn from_array<Len>(array: [T; Len]) -> Self
+```
+
+Creates a new vector, populating it with values derived from an array input. 
+The maximum length of the vector is determined based on the type signature.
+
+Example:
+```rust
+let bounded_vec: BoundedVec<Field, 10> = BoundedVec::from_array([1, 2, 3])
+```
+
+### map
+
+```rust
+pub fn map<U, Env>(self, f: fn[Env](T) -> U) -> BoundedVec<U, MaxLen>
+```
+
+Creates a new vector of equal size by calling a closure on each element in this vector.  
+
+Example:
+
+```rust title="bounded-vec-map-example" showLineNumbers 
+let vec: BoundedVec<u32, 4> = BoundedVec::from_array([1, 2, 3, 4]);
+            let result = vec.map(|value| value * 2);
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/collections/bounded_vec.nr#L495-L498" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/collections/bounded_vec.nr#L495-L498</a></sub></sup>
+
+
+### any
+
+```rust
+pub fn any<Env>(self, predicate: fn[Env](T) -> bool) -> bool
+```
+
+Returns true if the given predicate returns true for any element
+in this vector.
+
+Example:
+
+```rust title="bounded-vec-any-example" showLineNumbers 
+let mut v: BoundedVec<u32, 3> = BoundedVec::new();
+    v.extend_from_array([2, 4, 6]);
+
+    let all_even = !v.any(|elem: u32| elem % 2 != 0);
+    assert(all_even);
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/test_programs/noir_test_success/bounded_vec/src/main.nr#L256-L262" target="_blank" rel="noopener noreferrer">Source code: test_programs/noir_test_success/bounded_vec/src/main.nr#L256-L262</a></sub></sup>
+
diff --git a/docs/versioned_docs/version-v0.37.0/noir/standard_library/containers/hashmap.md b/docs/versioned_docs/version-v0.37.0/noir/standard_library/containers/hashmap.md
new file mode 100644
index 00000000000..395cc312705
--- /dev/null
+++ b/docs/versioned_docs/version-v0.37.0/noir/standard_library/containers/hashmap.md
@@ -0,0 +1,587 @@
+---
+title: HashMap
+keywords: [noir, map, hash, hashmap]
+sidebar_position: 1
+---
+
+`HashMap<Key, Value, MaxLen, Hasher>` is used to efficiently store and look up key-value pairs.
+
+`HashMap` is a bounded type which can store anywhere from zero to `MaxLen` total elements.
+Note that due to hash collisions, the actual maximum number of elements stored by any particular
+hashmap is likely lower than `MaxLen`. This is true even with cryptographic hash functions since
+every hash value will be performed modulo `MaxLen`.
+
+Example:
+
+```rust
+// Create a mapping from Fields to u32s with a maximum length of 12
+// using a poseidon2 hasher
+use std::hash::poseidon2::Poseidon2Hasher;
+let mut map: HashMap<Field, u32, 12, BuildHasherDefault<Poseidon2Hasher>> = HashMap::default();
+
+map.insert(1, 2);
+map.insert(3, 4);
+
+let two = map.get(1).unwrap();
+```
+
+## Methods
+
+### default
+
+```rust title="default" showLineNumbers 
+impl<K, V, let N: u32, B, H> Default for HashMap<K, V, N, B>
+where
+    B: BuildHasher<H> + Default,
+    H: Hasher + Default,
+{
+    /// Constructs an empty HashMap.
+    ///
+    /// Example:
+    ///
+    /// ```noir
+    /// let hashmap: HashMap<u8, u32, 10, BuildHasherDefault<Poseidon2Hasher>> = HashMap::default();
+    /// assert(hashmap.is_empty());
+    /// ```
+    fn default() -> Self {
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/collections/map.nr#L681-L696" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/collections/map.nr#L681-L696</a></sub></sup>
+
+
+Creates a fresh, empty HashMap.
+
+When using this function, always make sure to specify the maximum size of the hash map.
+
+This is the same `default` from the `Default` implementation given further below. It is
+repeated here for convenience since it is the recommended way to create a hashmap.
+
+Example:
+
+```rust title="default_example" showLineNumbers 
+let hashmap: HashMap<u8, u32, 10, BuildHasherDefault<Poseidon2Hasher>> = HashMap::default();
+    assert(hashmap.is_empty());
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/test_programs/execution_success/hashmap/src/main.nr#L207-L210" target="_blank" rel="noopener noreferrer">Source code: test_programs/execution_success/hashmap/src/main.nr#L207-L210</a></sub></sup>
+
+
+Because `HashMap` has so many generic arguments that are likely to be the same throughout
+your program, it may be helpful to create a type alias:
+
+```rust title="type_alias" showLineNumbers 
+type MyMap = HashMap<u8, u32, 10, BuildHasherDefault<Poseidon2Hasher>>;
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/test_programs/execution_success/hashmap/src/main.nr#L201-L203" target="_blank" rel="noopener noreferrer">Source code: test_programs/execution_success/hashmap/src/main.nr#L201-L203</a></sub></sup>
+
+
+### with_hasher
+
+```rust title="with_hasher" showLineNumbers 
+pub fn with_hasher<H>(_build_hasher: B) -> Self
+    where
+        B: BuildHasher<H>,
+    {
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/collections/map.nr#L103-L108" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/collections/map.nr#L103-L108</a></sub></sup>
+
+
+Creates a hashmap with an existing `BuildHasher`. This can be used to ensure multiple
+hashmaps are created with the same hasher instance.
+
+Example:
+
+```rust title="with_hasher_example" showLineNumbers 
+let my_hasher: BuildHasherDefault<Poseidon2Hasher> = Default::default();
+    let hashmap: HashMap<u8, u32, 10, BuildHasherDefault<Poseidon2Hasher>> =
+        HashMap::with_hasher(my_hasher);
+    assert(hashmap.is_empty());
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/test_programs/execution_success/hashmap/src/main.nr#L211-L216" target="_blank" rel="noopener noreferrer">Source code: test_programs/execution_success/hashmap/src/main.nr#L211-L216</a></sub></sup>
+
+
+### get
+
+```rust title="get" showLineNumbers 
+pub fn get<H>(self, key: K) -> Option<V>
+    where
+        K: Eq + Hash,
+        B: BuildHasher<H>,
+        H: Hasher,
+    {
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/collections/map.nr#L465-L472" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/collections/map.nr#L465-L472</a></sub></sup>
+
+
+Retrieves a value from the hashmap, returning `Option::none()` if it was not found.
+
+Example:
+
+```rust title="get_example" showLineNumbers 
+fn get_example(map: HashMap<Field, Field, 5, BuildHasherDefault<Poseidon2Hasher>>) {
+    let x = map.get(12);
+
+    if x.is_some() {
+        assert(x.unwrap() == 42);
+    }
+}
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/test_programs/execution_success/hashmap/src/main.nr#L296-L304" target="_blank" rel="noopener noreferrer">Source code: test_programs/execution_success/hashmap/src/main.nr#L296-L304</a></sub></sup>
+
+
+### insert
+
+```rust title="insert" showLineNumbers 
+pub fn insert<H>(&mut self, key: K, value: V)
+    where
+        K: Eq + Hash,
+        B: BuildHasher<H>,
+        H: Hasher,
+    {
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/collections/map.nr#L507-L514" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/collections/map.nr#L507-L514</a></sub></sup>
+
+
+Inserts a new key-value pair into the map. If the key was already in the map, its
+previous value will be overridden with the newly provided one.
+
+Example:
+
+```rust title="insert_example" showLineNumbers 
+let mut map: HashMap<Field, Field, 5, BuildHasherDefault<Poseidon2Hasher>> = HashMap::default();
+    map.insert(12, 42);
+    assert(map.len() == 1);
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/test_programs/execution_success/hashmap/src/main.nr#L217-L221" target="_blank" rel="noopener noreferrer">Source code: test_programs/execution_success/hashmap/src/main.nr#L217-L221</a></sub></sup>
+
+
+### remove
+
+```rust title="remove" showLineNumbers 
+pub fn remove<H>(&mut self, key: K)
+    where
+        K: Eq + Hash,
+        B: BuildHasher<H>,
+        H: Hasher,
+    {
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/collections/map.nr#L563-L570" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/collections/map.nr#L563-L570</a></sub></sup>
+
+
+Removes the given key-value pair from the map. If the key was not already present
+in the map, this does nothing.
+
+Example:
+
+```rust title="remove_example" showLineNumbers 
+map.remove(12);
+    assert(map.is_empty());
+
+    // If a key was not present in the map, remove does nothing
+    map.remove(12);
+    assert(map.is_empty());
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/test_programs/execution_success/hashmap/src/main.nr#L224-L231" target="_blank" rel="noopener noreferrer">Source code: test_programs/execution_success/hashmap/src/main.nr#L224-L231</a></sub></sup>
+
+
+### is_empty
+
+```rust title="is_empty" showLineNumbers 
+pub fn is_empty(self) -> bool {
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/collections/map.nr#L167-L169" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/collections/map.nr#L167-L169</a></sub></sup>
+
+
+True if the length of the hash map is empty.
+
+Example:
+
+```rust title="is_empty_example" showLineNumbers 
+assert(map.is_empty());
+
+    map.insert(1, 2);
+    assert(!map.is_empty());
+
+    map.remove(1);
+    assert(map.is_empty());
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/test_programs/execution_success/hashmap/src/main.nr#L232-L240" target="_blank" rel="noopener noreferrer">Source code: test_programs/execution_success/hashmap/src/main.nr#L232-L240</a></sub></sup>
+
+
+### len
+
+```rust title="len" showLineNumbers 
+pub fn len(self) -> u32 {
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/collections/map.nr#L424-L426" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/collections/map.nr#L424-L426</a></sub></sup>
+
+
+Returns the current length of this hash map.
+
+Example:
+
+```rust title="len_example" showLineNumbers 
+// This is equivalent to checking map.is_empty()
+    assert(map.len() == 0);
+
+    map.insert(1, 2);
+    map.insert(3, 4);
+    map.insert(5, 6);
+    assert(map.len() == 3);
+
+    // 3 was already present as a key in the hash map, so the length is unchanged
+    map.insert(3, 7);
+    assert(map.len() == 3);
+
+    map.remove(1);
+    assert(map.len() == 2);
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/test_programs/execution_success/hashmap/src/main.nr#L241-L256" target="_blank" rel="noopener noreferrer">Source code: test_programs/execution_success/hashmap/src/main.nr#L241-L256</a></sub></sup>
+
+
+### capacity
+
+```rust title="capacity" showLineNumbers 
+pub fn capacity(_self: Self) -> u32 {
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/collections/map.nr#L446-L448" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/collections/map.nr#L446-L448</a></sub></sup>
+
+
+Returns the maximum capacity of this hashmap. This is always equal to the capacity
+specified in the hashmap's type.
+
+Unlike hashmaps in general purpose programming languages, hashmaps in Noir have a
+static capacity that does not increase as the map grows larger. Thus, this capacity
+is also the maximum possible element count that can be inserted into the hashmap.
+Due to hash collisions (modulo the hashmap length), it is likely the actual maximum
+element count will be lower than the full capacity.
+
+Example:
+
+```rust title="capacity_example" showLineNumbers 
+let empty_map: HashMap<Field, Field, 42, BuildHasherDefault<Poseidon2Hasher>> =
+        HashMap::default();
+    assert(empty_map.len() == 0);
+    assert(empty_map.capacity() == 42);
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/test_programs/execution_success/hashmap/src/main.nr#L257-L262" target="_blank" rel="noopener noreferrer">Source code: test_programs/execution_success/hashmap/src/main.nr#L257-L262</a></sub></sup>
+
+
+### clear
+
+```rust title="clear" showLineNumbers 
+pub fn clear(&mut self) {
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/collections/map.nr#L123-L125" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/collections/map.nr#L123-L125</a></sub></sup>
+
+
+Clears the hashmap, removing all key-value pairs from it.
+
+Example:
+
+```rust title="clear_example" showLineNumbers 
+assert(!map.is_empty());
+    map.clear();
+    assert(map.is_empty());
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/test_programs/execution_success/hashmap/src/main.nr#L263-L267" target="_blank" rel="noopener noreferrer">Source code: test_programs/execution_success/hashmap/src/main.nr#L263-L267</a></sub></sup>
+
+
+### contains_key
+
+```rust title="contains_key" showLineNumbers 
+pub fn contains_key<H>(self, key: K) -> bool
+    where
+        K: Hash + Eq,
+        B: BuildHasher<H>,
+        H: Hasher,
+    {
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/collections/map.nr#L143-L150" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/collections/map.nr#L143-L150</a></sub></sup>
+
+
+True if the hashmap contains the given key. Unlike `get`, this will not also return
+the value associated with the key.
+
+Example:
+
+```rust title="contains_key_example" showLineNumbers 
+if map.contains_key(7) {
+        let value = map.get(7);
+        assert(value.is_some());
+    } else {
+        println("No value for key 7!");
+    }
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/test_programs/execution_success/hashmap/src/main.nr#L268-L275" target="_blank" rel="noopener noreferrer">Source code: test_programs/execution_success/hashmap/src/main.nr#L268-L275</a></sub></sup>
+
+
+### entries
+
+```rust title="entries" showLineNumbers 
+pub fn entries(self) -> BoundedVec<(K, V), N> {
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/collections/map.nr#L191-L193" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/collections/map.nr#L191-L193</a></sub></sup>
+
+
+Returns a vector of each key-value pair present in the hashmap.
+
+The length of the returned vector is always equal to the length of the hashmap.
+
+Example:
+
+```rust title="entries_example" showLineNumbers 
+let entries = map.entries();
+
+    // The length of a hashmap may not be compile-time known, so we
+    // need to loop over its capacity instead
+    for i in 0..map.capacity() {
+        if i < entries.len() {
+            let (key, value) = entries.get(i);
+            println(f"{key} -> {value}");
+        }
+    }
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/test_programs/execution_success/hashmap/src/main.nr#L307-L318" target="_blank" rel="noopener noreferrer">Source code: test_programs/execution_success/hashmap/src/main.nr#L307-L318</a></sub></sup>
+
+
+### keys
+
+```rust title="keys" showLineNumbers 
+pub fn keys(self) -> BoundedVec<K, N> {
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/collections/map.nr#L227-L229" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/collections/map.nr#L227-L229</a></sub></sup>
+
+
+Returns a vector of each key present in the hashmap.
+
+The length of the returned vector is always equal to the length of the hashmap.
+
+Example:
+
+```rust title="keys_example" showLineNumbers 
+let keys = map.keys();
+
+    for i in 0..keys.max_len() {
+        if i < keys.len() {
+            let key = keys.get_unchecked(i);
+            let value = map.get(key).unwrap_unchecked();
+            println(f"{key} -> {value}");
+        }
+    }
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/test_programs/execution_success/hashmap/src/main.nr#L319-L329" target="_blank" rel="noopener noreferrer">Source code: test_programs/execution_success/hashmap/src/main.nr#L319-L329</a></sub></sup>
+
+
+### values
+
+```rust title="values" showLineNumbers 
+pub fn values(self) -> BoundedVec<V, N> {
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/collections/map.nr#L262-L264" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/collections/map.nr#L262-L264</a></sub></sup>
+
+
+Returns a vector of each value present in the hashmap.
+
+The length of the returned vector is always equal to the length of the hashmap.
+
+Example:
+
+```rust title="values_example" showLineNumbers 
+let values = map.values();
+
+    for i in 0..values.max_len() {
+        if i < values.len() {
+            let value = values.get_unchecked(i);
+            println(f"Found value {value}");
+        }
+    }
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/test_programs/execution_success/hashmap/src/main.nr#L330-L339" target="_blank" rel="noopener noreferrer">Source code: test_programs/execution_success/hashmap/src/main.nr#L330-L339</a></sub></sup>
+
+
+### iter_mut
+
+```rust title="iter_mut" showLineNumbers 
+pub fn iter_mut<H>(&mut self, f: fn(K, V) -> (K, V))
+    where
+        K: Eq + Hash,
+        B: BuildHasher<H>,
+        H: Hasher,
+    {
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/collections/map.nr#L297-L304" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/collections/map.nr#L297-L304</a></sub></sup>
+
+
+Iterates through each key-value pair of the HashMap, setting each key-value pair to the
+result returned from the given function.
+
+Note that since keys can be mutated, the HashMap needs to be rebuilt as it is iterated
+through. If this is not desired, use `iter_values_mut` if only values need to be mutated,
+or `entries` if neither keys nor values need to be mutated.
+
+The iteration order is left unspecified. As a result, if two keys are mutated to become
+equal, which of the two values that will be present for the key in the resulting map is also unspecified.
+
+Example:
+
+```rust title="iter_mut_example" showLineNumbers 
+// Add 1 to each key in the map, and double the value associated with that key.
+    map.iter_mut(|k, v| (k + 1, v * 2));
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/test_programs/execution_success/hashmap/src/main.nr#L343-L346" target="_blank" rel="noopener noreferrer">Source code: test_programs/execution_success/hashmap/src/main.nr#L343-L346</a></sub></sup>
+
+
+### iter_keys_mut
+
+```rust title="iter_keys_mut" showLineNumbers 
+pub fn iter_keys_mut<H>(&mut self, f: fn(K) -> K)
+    where
+        K: Eq + Hash,
+        B: BuildHasher<H>,
+        H: Hasher,
+    {
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/collections/map.nr#L335-L342" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/collections/map.nr#L335-L342</a></sub></sup>
+
+
+Iterates through the HashMap, mutating each key to the result returned from
+the given function.
+
+Note that since keys can be mutated, the HashMap needs to be rebuilt as it is iterated
+through. If only iteration is desired and the keys are not intended to be mutated,
+prefer using `entries` instead.
+
+The iteration order is left unspecified. As a result, if two keys are mutated to become
+equal, which of the two values that will be present for the key in the resulting map is also unspecified.
+
+Example:
+
+```rust title="iter_keys_mut_example" showLineNumbers 
+// Double each key, leaving the value associated with that key untouched
+    map.iter_keys_mut(|k| k * 2);
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/test_programs/execution_success/hashmap/src/main.nr#L347-L350" target="_blank" rel="noopener noreferrer">Source code: test_programs/execution_success/hashmap/src/main.nr#L347-L350</a></sub></sup>
+
+
+### iter_values_mut
+
+```rust title="iter_values_mut" showLineNumbers 
+pub fn iter_values_mut(&mut self, f: fn(V) -> V) {
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/collections/map.nr#L367-L369" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/collections/map.nr#L367-L369</a></sub></sup>
+
+
+Iterates through the HashMap, applying the given function to each value and mutating the
+value to equal the result. This function is more efficient than `iter_mut` and `iter_keys_mut`
+because the keys are untouched and the underlying hashmap thus does not need to be reordered.
+
+Example:
+
+```rust title="iter_values_mut_example" showLineNumbers 
+// Halve each value
+    map.iter_values_mut(|v| v / 2);
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/test_programs/execution_success/hashmap/src/main.nr#L351-L354" target="_blank" rel="noopener noreferrer">Source code: test_programs/execution_success/hashmap/src/main.nr#L351-L354</a></sub></sup>
+
+
+### retain
+
+```rust title="retain" showLineNumbers 
+pub fn retain(&mut self, f: fn(K, V) -> bool) {
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/collections/map.nr#L388-L390" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/collections/map.nr#L388-L390</a></sub></sup>
+
+
+Retains only the key-value pairs for which the given function returns true.
+Any key-value pairs for which the function returns false will be removed from the map.
+
+Example:
+
+```rust title="retain_example" showLineNumbers 
+map.retain(|k, v| (k != 0) & (v != 0));
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/test_programs/execution_success/hashmap/src/main.nr#L279-L281" target="_blank" rel="noopener noreferrer">Source code: test_programs/execution_success/hashmap/src/main.nr#L279-L281</a></sub></sup>
+
+
+## Trait Implementations
+
+### default
+
+```rust title="default" showLineNumbers 
+impl<K, V, let N: u32, B, H> Default for HashMap<K, V, N, B>
+where
+    B: BuildHasher<H> + Default,
+    H: Hasher + Default,
+{
+    /// Constructs an empty HashMap.
+    ///
+    /// Example:
+    ///
+    /// ```noir
+    /// let hashmap: HashMap<u8, u32, 10, BuildHasherDefault<Poseidon2Hasher>> = HashMap::default();
+    /// assert(hashmap.is_empty());
+    /// ```
+    fn default() -> Self {
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/collections/map.nr#L681-L696" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/collections/map.nr#L681-L696</a></sub></sup>
+
+
+Constructs an empty HashMap.
+
+Example:
+
+```rust title="default_example" showLineNumbers 
+let hashmap: HashMap<u8, u32, 10, BuildHasherDefault<Poseidon2Hasher>> = HashMap::default();
+    assert(hashmap.is_empty());
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/test_programs/execution_success/hashmap/src/main.nr#L207-L210" target="_blank" rel="noopener noreferrer">Source code: test_programs/execution_success/hashmap/src/main.nr#L207-L210</a></sub></sup>
+
+
+### eq
+
+```rust title="eq" showLineNumbers 
+impl<K, V, let N: u32, B, H> Eq for HashMap<K, V, N, B>
+where
+    K: Eq + Hash,
+    V: Eq,
+    B: BuildHasher<H>,
+    H: Hasher,
+{
+    /// Checks if two HashMaps are equal.
+    ///
+    /// Example:
+    ///
+    /// ```noir
+    /// let mut map1: HashMap<Field, u64, 4, BuildHasherDefault<Poseidon2Hasher>> = HashMap::default();
+    /// let mut map2: HashMap<Field, u64, 4, BuildHasherDefault<Poseidon2Hasher>> = HashMap::default();
+    ///
+    /// map1.insert(1, 2);
+    /// map1.insert(3, 4);
+    ///
+    /// map2.insert(3, 4);
+    /// map2.insert(1, 2);
+    ///
+    /// assert(map1 == map2);
+    /// ```
+    fn eq(self, other: HashMap<K, V, N, B>) -> bool {
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/collections/map.nr#L629-L654" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/collections/map.nr#L629-L654</a></sub></sup>
+
+
+Checks if two HashMaps are equal.
+
+Example:
+
+```rust title="eq_example" showLineNumbers 
+let mut map1: HashMap<Field, u64, 4, BuildHasherDefault<Poseidon2Hasher>> = HashMap::default();
+    let mut map2: HashMap<Field, u64, 4, BuildHasherDefault<Poseidon2Hasher>> = HashMap::default();
+
+    map1.insert(1, 2);
+    map1.insert(3, 4);
+
+    map2.insert(3, 4);
+    map2.insert(1, 2);
+
+    assert(map1 == map2);
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/test_programs/execution_success/hashmap/src/main.nr#L282-L293" target="_blank" rel="noopener noreferrer">Source code: test_programs/execution_success/hashmap/src/main.nr#L282-L293</a></sub></sup>
+
diff --git a/docs/versioned_docs/version-v0.37.0/noir/standard_library/containers/index.md b/docs/versioned_docs/version-v0.37.0/noir/standard_library/containers/index.md
new file mode 100644
index 00000000000..ea84c6d5c21
--- /dev/null
+++ b/docs/versioned_docs/version-v0.37.0/noir/standard_library/containers/index.md
@@ -0,0 +1,5 @@
+---
+title: Containers
+description: Container types provided by Noir's standard library for storing and retrieving data
+keywords: [containers, data types, vec, hashmap]
+---
diff --git a/docs/versioned_docs/version-v0.37.0/noir/standard_library/containers/vec.mdx b/docs/versioned_docs/version-v0.37.0/noir/standard_library/containers/vec.mdx
new file mode 100644
index 00000000000..475011922f8
--- /dev/null
+++ b/docs/versioned_docs/version-v0.37.0/noir/standard_library/containers/vec.mdx
@@ -0,0 +1,170 @@
+---
+title: Vectors
+description: Delve into the Vec data type in Noir. Learn about its methods, practical examples, and best practices for using Vectors in your Noir code.
+keywords: [noir, vector type, methods, examples, dynamic arrays]
+sidebar_position: 6
+---
+
+import Experimental from '@site/src/components/Notes/_experimental.mdx';
+
+<Experimental />
+
+A vector is a collection type similar to Rust's `Vec<T>` type. In Noir, it is a convenient way to use slices as mutable arrays.
+
+Example:
+
+```rust
+let mut vector: Vec<Field> = Vec::new();
+for i in 0..5 {
+    vector.push(i);
+}
+assert(vector.len() == 5);
+```
+
+## Methods
+
+### new
+
+Creates a new, empty vector.
+
+```rust
+pub fn new() -> Self
+```
+
+Example:
+
+```rust
+let empty_vector: Vec<Field> = Vec::new();
+assert(empty_vector.len() == 0);
+```
+
+### from_slice
+
+Creates a vector containing each element from a given slice. Mutations to the resulting vector will not affect the original slice.
+
+```rust
+pub fn from_slice(slice: [T]) -> Self
+```
+
+Example:
+
+```rust
+let slice: [Field] = &[1, 2, 3];
+let vector_from_slice = Vec::from_slice(slice);
+assert(vector_from_slice.len() == 3);
+```
+
+### len
+
+Returns the number of elements in the vector.
+
+```rust
+pub fn len(self) -> Field
+```
+
+Example:
+
+```rust
+let empty_vector: Vec<Field> = Vec::new();
+assert(empty_vector.len() == 0);
+```
+
+### get
+
+Retrieves an element from the vector at a given index. Panics if the index points beyond the vector's end.
+
+```rust
+pub fn get(self, index: Field) -> T
+```
+
+Example:
+
+```rust
+let vector: Vec<Field> = Vec::from_slice(&[10, 20, 30]);
+assert(vector.get(1) == 20);
+```
+
+### set
+
+```rust
+pub fn set(&mut self: Self, index: u64, value: T) {
+```
+
+Writes an element to the vector at the given index, starting from zero.
+
+Panics if the index points beyond the vector's end.
+
+Example:
+
+```rust
+let vector: Vec<Field> = Vec::from_slice(&[10, 20, 30]);
+assert(vector.get(1) == 20);
+vector.set(1, 42);
+assert(vector.get(1) == 42);
+```
+
+### push
+
+Adds a new element to the vector's end, returning a new vector with a length one greater than the original unmodified vector.
+
+```rust
+pub fn push(&mut self, elem: T)
+```
+
+Example:
+
+```rust
+let mut vector: Vec<Field> = Vec::new();
+vector.push(10);
+assert(vector.len() == 1);
+```
+
+### pop
+
+Removes an element from the vector's end, returning a new vector with a length one less than the original vector, along with the removed element. Panics if the vector's length is zero.
+
+```rust
+pub fn pop(&mut self) -> T
+```
+
+Example:
+
+```rust
+let mut vector = Vec::from_slice(&[10, 20]);
+let popped_elem = vector.pop();
+assert(popped_elem == 20);
+assert(vector.len() == 1);
+```
+
+### insert
+
+Inserts an element at a specified index, shifting subsequent elements to the right.
+
+```rust
+pub fn insert(&mut self, index: Field, elem: T)
+```
+
+Example:
+
+```rust
+let mut vector = Vec::from_slice(&[10, 30]);
+vector.insert(1, 20);
+assert(vector.get(1) == 20);
+```
+
+### remove
+
+Removes an element at a specified index, shifting subsequent elements to the left, and returns the removed element.
+
+```rust
+pub fn remove(&mut self, index: Field) -> T
+```
+
+Example:
+
+```rust
+let mut vector = Vec::from_slice(&[10, 20, 30]);
+let removed_elem = vector.remove(1);
+assert(removed_elem == 20);
+assert(vector.len() == 2);
+```
diff --git a/docs/versioned_docs/version-v0.37.0/noir/standard_library/cryptographic_primitives/_category_.json b/docs/versioned_docs/version-v0.37.0/noir/standard_library/cryptographic_primitives/_category_.json
new file mode 100644
index 00000000000..5d694210bbf
--- /dev/null
+++ b/docs/versioned_docs/version-v0.37.0/noir/standard_library/cryptographic_primitives/_category_.json
@@ -0,0 +1,5 @@
+{
+    "position": 0,
+    "collapsible": true,
+    "collapsed": true
+}
diff --git a/docs/versioned_docs/version-v0.37.0/noir/standard_library/cryptographic_primitives/ciphers.mdx b/docs/versioned_docs/version-v0.37.0/noir/standard_library/cryptographic_primitives/ciphers.mdx
new file mode 100644
index 00000000000..d6a5e1a79eb
--- /dev/null
+++ b/docs/versioned_docs/version-v0.37.0/noir/standard_library/cryptographic_primitives/ciphers.mdx
@@ -0,0 +1,32 @@
+---
+title: Ciphers
+description:
+  Learn about the implemented ciphers ready to use for any Noir project
+keywords:
+  [ciphers, Noir project, aes128, encrypt]
+sidebar_position: 0
+---
+
+import BlackBoxInfo from '@site/src/components/Notes/_blackbox';
+
+## aes128
+
+Given a plaintext as an array of bytes, returns the corresponding aes128 ciphertext (CBC mode). Input padding is automatically performed using PKCS#7, so that the output length is `input.len() + (16 - input.len() % 16)`.
+
+```rust title="aes128" showLineNumbers 
+pub fn aes128_encrypt<let N: u32>(input: [u8; N], iv: [u8; 16], key: [u8; 16]) -> [u8] {}
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/aes128.nr#L2-L4" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/aes128.nr#L2-L4</a></sub></sup>
+
+
+```rust
+fn main() {
+    let input: [u8; 4] = [0, 12, 3, 15] // Random bytes, will be padded to 16 bytes.
+    let iv: [u8; 16] = [0; 16]; // Initialisation vector
+    let key: [u8; 16] = [0; 16] // AES key
+    let ciphertext = std::aes128::aes128_encrypt(inputs.as_bytes(), iv.as_bytes(), key.as_bytes()); // In this case, the output length will be 16 bytes.
+}
+```
+
+
+<BlackBoxInfo to="../black_box_fns"/>
\ No newline at end of file
diff --git a/docs/versioned_docs/version-v0.37.0/noir/standard_library/cryptographic_primitives/ec_primitives.md b/docs/versioned_docs/version-v0.37.0/noir/standard_library/cryptographic_primitives/ec_primitives.md
new file mode 100644
index 00000000000..f262d8160d6
--- /dev/null
+++ b/docs/versioned_docs/version-v0.37.0/noir/standard_library/cryptographic_primitives/ec_primitives.md
@@ -0,0 +1,102 @@
+---
+title: Elliptic Curve Primitives
+keywords: [cryptographic primitives, Noir project]
+sidebar_position: 4
+---
+
+Data structures and methods on them that allow you to carry out computations involving elliptic
+curves over the (mathematical) field corresponding to `Field`. For the field currently at our
+disposal, applications would involve a curve embedded in BN254, e.g. the
+[Baby Jubjub curve](https://eips.ethereum.org/EIPS/eip-2494).
+
+## Data structures
+
+### Elliptic curve configurations
+
+(`std::ec::{tecurve,montcurve,swcurve}::{affine,curvegroup}::Curve`), i.e. the specific elliptic
+curve you want to use, which would be specified using any one of the methods
+`std::ec::{tecurve,montcurve,swcurve}::{affine,curvegroup}::new` which take the coefficients in the
+defining equation together with a generator point as parameters. You can find more detail in the
+comments in
+[`noir_stdlib/src/ec/mod.nr`](https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/ec/mod.nr), but
+the gist of it is that the elliptic curves of interest are usually expressed in one of the standard
+forms implemented here (Twisted Edwards, Montgomery and Short Weierstraß), and in addition to that,
+you could choose to use `affine` coordinates (Cartesian coordinates - the usual (x,y) - possibly
+together with a point at infinity) or `curvegroup` coordinates (some form of projective coordinates
+requiring more coordinates but allowing for more efficient implementations of elliptic curve
+operations). Conversions between all of these forms are provided, and under the hood these
+conversions are done whenever an operation is more efficient in a different representation (or a
+mixed coordinate representation is employed).
+
+### Points
+
+(`std::ec::{tecurve,montcurve,swcurve}::{affine,curvegroup}::Point`), i.e. points lying on the
+elliptic curve. For a curve configuration `c` and a point `p`, it may be checked that `p`
+does indeed lie on `c` by calling `c.contains(p1)`.
+
+## Methods
+
+(given a choice of curve representation, e.g. use `std::ec::tecurve::affine::Curve` and use
+`std::ec::tecurve::affine::Point`)
+
+- The **zero element** is given by `Point::zero()`, and we can verify whether a point `p: Point` is
+  zero by calling `p.is_zero()`.
+- **Equality**: Points `p1: Point` and `p2: Point` may be checked for equality by calling
+  `p1.eq(p2)`.
+- **Addition**: For `c: Curve` and points `p1: Point` and `p2: Point` on the curve, adding these two
+  points is accomplished by calling `c.add(p1,p2)`.
+- **Negation**: For a point `p: Point`, `p.negate()` is its negation.
+- **Subtraction**: For `c` and `p1`, `p2` as above, subtracting `p2` from `p1` is accomplished by
+  calling `c.subtract(p1,p2)`.
+- **Scalar multiplication**: For `c` as above, `p: Point` a point on the curve and `n: Field`,
+  scalar multiplication is given by `c.mul(n,p)`. If instead `n :: [u1; N]`, i.e. `n` is a bit
+  array, the `bit_mul` method may be used instead: `c.bit_mul(n,p)`
+- **Multi-scalar multiplication**: For `c` as above and arrays `n: [Field; N]` and `p: [Point; N]`,
+  multi-scalar multiplication is given by `c.msm(n,p)`.
+- **Coordinate representation conversions**: The `into_group` method converts a point or curve
+  configuration in the affine representation to one in the CurveGroup representation, and
+  `into_affine` goes in the other direction.
+- **Curve representation conversions**: `tecurve` and `montcurve` curves and points are equivalent
+  and may be converted between one another by calling `into_montcurve` or `into_tecurve` on their
+  configurations or points. `swcurve` is more general and a curve c of one of the other two types
+  may be converted to this representation by calling `c.into_swcurve()`, whereas a point `p` lying
+  on the curve given by `c` may be mapped to its corresponding `swcurve` point by calling
+  `c.map_into_swcurve(p)`.
+- **Map-to-curve methods**: The Elligator 2 method of mapping a field element `n: Field` into a
+  `tecurve` or `montcurve` with configuration `c` may be called as `c.elligator2_map(n)`. For all of
+  the curve configurations, the SWU map-to-curve method may be called as `c.swu_map(z,n)`, where
+  `z: Field` depends on `Field` and `c` and must be chosen by the user (the conditions it needs to
+  satisfy are specified in the comments
+  [here](https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/ec/mod.nr)).
+
+## Examples
+
+The
+[ec_baby_jubjub test](https://github.com/noir-lang/noir/blob/master/test_programs/compile_success_empty/ec_baby_jubjub/src/main.nr)
+illustrates all of the above primitives on various forms of the Baby Jubjub curve. A couple of more
+interesting examples in Noir would be:
+
+Public-key cryptography: Given an elliptic curve and a 'base point' on it, determine the public key
+from the private key. This is a matter of using scalar multiplication. In the case of Baby Jubjub,
+for example, this code would do:
+
+```rust
+use std::ec::tecurve::affine::{Curve, Point};
+
+fn bjj_pub_key(priv_key: Field) -> Point
+{
+
+ let bjj = Curve::new(168700, 168696, G::new(995203441582195749578291179787384436505546430278305826713579947235728471134,5472060717959818805561601436314318772137091100104008585924551046643952123905));
+
+ let base_pt = Point::new(5299619240641551281634865583518297030282874472190772894086521144482721001553, 16950150798460657717958625567821834550301663161624707787222815936182638968203);
+
+ bjj.mul(priv_key,base_pt)
+}
+```
+
+This would come in handy in a Merkle proof.
+
+- EdDSA signature verification: This is a matter of combining these primitives with a suitable hash
+  function. See
+  [feat(stdlib): EdDSA sig verification noir#1136](https://github.com/noir-lang/noir/pull/1136) for
+  the case of Baby Jubjub and the Poseidon hash function.
diff --git a/docs/versioned_docs/version-v0.37.0/noir/standard_library/cryptographic_primitives/ecdsa_sig_verification.mdx b/docs/versioned_docs/version-v0.37.0/noir/standard_library/cryptographic_primitives/ecdsa_sig_verification.mdx
new file mode 100644
index 00000000000..8d96027b42c
--- /dev/null
+++ b/docs/versioned_docs/version-v0.37.0/noir/standard_library/cryptographic_primitives/ecdsa_sig_verification.mdx
@@ -0,0 +1,98 @@
+---
+title: ECDSA Signature Verification
+description: Learn about the cryptographic primitives regarding ECDSA over the secp256k1 and secp256r1 curves
+keywords: [cryptographic primitives, Noir project, ecdsa, secp256k1, secp256r1, signatures]
+sidebar_position: 3
+---
+
+import BlackBoxInfo from '@site/src/components/Notes/_blackbox';
+
+Noir supports ECDSA signatures verification over the secp256k1 and secp256r1 curves.
+
+## ecdsa_secp256k1::verify_signature
+
+Verifier for ECDSA Secp256k1 signatures.
+See ecdsa_secp256k1::verify_signature_slice for a version that accepts slices directly.
+
+```rust title="ecdsa_secp256k1" showLineNumbers 
+pub fn verify_signature<let N: u32>(
+    public_key_x: [u8; 32],
+    public_key_y: [u8; 32],
+    signature: [u8; 64],
+    message_hash: [u8; N],
+) -> bool
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/ecdsa_secp256k1.nr#L2-L9" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/ecdsa_secp256k1.nr#L2-L9</a></sub></sup>
+
+
+example:
+
+```rust
+fn main(hashed_message : [u8;32], pub_key_x : [u8;32], pub_key_y : [u8;32], signature : [u8;64]) {
+     let valid_signature = std::ecdsa_secp256k1::verify_signature(pub_key_x, pub_key_y, signature, hashed_message);
+     assert(valid_signature);
+}
+```
+
+<BlackBoxInfo to="../black_box_fns" />
+
+## ecdsa_secp256k1::verify_signature_slice
+
+Verifier for ECDSA Secp256k1 signatures where the message is a slice.
+
+```rust title="ecdsa_secp256k1_slice" showLineNumbers 
+pub fn verify_signature_slice(
+    public_key_x: [u8; 32],
+    public_key_y: [u8; 32],
+    signature: [u8; 64],
+    message_hash: [u8],
+) -> bool
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/ecdsa_secp256k1.nr#L13-L20" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/ecdsa_secp256k1.nr#L13-L20</a></sub></sup>
+
+
+<BlackBoxInfo to="../black_box_fns"/>
+
+## ecdsa_secp256r1::verify_signature
+
+Verifier for ECDSA Secp256r1 signatures.
+See ecdsa_secp256r1::verify_signature_slice for a version that accepts slices directly.
+
+```rust title="ecdsa_secp256r1" showLineNumbers 
+pub fn verify_signature<let N: u32>(
+    public_key_x: [u8; 32],
+    public_key_y: [u8; 32],
+    signature: [u8; 64],
+    message_hash: [u8; N],
+) -> bool
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/ecdsa_secp256r1.nr#L2-L9" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/ecdsa_secp256r1.nr#L2-L9</a></sub></sup>
+
+
+example:
+
+```rust
+fn main(hashed_message : [u8;32], pub_key_x : [u8;32], pub_key_y : [u8;32], signature : [u8;64]) {
+     let valid_signature = std::ecdsa_secp256r1::verify_signature(pub_key_x, pub_key_y, signature, hashed_message);
+     assert(valid_signature);
+}
+```
+
+<BlackBoxInfo to="../black_box_fns"/>
+
+## ecdsa_secp256r1::verify_signature
+
+Verifier for ECDSA Secp256r1 signatures where the message is a slice.
+
+```rust title="ecdsa_secp256r1_slice" showLineNumbers 
+pub fn verify_signature_slice(
+    public_key_x: [u8; 32],
+    public_key_y: [u8; 32],
+    signature: [u8; 64],
+    message_hash: [u8],
+) -> bool
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/ecdsa_secp256r1.nr#L13-L20" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/ecdsa_secp256r1.nr#L13-L20</a></sub></sup>
+
+
+<BlackBoxInfo to="../black_box_fns"/>
diff --git a/docs/versioned_docs/version-v0.37.0/noir/standard_library/cryptographic_primitives/eddsa.mdx b/docs/versioned_docs/version-v0.37.0/noir/standard_library/cryptographic_primitives/eddsa.mdx
new file mode 100644
index 00000000000..b283de693c8
--- /dev/null
+++ b/docs/versioned_docs/version-v0.37.0/noir/standard_library/cryptographic_primitives/eddsa.mdx
@@ -0,0 +1,37 @@
+---
+title: EdDSA Verification
+description: Learn about the cryptographic primitives regarding EdDSA
+keywords: [cryptographic primitives, Noir project, eddsa, signatures]
+sidebar_position: 5
+---
+
+import BlackBoxInfo from '@site/src/components/Notes/_blackbox';
+
+## eddsa::eddsa_poseidon_verify
+
+Verifier for EdDSA signatures
+
+```rust
+fn eddsa_poseidon_verify(public_key_x : Field, public_key_y : Field, signature_s: Field, signature_r8_x: Field, signature_r8_y: Field, message: Field) -> bool
+```
+
+It is also possible to specify the hash algorithm used for the signature by using the `eddsa_verify` function by passing a type implementing the Hasher trait with the turbofish operator. 
+For instance, if you want to use Poseidon2 instead, you can do the following:
+```rust
+use std::hash::poseidon2::Poseidon2Hasher;
+
+eddsa_verify::<Poseidon2Hasher>(pub_key_a.x, pub_key_a.y, s_a, r8_a.x, r8_a.y, msg);
+```
+
+<BlackBoxInfo to="../black_box_fns"/>
+
+## eddsa::eddsa_to_pub
+
+Private to public key conversion.
+
+Returns `(pub_key_x, pub_key_y)`
+
+```rust
+fn eddsa_to_pub(secret : Field) -> (Field, Field)
+```
+
diff --git a/docs/versioned_docs/version-v0.37.0/noir/standard_library/cryptographic_primitives/embedded_curve_ops.mdx b/docs/versioned_docs/version-v0.37.0/noir/standard_library/cryptographic_primitives/embedded_curve_ops.mdx
new file mode 100644
index 00000000000..482a36932b9
--- /dev/null
+++ b/docs/versioned_docs/version-v0.37.0/noir/standard_library/cryptographic_primitives/embedded_curve_ops.mdx
@@ -0,0 +1,95 @@
+---
+title: Scalar multiplication
+description: See how you can perform scalar multiplication in Noir
+keywords: [cryptographic primitives, Noir project, scalar multiplication]
+sidebar_position: 1
+---
+
+import BlackBoxInfo from '@site/src/components/Notes/_blackbox';
+
+The following functions perform operations over the embedded curve whose coordinates are defined by the configured noir field.
+For the BN254 scalar field, this is BabyJubJub or Grumpkin.
+
+:::note
+Suffixes `_low` and `_high` denote low and high limbs of a scalar.
+:::
+
+## embedded_curve_ops::multi_scalar_mul
+
+Performs multi scalar multiplication over the embedded curve.
+The function accepts arbitrary amount of point-scalar pairs on the input, it multiplies the individual pairs over
+the curve and returns a sum of the resulting points.
+
+Points represented as x and y coordinates [x1, y1, x2, y2, ...], scalars as low and high limbs [low1, high1, low2, high2, ...].
+
+```rust title="multi_scalar_mul" showLineNumbers 
+pub fn multi_scalar_mul<let N: u32>(
+    points: [EmbeddedCurvePoint; N],
+    scalars: [EmbeddedCurveScalar; N],
+) -> EmbeddedCurvePoint
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/embedded_curve_ops.nr#L103-L108" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/embedded_curve_ops.nr#L103-L108</a></sub></sup>
+
+
+example
+
+```rust
+fn main(point_x: Field, point_y: Field, scalar_low: Field, scalar_high: Field) {
+    let point = std::embedded_curve_ops::multi_scalar_mul([point_x, point_y], [scalar_low, scalar_high]);
+    println(point);
+}
+```
+
+## embedded_curve_ops::fixed_base_scalar_mul
+
+Performs fixed base scalar multiplication over the embedded curve (multiplies input scalar with a generator point).
+The function accepts a single scalar on the input represented as 2 fields.
+
+```rust title="fixed_base_scalar_mul" showLineNumbers 
+pub fn fixed_base_scalar_mul(scalar: EmbeddedCurveScalar) -> EmbeddedCurvePoint
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/embedded_curve_ops.nr#L120-L122" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/embedded_curve_ops.nr#L120-L122</a></sub></sup>
+
+
+example
+
+```rust
+fn main(scalar_low: Field, scalar_high: Field) {
+    let point = std::embedded_curve_ops::fixed_base_scalar_mul(scalar_low, scalar_high);
+    println(point);
+}
+```
+
+## embedded_curve_ops::embedded_curve_add
+
+Adds two points on the embedded curve.
+This function takes two `EmbeddedCurvePoint` structures as parameters, representing points on the curve, and returns a new `EmbeddedCurvePoint` structure that represents their sum.
+
+### Parameters:
+- `point1` (`EmbeddedCurvePoint`): The first point to add.
+- `point2` (`EmbeddedCurvePoint`): The second point to add.
+
+### Returns:
+- `EmbeddedCurvePoint`: The resulting point after the addition of `point1` and `point2`.
+
+```rust title="embedded_curve_add" showLineNumbers 
+pub fn embedded_curve_add(
+    point1: EmbeddedCurvePoint,
+    point2: EmbeddedCurvePoint,
+) -> EmbeddedCurvePoint {
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/embedded_curve_ops.nr#L136-L141" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/embedded_curve_ops.nr#L136-L141</a></sub></sup>
+
+
+example
+
+```rust
+fn main() {
+    let point1 = EmbeddedCurvePoint { x: 1, y: 2 };
+    let point2 = EmbeddedCurvePoint { x: 3, y: 4 };
+    let result = std::embedded_curve_ops::embedded_curve_add(point1, point2);
+    println!("Resulting Point: ({}, {})", result.x, result.y);
+}
+```
+
+<BlackBoxInfo to="../black_box_fns"/>
diff --git a/docs/versioned_docs/version-v0.37.0/noir/standard_library/cryptographic_primitives/hashes.mdx b/docs/versioned_docs/version-v0.37.0/noir/standard_library/cryptographic_primitives/hashes.mdx
new file mode 100644
index 00000000000..541a1971561
--- /dev/null
+++ b/docs/versioned_docs/version-v0.37.0/noir/standard_library/cryptographic_primitives/hashes.mdx
@@ -0,0 +1,227 @@
+---
+title: Hash methods
+description:
+  Learn about the cryptographic primitives ready to use for any Noir project, including sha256,
+  blake2s and pedersen
+keywords:
+  [cryptographic primitives, Noir project, sha256, blake2s, pedersen, hash]
+sidebar_position: 0
+---
+
+import BlackBoxInfo from '@site/src/components/Notes/_blackbox';
+
+## sha256
+
+Given an array of bytes, returns the resulting sha256 hash.
+Specify a message_size to hash only the first `message_size` bytes of the input.
+
+```rust title="sha256" showLineNumbers 
+pub fn sha256<let N: u32>(input: [u8; N]) -> HASH
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/hash/sha256.nr#L47-L49" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/hash/sha256.nr#L47-L49</a></sub></sup>
+
+
+example:
+```rust title="sha256_var" showLineNumbers 
+let digest = std::hash::sha256_var([x as u8], 1);
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/test_programs/execution_success/sha256/src/main.nr#L15-L17" target="_blank" rel="noopener noreferrer">Source code: test_programs/execution_success/sha256/src/main.nr#L15-L17</a></sub></sup>
+
+
+```rust
+fn main() {
+    let x = [163, 117, 178, 149]; // some random bytes
+    let hash = std::sha256::sha256_var(x, 4);
+}
+```
+
+
+<BlackBoxInfo to="../black_box_fns"/>
+
+## blake2s
+
+Given an array of bytes, returns an array with the Blake2 hash
+
+```rust title="blake2s" showLineNumbers 
+pub fn blake2s<let N: u32>(input: [u8; N]) -> [u8; 32]
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/hash/mod.nr#L18-L20" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/hash/mod.nr#L18-L20</a></sub></sup>
+
+
+example:
+
+```rust
+fn main() {
+    let x = [163, 117, 178, 149]; // some random bytes
+    let hash = std::hash::blake2s(x);
+}
+```
+
+<BlackBoxInfo to="../black_box_fns"/>
+
+## blake3
+
+Given an array of bytes, returns an array with the Blake3 hash
+
+```rust title="blake3" showLineNumbers 
+pub fn blake3<let N: u32>(input: [u8; N]) -> [u8; 32]
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/hash/mod.nr#L24-L26" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/hash/mod.nr#L24-L26</a></sub></sup>
+
+
+example:
+
+```rust
+fn main() {
+    let x = [163, 117, 178, 149]; // some random bytes
+    let hash = std::hash::blake3(x);
+}
+```
+
+<BlackBoxInfo to="../black_box_fns"/>
+
+## pedersen_hash
+
+Given an array of Fields, returns the Pedersen hash.
+
+```rust title="pedersen_hash" showLineNumbers 
+pub fn pedersen_hash<let N: u32>(input: [Field; N]) -> Field
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/hash/mod.nr#L49-L51" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/hash/mod.nr#L49-L51</a></sub></sup>
+
+
+example:
+
+```rust title="pedersen-hash" showLineNumbers 
+fn main(x: Field, y: Field, expected_hash: Field) {
+    let hash = std::hash::pedersen_hash([x, y]);
+    assert_eq(hash, expected_hash);
+}
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/test_programs/execution_success/pedersen_hash/src/main.nr#L1-L6" target="_blank" rel="noopener noreferrer">Source code: test_programs/execution_success/pedersen_hash/src/main.nr#L1-L6</a></sub></sup>
+
+
+<BlackBoxInfo to="../black_box_fns" />
+
+## pedersen_commitment
+
+Given an array of Fields, returns the Pedersen commitment.
+
+```rust title="pedersen_commitment" showLineNumbers 
+pub fn pedersen_commitment<let N: u32>(input: [Field; N]) -> EmbeddedCurvePoint {
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/hash/mod.nr#L29-L31" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/hash/mod.nr#L29-L31</a></sub></sup>
+
+
+example:
+
+```rust title="pedersen-commitment" showLineNumbers 
+fn main(x: Field, y: Field, expected_commitment: std::embedded_curve_ops::EmbeddedCurvePoint) {
+    let commitment = std::hash::pedersen_commitment([x, y]);
+    assert_eq(commitment.x, expected_commitment.x);
+    assert_eq(commitment.y, expected_commitment.y);
+}
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/test_programs/execution_success/pedersen_commitment/src/main.nr#L1-L7" target="_blank" rel="noopener noreferrer">Source code: test_programs/execution_success/pedersen_commitment/src/main.nr#L1-L7</a></sub></sup>
+
+
+<BlackBoxInfo to="../black_box_fns"/>
+
+## keccak256
+
+Given an array of bytes (`u8`), returns the resulting keccak hash as an array of
+32 bytes (`[u8; 32]`). Specify a message_size to hash only the first
+`message_size` bytes of the input.
+
+```rust title="keccak256" showLineNumbers 
+pub fn keccak256<let N: u32>(input: [u8; N], message_size: u32) -> [u8; 32]
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/hash/mod.nr#L116-L118" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/hash/mod.nr#L116-L118</a></sub></sup>
+
+
+example:
+
+```rust title="keccak256" showLineNumbers 
+fn main(x: Field, result: [u8; 32]) {
+    // We use the `as` keyword here to denote the fact that we want to take just the first byte from the x Field
+    // The padding is taken care of by the program
+    let digest = std::hash::keccak256([x as u8], 1);
+    assert(digest == result);
+
+    //#1399: variable message size
+    let message_size = 4;
+    let hash_a = std::hash::keccak256([1, 2, 3, 4], message_size);
+    let hash_b = std::hash::keccak256([1, 2, 3, 4, 0, 0, 0, 0], message_size);
+
+    assert(hash_a == hash_b);
+
+    let message_size_big = 8;
+    let hash_c = std::hash::keccak256([1, 2, 3, 4, 0, 0, 0, 0], message_size_big);
+
+    assert(hash_a != hash_c);
+}
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/test_programs/execution_success/keccak256/src/main.nr#L1-L20" target="_blank" rel="noopener noreferrer">Source code: test_programs/execution_success/keccak256/src/main.nr#L1-L20</a></sub></sup>
+
+
+<BlackBoxInfo to="../black_box_fns"/>
+
+## poseidon
+
+Given an array of Fields, returns a new Field with the Poseidon Hash. Mind that you need to specify
+how many inputs are there to your Poseidon function.
+
+```rust
+// example for hash_1, hash_2 accepts an array of length 2, etc
+fn hash_1(input: [Field; 1]) -> Field
+```
+
+example:
+
+```rust title="poseidon" showLineNumbers 
+use std::hash::poseidon;
+
+fn main(x1: [Field; 2], y1: pub Field, x2: [Field; 4], y2: pub Field) {
+    let hash1 = poseidon::bn254::hash_2(x1);
+    assert(hash1 == y1);
+
+    let hash2 = poseidon::bn254::hash_4(x2);
+    assert(hash2 == y2);
+}
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/test_programs/execution_success/poseidon_bn254_hash/src/main.nr#L1-L11" target="_blank" rel="noopener noreferrer">Source code: test_programs/execution_success/poseidon_bn254_hash/src/main.nr#L1-L11</a></sub></sup>
+
+
+## poseidon 2
+
+Given an array of Fields, returns a new Field with the Poseidon2 Hash. Contrary to the Poseidon
+function, there is only one hash and you can specify a message_size to hash only the first 
+`message_size` bytes of the input,
+
+```rust
+// example for hashing the first three elements of the input
+Poseidon2::hash(input, 3);
+```
+
+example:
+
+```rust title="poseidon2" showLineNumbers 
+use std::hash::poseidon2;
+
+fn main(inputs: [Field; 4], expected_hash: Field) {
+    let hash = poseidon2::Poseidon2::hash(inputs, inputs.len());
+    assert_eq(hash, expected_hash);
+}
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/test_programs/execution_success/poseidon2/src/main.nr#L1-L8" target="_blank" rel="noopener noreferrer">Source code: test_programs/execution_success/poseidon2/src/main.nr#L1-L8</a></sub></sup>
+
+
+## hash_to_field
+
+```rust
+fn hash_to_field(_input : [Field]) -> Field {}
+```
+
+Calculates the `blake2s` hash of the inputs and returns the hash modulo the field modulus to return
+a value which can be represented as a `Field`.
+
diff --git a/docs/versioned_docs/version-v0.37.0/noir/standard_library/cryptographic_primitives/index.md b/docs/versioned_docs/version-v0.37.0/noir/standard_library/cryptographic_primitives/index.md
new file mode 100644
index 00000000000..650f30165d5
--- /dev/null
+++ b/docs/versioned_docs/version-v0.37.0/noir/standard_library/cryptographic_primitives/index.md
@@ -0,0 +1,14 @@
+---
+title: Cryptographic Primitives
+description:
+  Learn about the cryptographic primitives ready to use for any Noir project
+keywords:
+  [
+    cryptographic primitives,
+    Noir project,
+  ]
+---
+
+The Noir team is progressively adding new cryptographic primitives to the standard library. Reach out for news or if you would be interested in adding more of these calculations in Noir.
+
+Some methods are available thanks to the Aztec backend, not being performed using Noir. When using other backends, these methods may or may not be supplied.
diff --git a/docs/versioned_docs/version-v0.37.0/noir/standard_library/cryptographic_primitives/schnorr.mdx b/docs/versioned_docs/version-v0.37.0/noir/standard_library/cryptographic_primitives/schnorr.mdx
new file mode 100644
index 00000000000..030452645c5
--- /dev/null
+++ b/docs/versioned_docs/version-v0.37.0/noir/standard_library/cryptographic_primitives/schnorr.mdx
@@ -0,0 +1,64 @@
+---
+title: Schnorr Signatures
+description: Learn how you can verify Schnorr signatures using Noir
+keywords: [cryptographic primitives, Noir project, schnorr, signatures]
+sidebar_position: 2
+---
+
+import BlackBoxInfo from '@site/src/components/Notes/_blackbox';
+
+## schnorr::verify_signature
+
+Verifier for Schnorr signatures over the embedded curve (for BN254 it is Grumpkin).
+See schnorr::verify_signature_slice for a version that works directly on slices.
+
+```rust title="schnorr_verify" showLineNumbers 
+pub fn verify_signature<let N: u32>(
+    public_key_x: Field,
+    public_key_y: Field,
+    signature: [u8; 64],
+    message: [u8; N],
+) -> bool
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/schnorr.nr#L4-L11" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/schnorr.nr#L4-L11</a></sub></sup>
+
+
+where `_signature` can be generated like so using the npm package
+[@noir-lang/barretenberg](https://www.npmjs.com/package/@noir-lang/barretenberg)
+
+```js
+const { BarretenbergWasm } = require('@noir-lang/barretenberg/dest/wasm');
+const { Schnorr } = require('@noir-lang/barretenberg/dest/crypto/schnorr');
+
+...
+
+const barretenberg = await BarretenbergWasm.new();
+const schnorr = new Schnorr(barretenberg);
+const pubKey = schnorr.computePublicKey(privateKey);
+const message = ...
+const signature = Array.from(
+    schnorr.constructSignature(hash, privateKey).toBuffer()
+);
+
+...
+```
+
+<BlackBoxInfo to="../black_box_fns"/>
+
+## schnorr::verify_signature_slice
+
+Verifier for Schnorr signatures over the embedded curve (for BN254 it is Grumpkin)
+where the message is a slice. 
+
+```rust title="schnorr_verify_slice" showLineNumbers 
+pub fn verify_signature_slice(
+    public_key_x: Field,
+    public_key_y: Field,
+    signature: [u8; 64],
+    message: [u8],
+) -> bool
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/schnorr.nr#L15-L22" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/schnorr.nr#L15-L22</a></sub></sup>
+
+
+<BlackBoxInfo to="../black_box_fns"/>
diff --git a/docs/versioned_docs/version-v0.37.0/noir/standard_library/fmtstr.md b/docs/versioned_docs/version-v0.37.0/noir/standard_library/fmtstr.md
new file mode 100644
index 00000000000..19809d60261
--- /dev/null
+++ b/docs/versioned_docs/version-v0.37.0/noir/standard_library/fmtstr.md
@@ -0,0 +1,17 @@
+---
+title: fmtstr
+---
+
+`fmtstr<N, T>` is the type resulting from using format string (`f"..."`).
+
+## Methods
+
+### quoted_contents
+
+```rust title="quoted_contents" showLineNumbers 
+pub comptime fn quoted_contents(self) -> Quoted {}
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/meta/format_string.nr#L3-L5" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/meta/format_string.nr#L3-L5</a></sub></sup>
+
+
+Returns the format string contents (that is, without the leading and trailing double quotes) as a `Quoted` value.
\ No newline at end of file
diff --git a/docs/versioned_docs/version-v0.37.0/noir/standard_library/is_unconstrained.md b/docs/versioned_docs/version-v0.37.0/noir/standard_library/is_unconstrained.md
new file mode 100644
index 00000000000..51bb1bda8f1
--- /dev/null
+++ b/docs/versioned_docs/version-v0.37.0/noir/standard_library/is_unconstrained.md
@@ -0,0 +1,69 @@
+---
+title: Is Unconstrained Function
+description:
+  The is_unconstrained function returns wether the context at that point of the program is unconstrained or not.
+keywords:
+  [
+    unconstrained
+  ]
+---
+
+It's very common for functions in circuits to take unconstrained hints of an expensive computation and then verify it. This is done by running the hint in an unconstrained context and then verifying the result in a constrained context.
+
+When a function is marked as unconstrained, any subsequent functions that it calls will also be run in an unconstrained context. However, if we are implementing a library function, other users might call it within an unconstrained context or a constrained one. Generally, in an unconstrained context we prefer just computing the result instead of taking a hint of it and verifying it, since that'd mean doing the same computation twice:
+
+```rust 
+
+fn my_expensive_computation(){
+  ...
+}
+
+unconstrained fn my_expensive_computation_hint(){
+  my_expensive_computation()
+}
+
+pub fn external_interface(){
+  my_expensive_computation_hint();
+  // verify my_expensive_computation: If external_interface is called from unconstrained, this is redundant
+  ...
+}
+
+```
+
+In order to improve the performance in an unconstrained context you can use the function at `std::runtime::is_unconstrained() -> bool`:
+
+
+```rust 
+use dep::std::runtime::is_unconstrained;
+
+fn my_expensive_computation(){
+  ...
+}
+
+unconstrained fn my_expensive_computation_hint(){
+  my_expensive_computation()
+}
+
+pub fn external_interface(){
+  if is_unconstrained() {
+    my_expensive_computation();
+  } else {
+    my_expensive_computation_hint();
+    // verify my_expensive_computation
+    ...
+  }
+}
+
+```
+
+The is_unconstrained result is resolved at compile time, so in unconstrained contexts the compiler removes the else branch, and in constrained contexts the compiler removes the if branch, reducing the amount of compute necessary to run external_interface.
+
+Note that using `is_unconstrained` in a `comptime` context will also return `true`:
+
+```
+fn main() {
+    comptime {
+        assert(is_unconstrained());
+    }
+}
+```
diff --git a/docs/versioned_docs/version-v0.37.0/noir/standard_library/logging.md b/docs/versioned_docs/version-v0.37.0/noir/standard_library/logging.md
new file mode 100644
index 00000000000..db75ef9f86f
--- /dev/null
+++ b/docs/versioned_docs/version-v0.37.0/noir/standard_library/logging.md
@@ -0,0 +1,78 @@
+---
+title: Logging
+description:
+  Learn how to use the println statement for debugging in Noir with this tutorial. Understand the
+  basics of logging in Noir and how to implement it in your code.
+keywords:
+  [
+    noir logging,
+    println statement,
+    print statement,
+    debugging in noir,
+    noir std library,
+    logging tutorial,
+    basic logging in noir,
+    noir logging implementation,
+    noir debugging techniques,
+    rust,
+  ]
+---
+
+The standard library provides two familiar statements you can use: `println` and `print`. Despite being a limited implementation of rust's `println!` and `print!` macros, these constructs can be useful for debugging.
+
+You can print the output of both statements in your Noir code by using the `nargo execute` command or the `--show-output` flag when using `nargo test` (provided there are print statements in your tests).
+
+It is recommended to use `nargo execute` if you want to debug failing constraints with `println` or `print` statements. This is due to every input in a test being a constant rather than a witness, so we issue an error during compilation while we only print during execution (which comes after compilation). Neither `println`, nor `print` are callable for failed constraints caught at compile time.
+
+Both `print` and `println` are generic functions which can work on integers, fields, strings, and even structs or expressions. Note however, that slices are currently unsupported. For example:
+
+```rust
+struct Person {
+    age: Field,
+    height: Field,
+}
+
+fn main(age: Field, height: Field) {
+    let person = Person {
+        age: age,
+        height: height,
+    };
+    println(person);
+    println(age + height);
+    println("Hello world!");
+}
+```
+
+You can print different types in the same statement (including strings) with a type called `fmtstr`. It can be specified in the same way as a normal string, just prepended with an "f" character:
+
+```rust
+  let fmt_str = f"i: {i}, j: {j}";
+  println(fmt_str);
+
+  let s = myStruct { y: x, x: y };
+  println(s);
+
+  println(f"i: {i}, s: {s}");
+
+  println(x);
+  println([x, y]);
+
+  let foo = fooStruct { my_struct: s, foo: 15 };
+  println(f"s: {s}, foo: {foo}");
+
+  println(15);       // prints 0x0f, implicit Field
+  println(-1 as u8); // prints 255
+  println(-1 as i8); // prints -1
+```
+
+Examples shown above are interchangeable between the two `print` statements:
+
+```rust
+let person = Person { age : age, height : height };
+
+println(person);
+print(person);
+
+println("Hello world!"); // Prints with a newline at the end of the input
+print("Hello world!");   // Prints the input and keeps cursor on the same line
+```
diff --git a/docs/versioned_docs/version-v0.37.0/noir/standard_library/mem.md b/docs/versioned_docs/version-v0.37.0/noir/standard_library/mem.md
new file mode 100644
index 00000000000..95d36ac2a72
--- /dev/null
+++ b/docs/versioned_docs/version-v0.37.0/noir/standard_library/mem.md
@@ -0,0 +1,52 @@
+---
+title: Memory Module
+description:
+  This module contains functions which manipulate memory in a low-level way
+keywords:
+  [
+    mem, memory, zeroed, transmute, checked_transmute
+  ]
+---
+
+# `std::mem::zeroed`
+
+```rust
+fn zeroed<T>() -> T
+```
+
+Returns a zeroed value of any type.
+This function is generally unsafe to use as the zeroed bit pattern is not guaranteed to be valid for all types.
+It can however, be useful in cases when the value is guaranteed not to be used such as in a BoundedVec library implementing a growable vector, up to a certain length, backed by an array.
+The array can be initialized with zeroed values which are guaranteed to be inaccessible until the vector is pushed to.
+Similarly, enumerations in noir can be implemented using this method by providing zeroed values for the unused variants.
+
+This function currently supports the following types:
+
+- Field
+- Bool
+- Uint
+- Array
+- Slice
+- String
+- Tuple
+- Functions
+  
+Using it on other types could result in unexpected behavior.
+
+# `std::mem::checked_transmute`
+
+```rust
+fn checked_transmute<T, U>(value: T) -> U
+```
+
+Transmutes a value of one type into the same value but with a new type `U`.
+
+This function is safe to use since both types are asserted to be equal later during compilation after the concrete values for generic types become known.
+This function is useful for cases where the compiler may fails a type check that is expected to pass where
+a user knows the two types to be equal. For example, when using arithmetic generics there are cases the compiler
+does not see as equal, such as `[Field; N*(A + B)]` and `[Field; N*A + N*B]`, which users may know to be equal.
+In these cases, `checked_transmute` can be used to cast the value to the desired type while also preserving safety
+by checking this equality once `N`, `A`, `B` are fully resolved.
+
+Note that since this safety check is performed after type checking rather than during, no error is issued if the function
+containing `checked_transmute` is never called.
diff --git a/docs/versioned_docs/version-v0.37.0/noir/standard_library/merkle_trees.md b/docs/versioned_docs/version-v0.37.0/noir/standard_library/merkle_trees.md
new file mode 100644
index 00000000000..6a9ebf72ada
--- /dev/null
+++ b/docs/versioned_docs/version-v0.37.0/noir/standard_library/merkle_trees.md
@@ -0,0 +1,58 @@
+---
+title: Merkle Trees
+description: Learn about Merkle Trees in Noir with this tutorial. Explore the basics of computing a merkle root using a proof, with examples.
+keywords:
+  [
+    Merkle trees in Noir,
+    Noir programming language,
+    check membership,
+    computing root from leaf,
+    Noir Merkle tree implementation,
+    Merkle tree tutorial,
+    Merkle tree code examples,
+    Noir libraries,
+    pedersen hash.,
+  ]
+---
+
+## compute_merkle_root
+
+Returns the root of the tree from the provided leaf and its hash path, using a [Pedersen hash](./cryptographic_primitives/hashes.mdx#pedersen_hash).
+
+```rust
+fn compute_merkle_root(leaf : Field, index : Field, hash_path: [Field]) -> Field
+```
+
+example:
+
+```rust
+/**
+    // these values are for this example only
+    index = "0"
+    priv_key = "0x000000000000000000000000000000000000000000000000000000616c696365"
+    secret = "0x1929ea3ab8d9106a899386883d9428f8256cfedb3c4f6b66bf4aa4d28a79988f"
+    note_hash_path = [
+    "0x1e61bdae0f027b1b2159e1f9d3f8d00fa668a952dddd822fda80dc745d6f65cc",
+    "0x0e4223f3925f98934393c74975142bd73079ab0621f4ee133cee050a3c194f1a",
+    "0x2fd7bb412155bf8693a3bd2a3e7581a679c95c68a052f835dddca85fa1569a40"
+    ]
+ */
+fn main(index: Field, priv_key: Field, secret: Field, note_hash_path: [Field; 3]) {
+
+    let pubkey = std::scalar_mul::fixed_base_embedded_curve(priv_key);
+    let pubkey_x = pubkey[0];
+    let pubkey_y = pubkey[1];
+    let note_commitment = std::hash::pedersen(&[pubkey_x, pubkey_y, secret]);
+
+    let root = std::merkle::compute_merkle_root(note_commitment[0], index, note_hash_path.as_slice());
+    println(root);
+}
+```
+
+To check merkle tree membership:
+
+1. Include a merkle root as a program input.
+2. Compute the merkle root of a given leaf, index and hash path.
+3. Assert the merkle roots are equal.
+
+For more info about merkle trees, see the Wikipedia [page](https://en.wikipedia.org/wiki/Merkle_tree).
diff --git a/docs/versioned_docs/version-v0.37.0/noir/standard_library/meta/ctstring.md b/docs/versioned_docs/version-v0.37.0/noir/standard_library/meta/ctstring.md
new file mode 100644
index 00000000000..b76f873ca03
--- /dev/null
+++ b/docs/versioned_docs/version-v0.37.0/noir/standard_library/meta/ctstring.md
@@ -0,0 +1,100 @@
+---
+title: CtString
+---
+
+`std::meta::ctstring` contains methods on the built-in `CtString` type which is
+a compile-time, dynamically-sized string type. Compared to `str<N>` and `fmtstr<N, T>`,
+`CtString` is useful because its size does not need to be specified in its type. This
+can be used for formatting items at compile-time or general string handling in `comptime`
+code.
+
+Since `fmtstr`s can be converted into `CtString`s, you can make use of their formatting
+abilities in CtStrings by formatting in `fmtstr`s then converting the result to a CtString
+afterward.
+
+## Traits
+
+### AsCtString
+
+```rust title="as-ctstring" showLineNumbers 
+pub trait AsCtString {
+    comptime fn as_ctstring(self) -> CtString;
+}
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/meta/ctstring.nr#L43-L47" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/meta/ctstring.nr#L43-L47</a></sub></sup>
+
+
+Converts an object into a compile-time string.
+
+Implementations:
+
+```rust
+impl<let N: u32> AsCtString for str<N> { ... }
+impl<let N: u32, T> AsCtString for fmtstr<N, T> { ... }
+```
+
+## Methods
+
+### new
+
+```rust title="new" showLineNumbers 
+pub comptime fn new() -> Self {
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/meta/ctstring.nr#L4-L6" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/meta/ctstring.nr#L4-L6</a></sub></sup>
+
+
+Creates an empty `CtString`.
+
+### append_str
+
+```rust title="append_str" showLineNumbers 
+pub comptime fn append_str<let N: u32>(self, s: str<N>) -> Self {
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/meta/ctstring.nr#L11-L13" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/meta/ctstring.nr#L11-L13</a></sub></sup>
+
+
+Returns a new CtString with the given str appended onto the end.
+
+### append_fmtstr
+
+```rust title="append_fmtstr" showLineNumbers 
+pub comptime fn append_fmtstr<let N: u32, T>(self, s: fmtstr<N, T>) -> Self {
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/meta/ctstring.nr#L17-L19" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/meta/ctstring.nr#L17-L19</a></sub></sup>
+
+
+Returns a new CtString with the given fmtstr appended onto the end.
+
+### as_quoted_str
+
+```rust title="as_quoted_str" showLineNumbers 
+pub comptime fn as_quoted_str(self) -> Quoted {
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/meta/ctstring.nr#L26-L28" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/meta/ctstring.nr#L26-L28</a></sub></sup>
+
+
+Returns a quoted string literal from this string's contents.
+
+There is no direct conversion from a `CtString` to a `str<N>` since
+the size would not be known. To get around this, this function can
+be used in combination with macro insertion (`!`) to insert this string
+literal at this function's call site.
+
+Example:
+
+```rust title="as_quoted_str_example" showLineNumbers 
+let my_ctstring = "foo bar".as_ctstring();
+            let my_str = my_ctstring.as_quoted_str!();
+
+            assert_eq(crate::meta::type_of(my_str), quote { str<7> }.as_type());
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/meta/ctstring.nr#L92-L97" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/meta/ctstring.nr#L92-L97</a></sub></sup>
+
+
+## Trait Implementations
+
+```rust
+impl Eq for CtString
+impl Hash for CtString
+impl Append for CtString
+```
diff --git a/docs/versioned_docs/version-v0.37.0/noir/standard_library/meta/expr.md b/docs/versioned_docs/version-v0.37.0/noir/standard_library/meta/expr.md
new file mode 100644
index 00000000000..b6d395c6700
--- /dev/null
+++ b/docs/versioned_docs/version-v0.37.0/noir/standard_library/meta/expr.md
@@ -0,0 +1,380 @@
+---
+title: Expr
+---
+
+`std::meta::expr` contains methods on the built-in `Expr` type for quoted, syntactically valid expressions.
+
+## Methods
+
+### as_array
+
+```rust title="as_array" showLineNumbers 
+pub comptime fn as_array(self) -> Option<[Expr]> {}
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/meta/expr.nr#L10-L12" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/meta/expr.nr#L10-L12</a></sub></sup>
+
+
+If this expression is an array, this returns a slice of each element in the array.
+
+### as_assert
+
+```rust title="as_assert" showLineNumbers 
+pub comptime fn as_assert(self) -> Option<(Expr, Option<Expr>)> {}
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/meta/expr.nr#L16-L18" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/meta/expr.nr#L16-L18</a></sub></sup>
+
+
+If this expression is an assert, this returns the assert expression and the optional message.
+
+### as_assert_eq
+
+```rust title="as_assert_eq" showLineNumbers 
+pub comptime fn as_assert_eq(self) -> Option<(Expr, Expr, Option<Expr>)> {}
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/meta/expr.nr#L23-L25" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/meta/expr.nr#L23-L25</a></sub></sup>
+
+
+If this expression is an assert_eq, this returns the left-hand-side and right-hand-side
+expressions, together with the optional message.
+
+### as_assign
+
+```rust title="as_assign" showLineNumbers 
+pub comptime fn as_assign(self) -> Option<(Expr, Expr)> {}
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/meta/expr.nr#L30-L32" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/meta/expr.nr#L30-L32</a></sub></sup>
+
+
+If this expression is an assignment, this returns a tuple with the left hand side
+and right hand side in order.
+
+### as_binary_op
+
+```rust title="as_binary_op" showLineNumbers 
+pub comptime fn as_binary_op(self) -> Option<(Expr, BinaryOp, Expr)> {}
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/meta/expr.nr#L37-L39" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/meta/expr.nr#L37-L39</a></sub></sup>
+
+
+If this expression is a binary operator operation `<lhs> <op> <rhs>`,
+return the left-hand side, operator, and the right-hand side of the operation.
+
+### as_block
+
+```rust title="as_block" showLineNumbers 
+pub comptime fn as_block(self) -> Option<[Expr]> {}
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/meta/expr.nr#L44-L46" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/meta/expr.nr#L44-L46</a></sub></sup>
+
+
+If this expression is a block `{ stmt1; stmt2; ...; stmtN }`, return
+a slice containing each statement.
+
+### as_bool
+
+```rust title="as_bool" showLineNumbers 
+pub comptime fn as_bool(self) -> Option<bool> {}
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/meta/expr.nr#L50-L52" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/meta/expr.nr#L50-L52</a></sub></sup>
+
+
+If this expression is a boolean literal, return that literal.
+
+### as_cast
+
+```rust title="as_cast" showLineNumbers 
+#[builtin(expr_as_cast)]
+    pub comptime fn as_cast(self) -> Option<(Expr, UnresolvedType)> {}
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/meta/expr.nr#L56-L59" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/meta/expr.nr#L56-L59</a></sub></sup>
+
+
+If this expression is a cast expression (`expr as type`), returns the casted
+expression and the type to cast to.
+
+### as_comptime
+
+```rust title="as_comptime" showLineNumbers 
+pub comptime fn as_comptime(self) -> Option<[Expr]> {}
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/meta/expr.nr#L64-L66" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/meta/expr.nr#L64-L66</a></sub></sup>
+
+
+If this expression is a `comptime { stmt1; stmt2; ...; stmtN }` block,
+return each statement in the block.
+
+### as_constructor
+
+```rust title="as_constructor" showLineNumbers 
+pub comptime fn as_constructor(self) -> Option<(UnresolvedType, [(Quoted, Expr)])> {}
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/meta/expr.nr#L71-L73" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/meta/expr.nr#L71-L73</a></sub></sup>
+
+
+If this expression is a constructor `Type { field1: expr1, ..., fieldN: exprN }`,
+return the type and the fields.
+
+### as_for
+
+```rust title="as_for" showLineNumbers 
+pub comptime fn as_for(self) -> Option<(Quoted, Expr, Expr)> {}
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/meta/expr.nr#L78-L80" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/meta/expr.nr#L78-L80</a></sub></sup>
+
+
+If this expression is a for statement over a single expression, return the identifier,
+the expression and the for loop body.
+
+### as_for_range
+
+```rust title="as_for" showLineNumbers 
+pub comptime fn as_for(self) -> Option<(Quoted, Expr, Expr)> {}
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/meta/expr.nr#L78-L80" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/meta/expr.nr#L78-L80</a></sub></sup>
+
+
+If this expression is a for statement over a range, return the identifier,
+the range start, the range end and the for loop body.
+
+### as_function_call
+
+```rust title="as_function_call" showLineNumbers 
+pub comptime fn as_function_call(self) -> Option<(Expr, [Expr])> {}
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/meta/expr.nr#L92-L94" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/meta/expr.nr#L92-L94</a></sub></sup>
+
+
+If this expression is a function call `foo(arg1, ..., argN)`, return
+the function and a slice of each argument.
+
+### as_if
+
+```rust title="as_if" showLineNumbers 
+pub comptime fn as_if(self) -> Option<(Expr, Expr, Option<Expr>)> {}
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/meta/expr.nr#L100-L102" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/meta/expr.nr#L100-L102</a></sub></sup>
+
+
+If this expression is an `if condition { then_branch } else { else_branch }`,
+return the condition, then branch, and else branch. If there is no else branch,
+`None` is returned for that branch instead.
+
+### as_index
+
+```rust title="as_index" showLineNumbers 
+pub comptime fn as_index(self) -> Option<(Expr, Expr)> {}
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/meta/expr.nr#L107-L109" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/meta/expr.nr#L107-L109</a></sub></sup>
+
+
+If this expression is an index into an array `array[index]`, return the
+array and the index.
+
+### as_integer
+
+```rust title="as_integer" showLineNumbers 
+pub comptime fn as_integer(self) -> Option<(Field, bool)> {}
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/meta/expr.nr#L114-L116" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/meta/expr.nr#L114-L116</a></sub></sup>
+
+
+If this expression is an integer literal, return the integer as a field
+as well as whether the integer is negative (true) or not (false).
+
+### as_lambda
+
+```rust title="as_lambda" showLineNumbers 
+pub comptime fn as_lambda(
+        self,
+    ) -> Option<([(Expr, Option<UnresolvedType>)], Option<UnresolvedType>, Expr)> {}
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/meta/expr.nr#L120-L124" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/meta/expr.nr#L120-L124</a></sub></sup>
+
+
+If this expression is a lambda, returns the parameters, return type and body.
+
+### as_let
+
+```rust title="as_let" showLineNumbers 
+pub comptime fn as_let(self) -> Option<(Expr, Option<UnresolvedType>, Expr)> {}
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/meta/expr.nr#L129-L131" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/meta/expr.nr#L129-L131</a></sub></sup>
+
+
+If this expression is a let statement, returns the let pattern as an `Expr`,
+the optional type annotation, and the assigned expression.
+
+### as_member_access
+
+```rust title="as_member_access" showLineNumbers 
+pub comptime fn as_member_access(self) -> Option<(Expr, Quoted)> {}
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/meta/expr.nr#L136-L138" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/meta/expr.nr#L136-L138</a></sub></sup>
+
+
+If this expression is a member access `foo.bar`, return the struct/tuple
+expression and the field. The field will be represented as a quoted value.
+
+### as_method_call
+
+```rust title="as_method_call" showLineNumbers 
+pub comptime fn as_method_call(self) -> Option<(Expr, Quoted, [UnresolvedType], [Expr])> {}
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/meta/expr.nr#L143-L145" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/meta/expr.nr#L143-L145</a></sub></sup>
+
+
+If this expression is a method call `foo.bar::<generic1, ..., genericM>(arg1, ..., argN)`, return
+the receiver, method name, a slice of each generic argument, and a slice of each argument.
+
+### as_repeated_element_array
+
+```rust title="as_repeated_element_array" showLineNumbers 
+pub comptime fn as_repeated_element_array(self) -> Option<(Expr, Expr)> {}
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/meta/expr.nr#L150-L152" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/meta/expr.nr#L150-L152</a></sub></sup>
+
+
+If this expression is a repeated element array `[elem; length]`, return
+the repeated element and the length expressions.
+
+### as_repeated_element_slice
+
+```rust title="as_repeated_element_slice" showLineNumbers 
+pub comptime fn as_repeated_element_slice(self) -> Option<(Expr, Expr)> {}
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/meta/expr.nr#L157-L159" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/meta/expr.nr#L157-L159</a></sub></sup>
+
+
+If this expression is a repeated element slice `[elem; length]`, return
+the repeated element and the length expressions.
+
+### as_slice
+
+```rust title="as_slice" showLineNumbers 
+pub comptime fn as_slice(self) -> Option<[Expr]> {}
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/meta/expr.nr#L164-L166" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/meta/expr.nr#L164-L166</a></sub></sup>
+
+
+If this expression is a slice literal `&[elem1, ..., elemN]`,
+return each element of the slice.
+
+### as_tuple
+
+```rust title="as_tuple" showLineNumbers 
+pub comptime fn as_tuple(self) -> Option<[Expr]> {}
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/meta/expr.nr#L171-L173" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/meta/expr.nr#L171-L173</a></sub></sup>
+
+
+If this expression is a tuple `(field1, ..., fieldN)`,
+return each element of the tuple.
+
+### as_unary_op
+
+```rust title="as_unary_op" showLineNumbers 
+pub comptime fn as_unary_op(self) -> Option<(UnaryOp, Expr)> {}
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/meta/expr.nr#L178-L180" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/meta/expr.nr#L178-L180</a></sub></sup>
+
+
+If this expression is a unary operation `<op> <rhs>`,
+return the unary operator as well as the right-hand side expression.
+
+### as_unsafe
+
+```rust title="as_unsafe" showLineNumbers 
+pub comptime fn as_unsafe(self) -> Option<[Expr]> {}
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/meta/expr.nr#L185-L187" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/meta/expr.nr#L185-L187</a></sub></sup>
+
+
+If this expression is an `unsafe { stmt1; ...; stmtN }` block,
+return each statement inside in a slice.
+
+### has_semicolon
+
+```rust title="has_semicolon" showLineNumbers 
+pub comptime fn has_semicolon(self) -> bool {}
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/meta/expr.nr#L206-L208" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/meta/expr.nr#L206-L208</a></sub></sup>
+
+
+`true` if this expression is trailed by a semicolon. E.g.
+
+```
+comptime {
+    let expr1 = quote { 1 + 2 }.as_expr().unwrap();
+    let expr2 = quote { 1 + 2; }.as_expr().unwrap();
+
+    assert(expr1.as_binary_op().is_some());
+    assert(expr2.as_binary_op().is_some());
+
+    assert(!expr1.has_semicolon());
+    assert(expr2.has_semicolon());
+}
+```
+
+### is_break
+
+```rust title="is_break" showLineNumbers 
+pub comptime fn is_break(self) -> bool {}
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/meta/expr.nr#L212-L214" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/meta/expr.nr#L212-L214</a></sub></sup>
+
+
+`true` if this expression is `break`.
+
+### is_continue
+
+```rust title="is_continue" showLineNumbers 
+pub comptime fn is_continue(self) -> bool {}
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/meta/expr.nr#L218-L220" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/meta/expr.nr#L218-L220</a></sub></sup>
+
+
+`true` if this expression is `continue`.
+
+### modify
+
+```rust title="modify" showLineNumbers 
+pub comptime fn modify<Env>(self, f: fn[Env](Expr) -> Option<Expr>) -> Expr {
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/meta/expr.nr#L229-L231" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/meta/expr.nr#L229-L231</a></sub></sup>
+
+
+Applies a mapping function to this expression and to all of its sub-expressions.
+`f` will be applied to each sub-expression first, then applied to the expression itself.
+
+This happens recursively for every expression within `self`.
+
+For example, calling `modify` on `(&[1], &[2, 3])` with an `f` that returns `Option::some`
+for expressions that are integers, doubling them, would return `(&[2], &[4, 6])`.
+
+### quoted
+
+```rust title="quoted" showLineNumbers 
+pub comptime fn quoted(self) -> Quoted {
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/meta/expr.nr#L266-L268" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/meta/expr.nr#L266-L268</a></sub></sup>
+
+
+Returns this expression as a `Quoted` value. It's the same as `quote { $self }`.
+
+### resolve
+
+```rust title="resolve" showLineNumbers 
+pub comptime fn resolve(self, in_function: Option<FunctionDefinition>) -> TypedExpr {}
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/meta/expr.nr#L282-L284" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/meta/expr.nr#L282-L284</a></sub></sup>
+
+
+Resolves and type-checks this expression and returns the result as a `TypedExpr`. 
+
+The `in_function` argument specifies where the expression is resolved:
+- If it's `none`, the expression is resolved in the function where `resolve` was called
+- If it's `some`, the expression is resolved in the given function
+
+If any names used by this expression are not in scope or if there are any type errors, 
+this will give compiler errors as if the expression was written directly into 
+the current `comptime` function.
\ No newline at end of file
diff --git a/docs/versioned_docs/version-v0.37.0/noir/standard_library/meta/function_def.md b/docs/versioned_docs/version-v0.37.0/noir/standard_library/meta/function_def.md
new file mode 100644
index 00000000000..b7f2ebdb889
--- /dev/null
+++ b/docs/versioned_docs/version-v0.37.0/noir/standard_library/meta/function_def.md
@@ -0,0 +1,166 @@
+---
+title: FunctionDefinition
+---
+
+`std::meta::function_def` contains methods on the built-in `FunctionDefinition` type representing
+a function definition in the source program.
+
+## Methods
+
+### add_attribute
+
+```rust title="add_attribute" showLineNumbers 
+pub comptime fn add_attribute<let N: u32>(self, attribute: str<N>) {}
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/meta/function_def.nr#L3-L5" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/meta/function_def.nr#L3-L5</a></sub></sup>
+
+
+Adds an attribute to the function. This is only valid
+on functions in the current crate which have not yet been resolved.
+This means any functions called at compile-time are invalid targets for this method.
+
+### body
+
+```rust title="body" showLineNumbers 
+pub comptime fn body(self) -> Expr {}
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/meta/function_def.nr#L8-L10" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/meta/function_def.nr#L8-L10</a></sub></sup>
+
+
+Returns the body of the function as an expression. This is only valid
+on functions in the current crate which have not yet been resolved.
+This means any functions called at compile-time are invalid targets for this method.
+
+### has_named_attribute
+
+```rust title="has_named_attribute" showLineNumbers 
+pub comptime fn has_named_attribute<let N: u32>(self, name: str<N>) -> bool {}
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/meta/function_def.nr#L13-L15" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/meta/function_def.nr#L13-L15</a></sub></sup>
+
+
+Returns true if this function has a custom attribute with the given name.
+
+### is_unconstrained
+
+```rust title="is_unconstrained" showLineNumbers 
+pub comptime fn is_unconstrained(self) -> bool {}
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/meta/function_def.nr#L18-L20" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/meta/function_def.nr#L18-L20</a></sub></sup>
+
+
+Returns true if this function is unconstrained.
+
+### module
+
+```rust title="module" showLineNumbers 
+pub comptime fn module(self) -> Module {}
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/meta/function_def.nr#L23-L25" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/meta/function_def.nr#L23-L25</a></sub></sup>
+
+
+Returns the module where the function is defined.
+
+### name
+
+```rust title="name" showLineNumbers 
+pub comptime fn name(self) -> Quoted {}
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/meta/function_def.nr#L28-L30" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/meta/function_def.nr#L28-L30</a></sub></sup>
+
+
+Returns the name of the function.
+
+### parameters
+
+```rust title="parameters" showLineNumbers 
+pub comptime fn parameters(self) -> [(Quoted, Type)] {}
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/meta/function_def.nr#L33-L35" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/meta/function_def.nr#L33-L35</a></sub></sup>
+
+
+Returns each parameter of the function as a tuple of (parameter pattern, parameter type).
+
+### return_type
+
+```rust title="return_type" showLineNumbers 
+pub comptime fn return_type(self) -> Type {}
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/meta/function_def.nr#L38-L40" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/meta/function_def.nr#L38-L40</a></sub></sup>
+
+
+The return type of the function.
+
+### set_body
+
+```rust title="set_body" showLineNumbers 
+pub comptime fn set_body(self, body: Expr) {}
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/meta/function_def.nr#L43-L45" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/meta/function_def.nr#L43-L45</a></sub></sup>
+
+
+Mutate the function body to a new expression. This is only valid
+on functions in the current crate which have not yet been resolved.
+This means any functions called at compile-time are invalid targets for this method.
+
+### set_parameters
+
+```rust title="set_parameters" showLineNumbers 
+pub comptime fn set_parameters(self, parameters: [(Quoted, Type)]) {}
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/meta/function_def.nr#L48-L50" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/meta/function_def.nr#L48-L50</a></sub></sup>
+
+
+Mutates the function's parameters to a new set of parameters. This is only valid
+on functions in the current crate which have not yet been resolved.
+This means any functions called at compile-time are invalid targets for this method.
+
+Expects a slice of (parameter pattern, parameter type) for each parameter. Requires
+each parameter pattern to be a syntactically valid parameter.
+
+### set_return_type
+
+```rust title="set_return_type" showLineNumbers 
+pub comptime fn set_return_type(self, return_type: Type) {}
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/meta/function_def.nr#L53-L55" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/meta/function_def.nr#L53-L55</a></sub></sup>
+
+
+Mutates the function's return type to a new type. This is only valid
+on functions in the current crate which have not yet been resolved.
+This means any functions called at compile-time are invalid targets for this method.
+
+### set_return_public
+
+```rust title="set_return_public" showLineNumbers 
+pub comptime fn set_return_public(self, public: bool) {}
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/meta/function_def.nr#L58-L60" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/meta/function_def.nr#L58-L60</a></sub></sup>
+
+
+Mutates the function's return visibility to public (if `true` is given) or private (if `false` is given).
+This is only valid on functions in the current crate which have not yet been resolved.
+This means any functions called at compile-time are invalid targets for this method.
+
+### set_unconstrained
+
+```rust title="set_unconstrained" showLineNumbers 
+pub comptime fn set_unconstrained(self, value: bool) {}
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/meta/function_def.nr#L66-L68" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/meta/function_def.nr#L66-L68</a></sub></sup>
+
+
+Mutates the function to be unconstrained (if `true` is given) or not (if `false` is given).
+This is only valid on functions in the current crate which have not yet been resolved.
+This means any functions called at compile-time are invalid targets for this method.
+
+## Trait Implementations
+
+```rust
+impl Eq for FunctionDefinition
+impl Hash for FunctionDefinition
+```
+
+Note that each function is assigned a unique ID internally and this is what is used for
+equality and hashing. So even functions with identical signatures and bodies may not
+be equal in this sense if they were originally different items in the source program.
diff --git a/docs/versioned_docs/version-v0.37.0/noir/standard_library/meta/index.md b/docs/versioned_docs/version-v0.37.0/noir/standard_library/meta/index.md
new file mode 100644
index 00000000000..14544c07442
--- /dev/null
+++ b/docs/versioned_docs/version-v0.37.0/noir/standard_library/meta/index.md
@@ -0,0 +1,224 @@
+---
+title: Metaprogramming
+description: Noir's Metaprogramming API
+keywords: [metaprogramming, comptime, macros, macro, quote, unquote]
+---
+
+`std::meta` is the entry point for Noir's metaprogramming API. This consists of `comptime` functions
+and types used for inspecting and modifying Noir programs.
+
+## Functions
+
+### type_of
+
+```rust title="type_of" showLineNumbers 
+pub comptime fn type_of<T>(x: T) -> Type {}
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/meta/mod.nr#L27-L29" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/meta/mod.nr#L27-L29</a></sub></sup>
+
+
+Returns the type of a variable at compile-time.
+
+Example:
+```rust
+comptime {
+    let x: i32 = 1;
+    let x_type: Type = std::meta::type_of(x);
+
+    assert_eq(x_type, quote { i32 }.as_type());
+}
+```
+
+### unquote
+
+```rust title="unquote" showLineNumbers 
+pub comptime fn unquote(code: Quoted) -> Quoted {
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/meta/mod.nr#L19-L21" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/meta/mod.nr#L19-L21</a></sub></sup>
+
+
+Unquotes the passed-in token stream where this function was called.
+
+Example:
+```rust
+comptime {
+    let code = quote { 1 + 2 };
+
+    // let x = 1 + 2;
+    let x = unquote!(code);
+}
+```
+
+### derive
+
+```rust title="derive" showLineNumbers 
+#[varargs]
+pub comptime fn derive(s: StructDefinition, traits: [TraitDefinition]) -> Quoted {
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/meta/mod.nr#L48-L51" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/meta/mod.nr#L48-L51</a></sub></sup>
+
+
+Attribute placed on struct definitions.
+
+Creates a trait impl for each trait passed in as an argument.
+To do this, the trait must have a derive handler registered
+with `derive_via` beforehand. The traits in the stdlib that
+can be derived this way are `Eq`, `Ord`, `Default`, and `Hash`.
+
+Example:
+```rust
+#[derive(Eq, Default)]
+struct Foo<T> {
+    x: i32,
+    y: T,
+}
+
+fn main() {
+    let foo1 = Foo::default();
+    let foo2 = Foo { x: 0, y: &[0] };
+    assert_eq(foo1, foo2);
+}
+```
+
+### derive_via
+
+```rust title="derive_via_signature" showLineNumbers 
+pub comptime fn derive_via(t: TraitDefinition, f: DeriveFunction) {
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/meta/mod.nr#L68-L70" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/meta/mod.nr#L68-L70</a></sub></sup>
+
+
+Attribute placed on trait definitions.
+
+Registers a function to create impls for the given trait
+when the trait is used in a `derive` call. Users may use
+this to register their own functions to enable their traits
+to be derived by `derive`.
+
+Because this function requires a function as an argument which
+should produce a trait impl for any given struct, users may find
+it helpful to use a function like `std::meta::make_trait_impl` to
+help creating these impls.
+
+Example:
+```rust
+#[derive_via(derive_do_nothing)]
+trait DoNothing {
+    fn do_nothing(self);
+}
+
+comptime fn derive_do_nothing(s: StructDefinition) -> Quoted {
+    let typ = s.as_type();
+    quote {
+        impl DoNothing for $typ {
+            fn do_nothing(self) {
+                println("Nothing");
+            }
+        }
+    }
+}
+```
+
+As another example, `derive_eq` in the stdlib is used to derive the `Eq`
+trait for any struct. It makes use of `make_trait_impl` to do this:
+
+```rust title="derive_eq" showLineNumbers 
+comptime fn derive_eq(s: StructDefinition) -> Quoted {
+    let signature = quote { fn eq(_self: Self, _other: Self) -> bool };
+    let for_each_field = |name| quote { (_self.$name == _other.$name) };
+    let body = |fields| {
+        if s.fields().len() == 0 {
+            quote { true }
+        } else {
+            fields
+        }
+    };
+    crate::meta::make_trait_impl(
+        s,
+        quote { Eq },
+        signature,
+        for_each_field,
+        quote { & },
+        body,
+    )
+}
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/cmp.nr#L10-L30" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/cmp.nr#L10-L30</a></sub></sup>
+
+
+### make_trait_impl
+
+```rust title="make_trait_impl" showLineNumbers 
+pub comptime fn make_trait_impl<Env1, Env2>(
+    s: StructDefinition,
+    trait_name: Quoted,
+    function_signature: Quoted,
+    for_each_field: fn[Env1](Quoted) -> Quoted,
+    join_fields_with: Quoted,
+    body: fn[Env2](Quoted) -> Quoted,
+) -> Quoted {
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/meta/mod.nr#L87-L96" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/meta/mod.nr#L87-L96</a></sub></sup>
+
+
+A helper function to more easily create trait impls while deriving traits.
+
+Note that this function only works for traits which:
+1. Have only one method
+2. Have no generics on the trait itself.
+  - E.g. Using this on a trait such as `trait Foo<T> { ... }` will result in the
+    generated impl incorrectly missing the `T` generic.
+
+If your trait fits these criteria then `make_trait_impl` is likely the easiest
+way to write your derive handler. The arguments are as follows:
+
+- `s`: The struct to make the impl for
+- `trait_name`: The name of the trait to derive. E.g. `quote { Eq }`.
+- `function_signature`: The signature of the trait method to derive. E.g. `fn eq(self, other: Self) -> bool`.
+- `for_each_field`: An operation to be performed on each field. E.g. `|name| quote { (self.$name == other.$name) }`.
+- `join_fields_with`: A separator to join each result of `for_each_field` with.
+  E.g. `quote { & }`. You can also use an empty `quote {}` for no separator.
+- `body`: The result of the field operations are passed into this function for any final processing.
+  This is the place to insert any setup/teardown code the trait requires. If the trait doesn't require
+  any such code, you can return the body as-is: `|body| body`.
+
+Example deriving `Hash`:
+
+```rust title="derive_hash" showLineNumbers 
+comptime fn derive_hash(s: StructDefinition) -> Quoted {
+    let name = quote { Hash };
+    let signature = quote { fn hash<H>(_self: Self, _state: &mut H) where H: std::hash::Hasher };
+    let for_each_field = |name| quote { _self.$name.hash(_state); };
+    crate::meta::make_trait_impl(
+        s,
+        name,
+        signature,
+        for_each_field,
+        quote {},
+        |fields| fields,
+    )
+}
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/hash/mod.nr#L137-L151" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/hash/mod.nr#L137-L151</a></sub></sup>
+
+
+Example deriving `Ord`:
+
+```rust title="derive_ord" showLineNumbers 
+comptime fn derive_ord(s: StructDefinition) -> Quoted {
+    let signature = quote { fn cmp(_self: Self, _other: Self) -> std::cmp::Ordering };
+    let for_each_field = |name| quote {
+        if result == std::cmp::Ordering::equal() {
+            result = _self.$name.cmp(_other.$name);
+        }
+    };
+    let body = |fields| quote {
+        let mut result = std::cmp::Ordering::equal();
+        $fields
+        result
+    };
+    crate::meta::make_trait_impl(s, quote { Ord }, signature, for_each_field, quote {}, body)
+}
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/cmp.nr#L216-L231" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/cmp.nr#L216-L231</a></sub></sup>
+
diff --git a/docs/versioned_docs/version-v0.37.0/noir/standard_library/meta/module.md b/docs/versioned_docs/version-v0.37.0/noir/standard_library/meta/module.md
new file mode 100644
index 00000000000..f47231972b7
--- /dev/null
+++ b/docs/versioned_docs/version-v0.37.0/noir/standard_library/meta/module.md
@@ -0,0 +1,82 @@
+---
+title: Module
+---
+
+`std::meta::module` contains methods on the built-in `Module` type which represents a module in the source program.
+Note that this type represents a module generally, it isn't limited to only `mod my_submodule { ... }`
+declarations in the source program.
+
+## Methods
+
+### add_item
+
+```rust title="add_item" showLineNumbers 
+pub comptime fn add_item(self, item: Quoted) {}
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/meta/module.nr#L3-L5" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/meta/module.nr#L3-L5</a></sub></sup>
+
+
+Adds a top-level item (a function, a struct, a global, etc.) to the module. 
+Adding multiple items in one go is also valid if the `Quoted` value has multiple items in it.  
+Note that the items are type-checked as if they are inside the module they are being added to.
+
+### functions
+
+```rust title="functions" showLineNumbers 
+pub comptime fn functions(self) -> [FunctionDefinition] {}
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/meta/module.nr#L18-L20" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/meta/module.nr#L18-L20</a></sub></sup>
+
+
+Returns each function defined in the module.
+
+### has_named_attribute
+
+```rust title="has_named_attribute" showLineNumbers 
+pub comptime fn has_named_attribute<let N: u32>(self, name: str<N>) -> bool {}
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/meta/module.nr#L8-L10" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/meta/module.nr#L8-L10</a></sub></sup>
+
+
+Returns true if this module has a custom attribute with the given name.
+
+### is_contract
+
+```rust title="is_contract" showLineNumbers 
+pub comptime fn is_contract(self) -> bool {}
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/meta/module.nr#L13-L15" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/meta/module.nr#L13-L15</a></sub></sup>
+
+
+`true` if this module is a contract module (was declared via `contract foo { ... }`).
+
+### name
+
+```rust title="name" showLineNumbers 
+pub comptime fn name(self) -> Quoted {}
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/meta/module.nr#L28-L30" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/meta/module.nr#L28-L30</a></sub></sup>
+
+
+Returns the name of the module.
+
+### structs
+
+```rust title="structs" showLineNumbers 
+pub comptime fn structs(self) -> [StructDefinition] {}
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/meta/module.nr#L23-L25" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/meta/module.nr#L23-L25</a></sub></sup>
+
+
+Returns each struct defined in the module.
+
+## Trait Implementations
+
+```rust
+impl Eq for Module
+impl Hash for Module
+```
+
+Note that each module is assigned a unique ID internally and this is what is used for
+equality and hashing. So even modules with identical names and contents may not
+be equal in this sense if they were originally different items in the source program.
diff --git a/docs/versioned_docs/version-v0.37.0/noir/standard_library/meta/op.md b/docs/versioned_docs/version-v0.37.0/noir/standard_library/meta/op.md
new file mode 100644
index 00000000000..03ea49ad8ec
--- /dev/null
+++ b/docs/versioned_docs/version-v0.37.0/noir/standard_library/meta/op.md
@@ -0,0 +1,244 @@
+---
+title: UnaryOp and BinaryOp
+---
+
+`std::meta::op` contains the `UnaryOp` and `BinaryOp` types as well as methods on them.
+These types are used to represent a unary or binary operator respectively in Noir source code.
+
+## Types
+
+### UnaryOp
+
+Represents a unary operator. One of `-`, `!`, `&mut`, or `*`.
+
+### Methods
+
+#### is_minus
+
+```rust title="is_minus" showLineNumbers 
+pub fn is_minus(self) -> bool {
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/meta/op.nr#L24-L26" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/meta/op.nr#L24-L26</a></sub></sup>
+
+
+Returns `true` if this operator is `-`.
+
+#### is_not
+
+```rust title="is_not" showLineNumbers 
+pub fn is_not(self) -> bool {
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/meta/op.nr#L30-L32" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/meta/op.nr#L30-L32</a></sub></sup>
+
+
+`true` if this operator is `!`
+
+#### is_mutable_reference
+
+```rust title="is_mutable_reference" showLineNumbers 
+pub fn is_mutable_reference(self) -> bool {
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/meta/op.nr#L36-L38" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/meta/op.nr#L36-L38</a></sub></sup>
+
+
+`true` if this operator is `&mut`
+
+#### is_dereference
+
+```rust title="is_dereference" showLineNumbers 
+pub fn is_dereference(self) -> bool {
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/meta/op.nr#L42-L44" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/meta/op.nr#L42-L44</a></sub></sup>
+
+
+`true` if this operator is `*`
+
+#### quoted
+
+```rust title="unary_quoted" showLineNumbers 
+pub comptime fn quoted(self) -> Quoted {
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/meta/op.nr#L48-L50" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/meta/op.nr#L48-L50</a></sub></sup>
+
+
+Returns this operator as a `Quoted` value.
+
+### Trait Implementations
+
+```rust
+impl Eq for UnaryOp
+impl Hash for UnaryOp
+```
+
+### BinaryOp
+
+Represents a binary operator. One of `+`, `-`, `*`, `/`, `%`, `==`, `!=`, `<`, `<=`, `>`, `>=`, `&`, `|`, `^`, `>>`, or `<<`.
+
+### Methods
+
+#### is_add
+
+```rust title="is_add" showLineNumbers 
+pub fn is_add(self) -> bool {
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/meta/op.nr#L86-L88" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/meta/op.nr#L86-L88</a></sub></sup>
+
+
+`true` if this operator is `+`
+
+#### is_subtract
+
+```rust title="is_subtract" showLineNumbers 
+pub fn is_subtract(self) -> bool {
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/meta/op.nr#L92-L94" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/meta/op.nr#L92-L94</a></sub></sup>
+
+
+`true` if this operator is `-`
+
+#### is_multiply
+
+```rust title="is_multiply" showLineNumbers 
+pub fn is_multiply(self) -> bool {
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/meta/op.nr#L98-L100" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/meta/op.nr#L98-L100</a></sub></sup>
+
+
+`true` if this operator is `*`
+
+#### is_divide
+
+```rust title="is_divide" showLineNumbers 
+pub fn is_divide(self) -> bool {
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/meta/op.nr#L104-L106" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/meta/op.nr#L104-L106</a></sub></sup>
+
+
+`true` if this operator is `/`
+
+#### is_modulo
+
+```rust title="is_modulo" showLineNumbers 
+pub fn is_modulo(self) -> bool {
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/meta/op.nr#L176-L178" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/meta/op.nr#L176-L178</a></sub></sup>
+
+
+`true` if this operator is `%`
+
+#### is_equal
+
+```rust title="is_equal" showLineNumbers 
+pub fn is_equal(self) -> bool {
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/meta/op.nr#L110-L112" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/meta/op.nr#L110-L112</a></sub></sup>
+
+
+`true` if this operator is `==`
+
+#### is_not_equal
+
+```rust title="is_not_equal" showLineNumbers 
+pub fn is_not_equal(self) -> bool {
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/meta/op.nr#L116-L118" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/meta/op.nr#L116-L118</a></sub></sup>
+
+
+`true` if this operator is `!=`
+
+#### is_less_than
+
+```rust title="is_less_than" showLineNumbers 
+pub fn is_less_than(self) -> bool {
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/meta/op.nr#L122-L124" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/meta/op.nr#L122-L124</a></sub></sup>
+
+
+`true` if this operator is `<`
+
+#### is_less_than_or_equal
+
+```rust title="is_less_than_or_equal" showLineNumbers 
+pub fn is_less_than_or_equal(self) -> bool {
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/meta/op.nr#L128-L130" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/meta/op.nr#L128-L130</a></sub></sup>
+
+
+`true` if this operator is `<=`
+
+#### is_greater_than
+
+```rust title="is_greater_than" showLineNumbers 
+pub fn is_greater_than(self) -> bool {
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/meta/op.nr#L134-L136" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/meta/op.nr#L134-L136</a></sub></sup>
+
+
+`true` if this operator is `>`
+
+#### is_greater_than_or_equal
+
+```rust title="is_greater_than_or_equal" showLineNumbers 
+pub fn is_greater_than_or_equal(self) -> bool {
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/meta/op.nr#L140-L142" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/meta/op.nr#L140-L142</a></sub></sup>
+
+
+`true` if this operator is `>=`
+
+#### is_and
+
+```rust title="is_and" showLineNumbers 
+pub fn is_and(self) -> bool {
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/meta/op.nr#L146-L148" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/meta/op.nr#L146-L148</a></sub></sup>
+
+
+`true` if this operator is `&`
+
+#### is_or
+
+```rust title="is_or" showLineNumbers 
+pub fn is_or(self) -> bool {
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/meta/op.nr#L152-L154" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/meta/op.nr#L152-L154</a></sub></sup>
+
+
+`true` if this operator is `|`
+
+#### is_shift_right
+
+```rust title="is_shift_right" showLineNumbers 
+pub fn is_shift_right(self) -> bool {
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/meta/op.nr#L164-L166" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/meta/op.nr#L164-L166</a></sub></sup>
+
+
+`true` if this operator is `>>`
+
+#### is_shift_left
+
+```rust title="is_shift_right" showLineNumbers 
+pub fn is_shift_right(self) -> bool {
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/meta/op.nr#L164-L166" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/meta/op.nr#L164-L166</a></sub></sup>
+
+
+`true` if this operator is `<<`
+
+#### quoted
+
+```rust title="binary_quoted" showLineNumbers 
+pub comptime fn quoted(self) -> Quoted {
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/meta/op.nr#L182-L184" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/meta/op.nr#L182-L184</a></sub></sup>
+
+
+Returns this operator as a `Quoted` value.
+
+### Trait Implementations
+
+```rust
+impl Eq for BinaryOp
+impl Hash for BinaryOp
+```
diff --git a/docs/versioned_docs/version-v0.37.0/noir/standard_library/meta/quoted.md b/docs/versioned_docs/version-v0.37.0/noir/standard_library/meta/quoted.md
new file mode 100644
index 00000000000..d7acf23bc07
--- /dev/null
+++ b/docs/versioned_docs/version-v0.37.0/noir/standard_library/meta/quoted.md
@@ -0,0 +1,141 @@
+---
+title: Quoted
+---
+
+`std::meta::quoted` contains methods on the built-in `Quoted` type which represents
+quoted token streams and is the result of the `quote { ... }` expression.
+
+## Methods
+
+### as_expr
+
+```rust title="as_expr" showLineNumbers 
+pub comptime fn as_expr(self) -> Option<Expr> {}
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/meta/quoted.nr#L6-L8" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/meta/quoted.nr#L6-L8</a></sub></sup>
+
+
+Parses the quoted token stream as an expression. Returns `Option::none()` if
+the expression failed to parse.
+
+Example:
+
+```rust title="as_expr_example" showLineNumbers 
+#[test]
+    fn test_expr_as_function_call() {
+        comptime
+        {
+            let expr = quote { foo(42) }.as_expr().unwrap();
+            let (_function, args) = expr.as_function_call().unwrap();
+            assert_eq(args.len(), 1);
+            assert_eq(args[0].as_integer().unwrap(), (42, false));
+        }
+    }
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/test_programs/noir_test_success/comptime_expr/src/main.nr#L360-L371" target="_blank" rel="noopener noreferrer">Source code: test_programs/noir_test_success/comptime_expr/src/main.nr#L360-L371</a></sub></sup>
+
+
+### as_module
+
+```rust title="as_module" showLineNumbers 
+pub comptime fn as_module(self) -> Option<Module> {}
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/meta/quoted.nr#L11-L13" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/meta/quoted.nr#L11-L13</a></sub></sup>
+
+
+Interprets this token stream as a module path leading to the name of a module.
+Returns `Option::none()` if the module isn't found or this token stream cannot be parsed as a path.
+
+Example:
+
+```rust title="as_module_example" showLineNumbers 
+mod baz {
+    pub mod qux {}
+}
+
+#[test]
+fn as_module_test() {
+    comptime {
+        let my_mod = quote { baz::qux }.as_module().unwrap();
+        assert_eq(my_mod.name(), quote { qux });
+    }
+}
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/test_programs/compile_success_empty/comptime_module/src/main.nr#L115-L127" target="_blank" rel="noopener noreferrer">Source code: test_programs/compile_success_empty/comptime_module/src/main.nr#L115-L127</a></sub></sup>
+
+
+### as_trait_constraint
+
+```rust title="as_trait_constraint" showLineNumbers 
+pub comptime fn as_trait_constraint(self) -> TraitConstraint {}
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/meta/quoted.nr#L16-L18" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/meta/quoted.nr#L16-L18</a></sub></sup>
+
+
+Interprets this token stream as a trait constraint (without an object type).
+Note that this function panics instead of returning `Option::none()` if the token
+stream does not parse and resolve to a valid trait constraint.
+
+Example:
+
+```rust title="implements_example" showLineNumbers 
+pub fn function_with_where<T>(_x: T)
+where
+    T: SomeTrait<i32>,
+{
+    comptime {
+        let t = quote { T }.as_type();
+        let some_trait_i32 = quote { SomeTrait<i32> }.as_trait_constraint();
+        assert(t.implements(some_trait_i32));
+
+        assert(t.get_trait_impl(some_trait_i32).is_none());
+    }
+}
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/test_programs/compile_success_empty/comptime_type/src/main.nr#L160-L173" target="_blank" rel="noopener noreferrer">Source code: test_programs/compile_success_empty/comptime_type/src/main.nr#L160-L173</a></sub></sup>
+
+
+### as_type
+
+```rust title="as_type" showLineNumbers 
+pub comptime fn as_type(self) -> Type {}
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/meta/quoted.nr#L21-L23" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/meta/quoted.nr#L21-L23</a></sub></sup>
+
+
+Interprets this token stream as a resolved type. Panics if the token
+stream doesn't parse to a type or if the type isn't a valid type in scope.
+
+```rust title="implements_example" showLineNumbers 
+pub fn function_with_where<T>(_x: T)
+where
+    T: SomeTrait<i32>,
+{
+    comptime {
+        let t = quote { T }.as_type();
+        let some_trait_i32 = quote { SomeTrait<i32> }.as_trait_constraint();
+        assert(t.implements(some_trait_i32));
+
+        assert(t.get_trait_impl(some_trait_i32).is_none());
+    }
+}
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/test_programs/compile_success_empty/comptime_type/src/main.nr#L160-L173" target="_blank" rel="noopener noreferrer">Source code: test_programs/compile_success_empty/comptime_type/src/main.nr#L160-L173</a></sub></sup>
+
+
+### tokens
+
+```rust title="tokens" showLineNumbers 
+pub comptime fn tokens(self) -> [Quoted] {}
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/meta/quoted.nr#L26-L28" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/meta/quoted.nr#L26-L28</a></sub></sup>
+
+
+Returns a slice of the individual tokens that form this token stream.
+
+## Trait Implementations
+
+```rust
+impl Eq for Quoted
+impl Hash for Quoted
+```
diff --git a/docs/versioned_docs/version-v0.37.0/noir/standard_library/meta/struct_def.md b/docs/versioned_docs/version-v0.37.0/noir/standard_library/meta/struct_def.md
new file mode 100644
index 00000000000..fd609942f4e
--- /dev/null
+++ b/docs/versioned_docs/version-v0.37.0/noir/standard_library/meta/struct_def.md
@@ -0,0 +1,177 @@
+---
+title: StructDefinition
+---
+
+`std::meta::struct_def` contains methods on the built-in `StructDefinition` type.
+This type corresponds to `struct Name { field1: Type1, ... }` items in the source program.
+
+## Methods
+
+### add_attribute
+
+```rust title="add_attribute" showLineNumbers 
+pub comptime fn add_attribute<let N: u32>(self, attribute: str<N>) {}
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/meta/struct_def.nr#L3-L5" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/meta/struct_def.nr#L3-L5</a></sub></sup>
+
+
+Adds an attribute to the struct.
+
+### add_generic
+
+```rust title="add_generic" showLineNumbers 
+pub comptime fn add_generic<let N: u32>(self, generic_name: str<N>) -> Type {}
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/meta/struct_def.nr#L8-L10" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/meta/struct_def.nr#L8-L10</a></sub></sup>
+
+
+Adds an generic to the struct. Returns the new generic type.
+Errors if the given generic name isn't a single identifier or if
+the struct already has a generic with the same name.
+
+This method should be used carefully, if there is existing code referring
+to the struct type it may be checked before this function is called and
+see the struct with the original number of generics. This method should
+thus be preferred to use on code generated from other macros and structs
+that are not used in function signatures.
+
+Example:
+
+```rust title="add-generic-example" showLineNumbers 
+comptime fn add_generic(s: StructDefinition) {
+        assert_eq(s.generics().len(), 0);
+        let new_generic = s.add_generic("T");
+
+        let generics = s.generics();
+        assert_eq(generics.len(), 1);
+        assert_eq(generics[0], new_generic);
+    }
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/test_programs/compile_success_empty/comptime_struct_definition/src/main.nr#L35-L44" target="_blank" rel="noopener noreferrer">Source code: test_programs/compile_success_empty/comptime_struct_definition/src/main.nr#L35-L44</a></sub></sup>
+
+
+### as_type
+
+```rust title="as_type" showLineNumbers 
+pub comptime fn as_type(self) -> Type {}
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/meta/struct_def.nr#L15-L17" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/meta/struct_def.nr#L15-L17</a></sub></sup>
+
+
+Returns this struct as a type in the source program. If this struct has
+any generics, the generics are also included as-is.
+
+### generics
+
+```rust title="generics" showLineNumbers 
+pub comptime fn generics(self) -> [Type] {}
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/meta/struct_def.nr#L26-L28" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/meta/struct_def.nr#L26-L28</a></sub></sup>
+
+
+Returns each generic on this struct.
+
+Example:
+
+```
+#[example]
+struct Foo<T, U> {
+    bar: [T; 2],
+    baz: Baz<U, U>,
+}
+
+comptime fn example(foo: StructDefinition) {
+    assert_eq(foo.generics().len(), 2);
+
+    // Fails because `T` isn't in scope
+    // let t = quote { T }.as_type();
+    // assert_eq(foo.generics()[0], t);
+}
+```
+
+### fields
+
+```rust title="fields" showLineNumbers 
+pub comptime fn fields(self) -> [(Quoted, Type)] {}
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/meta/struct_def.nr#L33-L35" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/meta/struct_def.nr#L33-L35</a></sub></sup>
+
+
+Returns each field of this struct as a pair of (field name, field type).
+
+### has_named_attribute
+
+```rust title="has_named_attribute" showLineNumbers 
+pub comptime fn has_named_attribute<let N: u32>(self, name: str<N>) -> bool {}
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/meta/struct_def.nr#L20-L22" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/meta/struct_def.nr#L20-L22</a></sub></sup>
+
+
+Returns true if this struct has a custom attribute with the given name.
+
+### module
+
+```rust title="module" showLineNumbers 
+pub comptime fn module(self) -> Module {}
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/meta/struct_def.nr#L38-L40" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/meta/struct_def.nr#L38-L40</a></sub></sup>
+
+
+Returns the module where the struct is defined.
+
+### name
+
+```rust title="name" showLineNumbers 
+pub comptime fn name(self) -> Quoted {}
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/meta/struct_def.nr#L43-L45" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/meta/struct_def.nr#L43-L45</a></sub></sup>
+
+
+Returns the name of this struct
+
+Note that the returned quoted value will be just the struct name, it will
+not be the full path to the struct, nor will it include any generics.
+
+### set_fields
+
+```rust title="set_fields" showLineNumbers 
+pub comptime fn set_fields(self, new_fields: [(Quoted, Type)]) {}
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/meta/struct_def.nr#L52-L54" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/meta/struct_def.nr#L52-L54</a></sub></sup>
+
+
+Sets the fields of this struct to the given fields list where each element
+is a pair of the field's name and the field's type. Expects each field name
+to be a single identifier. Note that this will override any previous fields
+on this struct. If those should be preserved, use `.fields()` to retrieve the
+current fields on the struct type and append the new fields from there.
+
+Example:
+
+```rust
+// Change this struct to:
+// struct Foo {
+//     a: u32,
+//     b: i8,
+// }
+#[mangle_fields]
+struct Foo { x: Field }
+
+comptime fn mangle_fields(s: StructDefinition) {
+    s.set_fields(&[
+        (quote { a }, quote { u32 }.as_type()),
+        (quote { b }, quote { i8 }.as_type()),
+    ]);
+}
+```
+
+## Trait Implementations
+
+```rust
+impl Eq for StructDefinition
+impl Hash for StructDefinition
+```
+
+Note that each struct is assigned a unique ID internally and this is what is used for
+equality and hashing. So even structs with identical generics and fields may not
+be equal in this sense if they were originally different items in the source program.
diff --git a/docs/versioned_docs/version-v0.37.0/noir/standard_library/meta/trait_constraint.md b/docs/versioned_docs/version-v0.37.0/noir/standard_library/meta/trait_constraint.md
new file mode 100644
index 00000000000..3106f732b5a
--- /dev/null
+++ b/docs/versioned_docs/version-v0.37.0/noir/standard_library/meta/trait_constraint.md
@@ -0,0 +1,17 @@
+---
+title: TraitConstraint
+---
+
+`std::meta::trait_constraint` contains methods on the built-in `TraitConstraint` type which represents
+a trait constraint that can be used to search for a trait implementation. This is similar
+syntactically to just the trait itself, but can also contain generic arguments. E.g. `Eq`, `Default`,
+`BuildHasher<Poseidon2Hasher>`.
+
+This type currently has no public methods but it can be used alongside `Type` in `implements` or `get_trait_impl`.
+
+## Trait Implementations
+
+```rust
+impl Eq for TraitConstraint
+impl Hash for TraitConstraint
+```
diff --git a/docs/versioned_docs/version-v0.37.0/noir/standard_library/meta/trait_def.md b/docs/versioned_docs/version-v0.37.0/noir/standard_library/meta/trait_def.md
new file mode 100644
index 00000000000..e661d3af7f1
--- /dev/null
+++ b/docs/versioned_docs/version-v0.37.0/noir/standard_library/meta/trait_def.md
@@ -0,0 +1,26 @@
+---
+title: TraitDefinition
+---
+
+`std::meta::trait_def` contains methods on the built-in `TraitDefinition` type. This type
+represents trait definitions such as `trait Foo { .. }` at the top-level of a program.
+
+## Methods
+
+### as_trait_constraint
+
+```rust title="as_trait_constraint" showLineNumbers 
+pub comptime fn as_trait_constraint(_self: Self) -> TraitConstraint {}
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/meta/trait_def.nr#L6-L8" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/meta/trait_def.nr#L6-L8</a></sub></sup>
+
+
+Converts this trait into a trait constraint. If there are any generics on this
+trait, they will be kept as-is without instantiating or replacing them.
+
+## Trait Implementations
+
+```rust
+impl Eq for TraitDefinition
+impl Hash for TraitDefinition
+```
diff --git a/docs/versioned_docs/version-v0.37.0/noir/standard_library/meta/trait_impl.md b/docs/versioned_docs/version-v0.37.0/noir/standard_library/meta/trait_impl.md
new file mode 100644
index 00000000000..a527617c1e6
--- /dev/null
+++ b/docs/versioned_docs/version-v0.37.0/noir/standard_library/meta/trait_impl.md
@@ -0,0 +1,60 @@
+---
+title: TraitImpl
+---
+
+`std::meta::trait_impl` contains methods on the built-in `TraitImpl` type which represents a trait
+implementation such as `impl Foo for Bar { ... }`.
+
+## Methods
+
+### trait_generic_args
+
+```rust title="trait_generic_args" showLineNumbers 
+pub comptime fn trait_generic_args(self) -> [Type] {}
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/meta/trait_impl.nr#L3-L5" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/meta/trait_impl.nr#L3-L5</a></sub></sup>
+
+
+Returns any generic arguments on the trait of this trait implementation, if any.
+
+```rs
+impl Foo<i32, Field> for Bar { ... }
+
+comptime {
+    let bar_type = quote { Bar }.as_type();
+    let foo = quote { Foo<i32, Field> }.as_trait_constraint();
+
+    let my_impl: TraitImpl = bar_type.get_trait_impl(foo).unwrap();
+
+    let generics = my_impl.trait_generic_args();
+    assert_eq(generics.len(), 2);
+
+    assert_eq(generics[0], quote { i32 }.as_type());
+    assert_eq(generics[1], quote { Field }.as_type());
+}
+```
+
+### methods
+
+```rust title="methods" showLineNumbers 
+pub comptime fn methods(self) -> [FunctionDefinition] {}
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/meta/trait_impl.nr#L8-L10" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/meta/trait_impl.nr#L8-L10</a></sub></sup>
+
+
+Returns each method in this trait impl.
+
+Example:
+
+```rs
+comptime {
+    let i32_type = quote { i32 }.as_type();
+    let eq = quote { Eq }.as_trait_constraint();
+
+    let impl_eq_for_i32: TraitImpl = i32_type.get_trait_impl(eq).unwrap();
+    let methods = impl_eq_for_i32.methods();
+
+    assert_eq(methods.len(), 1);
+    assert_eq(methods[0].name(), quote { eq });
+}
+```
diff --git a/docs/versioned_docs/version-v0.37.0/noir/standard_library/meta/typ.md b/docs/versioned_docs/version-v0.37.0/noir/standard_library/meta/typ.md
new file mode 100644
index 00000000000..90222c222f5
--- /dev/null
+++ b/docs/versioned_docs/version-v0.37.0/noir/standard_library/meta/typ.md
@@ -0,0 +1,264 @@
+---
+title: Type
+---
+
+`std::meta::typ` contains methods on the built-in `Type` type used for representing
+a type in the source program.
+
+## Functions
+
+```rust title="fresh_type_variable" showLineNumbers 
+pub comptime fn fresh_type_variable() -> Type {}
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/meta/typ.nr#L57-L59" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/meta/typ.nr#L57-L59</a></sub></sup>
+
+
+Creates and returns an unbound type variable. This is a special kind of type internal
+to type checking which will type check with any other type. When it is type checked
+against another type it will also be set to that type. For example, if `a` is a type
+variable and we have the type equality `(a, i32) = (u8, i32)`, the compiler will set
+`a` equal to `u8`.
+
+Unbound type variables will often be rendered as `_` while printing them. Bound type
+variables will appear as the type they are bound to.
+
+This can be used in conjunction with functions which internally perform type checks
+such as `Type::implements` or `Type::get_trait_impl` to potentially grab some of the types used.
+
+Note that calling `Type::implements` or `Type::get_trait_impl` on a type variable will always
+fail.
+
+Example:
+
+```rust title="serialize-setup" showLineNumbers 
+trait Serialize<let N: u32> {}
+
+impl Serialize<1> for Field {}
+
+impl<T, let N: u32, let M: u32> Serialize<N * M> for [T; N]
+where
+    T: Serialize<M>,
+{}
+
+impl<T, U, let N: u32, let M: u32> Serialize<N + M> for (T, U)
+where
+    T: Serialize<N>,
+    U: Serialize<M>,
+{}
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/test_programs/compile_success_empty/comptime_type/src/main.nr#L14-L29" target="_blank" rel="noopener noreferrer">Source code: test_programs/compile_success_empty/comptime_type/src/main.nr#L14-L29</a></sub></sup>
+
+```rust title="fresh-type-variable-example" showLineNumbers 
+let typevar1 = std::meta::typ::fresh_type_variable();
+        let constraint = quote { Serialize<$typevar1> }.as_trait_constraint();
+        let field_type = quote { Field }.as_type();
+
+        // Search for a trait impl (binding typevar1 to 1 when the impl is found):
+        assert(field_type.implements(constraint));
+
+        // typevar1 should be bound to the "1" generic now:
+        assert_eq(typevar1.as_constant().unwrap(), 1);
+
+        // If we want to do the same with a different type, we need to
+        // create a new type variable now that `typevar1` is bound
+        let typevar2 = std::meta::typ::fresh_type_variable();
+        let constraint = quote { Serialize<$typevar2> }.as_trait_constraint();
+        let array_type = quote { [(Field, Field); 5] }.as_type();
+        assert(array_type.implements(constraint));
+
+        // Now typevar2 should be bound to the serialized pair size 2 times the array length 5
+        assert_eq(typevar2.as_constant().unwrap(), 10);
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/test_programs/compile_success_empty/comptime_type/src/main.nr#L129-L149" target="_blank" rel="noopener noreferrer">Source code: test_programs/compile_success_empty/comptime_type/src/main.nr#L129-L149</a></sub></sup>
+
+
+## Methods
+
+### as_array
+
+```rust title="as_array" showLineNumbers 
+pub comptime fn as_array(self) -> Option<(Type, Type)> {}
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/meta/typ.nr#L76-L78" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/meta/typ.nr#L76-L78</a></sub></sup>
+
+
+If this type is an array, return a pair of (element type, size type).
+
+Example:
+
+```rust
+comptime {
+    let array_type = quote { [Field; 3] }.as_type();
+    let (field_type, three_type) = array_type.as_array().unwrap();
+
+    assert(field_type.is_field());
+    assert_eq(three_type.as_constant().unwrap(), 3);
+}
+```
+
+### as_constant
+
+```rust title="as_constant" showLineNumbers 
+pub comptime fn as_constant(self) -> Option<u32> {}
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/meta/typ.nr#L83-L85" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/meta/typ.nr#L83-L85</a></sub></sup>
+
+
+If this type is a constant integer (such as the `3` in the array type `[Field; 3]`),
+return the numeric constant.
+
+### as_integer
+
+```rust title="as_integer" showLineNumbers 
+pub comptime fn as_integer(self) -> Option<(bool, u8)> {}
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/meta/typ.nr#L90-L92" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/meta/typ.nr#L90-L92</a></sub></sup>
+
+
+If this is an integer type, return a boolean which is `true`
+if the type is signed, as well as the number of bits of this integer type.
+
+### as_mutable_reference
+
+```rust title="as_mutable_reference" showLineNumbers 
+comptime fn as_mutable_reference(self) -> Option<Type> {}
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/meta/typ.nr#L96-L98" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/meta/typ.nr#L96-L98</a></sub></sup>
+
+
+If this is a mutable reference type `&mut T`, returns the mutable type `T`.
+
+### as_slice
+
+```rust title="as_slice" showLineNumbers 
+pub comptime fn as_slice(self) -> Option<Type> {}
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/meta/typ.nr#L102-L104" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/meta/typ.nr#L102-L104</a></sub></sup>
+
+
+If this is a slice type, return the element type of the slice.
+
+### as_str
+
+```rust title="as_str" showLineNumbers 
+pub comptime fn as_str(self) -> Option<Type> {}
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/meta/typ.nr#L108-L110" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/meta/typ.nr#L108-L110</a></sub></sup>
+
+
+If this is a `str<N>` type, returns the length `N` as a type.
+
+### as_struct
+
+```rust title="as_struct" showLineNumbers 
+pub comptime fn as_struct(self) -> Option<(StructDefinition, [Type])> {}
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/meta/typ.nr#L114-L116" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/meta/typ.nr#L114-L116</a></sub></sup>
+
+
+If this is a struct type, returns the struct in addition to
+any generic arguments on this type.
+
+### as_tuple
+
+```rust title="as_tuple" showLineNumbers 
+pub comptime fn as_tuple(self) -> Option<[Type]> {}
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/meta/typ.nr#L120-L122" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/meta/typ.nr#L120-L122</a></sub></sup>
+
+
+If this is a tuple type, returns each element type of the tuple.
+
+### get_trait_impl
+
+```rust title="get_trait_impl" showLineNumbers 
+pub comptime fn get_trait_impl(self, constraint: TraitConstraint) -> Option<TraitImpl> {}
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/meta/typ.nr#L143-L145" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/meta/typ.nr#L143-L145</a></sub></sup>
+
+
+Retrieves the trait implementation that implements the given
+trait constraint for this type. If the trait constraint is not
+found, `None` is returned. Note that since the concrete trait implementation
+for a trait constraint specified from a `where` clause is unknown,
+this function will return `None` in these cases. If you only want to know
+whether a type implements a trait, use `implements` instead.
+
+Example:
+
+```rust
+comptime {
+    let field_type = quote { Field }.as_type();
+    let default = quote { Default }.as_trait_constraint();
+
+    let the_impl: TraitImpl = field_type.get_trait_impl(default).unwrap();
+    assert(the_impl.methods().len(), 1);
+}
+```
+
+### implements
+
+```rust title="implements" showLineNumbers 
+pub comptime fn implements(self, constraint: TraitConstraint) -> bool {}
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/meta/typ.nr#L166-L168" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/meta/typ.nr#L166-L168</a></sub></sup>
+
+
+`true` if this type implements the given trait. Note that unlike
+`get_trait_impl` this will also return true for any `where` constraints
+in scope.
+
+Example:
+
+```rust
+fn foo<T>() where T: Default {
+    comptime {
+        let field_type = quote { Field }.as_type();
+        let default = quote { Default }.as_trait_constraint();
+        assert(field_type.implements(default));
+
+        let t = quote { T }.as_type();
+        assert(t.implements(default));
+    }
+}
+```
+
+### is_bool
+
+```rust title="is_bool" showLineNumbers 
+pub comptime fn is_bool(self) -> bool {}
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/meta/typ.nr#L172-L174" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/meta/typ.nr#L172-L174</a></sub></sup>
+
+
+`true` if this type is `bool`.
+
+### is_field
+
+```rust title="is_field" showLineNumbers 
+pub comptime fn is_field(self) -> bool {}
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/meta/typ.nr#L178-L180" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/meta/typ.nr#L178-L180</a></sub></sup>
+
+
+`true` if this type is `Field`.
+
+### is_unit
+
+```rust title="is_unit" showLineNumbers 
+comptime fn is_unit(self) -> bool {}
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/meta/typ.nr#L184-L186" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/meta/typ.nr#L184-L186</a></sub></sup>
+
+
+`true` if this type is the unit `()` type.
+
+## Trait Implementations
+
+```rust
+impl Eq for Type
+impl Hash for Type
+```
+Note that this is syntactic equality, this is not the same as whether two types will type check
+to be the same type. Unless type inference or generics are being used however, users should not
+typically have to worry about this distinction unless `std::meta::typ::fresh_type_variable` is used.
diff --git a/docs/versioned_docs/version-v0.37.0/noir/standard_library/meta/typed_expr.md b/docs/versioned_docs/version-v0.37.0/noir/standard_library/meta/typed_expr.md
new file mode 100644
index 00000000000..0db7dbfef61
--- /dev/null
+++ b/docs/versioned_docs/version-v0.37.0/noir/standard_library/meta/typed_expr.md
@@ -0,0 +1,27 @@
+---
+title: TypedExpr
+---
+
+`std::meta::typed_expr` contains methods on the built-in `TypedExpr` type for resolved and type-checked expressions.
+
+## Methods
+
+### get_type
+
+```rust title="as_function_definition" showLineNumbers 
+pub comptime fn as_function_definition(self) -> Option<FunctionDefinition> {}
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/meta/typed_expr.nr#L7-L9" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/meta/typed_expr.nr#L7-L9</a></sub></sup>
+
+
+If this expression refers to a function definitions, returns it. Otherwise returns `Option::none()`.
+
+### get_type
+
+```rust title="get_type" showLineNumbers 
+pub comptime fn get_type(self) -> Option<Type> {}
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/meta/typed_expr.nr#L13-L15" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/meta/typed_expr.nr#L13-L15</a></sub></sup>
+
+
+Returns the type of the expression, or `Option::none()` if there were errors when the expression was previously resolved.
\ No newline at end of file
diff --git a/docs/versioned_docs/version-v0.37.0/noir/standard_library/meta/unresolved_type.md b/docs/versioned_docs/version-v0.37.0/noir/standard_library/meta/unresolved_type.md
new file mode 100644
index 00000000000..2826ec5ec0f
--- /dev/null
+++ b/docs/versioned_docs/version-v0.37.0/noir/standard_library/meta/unresolved_type.md
@@ -0,0 +1,57 @@
+---
+title: UnresolvedType
+---
+
+`std::meta::unresolved_type` contains methods on the built-in `UnresolvedType` type for the syntax of types.
+
+## Methods
+
+### as_mutable_reference
+
+```rust title="as_mutable_reference" showLineNumbers 
+comptime fn as_mutable_reference(self) -> Option<UnresolvedType> {}
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/meta/unresolved_type.nr#L8-L10" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/meta/unresolved_type.nr#L8-L10</a></sub></sup>
+
+
+If this is a mutable reference type `&mut T`, returns the mutable type `T`.
+
+### as_slice
+
+```rust title="as_slice" showLineNumbers 
+comptime fn as_slice(self) -> Option<UnresolvedType> {}
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/meta/unresolved_type.nr#L14-L16" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/meta/unresolved_type.nr#L14-L16</a></sub></sup>
+
+
+If this is a slice `&[T]`, returns the element type `T`.
+
+### is_bool
+
+```rust title="is_bool" showLineNumbers 
+comptime fn is_bool(self) -> bool {}
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/meta/unresolved_type.nr#L20-L22" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/meta/unresolved_type.nr#L20-L22</a></sub></sup>
+
+
+Returns `true` if this type is `bool`.
+
+### is_field
+
+```rust title="is_field" showLineNumbers 
+pub comptime fn is_field(self) -> bool {}
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/meta/unresolved_type.nr#L26-L28" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/meta/unresolved_type.nr#L26-L28</a></sub></sup>
+
+
+Returns true if this type refers to the Field type.
+
+### is_unit
+
+```rust title="is_unit" showLineNumbers 
+comptime fn is_unit(self) -> bool {}
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/meta/unresolved_type.nr#L32-L34" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/meta/unresolved_type.nr#L32-L34</a></sub></sup>
+
+
+Returns true if this type is the unit `()` type.
diff --git a/docs/versioned_docs/version-v0.37.0/noir/standard_library/options.md b/docs/versioned_docs/version-v0.37.0/noir/standard_library/options.md
new file mode 100644
index 00000000000..a1bd4e1de5f
--- /dev/null
+++ b/docs/versioned_docs/version-v0.37.0/noir/standard_library/options.md
@@ -0,0 +1,101 @@
+---
+title: Option<T> Type
+---
+
+The `Option<T>` type is a way to express that a value might be present (`Some(T))` or absent (`None`). It's a safer way to handle potential absence of values, compared to using nulls in many other languages.
+
+```rust
+struct Option<T> {
+    None,
+    Some(T),
+}
+```
+
+The `Option` type, already imported into your Noir program, can be used directly:
+
+```rust
+fn main() {
+    let none = Option::none();
+    let some = Option::some(3);
+}
+```
+
+See [this test](https://github.com/noir-lang/noir/blob/5cbfb9c4a06c8865c98ff2b594464b037d821a5c/crates/nargo_cli/tests/test_data/option/src/main.nr) for a more comprehensive set of examples of each of the methods described below.
+
+## Methods
+
+### none
+
+Constructs a none value.
+
+### some
+
+Constructs a some wrapper around a given value.
+
+### is_none
+
+Returns true if the Option is None.
+
+### is_some
+
+Returns true of the Option is Some.
+
+### unwrap
+
+Asserts `self.is_some()` and returns the wrapped value.
+
+### unwrap_unchecked
+
+Returns the inner value without asserting `self.is_some()`. This method can be useful within an if condition when we already know that `option.is_some()`. If the option is None, there is no guarantee what value will be returned, only that it will be of type T for an `Option<T>`.
+
+### unwrap_or
+
+Returns the wrapped value if `self.is_some()`. Otherwise, returns the given default value.
+
+### unwrap_or_else
+
+Returns the wrapped value if `self.is_some()`. Otherwise, calls the given function to return a default value.
+
+### expect
+
+Asserts `self.is_some()` with a provided custom message and returns the contained `Some` value. The custom message is expected to be a format string.
+
+### map
+
+If self is `Some(x)`, this returns `Some(f(x))`. Otherwise, this returns `None`.
+
+### map_or
+
+If self is `Some(x)`, this returns `f(x)`. Otherwise, this returns the given default value.
+
+### map_or_else
+
+If self is `Some(x)`, this returns `f(x)`. Otherwise, this returns `default()`.
+
+### and
+
+Returns None if self is None. Otherwise, this returns `other`.
+
+### and_then
+
+If self is None, this returns None. Otherwise, this calls the given function with the Some value contained within self, and returns the result of that call. In some languages this function is called `flat_map` or `bind`.
+
+### or
+
+If self is Some, return self. Otherwise, return `other`.
+
+### or_else
+
+If self is Some, return self. Otherwise, return `default()`.
+
+### xor
+
+If only one of the two Options is Some, return that option. Otherwise, if both options are Some or both are None, None is returned.
+
+### filter
+
+Returns `Some(x)` if self is `Some(x)` and `predicate(x)` is true. Otherwise, this returns `None`.
+
+### flatten
+
+Flattens an `Option<Option<T>>` into a `Option<T>`. This returns `None` if the outer Option is None. Otherwise, this returns the inner Option.
diff --git a/docs/versioned_docs/version-v0.37.0/noir/standard_library/recursion.mdx b/docs/versioned_docs/version-v0.37.0/noir/standard_library/recursion.mdx
new file mode 100644
index 00000000000..60414a2fa51
--- /dev/null
+++ b/docs/versioned_docs/version-v0.37.0/noir/standard_library/recursion.mdx
@@ -0,0 +1,85 @@
+---
+title: Recursive Proofs
+description: Learn about how to write recursive proofs in Noir.
+keywords: [recursion, recursive proofs, verification_key, verify_proof]
+---
+
+import BlackBoxInfo from '@site/src/components/Notes/_blackbox';
+
+Noir supports recursively verifying proofs, meaning you verify the proof of a Noir program in another Noir program. This enables creating proofs of arbitrary size by doing step-wise verification of smaller components of a large proof.
+
+Read [the explainer on recursion](../../explainers/explainer-recursion.md) to know more about this function and the [guide on how to use it.](../../how_to/how-to-recursion.md)
+
+## The `#[recursive]` Attribute
+
+In Noir, the `#[recursive]` attribute is used to indicate that a circuit is designed for recursive proof generation. When applied, it informs the compiler and the tooling that the circuit should be compiled in a way that makes its proofs suitable for recursive verification. This attribute eliminates the need for manual flagging of recursion at the tooling level, streamlining the proof generation process for recursive circuits.
+
+### Example usage with `#[recursive]`
+
+```rust
+#[recursive]
+fn main(x: Field, y: pub Field) {
+    assert(x == y, "x and y are not equal");
+}
+
+// This marks the circuit as recursion-friendly and indicates that proofs generated from this circuit
+// are intended for recursive verification.
+```
+
+By incorporating this attribute directly in the circuit's definition, tooling like Nargo and NoirJS can automatically execute recursive-specific duties for Noir programs (e.g. recursive-friendly proof artifact generation) without additional flags or configurations.
+
+## Verifying Recursive Proofs
+
+```rust
+#[foreign(recursive_aggregation)]
+pub fn verify_proof(verification_key: [Field], proof: [Field], public_inputs: [Field], key_hash: Field) {}
+```
+
+<BlackBoxInfo to="black_box_fns"/>
+
+## Example usage
+
+```rust
+
+fn main(
+    verification_key : [Field; 114],
+    proof : [Field; 93],
+    public_inputs : [Field; 1],
+    key_hash : Field,
+    proof_b : [Field; 93],
+) {
+    std::verify_proof(
+        verification_key,
+        proof,
+        public_inputs,
+        key_hash
+    );
+
+    std::verify_proof(
+        verification_key,
+        proof_b,
+        public_inputs,
+        key_hash
+    );
+}
+```
+
+You can see a full example of recursive proofs in [this example recursion demo repo](https://github.com/noir-lang/noir-examples/tree/master/recursion).
+
+## Parameters
+
+### `verification_key`
+
+The verification key for the zk program that is being verified.
+
+### `proof`
+
+The proof for the zk program that is being verified.
+
+### `public_inputs`
+
+These represent the public inputs of the proof we are verifying.
+
+### `key_hash`
+
+A key hash is used to check the validity of the verification key. The circuit implementing this opcode can use this hash to ensure that the key provided to the circuit matches the key produced by the circuit creator.
diff --git a/docs/versioned_docs/version-v0.37.0/noir/standard_library/traits.md b/docs/versioned_docs/version-v0.37.0/noir/standard_library/traits.md
new file mode 100644
index 00000000000..ee20f9cd949
--- /dev/null
+++ b/docs/versioned_docs/version-v0.37.0/noir/standard_library/traits.md
@@ -0,0 +1,628 @@
+---
+title: Traits
+description: Noir's stdlib provides a few commonly used traits.
+keywords: [traits, trait, interface, protocol, default, add, eq]
+---
+
+## `std::default`
+
+### `std::default::Default`
+
+```rust title="default-trait" showLineNumbers 
+pub trait Default {
+    fn default() -> Self;
+}
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/default.nr#L4-L8" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/default.nr#L4-L8</a></sub></sup>
+
+
+Constructs a default value of a type.
+
+Implementations:
+```rust
+impl Default for Field { .. }
+
+impl Default for i8 { .. }
+impl Default for i16 { .. }
+impl Default for i32 { .. }
+impl Default for i64 { .. }
+
+impl Default for u8 { .. }
+impl Default for u16 { .. }
+impl Default for u32 { .. }
+impl Default for u64 { .. }
+
+impl Default for () { .. }
+impl Default for bool { .. }
+
+impl<T, N> Default for [T; N]
+    where T: Default { .. }
+
+impl<T> Default for [T] { .. }
+
+impl<A, B> Default for (A, B)
+    where A: Default, B: Default { .. }
+
+impl<A, B, C> Default for (A, B, C)
+    where A: Default, B: Default, C: Default { .. }
+
+impl<A, B, C, D> Default for (A, B, C, D)
+    where A: Default, B: Default, C: Default, D: Default { .. }
+
+impl<A, B, C, D, E> Default for (A, B, C, D, E)
+    where A: Default, B: Default, C: Default, D: Default, E: Default { .. }
+```
+
+For primitive integer types, the return value of `default` is `0`. Container
+types such as arrays are filled with default values of their element type,
+except slices whose length is unknown and thus defaulted to zero.
+
+---
+
+## `std::convert`
+
+### `std::convert::From`
+
+```rust title="from-trait" showLineNumbers 
+pub trait From<T> {
+    fn from(input: T) -> Self;
+}
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/convert.nr#L1-L5" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/convert.nr#L1-L5</a></sub></sup>
+
+
+The `From` trait defines how to convert from a given type `T` to the type on which the trait is implemented.
+
+The Noir standard library provides a number of implementations of `From` between primitive types.
+```rust title="from-impls" showLineNumbers 
+// Unsigned integers
+
+impl From<u8> for u32 {
+    fn from(value: u8) -> u32 {
+        value as u32
+    }
+}
+
+impl From<u8> for u64 {
+    fn from(value: u8) -> u64 {
+        value as u64
+    }
+}
+impl From<u32> for u64 {
+    fn from(value: u32) -> u64 {
+        value as u64
+    }
+}
+
+impl From<u8> for Field {
+    fn from(value: u8) -> Field {
+        value as Field
+    }
+}
+impl From<u32> for Field {
+    fn from(value: u32) -> Field {
+        value as Field
+    }
+}
+impl From<u64> for Field {
+    fn from(value: u64) -> Field {
+        value as Field
+    }
+}
+
+// Signed integers
+
+impl From<i8> for i32 {
+    fn from(value: i8) -> i32 {
+        value as i32
+    }
+}
+
+impl From<i8> for i64 {
+    fn from(value: i8) -> i64 {
+        value as i64
+    }
+}
+impl From<i32> for i64 {
+    fn from(value: i32) -> i64 {
+        value as i64
+    }
+}
+
+// Booleans
+impl From<bool> for u8 {
+    fn from(value: bool) -> u8 {
+        value as u8
+    }
+}
+impl From<bool> for u32 {
+    fn from(value: bool) -> u32 {
+        value as u32
+    }
+}
+impl From<bool> for u64 {
+    fn from(value: bool) -> u64 {
+        value as u64
+    }
+}
+impl From<bool> for i8 {
+    fn from(value: bool) -> i8 {
+        value as i8
+    }
+}
+impl From<bool> for i32 {
+    fn from(value: bool) -> i32 {
+        value as i32
+    }
+}
+impl From<bool> for i64 {
+    fn from(value: bool) -> i64 {
+        value as i64
+    }
+}
+impl From<bool> for Field {
+    fn from(value: bool) -> Field {
+        value as Field
+    }
+}
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/convert.nr#L28-L119" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/convert.nr#L28-L119</a></sub></sup>
+
+
+#### When to implement `From`
+
+As a general rule of thumb, `From` may be implemented in the [situations where it would be suitable in Rust](https://doc.rust-lang.org/std/convert/trait.From.html#when-to-implement-from):
+
+- The conversion is *infallible*: Noir does not provide an equivalent to Rust's `TryFrom`, if the conversion can fail then provide a named method instead.
+- The conversion is *lossless*: semantically, it should not lose or discard information. For example, `u32: From<u16>` can losslessly convert any `u16` into a valid `u32` such that the original `u16` can be recovered. On the other hand, `u16: From<u32>` should not be implemented as `2**16` is a `u32` which cannot be losslessly converted into a `u16`.
+- The conversion is *value-preserving*: the conceptual kind and meaning of the resulting value is the same, even though the Noir type and technical representation might be different. While it's possible to infallibly and losslessly convert a `u8` into a `str<2>` hex representation, `4u8` and `"04"` are too different for `str<2>: From<u8>` to be implemented.
+- The conversion is *obvious*: it's the only reasonable conversion between the two types. If there's ambiguity on how to convert between them such that the same input could potentially map to two different values then a named method should be used. For instance rather than implementing `U128: From<[u8; 16]>`, the methods `U128::from_le_bytes` and `U128::from_be_bytes` are used as otherwise the endianness of the array would be ambiguous, resulting in two potential values of `U128` from the same byte array.
+
+One additional recommendation specific to Noir is:
+- The conversion is *efficient*: it's relatively cheap to convert between the two types. Due to being a ZK DSL, it's more important to avoid unnecessary computation compared to Rust. If the implementation of `From` would encourage users to perform unnecessary conversion, resulting in additional proving time, then it may be preferable to expose functionality such that this conversion may be avoided.
+
+### `std::convert::Into`
+
+The `Into` trait is defined as the reciprocal of `From`. It should be easy to convince yourself that if we can convert to type `A` from type `B`, then it's possible to convert type `B` into type `A`.
+
+For this reason, implementing `From` on a type will automatically generate a matching `Into` implementation. One should always prefer implementing `From` over `Into` as implementing `Into` will not generate a matching `From` implementation.
+
+```rust title="into-trait" showLineNumbers 
+pub trait Into<T> {
+    fn into(self) -> T;
+}
+
+impl<T, U> Into<T> for U
+where
+    T: From<U>,
+{
+    fn into(self) -> T {
+        T::from(self)
+    }
+}
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/convert.nr#L13-L26" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/convert.nr#L13-L26</a></sub></sup>
+
+
+`Into` is most useful when passing function arguments where the types don't quite match up with what the function expects. In this case, the compiler has enough type information to perform the necessary conversion by just appending `.into()` onto the arguments in question.
+
+---
+
+## `std::cmp`
+
+### `std::cmp::Eq`
+
+```rust title="eq-trait" showLineNumbers 
+pub trait Eq {
+    fn eq(self, other: Self) -> bool;
+}
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/cmp.nr#L4-L8" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/cmp.nr#L4-L8</a></sub></sup>
+
+
+Returns `true` if `self` is equal to `other`. Implementing this trait on a type
+allows the type to be used with `==` and `!=`.
+
+Implementations:
+```rust
+impl Eq for Field { .. }
+
+impl Eq for i8 { .. }
+impl Eq for i16 { .. }
+impl Eq for i32 { .. }
+impl Eq for i64 { .. }
+
+impl Eq for u8 { .. }
+impl Eq for u16 { .. }
+impl Eq for u32 { .. }
+impl Eq for u64 { .. }
+
+impl Eq for () { .. }
+impl Eq for bool { .. }
+
+impl<T, N> Eq for [T; N]
+    where T: Eq { .. }
+
+impl<T> Eq for [T]
+    where T: Eq { .. }
+
+impl<A, B> Eq for (A, B)
+    where A: Eq, B: Eq { .. }
+
+impl<A, B, C> Eq for (A, B, C)
+    where A: Eq, B: Eq, C: Eq { .. }
+
+impl<A, B, C, D> Eq for (A, B, C, D)
+    where A: Eq, B: Eq, C: Eq, D: Eq { .. }
+
+impl<A, B, C, D, E> Eq for (A, B, C, D, E)
+    where A: Eq, B: Eq, C: Eq, D: Eq, E: Eq { .. }
+```
+
+### `std::cmp::Ord`
+
+```rust title="ord-trait" showLineNumbers 
+pub trait Ord {
+    fn cmp(self, other: Self) -> Ordering;
+}
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/cmp.nr#L210-L214" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/cmp.nr#L210-L214</a></sub></sup>
+
+
+`a.cmp(b)` compares two values returning `Ordering::less()` if `a < b`,
+`Ordering::equal()` if `a == b`, or `Ordering::greater()` if `a > b`.
+Implementing this trait on a type allows `<`, `<=`, `>`, and `>=` to be
+used on values of the type.
+
+`std::cmp` also provides `max` and `min` functions for any type which implements the `Ord` trait.
+
+Implementations:
+
+```rust
+impl Ord for u8 { .. }
+impl Ord for u16 { .. }
+impl Ord for u32 { .. }
+impl Ord for u64 { .. }
+
+impl Ord for i8 { .. }
+impl Ord for i16 { .. }
+impl Ord for i32 { .. }
+
+impl Ord for i64 { .. }
+
+impl Ord for () { .. }
+impl Ord for bool { .. }
+
+impl<T, N> Ord for [T; N]
+    where T: Ord { .. }
+
+impl<T> Ord for [T]
+    where T: Ord { .. }
+
+impl<A, B> Ord for (A, B)
+    where A: Ord, B: Ord { .. }
+
+impl<A, B, C> Ord for (A, B, C)
+    where A: Ord, B: Ord, C: Ord { .. }
+
+impl<A, B, C, D> Ord for (A, B, C, D)
+    where A: Ord, B: Ord, C: Ord, D: Ord { .. }
+
+impl<A, B, C, D, E> Ord for (A, B, C, D, E)
+    where A: Ord, B: Ord, C: Ord, D: Ord, E: Ord { .. }
+```
+
+---
+
+## `std::ops`
+
+### `std::ops::Add`, `std::ops::Sub`, `std::ops::Mul`, and `std::ops::Div`
+
+These traits abstract over addition, subtraction, multiplication, and division respectively.
+Implementing these traits for a given type will also allow that type to be used with the corresponding operator
+for that trait (`+` for Add, etc) in addition to the normal method names.
+
+```rust title="add-trait" showLineNumbers 
+pub trait Add {
+    fn add(self, other: Self) -> Self;
+}
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/ops/arith.nr#L1-L5" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/ops/arith.nr#L1-L5</a></sub></sup>
+
+```rust title="sub-trait" showLineNumbers 
+pub trait Sub {
+    fn sub(self, other: Self) -> Self;
+}
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/ops/arith.nr#L60-L64" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/ops/arith.nr#L60-L64</a></sub></sup>
+
+```rust title="mul-trait" showLineNumbers 
+pub trait Mul {
+    fn mul(self, other: Self) -> Self;
+}
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/ops/arith.nr#L119-L123" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/ops/arith.nr#L119-L123</a></sub></sup>
+
+```rust title="div-trait" showLineNumbers 
+pub trait Div {
+    fn div(self, other: Self) -> Self;
+}
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/ops/arith.nr#L178-L182" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/ops/arith.nr#L178-L182</a></sub></sup>
+
+
+The implementations block below is given for the `Add` trait, but the same types that implement
+`Add` also implement `Sub`, `Mul`, and `Div`.
+
+Implementations:
+```rust
+impl Add for Field { .. }
+
+impl Add for i8 { .. }
+impl Add for i16 { .. }
+impl Add for i32 { .. }
+impl Add for i64 { .. }
+
+impl Add for u8 { .. }
+impl Add for u16 { .. }
+impl Add for u32 { .. }
+impl Add for u64 { .. }
+```
+
+### `std::ops::Rem`
+
+```rust title="rem-trait" showLineNumbers 
+pub trait Rem {
+    fn rem(self, other: Self) -> Self;
+}
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/ops/arith.nr#L237-L241" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/ops/arith.nr#L237-L241</a></sub></sup>
+
+
+`Rem::rem(a, b)` is the remainder function returning the result of what is
+left after dividing `a` and `b`. Implementing `Rem` allows the `%` operator
+to be used with the implementation type.
+
+Unlike other numeric traits, `Rem` is not implemented for `Field`.
+
+Implementations:
+```rust
+impl Rem for u8 { fn rem(self, other: u8) -> u8 { self % other } }
+impl Rem for u16 { fn rem(self, other: u16) -> u16 { self % other } }
+impl Rem for u32 { fn rem(self, other: u32) -> u32 { self % other } }
+impl Rem for u64 { fn rem(self, other: u64) -> u64 { self % other } }
+
+impl Rem for i8 { fn rem(self, other: i8) -> i8 { self % other } }
+impl Rem for i16 { fn rem(self, other: i16) -> i16 { self % other } }
+impl Rem for i32 { fn rem(self, other: i32) -> i32 { self % other } }
+impl Rem for i64 { fn rem(self, other: i64) -> i64 { self % other } }
+```
+
+### `std::ops::Neg`
+
+```rust title="neg-trait" showLineNumbers 
+pub trait Neg {
+    fn neg(self) -> Self;
+}
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/ops/arith.nr#L290-L294" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/ops/arith.nr#L290-L294</a></sub></sup>
+
+
+`Neg::neg` is equivalent to the unary negation operator `-`.
+
+Implementations:
+```rust title="neg-trait-impls" showLineNumbers 
+impl Neg for Field {
+    fn neg(self) -> Field {
+        -self
+    }
+}
+
+impl Neg for i8 {
+    fn neg(self) -> i8 {
+        -self
+    }
+}
+impl Neg for i16 {
+    fn neg(self) -> i16 {
+        -self
+    }
+}
+impl Neg for i32 {
+    fn neg(self) -> i32 {
+        -self
+    }
+}
+impl Neg for i64 {
+    fn neg(self) -> i64 {
+        -self
+    }
+}
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/ops/arith.nr#L296-L323" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/ops/arith.nr#L296-L323</a></sub></sup>
+
+
+### `std::ops::Not`
+
+```rust title="not-trait" showLineNumbers 
+pub trait Not {
+    fn not(self: Self) -> Self;
+}
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/ops/bit.nr#L1-L5" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/ops/bit.nr#L1-L5</a></sub></sup>
+
+
+`Not::not` is equivalent to the unary bitwise NOT operator `!`.
+
+Implementations:
+```rust title="not-trait-impls" showLineNumbers 
+impl Not for bool {
+    fn not(self) -> bool {
+        !self
+    }
+}
+
+impl Not for u64 {
+    fn not(self) -> u64 {
+        !self
+    }
+}
+impl Not for u32 {
+    fn not(self) -> u32 {
+        !self
+    }
+}
+impl Not for u16 {
+    fn not(self) -> u16 {
+        !self
+    }
+}
+impl Not for u8 {
+    fn not(self) -> u8 {
+        !self
+    }
+}
+impl Not for u1 {
+    fn not(self) -> u1 {
+        !self
+    }
+}
+
+impl Not for i8 {
+    fn not(self) -> i8 {
+        !self
+    }
+}
+impl Not for i16 {
+    fn not(self) -> i16 {
+        !self
+    }
+}
+impl Not for i32 {
+    fn not(self) -> i32 {
+        !self
+    }
+}
+impl Not for i64 {
+    fn not(self) -> i64 {
+        !self
+    }
+}
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/ops/bit.nr#L7-L60" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/ops/bit.nr#L7-L60</a></sub></sup>
+
+
+### `std::ops::{ BitOr, BitAnd, BitXor }`
+
+```rust title="bitor-trait" showLineNumbers 
+pub trait BitOr {
+    fn bitor(self, other: Self) -> Self;
+}
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/ops/bit.nr#L62-L66" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/ops/bit.nr#L62-L66</a></sub></sup>
+
+```rust title="bitand-trait" showLineNumbers 
+pub trait BitAnd {
+    fn bitand(self, other: Self) -> Self;
+}
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/ops/bit.nr#L121-L125" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/ops/bit.nr#L121-L125</a></sub></sup>
+
+```rust title="bitxor-trait" showLineNumbers 
+pub trait BitXor {
+    fn bitxor(self, other: Self) -> Self;
+}
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/ops/bit.nr#L180-L184" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/ops/bit.nr#L180-L184</a></sub></sup>
+
+
+Traits for the bitwise operations `|`, `&`, and `^`.
+
+Implementing `BitOr`, `BitAnd` or `BitXor` for a type allows the `|`, `&`, or `^` operator respectively
+to be used with the type.
+
+The implementations block below is given for the `BitOr` trait, but the same types that implement
+`BitOr` also implement `BitAnd` and `BitXor`.
+
+Implementations:
+```rust
+impl BitOr for bool { fn bitor(self, other: bool) -> bool { self | other } }
+
+impl BitOr for u8 { fn bitor(self, other: u8) -> u8 { self | other } }
+impl BitOr for u16 { fn bitor(self, other: u16) -> u16 { self | other } }
+impl BitOr for u32 { fn bitor(self, other: u32) -> u32 { self | other } }
+impl BitOr for u64 { fn bitor(self, other: u64) -> u64 { self | other } }
+
+impl BitOr for i8 { fn bitor(self, other: i8) -> i8 { self | other } }
+impl BitOr for i16 { fn bitor(self, other: i16) -> i16 { self | other } }
+impl BitOr for i32 { fn bitor(self, other: i32) -> i32 { self | other } }
+impl BitOr for i64 { fn bitor(self, other: i64) -> i64 { self | other } }
+```
+
+### `std::ops::{ Shl, Shr }`
+
+```rust title="shl-trait" showLineNumbers 
+pub trait Shl {
+    fn shl(self, other: u8) -> Self;
+}
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/ops/bit.nr#L239-L243" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/ops/bit.nr#L239-L243</a></sub></sup>
+
+```rust title="shr-trait" showLineNumbers 
+pub trait Shr {
+    fn shr(self, other: u8) -> Self;
+}
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/ops/bit.nr#L292-L296" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/ops/bit.nr#L292-L296</a></sub></sup>
+
+
+Traits for a bit shift left and bit shift right.
+
+Implementing `Shl` for a type allows the left shift operator (`<<`) to be used with the implementation type.
+Similarly, implementing `Shr` allows the right shift operator (`>>`) to be used with the type.
+
+Note that bit shifting is not currently implemented for signed types.
+
+The implementations block below is given for the `Shl` trait, but the same types that implement
+`Shl` also implement `Shr`.
+
+Implementations:
+```rust
+impl Shl for u8 { fn shl(self, other: u8) -> u8 { self << other } }
+impl Shl for u16 { fn shl(self, other: u16) -> u16 { self << other } }
+impl Shl for u32 { fn shl(self, other: u32) -> u32 { self << other } }
+impl Shl for u64 { fn shl(self, other: u64) -> u64 { self << other } }
+```
+
+---
+
+## `std::append`
+
+### `std::append::Append`
+
+`Append` can abstract over types that can be appended to - usually container types:
+
+```rust title="append-trait" showLineNumbers 
+pub trait Append {
+    fn empty() -> Self;
+    fn append(self, other: Self) -> Self;
+}
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/append.nr#L9-L14" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/append.nr#L9-L14</a></sub></sup>
+
+
+`Append` requires two methods:
+
+- `empty`: Constructs an empty value of `Self`.
+- `append`: Append two values together, returning the result.
+
+Additionally, it is expected that for any implementation:
+
+- `T::empty().append(x) == x`
+- `x.append(T::empty()) == x`
+
+Implementations:
+```rust
+impl<T> Append for [T]
+impl Append for Quoted
+```
diff --git a/docs/versioned_docs/version-v0.37.0/reference/NoirJS/noir_js/.nojekyll b/docs/versioned_docs/version-v0.37.0/reference/NoirJS/noir_js/.nojekyll
new file mode 100644
index 00000000000..e2ac6616add
--- /dev/null
+++ b/docs/versioned_docs/version-v0.37.0/reference/NoirJS/noir_js/.nojekyll
@@ -0,0 +1 @@
+TypeDoc added this file to prevent GitHub Pages from using Jekyll. You can turn off this behavior by setting the `githubPages` option to false.
\ No newline at end of file
diff --git a/docs/versioned_docs/version-v0.37.0/reference/NoirJS/noir_js/classes/Noir.md b/docs/versioned_docs/version-v0.37.0/reference/NoirJS/noir_js/classes/Noir.md
new file mode 100644
index 00000000000..ead255bc504
--- /dev/null
+++ b/docs/versioned_docs/version-v0.37.0/reference/NoirJS/noir_js/classes/Noir.md
@@ -0,0 +1,52 @@
+# Noir
+
+## Constructors
+
+### new Noir(circuit)
+
+```ts
+new Noir(circuit): Noir
+```
+
+#### Parameters
+
+| Parameter | Type |
+| :------ | :------ |
+| `circuit` | `CompiledCircuit` |
+
+#### Returns
+
+[`Noir`](Noir.md)
+
+## Methods
+
+### execute()
+
+```ts
+execute(inputs, foreignCallHandler?): Promise<object>
+```
+
+#### Parameters
+
+| Parameter | Type |
+| :------ | :------ |
+| `inputs` | `InputMap` |
+| `foreignCallHandler`? | [`ForeignCallHandler`](../type-aliases/ForeignCallHandler.md) |
+
+#### Returns
+
+`Promise`\<`object`\>
+
+#### Description
+
+Allows to execute a circuit to get its witness and return value.
+
+#### Example
+
+```typescript
+async execute(inputs)
+```
+
+***
+
+Generated using [typedoc-plugin-markdown](https://www.npmjs.com/package/typedoc-plugin-markdown) and [TypeDoc](https://typedoc.org/)
diff --git a/docs/versioned_docs/version-v0.37.0/reference/NoirJS/noir_js/functions/and.md b/docs/versioned_docs/version-v0.37.0/reference/NoirJS/noir_js/functions/and.md
new file mode 100644
index 00000000000..c783283e396
--- /dev/null
+++ b/docs/versioned_docs/version-v0.37.0/reference/NoirJS/noir_js/functions/and.md
@@ -0,0 +1,22 @@
+# and()
+
+```ts
+and(lhs, rhs): string
+```
+
+Performs a bitwise AND operation between `lhs` and `rhs`
+
+## Parameters
+
+| Parameter | Type | Description |
+| :------ | :------ | :------ |
+| `lhs` | `string` |  |
+| `rhs` | `string` |  |
+
+## Returns
+
+`string`
+
+***
+
+Generated using [typedoc-plugin-markdown](https://www.npmjs.com/package/typedoc-plugin-markdown) and [TypeDoc](https://typedoc.org/)
diff --git a/docs/versioned_docs/version-v0.37.0/reference/NoirJS/noir_js/functions/blake2s256.md b/docs/versioned_docs/version-v0.37.0/reference/NoirJS/noir_js/functions/blake2s256.md
new file mode 100644
index 00000000000..7882d0da8d5
--- /dev/null
+++ b/docs/versioned_docs/version-v0.37.0/reference/NoirJS/noir_js/functions/blake2s256.md
@@ -0,0 +1,21 @@
+# blake2s256()
+
+```ts
+blake2s256(inputs): Uint8Array
+```
+
+Calculates the Blake2s256 hash of the input bytes
+
+## Parameters
+
+| Parameter | Type | Description |
+| :------ | :------ | :------ |
+| `inputs` | `Uint8Array` |  |
+
+## Returns
+
+`Uint8Array`
+
+***
+
+Generated using [typedoc-plugin-markdown](https://www.npmjs.com/package/typedoc-plugin-markdown) and [TypeDoc](https://typedoc.org/)
diff --git a/docs/versioned_docs/version-v0.37.0/reference/NoirJS/noir_js/functions/ecdsa_secp256k1_verify.md b/docs/versioned_docs/version-v0.37.0/reference/NoirJS/noir_js/functions/ecdsa_secp256k1_verify.md
new file mode 100644
index 00000000000..5e3cd53e9d3
--- /dev/null
+++ b/docs/versioned_docs/version-v0.37.0/reference/NoirJS/noir_js/functions/ecdsa_secp256k1_verify.md
@@ -0,0 +1,28 @@
+# ecdsa\_secp256k1\_verify()
+
+```ts
+ecdsa_secp256k1_verify(
+   hashed_msg, 
+   public_key_x_bytes, 
+   public_key_y_bytes, 
+   signature): boolean
+```
+
+Verifies a ECDSA signature over the secp256k1 curve.
+
+## Parameters
+
+| Parameter | Type | Description |
+| :------ | :------ | :------ |
+| `hashed_msg` | `Uint8Array` |  |
+| `public_key_x_bytes` | `Uint8Array` |  |
+| `public_key_y_bytes` | `Uint8Array` |  |
+| `signature` | `Uint8Array` |  |
+
+## Returns
+
+`boolean`
+
+***
+
+Generated using [typedoc-plugin-markdown](https://www.npmjs.com/package/typedoc-plugin-markdown) and [TypeDoc](https://typedoc.org/)
diff --git a/docs/versioned_docs/version-v0.37.0/reference/NoirJS/noir_js/functions/ecdsa_secp256r1_verify.md b/docs/versioned_docs/version-v0.37.0/reference/NoirJS/noir_js/functions/ecdsa_secp256r1_verify.md
new file mode 100644
index 00000000000..0b20ff68957
--- /dev/null
+++ b/docs/versioned_docs/version-v0.37.0/reference/NoirJS/noir_js/functions/ecdsa_secp256r1_verify.md
@@ -0,0 +1,28 @@
+# ecdsa\_secp256r1\_verify()
+
+```ts
+ecdsa_secp256r1_verify(
+   hashed_msg, 
+   public_key_x_bytes, 
+   public_key_y_bytes, 
+   signature): boolean
+```
+
+Verifies a ECDSA signature over the secp256r1 curve.
+
+## Parameters
+
+| Parameter | Type | Description |
+| :------ | :------ | :------ |
+| `hashed_msg` | `Uint8Array` |  |
+| `public_key_x_bytes` | `Uint8Array` |  |
+| `public_key_y_bytes` | `Uint8Array` |  |
+| `signature` | `Uint8Array` |  |
+
+## Returns
+
+`boolean`
+
+***
+
+Generated using [typedoc-plugin-markdown](https://www.npmjs.com/package/typedoc-plugin-markdown) and [TypeDoc](https://typedoc.org/)
diff --git a/docs/versioned_docs/version-v0.37.0/reference/NoirJS/noir_js/functions/xor.md b/docs/versioned_docs/version-v0.37.0/reference/NoirJS/noir_js/functions/xor.md
new file mode 100644
index 00000000000..8d762b895d3
--- /dev/null
+++ b/docs/versioned_docs/version-v0.37.0/reference/NoirJS/noir_js/functions/xor.md
@@ -0,0 +1,22 @@
+# xor()
+
+```ts
+xor(lhs, rhs): string
+```
+
+Performs a bitwise XOR operation between `lhs` and `rhs`
+
+## Parameters
+
+| Parameter | Type | Description |
+| :------ | :------ | :------ |
+| `lhs` | `string` |  |
+| `rhs` | `string` |  |
+
+## Returns
+
+`string`
+
+***
+
+Generated using [typedoc-plugin-markdown](https://www.npmjs.com/package/typedoc-plugin-markdown) and [TypeDoc](https://typedoc.org/)
diff --git a/docs/versioned_docs/version-v0.37.0/reference/NoirJS/noir_js/index.md b/docs/versioned_docs/version-v0.37.0/reference/NoirJS/noir_js/index.md
new file mode 100644
index 00000000000..4de7a696991
--- /dev/null
+++ b/docs/versioned_docs/version-v0.37.0/reference/NoirJS/noir_js/index.md
@@ -0,0 +1,47 @@
+# noir_js
+
+## Exports
+
+### Classes
+
+| Class | Description |
+| :------ | :------ |
+| [Noir](classes/Noir.md) | - |
+
+### Type Aliases
+
+| Type alias | Description |
+| :------ | :------ |
+| [ErrorWithPayload](type-aliases/ErrorWithPayload.md) | - |
+| [ForeignCallHandler](type-aliases/ForeignCallHandler.md) | A callback which performs an foreign call and returns the response. |
+| [ForeignCallInput](type-aliases/ForeignCallInput.md) | - |
+| [ForeignCallOutput](type-aliases/ForeignCallOutput.md) | - |
+| [WitnessMap](type-aliases/WitnessMap.md) | - |
+
+### Functions
+
+| Function | Description |
+| :------ | :------ |
+| [and](functions/and.md) | Performs a bitwise AND operation between `lhs` and `rhs` |
+| [blake2s256](functions/blake2s256.md) | Calculates the Blake2s256 hash of the input bytes |
+| [ecdsa\_secp256k1\_verify](functions/ecdsa_secp256k1_verify.md) | Verifies a ECDSA signature over the secp256k1 curve. |
+| [ecdsa\_secp256r1\_verify](functions/ecdsa_secp256r1_verify.md) | Verifies a ECDSA signature over the secp256r1 curve. |
+| [xor](functions/xor.md) | Performs a bitwise XOR operation between `lhs` and `rhs` |
+
+## References
+
+### CompiledCircuit
+
+Renames and re-exports [InputMap](index.md#inputmap)
+
+## Variables
+
+### InputMap
+
+```ts
+InputMap: any;
+```
+
+***
+
+Generated using [typedoc-plugin-markdown](https://www.npmjs.com/package/typedoc-plugin-markdown) and [TypeDoc](https://typedoc.org/)
diff --git a/docs/versioned_docs/version-v0.37.0/reference/NoirJS/noir_js/type-aliases/ErrorWithPayload.md b/docs/versioned_docs/version-v0.37.0/reference/NoirJS/noir_js/type-aliases/ErrorWithPayload.md
new file mode 100644
index 00000000000..e8c2f4aef3d
--- /dev/null
+++ b/docs/versioned_docs/version-v0.37.0/reference/NoirJS/noir_js/type-aliases/ErrorWithPayload.md
@@ -0,0 +1,15 @@
+# ErrorWithPayload
+
+```ts
+type ErrorWithPayload: ExecutionError & object;
+```
+
+## Type declaration
+
+| Member | Type | Description |
+| :------ | :------ | :------ |
+| `decodedAssertionPayload` | `any` | - |
+
+***
+
+Generated using [typedoc-plugin-markdown](https://www.npmjs.com/package/typedoc-plugin-markdown) and [TypeDoc](https://typedoc.org/)
diff --git a/docs/versioned_docs/version-v0.37.0/reference/NoirJS/noir_js/type-aliases/ForeignCallHandler.md b/docs/versioned_docs/version-v0.37.0/reference/NoirJS/noir_js/type-aliases/ForeignCallHandler.md
new file mode 100644
index 00000000000..812b8b16481
--- /dev/null
+++ b/docs/versioned_docs/version-v0.37.0/reference/NoirJS/noir_js/type-aliases/ForeignCallHandler.md
@@ -0,0 +1,24 @@
+# ForeignCallHandler
+
+```ts
+type ForeignCallHandler: (name, inputs) => Promise<ForeignCallOutput[]>;
+```
+
+A callback which performs an foreign call and returns the response.
+
+## Parameters
+
+| Parameter | Type | Description |
+| :------ | :------ | :------ |
+| `name` | `string` | The identifier for the type of foreign call being performed. |
+| `inputs` | [`ForeignCallInput`](ForeignCallInput.md)[] | An array of hex encoded inputs to the foreign call. |
+
+## Returns
+
+`Promise`\<[`ForeignCallOutput`](ForeignCallOutput.md)[]\>
+
+outputs - An array of hex encoded outputs containing the results of the foreign call.
+
+***
+
+Generated using [typedoc-plugin-markdown](https://www.npmjs.com/package/typedoc-plugin-markdown) and [TypeDoc](https://typedoc.org/)
diff --git a/docs/versioned_docs/version-v0.37.0/reference/NoirJS/noir_js/type-aliases/ForeignCallInput.md b/docs/versioned_docs/version-v0.37.0/reference/NoirJS/noir_js/type-aliases/ForeignCallInput.md
new file mode 100644
index 00000000000..dd95809186a
--- /dev/null
+++ b/docs/versioned_docs/version-v0.37.0/reference/NoirJS/noir_js/type-aliases/ForeignCallInput.md
@@ -0,0 +1,9 @@
+# ForeignCallInput
+
+```ts
+type ForeignCallInput: string[];
+```
+
+***
+
+Generated using [typedoc-plugin-markdown](https://www.npmjs.com/package/typedoc-plugin-markdown) and [TypeDoc](https://typedoc.org/)
diff --git a/docs/versioned_docs/version-v0.37.0/reference/NoirJS/noir_js/type-aliases/ForeignCallOutput.md b/docs/versioned_docs/version-v0.37.0/reference/NoirJS/noir_js/type-aliases/ForeignCallOutput.md
new file mode 100644
index 00000000000..b71fb78a946
--- /dev/null
+++ b/docs/versioned_docs/version-v0.37.0/reference/NoirJS/noir_js/type-aliases/ForeignCallOutput.md
@@ -0,0 +1,9 @@
+# ForeignCallOutput
+
+```ts
+type ForeignCallOutput: string | string[];
+```
+
+***
+
+Generated using [typedoc-plugin-markdown](https://www.npmjs.com/package/typedoc-plugin-markdown) and [TypeDoc](https://typedoc.org/)
diff --git a/docs/versioned_docs/version-v0.37.0/reference/NoirJS/noir_js/type-aliases/WitnessMap.md b/docs/versioned_docs/version-v0.37.0/reference/NoirJS/noir_js/type-aliases/WitnessMap.md
new file mode 100644
index 00000000000..258c46f9d0c
--- /dev/null
+++ b/docs/versioned_docs/version-v0.37.0/reference/NoirJS/noir_js/type-aliases/WitnessMap.md
@@ -0,0 +1,9 @@
+# WitnessMap
+
+```ts
+type WitnessMap: Map<number, string>;
+```
+
+***
+
+Generated using [typedoc-plugin-markdown](https://www.npmjs.com/package/typedoc-plugin-markdown) and [TypeDoc](https://typedoc.org/)
diff --git a/docs/versioned_docs/version-v0.37.0/reference/NoirJS/noir_js/typedoc-sidebar.cjs b/docs/versioned_docs/version-v0.37.0/reference/NoirJS/noir_js/typedoc-sidebar.cjs
new file mode 100644
index 00000000000..4796b5abaa8
--- /dev/null
+++ b/docs/versioned_docs/version-v0.37.0/reference/NoirJS/noir_js/typedoc-sidebar.cjs
@@ -0,0 +1,4 @@
+// @ts-check
+/** @type {import('@docusaurus/plugin-content-docs').SidebarsConfig} */
+const typedocSidebar = { items: [{"type":"category","label":"Classes","items":[{"type":"doc","id":"reference/NoirJS/noir_js/classes/Noir","label":"Noir"}]},{"type":"category","label":"Type Aliases","items":[{"type":"doc","id":"reference/NoirJS/noir_js/type-aliases/ErrorWithPayload","label":"ErrorWithPayload"},{"type":"doc","id":"reference/NoirJS/noir_js/type-aliases/ForeignCallHandler","label":"ForeignCallHandler"},{"type":"doc","id":"reference/NoirJS/noir_js/type-aliases/ForeignCallInput","label":"ForeignCallInput"},{"type":"doc","id":"reference/NoirJS/noir_js/type-aliases/ForeignCallOutput","label":"ForeignCallOutput"},{"type":"doc","id":"reference/NoirJS/noir_js/type-aliases/WitnessMap","label":"WitnessMap"}]},{"type":"category","label":"Functions","items":[{"type":"doc","id":"reference/NoirJS/noir_js/functions/and","label":"and"},{"type":"doc","id":"reference/NoirJS/noir_js/functions/blake2s256","label":"blake2s256"},{"type":"doc","id":"reference/NoirJS/noir_js/functions/ecdsa_secp256k1_verify","label":"ecdsa_secp256k1_verify"},{"type":"doc","id":"reference/NoirJS/noir_js/functions/ecdsa_secp256r1_verify","label":"ecdsa_secp256r1_verify"},{"type":"doc","id":"reference/NoirJS/noir_js/functions/xor","label":"xor"}]}]};
+module.exports = typedocSidebar.items;
\ No newline at end of file
diff --git a/docs/versioned_docs/version-v0.37.0/reference/NoirJS/noir_wasm/.nojekyll b/docs/versioned_docs/version-v0.37.0/reference/NoirJS/noir_wasm/.nojekyll
new file mode 100644
index 00000000000..e2ac6616add
--- /dev/null
+++ b/docs/versioned_docs/version-v0.37.0/reference/NoirJS/noir_wasm/.nojekyll
@@ -0,0 +1 @@
+TypeDoc added this file to prevent GitHub Pages from using Jekyll. You can turn off this behavior by setting the `githubPages` option to false.
\ No newline at end of file
diff --git a/docs/versioned_docs/version-v0.37.0/reference/NoirJS/noir_wasm/functions/compile.md b/docs/versioned_docs/version-v0.37.0/reference/NoirJS/noir_wasm/functions/compile.md
new file mode 100644
index 00000000000..6faf763b37f
--- /dev/null
+++ b/docs/versioned_docs/version-v0.37.0/reference/NoirJS/noir_wasm/functions/compile.md
@@ -0,0 +1,51 @@
+# compile()
+
+```ts
+compile(
+   fileManager, 
+   projectPath?, 
+   logFn?, 
+debugLogFn?): Promise<ProgramCompilationArtifacts>
+```
+
+Compiles a Noir project
+
+## Parameters
+
+| Parameter | Type | Description |
+| :------ | :------ | :------ |
+| `fileManager` | `FileManager` | The file manager to use |
+| `projectPath`? | `string` | The path to the project inside the file manager. Defaults to the root of the file manager |
+| `logFn`? | `LogFn` | A logging function. If not provided, console.log will be used |
+| `debugLogFn`? | `LogFn` | A debug logging function. If not provided, logFn will be used |
+
+## Returns
+
+`Promise`\<[`ProgramCompilationArtifacts`](../index.md#programcompilationartifacts)\>
+
+## Example
+
+```typescript
+// Node.js
+
+import { compile_program, createFileManager } from '@noir-lang/noir_wasm';
+
+const fm = createFileManager(myProjectPath);
+const myCompiledCode = await compile_program(fm);
+```
+
+```typescript
+// Browser
+
+import { compile_program, createFileManager } from '@noir-lang/noir_wasm';
+
+const fm = createFileManager('/');
+for (const path of files) {
+  await fm.writeFile(path, await getFileAsStream(path));
+}
+const myCompiledCode = await compile_program(fm);
+```
+
+***
+
+Generated using [typedoc-plugin-markdown](https://www.npmjs.com/package/typedoc-plugin-markdown) and [TypeDoc](https://typedoc.org/)
diff --git a/docs/versioned_docs/version-v0.37.0/reference/NoirJS/noir_wasm/functions/compile_contract.md b/docs/versioned_docs/version-v0.37.0/reference/NoirJS/noir_wasm/functions/compile_contract.md
new file mode 100644
index 00000000000..7d0b39a43ef
--- /dev/null
+++ b/docs/versioned_docs/version-v0.37.0/reference/NoirJS/noir_wasm/functions/compile_contract.md
@@ -0,0 +1,51 @@
+# compile\_contract()
+
+```ts
+compile_contract(
+   fileManager, 
+   projectPath?, 
+   logFn?, 
+debugLogFn?): Promise<ContractCompilationArtifacts>
+```
+
+Compiles a Noir project
+
+## Parameters
+
+| Parameter | Type | Description |
+| :------ | :------ | :------ |
+| `fileManager` | `FileManager` | The file manager to use |
+| `projectPath`? | `string` | The path to the project inside the file manager. Defaults to the root of the file manager |
+| `logFn`? | `LogFn` | A logging function. If not provided, console.log will be used |
+| `debugLogFn`? | `LogFn` | A debug logging function. If not provided, logFn will be used |
+
+## Returns
+
+`Promise`\<[`ContractCompilationArtifacts`](../index.md#contractcompilationartifacts)\>
+
+## Example
+
+```typescript
+// Node.js
+
+import { compile_contract, createFileManager } from '@noir-lang/noir_wasm';
+
+const fm = createFileManager(myProjectPath);
+const myCompiledCode = await compile_contract(fm);
+```
+
+```typescript
+// Browser
+
+import { compile_contract, createFileManager } from '@noir-lang/noir_wasm';
+
+const fm = createFileManager('/');
+for (const path of files) {
+  await fm.writeFile(path, await getFileAsStream(path));
+}
+const myCompiledCode = await compile_contract(fm);
+```
+
+***
+
+Generated using [typedoc-plugin-markdown](https://www.npmjs.com/package/typedoc-plugin-markdown) and [TypeDoc](https://typedoc.org/)
diff --git a/docs/versioned_docs/version-v0.37.0/reference/NoirJS/noir_wasm/functions/createFileManager.md b/docs/versioned_docs/version-v0.37.0/reference/NoirJS/noir_wasm/functions/createFileManager.md
new file mode 100644
index 00000000000..7e65c1d69c7
--- /dev/null
+++ b/docs/versioned_docs/version-v0.37.0/reference/NoirJS/noir_wasm/functions/createFileManager.md
@@ -0,0 +1,21 @@
+# createFileManager()
+
+```ts
+createFileManager(dataDir): FileManager
+```
+
+Creates a new FileManager instance based on fs in node and memfs in the browser (via webpack alias)
+
+## Parameters
+
+| Parameter | Type | Description |
+| :------ | :------ | :------ |
+| `dataDir` | `string` | root of the file system |
+
+## Returns
+
+`FileManager`
+
+***
+
+Generated using [typedoc-plugin-markdown](https://www.npmjs.com/package/typedoc-plugin-markdown) and [TypeDoc](https://typedoc.org/)
diff --git a/docs/versioned_docs/version-v0.37.0/reference/NoirJS/noir_wasm/functions/inflateDebugSymbols.md b/docs/versioned_docs/version-v0.37.0/reference/NoirJS/noir_wasm/functions/inflateDebugSymbols.md
new file mode 100644
index 00000000000..fcea9275341
--- /dev/null
+++ b/docs/versioned_docs/version-v0.37.0/reference/NoirJS/noir_wasm/functions/inflateDebugSymbols.md
@@ -0,0 +1,21 @@
+# inflateDebugSymbols()
+
+```ts
+inflateDebugSymbols(debugSymbols): any
+```
+
+Decompresses and decodes the debug symbols
+
+## Parameters
+
+| Parameter | Type | Description |
+| :------ | :------ | :------ |
+| `debugSymbols` | `string` | The base64 encoded debug symbols |
+
+## Returns
+
+`any`
+
+***
+
+Generated using [typedoc-plugin-markdown](https://www.npmjs.com/package/typedoc-plugin-markdown) and [TypeDoc](https://typedoc.org/)
diff --git a/docs/versioned_docs/version-v0.37.0/reference/NoirJS/noir_wasm/index.md b/docs/versioned_docs/version-v0.37.0/reference/NoirJS/noir_wasm/index.md
new file mode 100644
index 00000000000..b6e0f9d1bc0
--- /dev/null
+++ b/docs/versioned_docs/version-v0.37.0/reference/NoirJS/noir_wasm/index.md
@@ -0,0 +1,49 @@
+# noir_wasm
+
+## Exports
+
+### Functions
+
+| Function | Description |
+| :------ | :------ |
+| [compile](functions/compile.md) | Compiles a Noir project |
+| [compile\_contract](functions/compile_contract.md) | Compiles a Noir project |
+| [createFileManager](functions/createFileManager.md) | Creates a new FileManager instance based on fs in node and memfs in the browser (via webpack alias) |
+| [inflateDebugSymbols](functions/inflateDebugSymbols.md) | Decompresses and decodes the debug symbols |
+
+## References
+
+### compile\_program
+
+Renames and re-exports [compile](functions/compile.md)
+
+## Interfaces
+
+### ContractCompilationArtifacts
+
+The compilation artifacts of a given contract.
+
+#### Properties
+
+| Property | Type | Description |
+| :------ | :------ | :------ |
+| `contract` | `ContractArtifact` | The compiled contract. |
+| `warnings` | `unknown`[] | Compilation warnings. |
+
+***
+
+### ProgramCompilationArtifacts
+
+The compilation artifacts of a given program.
+
+#### Properties
+
+| Property | Type | Description |
+| :------ | :------ | :------ |
+| `name` | `string` | not part of the compilation output, injected later |
+| `program` | `ProgramArtifact` | The compiled contract. |
+| `warnings` | `unknown`[] | Compilation warnings. |
+
+***
+
+Generated using [typedoc-plugin-markdown](https://www.npmjs.com/package/typedoc-plugin-markdown) and [TypeDoc](https://typedoc.org/)
diff --git a/docs/versioned_docs/version-v0.37.0/reference/NoirJS/noir_wasm/typedoc-sidebar.cjs b/docs/versioned_docs/version-v0.37.0/reference/NoirJS/noir_wasm/typedoc-sidebar.cjs
new file mode 100644
index 00000000000..e0870710349
--- /dev/null
+++ b/docs/versioned_docs/version-v0.37.0/reference/NoirJS/noir_wasm/typedoc-sidebar.cjs
@@ -0,0 +1,4 @@
+// @ts-check
+/** @type {import('@docusaurus/plugin-content-docs').SidebarsConfig} */
+const typedocSidebar = { items: [{"type":"doc","id":"reference/NoirJS/noir_wasm/index","label":"API"},{"type":"category","label":"Functions","items":[{"type":"doc","id":"reference/NoirJS/noir_wasm/functions/compile","label":"compile"},{"type":"doc","id":"reference/NoirJS/noir_wasm/functions/compile_contract","label":"compile_contract"},{"type":"doc","id":"reference/NoirJS/noir_wasm/functions/createFileManager","label":"createFileManager"},{"type":"doc","id":"reference/NoirJS/noir_wasm/functions/inflateDebugSymbols","label":"inflateDebugSymbols"}]}]};
+module.exports = typedocSidebar.items;
\ No newline at end of file
diff --git a/docs/versioned_docs/version-v0.37.0/reference/_category_.json b/docs/versioned_docs/version-v0.37.0/reference/_category_.json
new file mode 100644
index 00000000000..5b6a20a609a
--- /dev/null
+++ b/docs/versioned_docs/version-v0.37.0/reference/_category_.json
@@ -0,0 +1,5 @@
+{
+    "position": 4,
+    "collapsible": true,
+    "collapsed": true
+}
diff --git a/docs/versioned_docs/version-v0.37.0/reference/debugger/_category_.json b/docs/versioned_docs/version-v0.37.0/reference/debugger/_category_.json
new file mode 100644
index 00000000000..27869205ad3
--- /dev/null
+++ b/docs/versioned_docs/version-v0.37.0/reference/debugger/_category_.json
@@ -0,0 +1,6 @@
+{
+    "label": "Debugger",
+    "position": 1,
+    "collapsible": true,
+    "collapsed": true
+}
diff --git a/docs/versioned_docs/version-v0.37.0/reference/debugger/debugger_known_limitations.md b/docs/versioned_docs/version-v0.37.0/reference/debugger/debugger_known_limitations.md
new file mode 100644
index 00000000000..936d416ac4b
--- /dev/null
+++ b/docs/versioned_docs/version-v0.37.0/reference/debugger/debugger_known_limitations.md
@@ -0,0 +1,59 @@
+---
+title: Known limitations
+description:
+  An overview of known limitations of the current version of the Noir debugger
+keywords:
+  [
+    Nargo,
+    Noir Debugger,
+    VS Code,
+  ]
+sidebar_position: 2
+---
+
+# Debugger Known Limitations
+
+There are currently some limits to what the debugger can observe. 
+
+## Mutable references
+
+The debugger is currently blind to any state mutated via a mutable reference. For example, in:
+
+```
+let mut x = 1;
+let y = &mut x;
+*y = 2;
+```
+
+The update on `x` will not be observed by the debugger. That means, when running `vars` from the debugger REPL, or inspecting the _local variables_ pane in the VS Code debugger, `x` will appear with value 1 despite having executed `*y = 2;`.
+
+## Variables of type function or mutable references are opaque
+
+When inspecting variables, any variable of type `Function` or `MutableReference` will render its value as `<<function>>` or `<<mutable ref>>`.
+
+## Debugger instrumentation affects resulting ACIR
+                      
+In order to make the state of local variables observable, the debugger compiles Noir circuits interleaving foreign calls that track any mutations to them. While this works (except in the cases described above) and doesn't introduce any behavior changes, it does as a side effect produce bigger bytecode. In particular, when running the command `opcodes` on the REPL debugger, you will notice Unconstrained VM blocks that look like this:
+
+```
+...
+5    BRILLIG inputs=[Single(Expression { mul_terms: [], linear_combinations: [], q_c: 2 }), Single(Expression { mul_terms: [], linear_combinations: [(1, Witness(2))], q_c: 0 })]
+       |       outputs=[]
+  5.0  |   Mov { destination: RegisterIndex(2), source: RegisterIndex(0) }
+  5.1  |   Mov { destination: RegisterIndex(3), source: RegisterIndex(1) }
+  5.2  |   Const { destination: RegisterIndex(0), value: Value { inner: 0 } }
+  5.3  |   Const { destination: RegisterIndex(1), value: Value { inner: 0 } }
+  5.4  |   Mov { destination: RegisterIndex(2), source: RegisterIndex(2) }
+  5.5  |   Mov { destination: RegisterIndex(3), source: RegisterIndex(3) }
+  5.6  |   Call { location: 8 }
+  5.7  |   Stop
+  5.8  |   ForeignCall { function: "__debug_var_assign", destinations: [], inputs: [RegisterIndex(RegisterIndex(2)), RegisterIndex(RegisterIndex(3))] }
+...
+```               
+                                    
+If you are interested in debugging/inspecting compiled ACIR without these synthetic changes, you can invoke the REPL debugger with the `--skip-instrumentation` flag or launch the VS Code debugger with the `skipConfiguration` property set to true in its launch configuration. You can find more details about those in the [Debugger REPL reference](debugger_repl.md) and the [VS Code Debugger reference](debugger_vscode.md).
+
+:::note
+Skipping debugger instrumentation means you won't be able to inspect values of local variables.
+:::
+
diff --git a/docs/versioned_docs/version-v0.37.0/reference/debugger/debugger_repl.md b/docs/versioned_docs/version-v0.37.0/reference/debugger/debugger_repl.md
new file mode 100644
index 00000000000..46e2011304e
--- /dev/null
+++ b/docs/versioned_docs/version-v0.37.0/reference/debugger/debugger_repl.md
@@ -0,0 +1,360 @@
+---
+title: REPL Debugger
+description:
+  Noir Debugger REPL options and commands. 
+keywords:
+  [
+    Nargo,
+    Noir CLI,
+    Noir Debugger,
+    REPL,
+  ]
+sidebar_position: 1
+---
+
+## Running the REPL debugger
+
+`nargo debug [OPTIONS] [WITNESS_NAME]`
+
+Runs the Noir REPL debugger. If a `WITNESS_NAME` is provided the debugger writes the resulting execution witness to a `WITNESS_NAME` file.
+
+### Options
+
+| Option                | Description                                                  |
+| --------------------- | ------------------------------------------------------------ |
+| `-p, --prover-name <PROVER_NAME>` | The name of the toml file which contains the inputs for the prover [default: Prover]|
+| `--package <PACKAGE>` | The name of the package to debug                             |
+| `--print-acir`        | Display the ACIR for compiled circuit                        |
+| `--deny-warnings`     | Treat all warnings as errors                                 |
+| `--silence-warnings`  | Suppress warnings                                            |
+| `-h, --help`          | Print help                                                   |
+
+None of these options are required.
+
+:::note
+Since the debugger starts by compiling the target package, all Noir compiler options are also available. Check out the [compiler reference](../nargo_commands.md#nargo-compile) to learn more about the compiler options.
+:::
+
+## REPL commands
+
+Once the debugger is running, it accepts the following commands.
+
+#### `help` (h)
+
+Displays the menu of available commands.
+
+```
+> help
+Available commands:
+
+  opcodes                          display ACIR opcodes
+  into                             step into to the next opcode
+  next                             step until a new source location is reached
+  out                              step until a new source location is reached
+                                   and the current stack frame is finished
+  break LOCATION:OpcodeLocation    add a breakpoint at an opcode location
+  over                             step until a new source location is reached
+                                   without diving into function calls
+  restart                          restart the debugging session
+  delete LOCATION:OpcodeLocation   delete breakpoint at an opcode location
+  witness                          show witness map
+  witness index:u32                display a single witness from the witness map
+  witness index:u32 value:String   update a witness with the given value
+  memset index:usize value:String  update a memory cell with the given
+                                   value
+  continue                         continue execution until the end of the
+                                   program
+  vars                             show variable values available at this point
+                                   in execution
+  stacktrace                       display the current stack trace
+  memory                           show memory (valid when executing unconstrained code)                                 value
+  step                             step to the next ACIR opcode
+
+Other commands:
+
+  help  Show this help message
+  quit  Quit repl
+
+```
+
+### Stepping through programs
+
+#### `next` (n)
+
+Step until the next Noir source code location. While other commands, such as [`into`](#into-i) and [`step`](#step-s), allow for finer grained control of the program's execution at the opcode level, `next` is source code centric. For example:
+
+```
+3    ...
+4    fn main(x: u32) {
+5        assert(entry_point(x) == 2);
+6        swap_entry_point(x, x + 1);
+7 ->     assert(deep_entry_point(x) == 4);
+8        multiple_values_entry_point(x);
+9    }
+```
+
+
+Using `next` here would cause the debugger to jump to the definition of `deep_entry_point` (if available). 
+
+If you want to step over `deep_entry_point` and go straight to line 8, use [the `over` command](#over) instead.
+
+#### `over`
+
+Step until the next source code location, without diving into function calls. For example:
+
+```
+3    ...
+4    fn main(x: u32) {
+5        assert(entry_point(x) == 2);
+6        swap_entry_point(x, x + 1);
+7 ->     assert(deep_entry_point(x) == 4);
+8        multiple_values_entry_point(x);
+9    }
+```
+
+
+Using `over` here would cause the debugger to execute until line 8 (`multiple_values_entry_point(x);`).
+
+If you want to step into `deep_entry_point` instead, use [the `next` command](#next-n).
+
+#### `out`
+
+Step until the end of the current function call. For example:
+
+```
+  3    ...
+  4    fn main(x: u32) {
+  5        assert(entry_point(x) == 2);
+  6        swap_entry_point(x, x + 1);
+  7 ->     assert(deep_entry_point(x) == 4);
+  8        multiple_values_entry_point(x);
+  9    }
+ 10    
+ 11    unconstrained fn returns_multiple_values(x: u32) -> (u32, u32, u32, u32) {
+ 12    ...
+ ...
+ 55    
+ 56    unconstrained fn deep_entry_point(x: u32) -> u32 {
+ 57 ->     level_1(x + 1)
+ 58    }
+
+```
+
+Running `out` here will resume execution until line 8.
+
+#### `step` (s)
+
+Skips to the next ACIR code. A compiled Noir program is a sequence of ACIR opcodes. However, an unconstrained VM opcode denotes the start of an unconstrained code block, to be executed by the unconstrained VM. For example (redacted for brevity):
+
+```
+0  BLACKBOX::RANGE [(_0, num_bits: 32)] [ ]
+1 ->  BRILLIG inputs=[Single(Expression { mul_terms: [], linear_combinations: [(1, Witness(0))], q_c: 0 })] outputs=[Simple(Witness(1))]
+	1.0  |   Mov { destination: RegisterIndex(2), source: RegisterIndex(0) }
+	1.1  |   Const { destination: RegisterIndex(0), value: Value { inner: 0 } }
+	1.2  |   Const { destination: RegisterIndex(1), value: Value { inner: 0 } }
+	1.3  |   Mov { destination: RegisterIndex(2), source: RegisterIndex(2) }
+	1.4  |   Call { location: 7 }
+	...
+	1.43 |   Return
+2    EXPR [ (1, _1) -2 ]
+```
+
+The `->` here shows the debugger paused at an ACIR opcode: `BRILLIG`, at index 1, which denotes an unconstrained code block is about to start.
+
+Using the `step` command at this point would result in the debugger stopping at ACIR opcode 2, `EXPR`, skipping unconstrained computation steps.
+
+Use [the `into` command](#into-i) instead if you want to follow unconstrained computation step by step.
+
+#### `into` (i)
+
+Steps into the next opcode. A compiled Noir program is a sequence of ACIR opcodes. However, a BRILLIG opcode denotes the start of an unconstrained code block, to be executed by the unconstrained VM. For example (redacted for brevity):
+
+```
+0  BLACKBOX::RANGE [(_0, num_bits: 32)] [ ]
+1 ->  BRILLIG inputs=[Single(Expression { mul_terms: [], linear_combinations: [(1, Witness(0))], q_c: 0 })] outputs=[Simple(Witness(1))]
+	1.0  |   Mov { destination: RegisterIndex(2), source: RegisterIndex(0) }
+	1.1  |   Const { destination: RegisterIndex(0), value: Value { inner: 0 } }
+	1.2  |   Const { destination: RegisterIndex(1), value: Value { inner: 0 } }
+	1.3  |   Mov { destination: RegisterIndex(2), source: RegisterIndex(2) }
+	1.4  |   Call { location: 7 }
+	...
+	1.43 |   Return
+2    EXPR [ (1, _1) -2 ]
+``` 
+
+The `->` here shows the debugger paused at an ACIR opcode: `BRILLIG`, at index 1, which denotes an unconstrained code block is about to start.
+
+Using the `into` command at this point would result in the debugger stopping at opcode 1.0, `Mov ...`, allowing the debugger user to follow unconstrained computation step by step.
+
+Use [the `step` command](#step-s) instead if you want to skip to the next ACIR code directly.
+
+#### `continue` (c)
+
+Continues execution until the next breakpoint, or the end of the program.
+
+#### `restart` (res)
+
+Interrupts execution, and restarts a new debugging session from scratch.
+
+#### `opcodes` (o)
+
+Display the program's ACIR opcode sequence. For example:
+
+```
+0  BLACKBOX::RANGE [(_0, num_bits: 32)] [ ]
+1 ->  BRILLIG inputs=[Single(Expression { mul_terms: [], linear_combinations: [(1, Witness(0))], q_c: 0 })] outputs=[Simple(Witness(1))]
+	1.0  |   Mov { destination: RegisterIndex(2), source: RegisterIndex(0) }
+	1.1  |   Const { destination: RegisterIndex(0), value: Value { inner: 0 } }
+	1.2  |   Const { destination: RegisterIndex(1), value: Value { inner: 0 } }
+	1.3  |   Mov { destination: RegisterIndex(2), source: RegisterIndex(2) }
+	1.4  |   Call { location: 7 }
+	...
+	1.43 |   Return
+2     EXPR [ (1, _1) -2 ]
+```
+
+### Breakpoints
+
+#### `break [Opcode]` (or shorthand `b [Opcode]`)
+
+Sets a breakpoint on the specified opcode index. To get a list of the program opcode numbers, see [the `opcode` command](#opcodes-o). For example:
+
+```
+0  BLACKBOX::RANGE [(_0, num_bits: 32)] [ ]
+1 ->  BRILLIG inputs=[Single(Expression { mul_terms: [], linear_combinations: [(1, Witness(0))], q_c: 0 })] outputs=[Simple(Witness(1))]
+	1.0  |   Mov { destination: RegisterIndex(2), source: RegisterIndex(0) }
+	1.1  |   Const { destination: RegisterIndex(0), value: Value { inner: 0 } }
+	1.2  |   Const { destination: RegisterIndex(1), value: Value { inner: 0 } }
+	1.3  |   Mov { destination: RegisterIndex(2), source: RegisterIndex(2) }
+	1.4  |   Call { location: 7 }
+	...
+	1.43 |   Return
+2    EXPR [ (1, _1) -2 ]
+```
+
+In this example, issuing a `break 1.2` command adds break on opcode 1.2, as denoted by the `*` character:
+
+```
+0  BLACKBOX::RANGE [(_0, num_bits: 32)] [ ]
+1 ->  BRILLIG inputs=[Single(Expression { mul_terms: [], linear_combinations: [(1, Witness(0))], q_c: 0 })] outputs=[Simple(Witness(1))]
+	1.0  |   Mov { destination: RegisterIndex(2), source: RegisterIndex(0) }
+	1.1  |   Const { destination: RegisterIndex(0), value: Value { inner: 0 } }
+	1.2  | * Const { destination: RegisterIndex(1), value: Value { inner: 0 } }
+	1.3  |   Mov { destination: RegisterIndex(2), source: RegisterIndex(2) }
+	1.4  |   Call { location: 7 }
+	...
+	1.43 |   Return
+2    EXPR [ (1, _1) -2 ]
+```
+
+Running [the `continue` command](#continue-c) at this point would cause the debugger to execute the program until opcode 1.2.
+
+#### `delete [Opcode]` (or shorthand `d [Opcode]`)
+
+Deletes a breakpoint at an opcode location. Usage is analogous to [the `break` command](#).
+
+### Variable inspection
+
+#### vars
+
+Show variable values available at this point in execution.
+
+:::note
+The ability to inspect variable values from the debugger depends on compilation to be run in a special debug instrumentation mode. This instrumentation weaves variable tracing code with the original source code. 
+
+So variable value inspection comes at the expense of making the resulting ACIR bytecode bigger and harder to understand and optimize.
+
+If you find this compromise unacceptable, you can run the debugger with the flag `--skip-debug-instrumentation`. This will compile your circuit without any additional debug information, so the resulting ACIR bytecode will be identical to the one produced by standard Noir compilation. However, if you opt for this, the `vars` command will not be available while debugging.
+:::
+
+
+### Stacktrace
+
+#### `stacktrace`
+
+Displays the current stack trace.
+
+
+### Witness map
+
+#### `witness` (w)
+
+Show witness map. For example:
+
+```
+_0 = 0
+_1 = 2
+_2 = 1
+```
+
+#### `witness [Witness Index]`
+
+Display a single witness from the witness map. For example:
+
+```
+> witness 1
+_1 = 2
+```
+
+#### `witness [Witness Index] [New value]`
+
+Overwrite the given index with a new value. For example:
+
+```
+> witness 1 3
+_1 = 3
+```
+
+
+### Unconstrained VM memory
+
+#### `memory`
+
+Show unconstrained VM memory state. For example:
+
+```
+> memory
+At opcode 1.13: Store { destination_pointer: RegisterIndex(0), source: RegisterIndex(3) }
+...
+> registers
+0 = 0
+1 = 10
+2 = 0
+3 = 1
+4 = 1
+5 = 2³²
+6 = 1
+> into
+At opcode 1.14: Const { destination: RegisterIndex(5), value: Value { inner: 1 } }
+...
+> memory
+0 = 1
+>
+```
+
+In the example above: we start with clean memory, then step through a `Store` opcode which stores the value of register 3 (1) into the memory address stored in register 0 (0). Thus now `memory` shows memory address 0 contains value 1.
+
+:::note
+This command is only functional while the debugger is executing unconstrained code.
+:::
+
+#### `memset [Memory address] [New value]`
+
+Update a memory cell with the given value. For example:
+
+```
+> memory
+0 = 1
+> memset 0 2
+> memory
+0 = 2
+> memset 1 4
+> memory
+0 = 2
+1 = 4
+>
+```
+
+:::note
+This command is only functional while the debugger is executing unconstrained code.
+:::
\ No newline at end of file
diff --git a/docs/versioned_docs/version-v0.37.0/reference/debugger/debugger_vscode.md b/docs/versioned_docs/version-v0.37.0/reference/debugger/debugger_vscode.md
new file mode 100644
index 00000000000..c027332b3b0
--- /dev/null
+++ b/docs/versioned_docs/version-v0.37.0/reference/debugger/debugger_vscode.md
@@ -0,0 +1,82 @@
+---
+title: VS Code Debugger
+description:
+  VS Code Debugger configuration and features.
+keywords:
+  [
+    Nargo,
+    Noir CLI,
+    Noir Debugger,
+    VS Code,
+    IDE,
+  ]
+sidebar_position: 0
+---
+
+# VS Code Noir Debugger Reference
+
+The Noir debugger enabled by the vscode-noir extension ships with default settings such that the most common scenario should run without any additional configuration steps.
+
+These defaults can nevertheless be overridden by defining a launch configuration file. This page provides a reference for the properties you can override via a launch configuration file, as well as documenting the Nargo `dap` command, which is a dependency of the VS Code Noir debugger. 
+
+
+## Creating and editing launch configuration files
+
+To create a launch configuration file from VS Code, open the _debug pane_, and click on _create a launch.json file_. 
+
+![Creating a launch configuration file](@site/static/img/debugger/ref1-create-launch.png)
+
+A `launch.json` file will be created, populated with basic defaults. 
+
+### Noir Debugger launch.json properties
+
+#### projectFolder
+
+_String, optional._
+
+Absolute path to the Nargo project to debug. By default, it is dynamically determined by looking for the nearest `Nargo.toml` file to the active file at the moment of launching the debugger. 
+
+#### proverName
+
+_String, optional._
+
+Name of the prover input to use. Defaults to `Prover`, which looks for a file named `Prover.toml` at the `projectFolder`.
+
+#### generateAcir
+
+_Boolean, optional._
+
+If true, generate ACIR opcodes instead of unconstrained opcodes which will be closer to release binaries but less convenient for debugging. Defaults to `false`.
+                
+#### skipInstrumentation
+
+_Boolean, optional._
+
+Skips variables debugging instrumentation of code, making debugging less convenient but the resulting binary smaller and closer to production. Defaults to `false`.
+
+:::note
+Skipping instrumentation causes the debugger to be unable to inspect local variables.
+:::
+
+## `nargo dap [OPTIONS]`
+
+When run without any option flags, it starts the Nargo Debug Adapter Protocol server, which acts as the debugging backend for the VS Code Noir Debugger. 
+
+All option flags are related to preflight checks. The Debug Adapter Protocol specifies how errors are to be informed from a running DAP server, but it doesn't specify mechanisms to communicate server initialization errors between the DAP server and its client IDE. 
+
+Thus `nargo dap` ships with a _preflight check_ mode. If flag `--preflight-check` and the rest of the `--preflight-*` flags are provided, Nargo will run the same initialization routine except it will not start the DAP server.
+
+`vscode-noir` will then run `nargo dap` in preflight check mode first before a debugging session starts. If the preflight check ends in error, vscode-noir will present stderr and stdout output from this process through its own Output pane in VS Code. This makes it possible for users to diagnose what pieces of configuration might be wrong or missing in case of initialization errors.
+
+If the preflight check succeeds, `vscode-noir` proceeds to start the DAP server normally but running `nargo dap` without any additional flags.
+
+### Options
+
+| Option                                  | Description                                                                         |
+| --------------------------------------------------------- | --------------------------------------------------------------------------------------------------------- |
+| `--preflight-check`                     | If present, dap runs in preflight check mode.                               |
+| `--preflight-project-folder <PREFLIGHT_PROJECT_FOLDER>`   | Absolute path to the project to debug for preflight check.                        |
+| `--preflight-prover-name <PREFLIGHT_PROVER_NAME>`       | Name of prover file to use for preflight check                              |
+| `--preflight-generate-acir`                 | Optional. If present, compile in ACIR mode while running preflight check.                                 |
+| `--preflight-skip-instrumentation`            | Optional. If present, compile without introducing debug instrumentation while running preflight check.  |
+| `-h, --help`                            | Print help.                                               |
diff --git a/docs/versioned_docs/version-v0.37.0/reference/nargo_commands.md b/docs/versioned_docs/version-v0.37.0/reference/nargo_commands.md
new file mode 100644
index 00000000000..44fe8a2e62c
--- /dev/null
+++ b/docs/versioned_docs/version-v0.37.0/reference/nargo_commands.md
@@ -0,0 +1,301 @@
+---
+title: Nargo
+description:
+  Noir CLI Commands for Noir Prover and Verifier to create, execute, prove and verify programs,
+  generate Solidity verifier smart contract and compile into JSON file containing ACIR
+  representation and ABI of circuit.
+keywords:
+  [
+    Nargo,
+    Noir CLI,
+    Noir Prover,
+    Noir Verifier,
+    generate Solidity verifier,
+    compile JSON file,
+    ACIR representation,
+    ABI of circuit,
+    TypeScript,
+  ]
+sidebar_position: 0
+---
+
+# Command-Line Help for `nargo`
+
+This document contains the help content for the `nargo` command-line program.
+
+**Command Overview:**
+
+* [`nargo`↴](#nargo)
+* [`nargo check`↴](#nargo-check)
+* [`nargo fmt`↴](#nargo-fmt)
+* [`nargo compile`↴](#nargo-compile)
+* [`nargo new`↴](#nargo-new)
+* [`nargo init`↴](#nargo-init)
+* [`nargo execute`↴](#nargo-execute)
+* [`nargo debug`↴](#nargo-debug)
+* [`nargo test`↴](#nargo-test)
+* [`nargo info`↴](#nargo-info)
+* [`nargo lsp`↴](#nargo-lsp)
+
+## `nargo`
+
+Noir's package manager
+
+**Usage:** `nargo <COMMAND>`
+
+###### **Subcommands:**
+
+* `check` — Checks the constraint system for errors
+* `fmt` — Format the Noir files in a workspace
+* `compile` — Compile the program and its secret execution trace into ACIR format
+* `new` — Create a Noir project in a new directory
+* `init` — Create a Noir project in the current directory
+* `execute` — Executes a circuit to calculate its return value
+* `debug` — Executes a circuit in debug mode
+* `test` — Run the tests for this program
+* `info` — Provides detailed information on each of a program's function (represented by a single circuit)
+* `lsp` — Starts the Noir LSP server
+
+###### **Options:**
+
+
+
+
+## `nargo check`
+
+Checks the constraint system for errors
+
+**Usage:** `nargo check [OPTIONS]`
+
+###### **Options:**
+
+* `--package <PACKAGE>` — The name of the package to check
+* `--workspace` — Check all packages in the workspace
+* `--overwrite` — Force overwrite of existing files
+* `--expression-width <EXPRESSION_WIDTH>` — Specify the backend expression width that should be targeted
+* `--bounded-codegen` — Generate ACIR with the target backend expression width. The default is to generate ACIR without a bound and split expressions after code generation. Activating this flag can sometimes provide optimizations for certain programs
+
+  Default value: `false`
+* `--force` — Force a full recompilation
+* `--print-acir` — Display the ACIR for compiled circuit
+* `--deny-warnings` — Treat all warnings as errors
+* `--silence-warnings` — Suppress warnings
+* `--debug-comptime-in-file <DEBUG_COMPTIME_IN_FILE>` — Enable printing results of comptime evaluation: provide a path suffix for the module to debug, e.g. "package_name/src/main.nr"
+* `--skip-underconstrained-check` — Flag to turn off the compiler check for under constrained values. Warning: This can improve compilation speed but can also lead to correctness errors. This check should always be run on production code
+
+
+
+## `nargo fmt`
+
+Format the Noir files in a workspace
+
+**Usage:** `nargo fmt [OPTIONS]`
+
+###### **Options:**
+
+* `--check` — Run noirfmt in check mode
+
+
+
+## `nargo compile`
+
+Compile the program and its secret execution trace into ACIR format
+
+**Usage:** `nargo compile [OPTIONS]`
+
+###### **Options:**
+
+* `--package <PACKAGE>` — The name of the package to compile
+* `--workspace` — Compile all packages in the workspace
+* `--expression-width <EXPRESSION_WIDTH>` — Specify the backend expression width that should be targeted
+* `--bounded-codegen` — Generate ACIR with the target backend expression width. The default is to generate ACIR without a bound and split expressions after code generation. Activating this flag can sometimes provide optimizations for certain programs
+
+  Default value: `false`
+* `--force` — Force a full recompilation
+* `--print-acir` — Display the ACIR for compiled circuit
+* `--deny-warnings` — Treat all warnings as errors
+* `--silence-warnings` — Suppress warnings
+* `--debug-comptime-in-file <DEBUG_COMPTIME_IN_FILE>` — Enable printing results of comptime evaluation: provide a path suffix for the module to debug, e.g. "package_name/src/main.nr"
+* `--skip-underconstrained-check` — Flag to turn off the compiler check for under constrained values. Warning: This can improve compilation speed but can also lead to correctness errors. This check should always be run on production code
+
+
+
+## `nargo new`
+
+Create a Noir project in a new directory
+
+**Usage:** `nargo new [OPTIONS] <PATH>`
+
+###### **Arguments:**
+
+* `<PATH>` — The path to save the new project
+
+###### **Options:**
+
+* `--name <NAME>` — Name of the package [default: package directory name]
+* `--lib` — Use a library template
+* `--bin` — Use a binary template [default]
+* `--contract` — Use a contract template
+
+
+
+## `nargo init`
+
+Create a Noir project in the current directory
+
+**Usage:** `nargo init [OPTIONS]`
+
+###### **Options:**
+
+* `--name <NAME>` — Name of the package [default: current directory name]
+* `--lib` — Use a library template
+* `--bin` — Use a binary template [default]
+* `--contract` — Use a contract template
+
+
+
+## `nargo execute`
+
+Executes a circuit to calculate its return value
+
+**Usage:** `nargo execute [OPTIONS] [WITNESS_NAME]`
+
+###### **Arguments:**
+
+* `<WITNESS_NAME>` — Write the execution witness to named file
+
+Defaults to the name of the package being executed.
+
+###### **Options:**
+
+* `-p`, `--prover-name <PROVER_NAME>` — The name of the toml file which contains the inputs for the prover
+
+  Default value: `Prover`
+* `--package <PACKAGE>` — The name of the package to execute
+* `--workspace` — Execute all packages in the workspace
+* `--expression-width <EXPRESSION_WIDTH>` — Specify the backend expression width that should be targeted
+* `--bounded-codegen` — Generate ACIR with the target backend expression width. The default is to generate ACIR without a bound and split expressions after code generation. Activating this flag can sometimes provide optimizations for certain programs
+
+  Default value: `false`
+* `--force` — Force a full recompilation
+* `--print-acir` — Display the ACIR for compiled circuit
+* `--deny-warnings` — Treat all warnings as errors
+* `--silence-warnings` — Suppress warnings
+* `--debug-comptime-in-file <DEBUG_COMPTIME_IN_FILE>` — Enable printing results of comptime evaluation: provide a path suffix for the module to debug, e.g. "package_name/src/main.nr"
+* `--skip-underconstrained-check` — Flag to turn off the compiler check for under constrained values. Warning: This can improve compilation speed but can also lead to correctness errors. This check should always be run on production code
+* `--oracle-resolver <ORACLE_RESOLVER>` — JSON RPC url to solve oracle calls
+
+
+
+## `nargo debug`
+
+Executes a circuit in debug mode
+
+**Usage:** `nargo debug [OPTIONS] [WITNESS_NAME]`
+
+###### **Arguments:**
+
+* `<WITNESS_NAME>` — Write the execution witness to named file
+
+###### **Options:**
+
+* `-p`, `--prover-name <PROVER_NAME>` — The name of the toml file which contains the inputs for the prover
+
+  Default value: `Prover`
+* `--package <PACKAGE>` — The name of the package to execute
+* `--expression-width <EXPRESSION_WIDTH>` — Specify the backend expression width that should be targeted
+* `--bounded-codegen` — Generate ACIR with the target backend expression width. The default is to generate ACIR without a bound and split expressions after code generation. Activating this flag can sometimes provide optimizations for certain programs
+
+  Default value: `false`
+* `--force` — Force a full recompilation
+* `--print-acir` — Display the ACIR for compiled circuit
+* `--deny-warnings` — Treat all warnings as errors
+* `--silence-warnings` — Suppress warnings
+* `--debug-comptime-in-file <DEBUG_COMPTIME_IN_FILE>` — Enable printing results of comptime evaluation: provide a path suffix for the module to debug, e.g. "package_name/src/main.nr"
+* `--skip-underconstrained-check` — Flag to turn off the compiler check for under constrained values. Warning: This can improve compilation speed but can also lead to correctness errors. This check should always be run on production code
+* `--acir-mode` — Force ACIR output (disabling instrumentation)
+* `--skip-instrumentation <SKIP_INSTRUMENTATION>` — Disable vars debug instrumentation (enabled by default)
+
+  Possible values: `true`, `false`
+
+
+
+
+## `nargo test`
+
+Run the tests for this program
+
+**Usage:** `nargo test [OPTIONS] [TEST_NAME]`
+
+###### **Arguments:**
+
+* `<TEST_NAME>` — If given, only tests with names containing this string will be run
+
+###### **Options:**
+
+* `--show-output` — Display output of `println` statements
+* `--exact` — Only run tests that match exactly
+* `--package <PACKAGE>` — The name of the package to test
+* `--workspace` — Test all packages in the workspace
+* `--expression-width <EXPRESSION_WIDTH>` — Specify the backend expression width that should be targeted
+* `--bounded-codegen` — Generate ACIR with the target backend expression width. The default is to generate ACIR without a bound and split expressions after code generation. Activating this flag can sometimes provide optimizations for certain programs
+
+  Default value: `false`
+* `--force` — Force a full recompilation
+* `--print-acir` — Display the ACIR for compiled circuit
+* `--deny-warnings` — Treat all warnings as errors
+* `--silence-warnings` — Suppress warnings
+* `--debug-comptime-in-file <DEBUG_COMPTIME_IN_FILE>` — Enable printing results of comptime evaluation: provide a path suffix for the module to debug, e.g. "package_name/src/main.nr"
+* `--skip-underconstrained-check` — Flag to turn off the compiler check for under constrained values. Warning: This can improve compilation speed but can also lead to correctness errors. This check should always be run on production code
+* `--oracle-resolver <ORACLE_RESOLVER>` — JSON RPC url to solve oracle calls
+
+
+
+## `nargo info`
+
+Provides detailed information on each of a program's function (represented by a single circuit)
+
+Current information provided per circuit: 1. The number of ACIR opcodes 2. Counts the final number gates in the circuit used by a backend
+
+**Usage:** `nargo info [OPTIONS]`
+
+###### **Options:**
+
+* `--package <PACKAGE>` — The name of the package to detail
+* `--workspace` — Detail all packages in the workspace
+* `--profile-execution`
+* `-p`, `--prover-name <PROVER_NAME>` — The name of the toml file which contains the inputs for the prover
+
+  Default value: `Prover`
+* `--expression-width <EXPRESSION_WIDTH>` — Specify the backend expression width that should be targeted
+* `--bounded-codegen` — Generate ACIR with the target backend expression width. The default is to generate ACIR without a bound and split expressions after code generation. Activating this flag can sometimes provide optimizations for certain programs
+
+  Default value: `false`
+* `--force` — Force a full recompilation
+* `--print-acir` — Display the ACIR for compiled circuit
+* `--deny-warnings` — Treat all warnings as errors
+* `--silence-warnings` — Suppress warnings
+* `--debug-comptime-in-file <DEBUG_COMPTIME_IN_FILE>` — Enable printing results of comptime evaluation: provide a path suffix for the module to debug, e.g. "package_name/src/main.nr"
+* `--skip-underconstrained-check` — Flag to turn off the compiler check for under constrained values. Warning: This can improve compilation speed but can also lead to correctness errors. This check should always be run on production code
+
+
+
+## `nargo lsp`
+
+Starts the Noir LSP server
+
+Starts an LSP server which allows IDEs such as VS Code to display diagnostics in Noir source.
+
+VS Code Noir Language Support: https://marketplace.visualstudio.com/items?itemName=noir-lang.vscode-noir
+
+**Usage:** `nargo lsp`
+
+
+
+<hr/>
+
+<small><i>
+    This document was generated automatically by
+    <a href="https://crates.io/crates/clap-markdown"><code>clap-markdown</code></a>.
+</i></small>
+
diff --git a/docs/versioned_docs/version-v0.37.0/reference/noir_codegen.md b/docs/versioned_docs/version-v0.37.0/reference/noir_codegen.md
new file mode 100644
index 00000000000..e4c362f9610
--- /dev/null
+++ b/docs/versioned_docs/version-v0.37.0/reference/noir_codegen.md
@@ -0,0 +1,116 @@
+---
+title: Noir Codegen for TypeScript
+description: Learn how to use Noir codegen to generate TypeScript bindings 
+keywords: [Nargo, Noir, compile, TypeScript]
+sidebar_position: 3
+---
+
+When using TypeScript, it is extra work to interpret Noir program outputs in a type-safe way. Third party libraries may exist for popular Noir programs, but they are either hard to find or unmaintained.
+
+Now you can generate TypeScript bindings for your Noir programs in two steps:
+
+1. Exporting Noir functions using `nargo export`
+2. Using the TypeScript module `noir_codegen` to generate TypeScript binding
+
+**Note:** you can only export functions from a Noir *library* (not binary or contract program types).
+
+## Installation
+
+### Your TypeScript project
+
+If you don't already have a TypeScript project you can add the module with `yarn` (or `npm`), then initialize it:
+
+```bash
+yarn add typescript -D
+npx tsc --init
+```
+
+### Add TypeScript module - `noir_codegen`
+
+The following command will add the module to your project's devDependencies:
+
+```bash
+yarn add @noir-lang/noir_codegen -D
+```
+
+### Nargo library
+
+Make sure you have Nargo, v0.25.0 or greater, installed. If you don't, follow the [installation guide](../getting_started/noir_installation.md).
+
+If you're in a new project, make a `circuits` folder and create a new Noir library:
+
+```bash
+mkdir circuits && cd circuits
+nargo new --lib myNoirLib
+```
+
+## Usage
+
+### Export ABI of specified functions
+
+First go to the `.nr` files in your Noir library, and add the `#[export]` macro to each function that you want to use in TypeScript.
+
+```rust
+#[export]
+fn your_function(...
+```
+
+From your Noir library (where `Nargo.toml` is), run the following command:
+
+```bash
+nargo export
+```
+
+You will now have an `export` directory with a .json file per exported function.
+
+You can also specify the directory of Noir programs using `--program-dir`, for example:
+
+```bash
+nargo export --program-dir=./circuits/myNoirLib
+```
+
+### Generate TypeScript bindings from exported functions
+
+To use the `noir-codegen` package we added to the TypeScript project:
+
+```bash
+yarn noir-codegen ./export/your_function.json
+```
+
+This creates an `exports` directory with an `index.ts` file containing all exported functions.
+
+**Note:** adding `--out-dir` allows you to specify an output dir for your TypeScript bindings to go. Eg:
+
+```bash
+yarn noir-codegen ./export/*.json --out-dir ./path/to/output/dir
+```
+
+## Example .nr function to .ts output
+
+Consider a Noir library with this function:
+
+```rust
+#[export]
+fn not_equal(x: Field, y: Field) -> bool {
+    x != y
+}
+```
+
+After the export and codegen steps, you should have an `index.ts` like:
+
+```typescript
+export type Field = string;
+
+
+export const is_equal_circuit: CompiledCircuit = 
+{"abi":{"parameters":[{"name":"x","type":{"kind":"field"},"visibility":"private"},{"name":"y","type":{"kind":"field"},"visibility":"private"}],"return_type":{"abi_type":{"kind":"boolean"},"visibility":"private"}},"bytecode":"H4sIAAAAAAAA/7WUMQ7DIAxFQ0Krrr2JjSGYLVcpKrn/CaqqDQN12WK+hPBgmWd/wEyHbF1SS923uhOs3pfoChI+wKXMAXzIKyNj4PB0TFTYc0w5RUjoqeAeEu1wqK0F54RGkWvW44LPzExnlkbMEs4JNZmN8PxS42uHv82T8a3Jeyn2Ks+VLPcO558HmyLMCDOXAXXtpPt4R/Rt9T36ss6dS9HGPx/eG17nGegKBQAA"};
+
+export async function is_equal(x: Field, y: Field, foreignCallHandler?: ForeignCallHandler): Promise<boolean> {
+  const program = new Noir(is_equal_circuit);
+  const args: InputMap = { x, y };
+  const { returnValue } = await program.execute(args, foreignCallHandler);
+  return returnValue as boolean;
+}
+```
+
+Now the `is_equal()` function and relevant types are readily available for use in TypeScript.
diff --git a/docs/versioned_docs/version-v0.37.0/tooling/debugger.md b/docs/versioned_docs/version-v0.37.0/tooling/debugger.md
new file mode 100644
index 00000000000..200b5fc423a
--- /dev/null
+++ b/docs/versioned_docs/version-v0.37.0/tooling/debugger.md
@@ -0,0 +1,26 @@
+---
+title: Debugger
+description: Learn about the Noir Debugger, in its REPL or VS Code versions.
+keywords: [Nargo, VSCode, Visual Studio Code, REPL, Debugger]
+sidebar_position: 2
+---
+
+# Noir Debugger
+
+There are currently two ways of debugging Noir programs:
+
+1. From VS Code, via the [vscode-noir](https://github.com/noir-lang/vscode-noir) extension. You can install it via the [Visual Studio Marketplace](https://marketplace.visualstudio.com/items?itemName=noir-lang.vscode-noir).
+2. Via the REPL debugger, which ships with Nargo.
+
+In order to use either version of the debugger, you will need to install recent enough versions of Noir, [Nargo](../getting_started/noir_installation.md) and vscode-noir:
+
+- Noir & Nargo ≥0.28.0
+- Noir's VS Code extension ≥0.0.11
+
+:::info
+At the moment, the debugger supports debugging binary projects, but not contracts.
+:::
+
+We cover the VS Code Noir debugger more in depth in [its VS Code debugger how-to guide](../how_to/debugger/debugging_with_vs_code.md) and [the reference](../reference/debugger/debugger_vscode.md).
+
+The REPL debugger is discussed at length in [the REPL debugger how-to guide](../how_to/debugger/debugging_with_the_repl.md) and [the reference](../reference/debugger/debugger_repl.md).
diff --git a/docs/versioned_docs/version-v0.37.0/tooling/language_server.md b/docs/versioned_docs/version-v0.37.0/tooling/language_server.md
new file mode 100644
index 00000000000..81e0356ef8a
--- /dev/null
+++ b/docs/versioned_docs/version-v0.37.0/tooling/language_server.md
@@ -0,0 +1,43 @@
+---
+title: Language Server
+description: Learn about the Noir Language Server, how to install the components, and configuration that may be required.
+keywords: [Nargo, Language Server, LSP, VSCode, Visual Studio Code]
+sidebar_position: 0
+---
+
+This section helps you install and configure the Noir Language Server.
+
+The Language Server Protocol (LSP) has two components, the [Server](#language-server) and the [Client](#language-client). Below we describe each in the context of Noir.
+
+## Language Server
+
+The Server component is provided by the Nargo command line tool that you installed at the beginning of this guide.
+As long as Nargo is installed and you've used it to run other commands in this guide, it should be good to go!
+
+If you'd like to verify that the `nargo lsp` command is available, you can run `nargo --help` and look for `lsp` in the list of commands. If you see it, you're using a version of Noir with LSP support.
+
+## Language Client
+
+The Client component is usually an editor plugin that launches the Server. It communicates LSP messages between the editor and the Server. For example, when you save a file, the Client will alert the Server, so it can try to compile the project and report any errors.
+
+Currently, Noir provides a Language Client for Visual Studio Code via the [vscode-noir](https://github.com/noir-lang/vscode-noir) extension. You can install it via the [Visual Studio Marketplace](https://marketplace.visualstudio.com/items?itemName=noir-lang.vscode-noir).
+
+> **Note:** Noir's Language Server Protocol support currently assumes users' VSCode workspace root to be the same as users' Noir project root (i.e. where Nargo.toml lies).
+>
+> If LSP features seem to be missing / malfunctioning, make sure you are opening your Noir project directly (instead of as a sub-folder) in your VSCode instance.
+
+When your language server is running correctly and the VSCode plugin is installed, you should see handy codelens buttons for compilation, measuring circuit size, execution, and tests:
+
+![Compile and Execute](@site/static/img/codelens_compile_execute.png)
+![Run test](@site/static/img/codelens_run_test.png)
+
+You should also see your tests in the `testing` panel:
+
+![Testing panel](@site/static/img/codelens_testing_panel.png)
+
+### Configuration
+
+- **Noir: Enable LSP** - If checked, the extension will launch the Language Server via `nargo lsp` and communicate with it.
+- **Noir: Nargo Flags** - Additional flags may be specified if you require them to be added when the extension calls `nargo lsp`.
+- **Noir: Nargo Path** - An absolute path to a Nargo binary with the `lsp` command. This may be useful if Nargo is not within the `PATH` of your editor.
+- **Noir > Trace: Server** - Setting this to `"messages"` or `"verbose"` will log LSP messages between the Client and Server. Useful for debugging.
diff --git a/docs/versioned_docs/version-v0.37.0/tooling/testing.md b/docs/versioned_docs/version-v0.37.0/tooling/testing.md
new file mode 100644
index 00000000000..866677da567
--- /dev/null
+++ b/docs/versioned_docs/version-v0.37.0/tooling/testing.md
@@ -0,0 +1,79 @@
+---
+title: Testing in Noir
+description: Learn how to use Nargo to test your Noir program in a quick and easy way
+keywords: [Nargo, testing, Noir, compile, test]
+sidebar_position: 1
+---
+
+You can test your Noir programs using Noir circuits.
+
+Nargo will automatically compile and run any functions which have the decorator `#[test]` on them if
+you run `nargo test`.
+
+For example if you have a program like:
+
+```rust
+fn add(x: u64, y: u64) -> u64 {
+    x + y
+}
+#[test]
+fn test_add() {
+    assert(add(2,2) == 4);
+    assert(add(0,1) == 1);
+    assert(add(1,0) == 1);
+}
+```
+
+Running `nargo test` will test that the `test_add` function can be executed while satisfying all
+the constraints which allows you to test that add returns the expected values. Test functions can't
+have any arguments currently.
+
+### Test fail
+
+You can write tests that are expected to fail by using the decorator `#[test(should_fail)]`. For example:
+
+```rust
+fn add(x: u64, y: u64) -> u64 {
+    x + y
+}
+#[test(should_fail)]
+fn test_add() {
+    assert(add(2,2) == 5);
+}
+```
+
+You can be more specific and make it fail with a specific reason by using `should_fail_with = "<the reason for failure>"`:
+
+```rust
+fn main(african_swallow_avg_speed : Field) {
+    assert(african_swallow_avg_speed == 65, "What is the airspeed velocity of an unladen swallow");
+}
+
+#[test]
+fn test_king_arthur() {
+    main(65);
+}
+
+#[test(should_fail_with = "What is the airspeed velocity of an unladen swallow")]
+fn test_bridgekeeper() {
+    main(32);
+}
+```
+
+The string given to `should_fail_with` doesn't need to exactly match the failure reason, it just needs to be a substring of it:
+
+```rust
+fn main(african_swallow_avg_speed : Field) {
+    assert(african_swallow_avg_speed == 65, "What is the airspeed velocity of an unladen swallow");
+}
+
+#[test]
+fn test_king_arthur() {
+    main(65);
+}
+
+#[test(should_fail_with = "airspeed velocity")]
+fn test_bridgekeeper() {
+    main(32);
+}
+```
\ No newline at end of file
diff --git a/docs/versioned_docs/version-v0.37.0/tutorials/noirjs_app.md b/docs/versioned_docs/version-v0.37.0/tutorials/noirjs_app.md
new file mode 100644
index 00000000000..6e69ea0bbed
--- /dev/null
+++ b/docs/versioned_docs/version-v0.37.0/tutorials/noirjs_app.md
@@ -0,0 +1,366 @@
+---
+title: Building a web app with NoirJS
+description: Learn how to setup a new app that uses Noir to generate and verify zero-knowledge SNARK proofs in a typescript or javascript environment.
+keywords: [how to, guide, javascript, typescript, noir, barretenberg, zero-knowledge, proofs, app]
+sidebar_position: 0
+pagination_next: noir/concepts/data_types/index
+---
+
+NoirJS is a set of packages meant to work both in a browser and a server environment. In this tutorial, we will build a simple web app using them. From here, you should get an idea on how to proceed with your own Noir projects!
+
+You can find the complete app code for this guide [here](https://github.com/noir-lang/tiny-noirjs-app).
+
+## Setup
+
+:::note
+
+Feel free to use whatever versions, just keep in mind that Nargo and the NoirJS packages are meant to be in sync. For example, Nargo 0.31.x matches `noir_js@0.31.x`, etc.
+
+In this guide, we will be pinned to 0.31.0.
+
+:::
+
+Before we start, we want to make sure we have Node, Nargo and the Barretenberg proving system (`bb`) installed.
+
+We start by opening a terminal and executing `node --version`. If we don't get an output like `v20.10.0`, that means node is not installed. Let's do that by following the handy [nvm guide](https://github.com/nvm-sh/nvm?tab=readme-ov-file#install--update-script).
+
+As for `Nargo`, we can follow the [Nargo guide](../getting_started/quick_start.md) to install it. If you're lazy, just paste this on a terminal and run `noirup`:
+
+```sh
+curl -L https://raw.githubusercontent.com/noir-lang/noirup/main/install | bash
+```
+
+Follow the instructions on [this page](https://github.com/AztecProtocol/aztec-packages/tree/master/barretenberg/cpp/src/barretenberg/bb#installation) to install `bb`.
+Version 0.41.0 is compatible with `nargo` version 0.31.0, which you can install with `bbup -v 0.41.0` once `bbup` is installed.
+
+Easy enough. Onwards!
+
+## Our project
+
+ZK is a powerful technology. An app that doesn't reveal one of the inputs to _anyone_ is almost unbelievable, yet Noir makes it as easy as a single line of code.
+
+In fact, it's so simple that it comes nicely packaged in `nargo`. Let's do that!
+
+### Nargo
+
+Run:
+
+```bash
+nargo new circuit
+```
+
+And... That's about it. Your program is ready to be compiled and run.
+
+To compile, let's `cd` into the `circuit` folder to enter our project, and call:
+
+```bash
+nargo compile
+```
+
+This compiles our circuit into `json` format and add it to a new `target` folder.
+
+:::info
+
+At this point in the tutorial, your folder structure should look like this:
+
+```tree
+.
+└── circuit <---- our working directory
+    ├── Nargo.toml
+    ├── src
+    │   └── main.nr
+    └── target
+        └── circuit.json
+```
+
+:::
+
+### Node and Vite
+
+If you want to explore Nargo, feel free to go on a side-quest now and follow the steps in the
+[getting started](../getting_started/quick_start.md) guide. However, we want our app to run on the browser, so we need Vite.
+
+Vite is a powerful tool to generate static websites. While it provides all kinds of features, let's just go barebones with some good old vanilla JS.
+
+To do this this, go back to the previous folder (`cd ..`) and create a new vite project by running `npm create vite` and choosing "Vanilla" and "Javascript".
+
+A wild `vite-project` directory should now appear in your root folder! Let's not waste any time and dive right in:
+
+```bash
+cd vite-project
+```
+
+### Setting Up Vite and Configuring the Project
+
+Before we proceed with any coding, let's get our environment tailored for Noir. We'll start by laying down the foundations with a `vite.config.js` file. This little piece of configuration is our secret sauce for making sure everything meshes well with the NoirJS libraries and other special setups we might need, like handling WebAssembly modules. Here’s how you get that going:
+
+#### Creating the vite.config.js
+
+In your freshly minted `vite-project` folder, create a new file named `vite.config.js` and open it in your code editor. Paste the following to set the stage:
+
+```javascript
+import { defineConfig } from 'vite';
+import copy from 'rollup-plugin-copy';
+import fs from 'fs';
+import path from 'path';
+
+const wasmContentTypePlugin = {
+  name: 'wasm-content-type-plugin',
+  configureServer(server) {
+    server.middlewares.use(async (req, res, next) => {
+      if (req.url.endsWith('.wasm')) {
+        res.setHeader('Content-Type', 'application/wasm');
+        const newPath = req.url.replace('deps', 'dist');
+        const targetPath = path.join(__dirname, newPath);
+        const wasmContent = fs.readFileSync(targetPath);
+        return res.end(wasmContent);
+      }
+      next();
+    });
+  },
+};
+
+export default defineConfig(({ command }) => {
+  if (command === 'serve') {
+    return {
+      build: {
+        target: 'esnext',
+        rollupOptions: {
+          external: ['@aztec/bb.js']
+        }
+      },
+      optimizeDeps: {
+        esbuildOptions: {
+          target: 'esnext'
+        }
+      },
+      plugins: [
+        copy({
+          targets: [{ src: 'node_modules/**/*.wasm', dest: 'node_modules/.vite/dist' }],
+          copySync: true,
+          hook: 'buildStart',
+        }),
+        command === 'serve' ? wasmContentTypePlugin : [],
+      ],
+    };
+  }
+
+  return {};
+});
+```
+
+#### Install Dependencies
+
+Now that our stage is set, install the necessary NoirJS packages along with our other dependencies:
+
+```bash
+npm install && npm install @noir-lang/backend_barretenberg@0.31.0 @noir-lang/noir_js@0.31.0
+npm install rollup-plugin-copy --save-dev
+```
+
+:::info
+
+At this point in the tutorial, your folder structure should look like this:
+
+```tree
+.
+└── circuit
+    └── ...etc...
+└── vite-project <---- our working directory
+    └── ...etc...
+```
+
+:::
+
+#### Some cleanup
+
+`npx create vite` is amazing but it creates a bunch of files we don't really need for our simple example. Actually, let's just delete everything except for `vite.config.js`, `index.html`, `main.js` and `package.json`. I feel lighter already.
+
+![my heart is ready for you, noir.js](@site/static/img/memes/titanic.jpeg)
+
+## HTML
+
+Our app won't run like this, of course. We need some working HTML, at least. Let's open our broken-hearted `index.html` and replace everything with this code snippet:
+
+```html
+<!DOCTYPE html>
+<head>
+  <style>
+    .outer {
+        display: flex;
+        justify-content: space-between;
+        width: 100%;
+    }
+    .inner {
+        width: 45%;
+        border: 1px solid black;
+        padding: 10px;
+        word-wrap: break-word;
+    }
+  </style>
+</head>
+<body>
+  <script type="module" src="/main.js"></script>
+  <h1>Noir app</h1>
+  <div class="input-area">
+    <input id="guessInput" type="number" placeholder="Enter your guess" />
+    <button id="submitGuess">Submit Guess</button>
+  </div>
+  <div class="outer">
+    <div id="logs" class="inner"><h2>Logs</h2></div>
+    <div id="results" class="inner"><h2>Proof</h2></div>
+  </div>
+</body>
+</html>
+```
+
+It _could_ be a beautiful UI... Depending on which universe you live in.
+
+## Some good old vanilla Javascript
+
+Our love for Noir needs undivided attention, so let's just open `main.js` and delete everything (this is where the romantic scenery becomes a bit creepy).
+
+Start by pasting in this boilerplate code:
+
+```js
+function display(container, msg) {
+  const c = document.getElementById(container);
+  const p = document.createElement('p');
+  p.textContent = msg;
+  c.appendChild(p);
+}
+
+document.getElementById('submitGuess').addEventListener('click', async () => {
+  try {
+    // here's where love happens
+  } catch (err) {
+    display('logs', 'Oh 💔 Wrong guess');
+  }
+});
+```
+
+The display function doesn't do much. We're simply manipulating our website to see stuff happening. For example, if the proof fails, it will simply log a broken heart 😢
+
+:::info
+
+At this point in the tutorial, your folder structure should look like this:
+
+```tree
+.
+└── circuit
+    └── ...same as above
+└── vite-project
+    ├── vite.config.js
+    ├── main.js
+    ├── package.json
+    └── index.html
+```
+
+You'll see other files and folders showing up (like `package-lock.json`, `node_modules`) but you shouldn't have to care about those.
+
+:::
+
+## Some NoirJS
+
+We're starting with the good stuff now. If you've compiled the circuit as described above, you should have a `json` file we want to import at the very top of our `main.js` file:
+
+```ts
+import circuit from '../circuit/target/circuit.json';
+```
+
+[Noir is backend-agnostic](../index.mdx#whats-new-about-noir). We write Noir, but we also need a proving backend. That's why we need to import and instantiate the two dependencies we installed above: `BarretenbergBackend` and `Noir`. Let's import them right below:
+
+```js
+import { BarretenbergBackend, BarretenbergVerifier as Verifier } from '@noir-lang/backend_barretenberg';
+import { Noir } from '@noir-lang/noir_js';
+```
+
+And instantiate them inside our try-catch block:
+
+```ts
+// try {
+const backend = new BarretenbergBackend(circuit);
+const noir = new Noir(circuit);
+// }
+```
+
+:::note
+
+For the remainder of the tutorial, everything will be happening inside the `try` block
+
+:::
+
+## Our app
+
+Now for the app itself. We're capturing whatever is in the input when people press the submit button. Just add this:
+
+```js
+const x = parseInt(document.getElementById('guessInput').value);
+const input = { x, y: 2 };
+```
+
+Now we're ready to prove stuff! Let's feed some inputs to our circuit and calculate the proof:
+
+```js
+await setup(); // let's squeeze our wasm inits here
+
+display('logs', 'Generating proof... ⌛');
+const { witness } = await noir.execute(input);
+const proof = await backend.generateProof(witness);
+display('logs', 'Generating proof... ✅');
+display('results', proof.proof);
+```
+
+You're probably eager to see stuff happening, so go and run your app now!
+
+From your terminal, run `npm run dev`. If it doesn't open a browser for you, just visit `localhost:5173`. You should now see the worst UI ever, with an ugly input.
+
+![Getting Started 0](@site/static/img/noir_getting_started_1.png)
+
+Now, our circuit says `fn main(x: Field, y: pub Field)`. This means only the `y` value is public, and it's hardcoded above: `input = { x, y: 2 }`. In other words, you won't need to send your secret`x` to the verifier!
+
+By inputting any number other than 2 in the input box and clicking "submit", you should get a valid proof. Otherwise the proof won't even generate correctly. By the way, if you're human, you shouldn't be able to understand anything on the "proof" box. That's OK. We like you, human ❤️.
+
+## Verifying
+
+Time to celebrate, yes! But we shouldn't trust machines so blindly. Let's add these lines to see our proof being verified:
+
+```js
+display('logs', 'Verifying proof... ⌛');
+const isValid = await backend.verifyProof(proof);
+
+// or to cache and use the verification key:
+// const verificationKey = await backend.getVerificationKey();
+// const verifier = new Verifier();
+// const isValid = await verifier.verifyProof(proof, verificationKey);
+
+if (isValid) display('logs', 'Verifying proof... ✅');
+```
+
+You have successfully generated a client-side Noir web app!
+
+![coded app without math knowledge](@site/static/img/memes/flextape.jpeg)
+
+## Further Reading
+
+You can see how noirjs is used in a full stack Next.js hardhat application in the [noir-starter repo here](https://github.com/noir-lang/noir-starter/tree/main/vite-hardhat). The example shows how to calculate a proof in the browser and verify it with a deployed Solidity verifier contract from noirjs.
+
+You should also check out the more advanced examples in the [noir-examples repo](https://github.com/noir-lang/noir-examples), where you'll find reference usage for some cool apps.
+
+## UltraHonk Backend
+
+Barretenberg has recently exposed a new UltraHonk backend. We can use UltraHonk in NoirJS after version 0.33.0. Everything will be the same as the tutorial above, except that the class we need to import will change:
+
+```js
+import { UltraHonkBackend, UltraHonkVerifier as Verifier } from '@noir-lang/backend_barretenberg';
+```
+
+The backend will then be instantiated as such:
+
+```js
+const backend = new UltraHonkBackend(circuit);
+```
+
+Then all the commands to prove and verify your circuit will be same.
+
+The only feature currently unsupported with UltraHonk are [recursive proofs](../explainers/explainer-recursion.md).
diff --git a/docs/versioned_docs/version-v0.38.0/explainers/cspell.json b/docs/versioned_docs/version-v0.38.0/explainers/cspell.json
new file mode 100644
index 00000000000..c60b0a597b1
--- /dev/null
+++ b/docs/versioned_docs/version-v0.38.0/explainers/cspell.json
@@ -0,0 +1,5 @@
+{
+    "words": [
+        "Cryptdoku"
+    ]
+}
diff --git a/docs/versioned_docs/version-v0.38.0/explainers/explainer-oracle.md b/docs/versioned_docs/version-v0.38.0/explainers/explainer-oracle.md
new file mode 100644
index 00000000000..821e1f95c04
--- /dev/null
+++ b/docs/versioned_docs/version-v0.38.0/explainers/explainer-oracle.md
@@ -0,0 +1,57 @@
+---
+title: Oracles
+description: This guide provides an in-depth understanding of how Oracles work in Noir programming. Learn how to use outside calculations in your programs, constrain oracles, and understand their uses and limitations.
+keywords:
+  - Noir Programming
+  - Oracles
+  - JSON-RPC
+  - Foreign Call Handlers
+  - Constrained Functions
+  - Blockchain Programming
+sidebar_position: 1
+---
+
+If you've seen "The Matrix" you may recall "The Oracle" as Gloria Foster smoking cigarettes and baking cookies. While she appears to "know things", she is actually providing a calculation of a pre-determined future. Noir Oracles are similar, in a way. They don't calculate the future (yet), but they allow you to use outside calculations in your programs.
+
+![matrix oracle prediction](@site/static/img/memes/matrix_oracle.jpeg)
+
+A Noir program is usually self-contained. You can pass certain inputs to it, and it will generate a deterministic output for those inputs. But what if you wanted to defer some calculation to an outside process or source?
+
+Oracles are functions that provide this feature.
+
+## Use cases
+
+An example usage for Oracles is proving something on-chain. For example, proving that the ETH-USDC quote was below a certain target at a certain block time. Or even making more complex proofs like proving the ownership of an NFT as an anonymous login method.
+
+Another interesting use case is to defer expensive calculations to be made outside of the Noir program, and then constraining the result; similar to the use of [unconstrained functions](../noir/concepts//unconstrained.md).
+
+In short, anything that can be constrained in a Noir program but needs to be fetched from an external source is a great candidate to be used in oracles.
+
+## Constraining oracles
+
+Just like in The Matrix, Oracles are powerful. But with great power, comes great responsibility. Just because you're using them in a Noir program doesn't mean they're true. Noir has no superpowers. If you want to prove that Portugal won the Euro Cup 2016, you're still relying on potentially untrusted information.
+
+To give a concrete example, Alice wants to login to the [NounsDAO](https://nouns.wtf/) forum with her username "noir_nouner" by proving she owns a noun without revealing her ethereum address. Her Noir program could have an oracle call like this:
+
+```rust
+#[oracle(getNoun)]
+unconstrained fn get_noun(address: Field) -> Field
+```
+
+This oracle could naively resolve with the number of Nouns she possesses. However, it is useless as a trusted source, as the oracle could resolve to anything Alice wants. In order to make this oracle call actually useful, Alice would need to constrain the response from the oracle, by proving her address and the noun count belongs to the state tree of the contract.
+
+In short, **Oracles don't prove anything. Your Noir program does.**
+
+:::danger
+
+If you don't constrain the return of your oracle, you could be clearly opening an attack vector on your Noir program. Make double-triple sure that the return of an oracle call is constrained!
+
+:::
+
+## How to use Oracles
+
+On CLI, Nargo resolves oracles by making JSON RPC calls, which means it would require an RPC node to be running.
+
+In JavaScript, NoirJS accepts and resolves arbitrary call handlers (that is, not limited to JSON) as long as they match the expected types the developer defines. Refer to [Foreign Call Handler](../reference/NoirJS/noir_js/type-aliases/ForeignCallHandler.md) to learn more about NoirJS's call handling.
+
+If you want to build using oracles, follow through to the [oracle guide](../how_to/how-to-oracles.md) for a simple example on how to do that.
diff --git a/docs/versioned_docs/version-v0.38.0/explainers/explainer-recursion.md b/docs/versioned_docs/version-v0.38.0/explainers/explainer-recursion.md
new file mode 100644
index 00000000000..df8529ef4e0
--- /dev/null
+++ b/docs/versioned_docs/version-v0.38.0/explainers/explainer-recursion.md
@@ -0,0 +1,176 @@
+---
+title: Recursive proofs
+description: Explore the concept of recursive proofs in Zero-Knowledge programming. Understand how recursion works in Noir, a language for writing smart contracts on the EVM blockchain. Learn through practical examples like Alice and Bob's guessing game, Charlie's recursive merkle tree, and Daniel's reusable components. Discover how to use recursive proofs to optimize computational resources and improve efficiency.
+
+keywords:
+  [
+    "Recursive Proofs",
+    "Zero-Knowledge Programming",
+    "Noir",
+    "EVM Blockchain",
+    "Smart Contracts",
+    "Recursion in Noir",
+    "Alice and Bob Guessing Game",
+    "Recursive Merkle Tree",
+    "Reusable Components",
+    "Optimizing Computational Resources",
+    "Improving Efficiency",
+    "Verification Key",
+    "Aggregation",
+    "Recursive zkSNARK schemes",
+    "PLONK",
+    "Proving and Verification Keys"
+  ]
+sidebar_position: 1
+pagination_next: how_to/how-to-recursion
+---
+
+In programming, we tend to think of recursion as something calling itself. A classic example would be the calculation of the factorial of a number:
+
+```js
+function factorial(n) {
+    if (n === 0 || n === 1) {
+        return 1;
+    } else {
+        return n * factorial(n - 1);
+    }
+}
+```
+
+In this case, while `n` is not `1`, this function will keep calling itself until it hits the base case, bubbling up the result on the call stack:
+
+```md
+        Is `n` 1?  <---------
+           /\               /
+          /  \         n = n -1 
+         /    \           /
+       Yes     No --------
+```
+
+In Zero-Knowledge, recursion has some similarities.
+
+It is not a Noir function calling itself, but a proof being used as an input to another circuit. In short, you verify one proof *inside* another proof, returning the proof that both proofs are valid.
+
+This means that, given enough computational resources, you can prove the correctness of any arbitrary number of proofs in a single proof. This could be useful to design state channels (for which a common example would be [Bitcoin's Lightning Network](https://en.wikipedia.org/wiki/Lightning_Network)), to save on gas costs by settling one proof on-chain, or simply to make business logic less dependent on a consensus mechanism.
+
+## Examples
+
+Let us look at some of these examples
+
+### Alice and Bob - Guessing game
+
+Alice and Bob are friends, and they like guessing games. They want to play a guessing game online, but for that, they need a trusted third-party that knows both of their secrets and finishes the game once someone wins.
+
+So, they use zero-knowledge proofs. Alice tries to guess Bob's number, and Bob will generate a ZK proof stating whether she succeeded or failed.
+
+This ZK proof can go on a smart contract, revealing the winner and even giving prizes. However, this means every turn needs to be verified on-chain. This incurs some cost and waiting time that may simply make the game too expensive or time-consuming to be worth it.
+
+As a solution, Alice proposes the following: "what if Bob generates his proof, and instead of sending it on-chain, I verify it *within* my own proof before playing my own turn?".
+
+She can then generate a proof that she verified his proof, and so on.
+
+```md
+      Did you fail?  <--------------------------
+           / \                                  /
+          /   \                             n = n -1 
+         /     \                              /
+       Yes      No                           /
+        |        |                          /
+        |        |                         /
+        |      You win                    /
+        |                                /
+        |                               /
+Generate proof of that                 /
+        +                             /
+    my own guess     ----------------
+```
+
+### Charlie - Recursive merkle tree
+
+Charlie is a concerned citizen, and wants to be sure his vote in an election is accounted for. He votes with a ZK proof, but he has no way of knowing that his ZK proof was included in the total vote count!
+
+If the vote collector puts all of the votes into a [Merkle tree](https://en.wikipedia.org/wiki/Merkle_tree), everyone can prove the verification of two proofs within one proof, as such:
+
+```md
+                    abcd
+           __________|______________
+          |                         |
+         ab                         cd 
+     _____|_____              ______|______
+    |           |            |             |              
+  alice        bob        charlie        daniel 
+```
+
+Doing this recursively allows us to arrive on a final proof `abcd` which if true, verifies the correctness of all the votes.
+
+### Daniel - Reusable components
+
+Daniel has a big circuit and a big headache. A part of his circuit is a setup phase that finishes with some assertions that need to be made. But that section alone takes most of the proving time, and is largely independent of the rest of the circuit.
+
+He might find it more efficient to generate a proof for that setup phase separately, and verify that proof recursively in the actual business logic section of his circuit. This will allow for parallelization of both proofs, which results in a considerable speedup.
+
+## What params do I need
+
+As you can see in the [recursion reference](noir/standard_library/recursion.mdx), a simple recursive proof requires:
+
+- The proof to verify
+- The Verification Key of the circuit that generated the proof
+- A hash of this verification key, as it's needed for some backends
+- The public inputs for the proof
+
+:::info
+
+Recursive zkSNARK schemes do not necessarily "verify a proof" in the sense that you expect a true or false to be spit out by the verifier. Rather an aggregation object is built over the public inputs.
+
+So, taking the example of Alice and Bob and their guessing game:
+
+- Alice makes her guess. Her proof is *not* recursive: it doesn't verify any proof within it! It's just a standard `assert(x != y)` circuit
+- Bob verifies Alice's proof and makes his own guess. In this circuit, he doesn't exactly *prove* the verification of Alice's proof. Instead, he *aggregates* his proof to Alice's proof. The actual verification is done when the full proof is verified, for example when using `nargo verify` or through the verifier smart contract.
+
+We can imagine recursive proofs a [relay race](https://en.wikipedia.org/wiki/Relay_race). The first runner doesn't have to receive the baton from anyone else, as he/she already starts with it. But when his/her turn is over, the next runner needs to receive it, run a bit more, and pass it along. Even though every runner could theoretically verify the baton mid-run (why not? 🏃🔍), only at the end of the race does the referee verify that the whole race is valid.
+
+:::
+
+## Some architecture
+
+As with everything in computer science, there's no one-size-fits all. But there are some patterns that could help understanding and implementing them. To give three examples:
+
+### Adding some logic to a proof verification
+
+This would be an approach for something like our guessing game, where proofs are sent back and forth and are verified by each opponent. This circuit would be divided in two sections:
+
+- A `recursive verification` section, which would be just the call to `std::verify_proof`, and that would be skipped on the first move (since there's no proof to verify)
+- A `guessing` section, which is basically the logic part where the actual guessing happens
+
+In such a situation, and assuming Alice is first, she would skip the first part and try to guess Bob's number. Bob would then verify her proof on the first section of his run, and try to guess Alice's number on the second part, and so on.
+
+### Aggregating proofs
+
+In some one-way interaction situations, recursion would allow for aggregation of simple proofs that don't need to be immediately verified on-chain or elsewhere.
+
+To give a practical example, a barman wouldn't need to verify a "proof-of-age" on-chain every time he serves alcohol to a customer. Instead, the architecture would comprise two circuits:
+
+- A `main`, non-recursive circuit with some logic
+- A `recursive` circuit meant to verify two proofs in one proof
+
+The customer's proofs would be intermediate, and made on their phones, and the barman could just verify them locally. He would then aggregate them into a final proof sent on-chain (or elsewhere) at the end of the day.
+
+### Recursively verifying different circuits
+
+Nothing prevents you from verifying different circuits in a recursive proof, for example:
+
+- A `circuit1` circuit
+- A `circuit2` circuit
+- A `recursive` circuit
+
+In this example, a regulator could verify that taxes were paid for a specific purchase by aggregating both a `payer` circuit (proving that a purchase was made and taxes were paid), and a `receipt` circuit (proving that the payment was received)
+
+## How fast is it
+
+At the time of writing, verifying recursive proofs is surprisingly fast. This is because most of the time is spent on generating the verification key that will be used to generate the next proof. So you are able to cache the verification key and reuse it later.
+
+Currently, Noir JS packages don't expose the functionality of loading proving and verification keys, but that feature exists in the underlying `bb.js` package.
+
+## How can I try it
+
+Learn more about using recursion in Nargo and NoirJS in the [how-to guide](../how_to/how-to-recursion.md) and see a full example in [noir-examples](https://github.com/noir-lang/noir-examples).
diff --git a/docs/versioned_docs/version-v0.38.0/explainers/explainer-writing-noir.md b/docs/versioned_docs/version-v0.38.0/explainers/explainer-writing-noir.md
new file mode 100644
index 00000000000..3ce4245dc45
--- /dev/null
+++ b/docs/versioned_docs/version-v0.38.0/explainers/explainer-writing-noir.md
@@ -0,0 +1,177 @@
+---
+title: Thinking in Circuits
+description: Considerations when writing Noir programs
+keywords: [Noir, programming, rust]
+tags: [Optimization]
+sidebar_position: 0
+---
+
+
+This article intends to set you up with key concepts essential for writing more viable applications that use zero knowledge proofs, namely around efficient circuits.
+
+## Context - 'Efficient' is subjective
+
+When writing a web application for a performant computer with high-speed internet connection, writing efficient code sometimes is seen as an afterthought only if needed. Large multiplications running at the innermost of nested loops may not even be on a dev's radar.
+When writing firmware for a battery-powered microcontroller, you think of cpu cycles as rations to keep within a product's power budget.
+
+> Code is written to create applications that perform specific tasks within specific constraints
+
+And these constraints differ depending on where the compiled code is execute.
+
+### The Ethereum Virtual Machine (EVM)
+
+In scenarios where extremely low gas costs are required for an Ethereum application to be viable/competitive, Ethereum smart contract developers get into what is colloquially known as: "*gas golfing*". Finding the lowest execution cost of their compiled code (EVM bytecode) to achieve a specific task.
+
+The equivalent optimization task when writing zk circuits is affectionately referred to as "*gate golfing*", finding the lowest gate representation of the compiled Noir code.
+
+### Coding for circuits - a paradigm shift
+
+In zero knowledge cryptography, code is compiled to "circuits" consisting of arithmetic gates, and gate count is the significant cost. Depending on the proving system this is linearly proportionate to proving time, and so from a product point this should be kept as low as possible.
+
+Whilst writing efficient code for web apps and Solidity has a few key differences, writing efficient circuits have a different set of considerations. It is a bit of a paradigm shift, like writing code for GPUs for the first time...
+
+For example, drawing a circle at (0, 0) of radius `r`:
+- For a single CPU thread,
+```
+for theta in 0..2*pi {
+  let x = r * cos(theta);
+  let y = r * sin(theta);
+  draw(x, y);
+} // note: would do 0 - pi/2 and draw +ve/-ve x and y.
+```
+
+- For GPUs (simultaneous parallel calls with x, y across image),
+```
+if (x^2 + y^2 = r^2) {
+  draw(x, y);
+}
+```
+
+([Related](https://www.youtube.com/watch?v=-P28LKWTzrI))
+
+Whilst this CPU -> GPU does not translate to circuits exactly, it is intended to exemplify the difference in intuition when coding for different machine capabilities/constraints.
+
+### Context Takeaway
+
+For those coming from a primarily web app background, this article will explain what you need to consider when writing circuits. Furthermore, for those experienced writing efficient machine code, prepare to shift what you think is efficient 😬
+
+## Translating from Rust
+
+For some applications using Noir, existing code might be a convenient starting point to then proceed to optimize the gate count of.
+
+:::note
+Many valuable functions and algorithms have been written in more established languages (C/C++), and converted to modern ones (like Rust).
+:::
+
+Fortunately for Noir developers, when needing a particular function a Rust implementation can be readily compiled into Noir with some key changes. While the compiler does a decent amount of optimizations, it won't be able to change code that has been optimized for clock-cycles into code optimized for arithmetic gates.
+
+A few things to do when converting Rust code to Noir:
+- `println!` is not a macro, use `println` function (same for `assert_eq`)
+- No early `return` in function. Use constrain via assertion instead
+- No passing by reference. Remove `&` operator to pass by value (copy)
+- No boolean operators (`&&`, `||`). Use bitwise operators (`&`, `|`) with boolean values
+- No type `usize`. Use types `u8`, `u32`, `u64`, ... 
+- `main` return must be public, `pub`
+- No `const`, use `global`
+- Noir's LSP is your friend, so error message should be informative enough to resolve syntax issues.
+
+## Writing efficient Noir for performant products
+
+The following points help refine our understanding over time.
+
+:::note
+A Noir program makes a statement that can be verified.
+:::
+
+It compiles to a structure that represents the calculation, and can assert results within the calculation at any stage (via the `constrain` keyword).
+
+A Noir program compiles to an Abstract Circuit Intermediate Representation which is:
+ - Conceptually a tree structure
+ - Leaves (inputs) are the `Field` type
+ - Nodes contain arithmetic operations to combine them (gates)
+ - The root is the final result (return value)
+
+:::tip
+The command `nargo info` shows the programs circuit size, and is useful to compare the value of changes made.
+You can dig deeper and use the `--print-acir` param to take a closer look at individual ACIR opcodes, and the proving backend to see its gate count (eg for barretenberg, `bb gates -b ./target/program.json`).
+:::
+
+### Use the `Field` type
+
+Since the native type of values in circuits are `Field`s, using them for variables in Noir means less gates converting them under the hood.
+Some things to be mindful of when using a Field type for a regular integer value:
+- A variable of type `Field` can be cast `as` an integer type (eg `u8`, `u64`)
+  - Note: this retains only the bits of the integer type. Eg a Field value of 260 as a `u8` becomes 4
+- For Field types arithmetic operations meaningfully overflow/underflow, yet for integer types they are checked according to their size
+- Comparisons and bitwise operations do not exist for `Field`s, cast to an appropriately sized integer type when you need to
+
+:::tip
+Where possible, use `Field` type for values. Using smaller value types, and bit-packing strategies, will result in MORE gates
+:::
+
+
+### Use Arithmetic over non-arithmetic operations
+
+Since circuits are made of arithmetic gates, the cost of arithmetic operations tends to be one gate. Whereas for procedural code, they represent several clock cycles.
+
+Inversely, non-arithmetic operators are achieved with multiple gates, vs 1 clock cycle for procedural code.
+
+| (cost\op)  | arithmetic<br>(`*`, `+`) | bit-wise ops<br>(eg `<`, `\|`, `>>`) |
+| - | - | - |
+| **cycles** | 10+ | 1 |
+| **gates**  | 1 | 10+ |
+
+Bit-wise operations (e.g. bit shifts `<<` and `>>`), albeit commonly used in general programming and especially for clock cycle optimizations, are on the contrary expensive in gates when performed within circuits.
+
+Translate away from bit shifts when writing constrained functions for the best performance.
+
+On the flip side, feel free to use bit shifts in unconstrained functions and tests if necessary, as they are executed outside of circuits and does not induce performance hits.
+
+### Use static over dynamic values
+
+Another general theme that manifests in different ways is that static reads are represented with less gates than dynamic ones.
+
+Reading from read-only memory (ROM) adds less gates than random-access memory (RAM), 2 vs ~3.25 due to the additional bounds checks. Arrays of fixed length (albeit used at a lower capacity), will generate less gates than dynamic storage.
+
+Related to this, if an index used to access an array is not known at compile time (ie unknown until run time), then ROM will be converted to RAM, expanding the gate count.
+
+:::tip
+Use arrays and indices that are known at compile time where possible.
+Using `assert_constant(i);` before an index, `i`, is used in an array will give a compile error if `i` is NOT known at compile time.
+:::
+
+### Leverage unconstrained execution
+
+Constrained verification can leverage unconstrained execution, this is especially useful for operations that are represented by many gates.
+Use an [unconstrained function](../noir/concepts/unconstrained.md) to perform gate-heavy calculations, then verify and constrain the result.
+
+Eg division generates more gates than multiplication, so calculating the quotient in an unconstrained function then constraining the product for the quotient and divisor (+ any remainder) equals the dividend will be more efficient.
+
+Use `  if is_unconstrained() { /`, to conditionally execute code if being called in an unconstrained vs constrained way.
+
+## Advanced
+
+Unless you're well into the depth of gate optimization, this advanced section can be ignored.
+
+### Combine arithmetic operations
+
+A Noir program can be honed further by combining arithmetic operators in a way that makes the most of each constraint of the backend proving system. This is in scenarios where the backend might not be doing this perfectly.
+
+Eg Barretenberg backend (current default for Noir) is a width-4 PLONKish constraint system
+$ w_1*w_2*q_m + w_1*q_1 + w_2*q_2 + w_3*q_3 + w_4*q_4 + q_c = 0 $
+
+Here we see there is one occurrence of witness 1 and 2 ($w_1$, $w_2$) being multiplied together, with addition to witnesses 1-4 ($w_1$ .. $w_4$) multiplied by 4 corresponding circuit constants ($q_1$ .. $q_4$) (plus a final circuit constant, $q_c$).
+
+Use `nargo info --print-acir`, to inspect the ACIR opcodes (and the proving system for gates), and it may present opportunities to amend the order of operations and reduce the number of constraints.
+
+#### Variable as witness vs expression
+
+If you've come this far and really know what you're doing at the equation level, a temporary lever (that will become unnecessary/useless over time) is: `std::as_witness`. This informs the compiler to save a variable as a witness not an expression.
+
+The compiler will mostly be correct and optimal, but this may help some near term edge cases that are yet to optimize.
+Note: When used incorrectly it will create **less** efficient circuits (higher gate count).
+
+## References
+- Guillaume's ["`Cryptdoku`" talk](https://www.youtube.com/watch?v=MrQyzuogxgg) (Jun'23)
+- Tips from Tom, Jake and Zac.
+- [Idiomatic Noir](https://www.vlayer.xyz/blog/idiomatic-noir-part-1-collections) blog post
diff --git a/docs/versioned_docs/version-v0.38.0/getting_started/noir_installation.md b/docs/versioned_docs/version-v0.38.0/getting_started/noir_installation.md
new file mode 100644
index 00000000000..a5c7e649278
--- /dev/null
+++ b/docs/versioned_docs/version-v0.38.0/getting_started/noir_installation.md
@@ -0,0 +1,106 @@
+---
+title: Standalone Noir Installation
+description: There are different ways to install Nargo, the one-stop shop and command-line tool for developing Noir programs. This guide explains how to specify which version to install when using noirup, and using WSL for windows.
+keywords: [
+    Installation
+    Nargo
+    Noirup
+    Binaries
+    Compiling from Source
+    WSL for Windows
+    macOS
+    Linux
+    Nix
+    Direnv
+    Uninstalling Nargo
+  ]
+sidebar_position: 2
+---
+
+Noirup is the endorsed method for installing Nargo, streamlining the process of fetching binaries or compiling from source. It supports a range of options to cater to your specific needs, from nightly builds and specific versions to compiling from various sources.
+
+### Installing Noirup
+
+First, ensure you have `noirup` installed:
+
+```sh
+curl -L https://raw.githubusercontent.com/noir-lang/noirup/main/install | bash
+```
+
+### Fetching Binaries
+
+With `noirup`, you can easily switch between different Nargo versions, including nightly builds:
+
+- **Nightly Version**: Install the latest nightly build.
+
+  ```sh
+  noirup --version nightly
+  ```
+
+- **Specific Version**: Install a specific version of Nargo.
+
+  ```sh
+  noirup --version <version>
+  ```
+
+### Compiling from Source
+
+`noirup` also enables compiling Nargo from various sources:
+
+- **From a Specific Branch**: Install from the latest commit on a branch.
+
+  ```sh
+  noirup --branch <branch-name>
+  ```
+
+- **From a Fork**: Install from the main branch of a fork.
+
+  ```sh
+  noirup --repo <username/repo>
+  ```
+
+- **From a Specific Branch in a Fork**: Install from a specific branch in a fork.
+
+  ```sh
+  noirup --repo <username/repo> --branch <branch-name>
+  ```
+
+- **From a Specific Pull Request**: Install from a specific PR.
+
+  ```sh
+  noirup --pr <pr-number>
+  ```
+
+- **From a Specific Commit**: Install from a specific commit.
+
+  ```sh
+  noirup -C <commit-hash>
+  ```
+
+- **From Local Source**: Compile and install from a local directory.
+
+  ```sh
+  noirup --path ./path/to/local/source
+  ```
+
+## Installation on Windows
+
+The default backend for Noir (Barretenberg) doesn't provide Windows binaries at this time. For that reason, Noir cannot be installed natively. However, it is available by using Windows Subsystem for Linux (WSL).
+
+Step 1: Follow the instructions [here](https://learn.microsoft.com/en-us/windows/wsl/install) to install and run WSL.
+
+step 2: Follow the [Noirup instructions](#installing-noirup).
+
+## Setting up shell completions
+
+Once `nargo` is installed, you can [set up shell completions for it](setting_up_shell_completions).
+
+## Uninstalling Nargo
+
+If you installed Nargo with `noirup`, you can uninstall Nargo by removing the files in `~/.nargo`, `~/nargo`, and `~/noir_cache`. This ensures that all installed binaries, configurations, and cache related to Nargo are fully removed from your system.
+
+```bash
+rm -r ~/.nargo
+rm -r ~/nargo
+rm -r ~/noir_cache
+```
diff --git a/docs/versioned_docs/version-v0.38.0/getting_started/project_breakdown.md b/docs/versioned_docs/version-v0.38.0/getting_started/project_breakdown.md
new file mode 100644
index 00000000000..e442e377040
--- /dev/null
+++ b/docs/versioned_docs/version-v0.38.0/getting_started/project_breakdown.md
@@ -0,0 +1,159 @@
+---
+title: Project Breakdown
+description:
+  Learn about the anatomy of a Nargo project, including the purpose of the Prover TOML
+  file, and how to prove and verify your program.
+keywords:
+  [Nargo, Nargo project, Prover.toml, proof verification, private asset transfer]
+sidebar_position: 1
+---
+
+This section breaks down our hello world program from the previous section.
+
+## Anatomy of a Nargo Project
+
+Upon creating a new project with `nargo new` and building the in/output files with `nargo check`
+commands, you would get a minimal Nargo project of the following structure:
+
+    - src
+    - Prover.toml
+    - Nargo.toml
+
+The source directory _src_ holds the source code for your Noir program. By default only a _main.nr_
+file will be generated within it.
+
+### Prover.toml
+
+_Prover.toml_ is used for specifying the input values for executing and proving the program. You can specify `toml` files with different names by using the `--prover-name` or `-p` flags, see the [Prover](#provertoml) section below. Optionally you may specify expected output values for prove-time checking as well.
+
+### Nargo.toml
+
+_Nargo.toml_ contains the environmental options of your project. It contains a "package" section and a "dependencies" section.
+
+Example Nargo.toml:
+
+```toml
+[package]
+name = "noir_starter"
+type = "bin"
+authors = ["Alice"]
+compiler_version = "0.9.0"
+description = "Getting started with Noir"
+entry = "circuit/main.nr"
+license = "MIT"
+
+[dependencies]
+ecrecover = {tag = "v0.9.0", git = "https://github.com/colinnielsen/ecrecover-noir.git"}
+```
+
+Nargo.toml for a [workspace](../noir/modules_packages_crates/workspaces.md) will look a bit different. For example:
+
+```toml
+[workspace]
+members = ["crates/a", "crates/b"]
+default-member = "crates/a"
+```
+
+#### Package section
+
+The package section defines a number of fields including:
+
+- `name` (**required**) - the name of the package
+- `type` (**required**) - can be "bin", "lib", or "contract" to specify whether its a binary, library or Aztec contract
+- `authors` (optional) - authors of the project
+- `compiler_version` - specifies the version of the compiler to use. This is enforced by the compiler and follow's [Rust's versioning](https://doc.rust-lang.org/cargo/reference/manifest.html#the-version-field), so a `compiler_version = 0.18.0` will enforce Nargo version 0.18.0, `compiler_version = ^0.18.0` will enforce anything above 0.18.0 but below 0.19.0, etc. For more information, see how [Rust handles these operators](https://docs.rs/semver/latest/semver/enum.Op.html)
+- `description` (optional)
+- `entry` (optional) - a relative filepath to use as the entry point into your package (overrides the default of `src/lib.nr` or `src/main.nr`)
+- `backend` (optional)
+- `license` (optional)
+- `expression_width` (optional) - Sets the default backend expression width. This field will override the default backend expression width specified by the Noir compiler (currently set to width 4).
+
+#### Dependencies section
+
+This is where you will specify any dependencies for your project. See the [Dependencies page](../noir/modules_packages_crates/dependencies.md) for more info.
+
+`./proofs/` and `./contract/` directories will not be immediately visible until you create a proof or
+verifier contract respectively.
+
+### main.nr
+
+The _main.nr_ file contains a `main` method, this method is the entry point into your Noir program.
+
+In our sample program, _main.nr_ looks like this:
+
+```rust
+fn main(x : Field, y : Field) {
+    assert(x != y);
+}
+```
+
+The parameters `x` and `y` can be seen as the API for the program and must be supplied by the prover. Since neither `x` nor `y` is marked as public, the verifier does not supply any inputs, when verifying the proof.
+
+The prover supplies the values for `x` and `y` in the _Prover.toml_ file.
+
+As for the program body, `assert` ensures that the condition to be satisfied (e.g. `x != y`) is constrained by the proof of the execution of said program (i.e. if the condition was not met, the verifier would reject the proof as an invalid proof).
+
+### Prover.toml
+
+The _Prover.toml_ file is a file which the prover uses to supply the inputs to the Noir program (both private and public).
+
+In our hello world program the _Prover.toml_ file looks like this:
+
+```toml
+x = "1"
+y = "2"
+```
+
+When the command `nargo execute` is executed, nargo will execute the Noir program using the inputs specified in `Prover.toml`, aborting if it finds that these do not satisfy the constraints defined by `main`. In this example, `x` and `y` must satisfy the inequality constraint `assert(x != y)`.
+
+If an output name is specified such as `nargo execute foo`, the witness generated by this execution will be written to `./target/foo.gz`. This can then be used to generate a proof of the execution.
+
+#### Arrays of Structs
+
+The following code shows how to pass an array of structs to a Noir program to generate a proof.
+
+```rust
+// main.nr
+struct Foo {
+    bar: Field,
+    baz: Field,
+}
+
+fn main(foos: [Foo; 3]) -> pub Field {
+    foos[2].bar + foos[2].baz
+}
+```
+
+Prover.toml:
+
+```toml
+[[foos]] # foos[0]
+bar = 0
+baz = 0
+
+[[foos]] # foos[1]
+bar = 0
+baz = 0
+
+[[foos]] # foos[2]
+bar = 1
+baz = 2
+```
+
+#### Custom toml files
+
+You can specify a `toml` file with a different name to use for execution by using the `--prover-name` or `-p` flags.
+
+This command looks for proof inputs in the default **Prover.toml** and generates the witness and saves it at `./target/foo.gz`:
+
+```bash
+nargo execute foo
+```
+
+This command looks for proof inputs in the custom **OtherProver.toml** and generates the witness and saves it at `./target/bar.gz`:
+
+```bash
+nargo execute -p OtherProver bar
+```
+
+Now that you understand the concepts, you'll probably want some editor feedback while you are writing more complex code.
diff --git a/docs/versioned_docs/version-v0.38.0/getting_started/quick_start.md b/docs/versioned_docs/version-v0.38.0/getting_started/quick_start.md
new file mode 100644
index 00000000000..c693624eb82
--- /dev/null
+++ b/docs/versioned_docs/version-v0.38.0/getting_started/quick_start.md
@@ -0,0 +1,126 @@
+---
+title: Quick Start
+tags: []
+sidebar_position: 0
+---
+
+## Installation
+
+### Noir
+
+The easiest way to develop with Noir is using Nargo the CLI tool. It provides you the ability to start new projects, compile, execute and test Noir programs from the terminal.
+
+You can use `noirup` the installation script to quickly install and update Nargo:
+
+```bash
+curl -L noirup.dev | bash
+noirup
+```
+
+Once installed, you can [set up shell completions for the `nargo` command](setting_up_shell_completions).
+
+### Proving backend
+
+After installing Noir, we install a proving backend to work with our Noir programs.
+
+Proving backends provide you the abilities to generate proofs, verify proofs, generate smart contracts and more for your Noir programs.
+
+Different proving backends provide different tools for working with Noir programs, here we will use the [Barretenberg proving backend](https://github.com/AztecProtocol/aztec-packages/tree/master/barretenberg) developed by Aztec Labs as an example.
+
+You can use the `bbup` installation script to quickly install and update BB, Barretenberg's CLI tool:
+
+You can find the full list of proving backends compatible with Noir in Awesome Noir.
+
+```bash
+curl -L bbup.dev | bash
+bbup
+```
+
+For the full list of proving backends compatible with Noir, visit [Awesome Noir](https://github.com/noir-lang/awesome-noir/?tab=readme-ov-file#proving-backends).
+
+## Nargo
+
+Nargo provides the ability to initiate and execute Noir projects. Let's initialize the traditional `hello_world`:
+
+```sh
+nargo new hello_world
+```
+
+Two files will be created.
+
+- `src/main.nr` contains a simple boilerplate circuit
+- `Nargo.toml` contains environmental options, such as name, author, dependencies, and others.
+
+Glancing at _main.nr_ , we can see that inputs in Noir are private by default, but can be labeled public using the keyword `pub`. This means that we will _assert_ that we know a value `x` which is different from `y` without revealing `x`:
+
+```rust
+fn main(x : Field, y : pub Field) {
+    assert(x != y);
+}
+```
+
+To learn more about private and public values, check the [Data Types](../noir/concepts/data_types/index.md) section.
+
+### Compiling and executing
+
+We can now use `nargo` to generate a _Prover.toml_ file, where our input values will be specified:
+
+```sh
+cd hello_world
+nargo check
+
+Let's feed some valid values into this file:
+
+```toml
+x = "1"
+y = "2"
+```
+
+We're now ready to compile and execute our Noir program. By default the `nargo execute` command will do both, and generate the `witness` that we need to feed to our proving backend:
+
+```sh
+nargo execute
+```
+
+The witness corresponding to this execution will then be written to the file _./target/witness-name.gz_.
+
+The command also automatically compiles your Noir program if it was not already / was edited, which you may notice the compiled artifacts being written to the file _./target/hello_world.json_.
+
+With circuit compiled and witness generated, we're ready to prove.
+
+## Proving backend
+ 
+Different proving backends may provide different tools and commands to work with Noir programs. Here Barretenberg's `bb` CLI tool is used as an example:
+
+```sh
+bb prove -b ./target/hello_world.json -w ./target/hello_world.gz -o ./target/proof
+```
+
+:::tip
+
+Naming can be confusing, specially as you pass them to the `bb` commands. If unsure, it won't hurt to delete the target folder and start anew to make sure you're using the most recent versions of the compiled circuit and witness.
+
+:::
+
+The proof is now generated in the `target` folder. To verify it we first need to compute the verification key from the compiled circuit, and use it to verify:
+
+```sh
+bb write_vk -b ./target/hello_world.json -o ./target/vk
+bb verify -k ./target/vk -p ./target/proof
+```
+
+:::info
+
+Notice that in order to verify a proof, the verifier knows nothing but the circuit, which is compiled and used to generate the verification key. This is obviously quite important: private inputs remain private.
+
+As for the public inputs, you may have noticed they haven't been specified. This behavior varies with each particular backend, but barretenberg typically attaches them to the proof. You can see them by parsing and splitting it. For example for if your public inputs are 32 bytes:
+
+```bash
+head -c 32 ./target/proof | od -An -v -t x1 | tr -d $' \n'
+```
+
+:::
+
+Congratulations, you have now created and verified a proof for your very first Noir program!
+
+In the [next section](./project_breakdown.md), we will go into more detail on each step performed.
diff --git a/docs/versioned_docs/version-v0.38.0/getting_started/setting_up_shell_completions.md b/docs/versioned_docs/version-v0.38.0/getting_started/setting_up_shell_completions.md
new file mode 100644
index 00000000000..0447321cbab
--- /dev/null
+++ b/docs/versioned_docs/version-v0.38.0/getting_started/setting_up_shell_completions.md
@@ -0,0 +1,87 @@
+---
+title: Setting up shell completions
+tags: []
+sidebar_position: 3
+---
+
+The `nargo` binary provides a command to generate shell completions:
+
+```bash
+nargo generate-completion-script [shell]
+```
+
+where `shell` must be one of `bash`, `elvish`, `fish`, `powershell`, and `zsh`.
+
+Below we explain how to install them in some popular shells.
+
+## Installing Zsh Completions
+
+If you have `oh-my-zsh` installed, you might already have a directory of automatically loading completion scripts — `.oh-my-zsh/completions`.
+If not, first create it:
+
+```bash
+mkdir -p ~/.oh-my-zsh/completions`
+```
+
+Then copy the completion script to that directory:
+
+```bash
+nargo generate-completion-script zsh > ~/.oh-my-zsh/completions/_nargo
+```
+
+Without `oh-my-zsh`, you’ll need to add a path for completion scripts to your function path, and turn on completion script auto-loading. 
+First, add these lines to `~/.zshrc`:
+
+```bash
+fpath=(~/.zsh/completions $fpath)
+autoload -U compinit
+compinit
+```
+
+Next, create a directory at `~/.zsh/completions`:
+
+```bash
+mkdir -p ~/.zsh/completions
+```
+
+Then copy the completion script to that directory:
+
+```bash
+nargo generate-completion-script zsh > ~/.zsh/completions/_nargo
+```
+
+## Installing Bash Completions
+
+If you have [bash-completion](https://github.com/scop/bash-completion) installed, you can just copy the completion script to the `/usr/local/etc/bash_completion.d` directory:
+
+```bash
+nargo generate-completion-script bash > /usr/local/etc/bash_completion.d/nargo
+```
+
+Without `bash-completion`, you’ll need to source the completion script directly. 
+First create a directory such as `~/.bash_completions/`:
+
+```bash
+mkdir ~/.bash_completions/
+```
+
+Copy the completion script to that directory:
+
+```bash
+nargo generate-completion-script bash > ~/.bash_completions/nargo.bash
+```
+
+Then add the following line to `~/.bash_profile` or `~/.bashrc`:
+
+
+```bash
+source ~/.bash_completions/nargo.bash
+```
+
+## Installing Fish Completions
+
+Copy the completion script to any path listed in the environment variable `$fish_completion_path`. For example, a typical location is `~/.config/fish/completions/nargo.fish`:
+
+```bash
+nargo generate-completion-script fish > ~/.config/fish/completions/nargo.fish
+```
diff --git a/docs/versioned_docs/version-v0.38.0/how_to/_category_.json b/docs/versioned_docs/version-v0.38.0/how_to/_category_.json
new file mode 100644
index 00000000000..23b560f610b
--- /dev/null
+++ b/docs/versioned_docs/version-v0.38.0/how_to/_category_.json
@@ -0,0 +1,5 @@
+{
+    "position": 1,
+    "collapsible": true,
+    "collapsed": true
+}
diff --git a/docs/versioned_docs/version-v0.38.0/how_to/debugger/_category_.json b/docs/versioned_docs/version-v0.38.0/how_to/debugger/_category_.json
new file mode 100644
index 00000000000..cc2cbb1c253
--- /dev/null
+++ b/docs/versioned_docs/version-v0.38.0/how_to/debugger/_category_.json
@@ -0,0 +1,6 @@
+{
+    "label": "Debugging",
+    "position": 5,
+    "collapsible": true,
+    "collapsed": true
+}
diff --git a/docs/versioned_docs/version-v0.38.0/how_to/debugger/debugging_with_the_repl.md b/docs/versioned_docs/version-v0.38.0/how_to/debugger/debugging_with_the_repl.md
new file mode 100644
index 00000000000..1d64dae3f37
--- /dev/null
+++ b/docs/versioned_docs/version-v0.38.0/how_to/debugger/debugging_with_the_repl.md
@@ -0,0 +1,164 @@
+---
+title: Using the REPL Debugger
+description:
+  Step-by-step guide on how to debug your Noir circuits with the REPL Debugger. 
+keywords:
+  [
+    Nargo,
+    Noir CLI,
+    Noir Debugger,
+    REPL,
+  ]
+sidebar_position: 1
+---
+
+#### Pre-requisites
+
+In order to use the REPL debugger, first you need to install recent enough versions of Nargo and vscode-noir. 
+
+## Debugging a simple circuit
+
+Let's debug a simple circuit:
+
+```rust
+fn main(x : Field, y : pub Field) {
+    assert(x != y);
+}
+```
+
+To start the REPL debugger, using a terminal, go to a Noir circuit's home directory. Then:
+
+`$ nargo debug`
+
+You should be seeing this in your terminal:
+
+```
+[main] Starting debugger
+At ~/noir-examples/recursion/circuits/main/src/main.nr:1:9
+  1 -> fn main(x : Field, y : pub Field) {
+  2        assert(x != y);
+  3    }
+> 
+```
+
+The debugger displays the current Noir code location, and it is now waiting for us to drive it.
+
+Let's first take a look at the available commands. For that we'll use the `help` command.
+
+```
+> help
+Available commands:
+
+  opcodes                          display ACIR opcodes
+  into                             step into to the next opcode
+  next                             step until a new source location is reached
+  out                              step until a new source location is reached
+                                   and the current stack frame is finished
+  break LOCATION:OpcodeLocation    add a breakpoint at an opcode location
+  over                             step until a new source location is reached
+                                   without diving into function calls
+  restart                          restart the debugging session
+  delete LOCATION:OpcodeLocation   delete breakpoint at an opcode location
+  witness                          show witness map
+  witness index:u32                display a single witness from the witness map
+  witness index:u32 value:String   update a witness with the given value
+  memset index:usize value:String  update a memory cell with the given
+                                   value
+  continue                         continue execution until the end of the
+                                   program
+  vars                             show variable values available at this point
+                                   in execution
+  stacktrace                       display the current stack trace
+  memory                           show memory (valid when executing unconstrained code)
+  step                             step to the next ACIR opcode
+
+Other commands:
+
+  help  Show this help message
+  quit  Quit repl
+
+```
+
+Some commands operate only for unconstrained functions, such as `memory` and `memset`. If you try to use them while execution is paused at an ACIR opcode, the debugger will simply inform you that you are not executing unconstrained code:
+
+```
+> memory
+Unconstrained VM memory not available
+> 
+```
+
+Before continuing, we can take a look at the initial witness map:
+
+```
+> witness
+_0 = 1
+_1 = 2
+>
+```
+
+Cool, since `x==1`, `y==2`, and we want to check that `x != y`, our circuit should succeed. At this point we could intervene and use the witness setter command to change one of the witnesses. Let's set `y=3`, then back to 2, so we don't affect the expected result:
+
+```
+> witness
+_0 = 1
+_1 = 2
+> witness 1 3
+_1 = 3
+> witness
+_0 = 1
+_1 = 3
+> witness 1 2
+_1 = 2
+> witness
+_0 = 1
+_1 = 2
+>
+```
+
+Now we can inspect the current state of local variables. For that we use the `vars` command. 
+
+```
+> vars
+>
+```
+
+We currently have no vars in context, since we are at the entry point of the program. Let's use `next` to execute until the next point in the program.
+
+```
+> vars
+> next
+At ~/noir-examples/recursion/circuits/main/src/main.nr:1:20
+  1 -> fn main(x : Field, y : pub Field) {
+  2        assert(x != y);
+  3    }
+> vars
+x:Field = 0x01
+```
+
+As a result of stepping, the variable `x`, whose initial value comes from the witness map, is now in context and returned by `vars`.
+
+```
+> next
+  1    fn main(x : Field, y : pub Field) {
+  2 ->     assert(x != y);
+  3    }
+> vars
+y:Field = 0x02
+x:Field = 0x01
+```
+
+Stepping again we can finally see both variables and their values. And now we can see that the next assertion should succeed.
+
+Let's continue to the end:
+
+```
+> continue
+(Continuing execution...)
+Finished execution
+> q
+[main] Circuit witness successfully solved
+```
+
+Upon quitting the debugger after a solved circuit, the resulting circuit witness gets saved, equivalent to what would happen if we had run the same circuit with `nargo execute`.
+
+We just went through the basics of debugging using Noir REPL debugger. For a comprehensive reference, check out [the reference page](../../reference/debugger/debugger_repl.md).
diff --git a/docs/versioned_docs/version-v0.38.0/how_to/debugger/debugging_with_vs_code.md b/docs/versioned_docs/version-v0.38.0/how_to/debugger/debugging_with_vs_code.md
new file mode 100644
index 00000000000..a5858c1a5eb
--- /dev/null
+++ b/docs/versioned_docs/version-v0.38.0/how_to/debugger/debugging_with_vs_code.md
@@ -0,0 +1,68 @@
+---
+title: Using the VS Code Debugger
+description:
+  Step by step guide on how to debug your Noir circuits with the VS Code Debugger configuration and features.
+keywords:
+  [
+    Nargo,
+    Noir CLI,
+    Noir Debugger,
+    VS Code,
+    IDE,
+  ]
+sidebar_position: 0
+---
+
+This guide will show you how to use VS Code with the vscode-noir extension to debug a Noir project. 
+
+#### Pre-requisites
+
+- Nargo
+- vscode-noir
+- A Noir project with a `Nargo.toml`, `Prover.toml` and at least one Noir (`.nr`) containing an entry point function (typically `main`).
+
+## Running the debugger
+
+The easiest way to start debugging is to open the file you want to debug, and press `F5`. This will cause the debugger to launch, using your `Prover.toml` file as input.
+
+You should see something like this:
+
+![Debugger launched](@site/static/img/debugger/1-started.png)
+
+Let's inspect the state of the program. For that, we open VS Code's _Debug pane_. Look for this icon:
+
+![Debug pane icon](@site/static/img/debugger/2-icon.png)
+
+You will now see two categories of variables: Locals and Witness Map.
+
+![Debug pane expanded](@site/static/img/debugger/3-debug-pane.png)
+
+1. **Locals**: variables of your program. At this point in execution this section is empty, but as we step through the code it will get populated by `x`, `result`, `digest`, etc. 
+
+2. **Witness map**: these are initially populated from your project's `Prover.toml` file. In this example, they will be used to populate `x` and `result` at the beginning of the `main` function.
+
+Most of the time you will probably be focusing mostly on locals, as they represent the high level state of your program. 
+
+You might be interested in inspecting the witness map in case you are trying to solve a really low level issue in the compiler or runtime itself, so this concerns mostly advanced or niche users.
+
+Let's step through the program, by using the debugger buttons or their corresponding keyboard shortcuts.
+
+![Debugger buttons](@site/static/img/debugger/4-debugger-buttons.png)
+
+Now we can see in the variables pane that there's values for `digest`, `result` and `x`.
+
+![Inspecting locals](@site/static/img/debugger/5-assert.png)
+
+We can also inspect the values of variables by directly hovering on them on the code.
+
+![Hover locals](@site/static/img/debugger/6-hover.png)
+
+Let's set a break point at the `keccak256` function, so we can continue execution up to the point when it's first invoked without having to go one step at a time. 
+
+We just need to click the to the right of the line number 18. Once the breakpoint appears, we can click the `continue` button or use its corresponding keyboard shortcut (`F5` by default).
+
+![Breakpoint](@site/static/img/debugger/7-break.png)
+
+Now we are debugging the `keccak256` function, notice the _Call Stack pane_ at the lower right. This lets us inspect the current call stack of our process.
+
+That covers most of the current debugger functionalities. Check out [the reference](../../reference/debugger/debugger_vscode.md) for more details on how to configure the debugger.
\ No newline at end of file
diff --git a/docs/versioned_docs/version-v0.38.0/how_to/how-to-oracles.md b/docs/versioned_docs/version-v0.38.0/how_to/how-to-oracles.md
new file mode 100644
index 00000000000..08ce6ee5476
--- /dev/null
+++ b/docs/versioned_docs/version-v0.38.0/how_to/how-to-oracles.md
@@ -0,0 +1,275 @@
+---
+title: How to use Oracles
+description: Learn how to use oracles in your Noir program with examples in both Nargo and NoirJS. This guide also covers writing a JSON RPC server and providing custom foreign call handlers for NoirJS.
+keywords:
+  - Noir Programming
+  - Oracles
+  - Nargo
+  - NoirJS
+  - JSON RPC Server
+  - Foreign Call Handlers
+sidebar_position: 1
+---
+
+This guide shows you how to use oracles in your Noir program. For the sake of clarity, it assumes that:
+
+- You have read the [explainer on Oracles](../explainers/explainer-oracle.md) and are comfortable with the concept.
+- You have a Noir program to add oracles to. You can create one using the [vite-hardhat starter](https://github.com/noir-lang/noir-starter/tree/main/vite-hardhat) as a boilerplate.
+- You understand the concept of a JSON-RPC server. Visit the [JSON-RPC website](https://www.jsonrpc.org/) if you need a refresher.
+- You are comfortable with server-side JavaScript (e.g. Node.js, managing packages, etc.).
+
+## Rundown
+
+This guide has 3 major steps:
+
+1. How to modify our Noir program to make use of oracle calls as unconstrained functions
+2. How to write a JSON RPC Server to resolve these oracle calls with Nargo
+3. How to use them in Nargo and how to provide a custom resolver in NoirJS
+
+## Step 1 - Modify your Noir program
+
+An oracle is defined in a Noir program by defining two methods:
+
+- An unconstrained method - This tells the compiler that it is executing an [unconstrained functions](../noir/concepts//unconstrained.md).
+- A decorated oracle method - This tells the compiler that this method is an RPC call.
+
+An example of an oracle that returns a `Field` would be:
+
+```rust
+#[oracle(getSqrt)]
+unconstrained fn sqrt(number: Field) -> Field { }
+
+unconstrained fn get_sqrt(number: Field) -> Field {
+    sqrt(number)
+}
+```
+
+In this example, we're wrapping our oracle function in an unconstrained method, and decorating it with `oracle(getSqrt)`. We can then call the unconstrained function as we would call any other function:
+
+```rust
+fn main(input: Field) {
+    let sqrt = get_sqrt(input);
+}
+```
+
+In the next section, we will make this `getSqrt` (defined on the `sqrt` decorator) be a method of the RPC server Noir will use.
+
+:::danger
+
+As explained in the [Oracle Explainer](../explainers/explainer-oracle.md), this `main` function is unsafe unless you constrain its return value. For example:
+
+```rust
+fn main(input: Field) {
+    let sqrt = get_sqrt(input);
+    assert(sqrt.pow_32(2) as u64 == input as u64); // <---- constrain the return of an oracle!
+}
+```
+
+:::
+
+:::info
+
+Currently, oracles only work with single params or array params. For example:
+
+```rust
+#[oracle(getSqrt)]
+unconstrained fn sqrt([Field; 2]) -> [Field; 2] { }
+```
+
+:::
+
+## Step 2 - Write an RPC server
+
+Brillig will call *one* RPC server. Most likely you will have to write your own, and you can do it in whatever language you prefer. In this guide, we will do it in Javascript.
+
+Let's use the above example of an oracle that consumes an array with two `Field` and returns their square roots:
+
+```rust
+#[oracle(getSqrt)]
+unconstrained fn sqrt(input: [Field; 2]) -> [Field; 2] { }
+
+unconstrained fn get_sqrt(input: [Field; 2]) -> [Field; 2] {
+    sqrt(input)
+}
+
+fn main(input: [Field; 2]) {
+    let sqrt = get_sqrt(input);
+    assert(sqrt[0].pow_32(2) as u64 == input[0] as u64);
+    assert(sqrt[1].pow_32(2) as u64 == input[1] as u64);
+}
+
+#[test]
+fn test() {
+    let input = [4, 16];
+    main(input);
+}
+```
+
+:::info
+
+Why square root?
+
+In general, computing square roots is computationally more expensive than multiplications, which takes a toll when speaking about ZK applications. In this case, instead of calculating the square root in Noir, we are using our oracle to offload that computation to be made in plain. In our circuit we can simply multiply the two values.
+
+:::
+
+Now, we should write the correspondent RPC server, starting with the [default JSON-RPC 2.0 boilerplate](https://www.npmjs.com/package/json-rpc-2.0#example):
+
+```js
+import { JSONRPCServer } from "json-rpc-2.0";
+import express from "express";
+import bodyParser from "body-parser";
+
+const app = express();
+app.use(bodyParser.json());
+
+const server = new JSONRPCServer();
+app.post("/", (req, res) => {
+ const jsonRPCRequest = req.body;
+ server.receive(jsonRPCRequest).then((jsonRPCResponse) => {
+  if (jsonRPCResponse) {
+   res.json(jsonRPCResponse);
+  } else {
+   res.sendStatus(204);
+  }
+ });
+});
+
+app.listen(5555);
+```
+
+Now, we will add our `getSqrt` method, as expected by the `#[oracle(getSqrt)]` decorator in our Noir code. It maps through the params array and returns their square roots:
+
+```js
+server.addMethod("resolve_foreign_call", async (params) => {
+    if (params[0].function !== "getSqrt") {
+        throw Error("Unexpected foreign call")
+    };
+    const values = params[0].inputs[0].map((field) => {
+        return `${Math.sqrt(parseInt(field, 16))}`;
+    });
+    return { values: [values] };
+});
+```
+
+If you're using Typescript, the following types may be helpful in understanding the expected return value and making sure they're easy to follow:
+
+```js
+export type ForeignCallSingle = string;
+
+export type ForeignCallArray = string[];
+
+export type ForeignCallResult = {
+  values: (ForeignCallSingle | ForeignCallArray)[];
+};
+```
+
+:::info Multidimensional Arrays
+
+If the Oracle function is returning an array containing other arrays, such as `[['1','2],['3','4']]`, you need to provide the values in JSON as flattened values. In the previous example, it would be `['1', '2', '3', '4']`. In the Noir program, the Oracle signature can use a nested type, the flattened values will be automatically converted to the nested type.
+
+:::
+
+## Step 3 - Usage with Nargo
+
+Using the [`nargo` CLI tool](../reference/nargo_commands.md), you can use oracles in the `nargo test` and `nargo execute`  commands by passing a value to `--oracle-resolver`. For example:
+
+```bash
+nargo test --oracle-resolver http://localhost:5555
+```
+
+This tells `nargo` to use your RPC Server URL whenever it finds an oracle decorator.
+
+## Step 4 - Usage with NoirJS
+
+In a JS environment, an RPC server is not strictly necessary, as you may want to resolve your oracles without needing any JSON call at all. NoirJS simply expects that you pass a callback function when you generate proofs, and that callback function can be anything.
+
+For example, if your Noir program expects the host machine to provide CPU pseudo-randomness, you could simply pass it as the `foreignCallHandler`. You don't strictly need to create an RPC server to serve pseudo-randomness, as you may as well get it directly in your app:
+
+```js
+const foreignCallHandler = (name, inputs) => crypto.randomBytes(16) // etc
+
+await noir.execute(inputs, foreignCallHandler)
+```
+
+As one can see, in NoirJS, the [`foreignCallHandler`](../reference/NoirJS/noir_js/type-aliases/ForeignCallHandler.md) function simply means "a callback function that returns a value of type [`ForeignCallOutput`](../reference/NoirJS/noir_js/type-aliases/ForeignCallOutput.md). It doesn't have to be an RPC call like in the case for Nargo.
+
+:::tip
+
+Does this mean you don't have to write an RPC server like in [Step #2](#step-2---write-an-rpc-server)?
+
+You don't technically have to, but then how would you run `nargo test`? To use both `Nargo` and `NoirJS` in your development flow, you will have to write a JSON RPC server.
+
+:::
+
+In this case, let's make `foreignCallHandler` call the JSON RPC Server we created in [Step #2](#step-2---write-an-rpc-server), by making it a JSON RPC Client.
+
+For example, using the same `getSqrt` program in [Step #1](#step-1---modify-your-noir-program) (comments in the code):
+
+```js
+import { JSONRPCClient } from "json-rpc-2.0";
+
+// declaring the JSONRPCClient
+const client = new JSONRPCClient((jsonRPCRequest) => {
+// hitting the same JSON RPC Server we coded above
+ return fetch("http://localhost:5555", {
+  method: "POST",
+  headers: {
+   "content-type": "application/json",
+  },
+  body: JSON.stringify(jsonRPCRequest),
+ }).then((response) => {
+  if (response.status === 200) {
+   return response
+    .json()
+    .then((jsonRPCResponse) => client.receive(jsonRPCResponse));
+  } else if (jsonRPCRequest.id !== undefined) {
+   return Promise.reject(new Error(response.statusText));
+  }
+ });
+});
+
+// declaring a function that takes the name of the foreign call (getSqrt) and the inputs
+const foreignCallHandler = async (name, input) => {
+  const inputs = input[0].map((i) => i.toString("hex"))
+  // notice that the "inputs" parameter contains *all* the inputs
+  // in this case we to make the RPC request with the first parameter "numbers", which would be input[0]
+  const oracleReturn = await client.request("resolve_foreign_call", [
+    {
+      function: name,
+      inputs: [inputs]
+    },
+  ]);
+  return [oracleReturn.values[0]];
+};
+
+// the rest of your NoirJS code
+const input = { input: [4, 16] };
+const { witness } = await noir.execute(input, foreignCallHandler);
+```
+
+:::tip
+
+If you're in a NoirJS environment running your RPC server together with a frontend app, you'll probably hit a familiar problem in full-stack development: requests being blocked by [CORS](https://developer.mozilla.org/en-US/docs/Web/HTTP/CORS) policy. For development only, you can simply install and use the [`cors` npm package](https://www.npmjs.com/package/cors) to get around the problem:
+
+```bash
+yarn add cors
+```
+
+and use it as a middleware:
+
+```js
+import cors from "cors";
+
+const app = express();
+app.use(cors())
+```
+
+:::
+
+## Conclusion
+
+Hopefully by the end of this guide, you should be able to:
+
+- Write your own logic around Oracles and how to write a JSON RPC server to make them work with your Nargo commands.
+- Provide custom foreign call handlers for NoirJS.
\ No newline at end of file
diff --git a/docs/versioned_docs/version-v0.38.0/how_to/how-to-recursion.md b/docs/versioned_docs/version-v0.38.0/how_to/how-to-recursion.md
new file mode 100644
index 00000000000..fac79a9cf49
--- /dev/null
+++ b/docs/versioned_docs/version-v0.38.0/how_to/how-to-recursion.md
@@ -0,0 +1,172 @@
+---
+title: How to use recursion on NoirJS
+description: Learn how to implement recursion with NoirJS, a powerful tool for creating smart contracts on the EVM blockchain. This guide assumes familiarity with NoirJS, solidity verifiers, and the Barretenberg proving backend. Discover how to generate both final and intermediate proofs using `noir_js` and `bb.js`.
+keywords:
+  [
+    "NoirJS",
+    "EVM blockchain",
+    "smart contracts",
+    "recursion",
+    "solidity verifiers",
+    "Barretenberg backend",
+    "noir_js",
+    "intermediate proofs",
+    "final proofs",
+    "nargo compile",
+    "json import",
+    "recursive circuit",
+    "recursive app"
+  ]
+sidebar_position: 1
+---
+
+This guide shows you how to use recursive proofs in your NoirJS app. For the sake of clarity, it is assumed that:
+
+- You already have a NoirJS app. If you don't, please visit the [NoirJS tutorial](../tutorials/noirjs_app.md) and the [reference](../reference/NoirJS/noir_js/index.md).
+- You are familiar with what are recursive proofs and you have read the [recursion explainer](../explainers/explainer-recursion.md)
+- You already built a recursive circuit following [the reference](../noir/standard_library/recursion.mdx), and understand how it works.
+
+It is also assumed that you're not using `noir_wasm` for compilation, and instead you've used [`nargo compile`](../reference/nargo_commands.md) to generate the `json` you're now importing into your project. However, the guide should work just the same if you're using `noir_wasm`.
+
+:::info
+
+As you've read in the [explainer](../explainers/explainer-recursion.md), a recursive proof is an intermediate proof. This means that it doesn't necessarily generate the final step that makes it verifiable in a smart contract. However, it is easy to verify within another circuit.
+
+:::
+
+In a standard recursive app, you're also dealing with at least two circuits. For the purpose of this guide, we will assume the following:
+
+- `main`: a circuit of type `assert(x != y)`, where `main` is marked with a `#[recursive]` attribute. This attribute states that the backend should generate proofs that are friendly for verification within another circuit.
+- `recursive`: a circuit that verifies `main`
+
+For a full example of how recursive proofs work, please refer to the [noir-examples](https://github.com/noir-lang/noir-examples) repository. We will *not* be using it as a reference for this guide.
+
+## Step 1: Setup
+
+In a common NoirJS app, you need to instantiate a backend with something like `const backend = new Backend(circuit)`. Then you feed it to the `noir_js` interface.
+
+For recursion, this doesn't happen, and the only need for `noir_js` is only to `execute` a circuit and get its witness and return value. Everything else is not interfaced, so it needs to happen on the `backend` object.
+
+It is also recommended that you instantiate the backend with as many threads as possible, to allow for maximum concurrency:
+
+```js
+const backend = new Backend(circuit, { threads: 8 })
+```
+
+:::tip
+You can use the [`os.cpus()`](https://nodejs.org/api/os.html#oscpus) object in `nodejs` or [`navigator.hardwareConcurrency`](https://developer.mozilla.org/en-US/docs/Web/API/Navigator/hardwareConcurrency) on the browser to make the most out of those glorious cpu cores
+:::
+
+## Step 2: Generating the witness and the proof for `main`
+
+After instantiating the backend, you should also instantiate `noir_js`. We will use it to execute the circuit and get the witness.
+
+```js
+const noir = new Noir(circuit)
+const { witness } = noir.execute(input)
+```
+
+With this witness, you are now able to generate the intermediate proof for the main circuit:
+
+```js
+const { proof, publicInputs } = await backend.generateProof(witness)
+```
+
+:::warning
+
+Always keep in mind what is actually happening on your development process, otherwise you'll quickly become confused about what circuit we are actually running and why!
+
+In this case, you can imagine that Alice (running the `main` circuit) is proving something to Bob (running the `recursive` circuit), and Bob is verifying her proof within his proof.
+
+With this in mind, it becomes clear that our intermediate proof is the one *meant to be verified within another circuit*, so it must be Alice's. Actually, the only final proof in this theoretical scenario would be the last one, sent on-chain.
+
+:::
+
+## Step 3 - Verification and proof artifacts
+
+Optionally, you are able to verify the intermediate proof:
+
+```js
+const verified = await backend.verifyProof({ proof, publicInputs })
+```
+
+This can be useful to make sure our intermediate proof was correctly generated. But the real goal is to do it within another circuit. For that, we need to generate  recursive proof artifacts that will be passed to the circuit that is verifying the proof we just generated. Instead of passing the proof and verification key as a byte array, we pass them as fields which makes it cheaper to verify in a circuit:
+
+```js
+const { proofAsFields, vkAsFields, vkHash } = await backend.generateRecursiveProofArtifacts( { publicInputs, proof }, publicInputsCount)
+```
+
+This call takes the public inputs and the proof, but also the public inputs count. While this is easily retrievable by simply counting the `publicInputs` length, the backend interface doesn't currently abstract it away.
+
+:::info
+
+The `proofAsFields` has a constant size `[Field; 93]` and verification keys in Barretenberg are always `[Field; 114]`.
+
+:::
+
+:::warning
+
+One common mistake is to forget *who* makes this call.
+
+In a situation where Alice is generating the `main` proof, if she generates the proof artifacts and sends them to Bob, which gladly takes them as true, this would mean Alice could prove anything!
+
+Instead, Bob needs to make sure *he* extracts the proof artifacts, using his own instance of the `main` circuit backend. This way, Alice has to provide a valid proof for the correct `main` circuit.
+
+:::
+
+## Step 4 - Recursive proof generation
+
+With the artifacts, generating a recursive proof is no different from a normal proof. You simply use the `backend` (with the recursive circuit) to generate it:
+
+```js
+const recursiveInputs = {
+    verification_key: vkAsFields, // array of length 114
+    proof: proofAsFields, // array of length 93 + size of public inputs
+    publicInputs: [mainInput.y], // using the example above, where `y` is the only public input
+    key_hash: vkHash,
+}
+
+const { witness, returnValue } = noir.execute(recursiveInputs) // we're executing the recursive circuit now!
+const { proof, publicInputs } = backend.generateProof(witness)
+const verified = backend.verifyProof({ proof, publicInputs })
+```
+
+You can obviously chain this proof into another proof. In fact, if you're using recursive proofs, you're probably interested of using them this way!
+
+:::tip
+
+Managing circuits and "who does what" can be confusing. To make sure your naming is consistent, you can keep them in an object. For example:
+
+```js
+const circuits = {
+  main: mainJSON,
+  recursive: recursiveJSON
+}
+const backends = {
+  main: new BarretenbergBackend(circuits.main),
+  recursive: new BarretenbergBackend(circuits.recursive)
+}
+const noir_programs = {
+  main: new Noir(circuits.main),
+  recursive: new Noir(circuits.recursive)
+}
+```
+
+This allows you to neatly call exactly the method you want without conflicting names:
+
+```js
+// Alice runs this 👇
+const { witness: mainWitness } = await noir_programs.main.execute(input)
+const proof = await backends.main.generateProof(mainWitness)
+
+// Bob runs this 👇
+const verified = await backends.main.verifyProof(proof)
+const { proofAsFields, vkAsFields, vkHash } = await backends.main.generateRecursiveProofArtifacts(
+    proof,
+    numPublicInputs,
+);
+const { witness: recursiveWitness } = await noir_programs.recursive.execute(recursiveInputs)
+const recursiveProof = await backends.recursive.generateProof(recursiveWitness);
+```
+
+:::
diff --git a/docs/versioned_docs/version-v0.38.0/how_to/how-to-solidity-verifier.md b/docs/versioned_docs/version-v0.38.0/how_to/how-to-solidity-verifier.md
new file mode 100644
index 00000000000..2cc0f8e57ce
--- /dev/null
+++ b/docs/versioned_docs/version-v0.38.0/how_to/how-to-solidity-verifier.md
@@ -0,0 +1,259 @@
+---
+title: Generate a Solidity Verifier
+description:
+  Learn how to run the verifier as a smart contract on the blockchain. Compile a Solidity verifier
+  contract for your Noir program and deploy it on any EVM blockchain acting as a verifier smart
+  contract. Read more to find out
+keywords:
+  [
+    solidity verifier,
+    smart contract,
+    blockchain,
+    compiler,
+    plonk_vk.sol,
+    EVM blockchain,
+    verifying Noir programs,
+    proving backend,
+    Barretenberg,
+  ]
+sidebar_position: 0
+pagination_next: tutorials/noirjs_app
+---
+
+Noir has the ability to generate a verifier contract in Solidity, which can be deployed in many EVM-compatible blockchains such as Ethereum.
+
+This allows for a powerful feature set, as one can make use of the conciseness and the privacy provided by Noir in an immutable ledger. Applications can range from simple P2P guessing games, to complex private DeFi interactions.
+
+This guide shows you how to generate a Solidity Verifier and deploy it on the [Remix IDE](https://remix.ethereum.org/). It is assumed that:
+
+- You are comfortable with the Solidity programming language and understand how contracts are deployed on the Ethereum network
+- You have Noir installed and you have a Noir program. If you don't, [get started](../getting_started/quick_start.md) with Nargo and the example Hello Noir circuit
+- You are comfortable navigating RemixIDE. If you aren't or you need a refresher, you can find some video tutorials [here](https://www.youtube.com/channel/UCjTUPyFEr2xDGN6Cg8nKDaA) that could help you.
+
+## Rundown
+
+Generating a Solidity Verifier contract is actually a one-command process. However, compiling it and deploying it can have some caveats. Here's the rundown of this guide:
+
+1. How to generate a solidity smart contract
+2. How to compile the smart contract in the RemixIDE
+3. How to deploy it to a testnet
+
+## Step 1 - Generate a contract
+
+This is by far the most straightforward step. Just run:
+
+```sh
+nargo compile
+```
+
+This will compile your source code into a Noir build artifact to be stored in the `./target` directory, you can then generate the smart contract using the commands:
+
+```sh
+# Here we pass the path to the newly generated Noir artifact.
+bb write_vk -b ./target/<noir_artifact_name>.json
+bb contract
+```
+
+replacing `<noir_artifact_name>` with the name of your Noir project. A new `contract` folder would then be generated in your project directory, containing the Solidity
+file `contract.sol`. It can be deployed to any EVM blockchain acting as a verifier smart contract.
+
+You can find more information about `bb` and the default Noir proving backend on [this page](../getting_started/quick_start.md#proving-backend).
+
+:::info
+
+It is possible to generate verifier contracts of Noir programs for other smart contract platforms as long as the proving backend supplies an implementation.
+
+Barretenberg, the default proving backend for Nargo, supports generation of verifier contracts, for the time being these are only in Solidity.
+:::
+
+## Step 2 - Compiling
+
+We will mostly skip the details of RemixIDE, as the UI can change from version to version. For now, we can just open
+<a href="https://remix.ethereum.org" target="_blank">Remix</a> and create a blank workspace.
+
+![Create Workspace](@site/static/img/how-tos/solidity_verifier_1.png)
+
+We will create a new file to contain the contract Nargo generated, and copy-paste its content.
+
+:::warning
+
+You'll likely see a warning advising you to not trust pasted code. While it is an important warning, it is irrelevant in the context of this guide and can be ignored. We will not be deploying anywhere near a mainnet.
+
+:::
+
+To compile our the verifier, we can navigate to the compilation tab:
+
+![Compilation Tab](@site/static/img/how-tos/solidity_verifier_2.png)
+
+Remix should automatically match a suitable compiler version. However, hitting the "Compile" button will most likely generate a "Stack too deep" error:
+
+![Stack too deep](@site/static/img/how-tos/solidity_verifier_3.png)
+
+This is due to the verify function needing to put many variables on the stack, but enabling the optimizer resolves the issue. To do this, let's open the "Advanced Configurations" tab and enable optimization. The default 200 runs will suffice.
+
+:::info
+
+This time we will see a warning about an unused function parameter. This is expected, as the `verify` function doesn't use the `_proof` parameter inside a solidity block, it is loaded from calldata and used in assembly.
+
+:::
+
+![Compilation success](@site/static/img/how-tos/solidity_verifier_4.png)
+
+## Step 3 - Deploying
+
+At this point we should have a compiled contract ready to deploy. If we navigate to the deploy section in Remix, we will see many different environments we can deploy to. The steps to deploy on each environment would be out-of-scope for this guide, so we will just use the default Remix VM.
+
+Looking closely, we will notice that our "Solidity Verifier" is actually three contracts working together:
+
+- An `UltraVerificationKey` library which simply stores the verification key for our circuit.
+- An abstract contract `BaseUltraVerifier` containing most of the verifying logic.
+- A main `UltraVerifier` contract that inherits from the Base and uses the Key contract.
+
+Remix will take care of the dependencies for us so we can simply deploy the UltraVerifier contract by selecting it and hitting "deploy":
+
+![Deploying UltraVerifier](@site/static/img/how-tos/solidity_verifier_5.png)
+
+A contract will show up in the "Deployed Contracts" section, where we can retrieve the Verification Key Hash. This is particularly useful for double-checking that the deployer contract is the correct one.
+
+:::note
+
+Why "UltraVerifier"?
+
+To be precise, the Noir compiler (`nargo`) doesn't generate the verifier contract directly. It compiles the Noir code into an intermediate language (ACIR), which is then executed by the backend. So it is the backend that returns the verifier smart contract, not Noir.
+
+In this case, the Barretenberg Backend uses the UltraPlonk proving system, hence the "UltraVerifier" name.
+
+:::
+
+## Step 4 - Verifying
+
+To verify a proof using the Solidity verifier contract, we call the `verify` function in this extended contract:
+
+```solidity
+function verify(bytes calldata _proof, bytes32[] calldata _publicInputs) external view returns (bool)
+```
+
+When using the default example in the [Hello Noir](../getting_started/quick_start.md) guide, the easiest way to confirm that the verifier contract is doing its job is by calling the `verify` function via remix with the required parameters. Note that the public inputs must be passed in separately to the rest of the proof so we must split the proof as returned from `bb`.
+
+First generate a proof with `bb` at the location `./proof` using the steps in [get started](../getting_started/quick_start.md), this proof is in a binary format but we want to convert it into a hex string to pass into Remix, this can be done with the
+
+```bash
+# This value must be changed to match the number of public inputs (including return values!) in your program.
+NUM_PUBLIC_INPUTS=1
+PUBLIC_INPUT_BYTES=32*NUM_PUBLIC_INPUTS
+HEX_PUBLIC_INPUTS=$(head -c $PUBLIC_INPUT_BYTES ./proof | od -An -v -t x1 | tr -d $' \n')
+HEX_PROOF=$(tail -c +$(($PUBLIC_INPUT_BYTES + 1)) ./proof | od -An -v -t x1 | tr -d $' \n')
+
+echo "Public inputs:"
+echo $HEX_PUBLIC_INPUTS
+
+echo "Proof:"
+echo "0x$HEX_PROOF"
+```
+
+Remix expects that the public inputs will be split into an array of `bytes32` values so `HEX_PUBLIC_INPUTS` needs to be split up into 32 byte chunks which are prefixed with `0x` accordingly.
+
+A programmatic example of how the `verify` function is called can be seen in the example zk voting application [here](https://github.com/noir-lang/noir-examples/blob/33e598c257e2402ea3a6b68dd4c5ad492bce1b0a/foundry-voting/src/zkVote.sol#L35):
+
+```solidity
+function castVote(bytes calldata proof, uint proposalId, uint vote, bytes32 nullifierHash) public returns (bool) {
+  // ...
+  bytes32[] memory publicInputs = new bytes32[](4);
+  publicInputs[0] = merkleRoot;
+  publicInputs[1] = bytes32(proposalId);
+  publicInputs[2] = bytes32(vote);
+  publicInputs[3] = nullifierHash;
+  require(verifier.verify(proof, publicInputs), "Invalid proof");
+```
+
+:::info[Return Values]
+
+A circuit doesn't have the concept of a return value. Return values are just syntactic sugar in Noir.
+
+Under the hood, the return value is passed as an input to the circuit and is checked at the end of the circuit program.
+
+For example, if you have Noir program like this:
+
+```rust
+fn main(
+    // Public inputs
+    pubkey_x: pub Field,
+    pubkey_y: pub Field,
+    // Private inputs
+    priv_key: Field,
+) -> pub Field
+```
+
+the `verify` function will expect the public inputs array (second function parameter) to be of length 3, the two inputs and the return value.
+
+Passing only two inputs will result in an error such as `PUBLIC_INPUT_COUNT_INVALID(3, 2)`.
+
+In this case, the inputs parameter to `verify` would be an array ordered as `[pubkey_x, pubkey_y, return`.
+
+:::
+
+:::tip[Structs]
+
+You can pass structs to the verifier contract. They will be flattened so that the array of inputs is 1-dimensional array.
+
+For example, consider the following program:
+
+```rust
+struct Type1 {
+  val1: Field,
+  val2: Field,
+}
+
+struct Nested {
+  t1: Type1,
+  is_true: bool,
+}
+
+fn main(x: pub Field, nested: pub Nested, y: pub Field) {
+  //...
+}
+```
+
+The order of these inputs would be flattened to: `[x, nested.t1.val1, nested.t1.val2, nested.is_true, y]`
+
+:::
+
+The other function you can call is our entrypoint `verify` function, as defined above.
+
+:::tip
+
+It's worth noticing that the `verify` function is actually a `view` function. A `view` function does not alter the blockchain state, so it doesn't need to be distributed (i.e. it will run only on the executing node), and therefore doesn't cost any gas.
+
+This can be particularly useful in some situations. If Alice generated a proof and wants Bob to verify its correctness, Bob doesn't need to run Nargo, NoirJS, or any Noir specific infrastructure. He can simply make a call to the blockchain with the proof and verify it is correct without paying any gas.
+
+It would be incorrect to say that a Noir proof verification costs any gas at all. However, most of the time the result of `verify` is used to modify state (for example, to update a balance, a game state, etc). In that case the whole network needs to execute it, which does incur gas costs (calldata and execution, but not storage).
+
+:::
+
+## A Note on EVM chains
+
+Noir proof verification requires the ecMul, ecAdd and ecPairing precompiles. Not all EVM chains support EC Pairings, notably some of the ZK-EVMs. This means that you won't be able to use the verifier contract in all of them. You can find an incomplete list of which EVM chains support these precompiles [here](https://www.evmdiff.com/features?feature=precompiles).
+
+For example, chains like `zkSync ERA` and `Polygon zkEVM` do not currently support these precompiles, so proof verification via Solidity verifier contracts won't work. Here's a quick list of EVM chains that have been tested and are known to work:
+
+- Optimism
+- Arbitrum
+- Polygon PoS
+- Scroll
+- Celo
+- BSC
+- Blast L2
+- Avalanche C-Chain
+- Mode
+- Linea
+- Moonbeam
+
+If you test any other chains, please open a PR on this page to update the list. See [this doc](https://github.com/noir-lang/noir-starter/tree/main/with-foundry#testing-on-chain) for more info about testing verifier contracts on different EVM chains.
+
+## What's next
+
+Now that you know how to call a Noir Solidity Verifier on a smart contract using Remix, you should be comfortable with using it with some programmatic frameworks, such as [hardhat](https://github.com/noir-lang/noir-starter/tree/main/vite-hardhat) and [foundry](https://github.com/noir-lang/noir-starter/tree/main/with-foundry).
+
+You can find other tools, examples, boilerplates and libraries in the [awesome-noir](https://github.com/noir-lang/awesome-noir) repository.
+
+You should also be ready to write and deploy your first NoirJS app and start generating proofs on websites, phones, and NodeJS environments! Head on to the [NoirJS tutorial](../tutorials/noirjs_app.md) to learn how to do that.
diff --git a/docs/versioned_docs/version-v0.38.0/how_to/merkle-proof.mdx b/docs/versioned_docs/version-v0.38.0/how_to/merkle-proof.mdx
new file mode 100644
index 00000000000..0a128adb2de
--- /dev/null
+++ b/docs/versioned_docs/version-v0.38.0/how_to/merkle-proof.mdx
@@ -0,0 +1,48 @@
+---
+title: Prove Merkle Tree Membership
+description:
+  Learn how to use merkle membership proof in Noir to prove that a given leaf is a member of a
+  merkle tree with a specified root, at a given index.
+keywords:
+  [merkle proof, merkle membership proof, Noir, rust, hash function, Pedersen, sha256, merkle tree]
+sidebar_position: 4
+---
+
+Let's walk through an example of a merkle membership proof in Noir that proves that a given leaf is
+in a merkle tree.
+
+```rust
+
+fn main(message : [Field; 62], index : Field, hashpath : [Field; 40], root : Field) {
+    let leaf = std::hash::hash_to_field(message.as_slice());
+    let merkle_root = std::merkle::compute_merkle_root(leaf, index, hashpath);
+    assert(merkle_root == root);
+}
+
+```
+
+The message is hashed using `hash_to_field`. The specific hash function that is being used is chosen
+by the backend. The only requirement is that this hash function can heuristically be used as a
+random oracle. If only collision resistance is needed, then one can call `std::hash::pedersen_hash`
+instead.
+
+```rust
+let leaf = std::hash::hash_to_field(message.as_slice());
+```
+
+The leaf is then passed to a compute_merkle_root function with the root, index and hashpath. The returned root can then be asserted to be the same as the provided root.
+
+```rust
+let merkle_root = std::merkle::compute_merkle_root(leaf, index, hashpath);
+assert (merkle_root == root);
+```
+
+> **Note:** It is possible to re-implement the merkle tree implementation without standard library.
+> However, for most usecases, it is enough. In general, the standard library will always opt to be
+> as conservative as possible, while striking a balance with efficiency.
+
+An example, the merkle membership proof, only requires a hash function that has collision
+resistance, hence a hash function like Pedersen is allowed, which in most cases is more efficient
+than the even more conservative sha256.
+
+[View an example on the starter repo](https://github.com/noir-lang/noir-examples/blob/3ea09545cabfa464124ec2f3ea8e60c608abe6df/stealthdrop/circuits/src/main.nr#L20)
diff --git a/docs/versioned_docs/version-v0.38.0/how_to/using-devcontainers.mdx b/docs/versioned_docs/version-v0.38.0/how_to/using-devcontainers.mdx
new file mode 100644
index 00000000000..727ec6ca667
--- /dev/null
+++ b/docs/versioned_docs/version-v0.38.0/how_to/using-devcontainers.mdx
@@ -0,0 +1,110 @@
+---
+title: Developer Containers and Codespaces
+description: "Learn how to set up a devcontainer in your GitHub repository for a seamless coding experience with Codespaces. Follow our easy 8-step guide to create your own Noir environment without installing Nargo locally."
+keywords: ["Devcontainer", "Codespaces", "GitHub", "Noir Environment", "Docker Image", "Development Environment", "Remote Coding", "GitHub Codespaces", "Noir Programming", "Nargo", "VSCode Extensions", "Noirup"]
+sidebar_position: 1
+---
+
+Adding a developer container configuration file to your Noir project is one of the easiest way to unlock coding in browser.
+
+## What's a devcontainer after all?
+
+A [Developer Container](https://containers.dev/) (devcontainer for short) is a Docker image that comes preloaded with tools, extensions, and other tools you need to quickly get started or continue a project, without having to install Nargo locally. Think of it as a development environment in a box.
+
+There are many advantages to this:
+
+- It's platform and architecture agnostic
+- You don't need to have an IDE installed, or Nargo, or use a terminal at all
+- It's safer for using on a public machine or public network
+
+One of the best ways of using devcontainers is... not using your machine at all, for maximum control, performance, and ease of use.
+Enter Codespaces.
+
+## Codespaces
+
+If a devcontainer is just a Docker image, then what stops you from provisioning a `p3dn.24xlarge` AWS EC2 instance with 92 vCPUs and 768 GiB RAM and using it to prove your 10-gate SNARK proof? 
+
+Nothing! Except perhaps the 30-40$ per hour it will cost you. 
+
+The problem is that provisioning takes time, and I bet you don't want to see the AWS console every time you want to code something real quick.
+
+Fortunately, there's an easy and free way to get a decent remote machine ready and loaded in less than 2 minutes: Codespaces. [Codespaces is a Github feature](https://github.com/features/codespaces) that allows you to code in a remote machine by using devcontainers, and it's pretty cool:
+
+- You can start coding Noir in less than a minute
+- It uses the resources of a remote machine, so you can code on your grandma's phone if needed be
+- It makes it easy to share work with your frens
+- It's fully reusable, you can stop and restart whenever you need to
+
+:::info
+
+Don't take out your wallet just yet. Free GitHub accounts get about [15-60 hours of coding](https://github.com/features/codespaces) for free per month, depending on the size of your provisioned machine.
+
+:::
+
+## Tell me it's _actually_ easy
+
+It is!
+
+Github comes with a default codespace and you can use it to code your own devcontainer. That's exactly what we will be doing in this guide.
+
+<video width="100%" height="auto" controls>
+  <source src={require('@site/static/video/how-tos/devcontainer.mp4').default} type="video/mp4" />
+  Your browser does not support the video tag.
+</video>
+
+8 simple steps:
+
+#### 1. <a href="https://github.com/new" target="_blank">Create a new repository</a> on GitHub.
+
+#### 2. Click "Start coding with Codespaces". This will use the default image.
+
+#### 3. Create a folder called `.devcontainer` in the root of your repository.
+
+#### 4. Create a Dockerfile in that folder, and paste the following code:
+
+```docker
+FROM --platform=linux/amd64 node:lts-bookworm-slim
+SHELL ["/bin/bash", "-c"]
+RUN apt update && apt install -y curl bash git tar gzip libc++-dev
+RUN curl -L https://raw.githubusercontent.com/noir-lang/noirup/main/install | bash
+ENV PATH="/root/.nargo/bin:$PATH"
+RUN noirup
+ENTRYPOINT ["nargo"]
+```
+#### 5. Create a file called `devcontainer.json` in the same folder, and paste the following code:
+
+```json
+{
+ "name": "Noir on Codespaces",
+ "build": {
+    "context": ".",
+    "dockerfile": "Dockerfile"
+  },
+  "customizations": {
+    "vscode": {
+      "extensions": ["noir-lang.vscode-noir"]
+    }
+  }
+}
+```
+#### 6. Commit and push your changes
+
+This will pull the new image and build it, so it could take a minute or so
+
+#### 8. Done! 
+Just wait for the build to finish, and there's your easy Noir environment.
+
+
+Refer to [noir-starter](https://github.com/noir-lang/noir-starter/) as an example of how devcontainers can be used together with codespaces.
+
+
+
+## How do I use it?
+
+Using the codespace is obviously much easier than setting it up. 
+Just navigate to your repository and click "Code" -> "Open with Codespaces". It should take a few seconds to load, and you're ready to go.
+
+:::info
+
+If you really like the experience, you can add a badge to your readme, links to existing codespaces, and more. 
+Check out the [official docs](https://docs.github.com/en/codespaces/setting-up-your-project-for-codespaces/setting-up-your-repository/facilitating-quick-creation-and-resumption-of-codespaces) for more info.
diff --git a/docs/versioned_docs/version-v0.38.0/index.mdx b/docs/versioned_docs/version-v0.38.0/index.mdx
new file mode 100644
index 00000000000..5c116a73b3f
--- /dev/null
+++ b/docs/versioned_docs/version-v0.38.0/index.mdx
@@ -0,0 +1,76 @@
+---
+title: Noir Lang
+hide_title: true
+description:
+  Learn about the public alpha release of Noir, a domain specific language heavily influenced by Rust that compiles to
+  an intermediate language which can be compiled to an arithmetic circuit or a rank-1 constraint system.
+keywords:
+    [Noir,
+    Domain Specific Language,
+    Rust,
+    Intermediate Language,
+    Arithmetic Circuit,
+    Rank-1 Constraint System,
+    Ethereum Developers,
+    Protocol Developers,
+    Blockchain Developers,
+    Proving System,
+    Smart Contract Language]
+sidebar_position: 0
+---
+
+import Tabs from '@theme/Tabs';
+import TabItem from '@theme/TabItem';
+import ThemedImage from '@theme/ThemedImage';
+import useBaseUrl from '@docusaurus/useBaseUrl';
+
+<ThemedImage
+  sources={{
+    light: useBaseUrl("/img/logoDark.png"),
+    dark: useBaseUrl("/img/logo.png"),
+  }}
+  style={{display: "block", width: "50%", margin: "2rem auto"}} 
+  alt="Noir Logo" 
+/>
+
+Noir is an open-source Domain-Specific Language for safe and seamless construction of privacy-preserving Zero-Knowledge programs, requiring no previous knowledge on the underlying mathematics or cryptography.
+
+ZK programs are programs that can generate short proofs of statements without revealing all inputs to the statements. You can read more about Zero-Knowledge Proofs [here](https://dev.to/spalladino/a-beginners-intro-to-coding-zero-knowledge-proofs-c56).
+
+## What's new about Noir?
+
+Noir works differently from most ZK languages by taking a two-pronged path. First, it compiles the program to an adaptable intermediate language known as ACIR. From there, depending on a given project's needs, ACIR can be further compiled into an arithmetic circuit for integration with the proving backend.
+
+:::info
+
+Noir is backend agnostic, which means it makes no assumptions on which proving backend powers the ZK proof. Being the language that powers [Aztec Contracts](https://docs.aztec.network/developers/contracts/main), it defaults to Aztec's Barretenberg proving backend.
+
+However, the ACIR output can be transformed to be compatible with other PLONK-based backends, or into a [rank-1 constraint system](https://www.rareskills.io/post/rank-1-constraint-system) suitable for backends such as Arkwork's Marlin.
+
+:::
+
+## Who is Noir for?
+
+Noir can be used both in complex cloud-based backends and in user's smartphones, requiring no knowledge on the underlying math or cryptography. From authorization systems that keep a password in the user's device, to complex on-chain verification of recursive proofs, Noir is designed to abstract away complexity without any significant overhead. Here are some examples of situations where Noir can be used:
+
+<Tabs>
+  <TabItem value="Aztec Contracts" label="Aztec Contracts" default>
+    <img src={require("@site/static/img/aztec_logo.png").default} style={{display: "block", width: "50%", margin: "2rem auto"}} alt="Noir Logo"  />
+    
+    Aztec Contracts leverage Noir to allow for the storage and execution of private information. Writing an Aztec Contract is as easy as writing Noir, and Aztec developers can easily interact with the network storage and execution through the [Aztec.nr](https://docs.aztec.network/developers/contracts/main) library.
+  </TabItem>
+  <TabItem value="Solidity Verifiers" label="Solidity Verifiers">
+    <img src={require("@site/static/img/solidity_verifier_ex.png").default} style={{display: "block", margin: "2rem auto"}} alt="Soliditry Verifier Example"  />
+    Noir can auto-generate Solidity verifier contracts that verify Noir proofs. This allows for non-interactive verification of proofs containing private information in an immutable system. This feature powers a multitude of use-case scenarios, from P2P chess tournaments, to [Aztec Layer-2 Blockchain](https://docs.aztec.network/)
+  </TabItem>
+  <TabItem value="Full-Stack Development" label="Full-Stack Development">
+    Aztec Labs developed NoirJS, an easy interface to generate and verify Noir proofs in a Javascript environment. This allows for Noir to be used in webpages, mobile apps, games, and any other environment supporting JS execution in a standalone manner.
+  </TabItem>
+</Tabs>
+
+
+## Libraries
+
+Noir is meant to be easy to extend by simply importing Noir libraries just like in Rust. 
+The [awesome-noir repo](https://github.com/noir-lang/awesome-noir#libraries) is a collection of libraries developed by the Noir community.
+Writing a new library is easy and makes code be composable and easy to reuse. See the section on [dependencies](noir/modules_packages_crates/dependencies.md) for more information.
diff --git a/docs/versioned_docs/version-v0.38.0/migration_notes.md b/docs/versioned_docs/version-v0.38.0/migration_notes.md
new file mode 100644
index 00000000000..6bd740024e5
--- /dev/null
+++ b/docs/versioned_docs/version-v0.38.0/migration_notes.md
@@ -0,0 +1,105 @@
+---
+title: Migration notes
+description: Read about migration notes from previous versions, which could solve problems while updating
+keywords: [Noir, notes, migration, updating, upgrading]
+---
+
+Noir is in full-speed development. Things break fast, wild, and often. This page attempts to leave some notes on errors you might encounter when upgrading and how to resolve them until proper patches are built.
+
+### `backend encountered an error: libc++.so.1`
+
+Depending on your OS, you may encounter the following error when running `nargo prove` for the first time:
+
+```text
+The backend encountered an error: "/home/codespace/.nargo/backends/acvm-backend-barretenberg/backend_binary: error while loading shared libraries: libc++.so.1: cannot open shared object file: No such file or directory\n"
+```
+
+Install the `libc++-dev` library with:
+
+```bash
+sudo apt install libc++-dev
+```
+
+## ≥0.19
+
+### Enforcing `compiler_version`
+
+From this version on, the compiler will check for the `compiler_version` field in `Nargo.toml`, and will error if it doesn't match the current Nargo version in use.
+
+To update, please make sure this field in `Nargo.toml` matches the output of `nargo --version`.
+
+## ≥0.14
+
+The index of the [for loops](noir/concepts/control_flow.md#loops) is now of type `u64` instead of `Field`. An example refactor would be:
+
+```rust
+for i in 0..10 {
+    let i = i as Field;
+}
+```
+
+## ≥v0.11.0 and Nargo backend
+
+From this version onwards, Nargo starts managing backends through the `nargo backend` command. Upgrading to the versions per usual steps might lead to:
+
+### `backend encountered an error`
+
+This is likely due to the existing locally installed version of proving backend (e.g. barretenberg) is incompatible with the version of Nargo in use.
+
+To fix the issue:
+
+1. Uninstall the existing backend
+
+```bash
+nargo backend uninstall acvm-backend-barretenberg
+```
+
+You may replace _acvm-backend-barretenberg_ with the name of your backend listed in `nargo backend ls` or in ~/.nargo/backends.
+
+2. Reinstall a compatible version of the proving backend.
+
+If you are using the default barretenberg backend, simply run:
+
+```
+nargo prove
+```
+
+with your Noir program.
+
+This will trigger the download and installation of the latest version of barretenberg compatible with your Nargo in use.
+
+### `backend encountered an error: illegal instruction`
+
+On certain Intel-based systems, an `illegal instruction` error may arise due to incompatibility of barretenberg with certain CPU instructions.
+
+To fix the issue:
+
+1. Uninstall the existing backend
+
+```bash
+nargo backend uninstall acvm-backend-barretenberg
+```
+
+You may replace _acvm-backend-barretenberg_ with the name of your backend listed in `nargo backend ls` or in ~/.nargo/backends.
+
+2. Reinstall a compatible version of the proving backend.
+
+If you are using the default barretenberg backend, simply run:
+
+```
+nargo backend install acvm-backend-barretenberg https://github.com/noir-lang/barretenberg-js-binary/raw/master/run-bb.tar.gz
+```
+
+This downloads and installs a specific bb.js based version of barretenberg binary from GitHub.
+
+The gzipped file is running [this bash script](https://github.com/noir-lang/barretenberg-js-binary/blob/master/run-bb-js.sh), where we need to gzip it as the Nargo currently expect the backend to be zipped up.
+
+Then run:
+
+```
+DESIRED_BINARY_VERSION=0.8.1 nargo info
+```
+
+This overrides the bb native binary with a bb.js node application instead, which should be compatible with most if not all hardware. This does come with the drawback of being generally slower than native binary.
+
+0.8.1 indicates bb.js version 0.8.1, so if you change that it will update to a different version or the default version in the script if none was supplied.
diff --git a/docs/versioned_docs/version-v0.38.0/noir/concepts/_category_.json b/docs/versioned_docs/version-v0.38.0/noir/concepts/_category_.json
new file mode 100644
index 00000000000..7da08f8a8c5
--- /dev/null
+++ b/docs/versioned_docs/version-v0.38.0/noir/concepts/_category_.json
@@ -0,0 +1,6 @@
+{
+    "label": "Concepts",
+    "position": 0,
+    "collapsible": true,
+    "collapsed": true
+}
\ No newline at end of file
diff --git a/docs/versioned_docs/version-v0.38.0/noir/concepts/assert.md b/docs/versioned_docs/version-v0.38.0/noir/concepts/assert.md
new file mode 100644
index 00000000000..2132de42072
--- /dev/null
+++ b/docs/versioned_docs/version-v0.38.0/noir/concepts/assert.md
@@ -0,0 +1,78 @@
+---
+title: Assert Function
+description:
+  Learn about the `assert` and `static_assert` functions in Noir, which can be used to explicitly
+  constrain the predicate or comparison expression that follows to be true, and what happens if
+  the expression is false at runtime or compile-time, respectively.
+keywords: [Noir programming language, assert statement, predicate expression, comparison expression]
+sidebar_position: 4
+---
+
+Noir includes a special `assert` function which will explicitly constrain the predicate/comparison
+expression that follows to be true. If this expression is false at runtime, the program will fail to
+be proven. Example:
+
+```rust
+fn main(x : Field, y : Field) {
+    assert(x == y);
+}
+```
+
+> Assertions only work for predicate operations, such as `==`. If there's any ambiguity on the operation, the program will fail to compile. For example, it is unclear if `assert(x + y)` would check for `x + y == 0` or simply would return `true`.
+
+You can optionally provide a message to be logged when the assertion fails:
+
+```rust
+assert(x == y, "x and y are not equal");
+```
+
+Aside string literals, the optional message can be a format string or any other type supported as input for Noir's [print](../standard_library/logging.md) functions. This feature lets you incorporate runtime variables into your failed assertion logs:
+
+```rust
+assert(x == y, f"Expected x == y, but got {x} == {y}");
+```
+
+Using a variable as an assertion message directly:
+
+```rust
+struct myStruct {
+  myField: Field
+}
+
+let s = myStruct { myField: y };
+assert(s.myField == x, s);
+```
+
+There is also a special `static_assert` function that behaves like `assert`,
+but that runs at compile-time.
+
+```rust
+fn main(xs: [Field; 3]) {
+    let x = 2 + 2;
+    let y = 4;
+    static_assert(x == y, "expected 2 + 2 to equal 4");
+
+    // This passes since the length of `xs` is known at compile-time
+    static_assert(xs.len() == 3, "expected the input to have 3 elements");
+}
+```
+
+This function fails when passed a dynamic (run-time) argument:
+
+```rust
+fn main(x : Field, y : Field) {
+    // this fails because `x` is not known at compile-time
+    static_assert(x == 2, "expected x to be known at compile-time and equal to 2");
+
+    let mut example_slice = &[];
+    if y == 4 {
+        example_slice = example_slice.push_back(0);
+    }
+
+    // This fails because the length of `example_slice` is not known at
+    // compile-time
+    let error_message = "expected an empty slice, known at compile-time";
+    static_assert(example_slice.len() == 0, error_message);
+}
+```
+
diff --git a/docs/versioned_docs/version-v0.38.0/noir/concepts/comments.md b/docs/versioned_docs/version-v0.38.0/noir/concepts/comments.md
new file mode 100644
index 00000000000..b51a85f5c94
--- /dev/null
+++ b/docs/versioned_docs/version-v0.38.0/noir/concepts/comments.md
@@ -0,0 +1,33 @@
+---
+title: Comments
+description:
+  Learn how to write comments in Noir programming language. A comment is a line of code that is
+  ignored by the compiler, but it can be read by programmers. Single-line and multi-line comments
+  are supported in Noir.
+keywords: [Noir programming language, comments, single-line comments, multi-line comments]
+sidebar_position: 10
+---
+
+A comment is a line in your codebase which the compiler ignores, however it can be read by
+programmers.
+
+Here is a single line comment:
+
+```rust
+// This is a comment and is ignored
+```
+
+`//` is used to tell the compiler to ignore the rest of the line.
+
+Noir also supports multi-line block comments. Start a block comment with `/*` and end the block with `*/`.
+
+Noir does not natively support doc comments. You may be able to use [Rust doc comments](https://doc.rust-lang.org/reference/comments.html) in your code to leverage some Rust documentation build tools with Noir code.
+
+```rust
+/*
+  This is a block comment describing a complex function.
+*/
+fn main(x : Field, y : pub Field) {
+    assert(x != y);
+}
+```
diff --git a/docs/versioned_docs/version-v0.38.0/noir/concepts/comptime.md b/docs/versioned_docs/version-v0.38.0/noir/concepts/comptime.md
new file mode 100644
index 00000000000..2ceb030c7e1
--- /dev/null
+++ b/docs/versioned_docs/version-v0.38.0/noir/concepts/comptime.md
@@ -0,0 +1,445 @@
+---
+title: Compile-time Code & Metaprogramming
+description: Learn how to use metaprogramming in Noir to create macros or derive your own traits
+keywords: [Noir, comptime, compile-time, metaprogramming, macros, quote, unquote]
+sidebar_position: 15
+---
+
+## Overview
+
+Metaprogramming in Noir is comprised of three parts:
+1. `comptime` code
+2. Quoting and unquoting
+3. The metaprogramming API in `std::meta`
+
+Each of these are explained in more detail in the next sections but the wide picture is that
+`comptime` allows us to write code which runs at compile-time. In this `comptime` code we
+can quote and unquote snippets of the program, manipulate them, and insert them in other
+parts of the program. Comptime functions which do this are said to be macros. Additionally,
+there's a compile-time API of built-in types and functions provided by the compiler which allows
+for greater analysis and modification of programs.
+
+---
+
+## Comptime
+
+`comptime` is a new keyword in Noir which marks an item as executing or existing at compile-time. It can be used in several ways:
+
+- `comptime fn` to define functions which execute exclusively during compile-time.
+- `comptime global` to define a global variable which is evaluated at compile-time.
+  - Unlike runtime globals, `comptime global`s can be mutable.
+- `comptime { ... }` to execute a block of statements during compile-time.
+- `comptime let` to define a variable whose value is evaluated at compile-time.
+- `comptime for` to run a for loop at compile-time. Syntax sugar for `comptime { for .. }`.
+
+### Scoping
+
+Note that while in a `comptime` context, any runtime variables _local to the current function_ are never visible.
+
+### Evaluating
+
+Evaluation rules of `comptime` follows the normal unconstrained evaluation rules for other Noir code. There are a few things to note though:
+
+- Certain built-in functions may not be available, although more may be added over time.
+- Evaluation order of global items is currently unspecified. For example, given the following two functions we can't guarantee
+which `println` will execute first. The ordering of the two printouts will be arbitrary, but should be stable across multiple compilations with the same `nargo` version as long as the program is also unchanged.
+
+```rust
+fn one() {
+    comptime { println("one"); }
+}
+
+fn two() {
+    comptime { println("two"); }
+}
+```
+
+- Since evaluation order is unspecified, care should be taken when using mutable globals so that they do not rely on a particular ordering.
+For example, using globals to generate unique ids should be fine but relying on certain ids always being produced (especially after edits to the program) should be avoided.
+- Although most ordering of globals is unspecified, two are:
+  - Dependencies of a crate will always be evaluated before the dependent crate.
+  - Any annotations on a function will be run before the function itself is resolved. This is to allow the annotation to modify the function if necessary. Note that if the
+    function itself was called at compile-time previously, it will already be resolved and cannot be modified. To prevent accidentally calling functions you wish to modify
+    at compile-time, it may be helpful to sort your `comptime` annotation functions into a different crate along with any dependencies they require.
+
+### Lowering
+
+When a `comptime` value is used in runtime code it must be lowered into a runtime value. This means replacing the expression with the literal that it evaluated to. For example, the code:
+
+```rust
+struct Foo { array: [Field; 2], len: u32 }
+
+fn main() {
+    println(comptime {
+        let mut foo = std::mem::zeroed::<Foo>();
+        foo.array[0] = 4;
+        foo.len = 1;
+        foo
+    });
+}
+```
+
+will be converted to the following after `comptime` expressions are evaluated:
+
+```rust
+struct Foo { array: [Field; 2], len: u32 }
+
+fn main() {
+    println(Foo { array: [4, 0], len: 1 });
+}
+```
+
+Not all types of values can be lowered. For example, `Type`s and `TypeDefinition`s (among other types) cannot be lowered at all.
+
+```rust
+fn main() {
+    // There's nothing we could inline here to create a Type value at runtime
+    // let _ = get_type!();
+}
+
+comptime fn get_type() -> Type { ... }
+```
+
+---
+
+## (Quasi) Quote
+
+Macros in Noir are `comptime` functions which return code as a value which is inserted into the call site when it is lowered there.
+A code value in this case is of type `Quoted` and can be created by a `quote { ... }` expression.
+More specifically, the code value `quote` creates is a token stream - a representation of source code as a series of words, numbers, string literals, or operators.
+For example, the expression `quote { Hi "there reader"! }` would quote three tokens: the word "hi", the string "there reader", and an exclamation mark.
+You'll note that snippets that would otherwise be invalid syntax can still be quoted.
+
+When a `Quoted` value is used in runtime code, it is lowered into a `quote { ... }` expression. Since this expression is only valid
+in compile-time code however, we'd get an error if we tried this. Instead, we can use macro insertion to insert each token into the
+program at that point, and parse it as an expression. To do this, we have to add a `!` after the function name returning the `Quoted` value.
+If the value was created locally and there is no function returning it, `std::meta::unquote!(_)` can be used instead.
+Calling such a function at compile-time without `!` will just return the `Quoted` value to be further manipulated. For example:
+
+```rust title="quote-example" showLineNumbers 
+comptime fn quote_one() -> Quoted {
+        quote { 1 }
+    }
+
+    #[test]
+    fn returning_versus_macro_insertion() {
+        comptime {
+            // let _a: Quoted = quote { 1 };
+            let _a: Quoted = quote_one();
+
+            // let _b: Field = 1;
+            let _b: Field = quote_one!();
+
+            // Since integers default to fields, if we
+            // want a different type we have to explicitly cast
+            // let _c: i32 = 1 as i32;
+            let _c: i32 = quote_one!() as i32;
+        }
+    }
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/meta/mod.nr#L120-L140" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/meta/mod.nr#L120-L140</a></sub></sup>
+
+
+For those familiar with quoting from other languages (primarily lisps), Noir's `quote` is actually a _quasiquote_.
+This means we can escape the quoting by using the unquote operator to splice values in the middle of quoted code.
+
+## Unquote
+
+The unquote operator `$` is usable within a `quote` expression.
+It takes a variable as an argument, evaluates the variable, and splices the resulting value into the quoted token stream at that point. For example,
+
+```rust
+comptime {
+    let x = 1 + 2;
+    let y = quote { $x + 4 };
+}
+```
+
+The value of `y` above will be the token stream containing `3`, `+`, and `4`. We can also use this to combine `Quoted` values into larger token streams:
+
+```rust
+comptime {
+    let x = quote { 1 + 2 };
+    let y = quote { $x + 4 };
+}
+```
+
+The value of `y` above is now the token stream containing five tokens: `1 + 2 + 4`.
+
+Note that to unquote something, a variable name _must_ follow the `$` operator in a token stream.
+If it is an expression (even a parenthesized one), it will do nothing. Most likely a parse error will be given when the macro is later unquoted.
+
+Unquoting can also be avoided by escaping the `$` with a backslash:
+
+```
+comptime {
+    let x = quote { 1 + 2 };
+
+    // y contains the four tokens: `$x + 4`
+    let y = quote { \$x + 4 };
+}
+```
+
+---
+
+## Annotations
+
+Annotations provide a way to run a `comptime` function on an item in the program.
+When you use an annotation, the function with the same name will be called with that item as an argument:
+
+```rust
+#[my_struct_annotation]
+struct Foo {}
+
+comptime fn my_struct_annotation(s: StructDefinition) {
+    println("Called my_struct_annotation!");
+}
+
+#[my_function_annotation]
+fn foo() {}
+
+comptime fn my_function_annotation(f: FunctionDefinition) {
+    println("Called my_function_annotation!");
+}
+```
+
+Anything returned from one of these functions will be inserted at top-level along with the original item.
+Note that expressions are not valid at top-level so you'll get an error trying to return `3` or similar just as if you tried to write a program containing `3; struct Foo {}`.
+You can insert other top-level items such as trait impls, structs, or functions this way though.
+For example, this is the mechanism used to insert additional trait implementations into the program when deriving a trait impl from a struct:
+
+```rust title="derive-field-count-example" showLineNumbers 
+trait FieldCount {
+        fn field_count() -> u32;
+    }
+
+    #[derive_field_count]
+    struct Bar {
+        x: Field,
+        y: [Field; 2],
+    }
+
+    comptime fn derive_field_count(s: StructDefinition) -> Quoted {
+        let typ = s.as_type();
+        let field_count = s.fields().len();
+        quote {
+            impl FieldCount for $typ {
+                fn field_count() -> u32 {
+                    $field_count
+                }
+            }
+        }
+    }
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/meta/mod.nr#L142-L164" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/meta/mod.nr#L142-L164</a></sub></sup>
+
+
+### Calling annotations with additional arguments
+
+Arguments may optionally be given to annotations.
+When this is done, these additional arguments are passed to the annotation function after the item argument.
+
+```rust title="annotation-arguments-example" showLineNumbers 
+#[assert_field_is_type(quote { i32 }.as_type())]
+    struct MyStruct {
+        my_field: i32,
+    }
+
+    comptime fn assert_field_is_type(s: StructDefinition, typ: Type) {
+        // Assert the first field in `s` has type `typ`
+        let fields = s.fields();
+        assert_eq(fields[0].1, typ);
+    }
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/meta/mod.nr#L166-L177" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/meta/mod.nr#L166-L177</a></sub></sup>
+
+
+We can also take any number of arguments by adding the `varargs` annotation:
+
+```rust title="annotation-varargs-example" showLineNumbers 
+#[assert_three_args(1, 2, 3)]
+    struct MyOtherStruct {
+        my_other_field: u32,
+    }
+
+    #[varargs]
+    comptime fn assert_three_args(_s: StructDefinition, args: [Field]) {
+        assert_eq(args.len(), 3);
+    }
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/meta/mod.nr#L179-L189" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/meta/mod.nr#L179-L189</a></sub></sup>
+
+
+---
+
+## Comptime API
+
+Although `comptime`, `quote`, and unquoting provide a flexible base for writing macros,
+Noir's true metaprogramming ability comes from being able to interact with the compiler through a compile-time API.
+This API can be accessed through built-in functions in `std::meta` as well as on methods of several `comptime` types.
+
+The following is an incomplete list of some `comptime` types along with some useful methods on them. You can see more in the standard library [Metaprogramming section](../standard_library/meta).
+
+- `Quoted`: A token stream
+- `Type`: The type of a Noir type
+  - `fn implements(self, constraint: TraitConstraint) -> bool`
+    - Returns true if `self` implements the given trait constraint
+- `Expr`: A syntactically valid expression. Can be used to recur on a program's parse tree to inspect how it is structured.
+  - Methods:
+    - `fn as_function_call(self) -> Option<(Expr, [Expr])>`
+      - If this is a function call expression, return `(function, arguments)`
+    - `fn as_block(self) -> Option<[Expr]>`
+      - If this is a block, return each statement in the block
+- `FunctionDefinition`: A function definition
+  - Methods:
+    - `fn parameters(self) -> [(Quoted, Type)]`
+      - Returns a slice of `(name, type)` pairs for each parameter
+- `StructDefinition`: A struct definition
+  - Methods:
+    - `fn as_type(self) -> Type`
+      - Returns this `StructDefinition` as a `Type`. Any generics are kept as-is
+    - `fn generics(self) -> [Quoted]`
+      - Return the name of each generic on this struct
+    - `fn fields(self) -> [(Quoted, Type)]`
+      - Return the name and type of each field
+- `TraitConstraint`: A trait constraint such as `From<Field>`
+- `TypedExpr`: A type-checked expression.
+- `UnresolvedType`: A syntactic notation that refers to a Noir type that hasn't been resolved yet
+
+There are many more functions available by exploring the `std::meta` module and its submodules.
+Using these methods is the key to writing powerful metaprogramming libraries.
+
+### `#[use_callers_scope]`
+
+Since certain functions such as `Quoted::as_type`, `Expression::as_type`, or `Quoted::as_trait_constraint` will attempt
+to resolve their contents in a particular scope - it can be useful to change the scope they resolve in. By default
+these functions will resolve in the current function's scope which is usually the attribute function they are called in.
+If you're working on a library however, this may be a completely different module or crate to the item you're trying to
+use the attribute on. If you want to be able to use `Quoted::as_type` to refer to types local to the caller's scope for
+example, you can annotate your attribute function with `#[use_callers_scope]`. This will ensure your attribute, and any
+closures it uses, can refer to anything in the caller's scope. `#[use_callers_scope]` also works recursively. So if both
+your attribute function and a helper function it calls use it, then they can both refer to the same original caller.
+
+---
+
+## Example: Derive
+
+Using all of the above, we can write a `derive` macro that behaves similarly to Rust's but is not built into the language.
+From the user's perspective it will look like this:
+
+```rust
+// Example usage
+#[derive(Default, Eq, Ord)]
+struct MyStruct { my_field: u32 }
+```
+
+To implement `derive` we'll have to create a `comptime` function that accepts
+a variable amount of traits.
+
+```rust title="derive_example" showLineNumbers 
+// These are needed for the unconstrained hashmap we're using to store derive functions
+use crate::collections::umap::UHashMap;
+use crate::hash::BuildHasherDefault;
+use crate::hash::poseidon2::Poseidon2Hasher;
+
+// A derive function is one that given a struct definition can
+// create us a quoted trait impl from it.
+pub type DeriveFunction = fn(StructDefinition) -> Quoted;
+
+// We'll keep a global HANDLERS map to keep track of the derive handler for each trait
+comptime mut global HANDLERS: UHashMap<TraitDefinition, DeriveFunction, BuildHasherDefault<Poseidon2Hasher>> =
+    UHashMap::default();
+
+// Given a struct and a slice of traits to derive, create trait impls for each.
+// This function is as simple as iterating over the slice, checking if we have a trait
+// handler registered for the given trait, calling it, and appending the result.
+#[varargs]
+pub comptime fn derive(s: StructDefinition, traits: [TraitDefinition]) -> Quoted {
+    let mut result = quote {};
+
+    for trait_to_derive in traits {
+        let handler = unsafe { HANDLERS.get(trait_to_derive) };
+        assert(handler.is_some(), f"No derive function registered for `{trait_to_derive}`");
+
+        let trait_impl = handler.unwrap()(s);
+        result = quote { $result $trait_impl };
+    }
+
+    result
+}
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/meta/mod.nr#L31-L64" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/meta/mod.nr#L31-L64</a></sub></sup>
+
+
+Registering a derive function could be done as follows:
+
+```rust title="derive_via" showLineNumbers 
+// To register a handler for a trait, just add it to our handlers map
+pub comptime fn derive_via(t: TraitDefinition, f: DeriveFunction) {
+    HANDLERS.insert(t, f);
+}
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/meta/mod.nr#L66-L73" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/meta/mod.nr#L66-L73</a></sub></sup>
+
+
+```rust title="big-derive-usage-example" showLineNumbers 
+// Finally, to register a handler we call the above function as an annotation
+    // with our handler function.
+    #[derive_via(derive_do_nothing)]
+    trait DoNothing {
+        fn do_nothing(self);
+    }
+
+    comptime fn derive_do_nothing(s: StructDefinition) -> Quoted {
+        // This is simplified since we don't handle generics or where clauses!
+        // In a real example we'd likely also need to introduce each of
+        // `s.generics()` as well as a trait constraint for each generic
+        // to ensure they also implement the trait.
+        let typ = s.as_type();
+        quote {
+            impl DoNothing for $typ {
+                fn do_nothing(self) {
+                    // Traits can't tell us what to do
+                    println("something");
+                }
+            }
+        }
+    }
+
+    // Since `DoNothing` is a simple trait which:
+    // 1. Only has one method
+    // 2. Does not have any generics on the trait itself
+    // We can use `std::meta::make_trait_impl` to help us out.
+    // This helper function will generate our impl for us along with any
+    // necessary where clauses and still provides a flexible interface
+    // for us to work on each field on the struct.
+    comptime fn derive_do_nothing_alt(s: StructDefinition) -> Quoted {
+        let trait_name = quote { DoNothing };
+        let method_signature = quote { fn do_nothing(self) };
+
+        // Call `do_nothing` recursively on each field in the struct
+        let for_each_field = |field_name| quote { self.$field_name.do_nothing(); };
+
+        // Some traits like Eq want to join each field expression with something like `&`.
+        // We don't need that here
+        let join_fields_with = quote {};
+
+        // The body function is a spot to insert any extra setup/teardown needed.
+        // We'll insert our println here. Since we recur on each field, we should see
+        // one println for the struct itself, followed by a println for every field (recursively).
+        let body = |body| quote {
+            println("something");
+            $body
+        };
+        crate::meta::make_trait_impl(
+            s,
+            trait_name,
+            method_signature,
+            for_each_field,
+            join_fields_with,
+            body,
+        )
+    }
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/meta/mod.nr#L191-L249" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/meta/mod.nr#L191-L249</a></sub></sup>
+
diff --git a/docs/versioned_docs/version-v0.38.0/noir/concepts/control_flow.md b/docs/versioned_docs/version-v0.38.0/noir/concepts/control_flow.md
new file mode 100644
index 00000000000..b365bb22728
--- /dev/null
+++ b/docs/versioned_docs/version-v0.38.0/noir/concepts/control_flow.md
@@ -0,0 +1,79 @@
+---
+title: Control Flow
+description:
+  Learn how to use loops and if expressions in the Noir programming language. Discover the syntax
+  and examples for for loops and if-else statements.
+keywords: [Noir programming language, loops, for loop, if-else statements, Rust syntax]
+sidebar_position: 2
+---
+
+## If Expressions
+
+Noir supports `if-else` statements. The syntax is most similar to Rust's where it is not required
+for the statement's conditional to be surrounded by parentheses.
+
+```rust
+let a = 0;
+let mut x: u32 = 0;
+
+if a == 0 {
+    if a != 0 {
+        x = 6;
+    } else {
+        x = 2;
+    }
+} else {
+    x = 5;
+    assert(x == 5);
+}
+assert(x == 2);
+```
+
+## Loops
+
+Noir has one kind of loop: the `for` loop. `for` loops allow you to repeat a block of code multiple
+times.
+
+The following block of code between the braces is run 10 times.
+
+```rust
+for i in 0..10 {
+    // do something
+}
+```
+
+Alternatively, `start..=end` can be used for a range that is inclusive on both ends.
+
+The index for loops is of type `u64`.
+
+### Break and Continue
+
+In unconstrained code, `break` and `continue` are also allowed in `for` loops. These are only allowed
+in unconstrained code since normal constrained code requires that Noir knows exactly how many iterations
+a loop may have. `break` and `continue` can be used like so:
+
+```rust
+for i in 0 .. 10 {
+    println("Iteration start")
+
+    if i == 2 {
+        continue;
+    }
+
+    if i == 5 {
+        break;
+    }
+
+    println(i);
+}
+println("Loop end")
+```
+
+When used, `break` will end the current loop early and jump to the statement after the for loop. In the example
+above, the `break` will stop the loop and jump to the `println("Loop end")`.
+
+`continue` will stop the current iteration of the loop, and jump to the start of the next iteration. In the example
+above, `continue` will jump to `println("Iteration start")` when used. Note that the loop continues as normal after this.
+The iteration variable `i` is still increased by one as normal when `continue` is used.
+
+`break` and `continue` cannot currently be used to jump out of more than a single loop at a time.
diff --git a/docs/versioned_docs/version-v0.38.0/noir/concepts/data_bus.mdx b/docs/versioned_docs/version-v0.38.0/noir/concepts/data_bus.mdx
new file mode 100644
index 00000000000..e55e58622ce
--- /dev/null
+++ b/docs/versioned_docs/version-v0.38.0/noir/concepts/data_bus.mdx
@@ -0,0 +1,23 @@
+---
+title: Data Bus
+sidebar_position: 13
+---
+import Experimental from '@site/src/components/Notes/_experimental.mdx';
+
+<Experimental />
+
+The data bus is an optimization that the backend can use to make recursion more efficient.
+In order to use it, you must define some inputs of the program entry points (usually the `main()`
+function) with the `call_data` modifier, and the return values with the `return_data` modifier.
+These modifiers are incompatible with `pub` and `mut` modifiers.
+
+## Example
+
+```rust
+fn main(mut x: u32, y: call_data u32, z: call_data [u32;4] ) -> return_data u32 {
+  let a = z[x];
+  a+y
+}
+```
+
+As a result, both call_data and return_data will be treated as private inputs and encapsulated into a read-only array each, for the backend to process.
diff --git a/docs/versioned_docs/version-v0.38.0/noir/concepts/data_types/_category_.json b/docs/versioned_docs/version-v0.38.0/noir/concepts/data_types/_category_.json
new file mode 100644
index 00000000000..5d694210bbf
--- /dev/null
+++ b/docs/versioned_docs/version-v0.38.0/noir/concepts/data_types/_category_.json
@@ -0,0 +1,5 @@
+{
+    "position": 0,
+    "collapsible": true,
+    "collapsed": true
+}
diff --git a/docs/versioned_docs/version-v0.38.0/noir/concepts/data_types/arrays.md b/docs/versioned_docs/version-v0.38.0/noir/concepts/data_types/arrays.md
new file mode 100644
index 00000000000..289145a8c4d
--- /dev/null
+++ b/docs/versioned_docs/version-v0.38.0/noir/concepts/data_types/arrays.md
@@ -0,0 +1,276 @@
+---
+title: Arrays
+description:
+  Dive into the Array data type in Noir. Grasp its methods, practical examples, and best practices for efficiently using Arrays in your Noir code.
+keywords:
+  [
+    noir,
+    array type,
+    methods,
+    examples,
+    indexing,
+  ]
+sidebar_position: 4
+---
+
+An array is one way of grouping together values into one compound type. Array types can be inferred
+or explicitly specified via the syntax `[<Type>; <Size>]`:
+
+```rust
+fn main(x : Field, y : Field) {
+    let my_arr = [x, y];
+    let your_arr: [Field; 2] = [x, y];
+}
+```
+
+Here, both `my_arr` and `your_arr` are instantiated as an array containing two `Field` elements.
+
+Array elements can be accessed using indexing:
+
+```rust
+fn main() {
+    let a = [1, 2, 3, 4, 5];
+
+    let first = a[0];
+    let second = a[1];
+}
+```
+
+All elements in an array must be of the same type (i.e. homogeneous). That is, an array cannot group
+a `Field` value and a `u8` value together for example.
+
+You can write mutable arrays, like:
+
+```rust
+fn main() {
+    let mut arr = [1, 2, 3, 4, 5];
+    assert(arr[0] == 1);
+
+    arr[0] = 42;
+    assert(arr[0] == 42);
+}
+```
+
+You can instantiate a new array of a fixed size with the same value repeated for each element. The following example instantiates an array of length 32 where each element is of type Field and has the value 0.
+
+```rust
+let array: [Field; 32] = [0; 32];
+```
+
+Like in Rust, arrays in Noir are a fixed size. However, if you wish to convert an array to a [slice](./slices.mdx), you can just call `as_slice` on your array:
+
+```rust
+let array: [Field; 32] = [0; 32];
+let sl = array.as_slice()
+```
+
+You can define multidimensional arrays:
+
+```rust
+let array : [[Field; 2]; 2];
+let element = array[0][0];
+```
+
+However, multidimensional slices are not supported. For example, the following code will error at compile time:
+
+```rust
+let slice : [[Field]] = &[];
+```
+
+## Types
+
+You can create arrays of primitive types or structs. There is not yet support for nested arrays
+(arrays of arrays) or arrays of structs that contain arrays.
+
+## Methods
+
+For convenience, the STD provides some ready-to-use, common methods for arrays.
+Each of these functions are located within the generic impl `impl<T, N> [T; N] {`.
+So anywhere `self` appears, it refers to the variable `self: [T; N]`.
+
+### len
+
+Returns the length of an array
+
+```rust
+fn len(self) -> Field
+```
+
+example
+
+```rust
+fn main() {
+    let array = [42, 42];
+    assert(array.len() == 2);
+}
+```
+
+### sort
+
+Returns a new sorted array. The original array remains untouched. Notice that this function will
+only work for arrays of fields or integers, not for any arbitrary type. This is because the sorting
+logic it uses internally is optimized specifically for these values. If you need a sort function to
+sort any type, you should use the function `sort_via` described below.
+
+```rust
+fn sort(self) -> [T; N]
+```
+
+example
+
+```rust
+fn main() {
+    let arr = [42, 32];
+    let sorted = arr.sort();
+    assert(sorted == [32, 42]);
+}
+```
+
+### sort_via
+
+Sorts the array with a custom comparison function. The ordering function must return true if the first argument should be sorted to be before the second argument or is equal to the second argument.
+
+Using this method with an operator like `<` that does not return `true` for equal values will result in an assertion failure for arrays with equal elements.
+
+```rust
+fn sort_via(self, ordering: fn(T, T) -> bool) -> [T; N]
+```
+
+example
+
+```rust
+fn main() {
+    let arr = [42, 32]
+    let sorted_ascending = arr.sort_via(|a, b| a <= b);
+    assert(sorted_ascending == [32, 42]); // verifies
+
+    let sorted_descending = arr.sort_via(|a, b| a >= b);
+    assert(sorted_descending == [32, 42]); // does not verify
+}
+```
+
+### map
+
+Applies a function to each element of the array, returning a new array containing the mapped elements.
+
+```rust
+fn map<U>(self, f: fn(T) -> U) -> [U; N]
+```
+
+example
+
+```rust
+let a = [1, 2, 3];
+let b = a.map(|a| a * 2); // b is now [2, 4, 6]
+```
+
+### fold
+
+Applies a function to each element of the array, returning the final accumulated value. The first
+parameter is the initial value.
+
+```rust
+fn fold<U>(self, mut accumulator: U, f: fn(U, T) -> U) -> U
+```
+
+This is a left fold, so the given function will be applied to the accumulator and first element of
+the array, then the second, and so on. For a given call the expected result would be equivalent to:
+
+```rust
+let a1 = [1];
+let a2 = [1, 2];
+let a3 = [1, 2, 3];
+
+let f = |a, b| a - b;
+a1.fold(10, f)  //=> f(10, 1)
+a2.fold(10, f)  //=> f(f(10, 1), 2)
+a3.fold(10, f)  //=> f(f(f(10, 1), 2), 3)
+```
+
+example:
+
+```rust
+
+fn main() {
+    let arr = [2, 2, 2, 2, 2];
+    let folded = arr.fold(0, |a, b| a + b);
+    assert(folded == 10);
+}
+
+```
+
+### reduce
+
+Same as fold, but uses the first element as the starting element.
+
+Requires `self` to be non-empty.
+
+```rust
+fn reduce(self, f: fn(T, T) -> T) -> T
+```
+
+example:
+
+```rust
+fn main() {
+    let arr = [2, 2, 2, 2, 2];
+    let reduced = arr.reduce(|a, b| a + b);
+    assert(reduced == 10);
+}
+```
+
+### all
+
+Returns true if all the elements satisfy the given predicate
+
+```rust
+fn all(self, predicate: fn(T) -> bool) -> bool
+```
+
+example:
+
+```rust
+fn main() {
+    let arr = [2, 2, 2, 2, 2];
+    let all = arr.all(|a| a == 2);
+    assert(all);
+}
+```
+
+### any
+
+Returns true if any of the elements satisfy the given predicate
+
+```rust
+fn any(self, predicate: fn(T) -> bool) -> bool
+```
+
+example:
+
+```rust
+fn main() {
+    let arr = [2, 2, 2, 2, 5];
+    let any = arr.any(|a| a == 5);
+    assert(any);
+}
+```
+
+### as_str_unchecked
+
+Converts a byte array of type `[u8; N]` to a string. Note that this performs no UTF-8 validation -
+the given array is interpreted as-is as a string.
+
+```rust
+impl<let N: u32> [u8; N] {
+    pub fn as_str_unchecked(self) -> str<N>
+}
+```
+
+example:
+
+```rust
+fn main() {
+    let hi = [104, 105].as_str_unchecked();
+    assert_eq(hi, "hi");
+}
+```
diff --git a/docs/versioned_docs/version-v0.38.0/noir/concepts/data_types/booleans.md b/docs/versioned_docs/version-v0.38.0/noir/concepts/data_types/booleans.md
new file mode 100644
index 00000000000..2507af710e7
--- /dev/null
+++ b/docs/versioned_docs/version-v0.38.0/noir/concepts/data_types/booleans.md
@@ -0,0 +1,28 @@
+---
+title: Booleans
+description:
+  Delve into the Boolean data type in Noir. Understand its methods, practical examples, and best practices for using Booleans in your Noir programs.
+keywords:
+  [
+    noir,
+    boolean type,
+    methods,
+    examples,
+    logical operations,
+  ]
+sidebar_position: 2
+---
+
+
+The `bool` type in Noir has two possible values: `true` and `false`:
+
+```rust
+fn main() {
+    let t = true;
+    let f: bool = false;
+}
+```
+
+The boolean type is most commonly used in conditionals like `if` expressions and `assert`
+statements. More about conditionals is covered in the [Control Flow](../control_flow.md) and
+[Assert Function](../assert.md) sections.
diff --git a/docs/versioned_docs/version-v0.38.0/noir/concepts/data_types/fields.md b/docs/versioned_docs/version-v0.38.0/noir/concepts/data_types/fields.md
new file mode 100644
index 00000000000..b9b56f7ecc3
--- /dev/null
+++ b/docs/versioned_docs/version-v0.38.0/noir/concepts/data_types/fields.md
@@ -0,0 +1,246 @@
+---
+title: Fields
+description:
+  Dive deep into the Field data type in Noir. Understand its methods, practical examples, and best practices to effectively use Fields in your Noir programs.
+keywords:
+  [
+    noir,
+    field type,
+    methods,
+    examples,
+    best practices,
+  ]
+sidebar_position: 0
+---
+
+The field type corresponds to the native field type of the proving backend.
+
+The size of a Noir field depends on the elliptic curve's finite field for the proving backend
+adopted. For example, a field would be a 254-bit integer when paired with the default backend that
+spans the Grumpkin curve.
+
+Fields support integer arithmetic and are often used as the default numeric type in Noir:
+
+```rust
+fn main(x : Field, y : Field)  {
+    let z = x + y;
+}
+```
+
+`x`, `y` and `z` are all private fields in this example. Using the `let` keyword we defined a new
+private value `z` constrained to be equal to `x + y`.
+
+If proving efficiency is of priority, fields should be used as a default for solving problems.
+Smaller integer types (e.g. `u64`) incur extra range constraints.
+
+## Methods
+
+After declaring a Field, you can use these common methods on it:
+
+### to_le_bits
+
+Transforms the field into an array of bits, Little Endian.
+
+```rust title="to_le_bits" showLineNumbers 
+pub fn to_le_bits<let N: u32>(self: Self) -> [u1; N] {}
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/field/mod.nr#L32-L34" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/field/mod.nr#L32-L34</a></sub></sup>
+
+
+example:
+
+```rust title="to_le_bits_example" showLineNumbers 
+fn test_to_le_bits() {
+        let field = 2;
+        let bits: [u1; 8] = field.to_le_bits();
+        assert_eq(bits, [0, 1, 0, 0, 0, 0, 0, 0]);
+    }
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/field/mod.nr#L276-L282" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/field/mod.nr#L276-L282</a></sub></sup>
+
+
+
+### to_be_bits
+
+Transforms the field into an array of bits, Big Endian.
+
+```rust title="to_be_bits" showLineNumbers 
+pub fn to_be_bits<let N: u32>(self: Self) -> [u1; N] {}
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/field/mod.nr#L48-L50" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/field/mod.nr#L48-L50</a></sub></sup>
+
+
+example:
+
+```rust title="to_be_bits_example" showLineNumbers 
+fn test_to_be_bits() {
+        let field = 2;
+        let bits: [u1; 8] = field.to_be_bits();
+        assert_eq(bits, [0, 0, 0, 0, 0, 0, 1, 0]);
+    }
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/field/mod.nr#L267-L273" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/field/mod.nr#L267-L273</a></sub></sup>
+
+
+
+### to_le_bytes
+
+Transforms into an array of bytes, Little Endian
+
+```rust title="to_le_bytes" showLineNumbers 
+pub fn to_le_bytes<let N: u32>(self: Self) -> [u8; N] {
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/field/mod.nr#L61-L63" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/field/mod.nr#L61-L63</a></sub></sup>
+
+
+example:
+
+```rust title="to_le_bytes_example" showLineNumbers 
+fn test_to_le_bytes() {
+        let field = 2;
+        let bytes: [u8; 8] = field.to_le_bytes();
+        assert_eq(bytes, [2, 0, 0, 0, 0, 0, 0, 0]);
+        assert_eq(Field::from_le_bytes::<8>(bytes), field);
+    }
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/field/mod.nr#L295-L302" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/field/mod.nr#L295-L302</a></sub></sup>
+
+
+### to_be_bytes
+
+Transforms into an array of bytes, Big Endian
+
+```rust title="to_be_bytes" showLineNumbers 
+pub fn to_be_bytes<let N: u32>(self: Self) -> [u8; N] {
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/field/mod.nr#L94-L96" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/field/mod.nr#L94-L96</a></sub></sup>
+
+
+example:
+
+```rust title="to_be_bytes_example" showLineNumbers 
+fn test_to_be_bytes() {
+        let field = 2;
+        let bytes: [u8; 8] = field.to_be_bytes();
+        assert_eq(bytes, [0, 0, 0, 0, 0, 0, 0, 2]);
+        assert_eq(Field::from_be_bytes::<8>(bytes), field);
+    }
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/field/mod.nr#L285-L292" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/field/mod.nr#L285-L292</a></sub></sup>
+
+
+
+### to_le_radix
+
+Decomposes into an array over the specified base, Little Endian
+
+```rust title="to_le_radix" showLineNumbers 
+pub fn to_le_radix<let N: u32>(self: Self, radix: u32) -> [u8; N] {
+        // Brillig does not need an immediate radix
+        if !crate::runtime::is_unconstrained() {
+            crate::assert_constant(radix);
+        }
+        self.__to_le_radix(radix)
+    }
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/field/mod.nr#L118-L126" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/field/mod.nr#L118-L126</a></sub></sup>
+
+
+
+example:
+
+```rust title="to_le_radix_example" showLineNumbers 
+fn test_to_le_radix() {
+        let field = 2;
+        let bytes: [u8; 8] = field.to_le_radix(256);
+        assert_eq(bytes, [2, 0, 0, 0, 0, 0, 0, 0]);
+        assert_eq(Field::from_le_bytes::<8>(bytes), field);
+    }
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/field/mod.nr#L315-L322" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/field/mod.nr#L315-L322</a></sub></sup>
+
+
+
+### to_be_radix
+
+Decomposes into an array over the specified base, Big Endian
+
+```rust title="to_be_radix" showLineNumbers 
+pub fn to_be_radix<let N: u32>(self: Self, radix: u32) -> [u8; N] {
+        // Brillig does not need an immediate radix
+        if !crate::runtime::is_unconstrained() {
+            crate::assert_constant(radix);
+        }
+        self.__to_be_radix(radix)
+    }
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/field/mod.nr#L128-L136" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/field/mod.nr#L128-L136</a></sub></sup>
+
+
+example:
+
+```rust title="to_be_radix_example" showLineNumbers 
+fn test_to_be_radix() {
+        let field = 2;
+        let bytes: [u8; 8] = field.to_be_radix(256);
+        assert_eq(bytes, [0, 0, 0, 0, 0, 0, 0, 2]);
+        assert_eq(Field::from_be_bytes::<8>(bytes), field);
+    }
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/field/mod.nr#L305-L312" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/field/mod.nr#L305-L312</a></sub></sup>
+
+
+
+### pow_32
+
+Returns the value to the power of the specified exponent
+
+```rust
+fn pow_32(self, exponent: Field) -> Field
+```
+
+example:
+
+```rust
+fn main() {
+    let field = 2
+    let pow = field.pow_32(4);
+    assert(pow == 16);
+}
+```
+
+### assert_max_bit_size
+
+Adds a constraint to specify that the field can be represented with `bit_size` number of bits
+
+```rust title="assert_max_bit_size" showLineNumbers 
+pub fn assert_max_bit_size<let BIT_SIZE: u32>(self) {
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/field/mod.nr#L10-L12" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/field/mod.nr#L10-L12</a></sub></sup>
+
+
+example:
+
+```rust
+fn main() {
+    let field = 2
+    field.assert_max_bit_size(32);
+}
+```
+
+### sgn0
+
+Parity of (prime) Field element, i.e. sgn0(x mod p) = 0 if x ∈ \{0, ..., p-1\} is even, otherwise sgn0(x mod p) = 1.
+
+```rust
+fn sgn0(self) -> u1
+```
+
+
+### lt
+
+Returns true if the field is less than the other field
+
+```rust
+pub fn lt(self, another: Field) -> bool
+```
diff --git a/docs/versioned_docs/version-v0.38.0/noir/concepts/data_types/function_types.md b/docs/versioned_docs/version-v0.38.0/noir/concepts/data_types/function_types.md
new file mode 100644
index 00000000000..f6121af17e2
--- /dev/null
+++ b/docs/versioned_docs/version-v0.38.0/noir/concepts/data_types/function_types.md
@@ -0,0 +1,26 @@
+---
+title: Function types
+sidebar_position: 10
+---
+
+Noir supports higher-order functions. The syntax for a function type is as follows:
+
+```rust
+fn(arg1_type, arg2_type, ...) -> return_type
+```
+
+Example:
+
+```rust
+fn assert_returns_100(f: fn() -> Field) { // f takes no args and returns a Field
+    assert(f() == 100);
+}
+
+fn main() {
+    assert_returns_100(|| 100); // ok
+    assert_returns_100(|| 150); // fails
+}
+```
+
+A function type also has an optional capture environment - this is necessary to support closures.
+See [Lambdas](../lambdas.md) for more details.
diff --git a/docs/versioned_docs/version-v0.38.0/noir/concepts/data_types/index.md b/docs/versioned_docs/version-v0.38.0/noir/concepts/data_types/index.md
new file mode 100644
index 00000000000..0f2db2b2d75
--- /dev/null
+++ b/docs/versioned_docs/version-v0.38.0/noir/concepts/data_types/index.md
@@ -0,0 +1,126 @@
+---
+title: Data Types
+description:
+  Get a clear understanding of the two categories of Noir data types - primitive types and compound
+  types. Learn about their characteristics, differences, and how to use them in your Noir
+  programming.
+keywords:
+  [
+    noir,
+    data types,
+    primitive types,
+    compound types,
+    private types,
+    public types,
+  ]
+---
+
+Every value in Noir has a type, which determines which operations are valid for it.
+
+All values in Noir are fundamentally composed of `Field` elements. For a more approachable
+developing experience, abstractions are added on top to introduce different data types in Noir.
+
+Noir has two category of data types: primitive types (e.g. `Field`, integers, `bool`) and compound
+types that group primitive types (e.g. arrays, tuples, structs). Each value can either be private or
+public.
+
+## Private & Public Types
+
+A **private value** is known only to the Prover, while a **public value** is known by both the
+Prover and Verifier. Mark values as `private` when the value should only be known to the prover. All
+primitive types (including individual fields of compound types) in Noir are private by default, and
+can be marked public when certain values are intended to be revealed to the Verifier.
+
+> **Note:** For public values defined in Noir programs paired with smart contract verifiers, once
+> the proofs are verified on-chain the values can be considered known to everyone that has access to
+> that blockchain.
+
+Public data types are treated no differently to private types apart from the fact that their values
+will be revealed in proofs generated. Simply changing the value of a public type will not change the
+circuit (where the same goes for changing values of private types as well).
+
+_Private values_ are also referred to as _witnesses_ sometimes.
+
+> **Note:** The terms private and public when applied to a type (e.g. `pub Field`) have a different
+> meaning than when applied to a function (e.g. `pub fn foo() {}`).
+>
+> The former is a visibility modifier for the Prover to interpret if a value should be made known to
+> the Verifier, while the latter is a visibility modifier for the compiler to interpret if a
+> function should be made accessible to external Noir programs like in other languages.
+
+### pub Modifier
+
+All data types in Noir are private by default. Types are explicitly declared as public using the
+`pub` modifier:
+
+```rust
+fn main(x : Field, y : pub Field) -> pub Field {
+    x + y
+}
+```
+
+In this example, `x` is **private** while `y` and `x + y` (the return value) are **public**. Note
+that visibility is handled **per variable**, so it is perfectly valid to have one input that is
+private and another that is public.
+
+> **Note:** Public types can only be declared through parameters on `main`.
+
+## Type Aliases
+
+A type alias is a new name for an existing type. Type aliases are declared with the keyword `type`:
+
+```rust
+type Id = u8;
+
+fn main() {
+    let id: Id = 1;
+    let zero: u8 = 0;
+    assert(zero + 1 == id);
+}
+```
+
+Type aliases can also be used with [generics](../generics.md):
+
+```rust
+type Id<Size> = Size;
+
+fn main() {
+    let id: Id<u32> = 1;
+    let zero: u32 = 0;
+    assert(zero + 1 == id);
+}
+```
+
+Type aliases can even refer to other aliases. An error will be issued if they form a cycle:
+
+```rust
+// Ok!
+type A = B;
+type B = Field;
+
+type Bad1 = Bad2;
+
+// error: Dependency cycle found
+type Bad2 = Bad1;
+//   ^^^^^^^^^^^ 'Bad2' recursively depends on itself: Bad2 -> Bad1 -> Bad2
+```
+
+By default, like functions, type aliases are private to the module they exist in. You can use `pub`
+to make the type alias public or `pub(crate)` to make it public to just its crate:
+
+```rust
+// This type alias is now public
+pub type Id = u8;
+```
+
+## Wildcard Type
+Noir can usually infer the type of the variable from the context, so specifying the type of a variable is only required when it cannot be inferred. However, specifying a complex type can be tedious, especially when it has multiple generic arguments. Often some of the generic types can be inferred from the context, and Noir only needs a hint to properly infer the other types. We can partially specify a variable's type by using `_` as a marker, indicating where we still want the compiler to infer the type.
+
+```rust
+let a: [_; 4] = foo(b);
+```
+ 
+
+### BigInt
+
+You can achieve BigInt functionality using the [Noir BigInt](https://github.com/shuklaayush/noir-bigint) library.
diff --git a/docs/versioned_docs/version-v0.38.0/noir/concepts/data_types/integers.md b/docs/versioned_docs/version-v0.38.0/noir/concepts/data_types/integers.md
new file mode 100644
index 00000000000..a1d59bf3166
--- /dev/null
+++ b/docs/versioned_docs/version-v0.38.0/noir/concepts/data_types/integers.md
@@ -0,0 +1,156 @@
+---
+title: Integers
+description: Explore the Integer data type in Noir. Learn about its methods, see real-world examples, and grasp how to efficiently use Integers in your Noir code.
+keywords: [noir, integer types, methods, examples, arithmetic]
+sidebar_position: 1
+---
+
+An integer type is a range constrained field type.
+The Noir frontend supports both unsigned and signed integer types.
+The allowed sizes are 1, 8, 16, 32 and 64 bits.
+
+:::info
+
+When an integer is defined in Noir without a specific type, it will default to `Field`.
+
+The one exception is for loop indices which default to `u64` since comparisons on `Field`s are not possible.
+
+:::
+
+## Unsigned Integers
+
+An unsigned integer type is specified first with the letter `u` (indicating its unsigned nature) followed by its bit size (e.g. `8`):
+
+```rust
+fn main() {
+    let x: u8 = 1;
+    let y: u8 = 1;
+    let z = x + y;
+    assert (z == 2);
+}
+```
+
+The bit size determines the maximum value the integer type can store. For example, a `u8` variable can store a value in the range of 0 to 255 (i.e. $\\2^{8}-1\\$).
+
+## Signed Integers
+
+A signed integer type is specified first with the letter `i` (which stands for integer) followed by its bit size (e.g. `8`):
+
+```rust
+fn main() {
+    let x: i8 = -1;
+    let y: i8 = -1;
+    let z = x + y;
+    assert (z == -2);
+}
+```
+
+The bit size determines the maximum and minimum range of value the integer type can store. For example, an `i8` variable can store a value in the range of -128 to 127 (i.e. $\\-2^{7}\\$ to $\\2^{7}-1\\$).
+
+## 128 bits Unsigned Integers
+
+The built-in structure `U128` allows you to use 128-bit unsigned integers almost like a native integer type. However, there are some differences to keep in mind:
+- You cannot cast between a native integer and `U128`
+- There is a higher performance cost when using `U128`, compared to a native type.
+
+Conversion between unsigned integer types and U128 are done through the use of `from_integer` and `to_integer` functions. `from_integer` also accepts the `Field` type as input.
+
+```rust
+fn main() {
+    let x = U128::from_integer(23);
+    let y = U128::from_hex("0x7");
+    let z = x + y;
+    assert(z.to_integer() == 30);
+}
+```
+
+`U128` is implemented with two 64 bits limbs, representing the low and high bits, which explains the performance cost. You should expect `U128` to be twice more costly for addition and four times more costly for multiplication.
+You can construct a U128 from its limbs:
+```rust
+fn main(x: u64, y: u64) {
+    let x = U128::from_u64s_be(x,y);
+    assert(z.hi == x as Field);
+    assert(z.lo == y as Field);
+}
+```
+
+Note that the limbs are stored as Field elements in order to avoid unnecessary conversions.
+Apart from this, most operations will work as usual:
+
+```rust
+fn main(x: U128, y: U128) {
+    // multiplication
+    let c = x * y;
+    // addition and subtraction
+    let c = c - x + y;
+    // division
+    let c = x / y;
+    // bit operation;
+    let c = x & y | y;
+    // bit shift
+    let c = x << y;
+    // comparisons;
+    let c = x < y;
+    let c = x == y;
+}
+```
+
+## Overflows
+
+Computations that exceed the type boundaries will result in overflow errors. This happens with both signed and unsigned integers. For example, attempting to prove:
+
+```rust
+fn main(x: u8, y: u8) {
+    let z = x + y;
+}
+```
+
+With:
+
+```toml
+x = "255"
+y = "1"
+```
+
+Would result in:
+
+```
+$ nargo execute
+error: Assertion failed: 'attempt to add with overflow'
+┌─ ~/src/main.nr:9:13
+│
+│     let z = x + y;
+│             -----
+│
+= Call stack:
+  ...
+```
+
+A similar error would happen with signed integers:
+
+```rust
+fn main() {
+    let x: i8 = -118;
+    let y: i8 = -11;
+    let z = x + y;
+}
+```
+
+### Wrapping methods
+
+Although integer overflow is expected to error, some use-cases rely on wrapping. For these use-cases, the standard library provides `wrapping` variants of certain common operations:
+
+```rust
+fn wrapping_add<T>(x: T, y: T) -> T;
+fn wrapping_sub<T>(x: T, y: T) -> T;
+fn wrapping_mul<T>(x: T, y: T) -> T;
+```
+
+Example of how it is used:
+
+```rust
+
+fn main(x: u8, y: u8) -> pub u8 {
+    std::wrapping_add(x, y)
+}
+```
diff --git a/docs/versioned_docs/version-v0.38.0/noir/concepts/data_types/references.md b/docs/versioned_docs/version-v0.38.0/noir/concepts/data_types/references.md
new file mode 100644
index 00000000000..a5293d11cfb
--- /dev/null
+++ b/docs/versioned_docs/version-v0.38.0/noir/concepts/data_types/references.md
@@ -0,0 +1,23 @@
+---
+title: References
+sidebar_position: 9
+---
+
+Noir supports first-class references. References are a bit like pointers: they point to a specific address that can be followed to access the data stored at that address. You can use Rust-like syntax to use pointers in Noir: the `&` operator references the variable, the `*` operator dereferences it.
+
+Example:
+
+```rust
+fn main() {
+    let mut x = 2;
+
+    // you can reference x as &mut and pass it to multiplyBy2
+    multiplyBy2(&mut x);
+}
+
+// you can access &mut here
+fn multiplyBy2(x: &mut Field) {
+    // and dereference it with *
+    *x = *x * 2;
+}
+```
diff --git a/docs/versioned_docs/version-v0.38.0/noir/concepts/data_types/slices.mdx b/docs/versioned_docs/version-v0.38.0/noir/concepts/data_types/slices.mdx
new file mode 100644
index 00000000000..cfee564a302
--- /dev/null
+++ b/docs/versioned_docs/version-v0.38.0/noir/concepts/data_types/slices.mdx
@@ -0,0 +1,358 @@
+---
+title: Slices
+description: Explore the Slice data type in Noir. Understand its methods, see real-world examples, and learn how to effectively use Slices in your Noir programs.
+keywords: [noir, slice type, methods, examples, subarrays]
+sidebar_position: 5
+---
+
+import Experimental from '@site/src/components/Notes/_experimental.mdx';
+
+<Experimental />
+
+A slice is a dynamically-sized view into a sequence of elements. They can be resized at runtime, but because they don't own the data, they cannot be returned from a circuit. You can treat slices as arrays without a constrained size.
+
+```rust
+fn main() -> pub u32 {
+    let mut slice: [Field] = &[0; 2];
+
+    let mut new_slice = slice.push_back(6);
+    new_slice.len()
+}
+```
+
+To write a slice literal, use a preceding ampersand as in: `&[0; 2]` or
+`&[1, 2, 3]`.
+
+It is important to note that slices are not references to arrays. In Noir,
+`&[..]` is more similar to an immutable, growable vector.
+
+View the corresponding test file [here][test-file].
+
+[test-file]: https://github.com/noir-lang/noir/blob/f387ec1475129732f72ba294877efdf6857135ac/crates/nargo_cli/tests/test_data_ssa_refactor/slices/src/main.nr
+
+## Methods
+
+For convenience, the STD provides some ready-to-use, common methods for slices:
+
+### push_back
+
+Pushes a new element to the end of the slice, returning a new slice with a length one greater than the original unmodified slice.
+
+```rust
+fn push_back<T>(_self: [T], _elem: T) -> [T]
+```
+
+example:
+
+```rust
+fn main() -> pub Field {
+    let mut slice: [Field] = &[0; 2];
+
+    let mut new_slice = slice.push_back(6);
+    new_slice.len()
+}
+```
+
+View the corresponding test file [here][test-file].
+
+### push_front
+
+Returns a new array with the specified element inserted at index 0. The existing elements indexes are incremented by 1.
+
+```rust
+fn push_front(_self: Self, _elem: T) -> Self
+```
+
+Example:
+
+```rust
+let mut new_slice: [Field] = &[];
+new_slice = new_slice.push_front(20);
+assert(new_slice[0] == 20); // returns true
+```
+
+View the corresponding test file [here][test-file].
+
+### pop_front
+
+Returns a tuple of two items, the first element of the array and the rest of the array.
+
+```rust
+fn pop_front(_self: Self) -> (T, Self)
+```
+
+Example:
+
+```rust
+let (first_elem, rest_of_slice) = slice.pop_front();
+```
+
+View the corresponding test file [here][test-file].
+
+### pop_back
+
+Returns a tuple of two items, the beginning of the array with the last element omitted and the last element.
+
+```rust
+fn pop_back(_self: Self) -> (Self, T)
+```
+
+Example:
+
+```rust
+let (popped_slice, last_elem) = slice.pop_back();
+```
+
+View the corresponding test file [here][test-file].
+
+### append
+
+Loops over a slice and adds it to the end of another.
+
+```rust
+fn append(mut self, other: Self) -> Self
+```
+
+Example:
+
+```rust
+let append = &[1, 2].append(&[3, 4, 5]);
+```
+
+### insert
+
+Inserts an element at a specified index and shifts all following elements by 1.
+
+```rust
+fn insert(_self: Self, _index: Field, _elem: T) -> Self
+```
+
+Example:
+
+```rust
+new_slice = rest_of_slice.insert(2, 100);
+assert(new_slice[2] == 100);
+```
+
+View the corresponding test file [here][test-file].
+
+### remove
+
+Remove an element at a specified index, shifting all elements after it to the left, returning the altered slice and the removed element.
+
+```rust
+fn remove(_self: Self, _index: Field) -> (Self, T)
+```
+
+Example:
+
+```rust
+let (remove_slice, removed_elem) = slice.remove(3);
+```
+
+### len
+
+Returns the length of a slice
+
+```rust
+fn len(self) -> Field
+```
+
+Example:
+
+```rust
+fn main() {
+    let slice = &[42, 42];
+    assert(slice.len() == 2);
+}
+```
+
+### as_array
+
+Converts this slice into an array.
+
+Make sure to specify the size of the resulting array.
+Panics if the resulting array length is different than the slice's length.
+
+```rust
+fn as_array<let N: u32>(self) -> [T; N]
+```
+
+Example:
+
+```rust
+fn main() {
+    let slice = &[5, 6];
+
+    // Always specify the length of the resulting array!
+    let array: [Field; 2] = slice.as_array();
+
+    assert(array[0] == slice[0]);
+    assert(array[1] == slice[1]);
+}
+```
+
+### map
+
+Applies a function to each element of the slice, returning a new slice containing the mapped elements.
+
+```rust
+fn map<U, Env>(self, f: fn[Env](T) -> U) -> [U]
+```
+
+example
+
+```rust
+let a = &[1, 2, 3];
+let b = a.map(|a| a * 2); // b is now &[2, 4, 6]
+```
+
+### fold
+
+Applies a function to each element of the slice, returning the final accumulated value. The first
+parameter is the initial value.
+
+```rust
+fn fold<U, Env>(self, mut accumulator: U, f: fn[Env](U, T) -> U) -> U
+```
+
+This is a left fold, so the given function will be applied to the accumulator and first element of
+the slice, then the second, and so on. For a given call the expected result would be equivalent to:
+
+```rust
+let a1 = &[1];
+let a2 = &[1, 2];
+let a3 = &[1, 2, 3];
+
+let f = |a, b| a - b;
+a1.fold(10, f)  //=> f(10, 1)
+a2.fold(10, f)  //=> f(f(10, 1), 2)
+a3.fold(10, f)  //=> f(f(f(10, 1), 2), 3)
+```
+
+example:
+
+```rust
+
+fn main() {
+    let slice = &[2, 2, 2, 2, 2];
+    let folded = slice.fold(0, |a, b| a + b);
+    assert(folded == 10);
+}
+
+```
+
+### reduce
+
+Same as fold, but uses the first element as the starting element.
+
+```rust
+fn reduce<Env>(self, f: fn[Env](T, T) -> T) -> T
+```
+
+example:
+
+```rust
+fn main() {
+    let slice = &[2, 2, 2, 2, 2];
+    let reduced = slice.reduce(|a, b| a + b);
+    assert(reduced == 10);
+}
+```
+
+### filter
+
+Returns a new slice containing only elements for which the given predicate returns true.
+
+```rust
+fn filter<Env>(self, f: fn[Env](T) -> bool) -> Self
+```
+
+example:
+
+```rust
+fn main() {
+    let slice = &[1, 2, 3, 4, 5];
+    let odds = slice.filter(|x| x % 2 == 1);
+    assert_eq(odds, &[1, 3, 5]);
+}
+```
+
+### join
+
+Flatten each element in the slice into one value, separated by `separator`.
+
+Note that although slices implement `Append`, `join` cannot be used on slice
+elements since nested slices are prohibited.
+
+```rust
+fn join(self, separator: T) -> T where T: Append
+```
+
+example:
+
+```rust
+struct Accumulator {
+    total: Field,
+}
+
+// "Append" two accumulators by adding them
+impl Append for Accumulator {
+    fn empty() -> Self {
+        Self { total: 0 }
+    }
+
+    fn append(self, other: Self) -> Self {
+        Self { total: self.total + other.total }
+    }
+}
+
+fn main() {
+    let slice = &[1, 2, 3, 4, 5].map(|total| Accumulator { total });
+
+    let result = slice.join(Accumulator::empty());
+    assert_eq(result, Accumulator { total: 15 });
+
+    // We can use a non-empty separator to insert additional elements to sum:
+    let separator = Accumulator { total: 10 };
+    let result = slice.join(separator);
+    assert_eq(result, Accumulator { total: 55 });
+}
+```
+
+### all
+
+Returns true if all the elements satisfy the given predicate
+
+```rust
+fn all<Env>(self, predicate: fn[Env](T) -> bool) -> bool
+```
+
+example:
+
+```rust
+fn main() {
+    let slice = &[2, 2, 2, 2, 2];
+    let all = slice.all(|a| a == 2);
+    assert(all);
+}
+```
+
+### any
+
+Returns true if any of the elements satisfy the given predicate
+
+```rust
+fn any<Env>(self, predicate: fn[Env](T) -> bool) -> bool
+```
+
+example:
+
+```rust
+fn main() {
+    let slice = &[2, 2, 2, 2, 5];
+    let any = slice.any(|a| a == 5);
+    assert(any);
+}
+
+```
diff --git a/docs/versioned_docs/version-v0.38.0/noir/concepts/data_types/strings.md b/docs/versioned_docs/version-v0.38.0/noir/concepts/data_types/strings.md
new file mode 100644
index 00000000000..1fdee42425e
--- /dev/null
+++ b/docs/versioned_docs/version-v0.38.0/noir/concepts/data_types/strings.md
@@ -0,0 +1,79 @@
+---
+title: Strings
+description:
+  Discover the String data type in Noir. Learn about its methods, see real-world examples, and understand how to effectively manipulate and use Strings in Noir.
+keywords:
+  [
+    noir,
+    string type,
+    methods,
+    examples,
+    concatenation,
+  ]
+sidebar_position: 3
+---
+
+
+The string type is a fixed length value defined with `str<N>`.
+
+You can use strings in `assert()` functions or print them with
+`println()`. See more about [Logging](../../standard_library/logging.md).
+
+```rust
+
+fn main(message : pub str<11>, hex_as_string : str<4>) {
+    println(message);
+    assert(message == "hello world");
+    assert(hex_as_string == "0x41");
+}
+```
+
+You can convert a `str<N>` to a byte array by calling `as_bytes()`
+or a vector by calling `as_bytes_vec()`.
+
+```rust
+fn main() {
+    let message = "hello world";
+    let message_bytes = message.as_bytes();
+    let mut message_vec = message.as_bytes_vec();
+    assert(message_bytes.len() == 11);
+    assert(message_bytes[0] == 104);
+    assert(message_bytes[0] == message_vec.get(0));
+}
+```
+
+## Escape characters
+
+You can use escape characters for your strings:
+
+| Escape Sequence | Description     |
+|-----------------|-----------------|
+| `\r`            | Carriage Return |
+| `\n`            | Newline         |
+| `\t`            | Tab             |
+| `\0`            | Null Character  |
+| `\"`            | Double Quote    |
+| `\\`            | Backslash       |
+
+Example:
+
+```rust
+let s = "Hello \"world" // prints "Hello "world"
+let s = "hey \tyou"; // prints "hey   you"
+```
+
+## Raw strings
+
+A raw string begins with the letter `r` and is optionally delimited by a number of hashes `#`.
+
+Escape characters are *not* processed within raw strings. All contents are interpreted literally.
+
+Example:
+
+```rust
+let s = r"Hello world";
+let s = r#"Simon says "hello world""#;
+
+// Any number of hashes may be used (>= 1) as long as the string also terminates with the same number of hashes
+let s = r#####"One "#, Two "##, Three "###, Four "####, Five will end the string."#####; 
+```
diff --git a/docs/versioned_docs/version-v0.38.0/noir/concepts/data_types/structs.md b/docs/versioned_docs/version-v0.38.0/noir/concepts/data_types/structs.md
new file mode 100644
index 00000000000..29951ae843a
--- /dev/null
+++ b/docs/versioned_docs/version-v0.38.0/noir/concepts/data_types/structs.md
@@ -0,0 +1,96 @@
+---
+title: Structs
+description:
+  Explore the Struct data type in Noir. Learn about its methods, see real-world examples, and grasp how to effectively define and use Structs in your Noir programs.
+keywords:
+  [
+    noir,
+    struct type,
+    methods,
+    examples,
+    data structures,
+  ]
+sidebar_position: 8
+---
+
+A struct also allows for grouping multiple values of different types. Unlike tuples, we can also
+name each field.
+
+> **Note:** The usage of _field_ here refers to each element of the struct and is unrelated to the
+> field type of Noir.
+
+Defining a struct requires giving it a name and listing each field within as `<Key>: <Type>` pairs:
+
+```rust
+struct Animal {
+    hands: Field,
+    legs: Field,
+    eyes: u8,
+}
+```
+
+An instance of a struct can then be created with actual values in `<Key>: <Value>` pairs in any
+order. Struct fields are accessible using their given names:
+
+```rust
+fn main() {
+    let legs = 4;
+
+    let dog = Animal {
+        eyes: 2,
+        hands: 0,
+        legs,
+    };
+
+    let zero = dog.hands;
+}
+```
+
+Structs can also be destructured in a pattern, binding each field to a new variable:
+
+```rust
+fn main() {
+    let Animal { hands, legs: feet, eyes } = get_octopus();
+
+    let ten = hands + feet + eyes as u8;
+}
+
+fn get_octopus() -> Animal {
+    let octopus = Animal {
+        hands: 0,
+        legs: 8,
+        eyes: 2,
+    };
+
+    octopus
+}
+```
+
+The new variables can be bound with names different from the original struct field names, as
+showcased in the `legs --> feet` binding in the example above.
+
+### Visibility
+
+By default, like functions, structs are private to the module they exist in. You can use `pub`
+to make the struct public or `pub(crate)` to make it public to just its crate:
+
+```rust
+// This struct is now public
+pub struct Animal {
+    hands: Field,
+    legs: Field,
+    eyes: u8,
+}
+```
+
+The same applies to struct fields: by default they are private to the module they exist in,
+but they can be made `pub` or `pub(crate)`:
+
+```rust
+// This struct is now public
+pub struct Animal {
+    hands: Field,           // private to its module
+    pub(crate) legs: Field, // accessible from the entire crate
+    pub eyes: u8,           // accessible from anywhere
+}
+```
\ No newline at end of file
diff --git a/docs/versioned_docs/version-v0.38.0/noir/concepts/data_types/tuples.md b/docs/versioned_docs/version-v0.38.0/noir/concepts/data_types/tuples.md
new file mode 100644
index 00000000000..2ec5c9c4113
--- /dev/null
+++ b/docs/versioned_docs/version-v0.38.0/noir/concepts/data_types/tuples.md
@@ -0,0 +1,48 @@
+---
+title: Tuples
+description:
+  Dive into the Tuple data type in Noir. Understand its methods, practical examples, and best practices for efficiently using Tuples in your Noir code.
+keywords:
+  [
+    noir,
+    tuple type,
+    methods,
+    examples,
+    multi-value containers,
+  ]
+sidebar_position: 7
+---
+
+A tuple collects multiple values like an array, but with the added ability to collect values of
+different types:
+
+```rust
+fn main() {
+    let tup: (u8, u64, Field) = (255, 500, 1000);
+}
+```
+
+One way to access tuple elements is via destructuring using pattern matching:
+
+```rust
+fn main() {
+    let tup = (1, 2);
+
+    let (one, two) = tup;
+
+    let three = one + two;
+}
+```
+
+Another way to access tuple elements is via direct member access, using a period (`.`) followed by
+the index of the element we want to access. Index `0` corresponds to the first tuple element, `1` to
+the second and so on:
+
+```rust
+fn main() {
+    let tup = (5, 6, 7, 8);
+
+    let five = tup.0;
+    let eight = tup.3;
+}
+```
diff --git a/docs/versioned_docs/version-v0.38.0/noir/concepts/functions.md b/docs/versioned_docs/version-v0.38.0/noir/concepts/functions.md
new file mode 100644
index 00000000000..f656cdfd97a
--- /dev/null
+++ b/docs/versioned_docs/version-v0.38.0/noir/concepts/functions.md
@@ -0,0 +1,226 @@
+---
+title: Functions
+description:
+  Learn how to declare functions and methods in Noir, a programming language with Rust semantics.
+  This guide covers parameter declaration, return types, call expressions, and more.
+keywords: [Noir, Rust, functions, methods, parameter declaration, return types, call expressions]
+sidebar_position: 1
+---
+
+Functions in Noir follow the same semantics of Rust, though Noir does not support early returns.
+
+To declare a function the `fn` keyword is used.
+
+```rust
+fn foo() {}
+```
+
+By default, functions are visible only within the package they are defined. To make them visible outside of that package (for example, as part of a [library](../modules_packages_crates/crates_and_packages.md#libraries)), you should mark them as `pub`:
+
+```rust
+pub fn foo() {}
+```
+
+You can also restrict the visibility of the function to only the crate it was defined in, by specifying `pub(crate)`:
+
+```rust
+pub(crate) fn foo() {}  //foo can only be called within its crate
+```
+
+All parameters in a function must have a type and all types are known at compile time. The parameter
+is pre-pended with a colon and the parameter type. Multiple parameters are separated using a comma.
+
+```rust
+fn foo(x : Field, y : Field){}
+```
+
+The return type of a function can be stated by using the `->` arrow notation. The function below
+states that the foo function must return a `Field`. If the function returns no value, then the arrow
+is omitted.
+
+```rust
+fn foo(x : Field, y : Field) -> Field {
+    x + y
+}
+```
+
+Note that a `return` keyword is unneeded in this case - the last expression in a function's body is
+returned.
+
+## Main function
+
+If you're writing a binary, the `main` function is the starting point of your program. You can pass all types of expressions to it, as long as they have a fixed size at compile time:
+
+```rust
+fn main(x : Field) // this is fine: passing a Field
+fn main(x : [Field; 2]) // this is also fine: passing a Field with known size at compile-time
+fn main(x : (Field, bool)) // 👌: passing a (Field, bool) tuple means size 2
+fn main(x : str<5>) // this is fine, as long as you pass a string of size 5
+
+fn main(x : Vec<Field>) // can't compile, has variable size
+fn main(x : [Field]) // can't compile, has variable size
+fn main(....// i think you got it by now
+```
+
+Keep in mind [tests](../../tooling/testing.md) don't differentiate between `main` and any other function. The following snippet passes tests, but won't compile or prove:
+
+```rust
+fn main(x : [Field]) {
+    assert(x[0] == 1);
+}
+
+#[test]
+fn test_one() {
+    main(&[1, 2]);
+}
+```
+
+```bash
+$ nargo test
+[testing] Running 1 test functions
+[testing] Testing test_one... ok
+[testing] All tests passed
+
+$ nargo check
+The application panicked (crashed).
+Message:  Cannot have variable sized arrays as a parameter to main
+```
+
+## Call Expressions
+
+Calling a function in Noir is executed by using the function name and passing in the necessary
+arguments.
+
+Below we show how to call the `foo` function from the `main` function using a call expression:
+
+```rust
+fn main(x : Field, y : Field) {
+    let z = foo(x);
+}
+
+fn foo(x : Field) -> Field {
+    x + x
+}
+```
+
+## Methods
+
+You can define methods in Noir on any struct type in scope.
+
+```rust
+struct MyStruct {
+    foo: Field,
+    bar: Field,
+}
+
+impl MyStruct {
+    fn new(foo: Field) -> MyStruct {
+        MyStruct {
+            foo,
+            bar: 2,
+        }
+    }
+
+    fn sum(self) -> Field {
+        self.foo + self.bar
+    }
+}
+
+fn main() {
+    let s = MyStruct::new(40);
+    assert(s.sum() == 42);
+}
+```
+
+Methods are just syntactic sugar for functions, so if we wanted to we could also call `sum` as
+follows:
+
+```rust
+assert(MyStruct::sum(s) == 42);
+```
+
+It is also possible to specialize which method is chosen depending on the [generic](./generics.md) type that is used. In this example, the `foo` function returns different values depending on its type:
+
+```rust
+struct Foo<T> {}
+
+impl Foo<u32> {
+    fn foo(self) -> Field { 1 }
+}
+
+impl Foo<u64> {
+    fn foo(self) -> Field { 2 }
+}
+
+fn main() {
+    let f1: Foo<u32> = Foo{};
+    let f2: Foo<u64> = Foo{};
+    assert(f1.foo() + f2.foo() == 3);
+}
+```
+
+Also note that impls with the same method name defined in them cannot overlap. For example, if we already have `foo` defined for `Foo<u32>` and `Foo<u64>` like we do above, we cannot also define `foo` in an `impl<T> Foo<T>` since it would be ambiguous which version of `foo` to choose.
+
+```rust
+// Including this impl in the same project as the above snippet would
+// cause an overlapping impls error
+impl<T> Foo<T> {
+    fn foo(self) -> Field { 3 }
+}
+```
+
+## Lambdas
+
+Lambdas are anonymous functions. They follow the syntax of Rust - `|arg1, arg2, ..., argN| return_expression`.
+
+```rust
+let add_50 = |val| val + 50;
+assert(add_50(100) == 150);
+```
+
+See [Lambdas](./lambdas.md) for more details.
+
+## Attributes
+
+Attributes are metadata that can be applied to a function, using the following syntax: `#[attribute(value)]`.
+
+Supported attributes include:
+
+- **builtin**: the function is implemented by the compiler, for efficiency purposes.
+- **deprecated**: mark the function as _deprecated_. Calling the function will generate a warning: `warning: use of deprecated function`
+- **field**: Used to enable conditional compilation of code depending on the field size. See below for more details
+- **oracle**: mark the function as _oracle_; meaning it is an external unconstrained function, implemented in noir_js. See [Unconstrained](./unconstrained.md) and [NoirJS](../../reference/NoirJS/noir_js/index.md) for more details.
+- **test**: mark the function as unit tests. See [Tests](../../tooling/testing.md) for more details
+
+### Field Attribute
+
+The field attribute defines which field the function is compatible for. The function is conditionally compiled, under the condition that the field attribute matches the Noir native field.
+The field can be defined implicitly, by using the name of the elliptic curve usually associated to it - for instance bn254, bls12_381 - or explicitly by using the field (prime) order, in decimal or hexadecimal form.
+As a result, it is possible to define multiple versions of a function with each version specialized for a different field attribute. This can be useful when a function requires different parameters depending on the underlying elliptic curve.
+
+Example: we define the function `foo()` three times below. Once for the default Noir bn254 curve, once for the field $\mathbb F_{23}$, which will normally never be used by Noir, and once again for the bls12_381 curve.
+
+```rust
+#[field(bn254)]
+fn foo() -> u32 {
+    1
+}
+
+#[field(23)]
+fn foo() -> u32 {
+    2
+}
+
+// This commented code would not compile as foo would be defined twice because it is the same field as bn254
+// #[field(21888242871839275222246405745257275088548364400416034343698204186575808495617)]
+// fn foo() -> u32 {
+//     2
+// }
+
+#[field(bls12_381)]
+fn foo() -> u32 {
+    3
+}
+```
+
+If the field name is not known to Noir, it will discard the function. Field names are case insensitive.
diff --git a/docs/versioned_docs/version-v0.38.0/noir/concepts/generics.md b/docs/versioned_docs/version-v0.38.0/noir/concepts/generics.md
new file mode 100644
index 00000000000..c180a0ce7e6
--- /dev/null
+++ b/docs/versioned_docs/version-v0.38.0/noir/concepts/generics.md
@@ -0,0 +1,251 @@
+---
+title: Generics
+description: Learn how to use Generics in Noir
+keywords: [Noir, Rust, generics, functions, structs]
+sidebar_position: 7
+---
+
+Generics allow you to use the same functions with multiple different concrete data types. You can
+read more about the concept of generics in the Rust documentation
+[here](https://doc.rust-lang.org/book/ch10-01-syntax.html).
+
+Here is a trivial example showing the identity function that supports any type. In Rust, it is
+common to refer to the most general type as `T`. We follow the same convention in Noir.
+
+```rust
+fn id<T>(x: T) -> T  {
+    x
+}
+```
+
+## Numeric Generics
+
+If we want to be generic over array lengths (which are type-level integers), we can use numeric
+generics. Using these looks similar to using regular generics, but introducing them into scope
+requires declaring them with `let MyGenericName: IntegerType`. This can be done anywhere a normal
+generic is declared. Instead of types, these generics resolve to integers at compile-time.
+Here's an example of a struct that is generic over the size of the array it contains internally:
+
+```rust
+struct BigInt<let N: u32> {
+    limbs: [u32; N],
+}
+
+impl<let N: u32> BigInt<N> {
+    // `N` is in scope of all methods in the impl
+    fn first(first: BigInt<N>, second: BigInt<N>) -> Self {
+        assert(first.limbs != second.limbs);
+        first
+
+    fn second(first: BigInt<N>, second: Self) -> Self {
+        assert(first.limbs != second.limbs);
+        second
+    }
+}
+```
+
+## In Structs
+
+Generics are useful for specifying types in structs. For example, we can specify that a field in a
+struct will be of a certain generic type. In this case `value` is of type `T`.
+
+```rust
+struct RepeatedValue<T> {
+    value: T,
+    count: Field,
+}
+
+impl<T> RepeatedValue<T> {
+    fn print(self) {
+        for _i in 0 .. self.count {
+            println(self.value);
+        }
+    }
+}
+
+fn main() {
+    let repeated = RepeatedValue { value: "Hello!", count: 2 };
+    repeated.print();
+}
+```
+
+The `print` function will print `Hello!` an arbitrary number of times, twice in this case.
+
+## Calling functions on generic parameters
+
+Since a generic type `T` can represent any type, how can we call functions on the underlying type?
+In other words, how can we go from "any type `T`" to "any type `T` that has certain methods available?"
+
+This is what [traits](../concepts/traits.md) are for in Noir. Here's an example of a function generic over
+any type `T` that implements the `Eq` trait for equality:
+
+```rust
+fn first_element_is_equal<T, let N: u32>(array1: [T; N], array2: [T; N]) -> bool 
+    where T: Eq
+{
+    if (array1.len() == 0) | (array2.len() == 0) {
+        true
+    } else {
+        array1[0] == array2[0]
+    }
+}
+
+fn main() {
+    assert(first_element_is_equal([1, 2, 3], [1, 5, 6]));
+
+    // We can use first_element_is_equal for arrays of any type
+    // as long as we have an Eq impl for the types we pass in
+    let array = [MyStruct::new(), MyStruct::new()];
+    assert(array_eq(array, array, MyStruct::eq));
+}
+
+impl Eq for MyStruct {
+    fn eq(self, other: MyStruct) -> bool {
+        self.foo == other.foo
+    }
+}
+```
+
+You can find more details on traits and trait implementations on the [traits page](../concepts/traits.md).
+
+## Manually Specifying Generics with the Turbofish Operator
+
+There are times when the compiler cannot reasonably infer what type should be used for a generic, or when the developer themselves may want to manually distinguish generic type parameters. This is where the `::<>` turbofish operator comes into play.
+
+The `::<>` operator can follow a variable or path and can be used to manually specify generic arguments within the angle brackets.
+The name "turbofish" comes from that `::<>` looks like a little fish.
+
+Examples:
+```rust
+fn main() {
+    let mut slice = [];
+    slice = slice.push_back(1);
+    slice = slice.push_back(2);
+    // Without turbofish a type annotation would be needed on the left hand side
+    let array = slice.as_array::<2>();
+}
+```
+
+
+```rust
+trait MyTrait {
+    fn ten() -> Self;
+}
+
+impl MyTrait for Field {
+    fn ten() -> Self { 10 }
+}
+
+struct Foo<T> {
+    inner: T
+}
+        
+impl<T> Foo<T> {
+    fn generic_method<U>(_self: Self) -> U where U: MyTrait {
+        U::ten()
+    }
+}
+        
+fn example() {
+    let foo: Foo<Field> = Foo { inner: 1 };
+    // Using a type other than `Field` here (e.g. u32) would fail as 
+    // there is no matching impl for `u32: MyTrait`. 
+    //
+    // Substituting the `10` on the left hand side of this assert
+    // with `10 as u32` would also fail with a type mismatch as we 
+    // are expecting a `Field` from the right hand side.
+    assert(10 as u32 == foo.generic_method::<Field>());
+}
+```
+
+## Arithmetic Generics
+
+In addition to numeric generics, Noir also allows a limited form of arithmetic on generics.
+When you have a numeric generic such as `N`, you can use the following operators on it in a
+type position: `+`, `-`, `*`, `/`, and `%`.
+
+Note that type checking arithmetic generics is a best effort guess from the compiler and there
+are many cases of types that are equal that the compiler may not see as such. For example,
+we know that `T * (N + M)` should be equal to `T*N + T*M` but the compiler does not currently
+apply the distributive law and thus sees these as different types.
+
+Even with this limitation though, the compiler can handle common cases decently well:
+
+```rust
+trait Serialize<let N: u32> {
+    fn serialize(self) -> [Field; N];
+}
+
+impl Serialize<1> for Field {
+    fn serialize(self) -> [Field; 1] {
+        [self]
+    }
+}
+
+impl<T, let N: u32, let M: u32> Serialize<N * M> for [T; N]
+    where T: Serialize<M> { .. }
+
+impl<T, U, let N: u32, let M: u32> Serialize<N + M> for (T, U)
+    where T: Serialize<N>, U: Serialize<M> { .. }
+
+fn main() {
+    let data = (1, [2, 3, 4]);
+    assert_eq(data.serialize().len(), 4);
+}
+```
+
+Note that if there is any over or underflow the types will fail to unify:
+
+```rust title="underflow-example" showLineNumbers 
+fn pop<let N: u32>(array: [Field; N]) -> [Field; N - 1] {
+    let mut result: [Field; N - 1] = std::mem::zeroed();
+    for i in 0..N - 1 {
+        result[i] = array[i];
+    }
+    result
+}
+
+fn main() {
+    // error: Could not determine array length `(0 - 1)`
+    pop([]);
+}
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/test_programs/compile_failure/arithmetic_generics_underflow/src/main.nr#L1-L14" target="_blank" rel="noopener noreferrer">Source code: test_programs/compile_failure/arithmetic_generics_underflow/src/main.nr#L1-L14</a></sub></sup>
+
+
+This also applies if there is underflow in an intermediate calculation:
+
+```rust title="intermediate-underflow-example" showLineNumbers 
+fn main() {
+    // From main it looks like there's nothing sketchy going on
+    seems_fine([]);
+}
+
+// Since `seems_fine` says it can receive and return any length N
+fn seems_fine<let N: u32>(array: [Field; N]) -> [Field; N] {
+    // But inside `seems_fine` we pop from the array which
+    // requires the length to be greater than zero.
+
+    // error: Could not determine array length `(0 - 1)`
+    push_zero(pop(array))
+}
+
+fn pop<let N: u32>(array: [Field; N]) -> [Field; N - 1] {
+    let mut result: [Field; N - 1] = std::mem::zeroed();
+    for i in 0..N - 1 {
+        result[i] = array[i];
+    }
+    result
+}
+
+fn push_zero<let N: u32>(array: [Field; N]) -> [Field; N + 1] {
+    let mut result: [Field; N + 1] = std::mem::zeroed();
+    for i in 0..N {
+        result[i] = array[i];
+    }
+    // index N is already zeroed
+    result
+}
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/test_programs/compile_failure/arithmetic_generics_intermediate_underflow/src/main.nr#L1-L32" target="_blank" rel="noopener noreferrer">Source code: test_programs/compile_failure/arithmetic_generics_intermediate_underflow/src/main.nr#L1-L32</a></sub></sup>
+
diff --git a/docs/versioned_docs/version-v0.38.0/noir/concepts/globals.md b/docs/versioned_docs/version-v0.38.0/noir/concepts/globals.md
new file mode 100644
index 00000000000..6b8314399a2
--- /dev/null
+++ b/docs/versioned_docs/version-v0.38.0/noir/concepts/globals.md
@@ -0,0 +1,82 @@
+---
+title: Global Variables
+description:
+  Learn about global variables in Noir. Discover how
+  to declare, modify, and use them in your programs.
+keywords: [noir programming language, globals, global variables, constants]
+sidebar_position: 8
+---
+
+## Globals
+
+
+Noir supports global variables. The global's type can be inferred by the compiler entirely:
+
+```rust
+global N = 5; // Same as `global N: Field = 5`
+
+global TUPLE = (3, 2);
+
+fn main() {
+    assert(N == 5);
+    assert(N == TUPLE.0 + TUPLE.1);
+}
+```
+
+:::info
+
+Globals can be defined as any expression, so long as they don't depend on themselves - otherwise there would be a dependency cycle! For example:
+
+```rust
+global T = foo(T); // dependency error
+```
+
+:::
+
+
+If they are initialized to a literal integer, globals can be used to specify an array's length:
+
+```rust
+global N: u32 = 2;
+
+fn main(y : [Field; N]) {
+    assert(y[0] == y[1])
+}
+```
+
+A global from another module can be imported or referenced externally like any other name:
+
+```rust
+global N = 20;
+
+fn main() {
+    assert(my_submodule::N != N);
+}
+
+mod my_submodule {
+    global N: Field = 10;
+}
+```
+
+When a global is used, Noir replaces the name with its definition on each occurrence.
+This means globals defined using function calls will repeat the call each time they're used:
+
+```rust
+global RESULT = foo();
+
+fn foo() -> [Field; 100] { ... }
+```
+
+This is usually fine since Noir will generally optimize any function call that does not
+refer to a program input into a constant. It should be kept in mind however, if the called
+function performs side-effects like `println`, as these will still occur on each use.
+
+### Visibility
+
+By default, like functions, globals are private to the module they exist in. You can use `pub`
+to make the global public or `pub(crate)` to make it public to just its crate:
+
+```rust
+// This global is now public
+pub global N = 5;
+```
\ No newline at end of file
diff --git a/docs/versioned_docs/version-v0.38.0/noir/concepts/lambdas.md b/docs/versioned_docs/version-v0.38.0/noir/concepts/lambdas.md
new file mode 100644
index 00000000000..be3c7e0b5ca
--- /dev/null
+++ b/docs/versioned_docs/version-v0.38.0/noir/concepts/lambdas.md
@@ -0,0 +1,81 @@
+---
+title: Lambdas
+description: Learn how to use anonymous functions in Noir programming language.
+keywords: [Noir programming language, lambda, closure, function, anonymous function]
+sidebar_position: 9
+---
+
+## Introduction
+
+Lambdas are anonymous functions. The syntax is `|arg1, arg2, ..., argN| return_expression`.
+
+```rust
+let add_50 = |val| val + 50;
+assert(add_50(100) == 150);
+```
+
+A block can be used as the body of a lambda, allowing you to declare local variables inside it:
+
+```rust
+let cool = || {
+  let x = 100;
+  let y = 100;
+  x + y
+}
+
+assert(cool() == 200);
+```
+
+## Closures
+
+Inside the body of a lambda, you can use variables defined in the enclosing function. Such lambdas are called **closures**. In this example `x` is defined inside `main` and is accessed from within the lambda:
+
+```rust
+fn main() {
+  let x = 100;
+  let closure = || x + 150;
+  assert(closure() == 250);
+}
+```
+
+## Passing closures to higher-order functions
+
+It may catch you by surprise that the following code fails to compile:
+
+```rust
+fn foo(f: fn () -> Field) -> Field {
+ f()
+}
+
+fn main() {
+  let (x, y) = (50, 50);
+  assert(foo(|| x + y) == 100); // error :(
+}
+```
+
+The reason is that the closure's capture environment affects its type - we have a closure that captures two Fields and `foo`
+expects a regular function as an argument - those are incompatible.
+:::note
+
+Variables contained within the `||` are the closure's parameters, and the expression that follows it is the closure's body. The capture environment is comprised of any variables used in the closure's body that are not parameters.
+
+E.g. in |x| x + y, y would be a captured variable, but x would not be, since it is a parameter of the closure.
+
+:::
+The syntax for the type of a closure is `fn[env](args) -> ret_type`, where `env` is the capture environment of the closure -
+in this example that's `(Field, Field)`.
+
+The best solution in our case is to make `foo` generic over the environment type of its parameter, so that it can be called
+with closures with any environment, as well as with regular functions:
+
+```rust
+fn foo<Env>(f: fn[Env]() -> Field) -> Field {
+ f()
+}
+
+fn main() {
+  let (x, y) = (50, 50);
+  assert(foo(|| x + y) == 100); // compiles fine
+  assert(foo(|| 60) == 60);     // compiles fine
+}
+```
diff --git a/docs/versioned_docs/version-v0.38.0/noir/concepts/mutability.md b/docs/versioned_docs/version-v0.38.0/noir/concepts/mutability.md
new file mode 100644
index 00000000000..fdeef6a87c5
--- /dev/null
+++ b/docs/versioned_docs/version-v0.38.0/noir/concepts/mutability.md
@@ -0,0 +1,121 @@
+---
+title: Mutability
+description:
+  Learn about mutable variables in Noir. Discover how
+  to declare, modify, and use them in your programs.
+keywords: [noir programming language, mutability in noir, mutable variables]
+sidebar_position: 8
+---
+
+Variables in noir can be declared mutable via the `mut` keyword. Mutable variables can be reassigned
+to via an assignment expression.
+
+```rust
+let x = 2;
+x = 3; // error: x must be mutable to be assigned to
+
+let mut y = 3;
+let y = 4; // OK
+```
+
+The `mut` modifier can also apply to patterns:
+
+```rust
+let (a, mut b) = (1, 2);
+a = 11; // error: a must be mutable to be assigned to
+b = 12; // OK
+
+let mut (c, d) = (3, 4);
+c = 13; // OK
+d = 14; // OK
+
+// etc.
+let MyStruct { x: mut y } = MyStruct { x: a };
+// y is now in scope
+```
+
+Note that mutability in noir is local and everything is passed by value, so if a called function
+mutates its parameters then the parent function will keep the old value of the parameters.
+
+```rust
+fn main() -> pub Field {
+    let x = 3;
+    helper(x);
+    x // x is still 3
+}
+
+fn helper(mut x: i32) {
+    x = 4;
+}
+```
+
+## Non-local mutability
+
+Non-local mutability can be achieved through the mutable reference type `&mut T`:
+
+```rust
+fn set_to_zero(x: &mut Field) {
+    *x = 0;
+}
+
+fn main() {
+    let mut y = 42;
+    set_to_zero(&mut y);
+    assert(*y == 0);
+}
+```
+
+When creating a mutable reference, the original variable being referred to (`y` in this
+example) must also be mutable. Since mutable references are a reference type, they must
+be explicitly dereferenced via `*` to retrieve the underlying value. Note that this yields
+a copy of the value, so mutating this copy will not change the original value behind the
+reference:
+
+```rust
+fn main() {
+    let mut x = 1;
+    let x_ref = &mut x;
+
+    let mut y = *x_ref;
+    let y_ref = &mut y;
+
+    x = 2;
+    *x_ref = 3;
+
+    y = 4;
+    *y_ref = 5;
+
+    assert(x == 3);
+    assert(*x_ref == 3);
+    assert(y == 5);
+    assert(*y_ref == 5);
+}
+```
+
+Note that types in Noir are actually deeply immutable so the copy that occurs when
+dereferencing is only a conceptual copy - no additional constraints will occur.
+
+Mutable references can also be stored within structs. Note that there is also
+no lifetime parameter on these unlike rust. This is because the allocated memory
+always lasts the entire program - as if it were an array of one element.
+
+```rust
+struct Foo {
+    x: &mut Field
+}
+
+impl Foo {
+    fn incr(mut self) {
+        *self.x += 1;
+    }
+}
+
+fn main() {
+    let foo = Foo { x: &mut 0 };
+    foo.incr();
+    assert(*foo.x == 1);
+}
+```
+
+In general, you should avoid non-local & shared mutability unless it is needed. Sticking
+to only local mutability will improve readability and potentially improve compiler optimizations as well.
diff --git a/docs/versioned_docs/version-v0.38.0/noir/concepts/ops.md b/docs/versioned_docs/version-v0.38.0/noir/concepts/ops.md
new file mode 100644
index 00000000000..c35c36c38a9
--- /dev/null
+++ b/docs/versioned_docs/version-v0.38.0/noir/concepts/ops.md
@@ -0,0 +1,98 @@
+---
+title: Logical Operations
+description:
+  Learn about the supported arithmetic and logical operations in the Noir programming language.
+  Discover how to perform operations on private input types, integers, and booleans.
+keywords:
+  [
+    Noir programming language,
+    supported operations,
+    arithmetic operations,
+    logical operations,
+    predicate operators,
+    bitwise operations,
+    short-circuiting,
+    backend,
+  ]
+sidebar_position: 3
+---
+
+# Operations
+
+## Table of Supported Operations
+
+| Operation |                          Description                           |                           Requirements |
+| :-------- | :------------------------------------------------------------: | -------------------------------------: |
+| +         |             Adds two private input types together              |            Types must be private input |
+| -         |           Subtracts two private input types together           |            Types must be private input |
+| \*        |          Multiplies two private input types together           |            Types must be private input |
+| /         |            Divides two private input types together            |            Types must be private input |
+| ^         |              XOR two private input types together              |                  Types must be integer |
+| &         |              AND two private input types together              |                  Types must be integer |
+| \|        |              OR two private input types together               |                  Types must be integer |
+| \<\<        |        Left shift an integer by another integer amount         | Types must be integer, shift must be u8 |
+| >>        |        Right shift an integer by another integer amount        | Types must be integer, shift must be u8 |
+| !         |                     Bitwise not of a value                     |        Type must be integer or boolean |
+| \<         |       returns a bool if one value is less than the other       | Upper bound must have a known bit size |
+| \<=        | returns a bool if one value is less than or equal to the other | Upper bound must have a known bit size |
+| >         |       returns a bool if one value is more than the other       | Upper bound must have a known bit size |
+| >=        | returns a bool if one value is more than or equal to the other | Upper bound must have a known bit size |
+| ==        |       returns a bool if one value is equal to the other        |       Both types must not be constants |
+| !=        |     returns a bool if one value is not equal to the other      |       Both types must not be constants |
+
+### Predicate Operators
+
+`<,<=, !=, == , >, >=` are known as predicate/comparison operations because they compare two values.
+This differs from the operations such as `+` where the operands are used in _computation_.
+
+### Bitwise Operations Example
+
+```rust
+fn main(x : Field) {
+    let y = x as u32;
+    let z = y & y;
+}
+```
+
+`z` is implicitly constrained to be the result of `y & y`. The `&` operand is used to denote bitwise
+`&`.
+
+> `x & x` would not compile as `x` is a `Field` and not an integer type.
+
+### Logical Operators
+
+Noir has no support for the logical operators `||` and `&&`. This is because encoding the
+short-circuiting that these operators require can be inefficient for Noir's backend. Instead you can
+use the bitwise operators `|` and `&` which operate identically for booleans, just without the
+short-circuiting.
+
+```rust
+let my_val = 5;
+
+let mut flag = 1;
+if (my_val > 6) | (my_val == 0) {
+    flag = 0;
+}
+assert(flag == 1);
+
+if (my_val != 10) & (my_val < 50) {
+    flag = 0;
+}
+assert(flag == 0);
+```
+
+### Shorthand operators
+
+Noir shorthand operators for most of the above operators, namely `+=, -=, *=, /=, %=, &=, |=, ^=, <<=`, and `>>=`. These allow for more concise syntax. For example:
+
+```rust
+let mut i = 0;
+i = i + 1;
+```
+
+could be written as:
+
+```rust
+let mut i = 0;
+i += 1;
+```
diff --git a/docs/versioned_docs/version-v0.38.0/noir/concepts/oracles.mdx b/docs/versioned_docs/version-v0.38.0/noir/concepts/oracles.mdx
new file mode 100644
index 00000000000..77a2ac1550a
--- /dev/null
+++ b/docs/versioned_docs/version-v0.38.0/noir/concepts/oracles.mdx
@@ -0,0 +1,29 @@
+---
+title: Oracles
+description: Dive into how Noir supports Oracles via RPC calls, and learn how to declare an Oracle in Noir with our comprehensive guide.
+keywords:
+  - Noir
+  - Oracles
+  - RPC Calls
+  - Unconstrained Functions
+  - Programming
+  - Blockchain
+sidebar_position: 6
+---
+
+import Experimental from '@site/src/components/Notes/_experimental.mdx';
+
+<Experimental />
+
+Noir has support for Oracles via RPC calls. This means Noir will make an RPC call and use the return value for proof generation.
+
+Since Oracles are not resolved by Noir, they are [`unconstrained` functions](./unconstrained.md)
+
+You can declare an Oracle through the `#[oracle(<name>)]` flag. Example:
+
+```rust
+#[oracle(get_number_sequence)]
+unconstrained fn get_number_sequence(_size: Field) -> [Field] {}
+```
+
+The timeout for when using an external RPC oracle resolver can be set with the `NARGO_FOREIGN_CALL_TIMEOUT` environment variable. This timeout is in units of milliseconds.
diff --git a/docs/versioned_docs/version-v0.38.0/noir/concepts/shadowing.md b/docs/versioned_docs/version-v0.38.0/noir/concepts/shadowing.md
new file mode 100644
index 00000000000..5ce6130d201
--- /dev/null
+++ b/docs/versioned_docs/version-v0.38.0/noir/concepts/shadowing.md
@@ -0,0 +1,44 @@
+---
+title: Shadowing
+sidebar_position: 12
+---
+
+Noir allows for inheriting variables' values and re-declaring them with the same name similar to Rust, known as shadowing.
+
+For example, the following function is valid in Noir:
+
+```rust
+fn main() {
+    let x = 5;
+
+    {
+        let x = x * 2;
+        assert (x == 10);
+    }
+
+    assert (x == 5);
+}
+```
+
+In this example, a variable x is first defined with the value 5.
+
+The local scope that follows shadows the original x, i.e. creates a local mutable x based on the value of the original x. It is given a value of 2 times the original x.
+
+When we return to the main scope, x once again refers to just the original x, which stays at the value of 5.
+
+## Temporal mutability
+
+One way that shadowing is useful, in addition to ergonomics across scopes, is for temporarily mutating variables.
+
+```rust
+fn main() {
+    let age = 30;
+    // age = age + 5; // Would error as `age` is immutable by default.
+
+    let mut age = age + 5; // Temporarily mutates `age` with a new value.
+
+    let age = age; // Locks `age`'s mutability again.
+
+    assert (age == 35);
+}
+```
diff --git a/docs/versioned_docs/version-v0.38.0/noir/concepts/traits.md b/docs/versioned_docs/version-v0.38.0/noir/concepts/traits.md
new file mode 100644
index 00000000000..9da00a77587
--- /dev/null
+++ b/docs/versioned_docs/version-v0.38.0/noir/concepts/traits.md
@@ -0,0 +1,501 @@
+---
+title: Traits
+description:
+  Traits in Noir can be used to abstract out a common interface for functions across
+  several data types.
+keywords: [noir programming language, traits, interfaces, generic, protocol]
+sidebar_position: 14
+---
+
+## Overview
+
+Traits in Noir are a useful abstraction similar to interfaces or protocols in other languages. Each trait defines
+the interface of several methods contained within the trait. Types can then implement this trait by providing
+implementations for these methods. For example in the program:
+
+```rust
+struct Rectangle {
+    width: Field,
+    height: Field,
+}
+
+impl Rectangle {
+    fn area(self) -> Field {
+        self.width * self.height
+    }
+}
+
+fn log_area(r: Rectangle) {
+    println(r.area());
+}
+```
+
+We have a function `log_area` to log the area of a `Rectangle`. Now how should we change the program if we want this
+function to work on `Triangle`s as well?:
+
+```rust
+struct Triangle {
+    width: Field,
+    height: Field,
+}
+
+impl Triangle {
+    fn area(self) -> Field {
+        self.width * self.height / 2
+    }
+}
+```
+
+Making `log_area` generic over all types `T` would be invalid since not all types have an `area` method. Instead, we can
+introduce a new `Area` trait and make `log_area` generic over all types `T` that implement `Area`:
+
+```rust
+trait Area {
+    fn area(self) -> Field;
+}
+
+fn log_area<T>(shape: T) where T: Area {
+    println(shape.area());
+}
+```
+
+We also need to explicitly implement `Area` for `Rectangle` and `Triangle`. We can do that by changing their existing
+impls slightly. Note that the parameter types and return type of each of our `area` methods must match those defined
+by the `Area` trait.
+
+```rust
+impl Area for Rectangle {
+    fn area(self) -> Field {
+        self.width * self.height
+    }
+}
+
+impl Area for Triangle {
+    fn area(self) -> Field {
+        self.width * self.height / 2
+    }
+}
+```
+
+Now we have a working program that is generic over any type of Shape that is used! Others can even use this program
+as a library with their own types - such as `Circle` - as long as they also implement `Area` for these types.
+
+## Where Clauses
+
+As seen in `log_area` above, when we want to create a function or method that is generic over any type that implements
+a trait, we can add a where clause to the generic function.
+
+```rust
+fn log_area<T>(shape: T) where T: Area {
+    println(shape.area());
+}
+```
+
+It is also possible to apply multiple trait constraints on the same variable at once by combining traits with the `+`
+operator. Similarly, we can have multiple trait constraints by separating each with a comma:
+
+```rust
+fn foo<T, U>(elements: [T], thing: U) where
+    T: Default + Add + Eq,
+    U: Bar,
+{
+    let mut sum = T::default();
+
+    for element in elements {
+        sum += element;
+    }
+
+    if sum == T::default() {
+        thing.bar();
+    }
+}
+```
+
+## Generic Implementations
+
+You can add generics to a trait implementation by adding the generic list after the `impl` keyword:
+
+```rust
+trait Second {
+    fn second(self) -> Field;
+}
+
+impl<T> Second for (T, Field) {
+    fn second(self) -> Field {
+        self.1
+    }
+}
+```
+
+You can also implement a trait for every type this way:
+
+```rust
+trait Debug {
+    fn debug(self);
+}
+
+impl<T> Debug for T {
+    fn debug(self) {
+        println(self);
+    }
+}
+
+fn main() {
+    1.debug();
+}
+```
+
+### Generic Trait Implementations With Where Clauses
+
+Where clauses can be placed on trait implementations themselves to restrict generics in a similar way.
+For example, while `impl<T> Foo for T` implements the trait `Foo` for every type, `impl<T> Foo for T where T: Bar`
+will implement `Foo` only for types that also implement `Bar`. This is often used for implementing generic types.
+For example, here is the implementation for array equality:
+
+```rust
+impl<T, let N: u32> Eq for [T; let N: u32] where T: Eq {
+    // Test if two arrays have the same elements.
+    // Because both arrays must have length N, we know their lengths already match.
+    fn eq(self, other: Self) -> bool {
+        let mut result = true;
+
+        for i in 0 .. self.len() {
+            // The T: Eq constraint is needed to call == on the array elements here
+            result &= self[i] == other[i];
+        }
+
+        result
+    }
+}
+```
+
+Where clauses can also be placed on struct implementations. 
+For example, here is a method utilizing a generic type that implements the equality trait.
+
+```rust
+struct Foo<T> {
+    a: u32,
+    b: T,
+}
+
+impl<T> Foo<T> where T: Eq {
+    fn eq(self, other: Self) -> bool {
+        (self.a == other.a) & self.b.eq(other.b)
+    }
+}
+```
+
+## Generic Traits
+
+Traits themselves can also be generic by placing the generic arguments after the trait name. These generics are in
+scope of every item within the trait.
+
+```rust
+trait Into<T> {
+    // Convert `self` to type `T`
+    fn into(self) -> T;
+}
+```
+
+When implementing generic traits the generic arguments of the trait must be specified. This is also true anytime
+when referencing a generic trait (e.g. in a `where` clause).
+
+```rust
+struct MyStruct {
+    array: [Field; 2],
+}
+
+impl Into<[Field; 2]> for MyStruct {
+    fn into(self) -> [Field; 2] {
+        self.array
+    }
+}
+
+fn as_array<T>(x: T) -> [Field; 2] 
+    where T: Into<[Field; 2]>
+{
+    x.into()
+}
+
+fn main() {
+    let array = [1, 2];
+    let my_struct = MyStruct { array };
+
+    assert_eq(as_array(my_struct), array);
+}
+```
+
+### Associated Types and Constants
+
+Traits also support associated types and constraints which can be thought of as additional generics that are referred to by name.
+
+Here's an example of a trait with an associated type `Foo` and a constant `Bar`:
+
+```rust
+trait MyTrait {
+    type Foo;
+
+    let Bar: u32;
+}
+```
+
+Now when we're implementing `MyTrait` we also have to provide values for `Foo` and `Bar`:
+
+```rust
+impl MyTrait for Field {
+    type Foo = i32;
+
+    let Bar: u32 = 11;
+}
+```
+
+Since associated constants can also be used in a type position, its values are limited to only other
+expression kinds allowed in numeric generics.
+
+Note that currently all associated types and constants must be explicitly specified in a trait constraint.
+If we leave out any, we'll get an error that we're missing one:
+
+```rust
+// Error! Constraint is missing associated constant for `Bar`
+fn foo<T>(x: T) where T: MyTrait<Foo = i32> {
+    ...
+}
+```
+
+Because all associated types and constants must be explicitly specified, they are essentially named generics,
+although this is set to change in the future. Future versions of Noir will allow users to elide associated types
+in trait constraints similar to Rust. When this is done, you may still refer to their value with the `<Type as Trait>::AssociatedType`
+syntax:
+
+```rust
+// Only valid in future versions of Noir:
+fn foo<T>(x: T) where T: MyTrait {
+    let _: <T as MyTrait>::Foo = ...;
+}
+```
+
+The type as trait syntax is possible in Noir today but is less useful when each type must be explicitly specified anyway:
+
+```rust
+fn foo<T, F, let B: u32>(x: T) where T: MyTrait<Foo = F, Bar = B> {
+    // Works, but could just use F directly
+    let _: <T as MyTrait<Foo = F, Bar = B>>::Foo = ...;
+
+    let _: F = ...;
+}
+```
+
+## Trait Methods With No `self`
+
+A trait can contain any number of methods, each of which have access to the `Self` type which represents each type
+that eventually implements the trait. Similarly, the `self` variable is available as well but is not required to be used.
+For example, we can define a trait to create a default value for a type. This trait will need to return the `Self` type
+but doesn't need to take any parameters:
+
+```rust
+trait Default {
+    fn default() -> Self;
+}
+```
+
+Implementing this trait can be done similarly to any other trait:
+
+```rust
+impl Default for Field {
+    fn default() -> Field {
+        0
+    }
+}
+
+struct MyType {}
+
+impl Default for MyType {
+    fn default() -> Field {
+        MyType {}
+    }
+}
+```
+
+However, since there is no `self` parameter, we cannot call it via the method call syntax `object.method()`.
+Instead, we'll need to refer to the function directly. This can be done either by referring to the
+specific impl `MyType::default()` or referring to the trait itself `Default::default()`. In the later
+case, type inference determines the impl that is selected.
+
+```rust
+let my_struct = MyStruct::default();
+
+let x: Field = Default::default();
+let result = x + Default::default();
+```
+
+:::warning
+
+```rust
+let _ = Default::default();
+```
+
+If type inference cannot select which impl to use because of an ambiguous `Self` type, an impl will be
+arbitrarily selected. This occurs most often when the result of a trait function call with no parameters
+is unused. To avoid this, when calling a trait function with no `self` or `Self` parameters or return type,
+always refer to it via the implementation type's namespace - e.g. `MyType::default()`.
+This is set to change to an error in future Noir versions.
+
+:::
+
+## Default Method Implementations
+
+A trait can also have default implementations of its methods by giving a body to the desired functions.
+Note that this body must be valid for all types that may implement the trait. As a result, the only
+valid operations on `self` will be operations valid for any type or other operations on the trait itself.
+
+```rust
+trait Numeric {
+    fn add(self, other: Self) -> Self;
+
+    // Default implementation of double is (self + self)
+    fn double(self) -> Self {
+        self.add(self)
+    }
+}
+```
+
+When implementing a trait with default functions, a type may choose to implement only the required functions:
+
+```rust
+impl Numeric for Field {
+    fn add(self, other: Field) -> Field {
+        self + other
+    }
+}
+```
+
+Or it may implement the optional methods as well:
+
+```rust
+impl Numeric for u32 {
+    fn add(self, other: u32) -> u32 {
+        self + other
+    }
+
+    fn double(self) -> u32 {
+        self * 2
+    }
+}
+```
+
+## Impl Specialization
+
+When implementing traits for a generic type it is possible to implement the trait for only a certain combination
+of generics. This can be either as an optimization or because those specific generics are required to implement the trait.
+
+```rust
+trait Sub {
+    fn sub(self, other: Self) -> Self;
+}
+
+struct NonZero<T> {
+    value: T,
+}
+
+impl Sub for NonZero<Field> {
+    fn sub(self, other: Self) -> Self {
+        let value = self.value - other.value;
+        assert(value != 0);
+        NonZero { value }
+    }
+}
+```
+
+## Overlapping Implementations
+
+Overlapping implementations are disallowed by Noir to ensure Noir's decision on which impl to select is never ambiguous.
+This means if a trait `Foo` is already implemented
+by a type `Bar<T>` for all `T`, then we cannot also have a separate impl for `Bar<Field>` (or any other
+type argument). Similarly, if there is an impl for all `T` such as `impl<T> Debug for T`, we cannot create
+any more impls to `Debug` for other types since it would be ambiguous which impl to choose for any given
+method call.
+
+```rust
+trait Trait {}
+
+// Previous impl defined here
+impl<A, B> Trait for (A, B) {}
+
+// error: Impl for type `(Field, Field)` overlaps with existing impl
+impl Trait for (Field, Field) {}
+```
+
+## Trait Coherence
+
+Another restriction on trait implementations is coherence. This restriction ensures other crates cannot create
+impls that may overlap with other impls, even if several unrelated crates are used as dependencies in the same
+program.
+
+The coherence restriction is: to implement a trait, either the trait itself or the object type must be declared
+in the crate the impl is in.
+
+In practice this often comes up when using types provided by libraries. If a library provides a type `Foo` that does
+not implement a trait in the standard library such as `Default`, you may not `impl Default for Foo` in your own crate.
+While restrictive, this prevents later issues or silent changes in the program if the `Foo` library later added its
+own impl for `Default`. If you are a user of the `Foo` library in this scenario and need a trait not implemented by the
+library your choices are to either submit a patch to the library or use the newtype pattern.
+
+### The Newtype Pattern
+
+The newtype pattern gets around the coherence restriction by creating a new wrapper type around the library type
+that we cannot create `impl`s for. Since the new wrapper type is defined in our current crate, we can create
+impls for any trait we need on it.
+
+```rust
+struct Wrapper {
+    foo: some_library::Foo,
+}
+
+impl Default for Wrapper {
+    fn default() -> Wrapper {
+        Wrapper {
+            foo: some_library::Foo::new(),
+        }
+    }
+}
+```
+
+Since we have an impl for our own type, the behavior of this code will not change even if `some_library` is updated
+to provide its own `impl Default for Foo`. The downside of this pattern is that it requires extra wrapping and
+unwrapping of values when converting to and from the `Wrapper` and `Foo` types.
+
+### Trait Inheritance
+
+Sometimes, you might need one trait to use another trait’s functionality (like "inheritance" in some other languages). In this case, you can specify this relationship by listing any child traits after the parent trait's name and a colon. Now, whenever the parent trait is implemented it will require the child traits to be implemented as well. A parent trait is also called a "super trait."
+
+```rust
+trait Person {
+    fn name(self) -> String;
+}
+
+// Person is a supertrait of Student.
+// Implementing Student requires you to also impl Person.
+trait Student: Person {
+    fn university(self) -> String;
+}
+
+trait Programmer {
+    fn fav_language(self) -> String;
+}
+
+// CompSciStudent (computer science student) is a subtrait of both Programmer 
+// and Student. Implementing CompSciStudent requires you to impl both supertraits.
+trait CompSciStudent: Programmer + Student {
+    fn git_username(self) -> String;
+}
+```
+
+### Visibility
+
+By default, like functions, traits are private to the module they exist in. You can use `pub`
+to make the trait public or `pub(crate)` to make it public to just its crate:
+
+```rust
+// This trait is now public
+pub trait Trait {}
+```
\ No newline at end of file
diff --git a/docs/versioned_docs/version-v0.38.0/noir/concepts/unconstrained.md b/docs/versioned_docs/version-v0.38.0/noir/concepts/unconstrained.md
new file mode 100644
index 00000000000..b5221b8d2dd
--- /dev/null
+++ b/docs/versioned_docs/version-v0.38.0/noir/concepts/unconstrained.md
@@ -0,0 +1,104 @@
+---
+title: Unconstrained Functions
+description: "Learn about what unconstrained functions in Noir are, how to use them and when you'd want to."
+
+keywords: [Noir programming language, unconstrained, open]
+sidebar_position: 5
+---
+
+Unconstrained functions are functions which do not constrain any of the included computation and allow for non-deterministic computation.
+
+## Why?
+
+Zero-knowledge (ZK) domain-specific languages (DSL) enable developers to generate ZK proofs from their programs by compiling code down to the constraints of an NP complete language (such as R1CS or PLONKish languages). However, the hard bounds of a constraint system can be very limiting to the functionality of a ZK DSL.
+
+Enabling a circuit language to perform unconstrained execution is a powerful tool. Said another way, unconstrained execution lets developers generate witnesses from code that does not generate any constraints. Being able to execute logic outside of a circuit is critical for both circuit performance and constructing proofs on information that is external to a circuit.
+
+Fetching information from somewhere external to a circuit can also be used to enable developers to improve circuit efficiency.
+
+A ZK DSL does not just prove computation, but proves that some computation was handled correctly. Thus, it is necessary that when we switch from performing some operation directly inside of a circuit to inside of an unconstrained environment that the appropriate constraints are still laid down elsewhere in the circuit.
+
+## Example
+
+An in depth example might help drive the point home. This example comes from the excellent [post](https://discord.com/channels/1113924620781883405/1124022445054111926/1128747641853972590) by Tom in the Noir Discord.
+
+Let's look at how we can optimize a function to turn a `u72` into an array of `u8`s.
+
+```rust
+fn main(num: u72) -> pub [u8; 8] {
+    let mut out: [u8; 8] = [0; 8];
+    for i in 0..8 {
+        out[i] = (num >> (56 - (i * 8)) as u72 & 0xff) as u8;
+    }
+
+    out
+}
+```
+
+```
+Total ACIR opcodes generated for language PLONKCSat { width: 3 }: 91
+Backend circuit size: 3619
+```
+
+A lot of the operations in this function are optimized away by the compiler (all the bit-shifts turn into divisions by constants). However we can save a bunch of gates by casting to u8 a bit earlier. This automatically truncates the bit-shifted value to fit in a u8 which allows us to remove the AND against 0xff. This saves us ~480 gates in total.
+
+```rust
+fn main(num: u72) -> pub [u8; 8] {
+    let mut out: [u8; 8] = [0; 8];
+    for i in 0..8 {
+        out[i] = (num >> (56 - (i * 8)) as u8;
+    }
+
+    out
+}
+```
+
+```
+Total ACIR opcodes generated for language PLONKCSat { width: 3 }: 75
+Backend circuit size: 3143
+```
+
+Those are some nice savings already but we can do better. This code is all constrained so we're proving every step of calculating out using num, but we don't actually care about how we calculate this, just that it's correct. This is where brillig comes in.
+
+It turns out that truncating a u72 into a u8 is hard to do inside a snark, each time we do as u8 we lay down 4 ACIR opcodes which get converted into multiple gates. It's actually much easier to calculate num from out than the other way around. All we need to do is multiply each element of out by a constant and add them all together, both relatively easy operations inside a snark.
+
+We can then run `u72_to_u8` as unconstrained brillig code in order to calculate out, then use that result in our constrained function and assert that if we were to do the reverse calculation we'd get back num. This looks a little like the below:
+
+```rust
+fn main(num: u72) -> pub [u8; 8] {
+    let out = unsafe { 
+        u72_to_u8(num) 
+    };
+
+    let mut reconstructed_num: u72 = 0;
+    for i in 0..8 {
+        reconstructed_num += (out[i] as u72 << (56 - (8 * i)));
+    }
+    assert(num == reconstructed_num);
+    out
+}
+
+unconstrained fn u72_to_u8(num: u72) -> [u8; 8] {
+    let mut out: [u8; 8] = [0; 8];
+    for i in 0..8 {
+        out[i] = (num >> (56 - (i * 8))) as u8;
+    }
+    out
+}
+```
+
+```
+Total ACIR opcodes generated for language PLONKCSat { width: 3 }: 78
+Backend circuit size: 2902
+```
+
+This ends up taking off another ~250 gates from our circuit! We've ended up with more ACIR opcodes than before but they're easier for the backend to prove (resulting in fewer gates).
+
+Note that in order to invoke unconstrained functions we need to wrap them in an `unsafe` block,
+to make it clear that the call is unconstrained.
+
+Generally we want to use brillig whenever there's something that's easy to verify but hard to compute within the circuit. For example, if you wanted to calculate a square root of a number it'll be a much better idea to calculate this in brillig and then assert that if you square the result you get back your number.
+
+## Break and Continue
+
+In addition to loops over runtime bounds, `break` and `continue` are also available in unconstrained code. See [break and continue](../concepts/control_flow.md#break-and-continue)
diff --git a/docs/versioned_docs/version-v0.38.0/noir/modules_packages_crates/_category_.json b/docs/versioned_docs/version-v0.38.0/noir/modules_packages_crates/_category_.json
new file mode 100644
index 00000000000..1debcfe7675
--- /dev/null
+++ b/docs/versioned_docs/version-v0.38.0/noir/modules_packages_crates/_category_.json
@@ -0,0 +1,6 @@
+{
+    "label": "Modules, Packages and Crates",
+    "position": 2,
+    "collapsible": true,
+    "collapsed": true
+}
diff --git a/docs/versioned_docs/version-v0.38.0/noir/modules_packages_crates/crates_and_packages.md b/docs/versioned_docs/version-v0.38.0/noir/modules_packages_crates/crates_and_packages.md
new file mode 100644
index 00000000000..95ee9f52ab2
--- /dev/null
+++ b/docs/versioned_docs/version-v0.38.0/noir/modules_packages_crates/crates_and_packages.md
@@ -0,0 +1,43 @@
+---
+title: Crates and Packages
+description: Learn how to use Crates and Packages in your Noir project
+keywords: [Nargo, dependencies, package management, crates, package]
+sidebar_position: 0
+---
+
+## Crates
+
+A crate is the smallest amount of code that the Noir compiler considers at a time.
+Crates can contain modules, and the modules may be defined in other files that get compiled with the crate, as we’ll see in the coming sections.
+
+### Crate Types
+
+A Noir crate can come in several forms: binaries, libraries or contracts.
+
+#### Binaries
+
+_Binary crates_ are programs which you can compile to an ACIR circuit which you can then create proofs against. Each must have a function called `main` that defines the ACIR circuit which is to be proved.
+
+#### Libraries
+
+_Library crates_ don't have a `main` function and they don't compile down to ACIR. Instead they define functionality intended to be shared with multiple projects, and eventually included in a binary crate.
+
+#### Contracts
+
+Contract crates are similar to binary crates in that they compile to ACIR which you can create proofs against. They are different in that they do not have a single `main` function, but are a collection of functions to be deployed to the [Aztec network](https://aztec.network). You can learn more about the technical details of Aztec in the [monorepo](https://github.com/AztecProtocol/aztec-packages) or contract [examples](https://github.com/AztecProtocol/aztec-packages/tree/master/noir-projects/noir-contracts/contracts).
+
+### Crate Root
+
+Every crate has a root, which is the source file that the compiler starts, this is also known as the root module. The Noir compiler does not enforce any conditions on the name of the file which is the crate root, however if you are compiling via Nargo the crate root must be called `lib.nr` or `main.nr` for library or binary crates respectively.
+
+## Packages
+
+A Nargo _package_ is a collection of one of more crates that provides a set of functionality. A package must include a Nargo.toml file.
+
+A package _must_ contain either a library or a binary crate, but not both.
+
+### Differences from Cargo Packages
+
+One notable difference between Rust's Cargo and Noir's Nargo is that while Cargo allows a package to contain an unlimited number of binary crates and a single library crate, Nargo currently only allows a package to contain a single crate.
+
+In future this restriction may be lifted to allow a Nargo package to contain both a binary and library crate or multiple binary crates.
diff --git a/docs/versioned_docs/version-v0.38.0/noir/modules_packages_crates/dependencies.md b/docs/versioned_docs/version-v0.38.0/noir/modules_packages_crates/dependencies.md
new file mode 100644
index 00000000000..24e02de08fe
--- /dev/null
+++ b/docs/versioned_docs/version-v0.38.0/noir/modules_packages_crates/dependencies.md
@@ -0,0 +1,124 @@
+---
+title: Dependencies
+description:
+  Learn how to specify and manage dependencies in Nargo, allowing you to upload packages to GitHub
+  and use them easily in your project.
+keywords: [Nargo, dependencies, GitHub, package management, versioning]
+sidebar_position: 1
+---
+
+Nargo allows you to upload packages to GitHub and use them as dependencies.
+
+## Specifying a dependency
+
+Specifying a dependency requires a tag to a specific commit and the git url to the url containing
+the package.
+
+Currently, there are no requirements on the tag contents. If requirements are added, it would follow
+semver 2.0 guidelines.
+
+> Note: Without a `tag` , there would be no versioning and dependencies would change each time you
+> compile your project.
+
+For example, to add the [ecrecover-noir library](https://github.com/colinnielsen/ecrecover-noir) to your project, add it to `Nargo.toml`:
+
+```toml
+# Nargo.toml
+
+[dependencies]
+ecrecover = {tag = "v0.8.0", git = "https://github.com/colinnielsen/ecrecover-noir"}
+```
+
+If the module is in a subdirectory, you can define a subdirectory in your git repository, for example:
+
+```toml
+# Nargo.toml
+
+[dependencies]
+easy_private_token_contract = {tag ="v0.1.0-alpha62", git = "https://github.com/AztecProtocol/aztec-packages", directory = "noir-contracts/contracts/easy_private_token_contract"}
+```
+
+## Specifying a local dependency
+
+You can also specify dependencies that are local to your machine.
+
+For example, this file structure has a library and binary crate
+
+```tree
+├── binary_crate
+│   ├── Nargo.toml
+│   └── src
+│       └── main.nr
+└── lib_a
+    ├── Nargo.toml
+    └── src
+        └── lib.nr
+```
+
+Inside of the binary crate, you can specify:
+
+```toml
+# Nargo.toml
+
+[dependencies]
+lib_a = { path = "../lib_a" }
+```
+
+## Importing dependencies
+
+You can import a dependency to a Noir file using the following syntax. For example, to import the
+ecrecover-noir library and local lib_a referenced above:
+
+```rust
+use ecrecover;
+use lib_a;
+```
+
+You can also import only the specific parts of dependency that you want to use, like so:
+
+```rust
+use std::hash::sha256;
+use std::scalar_mul::fixed_base_embedded_curve;
+```
+
+Lastly, as demonstrated in the
+[elliptic curve example](../standard_library/cryptographic_primitives/ec_primitives.md#examples), you
+can import multiple items in the same line by enclosing them in curly braces:
+
+```rust
+use std::ec::tecurve::affine::{Curve, Point};
+```
+
+We don't have a way to consume libraries from inside a [workspace](./workspaces.md) as external dependencies right now.
+
+Inside a workspace, these are consumed as `{ path = "../to_lib" }` dependencies in Nargo.toml.
+
+## Dependencies of Dependencies
+
+Note that when you import a dependency, you also get access to all of the dependencies of that package.
+
+For example, the [phy_vector](https://github.com/resurgencelabs/phy_vector) library imports an [fraction](https://github.com/resurgencelabs/fraction) library. If you're importing the phy_vector library, then you can access the functions in fractions library like so:
+
+```rust
+use phy_vector;
+
+fn main(x : Field, y : pub Field) {
+  //...
+  let f = phy_vector::fraction::toFraction(true, 2, 1);
+  //...
+}
+```
+
+## Available Libraries
+
+Noir does not currently have an official package manager. You can find a list of available Noir libraries in the [awesome-noir repo here](https://github.com/noir-lang/awesome-noir#libraries).
+
+Some libraries that are available today include:
+
+- [Standard Library](https://github.com/noir-lang/noir/tree/master/noir_stdlib) - the Noir Standard Library
+- [Ethereum Storage Proof Verification](https://github.com/aragonzkresearch/noir-trie-proofs) - a library that contains the primitives necessary for RLP decoding (in the form of look-up table construction) and Ethereum state and storage proof verification (or verification of any trie proof involving 32-byte long keys)
+- [BigInt](https://github.com/shuklaayush/noir-bigint) - a library that provides a custom BigUint56 data type, allowing for computations on large unsigned integers
+- [ECrecover](https://github.com/colinnielsen/ecrecover-noir/tree/main) - a library to verify an ECDSA signature and return the source Ethereum address
+- [Sparse Merkle Tree Verifier](https://github.com/vocdoni/smtverifier-noir/tree/main) - a library for verification of sparse Merkle trees
+- [Signed Int](https://github.com/resurgencelabs/signed_int) - a library for accessing a custom Signed Integer data type, allowing access to negative numbers on Noir
+- [Fraction](https://github.com/resurgencelabs/fraction) - a library for accessing fractional number data type in Noir, allowing results that aren't whole numbers
diff --git a/docs/versioned_docs/version-v0.38.0/noir/modules_packages_crates/modules.md b/docs/versioned_docs/version-v0.38.0/noir/modules_packages_crates/modules.md
new file mode 100644
index 00000000000..14aa1f0579a
--- /dev/null
+++ b/docs/versioned_docs/version-v0.38.0/noir/modules_packages_crates/modules.md
@@ -0,0 +1,221 @@
+---
+title: Modules
+description:
+  Learn how to organize your files using modules in Noir, following the same convention as Rust's
+  module system. Examples included.
+keywords: [Noir, Rust, modules, organizing files, sub-modules]
+sidebar_position: 2
+---
+
+Noir's module system follows the same convention as the _newer_ version of Rust's module system.
+
+## Purpose of Modules
+
+Modules are used to organize files. Without modules all of your code would need to live in a single
+file. In Noir, the compiler does not automatically scan all of your files to detect modules. This
+must be done explicitly by the developer.
+
+## Examples
+
+### Importing a module in the crate root
+
+Filename : `src/main.nr`
+
+```rust
+mod foo;
+
+fn main() {
+    foo::hello_world();
+}
+```
+
+Filename : `src/foo.nr`
+
+```rust
+fn from_foo() {}
+```
+
+In the above snippet, the crate root is the `src/main.nr` file. The compiler sees the module
+declaration `mod foo` which prompts it to look for a foo.nr file.
+
+Visually this module hierarchy looks like the following :
+
+```
+crate
+ ├── main
+ │
+ └── foo
+      └── from_foo
+
+```
+
+The module filename may also be the name of the module as a directory with the contents in a 
+file named `mod.nr` within that directory. The above example can alternatively be expressed like this:
+
+Filename : `src/main.nr`
+
+```rust
+mod foo;
+
+fn main() {
+    foo::hello_world();
+}
+```
+
+Filename : `src/foo/mod.nr`
+
+```rust
+fn from_foo() {}
+```
+
+Note that it's an error to have both files `src/foo.nr` and `src/foo/mod.nr` in the filesystem.
+
+### Importing a module throughout the tree
+
+All modules are accessible from the `crate::` namespace.
+
+```
+crate
+ ├── bar
+ ├── foo
+ └── main
+
+```
+
+In the above snippet, if `bar` would like to use functions in `foo`, it can do so by `use crate::foo::function_name`.
+
+### Sub-modules
+
+Filename : `src/main.nr`
+
+```rust
+mod foo;
+
+fn main() {
+    foo::from_foo();
+}
+```
+
+Filename : `src/foo.nr`
+
+```rust
+mod bar;
+fn from_foo() {}
+```
+
+Filename : `src/foo/bar.nr`
+
+```rust
+fn from_bar() {}
+```
+
+In the above snippet, we have added an extra module to the module tree; `bar`. `bar` is a submodule
+of `foo` hence we declare bar in `foo.nr` with `mod bar`. Since `foo` is not the crate root, the
+compiler looks for the file associated with the `bar` module in `src/foo/bar.nr`
+
+Visually the module hierarchy looks as follows:
+
+```
+crate
+ ├── main
+ │
+ └── foo
+      ├── from_foo
+      └── bar
+           └── from_bar
+```
+
+Similar to importing a module in the crate root, modules can be placed in a `mod.nr` file, like this:
+
+Filename : `src/main.nr`
+
+```rust
+mod foo;
+
+fn main() {
+    foo::from_foo();
+}
+```
+
+Filename : `src/foo/mod.nr`
+
+```rust
+mod bar;
+fn from_foo() {}
+```
+
+Filename : `src/foo/bar/mod.nr`
+
+```rust
+fn from_bar() {}
+```
+
+### Referencing a parent module 
+
+Given a submodule, you can refer to its parent module using the `super` keyword.
+
+Filename : `src/main.nr`
+
+```rust
+mod foo;
+
+fn main() {
+    foo::from_foo();
+}
+```
+
+Filename : `src/foo.nr`
+
+```rust
+mod bar;
+
+fn from_foo() {}
+```
+
+Filename : `src/foo/bar.nr`
+
+```rust
+// Same as bar::from_foo
+use super::from_foo; 
+
+fn from_bar() {
+    from_foo();        // invokes super::from_foo(), which is bar::from_foo()
+    super::from_foo(); // also invokes bar::from_foo()
+}
+```
+
+### `use` visibility
+
+`use` declarations are private to the containing module, by default. However, like functions, 
+they can be marked as `pub` or `pub(crate)`. Such a use declaration serves to _re-export_ a name. 
+A public `use` declaration can therefore redirect some public name to a different target definition: 
+even a definition with a private canonical path, inside a different module.
+
+An example of re-exporting:
+
+```rust
+mod some_module {
+    pub use foo::{bar, baz};
+    mod foo {
+        pub fn bar() {}
+        pub fn baz() {}
+    }
+}
+
+fn main() {
+    some_module::bar();
+    some_module::baz();
+}
+```
+
+In this example, the module `some_module` re-exports two public names defined in `foo`.
+
+### Visibility
+
+By default, like functions, modules are private to the module (or crate) they exist in. You can use `pub`
+to make the module public or `pub(crate)` to make it public to just its crate:
+
+```rust
+// This module is now public and can be seen by other crates.
+pub mod foo;
+```
\ No newline at end of file
diff --git a/docs/versioned_docs/version-v0.38.0/noir/modules_packages_crates/workspaces.md b/docs/versioned_docs/version-v0.38.0/noir/modules_packages_crates/workspaces.md
new file mode 100644
index 00000000000..513497f12bf
--- /dev/null
+++ b/docs/versioned_docs/version-v0.38.0/noir/modules_packages_crates/workspaces.md
@@ -0,0 +1,42 @@
+---
+title: Workspaces
+sidebar_position: 3
+---
+
+Workspaces are a feature of nargo that allow you to manage multiple related Noir packages in a single repository. A workspace is essentially a group of related projects that share common build output directories and configurations.
+
+Each Noir project (with it's own Nargo.toml file) can be thought of as a package. Each package is expected to contain exactly one "named circuit", being the "name" defined in Nargo.toml with the program logic defined in `./src/main.nr`.
+
+For a project with the following structure:
+
+```tree
+├── crates
+│   ├── a
+│   │   ├── Nargo.toml
+│   │   └── Prover.toml
+│   │   └── src
+│   │       └── main.nr
+│   └── b
+│       ├── Nargo.toml
+│       └── Prover.toml
+│       └── src
+│           └── main.nr
+│
+└── Nargo.toml
+```
+
+You can define a workspace in Nargo.toml like so:
+
+```toml
+[workspace]
+members = ["crates/a", "crates/b"]
+default-member = "crates/a"
+```
+
+`members` indicates which packages are included in the workspace. As such, all member packages of a workspace will be processed when the `--workspace` flag is used with various commands or if a `default-member` is not specified.
+
+`default-member` indicates which package various commands process by default.
+
+Libraries can be defined in a workspace. Inside a workspace, these are consumed as `{ path = "../to_lib" }` dependencies in Nargo.toml.
+
+Inside a workspace, these are consumed as `{ path = "../to_lib" }` dependencies in Nargo.toml.
diff --git a/docs/versioned_docs/version-v0.38.0/noir/standard_library/_category_.json b/docs/versioned_docs/version-v0.38.0/noir/standard_library/_category_.json
new file mode 100644
index 00000000000..af04c0933fd
--- /dev/null
+++ b/docs/versioned_docs/version-v0.38.0/noir/standard_library/_category_.json
@@ -0,0 +1,6 @@
+{
+    "label": "Standard Library",
+    "position": 1,
+    "collapsible": true,
+    "collapsed": true
+}
diff --git a/docs/versioned_docs/version-v0.38.0/noir/standard_library/bigint.md b/docs/versioned_docs/version-v0.38.0/noir/standard_library/bigint.md
new file mode 100644
index 00000000000..05c3011634f
--- /dev/null
+++ b/docs/versioned_docs/version-v0.38.0/noir/standard_library/bigint.md
@@ -0,0 +1,127 @@
+---
+title: Big Integers
+description: How to use big integers from Noir standard library
+keywords:
+  [
+    Big Integer,
+    Noir programming language,
+    Noir libraries,
+  ]
+---
+
+The BigInt module in the standard library exposes some class of integers which do not fit (well) into a Noir native field. It implements modulo arithmetic, modulo a 'big' prime number.
+
+:::note
+
+The module can currently be considered as `Field`s with fixed modulo sizes used by a set of elliptic curves, in addition to just the native curve. [More work](https://github.com/noir-lang/noir/issues/510) is needed to achieve arbitrarily sized big integers.
+
+:::note
+
+`nargo` can be built with `--profile release-pedantic` to enable extra overflow checks which may affect `BigInt` results in some cases.
+Consider the [`noir-bignum`](https://github.com/noir-lang/noir-bignum) library for an optimized alternative approach.
+
+:::
+
+Currently 6 classes of integers (i.e 'big' prime numbers) are available in the module, namely:
+
+- BN254 Fq: Bn254Fq
+- BN254 Fr: Bn254Fr
+- Secp256k1 Fq: Secpk1Fq
+- Secp256k1 Fr: Secpk1Fr
+- Secp256r1 Fr: Secpr1Fr
+- Secp256r1 Fq: Secpr1Fq
+
+Where XXX Fq and XXX Fr denote respectively the order of the base and scalar field of the (usual) elliptic curve XXX.
+For instance the big integer 'Secpk1Fq' in the standard library refers to integers modulo $2^{256}-2^{32}-977$.
+
+Feel free to explore the source code for the other primes:
+
+```rust title="big_int_definition" showLineNumbers 
+pub struct BigInt {
+    pointer: u32,
+    modulus: u32,
+}
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/bigint.nr#L28-L33" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/bigint.nr#L28-L33</a></sub></sup>
+
+
+## Example usage
+
+A common use-case is when constructing a big integer from its bytes representation, and performing arithmetic operations on it:
+
+```rust title="big_int_example" showLineNumbers 
+fn big_int_example(x: u8, y: u8) {
+    let a = Secpk1Fq::from_le_bytes(&[x, y, 0, 45, 2]);
+    let b = Secpk1Fq::from_le_bytes(&[y, x, 9]);
+    let c = (a + b) * b / a;
+    let d = c.to_le_bytes();
+    println(d[0]);
+}
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/test_programs/execution_success/bigint/src/main.nr#L74-L82" target="_blank" rel="noopener noreferrer">Source code: test_programs/execution_success/bigint/src/main.nr#L74-L82</a></sub></sup>
+
+
+## Methods
+
+The available operations for each big integer are:
+
+### from_le_bytes
+
+Construct a big integer from its little-endian bytes representation. Example:
+
+```rust
+ // Construct a big integer from a slice of bytes
+ let a = Secpk1Fq::from_le_bytes(&[x, y, 0, 45, 2]);
+ // Construct a big integer from an array of 32 bytes
+ let a = Secpk1Fq::from_le_bytes_32([1;32]);
+ ```
+
+Sure, here's the formatted version of the remaining methods:
+
+### to_le_bytes
+
+Return the little-endian bytes representation of a big integer. Example:
+
+```rust
+let bytes = a.to_le_bytes();
+```
+
+### add
+
+Add two big integers. Example:
+
+```rust
+let sum = a + b;
+```
+
+### sub
+
+Subtract two big integers. Example:
+
+```rust
+let difference = a - b;
+```
+
+### mul
+
+Multiply two big integers. Example:
+
+```rust
+let product = a * b;
+```
+
+### div
+
+Divide two big integers. Note that division is field division and not euclidean division. Example:
+
+```rust
+let quotient = a / b;
+```
+
+### eq
+
+Compare two big integers. Example:
+
+```rust
+let are_equal = a == b;
+```
diff --git a/docs/versioned_docs/version-v0.38.0/noir/standard_library/black_box_fns.md b/docs/versioned_docs/version-v0.38.0/noir/standard_library/black_box_fns.md
new file mode 100644
index 00000000000..d6079ab182c
--- /dev/null
+++ b/docs/versioned_docs/version-v0.38.0/noir/standard_library/black_box_fns.md
@@ -0,0 +1,32 @@
+---
+title: Black Box Functions
+description: Black box functions are functions in Noir that rely on backends implementing support for specialized constraints.
+keywords: [noir, black box functions]
+---
+
+Black box functions are functions in Noir that rely on backends implementing support for specialized constraints. This makes certain zk-snark unfriendly computations cheaper than if they were implemented in Noir.
+
+The ACVM spec defines a set of blackbox functions which backends will be expected to implement. This allows backends to use optimized implementations of these constraints if they have them, however they may also fallback to less efficient naive implementations if not.
+
+## Function list
+
+Here is a list of the current black box functions:
+
+- [AES128](./cryptographic_primitives/ciphers.mdx#aes128)
+- [SHA256](./cryptographic_primitives/hashes.mdx#sha256)
+- [Schnorr signature verification](./cryptographic_primitives/schnorr.mdx)
+- [Blake2s](./cryptographic_primitives/hashes.mdx#blake2s)
+- [Blake3](./cryptographic_primitives/hashes.mdx#blake3)
+- [Pedersen Hash](./cryptographic_primitives/hashes.mdx#pedersen_hash)
+- [Pedersen Commitment](./cryptographic_primitives/hashes.mdx#pedersen_commitment)
+- [ECDSA signature verification](./cryptographic_primitives/ecdsa_sig_verification.mdx)
+- [Embedded curve operations (MSM, addition, ...)](./cryptographic_primitives/embedded_curve_ops.mdx)
+- AND
+- XOR
+- RANGE
+- [Keccak256](./cryptographic_primitives/hashes.mdx#keccak256)
+- [Recursive proof verification](./recursion.mdx)
+
+Most black box functions are included as part of the Noir standard library, however `AND`, `XOR` and `RANGE` are used as part of the Noir language syntax. For instance, using the bitwise operator `&` will invoke the `AND` black box function.
+
+You can view the black box functions defined in the ACVM code [here](https://github.com/noir-lang/noir/blob/master/acvm-repo/acir/src/circuit/black_box_functions.rs).
diff --git a/docs/versioned_docs/version-v0.38.0/noir/standard_library/bn254.md b/docs/versioned_docs/version-v0.38.0/noir/standard_library/bn254.md
new file mode 100644
index 00000000000..3294f005dbb
--- /dev/null
+++ b/docs/versioned_docs/version-v0.38.0/noir/standard_library/bn254.md
@@ -0,0 +1,46 @@
+---
+title: Bn254 Field Library
+---
+
+Noir provides a module in standard library with some optimized functions for bn254 Fr in `std::field::bn254`.
+
+## decompose
+
+```rust
+fn decompose(x: Field) -> (Field, Field) {}
+```
+
+Decomposes a single field into two fields, low and high. The low field contains the lower 16 bytes of the input field and the high field contains the upper 16 bytes of the input field. Both field results are range checked to 128 bits.
+
+
+## assert_gt
+
+```rust
+fn assert_gt(a: Field, b: Field) {}
+```
+
+Asserts that a > b. This will generate less constraints than using `assert(gt(a, b))`.
+
+## assert_lt
+
+```rust
+fn assert_lt(a: Field, b: Field) {}
+```
+
+Asserts that a < b. This will generate less constraints than using `assert(lt(a, b))`.
+
+## gt
+
+```rust
+fn gt(a: Field, b: Field) -> bool  {}
+```
+
+Returns true if a > b.
+
+## lt
+
+```rust
+fn lt(a: Field, b: Field) -> bool  {}
+```
+
+Returns true if a < b.
\ No newline at end of file
diff --git a/docs/versioned_docs/version-v0.38.0/noir/standard_library/containers/boundedvec.md b/docs/versioned_docs/version-v0.38.0/noir/standard_library/containers/boundedvec.md
new file mode 100644
index 00000000000..509b214bf3a
--- /dev/null
+++ b/docs/versioned_docs/version-v0.38.0/noir/standard_library/containers/boundedvec.md
@@ -0,0 +1,419 @@
+---
+title: Bounded Vectors
+keywords: [noir, vector, bounded vector, slice]
+sidebar_position: 1
+---
+
+A `BoundedVec<T, MaxLen>` is a growable storage similar to a `Vec<T>` except that it
+is bounded with a maximum possible length. Unlike `Vec`, `BoundedVec` is not implemented
+via slices and thus is not subject to the same restrictions slices are (notably, nested
+slices - and thus nested vectors as well - are disallowed).
+
+Since a BoundedVec is backed by a normal array under the hood, growing the BoundedVec by
+pushing an additional element is also more efficient - the length only needs to be increased
+by one.
+
+For these reasons `BoundedVec<T, N>` should generally be preferred over `Vec<T>` when there
+is a reasonable maximum bound that can be placed on the vector.
+
+Example:
+
+```rust
+let mut vector: BoundedVec<Field, 10> = BoundedVec::new();
+for i in 0..5 {
+    vector.push(i);
+}
+assert(vector.len() == 5);
+assert(vector.max_len() == 10);
+```
+
+## Methods
+
+### new
+
+```rust
+pub fn new() -> Self
+```
+
+Creates a new, empty vector of length zero.
+
+Since this container is backed by an array internally, it still needs an initial value
+to give each element. To resolve this, each element is zeroed internally. This value
+is guaranteed to be inaccessible unless `get_unchecked` is used.
+
+Example:
+
+```rust
+let empty_vector: BoundedVec<Field, 10> = BoundedVec::new();
+assert(empty_vector.len() == 0);
+```
+
+Note that whenever calling `new` the maximum length of the vector should always be specified
+via a type signature:
+
+```rust title="new_example" showLineNumbers 
+fn good() -> BoundedVec<Field, 10> {
+    // Ok! MaxLen is specified with a type annotation
+    let v1: BoundedVec<Field, 3> = BoundedVec::new();
+    let v2 = BoundedVec::new();
+
+    // Ok! MaxLen is known from the type of `good`'s return value
+    v2
+}
+
+fn bad() {
+    // Error: Type annotation needed
+    // The compiler can't infer `MaxLen` from this code.
+    let mut v3 = BoundedVec::new();
+    v3.push(5);
+}
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/test_programs/noir_test_success/bounded_vec/src/main.nr#L11-L27" target="_blank" rel="noopener noreferrer">Source code: test_programs/noir_test_success/bounded_vec/src/main.nr#L11-L27</a></sub></sup>
+
+
+This defaulting of `MaxLen` (and numeric generics in general) to zero may change in future noir versions
+but for now make sure to use type annotations when using bounded vectors. Otherwise, you will receive a constraint failure at runtime when the vec is pushed to.
+
+### get
+
+```rust
+pub fn get(self, index: u64) -> T {
+```
+
+Retrieves an element from the vector at the given index, starting from zero.
+
+If the given index is equal to or greater than the length of the vector, this
+will issue a constraint failure.
+
+Example:
+
+```rust
+fn foo<N>(v: BoundedVec<u32, N>) {
+    let first = v.get(0);
+    let last = v.get(v.len() - 1);
+    assert(first != last);
+}
+```
+
+### get_unchecked
+
+```rust
+pub fn get_unchecked(self, index: u64) -> T {
+```
+
+Retrieves an element from the vector at the given index, starting from zero, without
+performing a bounds check.
+
+Since this function does not perform a bounds check on length before accessing the element,
+it is unsafe! Use at your own risk!
+
+Example:
+
+```rust title="get_unchecked_example" showLineNumbers 
+fn sum_of_first_three<let N: u32>(v: BoundedVec<u32, N>) -> u32 {
+    // Always ensure the length is larger than the largest
+    // index passed to get_unchecked
+    assert(v.len() > 2);
+    let first = v.get_unchecked(0);
+    let second = v.get_unchecked(1);
+    let third = v.get_unchecked(2);
+    first + second + third
+}
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/test_programs/noir_test_success/bounded_vec/src/main.nr#L54-L64" target="_blank" rel="noopener noreferrer">Source code: test_programs/noir_test_success/bounded_vec/src/main.nr#L54-L64</a></sub></sup>
+
+
+### set
+
+```rust
+pub fn set(&mut self: Self, index: u64, value: T) {
+```
+
+Writes an element to the vector at the given index, starting from zero.
+
+If the given index is equal to or greater than the length of the vector, this will issue a constraint failure.
+
+Example:
+
+```rust
+fn foo<N>(v: BoundedVec<u32, N>) {
+    let first = v.get(0);
+    assert(first != 42);
+    v.set(0, 42);
+    let new_first = v.get(0);
+    assert(new_first == 42);
+}
+```
+
+### set_unchecked
+
+```rust
+pub fn set_unchecked(&mut self: Self, index: u64, value: T) -> T {
+```
+
+Writes an element to the vector at the given index, starting from zero, without performing a bounds check.
+
+Since this function does not perform a bounds check on length before accessing the element, it is unsafe! Use at your own risk!
+
+Example:
+
+```rust title="set_unchecked_example" showLineNumbers 
+fn set_unchecked_example() {
+    let mut vec: BoundedVec<u32, 5> = BoundedVec::new();
+    vec.extend_from_array([1, 2]);
+
+    // Here we're safely writing within the valid range of `vec`
+    // `vec` now has the value [42, 2]
+    vec.set_unchecked(0, 42);
+
+    // We can then safely read this value back out of `vec`.
+    // Notice that we use the checked version of `get` which would prevent reading unsafe values.
+    assert_eq(vec.get(0), 42);
+
+    // We've now written past the end of `vec`.
+    // As this index is still within the maximum potential length of `v`,
+    // it won't cause a constraint failure.
+    vec.set_unchecked(2, 42);
+    println(vec);
+
+    // This will write past the end of the maximum potential length of `vec`,
+    // it will then trigger a constraint failure.
+    vec.set_unchecked(5, 42);
+    println(vec);
+}
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/test_programs/noir_test_success/bounded_vec/src/main.nr#L67-L91" target="_blank" rel="noopener noreferrer">Source code: test_programs/noir_test_success/bounded_vec/src/main.nr#L67-L91</a></sub></sup>
+
+
+
+### push
+
+```rust
+pub fn push(&mut self, elem: T) {
+```
+
+Pushes an element to the end of the vector. This increases the length
+of the vector by one.
+
+Panics if the new length of the vector will be greater than the max length.
+
+Example:
+
+```rust title="bounded-vec-push-example" showLineNumbers 
+let mut v: BoundedVec<Field, 2> = BoundedVec::new();
+
+    v.push(1);
+    v.push(2);
+
+    // Panics with failed assertion "push out of bounds"
+    v.push(3);
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/test_programs/noir_test_success/bounded_vec/src/main.nr#L95-L103" target="_blank" rel="noopener noreferrer">Source code: test_programs/noir_test_success/bounded_vec/src/main.nr#L95-L103</a></sub></sup>
+
+
+### pop
+
+```rust
+pub fn pop(&mut self) -> T
+```
+
+Pops the element at the end of the vector. This will decrease the length
+of the vector by one.
+
+Panics if the vector is empty.
+
+Example:
+
+```rust title="bounded-vec-pop-example" showLineNumbers 
+let mut v: BoundedVec<Field, 2> = BoundedVec::new();
+    v.push(1);
+    v.push(2);
+
+    let two = v.pop();
+    let one = v.pop();
+
+    assert(two == 2);
+    assert(one == 1);
+    // error: cannot pop from an empty vector
+    // let _ = v.pop();
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/test_programs/noir_test_success/bounded_vec/src/main.nr#L108-L120" target="_blank" rel="noopener noreferrer">Source code: test_programs/noir_test_success/bounded_vec/src/main.nr#L108-L120</a></sub></sup>
+
+
+### len
+
+```rust
+pub fn len(self) -> u64 {
+```
+
+Returns the current length of this vector
+
+Example:
+
+```rust title="bounded-vec-len-example" showLineNumbers 
+let mut v: BoundedVec<Field, 4> = BoundedVec::new();
+    assert(v.len() == 0);
+
+    v.push(100);
+    assert(v.len() == 1);
+
+    v.push(200);
+    v.push(300);
+    v.push(400);
+    assert(v.len() == 4);
+
+    let _ = v.pop();
+    let _ = v.pop();
+    assert(v.len() == 2);
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/test_programs/noir_test_success/bounded_vec/src/main.nr#L125-L140" target="_blank" rel="noopener noreferrer">Source code: test_programs/noir_test_success/bounded_vec/src/main.nr#L125-L140</a></sub></sup>
+
+
+### max_len
+
+```rust
+pub fn max_len(_self: BoundedVec<T, MaxLen>) -> u64 {
+```
+
+Returns the maximum length of this vector. This is always
+equal to the `MaxLen` parameter this vector was initialized with.
+
+Example:
+
+```rust title="bounded-vec-max-len-example" showLineNumbers 
+let mut v: BoundedVec<Field, 5> = BoundedVec::new();
+
+    assert(v.max_len() == 5);
+    v.push(10);
+    assert(v.max_len() == 5);
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/test_programs/noir_test_success/bounded_vec/src/main.nr#L145-L151" target="_blank" rel="noopener noreferrer">Source code: test_programs/noir_test_success/bounded_vec/src/main.nr#L145-L151</a></sub></sup>
+
+
+### storage
+
+```rust
+pub fn storage(self) -> [T; MaxLen] {
+```
+
+Returns the internal array within this vector.
+Since arrays in Noir are immutable, mutating the returned storage array will not mutate
+the storage held internally by this vector.
+
+Note that uninitialized elements may be zeroed out!
+
+Example:
+
+```rust title="bounded-vec-storage-example" showLineNumbers 
+let mut v: BoundedVec<Field, 5> = BoundedVec::new();
+
+    assert(v.storage() == [0, 0, 0, 0, 0]);
+
+    v.push(57);
+    assert(v.storage() == [57, 0, 0, 0, 0]);
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/test_programs/noir_test_success/bounded_vec/src/main.nr#L156-L163" target="_blank" rel="noopener noreferrer">Source code: test_programs/noir_test_success/bounded_vec/src/main.nr#L156-L163</a></sub></sup>
+
+
+### extend_from_array
+
+```rust
+pub fn extend_from_array<Len>(&mut self, array: [T; Len])
+```
+
+Pushes each element from the given array to this vector.
+
+Panics if pushing each element would cause the length of this vector
+to exceed the maximum length.
+
+Example:
+
+```rust title="bounded-vec-extend-from-array-example" showLineNumbers 
+let mut vec: BoundedVec<Field, 3> = BoundedVec::new();
+    vec.extend_from_array([2, 4]);
+
+    assert(vec.len == 2);
+    assert(vec.get(0) == 2);
+    assert(vec.get(1) == 4);
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/test_programs/noir_test_success/bounded_vec/src/main.nr#L168-L175" target="_blank" rel="noopener noreferrer">Source code: test_programs/noir_test_success/bounded_vec/src/main.nr#L168-L175</a></sub></sup>
+
+
+### extend_from_bounded_vec
+
+```rust
+pub fn extend_from_bounded_vec<Len>(&mut self, vec: BoundedVec<T, Len>)
+```
+
+Pushes each element from the other vector to this vector. The length of
+the other vector is left unchanged.
+
+Panics if pushing each element would cause the length of this vector
+to exceed the maximum length.
+
+Example:
+
+```rust title="bounded-vec-extend-from-bounded-vec-example" showLineNumbers 
+let mut v1: BoundedVec<Field, 5> = BoundedVec::new();
+    let mut v2: BoundedVec<Field, 7> = BoundedVec::new();
+
+    v2.extend_from_array([1, 2, 3]);
+    v1.extend_from_bounded_vec(v2);
+
+    assert(v1.storage() == [1, 2, 3, 0, 0]);
+    assert(v2.storage() == [1, 2, 3, 0, 0, 0, 0]);
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/test_programs/noir_test_success/bounded_vec/src/main.nr#L180-L189" target="_blank" rel="noopener noreferrer">Source code: test_programs/noir_test_success/bounded_vec/src/main.nr#L180-L189</a></sub></sup>
+
+
+### from_array
+
+```rust
+pub fn from_array<Len>(array: [T; Len]) -> Self
+```
+
+Creates a new vector, populating it with values derived from an array input. 
+The maximum length of the vector is determined based on the type signature.
+
+Example:
+```rust
+let bounded_vec: BoundedVec<Field, 10> = BoundedVec::from_array([1, 2, 3])
+```
+
+### map
+
+```rust
+pub fn map<U, Env>(self, f: fn[Env](T) -> U) -> BoundedVec<U, MaxLen>
+```
+
+Creates a new vector of equal size by calling a closure on each element in this vector.  
+
+Example:
+
+```rust title="bounded-vec-map-example" showLineNumbers 
+let vec: BoundedVec<u32, 4> = BoundedVec::from_array([1, 2, 3, 4]);
+            let result = vec.map(|value| value * 2);
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/collections/bounded_vec.nr#L495-L498" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/collections/bounded_vec.nr#L495-L498</a></sub></sup>
+
+
+### any
+
+```rust
+pub fn any<Env>(self, predicate: fn[Env](T) -> bool) -> bool
+```
+
+Returns true if the given predicate returns true for any element
+in this vector.
+
+Example:
+
+```rust title="bounded-vec-any-example" showLineNumbers 
+let mut v: BoundedVec<u32, 3> = BoundedVec::new();
+    v.extend_from_array([2, 4, 6]);
+
+    let all_even = !v.any(|elem: u32| elem % 2 != 0);
+    assert(all_even);
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/test_programs/noir_test_success/bounded_vec/src/main.nr#L256-L262" target="_blank" rel="noopener noreferrer">Source code: test_programs/noir_test_success/bounded_vec/src/main.nr#L256-L262</a></sub></sup>
+
diff --git a/docs/versioned_docs/version-v0.38.0/noir/standard_library/containers/hashmap.md b/docs/versioned_docs/version-v0.38.0/noir/standard_library/containers/hashmap.md
new file mode 100644
index 00000000000..395cc312705
--- /dev/null
+++ b/docs/versioned_docs/version-v0.38.0/noir/standard_library/containers/hashmap.md
@@ -0,0 +1,587 @@
+---
+title: HashMap
+keywords: [noir, map, hash, hashmap]
+sidebar_position: 1
+---
+
+`HashMap<Key, Value, MaxLen, Hasher>` is used to efficiently store and look up key-value pairs.
+
+`HashMap` is a bounded type which can store anywhere from zero to `MaxLen` total elements.
+Note that due to hash collisions, the actual maximum number of elements stored by any particular
+hashmap is likely lower than `MaxLen`. This is true even with cryptographic hash functions since
+every hash value will be performed modulo `MaxLen`.
+
+Example:
+
+```rust
+// Create a mapping from Fields to u32s with a maximum length of 12
+// using a poseidon2 hasher
+use std::hash::poseidon2::Poseidon2Hasher;
+let mut map: HashMap<Field, u32, 12, BuildHasherDefault<Poseidon2Hasher>> = HashMap::default();
+
+map.insert(1, 2);
+map.insert(3, 4);
+
+let two = map.get(1).unwrap();
+```
+
+## Methods
+
+### default
+
+```rust title="default" showLineNumbers 
+impl<K, V, let N: u32, B, H> Default for HashMap<K, V, N, B>
+where
+    B: BuildHasher<H> + Default,
+    H: Hasher + Default,
+{
+    /// Constructs an empty HashMap.
+    ///
+    /// Example:
+    ///
+    /// ```noir
+    /// let hashmap: HashMap<u8, u32, 10, BuildHasherDefault<Poseidon2Hasher>> = HashMap::default();
+    /// assert(hashmap.is_empty());
+    /// ```
+    fn default() -> Self {
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/collections/map.nr#L681-L696" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/collections/map.nr#L681-L696</a></sub></sup>
+
+
+Creates a fresh, empty HashMap.
+
+When using this function, always make sure to specify the maximum size of the hash map.
+
+This is the same `default` from the `Default` implementation given further below. It is
+repeated here for convenience since it is the recommended way to create a hashmap.
+
+Example:
+
+```rust title="default_example" showLineNumbers 
+let hashmap: HashMap<u8, u32, 10, BuildHasherDefault<Poseidon2Hasher>> = HashMap::default();
+    assert(hashmap.is_empty());
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/test_programs/execution_success/hashmap/src/main.nr#L207-L210" target="_blank" rel="noopener noreferrer">Source code: test_programs/execution_success/hashmap/src/main.nr#L207-L210</a></sub></sup>
+
+
+Because `HashMap` has so many generic arguments that are likely to be the same throughout
+your program, it may be helpful to create a type alias:
+
+```rust title="type_alias" showLineNumbers 
+type MyMap = HashMap<u8, u32, 10, BuildHasherDefault<Poseidon2Hasher>>;
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/test_programs/execution_success/hashmap/src/main.nr#L201-L203" target="_blank" rel="noopener noreferrer">Source code: test_programs/execution_success/hashmap/src/main.nr#L201-L203</a></sub></sup>
+
+
+### with_hasher
+
+```rust title="with_hasher" showLineNumbers 
+pub fn with_hasher<H>(_build_hasher: B) -> Self
+    where
+        B: BuildHasher<H>,
+    {
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/collections/map.nr#L103-L108" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/collections/map.nr#L103-L108</a></sub></sup>
+
+
+Creates a hashmap with an existing `BuildHasher`. This can be used to ensure multiple
+hashmaps are created with the same hasher instance.
+
+Example:
+
+```rust title="with_hasher_example" showLineNumbers 
+let my_hasher: BuildHasherDefault<Poseidon2Hasher> = Default::default();
+    let hashmap: HashMap<u8, u32, 10, BuildHasherDefault<Poseidon2Hasher>> =
+        HashMap::with_hasher(my_hasher);
+    assert(hashmap.is_empty());
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/test_programs/execution_success/hashmap/src/main.nr#L211-L216" target="_blank" rel="noopener noreferrer">Source code: test_programs/execution_success/hashmap/src/main.nr#L211-L216</a></sub></sup>
+
+
+### get
+
+```rust title="get" showLineNumbers 
+pub fn get<H>(self, key: K) -> Option<V>
+    where
+        K: Eq + Hash,
+        B: BuildHasher<H>,
+        H: Hasher,
+    {
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/collections/map.nr#L465-L472" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/collections/map.nr#L465-L472</a></sub></sup>
+
+
+Retrieves a value from the hashmap, returning `Option::none()` if it was not found.
+
+Example:
+
+```rust title="get_example" showLineNumbers 
+fn get_example(map: HashMap<Field, Field, 5, BuildHasherDefault<Poseidon2Hasher>>) {
+    let x = map.get(12);
+
+    if x.is_some() {
+        assert(x.unwrap() == 42);
+    }
+}
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/test_programs/execution_success/hashmap/src/main.nr#L296-L304" target="_blank" rel="noopener noreferrer">Source code: test_programs/execution_success/hashmap/src/main.nr#L296-L304</a></sub></sup>
+
+
+### insert
+
+```rust title="insert" showLineNumbers 
+pub fn insert<H>(&mut self, key: K, value: V)
+    where
+        K: Eq + Hash,
+        B: BuildHasher<H>,
+        H: Hasher,
+    {
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/collections/map.nr#L507-L514" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/collections/map.nr#L507-L514</a></sub></sup>
+
+
+Inserts a new key-value pair into the map. If the key was already in the map, its
+previous value will be overridden with the newly provided one.
+
+Example:
+
+```rust title="insert_example" showLineNumbers 
+let mut map: HashMap<Field, Field, 5, BuildHasherDefault<Poseidon2Hasher>> = HashMap::default();
+    map.insert(12, 42);
+    assert(map.len() == 1);
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/test_programs/execution_success/hashmap/src/main.nr#L217-L221" target="_blank" rel="noopener noreferrer">Source code: test_programs/execution_success/hashmap/src/main.nr#L217-L221</a></sub></sup>
+
+
+### remove
+
+```rust title="remove" showLineNumbers 
+pub fn remove<H>(&mut self, key: K)
+    where
+        K: Eq + Hash,
+        B: BuildHasher<H>,
+        H: Hasher,
+    {
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/collections/map.nr#L563-L570" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/collections/map.nr#L563-L570</a></sub></sup>
+
+
+Removes the given key-value pair from the map. If the key was not already present
+in the map, this does nothing.
+
+Example:
+
+```rust title="remove_example" showLineNumbers 
+map.remove(12);
+    assert(map.is_empty());
+
+    // If a key was not present in the map, remove does nothing
+    map.remove(12);
+    assert(map.is_empty());
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/test_programs/execution_success/hashmap/src/main.nr#L224-L231" target="_blank" rel="noopener noreferrer">Source code: test_programs/execution_success/hashmap/src/main.nr#L224-L231</a></sub></sup>
+
+
+### is_empty
+
+```rust title="is_empty" showLineNumbers 
+pub fn is_empty(self) -> bool {
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/collections/map.nr#L167-L169" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/collections/map.nr#L167-L169</a></sub></sup>
+
+
+True if the length of the hash map is empty.
+
+Example:
+
+```rust title="is_empty_example" showLineNumbers 
+assert(map.is_empty());
+
+    map.insert(1, 2);
+    assert(!map.is_empty());
+
+    map.remove(1);
+    assert(map.is_empty());
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/test_programs/execution_success/hashmap/src/main.nr#L232-L240" target="_blank" rel="noopener noreferrer">Source code: test_programs/execution_success/hashmap/src/main.nr#L232-L240</a></sub></sup>
+
+
+### len
+
+```rust title="len" showLineNumbers 
+pub fn len(self) -> u32 {
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/collections/map.nr#L424-L426" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/collections/map.nr#L424-L426</a></sub></sup>
+
+
+Returns the current length of this hash map.
+
+Example:
+
+```rust title="len_example" showLineNumbers 
+// This is equivalent to checking map.is_empty()
+    assert(map.len() == 0);
+
+    map.insert(1, 2);
+    map.insert(3, 4);
+    map.insert(5, 6);
+    assert(map.len() == 3);
+
+    // 3 was already present as a key in the hash map, so the length is unchanged
+    map.insert(3, 7);
+    assert(map.len() == 3);
+
+    map.remove(1);
+    assert(map.len() == 2);
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/test_programs/execution_success/hashmap/src/main.nr#L241-L256" target="_blank" rel="noopener noreferrer">Source code: test_programs/execution_success/hashmap/src/main.nr#L241-L256</a></sub></sup>
+
+
+### capacity
+
+```rust title="capacity" showLineNumbers 
+pub fn capacity(_self: Self) -> u32 {
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/collections/map.nr#L446-L448" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/collections/map.nr#L446-L448</a></sub></sup>
+
+
+Returns the maximum capacity of this hashmap. This is always equal to the capacity
+specified in the hashmap's type.
+
+Unlike hashmaps in general purpose programming languages, hashmaps in Noir have a
+static capacity that does not increase as the map grows larger. Thus, this capacity
+is also the maximum possible element count that can be inserted into the hashmap.
+Due to hash collisions (modulo the hashmap length), it is likely the actual maximum
+element count will be lower than the full capacity.
+
+Example:
+
+```rust title="capacity_example" showLineNumbers 
+let empty_map: HashMap<Field, Field, 42, BuildHasherDefault<Poseidon2Hasher>> =
+        HashMap::default();
+    assert(empty_map.len() == 0);
+    assert(empty_map.capacity() == 42);
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/test_programs/execution_success/hashmap/src/main.nr#L257-L262" target="_blank" rel="noopener noreferrer">Source code: test_programs/execution_success/hashmap/src/main.nr#L257-L262</a></sub></sup>
+
+
+### clear
+
+```rust title="clear" showLineNumbers 
+pub fn clear(&mut self) {
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/collections/map.nr#L123-L125" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/collections/map.nr#L123-L125</a></sub></sup>
+
+
+Clears the hashmap, removing all key-value pairs from it.
+
+Example:
+
+```rust title="clear_example" showLineNumbers 
+assert(!map.is_empty());
+    map.clear();
+    assert(map.is_empty());
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/test_programs/execution_success/hashmap/src/main.nr#L263-L267" target="_blank" rel="noopener noreferrer">Source code: test_programs/execution_success/hashmap/src/main.nr#L263-L267</a></sub></sup>
+
+
+### contains_key
+
+```rust title="contains_key" showLineNumbers 
+pub fn contains_key<H>(self, key: K) -> bool
+    where
+        K: Hash + Eq,
+        B: BuildHasher<H>,
+        H: Hasher,
+    {
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/collections/map.nr#L143-L150" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/collections/map.nr#L143-L150</a></sub></sup>
+
+
+True if the hashmap contains the given key. Unlike `get`, this will not also return
+the value associated with the key.
+
+Example:
+
+```rust title="contains_key_example" showLineNumbers 
+if map.contains_key(7) {
+        let value = map.get(7);
+        assert(value.is_some());
+    } else {
+        println("No value for key 7!");
+    }
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/test_programs/execution_success/hashmap/src/main.nr#L268-L275" target="_blank" rel="noopener noreferrer">Source code: test_programs/execution_success/hashmap/src/main.nr#L268-L275</a></sub></sup>
+
+
+### entries
+
+```rust title="entries" showLineNumbers 
+pub fn entries(self) -> BoundedVec<(K, V), N> {
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/collections/map.nr#L191-L193" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/collections/map.nr#L191-L193</a></sub></sup>
+
+
+Returns a vector of each key-value pair present in the hashmap.
+
+The length of the returned vector is always equal to the length of the hashmap.
+
+Example:
+
+```rust title="entries_example" showLineNumbers 
+let entries = map.entries();
+
+    // The length of a hashmap may not be compile-time known, so we
+    // need to loop over its capacity instead
+    for i in 0..map.capacity() {
+        if i < entries.len() {
+            let (key, value) = entries.get(i);
+            println(f"{key} -> {value}");
+        }
+    }
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/test_programs/execution_success/hashmap/src/main.nr#L307-L318" target="_blank" rel="noopener noreferrer">Source code: test_programs/execution_success/hashmap/src/main.nr#L307-L318</a></sub></sup>
+
+
+### keys
+
+```rust title="keys" showLineNumbers 
+pub fn keys(self) -> BoundedVec<K, N> {
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/collections/map.nr#L227-L229" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/collections/map.nr#L227-L229</a></sub></sup>
+
+
+Returns a vector of each key present in the hashmap.
+
+The length of the returned vector is always equal to the length of the hashmap.
+
+Example:
+
+```rust title="keys_example" showLineNumbers 
+let keys = map.keys();
+
+    for i in 0..keys.max_len() {
+        if i < keys.len() {
+            let key = keys.get_unchecked(i);
+            let value = map.get(key).unwrap_unchecked();
+            println(f"{key} -> {value}");
+        }
+    }
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/test_programs/execution_success/hashmap/src/main.nr#L319-L329" target="_blank" rel="noopener noreferrer">Source code: test_programs/execution_success/hashmap/src/main.nr#L319-L329</a></sub></sup>
+
+
+### values
+
+```rust title="values" showLineNumbers 
+pub fn values(self) -> BoundedVec<V, N> {
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/collections/map.nr#L262-L264" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/collections/map.nr#L262-L264</a></sub></sup>
+
+
+Returns a vector of each value present in the hashmap.
+
+The length of the returned vector is always equal to the length of the hashmap.
+
+Example:
+
+```rust title="values_example" showLineNumbers 
+let values = map.values();
+
+    for i in 0..values.max_len() {
+        if i < values.len() {
+            let value = values.get_unchecked(i);
+            println(f"Found value {value}");
+        }
+    }
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/test_programs/execution_success/hashmap/src/main.nr#L330-L339" target="_blank" rel="noopener noreferrer">Source code: test_programs/execution_success/hashmap/src/main.nr#L330-L339</a></sub></sup>
+
+
+### iter_mut
+
+```rust title="iter_mut" showLineNumbers 
+pub fn iter_mut<H>(&mut self, f: fn(K, V) -> (K, V))
+    where
+        K: Eq + Hash,
+        B: BuildHasher<H>,
+        H: Hasher,
+    {
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/collections/map.nr#L297-L304" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/collections/map.nr#L297-L304</a></sub></sup>
+
+
+Iterates through each key-value pair of the HashMap, setting each key-value pair to the
+result returned from the given function.
+
+Note that since keys can be mutated, the HashMap needs to be rebuilt as it is iterated
+through. If this is not desired, use `iter_values_mut` if only values need to be mutated,
+or `entries` if neither keys nor values need to be mutated.
+
+The iteration order is left unspecified. As a result, if two keys are mutated to become
+equal, which of the two values that will be present for the key in the resulting map is also unspecified.
+
+Example:
+
+```rust title="iter_mut_example" showLineNumbers 
+// Add 1 to each key in the map, and double the value associated with that key.
+    map.iter_mut(|k, v| (k + 1, v * 2));
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/test_programs/execution_success/hashmap/src/main.nr#L343-L346" target="_blank" rel="noopener noreferrer">Source code: test_programs/execution_success/hashmap/src/main.nr#L343-L346</a></sub></sup>
+
+
+### iter_keys_mut
+
+```rust title="iter_keys_mut" showLineNumbers 
+pub fn iter_keys_mut<H>(&mut self, f: fn(K) -> K)
+    where
+        K: Eq + Hash,
+        B: BuildHasher<H>,
+        H: Hasher,
+    {
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/collections/map.nr#L335-L342" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/collections/map.nr#L335-L342</a></sub></sup>
+
+
+Iterates through the HashMap, mutating each key to the result returned from
+the given function.
+
+Note that since keys can be mutated, the HashMap needs to be rebuilt as it is iterated
+through. If only iteration is desired and the keys are not intended to be mutated,
+prefer using `entries` instead.
+
+The iteration order is left unspecified. As a result, if two keys are mutated to become
+equal, which of the two values that will be present for the key in the resulting map is also unspecified.
+
+Example:
+
+```rust title="iter_keys_mut_example" showLineNumbers 
+// Double each key, leaving the value associated with that key untouched
+    map.iter_keys_mut(|k| k * 2);
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/test_programs/execution_success/hashmap/src/main.nr#L347-L350" target="_blank" rel="noopener noreferrer">Source code: test_programs/execution_success/hashmap/src/main.nr#L347-L350</a></sub></sup>
+
+
+### iter_values_mut
+
+```rust title="iter_values_mut" showLineNumbers 
+pub fn iter_values_mut(&mut self, f: fn(V) -> V) {
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/collections/map.nr#L367-L369" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/collections/map.nr#L367-L369</a></sub></sup>
+
+
+Iterates through the HashMap, applying the given function to each value and mutating the
+value to equal the result. This function is more efficient than `iter_mut` and `iter_keys_mut`
+because the keys are untouched and the underlying hashmap thus does not need to be reordered.
+
+Example:
+
+```rust title="iter_values_mut_example" showLineNumbers 
+// Halve each value
+    map.iter_values_mut(|v| v / 2);
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/test_programs/execution_success/hashmap/src/main.nr#L351-L354" target="_blank" rel="noopener noreferrer">Source code: test_programs/execution_success/hashmap/src/main.nr#L351-L354</a></sub></sup>
+
+
+### retain
+
+```rust title="retain" showLineNumbers 
+pub fn retain(&mut self, f: fn(K, V) -> bool) {
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/collections/map.nr#L388-L390" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/collections/map.nr#L388-L390</a></sub></sup>
+
+
+Retains only the key-value pairs for which the given function returns true.
+Any key-value pairs for which the function returns false will be removed from the map.
+
+Example:
+
+```rust title="retain_example" showLineNumbers 
+map.retain(|k, v| (k != 0) & (v != 0));
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/test_programs/execution_success/hashmap/src/main.nr#L279-L281" target="_blank" rel="noopener noreferrer">Source code: test_programs/execution_success/hashmap/src/main.nr#L279-L281</a></sub></sup>
+
+
+## Trait Implementations
+
+### default
+
+```rust title="default" showLineNumbers 
+impl<K, V, let N: u32, B, H> Default for HashMap<K, V, N, B>
+where
+    B: BuildHasher<H> + Default,
+    H: Hasher + Default,
+{
+    /// Constructs an empty HashMap.
+    ///
+    /// Example:
+    ///
+    /// ```noir
+    /// let hashmap: HashMap<u8, u32, 10, BuildHasherDefault<Poseidon2Hasher>> = HashMap::default();
+    /// assert(hashmap.is_empty());
+    /// ```
+    fn default() -> Self {
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/collections/map.nr#L681-L696" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/collections/map.nr#L681-L696</a></sub></sup>
+
+
+Constructs an empty HashMap.
+
+Example:
+
+```rust title="default_example" showLineNumbers 
+let hashmap: HashMap<u8, u32, 10, BuildHasherDefault<Poseidon2Hasher>> = HashMap::default();
+    assert(hashmap.is_empty());
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/test_programs/execution_success/hashmap/src/main.nr#L207-L210" target="_blank" rel="noopener noreferrer">Source code: test_programs/execution_success/hashmap/src/main.nr#L207-L210</a></sub></sup>
+
+
+### eq
+
+```rust title="eq" showLineNumbers 
+impl<K, V, let N: u32, B, H> Eq for HashMap<K, V, N, B>
+where
+    K: Eq + Hash,
+    V: Eq,
+    B: BuildHasher<H>,
+    H: Hasher,
+{
+    /// Checks if two HashMaps are equal.
+    ///
+    /// Example:
+    ///
+    /// ```noir
+    /// let mut map1: HashMap<Field, u64, 4, BuildHasherDefault<Poseidon2Hasher>> = HashMap::default();
+    /// let mut map2: HashMap<Field, u64, 4, BuildHasherDefault<Poseidon2Hasher>> = HashMap::default();
+    ///
+    /// map1.insert(1, 2);
+    /// map1.insert(3, 4);
+    ///
+    /// map2.insert(3, 4);
+    /// map2.insert(1, 2);
+    ///
+    /// assert(map1 == map2);
+    /// ```
+    fn eq(self, other: HashMap<K, V, N, B>) -> bool {
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/collections/map.nr#L629-L654" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/collections/map.nr#L629-L654</a></sub></sup>
+
+
+Checks if two HashMaps are equal.
+
+Example:
+
+```rust title="eq_example" showLineNumbers 
+let mut map1: HashMap<Field, u64, 4, BuildHasherDefault<Poseidon2Hasher>> = HashMap::default();
+    let mut map2: HashMap<Field, u64, 4, BuildHasherDefault<Poseidon2Hasher>> = HashMap::default();
+
+    map1.insert(1, 2);
+    map1.insert(3, 4);
+
+    map2.insert(3, 4);
+    map2.insert(1, 2);
+
+    assert(map1 == map2);
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/test_programs/execution_success/hashmap/src/main.nr#L282-L293" target="_blank" rel="noopener noreferrer">Source code: test_programs/execution_success/hashmap/src/main.nr#L282-L293</a></sub></sup>
+
diff --git a/docs/versioned_docs/version-v0.38.0/noir/standard_library/containers/index.md b/docs/versioned_docs/version-v0.38.0/noir/standard_library/containers/index.md
new file mode 100644
index 00000000000..ea84c6d5c21
--- /dev/null
+++ b/docs/versioned_docs/version-v0.38.0/noir/standard_library/containers/index.md
@@ -0,0 +1,5 @@
+---
+title: Containers
+description: Container types provided by Noir's standard library for storing and retrieving data
+keywords: [containers, data types, vec, hashmap]
+---
diff --git a/docs/versioned_docs/version-v0.38.0/noir/standard_library/containers/vec.mdx b/docs/versioned_docs/version-v0.38.0/noir/standard_library/containers/vec.mdx
new file mode 100644
index 00000000000..475011922f8
--- /dev/null
+++ b/docs/versioned_docs/version-v0.38.0/noir/standard_library/containers/vec.mdx
@@ -0,0 +1,170 @@
+---
+title: Vectors
+description: Delve into the Vec data type in Noir. Learn about its methods, practical examples, and best practices for using Vectors in your Noir code.
+keywords: [noir, vector type, methods, examples, dynamic arrays]
+sidebar_position: 6
+---
+
+import Experimental from '@site/src/components/Notes/_experimental.mdx';
+
+<Experimental />
+
+A vector is a collection type similar to Rust's `Vec<T>` type. In Noir, it is a convenient way to use slices as mutable arrays.
+
+Example:
+
+```rust
+let mut vector: Vec<Field> = Vec::new();
+for i in 0..5 {
+    vector.push(i);
+}
+assert(vector.len() == 5);
+```
+
+## Methods
+
+### new
+
+Creates a new, empty vector.
+
+```rust
+pub fn new() -> Self
+```
+
+Example:
+
+```rust
+let empty_vector: Vec<Field> = Vec::new();
+assert(empty_vector.len() == 0);
+```
+
+### from_slice
+
+Creates a vector containing each element from a given slice. Mutations to the resulting vector will not affect the original slice.
+
+```rust
+pub fn from_slice(slice: [T]) -> Self
+```
+
+Example:
+
+```rust
+let slice: [Field] = &[1, 2, 3];
+let vector_from_slice = Vec::from_slice(slice);
+assert(vector_from_slice.len() == 3);
+```
+
+### len
+
+Returns the number of elements in the vector.
+
+```rust
+pub fn len(self) -> Field
+```
+
+Example:
+
+```rust
+let empty_vector: Vec<Field> = Vec::new();
+assert(empty_vector.len() == 0);
+```
+
+### get
+
+Retrieves an element from the vector at a given index. Panics if the index points beyond the vector's end.
+
+```rust
+pub fn get(self, index: Field) -> T
+```
+
+Example:
+
+```rust
+let vector: Vec<Field> = Vec::from_slice(&[10, 20, 30]);
+assert(vector.get(1) == 20);
+```
+
+### set
+
+```rust
+pub fn set(&mut self: Self, index: u64, value: T) {
+```
+
+Writes an element to the vector at the given index, starting from zero.
+
+Panics if the index points beyond the vector's end.
+
+Example:
+
+```rust
+let vector: Vec<Field> = Vec::from_slice(&[10, 20, 30]);
+assert(vector.get(1) == 20);
+vector.set(1, 42);
+assert(vector.get(1) == 42);
+```
+
+### push
+
+Adds a new element to the vector's end, returning a new vector with a length one greater than the original unmodified vector.
+
+```rust
+pub fn push(&mut self, elem: T)
+```
+
+Example:
+
+```rust
+let mut vector: Vec<Field> = Vec::new();
+vector.push(10);
+assert(vector.len() == 1);
+```
+
+### pop
+
+Removes an element from the vector's end, returning a new vector with a length one less than the original vector, along with the removed element. Panics if the vector's length is zero.
+
+```rust
+pub fn pop(&mut self) -> T
+```
+
+Example:
+
+```rust
+let mut vector = Vec::from_slice(&[10, 20]);
+let popped_elem = vector.pop();
+assert(popped_elem == 20);
+assert(vector.len() == 1);
+```
+
+### insert
+
+Inserts an element at a specified index, shifting subsequent elements to the right.
+
+```rust
+pub fn insert(&mut self, index: Field, elem: T)
+```
+
+Example:
+
+```rust
+let mut vector = Vec::from_slice(&[10, 30]);
+vector.insert(1, 20);
+assert(vector.get(1) == 20);
+```
+
+### remove
+
+Removes an element at a specified index, shifting subsequent elements to the left, and returns the removed element.
+
+```rust
+pub fn remove(&mut self, index: Field) -> T
+```
+
+Example:
+
+```rust
+let mut vector = Vec::from_slice(&[10, 20, 30]);
+let removed_elem = vector.remove(1);
+assert(removed_elem == 20);
+assert(vector.len() == 2);
+```
diff --git a/docs/versioned_docs/version-v0.38.0/noir/standard_library/cryptographic_primitives/_category_.json b/docs/versioned_docs/version-v0.38.0/noir/standard_library/cryptographic_primitives/_category_.json
new file mode 100644
index 00000000000..5d694210bbf
--- /dev/null
+++ b/docs/versioned_docs/version-v0.38.0/noir/standard_library/cryptographic_primitives/_category_.json
@@ -0,0 +1,5 @@
+{
+    "position": 0,
+    "collapsible": true,
+    "collapsed": true
+}
diff --git a/docs/versioned_docs/version-v0.38.0/noir/standard_library/cryptographic_primitives/ciphers.mdx b/docs/versioned_docs/version-v0.38.0/noir/standard_library/cryptographic_primitives/ciphers.mdx
new file mode 100644
index 00000000000..d6a5e1a79eb
--- /dev/null
+++ b/docs/versioned_docs/version-v0.38.0/noir/standard_library/cryptographic_primitives/ciphers.mdx
@@ -0,0 +1,32 @@
+---
+title: Ciphers
+description:
+  Learn about the implemented ciphers ready to use for any Noir project
+keywords:
+  [ciphers, Noir project, aes128, encrypt]
+sidebar_position: 0
+---
+
+import BlackBoxInfo from '@site/src/components/Notes/_blackbox';
+
+## aes128
+
+Given a plaintext as an array of bytes, returns the corresponding aes128 ciphertext (CBC mode). Input padding is automatically performed using PKCS#7, so that the output length is `input.len() + (16 - input.len() % 16)`.
+
+```rust title="aes128" showLineNumbers 
+pub fn aes128_encrypt<let N: u32>(input: [u8; N], iv: [u8; 16], key: [u8; 16]) -> [u8] {}
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/aes128.nr#L2-L4" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/aes128.nr#L2-L4</a></sub></sup>
+
+
+```rust
+fn main() {
+    let input: [u8; 4] = [0, 12, 3, 15] // Random bytes, will be padded to 16 bytes.
+    let iv: [u8; 16] = [0; 16]; // Initialisation vector
+    let key: [u8; 16] = [0; 16] // AES key
+    let ciphertext = std::aes128::aes128_encrypt(inputs.as_bytes(), iv.as_bytes(), key.as_bytes()); // In this case, the output length will be 16 bytes.
+}
+```
+
+
+<BlackBoxInfo to="../black_box_fns"/>
\ No newline at end of file
diff --git a/docs/versioned_docs/version-v0.38.0/noir/standard_library/cryptographic_primitives/ec_primitives.md b/docs/versioned_docs/version-v0.38.0/noir/standard_library/cryptographic_primitives/ec_primitives.md
new file mode 100644
index 00000000000..f262d8160d6
--- /dev/null
+++ b/docs/versioned_docs/version-v0.38.0/noir/standard_library/cryptographic_primitives/ec_primitives.md
@@ -0,0 +1,102 @@
+---
+title: Elliptic Curve Primitives
+keywords: [cryptographic primitives, Noir project]
+sidebar_position: 4
+---
+
+Data structures and methods on them that allow you to carry out computations involving elliptic
+curves over the (mathematical) field corresponding to `Field`. For the field currently at our
+disposal, applications would involve a curve embedded in BN254, e.g. the
+[Baby Jubjub curve](https://eips.ethereum.org/EIPS/eip-2494).
+
+## Data structures
+
+### Elliptic curve configurations
+
+(`std::ec::{tecurve,montcurve,swcurve}::{affine,curvegroup}::Curve`), i.e. the specific elliptic
+curve you want to use, which would be specified using any one of the methods
+`std::ec::{tecurve,montcurve,swcurve}::{affine,curvegroup}::new` which take the coefficients in the
+defining equation together with a generator point as parameters. You can find more detail in the
+comments in
+[`noir_stdlib/src/ec/mod.nr`](https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/ec/mod.nr), but
+the gist of it is that the elliptic curves of interest are usually expressed in one of the standard
+forms implemented here (Twisted Edwards, Montgomery and Short Weierstraß), and in addition to that,
+you could choose to use `affine` coordinates (Cartesian coordinates - the usual (x,y) - possibly
+together with a point at infinity) or `curvegroup` coordinates (some form of projective coordinates
+requiring more coordinates but allowing for more efficient implementations of elliptic curve
+operations). Conversions between all of these forms are provided, and under the hood these
+conversions are done whenever an operation is more efficient in a different representation (or a
+mixed coordinate representation is employed).
+
+### Points
+
+(`std::ec::{tecurve,montcurve,swcurve}::{affine,curvegroup}::Point`), i.e. points lying on the
+elliptic curve. For a curve configuration `c` and a point `p`, it may be checked that `p`
+does indeed lie on `c` by calling `c.contains(p1)`.
+
+## Methods
+
+(given a choice of curve representation, e.g. use `std::ec::tecurve::affine::Curve` and use
+`std::ec::tecurve::affine::Point`)
+
+- The **zero element** is given by `Point::zero()`, and we can verify whether a point `p: Point` is
+  zero by calling `p.is_zero()`.
+- **Equality**: Points `p1: Point` and `p2: Point` may be checked for equality by calling
+  `p1.eq(p2)`.
+- **Addition**: For `c: Curve` and points `p1: Point` and `p2: Point` on the curve, adding these two
+  points is accomplished by calling `c.add(p1,p2)`.
+- **Negation**: For a point `p: Point`, `p.negate()` is its negation.
+- **Subtraction**: For `c` and `p1`, `p2` as above, subtracting `p2` from `p1` is accomplished by
+  calling `c.subtract(p1,p2)`.
+- **Scalar multiplication**: For `c` as above, `p: Point` a point on the curve and `n: Field`,
+  scalar multiplication is given by `c.mul(n,p)`. If instead `n :: [u1; N]`, i.e. `n` is a bit
+  array, the `bit_mul` method may be used instead: `c.bit_mul(n,p)`
+- **Multi-scalar multiplication**: For `c` as above and arrays `n: [Field; N]` and `p: [Point; N]`,
+  multi-scalar multiplication is given by `c.msm(n,p)`.
+- **Coordinate representation conversions**: The `into_group` method converts a point or curve
+  configuration in the affine representation to one in the CurveGroup representation, and
+  `into_affine` goes in the other direction.
+- **Curve representation conversions**: `tecurve` and `montcurve` curves and points are equivalent
+  and may be converted between one another by calling `into_montcurve` or `into_tecurve` on their
+  configurations or points. `swcurve` is more general and a curve c of one of the other two types
+  may be converted to this representation by calling `c.into_swcurve()`, whereas a point `p` lying
+  on the curve given by `c` may be mapped to its corresponding `swcurve` point by calling
+  `c.map_into_swcurve(p)`.
+- **Map-to-curve methods**: The Elligator 2 method of mapping a field element `n: Field` into a
+  `tecurve` or `montcurve` with configuration `c` may be called as `c.elligator2_map(n)`. For all of
+  the curve configurations, the SWU map-to-curve method may be called as `c.swu_map(z,n)`, where
+  `z: Field` depends on `Field` and `c` and must be chosen by the user (the conditions it needs to
+  satisfy are specified in the comments
+  [here](https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/ec/mod.nr)).
+
+## Examples
+
+The
+[ec_baby_jubjub test](https://github.com/noir-lang/noir/blob/master/test_programs/compile_success_empty/ec_baby_jubjub/src/main.nr)
+illustrates all of the above primitives on various forms of the Baby Jubjub curve. A couple of more
+interesting examples in Noir would be:
+
+Public-key cryptography: Given an elliptic curve and a 'base point' on it, determine the public key
+from the private key. This is a matter of using scalar multiplication. In the case of Baby Jubjub,
+for example, this code would do:
+
+```rust
+use std::ec::tecurve::affine::{Curve, Point};
+
+fn bjj_pub_key(priv_key: Field) -> Point
+{
+
+ let bjj = Curve::new(168700, 168696, G::new(995203441582195749578291179787384436505546430278305826713579947235728471134,5472060717959818805561601436314318772137091100104008585924551046643952123905));
+
+ let base_pt = Point::new(5299619240641551281634865583518297030282874472190772894086521144482721001553, 16950150798460657717958625567821834550301663161624707787222815936182638968203);
+
+ bjj.mul(priv_key,base_pt)
+}
+```
+
+This would come in handy in a Merkle proof.
+
+- EdDSA signature verification: This is a matter of combining these primitives with a suitable hash
+  function. See
+  [feat(stdlib): EdDSA sig verification noir#1136](https://github.com/noir-lang/noir/pull/1136) for
+  the case of Baby Jubjub and the Poseidon hash function.
diff --git a/docs/versioned_docs/version-v0.38.0/noir/standard_library/cryptographic_primitives/ecdsa_sig_verification.mdx b/docs/versioned_docs/version-v0.38.0/noir/standard_library/cryptographic_primitives/ecdsa_sig_verification.mdx
new file mode 100644
index 00000000000..8d96027b42c
--- /dev/null
+++ b/docs/versioned_docs/version-v0.38.0/noir/standard_library/cryptographic_primitives/ecdsa_sig_verification.mdx
@@ -0,0 +1,98 @@
+---
+title: ECDSA Signature Verification
+description: Learn about the cryptographic primitives regarding ECDSA over the secp256k1 and secp256r1 curves
+keywords: [cryptographic primitives, Noir project, ecdsa, secp256k1, secp256r1, signatures]
+sidebar_position: 3
+---
+
+import BlackBoxInfo from '@site/src/components/Notes/_blackbox';
+
+Noir supports ECDSA signatures verification over the secp256k1 and secp256r1 curves.
+
+## ecdsa_secp256k1::verify_signature
+
+Verifier for ECDSA Secp256k1 signatures.
+See ecdsa_secp256k1::verify_signature_slice for a version that accepts slices directly.
+
+```rust title="ecdsa_secp256k1" showLineNumbers 
+pub fn verify_signature<let N: u32>(
+    public_key_x: [u8; 32],
+    public_key_y: [u8; 32],
+    signature: [u8; 64],
+    message_hash: [u8; N],
+) -> bool
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/ecdsa_secp256k1.nr#L2-L9" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/ecdsa_secp256k1.nr#L2-L9</a></sub></sup>
+
+
+example:
+
+```rust
+fn main(hashed_message : [u8;32], pub_key_x : [u8;32], pub_key_y : [u8;32], signature : [u8;64]) {
+     let valid_signature = std::ecdsa_secp256k1::verify_signature(pub_key_x, pub_key_y, signature, hashed_message);
+     assert(valid_signature);
+}
+```
+
+<BlackBoxInfo to="../black_box_fns" />
+
+## ecdsa_secp256k1::verify_signature_slice
+
+Verifier for ECDSA Secp256k1 signatures where the message is a slice.
+
+```rust title="ecdsa_secp256k1_slice" showLineNumbers 
+pub fn verify_signature_slice(
+    public_key_x: [u8; 32],
+    public_key_y: [u8; 32],
+    signature: [u8; 64],
+    message_hash: [u8],
+) -> bool
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/ecdsa_secp256k1.nr#L13-L20" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/ecdsa_secp256k1.nr#L13-L20</a></sub></sup>
+
+
+<BlackBoxInfo to="../black_box_fns"/>
+
+## ecdsa_secp256r1::verify_signature
+
+Verifier for ECDSA Secp256r1 signatures.
+See ecdsa_secp256r1::verify_signature_slice for a version that accepts slices directly.
+
+```rust title="ecdsa_secp256r1" showLineNumbers 
+pub fn verify_signature<let N: u32>(
+    public_key_x: [u8; 32],
+    public_key_y: [u8; 32],
+    signature: [u8; 64],
+    message_hash: [u8; N],
+) -> bool
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/ecdsa_secp256r1.nr#L2-L9" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/ecdsa_secp256r1.nr#L2-L9</a></sub></sup>
+
+
+example:
+
+```rust
+fn main(hashed_message : [u8;32], pub_key_x : [u8;32], pub_key_y : [u8;32], signature : [u8;64]) {
+     let valid_signature = std::ecdsa_secp256r1::verify_signature(pub_key_x, pub_key_y, signature, hashed_message);
+     assert(valid_signature);
+}
+```
+
+<BlackBoxInfo to="../black_box_fns"/>
+
+## ecdsa_secp256r1::verify_signature
+
+Verifier for ECDSA Secp256r1 signatures where the message is a slice.
+
+```rust title="ecdsa_secp256r1_slice" showLineNumbers 
+pub fn verify_signature_slice(
+    public_key_x: [u8; 32],
+    public_key_y: [u8; 32],
+    signature: [u8; 64],
+    message_hash: [u8],
+) -> bool
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/ecdsa_secp256r1.nr#L13-L20" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/ecdsa_secp256r1.nr#L13-L20</a></sub></sup>
+
+
+<BlackBoxInfo to="../black_box_fns"/>
diff --git a/docs/versioned_docs/version-v0.38.0/noir/standard_library/cryptographic_primitives/eddsa.mdx b/docs/versioned_docs/version-v0.38.0/noir/standard_library/cryptographic_primitives/eddsa.mdx
new file mode 100644
index 00000000000..b283de693c8
--- /dev/null
+++ b/docs/versioned_docs/version-v0.38.0/noir/standard_library/cryptographic_primitives/eddsa.mdx
@@ -0,0 +1,37 @@
+---
+title: EdDSA Verification
+description: Learn about the cryptographic primitives regarding EdDSA
+keywords: [cryptographic primitives, Noir project, eddsa, signatures]
+sidebar_position: 5
+---
+
+import BlackBoxInfo from '@site/src/components/Notes/_blackbox';
+
+## eddsa::eddsa_poseidon_verify
+
+Verifier for EdDSA signatures
+
+```rust
+fn eddsa_poseidon_verify(public_key_x : Field, public_key_y : Field, signature_s: Field, signature_r8_x: Field, signature_r8_y: Field, message: Field) -> bool
+```
+
+It is also possible to specify the hash algorithm used for the signature by using the `eddsa_verify` function by passing a type implementing the Hasher trait with the turbofish operator. 
+For instance, if you want to use Poseidon2 instead, you can do the following:
+```rust
+use std::hash::poseidon2::Poseidon2Hasher;
+
+eddsa_verify::<Poseidon2Hasher>(pub_key_a.x, pub_key_a.y, s_a, r8_a.x, r8_a.y, msg);
+```
+
+<BlackBoxInfo to="../black_box_fns"/>
+
+## eddsa::eddsa_to_pub
+
+Private to public key conversion.
+
+Returns `(pub_key_x, pub_key_y)`
+
+```rust
+fn eddsa_to_pub(secret : Field) -> (Field, Field)
+```
+
diff --git a/docs/versioned_docs/version-v0.38.0/noir/standard_library/cryptographic_primitives/embedded_curve_ops.mdx b/docs/versioned_docs/version-v0.38.0/noir/standard_library/cryptographic_primitives/embedded_curve_ops.mdx
new file mode 100644
index 00000000000..482a36932b9
--- /dev/null
+++ b/docs/versioned_docs/version-v0.38.0/noir/standard_library/cryptographic_primitives/embedded_curve_ops.mdx
@@ -0,0 +1,95 @@
+---
+title: Scalar multiplication
+description: See how you can perform scalar multiplication in Noir
+keywords: [cryptographic primitives, Noir project, scalar multiplication]
+sidebar_position: 1
+---
+
+import BlackBoxInfo from '@site/src/components/Notes/_blackbox';
+
+The following functions perform operations over the embedded curve whose coordinates are defined by the configured noir field.
+For the BN254 scalar field, this is BabyJubJub or Grumpkin.
+
+:::note
+Suffixes `_low` and `_high` denote low and high limbs of a scalar.
+:::
+
+## embedded_curve_ops::multi_scalar_mul
+
+Performs multi scalar multiplication over the embedded curve.
+The function accepts arbitrary amount of point-scalar pairs on the input, it multiplies the individual pairs over
+the curve and returns a sum of the resulting points.
+
+Points represented as x and y coordinates [x1, y1, x2, y2, ...], scalars as low and high limbs [low1, high1, low2, high2, ...].
+
+```rust title="multi_scalar_mul" showLineNumbers 
+pub fn multi_scalar_mul<let N: u32>(
+    points: [EmbeddedCurvePoint; N],
+    scalars: [EmbeddedCurveScalar; N],
+) -> EmbeddedCurvePoint
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/embedded_curve_ops.nr#L103-L108" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/embedded_curve_ops.nr#L103-L108</a></sub></sup>
+
+
+example
+
+```rust
+fn main(point_x: Field, point_y: Field, scalar_low: Field, scalar_high: Field) {
+    let point = std::embedded_curve_ops::multi_scalar_mul([point_x, point_y], [scalar_low, scalar_high]);
+    println(point);
+}
+```
+
+## embedded_curve_ops::fixed_base_scalar_mul
+
+Performs fixed base scalar multiplication over the embedded curve (multiplies input scalar with a generator point).
+The function accepts a single scalar on the input represented as 2 fields.
+
+```rust title="fixed_base_scalar_mul" showLineNumbers 
+pub fn fixed_base_scalar_mul(scalar: EmbeddedCurveScalar) -> EmbeddedCurvePoint
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/embedded_curve_ops.nr#L120-L122" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/embedded_curve_ops.nr#L120-L122</a></sub></sup>
+
+
+example
+
+```rust
+fn main(scalar_low: Field, scalar_high: Field) {
+    let point = std::embedded_curve_ops::fixed_base_scalar_mul(scalar_low, scalar_high);
+    println(point);
+}
+```
+
+## embedded_curve_ops::embedded_curve_add
+
+Adds two points on the embedded curve.
+This function takes two `EmbeddedCurvePoint` structures as parameters, representing points on the curve, and returns a new `EmbeddedCurvePoint` structure that represents their sum.
+
+### Parameters:
+- `point1` (`EmbeddedCurvePoint`): The first point to add.
+- `point2` (`EmbeddedCurvePoint`): The second point to add.
+
+### Returns:
+- `EmbeddedCurvePoint`: The resulting point after the addition of `point1` and `point2`.
+
+```rust title="embedded_curve_add" showLineNumbers 
+pub fn embedded_curve_add(
+    point1: EmbeddedCurvePoint,
+    point2: EmbeddedCurvePoint,
+) -> EmbeddedCurvePoint {
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/embedded_curve_ops.nr#L136-L141" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/embedded_curve_ops.nr#L136-L141</a></sub></sup>
+
+
+example
+
+```rust
+fn main() {
+    let point1 = EmbeddedCurvePoint { x: 1, y: 2 };
+    let point2 = EmbeddedCurvePoint { x: 3, y: 4 };
+    let result = std::embedded_curve_ops::embedded_curve_add(point1, point2);
+    println!("Resulting Point: ({}, {})", result.x, result.y);
+}
+```
+
+<BlackBoxInfo to="../black_box_fns"/>
diff --git a/docs/versioned_docs/version-v0.38.0/noir/standard_library/cryptographic_primitives/hashes.mdx b/docs/versioned_docs/version-v0.38.0/noir/standard_library/cryptographic_primitives/hashes.mdx
new file mode 100644
index 00000000000..541a1971561
--- /dev/null
+++ b/docs/versioned_docs/version-v0.38.0/noir/standard_library/cryptographic_primitives/hashes.mdx
@@ -0,0 +1,227 @@
+---
+title: Hash methods
+description:
+  Learn about the cryptographic primitives ready to use for any Noir project, including sha256,
+  blake2s and pedersen
+keywords:
+  [cryptographic primitives, Noir project, sha256, blake2s, pedersen, hash]
+sidebar_position: 0
+---
+
+import BlackBoxInfo from '@site/src/components/Notes/_blackbox';
+
+## sha256
+
+Given an array of bytes, returns the resulting sha256 hash.
+Specify a message_size to hash only the first `message_size` bytes of the input.
+
+```rust title="sha256" showLineNumbers 
+pub fn sha256<let N: u32>(input: [u8; N]) -> HASH
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/hash/sha256.nr#L47-L49" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/hash/sha256.nr#L47-L49</a></sub></sup>
+
+
+example:
+```rust title="sha256_var" showLineNumbers 
+let digest = std::hash::sha256_var([x as u8], 1);
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/test_programs/execution_success/sha256/src/main.nr#L15-L17" target="_blank" rel="noopener noreferrer">Source code: test_programs/execution_success/sha256/src/main.nr#L15-L17</a></sub></sup>
+
+
+```rust
+fn main() {
+    let x = [163, 117, 178, 149]; // some random bytes
+    let hash = std::sha256::sha256_var(x, 4);
+}
+```
+
+
+<BlackBoxInfo to="../black_box_fns"/>
+
+## blake2s
+
+Given an array of bytes, returns an array with the Blake2 hash
+
+```rust title="blake2s" showLineNumbers 
+pub fn blake2s<let N: u32>(input: [u8; N]) -> [u8; 32]
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/hash/mod.nr#L18-L20" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/hash/mod.nr#L18-L20</a></sub></sup>
+
+
+example:
+
+```rust
+fn main() {
+    let x = [163, 117, 178, 149]; // some random bytes
+    let hash = std::hash::blake2s(x);
+}
+```
+
+<BlackBoxInfo to="../black_box_fns"/>
+
+## blake3
+
+Given an array of bytes, returns an array with the Blake3 hash
+
+```rust title="blake3" showLineNumbers 
+pub fn blake3<let N: u32>(input: [u8; N]) -> [u8; 32]
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/hash/mod.nr#L24-L26" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/hash/mod.nr#L24-L26</a></sub></sup>
+
+
+example:
+
+```rust
+fn main() {
+    let x = [163, 117, 178, 149]; // some random bytes
+    let hash = std::hash::blake3(x);
+}
+```
+
+<BlackBoxInfo to="../black_box_fns"/>
+
+## pedersen_hash
+
+Given an array of Fields, returns the Pedersen hash.
+
+```rust title="pedersen_hash" showLineNumbers 
+pub fn pedersen_hash<let N: u32>(input: [Field; N]) -> Field
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/hash/mod.nr#L49-L51" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/hash/mod.nr#L49-L51</a></sub></sup>
+
+
+example:
+
+```rust title="pedersen-hash" showLineNumbers 
+fn main(x: Field, y: Field, expected_hash: Field) {
+    let hash = std::hash::pedersen_hash([x, y]);
+    assert_eq(hash, expected_hash);
+}
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/test_programs/execution_success/pedersen_hash/src/main.nr#L1-L6" target="_blank" rel="noopener noreferrer">Source code: test_programs/execution_success/pedersen_hash/src/main.nr#L1-L6</a></sub></sup>
+
+
+<BlackBoxInfo to="../black_box_fns" />
+
+## pedersen_commitment
+
+Given an array of Fields, returns the Pedersen commitment.
+
+```rust title="pedersen_commitment" showLineNumbers 
+pub fn pedersen_commitment<let N: u32>(input: [Field; N]) -> EmbeddedCurvePoint {
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/hash/mod.nr#L29-L31" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/hash/mod.nr#L29-L31</a></sub></sup>
+
+
+example:
+
+```rust title="pedersen-commitment" showLineNumbers 
+fn main(x: Field, y: Field, expected_commitment: std::embedded_curve_ops::EmbeddedCurvePoint) {
+    let commitment = std::hash::pedersen_commitment([x, y]);
+    assert_eq(commitment.x, expected_commitment.x);
+    assert_eq(commitment.y, expected_commitment.y);
+}
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/test_programs/execution_success/pedersen_commitment/src/main.nr#L1-L7" target="_blank" rel="noopener noreferrer">Source code: test_programs/execution_success/pedersen_commitment/src/main.nr#L1-L7</a></sub></sup>
+
+
+<BlackBoxInfo to="../black_box_fns"/>
+
+## keccak256
+
+Given an array of bytes (`u8`), returns the resulting keccak hash as an array of
+32 bytes (`[u8; 32]`). Specify a message_size to hash only the first
+`message_size` bytes of the input.
+
+```rust title="keccak256" showLineNumbers 
+pub fn keccak256<let N: u32>(input: [u8; N], message_size: u32) -> [u8; 32]
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/hash/mod.nr#L116-L118" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/hash/mod.nr#L116-L118</a></sub></sup>
+
+
+example:
+
+```rust title="keccak256" showLineNumbers 
+fn main(x: Field, result: [u8; 32]) {
+    // We use the `as` keyword here to denote the fact that we want to take just the first byte from the x Field
+    // The padding is taken care of by the program
+    let digest = std::hash::keccak256([x as u8], 1);
+    assert(digest == result);
+
+    //#1399: variable message size
+    let message_size = 4;
+    let hash_a = std::hash::keccak256([1, 2, 3, 4], message_size);
+    let hash_b = std::hash::keccak256([1, 2, 3, 4, 0, 0, 0, 0], message_size);
+
+    assert(hash_a == hash_b);
+
+    let message_size_big = 8;
+    let hash_c = std::hash::keccak256([1, 2, 3, 4, 0, 0, 0, 0], message_size_big);
+
+    assert(hash_a != hash_c);
+}
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/test_programs/execution_success/keccak256/src/main.nr#L1-L20" target="_blank" rel="noopener noreferrer">Source code: test_programs/execution_success/keccak256/src/main.nr#L1-L20</a></sub></sup>
+
+
+<BlackBoxInfo to="../black_box_fns"/>
+
+## poseidon
+
+Given an array of Fields, returns a new Field with the Poseidon Hash. Mind that you need to specify
+how many inputs are there to your Poseidon function.
+
+```rust
+// example for hash_1, hash_2 accepts an array of length 2, etc
+fn hash_1(input: [Field; 1]) -> Field
+```
+
+example:
+
+```rust title="poseidon" showLineNumbers 
+use std::hash::poseidon;
+
+fn main(x1: [Field; 2], y1: pub Field, x2: [Field; 4], y2: pub Field) {
+    let hash1 = poseidon::bn254::hash_2(x1);
+    assert(hash1 == y1);
+
+    let hash2 = poseidon::bn254::hash_4(x2);
+    assert(hash2 == y2);
+}
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/test_programs/execution_success/poseidon_bn254_hash/src/main.nr#L1-L11" target="_blank" rel="noopener noreferrer">Source code: test_programs/execution_success/poseidon_bn254_hash/src/main.nr#L1-L11</a></sub></sup>
+
+
+## poseidon 2
+
+Given an array of Fields, returns a new Field with the Poseidon2 Hash. Contrary to the Poseidon
+function, there is only one hash and you can specify a message_size to hash only the first 
+`message_size` bytes of the input,
+
+```rust
+// example for hashing the first three elements of the input
+Poseidon2::hash(input, 3);
+```
+
+example:
+
+```rust title="poseidon2" showLineNumbers 
+use std::hash::poseidon2;
+
+fn main(inputs: [Field; 4], expected_hash: Field) {
+    let hash = poseidon2::Poseidon2::hash(inputs, inputs.len());
+    assert_eq(hash, expected_hash);
+}
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/test_programs/execution_success/poseidon2/src/main.nr#L1-L8" target="_blank" rel="noopener noreferrer">Source code: test_programs/execution_success/poseidon2/src/main.nr#L1-L8</a></sub></sup>
+
+
+## hash_to_field
+
+```rust
+fn hash_to_field(_input : [Field]) -> Field {}
+```
+
+Calculates the `blake2s` hash of the inputs and returns the hash modulo the field modulus to return
+a value which can be represented as a `Field`.
+
diff --git a/docs/versioned_docs/version-v0.38.0/noir/standard_library/cryptographic_primitives/index.md b/docs/versioned_docs/version-v0.38.0/noir/standard_library/cryptographic_primitives/index.md
new file mode 100644
index 00000000000..650f30165d5
--- /dev/null
+++ b/docs/versioned_docs/version-v0.38.0/noir/standard_library/cryptographic_primitives/index.md
@@ -0,0 +1,14 @@
+---
+title: Cryptographic Primitives
+description:
+  Learn about the cryptographic primitives ready to use for any Noir project
+keywords:
+  [
+    cryptographic primitives,
+    Noir project,
+  ]
+---
+
+The Noir team is progressively adding new cryptographic primitives to the standard library. Reach out for news or if you would be interested in adding more of these calculations in Noir.
+
+Some methods are available thanks to the Aztec backend, not being performed using Noir. When using other backends, these methods may or may not be supplied.
diff --git a/docs/versioned_docs/version-v0.38.0/noir/standard_library/cryptographic_primitives/schnorr.mdx b/docs/versioned_docs/version-v0.38.0/noir/standard_library/cryptographic_primitives/schnorr.mdx
new file mode 100644
index 00000000000..030452645c5
--- /dev/null
+++ b/docs/versioned_docs/version-v0.38.0/noir/standard_library/cryptographic_primitives/schnorr.mdx
@@ -0,0 +1,64 @@
+---
+title: Schnorr Signatures
+description: Learn how you can verify Schnorr signatures using Noir
+keywords: [cryptographic primitives, Noir project, schnorr, signatures]
+sidebar_position: 2
+---
+
+import BlackBoxInfo from '@site/src/components/Notes/_blackbox';
+
+## schnorr::verify_signature
+
+Verifier for Schnorr signatures over the embedded curve (for BN254 it is Grumpkin).
+See schnorr::verify_signature_slice for a version that works directly on slices.
+
+```rust title="schnorr_verify" showLineNumbers 
+pub fn verify_signature<let N: u32>(
+    public_key_x: Field,
+    public_key_y: Field,
+    signature: [u8; 64],
+    message: [u8; N],
+) -> bool
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/schnorr.nr#L4-L11" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/schnorr.nr#L4-L11</a></sub></sup>
+
+
+where `_signature` can be generated like so using the npm package
+[@noir-lang/barretenberg](https://www.npmjs.com/package/@noir-lang/barretenberg)
+
+```js
+const { BarretenbergWasm } = require('@noir-lang/barretenberg/dest/wasm');
+const { Schnorr } = require('@noir-lang/barretenberg/dest/crypto/schnorr');
+
+...
+
+const barretenberg = await BarretenbergWasm.new();
+const schnorr = new Schnorr(barretenberg);
+const pubKey = schnorr.computePublicKey(privateKey);
+const message = ...
+const signature = Array.from(
+    schnorr.constructSignature(hash, privateKey).toBuffer()
+);
+
+...
+```
+
+<BlackBoxInfo to="../black_box_fns"/>
+
+## schnorr::verify_signature_slice
+
+Verifier for Schnorr signatures over the embedded curve (for BN254 it is Grumpkin)
+where the message is a slice. 
+
+```rust title="schnorr_verify_slice" showLineNumbers 
+pub fn verify_signature_slice(
+    public_key_x: Field,
+    public_key_y: Field,
+    signature: [u8; 64],
+    message: [u8],
+) -> bool
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/schnorr.nr#L15-L22" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/schnorr.nr#L15-L22</a></sub></sup>
+
+
+<BlackBoxInfo to="../black_box_fns"/>
diff --git a/docs/versioned_docs/version-v0.38.0/noir/standard_library/fmtstr.md b/docs/versioned_docs/version-v0.38.0/noir/standard_library/fmtstr.md
new file mode 100644
index 00000000000..19809d60261
--- /dev/null
+++ b/docs/versioned_docs/version-v0.38.0/noir/standard_library/fmtstr.md
@@ -0,0 +1,17 @@
+---
+title: fmtstr
+---
+
+`fmtstr<N, T>` is the type resulting from using format string (`f"..."`).
+
+## Methods
+
+### quoted_contents
+
+```rust title="quoted_contents" showLineNumbers 
+pub comptime fn quoted_contents(self) -> Quoted {}
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/meta/format_string.nr#L3-L5" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/meta/format_string.nr#L3-L5</a></sub></sup>
+
+
+Returns the format string contents (that is, without the leading and trailing double quotes) as a `Quoted` value.
\ No newline at end of file
diff --git a/docs/versioned_docs/version-v0.38.0/noir/standard_library/is_unconstrained.md b/docs/versioned_docs/version-v0.38.0/noir/standard_library/is_unconstrained.md
new file mode 100644
index 00000000000..51bb1bda8f1
--- /dev/null
+++ b/docs/versioned_docs/version-v0.38.0/noir/standard_library/is_unconstrained.md
@@ -0,0 +1,69 @@
+---
+title: Is Unconstrained Function
+description:
+  The is_unconstrained function returns wether the context at that point of the program is unconstrained or not.
+keywords:
+  [
+    unconstrained
+  ]
+---
+
+It's very common for functions in circuits to take unconstrained hints of an expensive computation and then verify it. This is done by running the hint in an unconstrained context and then verifying the result in a constrained context.
+
+When a function is marked as unconstrained, any subsequent functions that it calls will also be run in an unconstrained context. However, if we are implementing a library function, other users might call it within an unconstrained context or a constrained one. Generally, in an unconstrained context we prefer just computing the result instead of taking a hint of it and verifying it, since that'd mean doing the same computation twice:
+
+```rust 
+
+fn my_expensive_computation(){
+  ...
+}
+
+unconstrained fn my_expensive_computation_hint(){
+  my_expensive_computation()
+}
+
+pub fn external_interface(){
+  my_expensive_computation_hint();
+  // verify my_expensive_computation: If external_interface is called from unconstrained, this is redundant
+  ...
+}
+
+```
+
+In order to improve the performance in an unconstrained context you can use the function at `std::runtime::is_unconstrained() -> bool`:
+
+
+```rust 
+use dep::std::runtime::is_unconstrained;
+
+fn my_expensive_computation(){
+  ...
+}
+
+unconstrained fn my_expensive_computation_hint(){
+  my_expensive_computation()
+}
+
+pub fn external_interface(){
+  if is_unconstrained() {
+    my_expensive_computation();
+  } else {
+    my_expensive_computation_hint();
+    // verify my_expensive_computation
+    ...
+  }
+}
+
+```
+
+The is_unconstrained result is resolved at compile time, so in unconstrained contexts the compiler removes the else branch, and in constrained contexts the compiler removes the if branch, reducing the amount of compute necessary to run external_interface.
+
+Note that using `is_unconstrained` in a `comptime` context will also return `true`:
+
+```
+fn main() {
+    comptime {
+        assert(is_unconstrained());
+    }
+}
+```
diff --git a/docs/versioned_docs/version-v0.38.0/noir/standard_library/logging.md b/docs/versioned_docs/version-v0.38.0/noir/standard_library/logging.md
new file mode 100644
index 00000000000..db75ef9f86f
--- /dev/null
+++ b/docs/versioned_docs/version-v0.38.0/noir/standard_library/logging.md
@@ -0,0 +1,78 @@
+---
+title: Logging
+description:
+  Learn how to use the println statement for debugging in Noir with this tutorial. Understand the
+  basics of logging in Noir and how to implement it in your code.
+keywords:
+  [
+    noir logging,
+    println statement,
+    print statement,
+    debugging in noir,
+    noir std library,
+    logging tutorial,
+    basic logging in noir,
+    noir logging implementation,
+    noir debugging techniques,
+    rust,
+  ]
+---
+
+The standard library provides two familiar statements you can use: `println` and `print`. Despite being a limited implementation of rust's `println!` and `print!` macros, these constructs can be useful for debugging.
+
+You can print the output of both statements in your Noir code by using the `nargo execute` command or the `--show-output` flag when using `nargo test` (provided there are print statements in your tests).
+
+It is recommended to use `nargo execute` if you want to debug failing constraints with `println` or `print` statements. This is due to every input in a test being a constant rather than a witness, so we issue an error during compilation while we only print during execution (which comes after compilation). Neither `println`, nor `print` are callable for failed constraints caught at compile time.
+
+Both `print` and `println` are generic functions which can work on integers, fields, strings, and even structs or expressions. Note however, that slices are currently unsupported. For example:
+
+```rust
+struct Person {
+    age: Field,
+    height: Field,
+}
+
+fn main(age: Field, height: Field) {
+    let person = Person {
+        age: age,
+        height: height,
+    };
+    println(person);
+    println(age + height);
+    println("Hello world!");
+}
+```
+
+You can print different types in the same statement (including strings) with a type called `fmtstr`. It can be specified in the same way as a normal string, just prepended with an "f" character:
+
+```rust
+  let fmt_str = f"i: {i}, j: {j}";
+  println(fmt_str);
+
+  let s = myStruct { y: x, x: y };
+  println(s);
+
+  println(f"i: {i}, s: {s}");
+
+  println(x);
+  println([x, y]);
+
+  let foo = fooStruct { my_struct: s, foo: 15 };
+  println(f"s: {s}, foo: {foo}");
+
+  println(15);       // prints 0x0f, implicit Field
+  println(-1 as u8); // prints 255
+  println(-1 as i8); // prints -1
+```
+
+Examples shown above are interchangeable between the two `print` statements:
+
+```rust
+let person = Person { age : age, height : height };
+
+println(person);
+print(person);
+
+println("Hello world!"); // Prints with a newline at the end of the input
+print("Hello world!");   // Prints the input and keeps cursor on the same line
+```
diff --git a/docs/versioned_docs/version-v0.38.0/noir/standard_library/mem.md b/docs/versioned_docs/version-v0.38.0/noir/standard_library/mem.md
new file mode 100644
index 00000000000..95d36ac2a72
--- /dev/null
+++ b/docs/versioned_docs/version-v0.38.0/noir/standard_library/mem.md
@@ -0,0 +1,52 @@
+---
+title: Memory Module
+description:
+  This module contains functions which manipulate memory in a low-level way
+keywords:
+  [
+    mem, memory, zeroed, transmute, checked_transmute
+  ]
+---
+
+# `std::mem::zeroed`
+
+```rust
+fn zeroed<T>() -> T
+```
+
+Returns a zeroed value of any type.
+This function is generally unsafe to use as the zeroed bit pattern is not guaranteed to be valid for all types.
+It can however, be useful in cases when the value is guaranteed not to be used such as in a BoundedVec library implementing a growable vector, up to a certain length, backed by an array.
+The array can be initialized with zeroed values which are guaranteed to be inaccessible until the vector is pushed to.
+Similarly, enumerations in noir can be implemented using this method by providing zeroed values for the unused variants.
+
+This function currently supports the following types:
+
+- Field
+- Bool
+- Uint
+- Array
+- Slice
+- String
+- Tuple
+- Functions
+  
+Using it on other types could result in unexpected behavior.
+
+# `std::mem::checked_transmute`
+
+```rust
+fn checked_transmute<T, U>(value: T) -> U
+```
+
+Transmutes a value of one type into the same value but with a new type `U`.
+
+This function is safe to use since both types are asserted to be equal later during compilation after the concrete values for generic types become known.
+This function is useful for cases where the compiler may fails a type check that is expected to pass where
+a user knows the two types to be equal. For example, when using arithmetic generics there are cases the compiler
+does not see as equal, such as `[Field; N*(A + B)]` and `[Field; N*A + N*B]`, which users may know to be equal.
+In these cases, `checked_transmute` can be used to cast the value to the desired type while also preserving safety
+by checking this equality once `N`, `A`, `B` are fully resolved.
+
+Note that since this safety check is performed after type checking rather than during, no error is issued if the function
+containing `checked_transmute` is never called.
diff --git a/docs/versioned_docs/version-v0.38.0/noir/standard_library/merkle_trees.md b/docs/versioned_docs/version-v0.38.0/noir/standard_library/merkle_trees.md
new file mode 100644
index 00000000000..6a9ebf72ada
--- /dev/null
+++ b/docs/versioned_docs/version-v0.38.0/noir/standard_library/merkle_trees.md
@@ -0,0 +1,58 @@
+---
+title: Merkle Trees
+description: Learn about Merkle Trees in Noir with this tutorial. Explore the basics of computing a merkle root using a proof, with examples.
+keywords:
+  [
+    Merkle trees in Noir,
+    Noir programming language,
+    check membership,
+    computing root from leaf,
+    Noir Merkle tree implementation,
+    Merkle tree tutorial,
+    Merkle tree code examples,
+    Noir libraries,
+    pedersen hash.,
+  ]
+---
+
+## compute_merkle_root
+
+Returns the root of the tree from the provided leaf and its hash path, using a [Pedersen hash](./cryptographic_primitives/hashes.mdx#pedersen_hash).
+
+```rust
+fn compute_merkle_root(leaf : Field, index : Field, hash_path: [Field]) -> Field
+```
+
+example:
+
+```rust
+/**
+    // these values are for this example only
+    index = "0"
+    priv_key = "0x000000000000000000000000000000000000000000000000000000616c696365"
+    secret = "0x1929ea3ab8d9106a899386883d9428f8256cfedb3c4f6b66bf4aa4d28a79988f"
+    note_hash_path = [
+    "0x1e61bdae0f027b1b2159e1f9d3f8d00fa668a952dddd822fda80dc745d6f65cc",
+    "0x0e4223f3925f98934393c74975142bd73079ab0621f4ee133cee050a3c194f1a",
+    "0x2fd7bb412155bf8693a3bd2a3e7581a679c95c68a052f835dddca85fa1569a40"
+    ]
+ */
+fn main(index: Field, priv_key: Field, secret: Field, note_hash_path: [Field; 3]) {
+
+    let pubkey = std::scalar_mul::fixed_base_embedded_curve(priv_key);
+    let pubkey_x = pubkey[0];
+    let pubkey_y = pubkey[1];
+    let note_commitment = std::hash::pedersen(&[pubkey_x, pubkey_y, secret]);
+
+    let root = std::merkle::compute_merkle_root(note_commitment[0], index, note_hash_path.as_slice());
+    println(root);
+}
+```
+
+To check merkle tree membership:
+
+1. Include a merkle root as a program input.
+2. Compute the merkle root of a given leaf, index and hash path.
+3. Assert the merkle roots are equal.
+
+For more info about merkle trees, see the Wikipedia [page](https://en.wikipedia.org/wiki/Merkle_tree).
diff --git a/docs/versioned_docs/version-v0.38.0/noir/standard_library/meta/ctstring.md b/docs/versioned_docs/version-v0.38.0/noir/standard_library/meta/ctstring.md
new file mode 100644
index 00000000000..b76f873ca03
--- /dev/null
+++ b/docs/versioned_docs/version-v0.38.0/noir/standard_library/meta/ctstring.md
@@ -0,0 +1,100 @@
+---
+title: CtString
+---
+
+`std::meta::ctstring` contains methods on the built-in `CtString` type which is
+a compile-time, dynamically-sized string type. Compared to `str<N>` and `fmtstr<N, T>`,
+`CtString` is useful because its size does not need to be specified in its type. This
+can be used for formatting items at compile-time or general string handling in `comptime`
+code.
+
+Since `fmtstr`s can be converted into `CtString`s, you can make use of their formatting
+abilities in CtStrings by formatting in `fmtstr`s then converting the result to a CtString
+afterward.
+
+## Traits
+
+### AsCtString
+
+```rust title="as-ctstring" showLineNumbers 
+pub trait AsCtString {
+    comptime fn as_ctstring(self) -> CtString;
+}
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/meta/ctstring.nr#L43-L47" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/meta/ctstring.nr#L43-L47</a></sub></sup>
+
+
+Converts an object into a compile-time string.
+
+Implementations:
+
+```rust
+impl<let N: u32> AsCtString for str<N> { ... }
+impl<let N: u32, T> AsCtString for fmtstr<N, T> { ... }
+```
+
+## Methods
+
+### new
+
+```rust title="new" showLineNumbers 
+pub comptime fn new() -> Self {
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/meta/ctstring.nr#L4-L6" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/meta/ctstring.nr#L4-L6</a></sub></sup>
+
+
+Creates an empty `CtString`.
+
+### append_str
+
+```rust title="append_str" showLineNumbers 
+pub comptime fn append_str<let N: u32>(self, s: str<N>) -> Self {
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/meta/ctstring.nr#L11-L13" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/meta/ctstring.nr#L11-L13</a></sub></sup>
+
+
+Returns a new CtString with the given str appended onto the end.
+
+### append_fmtstr
+
+```rust title="append_fmtstr" showLineNumbers 
+pub comptime fn append_fmtstr<let N: u32, T>(self, s: fmtstr<N, T>) -> Self {
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/meta/ctstring.nr#L17-L19" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/meta/ctstring.nr#L17-L19</a></sub></sup>
+
+
+Returns a new CtString with the given fmtstr appended onto the end.
+
+### as_quoted_str
+
+```rust title="as_quoted_str" showLineNumbers 
+pub comptime fn as_quoted_str(self) -> Quoted {
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/meta/ctstring.nr#L26-L28" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/meta/ctstring.nr#L26-L28</a></sub></sup>
+
+
+Returns a quoted string literal from this string's contents.
+
+There is no direct conversion from a `CtString` to a `str<N>` since
+the size would not be known. To get around this, this function can
+be used in combination with macro insertion (`!`) to insert this string
+literal at this function's call site.
+
+Example:
+
+```rust title="as_quoted_str_example" showLineNumbers 
+let my_ctstring = "foo bar".as_ctstring();
+            let my_str = my_ctstring.as_quoted_str!();
+
+            assert_eq(crate::meta::type_of(my_str), quote { str<7> }.as_type());
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/meta/ctstring.nr#L92-L97" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/meta/ctstring.nr#L92-L97</a></sub></sup>
+
+
+## Trait Implementations
+
+```rust
+impl Eq for CtString
+impl Hash for CtString
+impl Append for CtString
+```
diff --git a/docs/versioned_docs/version-v0.38.0/noir/standard_library/meta/expr.md b/docs/versioned_docs/version-v0.38.0/noir/standard_library/meta/expr.md
new file mode 100644
index 00000000000..b6d395c6700
--- /dev/null
+++ b/docs/versioned_docs/version-v0.38.0/noir/standard_library/meta/expr.md
@@ -0,0 +1,380 @@
+---
+title: Expr
+---
+
+`std::meta::expr` contains methods on the built-in `Expr` type for quoted, syntactically valid expressions.
+
+## Methods
+
+### as_array
+
+```rust title="as_array" showLineNumbers 
+pub comptime fn as_array(self) -> Option<[Expr]> {}
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/meta/expr.nr#L10-L12" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/meta/expr.nr#L10-L12</a></sub></sup>
+
+
+If this expression is an array, this returns a slice of each element in the array.
+
+### as_assert
+
+```rust title="as_assert" showLineNumbers 
+pub comptime fn as_assert(self) -> Option<(Expr, Option<Expr>)> {}
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/meta/expr.nr#L16-L18" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/meta/expr.nr#L16-L18</a></sub></sup>
+
+
+If this expression is an assert, this returns the assert expression and the optional message.
+
+### as_assert_eq
+
+```rust title="as_assert_eq" showLineNumbers 
+pub comptime fn as_assert_eq(self) -> Option<(Expr, Expr, Option<Expr>)> {}
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/meta/expr.nr#L23-L25" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/meta/expr.nr#L23-L25</a></sub></sup>
+
+
+If this expression is an assert_eq, this returns the left-hand-side and right-hand-side
+expressions, together with the optional message.
+
+### as_assign
+
+```rust title="as_assign" showLineNumbers 
+pub comptime fn as_assign(self) -> Option<(Expr, Expr)> {}
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/meta/expr.nr#L30-L32" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/meta/expr.nr#L30-L32</a></sub></sup>
+
+
+If this expression is an assignment, this returns a tuple with the left hand side
+and right hand side in order.
+
+### as_binary_op
+
+```rust title="as_binary_op" showLineNumbers 
+pub comptime fn as_binary_op(self) -> Option<(Expr, BinaryOp, Expr)> {}
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/meta/expr.nr#L37-L39" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/meta/expr.nr#L37-L39</a></sub></sup>
+
+
+If this expression is a binary operator operation `<lhs> <op> <rhs>`,
+return the left-hand side, operator, and the right-hand side of the operation.
+
+### as_block
+
+```rust title="as_block" showLineNumbers 
+pub comptime fn as_block(self) -> Option<[Expr]> {}
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/meta/expr.nr#L44-L46" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/meta/expr.nr#L44-L46</a></sub></sup>
+
+
+If this expression is a block `{ stmt1; stmt2; ...; stmtN }`, return
+a slice containing each statement.
+
+### as_bool
+
+```rust title="as_bool" showLineNumbers 
+pub comptime fn as_bool(self) -> Option<bool> {}
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/meta/expr.nr#L50-L52" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/meta/expr.nr#L50-L52</a></sub></sup>
+
+
+If this expression is a boolean literal, return that literal.
+
+### as_cast
+
+```rust title="as_cast" showLineNumbers 
+#[builtin(expr_as_cast)]
+    pub comptime fn as_cast(self) -> Option<(Expr, UnresolvedType)> {}
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/meta/expr.nr#L56-L59" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/meta/expr.nr#L56-L59</a></sub></sup>
+
+
+If this expression is a cast expression (`expr as type`), returns the casted
+expression and the type to cast to.
+
+### as_comptime
+
+```rust title="as_comptime" showLineNumbers 
+pub comptime fn as_comptime(self) -> Option<[Expr]> {}
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/meta/expr.nr#L64-L66" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/meta/expr.nr#L64-L66</a></sub></sup>
+
+
+If this expression is a `comptime { stmt1; stmt2; ...; stmtN }` block,
+return each statement in the block.
+
+### as_constructor
+
+```rust title="as_constructor" showLineNumbers 
+pub comptime fn as_constructor(self) -> Option<(UnresolvedType, [(Quoted, Expr)])> {}
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/meta/expr.nr#L71-L73" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/meta/expr.nr#L71-L73</a></sub></sup>
+
+
+If this expression is a constructor `Type { field1: expr1, ..., fieldN: exprN }`,
+return the type and the fields.
+
+### as_for
+
+```rust title="as_for" showLineNumbers 
+pub comptime fn as_for(self) -> Option<(Quoted, Expr, Expr)> {}
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/meta/expr.nr#L78-L80" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/meta/expr.nr#L78-L80</a></sub></sup>
+
+
+If this expression is a for statement over a single expression, return the identifier,
+the expression and the for loop body.
+
+### as_for_range
+
+```rust title="as_for" showLineNumbers 
+pub comptime fn as_for(self) -> Option<(Quoted, Expr, Expr)> {}
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/meta/expr.nr#L78-L80" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/meta/expr.nr#L78-L80</a></sub></sup>
+
+
+If this expression is a for statement over a range, return the identifier,
+the range start, the range end and the for loop body.
+
+### as_function_call
+
+```rust title="as_function_call" showLineNumbers 
+pub comptime fn as_function_call(self) -> Option<(Expr, [Expr])> {}
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/meta/expr.nr#L92-L94" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/meta/expr.nr#L92-L94</a></sub></sup>
+
+
+If this expression is a function call `foo(arg1, ..., argN)`, return
+the function and a slice of each argument.
+
+### as_if
+
+```rust title="as_if" showLineNumbers 
+pub comptime fn as_if(self) -> Option<(Expr, Expr, Option<Expr>)> {}
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/meta/expr.nr#L100-L102" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/meta/expr.nr#L100-L102</a></sub></sup>
+
+
+If this expression is an `if condition { then_branch } else { else_branch }`,
+return the condition, then branch, and else branch. If there is no else branch,
+`None` is returned for that branch instead.
+
+### as_index
+
+```rust title="as_index" showLineNumbers 
+pub comptime fn as_index(self) -> Option<(Expr, Expr)> {}
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/meta/expr.nr#L107-L109" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/meta/expr.nr#L107-L109</a></sub></sup>
+
+
+If this expression is an index into an array `array[index]`, return the
+array and the index.
+
+### as_integer
+
+```rust title="as_integer" showLineNumbers 
+pub comptime fn as_integer(self) -> Option<(Field, bool)> {}
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/meta/expr.nr#L114-L116" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/meta/expr.nr#L114-L116</a></sub></sup>
+
+
+If this expression is an integer literal, return the integer as a field
+as well as whether the integer is negative (true) or not (false).
+
+### as_lambda
+
+```rust title="as_lambda" showLineNumbers 
+pub comptime fn as_lambda(
+        self,
+    ) -> Option<([(Expr, Option<UnresolvedType>)], Option<UnresolvedType>, Expr)> {}
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/meta/expr.nr#L120-L124" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/meta/expr.nr#L120-L124</a></sub></sup>
+
+
+If this expression is a lambda, returns the parameters, return type and body.
+
+### as_let
+
+```rust title="as_let" showLineNumbers 
+pub comptime fn as_let(self) -> Option<(Expr, Option<UnresolvedType>, Expr)> {}
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/meta/expr.nr#L129-L131" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/meta/expr.nr#L129-L131</a></sub></sup>
+
+
+If this expression is a let statement, returns the let pattern as an `Expr`,
+the optional type annotation, and the assigned expression.
+
+### as_member_access
+
+```rust title="as_member_access" showLineNumbers 
+pub comptime fn as_member_access(self) -> Option<(Expr, Quoted)> {}
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/meta/expr.nr#L136-L138" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/meta/expr.nr#L136-L138</a></sub></sup>
+
+
+If this expression is a member access `foo.bar`, return the struct/tuple
+expression and the field. The field will be represented as a quoted value.
+
+### as_method_call
+
+```rust title="as_method_call" showLineNumbers 
+pub comptime fn as_method_call(self) -> Option<(Expr, Quoted, [UnresolvedType], [Expr])> {}
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/meta/expr.nr#L143-L145" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/meta/expr.nr#L143-L145</a></sub></sup>
+
+
+If this expression is a method call `foo.bar::<generic1, ..., genericM>(arg1, ..., argN)`, return
+the receiver, method name, a slice of each generic argument, and a slice of each argument.
+
+### as_repeated_element_array
+
+```rust title="as_repeated_element_array" showLineNumbers 
+pub comptime fn as_repeated_element_array(self) -> Option<(Expr, Expr)> {}
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/meta/expr.nr#L150-L152" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/meta/expr.nr#L150-L152</a></sub></sup>
+
+
+If this expression is a repeated element array `[elem; length]`, return
+the repeated element and the length expressions.
+
+### as_repeated_element_slice
+
+```rust title="as_repeated_element_slice" showLineNumbers 
+pub comptime fn as_repeated_element_slice(self) -> Option<(Expr, Expr)> {}
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/meta/expr.nr#L157-L159" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/meta/expr.nr#L157-L159</a></sub></sup>
+
+
+If this expression is a repeated element slice `[elem; length]`, return
+the repeated element and the length expressions.
+
+### as_slice
+
+```rust title="as_slice" showLineNumbers 
+pub comptime fn as_slice(self) -> Option<[Expr]> {}
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/meta/expr.nr#L164-L166" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/meta/expr.nr#L164-L166</a></sub></sup>
+
+
+If this expression is a slice literal `&[elem1, ..., elemN]`,
+return each element of the slice.
+
+### as_tuple
+
+```rust title="as_tuple" showLineNumbers 
+pub comptime fn as_tuple(self) -> Option<[Expr]> {}
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/meta/expr.nr#L171-L173" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/meta/expr.nr#L171-L173</a></sub></sup>
+
+
+If this expression is a tuple `(field1, ..., fieldN)`,
+return each element of the tuple.
+
+### as_unary_op
+
+```rust title="as_unary_op" showLineNumbers 
+pub comptime fn as_unary_op(self) -> Option<(UnaryOp, Expr)> {}
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/meta/expr.nr#L178-L180" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/meta/expr.nr#L178-L180</a></sub></sup>
+
+
+If this expression is a unary operation `<op> <rhs>`,
+return the unary operator as well as the right-hand side expression.
+
+### as_unsafe
+
+```rust title="as_unsafe" showLineNumbers 
+pub comptime fn as_unsafe(self) -> Option<[Expr]> {}
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/meta/expr.nr#L185-L187" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/meta/expr.nr#L185-L187</a></sub></sup>
+
+
+If this expression is an `unsafe { stmt1; ...; stmtN }` block,
+return each statement inside in a slice.
+
+### has_semicolon
+
+```rust title="has_semicolon" showLineNumbers 
+pub comptime fn has_semicolon(self) -> bool {}
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/meta/expr.nr#L206-L208" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/meta/expr.nr#L206-L208</a></sub></sup>
+
+
+`true` if this expression is trailed by a semicolon. E.g.
+
+```
+comptime {
+    let expr1 = quote { 1 + 2 }.as_expr().unwrap();
+    let expr2 = quote { 1 + 2; }.as_expr().unwrap();
+
+    assert(expr1.as_binary_op().is_some());
+    assert(expr2.as_binary_op().is_some());
+
+    assert(!expr1.has_semicolon());
+    assert(expr2.has_semicolon());
+}
+```
+
+### is_break
+
+```rust title="is_break" showLineNumbers 
+pub comptime fn is_break(self) -> bool {}
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/meta/expr.nr#L212-L214" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/meta/expr.nr#L212-L214</a></sub></sup>
+
+
+`true` if this expression is `break`.
+
+### is_continue
+
+```rust title="is_continue" showLineNumbers 
+pub comptime fn is_continue(self) -> bool {}
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/meta/expr.nr#L218-L220" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/meta/expr.nr#L218-L220</a></sub></sup>
+
+
+`true` if this expression is `continue`.
+
+### modify
+
+```rust title="modify" showLineNumbers 
+pub comptime fn modify<Env>(self, f: fn[Env](Expr) -> Option<Expr>) -> Expr {
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/meta/expr.nr#L229-L231" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/meta/expr.nr#L229-L231</a></sub></sup>
+
+
+Applies a mapping function to this expression and to all of its sub-expressions.
+`f` will be applied to each sub-expression first, then applied to the expression itself.
+
+This happens recursively for every expression within `self`.
+
+For example, calling `modify` on `(&[1], &[2, 3])` with an `f` that returns `Option::some`
+for expressions that are integers, doubling them, would return `(&[2], &[4, 6])`.
+
+### quoted
+
+```rust title="quoted" showLineNumbers 
+pub comptime fn quoted(self) -> Quoted {
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/meta/expr.nr#L266-L268" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/meta/expr.nr#L266-L268</a></sub></sup>
+
+
+Returns this expression as a `Quoted` value. It's the same as `quote { $self }`.
+
+### resolve
+
+```rust title="resolve" showLineNumbers 
+pub comptime fn resolve(self, in_function: Option<FunctionDefinition>) -> TypedExpr {}
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/meta/expr.nr#L282-L284" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/meta/expr.nr#L282-L284</a></sub></sup>
+
+
+Resolves and type-checks this expression and returns the result as a `TypedExpr`. 
+
+The `in_function` argument specifies where the expression is resolved:
+- If it's `none`, the expression is resolved in the function where `resolve` was called
+- If it's `some`, the expression is resolved in the given function
+
+If any names used by this expression are not in scope or if there are any type errors, 
+this will give compiler errors as if the expression was written directly into 
+the current `comptime` function.
\ No newline at end of file
diff --git a/docs/versioned_docs/version-v0.38.0/noir/standard_library/meta/function_def.md b/docs/versioned_docs/version-v0.38.0/noir/standard_library/meta/function_def.md
new file mode 100644
index 00000000000..b7f2ebdb889
--- /dev/null
+++ b/docs/versioned_docs/version-v0.38.0/noir/standard_library/meta/function_def.md
@@ -0,0 +1,166 @@
+---
+title: FunctionDefinition
+---
+
+`std::meta::function_def` contains methods on the built-in `FunctionDefinition` type representing
+a function definition in the source program.
+
+## Methods
+
+### add_attribute
+
+```rust title="add_attribute" showLineNumbers 
+pub comptime fn add_attribute<let N: u32>(self, attribute: str<N>) {}
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/meta/function_def.nr#L3-L5" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/meta/function_def.nr#L3-L5</a></sub></sup>
+
+
+Adds an attribute to the function. This is only valid
+on functions in the current crate which have not yet been resolved.
+This means any functions called at compile-time are invalid targets for this method.
+
+### body
+
+```rust title="body" showLineNumbers 
+pub comptime fn body(self) -> Expr {}
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/meta/function_def.nr#L8-L10" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/meta/function_def.nr#L8-L10</a></sub></sup>
+
+
+Returns the body of the function as an expression. This is only valid
+on functions in the current crate which have not yet been resolved.
+This means any functions called at compile-time are invalid targets for this method.
+
+### has_named_attribute
+
+```rust title="has_named_attribute" showLineNumbers 
+pub comptime fn has_named_attribute<let N: u32>(self, name: str<N>) -> bool {}
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/meta/function_def.nr#L13-L15" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/meta/function_def.nr#L13-L15</a></sub></sup>
+
+
+Returns true if this function has a custom attribute with the given name.
+
+### is_unconstrained
+
+```rust title="is_unconstrained" showLineNumbers 
+pub comptime fn is_unconstrained(self) -> bool {}
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/meta/function_def.nr#L18-L20" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/meta/function_def.nr#L18-L20</a></sub></sup>
+
+
+Returns true if this function is unconstrained.
+
+### module
+
+```rust title="module" showLineNumbers 
+pub comptime fn module(self) -> Module {}
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/meta/function_def.nr#L23-L25" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/meta/function_def.nr#L23-L25</a></sub></sup>
+
+
+Returns the module where the function is defined.
+
+### name
+
+```rust title="name" showLineNumbers 
+pub comptime fn name(self) -> Quoted {}
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/meta/function_def.nr#L28-L30" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/meta/function_def.nr#L28-L30</a></sub></sup>
+
+
+Returns the name of the function.
+
+### parameters
+
+```rust title="parameters" showLineNumbers 
+pub comptime fn parameters(self) -> [(Quoted, Type)] {}
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/meta/function_def.nr#L33-L35" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/meta/function_def.nr#L33-L35</a></sub></sup>
+
+
+Returns each parameter of the function as a tuple of (parameter pattern, parameter type).
+
+### return_type
+
+```rust title="return_type" showLineNumbers 
+pub comptime fn return_type(self) -> Type {}
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/meta/function_def.nr#L38-L40" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/meta/function_def.nr#L38-L40</a></sub></sup>
+
+
+The return type of the function.
+
+### set_body
+
+```rust title="set_body" showLineNumbers 
+pub comptime fn set_body(self, body: Expr) {}
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/meta/function_def.nr#L43-L45" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/meta/function_def.nr#L43-L45</a></sub></sup>
+
+
+Mutate the function body to a new expression. This is only valid
+on functions in the current crate which have not yet been resolved.
+This means any functions called at compile-time are invalid targets for this method.
+
+### set_parameters
+
+```rust title="set_parameters" showLineNumbers 
+pub comptime fn set_parameters(self, parameters: [(Quoted, Type)]) {}
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/meta/function_def.nr#L48-L50" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/meta/function_def.nr#L48-L50</a></sub></sup>
+
+
+Mutates the function's parameters to a new set of parameters. This is only valid
+on functions in the current crate which have not yet been resolved.
+This means any functions called at compile-time are invalid targets for this method.
+
+Expects a slice of (parameter pattern, parameter type) for each parameter. Requires
+each parameter pattern to be a syntactically valid parameter.
+
+### set_return_type
+
+```rust title="set_return_type" showLineNumbers 
+pub comptime fn set_return_type(self, return_type: Type) {}
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/meta/function_def.nr#L53-L55" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/meta/function_def.nr#L53-L55</a></sub></sup>
+
+
+Mutates the function's return type to a new type. This is only valid
+on functions in the current crate which have not yet been resolved.
+This means any functions called at compile-time are invalid targets for this method.
+
+### set_return_public
+
+```rust title="set_return_public" showLineNumbers 
+pub comptime fn set_return_public(self, public: bool) {}
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/meta/function_def.nr#L58-L60" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/meta/function_def.nr#L58-L60</a></sub></sup>
+
+
+Mutates the function's return visibility to public (if `true` is given) or private (if `false` is given).
+This is only valid on functions in the current crate which have not yet been resolved.
+This means any functions called at compile-time are invalid targets for this method.
+
+### set_unconstrained
+
+```rust title="set_unconstrained" showLineNumbers 
+pub comptime fn set_unconstrained(self, value: bool) {}
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/meta/function_def.nr#L66-L68" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/meta/function_def.nr#L66-L68</a></sub></sup>
+
+
+Mutates the function to be unconstrained (if `true` is given) or not (if `false` is given).
+This is only valid on functions in the current crate which have not yet been resolved.
+This means any functions called at compile-time are invalid targets for this method.
+
+## Trait Implementations
+
+```rust
+impl Eq for FunctionDefinition
+impl Hash for FunctionDefinition
+```
+
+Note that each function is assigned a unique ID internally and this is what is used for
+equality and hashing. So even functions with identical signatures and bodies may not
+be equal in this sense if they were originally different items in the source program.
diff --git a/docs/versioned_docs/version-v0.38.0/noir/standard_library/meta/index.md b/docs/versioned_docs/version-v0.38.0/noir/standard_library/meta/index.md
new file mode 100644
index 00000000000..14544c07442
--- /dev/null
+++ b/docs/versioned_docs/version-v0.38.0/noir/standard_library/meta/index.md
@@ -0,0 +1,224 @@
+---
+title: Metaprogramming
+description: Noir's Metaprogramming API
+keywords: [metaprogramming, comptime, macros, macro, quote, unquote]
+---
+
+`std::meta` is the entry point for Noir's metaprogramming API. This consists of `comptime` functions
+and types used for inspecting and modifying Noir programs.
+
+## Functions
+
+### type_of
+
+```rust title="type_of" showLineNumbers 
+pub comptime fn type_of<T>(x: T) -> Type {}
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/meta/mod.nr#L27-L29" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/meta/mod.nr#L27-L29</a></sub></sup>
+
+
+Returns the type of a variable at compile-time.
+
+Example:
+```rust
+comptime {
+    let x: i32 = 1;
+    let x_type: Type = std::meta::type_of(x);
+
+    assert_eq(x_type, quote { i32 }.as_type());
+}
+```
+
+### unquote
+
+```rust title="unquote" showLineNumbers 
+pub comptime fn unquote(code: Quoted) -> Quoted {
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/meta/mod.nr#L19-L21" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/meta/mod.nr#L19-L21</a></sub></sup>
+
+
+Unquotes the passed-in token stream where this function was called.
+
+Example:
+```rust
+comptime {
+    let code = quote { 1 + 2 };
+
+    // let x = 1 + 2;
+    let x = unquote!(code);
+}
+```
+
+### derive
+
+```rust title="derive" showLineNumbers 
+#[varargs]
+pub comptime fn derive(s: StructDefinition, traits: [TraitDefinition]) -> Quoted {
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/meta/mod.nr#L48-L51" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/meta/mod.nr#L48-L51</a></sub></sup>
+
+
+Attribute placed on struct definitions.
+
+Creates a trait impl for each trait passed in as an argument.
+To do this, the trait must have a derive handler registered
+with `derive_via` beforehand. The traits in the stdlib that
+can be derived this way are `Eq`, `Ord`, `Default`, and `Hash`.
+
+Example:
+```rust
+#[derive(Eq, Default)]
+struct Foo<T> {
+    x: i32,
+    y: T,
+}
+
+fn main() {
+    let foo1 = Foo::default();
+    let foo2 = Foo { x: 0, y: &[0] };
+    assert_eq(foo1, foo2);
+}
+```
+
+### derive_via
+
+```rust title="derive_via_signature" showLineNumbers 
+pub comptime fn derive_via(t: TraitDefinition, f: DeriveFunction) {
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/meta/mod.nr#L68-L70" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/meta/mod.nr#L68-L70</a></sub></sup>
+
+
+Attribute placed on trait definitions.
+
+Registers a function to create impls for the given trait
+when the trait is used in a `derive` call. Users may use
+this to register their own functions to enable their traits
+to be derived by `derive`.
+
+Because this function requires a function as an argument which
+should produce a trait impl for any given struct, users may find
+it helpful to use a function like `std::meta::make_trait_impl` to
+help creating these impls.
+
+Example:
+```rust
+#[derive_via(derive_do_nothing)]
+trait DoNothing {
+    fn do_nothing(self);
+}
+
+comptime fn derive_do_nothing(s: StructDefinition) -> Quoted {
+    let typ = s.as_type();
+    quote {
+        impl DoNothing for $typ {
+            fn do_nothing(self) {
+                println("Nothing");
+            }
+        }
+    }
+}
+```
+
+As another example, `derive_eq` in the stdlib is used to derive the `Eq`
+trait for any struct. It makes use of `make_trait_impl` to do this:
+
+```rust title="derive_eq" showLineNumbers 
+comptime fn derive_eq(s: StructDefinition) -> Quoted {
+    let signature = quote { fn eq(_self: Self, _other: Self) -> bool };
+    let for_each_field = |name| quote { (_self.$name == _other.$name) };
+    let body = |fields| {
+        if s.fields().len() == 0 {
+            quote { true }
+        } else {
+            fields
+        }
+    };
+    crate::meta::make_trait_impl(
+        s,
+        quote { Eq },
+        signature,
+        for_each_field,
+        quote { & },
+        body,
+    )
+}
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/cmp.nr#L10-L30" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/cmp.nr#L10-L30</a></sub></sup>
+
+
+### make_trait_impl
+
+```rust title="make_trait_impl" showLineNumbers 
+pub comptime fn make_trait_impl<Env1, Env2>(
+    s: StructDefinition,
+    trait_name: Quoted,
+    function_signature: Quoted,
+    for_each_field: fn[Env1](Quoted) -> Quoted,
+    join_fields_with: Quoted,
+    body: fn[Env2](Quoted) -> Quoted,
+) -> Quoted {
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/meta/mod.nr#L87-L96" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/meta/mod.nr#L87-L96</a></sub></sup>
+
+
+A helper function to more easily create trait impls while deriving traits.
+
+Note that this function only works for traits which:
+1. Have only one method
+2. Have no generics on the trait itself.
+  - E.g. Using this on a trait such as `trait Foo<T> { ... }` will result in the
+    generated impl incorrectly missing the `T` generic.
+
+If your trait fits these criteria then `make_trait_impl` is likely the easiest
+way to write your derive handler. The arguments are as follows:
+
+- `s`: The struct to make the impl for
+- `trait_name`: The name of the trait to derive. E.g. `quote { Eq }`.
+- `function_signature`: The signature of the trait method to derive. E.g. `fn eq(self, other: Self) -> bool`.
+- `for_each_field`: An operation to be performed on each field. E.g. `|name| quote { (self.$name == other.$name) }`.
+- `join_fields_with`: A separator to join each result of `for_each_field` with.
+  E.g. `quote { & }`. You can also use an empty `quote {}` for no separator.
+- `body`: The result of the field operations are passed into this function for any final processing.
+  This is the place to insert any setup/teardown code the trait requires. If the trait doesn't require
+  any such code, you can return the body as-is: `|body| body`.
+
+Example deriving `Hash`:
+
+```rust title="derive_hash" showLineNumbers 
+comptime fn derive_hash(s: StructDefinition) -> Quoted {
+    let name = quote { Hash };
+    let signature = quote { fn hash<H>(_self: Self, _state: &mut H) where H: std::hash::Hasher };
+    let for_each_field = |name| quote { _self.$name.hash(_state); };
+    crate::meta::make_trait_impl(
+        s,
+        name,
+        signature,
+        for_each_field,
+        quote {},
+        |fields| fields,
+    )
+}
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/hash/mod.nr#L137-L151" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/hash/mod.nr#L137-L151</a></sub></sup>
+
+
+Example deriving `Ord`:
+
+```rust title="derive_ord" showLineNumbers 
+comptime fn derive_ord(s: StructDefinition) -> Quoted {
+    let signature = quote { fn cmp(_self: Self, _other: Self) -> std::cmp::Ordering };
+    let for_each_field = |name| quote {
+        if result == std::cmp::Ordering::equal() {
+            result = _self.$name.cmp(_other.$name);
+        }
+    };
+    let body = |fields| quote {
+        let mut result = std::cmp::Ordering::equal();
+        $fields
+        result
+    };
+    crate::meta::make_trait_impl(s, quote { Ord }, signature, for_each_field, quote {}, body)
+}
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/cmp.nr#L216-L231" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/cmp.nr#L216-L231</a></sub></sup>
+
diff --git a/docs/versioned_docs/version-v0.38.0/noir/standard_library/meta/module.md b/docs/versioned_docs/version-v0.38.0/noir/standard_library/meta/module.md
new file mode 100644
index 00000000000..f47231972b7
--- /dev/null
+++ b/docs/versioned_docs/version-v0.38.0/noir/standard_library/meta/module.md
@@ -0,0 +1,82 @@
+---
+title: Module
+---
+
+`std::meta::module` contains methods on the built-in `Module` type which represents a module in the source program.
+Note that this type represents a module generally, it isn't limited to only `mod my_submodule { ... }`
+declarations in the source program.
+
+## Methods
+
+### add_item
+
+```rust title="add_item" showLineNumbers 
+pub comptime fn add_item(self, item: Quoted) {}
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/meta/module.nr#L3-L5" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/meta/module.nr#L3-L5</a></sub></sup>
+
+
+Adds a top-level item (a function, a struct, a global, etc.) to the module. 
+Adding multiple items in one go is also valid if the `Quoted` value has multiple items in it.  
+Note that the items are type-checked as if they are inside the module they are being added to.
+
+### functions
+
+```rust title="functions" showLineNumbers 
+pub comptime fn functions(self) -> [FunctionDefinition] {}
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/meta/module.nr#L18-L20" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/meta/module.nr#L18-L20</a></sub></sup>
+
+
+Returns each function defined in the module.
+
+### has_named_attribute
+
+```rust title="has_named_attribute" showLineNumbers 
+pub comptime fn has_named_attribute<let N: u32>(self, name: str<N>) -> bool {}
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/meta/module.nr#L8-L10" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/meta/module.nr#L8-L10</a></sub></sup>
+
+
+Returns true if this module has a custom attribute with the given name.
+
+### is_contract
+
+```rust title="is_contract" showLineNumbers 
+pub comptime fn is_contract(self) -> bool {}
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/meta/module.nr#L13-L15" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/meta/module.nr#L13-L15</a></sub></sup>
+
+
+`true` if this module is a contract module (was declared via `contract foo { ... }`).
+
+### name
+
+```rust title="name" showLineNumbers 
+pub comptime fn name(self) -> Quoted {}
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/meta/module.nr#L28-L30" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/meta/module.nr#L28-L30</a></sub></sup>
+
+
+Returns the name of the module.
+
+### structs
+
+```rust title="structs" showLineNumbers 
+pub comptime fn structs(self) -> [StructDefinition] {}
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/meta/module.nr#L23-L25" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/meta/module.nr#L23-L25</a></sub></sup>
+
+
+Returns each struct defined in the module.
+
+## Trait Implementations
+
+```rust
+impl Eq for Module
+impl Hash for Module
+```
+
+Note that each module is assigned a unique ID internally and this is what is used for
+equality and hashing. So even modules with identical names and contents may not
+be equal in this sense if they were originally different items in the source program.
diff --git a/docs/versioned_docs/version-v0.38.0/noir/standard_library/meta/op.md b/docs/versioned_docs/version-v0.38.0/noir/standard_library/meta/op.md
new file mode 100644
index 00000000000..03ea49ad8ec
--- /dev/null
+++ b/docs/versioned_docs/version-v0.38.0/noir/standard_library/meta/op.md
@@ -0,0 +1,244 @@
+---
+title: UnaryOp and BinaryOp
+---
+
+`std::meta::op` contains the `UnaryOp` and `BinaryOp` types as well as methods on them.
+These types are used to represent a unary or binary operator respectively in Noir source code.
+
+## Types
+
+### UnaryOp
+
+Represents a unary operator. One of `-`, `!`, `&mut`, or `*`.
+
+### Methods
+
+#### is_minus
+
+```rust title="is_minus" showLineNumbers 
+pub fn is_minus(self) -> bool {
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/meta/op.nr#L24-L26" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/meta/op.nr#L24-L26</a></sub></sup>
+
+
+Returns `true` if this operator is `-`.
+
+#### is_not
+
+```rust title="is_not" showLineNumbers 
+pub fn is_not(self) -> bool {
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/meta/op.nr#L30-L32" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/meta/op.nr#L30-L32</a></sub></sup>
+
+
+`true` if this operator is `!`
+
+#### is_mutable_reference
+
+```rust title="is_mutable_reference" showLineNumbers 
+pub fn is_mutable_reference(self) -> bool {
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/meta/op.nr#L36-L38" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/meta/op.nr#L36-L38</a></sub></sup>
+
+
+`true` if this operator is `&mut`
+
+#### is_dereference
+
+```rust title="is_dereference" showLineNumbers 
+pub fn is_dereference(self) -> bool {
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/meta/op.nr#L42-L44" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/meta/op.nr#L42-L44</a></sub></sup>
+
+
+`true` if this operator is `*`
+
+#### quoted
+
+```rust title="unary_quoted" showLineNumbers 
+pub comptime fn quoted(self) -> Quoted {
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/meta/op.nr#L48-L50" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/meta/op.nr#L48-L50</a></sub></sup>
+
+
+Returns this operator as a `Quoted` value.
+
+### Trait Implementations
+
+```rust
+impl Eq for UnaryOp
+impl Hash for UnaryOp
+```
+
+### BinaryOp
+
+Represents a binary operator. One of `+`, `-`, `*`, `/`, `%`, `==`, `!=`, `<`, `<=`, `>`, `>=`, `&`, `|`, `^`, `>>`, or `<<`.
+
+### Methods
+
+#### is_add
+
+```rust title="is_add" showLineNumbers 
+pub fn is_add(self) -> bool {
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/meta/op.nr#L86-L88" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/meta/op.nr#L86-L88</a></sub></sup>
+
+
+`true` if this operator is `+`
+
+#### is_subtract
+
+```rust title="is_subtract" showLineNumbers 
+pub fn is_subtract(self) -> bool {
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/meta/op.nr#L92-L94" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/meta/op.nr#L92-L94</a></sub></sup>
+
+
+`true` if this operator is `-`
+
+#### is_multiply
+
+```rust title="is_multiply" showLineNumbers 
+pub fn is_multiply(self) -> bool {
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/meta/op.nr#L98-L100" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/meta/op.nr#L98-L100</a></sub></sup>
+
+
+`true` if this operator is `*`
+
+#### is_divide
+
+```rust title="is_divide" showLineNumbers 
+pub fn is_divide(self) -> bool {
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/meta/op.nr#L104-L106" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/meta/op.nr#L104-L106</a></sub></sup>
+
+
+`true` if this operator is `/`
+
+#### is_modulo
+
+```rust title="is_modulo" showLineNumbers 
+pub fn is_modulo(self) -> bool {
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/meta/op.nr#L176-L178" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/meta/op.nr#L176-L178</a></sub></sup>
+
+
+`true` if this operator is `%`
+
+#### is_equal
+
+```rust title="is_equal" showLineNumbers 
+pub fn is_equal(self) -> bool {
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/meta/op.nr#L110-L112" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/meta/op.nr#L110-L112</a></sub></sup>
+
+
+`true` if this operator is `==`
+
+#### is_not_equal
+
+```rust title="is_not_equal" showLineNumbers 
+pub fn is_not_equal(self) -> bool {
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/meta/op.nr#L116-L118" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/meta/op.nr#L116-L118</a></sub></sup>
+
+
+`true` if this operator is `!=`
+
+#### is_less_than
+
+```rust title="is_less_than" showLineNumbers 
+pub fn is_less_than(self) -> bool {
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/meta/op.nr#L122-L124" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/meta/op.nr#L122-L124</a></sub></sup>
+
+
+`true` if this operator is `<`
+
+#### is_less_than_or_equal
+
+```rust title="is_less_than_or_equal" showLineNumbers 
+pub fn is_less_than_or_equal(self) -> bool {
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/meta/op.nr#L128-L130" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/meta/op.nr#L128-L130</a></sub></sup>
+
+
+`true` if this operator is `<=`
+
+#### is_greater_than
+
+```rust title="is_greater_than" showLineNumbers 
+pub fn is_greater_than(self) -> bool {
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/meta/op.nr#L134-L136" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/meta/op.nr#L134-L136</a></sub></sup>
+
+
+`true` if this operator is `>`
+
+#### is_greater_than_or_equal
+
+```rust title="is_greater_than_or_equal" showLineNumbers 
+pub fn is_greater_than_or_equal(self) -> bool {
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/meta/op.nr#L140-L142" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/meta/op.nr#L140-L142</a></sub></sup>
+
+
+`true` if this operator is `>=`
+
+#### is_and
+
+```rust title="is_and" showLineNumbers 
+pub fn is_and(self) -> bool {
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/meta/op.nr#L146-L148" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/meta/op.nr#L146-L148</a></sub></sup>
+
+
+`true` if this operator is `&`
+
+#### is_or
+
+```rust title="is_or" showLineNumbers 
+pub fn is_or(self) -> bool {
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/meta/op.nr#L152-L154" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/meta/op.nr#L152-L154</a></sub></sup>
+
+
+`true` if this operator is `|`
+
+#### is_shift_right
+
+```rust title="is_shift_right" showLineNumbers 
+pub fn is_shift_right(self) -> bool {
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/meta/op.nr#L164-L166" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/meta/op.nr#L164-L166</a></sub></sup>
+
+
+`true` if this operator is `>>`
+
+#### is_shift_left
+
+```rust title="is_shift_right" showLineNumbers 
+pub fn is_shift_right(self) -> bool {
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/meta/op.nr#L164-L166" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/meta/op.nr#L164-L166</a></sub></sup>
+
+
+`true` if this operator is `<<`
+
+#### quoted
+
+```rust title="binary_quoted" showLineNumbers 
+pub comptime fn quoted(self) -> Quoted {
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/meta/op.nr#L182-L184" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/meta/op.nr#L182-L184</a></sub></sup>
+
+
+Returns this operator as a `Quoted` value.
+
+### Trait Implementations
+
+```rust
+impl Eq for BinaryOp
+impl Hash for BinaryOp
+```
diff --git a/docs/versioned_docs/version-v0.38.0/noir/standard_library/meta/quoted.md b/docs/versioned_docs/version-v0.38.0/noir/standard_library/meta/quoted.md
new file mode 100644
index 00000000000..d7acf23bc07
--- /dev/null
+++ b/docs/versioned_docs/version-v0.38.0/noir/standard_library/meta/quoted.md
@@ -0,0 +1,141 @@
+---
+title: Quoted
+---
+
+`std::meta::quoted` contains methods on the built-in `Quoted` type which represents
+quoted token streams and is the result of the `quote { ... }` expression.
+
+## Methods
+
+### as_expr
+
+```rust title="as_expr" showLineNumbers 
+pub comptime fn as_expr(self) -> Option<Expr> {}
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/meta/quoted.nr#L6-L8" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/meta/quoted.nr#L6-L8</a></sub></sup>
+
+
+Parses the quoted token stream as an expression. Returns `Option::none()` if
+the expression failed to parse.
+
+Example:
+
+```rust title="as_expr_example" showLineNumbers 
+#[test]
+    fn test_expr_as_function_call() {
+        comptime
+        {
+            let expr = quote { foo(42) }.as_expr().unwrap();
+            let (_function, args) = expr.as_function_call().unwrap();
+            assert_eq(args.len(), 1);
+            assert_eq(args[0].as_integer().unwrap(), (42, false));
+        }
+    }
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/test_programs/noir_test_success/comptime_expr/src/main.nr#L360-L371" target="_blank" rel="noopener noreferrer">Source code: test_programs/noir_test_success/comptime_expr/src/main.nr#L360-L371</a></sub></sup>
+
+
+### as_module
+
+```rust title="as_module" showLineNumbers 
+pub comptime fn as_module(self) -> Option<Module> {}
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/meta/quoted.nr#L11-L13" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/meta/quoted.nr#L11-L13</a></sub></sup>
+
+
+Interprets this token stream as a module path leading to the name of a module.
+Returns `Option::none()` if the module isn't found or this token stream cannot be parsed as a path.
+
+Example:
+
+```rust title="as_module_example" showLineNumbers 
+mod baz {
+    pub mod qux {}
+}
+
+#[test]
+fn as_module_test() {
+    comptime {
+        let my_mod = quote { baz::qux }.as_module().unwrap();
+        assert_eq(my_mod.name(), quote { qux });
+    }
+}
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/test_programs/compile_success_empty/comptime_module/src/main.nr#L115-L127" target="_blank" rel="noopener noreferrer">Source code: test_programs/compile_success_empty/comptime_module/src/main.nr#L115-L127</a></sub></sup>
+
+
+### as_trait_constraint
+
+```rust title="as_trait_constraint" showLineNumbers 
+pub comptime fn as_trait_constraint(self) -> TraitConstraint {}
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/meta/quoted.nr#L16-L18" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/meta/quoted.nr#L16-L18</a></sub></sup>
+
+
+Interprets this token stream as a trait constraint (without an object type).
+Note that this function panics instead of returning `Option::none()` if the token
+stream does not parse and resolve to a valid trait constraint.
+
+Example:
+
+```rust title="implements_example" showLineNumbers 
+pub fn function_with_where<T>(_x: T)
+where
+    T: SomeTrait<i32>,
+{
+    comptime {
+        let t = quote { T }.as_type();
+        let some_trait_i32 = quote { SomeTrait<i32> }.as_trait_constraint();
+        assert(t.implements(some_trait_i32));
+
+        assert(t.get_trait_impl(some_trait_i32).is_none());
+    }
+}
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/test_programs/compile_success_empty/comptime_type/src/main.nr#L160-L173" target="_blank" rel="noopener noreferrer">Source code: test_programs/compile_success_empty/comptime_type/src/main.nr#L160-L173</a></sub></sup>
+
+
+### as_type
+
+```rust title="as_type" showLineNumbers 
+pub comptime fn as_type(self) -> Type {}
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/meta/quoted.nr#L21-L23" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/meta/quoted.nr#L21-L23</a></sub></sup>
+
+
+Interprets this token stream as a resolved type. Panics if the token
+stream doesn't parse to a type or if the type isn't a valid type in scope.
+
+```rust title="implements_example" showLineNumbers 
+pub fn function_with_where<T>(_x: T)
+where
+    T: SomeTrait<i32>,
+{
+    comptime {
+        let t = quote { T }.as_type();
+        let some_trait_i32 = quote { SomeTrait<i32> }.as_trait_constraint();
+        assert(t.implements(some_trait_i32));
+
+        assert(t.get_trait_impl(some_trait_i32).is_none());
+    }
+}
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/test_programs/compile_success_empty/comptime_type/src/main.nr#L160-L173" target="_blank" rel="noopener noreferrer">Source code: test_programs/compile_success_empty/comptime_type/src/main.nr#L160-L173</a></sub></sup>
+
+
+### tokens
+
+```rust title="tokens" showLineNumbers 
+pub comptime fn tokens(self) -> [Quoted] {}
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/meta/quoted.nr#L26-L28" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/meta/quoted.nr#L26-L28</a></sub></sup>
+
+
+Returns a slice of the individual tokens that form this token stream.
+
+## Trait Implementations
+
+```rust
+impl Eq for Quoted
+impl Hash for Quoted
+```
diff --git a/docs/versioned_docs/version-v0.38.0/noir/standard_library/meta/struct_def.md b/docs/versioned_docs/version-v0.38.0/noir/standard_library/meta/struct_def.md
new file mode 100644
index 00000000000..fd609942f4e
--- /dev/null
+++ b/docs/versioned_docs/version-v0.38.0/noir/standard_library/meta/struct_def.md
@@ -0,0 +1,177 @@
+---
+title: StructDefinition
+---
+
+`std::meta::struct_def` contains methods on the built-in `StructDefinition` type.
+This type corresponds to `struct Name { field1: Type1, ... }` items in the source program.
+
+## Methods
+
+### add_attribute
+
+```rust title="add_attribute" showLineNumbers 
+pub comptime fn add_attribute<let N: u32>(self, attribute: str<N>) {}
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/meta/struct_def.nr#L3-L5" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/meta/struct_def.nr#L3-L5</a></sub></sup>
+
+
+Adds an attribute to the struct.
+
+### add_generic
+
+```rust title="add_generic" showLineNumbers 
+pub comptime fn add_generic<let N: u32>(self, generic_name: str<N>) -> Type {}
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/meta/struct_def.nr#L8-L10" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/meta/struct_def.nr#L8-L10</a></sub></sup>
+
+
+Adds an generic to the struct. Returns the new generic type.
+Errors if the given generic name isn't a single identifier or if
+the struct already has a generic with the same name.
+
+This method should be used carefully, if there is existing code referring
+to the struct type it may be checked before this function is called and
+see the struct with the original number of generics. This method should
+thus be preferred to use on code generated from other macros and structs
+that are not used in function signatures.
+
+Example:
+
+```rust title="add-generic-example" showLineNumbers 
+comptime fn add_generic(s: StructDefinition) {
+        assert_eq(s.generics().len(), 0);
+        let new_generic = s.add_generic("T");
+
+        let generics = s.generics();
+        assert_eq(generics.len(), 1);
+        assert_eq(generics[0], new_generic);
+    }
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/test_programs/compile_success_empty/comptime_struct_definition/src/main.nr#L35-L44" target="_blank" rel="noopener noreferrer">Source code: test_programs/compile_success_empty/comptime_struct_definition/src/main.nr#L35-L44</a></sub></sup>
+
+
+### as_type
+
+```rust title="as_type" showLineNumbers 
+pub comptime fn as_type(self) -> Type {}
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/meta/struct_def.nr#L15-L17" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/meta/struct_def.nr#L15-L17</a></sub></sup>
+
+
+Returns this struct as a type in the source program. If this struct has
+any generics, the generics are also included as-is.
+
+### generics
+
+```rust title="generics" showLineNumbers 
+pub comptime fn generics(self) -> [Type] {}
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/meta/struct_def.nr#L26-L28" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/meta/struct_def.nr#L26-L28</a></sub></sup>
+
+
+Returns each generic on this struct.
+
+Example:
+
+```
+#[example]
+struct Foo<T, U> {
+    bar: [T; 2],
+    baz: Baz<U, U>,
+}
+
+comptime fn example(foo: StructDefinition) {
+    assert_eq(foo.generics().len(), 2);
+
+    // Fails because `T` isn't in scope
+    // let t = quote { T }.as_type();
+    // assert_eq(foo.generics()[0], t);
+}
+```
+
+### fields
+
+```rust title="fields" showLineNumbers 
+pub comptime fn fields(self) -> [(Quoted, Type)] {}
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/meta/struct_def.nr#L33-L35" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/meta/struct_def.nr#L33-L35</a></sub></sup>
+
+
+Returns each field of this struct as a pair of (field name, field type).
+
+### has_named_attribute
+
+```rust title="has_named_attribute" showLineNumbers 
+pub comptime fn has_named_attribute<let N: u32>(self, name: str<N>) -> bool {}
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/meta/struct_def.nr#L20-L22" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/meta/struct_def.nr#L20-L22</a></sub></sup>
+
+
+Returns true if this struct has a custom attribute with the given name.
+
+### module
+
+```rust title="module" showLineNumbers 
+pub comptime fn module(self) -> Module {}
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/meta/struct_def.nr#L38-L40" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/meta/struct_def.nr#L38-L40</a></sub></sup>
+
+
+Returns the module where the struct is defined.
+
+### name
+
+```rust title="name" showLineNumbers 
+pub comptime fn name(self) -> Quoted {}
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/meta/struct_def.nr#L43-L45" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/meta/struct_def.nr#L43-L45</a></sub></sup>
+
+
+Returns the name of this struct
+
+Note that the returned quoted value will be just the struct name, it will
+not be the full path to the struct, nor will it include any generics.
+
+### set_fields
+
+```rust title="set_fields" showLineNumbers 
+pub comptime fn set_fields(self, new_fields: [(Quoted, Type)]) {}
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/meta/struct_def.nr#L52-L54" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/meta/struct_def.nr#L52-L54</a></sub></sup>
+
+
+Sets the fields of this struct to the given fields list where each element
+is a pair of the field's name and the field's type. Expects each field name
+to be a single identifier. Note that this will override any previous fields
+on this struct. If those should be preserved, use `.fields()` to retrieve the
+current fields on the struct type and append the new fields from there.
+
+Example:
+
+```rust
+// Change this struct to:
+// struct Foo {
+//     a: u32,
+//     b: i8,
+// }
+#[mangle_fields]
+struct Foo { x: Field }
+
+comptime fn mangle_fields(s: StructDefinition) {
+    s.set_fields(&[
+        (quote { a }, quote { u32 }.as_type()),
+        (quote { b }, quote { i8 }.as_type()),
+    ]);
+}
+```
+
+## Trait Implementations
+
+```rust
+impl Eq for StructDefinition
+impl Hash for StructDefinition
+```
+
+Note that each struct is assigned a unique ID internally and this is what is used for
+equality and hashing. So even structs with identical generics and fields may not
+be equal in this sense if they were originally different items in the source program.
diff --git a/docs/versioned_docs/version-v0.38.0/noir/standard_library/meta/trait_constraint.md b/docs/versioned_docs/version-v0.38.0/noir/standard_library/meta/trait_constraint.md
new file mode 100644
index 00000000000..3106f732b5a
--- /dev/null
+++ b/docs/versioned_docs/version-v0.38.0/noir/standard_library/meta/trait_constraint.md
@@ -0,0 +1,17 @@
+---
+title: TraitConstraint
+---
+
+`std::meta::trait_constraint` contains methods on the built-in `TraitConstraint` type which represents
+a trait constraint that can be used to search for a trait implementation. This is similar
+syntactically to just the trait itself, but can also contain generic arguments. E.g. `Eq`, `Default`,
+`BuildHasher<Poseidon2Hasher>`.
+
+This type currently has no public methods but it can be used alongside `Type` in `implements` or `get_trait_impl`.
+
+## Trait Implementations
+
+```rust
+impl Eq for TraitConstraint
+impl Hash for TraitConstraint
+```
diff --git a/docs/versioned_docs/version-v0.38.0/noir/standard_library/meta/trait_def.md b/docs/versioned_docs/version-v0.38.0/noir/standard_library/meta/trait_def.md
new file mode 100644
index 00000000000..e661d3af7f1
--- /dev/null
+++ b/docs/versioned_docs/version-v0.38.0/noir/standard_library/meta/trait_def.md
@@ -0,0 +1,26 @@
+---
+title: TraitDefinition
+---
+
+`std::meta::trait_def` contains methods on the built-in `TraitDefinition` type. This type
+represents trait definitions such as `trait Foo { .. }` at the top-level of a program.
+
+## Methods
+
+### as_trait_constraint
+
+```rust title="as_trait_constraint" showLineNumbers 
+pub comptime fn as_trait_constraint(_self: Self) -> TraitConstraint {}
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/meta/trait_def.nr#L6-L8" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/meta/trait_def.nr#L6-L8</a></sub></sup>
+
+
+Converts this trait into a trait constraint. If there are any generics on this
+trait, they will be kept as-is without instantiating or replacing them.
+
+## Trait Implementations
+
+```rust
+impl Eq for TraitDefinition
+impl Hash for TraitDefinition
+```
diff --git a/docs/versioned_docs/version-v0.38.0/noir/standard_library/meta/trait_impl.md b/docs/versioned_docs/version-v0.38.0/noir/standard_library/meta/trait_impl.md
new file mode 100644
index 00000000000..a527617c1e6
--- /dev/null
+++ b/docs/versioned_docs/version-v0.38.0/noir/standard_library/meta/trait_impl.md
@@ -0,0 +1,60 @@
+---
+title: TraitImpl
+---
+
+`std::meta::trait_impl` contains methods on the built-in `TraitImpl` type which represents a trait
+implementation such as `impl Foo for Bar { ... }`.
+
+## Methods
+
+### trait_generic_args
+
+```rust title="trait_generic_args" showLineNumbers 
+pub comptime fn trait_generic_args(self) -> [Type] {}
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/meta/trait_impl.nr#L3-L5" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/meta/trait_impl.nr#L3-L5</a></sub></sup>
+
+
+Returns any generic arguments on the trait of this trait implementation, if any.
+
+```rs
+impl Foo<i32, Field> for Bar { ... }
+
+comptime {
+    let bar_type = quote { Bar }.as_type();
+    let foo = quote { Foo<i32, Field> }.as_trait_constraint();
+
+    let my_impl: TraitImpl = bar_type.get_trait_impl(foo).unwrap();
+
+    let generics = my_impl.trait_generic_args();
+    assert_eq(generics.len(), 2);
+
+    assert_eq(generics[0], quote { i32 }.as_type());
+    assert_eq(generics[1], quote { Field }.as_type());
+}
+```
+
+### methods
+
+```rust title="methods" showLineNumbers 
+pub comptime fn methods(self) -> [FunctionDefinition] {}
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/meta/trait_impl.nr#L8-L10" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/meta/trait_impl.nr#L8-L10</a></sub></sup>
+
+
+Returns each method in this trait impl.
+
+Example:
+
+```rs
+comptime {
+    let i32_type = quote { i32 }.as_type();
+    let eq = quote { Eq }.as_trait_constraint();
+
+    let impl_eq_for_i32: TraitImpl = i32_type.get_trait_impl(eq).unwrap();
+    let methods = impl_eq_for_i32.methods();
+
+    assert_eq(methods.len(), 1);
+    assert_eq(methods[0].name(), quote { eq });
+}
+```
diff --git a/docs/versioned_docs/version-v0.38.0/noir/standard_library/meta/typ.md b/docs/versioned_docs/version-v0.38.0/noir/standard_library/meta/typ.md
new file mode 100644
index 00000000000..90222c222f5
--- /dev/null
+++ b/docs/versioned_docs/version-v0.38.0/noir/standard_library/meta/typ.md
@@ -0,0 +1,264 @@
+---
+title: Type
+---
+
+`std::meta::typ` contains methods on the built-in `Type` type used for representing
+a type in the source program.
+
+## Functions
+
+```rust title="fresh_type_variable" showLineNumbers 
+pub comptime fn fresh_type_variable() -> Type {}
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/meta/typ.nr#L57-L59" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/meta/typ.nr#L57-L59</a></sub></sup>
+
+
+Creates and returns an unbound type variable. This is a special kind of type internal
+to type checking which will type check with any other type. When it is type checked
+against another type it will also be set to that type. For example, if `a` is a type
+variable and we have the type equality `(a, i32) = (u8, i32)`, the compiler will set
+`a` equal to `u8`.
+
+Unbound type variables will often be rendered as `_` while printing them. Bound type
+variables will appear as the type they are bound to.
+
+This can be used in conjunction with functions which internally perform type checks
+such as `Type::implements` or `Type::get_trait_impl` to potentially grab some of the types used.
+
+Note that calling `Type::implements` or `Type::get_trait_impl` on a type variable will always
+fail.
+
+Example:
+
+```rust title="serialize-setup" showLineNumbers 
+trait Serialize<let N: u32> {}
+
+impl Serialize<1> for Field {}
+
+impl<T, let N: u32, let M: u32> Serialize<N * M> for [T; N]
+where
+    T: Serialize<M>,
+{}
+
+impl<T, U, let N: u32, let M: u32> Serialize<N + M> for (T, U)
+where
+    T: Serialize<N>,
+    U: Serialize<M>,
+{}
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/test_programs/compile_success_empty/comptime_type/src/main.nr#L14-L29" target="_blank" rel="noopener noreferrer">Source code: test_programs/compile_success_empty/comptime_type/src/main.nr#L14-L29</a></sub></sup>
+
+```rust title="fresh-type-variable-example" showLineNumbers 
+let typevar1 = std::meta::typ::fresh_type_variable();
+        let constraint = quote { Serialize<$typevar1> }.as_trait_constraint();
+        let field_type = quote { Field }.as_type();
+
+        // Search for a trait impl (binding typevar1 to 1 when the impl is found):
+        assert(field_type.implements(constraint));
+
+        // typevar1 should be bound to the "1" generic now:
+        assert_eq(typevar1.as_constant().unwrap(), 1);
+
+        // If we want to do the same with a different type, we need to
+        // create a new type variable now that `typevar1` is bound
+        let typevar2 = std::meta::typ::fresh_type_variable();
+        let constraint = quote { Serialize<$typevar2> }.as_trait_constraint();
+        let array_type = quote { [(Field, Field); 5] }.as_type();
+        assert(array_type.implements(constraint));
+
+        // Now typevar2 should be bound to the serialized pair size 2 times the array length 5
+        assert_eq(typevar2.as_constant().unwrap(), 10);
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/test_programs/compile_success_empty/comptime_type/src/main.nr#L129-L149" target="_blank" rel="noopener noreferrer">Source code: test_programs/compile_success_empty/comptime_type/src/main.nr#L129-L149</a></sub></sup>
+
+
+## Methods
+
+### as_array
+
+```rust title="as_array" showLineNumbers 
+pub comptime fn as_array(self) -> Option<(Type, Type)> {}
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/meta/typ.nr#L76-L78" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/meta/typ.nr#L76-L78</a></sub></sup>
+
+
+If this type is an array, return a pair of (element type, size type).
+
+Example:
+
+```rust
+comptime {
+    let array_type = quote { [Field; 3] }.as_type();
+    let (field_type, three_type) = array_type.as_array().unwrap();
+
+    assert(field_type.is_field());
+    assert_eq(three_type.as_constant().unwrap(), 3);
+}
+```
+
+### as_constant
+
+```rust title="as_constant" showLineNumbers 
+pub comptime fn as_constant(self) -> Option<u32> {}
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/meta/typ.nr#L83-L85" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/meta/typ.nr#L83-L85</a></sub></sup>
+
+
+If this type is a constant integer (such as the `3` in the array type `[Field; 3]`),
+return the numeric constant.
+
+### as_integer
+
+```rust title="as_integer" showLineNumbers 
+pub comptime fn as_integer(self) -> Option<(bool, u8)> {}
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/meta/typ.nr#L90-L92" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/meta/typ.nr#L90-L92</a></sub></sup>
+
+
+If this is an integer type, return a boolean which is `true`
+if the type is signed, as well as the number of bits of this integer type.
+
+### as_mutable_reference
+
+```rust title="as_mutable_reference" showLineNumbers 
+comptime fn as_mutable_reference(self) -> Option<Type> {}
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/meta/typ.nr#L96-L98" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/meta/typ.nr#L96-L98</a></sub></sup>
+
+
+If this is a mutable reference type `&mut T`, returns the mutable type `T`.
+
+### as_slice
+
+```rust title="as_slice" showLineNumbers 
+pub comptime fn as_slice(self) -> Option<Type> {}
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/meta/typ.nr#L102-L104" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/meta/typ.nr#L102-L104</a></sub></sup>
+
+
+If this is a slice type, return the element type of the slice.
+
+### as_str
+
+```rust title="as_str" showLineNumbers 
+pub comptime fn as_str(self) -> Option<Type> {}
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/meta/typ.nr#L108-L110" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/meta/typ.nr#L108-L110</a></sub></sup>
+
+
+If this is a `str<N>` type, returns the length `N` as a type.
+
+### as_struct
+
+```rust title="as_struct" showLineNumbers 
+pub comptime fn as_struct(self) -> Option<(StructDefinition, [Type])> {}
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/meta/typ.nr#L114-L116" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/meta/typ.nr#L114-L116</a></sub></sup>
+
+
+If this is a struct type, returns the struct in addition to
+any generic arguments on this type.
+
+### as_tuple
+
+```rust title="as_tuple" showLineNumbers 
+pub comptime fn as_tuple(self) -> Option<[Type]> {}
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/meta/typ.nr#L120-L122" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/meta/typ.nr#L120-L122</a></sub></sup>
+
+
+If this is a tuple type, returns each element type of the tuple.
+
+### get_trait_impl
+
+```rust title="get_trait_impl" showLineNumbers 
+pub comptime fn get_trait_impl(self, constraint: TraitConstraint) -> Option<TraitImpl> {}
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/meta/typ.nr#L143-L145" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/meta/typ.nr#L143-L145</a></sub></sup>
+
+
+Retrieves the trait implementation that implements the given
+trait constraint for this type. If the trait constraint is not
+found, `None` is returned. Note that since the concrete trait implementation
+for a trait constraint specified from a `where` clause is unknown,
+this function will return `None` in these cases. If you only want to know
+whether a type implements a trait, use `implements` instead.
+
+Example:
+
+```rust
+comptime {
+    let field_type = quote { Field }.as_type();
+    let default = quote { Default }.as_trait_constraint();
+
+    let the_impl: TraitImpl = field_type.get_trait_impl(default).unwrap();
+    assert(the_impl.methods().len(), 1);
+}
+```
+
+### implements
+
+```rust title="implements" showLineNumbers 
+pub comptime fn implements(self, constraint: TraitConstraint) -> bool {}
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/meta/typ.nr#L166-L168" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/meta/typ.nr#L166-L168</a></sub></sup>
+
+
+`true` if this type implements the given trait. Note that unlike
+`get_trait_impl` this will also return true for any `where` constraints
+in scope.
+
+Example:
+
+```rust
+fn foo<T>() where T: Default {
+    comptime {
+        let field_type = quote { Field }.as_type();
+        let default = quote { Default }.as_trait_constraint();
+        assert(field_type.implements(default));
+
+        let t = quote { T }.as_type();
+        assert(t.implements(default));
+    }
+}
+```
+
+### is_bool
+
+```rust title="is_bool" showLineNumbers 
+pub comptime fn is_bool(self) -> bool {}
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/meta/typ.nr#L172-L174" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/meta/typ.nr#L172-L174</a></sub></sup>
+
+
+`true` if this type is `bool`.
+
+### is_field
+
+```rust title="is_field" showLineNumbers 
+pub comptime fn is_field(self) -> bool {}
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/meta/typ.nr#L178-L180" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/meta/typ.nr#L178-L180</a></sub></sup>
+
+
+`true` if this type is `Field`.
+
+### is_unit
+
+```rust title="is_unit" showLineNumbers 
+comptime fn is_unit(self) -> bool {}
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/meta/typ.nr#L184-L186" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/meta/typ.nr#L184-L186</a></sub></sup>
+
+
+`true` if this type is the unit `()` type.
+
+## Trait Implementations
+
+```rust
+impl Eq for Type
+impl Hash for Type
+```
+Note that this is syntactic equality, this is not the same as whether two types will type check
+to be the same type. Unless type inference or generics are being used however, users should not
+typically have to worry about this distinction unless `std::meta::typ::fresh_type_variable` is used.
diff --git a/docs/versioned_docs/version-v0.38.0/noir/standard_library/meta/typed_expr.md b/docs/versioned_docs/version-v0.38.0/noir/standard_library/meta/typed_expr.md
new file mode 100644
index 00000000000..0db7dbfef61
--- /dev/null
+++ b/docs/versioned_docs/version-v0.38.0/noir/standard_library/meta/typed_expr.md
@@ -0,0 +1,27 @@
+---
+title: TypedExpr
+---
+
+`std::meta::typed_expr` contains methods on the built-in `TypedExpr` type for resolved and type-checked expressions.
+
+## Methods
+
+### get_type
+
+```rust title="as_function_definition" showLineNumbers 
+pub comptime fn as_function_definition(self) -> Option<FunctionDefinition> {}
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/meta/typed_expr.nr#L7-L9" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/meta/typed_expr.nr#L7-L9</a></sub></sup>
+
+
+If this expression refers to a function definitions, returns it. Otherwise returns `Option::none()`.
+
+### get_type
+
+```rust title="get_type" showLineNumbers 
+pub comptime fn get_type(self) -> Option<Type> {}
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/meta/typed_expr.nr#L13-L15" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/meta/typed_expr.nr#L13-L15</a></sub></sup>
+
+
+Returns the type of the expression, or `Option::none()` if there were errors when the expression was previously resolved.
\ No newline at end of file
diff --git a/docs/versioned_docs/version-v0.38.0/noir/standard_library/meta/unresolved_type.md b/docs/versioned_docs/version-v0.38.0/noir/standard_library/meta/unresolved_type.md
new file mode 100644
index 00000000000..2826ec5ec0f
--- /dev/null
+++ b/docs/versioned_docs/version-v0.38.0/noir/standard_library/meta/unresolved_type.md
@@ -0,0 +1,57 @@
+---
+title: UnresolvedType
+---
+
+`std::meta::unresolved_type` contains methods on the built-in `UnresolvedType` type for the syntax of types.
+
+## Methods
+
+### as_mutable_reference
+
+```rust title="as_mutable_reference" showLineNumbers 
+comptime fn as_mutable_reference(self) -> Option<UnresolvedType> {}
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/meta/unresolved_type.nr#L8-L10" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/meta/unresolved_type.nr#L8-L10</a></sub></sup>
+
+
+If this is a mutable reference type `&mut T`, returns the mutable type `T`.
+
+### as_slice
+
+```rust title="as_slice" showLineNumbers 
+comptime fn as_slice(self) -> Option<UnresolvedType> {}
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/meta/unresolved_type.nr#L14-L16" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/meta/unresolved_type.nr#L14-L16</a></sub></sup>
+
+
+If this is a slice `&[T]`, returns the element type `T`.
+
+### is_bool
+
+```rust title="is_bool" showLineNumbers 
+comptime fn is_bool(self) -> bool {}
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/meta/unresolved_type.nr#L20-L22" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/meta/unresolved_type.nr#L20-L22</a></sub></sup>
+
+
+Returns `true` if this type is `bool`.
+
+### is_field
+
+```rust title="is_field" showLineNumbers 
+pub comptime fn is_field(self) -> bool {}
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/meta/unresolved_type.nr#L26-L28" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/meta/unresolved_type.nr#L26-L28</a></sub></sup>
+
+
+Returns true if this type refers to the Field type.
+
+### is_unit
+
+```rust title="is_unit" showLineNumbers 
+comptime fn is_unit(self) -> bool {}
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/meta/unresolved_type.nr#L32-L34" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/meta/unresolved_type.nr#L32-L34</a></sub></sup>
+
+
+Returns true if this type is the unit `()` type.
diff --git a/docs/versioned_docs/version-v0.38.0/noir/standard_library/options.md b/docs/versioned_docs/version-v0.38.0/noir/standard_library/options.md
new file mode 100644
index 00000000000..a1bd4e1de5f
--- /dev/null
+++ b/docs/versioned_docs/version-v0.38.0/noir/standard_library/options.md
@@ -0,0 +1,101 @@
+---
+title: Option<T> Type
+---
+
+The `Option<T>` type is a way to express that a value might be present (`Some(T))` or absent (`None`). It's a safer way to handle potential absence of values, compared to using nulls in many other languages.
+
+```rust
+struct Option<T> {
+    None,
+    Some(T),
+}
+```
+
+The `Option` type, already imported into your Noir program, can be used directly:
+
+```rust
+fn main() {
+    let none = Option::none();
+    let some = Option::some(3);
+}
+```
+
+See [this test](https://github.com/noir-lang/noir/blob/5cbfb9c4a06c8865c98ff2b594464b037d821a5c/crates/nargo_cli/tests/test_data/option/src/main.nr) for a more comprehensive set of examples of each of the methods described below.
+
+## Methods
+
+### none
+
+Constructs a none value.
+
+### some
+
+Constructs a some wrapper around a given value.
+
+### is_none
+
+Returns true if the Option is None.
+
+### is_some
+
+Returns true of the Option is Some.
+
+### unwrap
+
+Asserts `self.is_some()` and returns the wrapped value.
+
+### unwrap_unchecked
+
+Returns the inner value without asserting `self.is_some()`. This method can be useful within an if condition when we already know that `option.is_some()`. If the option is None, there is no guarantee what value will be returned, only that it will be of type T for an `Option<T>`.
+
+### unwrap_or
+
+Returns the wrapped value if `self.is_some()`. Otherwise, returns the given default value.
+
+### unwrap_or_else
+
+Returns the wrapped value if `self.is_some()`. Otherwise, calls the given function to return a default value.
+
+### expect
+
+Asserts `self.is_some()` with a provided custom message and returns the contained `Some` value. The custom message is expected to be a format string.
+
+### map
+
+If self is `Some(x)`, this returns `Some(f(x))`. Otherwise, this returns `None`.
+
+### map_or
+
+If self is `Some(x)`, this returns `f(x)`. Otherwise, this returns the given default value.
+
+### map_or_else
+
+If self is `Some(x)`, this returns `f(x)`. Otherwise, this returns `default()`.
+
+### and
+
+Returns None if self is None. Otherwise, this returns `other`.
+
+### and_then
+
+If self is None, this returns None. Otherwise, this calls the given function with the Some value contained within self, and returns the result of that call. In some languages this function is called `flat_map` or `bind`.
+
+### or
+
+If self is Some, return self. Otherwise, return `other`.
+
+### or_else
+
+If self is Some, return self. Otherwise, return `default()`.
+
+### xor
+
+If only one of the two Options is Some, return that option. Otherwise, if both options are Some or both are None, None is returned.
+
+### filter
+
+Returns `Some(x)` if self is `Some(x)` and `predicate(x)` is true. Otherwise, this returns `None`.
+
+### flatten
+
+Flattens an `Option<Option<T>>` into a `Option<T>`. This returns `None` if the outer Option is None. Otherwise, this returns the inner Option.
diff --git a/docs/versioned_docs/version-v0.38.0/noir/standard_library/recursion.mdx b/docs/versioned_docs/version-v0.38.0/noir/standard_library/recursion.mdx
new file mode 100644
index 00000000000..60414a2fa51
--- /dev/null
+++ b/docs/versioned_docs/version-v0.38.0/noir/standard_library/recursion.mdx
@@ -0,0 +1,85 @@
+---
+title: Recursive Proofs
+description: Learn about how to write recursive proofs in Noir.
+keywords: [recursion, recursive proofs, verification_key, verify_proof]
+---
+
+import BlackBoxInfo from '@site/src/components/Notes/_blackbox';
+
+Noir supports recursively verifying proofs, meaning you verify the proof of a Noir program in another Noir program. This enables creating proofs of arbitrary size by doing step-wise verification of smaller components of a large proof.
+
+Read [the explainer on recursion](../../explainers/explainer-recursion.md) to know more about this function and the [guide on how to use it.](../../how_to/how-to-recursion.md)
+
+## The `#[recursive]` Attribute
+
+In Noir, the `#[recursive]` attribute is used to indicate that a circuit is designed for recursive proof generation. When applied, it informs the compiler and the tooling that the circuit should be compiled in a way that makes its proofs suitable for recursive verification. This attribute eliminates the need for manual flagging of recursion at the tooling level, streamlining the proof generation process for recursive circuits.
+
+### Example usage with `#[recursive]`
+
+```rust
+#[recursive]
+fn main(x: Field, y: pub Field) {
+    assert(x == y, "x and y are not equal");
+}
+
+// This marks the circuit as recursion-friendly and indicates that proofs generated from this circuit
+// are intended for recursive verification.
+```
+
+By incorporating this attribute directly in the circuit's definition, tooling like Nargo and NoirJS can automatically execute recursive-specific duties for Noir programs (e.g. recursive-friendly proof artifact generation) without additional flags or configurations.
+
+## Verifying Recursive Proofs
+
+```rust
+#[foreign(recursive_aggregation)]
+pub fn verify_proof(verification_key: [Field], proof: [Field], public_inputs: [Field], key_hash: Field) {}
+```
+
+<BlackBoxInfo to="black_box_fns"/>
+
+## Example usage
+
+```rust
+
+fn main(
+    verification_key : [Field; 114],
+    proof : [Field; 93],
+    public_inputs : [Field; 1],
+    key_hash : Field,
+    proof_b : [Field; 93],
+) {
+    std::verify_proof(
+        verification_key,
+        proof,
+        public_inputs,
+        key_hash
+    );
+
+    std::verify_proof(
+        verification_key,
+        proof_b,
+        public_inputs,
+        key_hash
+    );
+}
+```
+
+You can see a full example of recursive proofs in [this example recursion demo repo](https://github.com/noir-lang/noir-examples/tree/master/recursion).
+
+## Parameters
+
+### `verification_key`
+
+The verification key for the zk program that is being verified.
+
+### `proof`
+
+The proof for the zk program that is being verified.
+
+### `public_inputs`
+
+These represent the public inputs of the proof we are verifying.
+
+### `key_hash`
+
+A key hash is used to check the validity of the verification key. The circuit implementing this opcode can use this hash to ensure that the key provided to the circuit matches the key produced by the circuit creator.
diff --git a/docs/versioned_docs/version-v0.38.0/noir/standard_library/traits.md b/docs/versioned_docs/version-v0.38.0/noir/standard_library/traits.md
new file mode 100644
index 00000000000..ee20f9cd949
--- /dev/null
+++ b/docs/versioned_docs/version-v0.38.0/noir/standard_library/traits.md
@@ -0,0 +1,628 @@
+---
+title: Traits
+description: Noir's stdlib provides a few commonly used traits.
+keywords: [traits, trait, interface, protocol, default, add, eq]
+---
+
+## `std::default`
+
+### `std::default::Default`
+
+```rust title="default-trait" showLineNumbers 
+pub trait Default {
+    fn default() -> Self;
+}
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/default.nr#L4-L8" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/default.nr#L4-L8</a></sub></sup>
+
+
+Constructs a default value of a type.
+
+Implementations:
+```rust
+impl Default for Field { .. }
+
+impl Default for i8 { .. }
+impl Default for i16 { .. }
+impl Default for i32 { .. }
+impl Default for i64 { .. }
+
+impl Default for u8 { .. }
+impl Default for u16 { .. }
+impl Default for u32 { .. }
+impl Default for u64 { .. }
+
+impl Default for () { .. }
+impl Default for bool { .. }
+
+impl<T, N> Default for [T; N]
+    where T: Default { .. }
+
+impl<T> Default for [T] { .. }
+
+impl<A, B> Default for (A, B)
+    where A: Default, B: Default { .. }
+
+impl<A, B, C> Default for (A, B, C)
+    where A: Default, B: Default, C: Default { .. }
+
+impl<A, B, C, D> Default for (A, B, C, D)
+    where A: Default, B: Default, C: Default, D: Default { .. }
+
+impl<A, B, C, D, E> Default for (A, B, C, D, E)
+    where A: Default, B: Default, C: Default, D: Default, E: Default { .. }
+```
+
+For primitive integer types, the return value of `default` is `0`. Container
+types such as arrays are filled with default values of their element type,
+except slices whose length is unknown and thus defaulted to zero.
+
+---
+
+## `std::convert`
+
+### `std::convert::From`
+
+```rust title="from-trait" showLineNumbers 
+pub trait From<T> {
+    fn from(input: T) -> Self;
+}
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/convert.nr#L1-L5" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/convert.nr#L1-L5</a></sub></sup>
+
+
+The `From` trait defines how to convert from a given type `T` to the type on which the trait is implemented.
+
+The Noir standard library provides a number of implementations of `From` between primitive types.
+```rust title="from-impls" showLineNumbers 
+// Unsigned integers
+
+impl From<u8> for u32 {
+    fn from(value: u8) -> u32 {
+        value as u32
+    }
+}
+
+impl From<u8> for u64 {
+    fn from(value: u8) -> u64 {
+        value as u64
+    }
+}
+impl From<u32> for u64 {
+    fn from(value: u32) -> u64 {
+        value as u64
+    }
+}
+
+impl From<u8> for Field {
+    fn from(value: u8) -> Field {
+        value as Field
+    }
+}
+impl From<u32> for Field {
+    fn from(value: u32) -> Field {
+        value as Field
+    }
+}
+impl From<u64> for Field {
+    fn from(value: u64) -> Field {
+        value as Field
+    }
+}
+
+// Signed integers
+
+impl From<i8> for i32 {
+    fn from(value: i8) -> i32 {
+        value as i32
+    }
+}
+
+impl From<i8> for i64 {
+    fn from(value: i8) -> i64 {
+        value as i64
+    }
+}
+impl From<i32> for i64 {
+    fn from(value: i32) -> i64 {
+        value as i64
+    }
+}
+
+// Booleans
+impl From<bool> for u8 {
+    fn from(value: bool) -> u8 {
+        value as u8
+    }
+}
+impl From<bool> for u32 {
+    fn from(value: bool) -> u32 {
+        value as u32
+    }
+}
+impl From<bool> for u64 {
+    fn from(value: bool) -> u64 {
+        value as u64
+    }
+}
+impl From<bool> for i8 {
+    fn from(value: bool) -> i8 {
+        value as i8
+    }
+}
+impl From<bool> for i32 {
+    fn from(value: bool) -> i32 {
+        value as i32
+    }
+}
+impl From<bool> for i64 {
+    fn from(value: bool) -> i64 {
+        value as i64
+    }
+}
+impl From<bool> for Field {
+    fn from(value: bool) -> Field {
+        value as Field
+    }
+}
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/convert.nr#L28-L119" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/convert.nr#L28-L119</a></sub></sup>
+
+
+#### When to implement `From`
+
+As a general rule of thumb, `From` may be implemented in the [situations where it would be suitable in Rust](https://doc.rust-lang.org/std/convert/trait.From.html#when-to-implement-from):
+
+- The conversion is *infallible*: Noir does not provide an equivalent to Rust's `TryFrom`, if the conversion can fail then provide a named method instead.
+- The conversion is *lossless*: semantically, it should not lose or discard information. For example, `u32: From<u16>` can losslessly convert any `u16` into a valid `u32` such that the original `u16` can be recovered. On the other hand, `u16: From<u32>` should not be implemented as `2**16` is a `u32` which cannot be losslessly converted into a `u16`.
+- The conversion is *value-preserving*: the conceptual kind and meaning of the resulting value is the same, even though the Noir type and technical representation might be different. While it's possible to infallibly and losslessly convert a `u8` into a `str<2>` hex representation, `4u8` and `"04"` are too different for `str<2>: From<u8>` to be implemented.
+- The conversion is *obvious*: it's the only reasonable conversion between the two types. If there's ambiguity on how to convert between them such that the same input could potentially map to two different values then a named method should be used. For instance rather than implementing `U128: From<[u8; 16]>`, the methods `U128::from_le_bytes` and `U128::from_be_bytes` are used as otherwise the endianness of the array would be ambiguous, resulting in two potential values of `U128` from the same byte array.
+
+One additional recommendation specific to Noir is:
+- The conversion is *efficient*: it's relatively cheap to convert between the two types. Due to being a ZK DSL, it's more important to avoid unnecessary computation compared to Rust. If the implementation of `From` would encourage users to perform unnecessary conversion, resulting in additional proving time, then it may be preferable to expose functionality such that this conversion may be avoided.
+
+### `std::convert::Into`
+
+The `Into` trait is defined as the reciprocal of `From`. It should be easy to convince yourself that if we can convert to type `A` from type `B`, then it's possible to convert type `B` into type `A`.
+
+For this reason, implementing `From` on a type will automatically generate a matching `Into` implementation. One should always prefer implementing `From` over `Into` as implementing `Into` will not generate a matching `From` implementation.
+
+```rust title="into-trait" showLineNumbers 
+pub trait Into<T> {
+    fn into(self) -> T;
+}
+
+impl<T, U> Into<T> for U
+where
+    T: From<U>,
+{
+    fn into(self) -> T {
+        T::from(self)
+    }
+}
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/convert.nr#L13-L26" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/convert.nr#L13-L26</a></sub></sup>
+
+
+`Into` is most useful when passing function arguments where the types don't quite match up with what the function expects. In this case, the compiler has enough type information to perform the necessary conversion by just appending `.into()` onto the arguments in question.
+
+---
+
+## `std::cmp`
+
+### `std::cmp::Eq`
+
+```rust title="eq-trait" showLineNumbers 
+pub trait Eq {
+    fn eq(self, other: Self) -> bool;
+}
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/cmp.nr#L4-L8" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/cmp.nr#L4-L8</a></sub></sup>
+
+
+Returns `true` if `self` is equal to `other`. Implementing this trait on a type
+allows the type to be used with `==` and `!=`.
+
+Implementations:
+```rust
+impl Eq for Field { .. }
+
+impl Eq for i8 { .. }
+impl Eq for i16 { .. }
+impl Eq for i32 { .. }
+impl Eq for i64 { .. }
+
+impl Eq for u8 { .. }
+impl Eq for u16 { .. }
+impl Eq for u32 { .. }
+impl Eq for u64 { .. }
+
+impl Eq for () { .. }
+impl Eq for bool { .. }
+
+impl<T, N> Eq for [T; N]
+    where T: Eq { .. }
+
+impl<T> Eq for [T]
+    where T: Eq { .. }
+
+impl<A, B> Eq for (A, B)
+    where A: Eq, B: Eq { .. }
+
+impl<A, B, C> Eq for (A, B, C)
+    where A: Eq, B: Eq, C: Eq { .. }
+
+impl<A, B, C, D> Eq for (A, B, C, D)
+    where A: Eq, B: Eq, C: Eq, D: Eq { .. }
+
+impl<A, B, C, D, E> Eq for (A, B, C, D, E)
+    where A: Eq, B: Eq, C: Eq, D: Eq, E: Eq { .. }
+```
+
+### `std::cmp::Ord`
+
+```rust title="ord-trait" showLineNumbers 
+pub trait Ord {
+    fn cmp(self, other: Self) -> Ordering;
+}
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/cmp.nr#L210-L214" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/cmp.nr#L210-L214</a></sub></sup>
+
+
+`a.cmp(b)` compares two values returning `Ordering::less()` if `a < b`,
+`Ordering::equal()` if `a == b`, or `Ordering::greater()` if `a > b`.
+Implementing this trait on a type allows `<`, `<=`, `>`, and `>=` to be
+used on values of the type.
+
+`std::cmp` also provides `max` and `min` functions for any type which implements the `Ord` trait.
+
+Implementations:
+
+```rust
+impl Ord for u8 { .. }
+impl Ord for u16 { .. }
+impl Ord for u32 { .. }
+impl Ord for u64 { .. }
+
+impl Ord for i8 { .. }
+impl Ord for i16 { .. }
+impl Ord for i32 { .. }
+
+impl Ord for i64 { .. }
+
+impl Ord for () { .. }
+impl Ord for bool { .. }
+
+impl<T, N> Ord for [T; N]
+    where T: Ord { .. }
+
+impl<T> Ord for [T]
+    where T: Ord { .. }
+
+impl<A, B> Ord for (A, B)
+    where A: Ord, B: Ord { .. }
+
+impl<A, B, C> Ord for (A, B, C)
+    where A: Ord, B: Ord, C: Ord { .. }
+
+impl<A, B, C, D> Ord for (A, B, C, D)
+    where A: Ord, B: Ord, C: Ord, D: Ord { .. }
+
+impl<A, B, C, D, E> Ord for (A, B, C, D, E)
+    where A: Ord, B: Ord, C: Ord, D: Ord, E: Ord { .. }
+```
+
+---
+
+## `std::ops`
+
+### `std::ops::Add`, `std::ops::Sub`, `std::ops::Mul`, and `std::ops::Div`
+
+These traits abstract over addition, subtraction, multiplication, and division respectively.
+Implementing these traits for a given type will also allow that type to be used with the corresponding operator
+for that trait (`+` for Add, etc) in addition to the normal method names.
+
+```rust title="add-trait" showLineNumbers 
+pub trait Add {
+    fn add(self, other: Self) -> Self;
+}
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/ops/arith.nr#L1-L5" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/ops/arith.nr#L1-L5</a></sub></sup>
+
+```rust title="sub-trait" showLineNumbers 
+pub trait Sub {
+    fn sub(self, other: Self) -> Self;
+}
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/ops/arith.nr#L60-L64" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/ops/arith.nr#L60-L64</a></sub></sup>
+
+```rust title="mul-trait" showLineNumbers 
+pub trait Mul {
+    fn mul(self, other: Self) -> Self;
+}
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/ops/arith.nr#L119-L123" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/ops/arith.nr#L119-L123</a></sub></sup>
+
+```rust title="div-trait" showLineNumbers 
+pub trait Div {
+    fn div(self, other: Self) -> Self;
+}
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/ops/arith.nr#L178-L182" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/ops/arith.nr#L178-L182</a></sub></sup>
+
+
+The implementations block below is given for the `Add` trait, but the same types that implement
+`Add` also implement `Sub`, `Mul`, and `Div`.
+
+Implementations:
+```rust
+impl Add for Field { .. }
+
+impl Add for i8 { .. }
+impl Add for i16 { .. }
+impl Add for i32 { .. }
+impl Add for i64 { .. }
+
+impl Add for u8 { .. }
+impl Add for u16 { .. }
+impl Add for u32 { .. }
+impl Add for u64 { .. }
+```
+
+### `std::ops::Rem`
+
+```rust title="rem-trait" showLineNumbers 
+pub trait Rem {
+    fn rem(self, other: Self) -> Self;
+}
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/ops/arith.nr#L237-L241" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/ops/arith.nr#L237-L241</a></sub></sup>
+
+
+`Rem::rem(a, b)` is the remainder function returning the result of what is
+left after dividing `a` and `b`. Implementing `Rem` allows the `%` operator
+to be used with the implementation type.
+
+Unlike other numeric traits, `Rem` is not implemented for `Field`.
+
+Implementations:
+```rust
+impl Rem for u8 { fn rem(self, other: u8) -> u8 { self % other } }
+impl Rem for u16 { fn rem(self, other: u16) -> u16 { self % other } }
+impl Rem for u32 { fn rem(self, other: u32) -> u32 { self % other } }
+impl Rem for u64 { fn rem(self, other: u64) -> u64 { self % other } }
+
+impl Rem for i8 { fn rem(self, other: i8) -> i8 { self % other } }
+impl Rem for i16 { fn rem(self, other: i16) -> i16 { self % other } }
+impl Rem for i32 { fn rem(self, other: i32) -> i32 { self % other } }
+impl Rem for i64 { fn rem(self, other: i64) -> i64 { self % other } }
+```
+
+### `std::ops::Neg`
+
+```rust title="neg-trait" showLineNumbers 
+pub trait Neg {
+    fn neg(self) -> Self;
+}
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/ops/arith.nr#L290-L294" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/ops/arith.nr#L290-L294</a></sub></sup>
+
+
+`Neg::neg` is equivalent to the unary negation operator `-`.
+
+Implementations:
+```rust title="neg-trait-impls" showLineNumbers 
+impl Neg for Field {
+    fn neg(self) -> Field {
+        -self
+    }
+}
+
+impl Neg for i8 {
+    fn neg(self) -> i8 {
+        -self
+    }
+}
+impl Neg for i16 {
+    fn neg(self) -> i16 {
+        -self
+    }
+}
+impl Neg for i32 {
+    fn neg(self) -> i32 {
+        -self
+    }
+}
+impl Neg for i64 {
+    fn neg(self) -> i64 {
+        -self
+    }
+}
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/ops/arith.nr#L296-L323" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/ops/arith.nr#L296-L323</a></sub></sup>
+
+
+### `std::ops::Not`
+
+```rust title="not-trait" showLineNumbers 
+pub trait Not {
+    fn not(self: Self) -> Self;
+}
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/ops/bit.nr#L1-L5" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/ops/bit.nr#L1-L5</a></sub></sup>
+
+
+`Not::not` is equivalent to the unary bitwise NOT operator `!`.
+
+Implementations:
+```rust title="not-trait-impls" showLineNumbers 
+impl Not for bool {
+    fn not(self) -> bool {
+        !self
+    }
+}
+
+impl Not for u64 {
+    fn not(self) -> u64 {
+        !self
+    }
+}
+impl Not for u32 {
+    fn not(self) -> u32 {
+        !self
+    }
+}
+impl Not for u16 {
+    fn not(self) -> u16 {
+        !self
+    }
+}
+impl Not for u8 {
+    fn not(self) -> u8 {
+        !self
+    }
+}
+impl Not for u1 {
+    fn not(self) -> u1 {
+        !self
+    }
+}
+
+impl Not for i8 {
+    fn not(self) -> i8 {
+        !self
+    }
+}
+impl Not for i16 {
+    fn not(self) -> i16 {
+        !self
+    }
+}
+impl Not for i32 {
+    fn not(self) -> i32 {
+        !self
+    }
+}
+impl Not for i64 {
+    fn not(self) -> i64 {
+        !self
+    }
+}
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/ops/bit.nr#L7-L60" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/ops/bit.nr#L7-L60</a></sub></sup>
+
+
+### `std::ops::{ BitOr, BitAnd, BitXor }`
+
+```rust title="bitor-trait" showLineNumbers 
+pub trait BitOr {
+    fn bitor(self, other: Self) -> Self;
+}
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/ops/bit.nr#L62-L66" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/ops/bit.nr#L62-L66</a></sub></sup>
+
+```rust title="bitand-trait" showLineNumbers 
+pub trait BitAnd {
+    fn bitand(self, other: Self) -> Self;
+}
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/ops/bit.nr#L121-L125" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/ops/bit.nr#L121-L125</a></sub></sup>
+
+```rust title="bitxor-trait" showLineNumbers 
+pub trait BitXor {
+    fn bitxor(self, other: Self) -> Self;
+}
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/ops/bit.nr#L180-L184" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/ops/bit.nr#L180-L184</a></sub></sup>
+
+
+Traits for the bitwise operations `|`, `&`, and `^`.
+
+Implementing `BitOr`, `BitAnd` or `BitXor` for a type allows the `|`, `&`, or `^` operator respectively
+to be used with the type.
+
+The implementations block below is given for the `BitOr` trait, but the same types that implement
+`BitOr` also implement `BitAnd` and `BitXor`.
+
+Implementations:
+```rust
+impl BitOr for bool { fn bitor(self, other: bool) -> bool { self | other } }
+
+impl BitOr for u8 { fn bitor(self, other: u8) -> u8 { self | other } }
+impl BitOr for u16 { fn bitor(self, other: u16) -> u16 { self | other } }
+impl BitOr for u32 { fn bitor(self, other: u32) -> u32 { self | other } }
+impl BitOr for u64 { fn bitor(self, other: u64) -> u64 { self | other } }
+
+impl BitOr for i8 { fn bitor(self, other: i8) -> i8 { self | other } }
+impl BitOr for i16 { fn bitor(self, other: i16) -> i16 { self | other } }
+impl BitOr for i32 { fn bitor(self, other: i32) -> i32 { self | other } }
+impl BitOr for i64 { fn bitor(self, other: i64) -> i64 { self | other } }
+```
+
+### `std::ops::{ Shl, Shr }`
+
+```rust title="shl-trait" showLineNumbers 
+pub trait Shl {
+    fn shl(self, other: u8) -> Self;
+}
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/ops/bit.nr#L239-L243" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/ops/bit.nr#L239-L243</a></sub></sup>
+
+```rust title="shr-trait" showLineNumbers 
+pub trait Shr {
+    fn shr(self, other: u8) -> Self;
+}
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/ops/bit.nr#L292-L296" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/ops/bit.nr#L292-L296</a></sub></sup>
+
+
+Traits for a bit shift left and bit shift right.
+
+Implementing `Shl` for a type allows the left shift operator (`<<`) to be used with the implementation type.
+Similarly, implementing `Shr` allows the right shift operator (`>>`) to be used with the type.
+
+Note that bit shifting is not currently implemented for signed types.
+
+The implementations block below is given for the `Shl` trait, but the same types that implement
+`Shl` also implement `Shr`.
+
+Implementations:
+```rust
+impl Shl for u8 { fn shl(self, other: u8) -> u8 { self << other } }
+impl Shl for u16 { fn shl(self, other: u16) -> u16 { self << other } }
+impl Shl for u32 { fn shl(self, other: u32) -> u32 { self << other } }
+impl Shl for u64 { fn shl(self, other: u64) -> u64 { self << other } }
+```
+
+---
+
+## `std::append`
+
+### `std::append::Append`
+
+`Append` can abstract over types that can be appended to - usually container types:
+
+```rust title="append-trait" showLineNumbers 
+pub trait Append {
+    fn empty() -> Self;
+    fn append(self, other: Self) -> Self;
+}
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/append.nr#L9-L14" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/append.nr#L9-L14</a></sub></sup>
+
+
+`Append` requires two methods:
+
+- `empty`: Constructs an empty value of `Self`.
+- `append`: Append two values together, returning the result.
+
+Additionally, it is expected that for any implementation:
+
+- `T::empty().append(x) == x`
+- `x.append(T::empty()) == x`
+
+Implementations:
+```rust
+impl<T> Append for [T]
+impl Append for Quoted
+```
diff --git a/docs/versioned_docs/version-v0.38.0/reference/NoirJS/noir_js/.nojekyll b/docs/versioned_docs/version-v0.38.0/reference/NoirJS/noir_js/.nojekyll
new file mode 100644
index 00000000000..e2ac6616add
--- /dev/null
+++ b/docs/versioned_docs/version-v0.38.0/reference/NoirJS/noir_js/.nojekyll
@@ -0,0 +1 @@
+TypeDoc added this file to prevent GitHub Pages from using Jekyll. You can turn off this behavior by setting the `githubPages` option to false.
\ No newline at end of file
diff --git a/docs/versioned_docs/version-v0.38.0/reference/NoirJS/noir_js/classes/Noir.md b/docs/versioned_docs/version-v0.38.0/reference/NoirJS/noir_js/classes/Noir.md
new file mode 100644
index 00000000000..ead255bc504
--- /dev/null
+++ b/docs/versioned_docs/version-v0.38.0/reference/NoirJS/noir_js/classes/Noir.md
@@ -0,0 +1,52 @@
+# Noir
+
+## Constructors
+
+### new Noir(circuit)
+
+```ts
+new Noir(circuit): Noir
+```
+
+#### Parameters
+
+| Parameter | Type |
+| :------ | :------ |
+| `circuit` | `CompiledCircuit` |
+
+#### Returns
+
+[`Noir`](Noir.md)
+
+## Methods
+
+### execute()
+
+```ts
+execute(inputs, foreignCallHandler?): Promise<object>
+```
+
+#### Parameters
+
+| Parameter | Type |
+| :------ | :------ |
+| `inputs` | `InputMap` |
+| `foreignCallHandler`? | [`ForeignCallHandler`](../type-aliases/ForeignCallHandler.md) |
+
+#### Returns
+
+`Promise`\<`object`\>
+
+#### Description
+
+Allows to execute a circuit to get its witness and return value.
+
+#### Example
+
+```typescript
+async execute(inputs)
+```
+
+***
+
+Generated using [typedoc-plugin-markdown](https://www.npmjs.com/package/typedoc-plugin-markdown) and [TypeDoc](https://typedoc.org/)
diff --git a/docs/versioned_docs/version-v0.38.0/reference/NoirJS/noir_js/functions/and.md b/docs/versioned_docs/version-v0.38.0/reference/NoirJS/noir_js/functions/and.md
new file mode 100644
index 00000000000..c783283e396
--- /dev/null
+++ b/docs/versioned_docs/version-v0.38.0/reference/NoirJS/noir_js/functions/and.md
@@ -0,0 +1,22 @@
+# and()
+
+```ts
+and(lhs, rhs): string
+```
+
+Performs a bitwise AND operation between `lhs` and `rhs`
+
+## Parameters
+
+| Parameter | Type | Description |
+| :------ | :------ | :------ |
+| `lhs` | `string` |  |
+| `rhs` | `string` |  |
+
+## Returns
+
+`string`
+
+***
+
+Generated using [typedoc-plugin-markdown](https://www.npmjs.com/package/typedoc-plugin-markdown) and [TypeDoc](https://typedoc.org/)
diff --git a/docs/versioned_docs/version-v0.38.0/reference/NoirJS/noir_js/functions/blake2s256.md b/docs/versioned_docs/version-v0.38.0/reference/NoirJS/noir_js/functions/blake2s256.md
new file mode 100644
index 00000000000..7882d0da8d5
--- /dev/null
+++ b/docs/versioned_docs/version-v0.38.0/reference/NoirJS/noir_js/functions/blake2s256.md
@@ -0,0 +1,21 @@
+# blake2s256()
+
+```ts
+blake2s256(inputs): Uint8Array
+```
+
+Calculates the Blake2s256 hash of the input bytes
+
+## Parameters
+
+| Parameter | Type | Description |
+| :------ | :------ | :------ |
+| `inputs` | `Uint8Array` |  |
+
+## Returns
+
+`Uint8Array`
+
+***
+
+Generated using [typedoc-plugin-markdown](https://www.npmjs.com/package/typedoc-plugin-markdown) and [TypeDoc](https://typedoc.org/)
diff --git a/docs/versioned_docs/version-v0.38.0/reference/NoirJS/noir_js/functions/ecdsa_secp256k1_verify.md b/docs/versioned_docs/version-v0.38.0/reference/NoirJS/noir_js/functions/ecdsa_secp256k1_verify.md
new file mode 100644
index 00000000000..5e3cd53e9d3
--- /dev/null
+++ b/docs/versioned_docs/version-v0.38.0/reference/NoirJS/noir_js/functions/ecdsa_secp256k1_verify.md
@@ -0,0 +1,28 @@
+# ecdsa\_secp256k1\_verify()
+
+```ts
+ecdsa_secp256k1_verify(
+   hashed_msg, 
+   public_key_x_bytes, 
+   public_key_y_bytes, 
+   signature): boolean
+```
+
+Verifies a ECDSA signature over the secp256k1 curve.
+
+## Parameters
+
+| Parameter | Type | Description |
+| :------ | :------ | :------ |
+| `hashed_msg` | `Uint8Array` |  |
+| `public_key_x_bytes` | `Uint8Array` |  |
+| `public_key_y_bytes` | `Uint8Array` |  |
+| `signature` | `Uint8Array` |  |
+
+## Returns
+
+`boolean`
+
+***
+
+Generated using [typedoc-plugin-markdown](https://www.npmjs.com/package/typedoc-plugin-markdown) and [TypeDoc](https://typedoc.org/)
diff --git a/docs/versioned_docs/version-v0.38.0/reference/NoirJS/noir_js/functions/ecdsa_secp256r1_verify.md b/docs/versioned_docs/version-v0.38.0/reference/NoirJS/noir_js/functions/ecdsa_secp256r1_verify.md
new file mode 100644
index 00000000000..0b20ff68957
--- /dev/null
+++ b/docs/versioned_docs/version-v0.38.0/reference/NoirJS/noir_js/functions/ecdsa_secp256r1_verify.md
@@ -0,0 +1,28 @@
+# ecdsa\_secp256r1\_verify()
+
+```ts
+ecdsa_secp256r1_verify(
+   hashed_msg, 
+   public_key_x_bytes, 
+   public_key_y_bytes, 
+   signature): boolean
+```
+
+Verifies a ECDSA signature over the secp256r1 curve.
+
+## Parameters
+
+| Parameter | Type | Description |
+| :------ | :------ | :------ |
+| `hashed_msg` | `Uint8Array` |  |
+| `public_key_x_bytes` | `Uint8Array` |  |
+| `public_key_y_bytes` | `Uint8Array` |  |
+| `signature` | `Uint8Array` |  |
+
+## Returns
+
+`boolean`
+
+***
+
+Generated using [typedoc-plugin-markdown](https://www.npmjs.com/package/typedoc-plugin-markdown) and [TypeDoc](https://typedoc.org/)
diff --git a/docs/versioned_docs/version-v0.38.0/reference/NoirJS/noir_js/functions/xor.md b/docs/versioned_docs/version-v0.38.0/reference/NoirJS/noir_js/functions/xor.md
new file mode 100644
index 00000000000..8d762b895d3
--- /dev/null
+++ b/docs/versioned_docs/version-v0.38.0/reference/NoirJS/noir_js/functions/xor.md
@@ -0,0 +1,22 @@
+# xor()
+
+```ts
+xor(lhs, rhs): string
+```
+
+Performs a bitwise XOR operation between `lhs` and `rhs`
+
+## Parameters
+
+| Parameter | Type | Description |
+| :------ | :------ | :------ |
+| `lhs` | `string` |  |
+| `rhs` | `string` |  |
+
+## Returns
+
+`string`
+
+***
+
+Generated using [typedoc-plugin-markdown](https://www.npmjs.com/package/typedoc-plugin-markdown) and [TypeDoc](https://typedoc.org/)
diff --git a/docs/versioned_docs/version-v0.38.0/reference/NoirJS/noir_js/index.md b/docs/versioned_docs/version-v0.38.0/reference/NoirJS/noir_js/index.md
new file mode 100644
index 00000000000..4de7a696991
--- /dev/null
+++ b/docs/versioned_docs/version-v0.38.0/reference/NoirJS/noir_js/index.md
@@ -0,0 +1,47 @@
+# noir_js
+
+## Exports
+
+### Classes
+
+| Class | Description |
+| :------ | :------ |
+| [Noir](classes/Noir.md) | - |
+
+### Type Aliases
+
+| Type alias | Description |
+| :------ | :------ |
+| [ErrorWithPayload](type-aliases/ErrorWithPayload.md) | - |
+| [ForeignCallHandler](type-aliases/ForeignCallHandler.md) | A callback which performs an foreign call and returns the response. |
+| [ForeignCallInput](type-aliases/ForeignCallInput.md) | - |
+| [ForeignCallOutput](type-aliases/ForeignCallOutput.md) | - |
+| [WitnessMap](type-aliases/WitnessMap.md) | - |
+
+### Functions
+
+| Function | Description |
+| :------ | :------ |
+| [and](functions/and.md) | Performs a bitwise AND operation between `lhs` and `rhs` |
+| [blake2s256](functions/blake2s256.md) | Calculates the Blake2s256 hash of the input bytes |
+| [ecdsa\_secp256k1\_verify](functions/ecdsa_secp256k1_verify.md) | Verifies a ECDSA signature over the secp256k1 curve. |
+| [ecdsa\_secp256r1\_verify](functions/ecdsa_secp256r1_verify.md) | Verifies a ECDSA signature over the secp256r1 curve. |
+| [xor](functions/xor.md) | Performs a bitwise XOR operation between `lhs` and `rhs` |
+
+## References
+
+### CompiledCircuit
+
+Renames and re-exports [InputMap](index.md#inputmap)
+
+## Variables
+
+### InputMap
+
+```ts
+InputMap: any;
+```
+
+***
+
+Generated using [typedoc-plugin-markdown](https://www.npmjs.com/package/typedoc-plugin-markdown) and [TypeDoc](https://typedoc.org/)
diff --git a/docs/versioned_docs/version-v0.38.0/reference/NoirJS/noir_js/type-aliases/ErrorWithPayload.md b/docs/versioned_docs/version-v0.38.0/reference/NoirJS/noir_js/type-aliases/ErrorWithPayload.md
new file mode 100644
index 00000000000..e8c2f4aef3d
--- /dev/null
+++ b/docs/versioned_docs/version-v0.38.0/reference/NoirJS/noir_js/type-aliases/ErrorWithPayload.md
@@ -0,0 +1,15 @@
+# ErrorWithPayload
+
+```ts
+type ErrorWithPayload: ExecutionError & object;
+```
+
+## Type declaration
+
+| Member | Type | Description |
+| :------ | :------ | :------ |
+| `decodedAssertionPayload` | `any` | - |
+
+***
+
+Generated using [typedoc-plugin-markdown](https://www.npmjs.com/package/typedoc-plugin-markdown) and [TypeDoc](https://typedoc.org/)
diff --git a/docs/versioned_docs/version-v0.38.0/reference/NoirJS/noir_js/type-aliases/ForeignCallHandler.md b/docs/versioned_docs/version-v0.38.0/reference/NoirJS/noir_js/type-aliases/ForeignCallHandler.md
new file mode 100644
index 00000000000..812b8b16481
--- /dev/null
+++ b/docs/versioned_docs/version-v0.38.0/reference/NoirJS/noir_js/type-aliases/ForeignCallHandler.md
@@ -0,0 +1,24 @@
+# ForeignCallHandler
+
+```ts
+type ForeignCallHandler: (name, inputs) => Promise<ForeignCallOutput[]>;
+```
+
+A callback which performs an foreign call and returns the response.
+
+## Parameters
+
+| Parameter | Type | Description |
+| :------ | :------ | :------ |
+| `name` | `string` | The identifier for the type of foreign call being performed. |
+| `inputs` | [`ForeignCallInput`](ForeignCallInput.md)[] | An array of hex encoded inputs to the foreign call. |
+
+## Returns
+
+`Promise`\<[`ForeignCallOutput`](ForeignCallOutput.md)[]\>
+
+outputs - An array of hex encoded outputs containing the results of the foreign call.
+
+***
+
+Generated using [typedoc-plugin-markdown](https://www.npmjs.com/package/typedoc-plugin-markdown) and [TypeDoc](https://typedoc.org/)
diff --git a/docs/versioned_docs/version-v0.38.0/reference/NoirJS/noir_js/type-aliases/ForeignCallInput.md b/docs/versioned_docs/version-v0.38.0/reference/NoirJS/noir_js/type-aliases/ForeignCallInput.md
new file mode 100644
index 00000000000..dd95809186a
--- /dev/null
+++ b/docs/versioned_docs/version-v0.38.0/reference/NoirJS/noir_js/type-aliases/ForeignCallInput.md
@@ -0,0 +1,9 @@
+# ForeignCallInput
+
+```ts
+type ForeignCallInput: string[];
+```
+
+***
+
+Generated using [typedoc-plugin-markdown](https://www.npmjs.com/package/typedoc-plugin-markdown) and [TypeDoc](https://typedoc.org/)
diff --git a/docs/versioned_docs/version-v0.38.0/reference/NoirJS/noir_js/type-aliases/ForeignCallOutput.md b/docs/versioned_docs/version-v0.38.0/reference/NoirJS/noir_js/type-aliases/ForeignCallOutput.md
new file mode 100644
index 00000000000..b71fb78a946
--- /dev/null
+++ b/docs/versioned_docs/version-v0.38.0/reference/NoirJS/noir_js/type-aliases/ForeignCallOutput.md
@@ -0,0 +1,9 @@
+# ForeignCallOutput
+
+```ts
+type ForeignCallOutput: string | string[];
+```
+
+***
+
+Generated using [typedoc-plugin-markdown](https://www.npmjs.com/package/typedoc-plugin-markdown) and [TypeDoc](https://typedoc.org/)
diff --git a/docs/versioned_docs/version-v0.38.0/reference/NoirJS/noir_js/type-aliases/WitnessMap.md b/docs/versioned_docs/version-v0.38.0/reference/NoirJS/noir_js/type-aliases/WitnessMap.md
new file mode 100644
index 00000000000..258c46f9d0c
--- /dev/null
+++ b/docs/versioned_docs/version-v0.38.0/reference/NoirJS/noir_js/type-aliases/WitnessMap.md
@@ -0,0 +1,9 @@
+# WitnessMap
+
+```ts
+type WitnessMap: Map<number, string>;
+```
+
+***
+
+Generated using [typedoc-plugin-markdown](https://www.npmjs.com/package/typedoc-plugin-markdown) and [TypeDoc](https://typedoc.org/)
diff --git a/docs/versioned_docs/version-v0.38.0/reference/NoirJS/noir_js/typedoc-sidebar.cjs b/docs/versioned_docs/version-v0.38.0/reference/NoirJS/noir_js/typedoc-sidebar.cjs
new file mode 100644
index 00000000000..4796b5abaa8
--- /dev/null
+++ b/docs/versioned_docs/version-v0.38.0/reference/NoirJS/noir_js/typedoc-sidebar.cjs
@@ -0,0 +1,4 @@
+// @ts-check
+/** @type {import('@docusaurus/plugin-content-docs').SidebarsConfig} */
+const typedocSidebar = { items: [{"type":"category","label":"Classes","items":[{"type":"doc","id":"reference/NoirJS/noir_js/classes/Noir","label":"Noir"}]},{"type":"category","label":"Type Aliases","items":[{"type":"doc","id":"reference/NoirJS/noir_js/type-aliases/ErrorWithPayload","label":"ErrorWithPayload"},{"type":"doc","id":"reference/NoirJS/noir_js/type-aliases/ForeignCallHandler","label":"ForeignCallHandler"},{"type":"doc","id":"reference/NoirJS/noir_js/type-aliases/ForeignCallInput","label":"ForeignCallInput"},{"type":"doc","id":"reference/NoirJS/noir_js/type-aliases/ForeignCallOutput","label":"ForeignCallOutput"},{"type":"doc","id":"reference/NoirJS/noir_js/type-aliases/WitnessMap","label":"WitnessMap"}]},{"type":"category","label":"Functions","items":[{"type":"doc","id":"reference/NoirJS/noir_js/functions/and","label":"and"},{"type":"doc","id":"reference/NoirJS/noir_js/functions/blake2s256","label":"blake2s256"},{"type":"doc","id":"reference/NoirJS/noir_js/functions/ecdsa_secp256k1_verify","label":"ecdsa_secp256k1_verify"},{"type":"doc","id":"reference/NoirJS/noir_js/functions/ecdsa_secp256r1_verify","label":"ecdsa_secp256r1_verify"},{"type":"doc","id":"reference/NoirJS/noir_js/functions/xor","label":"xor"}]}]};
+module.exports = typedocSidebar.items;
\ No newline at end of file
diff --git a/docs/versioned_docs/version-v0.38.0/reference/NoirJS/noir_wasm/.nojekyll b/docs/versioned_docs/version-v0.38.0/reference/NoirJS/noir_wasm/.nojekyll
new file mode 100644
index 00000000000..e2ac6616add
--- /dev/null
+++ b/docs/versioned_docs/version-v0.38.0/reference/NoirJS/noir_wasm/.nojekyll
@@ -0,0 +1 @@
+TypeDoc added this file to prevent GitHub Pages from using Jekyll. You can turn off this behavior by setting the `githubPages` option to false.
\ No newline at end of file
diff --git a/docs/versioned_docs/version-v0.38.0/reference/NoirJS/noir_wasm/functions/compile.md b/docs/versioned_docs/version-v0.38.0/reference/NoirJS/noir_wasm/functions/compile.md
new file mode 100644
index 00000000000..6faf763b37f
--- /dev/null
+++ b/docs/versioned_docs/version-v0.38.0/reference/NoirJS/noir_wasm/functions/compile.md
@@ -0,0 +1,51 @@
+# compile()
+
+```ts
+compile(
+   fileManager, 
+   projectPath?, 
+   logFn?, 
+debugLogFn?): Promise<ProgramCompilationArtifacts>
+```
+
+Compiles a Noir project
+
+## Parameters
+
+| Parameter | Type | Description |
+| :------ | :------ | :------ |
+| `fileManager` | `FileManager` | The file manager to use |
+| `projectPath`? | `string` | The path to the project inside the file manager. Defaults to the root of the file manager |
+| `logFn`? | `LogFn` | A logging function. If not provided, console.log will be used |
+| `debugLogFn`? | `LogFn` | A debug logging function. If not provided, logFn will be used |
+
+## Returns
+
+`Promise`\<[`ProgramCompilationArtifacts`](../index.md#programcompilationartifacts)\>
+
+## Example
+
+```typescript
+// Node.js
+
+import { compile_program, createFileManager } from '@noir-lang/noir_wasm';
+
+const fm = createFileManager(myProjectPath);
+const myCompiledCode = await compile_program(fm);
+```
+
+```typescript
+// Browser
+
+import { compile_program, createFileManager } from '@noir-lang/noir_wasm';
+
+const fm = createFileManager('/');
+for (const path of files) {
+  await fm.writeFile(path, await getFileAsStream(path));
+}
+const myCompiledCode = await compile_program(fm);
+```
+
+***
+
+Generated using [typedoc-plugin-markdown](https://www.npmjs.com/package/typedoc-plugin-markdown) and [TypeDoc](https://typedoc.org/)
diff --git a/docs/versioned_docs/version-v0.38.0/reference/NoirJS/noir_wasm/functions/compile_contract.md b/docs/versioned_docs/version-v0.38.0/reference/NoirJS/noir_wasm/functions/compile_contract.md
new file mode 100644
index 00000000000..7d0b39a43ef
--- /dev/null
+++ b/docs/versioned_docs/version-v0.38.0/reference/NoirJS/noir_wasm/functions/compile_contract.md
@@ -0,0 +1,51 @@
+# compile\_contract()
+
+```ts
+compile_contract(
+   fileManager, 
+   projectPath?, 
+   logFn?, 
+debugLogFn?): Promise<ContractCompilationArtifacts>
+```
+
+Compiles a Noir project
+
+## Parameters
+
+| Parameter | Type | Description |
+| :------ | :------ | :------ |
+| `fileManager` | `FileManager` | The file manager to use |
+| `projectPath`? | `string` | The path to the project inside the file manager. Defaults to the root of the file manager |
+| `logFn`? | `LogFn` | A logging function. If not provided, console.log will be used |
+| `debugLogFn`? | `LogFn` | A debug logging function. If not provided, logFn will be used |
+
+## Returns
+
+`Promise`\<[`ContractCompilationArtifacts`](../index.md#contractcompilationartifacts)\>
+
+## Example
+
+```typescript
+// Node.js
+
+import { compile_contract, createFileManager } from '@noir-lang/noir_wasm';
+
+const fm = createFileManager(myProjectPath);
+const myCompiledCode = await compile_contract(fm);
+```
+
+```typescript
+// Browser
+
+import { compile_contract, createFileManager } from '@noir-lang/noir_wasm';
+
+const fm = createFileManager('/');
+for (const path of files) {
+  await fm.writeFile(path, await getFileAsStream(path));
+}
+const myCompiledCode = await compile_contract(fm);
+```
+
+***
+
+Generated using [typedoc-plugin-markdown](https://www.npmjs.com/package/typedoc-plugin-markdown) and [TypeDoc](https://typedoc.org/)
diff --git a/docs/versioned_docs/version-v0.38.0/reference/NoirJS/noir_wasm/functions/createFileManager.md b/docs/versioned_docs/version-v0.38.0/reference/NoirJS/noir_wasm/functions/createFileManager.md
new file mode 100644
index 00000000000..7e65c1d69c7
--- /dev/null
+++ b/docs/versioned_docs/version-v0.38.0/reference/NoirJS/noir_wasm/functions/createFileManager.md
@@ -0,0 +1,21 @@
+# createFileManager()
+
+```ts
+createFileManager(dataDir): FileManager
+```
+
+Creates a new FileManager instance based on fs in node and memfs in the browser (via webpack alias)
+
+## Parameters
+
+| Parameter | Type | Description |
+| :------ | :------ | :------ |
+| `dataDir` | `string` | root of the file system |
+
+## Returns
+
+`FileManager`
+
+***
+
+Generated using [typedoc-plugin-markdown](https://www.npmjs.com/package/typedoc-plugin-markdown) and [TypeDoc](https://typedoc.org/)
diff --git a/docs/versioned_docs/version-v0.38.0/reference/NoirJS/noir_wasm/functions/inflateDebugSymbols.md b/docs/versioned_docs/version-v0.38.0/reference/NoirJS/noir_wasm/functions/inflateDebugSymbols.md
new file mode 100644
index 00000000000..fcea9275341
--- /dev/null
+++ b/docs/versioned_docs/version-v0.38.0/reference/NoirJS/noir_wasm/functions/inflateDebugSymbols.md
@@ -0,0 +1,21 @@
+# inflateDebugSymbols()
+
+```ts
+inflateDebugSymbols(debugSymbols): any
+```
+
+Decompresses and decodes the debug symbols
+
+## Parameters
+
+| Parameter | Type | Description |
+| :------ | :------ | :------ |
+| `debugSymbols` | `string` | The base64 encoded debug symbols |
+
+## Returns
+
+`any`
+
+***
+
+Generated using [typedoc-plugin-markdown](https://www.npmjs.com/package/typedoc-plugin-markdown) and [TypeDoc](https://typedoc.org/)
diff --git a/docs/versioned_docs/version-v0.38.0/reference/NoirJS/noir_wasm/index.md b/docs/versioned_docs/version-v0.38.0/reference/NoirJS/noir_wasm/index.md
new file mode 100644
index 00000000000..b6e0f9d1bc0
--- /dev/null
+++ b/docs/versioned_docs/version-v0.38.0/reference/NoirJS/noir_wasm/index.md
@@ -0,0 +1,49 @@
+# noir_wasm
+
+## Exports
+
+### Functions
+
+| Function | Description |
+| :------ | :------ |
+| [compile](functions/compile.md) | Compiles a Noir project |
+| [compile\_contract](functions/compile_contract.md) | Compiles a Noir project |
+| [createFileManager](functions/createFileManager.md) | Creates a new FileManager instance based on fs in node and memfs in the browser (via webpack alias) |
+| [inflateDebugSymbols](functions/inflateDebugSymbols.md) | Decompresses and decodes the debug symbols |
+
+## References
+
+### compile\_program
+
+Renames and re-exports [compile](functions/compile.md)
+
+## Interfaces
+
+### ContractCompilationArtifacts
+
+The compilation artifacts of a given contract.
+
+#### Properties
+
+| Property | Type | Description |
+| :------ | :------ | :------ |
+| `contract` | `ContractArtifact` | The compiled contract. |
+| `warnings` | `unknown`[] | Compilation warnings. |
+
+***
+
+### ProgramCompilationArtifacts
+
+The compilation artifacts of a given program.
+
+#### Properties
+
+| Property | Type | Description |
+| :------ | :------ | :------ |
+| `name` | `string` | not part of the compilation output, injected later |
+| `program` | `ProgramArtifact` | The compiled contract. |
+| `warnings` | `unknown`[] | Compilation warnings. |
+
+***
+
+Generated using [typedoc-plugin-markdown](https://www.npmjs.com/package/typedoc-plugin-markdown) and [TypeDoc](https://typedoc.org/)
diff --git a/docs/versioned_docs/version-v0.38.0/reference/NoirJS/noir_wasm/typedoc-sidebar.cjs b/docs/versioned_docs/version-v0.38.0/reference/NoirJS/noir_wasm/typedoc-sidebar.cjs
new file mode 100644
index 00000000000..e0870710349
--- /dev/null
+++ b/docs/versioned_docs/version-v0.38.0/reference/NoirJS/noir_wasm/typedoc-sidebar.cjs
@@ -0,0 +1,4 @@
+// @ts-check
+/** @type {import('@docusaurus/plugin-content-docs').SidebarsConfig} */
+const typedocSidebar = { items: [{"type":"doc","id":"reference/NoirJS/noir_wasm/index","label":"API"},{"type":"category","label":"Functions","items":[{"type":"doc","id":"reference/NoirJS/noir_wasm/functions/compile","label":"compile"},{"type":"doc","id":"reference/NoirJS/noir_wasm/functions/compile_contract","label":"compile_contract"},{"type":"doc","id":"reference/NoirJS/noir_wasm/functions/createFileManager","label":"createFileManager"},{"type":"doc","id":"reference/NoirJS/noir_wasm/functions/inflateDebugSymbols","label":"inflateDebugSymbols"}]}]};
+module.exports = typedocSidebar.items;
\ No newline at end of file
diff --git a/docs/versioned_docs/version-v0.38.0/reference/_category_.json b/docs/versioned_docs/version-v0.38.0/reference/_category_.json
new file mode 100644
index 00000000000..5b6a20a609a
--- /dev/null
+++ b/docs/versioned_docs/version-v0.38.0/reference/_category_.json
@@ -0,0 +1,5 @@
+{
+    "position": 4,
+    "collapsible": true,
+    "collapsed": true
+}
diff --git a/docs/versioned_docs/version-v0.38.0/reference/debugger/_category_.json b/docs/versioned_docs/version-v0.38.0/reference/debugger/_category_.json
new file mode 100644
index 00000000000..27869205ad3
--- /dev/null
+++ b/docs/versioned_docs/version-v0.38.0/reference/debugger/_category_.json
@@ -0,0 +1,6 @@
+{
+    "label": "Debugger",
+    "position": 1,
+    "collapsible": true,
+    "collapsed": true
+}
diff --git a/docs/versioned_docs/version-v0.38.0/reference/debugger/debugger_known_limitations.md b/docs/versioned_docs/version-v0.38.0/reference/debugger/debugger_known_limitations.md
new file mode 100644
index 00000000000..936d416ac4b
--- /dev/null
+++ b/docs/versioned_docs/version-v0.38.0/reference/debugger/debugger_known_limitations.md
@@ -0,0 +1,59 @@
+---
+title: Known limitations
+description:
+  An overview of known limitations of the current version of the Noir debugger
+keywords:
+  [
+    Nargo,
+    Noir Debugger,
+    VS Code,
+  ]
+sidebar_position: 2
+---
+
+# Debugger Known Limitations
+
+There are currently some limits to what the debugger can observe. 
+
+## Mutable references
+
+The debugger is currently blind to any state mutated via a mutable reference. For example, in:
+
+```
+let mut x = 1;
+let y = &mut x;
+*y = 2;
+```
+
+The update on `x` will not be observed by the debugger. That means, when running `vars` from the debugger REPL, or inspecting the _local variables_ pane in the VS Code debugger, `x` will appear with value 1 despite having executed `*y = 2;`.
+
+## Variables of type function or mutable references are opaque
+
+When inspecting variables, any variable of type `Function` or `MutableReference` will render its value as `<<function>>` or `<<mutable ref>>`.
+
+## Debugger instrumentation affects resulting ACIR
+                      
+In order to make the state of local variables observable, the debugger compiles Noir circuits interleaving foreign calls that track any mutations to them. While this works (except in the cases described above) and doesn't introduce any behavior changes, it does as a side effect produce bigger bytecode. In particular, when running the command `opcodes` on the REPL debugger, you will notice Unconstrained VM blocks that look like this:
+
+```
+...
+5    BRILLIG inputs=[Single(Expression { mul_terms: [], linear_combinations: [], q_c: 2 }), Single(Expression { mul_terms: [], linear_combinations: [(1, Witness(2))], q_c: 0 })]
+       |       outputs=[]
+  5.0  |   Mov { destination: RegisterIndex(2), source: RegisterIndex(0) }
+  5.1  |   Mov { destination: RegisterIndex(3), source: RegisterIndex(1) }
+  5.2  |   Const { destination: RegisterIndex(0), value: Value { inner: 0 } }
+  5.3  |   Const { destination: RegisterIndex(1), value: Value { inner: 0 } }
+  5.4  |   Mov { destination: RegisterIndex(2), source: RegisterIndex(2) }
+  5.5  |   Mov { destination: RegisterIndex(3), source: RegisterIndex(3) }
+  5.6  |   Call { location: 8 }
+  5.7  |   Stop
+  5.8  |   ForeignCall { function: "__debug_var_assign", destinations: [], inputs: [RegisterIndex(RegisterIndex(2)), RegisterIndex(RegisterIndex(3))] }
+...
+```               
+                                    
+If you are interested in debugging/inspecting compiled ACIR without these synthetic changes, you can invoke the REPL debugger with the `--skip-instrumentation` flag or launch the VS Code debugger with the `skipConfiguration` property set to true in its launch configuration. You can find more details about those in the [Debugger REPL reference](debugger_repl.md) and the [VS Code Debugger reference](debugger_vscode.md).
+
+:::note
+Skipping debugger instrumentation means you won't be able to inspect values of local variables.
+:::
+
diff --git a/docs/versioned_docs/version-v0.38.0/reference/debugger/debugger_repl.md b/docs/versioned_docs/version-v0.38.0/reference/debugger/debugger_repl.md
new file mode 100644
index 00000000000..46e2011304e
--- /dev/null
+++ b/docs/versioned_docs/version-v0.38.0/reference/debugger/debugger_repl.md
@@ -0,0 +1,360 @@
+---
+title: REPL Debugger
+description:
+  Noir Debugger REPL options and commands. 
+keywords:
+  [
+    Nargo,
+    Noir CLI,
+    Noir Debugger,
+    REPL,
+  ]
+sidebar_position: 1
+---
+
+## Running the REPL debugger
+
+`nargo debug [OPTIONS] [WITNESS_NAME]`
+
+Runs the Noir REPL debugger. If a `WITNESS_NAME` is provided the debugger writes the resulting execution witness to a `WITNESS_NAME` file.
+
+### Options
+
+| Option                | Description                                                  |
+| --------------------- | ------------------------------------------------------------ |
+| `-p, --prover-name <PROVER_NAME>` | The name of the toml file which contains the inputs for the prover [default: Prover]|
+| `--package <PACKAGE>` | The name of the package to debug                             |
+| `--print-acir`        | Display the ACIR for compiled circuit                        |
+| `--deny-warnings`     | Treat all warnings as errors                                 |
+| `--silence-warnings`  | Suppress warnings                                            |
+| `-h, --help`          | Print help                                                   |
+
+None of these options are required.
+
+:::note
+Since the debugger starts by compiling the target package, all Noir compiler options are also available. Check out the [compiler reference](../nargo_commands.md#nargo-compile) to learn more about the compiler options.
+:::
+
+## REPL commands
+
+Once the debugger is running, it accepts the following commands.
+
+#### `help` (h)
+
+Displays the menu of available commands.
+
+```
+> help
+Available commands:
+
+  opcodes                          display ACIR opcodes
+  into                             step into to the next opcode
+  next                             step until a new source location is reached
+  out                              step until a new source location is reached
+                                   and the current stack frame is finished
+  break LOCATION:OpcodeLocation    add a breakpoint at an opcode location
+  over                             step until a new source location is reached
+                                   without diving into function calls
+  restart                          restart the debugging session
+  delete LOCATION:OpcodeLocation   delete breakpoint at an opcode location
+  witness                          show witness map
+  witness index:u32                display a single witness from the witness map
+  witness index:u32 value:String   update a witness with the given value
+  memset index:usize value:String  update a memory cell with the given
+                                   value
+  continue                         continue execution until the end of the
+                                   program
+  vars                             show variable values available at this point
+                                   in execution
+  stacktrace                       display the current stack trace
+  memory                           show memory (valid when executing unconstrained code)                                 value
+  step                             step to the next ACIR opcode
+
+Other commands:
+
+  help  Show this help message
+  quit  Quit repl
+
+```
+
+### Stepping through programs
+
+#### `next` (n)
+
+Step until the next Noir source code location. While other commands, such as [`into`](#into-i) and [`step`](#step-s), allow for finer grained control of the program's execution at the opcode level, `next` is source code centric. For example:
+
+```
+3    ...
+4    fn main(x: u32) {
+5        assert(entry_point(x) == 2);
+6        swap_entry_point(x, x + 1);
+7 ->     assert(deep_entry_point(x) == 4);
+8        multiple_values_entry_point(x);
+9    }
+```
+
+
+Using `next` here would cause the debugger to jump to the definition of `deep_entry_point` (if available). 
+
+If you want to step over `deep_entry_point` and go straight to line 8, use [the `over` command](#over) instead.
+
+#### `over`
+
+Step until the next source code location, without diving into function calls. For example:
+
+```
+3    ...
+4    fn main(x: u32) {
+5        assert(entry_point(x) == 2);
+6        swap_entry_point(x, x + 1);
+7 ->     assert(deep_entry_point(x) == 4);
+8        multiple_values_entry_point(x);
+9    }
+```
+
+
+Using `over` here would cause the debugger to execute until line 8 (`multiple_values_entry_point(x);`).
+
+If you want to step into `deep_entry_point` instead, use [the `next` command](#next-n).
+
+#### `out`
+
+Step until the end of the current function call. For example:
+
+```
+  3    ...
+  4    fn main(x: u32) {
+  5        assert(entry_point(x) == 2);
+  6        swap_entry_point(x, x + 1);
+  7 ->     assert(deep_entry_point(x) == 4);
+  8        multiple_values_entry_point(x);
+  9    }
+ 10    
+ 11    unconstrained fn returns_multiple_values(x: u32) -> (u32, u32, u32, u32) {
+ 12    ...
+ ...
+ 55    
+ 56    unconstrained fn deep_entry_point(x: u32) -> u32 {
+ 57 ->     level_1(x + 1)
+ 58    }
+
+```
+
+Running `out` here will resume execution until line 8.
+
+#### `step` (s)
+
+Skips to the next ACIR code. A compiled Noir program is a sequence of ACIR opcodes. However, an unconstrained VM opcode denotes the start of an unconstrained code block, to be executed by the unconstrained VM. For example (redacted for brevity):
+
+```
+0  BLACKBOX::RANGE [(_0, num_bits: 32)] [ ]
+1 ->  BRILLIG inputs=[Single(Expression { mul_terms: [], linear_combinations: [(1, Witness(0))], q_c: 0 })] outputs=[Simple(Witness(1))]
+	1.0  |   Mov { destination: RegisterIndex(2), source: RegisterIndex(0) }
+	1.1  |   Const { destination: RegisterIndex(0), value: Value { inner: 0 } }
+	1.2  |   Const { destination: RegisterIndex(1), value: Value { inner: 0 } }
+	1.3  |   Mov { destination: RegisterIndex(2), source: RegisterIndex(2) }
+	1.4  |   Call { location: 7 }
+	...
+	1.43 |   Return
+2    EXPR [ (1, _1) -2 ]
+```
+
+The `->` here shows the debugger paused at an ACIR opcode: `BRILLIG`, at index 1, which denotes an unconstrained code block is about to start.
+
+Using the `step` command at this point would result in the debugger stopping at ACIR opcode 2, `EXPR`, skipping unconstrained computation steps.
+
+Use [the `into` command](#into-i) instead if you want to follow unconstrained computation step by step.
+
+#### `into` (i)
+
+Steps into the next opcode. A compiled Noir program is a sequence of ACIR opcodes. However, a BRILLIG opcode denotes the start of an unconstrained code block, to be executed by the unconstrained VM. For example (redacted for brevity):
+
+```
+0  BLACKBOX::RANGE [(_0, num_bits: 32)] [ ]
+1 ->  BRILLIG inputs=[Single(Expression { mul_terms: [], linear_combinations: [(1, Witness(0))], q_c: 0 })] outputs=[Simple(Witness(1))]
+	1.0  |   Mov { destination: RegisterIndex(2), source: RegisterIndex(0) }
+	1.1  |   Const { destination: RegisterIndex(0), value: Value { inner: 0 } }
+	1.2  |   Const { destination: RegisterIndex(1), value: Value { inner: 0 } }
+	1.3  |   Mov { destination: RegisterIndex(2), source: RegisterIndex(2) }
+	1.4  |   Call { location: 7 }
+	...
+	1.43 |   Return
+2    EXPR [ (1, _1) -2 ]
+``` 
+
+The `->` here shows the debugger paused at an ACIR opcode: `BRILLIG`, at index 1, which denotes an unconstrained code block is about to start.
+
+Using the `into` command at this point would result in the debugger stopping at opcode 1.0, `Mov ...`, allowing the debugger user to follow unconstrained computation step by step.
+
+Use [the `step` command](#step-s) instead if you want to skip to the next ACIR code directly.
+
+#### `continue` (c)
+
+Continues execution until the next breakpoint, or the end of the program.
+
+#### `restart` (res)
+
+Interrupts execution, and restarts a new debugging session from scratch.
+
+#### `opcodes` (o)
+
+Display the program's ACIR opcode sequence. For example:
+
+```
+0  BLACKBOX::RANGE [(_0, num_bits: 32)] [ ]
+1 ->  BRILLIG inputs=[Single(Expression { mul_terms: [], linear_combinations: [(1, Witness(0))], q_c: 0 })] outputs=[Simple(Witness(1))]
+	1.0  |   Mov { destination: RegisterIndex(2), source: RegisterIndex(0) }
+	1.1  |   Const { destination: RegisterIndex(0), value: Value { inner: 0 } }
+	1.2  |   Const { destination: RegisterIndex(1), value: Value { inner: 0 } }
+	1.3  |   Mov { destination: RegisterIndex(2), source: RegisterIndex(2) }
+	1.4  |   Call { location: 7 }
+	...
+	1.43 |   Return
+2     EXPR [ (1, _1) -2 ]
+```
+
+### Breakpoints
+
+#### `break [Opcode]` (or shorthand `b [Opcode]`)
+
+Sets a breakpoint on the specified opcode index. To get a list of the program opcode numbers, see [the `opcode` command](#opcodes-o). For example:
+
+```
+0  BLACKBOX::RANGE [(_0, num_bits: 32)] [ ]
+1 ->  BRILLIG inputs=[Single(Expression { mul_terms: [], linear_combinations: [(1, Witness(0))], q_c: 0 })] outputs=[Simple(Witness(1))]
+	1.0  |   Mov { destination: RegisterIndex(2), source: RegisterIndex(0) }
+	1.1  |   Const { destination: RegisterIndex(0), value: Value { inner: 0 } }
+	1.2  |   Const { destination: RegisterIndex(1), value: Value { inner: 0 } }
+	1.3  |   Mov { destination: RegisterIndex(2), source: RegisterIndex(2) }
+	1.4  |   Call { location: 7 }
+	...
+	1.43 |   Return
+2    EXPR [ (1, _1) -2 ]
+```
+
+In this example, issuing a `break 1.2` command adds break on opcode 1.2, as denoted by the `*` character:
+
+```
+0  BLACKBOX::RANGE [(_0, num_bits: 32)] [ ]
+1 ->  BRILLIG inputs=[Single(Expression { mul_terms: [], linear_combinations: [(1, Witness(0))], q_c: 0 })] outputs=[Simple(Witness(1))]
+	1.0  |   Mov { destination: RegisterIndex(2), source: RegisterIndex(0) }
+	1.1  |   Const { destination: RegisterIndex(0), value: Value { inner: 0 } }
+	1.2  | * Const { destination: RegisterIndex(1), value: Value { inner: 0 } }
+	1.3  |   Mov { destination: RegisterIndex(2), source: RegisterIndex(2) }
+	1.4  |   Call { location: 7 }
+	...
+	1.43 |   Return
+2    EXPR [ (1, _1) -2 ]
+```
+
+Running [the `continue` command](#continue-c) at this point would cause the debugger to execute the program until opcode 1.2.
+
+#### `delete [Opcode]` (or shorthand `d [Opcode]`)
+
+Deletes a breakpoint at an opcode location. Usage is analogous to [the `break` command](#).
+
+### Variable inspection
+
+#### vars
+
+Show variable values available at this point in execution.
+
+:::note
+The ability to inspect variable values from the debugger depends on compilation to be run in a special debug instrumentation mode. This instrumentation weaves variable tracing code with the original source code. 
+
+So variable value inspection comes at the expense of making the resulting ACIR bytecode bigger and harder to understand and optimize.
+
+If you find this compromise unacceptable, you can run the debugger with the flag `--skip-debug-instrumentation`. This will compile your circuit without any additional debug information, so the resulting ACIR bytecode will be identical to the one produced by standard Noir compilation. However, if you opt for this, the `vars` command will not be available while debugging.
+:::
+
+
+### Stacktrace
+
+#### `stacktrace`
+
+Displays the current stack trace.
+
+
+### Witness map
+
+#### `witness` (w)
+
+Show witness map. For example:
+
+```
+_0 = 0
+_1 = 2
+_2 = 1
+```
+
+#### `witness [Witness Index]`
+
+Display a single witness from the witness map. For example:
+
+```
+> witness 1
+_1 = 2
+```
+
+#### `witness [Witness Index] [New value]`
+
+Overwrite the given index with a new value. For example:
+
+```
+> witness 1 3
+_1 = 3
+```
+
+
+### Unconstrained VM memory
+
+#### `memory`
+
+Show unconstrained VM memory state. For example:
+
+```
+> memory
+At opcode 1.13: Store { destination_pointer: RegisterIndex(0), source: RegisterIndex(3) }
+...
+> registers
+0 = 0
+1 = 10
+2 = 0
+3 = 1
+4 = 1
+5 = 2³²
+6 = 1
+> into
+At opcode 1.14: Const { destination: RegisterIndex(5), value: Value { inner: 1 } }
+...
+> memory
+0 = 1
+>
+```
+
+In the example above: we start with clean memory, then step through a `Store` opcode which stores the value of register 3 (1) into the memory address stored in register 0 (0). Thus now `memory` shows memory address 0 contains value 1.
+
+:::note
+This command is only functional while the debugger is executing unconstrained code.
+:::
+
+#### `memset [Memory address] [New value]`
+
+Update a memory cell with the given value. For example:
+
+```
+> memory
+0 = 1
+> memset 0 2
+> memory
+0 = 2
+> memset 1 4
+> memory
+0 = 2
+1 = 4
+>
+```
+
+:::note
+This command is only functional while the debugger is executing unconstrained code.
+:::
\ No newline at end of file
diff --git a/docs/versioned_docs/version-v0.38.0/reference/debugger/debugger_vscode.md b/docs/versioned_docs/version-v0.38.0/reference/debugger/debugger_vscode.md
new file mode 100644
index 00000000000..c027332b3b0
--- /dev/null
+++ b/docs/versioned_docs/version-v0.38.0/reference/debugger/debugger_vscode.md
@@ -0,0 +1,82 @@
+---
+title: VS Code Debugger
+description:
+  VS Code Debugger configuration and features.
+keywords:
+  [
+    Nargo,
+    Noir CLI,
+    Noir Debugger,
+    VS Code,
+    IDE,
+  ]
+sidebar_position: 0
+---
+
+# VS Code Noir Debugger Reference
+
+The Noir debugger enabled by the vscode-noir extension ships with default settings such that the most common scenario should run without any additional configuration steps.
+
+These defaults can nevertheless be overridden by defining a launch configuration file. This page provides a reference for the properties you can override via a launch configuration file, as well as documenting the Nargo `dap` command, which is a dependency of the VS Code Noir debugger. 
+
+
+## Creating and editing launch configuration files
+
+To create a launch configuration file from VS Code, open the _debug pane_, and click on _create a launch.json file_. 
+
+![Creating a launch configuration file](@site/static/img/debugger/ref1-create-launch.png)
+
+A `launch.json` file will be created, populated with basic defaults. 
+
+### Noir Debugger launch.json properties
+
+#### projectFolder
+
+_String, optional._
+
+Absolute path to the Nargo project to debug. By default, it is dynamically determined by looking for the nearest `Nargo.toml` file to the active file at the moment of launching the debugger. 
+
+#### proverName
+
+_String, optional._
+
+Name of the prover input to use. Defaults to `Prover`, which looks for a file named `Prover.toml` at the `projectFolder`.
+
+#### generateAcir
+
+_Boolean, optional._
+
+If true, generate ACIR opcodes instead of unconstrained opcodes which will be closer to release binaries but less convenient for debugging. Defaults to `false`.
+                
+#### skipInstrumentation
+
+_Boolean, optional._
+
+Skips variables debugging instrumentation of code, making debugging less convenient but the resulting binary smaller and closer to production. Defaults to `false`.
+
+:::note
+Skipping instrumentation causes the debugger to be unable to inspect local variables.
+:::
+
+## `nargo dap [OPTIONS]`
+
+When run without any option flags, it starts the Nargo Debug Adapter Protocol server, which acts as the debugging backend for the VS Code Noir Debugger. 
+
+All option flags are related to preflight checks. The Debug Adapter Protocol specifies how errors are to be informed from a running DAP server, but it doesn't specify mechanisms to communicate server initialization errors between the DAP server and its client IDE. 
+
+Thus `nargo dap` ships with a _preflight check_ mode. If flag `--preflight-check` and the rest of the `--preflight-*` flags are provided, Nargo will run the same initialization routine except it will not start the DAP server.
+
+`vscode-noir` will then run `nargo dap` in preflight check mode first before a debugging session starts. If the preflight check ends in error, vscode-noir will present stderr and stdout output from this process through its own Output pane in VS Code. This makes it possible for users to diagnose what pieces of configuration might be wrong or missing in case of initialization errors.
+
+If the preflight check succeeds, `vscode-noir` proceeds to start the DAP server normally but running `nargo dap` without any additional flags.
+
+### Options
+
+| Option                                  | Description                                                                         |
+| --------------------------------------------------------- | --------------------------------------------------------------------------------------------------------- |
+| `--preflight-check`                     | If present, dap runs in preflight check mode.                               |
+| `--preflight-project-folder <PREFLIGHT_PROJECT_FOLDER>`   | Absolute path to the project to debug for preflight check.                        |
+| `--preflight-prover-name <PREFLIGHT_PROVER_NAME>`       | Name of prover file to use for preflight check                              |
+| `--preflight-generate-acir`                 | Optional. If present, compile in ACIR mode while running preflight check.                                 |
+| `--preflight-skip-instrumentation`            | Optional. If present, compile without introducing debug instrumentation while running preflight check.  |
+| `-h, --help`                            | Print help.                                               |
diff --git a/docs/versioned_docs/version-v0.38.0/reference/nargo_commands.md b/docs/versioned_docs/version-v0.38.0/reference/nargo_commands.md
new file mode 100644
index 00000000000..8842fad6647
--- /dev/null
+++ b/docs/versioned_docs/version-v0.38.0/reference/nargo_commands.md
@@ -0,0 +1,474 @@
+---
+title: Nargo
+description:
+  Noir CLI Commands for Noir Prover and Verifier to create, execute, prove and verify programs,
+  generate Solidity verifier smart contract and compile into JSON file containing ACIR
+  representation and ABI of circuit.
+keywords:
+  [
+    Nargo,
+    Noir CLI,
+    Noir Prover,
+    Noir Verifier,
+    generate Solidity verifier,
+    compile JSON file,
+    ACIR representation,
+    ABI of circuit,
+    TypeScript,
+  ]
+sidebar_position: 0
+---
+
+# Command-Line Help for `nargo`
+
+This document contains the help content for the `nargo` command-line program.
+
+**Command Overview:**
+
+* [`nargo`↴](#nargo)
+* [`nargo check`↴](#nargo-check)
+* [`nargo fmt`↴](#nargo-fmt)
+* [`nargo compile`↴](#nargo-compile)
+* [`nargo new`↴](#nargo-new)
+* [`nargo init`↴](#nargo-init)
+* [`nargo execute`↴](#nargo-execute)
+* [`nargo debug`↴](#nargo-debug)
+* [`nargo test`↴](#nargo-test)
+* [`nargo info`↴](#nargo-info)
+* [`nargo lsp`↴](#nargo-lsp)
+* [`nargo generate-completion-script`↴](#nargo-generate-completion-script)
+
+## `nargo`
+
+Noir's package manager
+
+**Usage:** `nargo <COMMAND>`
+
+###### **Subcommands:**
+
+* `check` — Checks the constraint system for errors
+* `fmt` — Format the Noir files in a workspace
+* `compile` — Compile the program and its secret execution trace into ACIR format
+* `new` — Create a Noir project in a new directory
+* `init` — Create a Noir project in the current directory
+* `execute` — Executes a circuit to calculate its return value
+* `debug` — Executes a circuit in debug mode
+* `test` — Run the tests for this program
+* `info` — Provides detailed information on each of a program's function (represented by a single circuit)
+* `lsp` — Starts the Noir LSP server
+* `generate-completion-script` — Generates a shell completion script for your favorite shell
+
+###### **Options:**
+
+
+
+
+## `nargo check`
+
+Checks the constraint system for errors
+
+**Usage:** `nargo check [OPTIONS]`
+
+###### **Options:**
+
+* `--package <PACKAGE>` — The name of the package to check
+* `--workspace` — Check all packages in the workspace
+
+  Possible values: `true`, `false`
+
+* `--overwrite` — Force overwrite of existing files
+
+  Possible values: `true`, `false`
+
+* `--expression-width <EXPRESSION_WIDTH>` — Specify the backend expression width that should be targeted
+* `--bounded-codegen` — Generate ACIR with the target backend expression width. The default is to generate ACIR without a bound and split expressions after code generation. Activating this flag can sometimes provide optimizations for certain programs
+
+  Default value: `false`
+
+  Possible values: `true`, `false`
+
+* `--force` — Force a full recompilation
+
+  Possible values: `true`, `false`
+
+* `--print-acir` — Display the ACIR for compiled circuit
+
+  Possible values: `true`, `false`
+
+* `--deny-warnings` — Treat all warnings as errors
+
+  Possible values: `true`, `false`
+
+* `--silence-warnings` — Suppress warnings
+
+  Possible values: `true`, `false`
+
+* `--debug-comptime-in-file <DEBUG_COMPTIME_IN_FILE>` — Enable printing results of comptime evaluation: provide a path suffix for the module to debug, e.g. "package_name/src/main.nr"
+* `--skip-underconstrained-check` — Flag to turn off the compiler check for under constrained values. Warning: This can improve compilation speed but can also lead to correctness errors. This check should always be run on production code
+
+  Possible values: `true`, `false`
+
+
+
+
+## `nargo fmt`
+
+Format the Noir files in a workspace
+
+**Usage:** `nargo fmt [OPTIONS]`
+
+###### **Options:**
+
+* `--check` — Run noirfmt in check mode
+
+  Possible values: `true`, `false`
+
+
+
+
+## `nargo compile`
+
+Compile the program and its secret execution trace into ACIR format
+
+**Usage:** `nargo compile [OPTIONS]`
+
+###### **Options:**
+
+* `--package <PACKAGE>` — The name of the package to compile
+* `--workspace` — Compile all packages in the workspace
+
+  Possible values: `true`, `false`
+
+* `--expression-width <EXPRESSION_WIDTH>` — Specify the backend expression width that should be targeted
+* `--bounded-codegen` — Generate ACIR with the target backend expression width. The default is to generate ACIR without a bound and split expressions after code generation. Activating this flag can sometimes provide optimizations for certain programs
+
+  Default value: `false`
+
+  Possible values: `true`, `false`
+
+* `--force` — Force a full recompilation
+
+  Possible values: `true`, `false`
+
+* `--print-acir` — Display the ACIR for compiled circuit
+
+  Possible values: `true`, `false`
+
+* `--deny-warnings` — Treat all warnings as errors
+
+  Possible values: `true`, `false`
+
+* `--silence-warnings` — Suppress warnings
+
+  Possible values: `true`, `false`
+
+* `--debug-comptime-in-file <DEBUG_COMPTIME_IN_FILE>` — Enable printing results of comptime evaluation: provide a path suffix for the module to debug, e.g. "package_name/src/main.nr"
+* `--skip-underconstrained-check` — Flag to turn off the compiler check for under constrained values. Warning: This can improve compilation speed but can also lead to correctness errors. This check should always be run on production code
+
+  Possible values: `true`, `false`
+
+
+
+
+## `nargo new`
+
+Create a Noir project in a new directory
+
+**Usage:** `nargo new [OPTIONS] <PATH>`
+
+###### **Arguments:**
+
+* `<PATH>` — The path to save the new project
+
+###### **Options:**
+
+* `--name <NAME>` — Name of the package [default: package directory name]
+* `--lib` — Use a library template
+
+  Possible values: `true`, `false`
+
+* `--bin` — Use a binary template [default]
+
+  Possible values: `true`, `false`
+
+* `--contract` — Use a contract template
+
+  Possible values: `true`, `false`
+
+
+
+
+## `nargo init`
+
+Create a Noir project in the current directory
+
+**Usage:** `nargo init [OPTIONS]`
+
+###### **Options:**
+
+* `--name <NAME>` — Name of the package [default: current directory name]
+* `--lib` — Use a library template
+
+  Possible values: `true`, `false`
+
+* `--bin` — Use a binary template [default]
+
+  Possible values: `true`, `false`
+
+* `--contract` — Use a contract template
+
+  Possible values: `true`, `false`
+
+
+
+
+## `nargo execute`
+
+Executes a circuit to calculate its return value
+
+**Usage:** `nargo execute [OPTIONS] [WITNESS_NAME]`
+
+###### **Arguments:**
+
+* `<WITNESS_NAME>` — Write the execution witness to named file
+
+Defaults to the name of the package being executed.
+
+###### **Options:**
+
+* `-p`, `--prover-name <PROVER_NAME>` — The name of the toml file which contains the inputs for the prover
+
+  Default value: `Prover`
+* `--package <PACKAGE>` — The name of the package to execute
+* `--workspace` — Execute all packages in the workspace
+
+  Possible values: `true`, `false`
+
+* `--expression-width <EXPRESSION_WIDTH>` — Specify the backend expression width that should be targeted
+* `--bounded-codegen` — Generate ACIR with the target backend expression width. The default is to generate ACIR without a bound and split expressions after code generation. Activating this flag can sometimes provide optimizations for certain programs
+
+  Default value: `false`
+
+  Possible values: `true`, `false`
+
+* `--force` — Force a full recompilation
+
+  Possible values: `true`, `false`
+
+* `--print-acir` — Display the ACIR for compiled circuit
+
+  Possible values: `true`, `false`
+
+* `--deny-warnings` — Treat all warnings as errors
+
+  Possible values: `true`, `false`
+
+* `--silence-warnings` — Suppress warnings
+
+  Possible values: `true`, `false`
+
+* `--debug-comptime-in-file <DEBUG_COMPTIME_IN_FILE>` — Enable printing results of comptime evaluation: provide a path suffix for the module to debug, e.g. "package_name/src/main.nr"
+* `--skip-underconstrained-check` — Flag to turn off the compiler check for under constrained values. Warning: This can improve compilation speed but can also lead to correctness errors. This check should always be run on production code
+
+  Possible values: `true`, `false`
+
+* `--oracle-resolver <ORACLE_RESOLVER>` — JSON RPC url to solve oracle calls
+
+
+
+## `nargo debug`
+
+Executes a circuit in debug mode
+
+**Usage:** `nargo debug [OPTIONS] [WITNESS_NAME]`
+
+###### **Arguments:**
+
+* `<WITNESS_NAME>` — Write the execution witness to named file
+
+###### **Options:**
+
+* `-p`, `--prover-name <PROVER_NAME>` — The name of the toml file which contains the inputs for the prover
+
+  Default value: `Prover`
+* `--package <PACKAGE>` — The name of the package to execute
+* `--expression-width <EXPRESSION_WIDTH>` — Specify the backend expression width that should be targeted
+* `--bounded-codegen` — Generate ACIR with the target backend expression width. The default is to generate ACIR without a bound and split expressions after code generation. Activating this flag can sometimes provide optimizations for certain programs
+
+  Default value: `false`
+
+  Possible values: `true`, `false`
+
+* `--force` — Force a full recompilation
+
+  Possible values: `true`, `false`
+
+* `--print-acir` — Display the ACIR for compiled circuit
+
+  Possible values: `true`, `false`
+
+* `--deny-warnings` — Treat all warnings as errors
+
+  Possible values: `true`, `false`
+
+* `--silence-warnings` — Suppress warnings
+
+  Possible values: `true`, `false`
+
+* `--debug-comptime-in-file <DEBUG_COMPTIME_IN_FILE>` — Enable printing results of comptime evaluation: provide a path suffix for the module to debug, e.g. "package_name/src/main.nr"
+* `--skip-underconstrained-check` — Flag to turn off the compiler check for under constrained values. Warning: This can improve compilation speed but can also lead to correctness errors. This check should always be run on production code
+
+  Possible values: `true`, `false`
+
+* `--acir-mode` — Force ACIR output (disabling instrumentation)
+
+  Possible values: `true`, `false`
+
+* `--skip-instrumentation <SKIP_INSTRUMENTATION>` — Disable vars debug instrumentation (enabled by default)
+
+  Possible values: `true`, `false`
+
+
+
+
+## `nargo test`
+
+Run the tests for this program
+
+**Usage:** `nargo test [OPTIONS] [TEST_NAME]`
+
+###### **Arguments:**
+
+* `<TEST_NAME>` — If given, only tests with names containing this string will be run
+
+###### **Options:**
+
+* `--show-output` — Display output of `println` statements
+
+  Possible values: `true`, `false`
+
+* `--exact` — Only run tests that match exactly
+
+  Possible values: `true`, `false`
+
+* `--package <PACKAGE>` — The name of the package to test
+* `--workspace` — Test all packages in the workspace
+
+  Possible values: `true`, `false`
+
+* `--expression-width <EXPRESSION_WIDTH>` — Specify the backend expression width that should be targeted
+* `--bounded-codegen` — Generate ACIR with the target backend expression width. The default is to generate ACIR without a bound and split expressions after code generation. Activating this flag can sometimes provide optimizations for certain programs
+
+  Default value: `false`
+
+  Possible values: `true`, `false`
+
+* `--force` — Force a full recompilation
+
+  Possible values: `true`, `false`
+
+* `--print-acir` — Display the ACIR for compiled circuit
+
+  Possible values: `true`, `false`
+
+* `--deny-warnings` — Treat all warnings as errors
+
+  Possible values: `true`, `false`
+
+* `--silence-warnings` — Suppress warnings
+
+  Possible values: `true`, `false`
+
+* `--debug-comptime-in-file <DEBUG_COMPTIME_IN_FILE>` — Enable printing results of comptime evaluation: provide a path suffix for the module to debug, e.g. "package_name/src/main.nr"
+* `--skip-underconstrained-check` — Flag to turn off the compiler check for under constrained values. Warning: This can improve compilation speed but can also lead to correctness errors. This check should always be run on production code
+
+  Possible values: `true`, `false`
+
+* `--oracle-resolver <ORACLE_RESOLVER>` — JSON RPC url to solve oracle calls
+
+
+
+## `nargo info`
+
+Provides detailed information on each of a program's function (represented by a single circuit)
+
+Current information provided per circuit: 1. The number of ACIR opcodes 2. Counts the final number gates in the circuit used by a backend
+
+**Usage:** `nargo info [OPTIONS]`
+
+###### **Options:**
+
+* `--package <PACKAGE>` — The name of the package to detail
+* `--workspace` — Detail all packages in the workspace
+
+  Possible values: `true`, `false`
+
+* `--profile-execution`
+
+  Possible values: `true`, `false`
+
+* `-p`, `--prover-name <PROVER_NAME>` — The name of the toml file which contains the inputs for the prover
+
+  Default value: `Prover`
+* `--expression-width <EXPRESSION_WIDTH>` — Specify the backend expression width that should be targeted
+* `--bounded-codegen` — Generate ACIR with the target backend expression width. The default is to generate ACIR without a bound and split expressions after code generation. Activating this flag can sometimes provide optimizations for certain programs
+
+  Default value: `false`
+
+  Possible values: `true`, `false`
+
+* `--force` — Force a full recompilation
+
+  Possible values: `true`, `false`
+
+* `--print-acir` — Display the ACIR for compiled circuit
+
+  Possible values: `true`, `false`
+
+* `--deny-warnings` — Treat all warnings as errors
+
+  Possible values: `true`, `false`
+
+* `--silence-warnings` — Suppress warnings
+
+  Possible values: `true`, `false`
+
+* `--debug-comptime-in-file <DEBUG_COMPTIME_IN_FILE>` — Enable printing results of comptime evaluation: provide a path suffix for the module to debug, e.g. "package_name/src/main.nr"
+* `--skip-underconstrained-check` — Flag to turn off the compiler check for under constrained values. Warning: This can improve compilation speed but can also lead to correctness errors. This check should always be run on production code
+
+  Possible values: `true`, `false`
+
+
+
+
+## `nargo lsp`
+
+Starts the Noir LSP server
+
+Starts an LSP server which allows IDEs such as VS Code to display diagnostics in Noir source.
+
+VS Code Noir Language Support: https://marketplace.visualstudio.com/items?itemName=noir-lang.vscode-noir
+
+**Usage:** `nargo lsp`
+
+
+
+## `nargo generate-completion-script`
+
+Generates a shell completion script for your favorite shell
+
+**Usage:** `nargo generate-completion-script <SHELL>`
+
+###### **Arguments:**
+
+* `<SHELL>` — The shell to generate completions for. One of: bash, elvish, fish, powershell, zsh
+
+
+
+<hr/>
+
+<small><i>
+    This document was generated automatically by
+    <a href="https://crates.io/crates/clap-markdown"><code>clap-markdown</code></a>.
+</i></small>
+
diff --git a/docs/versioned_docs/version-v0.38.0/reference/noir_codegen.md b/docs/versioned_docs/version-v0.38.0/reference/noir_codegen.md
new file mode 100644
index 00000000000..e4c362f9610
--- /dev/null
+++ b/docs/versioned_docs/version-v0.38.0/reference/noir_codegen.md
@@ -0,0 +1,116 @@
+---
+title: Noir Codegen for TypeScript
+description: Learn how to use Noir codegen to generate TypeScript bindings 
+keywords: [Nargo, Noir, compile, TypeScript]
+sidebar_position: 3
+---
+
+When using TypeScript, it is extra work to interpret Noir program outputs in a type-safe way. Third party libraries may exist for popular Noir programs, but they are either hard to find or unmaintained.
+
+Now you can generate TypeScript bindings for your Noir programs in two steps:
+
+1. Exporting Noir functions using `nargo export`
+2. Using the TypeScript module `noir_codegen` to generate TypeScript binding
+
+**Note:** you can only export functions from a Noir *library* (not binary or contract program types).
+
+## Installation
+
+### Your TypeScript project
+
+If you don't already have a TypeScript project you can add the module with `yarn` (or `npm`), then initialize it:
+
+```bash
+yarn add typescript -D
+npx tsc --init
+```
+
+### Add TypeScript module - `noir_codegen`
+
+The following command will add the module to your project's devDependencies:
+
+```bash
+yarn add @noir-lang/noir_codegen -D
+```
+
+### Nargo library
+
+Make sure you have Nargo, v0.25.0 or greater, installed. If you don't, follow the [installation guide](../getting_started/noir_installation.md).
+
+If you're in a new project, make a `circuits` folder and create a new Noir library:
+
+```bash
+mkdir circuits && cd circuits
+nargo new --lib myNoirLib
+```
+
+## Usage
+
+### Export ABI of specified functions
+
+First go to the `.nr` files in your Noir library, and add the `#[export]` macro to each function that you want to use in TypeScript.
+
+```rust
+#[export]
+fn your_function(...
+```
+
+From your Noir library (where `Nargo.toml` is), run the following command:
+
+```bash
+nargo export
+```
+
+You will now have an `export` directory with a .json file per exported function.
+
+You can also specify the directory of Noir programs using `--program-dir`, for example:
+
+```bash
+nargo export --program-dir=./circuits/myNoirLib
+```
+
+### Generate TypeScript bindings from exported functions
+
+To use the `noir-codegen` package we added to the TypeScript project:
+
+```bash
+yarn noir-codegen ./export/your_function.json
+```
+
+This creates an `exports` directory with an `index.ts` file containing all exported functions.
+
+**Note:** adding `--out-dir` allows you to specify an output dir for your TypeScript bindings to go. Eg:
+
+```bash
+yarn noir-codegen ./export/*.json --out-dir ./path/to/output/dir
+```
+
+## Example .nr function to .ts output
+
+Consider a Noir library with this function:
+
+```rust
+#[export]
+fn not_equal(x: Field, y: Field) -> bool {
+    x != y
+}
+```
+
+After the export and codegen steps, you should have an `index.ts` like:
+
+```typescript
+export type Field = string;
+
+
+export const is_equal_circuit: CompiledCircuit = 
+{"abi":{"parameters":[{"name":"x","type":{"kind":"field"},"visibility":"private"},{"name":"y","type":{"kind":"field"},"visibility":"private"}],"return_type":{"abi_type":{"kind":"boolean"},"visibility":"private"}},"bytecode":"H4sIAAAAAAAA/7WUMQ7DIAxFQ0Krrr2JjSGYLVcpKrn/CaqqDQN12WK+hPBgmWd/wEyHbF1SS923uhOs3pfoChI+wKXMAXzIKyNj4PB0TFTYc0w5RUjoqeAeEu1wqK0F54RGkWvW44LPzExnlkbMEs4JNZmN8PxS42uHv82T8a3Jeyn2Ks+VLPcO558HmyLMCDOXAXXtpPt4R/Rt9T36ss6dS9HGPx/eG17nGegKBQAA"};
+
+export async function is_equal(x: Field, y: Field, foreignCallHandler?: ForeignCallHandler): Promise<boolean> {
+  const program = new Noir(is_equal_circuit);
+  const args: InputMap = { x, y };
+  const { returnValue } = await program.execute(args, foreignCallHandler);
+  return returnValue as boolean;
+}
+```
+
+Now the `is_equal()` function and relevant types are readily available for use in TypeScript.
diff --git a/docs/versioned_docs/version-v0.38.0/tooling/debugger.md b/docs/versioned_docs/version-v0.38.0/tooling/debugger.md
new file mode 100644
index 00000000000..200b5fc423a
--- /dev/null
+++ b/docs/versioned_docs/version-v0.38.0/tooling/debugger.md
@@ -0,0 +1,26 @@
+---
+title: Debugger
+description: Learn about the Noir Debugger, in its REPL or VS Code versions.
+keywords: [Nargo, VSCode, Visual Studio Code, REPL, Debugger]
+sidebar_position: 2
+---
+
+# Noir Debugger
+
+There are currently two ways of debugging Noir programs:
+
+1. From VS Code, via the [vscode-noir](https://github.com/noir-lang/vscode-noir) extension. You can install it via the [Visual Studio Marketplace](https://marketplace.visualstudio.com/items?itemName=noir-lang.vscode-noir).
+2. Via the REPL debugger, which ships with Nargo.
+
+In order to use either version of the debugger, you will need to install recent enough versions of Noir, [Nargo](../getting_started/noir_installation.md) and vscode-noir:
+
+- Noir & Nargo ≥0.28.0
+- Noir's VS Code extension ≥0.0.11
+
+:::info
+At the moment, the debugger supports debugging binary projects, but not contracts.
+:::
+
+We cover the VS Code Noir debugger more in depth in [its VS Code debugger how-to guide](../how_to/debugger/debugging_with_vs_code.md) and [the reference](../reference/debugger/debugger_vscode.md).
+
+The REPL debugger is discussed at length in [the REPL debugger how-to guide](../how_to/debugger/debugging_with_the_repl.md) and [the reference](../reference/debugger/debugger_repl.md).
diff --git a/docs/versioned_docs/version-v0.38.0/tooling/language_server.md b/docs/versioned_docs/version-v0.38.0/tooling/language_server.md
new file mode 100644
index 00000000000..81e0356ef8a
--- /dev/null
+++ b/docs/versioned_docs/version-v0.38.0/tooling/language_server.md
@@ -0,0 +1,43 @@
+---
+title: Language Server
+description: Learn about the Noir Language Server, how to install the components, and configuration that may be required.
+keywords: [Nargo, Language Server, LSP, VSCode, Visual Studio Code]
+sidebar_position: 0
+---
+
+This section helps you install and configure the Noir Language Server.
+
+The Language Server Protocol (LSP) has two components, the [Server](#language-server) and the [Client](#language-client). Below we describe each in the context of Noir.
+
+## Language Server
+
+The Server component is provided by the Nargo command line tool that you installed at the beginning of this guide.
+As long as Nargo is installed and you've used it to run other commands in this guide, it should be good to go!
+
+If you'd like to verify that the `nargo lsp` command is available, you can run `nargo --help` and look for `lsp` in the list of commands. If you see it, you're using a version of Noir with LSP support.
+
+## Language Client
+
+The Client component is usually an editor plugin that launches the Server. It communicates LSP messages between the editor and the Server. For example, when you save a file, the Client will alert the Server, so it can try to compile the project and report any errors.
+
+Currently, Noir provides a Language Client for Visual Studio Code via the [vscode-noir](https://github.com/noir-lang/vscode-noir) extension. You can install it via the [Visual Studio Marketplace](https://marketplace.visualstudio.com/items?itemName=noir-lang.vscode-noir).
+
+> **Note:** Noir's Language Server Protocol support currently assumes users' VSCode workspace root to be the same as users' Noir project root (i.e. where Nargo.toml lies).
+>
+> If LSP features seem to be missing / malfunctioning, make sure you are opening your Noir project directly (instead of as a sub-folder) in your VSCode instance.
+
+When your language server is running correctly and the VSCode plugin is installed, you should see handy codelens buttons for compilation, measuring circuit size, execution, and tests:
+
+![Compile and Execute](@site/static/img/codelens_compile_execute.png)
+![Run test](@site/static/img/codelens_run_test.png)
+
+You should also see your tests in the `testing` panel:
+
+![Testing panel](@site/static/img/codelens_testing_panel.png)
+
+### Configuration
+
+- **Noir: Enable LSP** - If checked, the extension will launch the Language Server via `nargo lsp` and communicate with it.
+- **Noir: Nargo Flags** - Additional flags may be specified if you require them to be added when the extension calls `nargo lsp`.
+- **Noir: Nargo Path** - An absolute path to a Nargo binary with the `lsp` command. This may be useful if Nargo is not within the `PATH` of your editor.
+- **Noir > Trace: Server** - Setting this to `"messages"` or `"verbose"` will log LSP messages between the Client and Server. Useful for debugging.
diff --git a/docs/versioned_docs/version-v0.38.0/tooling/testing.md b/docs/versioned_docs/version-v0.38.0/tooling/testing.md
new file mode 100644
index 00000000000..866677da567
--- /dev/null
+++ b/docs/versioned_docs/version-v0.38.0/tooling/testing.md
@@ -0,0 +1,79 @@
+---
+title: Testing in Noir
+description: Learn how to use Nargo to test your Noir program in a quick and easy way
+keywords: [Nargo, testing, Noir, compile, test]
+sidebar_position: 1
+---
+
+You can test your Noir programs using Noir circuits.
+
+Nargo will automatically compile and run any functions which have the decorator `#[test]` on them if
+you run `nargo test`.
+
+For example if you have a program like:
+
+```rust
+fn add(x: u64, y: u64) -> u64 {
+    x + y
+}
+#[test]
+fn test_add() {
+    assert(add(2,2) == 4);
+    assert(add(0,1) == 1);
+    assert(add(1,0) == 1);
+}
+```
+
+Running `nargo test` will test that the `test_add` function can be executed while satisfying all
+the constraints which allows you to test that add returns the expected values. Test functions can't
+have any arguments currently.
+
+### Test fail
+
+You can write tests that are expected to fail by using the decorator `#[test(should_fail)]`. For example:
+
+```rust
+fn add(x: u64, y: u64) -> u64 {
+    x + y
+}
+#[test(should_fail)]
+fn test_add() {
+    assert(add(2,2) == 5);
+}
+```
+
+You can be more specific and make it fail with a specific reason by using `should_fail_with = "<the reason for failure>"`:
+
+```rust
+fn main(african_swallow_avg_speed : Field) {
+    assert(african_swallow_avg_speed == 65, "What is the airspeed velocity of an unladen swallow");
+}
+
+#[test]
+fn test_king_arthur() {
+    main(65);
+}
+
+#[test(should_fail_with = "What is the airspeed velocity of an unladen swallow")]
+fn test_bridgekeeper() {
+    main(32);
+}
+```
+
+The string given to `should_fail_with` doesn't need to exactly match the failure reason, it just needs to be a substring of it:
+
+```rust
+fn main(african_swallow_avg_speed : Field) {
+    assert(african_swallow_avg_speed == 65, "What is the airspeed velocity of an unladen swallow");
+}
+
+#[test]
+fn test_king_arthur() {
+    main(65);
+}
+
+#[test(should_fail_with = "airspeed velocity")]
+fn test_bridgekeeper() {
+    main(32);
+}
+```
\ No newline at end of file
diff --git a/docs/versioned_docs/version-v0.38.0/tutorials/noirjs_app.md b/docs/versioned_docs/version-v0.38.0/tutorials/noirjs_app.md
new file mode 100644
index 00000000000..6e69ea0bbed
--- /dev/null
+++ b/docs/versioned_docs/version-v0.38.0/tutorials/noirjs_app.md
@@ -0,0 +1,366 @@
+---
+title: Building a web app with NoirJS
+description: Learn how to setup a new app that uses Noir to generate and verify zero-knowledge SNARK proofs in a typescript or javascript environment.
+keywords: [how to, guide, javascript, typescript, noir, barretenberg, zero-knowledge, proofs, app]
+sidebar_position: 0
+pagination_next: noir/concepts/data_types/index
+---
+
+NoirJS is a set of packages meant to work both in a browser and a server environment. In this tutorial, we will build a simple web app using them. From here, you should get an idea on how to proceed with your own Noir projects!
+
+You can find the complete app code for this guide [here](https://github.com/noir-lang/tiny-noirjs-app).
+
+## Setup
+
+:::note
+
+Feel free to use whatever versions, just keep in mind that Nargo and the NoirJS packages are meant to be in sync. For example, Nargo 0.31.x matches `noir_js@0.31.x`, etc.
+
+In this guide, we will be pinned to 0.31.0.
+
+:::
+
+Before we start, we want to make sure we have Node, Nargo and the Barretenberg proving system (`bb`) installed.
+
+We start by opening a terminal and executing `node --version`. If we don't get an output like `v20.10.0`, that means node is not installed. Let's do that by following the handy [nvm guide](https://github.com/nvm-sh/nvm?tab=readme-ov-file#install--update-script).
+
+As for `Nargo`, we can follow the [Nargo guide](../getting_started/quick_start.md) to install it. If you're lazy, just paste this on a terminal and run `noirup`:
+
+```sh
+curl -L https://raw.githubusercontent.com/noir-lang/noirup/main/install | bash
+```
+
+Follow the instructions on [this page](https://github.com/AztecProtocol/aztec-packages/tree/master/barretenberg/cpp/src/barretenberg/bb#installation) to install `bb`.
+Version 0.41.0 is compatible with `nargo` version 0.31.0, which you can install with `bbup -v 0.41.0` once `bbup` is installed.
+
+Easy enough. Onwards!
+
+## Our project
+
+ZK is a powerful technology. An app that doesn't reveal one of the inputs to _anyone_ is almost unbelievable, yet Noir makes it as easy as a single line of code.
+
+In fact, it's so simple that it comes nicely packaged in `nargo`. Let's do that!
+
+### Nargo
+
+Run:
+
+```bash
+nargo new circuit
+```
+
+And... That's about it. Your program is ready to be compiled and run.
+
+To compile, let's `cd` into the `circuit` folder to enter our project, and call:
+
+```bash
+nargo compile
+```
+
+This compiles our circuit into `json` format and add it to a new `target` folder.
+
+:::info
+
+At this point in the tutorial, your folder structure should look like this:
+
+```tree
+.
+└── circuit <---- our working directory
+    ├── Nargo.toml
+    ├── src
+    │   └── main.nr
+    └── target
+        └── circuit.json
+```
+
+:::
+
+### Node and Vite
+
+If you want to explore Nargo, feel free to go on a side-quest now and follow the steps in the
+[getting started](../getting_started/quick_start.md) guide. However, we want our app to run on the browser, so we need Vite.
+
+Vite is a powerful tool to generate static websites. While it provides all kinds of features, let's just go barebones with some good old vanilla JS.
+
+To do this this, go back to the previous folder (`cd ..`) and create a new vite project by running `npm create vite` and choosing "Vanilla" and "Javascript".
+
+A wild `vite-project` directory should now appear in your root folder! Let's not waste any time and dive right in:
+
+```bash
+cd vite-project
+```
+
+### Setting Up Vite and Configuring the Project
+
+Before we proceed with any coding, let's get our environment tailored for Noir. We'll start by laying down the foundations with a `vite.config.js` file. This little piece of configuration is our secret sauce for making sure everything meshes well with the NoirJS libraries and other special setups we might need, like handling WebAssembly modules. Here’s how you get that going:
+
+#### Creating the vite.config.js
+
+In your freshly minted `vite-project` folder, create a new file named `vite.config.js` and open it in your code editor. Paste the following to set the stage:
+
+```javascript
+import { defineConfig } from 'vite';
+import copy from 'rollup-plugin-copy';
+import fs from 'fs';
+import path from 'path';
+
+const wasmContentTypePlugin = {
+  name: 'wasm-content-type-plugin',
+  configureServer(server) {
+    server.middlewares.use(async (req, res, next) => {
+      if (req.url.endsWith('.wasm')) {
+        res.setHeader('Content-Type', 'application/wasm');
+        const newPath = req.url.replace('deps', 'dist');
+        const targetPath = path.join(__dirname, newPath);
+        const wasmContent = fs.readFileSync(targetPath);
+        return res.end(wasmContent);
+      }
+      next();
+    });
+  },
+};
+
+export default defineConfig(({ command }) => {
+  if (command === 'serve') {
+    return {
+      build: {
+        target: 'esnext',
+        rollupOptions: {
+          external: ['@aztec/bb.js']
+        }
+      },
+      optimizeDeps: {
+        esbuildOptions: {
+          target: 'esnext'
+        }
+      },
+      plugins: [
+        copy({
+          targets: [{ src: 'node_modules/**/*.wasm', dest: 'node_modules/.vite/dist' }],
+          copySync: true,
+          hook: 'buildStart',
+        }),
+        command === 'serve' ? wasmContentTypePlugin : [],
+      ],
+    };
+  }
+
+  return {};
+});
+```
+
+#### Install Dependencies
+
+Now that our stage is set, install the necessary NoirJS packages along with our other dependencies:
+
+```bash
+npm install && npm install @noir-lang/backend_barretenberg@0.31.0 @noir-lang/noir_js@0.31.0
+npm install rollup-plugin-copy --save-dev
+```
+
+:::info
+
+At this point in the tutorial, your folder structure should look like this:
+
+```tree
+.
+└── circuit
+    └── ...etc...
+└── vite-project <---- our working directory
+    └── ...etc...
+```
+
+:::
+
+#### Some cleanup
+
+`npx create vite` is amazing but it creates a bunch of files we don't really need for our simple example. Actually, let's just delete everything except for `vite.config.js`, `index.html`, `main.js` and `package.json`. I feel lighter already.
+
+![my heart is ready for you, noir.js](@site/static/img/memes/titanic.jpeg)
+
+## HTML
+
+Our app won't run like this, of course. We need some working HTML, at least. Let's open our broken-hearted `index.html` and replace everything with this code snippet:
+
+```html
+<!DOCTYPE html>
+<head>
+  <style>
+    .outer {
+        display: flex;
+        justify-content: space-between;
+        width: 100%;
+    }
+    .inner {
+        width: 45%;
+        border: 1px solid black;
+        padding: 10px;
+        word-wrap: break-word;
+    }
+  </style>
+</head>
+<body>
+  <script type="module" src="/main.js"></script>
+  <h1>Noir app</h1>
+  <div class="input-area">
+    <input id="guessInput" type="number" placeholder="Enter your guess" />
+    <button id="submitGuess">Submit Guess</button>
+  </div>
+  <div class="outer">
+    <div id="logs" class="inner"><h2>Logs</h2></div>
+    <div id="results" class="inner"><h2>Proof</h2></div>
+  </div>
+</body>
+</html>
+```
+
+It _could_ be a beautiful UI... Depending on which universe you live in.
+
+## Some good old vanilla Javascript
+
+Our love for Noir needs undivided attention, so let's just open `main.js` and delete everything (this is where the romantic scenery becomes a bit creepy).
+
+Start by pasting in this boilerplate code:
+
+```js
+function display(container, msg) {
+  const c = document.getElementById(container);
+  const p = document.createElement('p');
+  p.textContent = msg;
+  c.appendChild(p);
+}
+
+document.getElementById('submitGuess').addEventListener('click', async () => {
+  try {
+    // here's where love happens
+  } catch (err) {
+    display('logs', 'Oh 💔 Wrong guess');
+  }
+});
+```
+
+The display function doesn't do much. We're simply manipulating our website to see stuff happening. For example, if the proof fails, it will simply log a broken heart 😢
+
+:::info
+
+At this point in the tutorial, your folder structure should look like this:
+
+```tree
+.
+└── circuit
+    └── ...same as above
+└── vite-project
+    ├── vite.config.js
+    ├── main.js
+    ├── package.json
+    └── index.html
+```
+
+You'll see other files and folders showing up (like `package-lock.json`, `node_modules`) but you shouldn't have to care about those.
+
+:::
+
+## Some NoirJS
+
+We're starting with the good stuff now. If you've compiled the circuit as described above, you should have a `json` file we want to import at the very top of our `main.js` file:
+
+```ts
+import circuit from '../circuit/target/circuit.json';
+```
+
+[Noir is backend-agnostic](../index.mdx#whats-new-about-noir). We write Noir, but we also need a proving backend. That's why we need to import and instantiate the two dependencies we installed above: `BarretenbergBackend` and `Noir`. Let's import them right below:
+
+```js
+import { BarretenbergBackend, BarretenbergVerifier as Verifier } from '@noir-lang/backend_barretenberg';
+import { Noir } from '@noir-lang/noir_js';
+```
+
+And instantiate them inside our try-catch block:
+
+```ts
+// try {
+const backend = new BarretenbergBackend(circuit);
+const noir = new Noir(circuit);
+// }
+```
+
+:::note
+
+For the remainder of the tutorial, everything will be happening inside the `try` block
+
+:::
+
+## Our app
+
+Now for the app itself. We're capturing whatever is in the input when people press the submit button. Just add this:
+
+```js
+const x = parseInt(document.getElementById('guessInput').value);
+const input = { x, y: 2 };
+```
+
+Now we're ready to prove stuff! Let's feed some inputs to our circuit and calculate the proof:
+
+```js
+await setup(); // let's squeeze our wasm inits here
+
+display('logs', 'Generating proof... ⌛');
+const { witness } = await noir.execute(input);
+const proof = await backend.generateProof(witness);
+display('logs', 'Generating proof... ✅');
+display('results', proof.proof);
+```
+
+You're probably eager to see stuff happening, so go and run your app now!
+
+From your terminal, run `npm run dev`. If it doesn't open a browser for you, just visit `localhost:5173`. You should now see the worst UI ever, with an ugly input.
+
+![Getting Started 0](@site/static/img/noir_getting_started_1.png)
+
+Now, our circuit says `fn main(x: Field, y: pub Field)`. This means only the `y` value is public, and it's hardcoded above: `input = { x, y: 2 }`. In other words, you won't need to send your secret`x` to the verifier!
+
+By inputting any number other than 2 in the input box and clicking "submit", you should get a valid proof. Otherwise the proof won't even generate correctly. By the way, if you're human, you shouldn't be able to understand anything on the "proof" box. That's OK. We like you, human ❤️.
+
+## Verifying
+
+Time to celebrate, yes! But we shouldn't trust machines so blindly. Let's add these lines to see our proof being verified:
+
+```js
+display('logs', 'Verifying proof... ⌛');
+const isValid = await backend.verifyProof(proof);
+
+// or to cache and use the verification key:
+// const verificationKey = await backend.getVerificationKey();
+// const verifier = new Verifier();
+// const isValid = await verifier.verifyProof(proof, verificationKey);
+
+if (isValid) display('logs', 'Verifying proof... ✅');
+```
+
+You have successfully generated a client-side Noir web app!
+
+![coded app without math knowledge](@site/static/img/memes/flextape.jpeg)
+
+## Further Reading
+
+You can see how noirjs is used in a full stack Next.js hardhat application in the [noir-starter repo here](https://github.com/noir-lang/noir-starter/tree/main/vite-hardhat). The example shows how to calculate a proof in the browser and verify it with a deployed Solidity verifier contract from noirjs.
+
+You should also check out the more advanced examples in the [noir-examples repo](https://github.com/noir-lang/noir-examples), where you'll find reference usage for some cool apps.
+
+## UltraHonk Backend
+
+Barretenberg has recently exposed a new UltraHonk backend. We can use UltraHonk in NoirJS after version 0.33.0. Everything will be the same as the tutorial above, except that the class we need to import will change:
+
+```js
+import { UltraHonkBackend, UltraHonkVerifier as Verifier } from '@noir-lang/backend_barretenberg';
+```
+
+The backend will then be instantiated as such:
+
+```js
+const backend = new UltraHonkBackend(circuit);
+```
+
+Then all the commands to prove and verify your circuit will be same.
+
+The only feature currently unsupported with UltraHonk are [recursive proofs](../explainers/explainer-recursion.md).
diff --git a/docs/versioned_docs/version-v0.39.0/explainers/cspell.json b/docs/versioned_docs/version-v0.39.0/explainers/cspell.json
new file mode 100644
index 00000000000..c60b0a597b1
--- /dev/null
+++ b/docs/versioned_docs/version-v0.39.0/explainers/cspell.json
@@ -0,0 +1,5 @@
+{
+    "words": [
+        "Cryptdoku"
+    ]
+}
diff --git a/docs/versioned_docs/version-v0.39.0/explainers/explainer-oracle.md b/docs/versioned_docs/version-v0.39.0/explainers/explainer-oracle.md
new file mode 100644
index 00000000000..821e1f95c04
--- /dev/null
+++ b/docs/versioned_docs/version-v0.39.0/explainers/explainer-oracle.md
@@ -0,0 +1,57 @@
+---
+title: Oracles
+description: This guide provides an in-depth understanding of how Oracles work in Noir programming. Learn how to use outside calculations in your programs, constrain oracles, and understand their uses and limitations.
+keywords:
+  - Noir Programming
+  - Oracles
+  - JSON-RPC
+  - Foreign Call Handlers
+  - Constrained Functions
+  - Blockchain Programming
+sidebar_position: 1
+---
+
+If you've seen "The Matrix" you may recall "The Oracle" as Gloria Foster smoking cigarettes and baking cookies. While she appears to "know things", she is actually providing a calculation of a pre-determined future. Noir Oracles are similar, in a way. They don't calculate the future (yet), but they allow you to use outside calculations in your programs.
+
+![matrix oracle prediction](@site/static/img/memes/matrix_oracle.jpeg)
+
+A Noir program is usually self-contained. You can pass certain inputs to it, and it will generate a deterministic output for those inputs. But what if you wanted to defer some calculation to an outside process or source?
+
+Oracles are functions that provide this feature.
+
+## Use cases
+
+An example usage for Oracles is proving something on-chain. For example, proving that the ETH-USDC quote was below a certain target at a certain block time. Or even making more complex proofs like proving the ownership of an NFT as an anonymous login method.
+
+Another interesting use case is to defer expensive calculations to be made outside of the Noir program, and then constraining the result; similar to the use of [unconstrained functions](../noir/concepts//unconstrained.md).
+
+In short, anything that can be constrained in a Noir program but needs to be fetched from an external source is a great candidate to be used in oracles.
+
+## Constraining oracles
+
+Just like in The Matrix, Oracles are powerful. But with great power, comes great responsibility. Just because you're using them in a Noir program doesn't mean they're true. Noir has no superpowers. If you want to prove that Portugal won the Euro Cup 2016, you're still relying on potentially untrusted information.
+
+To give a concrete example, Alice wants to login to the [NounsDAO](https://nouns.wtf/) forum with her username "noir_nouner" by proving she owns a noun without revealing her ethereum address. Her Noir program could have an oracle call like this:
+
+```rust
+#[oracle(getNoun)]
+unconstrained fn get_noun(address: Field) -> Field
+```
+
+This oracle could naively resolve with the number of Nouns she possesses. However, it is useless as a trusted source, as the oracle could resolve to anything Alice wants. In order to make this oracle call actually useful, Alice would need to constrain the response from the oracle, by proving her address and the noun count belongs to the state tree of the contract.
+
+In short, **Oracles don't prove anything. Your Noir program does.**
+
+:::danger
+
+If you don't constrain the return of your oracle, you could be clearly opening an attack vector on your Noir program. Make double-triple sure that the return of an oracle call is constrained!
+
+:::
+
+## How to use Oracles
+
+On CLI, Nargo resolves oracles by making JSON RPC calls, which means it would require an RPC node to be running.
+
+In JavaScript, NoirJS accepts and resolves arbitrary call handlers (that is, not limited to JSON) as long as they match the expected types the developer defines. Refer to [Foreign Call Handler](../reference/NoirJS/noir_js/type-aliases/ForeignCallHandler.md) to learn more about NoirJS's call handling.
+
+If you want to build using oracles, follow through to the [oracle guide](../how_to/how-to-oracles.md) for a simple example on how to do that.
diff --git a/docs/versioned_docs/version-v0.39.0/explainers/explainer-recursion.md b/docs/versioned_docs/version-v0.39.0/explainers/explainer-recursion.md
new file mode 100644
index 00000000000..df8529ef4e0
--- /dev/null
+++ b/docs/versioned_docs/version-v0.39.0/explainers/explainer-recursion.md
@@ -0,0 +1,176 @@
+---
+title: Recursive proofs
+description: Explore the concept of recursive proofs in Zero-Knowledge programming. Understand how recursion works in Noir, a language for writing smart contracts on the EVM blockchain. Learn through practical examples like Alice and Bob's guessing game, Charlie's recursive merkle tree, and Daniel's reusable components. Discover how to use recursive proofs to optimize computational resources and improve efficiency.
+
+keywords:
+  [
+    "Recursive Proofs",
+    "Zero-Knowledge Programming",
+    "Noir",
+    "EVM Blockchain",
+    "Smart Contracts",
+    "Recursion in Noir",
+    "Alice and Bob Guessing Game",
+    "Recursive Merkle Tree",
+    "Reusable Components",
+    "Optimizing Computational Resources",
+    "Improving Efficiency",
+    "Verification Key",
+    "Aggregation",
+    "Recursive zkSNARK schemes",
+    "PLONK",
+    "Proving and Verification Keys"
+  ]
+sidebar_position: 1
+pagination_next: how_to/how-to-recursion
+---
+
+In programming, we tend to think of recursion as something calling itself. A classic example would be the calculation of the factorial of a number:
+
+```js
+function factorial(n) {
+    if (n === 0 || n === 1) {
+        return 1;
+    } else {
+        return n * factorial(n - 1);
+    }
+}
+```
+
+In this case, while `n` is not `1`, this function will keep calling itself until it hits the base case, bubbling up the result on the call stack:
+
+```md
+        Is `n` 1?  <---------
+           /\               /
+          /  \         n = n -1 
+         /    \           /
+       Yes     No --------
+```
+
+In Zero-Knowledge, recursion has some similarities.
+
+It is not a Noir function calling itself, but a proof being used as an input to another circuit. In short, you verify one proof *inside* another proof, returning the proof that both proofs are valid.
+
+This means that, given enough computational resources, you can prove the correctness of any arbitrary number of proofs in a single proof. This could be useful to design state channels (for which a common example would be [Bitcoin's Lightning Network](https://en.wikipedia.org/wiki/Lightning_Network)), to save on gas costs by settling one proof on-chain, or simply to make business logic less dependent on a consensus mechanism.
+
+## Examples
+
+Let us look at some of these examples
+
+### Alice and Bob - Guessing game
+
+Alice and Bob are friends, and they like guessing games. They want to play a guessing game online, but for that, they need a trusted third-party that knows both of their secrets and finishes the game once someone wins.
+
+So, they use zero-knowledge proofs. Alice tries to guess Bob's number, and Bob will generate a ZK proof stating whether she succeeded or failed.
+
+This ZK proof can go on a smart contract, revealing the winner and even giving prizes. However, this means every turn needs to be verified on-chain. This incurs some cost and waiting time that may simply make the game too expensive or time-consuming to be worth it.
+
+As a solution, Alice proposes the following: "what if Bob generates his proof, and instead of sending it on-chain, I verify it *within* my own proof before playing my own turn?".
+
+She can then generate a proof that she verified his proof, and so on.
+
+```md
+      Did you fail?  <--------------------------
+           / \                                  /
+          /   \                             n = n -1 
+         /     \                              /
+       Yes      No                           /
+        |        |                          /
+        |        |                         /
+        |      You win                    /
+        |                                /
+        |                               /
+Generate proof of that                 /
+        +                             /
+    my own guess     ----------------
+```
+
+### Charlie - Recursive merkle tree
+
+Charlie is a concerned citizen, and wants to be sure his vote in an election is accounted for. He votes with a ZK proof, but he has no way of knowing that his ZK proof was included in the total vote count!
+
+If the vote collector puts all of the votes into a [Merkle tree](https://en.wikipedia.org/wiki/Merkle_tree), everyone can prove the verification of two proofs within one proof, as such:
+
+```md
+                    abcd
+           __________|______________
+          |                         |
+         ab                         cd 
+     _____|_____              ______|______
+    |           |            |             |              
+  alice        bob        charlie        daniel 
+```
+
+Doing this recursively allows us to arrive on a final proof `abcd` which if true, verifies the correctness of all the votes.
+
+### Daniel - Reusable components
+
+Daniel has a big circuit and a big headache. A part of his circuit is a setup phase that finishes with some assertions that need to be made. But that section alone takes most of the proving time, and is largely independent of the rest of the circuit.
+
+He might find it more efficient to generate a proof for that setup phase separately, and verify that proof recursively in the actual business logic section of his circuit. This will allow for parallelization of both proofs, which results in a considerable speedup.
+
+## What params do I need
+
+As you can see in the [recursion reference](noir/standard_library/recursion.mdx), a simple recursive proof requires:
+
+- The proof to verify
+- The Verification Key of the circuit that generated the proof
+- A hash of this verification key, as it's needed for some backends
+- The public inputs for the proof
+
+:::info
+
+Recursive zkSNARK schemes do not necessarily "verify a proof" in the sense that you expect a true or false to be spit out by the verifier. Rather an aggregation object is built over the public inputs.
+
+So, taking the example of Alice and Bob and their guessing game:
+
+- Alice makes her guess. Her proof is *not* recursive: it doesn't verify any proof within it! It's just a standard `assert(x != y)` circuit
+- Bob verifies Alice's proof and makes his own guess. In this circuit, he doesn't exactly *prove* the verification of Alice's proof. Instead, he *aggregates* his proof to Alice's proof. The actual verification is done when the full proof is verified, for example when using `nargo verify` or through the verifier smart contract.
+
+We can imagine recursive proofs a [relay race](https://en.wikipedia.org/wiki/Relay_race). The first runner doesn't have to receive the baton from anyone else, as he/she already starts with it. But when his/her turn is over, the next runner needs to receive it, run a bit more, and pass it along. Even though every runner could theoretically verify the baton mid-run (why not? 🏃🔍), only at the end of the race does the referee verify that the whole race is valid.
+
+:::
+
+## Some architecture
+
+As with everything in computer science, there's no one-size-fits all. But there are some patterns that could help understanding and implementing them. To give three examples:
+
+### Adding some logic to a proof verification
+
+This would be an approach for something like our guessing game, where proofs are sent back and forth and are verified by each opponent. This circuit would be divided in two sections:
+
+- A `recursive verification` section, which would be just the call to `std::verify_proof`, and that would be skipped on the first move (since there's no proof to verify)
+- A `guessing` section, which is basically the logic part where the actual guessing happens
+
+In such a situation, and assuming Alice is first, she would skip the first part and try to guess Bob's number. Bob would then verify her proof on the first section of his run, and try to guess Alice's number on the second part, and so on.
+
+### Aggregating proofs
+
+In some one-way interaction situations, recursion would allow for aggregation of simple proofs that don't need to be immediately verified on-chain or elsewhere.
+
+To give a practical example, a barman wouldn't need to verify a "proof-of-age" on-chain every time he serves alcohol to a customer. Instead, the architecture would comprise two circuits:
+
+- A `main`, non-recursive circuit with some logic
+- A `recursive` circuit meant to verify two proofs in one proof
+
+The customer's proofs would be intermediate, and made on their phones, and the barman could just verify them locally. He would then aggregate them into a final proof sent on-chain (or elsewhere) at the end of the day.
+
+### Recursively verifying different circuits
+
+Nothing prevents you from verifying different circuits in a recursive proof, for example:
+
+- A `circuit1` circuit
+- A `circuit2` circuit
+- A `recursive` circuit
+
+In this example, a regulator could verify that taxes were paid for a specific purchase by aggregating both a `payer` circuit (proving that a purchase was made and taxes were paid), and a `receipt` circuit (proving that the payment was received)
+
+## How fast is it
+
+At the time of writing, verifying recursive proofs is surprisingly fast. This is because most of the time is spent on generating the verification key that will be used to generate the next proof. So you are able to cache the verification key and reuse it later.
+
+Currently, Noir JS packages don't expose the functionality of loading proving and verification keys, but that feature exists in the underlying `bb.js` package.
+
+## How can I try it
+
+Learn more about using recursion in Nargo and NoirJS in the [how-to guide](../how_to/how-to-recursion.md) and see a full example in [noir-examples](https://github.com/noir-lang/noir-examples).
diff --git a/docs/versioned_docs/version-v0.39.0/explainers/explainer-writing-noir.md b/docs/versioned_docs/version-v0.39.0/explainers/explainer-writing-noir.md
new file mode 100644
index 00000000000..3ce4245dc45
--- /dev/null
+++ b/docs/versioned_docs/version-v0.39.0/explainers/explainer-writing-noir.md
@@ -0,0 +1,177 @@
+---
+title: Thinking in Circuits
+description: Considerations when writing Noir programs
+keywords: [Noir, programming, rust]
+tags: [Optimization]
+sidebar_position: 0
+---
+
+
+This article intends to set you up with key concepts essential for writing more viable applications that use zero knowledge proofs, namely around efficient circuits.
+
+## Context - 'Efficient' is subjective
+
+When writing a web application for a performant computer with high-speed internet connection, writing efficient code sometimes is seen as an afterthought only if needed. Large multiplications running at the innermost of nested loops may not even be on a dev's radar.
+When writing firmware for a battery-powered microcontroller, you think of cpu cycles as rations to keep within a product's power budget.
+
+> Code is written to create applications that perform specific tasks within specific constraints
+
+And these constraints differ depending on where the compiled code is execute.
+
+### The Ethereum Virtual Machine (EVM)
+
+In scenarios where extremely low gas costs are required for an Ethereum application to be viable/competitive, Ethereum smart contract developers get into what is colloquially known as: "*gas golfing*". Finding the lowest execution cost of their compiled code (EVM bytecode) to achieve a specific task.
+
+The equivalent optimization task when writing zk circuits is affectionately referred to as "*gate golfing*", finding the lowest gate representation of the compiled Noir code.
+
+### Coding for circuits - a paradigm shift
+
+In zero knowledge cryptography, code is compiled to "circuits" consisting of arithmetic gates, and gate count is the significant cost. Depending on the proving system this is linearly proportionate to proving time, and so from a product point this should be kept as low as possible.
+
+Whilst writing efficient code for web apps and Solidity has a few key differences, writing efficient circuits have a different set of considerations. It is a bit of a paradigm shift, like writing code for GPUs for the first time...
+
+For example, drawing a circle at (0, 0) of radius `r`:
+- For a single CPU thread,
+```
+for theta in 0..2*pi {
+  let x = r * cos(theta);
+  let y = r * sin(theta);
+  draw(x, y);
+} // note: would do 0 - pi/2 and draw +ve/-ve x and y.
+```
+
+- For GPUs (simultaneous parallel calls with x, y across image),
+```
+if (x^2 + y^2 = r^2) {
+  draw(x, y);
+}
+```
+
+([Related](https://www.youtube.com/watch?v=-P28LKWTzrI))
+
+Whilst this CPU -> GPU does not translate to circuits exactly, it is intended to exemplify the difference in intuition when coding for different machine capabilities/constraints.
+
+### Context Takeaway
+
+For those coming from a primarily web app background, this article will explain what you need to consider when writing circuits. Furthermore, for those experienced writing efficient machine code, prepare to shift what you think is efficient 😬
+
+## Translating from Rust
+
+For some applications using Noir, existing code might be a convenient starting point to then proceed to optimize the gate count of.
+
+:::note
+Many valuable functions and algorithms have been written in more established languages (C/C++), and converted to modern ones (like Rust).
+:::
+
+Fortunately for Noir developers, when needing a particular function a Rust implementation can be readily compiled into Noir with some key changes. While the compiler does a decent amount of optimizations, it won't be able to change code that has been optimized for clock-cycles into code optimized for arithmetic gates.
+
+A few things to do when converting Rust code to Noir:
+- `println!` is not a macro, use `println` function (same for `assert_eq`)
+- No early `return` in function. Use constrain via assertion instead
+- No passing by reference. Remove `&` operator to pass by value (copy)
+- No boolean operators (`&&`, `||`). Use bitwise operators (`&`, `|`) with boolean values
+- No type `usize`. Use types `u8`, `u32`, `u64`, ... 
+- `main` return must be public, `pub`
+- No `const`, use `global`
+- Noir's LSP is your friend, so error message should be informative enough to resolve syntax issues.
+
+## Writing efficient Noir for performant products
+
+The following points help refine our understanding over time.
+
+:::note
+A Noir program makes a statement that can be verified.
+:::
+
+It compiles to a structure that represents the calculation, and can assert results within the calculation at any stage (via the `constrain` keyword).
+
+A Noir program compiles to an Abstract Circuit Intermediate Representation which is:
+ - Conceptually a tree structure
+ - Leaves (inputs) are the `Field` type
+ - Nodes contain arithmetic operations to combine them (gates)
+ - The root is the final result (return value)
+
+:::tip
+The command `nargo info` shows the programs circuit size, and is useful to compare the value of changes made.
+You can dig deeper and use the `--print-acir` param to take a closer look at individual ACIR opcodes, and the proving backend to see its gate count (eg for barretenberg, `bb gates -b ./target/program.json`).
+:::
+
+### Use the `Field` type
+
+Since the native type of values in circuits are `Field`s, using them for variables in Noir means less gates converting them under the hood.
+Some things to be mindful of when using a Field type for a regular integer value:
+- A variable of type `Field` can be cast `as` an integer type (eg `u8`, `u64`)
+  - Note: this retains only the bits of the integer type. Eg a Field value of 260 as a `u8` becomes 4
+- For Field types arithmetic operations meaningfully overflow/underflow, yet for integer types they are checked according to their size
+- Comparisons and bitwise operations do not exist for `Field`s, cast to an appropriately sized integer type when you need to
+
+:::tip
+Where possible, use `Field` type for values. Using smaller value types, and bit-packing strategies, will result in MORE gates
+:::
+
+
+### Use Arithmetic over non-arithmetic operations
+
+Since circuits are made of arithmetic gates, the cost of arithmetic operations tends to be one gate. Whereas for procedural code, they represent several clock cycles.
+
+Inversely, non-arithmetic operators are achieved with multiple gates, vs 1 clock cycle for procedural code.
+
+| (cost\op)  | arithmetic<br>(`*`, `+`) | bit-wise ops<br>(eg `<`, `\|`, `>>`) |
+| - | - | - |
+| **cycles** | 10+ | 1 |
+| **gates**  | 1 | 10+ |
+
+Bit-wise operations (e.g. bit shifts `<<` and `>>`), albeit commonly used in general programming and especially for clock cycle optimizations, are on the contrary expensive in gates when performed within circuits.
+
+Translate away from bit shifts when writing constrained functions for the best performance.
+
+On the flip side, feel free to use bit shifts in unconstrained functions and tests if necessary, as they are executed outside of circuits and does not induce performance hits.
+
+### Use static over dynamic values
+
+Another general theme that manifests in different ways is that static reads are represented with less gates than dynamic ones.
+
+Reading from read-only memory (ROM) adds less gates than random-access memory (RAM), 2 vs ~3.25 due to the additional bounds checks. Arrays of fixed length (albeit used at a lower capacity), will generate less gates than dynamic storage.
+
+Related to this, if an index used to access an array is not known at compile time (ie unknown until run time), then ROM will be converted to RAM, expanding the gate count.
+
+:::tip
+Use arrays and indices that are known at compile time where possible.
+Using `assert_constant(i);` before an index, `i`, is used in an array will give a compile error if `i` is NOT known at compile time.
+:::
+
+### Leverage unconstrained execution
+
+Constrained verification can leverage unconstrained execution, this is especially useful for operations that are represented by many gates.
+Use an [unconstrained function](../noir/concepts/unconstrained.md) to perform gate-heavy calculations, then verify and constrain the result.
+
+Eg division generates more gates than multiplication, so calculating the quotient in an unconstrained function then constraining the product for the quotient and divisor (+ any remainder) equals the dividend will be more efficient.
+
+Use `  if is_unconstrained() { /`, to conditionally execute code if being called in an unconstrained vs constrained way.
+
+## Advanced
+
+Unless you're well into the depth of gate optimization, this advanced section can be ignored.
+
+### Combine arithmetic operations
+
+A Noir program can be honed further by combining arithmetic operators in a way that makes the most of each constraint of the backend proving system. This is in scenarios where the backend might not be doing this perfectly.
+
+Eg Barretenberg backend (current default for Noir) is a width-4 PLONKish constraint system
+$ w_1*w_2*q_m + w_1*q_1 + w_2*q_2 + w_3*q_3 + w_4*q_4 + q_c = 0 $
+
+Here we see there is one occurrence of witness 1 and 2 ($w_1$, $w_2$) being multiplied together, with addition to witnesses 1-4 ($w_1$ .. $w_4$) multiplied by 4 corresponding circuit constants ($q_1$ .. $q_4$) (plus a final circuit constant, $q_c$).
+
+Use `nargo info --print-acir`, to inspect the ACIR opcodes (and the proving system for gates), and it may present opportunities to amend the order of operations and reduce the number of constraints.
+
+#### Variable as witness vs expression
+
+If you've come this far and really know what you're doing at the equation level, a temporary lever (that will become unnecessary/useless over time) is: `std::as_witness`. This informs the compiler to save a variable as a witness not an expression.
+
+The compiler will mostly be correct and optimal, but this may help some near term edge cases that are yet to optimize.
+Note: When used incorrectly it will create **less** efficient circuits (higher gate count).
+
+## References
+- Guillaume's ["`Cryptdoku`" talk](https://www.youtube.com/watch?v=MrQyzuogxgg) (Jun'23)
+- Tips from Tom, Jake and Zac.
+- [Idiomatic Noir](https://www.vlayer.xyz/blog/idiomatic-noir-part-1-collections) blog post
diff --git a/docs/versioned_docs/version-v0.39.0/getting_started/noir_installation.md b/docs/versioned_docs/version-v0.39.0/getting_started/noir_installation.md
new file mode 100644
index 00000000000..a5c7e649278
--- /dev/null
+++ b/docs/versioned_docs/version-v0.39.0/getting_started/noir_installation.md
@@ -0,0 +1,106 @@
+---
+title: Standalone Noir Installation
+description: There are different ways to install Nargo, the one-stop shop and command-line tool for developing Noir programs. This guide explains how to specify which version to install when using noirup, and using WSL for windows.
+keywords: [
+    Installation
+    Nargo
+    Noirup
+    Binaries
+    Compiling from Source
+    WSL for Windows
+    macOS
+    Linux
+    Nix
+    Direnv
+    Uninstalling Nargo
+  ]
+sidebar_position: 2
+---
+
+Noirup is the endorsed method for installing Nargo, streamlining the process of fetching binaries or compiling from source. It supports a range of options to cater to your specific needs, from nightly builds and specific versions to compiling from various sources.
+
+### Installing Noirup
+
+First, ensure you have `noirup` installed:
+
+```sh
+curl -L https://raw.githubusercontent.com/noir-lang/noirup/main/install | bash
+```
+
+### Fetching Binaries
+
+With `noirup`, you can easily switch between different Nargo versions, including nightly builds:
+
+- **Nightly Version**: Install the latest nightly build.
+
+  ```sh
+  noirup --version nightly
+  ```
+
+- **Specific Version**: Install a specific version of Nargo.
+
+  ```sh
+  noirup --version <version>
+  ```
+
+### Compiling from Source
+
+`noirup` also enables compiling Nargo from various sources:
+
+- **From a Specific Branch**: Install from the latest commit on a branch.
+
+  ```sh
+  noirup --branch <branch-name>
+  ```
+
+- **From a Fork**: Install from the main branch of a fork.
+
+  ```sh
+  noirup --repo <username/repo>
+  ```
+
+- **From a Specific Branch in a Fork**: Install from a specific branch in a fork.
+
+  ```sh
+  noirup --repo <username/repo> --branch <branch-name>
+  ```
+
+- **From a Specific Pull Request**: Install from a specific PR.
+
+  ```sh
+  noirup --pr <pr-number>
+  ```
+
+- **From a Specific Commit**: Install from a specific commit.
+
+  ```sh
+  noirup -C <commit-hash>
+  ```
+
+- **From Local Source**: Compile and install from a local directory.
+
+  ```sh
+  noirup --path ./path/to/local/source
+  ```
+
+## Installation on Windows
+
+The default backend for Noir (Barretenberg) doesn't provide Windows binaries at this time. For that reason, Noir cannot be installed natively. However, it is available by using Windows Subsystem for Linux (WSL).
+
+Step 1: Follow the instructions [here](https://learn.microsoft.com/en-us/windows/wsl/install) to install and run WSL.
+
+step 2: Follow the [Noirup instructions](#installing-noirup).
+
+## Setting up shell completions
+
+Once `nargo` is installed, you can [set up shell completions for it](setting_up_shell_completions).
+
+## Uninstalling Nargo
+
+If you installed Nargo with `noirup`, you can uninstall Nargo by removing the files in `~/.nargo`, `~/nargo`, and `~/noir_cache`. This ensures that all installed binaries, configurations, and cache related to Nargo are fully removed from your system.
+
+```bash
+rm -r ~/.nargo
+rm -r ~/nargo
+rm -r ~/noir_cache
+```
diff --git a/docs/versioned_docs/version-v0.39.0/getting_started/project_breakdown.md b/docs/versioned_docs/version-v0.39.0/getting_started/project_breakdown.md
new file mode 100644
index 00000000000..e442e377040
--- /dev/null
+++ b/docs/versioned_docs/version-v0.39.0/getting_started/project_breakdown.md
@@ -0,0 +1,159 @@
+---
+title: Project Breakdown
+description:
+  Learn about the anatomy of a Nargo project, including the purpose of the Prover TOML
+  file, and how to prove and verify your program.
+keywords:
+  [Nargo, Nargo project, Prover.toml, proof verification, private asset transfer]
+sidebar_position: 1
+---
+
+This section breaks down our hello world program from the previous section.
+
+## Anatomy of a Nargo Project
+
+Upon creating a new project with `nargo new` and building the in/output files with `nargo check`
+commands, you would get a minimal Nargo project of the following structure:
+
+    - src
+    - Prover.toml
+    - Nargo.toml
+
+The source directory _src_ holds the source code for your Noir program. By default only a _main.nr_
+file will be generated within it.
+
+### Prover.toml
+
+_Prover.toml_ is used for specifying the input values for executing and proving the program. You can specify `toml` files with different names by using the `--prover-name` or `-p` flags, see the [Prover](#provertoml) section below. Optionally you may specify expected output values for prove-time checking as well.
+
+### Nargo.toml
+
+_Nargo.toml_ contains the environmental options of your project. It contains a "package" section and a "dependencies" section.
+
+Example Nargo.toml:
+
+```toml
+[package]
+name = "noir_starter"
+type = "bin"
+authors = ["Alice"]
+compiler_version = "0.9.0"
+description = "Getting started with Noir"
+entry = "circuit/main.nr"
+license = "MIT"
+
+[dependencies]
+ecrecover = {tag = "v0.9.0", git = "https://github.com/colinnielsen/ecrecover-noir.git"}
+```
+
+Nargo.toml for a [workspace](../noir/modules_packages_crates/workspaces.md) will look a bit different. For example:
+
+```toml
+[workspace]
+members = ["crates/a", "crates/b"]
+default-member = "crates/a"
+```
+
+#### Package section
+
+The package section defines a number of fields including:
+
+- `name` (**required**) - the name of the package
+- `type` (**required**) - can be "bin", "lib", or "contract" to specify whether its a binary, library or Aztec contract
+- `authors` (optional) - authors of the project
+- `compiler_version` - specifies the version of the compiler to use. This is enforced by the compiler and follow's [Rust's versioning](https://doc.rust-lang.org/cargo/reference/manifest.html#the-version-field), so a `compiler_version = 0.18.0` will enforce Nargo version 0.18.0, `compiler_version = ^0.18.0` will enforce anything above 0.18.0 but below 0.19.0, etc. For more information, see how [Rust handles these operators](https://docs.rs/semver/latest/semver/enum.Op.html)
+- `description` (optional)
+- `entry` (optional) - a relative filepath to use as the entry point into your package (overrides the default of `src/lib.nr` or `src/main.nr`)
+- `backend` (optional)
+- `license` (optional)
+- `expression_width` (optional) - Sets the default backend expression width. This field will override the default backend expression width specified by the Noir compiler (currently set to width 4).
+
+#### Dependencies section
+
+This is where you will specify any dependencies for your project. See the [Dependencies page](../noir/modules_packages_crates/dependencies.md) for more info.
+
+`./proofs/` and `./contract/` directories will not be immediately visible until you create a proof or
+verifier contract respectively.
+
+### main.nr
+
+The _main.nr_ file contains a `main` method, this method is the entry point into your Noir program.
+
+In our sample program, _main.nr_ looks like this:
+
+```rust
+fn main(x : Field, y : Field) {
+    assert(x != y);
+}
+```
+
+The parameters `x` and `y` can be seen as the API for the program and must be supplied by the prover. Since neither `x` nor `y` is marked as public, the verifier does not supply any inputs, when verifying the proof.
+
+The prover supplies the values for `x` and `y` in the _Prover.toml_ file.
+
+As for the program body, `assert` ensures that the condition to be satisfied (e.g. `x != y`) is constrained by the proof of the execution of said program (i.e. if the condition was not met, the verifier would reject the proof as an invalid proof).
+
+### Prover.toml
+
+The _Prover.toml_ file is a file which the prover uses to supply the inputs to the Noir program (both private and public).
+
+In our hello world program the _Prover.toml_ file looks like this:
+
+```toml
+x = "1"
+y = "2"
+```
+
+When the command `nargo execute` is executed, nargo will execute the Noir program using the inputs specified in `Prover.toml`, aborting if it finds that these do not satisfy the constraints defined by `main`. In this example, `x` and `y` must satisfy the inequality constraint `assert(x != y)`.
+
+If an output name is specified such as `nargo execute foo`, the witness generated by this execution will be written to `./target/foo.gz`. This can then be used to generate a proof of the execution.
+
+#### Arrays of Structs
+
+The following code shows how to pass an array of structs to a Noir program to generate a proof.
+
+```rust
+// main.nr
+struct Foo {
+    bar: Field,
+    baz: Field,
+}
+
+fn main(foos: [Foo; 3]) -> pub Field {
+    foos[2].bar + foos[2].baz
+}
+```
+
+Prover.toml:
+
+```toml
+[[foos]] # foos[0]
+bar = 0
+baz = 0
+
+[[foos]] # foos[1]
+bar = 0
+baz = 0
+
+[[foos]] # foos[2]
+bar = 1
+baz = 2
+```
+
+#### Custom toml files
+
+You can specify a `toml` file with a different name to use for execution by using the `--prover-name` or `-p` flags.
+
+This command looks for proof inputs in the default **Prover.toml** and generates the witness and saves it at `./target/foo.gz`:
+
+```bash
+nargo execute foo
+```
+
+This command looks for proof inputs in the custom **OtherProver.toml** and generates the witness and saves it at `./target/bar.gz`:
+
+```bash
+nargo execute -p OtherProver bar
+```
+
+Now that you understand the concepts, you'll probably want some editor feedback while you are writing more complex code.
diff --git a/docs/versioned_docs/version-v0.39.0/getting_started/quick_start.md b/docs/versioned_docs/version-v0.39.0/getting_started/quick_start.md
new file mode 100644
index 00000000000..c693624eb82
--- /dev/null
+++ b/docs/versioned_docs/version-v0.39.0/getting_started/quick_start.md
@@ -0,0 +1,126 @@
+---
+title: Quick Start
+tags: []
+sidebar_position: 0
+---
+
+## Installation
+
+### Noir
+
+The easiest way to develop with Noir is using Nargo the CLI tool. It provides you the ability to start new projects, compile, execute and test Noir programs from the terminal.
+
+You can use `noirup` the installation script to quickly install and update Nargo:
+
+```bash
+curl -L noirup.dev | bash
+noirup
+```
+
+Once installed, you can [set up shell completions for the `nargo` command](setting_up_shell_completions).
+
+### Proving backend
+
+After installing Noir, we install a proving backend to work with our Noir programs.
+
+Proving backends provide you the abilities to generate proofs, verify proofs, generate smart contracts and more for your Noir programs.
+
+Different proving backends provide different tools for working with Noir programs, here we will use the [Barretenberg proving backend](https://github.com/AztecProtocol/aztec-packages/tree/master/barretenberg) developed by Aztec Labs as an example.
+
+You can use the `bbup` installation script to quickly install and update BB, Barretenberg's CLI tool:
+
+You can find the full list of proving backends compatible with Noir in Awesome Noir.
+
+```bash
+curl -L bbup.dev | bash
+bbup
+```
+
+For the full list of proving backends compatible with Noir, visit [Awesome Noir](https://github.com/noir-lang/awesome-noir/?tab=readme-ov-file#proving-backends).
+
+## Nargo
+
+Nargo provides the ability to initiate and execute Noir projects. Let's initialize the traditional `hello_world`:
+
+```sh
+nargo new hello_world
+```
+
+Two files will be created.
+
+- `src/main.nr` contains a simple boilerplate circuit
+- `Nargo.toml` contains environmental options, such as name, author, dependencies, and others.
+
+Glancing at _main.nr_ , we can see that inputs in Noir are private by default, but can be labeled public using the keyword `pub`. This means that we will _assert_ that we know a value `x` which is different from `y` without revealing `x`:
+
+```rust
+fn main(x : Field, y : pub Field) {
+    assert(x != y);
+}
+```
+
+To learn more about private and public values, check the [Data Types](../noir/concepts/data_types/index.md) section.
+
+### Compiling and executing
+
+We can now use `nargo` to generate a _Prover.toml_ file, where our input values will be specified:
+
+```sh
+cd hello_world
+nargo check
+
+Let's feed some valid values into this file:
+
+```toml
+x = "1"
+y = "2"
+```
+
+We're now ready to compile and execute our Noir program. By default the `nargo execute` command will do both, and generate the `witness` that we need to feed to our proving backend:
+
+```sh
+nargo execute
+```
+
+The witness corresponding to this execution will then be written to the file _./target/witness-name.gz_.
+
+The command also automatically compiles your Noir program if it was not already / was edited, which you may notice the compiled artifacts being written to the file _./target/hello_world.json_.
+
+With circuit compiled and witness generated, we're ready to prove.
+
+## Proving backend
+ 
+Different proving backends may provide different tools and commands to work with Noir programs. Here Barretenberg's `bb` CLI tool is used as an example:
+
+```sh
+bb prove -b ./target/hello_world.json -w ./target/hello_world.gz -o ./target/proof
+```
+
+:::tip
+
+Naming can be confusing, specially as you pass them to the `bb` commands. If unsure, it won't hurt to delete the target folder and start anew to make sure you're using the most recent versions of the compiled circuit and witness.
+
+:::
+
+The proof is now generated in the `target` folder. To verify it we first need to compute the verification key from the compiled circuit, and use it to verify:
+
+```sh
+bb write_vk -b ./target/hello_world.json -o ./target/vk
+bb verify -k ./target/vk -p ./target/proof
+```
+
+:::info
+
+Notice that in order to verify a proof, the verifier knows nothing but the circuit, which is compiled and used to generate the verification key. This is obviously quite important: private inputs remain private.
+
+As for the public inputs, you may have noticed they haven't been specified. This behavior varies with each particular backend, but barretenberg typically attaches them to the proof. You can see them by parsing and splitting it. For example for if your public inputs are 32 bytes:
+
+```bash
+head -c 32 ./target/proof | od -An -v -t x1 | tr -d $' \n'
+```
+
+:::
+
+Congratulations, you have now created and verified a proof for your very first Noir program!
+
+In the [next section](./project_breakdown.md), we will go into more detail on each step performed.
diff --git a/docs/versioned_docs/version-v0.39.0/getting_started/setting_up_shell_completions.md b/docs/versioned_docs/version-v0.39.0/getting_started/setting_up_shell_completions.md
new file mode 100644
index 00000000000..0447321cbab
--- /dev/null
+++ b/docs/versioned_docs/version-v0.39.0/getting_started/setting_up_shell_completions.md
@@ -0,0 +1,87 @@
+---
+title: Setting up shell completions
+tags: []
+sidebar_position: 3
+---
+
+The `nargo` binary provides a command to generate shell completions:
+
+```bash
+nargo generate-completion-script [shell]
+```
+
+where `shell` must be one of `bash`, `elvish`, `fish`, `powershell`, and `zsh`.
+
+Below we explain how to install them in some popular shells.
+
+## Installing Zsh Completions
+
+If you have `oh-my-zsh` installed, you might already have a directory of automatically loading completion scripts — `.oh-my-zsh/completions`.
+If not, first create it:
+
+```bash
+mkdir -p ~/.oh-my-zsh/completions`
+```
+
+Then copy the completion script to that directory:
+
+```bash
+nargo generate-completion-script zsh > ~/.oh-my-zsh/completions/_nargo
+```
+
+Without `oh-my-zsh`, you’ll need to add a path for completion scripts to your function path, and turn on completion script auto-loading. 
+First, add these lines to `~/.zshrc`:
+
+```bash
+fpath=(~/.zsh/completions $fpath)
+autoload -U compinit
+compinit
+```
+
+Next, create a directory at `~/.zsh/completions`:
+
+```bash
+mkdir -p ~/.zsh/completions
+```
+
+Then copy the completion script to that directory:
+
+```bash
+nargo generate-completion-script zsh > ~/.zsh/completions/_nargo
+```
+
+## Installing Bash Completions
+
+If you have [bash-completion](https://github.com/scop/bash-completion) installed, you can just copy the completion script to the `/usr/local/etc/bash_completion.d` directory:
+
+```bash
+nargo generate-completion-script bash > /usr/local/etc/bash_completion.d/nargo
+```
+
+Without `bash-completion`, you’ll need to source the completion script directly. 
+First create a directory such as `~/.bash_completions/`:
+
+```bash
+mkdir ~/.bash_completions/
+```
+
+Copy the completion script to that directory:
+
+```bash
+nargo generate-completion-script bash > ~/.bash_completions/nargo.bash
+```
+
+Then add the following line to `~/.bash_profile` or `~/.bashrc`:
+
+
+```bash
+source ~/.bash_completions/nargo.bash
+```
+
+## Installing Fish Completions
+
+Copy the completion script to any path listed in the environment variable `$fish_completion_path`. For example, a typical location is `~/.config/fish/completions/nargo.fish`:
+
+```bash
+nargo generate-completion-script fish > ~/.config/fish/completions/nargo.fish
+```
diff --git a/docs/versioned_docs/version-v0.39.0/how_to/_category_.json b/docs/versioned_docs/version-v0.39.0/how_to/_category_.json
new file mode 100644
index 00000000000..23b560f610b
--- /dev/null
+++ b/docs/versioned_docs/version-v0.39.0/how_to/_category_.json
@@ -0,0 +1,5 @@
+{
+    "position": 1,
+    "collapsible": true,
+    "collapsed": true
+}
diff --git a/docs/versioned_docs/version-v0.39.0/how_to/debugger/_category_.json b/docs/versioned_docs/version-v0.39.0/how_to/debugger/_category_.json
new file mode 100644
index 00000000000..cc2cbb1c253
--- /dev/null
+++ b/docs/versioned_docs/version-v0.39.0/how_to/debugger/_category_.json
@@ -0,0 +1,6 @@
+{
+    "label": "Debugging",
+    "position": 5,
+    "collapsible": true,
+    "collapsed": true
+}
diff --git a/docs/versioned_docs/version-v0.39.0/how_to/debugger/debugging_with_the_repl.md b/docs/versioned_docs/version-v0.39.0/how_to/debugger/debugging_with_the_repl.md
new file mode 100644
index 00000000000..1d64dae3f37
--- /dev/null
+++ b/docs/versioned_docs/version-v0.39.0/how_to/debugger/debugging_with_the_repl.md
@@ -0,0 +1,164 @@
+---
+title: Using the REPL Debugger
+description:
+  Step-by-step guide on how to debug your Noir circuits with the REPL Debugger. 
+keywords:
+  [
+    Nargo,
+    Noir CLI,
+    Noir Debugger,
+    REPL,
+  ]
+sidebar_position: 1
+---
+
+#### Pre-requisites
+
+In order to use the REPL debugger, first you need to install recent enough versions of Nargo and vscode-noir. 
+
+## Debugging a simple circuit
+
+Let's debug a simple circuit:
+
+```rust
+fn main(x : Field, y : pub Field) {
+    assert(x != y);
+}
+```
+
+To start the REPL debugger, using a terminal, go to a Noir circuit's home directory. Then:
+
+`$ nargo debug`
+
+You should be seeing this in your terminal:
+
+```
+[main] Starting debugger
+At ~/noir-examples/recursion/circuits/main/src/main.nr:1:9
+  1 -> fn main(x : Field, y : pub Field) {
+  2        assert(x != y);
+  3    }
+> 
+```
+
+The debugger displays the current Noir code location, and it is now waiting for us to drive it.
+
+Let's first take a look at the available commands. For that we'll use the `help` command.
+
+```
+> help
+Available commands:
+
+  opcodes                          display ACIR opcodes
+  into                             step into to the next opcode
+  next                             step until a new source location is reached
+  out                              step until a new source location is reached
+                                   and the current stack frame is finished
+  break LOCATION:OpcodeLocation    add a breakpoint at an opcode location
+  over                             step until a new source location is reached
+                                   without diving into function calls
+  restart                          restart the debugging session
+  delete LOCATION:OpcodeLocation   delete breakpoint at an opcode location
+  witness                          show witness map
+  witness index:u32                display a single witness from the witness map
+  witness index:u32 value:String   update a witness with the given value
+  memset index:usize value:String  update a memory cell with the given
+                                   value
+  continue                         continue execution until the end of the
+                                   program
+  vars                             show variable values available at this point
+                                   in execution
+  stacktrace                       display the current stack trace
+  memory                           show memory (valid when executing unconstrained code)
+  step                             step to the next ACIR opcode
+
+Other commands:
+
+  help  Show this help message
+  quit  Quit repl
+
+```
+
+Some commands operate only for unconstrained functions, such as `memory` and `memset`. If you try to use them while execution is paused at an ACIR opcode, the debugger will simply inform you that you are not executing unconstrained code:
+
+```
+> memory
+Unconstrained VM memory not available
+> 
+```
+
+Before continuing, we can take a look at the initial witness map:
+
+```
+> witness
+_0 = 1
+_1 = 2
+>
+```
+
+Cool, since `x==1`, `y==2`, and we want to check that `x != y`, our circuit should succeed. At this point we could intervene and use the witness setter command to change one of the witnesses. Let's set `y=3`, then back to 2, so we don't affect the expected result:
+
+```
+> witness
+_0 = 1
+_1 = 2
+> witness 1 3
+_1 = 3
+> witness
+_0 = 1
+_1 = 3
+> witness 1 2
+_1 = 2
+> witness
+_0 = 1
+_1 = 2
+>
+```
+
+Now we can inspect the current state of local variables. For that we use the `vars` command. 
+
+```
+> vars
+>
+```
+
+We currently have no vars in context, since we are at the entry point of the program. Let's use `next` to execute until the next point in the program.
+
+```
+> vars
+> next
+At ~/noir-examples/recursion/circuits/main/src/main.nr:1:20
+  1 -> fn main(x : Field, y : pub Field) {
+  2        assert(x != y);
+  3    }
+> vars
+x:Field = 0x01
+```
+
+As a result of stepping, the variable `x`, whose initial value comes from the witness map, is now in context and returned by `vars`.
+
+```
+> next
+  1    fn main(x : Field, y : pub Field) {
+  2 ->     assert(x != y);
+  3    }
+> vars
+y:Field = 0x02
+x:Field = 0x01
+```
+
+Stepping again we can finally see both variables and their values. And now we can see that the next assertion should succeed.
+
+Let's continue to the end:
+
+```
+> continue
+(Continuing execution...)
+Finished execution
+> q
+[main] Circuit witness successfully solved
+```
+
+Upon quitting the debugger after a solved circuit, the resulting circuit witness gets saved, equivalent to what would happen if we had run the same circuit with `nargo execute`.
+
+We just went through the basics of debugging using Noir REPL debugger. For a comprehensive reference, check out [the reference page](../../reference/debugger/debugger_repl.md).
diff --git a/docs/versioned_docs/version-v0.39.0/how_to/debugger/debugging_with_vs_code.md b/docs/versioned_docs/version-v0.39.0/how_to/debugger/debugging_with_vs_code.md
new file mode 100644
index 00000000000..a5858c1a5eb
--- /dev/null
+++ b/docs/versioned_docs/version-v0.39.0/how_to/debugger/debugging_with_vs_code.md
@@ -0,0 +1,68 @@
+---
+title: Using the VS Code Debugger
+description:
+  Step by step guide on how to debug your Noir circuits with the VS Code Debugger configuration and features.
+keywords:
+  [
+    Nargo,
+    Noir CLI,
+    Noir Debugger,
+    VS Code,
+    IDE,
+  ]
+sidebar_position: 0
+---
+
+This guide will show you how to use VS Code with the vscode-noir extension to debug a Noir project. 
+
+#### Pre-requisites
+
+- Nargo
+- vscode-noir
+- A Noir project with a `Nargo.toml`, `Prover.toml` and at least one Noir (`.nr`) containing an entry point function (typically `main`).
+
+## Running the debugger
+
+The easiest way to start debugging is to open the file you want to debug, and press `F5`. This will cause the debugger to launch, using your `Prover.toml` file as input.
+
+You should see something like this:
+
+![Debugger launched](@site/static/img/debugger/1-started.png)
+
+Let's inspect the state of the program. For that, we open VS Code's _Debug pane_. Look for this icon:
+
+![Debug pane icon](@site/static/img/debugger/2-icon.png)
+
+You will now see two categories of variables: Locals and Witness Map.
+
+![Debug pane expanded](@site/static/img/debugger/3-debug-pane.png)
+
+1. **Locals**: variables of your program. At this point in execution this section is empty, but as we step through the code it will get populated by `x`, `result`, `digest`, etc. 
+
+2. **Witness map**: these are initially populated from your project's `Prover.toml` file. In this example, they will be used to populate `x` and `result` at the beginning of the `main` function.
+
+Most of the time you will probably be focusing mostly on locals, as they represent the high level state of your program. 
+
+You might be interested in inspecting the witness map in case you are trying to solve a really low level issue in the compiler or runtime itself, so this concerns mostly advanced or niche users.
+
+Let's step through the program, by using the debugger buttons or their corresponding keyboard shortcuts.
+
+![Debugger buttons](@site/static/img/debugger/4-debugger-buttons.png)
+
+Now we can see in the variables pane that there's values for `digest`, `result` and `x`.
+
+![Inspecting locals](@site/static/img/debugger/5-assert.png)
+
+We can also inspect the values of variables by directly hovering on them on the code.
+
+![Hover locals](@site/static/img/debugger/6-hover.png)
+
+Let's set a break point at the `keccak256` function, so we can continue execution up to the point when it's first invoked without having to go one step at a time. 
+
+We just need to click the to the right of the line number 18. Once the breakpoint appears, we can click the `continue` button or use its corresponding keyboard shortcut (`F5` by default).
+
+![Breakpoint](@site/static/img/debugger/7-break.png)
+
+Now we are debugging the `keccak256` function, notice the _Call Stack pane_ at the lower right. This lets us inspect the current call stack of our process.
+
+That covers most of the current debugger functionalities. Check out [the reference](../../reference/debugger/debugger_vscode.md) for more details on how to configure the debugger.
\ No newline at end of file
diff --git a/docs/versioned_docs/version-v0.39.0/how_to/how-to-oracles.md b/docs/versioned_docs/version-v0.39.0/how_to/how-to-oracles.md
new file mode 100644
index 00000000000..4763b7788d6
--- /dev/null
+++ b/docs/versioned_docs/version-v0.39.0/how_to/how-to-oracles.md
@@ -0,0 +1,275 @@
+---
+title: How to use Oracles
+description: Learn how to use oracles in your Noir program with examples in both Nargo and NoirJS. This guide also covers writing a JSON RPC server and providing custom foreign call handlers for NoirJS.
+keywords:
+  - Noir Programming
+  - Oracles
+  - Nargo
+  - NoirJS
+  - JSON RPC Server
+  - Foreign Call Handlers
+sidebar_position: 1
+---
+
+This guide shows you how to use oracles in your Noir program. For the sake of clarity, it assumes that:
+
+- You have read the [explainer on Oracles](../explainers/explainer-oracle.md) and are comfortable with the concept.
+- You have a Noir program to add oracles to. You can create one using the [vite-hardhat starter](https://github.com/noir-lang/noir-starter/tree/main/vite-hardhat) as a boilerplate.
+- You understand the concept of a JSON-RPC server. Visit the [JSON-RPC website](https://www.jsonrpc.org/) if you need a refresher.
+- You are comfortable with server-side JavaScript (e.g. Node.js, managing packages, etc.).
+
+## Rundown
+
+This guide has 3 major steps:
+
+1. How to modify our Noir program to make use of oracle calls as unconstrained functions
+2. How to write a JSON RPC Server to resolve these oracle calls with Nargo
+3. How to use them in Nargo and how to provide a custom resolver in NoirJS
+
+## Step 1 - Modify your Noir program
+
+An oracle is defined in a Noir program by defining two methods:
+
+- An unconstrained method - This tells the compiler that it is executing an [unconstrained functions](../noir/concepts//unconstrained.md).
+- A decorated oracle method - This tells the compiler that this method is an RPC call.
+
+An example of an oracle that returns a `Field` would be:
+
+```rust
+#[oracle(getSqrt)]
+unconstrained fn sqrt(number: Field) -> Field { }
+
+unconstrained fn get_sqrt(number: Field) -> Field {
+    sqrt(number)
+}
+```
+
+In this example, we're wrapping our oracle function in an unconstrained method, and decorating it with `oracle(getSqrt)`. We can then call the unconstrained function as we would call any other function:
+
+```rust
+fn main(input: Field) {
+    let sqrt = get_sqrt(input);
+}
+```
+
+In the next section, we will make this `getSqrt` (defined on the `sqrt` decorator) be a method of the RPC server Noir will use.
+
+:::danger
+
+As explained in the [Oracle Explainer](../explainers/explainer-oracle.md), this `main` function is unsafe unless you constrain its return value. For example:
+
+```rust
+fn main(input: Field) {
+    let sqrt = get_sqrt(input);
+    assert(sqrt.pow_32(2) as u64 == input as u64); // <---- constrain the return of an oracle!
+}
+```
+
+:::
+
+:::info
+
+Currently, oracles only work with single params or array params. For example:
+
+```rust
+#[oracle(getSqrt)]
+unconstrained fn sqrt([Field; 2]) -> [Field; 2] { }
+```
+
+:::
+
+## Step 2 - Write an RPC server
+
+Brillig will call *one* RPC server. Most likely you will have to write your own, and you can do it in whatever language you prefer. In this guide, we will do it in Javascript.
+
+Let's use the above example of an oracle that consumes an array with two `Field` and returns their square roots:
+
+```rust
+#[oracle(getSqrt)]
+unconstrained fn sqrt(input: [Field; 2]) -> [Field; 2] { }
+
+unconstrained fn get_sqrt(input: [Field; 2]) -> [Field; 2] {
+    sqrt(input)
+}
+
+fn main(input: [Field; 2]) {
+    let sqrt = get_sqrt(input);
+    assert(sqrt[0].pow_32(2) as u64 == input[0] as u64);
+    assert(sqrt[1].pow_32(2) as u64 == input[1] as u64);
+}
+
+#[test]
+fn test() {
+    let input = [4, 16];
+    main(input);
+}
+```
+
+:::info
+
+Why square root?
+
+In general, computing square roots is computationally more expensive than multiplications, which takes a toll when speaking about ZK applications. In this case, instead of calculating the square root in Noir, we are using our oracle to offload that computation to be made in plain. In our circuit we can simply multiply the two values.
+
+:::
+
+Now, we should write the correspondent RPC server, starting with the [default JSON-RPC 2.0 boilerplate](https://www.npmjs.com/package/json-rpc-2.0#example):
+
+```js
+import { JSONRPCServer } from "json-rpc-2.0";
+import express from "express";
+import bodyParser from "body-parser";
+
+const app = express();
+app.use(bodyParser.json());
+
+const server = new JSONRPCServer();
+app.post("/", (req, res) => {
+ const jsonRPCRequest = req.body;
+ server.receive(jsonRPCRequest).then((jsonRPCResponse) => {
+  if (jsonRPCResponse) {
+   res.json(jsonRPCResponse);
+  } else {
+   res.sendStatus(204);
+  }
+ });
+});
+
+app.listen(5555);
+```
+
+Now, we will add our `getSqrt` method, as expected by the `#[oracle(getSqrt)]` decorator in our Noir code. It maps through the params array and returns their square roots:
+
+```js
+server.addMethod("resolve_foreign_call", async (params) => {
+    if (params[0].function !== "getSqrt") {
+        throw Error("Unexpected foreign call")
+    };
+    const values = params[0].inputs[0].map((field) => {
+        return `${Math.sqrt(parseInt(field, 16))}`;
+    });
+    return { values: [values] };
+});
+```
+
+If you're using Typescript, the following types may be helpful in understanding the expected return value and making sure they're easy to follow:
+
+```js
+export type ForeignCallSingle = string;
+
+export type ForeignCallArray = string[];
+
+export type ForeignCallResult = {
+  values: (ForeignCallSingle | ForeignCallArray)[];
+};
+```
+
+:::info Multidimensional Arrays
+
+If the Oracle function is returning an array containing other arrays, such as `[['1','2],['3','4']]`, you need to provide the values in JSON as flattened values. In the previous example, it would be `['1', '2', '3', '4']`. In the Noir program, the Oracle signature can use a nested type, the flattened values will be automatically converted to the nested type.
+
+:::
+
+## Step 3 - Usage with Nargo
+
+Using the [`nargo` CLI tool](../reference/nargo_commands.md), you can use oracles in the `nargo test` and `nargo execute`  commands by passing a value to `--oracle-resolver`. For example:
+
+```bash
+nargo test --oracle-resolver http://localhost:5555
+```
+
+This tells `nargo` to use your RPC Server URL whenever it finds an oracle decorator.
+
+## Step 4 - Usage with NoirJS
+
+In a JS environment, an RPC server is not strictly necessary, as you may want to resolve your oracles without needing any JSON call at all. NoirJS simply expects that you pass a callback function when you generate proofs, and that callback function can be anything.
+
+For example, if your Noir program expects the host machine to provide CPU pseudo-randomness, you could simply pass it as the `foreignCallHandler`. You don't strictly need to create an RPC server to serve pseudo-randomness, as you may as well get it directly in your app:
+
+```js
+const foreignCallHandler = (name, inputs) => crypto.randomBytes(16) // etc
+
+await noir.execute(inputs, foreignCallHandler)
+```
+
+As one can see, in NoirJS, the [`foreignCallHandler`](../reference/NoirJS/noir_js/type-aliases/ForeignCallHandler.md) function simply means "a callback function that returns a value of type [`ForeignCallOutput`](../reference/NoirJS/noir_js/type-aliases/ForeignCallOutput.md). It doesn't have to be an RPC call like in the case for Nargo.
+
+:::tip
+
+Does this mean you don't have to write an RPC server like in [Step #2](#step-2---write-an-rpc-server)?
+
+You don't technically have to, but then how would you run `nargo test`? To use both `Nargo` and `NoirJS` in your development flow, you will have to write a JSON RPC server.
+
+:::
+
+In this case, let's make `foreignCallHandler` call the JSON RPC Server we created in [Step #2](#step-2---write-an-rpc-server), by making it a JSON RPC Client.
+
+For example, using the same `getSqrt` program in [Step #1](#step-1---modify-your-noir-program) (comments in the code):
+
+```js
+import { JSONRPCClient } from "json-rpc-2.0";
+
+// declaring the JSONRPCClient
+const client = new JSONRPCClient((jsonRPCRequest) => {
+// hitting the same JSON RPC Server we coded above
+ return fetch("http://localhost:5555", {
+  method: "POST",
+  headers: {
+   "content-type": "application/json",
+  },
+  body: JSON.stringify(jsonRPCRequest),
+ }).then((response) => {
+  if (response.status === 200) {
+   return response
+    .json()
+    .then((jsonRPCResponse) => client.receive(jsonRPCResponse));
+  } else if (jsonRPCRequest.id !== undefined) {
+   return Promise.reject(new Error(response.statusText));
+  }
+ });
+});
+
+// declaring a function that takes the name of the foreign call (getSqrt) and the inputs
+const foreignCallHandler = async (name, input) => {
+  const inputs = input[0].map((i) => i.toString("hex"))
+  // notice that the "inputs" parameter contains *all* the inputs
+  // in this case we to make the RPC request with the first parameter "numbers", which would be input[0]
+  const oracleReturn = await client.request("resolve_foreign_call", [
+    {
+      function: name,
+      inputs: [inputs]
+    },
+  ]);
+  return [oracleReturn.values[0]];
+};
+
+// the rest of your NoirJS code
+const input = { input: [4, 16] };
+const { witness } = await noir.execute(input, foreignCallHandler);
+```
+
+:::tip
+
+If you're in a NoirJS environment running your RPC server together with a frontend app, you'll probably hit a familiar problem in full-stack development: requests being blocked by [CORS](https://developer.mozilla.org/en-US/docs/Web/HTTP/CORS) policy. For development only, you can simply install and use the [`cors` npm package](https://www.npmjs.com/package/cors) to get around the problem:
+
+```bash
+yarn add cors
+```
+
+and use it as a middleware:
+
+```js
+import cors from "cors";
+
+const app = express();
+app.use(cors())
+```
+
+:::
+
+## Conclusion
+
+Hopefully by the end of this guide, you should be able to:
+
+- Write your own logic around Oracles and how to write a JSON RPC server to make them work with your Nargo commands.
+- Provide custom foreign call handlers for NoirJS.
diff --git a/docs/versioned_docs/version-v0.39.0/how_to/how-to-recursion.md b/docs/versioned_docs/version-v0.39.0/how_to/how-to-recursion.md
new file mode 100644
index 00000000000..399e4d4b38a
--- /dev/null
+++ b/docs/versioned_docs/version-v0.39.0/how_to/how-to-recursion.md
@@ -0,0 +1,172 @@
+---
+title: How to use recursion on NoirJS
+description: Learn how to implement recursion with NoirJS, a powerful tool for creating smart contracts on the EVM blockchain. This guide assumes familiarity with NoirJS, solidity verifiers, and the Barretenberg proving backend. Discover how to generate both final and intermediate proofs using `noir_js` and `bb.js`.
+keywords:
+  [
+    "NoirJS",
+    "EVM blockchain",
+    "smart contracts",
+    "recursion",
+    "solidity verifiers",
+    "Barretenberg backend",
+    "noir_js",
+    "intermediate proofs",
+    "final proofs",
+    "nargo compile",
+    "json import",
+    "recursive circuit",
+    "recursive app"
+  ]
+sidebar_position: 1
+---
+
+This guide shows you how to use recursive proofs in your NoirJS app. For the sake of clarity, it is assumed that:
+
+- You already have a NoirJS app. If you don't, please visit the [NoirJS tutorial](../tutorials/noirjs_app.md) and the [reference](../reference/NoirJS/noir_js/index.md).
+- You are familiar with what are recursive proofs and you have read the [recursion explainer](../explainers/explainer-recursion.md)
+- You already built a recursive circuit following [the reference](../noir/standard_library/recursion.mdx), and understand how it works.
+
+It is also assumed that you're not using `noir_wasm` for compilation, and instead you've used [`nargo compile`](../reference/nargo_commands.md) to generate the `json` you're now importing into your project. However, the guide should work just the same if you're using `noir_wasm`.
+
+:::info
+
+As you've read in the [explainer](../explainers/explainer-recursion.md), a recursive proof is an intermediate proof. This means that it doesn't necessarily generate the final step that makes it verifiable in a smart contract. However, it is easy to verify within another circuit.
+
+:::
+
+In a standard recursive app, you're also dealing with at least two circuits. For the purpose of this guide, we will assume the following:
+
+- `main`: a circuit of type `assert(x != y)`, which we want to embed in another circuit recursively. For example when proving with the `bb` tool, we can use the `--recursive` CLI option to tell the backend that it should generate proofs that are friendly for verification within another circuit.
+- `recursive`: a circuit that verifies `main`
+
+For a full example of how recursive proofs work, please refer to the [noir-examples](https://github.com/noir-lang/noir-examples) repository. We will *not* be using it as a reference for this guide.
+
+## Step 1: Setup
+
+In a common NoirJS app, you need to instantiate a backend with something like `const backend = new Backend(circuit)`. Then you feed it to the `noir_js` interface.
+
+For recursion, this doesn't happen, and the only need for `noir_js` is only to `execute` a circuit and get its witness and return value. Everything else is not interfaced, so it needs to happen on the `backend` object.
+
+It is also recommended that you instantiate the backend with as many threads as possible, to allow for maximum concurrency:
+
+```js
+const backend = new UltraPlonkBackend(circuit, { threads: 8 }, { recursive: true })
+```
+
+:::tip
+You can use the [`os.cpus()`](https://nodejs.org/api/os.html#oscpus) object in `nodejs` or [`navigator.hardwareConcurrency`](https://developer.mozilla.org/en-US/docs/Web/API/Navigator/hardwareConcurrency) on the browser to make the most out of those glorious cpu cores
+:::
+
+## Step 2: Generating the witness and the proof for `main`
+
+After instantiating the backend, you should also instantiate `noir_js`. We will use it to execute the circuit and get the witness.
+
+```js
+const noir = new Noir(circuit)
+const { witness } = noir.execute(input)
+```
+
+With this witness, you are now able to generate the intermediate proof for the main circuit:
+
+```js
+const { proof, publicInputs } = await backend.generateProof(witness)
+```
+
+:::warning
+
+Always keep in mind what is actually happening on your development process, otherwise you'll quickly become confused about what circuit we are actually running and why!
+
+In this case, you can imagine that Alice (running the `main` circuit) is proving something to Bob (running the `recursive` circuit), and Bob is verifying her proof within his proof.
+
+With this in mind, it becomes clear that our intermediate proof is the one *meant to be verified within another circuit*, so it must be Alice's. Actually, the only final proof in this theoretical scenario would be the last one, sent on-chain.
+
+:::
+
+## Step 3 - Verification and proof artifacts
+
+Optionally, you are able to verify the intermediate proof:
+
+```js
+const verified = await backend.verifyProof({ proof, publicInputs })
+```
+
+This can be useful to make sure our intermediate proof was correctly generated. But the real goal is to do it within another circuit. For that, we need to generate  recursive proof artifacts that will be passed to the circuit that is verifying the proof we just generated. Instead of passing the proof and verification key as a byte array, we pass them as fields which makes it cheaper to verify in a circuit:
+
+```js
+const { proofAsFields, vkAsFields, vkHash } = await backend.generateRecursiveProofArtifacts( { publicInputs, proof }, publicInputsCount)
+```
+
+This call takes the public inputs and the proof, but also the public inputs count. While this is easily retrievable by simply counting the `publicInputs` length, the backend interface doesn't currently abstract it away.
+
+:::info
+
+The `proofAsFields` has a constant size `[Field; 93]` and verification keys in Barretenberg are always `[Field; 114]`.
+
+:::
+
+:::warning
+
+One common mistake is to forget *who* makes this call.
+
+In a situation where Alice is generating the `main` proof, if she generates the proof artifacts and sends them to Bob, which gladly takes them as true, this would mean Alice could prove anything!
+
+Instead, Bob needs to make sure *he* extracts the proof artifacts, using his own instance of the `main` circuit backend. This way, Alice has to provide a valid proof for the correct `main` circuit.
+
+:::
+
+## Step 4 - Recursive proof generation
+
+With the artifacts, generating a recursive proof is no different from a normal proof. You simply use the `backend` (with the recursive circuit) to generate it:
+
+```js
+const recursiveInputs = {
+    verification_key: vkAsFields, // array of length 114
+    proof: proofAsFields, // array of length 93 + size of public inputs
+    publicInputs: [mainInput.y], // using the example above, where `y` is the only public input
+    key_hash: vkHash,
+}
+
+const { witness, returnValue } = noir.execute(recursiveInputs) // we're executing the recursive circuit now!
+const { proof, publicInputs } = backend.generateProof(witness)
+const verified = backend.verifyProof({ proof, publicInputs })
+```
+
+You can obviously chain this proof into another proof. In fact, if you're using recursive proofs, you're probably interested of using them this way!
+
+:::tip
+
+Managing circuits and "who does what" can be confusing. To make sure your naming is consistent, you can keep them in an object. For example:
+
+```js
+const circuits = {
+  main: mainJSON,
+  recursive: recursiveJSON
+}
+const backends = {
+  main: new BarretenbergBackend(circuits.main),
+  recursive: new BarretenbergBackend(circuits.recursive)
+}
+const noir_programs = {
+  main: new Noir(circuits.main),
+  recursive: new Noir(circuits.recursive)
+}
+```
+
+This allows you to neatly call exactly the method you want without conflicting names:
+
+```js
+// Alice runs this 👇
+const { witness: mainWitness } = await noir_programs.main.execute(input)
+const proof = await backends.main.generateProof(mainWitness)
+
+// Bob runs this 👇
+const verified = await backends.main.verifyProof(proof)
+const { proofAsFields, vkAsFields, vkHash } = await backends.main.generateRecursiveProofArtifacts(
+    proof,
+    numPublicInputs,
+);
+const { witness: recursiveWitness } = await noir_programs.recursive.execute(recursiveInputs)
+const recursiveProof = await backends.recursive.generateProof(recursiveWitness);
+```
+
+:::
diff --git a/docs/versioned_docs/version-v0.39.0/how_to/how-to-solidity-verifier.md b/docs/versioned_docs/version-v0.39.0/how_to/how-to-solidity-verifier.md
new file mode 100644
index 00000000000..2cc0f8e57ce
--- /dev/null
+++ b/docs/versioned_docs/version-v0.39.0/how_to/how-to-solidity-verifier.md
@@ -0,0 +1,259 @@
+---
+title: Generate a Solidity Verifier
+description:
+  Learn how to run the verifier as a smart contract on the blockchain. Compile a Solidity verifier
+  contract for your Noir program and deploy it on any EVM blockchain acting as a verifier smart
+  contract. Read more to find out
+keywords:
+  [
+    solidity verifier,
+    smart contract,
+    blockchain,
+    compiler,
+    plonk_vk.sol,
+    EVM blockchain,
+    verifying Noir programs,
+    proving backend,
+    Barretenberg,
+  ]
+sidebar_position: 0
+pagination_next: tutorials/noirjs_app
+---
+
+Noir has the ability to generate a verifier contract in Solidity, which can be deployed in many EVM-compatible blockchains such as Ethereum.
+
+This allows for a powerful feature set, as one can make use of the conciseness and the privacy provided by Noir in an immutable ledger. Applications can range from simple P2P guessing games, to complex private DeFi interactions.
+
+This guide shows you how to generate a Solidity Verifier and deploy it on the [Remix IDE](https://remix.ethereum.org/). It is assumed that:
+
+- You are comfortable with the Solidity programming language and understand how contracts are deployed on the Ethereum network
+- You have Noir installed and you have a Noir program. If you don't, [get started](../getting_started/quick_start.md) with Nargo and the example Hello Noir circuit
+- You are comfortable navigating RemixIDE. If you aren't or you need a refresher, you can find some video tutorials [here](https://www.youtube.com/channel/UCjTUPyFEr2xDGN6Cg8nKDaA) that could help you.
+
+## Rundown
+
+Generating a Solidity Verifier contract is actually a one-command process. However, compiling it and deploying it can have some caveats. Here's the rundown of this guide:
+
+1. How to generate a solidity smart contract
+2. How to compile the smart contract in the RemixIDE
+3. How to deploy it to a testnet
+
+## Step 1 - Generate a contract
+
+This is by far the most straightforward step. Just run:
+
+```sh
+nargo compile
+```
+
+This will compile your source code into a Noir build artifact to be stored in the `./target` directory, you can then generate the smart contract using the commands:
+
+```sh
+# Here we pass the path to the newly generated Noir artifact.
+bb write_vk -b ./target/<noir_artifact_name>.json
+bb contract
+```
+
+replacing `<noir_artifact_name>` with the name of your Noir project. A new `contract` folder would then be generated in your project directory, containing the Solidity
+file `contract.sol`. It can be deployed to any EVM blockchain acting as a verifier smart contract.
+
+You can find more information about `bb` and the default Noir proving backend on [this page](../getting_started/quick_start.md#proving-backend).
+
+:::info
+
+It is possible to generate verifier contracts of Noir programs for other smart contract platforms as long as the proving backend supplies an implementation.
+
+Barretenberg, the default proving backend for Nargo, supports generation of verifier contracts, for the time being these are only in Solidity.
+:::
+
+## Step 2 - Compiling
+
+We will mostly skip the details of RemixIDE, as the UI can change from version to version. For now, we can just open
+<a href="https://remix.ethereum.org" target="_blank">Remix</a> and create a blank workspace.
+
+![Create Workspace](@site/static/img/how-tos/solidity_verifier_1.png)
+
+We will create a new file to contain the contract Nargo generated, and copy-paste its content.
+
+:::warning
+
+You'll likely see a warning advising you to not trust pasted code. While it is an important warning, it is irrelevant in the context of this guide and can be ignored. We will not be deploying anywhere near a mainnet.
+
+:::
+
+To compile our the verifier, we can navigate to the compilation tab:
+
+![Compilation Tab](@site/static/img/how-tos/solidity_verifier_2.png)
+
+Remix should automatically match a suitable compiler version. However, hitting the "Compile" button will most likely generate a "Stack too deep" error:
+
+![Stack too deep](@site/static/img/how-tos/solidity_verifier_3.png)
+
+This is due to the verify function needing to put many variables on the stack, but enabling the optimizer resolves the issue. To do this, let's open the "Advanced Configurations" tab and enable optimization. The default 200 runs will suffice.
+
+:::info
+
+This time we will see a warning about an unused function parameter. This is expected, as the `verify` function doesn't use the `_proof` parameter inside a solidity block, it is loaded from calldata and used in assembly.
+
+:::
+
+![Compilation success](@site/static/img/how-tos/solidity_verifier_4.png)
+
+## Step 3 - Deploying
+
+At this point we should have a compiled contract ready to deploy. If we navigate to the deploy section in Remix, we will see many different environments we can deploy to. The steps to deploy on each environment would be out-of-scope for this guide, so we will just use the default Remix VM.
+
+Looking closely, we will notice that our "Solidity Verifier" is actually three contracts working together:
+
+- An `UltraVerificationKey` library which simply stores the verification key for our circuit.
+- An abstract contract `BaseUltraVerifier` containing most of the verifying logic.
+- A main `UltraVerifier` contract that inherits from the Base and uses the Key contract.
+
+Remix will take care of the dependencies for us so we can simply deploy the UltraVerifier contract by selecting it and hitting "deploy":
+
+![Deploying UltraVerifier](@site/static/img/how-tos/solidity_verifier_5.png)
+
+A contract will show up in the "Deployed Contracts" section, where we can retrieve the Verification Key Hash. This is particularly useful for double-checking that the deployer contract is the correct one.
+
+:::note
+
+Why "UltraVerifier"?
+
+To be precise, the Noir compiler (`nargo`) doesn't generate the verifier contract directly. It compiles the Noir code into an intermediate language (ACIR), which is then executed by the backend. So it is the backend that returns the verifier smart contract, not Noir.
+
+In this case, the Barretenberg Backend uses the UltraPlonk proving system, hence the "UltraVerifier" name.
+
+:::
+
+## Step 4 - Verifying
+
+To verify a proof using the Solidity verifier contract, we call the `verify` function in this extended contract:
+
+```solidity
+function verify(bytes calldata _proof, bytes32[] calldata _publicInputs) external view returns (bool)
+```
+
+When using the default example in the [Hello Noir](../getting_started/quick_start.md) guide, the easiest way to confirm that the verifier contract is doing its job is by calling the `verify` function via remix with the required parameters. Note that the public inputs must be passed in separately to the rest of the proof so we must split the proof as returned from `bb`.
+
+First generate a proof with `bb` at the location `./proof` using the steps in [get started](../getting_started/quick_start.md), this proof is in a binary format but we want to convert it into a hex string to pass into Remix, this can be done with the
+
+```bash
+# This value must be changed to match the number of public inputs (including return values!) in your program.
+NUM_PUBLIC_INPUTS=1
+PUBLIC_INPUT_BYTES=32*NUM_PUBLIC_INPUTS
+HEX_PUBLIC_INPUTS=$(head -c $PUBLIC_INPUT_BYTES ./proof | od -An -v -t x1 | tr -d $' \n')
+HEX_PROOF=$(tail -c +$(($PUBLIC_INPUT_BYTES + 1)) ./proof | od -An -v -t x1 | tr -d $' \n')
+
+echo "Public inputs:"
+echo $HEX_PUBLIC_INPUTS
+
+echo "Proof:"
+echo "0x$HEX_PROOF"
+```
+
+Remix expects that the public inputs will be split into an array of `bytes32` values so `HEX_PUBLIC_INPUTS` needs to be split up into 32 byte chunks which are prefixed with `0x` accordingly.
+
+A programmatic example of how the `verify` function is called can be seen in the example zk voting application [here](https://github.com/noir-lang/noir-examples/blob/33e598c257e2402ea3a6b68dd4c5ad492bce1b0a/foundry-voting/src/zkVote.sol#L35):
+
+```solidity
+function castVote(bytes calldata proof, uint proposalId, uint vote, bytes32 nullifierHash) public returns (bool) {
+  // ...
+  bytes32[] memory publicInputs = new bytes32[](4);
+  publicInputs[0] = merkleRoot;
+  publicInputs[1] = bytes32(proposalId);
+  publicInputs[2] = bytes32(vote);
+  publicInputs[3] = nullifierHash;
+  require(verifier.verify(proof, publicInputs), "Invalid proof");
+```
+
+:::info[Return Values]
+
+A circuit doesn't have the concept of a return value. Return values are just syntactic sugar in Noir.
+
+Under the hood, the return value is passed as an input to the circuit and is checked at the end of the circuit program.
+
+For example, if you have Noir program like this:
+
+```rust
+fn main(
+    // Public inputs
+    pubkey_x: pub Field,
+    pubkey_y: pub Field,
+    // Private inputs
+    priv_key: Field,
+) -> pub Field
+```
+
+the `verify` function will expect the public inputs array (second function parameter) to be of length 3, the two inputs and the return value.
+
+Passing only two inputs will result in an error such as `PUBLIC_INPUT_COUNT_INVALID(3, 2)`.
+
+In this case, the inputs parameter to `verify` would be an array ordered as `[pubkey_x, pubkey_y, return`.
+
+:::
+
+:::tip[Structs]
+
+You can pass structs to the verifier contract. They will be flattened so that the array of inputs is 1-dimensional array.
+
+For example, consider the following program:
+
+```rust
+struct Type1 {
+  val1: Field,
+  val2: Field,
+}
+
+struct Nested {
+  t1: Type1,
+  is_true: bool,
+}
+
+fn main(x: pub Field, nested: pub Nested, y: pub Field) {
+  //...
+}
+```
+
+The order of these inputs would be flattened to: `[x, nested.t1.val1, nested.t1.val2, nested.is_true, y]`
+
+:::
+
+The other function you can call is our entrypoint `verify` function, as defined above.
+
+:::tip
+
+It's worth noticing that the `verify` function is actually a `view` function. A `view` function does not alter the blockchain state, so it doesn't need to be distributed (i.e. it will run only on the executing node), and therefore doesn't cost any gas.
+
+This can be particularly useful in some situations. If Alice generated a proof and wants Bob to verify its correctness, Bob doesn't need to run Nargo, NoirJS, or any Noir specific infrastructure. He can simply make a call to the blockchain with the proof and verify it is correct without paying any gas.
+
+It would be incorrect to say that a Noir proof verification costs any gas at all. However, most of the time the result of `verify` is used to modify state (for example, to update a balance, a game state, etc). In that case the whole network needs to execute it, which does incur gas costs (calldata and execution, but not storage).
+
+:::
+
+## A Note on EVM chains
+
+Noir proof verification requires the ecMul, ecAdd and ecPairing precompiles. Not all EVM chains support EC Pairings, notably some of the ZK-EVMs. This means that you won't be able to use the verifier contract in all of them. You can find an incomplete list of which EVM chains support these precompiles [here](https://www.evmdiff.com/features?feature=precompiles).
+
+For example, chains like `zkSync ERA` and `Polygon zkEVM` do not currently support these precompiles, so proof verification via Solidity verifier contracts won't work. Here's a quick list of EVM chains that have been tested and are known to work:
+
+- Optimism
+- Arbitrum
+- Polygon PoS
+- Scroll
+- Celo
+- BSC
+- Blast L2
+- Avalanche C-Chain
+- Mode
+- Linea
+- Moonbeam
+
+If you test any other chains, please open a PR on this page to update the list. See [this doc](https://github.com/noir-lang/noir-starter/tree/main/with-foundry#testing-on-chain) for more info about testing verifier contracts on different EVM chains.
+
+## What's next
+
+Now that you know how to call a Noir Solidity Verifier on a smart contract using Remix, you should be comfortable with using it with some programmatic frameworks, such as [hardhat](https://github.com/noir-lang/noir-starter/tree/main/vite-hardhat) and [foundry](https://github.com/noir-lang/noir-starter/tree/main/with-foundry).
+
+You can find other tools, examples, boilerplates and libraries in the [awesome-noir](https://github.com/noir-lang/awesome-noir) repository.
+
+You should also be ready to write and deploy your first NoirJS app and start generating proofs on websites, phones, and NodeJS environments! Head on to the [NoirJS tutorial](../tutorials/noirjs_app.md) to learn how to do that.
diff --git a/docs/versioned_docs/version-v0.39.0/how_to/merkle-proof.mdx b/docs/versioned_docs/version-v0.39.0/how_to/merkle-proof.mdx
new file mode 100644
index 00000000000..0a128adb2de
--- /dev/null
+++ b/docs/versioned_docs/version-v0.39.0/how_to/merkle-proof.mdx
@@ -0,0 +1,48 @@
+---
+title: Prove Merkle Tree Membership
+description:
+  Learn how to use merkle membership proof in Noir to prove that a given leaf is a member of a
+  merkle tree with a specified root, at a given index.
+keywords:
+  [merkle proof, merkle membership proof, Noir, rust, hash function, Pedersen, sha256, merkle tree]
+sidebar_position: 4
+---
+
+Let's walk through an example of a merkle membership proof in Noir that proves that a given leaf is
+in a merkle tree.
+
+```rust
+
+fn main(message : [Field; 62], index : Field, hashpath : [Field; 40], root : Field) {
+    let leaf = std::hash::hash_to_field(message.as_slice());
+    let merkle_root = std::merkle::compute_merkle_root(leaf, index, hashpath);
+    assert(merkle_root == root);
+}
+
+```
+
+The message is hashed using `hash_to_field`. The specific hash function that is being used is chosen
+by the backend. The only requirement is that this hash function can heuristically be used as a
+random oracle. If only collision resistance is needed, then one can call `std::hash::pedersen_hash`
+instead.
+
+```rust
+let leaf = std::hash::hash_to_field(message.as_slice());
+```
+
+The leaf is then passed to a compute_merkle_root function with the root, index and hashpath. The returned root can then be asserted to be the same as the provided root.
+
+```rust
+let merkle_root = std::merkle::compute_merkle_root(leaf, index, hashpath);
+assert (merkle_root == root);
+```
+
+> **Note:** It is possible to re-implement the merkle tree implementation without standard library.
+> However, for most usecases, it is enough. In general, the standard library will always opt to be
+> as conservative as possible, while striking a balance with efficiency.
+
+An example, the merkle membership proof, only requires a hash function that has collision
+resistance, hence a hash function like Pedersen is allowed, which in most cases is more efficient
+than the even more conservative sha256.
+
+[View an example on the starter repo](https://github.com/noir-lang/noir-examples/blob/3ea09545cabfa464124ec2f3ea8e60c608abe6df/stealthdrop/circuits/src/main.nr#L20)
diff --git a/docs/versioned_docs/version-v0.39.0/how_to/using-devcontainers.mdx b/docs/versioned_docs/version-v0.39.0/how_to/using-devcontainers.mdx
new file mode 100644
index 00000000000..727ec6ca667
--- /dev/null
+++ b/docs/versioned_docs/version-v0.39.0/how_to/using-devcontainers.mdx
@@ -0,0 +1,110 @@
+---
+title: Developer Containers and Codespaces
+description: "Learn how to set up a devcontainer in your GitHub repository for a seamless coding experience with Codespaces. Follow our easy 8-step guide to create your own Noir environment without installing Nargo locally."
+keywords: ["Devcontainer", "Codespaces", "GitHub", "Noir Environment", "Docker Image", "Development Environment", "Remote Coding", "GitHub Codespaces", "Noir Programming", "Nargo", "VSCode Extensions", "Noirup"]
+sidebar_position: 1
+---
+
+Adding a developer container configuration file to your Noir project is one of the easiest way to unlock coding in browser.
+
+## What's a devcontainer after all?
+
+A [Developer Container](https://containers.dev/) (devcontainer for short) is a Docker image that comes preloaded with tools, extensions, and other tools you need to quickly get started or continue a project, without having to install Nargo locally. Think of it as a development environment in a box.
+
+There are many advantages to this:
+
+- It's platform and architecture agnostic
+- You don't need to have an IDE installed, or Nargo, or use a terminal at all
+- It's safer for using on a public machine or public network
+
+One of the best ways of using devcontainers is... not using your machine at all, for maximum control, performance, and ease of use.
+Enter Codespaces.
+
+## Codespaces
+
+If a devcontainer is just a Docker image, then what stops you from provisioning a `p3dn.24xlarge` AWS EC2 instance with 92 vCPUs and 768 GiB RAM and using it to prove your 10-gate SNARK proof? 
+
+Nothing! Except perhaps the 30-40$ per hour it will cost you. 
+
+The problem is that provisioning takes time, and I bet you don't want to see the AWS console every time you want to code something real quick.
+
+Fortunately, there's an easy and free way to get a decent remote machine ready and loaded in less than 2 minutes: Codespaces. [Codespaces is a Github feature](https://github.com/features/codespaces) that allows you to code in a remote machine by using devcontainers, and it's pretty cool:
+
+- You can start coding Noir in less than a minute
+- It uses the resources of a remote machine, so you can code on your grandma's phone if needed be
+- It makes it easy to share work with your frens
+- It's fully reusable, you can stop and restart whenever you need to
+
+:::info
+
+Don't take out your wallet just yet. Free GitHub accounts get about [15-60 hours of coding](https://github.com/features/codespaces) for free per month, depending on the size of your provisioned machine.
+
+:::
+
+## Tell me it's _actually_ easy
+
+It is!
+
+Github comes with a default codespace and you can use it to code your own devcontainer. That's exactly what we will be doing in this guide.
+
+<video width="100%" height="auto" controls>
+  <source src={require('@site/static/video/how-tos/devcontainer.mp4').default} type="video/mp4" />
+  Your browser does not support the video tag.
+</video>
+
+8 simple steps:
+
+#### 1. <a href="https://github.com/new" target="_blank">Create a new repository</a> on GitHub.
+
+#### 2. Click "Start coding with Codespaces". This will use the default image.
+
+#### 3. Create a folder called `.devcontainer` in the root of your repository.
+
+#### 4. Create a Dockerfile in that folder, and paste the following code:
+
+```docker
+FROM --platform=linux/amd64 node:lts-bookworm-slim
+SHELL ["/bin/bash", "-c"]
+RUN apt update && apt install -y curl bash git tar gzip libc++-dev
+RUN curl -L https://raw.githubusercontent.com/noir-lang/noirup/main/install | bash
+ENV PATH="/root/.nargo/bin:$PATH"
+RUN noirup
+ENTRYPOINT ["nargo"]
+```
+#### 5. Create a file called `devcontainer.json` in the same folder, and paste the following code:
+
+```json
+{
+ "name": "Noir on Codespaces",
+ "build": {
+    "context": ".",
+    "dockerfile": "Dockerfile"
+  },
+  "customizations": {
+    "vscode": {
+      "extensions": ["noir-lang.vscode-noir"]
+    }
+  }
+}
+```
+#### 6. Commit and push your changes
+
+This will pull the new image and build it, so it could take a minute or so
+
+#### 8. Done! 
+Just wait for the build to finish, and there's your easy Noir environment.
+
+
+Refer to [noir-starter](https://github.com/noir-lang/noir-starter/) as an example of how devcontainers can be used together with codespaces.
+
+
+
+## How do I use it?
+
+Using the codespace is obviously much easier than setting it up. 
+Just navigate to your repository and click "Code" -> "Open with Codespaces". It should take a few seconds to load, and you're ready to go.
+
+:::info
+
+If you really like the experience, you can add a badge to your readme, links to existing codespaces, and more. 
+Check out the [official docs](https://docs.github.com/en/codespaces/setting-up-your-project-for-codespaces/setting-up-your-repository/facilitating-quick-creation-and-resumption-of-codespaces) for more info.
diff --git a/docs/versioned_docs/version-v0.39.0/index.mdx b/docs/versioned_docs/version-v0.39.0/index.mdx
new file mode 100644
index 00000000000..5c116a73b3f
--- /dev/null
+++ b/docs/versioned_docs/version-v0.39.0/index.mdx
@@ -0,0 +1,76 @@
+---
+title: Noir Lang
+hide_title: true
+description:
+  Learn about the public alpha release of Noir, a domain specific language heavily influenced by Rust that compiles to
+  an intermediate language which can be compiled to an arithmetic circuit or a rank-1 constraint system.
+keywords:
+    [Noir,
+    Domain Specific Language,
+    Rust,
+    Intermediate Language,
+    Arithmetic Circuit,
+    Rank-1 Constraint System,
+    Ethereum Developers,
+    Protocol Developers,
+    Blockchain Developers,
+    Proving System,
+    Smart Contract Language]
+sidebar_position: 0
+---
+
+import Tabs from '@theme/Tabs';
+import TabItem from '@theme/TabItem';
+import ThemedImage from '@theme/ThemedImage';
+import useBaseUrl from '@docusaurus/useBaseUrl';
+
+<ThemedImage
+  sources={{
+    light: useBaseUrl("/img/logoDark.png"),
+    dark: useBaseUrl("/img/logo.png"),
+  }}
+  style={{display: "block", width: "50%", margin: "2rem auto"}} 
+  alt="Noir Logo" 
+/>
+
+Noir is an open-source Domain-Specific Language for safe and seamless construction of privacy-preserving Zero-Knowledge programs, requiring no previous knowledge on the underlying mathematics or cryptography.
+
+ZK programs are programs that can generate short proofs of statements without revealing all inputs to the statements. You can read more about Zero-Knowledge Proofs [here](https://dev.to/spalladino/a-beginners-intro-to-coding-zero-knowledge-proofs-c56).
+
+## What's new about Noir?
+
+Noir works differently from most ZK languages by taking a two-pronged path. First, it compiles the program to an adaptable intermediate language known as ACIR. From there, depending on a given project's needs, ACIR can be further compiled into an arithmetic circuit for integration with the proving backend.
+
+:::info
+
+Noir is backend agnostic, which means it makes no assumptions on which proving backend powers the ZK proof. Being the language that powers [Aztec Contracts](https://docs.aztec.network/developers/contracts/main), it defaults to Aztec's Barretenberg proving backend.
+
+However, the ACIR output can be transformed to be compatible with other PLONK-based backends, or into a [rank-1 constraint system](https://www.rareskills.io/post/rank-1-constraint-system) suitable for backends such as Arkwork's Marlin.
+
+:::
+
+## Who is Noir for?
+
+Noir can be used both in complex cloud-based backends and in user's smartphones, requiring no knowledge on the underlying math or cryptography. From authorization systems that keep a password in the user's device, to complex on-chain verification of recursive proofs, Noir is designed to abstract away complexity without any significant overhead. Here are some examples of situations where Noir can be used:
+
+<Tabs>
+  <TabItem value="Aztec Contracts" label="Aztec Contracts" default>
+    <img src={require("@site/static/img/aztec_logo.png").default} style={{display: "block", width: "50%", margin: "2rem auto"}} alt="Noir Logo"  />
+    
+    Aztec Contracts leverage Noir to allow for the storage and execution of private information. Writing an Aztec Contract is as easy as writing Noir, and Aztec developers can easily interact with the network storage and execution through the [Aztec.nr](https://docs.aztec.network/developers/contracts/main) library.
+  </TabItem>
+  <TabItem value="Solidity Verifiers" label="Solidity Verifiers">
+    <img src={require("@site/static/img/solidity_verifier_ex.png").default} style={{display: "block", margin: "2rem auto"}} alt="Soliditry Verifier Example"  />
+    Noir can auto-generate Solidity verifier contracts that verify Noir proofs. This allows for non-interactive verification of proofs containing private information in an immutable system. This feature powers a multitude of use-case scenarios, from P2P chess tournaments, to [Aztec Layer-2 Blockchain](https://docs.aztec.network/)
+  </TabItem>
+  <TabItem value="Full-Stack Development" label="Full-Stack Development">
+    Aztec Labs developed NoirJS, an easy interface to generate and verify Noir proofs in a Javascript environment. This allows for Noir to be used in webpages, mobile apps, games, and any other environment supporting JS execution in a standalone manner.
+  </TabItem>
+</Tabs>
+
+
+## Libraries
+
+Noir is meant to be easy to extend by simply importing Noir libraries just like in Rust. 
+The [awesome-noir repo](https://github.com/noir-lang/awesome-noir#libraries) is a collection of libraries developed by the Noir community.
+Writing a new library is easy and makes code be composable and easy to reuse. See the section on [dependencies](noir/modules_packages_crates/dependencies.md) for more information.
diff --git a/docs/versioned_docs/version-v0.39.0/migration_notes.md b/docs/versioned_docs/version-v0.39.0/migration_notes.md
new file mode 100644
index 00000000000..6bd740024e5
--- /dev/null
+++ b/docs/versioned_docs/version-v0.39.0/migration_notes.md
@@ -0,0 +1,105 @@
+---
+title: Migration notes
+description: Read about migration notes from previous versions, which could solve problems while updating
+keywords: [Noir, notes, migration, updating, upgrading]
+---
+
+Noir is in full-speed development. Things break fast, wild, and often. This page attempts to leave some notes on errors you might encounter when upgrading and how to resolve them until proper patches are built.
+
+### `backend encountered an error: libc++.so.1`
+
+Depending on your OS, you may encounter the following error when running `nargo prove` for the first time:
+
+```text
+The backend encountered an error: "/home/codespace/.nargo/backends/acvm-backend-barretenberg/backend_binary: error while loading shared libraries: libc++.so.1: cannot open shared object file: No such file or directory\n"
+```
+
+Install the `libc++-dev` library with:
+
+```bash
+sudo apt install libc++-dev
+```
+
+## ≥0.19
+
+### Enforcing `compiler_version`
+
+From this version on, the compiler will check for the `compiler_version` field in `Nargo.toml`, and will error if it doesn't match the current Nargo version in use.
+
+To update, please make sure this field in `Nargo.toml` matches the output of `nargo --version`.
+
+## ≥0.14
+
+The index of the [for loops](noir/concepts/control_flow.md#loops) is now of type `u64` instead of `Field`. An example refactor would be:
+
+```rust
+for i in 0..10 {
+    let i = i as Field;
+}
+```
+
+## ≥v0.11.0 and Nargo backend
+
+From this version onwards, Nargo starts managing backends through the `nargo backend` command. Upgrading to the versions per usual steps might lead to:
+
+### `backend encountered an error`
+
+This is likely due to the existing locally installed version of proving backend (e.g. barretenberg) is incompatible with the version of Nargo in use.
+
+To fix the issue:
+
+1. Uninstall the existing backend
+
+```bash
+nargo backend uninstall acvm-backend-barretenberg
+```
+
+You may replace _acvm-backend-barretenberg_ with the name of your backend listed in `nargo backend ls` or in ~/.nargo/backends.
+
+2. Reinstall a compatible version of the proving backend.
+
+If you are using the default barretenberg backend, simply run:
+
+```
+nargo prove
+```
+
+with your Noir program.
+
+This will trigger the download and installation of the latest version of barretenberg compatible with your Nargo in use.
+
+### `backend encountered an error: illegal instruction`
+
+On certain Intel-based systems, an `illegal instruction` error may arise due to incompatibility of barretenberg with certain CPU instructions.
+
+To fix the issue:
+
+1. Uninstall the existing backend
+
+```bash
+nargo backend uninstall acvm-backend-barretenberg
+```
+
+You may replace _acvm-backend-barretenberg_ with the name of your backend listed in `nargo backend ls` or in ~/.nargo/backends.
+
+2. Reinstall a compatible version of the proving backend.
+
+If you are using the default barretenberg backend, simply run:
+
+```
+nargo backend install acvm-backend-barretenberg https://github.com/noir-lang/barretenberg-js-binary/raw/master/run-bb.tar.gz
+```
+
+This downloads and installs a specific bb.js based version of barretenberg binary from GitHub.
+
+The gzipped file is running [this bash script](https://github.com/noir-lang/barretenberg-js-binary/blob/master/run-bb-js.sh), where we need to gzip it as the Nargo currently expect the backend to be zipped up.
+
+Then run:
+
+```
+DESIRED_BINARY_VERSION=0.8.1 nargo info
+```
+
+This overrides the bb native binary with a bb.js node application instead, which should be compatible with most if not all hardware. This does come with the drawback of being generally slower than native binary.
+
+0.8.1 indicates bb.js version 0.8.1, so if you change that it will update to a different version or the default version in the script if none was supplied.
diff --git a/docs/versioned_docs/version-v0.39.0/noir/concepts/_category_.json b/docs/versioned_docs/version-v0.39.0/noir/concepts/_category_.json
new file mode 100644
index 00000000000..7da08f8a8c5
--- /dev/null
+++ b/docs/versioned_docs/version-v0.39.0/noir/concepts/_category_.json
@@ -0,0 +1,6 @@
+{
+    "label": "Concepts",
+    "position": 0,
+    "collapsible": true,
+    "collapsed": true
+}
\ No newline at end of file
diff --git a/docs/versioned_docs/version-v0.39.0/noir/concepts/assert.md b/docs/versioned_docs/version-v0.39.0/noir/concepts/assert.md
new file mode 100644
index 00000000000..2132de42072
--- /dev/null
+++ b/docs/versioned_docs/version-v0.39.0/noir/concepts/assert.md
@@ -0,0 +1,78 @@
+---
+title: Assert Function
+description:
+  Learn about the `assert` and `static_assert` functions in Noir, which can be used to explicitly
+  constrain the predicate or comparison expression that follows to be true, and what happens if
+  the expression is false at runtime or compile-time, respectively.
+keywords: [Noir programming language, assert statement, predicate expression, comparison expression]
+sidebar_position: 4
+---
+
+Noir includes a special `assert` function which will explicitly constrain the predicate/comparison
+expression that follows to be true. If this expression is false at runtime, the program will fail to
+be proven. Example:
+
+```rust
+fn main(x : Field, y : Field) {
+    assert(x == y);
+}
+```
+
+> Assertions only work for predicate operations, such as `==`. If there's any ambiguity on the operation, the program will fail to compile. For example, it is unclear if `assert(x + y)` would check for `x + y == 0` or simply would return `true`.
+
+You can optionally provide a message to be logged when the assertion fails:
+
+```rust
+assert(x == y, "x and y are not equal");
+```
+
+Aside string literals, the optional message can be a format string or any other type supported as input for Noir's [print](../standard_library/logging.md) functions. This feature lets you incorporate runtime variables into your failed assertion logs:
+
+```rust
+assert(x == y, f"Expected x == y, but got {x} == {y}");
+```
+
+Using a variable as an assertion message directly:
+
+```rust
+struct myStruct {
+  myField: Field
+}
+
+let s = myStruct { myField: y };
+assert(s.myField == x, s);
+```
+
+There is also a special `static_assert` function that behaves like `assert`,
+but that runs at compile-time.
+
+```rust
+fn main(xs: [Field; 3]) {
+    let x = 2 + 2;
+    let y = 4;
+    static_assert(x == y, "expected 2 + 2 to equal 4");
+
+    // This passes since the length of `xs` is known at compile-time
+    static_assert(xs.len() == 3, "expected the input to have 3 elements");
+}
+```
+
+This function fails when passed a dynamic (run-time) argument:
+
+```rust
+fn main(x : Field, y : Field) {
+    // this fails because `x` is not known at compile-time
+    static_assert(x == 2, "expected x to be known at compile-time and equal to 2");
+
+    let mut example_slice = &[];
+    if y == 4 {
+        example_slice = example_slice.push_back(0);
+    }
+
+    // This fails because the length of `example_slice` is not known at
+    // compile-time
+    let error_message = "expected an empty slice, known at compile-time";
+    static_assert(example_slice.len() == 0, error_message);
+}
+```
+
diff --git a/docs/versioned_docs/version-v0.39.0/noir/concepts/comments.md b/docs/versioned_docs/version-v0.39.0/noir/concepts/comments.md
new file mode 100644
index 00000000000..b51a85f5c94
--- /dev/null
+++ b/docs/versioned_docs/version-v0.39.0/noir/concepts/comments.md
@@ -0,0 +1,33 @@
+---
+title: Comments
+description:
+  Learn how to write comments in Noir programming language. A comment is a line of code that is
+  ignored by the compiler, but it can be read by programmers. Single-line and multi-line comments
+  are supported in Noir.
+keywords: [Noir programming language, comments, single-line comments, multi-line comments]
+sidebar_position: 10
+---
+
+A comment is a line in your codebase which the compiler ignores, however it can be read by
+programmers.
+
+Here is a single line comment:
+
+```rust
+// This is a comment and is ignored
+```
+
+`//` is used to tell the compiler to ignore the rest of the line.
+
+Noir also supports multi-line block comments. Start a block comment with `/*` and end the block with `*/`.
+
+Noir does not natively support doc comments. You may be able to use [Rust doc comments](https://doc.rust-lang.org/reference/comments.html) in your code to leverage some Rust documentation build tools with Noir code.
+
+```rust
+/*
+  This is a block comment describing a complex function.
+*/
+fn main(x : Field, y : pub Field) {
+    assert(x != y);
+}
+```
diff --git a/docs/versioned_docs/version-v0.39.0/noir/concepts/comptime.md b/docs/versioned_docs/version-v0.39.0/noir/concepts/comptime.md
new file mode 100644
index 00000000000..2ceb030c7e1
--- /dev/null
+++ b/docs/versioned_docs/version-v0.39.0/noir/concepts/comptime.md
@@ -0,0 +1,445 @@
+---
+title: Compile-time Code & Metaprogramming
+description: Learn how to use metaprogramming in Noir to create macros or derive your own traits
+keywords: [Noir, comptime, compile-time, metaprogramming, macros, quote, unquote]
+sidebar_position: 15
+---
+
+## Overview
+
+Metaprogramming in Noir is comprised of three parts:
+1. `comptime` code
+2. Quoting and unquoting
+3. The metaprogramming API in `std::meta`
+
+Each of these are explained in more detail in the next sections but the wide picture is that
+`comptime` allows us to write code which runs at compile-time. In this `comptime` code we
+can quote and unquote snippets of the program, manipulate them, and insert them in other
+parts of the program. Comptime functions which do this are said to be macros. Additionally,
+there's a compile-time API of built-in types and functions provided by the compiler which allows
+for greater analysis and modification of programs.
+
+---
+
+## Comptime
+
+`comptime` is a new keyword in Noir which marks an item as executing or existing at compile-time. It can be used in several ways:
+
+- `comptime fn` to define functions which execute exclusively during compile-time.
+- `comptime global` to define a global variable which is evaluated at compile-time.
+  - Unlike runtime globals, `comptime global`s can be mutable.
+- `comptime { ... }` to execute a block of statements during compile-time.
+- `comptime let` to define a variable whose value is evaluated at compile-time.
+- `comptime for` to run a for loop at compile-time. Syntax sugar for `comptime { for .. }`.
+
+### Scoping
+
+Note that while in a `comptime` context, any runtime variables _local to the current function_ are never visible.
+
+### Evaluating
+
+Evaluation rules of `comptime` follows the normal unconstrained evaluation rules for other Noir code. There are a few things to note though:
+
+- Certain built-in functions may not be available, although more may be added over time.
+- Evaluation order of global items is currently unspecified. For example, given the following two functions we can't guarantee
+which `println` will execute first. The ordering of the two printouts will be arbitrary, but should be stable across multiple compilations with the same `nargo` version as long as the program is also unchanged.
+
+```rust
+fn one() {
+    comptime { println("one"); }
+}
+
+fn two() {
+    comptime { println("two"); }
+}
+```
+
+- Since evaluation order is unspecified, care should be taken when using mutable globals so that they do not rely on a particular ordering.
+For example, using globals to generate unique ids should be fine but relying on certain ids always being produced (especially after edits to the program) should be avoided.
+- Although most ordering of globals is unspecified, two are:
+  - Dependencies of a crate will always be evaluated before the dependent crate.
+  - Any annotations on a function will be run before the function itself is resolved. This is to allow the annotation to modify the function if necessary. Note that if the
+    function itself was called at compile-time previously, it will already be resolved and cannot be modified. To prevent accidentally calling functions you wish to modify
+    at compile-time, it may be helpful to sort your `comptime` annotation functions into a different crate along with any dependencies they require.
+
+### Lowering
+
+When a `comptime` value is used in runtime code it must be lowered into a runtime value. This means replacing the expression with the literal that it evaluated to. For example, the code:
+
+```rust
+struct Foo { array: [Field; 2], len: u32 }
+
+fn main() {
+    println(comptime {
+        let mut foo = std::mem::zeroed::<Foo>();
+        foo.array[0] = 4;
+        foo.len = 1;
+        foo
+    });
+}
+```
+
+will be converted to the following after `comptime` expressions are evaluated:
+
+```rust
+struct Foo { array: [Field; 2], len: u32 }
+
+fn main() {
+    println(Foo { array: [4, 0], len: 1 });
+}
+```
+
+Not all types of values can be lowered. For example, `Type`s and `TypeDefinition`s (among other types) cannot be lowered at all.
+
+```rust
+fn main() {
+    // There's nothing we could inline here to create a Type value at runtime
+    // let _ = get_type!();
+}
+
+comptime fn get_type() -> Type { ... }
+```
+
+---
+
+## (Quasi) Quote
+
+Macros in Noir are `comptime` functions which return code as a value which is inserted into the call site when it is lowered there.
+A code value in this case is of type `Quoted` and can be created by a `quote { ... }` expression.
+More specifically, the code value `quote` creates is a token stream - a representation of source code as a series of words, numbers, string literals, or operators.
+For example, the expression `quote { Hi "there reader"! }` would quote three tokens: the word "hi", the string "there reader", and an exclamation mark.
+You'll note that snippets that would otherwise be invalid syntax can still be quoted.
+
+When a `Quoted` value is used in runtime code, it is lowered into a `quote { ... }` expression. Since this expression is only valid
+in compile-time code however, we'd get an error if we tried this. Instead, we can use macro insertion to insert each token into the
+program at that point, and parse it as an expression. To do this, we have to add a `!` after the function name returning the `Quoted` value.
+If the value was created locally and there is no function returning it, `std::meta::unquote!(_)` can be used instead.
+Calling such a function at compile-time without `!` will just return the `Quoted` value to be further manipulated. For example:
+
+```rust title="quote-example" showLineNumbers 
+comptime fn quote_one() -> Quoted {
+        quote { 1 }
+    }
+
+    #[test]
+    fn returning_versus_macro_insertion() {
+        comptime {
+            // let _a: Quoted = quote { 1 };
+            let _a: Quoted = quote_one();
+
+            // let _b: Field = 1;
+            let _b: Field = quote_one!();
+
+            // Since integers default to fields, if we
+            // want a different type we have to explicitly cast
+            // let _c: i32 = 1 as i32;
+            let _c: i32 = quote_one!() as i32;
+        }
+    }
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/meta/mod.nr#L120-L140" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/meta/mod.nr#L120-L140</a></sub></sup>
+
+
+For those familiar with quoting from other languages (primarily lisps), Noir's `quote` is actually a _quasiquote_.
+This means we can escape the quoting by using the unquote operator to splice values in the middle of quoted code.
+
+## Unquote
+
+The unquote operator `$` is usable within a `quote` expression.
+It takes a variable as an argument, evaluates the variable, and splices the resulting value into the quoted token stream at that point. For example,
+
+```rust
+comptime {
+    let x = 1 + 2;
+    let y = quote { $x + 4 };
+}
+```
+
+The value of `y` above will be the token stream containing `3`, `+`, and `4`. We can also use this to combine `Quoted` values into larger token streams:
+
+```rust
+comptime {
+    let x = quote { 1 + 2 };
+    let y = quote { $x + 4 };
+}
+```
+
+The value of `y` above is now the token stream containing five tokens: `1 + 2 + 4`.
+
+Note that to unquote something, a variable name _must_ follow the `$` operator in a token stream.
+If it is an expression (even a parenthesized one), it will do nothing. Most likely a parse error will be given when the macro is later unquoted.
+
+Unquoting can also be avoided by escaping the `$` with a backslash:
+
+```
+comptime {
+    let x = quote { 1 + 2 };
+
+    // y contains the four tokens: `$x + 4`
+    let y = quote { \$x + 4 };
+}
+```
+
+---
+
+## Annotations
+
+Annotations provide a way to run a `comptime` function on an item in the program.
+When you use an annotation, the function with the same name will be called with that item as an argument:
+
+```rust
+#[my_struct_annotation]
+struct Foo {}
+
+comptime fn my_struct_annotation(s: StructDefinition) {
+    println("Called my_struct_annotation!");
+}
+
+#[my_function_annotation]
+fn foo() {}
+
+comptime fn my_function_annotation(f: FunctionDefinition) {
+    println("Called my_function_annotation!");
+}
+```
+
+Anything returned from one of these functions will be inserted at top-level along with the original item.
+Note that expressions are not valid at top-level so you'll get an error trying to return `3` or similar just as if you tried to write a program containing `3; struct Foo {}`.
+You can insert other top-level items such as trait impls, structs, or functions this way though.
+For example, this is the mechanism used to insert additional trait implementations into the program when deriving a trait impl from a struct:
+
+```rust title="derive-field-count-example" showLineNumbers 
+trait FieldCount {
+        fn field_count() -> u32;
+    }
+
+    #[derive_field_count]
+    struct Bar {
+        x: Field,
+        y: [Field; 2],
+    }
+
+    comptime fn derive_field_count(s: StructDefinition) -> Quoted {
+        let typ = s.as_type();
+        let field_count = s.fields().len();
+        quote {
+            impl FieldCount for $typ {
+                fn field_count() -> u32 {
+                    $field_count
+                }
+            }
+        }
+    }
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/meta/mod.nr#L142-L164" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/meta/mod.nr#L142-L164</a></sub></sup>
+
+
+### Calling annotations with additional arguments
+
+Arguments may optionally be given to annotations.
+When this is done, these additional arguments are passed to the annotation function after the item argument.
+
+```rust title="annotation-arguments-example" showLineNumbers 
+#[assert_field_is_type(quote { i32 }.as_type())]
+    struct MyStruct {
+        my_field: i32,
+    }
+
+    comptime fn assert_field_is_type(s: StructDefinition, typ: Type) {
+        // Assert the first field in `s` has type `typ`
+        let fields = s.fields();
+        assert_eq(fields[0].1, typ);
+    }
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/meta/mod.nr#L166-L177" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/meta/mod.nr#L166-L177</a></sub></sup>
+
+
+We can also take any number of arguments by adding the `varargs` annotation:
+
+```rust title="annotation-varargs-example" showLineNumbers 
+#[assert_three_args(1, 2, 3)]
+    struct MyOtherStruct {
+        my_other_field: u32,
+    }
+
+    #[varargs]
+    comptime fn assert_three_args(_s: StructDefinition, args: [Field]) {
+        assert_eq(args.len(), 3);
+    }
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/meta/mod.nr#L179-L189" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/meta/mod.nr#L179-L189</a></sub></sup>
+
+
+---
+
+## Comptime API
+
+Although `comptime`, `quote`, and unquoting provide a flexible base for writing macros,
+Noir's true metaprogramming ability comes from being able to interact with the compiler through a compile-time API.
+This API can be accessed through built-in functions in `std::meta` as well as on methods of several `comptime` types.
+
+The following is an incomplete list of some `comptime` types along with some useful methods on them. You can see more in the standard library [Metaprogramming section](../standard_library/meta).
+
+- `Quoted`: A token stream
+- `Type`: The type of a Noir type
+  - `fn implements(self, constraint: TraitConstraint) -> bool`
+    - Returns true if `self` implements the given trait constraint
+- `Expr`: A syntactically valid expression. Can be used to recur on a program's parse tree to inspect how it is structured.
+  - Methods:
+    - `fn as_function_call(self) -> Option<(Expr, [Expr])>`
+      - If this is a function call expression, return `(function, arguments)`
+    - `fn as_block(self) -> Option<[Expr]>`
+      - If this is a block, return each statement in the block
+- `FunctionDefinition`: A function definition
+  - Methods:
+    - `fn parameters(self) -> [(Quoted, Type)]`
+      - Returns a slice of `(name, type)` pairs for each parameter
+- `StructDefinition`: A struct definition
+  - Methods:
+    - `fn as_type(self) -> Type`
+      - Returns this `StructDefinition` as a `Type`. Any generics are kept as-is
+    - `fn generics(self) -> [Quoted]`
+      - Return the name of each generic on this struct
+    - `fn fields(self) -> [(Quoted, Type)]`
+      - Return the name and type of each field
+- `TraitConstraint`: A trait constraint such as `From<Field>`
+- `TypedExpr`: A type-checked expression.
+- `UnresolvedType`: A syntactic notation that refers to a Noir type that hasn't been resolved yet
+
+There are many more functions available by exploring the `std::meta` module and its submodules.
+Using these methods is the key to writing powerful metaprogramming libraries.
+
+### `#[use_callers_scope]`
+
+Since certain functions such as `Quoted::as_type`, `Expression::as_type`, or `Quoted::as_trait_constraint` will attempt
+to resolve their contents in a particular scope - it can be useful to change the scope they resolve in. By default
+these functions will resolve in the current function's scope which is usually the attribute function they are called in.
+If you're working on a library however, this may be a completely different module or crate to the item you're trying to
+use the attribute on. If you want to be able to use `Quoted::as_type` to refer to types local to the caller's scope for
+example, you can annotate your attribute function with `#[use_callers_scope]`. This will ensure your attribute, and any
+closures it uses, can refer to anything in the caller's scope. `#[use_callers_scope]` also works recursively. So if both
+your attribute function and a helper function it calls use it, then they can both refer to the same original caller.
+
+---
+
+## Example: Derive
+
+Using all of the above, we can write a `derive` macro that behaves similarly to Rust's but is not built into the language.
+From the user's perspective it will look like this:
+
+```rust
+// Example usage
+#[derive(Default, Eq, Ord)]
+struct MyStruct { my_field: u32 }
+```
+
+To implement `derive` we'll have to create a `comptime` function that accepts
+a variable amount of traits.
+
+```rust title="derive_example" showLineNumbers 
+// These are needed for the unconstrained hashmap we're using to store derive functions
+use crate::collections::umap::UHashMap;
+use crate::hash::BuildHasherDefault;
+use crate::hash::poseidon2::Poseidon2Hasher;
+
+// A derive function is one that given a struct definition can
+// create us a quoted trait impl from it.
+pub type DeriveFunction = fn(StructDefinition) -> Quoted;
+
+// We'll keep a global HANDLERS map to keep track of the derive handler for each trait
+comptime mut global HANDLERS: UHashMap<TraitDefinition, DeriveFunction, BuildHasherDefault<Poseidon2Hasher>> =
+    UHashMap::default();
+
+// Given a struct and a slice of traits to derive, create trait impls for each.
+// This function is as simple as iterating over the slice, checking if we have a trait
+// handler registered for the given trait, calling it, and appending the result.
+#[varargs]
+pub comptime fn derive(s: StructDefinition, traits: [TraitDefinition]) -> Quoted {
+    let mut result = quote {};
+
+    for trait_to_derive in traits {
+        let handler = unsafe { HANDLERS.get(trait_to_derive) };
+        assert(handler.is_some(), f"No derive function registered for `{trait_to_derive}`");
+
+        let trait_impl = handler.unwrap()(s);
+        result = quote { $result $trait_impl };
+    }
+
+    result
+}
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/meta/mod.nr#L31-L64" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/meta/mod.nr#L31-L64</a></sub></sup>
+
+
+Registering a derive function could be done as follows:
+
+```rust title="derive_via" showLineNumbers 
+// To register a handler for a trait, just add it to our handlers map
+pub comptime fn derive_via(t: TraitDefinition, f: DeriveFunction) {
+    HANDLERS.insert(t, f);
+}
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/meta/mod.nr#L66-L73" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/meta/mod.nr#L66-L73</a></sub></sup>
+
+
+```rust title="big-derive-usage-example" showLineNumbers 
+// Finally, to register a handler we call the above function as an annotation
+    // with our handler function.
+    #[derive_via(derive_do_nothing)]
+    trait DoNothing {
+        fn do_nothing(self);
+    }
+
+    comptime fn derive_do_nothing(s: StructDefinition) -> Quoted {
+        // This is simplified since we don't handle generics or where clauses!
+        // In a real example we'd likely also need to introduce each of
+        // `s.generics()` as well as a trait constraint for each generic
+        // to ensure they also implement the trait.
+        let typ = s.as_type();
+        quote {
+            impl DoNothing for $typ {
+                fn do_nothing(self) {
+                    // Traits can't tell us what to do
+                    println("something");
+                }
+            }
+        }
+    }
+
+    // Since `DoNothing` is a simple trait which:
+    // 1. Only has one method
+    // 2. Does not have any generics on the trait itself
+    // We can use `std::meta::make_trait_impl` to help us out.
+    // This helper function will generate our impl for us along with any
+    // necessary where clauses and still provides a flexible interface
+    // for us to work on each field on the struct.
+    comptime fn derive_do_nothing_alt(s: StructDefinition) -> Quoted {
+        let trait_name = quote { DoNothing };
+        let method_signature = quote { fn do_nothing(self) };
+
+        // Call `do_nothing` recursively on each field in the struct
+        let for_each_field = |field_name| quote { self.$field_name.do_nothing(); };
+
+        // Some traits like Eq want to join each field expression with something like `&`.
+        // We don't need that here
+        let join_fields_with = quote {};
+
+        // The body function is a spot to insert any extra setup/teardown needed.
+        // We'll insert our println here. Since we recur on each field, we should see
+        // one println for the struct itself, followed by a println for every field (recursively).
+        let body = |body| quote {
+            println("something");
+            $body
+        };
+        crate::meta::make_trait_impl(
+            s,
+            trait_name,
+            method_signature,
+            for_each_field,
+            join_fields_with,
+            body,
+        )
+    }
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/meta/mod.nr#L191-L249" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/meta/mod.nr#L191-L249</a></sub></sup>
+
diff --git a/docs/versioned_docs/version-v0.39.0/noir/concepts/control_flow.md b/docs/versioned_docs/version-v0.39.0/noir/concepts/control_flow.md
new file mode 100644
index 00000000000..b365bb22728
--- /dev/null
+++ b/docs/versioned_docs/version-v0.39.0/noir/concepts/control_flow.md
@@ -0,0 +1,79 @@
+---
+title: Control Flow
+description:
+  Learn how to use loops and if expressions in the Noir programming language. Discover the syntax
+  and examples for for loops and if-else statements.
+keywords: [Noir programming language, loops, for loop, if-else statements, Rust syntax]
+sidebar_position: 2
+---
+
+## If Expressions
+
+Noir supports `if-else` statements. The syntax is most similar to Rust's where it is not required
+for the statement's conditional to be surrounded by parentheses.
+
+```rust
+let a = 0;
+let mut x: u32 = 0;
+
+if a == 0 {
+    if a != 0 {
+        x = 6;
+    } else {
+        x = 2;
+    }
+} else {
+    x = 5;
+    assert(x == 5);
+}
+assert(x == 2);
+```
+
+## Loops
+
+Noir has one kind of loop: the `for` loop. `for` loops allow you to repeat a block of code multiple
+times.
+
+The following block of code between the braces is run 10 times.
+
+```rust
+for i in 0..10 {
+    // do something
+}
+```
+
+Alternatively, `start..=end` can be used for a range that is inclusive on both ends.
+
+The index for loops is of type `u64`.
+
+### Break and Continue
+
+In unconstrained code, `break` and `continue` are also allowed in `for` loops. These are only allowed
+in unconstrained code since normal constrained code requires that Noir knows exactly how many iterations
+a loop may have. `break` and `continue` can be used like so:
+
+```rust
+for i in 0 .. 10 {
+    println("Iteration start")
+
+    if i == 2 {
+        continue;
+    }
+
+    if i == 5 {
+        break;
+    }
+
+    println(i);
+}
+println("Loop end")
+```
+
+When used, `break` will end the current loop early and jump to the statement after the for loop. In the example
+above, the `break` will stop the loop and jump to the `println("Loop end")`.
+
+`continue` will stop the current iteration of the loop, and jump to the start of the next iteration. In the example
+above, `continue` will jump to `println("Iteration start")` when used. Note that the loop continues as normal after this.
+The iteration variable `i` is still increased by one as normal when `continue` is used.
+
+`break` and `continue` cannot currently be used to jump out of more than a single loop at a time.
diff --git a/docs/versioned_docs/version-v0.39.0/noir/concepts/data_bus.mdx b/docs/versioned_docs/version-v0.39.0/noir/concepts/data_bus.mdx
new file mode 100644
index 00000000000..e55e58622ce
--- /dev/null
+++ b/docs/versioned_docs/version-v0.39.0/noir/concepts/data_bus.mdx
@@ -0,0 +1,23 @@
+---
+title: Data Bus
+sidebar_position: 13
+---
+import Experimental from '@site/src/components/Notes/_experimental.mdx';
+
+<Experimental />
+
+The data bus is an optimization that the backend can use to make recursion more efficient.
+In order to use it, you must define some inputs of the program entry points (usually the `main()`
+function) with the `call_data` modifier, and the return values with the `return_data` modifier.
+These modifiers are incompatible with `pub` and `mut` modifiers.
+
+## Example
+
+```rust
+fn main(mut x: u32, y: call_data u32, z: call_data [u32;4] ) -> return_data u32 {
+  let a = z[x];
+  a+y
+}
+```
+
+As a result, both call_data and return_data will be treated as private inputs and encapsulated into a read-only array each, for the backend to process.
diff --git a/docs/versioned_docs/version-v0.39.0/noir/concepts/data_types/_category_.json b/docs/versioned_docs/version-v0.39.0/noir/concepts/data_types/_category_.json
new file mode 100644
index 00000000000..5d694210bbf
--- /dev/null
+++ b/docs/versioned_docs/version-v0.39.0/noir/concepts/data_types/_category_.json
@@ -0,0 +1,5 @@
+{
+    "position": 0,
+    "collapsible": true,
+    "collapsed": true
+}
diff --git a/docs/versioned_docs/version-v0.39.0/noir/concepts/data_types/arrays.md b/docs/versioned_docs/version-v0.39.0/noir/concepts/data_types/arrays.md
new file mode 100644
index 00000000000..289145a8c4d
--- /dev/null
+++ b/docs/versioned_docs/version-v0.39.0/noir/concepts/data_types/arrays.md
@@ -0,0 +1,276 @@
+---
+title: Arrays
+description:
+  Dive into the Array data type in Noir. Grasp its methods, practical examples, and best practices for efficiently using Arrays in your Noir code.
+keywords:
+  [
+    noir,
+    array type,
+    methods,
+    examples,
+    indexing,
+  ]
+sidebar_position: 4
+---
+
+An array is one way of grouping together values into one compound type. Array types can be inferred
+or explicitly specified via the syntax `[<Type>; <Size>]`:
+
+```rust
+fn main(x : Field, y : Field) {
+    let my_arr = [x, y];
+    let your_arr: [Field; 2] = [x, y];
+}
+```
+
+Here, both `my_arr` and `your_arr` are instantiated as an array containing two `Field` elements.
+
+Array elements can be accessed using indexing:
+
+```rust
+fn main() {
+    let a = [1, 2, 3, 4, 5];
+
+    let first = a[0];
+    let second = a[1];
+}
+```
+
+All elements in an array must be of the same type (i.e. homogeneous). That is, an array cannot group
+a `Field` value and a `u8` value together for example.
+
+You can write mutable arrays, like:
+
+```rust
+fn main() {
+    let mut arr = [1, 2, 3, 4, 5];
+    assert(arr[0] == 1);
+
+    arr[0] = 42;
+    assert(arr[0] == 42);
+}
+```
+
+You can instantiate a new array of a fixed size with the same value repeated for each element. The following example instantiates an array of length 32 where each element is of type Field and has the value 0.
+
+```rust
+let array: [Field; 32] = [0; 32];
+```
+
+Like in Rust, arrays in Noir are a fixed size. However, if you wish to convert an array to a [slice](./slices.mdx), you can just call `as_slice` on your array:
+
+```rust
+let array: [Field; 32] = [0; 32];
+let sl = array.as_slice()
+```
+
+You can define multidimensional arrays:
+
+```rust
+let array : [[Field; 2]; 2];
+let element = array[0][0];
+```
+
+However, multidimensional slices are not supported. For example, the following code will error at compile time:
+
+```rust
+let slice : [[Field]] = &[];
+```
+
+## Types
+
+You can create arrays of primitive types or structs. There is not yet support for nested arrays
+(arrays of arrays) or arrays of structs that contain arrays.
+
+## Methods
+
+For convenience, the STD provides some ready-to-use, common methods for arrays.
+Each of these functions are located within the generic impl `impl<T, N> [T; N] {`.
+So anywhere `self` appears, it refers to the variable `self: [T; N]`.
+
+### len
+
+Returns the length of an array
+
+```rust
+fn len(self) -> Field
+```
+
+example
+
+```rust
+fn main() {
+    let array = [42, 42];
+    assert(array.len() == 2);
+}
+```
+
+### sort
+
+Returns a new sorted array. The original array remains untouched. Notice that this function will
+only work for arrays of fields or integers, not for any arbitrary type. This is because the sorting
+logic it uses internally is optimized specifically for these values. If you need a sort function to
+sort any type, you should use the function `sort_via` described below.
+
+```rust
+fn sort(self) -> [T; N]
+```
+
+example
+
+```rust
+fn main() {
+    let arr = [42, 32];
+    let sorted = arr.sort();
+    assert(sorted == [32, 42]);
+}
+```
+
+### sort_via
+
+Sorts the array with a custom comparison function. The ordering function must return true if the first argument should be sorted to be before the second argument or is equal to the second argument.
+
+Using this method with an operator like `<` that does not return `true` for equal values will result in an assertion failure for arrays with equal elements.
+
+```rust
+fn sort_via(self, ordering: fn(T, T) -> bool) -> [T; N]
+```
+
+example
+
+```rust
+fn main() {
+    let arr = [42, 32]
+    let sorted_ascending = arr.sort_via(|a, b| a <= b);
+    assert(sorted_ascending == [32, 42]); // verifies
+
+    let sorted_descending = arr.sort_via(|a, b| a >= b);
+    assert(sorted_descending == [32, 42]); // does not verify
+}
+```
+
+### map
+
+Applies a function to each element of the array, returning a new array containing the mapped elements.
+
+```rust
+fn map<U>(self, f: fn(T) -> U) -> [U; N]
+```
+
+example
+
+```rust
+let a = [1, 2, 3];
+let b = a.map(|a| a * 2); // b is now [2, 4, 6]
+```
+
+### fold
+
+Applies a function to each element of the array, returning the final accumulated value. The first
+parameter is the initial value.
+
+```rust
+fn fold<U>(self, mut accumulator: U, f: fn(U, T) -> U) -> U
+```
+
+This is a left fold, so the given function will be applied to the accumulator and first element of
+the array, then the second, and so on. For a given call the expected result would be equivalent to:
+
+```rust
+let a1 = [1];
+let a2 = [1, 2];
+let a3 = [1, 2, 3];
+
+let f = |a, b| a - b;
+a1.fold(10, f)  //=> f(10, 1)
+a2.fold(10, f)  //=> f(f(10, 1), 2)
+a3.fold(10, f)  //=> f(f(f(10, 1), 2), 3)
+```
+
+example:
+
+```rust
+
+fn main() {
+    let arr = [2, 2, 2, 2, 2];
+    let folded = arr.fold(0, |a, b| a + b);
+    assert(folded == 10);
+}
+
+```
+
+### reduce
+
+Same as fold, but uses the first element as the starting element.
+
+Requires `self` to be non-empty.
+
+```rust
+fn reduce(self, f: fn(T, T) -> T) -> T
+```
+
+example:
+
+```rust
+fn main() {
+    let arr = [2, 2, 2, 2, 2];
+    let reduced = arr.reduce(|a, b| a + b);
+    assert(reduced == 10);
+}
+```
+
+### all
+
+Returns true if all the elements satisfy the given predicate
+
+```rust
+fn all(self, predicate: fn(T) -> bool) -> bool
+```
+
+example:
+
+```rust
+fn main() {
+    let arr = [2, 2, 2, 2, 2];
+    let all = arr.all(|a| a == 2);
+    assert(all);
+}
+```
+
+### any
+
+Returns true if any of the elements satisfy the given predicate
+
+```rust
+fn any(self, predicate: fn(T) -> bool) -> bool
+```
+
+example:
+
+```rust
+fn main() {
+    let arr = [2, 2, 2, 2, 5];
+    let any = arr.any(|a| a == 5);
+    assert(any);
+}
+```
+
+### as_str_unchecked
+
+Converts a byte array of type `[u8; N]` to a string. Note that this performs no UTF-8 validation -
+the given array is interpreted as-is as a string.
+
+```rust
+impl<let N: u32> [u8; N] {
+    pub fn as_str_unchecked(self) -> str<N>
+}
+```
+
+example:
+
+```rust
+fn main() {
+    let hi = [104, 105].as_str_unchecked();
+    assert_eq(hi, "hi");
+}
+```
diff --git a/docs/versioned_docs/version-v0.39.0/noir/concepts/data_types/booleans.md b/docs/versioned_docs/version-v0.39.0/noir/concepts/data_types/booleans.md
new file mode 100644
index 00000000000..2507af710e7
--- /dev/null
+++ b/docs/versioned_docs/version-v0.39.0/noir/concepts/data_types/booleans.md
@@ -0,0 +1,28 @@
+---
+title: Booleans
+description:
+  Delve into the Boolean data type in Noir. Understand its methods, practical examples, and best practices for using Booleans in your Noir programs.
+keywords:
+  [
+    noir,
+    boolean type,
+    methods,
+    examples,
+    logical operations,
+  ]
+sidebar_position: 2
+---
+
+
+The `bool` type in Noir has two possible values: `true` and `false`:
+
+```rust
+fn main() {
+    let t = true;
+    let f: bool = false;
+}
+```
+
+The boolean type is most commonly used in conditionals like `if` expressions and `assert`
+statements. More about conditionals is covered in the [Control Flow](../control_flow.md) and
+[Assert Function](../assert.md) sections.
diff --git a/docs/versioned_docs/version-v0.39.0/noir/concepts/data_types/fields.md b/docs/versioned_docs/version-v0.39.0/noir/concepts/data_types/fields.md
new file mode 100644
index 00000000000..b9b56f7ecc3
--- /dev/null
+++ b/docs/versioned_docs/version-v0.39.0/noir/concepts/data_types/fields.md
@@ -0,0 +1,246 @@
+---
+title: Fields
+description:
+  Dive deep into the Field data type in Noir. Understand its methods, practical examples, and best practices to effectively use Fields in your Noir programs.
+keywords:
+  [
+    noir,
+    field type,
+    methods,
+    examples,
+    best practices,
+  ]
+sidebar_position: 0
+---
+
+The field type corresponds to the native field type of the proving backend.
+
+The size of a Noir field depends on the elliptic curve's finite field for the proving backend
+adopted. For example, a field would be a 254-bit integer when paired with the default backend that
+spans the Grumpkin curve.
+
+Fields support integer arithmetic and are often used as the default numeric type in Noir:
+
+```rust
+fn main(x : Field, y : Field)  {
+    let z = x + y;
+}
+```
+
+`x`, `y` and `z` are all private fields in this example. Using the `let` keyword we defined a new
+private value `z` constrained to be equal to `x + y`.
+
+If proving efficiency is of priority, fields should be used as a default for solving problems.
+Smaller integer types (e.g. `u64`) incur extra range constraints.
+
+## Methods
+
+After declaring a Field, you can use these common methods on it:
+
+### to_le_bits
+
+Transforms the field into an array of bits, Little Endian.
+
+```rust title="to_le_bits" showLineNumbers 
+pub fn to_le_bits<let N: u32>(self: Self) -> [u1; N] {}
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/field/mod.nr#L32-L34" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/field/mod.nr#L32-L34</a></sub></sup>
+
+
+example:
+
+```rust title="to_le_bits_example" showLineNumbers 
+fn test_to_le_bits() {
+        let field = 2;
+        let bits: [u1; 8] = field.to_le_bits();
+        assert_eq(bits, [0, 1, 0, 0, 0, 0, 0, 0]);
+    }
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/field/mod.nr#L276-L282" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/field/mod.nr#L276-L282</a></sub></sup>
+
+
+
+### to_be_bits
+
+Transforms the field into an array of bits, Big Endian.
+
+```rust title="to_be_bits" showLineNumbers 
+pub fn to_be_bits<let N: u32>(self: Self) -> [u1; N] {}
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/field/mod.nr#L48-L50" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/field/mod.nr#L48-L50</a></sub></sup>
+
+
+example:
+
+```rust title="to_be_bits_example" showLineNumbers 
+fn test_to_be_bits() {
+        let field = 2;
+        let bits: [u1; 8] = field.to_be_bits();
+        assert_eq(bits, [0, 0, 0, 0, 0, 0, 1, 0]);
+    }
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/field/mod.nr#L267-L273" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/field/mod.nr#L267-L273</a></sub></sup>
+
+
+
+### to_le_bytes
+
+Transforms into an array of bytes, Little Endian
+
+```rust title="to_le_bytes" showLineNumbers 
+pub fn to_le_bytes<let N: u32>(self: Self) -> [u8; N] {
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/field/mod.nr#L61-L63" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/field/mod.nr#L61-L63</a></sub></sup>
+
+
+example:
+
+```rust title="to_le_bytes_example" showLineNumbers 
+fn test_to_le_bytes() {
+        let field = 2;
+        let bytes: [u8; 8] = field.to_le_bytes();
+        assert_eq(bytes, [2, 0, 0, 0, 0, 0, 0, 0]);
+        assert_eq(Field::from_le_bytes::<8>(bytes), field);
+    }
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/field/mod.nr#L295-L302" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/field/mod.nr#L295-L302</a></sub></sup>
+
+
+### to_be_bytes
+
+Transforms into an array of bytes, Big Endian
+
+```rust title="to_be_bytes" showLineNumbers 
+pub fn to_be_bytes<let N: u32>(self: Self) -> [u8; N] {
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/field/mod.nr#L94-L96" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/field/mod.nr#L94-L96</a></sub></sup>
+
+
+example:
+
+```rust title="to_be_bytes_example" showLineNumbers 
+fn test_to_be_bytes() {
+        let field = 2;
+        let bytes: [u8; 8] = field.to_be_bytes();
+        assert_eq(bytes, [0, 0, 0, 0, 0, 0, 0, 2]);
+        assert_eq(Field::from_be_bytes::<8>(bytes), field);
+    }
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/field/mod.nr#L285-L292" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/field/mod.nr#L285-L292</a></sub></sup>
+
+
+
+### to_le_radix
+
+Decomposes into an array over the specified base, Little Endian
+
+```rust title="to_le_radix" showLineNumbers 
+pub fn to_le_radix<let N: u32>(self: Self, radix: u32) -> [u8; N] {
+        // Brillig does not need an immediate radix
+        if !crate::runtime::is_unconstrained() {
+            crate::assert_constant(radix);
+        }
+        self.__to_le_radix(radix)
+    }
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/field/mod.nr#L118-L126" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/field/mod.nr#L118-L126</a></sub></sup>
+
+
+
+example:
+
+```rust title="to_le_radix_example" showLineNumbers 
+fn test_to_le_radix() {
+        let field = 2;
+        let bytes: [u8; 8] = field.to_le_radix(256);
+        assert_eq(bytes, [2, 0, 0, 0, 0, 0, 0, 0]);
+        assert_eq(Field::from_le_bytes::<8>(bytes), field);
+    }
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/field/mod.nr#L315-L322" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/field/mod.nr#L315-L322</a></sub></sup>
+
+
+
+### to_be_radix
+
+Decomposes into an array over the specified base, Big Endian
+
+```rust title="to_be_radix" showLineNumbers 
+pub fn to_be_radix<let N: u32>(self: Self, radix: u32) -> [u8; N] {
+        // Brillig does not need an immediate radix
+        if !crate::runtime::is_unconstrained() {
+            crate::assert_constant(radix);
+        }
+        self.__to_be_radix(radix)
+    }
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/field/mod.nr#L128-L136" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/field/mod.nr#L128-L136</a></sub></sup>
+
+
+example:
+
+```rust title="to_be_radix_example" showLineNumbers 
+fn test_to_be_radix() {
+        let field = 2;
+        let bytes: [u8; 8] = field.to_be_radix(256);
+        assert_eq(bytes, [0, 0, 0, 0, 0, 0, 0, 2]);
+        assert_eq(Field::from_be_bytes::<8>(bytes), field);
+    }
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/field/mod.nr#L305-L312" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/field/mod.nr#L305-L312</a></sub></sup>
+
+
+
+### pow_32
+
+Returns the value to the power of the specified exponent
+
+```rust
+fn pow_32(self, exponent: Field) -> Field
+```
+
+example:
+
+```rust
+fn main() {
+    let field = 2
+    let pow = field.pow_32(4);
+    assert(pow == 16);
+}
+```
+
+### assert_max_bit_size
+
+Adds a constraint to specify that the field can be represented with `bit_size` number of bits
+
+```rust title="assert_max_bit_size" showLineNumbers 
+pub fn assert_max_bit_size<let BIT_SIZE: u32>(self) {
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/field/mod.nr#L10-L12" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/field/mod.nr#L10-L12</a></sub></sup>
+
+
+example:
+
+```rust
+fn main() {
+    let field = 2
+    field.assert_max_bit_size(32);
+}
+```
+
+### sgn0
+
+Parity of (prime) Field element, i.e. sgn0(x mod p) = 0 if x ∈ \{0, ..., p-1\} is even, otherwise sgn0(x mod p) = 1.
+
+```rust
+fn sgn0(self) -> u1
+```
+
+
+### lt
+
+Returns true if the field is less than the other field
+
+```rust
+pub fn lt(self, another: Field) -> bool
+```
diff --git a/docs/versioned_docs/version-v0.39.0/noir/concepts/data_types/function_types.md b/docs/versioned_docs/version-v0.39.0/noir/concepts/data_types/function_types.md
new file mode 100644
index 00000000000..f6121af17e2
--- /dev/null
+++ b/docs/versioned_docs/version-v0.39.0/noir/concepts/data_types/function_types.md
@@ -0,0 +1,26 @@
+---
+title: Function types
+sidebar_position: 10
+---
+
+Noir supports higher-order functions. The syntax for a function type is as follows:
+
+```rust
+fn(arg1_type, arg2_type, ...) -> return_type
+```
+
+Example:
+
+```rust
+fn assert_returns_100(f: fn() -> Field) { // f takes no args and returns a Field
+    assert(f() == 100);
+}
+
+fn main() {
+    assert_returns_100(|| 100); // ok
+    assert_returns_100(|| 150); // fails
+}
+```
+
+A function type also has an optional capture environment - this is necessary to support closures.
+See [Lambdas](../lambdas.md) for more details.
diff --git a/docs/versioned_docs/version-v0.39.0/noir/concepts/data_types/index.md b/docs/versioned_docs/version-v0.39.0/noir/concepts/data_types/index.md
new file mode 100644
index 00000000000..0f2db2b2d75
--- /dev/null
+++ b/docs/versioned_docs/version-v0.39.0/noir/concepts/data_types/index.md
@@ -0,0 +1,126 @@
+---
+title: Data Types
+description:
+  Get a clear understanding of the two categories of Noir data types - primitive types and compound
+  types. Learn about their characteristics, differences, and how to use them in your Noir
+  programming.
+keywords:
+  [
+    noir,
+    data types,
+    primitive types,
+    compound types,
+    private types,
+    public types,
+  ]
+---
+
+Every value in Noir has a type, which determines which operations are valid for it.
+
+All values in Noir are fundamentally composed of `Field` elements. For a more approachable
+developing experience, abstractions are added on top to introduce different data types in Noir.
+
+Noir has two category of data types: primitive types (e.g. `Field`, integers, `bool`) and compound
+types that group primitive types (e.g. arrays, tuples, structs). Each value can either be private or
+public.
+
+## Private & Public Types
+
+A **private value** is known only to the Prover, while a **public value** is known by both the
+Prover and Verifier. Mark values as `private` when the value should only be known to the prover. All
+primitive types (including individual fields of compound types) in Noir are private by default, and
+can be marked public when certain values are intended to be revealed to the Verifier.
+
+> **Note:** For public values defined in Noir programs paired with smart contract verifiers, once
+> the proofs are verified on-chain the values can be considered known to everyone that has access to
+> that blockchain.
+
+Public data types are treated no differently to private types apart from the fact that their values
+will be revealed in proofs generated. Simply changing the value of a public type will not change the
+circuit (where the same goes for changing values of private types as well).
+
+_Private values_ are also referred to as _witnesses_ sometimes.
+
+> **Note:** The terms private and public when applied to a type (e.g. `pub Field`) have a different
+> meaning than when applied to a function (e.g. `pub fn foo() {}`).
+>
+> The former is a visibility modifier for the Prover to interpret if a value should be made known to
+> the Verifier, while the latter is a visibility modifier for the compiler to interpret if a
+> function should be made accessible to external Noir programs like in other languages.
+
+### pub Modifier
+
+All data types in Noir are private by default. Types are explicitly declared as public using the
+`pub` modifier:
+
+```rust
+fn main(x : Field, y : pub Field) -> pub Field {
+    x + y
+}
+```
+
+In this example, `x` is **private** while `y` and `x + y` (the return value) are **public**. Note
+that visibility is handled **per variable**, so it is perfectly valid to have one input that is
+private and another that is public.
+
+> **Note:** Public types can only be declared through parameters on `main`.
+
+## Type Aliases
+
+A type alias is a new name for an existing type. Type aliases are declared with the keyword `type`:
+
+```rust
+type Id = u8;
+
+fn main() {
+    let id: Id = 1;
+    let zero: u8 = 0;
+    assert(zero + 1 == id);
+}
+```
+
+Type aliases can also be used with [generics](../generics.md):
+
+```rust
+type Id<Size> = Size;
+
+fn main() {
+    let id: Id<u32> = 1;
+    let zero: u32 = 0;
+    assert(zero + 1 == id);
+}
+```
+
+Type aliases can even refer to other aliases. An error will be issued if they form a cycle:
+
+```rust
+// Ok!
+type A = B;
+type B = Field;
+
+type Bad1 = Bad2;
+
+// error: Dependency cycle found
+type Bad2 = Bad1;
+//   ^^^^^^^^^^^ 'Bad2' recursively depends on itself: Bad2 -> Bad1 -> Bad2
+```
+
+By default, like functions, type aliases are private to the module they exist in. You can use `pub`
+to make the type alias public or `pub(crate)` to make it public to just its crate:
+
+```rust
+// This type alias is now public
+pub type Id = u8;
+```
+
+## Wildcard Type
+Noir can usually infer the type of the variable from the context, so specifying the type of a variable is only required when it cannot be inferred. However, specifying a complex type can be tedious, especially when it has multiple generic arguments. Often some of the generic types can be inferred from the context, and Noir only needs a hint to properly infer the other types. We can partially specify a variable's type by using `_` as a marker, indicating where we still want the compiler to infer the type.
+
+```rust
+let a: [_; 4] = foo(b);
+```
+ 
+
+### BigInt
+
+You can achieve BigInt functionality using the [Noir BigInt](https://github.com/shuklaayush/noir-bigint) library.
diff --git a/docs/versioned_docs/version-v0.39.0/noir/concepts/data_types/integers.md b/docs/versioned_docs/version-v0.39.0/noir/concepts/data_types/integers.md
new file mode 100644
index 00000000000..a1d59bf3166
--- /dev/null
+++ b/docs/versioned_docs/version-v0.39.0/noir/concepts/data_types/integers.md
@@ -0,0 +1,156 @@
+---
+title: Integers
+description: Explore the Integer data type in Noir. Learn about its methods, see real-world examples, and grasp how to efficiently use Integers in your Noir code.
+keywords: [noir, integer types, methods, examples, arithmetic]
+sidebar_position: 1
+---
+
+An integer type is a range constrained field type.
+The Noir frontend supports both unsigned and signed integer types.
+The allowed sizes are 1, 8, 16, 32 and 64 bits.
+
+:::info
+
+When an integer is defined in Noir without a specific type, it will default to `Field`.
+
+The one exception is for loop indices which default to `u64` since comparisons on `Field`s are not possible.
+
+:::
+
+## Unsigned Integers
+
+An unsigned integer type is specified first with the letter `u` (indicating its unsigned nature) followed by its bit size (e.g. `8`):
+
+```rust
+fn main() {
+    let x: u8 = 1;
+    let y: u8 = 1;
+    let z = x + y;
+    assert (z == 2);
+}
+```
+
+The bit size determines the maximum value the integer type can store. For example, a `u8` variable can store a value in the range of 0 to 255 (i.e. $\\2^{8}-1\\$).
+
+## Signed Integers
+
+A signed integer type is specified first with the letter `i` (which stands for integer) followed by its bit size (e.g. `8`):
+
+```rust
+fn main() {
+    let x: i8 = -1;
+    let y: i8 = -1;
+    let z = x + y;
+    assert (z == -2);
+}
+```
+
+The bit size determines the maximum and minimum range of value the integer type can store. For example, an `i8` variable can store a value in the range of -128 to 127 (i.e. $\\-2^{7}\\$ to $\\2^{7}-1\\$).
+
+## 128 bits Unsigned Integers
+
+The built-in structure `U128` allows you to use 128-bit unsigned integers almost like a native integer type. However, there are some differences to keep in mind:
+- You cannot cast between a native integer and `U128`
+- There is a higher performance cost when using `U128`, compared to a native type.
+
+Conversion between unsigned integer types and U128 are done through the use of `from_integer` and `to_integer` functions. `from_integer` also accepts the `Field` type as input.
+
+```rust
+fn main() {
+    let x = U128::from_integer(23);
+    let y = U128::from_hex("0x7");
+    let z = x + y;
+    assert(z.to_integer() == 30);
+}
+```
+
+`U128` is implemented with two 64 bits limbs, representing the low and high bits, which explains the performance cost. You should expect `U128` to be twice more costly for addition and four times more costly for multiplication.
+You can construct a U128 from its limbs:
+```rust
+fn main(x: u64, y: u64) {
+    let x = U128::from_u64s_be(x,y);
+    assert(z.hi == x as Field);
+    assert(z.lo == y as Field);
+}
+```
+
+Note that the limbs are stored as Field elements in order to avoid unnecessary conversions.
+Apart from this, most operations will work as usual:
+
+```rust
+fn main(x: U128, y: U128) {
+    // multiplication
+    let c = x * y;
+    // addition and subtraction
+    let c = c - x + y;
+    // division
+    let c = x / y;
+    // bit operation;
+    let c = x & y | y;
+    // bit shift
+    let c = x << y;
+    // comparisons;
+    let c = x < y;
+    let c = x == y;
+}
+```
+
+## Overflows
+
+Computations that exceed the type boundaries will result in overflow errors. This happens with both signed and unsigned integers. For example, attempting to prove:
+
+```rust
+fn main(x: u8, y: u8) {
+    let z = x + y;
+}
+```
+
+With:
+
+```toml
+x = "255"
+y = "1"
+```
+
+Would result in:
+
+```
+$ nargo execute
+error: Assertion failed: 'attempt to add with overflow'
+┌─ ~/src/main.nr:9:13
+│
+│     let z = x + y;
+│             -----
+│
+= Call stack:
+  ...
+```
+
+A similar error would happen with signed integers:
+
+```rust
+fn main() {
+    let x: i8 = -118;
+    let y: i8 = -11;
+    let z = x + y;
+}
+```
+
+### Wrapping methods
+
+Although integer overflow is expected to error, some use-cases rely on wrapping. For these use-cases, the standard library provides `wrapping` variants of certain common operations:
+
+```rust
+fn wrapping_add<T>(x: T, y: T) -> T;
+fn wrapping_sub<T>(x: T, y: T) -> T;
+fn wrapping_mul<T>(x: T, y: T) -> T;
+```
+
+Example of how it is used:
+
+```rust
+
+fn main(x: u8, y: u8) -> pub u8 {
+    std::wrapping_add(x, y)
+}
+```
diff --git a/docs/versioned_docs/version-v0.39.0/noir/concepts/data_types/references.md b/docs/versioned_docs/version-v0.39.0/noir/concepts/data_types/references.md
new file mode 100644
index 00000000000..a5293d11cfb
--- /dev/null
+++ b/docs/versioned_docs/version-v0.39.0/noir/concepts/data_types/references.md
@@ -0,0 +1,23 @@
+---
+title: References
+sidebar_position: 9
+---
+
+Noir supports first-class references. References are a bit like pointers: they point to a specific address that can be followed to access the data stored at that address. You can use Rust-like syntax to use pointers in Noir: the `&` operator references the variable, the `*` operator dereferences it.
+
+Example:
+
+```rust
+fn main() {
+    let mut x = 2;
+
+    // you can reference x as &mut and pass it to multiplyBy2
+    multiplyBy2(&mut x);
+}
+
+// you can access &mut here
+fn multiplyBy2(x: &mut Field) {
+    // and dereference it with *
+    *x = *x * 2;
+}
+```
diff --git a/docs/versioned_docs/version-v0.39.0/noir/concepts/data_types/slices.mdx b/docs/versioned_docs/version-v0.39.0/noir/concepts/data_types/slices.mdx
new file mode 100644
index 00000000000..cfee564a302
--- /dev/null
+++ b/docs/versioned_docs/version-v0.39.0/noir/concepts/data_types/slices.mdx
@@ -0,0 +1,358 @@
+---
+title: Slices
+description: Explore the Slice data type in Noir. Understand its methods, see real-world examples, and learn how to effectively use Slices in your Noir programs.
+keywords: [noir, slice type, methods, examples, subarrays]
+sidebar_position: 5
+---
+
+import Experimental from '@site/src/components/Notes/_experimental.mdx';
+
+<Experimental />
+
+A slice is a dynamically-sized view into a sequence of elements. They can be resized at runtime, but because they don't own the data, they cannot be returned from a circuit. You can treat slices as arrays without a constrained size.
+
+```rust
+fn main() -> pub u32 {
+    let mut slice: [Field] = &[0; 2];
+
+    let mut new_slice = slice.push_back(6);
+    new_slice.len()
+}
+```
+
+To write a slice literal, use a preceding ampersand as in: `&[0; 2]` or
+`&[1, 2, 3]`.
+
+It is important to note that slices are not references to arrays. In Noir,
+`&[..]` is more similar to an immutable, growable vector.
+
+View the corresponding test file [here][test-file].
+
+[test-file]: https://github.com/noir-lang/noir/blob/f387ec1475129732f72ba294877efdf6857135ac/crates/nargo_cli/tests/test_data_ssa_refactor/slices/src/main.nr
+
+## Methods
+
+For convenience, the STD provides some ready-to-use, common methods for slices:
+
+### push_back
+
+Pushes a new element to the end of the slice, returning a new slice with a length one greater than the original unmodified slice.
+
+```rust
+fn push_back<T>(_self: [T], _elem: T) -> [T]
+```
+
+example:
+
+```rust
+fn main() -> pub Field {
+    let mut slice: [Field] = &[0; 2];
+
+    let mut new_slice = slice.push_back(6);
+    new_slice.len()
+}
+```
+
+View the corresponding test file [here][test-file].
+
+### push_front
+
+Returns a new array with the specified element inserted at index 0. The existing elements indexes are incremented by 1.
+
+```rust
+fn push_front(_self: Self, _elem: T) -> Self
+```
+
+Example:
+
+```rust
+let mut new_slice: [Field] = &[];
+new_slice = new_slice.push_front(20);
+assert(new_slice[0] == 20); // returns true
+```
+
+View the corresponding test file [here][test-file].
+
+### pop_front
+
+Returns a tuple of two items, the first element of the array and the rest of the array.
+
+```rust
+fn pop_front(_self: Self) -> (T, Self)
+```
+
+Example:
+
+```rust
+let (first_elem, rest_of_slice) = slice.pop_front();
+```
+
+View the corresponding test file [here][test-file].
+
+### pop_back
+
+Returns a tuple of two items, the beginning of the array with the last element omitted and the last element.
+
+```rust
+fn pop_back(_self: Self) -> (Self, T)
+```
+
+Example:
+
+```rust
+let (popped_slice, last_elem) = slice.pop_back();
+```
+
+View the corresponding test file [here][test-file].
+
+### append
+
+Loops over a slice and adds it to the end of another.
+
+```rust
+fn append(mut self, other: Self) -> Self
+```
+
+Example:
+
+```rust
+let append = &[1, 2].append(&[3, 4, 5]);
+```
+
+### insert
+
+Inserts an element at a specified index and shifts all following elements by 1.
+
+```rust
+fn insert(_self: Self, _index: Field, _elem: T) -> Self
+```
+
+Example:
+
+```rust
+new_slice = rest_of_slice.insert(2, 100);
+assert(new_slice[2] == 100);
+```
+
+View the corresponding test file [here][test-file].
+
+### remove
+
+Remove an element at a specified index, shifting all elements after it to the left, returning the altered slice and the removed element.
+
+```rust
+fn remove(_self: Self, _index: Field) -> (Self, T)
+```
+
+Example:
+
+```rust
+let (remove_slice, removed_elem) = slice.remove(3);
+```
+
+### len
+
+Returns the length of a slice
+
+```rust
+fn len(self) -> Field
+```
+
+Example:
+
+```rust
+fn main() {
+    let slice = &[42, 42];
+    assert(slice.len() == 2);
+}
+```
+
+### as_array
+
+Converts this slice into an array.
+
+Make sure to specify the size of the resulting array.
+Panics if the resulting array length is different than the slice's length.
+
+```rust
+fn as_array<let N: u32>(self) -> [T; N]
+```
+
+Example:
+
+```rust
+fn main() {
+    let slice = &[5, 6];
+
+    // Always specify the length of the resulting array!
+    let array: [Field; 2] = slice.as_array();
+
+    assert(array[0] == slice[0]);
+    assert(array[1] == slice[1]);
+}
+```
+
+### map
+
+Applies a function to each element of the slice, returning a new slice containing the mapped elements.
+
+```rust
+fn map<U, Env>(self, f: fn[Env](T) -> U) -> [U]
+```
+
+example
+
+```rust
+let a = &[1, 2, 3];
+let b = a.map(|a| a * 2); // b is now &[2, 4, 6]
+```
+
+### fold
+
+Applies a function to each element of the slice, returning the final accumulated value. The first
+parameter is the initial value.
+
+```rust
+fn fold<U, Env>(self, mut accumulator: U, f: fn[Env](U, T) -> U) -> U
+```
+
+This is a left fold, so the given function will be applied to the accumulator and first element of
+the slice, then the second, and so on. For a given call the expected result would be equivalent to:
+
+```rust
+let a1 = &[1];
+let a2 = &[1, 2];
+let a3 = &[1, 2, 3];
+
+let f = |a, b| a - b;
+a1.fold(10, f)  //=> f(10, 1)
+a2.fold(10, f)  //=> f(f(10, 1), 2)
+a3.fold(10, f)  //=> f(f(f(10, 1), 2), 3)
+```
+
+example:
+
+```rust
+
+fn main() {
+    let slice = &[2, 2, 2, 2, 2];
+    let folded = slice.fold(0, |a, b| a + b);
+    assert(folded == 10);
+}
+
+```
+
+### reduce
+
+Same as fold, but uses the first element as the starting element.
+
+```rust
+fn reduce<Env>(self, f: fn[Env](T, T) -> T) -> T
+```
+
+example:
+
+```rust
+fn main() {
+    let slice = &[2, 2, 2, 2, 2];
+    let reduced = slice.reduce(|a, b| a + b);
+    assert(reduced == 10);
+}
+```
+
+### filter
+
+Returns a new slice containing only elements for which the given predicate returns true.
+
+```rust
+fn filter<Env>(self, f: fn[Env](T) -> bool) -> Self
+```
+
+example:
+
+```rust
+fn main() {
+    let slice = &[1, 2, 3, 4, 5];
+    let odds = slice.filter(|x| x % 2 == 1);
+    assert_eq(odds, &[1, 3, 5]);
+}
+```
+
+### join
+
+Flatten each element in the slice into one value, separated by `separator`.
+
+Note that although slices implement `Append`, `join` cannot be used on slice
+elements since nested slices are prohibited.
+
+```rust
+fn join(self, separator: T) -> T where T: Append
+```
+
+example:
+
+```rust
+struct Accumulator {
+    total: Field,
+}
+
+// "Append" two accumulators by adding them
+impl Append for Accumulator {
+    fn empty() -> Self {
+        Self { total: 0 }
+    }
+
+    fn append(self, other: Self) -> Self {
+        Self { total: self.total + other.total }
+    }
+}
+
+fn main() {
+    let slice = &[1, 2, 3, 4, 5].map(|total| Accumulator { total });
+
+    let result = slice.join(Accumulator::empty());
+    assert_eq(result, Accumulator { total: 15 });
+
+    // We can use a non-empty separator to insert additional elements to sum:
+    let separator = Accumulator { total: 10 };
+    let result = slice.join(separator);
+    assert_eq(result, Accumulator { total: 55 });
+}
+```
+
+### all
+
+Returns true if all the elements satisfy the given predicate
+
+```rust
+fn all<Env>(self, predicate: fn[Env](T) -> bool) -> bool
+```
+
+example:
+
+```rust
+fn main() {
+    let slice = &[2, 2, 2, 2, 2];
+    let all = slice.all(|a| a == 2);
+    assert(all);
+}
+```
+
+### any
+
+Returns true if any of the elements satisfy the given predicate
+
+```rust
+fn any<Env>(self, predicate: fn[Env](T) -> bool) -> bool
+```
+
+example:
+
+```rust
+fn main() {
+    let slice = &[2, 2, 2, 2, 5];
+    let any = slice.any(|a| a == 5);
+    assert(any);
+}
+
+```
diff --git a/docs/versioned_docs/version-v0.39.0/noir/concepts/data_types/strings.md b/docs/versioned_docs/version-v0.39.0/noir/concepts/data_types/strings.md
new file mode 100644
index 00000000000..1fdee42425e
--- /dev/null
+++ b/docs/versioned_docs/version-v0.39.0/noir/concepts/data_types/strings.md
@@ -0,0 +1,79 @@
+---
+title: Strings
+description:
+  Discover the String data type in Noir. Learn about its methods, see real-world examples, and understand how to effectively manipulate and use Strings in Noir.
+keywords:
+  [
+    noir,
+    string type,
+    methods,
+    examples,
+    concatenation,
+  ]
+sidebar_position: 3
+---
+
+
+The string type is a fixed length value defined with `str<N>`.
+
+You can use strings in `assert()` functions or print them with
+`println()`. See more about [Logging](../../standard_library/logging.md).
+
+```rust
+
+fn main(message : pub str<11>, hex_as_string : str<4>) {
+    println(message);
+    assert(message == "hello world");
+    assert(hex_as_string == "0x41");
+}
+```
+
+You can convert a `str<N>` to a byte array by calling `as_bytes()`
+or a vector by calling `as_bytes_vec()`.
+
+```rust
+fn main() {
+    let message = "hello world";
+    let message_bytes = message.as_bytes();
+    let mut message_vec = message.as_bytes_vec();
+    assert(message_bytes.len() == 11);
+    assert(message_bytes[0] == 104);
+    assert(message_bytes[0] == message_vec.get(0));
+}
+```
+
+## Escape characters
+
+You can use escape characters for your strings:
+
+| Escape Sequence | Description     |
+|-----------------|-----------------|
+| `\r`            | Carriage Return |
+| `\n`            | Newline         |
+| `\t`            | Tab             |
+| `\0`            | Null Character  |
+| `\"`            | Double Quote    |
+| `\\`            | Backslash       |
+
+Example:
+
+```rust
+let s = "Hello \"world" // prints "Hello "world"
+let s = "hey \tyou"; // prints "hey   you"
+```
+
+## Raw strings
+
+A raw string begins with the letter `r` and is optionally delimited by a number of hashes `#`.
+
+Escape characters are *not* processed within raw strings. All contents are interpreted literally.
+
+Example:
+
+```rust
+let s = r"Hello world";
+let s = r#"Simon says "hello world""#;
+
+// Any number of hashes may be used (>= 1) as long as the string also terminates with the same number of hashes
+let s = r#####"One "#, Two "##, Three "###, Four "####, Five will end the string."#####; 
+```
diff --git a/docs/versioned_docs/version-v0.39.0/noir/concepts/data_types/structs.md b/docs/versioned_docs/version-v0.39.0/noir/concepts/data_types/structs.md
new file mode 100644
index 00000000000..29951ae843a
--- /dev/null
+++ b/docs/versioned_docs/version-v0.39.0/noir/concepts/data_types/structs.md
@@ -0,0 +1,96 @@
+---
+title: Structs
+description:
+  Explore the Struct data type in Noir. Learn about its methods, see real-world examples, and grasp how to effectively define and use Structs in your Noir programs.
+keywords:
+  [
+    noir,
+    struct type,
+    methods,
+    examples,
+    data structures,
+  ]
+sidebar_position: 8
+---
+
+A struct also allows for grouping multiple values of different types. Unlike tuples, we can also
+name each field.
+
+> **Note:** The usage of _field_ here refers to each element of the struct and is unrelated to the
+> field type of Noir.
+
+Defining a struct requires giving it a name and listing each field within as `<Key>: <Type>` pairs:
+
+```rust
+struct Animal {
+    hands: Field,
+    legs: Field,
+    eyes: u8,
+}
+```
+
+An instance of a struct can then be created with actual values in `<Key>: <Value>` pairs in any
+order. Struct fields are accessible using their given names:
+
+```rust
+fn main() {
+    let legs = 4;
+
+    let dog = Animal {
+        eyes: 2,
+        hands: 0,
+        legs,
+    };
+
+    let zero = dog.hands;
+}
+```
+
+Structs can also be destructured in a pattern, binding each field to a new variable:
+
+```rust
+fn main() {
+    let Animal { hands, legs: feet, eyes } = get_octopus();
+
+    let ten = hands + feet + eyes as u8;
+}
+
+fn get_octopus() -> Animal {
+    let octopus = Animal {
+        hands: 0,
+        legs: 8,
+        eyes: 2,
+    };
+
+    octopus
+}
+```
+
+The new variables can be bound with names different from the original struct field names, as
+showcased in the `legs --> feet` binding in the example above.
+
+### Visibility
+
+By default, like functions, structs are private to the module they exist in. You can use `pub`
+to make the struct public or `pub(crate)` to make it public to just its crate:
+
+```rust
+// This struct is now public
+pub struct Animal {
+    hands: Field,
+    legs: Field,
+    eyes: u8,
+}
+```
+
+The same applies to struct fields: by default they are private to the module they exist in,
+but they can be made `pub` or `pub(crate)`:
+
+```rust
+// This struct is now public
+pub struct Animal {
+    hands: Field,           // private to its module
+    pub(crate) legs: Field, // accessible from the entire crate
+    pub eyes: u8,           // accessible from anywhere
+}
+```
\ No newline at end of file
diff --git a/docs/versioned_docs/version-v0.39.0/noir/concepts/data_types/tuples.md b/docs/versioned_docs/version-v0.39.0/noir/concepts/data_types/tuples.md
new file mode 100644
index 00000000000..2ec5c9c4113
--- /dev/null
+++ b/docs/versioned_docs/version-v0.39.0/noir/concepts/data_types/tuples.md
@@ -0,0 +1,48 @@
+---
+title: Tuples
+description:
+  Dive into the Tuple data type in Noir. Understand its methods, practical examples, and best practices for efficiently using Tuples in your Noir code.
+keywords:
+  [
+    noir,
+    tuple type,
+    methods,
+    examples,
+    multi-value containers,
+  ]
+sidebar_position: 7
+---
+
+A tuple collects multiple values like an array, but with the added ability to collect values of
+different types:
+
+```rust
+fn main() {
+    let tup: (u8, u64, Field) = (255, 500, 1000);
+}
+```
+
+One way to access tuple elements is via destructuring using pattern matching:
+
+```rust
+fn main() {
+    let tup = (1, 2);
+
+    let (one, two) = tup;
+
+    let three = one + two;
+}
+```
+
+Another way to access tuple elements is via direct member access, using a period (`.`) followed by
+the index of the element we want to access. Index `0` corresponds to the first tuple element, `1` to
+the second and so on:
+
+```rust
+fn main() {
+    let tup = (5, 6, 7, 8);
+
+    let five = tup.0;
+    let eight = tup.3;
+}
+```
diff --git a/docs/versioned_docs/version-v0.39.0/noir/concepts/functions.md b/docs/versioned_docs/version-v0.39.0/noir/concepts/functions.md
new file mode 100644
index 00000000000..f656cdfd97a
--- /dev/null
+++ b/docs/versioned_docs/version-v0.39.0/noir/concepts/functions.md
@@ -0,0 +1,226 @@
+---
+title: Functions
+description:
+  Learn how to declare functions and methods in Noir, a programming language with Rust semantics.
+  This guide covers parameter declaration, return types, call expressions, and more.
+keywords: [Noir, Rust, functions, methods, parameter declaration, return types, call expressions]
+sidebar_position: 1
+---
+
+Functions in Noir follow the same semantics of Rust, though Noir does not support early returns.
+
+To declare a function the `fn` keyword is used.
+
+```rust
+fn foo() {}
+```
+
+By default, functions are visible only within the package they are defined. To make them visible outside of that package (for example, as part of a [library](../modules_packages_crates/crates_and_packages.md#libraries)), you should mark them as `pub`:
+
+```rust
+pub fn foo() {}
+```
+
+You can also restrict the visibility of the function to only the crate it was defined in, by specifying `pub(crate)`:
+
+```rust
+pub(crate) fn foo() {}  //foo can only be called within its crate
+```
+
+All parameters in a function must have a type and all types are known at compile time. The parameter
+is pre-pended with a colon and the parameter type. Multiple parameters are separated using a comma.
+
+```rust
+fn foo(x : Field, y : Field){}
+```
+
+The return type of a function can be stated by using the `->` arrow notation. The function below
+states that the foo function must return a `Field`. If the function returns no value, then the arrow
+is omitted.
+
+```rust
+fn foo(x : Field, y : Field) -> Field {
+    x + y
+}
+```
+
+Note that a `return` keyword is unneeded in this case - the last expression in a function's body is
+returned.
+
+## Main function
+
+If you're writing a binary, the `main` function is the starting point of your program. You can pass all types of expressions to it, as long as they have a fixed size at compile time:
+
+```rust
+fn main(x : Field) // this is fine: passing a Field
+fn main(x : [Field; 2]) // this is also fine: passing a Field with known size at compile-time
+fn main(x : (Field, bool)) // 👌: passing a (Field, bool) tuple means size 2
+fn main(x : str<5>) // this is fine, as long as you pass a string of size 5
+
+fn main(x : Vec<Field>) // can't compile, has variable size
+fn main(x : [Field]) // can't compile, has variable size
+fn main(....// i think you got it by now
+```
+
+Keep in mind [tests](../../tooling/testing.md) don't differentiate between `main` and any other function. The following snippet passes tests, but won't compile or prove:
+
+```rust
+fn main(x : [Field]) {
+    assert(x[0] == 1);
+}
+
+#[test]
+fn test_one() {
+    main(&[1, 2]);
+}
+```
+
+```bash
+$ nargo test
+[testing] Running 1 test functions
+[testing] Testing test_one... ok
+[testing] All tests passed
+
+$ nargo check
+The application panicked (crashed).
+Message:  Cannot have variable sized arrays as a parameter to main
+```
+
+## Call Expressions
+
+Calling a function in Noir is executed by using the function name and passing in the necessary
+arguments.
+
+Below we show how to call the `foo` function from the `main` function using a call expression:
+
+```rust
+fn main(x : Field, y : Field) {
+    let z = foo(x);
+}
+
+fn foo(x : Field) -> Field {
+    x + x
+}
+```
+
+## Methods
+
+You can define methods in Noir on any struct type in scope.
+
+```rust
+struct MyStruct {
+    foo: Field,
+    bar: Field,
+}
+
+impl MyStruct {
+    fn new(foo: Field) -> MyStruct {
+        MyStruct {
+            foo,
+            bar: 2,
+        }
+    }
+
+    fn sum(self) -> Field {
+        self.foo + self.bar
+    }
+}
+
+fn main() {
+    let s = MyStruct::new(40);
+    assert(s.sum() == 42);
+}
+```
+
+Methods are just syntactic sugar for functions, so if we wanted to we could also call `sum` as
+follows:
+
+```rust
+assert(MyStruct::sum(s) == 42);
+```
+
+It is also possible to specialize which method is chosen depending on the [generic](./generics.md) type that is used. In this example, the `foo` function returns different values depending on its type:
+
+```rust
+struct Foo<T> {}
+
+impl Foo<u32> {
+    fn foo(self) -> Field { 1 }
+}
+
+impl Foo<u64> {
+    fn foo(self) -> Field { 2 }
+}
+
+fn main() {
+    let f1: Foo<u32> = Foo{};
+    let f2: Foo<u64> = Foo{};
+    assert(f1.foo() + f2.foo() == 3);
+}
+```
+
+Also note that impls with the same method name defined in them cannot overlap. For example, if we already have `foo` defined for `Foo<u32>` and `Foo<u64>` like we do above, we cannot also define `foo` in an `impl<T> Foo<T>` since it would be ambiguous which version of `foo` to choose.
+
+```rust
+// Including this impl in the same project as the above snippet would
+// cause an overlapping impls error
+impl<T> Foo<T> {
+    fn foo(self) -> Field { 3 }
+}
+```
+
+## Lambdas
+
+Lambdas are anonymous functions. They follow the syntax of Rust - `|arg1, arg2, ..., argN| return_expression`.
+
+```rust
+let add_50 = |val| val + 50;
+assert(add_50(100) == 150);
+```
+
+See [Lambdas](./lambdas.md) for more details.
+
+## Attributes
+
+Attributes are metadata that can be applied to a function, using the following syntax: `#[attribute(value)]`.
+
+Supported attributes include:
+
+- **builtin**: the function is implemented by the compiler, for efficiency purposes.
+- **deprecated**: mark the function as _deprecated_. Calling the function will generate a warning: `warning: use of deprecated function`
+- **field**: Used to enable conditional compilation of code depending on the field size. See below for more details
+- **oracle**: mark the function as _oracle_; meaning it is an external unconstrained function, implemented in noir_js. See [Unconstrained](./unconstrained.md) and [NoirJS](../../reference/NoirJS/noir_js/index.md) for more details.
+- **test**: mark the function as unit tests. See [Tests](../../tooling/testing.md) for more details
+
+### Field Attribute
+
+The field attribute defines which field the function is compatible for. The function is conditionally compiled, under the condition that the field attribute matches the Noir native field.
+The field can be defined implicitly, by using the name of the elliptic curve usually associated to it - for instance bn254, bls12_381 - or explicitly by using the field (prime) order, in decimal or hexadecimal form.
+As a result, it is possible to define multiple versions of a function with each version specialized for a different field attribute. This can be useful when a function requires different parameters depending on the underlying elliptic curve.
+
+Example: we define the function `foo()` three times below. Once for the default Noir bn254 curve, once for the field $\mathbb F_{23}$, which will normally never be used by Noir, and once again for the bls12_381 curve.
+
+```rust
+#[field(bn254)]
+fn foo() -> u32 {
+    1
+}
+
+#[field(23)]
+fn foo() -> u32 {
+    2
+}
+
+// This commented code would not compile as foo would be defined twice because it is the same field as bn254
+// #[field(21888242871839275222246405745257275088548364400416034343698204186575808495617)]
+// fn foo() -> u32 {
+//     2
+// }
+
+#[field(bls12_381)]
+fn foo() -> u32 {
+    3
+}
+```
+
+If the field name is not known to Noir, it will discard the function. Field names are case insensitive.
diff --git a/docs/versioned_docs/version-v0.39.0/noir/concepts/generics.md b/docs/versioned_docs/version-v0.39.0/noir/concepts/generics.md
new file mode 100644
index 00000000000..c180a0ce7e6
--- /dev/null
+++ b/docs/versioned_docs/version-v0.39.0/noir/concepts/generics.md
@@ -0,0 +1,251 @@
+---
+title: Generics
+description: Learn how to use Generics in Noir
+keywords: [Noir, Rust, generics, functions, structs]
+sidebar_position: 7
+---
+
+Generics allow you to use the same functions with multiple different concrete data types. You can
+read more about the concept of generics in the Rust documentation
+[here](https://doc.rust-lang.org/book/ch10-01-syntax.html).
+
+Here is a trivial example showing the identity function that supports any type. In Rust, it is
+common to refer to the most general type as `T`. We follow the same convention in Noir.
+
+```rust
+fn id<T>(x: T) -> T  {
+    x
+}
+```
+
+## Numeric Generics
+
+If we want to be generic over array lengths (which are type-level integers), we can use numeric
+generics. Using these looks similar to using regular generics, but introducing them into scope
+requires declaring them with `let MyGenericName: IntegerType`. This can be done anywhere a normal
+generic is declared. Instead of types, these generics resolve to integers at compile-time.
+Here's an example of a struct that is generic over the size of the array it contains internally:
+
+```rust
+struct BigInt<let N: u32> {
+    limbs: [u32; N],
+}
+
+impl<let N: u32> BigInt<N> {
+    // `N` is in scope of all methods in the impl
+    fn first(first: BigInt<N>, second: BigInt<N>) -> Self {
+        assert(first.limbs != second.limbs);
+        first
+
+    fn second(first: BigInt<N>, second: Self) -> Self {
+        assert(first.limbs != second.limbs);
+        second
+    }
+}
+```
+
+## In Structs
+
+Generics are useful for specifying types in structs. For example, we can specify that a field in a
+struct will be of a certain generic type. In this case `value` is of type `T`.
+
+```rust
+struct RepeatedValue<T> {
+    value: T,
+    count: Field,
+}
+
+impl<T> RepeatedValue<T> {
+    fn print(self) {
+        for _i in 0 .. self.count {
+            println(self.value);
+        }
+    }
+}
+
+fn main() {
+    let repeated = RepeatedValue { value: "Hello!", count: 2 };
+    repeated.print();
+}
+```
+
+The `print` function will print `Hello!` an arbitrary number of times, twice in this case.
+
+## Calling functions on generic parameters
+
+Since a generic type `T` can represent any type, how can we call functions on the underlying type?
+In other words, how can we go from "any type `T`" to "any type `T` that has certain methods available?"
+
+This is what [traits](../concepts/traits.md) are for in Noir. Here's an example of a function generic over
+any type `T` that implements the `Eq` trait for equality:
+
+```rust
+fn first_element_is_equal<T, let N: u32>(array1: [T; N], array2: [T; N]) -> bool 
+    where T: Eq
+{
+    if (array1.len() == 0) | (array2.len() == 0) {
+        true
+    } else {
+        array1[0] == array2[0]
+    }
+}
+
+fn main() {
+    assert(first_element_is_equal([1, 2, 3], [1, 5, 6]));
+
+    // We can use first_element_is_equal for arrays of any type
+    // as long as we have an Eq impl for the types we pass in
+    let array = [MyStruct::new(), MyStruct::new()];
+    assert(array_eq(array, array, MyStruct::eq));
+}
+
+impl Eq for MyStruct {
+    fn eq(self, other: MyStruct) -> bool {
+        self.foo == other.foo
+    }
+}
+```
+
+You can find more details on traits and trait implementations on the [traits page](../concepts/traits.md).
+
+## Manually Specifying Generics with the Turbofish Operator
+
+There are times when the compiler cannot reasonably infer what type should be used for a generic, or when the developer themselves may want to manually distinguish generic type parameters. This is where the `::<>` turbofish operator comes into play.
+
+The `::<>` operator can follow a variable or path and can be used to manually specify generic arguments within the angle brackets.
+The name "turbofish" comes from that `::<>` looks like a little fish.
+
+Examples:
+```rust
+fn main() {
+    let mut slice = [];
+    slice = slice.push_back(1);
+    slice = slice.push_back(2);
+    // Without turbofish a type annotation would be needed on the left hand side
+    let array = slice.as_array::<2>();
+}
+```
+
+
+```rust
+trait MyTrait {
+    fn ten() -> Self;
+}
+
+impl MyTrait for Field {
+    fn ten() -> Self { 10 }
+}
+
+struct Foo<T> {
+    inner: T
+}
+        
+impl<T> Foo<T> {
+    fn generic_method<U>(_self: Self) -> U where U: MyTrait {
+        U::ten()
+    }
+}
+        
+fn example() {
+    let foo: Foo<Field> = Foo { inner: 1 };
+    // Using a type other than `Field` here (e.g. u32) would fail as 
+    // there is no matching impl for `u32: MyTrait`. 
+    //
+    // Substituting the `10` on the left hand side of this assert
+    // with `10 as u32` would also fail with a type mismatch as we 
+    // are expecting a `Field` from the right hand side.
+    assert(10 as u32 == foo.generic_method::<Field>());
+}
+```
+
+## Arithmetic Generics
+
+In addition to numeric generics, Noir also allows a limited form of arithmetic on generics.
+When you have a numeric generic such as `N`, you can use the following operators on it in a
+type position: `+`, `-`, `*`, `/`, and `%`.
+
+Note that type checking arithmetic generics is a best effort guess from the compiler and there
+are many cases of types that are equal that the compiler may not see as such. For example,
+we know that `T * (N + M)` should be equal to `T*N + T*M` but the compiler does not currently
+apply the distributive law and thus sees these as different types.
+
+Even with this limitation though, the compiler can handle common cases decently well:
+
+```rust
+trait Serialize<let N: u32> {
+    fn serialize(self) -> [Field; N];
+}
+
+impl Serialize<1> for Field {
+    fn serialize(self) -> [Field; 1] {
+        [self]
+    }
+}
+
+impl<T, let N: u32, let M: u32> Serialize<N * M> for [T; N]
+    where T: Serialize<M> { .. }
+
+impl<T, U, let N: u32, let M: u32> Serialize<N + M> for (T, U)
+    where T: Serialize<N>, U: Serialize<M> { .. }
+
+fn main() {
+    let data = (1, [2, 3, 4]);
+    assert_eq(data.serialize().len(), 4);
+}
+```
+
+Note that if there is any over or underflow the types will fail to unify:
+
+```rust title="underflow-example" showLineNumbers 
+fn pop<let N: u32>(array: [Field; N]) -> [Field; N - 1] {
+    let mut result: [Field; N - 1] = std::mem::zeroed();
+    for i in 0..N - 1 {
+        result[i] = array[i];
+    }
+    result
+}
+
+fn main() {
+    // error: Could not determine array length `(0 - 1)`
+    pop([]);
+}
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/test_programs/compile_failure/arithmetic_generics_underflow/src/main.nr#L1-L14" target="_blank" rel="noopener noreferrer">Source code: test_programs/compile_failure/arithmetic_generics_underflow/src/main.nr#L1-L14</a></sub></sup>
+
+
+This also applies if there is underflow in an intermediate calculation:
+
+```rust title="intermediate-underflow-example" showLineNumbers 
+fn main() {
+    // From main it looks like there's nothing sketchy going on
+    seems_fine([]);
+}
+
+// Since `seems_fine` says it can receive and return any length N
+fn seems_fine<let N: u32>(array: [Field; N]) -> [Field; N] {
+    // But inside `seems_fine` we pop from the array which
+    // requires the length to be greater than zero.
+
+    // error: Could not determine array length `(0 - 1)`
+    push_zero(pop(array))
+}
+
+fn pop<let N: u32>(array: [Field; N]) -> [Field; N - 1] {
+    let mut result: [Field; N - 1] = std::mem::zeroed();
+    for i in 0..N - 1 {
+        result[i] = array[i];
+    }
+    result
+}
+
+fn push_zero<let N: u32>(array: [Field; N]) -> [Field; N + 1] {
+    let mut result: [Field; N + 1] = std::mem::zeroed();
+    for i in 0..N {
+        result[i] = array[i];
+    }
+    // index N is already zeroed
+    result
+}
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/test_programs/compile_failure/arithmetic_generics_intermediate_underflow/src/main.nr#L1-L32" target="_blank" rel="noopener noreferrer">Source code: test_programs/compile_failure/arithmetic_generics_intermediate_underflow/src/main.nr#L1-L32</a></sub></sup>
+
diff --git a/docs/versioned_docs/version-v0.39.0/noir/concepts/globals.md b/docs/versioned_docs/version-v0.39.0/noir/concepts/globals.md
new file mode 100644
index 00000000000..6b8314399a2
--- /dev/null
+++ b/docs/versioned_docs/version-v0.39.0/noir/concepts/globals.md
@@ -0,0 +1,82 @@
+---
+title: Global Variables
+description:
+  Learn about global variables in Noir. Discover how
+  to declare, modify, and use them in your programs.
+keywords: [noir programming language, globals, global variables, constants]
+sidebar_position: 8
+---
+
+## Globals
+
+
+Noir supports global variables. The global's type can be inferred by the compiler entirely:
+
+```rust
+global N = 5; // Same as `global N: Field = 5`
+
+global TUPLE = (3, 2);
+
+fn main() {
+    assert(N == 5);
+    assert(N == TUPLE.0 + TUPLE.1);
+}
+```
+
+:::info
+
+Globals can be defined as any expression, so long as they don't depend on themselves - otherwise there would be a dependency cycle! For example:
+
+```rust
+global T = foo(T); // dependency error
+```
+
+:::
+
+
+If they are initialized to a literal integer, globals can be used to specify an array's length:
+
+```rust
+global N: u32 = 2;
+
+fn main(y : [Field; N]) {
+    assert(y[0] == y[1])
+}
+```
+
+A global from another module can be imported or referenced externally like any other name:
+
+```rust
+global N = 20;
+
+fn main() {
+    assert(my_submodule::N != N);
+}
+
+mod my_submodule {
+    global N: Field = 10;
+}
+```
+
+When a global is used, Noir replaces the name with its definition on each occurrence.
+This means globals defined using function calls will repeat the call each time they're used:
+
+```rust
+global RESULT = foo();
+
+fn foo() -> [Field; 100] { ... }
+```
+
+This is usually fine since Noir will generally optimize any function call that does not
+refer to a program input into a constant. It should be kept in mind however, if the called
+function performs side-effects like `println`, as these will still occur on each use.
+
+### Visibility
+
+By default, like functions, globals are private to the module they exist in. You can use `pub`
+to make the global public or `pub(crate)` to make it public to just its crate:
+
+```rust
+// This global is now public
+pub global N = 5;
+```
\ No newline at end of file
diff --git a/docs/versioned_docs/version-v0.39.0/noir/concepts/lambdas.md b/docs/versioned_docs/version-v0.39.0/noir/concepts/lambdas.md
new file mode 100644
index 00000000000..be3c7e0b5ca
--- /dev/null
+++ b/docs/versioned_docs/version-v0.39.0/noir/concepts/lambdas.md
@@ -0,0 +1,81 @@
+---
+title: Lambdas
+description: Learn how to use anonymous functions in Noir programming language.
+keywords: [Noir programming language, lambda, closure, function, anonymous function]
+sidebar_position: 9
+---
+
+## Introduction
+
+Lambdas are anonymous functions. The syntax is `|arg1, arg2, ..., argN| return_expression`.
+
+```rust
+let add_50 = |val| val + 50;
+assert(add_50(100) == 150);
+```
+
+A block can be used as the body of a lambda, allowing you to declare local variables inside it:
+
+```rust
+let cool = || {
+  let x = 100;
+  let y = 100;
+  x + y
+}
+
+assert(cool() == 200);
+```
+
+## Closures
+
+Inside the body of a lambda, you can use variables defined in the enclosing function. Such lambdas are called **closures**. In this example `x` is defined inside `main` and is accessed from within the lambda:
+
+```rust
+fn main() {
+  let x = 100;
+  let closure = || x + 150;
+  assert(closure() == 250);
+}
+```
+
+## Passing closures to higher-order functions
+
+It may catch you by surprise that the following code fails to compile:
+
+```rust
+fn foo(f: fn () -> Field) -> Field {
+ f()
+}
+
+fn main() {
+  let (x, y) = (50, 50);
+  assert(foo(|| x + y) == 100); // error :(
+}
+```
+
+The reason is that the closure's capture environment affects its type - we have a closure that captures two Fields and `foo`
+expects a regular function as an argument - those are incompatible.
+:::note
+
+Variables contained within the `||` are the closure's parameters, and the expression that follows it is the closure's body. The capture environment is comprised of any variables used in the closure's body that are not parameters.
+
+E.g. in |x| x + y, y would be a captured variable, but x would not be, since it is a parameter of the closure.
+
+:::
+The syntax for the type of a closure is `fn[env](args) -> ret_type`, where `env` is the capture environment of the closure -
+in this example that's `(Field, Field)`.
+
+The best solution in our case is to make `foo` generic over the environment type of its parameter, so that it can be called
+with closures with any environment, as well as with regular functions:
+
+```rust
+fn foo<Env>(f: fn[Env]() -> Field) -> Field {
+ f()
+}
+
+fn main() {
+  let (x, y) = (50, 50);
+  assert(foo(|| x + y) == 100); // compiles fine
+  assert(foo(|| 60) == 60);     // compiles fine
+}
+```
diff --git a/docs/versioned_docs/version-v0.39.0/noir/concepts/mutability.md b/docs/versioned_docs/version-v0.39.0/noir/concepts/mutability.md
new file mode 100644
index 00000000000..fdeef6a87c5
--- /dev/null
+++ b/docs/versioned_docs/version-v0.39.0/noir/concepts/mutability.md
@@ -0,0 +1,121 @@
+---
+title: Mutability
+description:
+  Learn about mutable variables in Noir. Discover how
+  to declare, modify, and use them in your programs.
+keywords: [noir programming language, mutability in noir, mutable variables]
+sidebar_position: 8
+---
+
+Variables in noir can be declared mutable via the `mut` keyword. Mutable variables can be reassigned
+to via an assignment expression.
+
+```rust
+let x = 2;
+x = 3; // error: x must be mutable to be assigned to
+
+let mut y = 3;
+let y = 4; // OK
+```
+
+The `mut` modifier can also apply to patterns:
+
+```rust
+let (a, mut b) = (1, 2);
+a = 11; // error: a must be mutable to be assigned to
+b = 12; // OK
+
+let mut (c, d) = (3, 4);
+c = 13; // OK
+d = 14; // OK
+
+// etc.
+let MyStruct { x: mut y } = MyStruct { x: a };
+// y is now in scope
+```
+
+Note that mutability in noir is local and everything is passed by value, so if a called function
+mutates its parameters then the parent function will keep the old value of the parameters.
+
+```rust
+fn main() -> pub Field {
+    let x = 3;
+    helper(x);
+    x // x is still 3
+}
+
+fn helper(mut x: i32) {
+    x = 4;
+}
+```
+
+## Non-local mutability
+
+Non-local mutability can be achieved through the mutable reference type `&mut T`:
+
+```rust
+fn set_to_zero(x: &mut Field) {
+    *x = 0;
+}
+
+fn main() {
+    let mut y = 42;
+    set_to_zero(&mut y);
+    assert(*y == 0);
+}
+```
+
+When creating a mutable reference, the original variable being referred to (`y` in this
+example) must also be mutable. Since mutable references are a reference type, they must
+be explicitly dereferenced via `*` to retrieve the underlying value. Note that this yields
+a copy of the value, so mutating this copy will not change the original value behind the
+reference:
+
+```rust
+fn main() {
+    let mut x = 1;
+    let x_ref = &mut x;
+
+    let mut y = *x_ref;
+    let y_ref = &mut y;
+
+    x = 2;
+    *x_ref = 3;
+
+    y = 4;
+    *y_ref = 5;
+
+    assert(x == 3);
+    assert(*x_ref == 3);
+    assert(y == 5);
+    assert(*y_ref == 5);
+}
+```
+
+Note that types in Noir are actually deeply immutable so the copy that occurs when
+dereferencing is only a conceptual copy - no additional constraints will occur.
+
+Mutable references can also be stored within structs. Note that there is also
+no lifetime parameter on these unlike rust. This is because the allocated memory
+always lasts the entire program - as if it were an array of one element.
+
+```rust
+struct Foo {
+    x: &mut Field
+}
+
+impl Foo {
+    fn incr(mut self) {
+        *self.x += 1;
+    }
+}
+
+fn main() {
+    let foo = Foo { x: &mut 0 };
+    foo.incr();
+    assert(*foo.x == 1);
+}
+```
+
+In general, you should avoid non-local & shared mutability unless it is needed. Sticking
+to only local mutability will improve readability and potentially improve compiler optimizations as well.
diff --git a/docs/versioned_docs/version-v0.39.0/noir/concepts/ops.md b/docs/versioned_docs/version-v0.39.0/noir/concepts/ops.md
new file mode 100644
index 00000000000..c35c36c38a9
--- /dev/null
+++ b/docs/versioned_docs/version-v0.39.0/noir/concepts/ops.md
@@ -0,0 +1,98 @@
+---
+title: Logical Operations
+description:
+  Learn about the supported arithmetic and logical operations in the Noir programming language.
+  Discover how to perform operations on private input types, integers, and booleans.
+keywords:
+  [
+    Noir programming language,
+    supported operations,
+    arithmetic operations,
+    logical operations,
+    predicate operators,
+    bitwise operations,
+    short-circuiting,
+    backend,
+  ]
+sidebar_position: 3
+---
+
+# Operations
+
+## Table of Supported Operations
+
+| Operation |                          Description                           |                           Requirements |
+| :-------- | :------------------------------------------------------------: | -------------------------------------: |
+| +         |             Adds two private input types together              |            Types must be private input |
+| -         |           Subtracts two private input types together           |            Types must be private input |
+| \*        |          Multiplies two private input types together           |            Types must be private input |
+| /         |            Divides two private input types together            |            Types must be private input |
+| ^         |              XOR two private input types together              |                  Types must be integer |
+| &         |              AND two private input types together              |                  Types must be integer |
+| \|        |              OR two private input types together               |                  Types must be integer |
+| \<\<        |        Left shift an integer by another integer amount         | Types must be integer, shift must be u8 |
+| >>        |        Right shift an integer by another integer amount        | Types must be integer, shift must be u8 |
+| !         |                     Bitwise not of a value                     |        Type must be integer or boolean |
+| \<         |       returns a bool if one value is less than the other       | Upper bound must have a known bit size |
+| \<=        | returns a bool if one value is less than or equal to the other | Upper bound must have a known bit size |
+| >         |       returns a bool if one value is more than the other       | Upper bound must have a known bit size |
+| >=        | returns a bool if one value is more than or equal to the other | Upper bound must have a known bit size |
+| ==        |       returns a bool if one value is equal to the other        |       Both types must not be constants |
+| !=        |     returns a bool if one value is not equal to the other      |       Both types must not be constants |
+
+### Predicate Operators
+
+`<,<=, !=, == , >, >=` are known as predicate/comparison operations because they compare two values.
+This differs from the operations such as `+` where the operands are used in _computation_.
+
+### Bitwise Operations Example
+
+```rust
+fn main(x : Field) {
+    let y = x as u32;
+    let z = y & y;
+}
+```
+
+`z` is implicitly constrained to be the result of `y & y`. The `&` operand is used to denote bitwise
+`&`.
+
+> `x & x` would not compile as `x` is a `Field` and not an integer type.
+
+### Logical Operators
+
+Noir has no support for the logical operators `||` and `&&`. This is because encoding the
+short-circuiting that these operators require can be inefficient for Noir's backend. Instead you can
+use the bitwise operators `|` and `&` which operate identically for booleans, just without the
+short-circuiting.
+
+```rust
+let my_val = 5;
+
+let mut flag = 1;
+if (my_val > 6) | (my_val == 0) {
+    flag = 0;
+}
+assert(flag == 1);
+
+if (my_val != 10) & (my_val < 50) {
+    flag = 0;
+}
+assert(flag == 0);
+```
+
+### Shorthand operators
+
+Noir shorthand operators for most of the above operators, namely `+=, -=, *=, /=, %=, &=, |=, ^=, <<=`, and `>>=`. These allow for more concise syntax. For example:
+
+```rust
+let mut i = 0;
+i = i + 1;
+```
+
+could be written as:
+
+```rust
+let mut i = 0;
+i += 1;
+```
diff --git a/docs/versioned_docs/version-v0.39.0/noir/concepts/oracles.mdx b/docs/versioned_docs/version-v0.39.0/noir/concepts/oracles.mdx
new file mode 100644
index 00000000000..77a2ac1550a
--- /dev/null
+++ b/docs/versioned_docs/version-v0.39.0/noir/concepts/oracles.mdx
@@ -0,0 +1,29 @@
+---
+title: Oracles
+description: Dive into how Noir supports Oracles via RPC calls, and learn how to declare an Oracle in Noir with our comprehensive guide.
+keywords:
+  - Noir
+  - Oracles
+  - RPC Calls
+  - Unconstrained Functions
+  - Programming
+  - Blockchain
+sidebar_position: 6
+---
+
+import Experimental from '@site/src/components/Notes/_experimental.mdx';
+
+<Experimental />
+
+Noir has support for Oracles via RPC calls. This means Noir will make an RPC call and use the return value for proof generation.
+
+Since Oracles are not resolved by Noir, they are [`unconstrained` functions](./unconstrained.md)
+
+You can declare an Oracle through the `#[oracle(<name>)]` flag. Example:
+
+```rust
+#[oracle(get_number_sequence)]
+unconstrained fn get_number_sequence(_size: Field) -> [Field] {}
+```
+
+The timeout for when using an external RPC oracle resolver can be set with the `NARGO_FOREIGN_CALL_TIMEOUT` environment variable. This timeout is in units of milliseconds.
diff --git a/docs/versioned_docs/version-v0.39.0/noir/concepts/shadowing.md b/docs/versioned_docs/version-v0.39.0/noir/concepts/shadowing.md
new file mode 100644
index 00000000000..5ce6130d201
--- /dev/null
+++ b/docs/versioned_docs/version-v0.39.0/noir/concepts/shadowing.md
@@ -0,0 +1,44 @@
+---
+title: Shadowing
+sidebar_position: 12
+---
+
+Noir allows for inheriting variables' values and re-declaring them with the same name similar to Rust, known as shadowing.
+
+For example, the following function is valid in Noir:
+
+```rust
+fn main() {
+    let x = 5;
+
+    {
+        let x = x * 2;
+        assert (x == 10);
+    }
+
+    assert (x == 5);
+}
+```
+
+In this example, a variable x is first defined with the value 5.
+
+The local scope that follows shadows the original x, i.e. creates a local mutable x based on the value of the original x. It is given a value of 2 times the original x.
+
+When we return to the main scope, x once again refers to just the original x, which stays at the value of 5.
+
+## Temporal mutability
+
+One way that shadowing is useful, in addition to ergonomics across scopes, is for temporarily mutating variables.
+
+```rust
+fn main() {
+    let age = 30;
+    // age = age + 5; // Would error as `age` is immutable by default.
+
+    let mut age = age + 5; // Temporarily mutates `age` with a new value.
+
+    let age = age; // Locks `age`'s mutability again.
+
+    assert (age == 35);
+}
+```
diff --git a/docs/versioned_docs/version-v0.39.0/noir/concepts/traits.md b/docs/versioned_docs/version-v0.39.0/noir/concepts/traits.md
new file mode 100644
index 00000000000..9da00a77587
--- /dev/null
+++ b/docs/versioned_docs/version-v0.39.0/noir/concepts/traits.md
@@ -0,0 +1,501 @@
+---
+title: Traits
+description:
+  Traits in Noir can be used to abstract out a common interface for functions across
+  several data types.
+keywords: [noir programming language, traits, interfaces, generic, protocol]
+sidebar_position: 14
+---
+
+## Overview
+
+Traits in Noir are a useful abstraction similar to interfaces or protocols in other languages. Each trait defines
+the interface of several methods contained within the trait. Types can then implement this trait by providing
+implementations for these methods. For example in the program:
+
+```rust
+struct Rectangle {
+    width: Field,
+    height: Field,
+}
+
+impl Rectangle {
+    fn area(self) -> Field {
+        self.width * self.height
+    }
+}
+
+fn log_area(r: Rectangle) {
+    println(r.area());
+}
+```
+
+We have a function `log_area` to log the area of a `Rectangle`. Now how should we change the program if we want this
+function to work on `Triangle`s as well?:
+
+```rust
+struct Triangle {
+    width: Field,
+    height: Field,
+}
+
+impl Triangle {
+    fn area(self) -> Field {
+        self.width * self.height / 2
+    }
+}
+```
+
+Making `log_area` generic over all types `T` would be invalid since not all types have an `area` method. Instead, we can
+introduce a new `Area` trait and make `log_area` generic over all types `T` that implement `Area`:
+
+```rust
+trait Area {
+    fn area(self) -> Field;
+}
+
+fn log_area<T>(shape: T) where T: Area {
+    println(shape.area());
+}
+```
+
+We also need to explicitly implement `Area` for `Rectangle` and `Triangle`. We can do that by changing their existing
+impls slightly. Note that the parameter types and return type of each of our `area` methods must match those defined
+by the `Area` trait.
+
+```rust
+impl Area for Rectangle {
+    fn area(self) -> Field {
+        self.width * self.height
+    }
+}
+
+impl Area for Triangle {
+    fn area(self) -> Field {
+        self.width * self.height / 2
+    }
+}
+```
+
+Now we have a working program that is generic over any type of Shape that is used! Others can even use this program
+as a library with their own types - such as `Circle` - as long as they also implement `Area` for these types.
+
+## Where Clauses
+
+As seen in `log_area` above, when we want to create a function or method that is generic over any type that implements
+a trait, we can add a where clause to the generic function.
+
+```rust
+fn log_area<T>(shape: T) where T: Area {
+    println(shape.area());
+}
+```
+
+It is also possible to apply multiple trait constraints on the same variable at once by combining traits with the `+`
+operator. Similarly, we can have multiple trait constraints by separating each with a comma:
+
+```rust
+fn foo<T, U>(elements: [T], thing: U) where
+    T: Default + Add + Eq,
+    U: Bar,
+{
+    let mut sum = T::default();
+
+    for element in elements {
+        sum += element;
+    }
+
+    if sum == T::default() {
+        thing.bar();
+    }
+}
+```
+
+## Generic Implementations
+
+You can add generics to a trait implementation by adding the generic list after the `impl` keyword:
+
+```rust
+trait Second {
+    fn second(self) -> Field;
+}
+
+impl<T> Second for (T, Field) {
+    fn second(self) -> Field {
+        self.1
+    }
+}
+```
+
+You can also implement a trait for every type this way:
+
+```rust
+trait Debug {
+    fn debug(self);
+}
+
+impl<T> Debug for T {
+    fn debug(self) {
+        println(self);
+    }
+}
+
+fn main() {
+    1.debug();
+}
+```
+
+### Generic Trait Implementations With Where Clauses
+
+Where clauses can be placed on trait implementations themselves to restrict generics in a similar way.
+For example, while `impl<T> Foo for T` implements the trait `Foo` for every type, `impl<T> Foo for T where T: Bar`
+will implement `Foo` only for types that also implement `Bar`. This is often used for implementing generic types.
+For example, here is the implementation for array equality:
+
+```rust
+impl<T, let N: u32> Eq for [T; let N: u32] where T: Eq {
+    // Test if two arrays have the same elements.
+    // Because both arrays must have length N, we know their lengths already match.
+    fn eq(self, other: Self) -> bool {
+        let mut result = true;
+
+        for i in 0 .. self.len() {
+            // The T: Eq constraint is needed to call == on the array elements here
+            result &= self[i] == other[i];
+        }
+
+        result
+    }
+}
+```
+
+Where clauses can also be placed on struct implementations. 
+For example, here is a method utilizing a generic type that implements the equality trait.
+
+```rust
+struct Foo<T> {
+    a: u32,
+    b: T,
+}
+
+impl<T> Foo<T> where T: Eq {
+    fn eq(self, other: Self) -> bool {
+        (self.a == other.a) & self.b.eq(other.b)
+    }
+}
+```
+
+## Generic Traits
+
+Traits themselves can also be generic by placing the generic arguments after the trait name. These generics are in
+scope of every item within the trait.
+
+```rust
+trait Into<T> {
+    // Convert `self` to type `T`
+    fn into(self) -> T;
+}
+```
+
+When implementing generic traits the generic arguments of the trait must be specified. This is also true anytime
+when referencing a generic trait (e.g. in a `where` clause).
+
+```rust
+struct MyStruct {
+    array: [Field; 2],
+}
+
+impl Into<[Field; 2]> for MyStruct {
+    fn into(self) -> [Field; 2] {
+        self.array
+    }
+}
+
+fn as_array<T>(x: T) -> [Field; 2] 
+    where T: Into<[Field; 2]>
+{
+    x.into()
+}
+
+fn main() {
+    let array = [1, 2];
+    let my_struct = MyStruct { array };
+
+    assert_eq(as_array(my_struct), array);
+}
+```
+
+### Associated Types and Constants
+
+Traits also support associated types and constraints which can be thought of as additional generics that are referred to by name.
+
+Here's an example of a trait with an associated type `Foo` and a constant `Bar`:
+
+```rust
+trait MyTrait {
+    type Foo;
+
+    let Bar: u32;
+}
+```
+
+Now when we're implementing `MyTrait` we also have to provide values for `Foo` and `Bar`:
+
+```rust
+impl MyTrait for Field {
+    type Foo = i32;
+
+    let Bar: u32 = 11;
+}
+```
+
+Since associated constants can also be used in a type position, its values are limited to only other
+expression kinds allowed in numeric generics.
+
+Note that currently all associated types and constants must be explicitly specified in a trait constraint.
+If we leave out any, we'll get an error that we're missing one:
+
+```rust
+// Error! Constraint is missing associated constant for `Bar`
+fn foo<T>(x: T) where T: MyTrait<Foo = i32> {
+    ...
+}
+```
+
+Because all associated types and constants must be explicitly specified, they are essentially named generics,
+although this is set to change in the future. Future versions of Noir will allow users to elide associated types
+in trait constraints similar to Rust. When this is done, you may still refer to their value with the `<Type as Trait>::AssociatedType`
+syntax:
+
+```rust
+// Only valid in future versions of Noir:
+fn foo<T>(x: T) where T: MyTrait {
+    let _: <T as MyTrait>::Foo = ...;
+}
+```
+
+The type as trait syntax is possible in Noir today but is less useful when each type must be explicitly specified anyway:
+
+```rust
+fn foo<T, F, let B: u32>(x: T) where T: MyTrait<Foo = F, Bar = B> {
+    // Works, but could just use F directly
+    let _: <T as MyTrait<Foo = F, Bar = B>>::Foo = ...;
+
+    let _: F = ...;
+}
+```
+
+## Trait Methods With No `self`
+
+A trait can contain any number of methods, each of which have access to the `Self` type which represents each type
+that eventually implements the trait. Similarly, the `self` variable is available as well but is not required to be used.
+For example, we can define a trait to create a default value for a type. This trait will need to return the `Self` type
+but doesn't need to take any parameters:
+
+```rust
+trait Default {
+    fn default() -> Self;
+}
+```
+
+Implementing this trait can be done similarly to any other trait:
+
+```rust
+impl Default for Field {
+    fn default() -> Field {
+        0
+    }
+}
+
+struct MyType {}
+
+impl Default for MyType {
+    fn default() -> Field {
+        MyType {}
+    }
+}
+```
+
+However, since there is no `self` parameter, we cannot call it via the method call syntax `object.method()`.
+Instead, we'll need to refer to the function directly. This can be done either by referring to the
+specific impl `MyType::default()` or referring to the trait itself `Default::default()`. In the later
+case, type inference determines the impl that is selected.
+
+```rust
+let my_struct = MyStruct::default();
+
+let x: Field = Default::default();
+let result = x + Default::default();
+```
+
+:::warning
+
+```rust
+let _ = Default::default();
+```
+
+If type inference cannot select which impl to use because of an ambiguous `Self` type, an impl will be
+arbitrarily selected. This occurs most often when the result of a trait function call with no parameters
+is unused. To avoid this, when calling a trait function with no `self` or `Self` parameters or return type,
+always refer to it via the implementation type's namespace - e.g. `MyType::default()`.
+This is set to change to an error in future Noir versions.
+
+:::
+
+## Default Method Implementations
+
+A trait can also have default implementations of its methods by giving a body to the desired functions.
+Note that this body must be valid for all types that may implement the trait. As a result, the only
+valid operations on `self` will be operations valid for any type or other operations on the trait itself.
+
+```rust
+trait Numeric {
+    fn add(self, other: Self) -> Self;
+
+    // Default implementation of double is (self + self)
+    fn double(self) -> Self {
+        self.add(self)
+    }
+}
+```
+
+When implementing a trait with default functions, a type may choose to implement only the required functions:
+
+```rust
+impl Numeric for Field {
+    fn add(self, other: Field) -> Field {
+        self + other
+    }
+}
+```
+
+Or it may implement the optional methods as well:
+
+```rust
+impl Numeric for u32 {
+    fn add(self, other: u32) -> u32 {
+        self + other
+    }
+
+    fn double(self) -> u32 {
+        self * 2
+    }
+}
+```
+
+## Impl Specialization
+
+When implementing traits for a generic type it is possible to implement the trait for only a certain combination
+of generics. This can be either as an optimization or because those specific generics are required to implement the trait.
+
+```rust
+trait Sub {
+    fn sub(self, other: Self) -> Self;
+}
+
+struct NonZero<T> {
+    value: T,
+}
+
+impl Sub for NonZero<Field> {
+    fn sub(self, other: Self) -> Self {
+        let value = self.value - other.value;
+        assert(value != 0);
+        NonZero { value }
+    }
+}
+```
+
+## Overlapping Implementations
+
+Overlapping implementations are disallowed by Noir to ensure Noir's decision on which impl to select is never ambiguous.
+This means if a trait `Foo` is already implemented
+by a type `Bar<T>` for all `T`, then we cannot also have a separate impl for `Bar<Field>` (or any other
+type argument). Similarly, if there is an impl for all `T` such as `impl<T> Debug for T`, we cannot create
+any more impls to `Debug` for other types since it would be ambiguous which impl to choose for any given
+method call.
+
+```rust
+trait Trait {}
+
+// Previous impl defined here
+impl<A, B> Trait for (A, B) {}
+
+// error: Impl for type `(Field, Field)` overlaps with existing impl
+impl Trait for (Field, Field) {}
+```
+
+## Trait Coherence
+
+Another restriction on trait implementations is coherence. This restriction ensures other crates cannot create
+impls that may overlap with other impls, even if several unrelated crates are used as dependencies in the same
+program.
+
+The coherence restriction is: to implement a trait, either the trait itself or the object type must be declared
+in the crate the impl is in.
+
+In practice this often comes up when using types provided by libraries. If a library provides a type `Foo` that does
+not implement a trait in the standard library such as `Default`, you may not `impl Default for Foo` in your own crate.
+While restrictive, this prevents later issues or silent changes in the program if the `Foo` library later added its
+own impl for `Default`. If you are a user of the `Foo` library in this scenario and need a trait not implemented by the
+library your choices are to either submit a patch to the library or use the newtype pattern.
+
+### The Newtype Pattern
+
+The newtype pattern gets around the coherence restriction by creating a new wrapper type around the library type
+that we cannot create `impl`s for. Since the new wrapper type is defined in our current crate, we can create
+impls for any trait we need on it.
+
+```rust
+struct Wrapper {
+    foo: some_library::Foo,
+}
+
+impl Default for Wrapper {
+    fn default() -> Wrapper {
+        Wrapper {
+            foo: some_library::Foo::new(),
+        }
+    }
+}
+```
+
+Since we have an impl for our own type, the behavior of this code will not change even if `some_library` is updated
+to provide its own `impl Default for Foo`. The downside of this pattern is that it requires extra wrapping and
+unwrapping of values when converting to and from the `Wrapper` and `Foo` types.
+
+### Trait Inheritance
+
+Sometimes, you might need one trait to use another trait’s functionality (like "inheritance" in some other languages). In this case, you can specify this relationship by listing any child traits after the parent trait's name and a colon. Now, whenever the parent trait is implemented it will require the child traits to be implemented as well. A parent trait is also called a "super trait."
+
+```rust
+trait Person {
+    fn name(self) -> String;
+}
+
+// Person is a supertrait of Student.
+// Implementing Student requires you to also impl Person.
+trait Student: Person {
+    fn university(self) -> String;
+}
+
+trait Programmer {
+    fn fav_language(self) -> String;
+}
+
+// CompSciStudent (computer science student) is a subtrait of both Programmer 
+// and Student. Implementing CompSciStudent requires you to impl both supertraits.
+trait CompSciStudent: Programmer + Student {
+    fn git_username(self) -> String;
+}
+```
+
+### Visibility
+
+By default, like functions, traits are private to the module they exist in. You can use `pub`
+to make the trait public or `pub(crate)` to make it public to just its crate:
+
+```rust
+// This trait is now public
+pub trait Trait {}
+```
\ No newline at end of file
diff --git a/docs/versioned_docs/version-v0.39.0/noir/concepts/unconstrained.md b/docs/versioned_docs/version-v0.39.0/noir/concepts/unconstrained.md
new file mode 100644
index 00000000000..b5221b8d2dd
--- /dev/null
+++ b/docs/versioned_docs/version-v0.39.0/noir/concepts/unconstrained.md
@@ -0,0 +1,104 @@
+---
+title: Unconstrained Functions
+description: "Learn about what unconstrained functions in Noir are, how to use them and when you'd want to."
+
+keywords: [Noir programming language, unconstrained, open]
+sidebar_position: 5
+---
+
+Unconstrained functions are functions which do not constrain any of the included computation and allow for non-deterministic computation.
+
+## Why?
+
+Zero-knowledge (ZK) domain-specific languages (DSL) enable developers to generate ZK proofs from their programs by compiling code down to the constraints of an NP complete language (such as R1CS or PLONKish languages). However, the hard bounds of a constraint system can be very limiting to the functionality of a ZK DSL.
+
+Enabling a circuit language to perform unconstrained execution is a powerful tool. Said another way, unconstrained execution lets developers generate witnesses from code that does not generate any constraints. Being able to execute logic outside of a circuit is critical for both circuit performance and constructing proofs on information that is external to a circuit.
+
+Fetching information from somewhere external to a circuit can also be used to enable developers to improve circuit efficiency.
+
+A ZK DSL does not just prove computation, but proves that some computation was handled correctly. Thus, it is necessary that when we switch from performing some operation directly inside of a circuit to inside of an unconstrained environment that the appropriate constraints are still laid down elsewhere in the circuit.
+
+## Example
+
+An in depth example might help drive the point home. This example comes from the excellent [post](https://discord.com/channels/1113924620781883405/1124022445054111926/1128747641853972590) by Tom in the Noir Discord.
+
+Let's look at how we can optimize a function to turn a `u72` into an array of `u8`s.
+
+```rust
+fn main(num: u72) -> pub [u8; 8] {
+    let mut out: [u8; 8] = [0; 8];
+    for i in 0..8 {
+        out[i] = (num >> (56 - (i * 8)) as u72 & 0xff) as u8;
+    }
+
+    out
+}
+```
+
+```
+Total ACIR opcodes generated for language PLONKCSat { width: 3 }: 91
+Backend circuit size: 3619
+```
+
+A lot of the operations in this function are optimized away by the compiler (all the bit-shifts turn into divisions by constants). However we can save a bunch of gates by casting to u8 a bit earlier. This automatically truncates the bit-shifted value to fit in a u8 which allows us to remove the AND against 0xff. This saves us ~480 gates in total.
+
+```rust
+fn main(num: u72) -> pub [u8; 8] {
+    let mut out: [u8; 8] = [0; 8];
+    for i in 0..8 {
+        out[i] = (num >> (56 - (i * 8)) as u8;
+    }
+
+    out
+}
+```
+
+```
+Total ACIR opcodes generated for language PLONKCSat { width: 3 }: 75
+Backend circuit size: 3143
+```
+
+Those are some nice savings already but we can do better. This code is all constrained so we're proving every step of calculating out using num, but we don't actually care about how we calculate this, just that it's correct. This is where brillig comes in.
+
+It turns out that truncating a u72 into a u8 is hard to do inside a snark, each time we do as u8 we lay down 4 ACIR opcodes which get converted into multiple gates. It's actually much easier to calculate num from out than the other way around. All we need to do is multiply each element of out by a constant and add them all together, both relatively easy operations inside a snark.
+
+We can then run `u72_to_u8` as unconstrained brillig code in order to calculate out, then use that result in our constrained function and assert that if we were to do the reverse calculation we'd get back num. This looks a little like the below:
+
+```rust
+fn main(num: u72) -> pub [u8; 8] {
+    let out = unsafe { 
+        u72_to_u8(num) 
+    };
+
+    let mut reconstructed_num: u72 = 0;
+    for i in 0..8 {
+        reconstructed_num += (out[i] as u72 << (56 - (8 * i)));
+    }
+    assert(num == reconstructed_num);
+    out
+}
+
+unconstrained fn u72_to_u8(num: u72) -> [u8; 8] {
+    let mut out: [u8; 8] = [0; 8];
+    for i in 0..8 {
+        out[i] = (num >> (56 - (i * 8))) as u8;
+    }
+    out
+}
+```
+
+```
+Total ACIR opcodes generated for language PLONKCSat { width: 3 }: 78
+Backend circuit size: 2902
+```
+
+This ends up taking off another ~250 gates from our circuit! We've ended up with more ACIR opcodes than before but they're easier for the backend to prove (resulting in fewer gates).
+
+Note that in order to invoke unconstrained functions we need to wrap them in an `unsafe` block,
+to make it clear that the call is unconstrained.
+
+Generally we want to use brillig whenever there's something that's easy to verify but hard to compute within the circuit. For example, if you wanted to calculate a square root of a number it'll be a much better idea to calculate this in brillig and then assert that if you square the result you get back your number.
+
+## Break and Continue
+
+In addition to loops over runtime bounds, `break` and `continue` are also available in unconstrained code. See [break and continue](../concepts/control_flow.md#break-and-continue)
diff --git a/docs/versioned_docs/version-v0.39.0/noir/modules_packages_crates/_category_.json b/docs/versioned_docs/version-v0.39.0/noir/modules_packages_crates/_category_.json
new file mode 100644
index 00000000000..1debcfe7675
--- /dev/null
+++ b/docs/versioned_docs/version-v0.39.0/noir/modules_packages_crates/_category_.json
@@ -0,0 +1,6 @@
+{
+    "label": "Modules, Packages and Crates",
+    "position": 2,
+    "collapsible": true,
+    "collapsed": true
+}
diff --git a/docs/versioned_docs/version-v0.39.0/noir/modules_packages_crates/crates_and_packages.md b/docs/versioned_docs/version-v0.39.0/noir/modules_packages_crates/crates_and_packages.md
new file mode 100644
index 00000000000..95ee9f52ab2
--- /dev/null
+++ b/docs/versioned_docs/version-v0.39.0/noir/modules_packages_crates/crates_and_packages.md
@@ -0,0 +1,43 @@
+---
+title: Crates and Packages
+description: Learn how to use Crates and Packages in your Noir project
+keywords: [Nargo, dependencies, package management, crates, package]
+sidebar_position: 0
+---
+
+## Crates
+
+A crate is the smallest amount of code that the Noir compiler considers at a time.
+Crates can contain modules, and the modules may be defined in other files that get compiled with the crate, as we’ll see in the coming sections.
+
+### Crate Types
+
+A Noir crate can come in several forms: binaries, libraries or contracts.
+
+#### Binaries
+
+_Binary crates_ are programs which you can compile to an ACIR circuit which you can then create proofs against. Each must have a function called `main` that defines the ACIR circuit which is to be proved.
+
+#### Libraries
+
+_Library crates_ don't have a `main` function and they don't compile down to ACIR. Instead they define functionality intended to be shared with multiple projects, and eventually included in a binary crate.
+
+#### Contracts
+
+Contract crates are similar to binary crates in that they compile to ACIR which you can create proofs against. They are different in that they do not have a single `main` function, but are a collection of functions to be deployed to the [Aztec network](https://aztec.network). You can learn more about the technical details of Aztec in the [monorepo](https://github.com/AztecProtocol/aztec-packages) or contract [examples](https://github.com/AztecProtocol/aztec-packages/tree/master/noir-projects/noir-contracts/contracts).
+
+### Crate Root
+
+Every crate has a root, which is the source file that the compiler starts, this is also known as the root module. The Noir compiler does not enforce any conditions on the name of the file which is the crate root, however if you are compiling via Nargo the crate root must be called `lib.nr` or `main.nr` for library or binary crates respectively.
+
+## Packages
+
+A Nargo _package_ is a collection of one of more crates that provides a set of functionality. A package must include a Nargo.toml file.
+
+A package _must_ contain either a library or a binary crate, but not both.
+
+### Differences from Cargo Packages
+
+One notable difference between Rust's Cargo and Noir's Nargo is that while Cargo allows a package to contain an unlimited number of binary crates and a single library crate, Nargo currently only allows a package to contain a single crate.
+
+In future this restriction may be lifted to allow a Nargo package to contain both a binary and library crate or multiple binary crates.
diff --git a/docs/versioned_docs/version-v0.39.0/noir/modules_packages_crates/dependencies.md b/docs/versioned_docs/version-v0.39.0/noir/modules_packages_crates/dependencies.md
new file mode 100644
index 00000000000..24e02de08fe
--- /dev/null
+++ b/docs/versioned_docs/version-v0.39.0/noir/modules_packages_crates/dependencies.md
@@ -0,0 +1,124 @@
+---
+title: Dependencies
+description:
+  Learn how to specify and manage dependencies in Nargo, allowing you to upload packages to GitHub
+  and use them easily in your project.
+keywords: [Nargo, dependencies, GitHub, package management, versioning]
+sidebar_position: 1
+---
+
+Nargo allows you to upload packages to GitHub and use them as dependencies.
+
+## Specifying a dependency
+
+Specifying a dependency requires a tag to a specific commit and the git url to the url containing
+the package.
+
+Currently, there are no requirements on the tag contents. If requirements are added, it would follow
+semver 2.0 guidelines.
+
+> Note: Without a `tag` , there would be no versioning and dependencies would change each time you
+> compile your project.
+
+For example, to add the [ecrecover-noir library](https://github.com/colinnielsen/ecrecover-noir) to your project, add it to `Nargo.toml`:
+
+```toml
+# Nargo.toml
+
+[dependencies]
+ecrecover = {tag = "v0.8.0", git = "https://github.com/colinnielsen/ecrecover-noir"}
+```
+
+If the module is in a subdirectory, you can define a subdirectory in your git repository, for example:
+
+```toml
+# Nargo.toml
+
+[dependencies]
+easy_private_token_contract = {tag ="v0.1.0-alpha62", git = "https://github.com/AztecProtocol/aztec-packages", directory = "noir-contracts/contracts/easy_private_token_contract"}
+```
+
+## Specifying a local dependency
+
+You can also specify dependencies that are local to your machine.
+
+For example, this file structure has a library and binary crate
+
+```tree
+├── binary_crate
+│   ├── Nargo.toml
+│   └── src
+│       └── main.nr
+└── lib_a
+    ├── Nargo.toml
+    └── src
+        └── lib.nr
+```
+
+Inside of the binary crate, you can specify:
+
+```toml
+# Nargo.toml
+
+[dependencies]
+lib_a = { path = "../lib_a" }
+```
+
+## Importing dependencies
+
+You can import a dependency to a Noir file using the following syntax. For example, to import the
+ecrecover-noir library and local lib_a referenced above:
+
+```rust
+use ecrecover;
+use lib_a;
+```
+
+You can also import only the specific parts of dependency that you want to use, like so:
+
+```rust
+use std::hash::sha256;
+use std::scalar_mul::fixed_base_embedded_curve;
+```
+
+Lastly, as demonstrated in the
+[elliptic curve example](../standard_library/cryptographic_primitives/ec_primitives.md#examples), you
+can import multiple items in the same line by enclosing them in curly braces:
+
+```rust
+use std::ec::tecurve::affine::{Curve, Point};
+```
+
+We don't have a way to consume libraries from inside a [workspace](./workspaces.md) as external dependencies right now.
+
+Inside a workspace, these are consumed as `{ path = "../to_lib" }` dependencies in Nargo.toml.
+
+## Dependencies of Dependencies
+
+Note that when you import a dependency, you also get access to all of the dependencies of that package.
+
+For example, the [phy_vector](https://github.com/resurgencelabs/phy_vector) library imports an [fraction](https://github.com/resurgencelabs/fraction) library. If you're importing the phy_vector library, then you can access the functions in fractions library like so:
+
+```rust
+use phy_vector;
+
+fn main(x : Field, y : pub Field) {
+  //...
+  let f = phy_vector::fraction::toFraction(true, 2, 1);
+  //...
+}
+```
+
+## Available Libraries
+
+Noir does not currently have an official package manager. You can find a list of available Noir libraries in the [awesome-noir repo here](https://github.com/noir-lang/awesome-noir#libraries).
+
+Some libraries that are available today include:
+
+- [Standard Library](https://github.com/noir-lang/noir/tree/master/noir_stdlib) - the Noir Standard Library
+- [Ethereum Storage Proof Verification](https://github.com/aragonzkresearch/noir-trie-proofs) - a library that contains the primitives necessary for RLP decoding (in the form of look-up table construction) and Ethereum state and storage proof verification (or verification of any trie proof involving 32-byte long keys)
+- [BigInt](https://github.com/shuklaayush/noir-bigint) - a library that provides a custom BigUint56 data type, allowing for computations on large unsigned integers
+- [ECrecover](https://github.com/colinnielsen/ecrecover-noir/tree/main) - a library to verify an ECDSA signature and return the source Ethereum address
+- [Sparse Merkle Tree Verifier](https://github.com/vocdoni/smtverifier-noir/tree/main) - a library for verification of sparse Merkle trees
+- [Signed Int](https://github.com/resurgencelabs/signed_int) - a library for accessing a custom Signed Integer data type, allowing access to negative numbers on Noir
+- [Fraction](https://github.com/resurgencelabs/fraction) - a library for accessing fractional number data type in Noir, allowing results that aren't whole numbers
diff --git a/docs/versioned_docs/version-v0.39.0/noir/modules_packages_crates/modules.md b/docs/versioned_docs/version-v0.39.0/noir/modules_packages_crates/modules.md
new file mode 100644
index 00000000000..14aa1f0579a
--- /dev/null
+++ b/docs/versioned_docs/version-v0.39.0/noir/modules_packages_crates/modules.md
@@ -0,0 +1,221 @@
+---
+title: Modules
+description:
+  Learn how to organize your files using modules in Noir, following the same convention as Rust's
+  module system. Examples included.
+keywords: [Noir, Rust, modules, organizing files, sub-modules]
+sidebar_position: 2
+---
+
+Noir's module system follows the same convention as the _newer_ version of Rust's module system.
+
+## Purpose of Modules
+
+Modules are used to organize files. Without modules all of your code would need to live in a single
+file. In Noir, the compiler does not automatically scan all of your files to detect modules. This
+must be done explicitly by the developer.
+
+## Examples
+
+### Importing a module in the crate root
+
+Filename : `src/main.nr`
+
+```rust
+mod foo;
+
+fn main() {
+    foo::hello_world();
+}
+```
+
+Filename : `src/foo.nr`
+
+```rust
+fn from_foo() {}
+```
+
+In the above snippet, the crate root is the `src/main.nr` file. The compiler sees the module
+declaration `mod foo` which prompts it to look for a foo.nr file.
+
+Visually this module hierarchy looks like the following :
+
+```
+crate
+ ├── main
+ │
+ └── foo
+      └── from_foo
+
+```
+
+The module filename may also be the name of the module as a directory with the contents in a 
+file named `mod.nr` within that directory. The above example can alternatively be expressed like this:
+
+Filename : `src/main.nr`
+
+```rust
+mod foo;
+
+fn main() {
+    foo::hello_world();
+}
+```
+
+Filename : `src/foo/mod.nr`
+
+```rust
+fn from_foo() {}
+```
+
+Note that it's an error to have both files `src/foo.nr` and `src/foo/mod.nr` in the filesystem.
+
+### Importing a module throughout the tree
+
+All modules are accessible from the `crate::` namespace.
+
+```
+crate
+ ├── bar
+ ├── foo
+ └── main
+
+```
+
+In the above snippet, if `bar` would like to use functions in `foo`, it can do so by `use crate::foo::function_name`.
+
+### Sub-modules
+
+Filename : `src/main.nr`
+
+```rust
+mod foo;
+
+fn main() {
+    foo::from_foo();
+}
+```
+
+Filename : `src/foo.nr`
+
+```rust
+mod bar;
+fn from_foo() {}
+```
+
+Filename : `src/foo/bar.nr`
+
+```rust
+fn from_bar() {}
+```
+
+In the above snippet, we have added an extra module to the module tree; `bar`. `bar` is a submodule
+of `foo` hence we declare bar in `foo.nr` with `mod bar`. Since `foo` is not the crate root, the
+compiler looks for the file associated with the `bar` module in `src/foo/bar.nr`
+
+Visually the module hierarchy looks as follows:
+
+```
+crate
+ ├── main
+ │
+ └── foo
+      ├── from_foo
+      └── bar
+           └── from_bar
+```
+
+Similar to importing a module in the crate root, modules can be placed in a `mod.nr` file, like this:
+
+Filename : `src/main.nr`
+
+```rust
+mod foo;
+
+fn main() {
+    foo::from_foo();
+}
+```
+
+Filename : `src/foo/mod.nr`
+
+```rust
+mod bar;
+fn from_foo() {}
+```
+
+Filename : `src/foo/bar/mod.nr`
+
+```rust
+fn from_bar() {}
+```
+
+### Referencing a parent module 
+
+Given a submodule, you can refer to its parent module using the `super` keyword.
+
+Filename : `src/main.nr`
+
+```rust
+mod foo;
+
+fn main() {
+    foo::from_foo();
+}
+```
+
+Filename : `src/foo.nr`
+
+```rust
+mod bar;
+
+fn from_foo() {}
+```
+
+Filename : `src/foo/bar.nr`
+
+```rust
+// Same as bar::from_foo
+use super::from_foo; 
+
+fn from_bar() {
+    from_foo();        // invokes super::from_foo(), which is bar::from_foo()
+    super::from_foo(); // also invokes bar::from_foo()
+}
+```
+
+### `use` visibility
+
+`use` declarations are private to the containing module, by default. However, like functions, 
+they can be marked as `pub` or `pub(crate)`. Such a use declaration serves to _re-export_ a name. 
+A public `use` declaration can therefore redirect some public name to a different target definition: 
+even a definition with a private canonical path, inside a different module.
+
+An example of re-exporting:
+
+```rust
+mod some_module {
+    pub use foo::{bar, baz};
+    mod foo {
+        pub fn bar() {}
+        pub fn baz() {}
+    }
+}
+
+fn main() {
+    some_module::bar();
+    some_module::baz();
+}
+```
+
+In this example, the module `some_module` re-exports two public names defined in `foo`.
+
+### Visibility
+
+By default, like functions, modules are private to the module (or crate) they exist in. You can use `pub`
+to make the module public or `pub(crate)` to make it public to just its crate:
+
+```rust
+// This module is now public and can be seen by other crates.
+pub mod foo;
+```
\ No newline at end of file
diff --git a/docs/versioned_docs/version-v0.39.0/noir/modules_packages_crates/workspaces.md b/docs/versioned_docs/version-v0.39.0/noir/modules_packages_crates/workspaces.md
new file mode 100644
index 00000000000..513497f12bf
--- /dev/null
+++ b/docs/versioned_docs/version-v0.39.0/noir/modules_packages_crates/workspaces.md
@@ -0,0 +1,42 @@
+---
+title: Workspaces
+sidebar_position: 3
+---
+
+Workspaces are a feature of nargo that allow you to manage multiple related Noir packages in a single repository. A workspace is essentially a group of related projects that share common build output directories and configurations.
+
+Each Noir project (with it's own Nargo.toml file) can be thought of as a package. Each package is expected to contain exactly one "named circuit", being the "name" defined in Nargo.toml with the program logic defined in `./src/main.nr`.
+
+For a project with the following structure:
+
+```tree
+├── crates
+│   ├── a
+│   │   ├── Nargo.toml
+│   │   └── Prover.toml
+│   │   └── src
+│   │       └── main.nr
+│   └── b
+│       ├── Nargo.toml
+│       └── Prover.toml
+│       └── src
+│           └── main.nr
+│
+└── Nargo.toml
+```
+
+You can define a workspace in Nargo.toml like so:
+
+```toml
+[workspace]
+members = ["crates/a", "crates/b"]
+default-member = "crates/a"
+```
+
+`members` indicates which packages are included in the workspace. As such, all member packages of a workspace will be processed when the `--workspace` flag is used with various commands or if a `default-member` is not specified.
+
+`default-member` indicates which package various commands process by default.
+
+Libraries can be defined in a workspace. Inside a workspace, these are consumed as `{ path = "../to_lib" }` dependencies in Nargo.toml.
+
+Inside a workspace, these are consumed as `{ path = "../to_lib" }` dependencies in Nargo.toml.
diff --git a/docs/versioned_docs/version-v0.39.0/noir/standard_library/_category_.json b/docs/versioned_docs/version-v0.39.0/noir/standard_library/_category_.json
new file mode 100644
index 00000000000..af04c0933fd
--- /dev/null
+++ b/docs/versioned_docs/version-v0.39.0/noir/standard_library/_category_.json
@@ -0,0 +1,6 @@
+{
+    "label": "Standard Library",
+    "position": 1,
+    "collapsible": true,
+    "collapsed": true
+}
diff --git a/docs/versioned_docs/version-v0.39.0/noir/standard_library/bigint.md b/docs/versioned_docs/version-v0.39.0/noir/standard_library/bigint.md
new file mode 100644
index 00000000000..05c3011634f
--- /dev/null
+++ b/docs/versioned_docs/version-v0.39.0/noir/standard_library/bigint.md
@@ -0,0 +1,127 @@
+---
+title: Big Integers
+description: How to use big integers from Noir standard library
+keywords:
+  [
+    Big Integer,
+    Noir programming language,
+    Noir libraries,
+  ]
+---
+
+The BigInt module in the standard library exposes some class of integers which do not fit (well) into a Noir native field. It implements modulo arithmetic, modulo a 'big' prime number.
+
+:::note
+
+The module can currently be considered as `Field`s with fixed modulo sizes used by a set of elliptic curves, in addition to just the native curve. [More work](https://github.com/noir-lang/noir/issues/510) is needed to achieve arbitrarily sized big integers.
+
+:::note
+
+`nargo` can be built with `--profile release-pedantic` to enable extra overflow checks which may affect `BigInt` results in some cases.
+Consider the [`noir-bignum`](https://github.com/noir-lang/noir-bignum) library for an optimized alternative approach.
+
+:::
+
+Currently 6 classes of integers (i.e 'big' prime numbers) are available in the module, namely:
+
+- BN254 Fq: Bn254Fq
+- BN254 Fr: Bn254Fr
+- Secp256k1 Fq: Secpk1Fq
+- Secp256k1 Fr: Secpk1Fr
+- Secp256r1 Fr: Secpr1Fr
+- Secp256r1 Fq: Secpr1Fq
+
+Where XXX Fq and XXX Fr denote respectively the order of the base and scalar field of the (usual) elliptic curve XXX.
+For instance the big integer 'Secpk1Fq' in the standard library refers to integers modulo $2^{256}-2^{32}-977$.
+
+Feel free to explore the source code for the other primes:
+
+```rust title="big_int_definition" showLineNumbers 
+pub struct BigInt {
+    pointer: u32,
+    modulus: u32,
+}
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/bigint.nr#L28-L33" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/bigint.nr#L28-L33</a></sub></sup>
+
+
+## Example usage
+
+A common use-case is when constructing a big integer from its bytes representation, and performing arithmetic operations on it:
+
+```rust title="big_int_example" showLineNumbers 
+fn big_int_example(x: u8, y: u8) {
+    let a = Secpk1Fq::from_le_bytes(&[x, y, 0, 45, 2]);
+    let b = Secpk1Fq::from_le_bytes(&[y, x, 9]);
+    let c = (a + b) * b / a;
+    let d = c.to_le_bytes();
+    println(d[0]);
+}
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/test_programs/execution_success/bigint/src/main.nr#L74-L82" target="_blank" rel="noopener noreferrer">Source code: test_programs/execution_success/bigint/src/main.nr#L74-L82</a></sub></sup>
+
+
+## Methods
+
+The available operations for each big integer are:
+
+### from_le_bytes
+
+Construct a big integer from its little-endian bytes representation. Example:
+
+```rust
+ // Construct a big integer from a slice of bytes
+ let a = Secpk1Fq::from_le_bytes(&[x, y, 0, 45, 2]);
+ // Construct a big integer from an array of 32 bytes
+ let a = Secpk1Fq::from_le_bytes_32([1;32]);
+ ```
+
+Sure, here's the formatted version of the remaining methods:
+
+### to_le_bytes
+
+Return the little-endian bytes representation of a big integer. Example:
+
+```rust
+let bytes = a.to_le_bytes();
+```
+
+### add
+
+Add two big integers. Example:
+
+```rust
+let sum = a + b;
+```
+
+### sub
+
+Subtract two big integers. Example:
+
+```rust
+let difference = a - b;
+```
+
+### mul
+
+Multiply two big integers. Example:
+
+```rust
+let product = a * b;
+```
+
+### div
+
+Divide two big integers. Note that division is field division and not euclidean division. Example:
+
+```rust
+let quotient = a / b;
+```
+
+### eq
+
+Compare two big integers. Example:
+
+```rust
+let are_equal = a == b;
+```
diff --git a/docs/versioned_docs/version-v0.39.0/noir/standard_library/black_box_fns.md b/docs/versioned_docs/version-v0.39.0/noir/standard_library/black_box_fns.md
new file mode 100644
index 00000000000..d6079ab182c
--- /dev/null
+++ b/docs/versioned_docs/version-v0.39.0/noir/standard_library/black_box_fns.md
@@ -0,0 +1,32 @@
+---
+title: Black Box Functions
+description: Black box functions are functions in Noir that rely on backends implementing support for specialized constraints.
+keywords: [noir, black box functions]
+---
+
+Black box functions are functions in Noir that rely on backends implementing support for specialized constraints. This makes certain zk-snark unfriendly computations cheaper than if they were implemented in Noir.
+
+The ACVM spec defines a set of blackbox functions which backends will be expected to implement. This allows backends to use optimized implementations of these constraints if they have them, however they may also fallback to less efficient naive implementations if not.
+
+## Function list
+
+Here is a list of the current black box functions:
+
+- [AES128](./cryptographic_primitives/ciphers.mdx#aes128)
+- [SHA256](./cryptographic_primitives/hashes.mdx#sha256)
+- [Schnorr signature verification](./cryptographic_primitives/schnorr.mdx)
+- [Blake2s](./cryptographic_primitives/hashes.mdx#blake2s)
+- [Blake3](./cryptographic_primitives/hashes.mdx#blake3)
+- [Pedersen Hash](./cryptographic_primitives/hashes.mdx#pedersen_hash)
+- [Pedersen Commitment](./cryptographic_primitives/hashes.mdx#pedersen_commitment)
+- [ECDSA signature verification](./cryptographic_primitives/ecdsa_sig_verification.mdx)
+- [Embedded curve operations (MSM, addition, ...)](./cryptographic_primitives/embedded_curve_ops.mdx)
+- AND
+- XOR
+- RANGE
+- [Keccak256](./cryptographic_primitives/hashes.mdx#keccak256)
+- [Recursive proof verification](./recursion.mdx)
+
+Most black box functions are included as part of the Noir standard library, however `AND`, `XOR` and `RANGE` are used as part of the Noir language syntax. For instance, using the bitwise operator `&` will invoke the `AND` black box function.
+
+You can view the black box functions defined in the ACVM code [here](https://github.com/noir-lang/noir/blob/master/acvm-repo/acir/src/circuit/black_box_functions.rs).
diff --git a/docs/versioned_docs/version-v0.39.0/noir/standard_library/bn254.md b/docs/versioned_docs/version-v0.39.0/noir/standard_library/bn254.md
new file mode 100644
index 00000000000..3294f005dbb
--- /dev/null
+++ b/docs/versioned_docs/version-v0.39.0/noir/standard_library/bn254.md
@@ -0,0 +1,46 @@
+---
+title: Bn254 Field Library
+---
+
+Noir provides a module in standard library with some optimized functions for bn254 Fr in `std::field::bn254`.
+
+## decompose
+
+```rust
+fn decompose(x: Field) -> (Field, Field) {}
+```
+
+Decomposes a single field into two fields, low and high. The low field contains the lower 16 bytes of the input field and the high field contains the upper 16 bytes of the input field. Both field results are range checked to 128 bits.
+
+
+## assert_gt
+
+```rust
+fn assert_gt(a: Field, b: Field) {}
+```
+
+Asserts that a > b. This will generate less constraints than using `assert(gt(a, b))`.
+
+## assert_lt
+
+```rust
+fn assert_lt(a: Field, b: Field) {}
+```
+
+Asserts that a < b. This will generate less constraints than using `assert(lt(a, b))`.
+
+## gt
+
+```rust
+fn gt(a: Field, b: Field) -> bool  {}
+```
+
+Returns true if a > b.
+
+## lt
+
+```rust
+fn lt(a: Field, b: Field) -> bool  {}
+```
+
+Returns true if a < b.
\ No newline at end of file
diff --git a/docs/versioned_docs/version-v0.39.0/noir/standard_library/containers/boundedvec.md b/docs/versioned_docs/version-v0.39.0/noir/standard_library/containers/boundedvec.md
new file mode 100644
index 00000000000..509b214bf3a
--- /dev/null
+++ b/docs/versioned_docs/version-v0.39.0/noir/standard_library/containers/boundedvec.md
@@ -0,0 +1,419 @@
+---
+title: Bounded Vectors
+keywords: [noir, vector, bounded vector, slice]
+sidebar_position: 1
+---
+
+A `BoundedVec<T, MaxLen>` is a growable storage similar to a `Vec<T>` except that it
+is bounded with a maximum possible length. Unlike `Vec`, `BoundedVec` is not implemented
+via slices and thus is not subject to the same restrictions slices are (notably, nested
+slices - and thus nested vectors as well - are disallowed).
+
+Since a BoundedVec is backed by a normal array under the hood, growing the BoundedVec by
+pushing an additional element is also more efficient - the length only needs to be increased
+by one.
+
+For these reasons `BoundedVec<T, N>` should generally be preferred over `Vec<T>` when there
+is a reasonable maximum bound that can be placed on the vector.
+
+Example:
+
+```rust
+let mut vector: BoundedVec<Field, 10> = BoundedVec::new();
+for i in 0..5 {
+    vector.push(i);
+}
+assert(vector.len() == 5);
+assert(vector.max_len() == 10);
+```
+
+## Methods
+
+### new
+
+```rust
+pub fn new() -> Self
+```
+
+Creates a new, empty vector of length zero.
+
+Since this container is backed by an array internally, it still needs an initial value
+to give each element. To resolve this, each element is zeroed internally. This value
+is guaranteed to be inaccessible unless `get_unchecked` is used.
+
+Example:
+
+```rust
+let empty_vector: BoundedVec<Field, 10> = BoundedVec::new();
+assert(empty_vector.len() == 0);
+```
+
+Note that whenever calling `new` the maximum length of the vector should always be specified
+via a type signature:
+
+```rust title="new_example" showLineNumbers 
+fn good() -> BoundedVec<Field, 10> {
+    // Ok! MaxLen is specified with a type annotation
+    let v1: BoundedVec<Field, 3> = BoundedVec::new();
+    let v2 = BoundedVec::new();
+
+    // Ok! MaxLen is known from the type of `good`'s return value
+    v2
+}
+
+fn bad() {
+    // Error: Type annotation needed
+    // The compiler can't infer `MaxLen` from this code.
+    let mut v3 = BoundedVec::new();
+    v3.push(5);
+}
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/test_programs/noir_test_success/bounded_vec/src/main.nr#L11-L27" target="_blank" rel="noopener noreferrer">Source code: test_programs/noir_test_success/bounded_vec/src/main.nr#L11-L27</a></sub></sup>
+
+
+This defaulting of `MaxLen` (and numeric generics in general) to zero may change in future noir versions
+but for now make sure to use type annotations when using bounded vectors. Otherwise, you will receive a constraint failure at runtime when the vec is pushed to.
+
+### get
+
+```rust
+pub fn get(self, index: u64) -> T {
+```
+
+Retrieves an element from the vector at the given index, starting from zero.
+
+If the given index is equal to or greater than the length of the vector, this
+will issue a constraint failure.
+
+Example:
+
+```rust
+fn foo<N>(v: BoundedVec<u32, N>) {
+    let first = v.get(0);
+    let last = v.get(v.len() - 1);
+    assert(first != last);
+}
+```
+
+### get_unchecked
+
+```rust
+pub fn get_unchecked(self, index: u64) -> T {
+```
+
+Retrieves an element from the vector at the given index, starting from zero, without
+performing a bounds check.
+
+Since this function does not perform a bounds check on length before accessing the element,
+it is unsafe! Use at your own risk!
+
+Example:
+
+```rust title="get_unchecked_example" showLineNumbers 
+fn sum_of_first_three<let N: u32>(v: BoundedVec<u32, N>) -> u32 {
+    // Always ensure the length is larger than the largest
+    // index passed to get_unchecked
+    assert(v.len() > 2);
+    let first = v.get_unchecked(0);
+    let second = v.get_unchecked(1);
+    let third = v.get_unchecked(2);
+    first + second + third
+}
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/test_programs/noir_test_success/bounded_vec/src/main.nr#L54-L64" target="_blank" rel="noopener noreferrer">Source code: test_programs/noir_test_success/bounded_vec/src/main.nr#L54-L64</a></sub></sup>
+
+
+### set
+
+```rust
+pub fn set(&mut self: Self, index: u64, value: T) {
+```
+
+Writes an element to the vector at the given index, starting from zero.
+
+If the given index is equal to or greater than the length of the vector, this will issue a constraint failure.
+
+Example:
+
+```rust
+fn foo<N>(v: BoundedVec<u32, N>) {
+    let first = v.get(0);
+    assert(first != 42);
+    v.set(0, 42);
+    let new_first = v.get(0);
+    assert(new_first == 42);
+}
+```
+
+### set_unchecked
+
+```rust
+pub fn set_unchecked(&mut self: Self, index: u64, value: T) -> T {
+```
+
+Writes an element to the vector at the given index, starting from zero, without performing a bounds check.
+
+Since this function does not perform a bounds check on length before accessing the element, it is unsafe! Use at your own risk!
+
+Example:
+
+```rust title="set_unchecked_example" showLineNumbers 
+fn set_unchecked_example() {
+    let mut vec: BoundedVec<u32, 5> = BoundedVec::new();
+    vec.extend_from_array([1, 2]);
+
+    // Here we're safely writing within the valid range of `vec`
+    // `vec` now has the value [42, 2]
+    vec.set_unchecked(0, 42);
+
+    // We can then safely read this value back out of `vec`.
+    // Notice that we use the checked version of `get` which would prevent reading unsafe values.
+    assert_eq(vec.get(0), 42);
+
+    // We've now written past the end of `vec`.
+    // As this index is still within the maximum potential length of `v`,
+    // it won't cause a constraint failure.
+    vec.set_unchecked(2, 42);
+    println(vec);
+
+    // This will write past the end of the maximum potential length of `vec`,
+    // it will then trigger a constraint failure.
+    vec.set_unchecked(5, 42);
+    println(vec);
+}
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/test_programs/noir_test_success/bounded_vec/src/main.nr#L67-L91" target="_blank" rel="noopener noreferrer">Source code: test_programs/noir_test_success/bounded_vec/src/main.nr#L67-L91</a></sub></sup>
+
+
+
+### push
+
+```rust
+pub fn push(&mut self, elem: T) {
+```
+
+Pushes an element to the end of the vector. This increases the length
+of the vector by one.
+
+Panics if the new length of the vector will be greater than the max length.
+
+Example:
+
+```rust title="bounded-vec-push-example" showLineNumbers 
+let mut v: BoundedVec<Field, 2> = BoundedVec::new();
+
+    v.push(1);
+    v.push(2);
+
+    // Panics with failed assertion "push out of bounds"
+    v.push(3);
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/test_programs/noir_test_success/bounded_vec/src/main.nr#L95-L103" target="_blank" rel="noopener noreferrer">Source code: test_programs/noir_test_success/bounded_vec/src/main.nr#L95-L103</a></sub></sup>
+
+
+### pop
+
+```rust
+pub fn pop(&mut self) -> T
+```
+
+Pops the element at the end of the vector. This will decrease the length
+of the vector by one.
+
+Panics if the vector is empty.
+
+Example:
+
+```rust title="bounded-vec-pop-example" showLineNumbers 
+let mut v: BoundedVec<Field, 2> = BoundedVec::new();
+    v.push(1);
+    v.push(2);
+
+    let two = v.pop();
+    let one = v.pop();
+
+    assert(two == 2);
+    assert(one == 1);
+    // error: cannot pop from an empty vector
+    // let _ = v.pop();
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/test_programs/noir_test_success/bounded_vec/src/main.nr#L108-L120" target="_blank" rel="noopener noreferrer">Source code: test_programs/noir_test_success/bounded_vec/src/main.nr#L108-L120</a></sub></sup>
+
+
+### len
+
+```rust
+pub fn len(self) -> u64 {
+```
+
+Returns the current length of this vector
+
+Example:
+
+```rust title="bounded-vec-len-example" showLineNumbers 
+let mut v: BoundedVec<Field, 4> = BoundedVec::new();
+    assert(v.len() == 0);
+
+    v.push(100);
+    assert(v.len() == 1);
+
+    v.push(200);
+    v.push(300);
+    v.push(400);
+    assert(v.len() == 4);
+
+    let _ = v.pop();
+    let _ = v.pop();
+    assert(v.len() == 2);
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/test_programs/noir_test_success/bounded_vec/src/main.nr#L125-L140" target="_blank" rel="noopener noreferrer">Source code: test_programs/noir_test_success/bounded_vec/src/main.nr#L125-L140</a></sub></sup>
+
+
+### max_len
+
+```rust
+pub fn max_len(_self: BoundedVec<T, MaxLen>) -> u64 {
+```
+
+Returns the maximum length of this vector. This is always
+equal to the `MaxLen` parameter this vector was initialized with.
+
+Example:
+
+```rust title="bounded-vec-max-len-example" showLineNumbers 
+let mut v: BoundedVec<Field, 5> = BoundedVec::new();
+
+    assert(v.max_len() == 5);
+    v.push(10);
+    assert(v.max_len() == 5);
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/test_programs/noir_test_success/bounded_vec/src/main.nr#L145-L151" target="_blank" rel="noopener noreferrer">Source code: test_programs/noir_test_success/bounded_vec/src/main.nr#L145-L151</a></sub></sup>
+
+
+### storage
+
+```rust
+pub fn storage(self) -> [T; MaxLen] {
+```
+
+Returns the internal array within this vector.
+Since arrays in Noir are immutable, mutating the returned storage array will not mutate
+the storage held internally by this vector.
+
+Note that uninitialized elements may be zeroed out!
+
+Example:
+
+```rust title="bounded-vec-storage-example" showLineNumbers 
+let mut v: BoundedVec<Field, 5> = BoundedVec::new();
+
+    assert(v.storage() == [0, 0, 0, 0, 0]);
+
+    v.push(57);
+    assert(v.storage() == [57, 0, 0, 0, 0]);
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/test_programs/noir_test_success/bounded_vec/src/main.nr#L156-L163" target="_blank" rel="noopener noreferrer">Source code: test_programs/noir_test_success/bounded_vec/src/main.nr#L156-L163</a></sub></sup>
+
+
+### extend_from_array
+
+```rust
+pub fn extend_from_array<Len>(&mut self, array: [T; Len])
+```
+
+Pushes each element from the given array to this vector.
+
+Panics if pushing each element would cause the length of this vector
+to exceed the maximum length.
+
+Example:
+
+```rust title="bounded-vec-extend-from-array-example" showLineNumbers 
+let mut vec: BoundedVec<Field, 3> = BoundedVec::new();
+    vec.extend_from_array([2, 4]);
+
+    assert(vec.len == 2);
+    assert(vec.get(0) == 2);
+    assert(vec.get(1) == 4);
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/test_programs/noir_test_success/bounded_vec/src/main.nr#L168-L175" target="_blank" rel="noopener noreferrer">Source code: test_programs/noir_test_success/bounded_vec/src/main.nr#L168-L175</a></sub></sup>
+
+
+### extend_from_bounded_vec
+
+```rust
+pub fn extend_from_bounded_vec<Len>(&mut self, vec: BoundedVec<T, Len>)
+```
+
+Pushes each element from the other vector to this vector. The length of
+the other vector is left unchanged.
+
+Panics if pushing each element would cause the length of this vector
+to exceed the maximum length.
+
+Example:
+
+```rust title="bounded-vec-extend-from-bounded-vec-example" showLineNumbers 
+let mut v1: BoundedVec<Field, 5> = BoundedVec::new();
+    let mut v2: BoundedVec<Field, 7> = BoundedVec::new();
+
+    v2.extend_from_array([1, 2, 3]);
+    v1.extend_from_bounded_vec(v2);
+
+    assert(v1.storage() == [1, 2, 3, 0, 0]);
+    assert(v2.storage() == [1, 2, 3, 0, 0, 0, 0]);
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/test_programs/noir_test_success/bounded_vec/src/main.nr#L180-L189" target="_blank" rel="noopener noreferrer">Source code: test_programs/noir_test_success/bounded_vec/src/main.nr#L180-L189</a></sub></sup>
+
+
+### from_array
+
+```rust
+pub fn from_array<Len>(array: [T; Len]) -> Self
+```
+
+Creates a new vector, populating it with values derived from an array input. 
+The maximum length of the vector is determined based on the type signature.
+
+Example:
+```rust
+let bounded_vec: BoundedVec<Field, 10> = BoundedVec::from_array([1, 2, 3])
+```
+
+### map
+
+```rust
+pub fn map<U, Env>(self, f: fn[Env](T) -> U) -> BoundedVec<U, MaxLen>
+```
+
+Creates a new vector of equal size by calling a closure on each element in this vector.  
+
+Example:
+
+```rust title="bounded-vec-map-example" showLineNumbers 
+let vec: BoundedVec<u32, 4> = BoundedVec::from_array([1, 2, 3, 4]);
+            let result = vec.map(|value| value * 2);
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/collections/bounded_vec.nr#L495-L498" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/collections/bounded_vec.nr#L495-L498</a></sub></sup>
+
+
+### any
+
+```rust
+pub fn any<Env>(self, predicate: fn[Env](T) -> bool) -> bool
+```
+
+Returns true if the given predicate returns true for any element
+in this vector.
+
+Example:
+
+```rust title="bounded-vec-any-example" showLineNumbers 
+let mut v: BoundedVec<u32, 3> = BoundedVec::new();
+    v.extend_from_array([2, 4, 6]);
+
+    let all_even = !v.any(|elem: u32| elem % 2 != 0);
+    assert(all_even);
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/test_programs/noir_test_success/bounded_vec/src/main.nr#L256-L262" target="_blank" rel="noopener noreferrer">Source code: test_programs/noir_test_success/bounded_vec/src/main.nr#L256-L262</a></sub></sup>
+
diff --git a/docs/versioned_docs/version-v0.39.0/noir/standard_library/containers/hashmap.md b/docs/versioned_docs/version-v0.39.0/noir/standard_library/containers/hashmap.md
new file mode 100644
index 00000000000..395cc312705
--- /dev/null
+++ b/docs/versioned_docs/version-v0.39.0/noir/standard_library/containers/hashmap.md
@@ -0,0 +1,587 @@
+---
+title: HashMap
+keywords: [noir, map, hash, hashmap]
+sidebar_position: 1
+---
+
+`HashMap<Key, Value, MaxLen, Hasher>` is used to efficiently store and look up key-value pairs.
+
+`HashMap` is a bounded type which can store anywhere from zero to `MaxLen` total elements.
+Note that due to hash collisions, the actual maximum number of elements stored by any particular
+hashmap is likely lower than `MaxLen`. This is true even with cryptographic hash functions since
+every hash value will be performed modulo `MaxLen`.
+
+Example:
+
+```rust
+// Create a mapping from Fields to u32s with a maximum length of 12
+// using a poseidon2 hasher
+use std::hash::poseidon2::Poseidon2Hasher;
+let mut map: HashMap<Field, u32, 12, BuildHasherDefault<Poseidon2Hasher>> = HashMap::default();
+
+map.insert(1, 2);
+map.insert(3, 4);
+
+let two = map.get(1).unwrap();
+```
+
+## Methods
+
+### default
+
+```rust title="default" showLineNumbers 
+impl<K, V, let N: u32, B, H> Default for HashMap<K, V, N, B>
+where
+    B: BuildHasher<H> + Default,
+    H: Hasher + Default,
+{
+    /// Constructs an empty HashMap.
+    ///
+    /// Example:
+    ///
+    /// ```noir
+    /// let hashmap: HashMap<u8, u32, 10, BuildHasherDefault<Poseidon2Hasher>> = HashMap::default();
+    /// assert(hashmap.is_empty());
+    /// ```
+    fn default() -> Self {
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/collections/map.nr#L681-L696" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/collections/map.nr#L681-L696</a></sub></sup>
+
+
+Creates a fresh, empty HashMap.
+
+When using this function, always make sure to specify the maximum size of the hash map.
+
+This is the same `default` from the `Default` implementation given further below. It is
+repeated here for convenience since it is the recommended way to create a hashmap.
+
+Example:
+
+```rust title="default_example" showLineNumbers 
+let hashmap: HashMap<u8, u32, 10, BuildHasherDefault<Poseidon2Hasher>> = HashMap::default();
+    assert(hashmap.is_empty());
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/test_programs/execution_success/hashmap/src/main.nr#L207-L210" target="_blank" rel="noopener noreferrer">Source code: test_programs/execution_success/hashmap/src/main.nr#L207-L210</a></sub></sup>
+
+
+Because `HashMap` has so many generic arguments that are likely to be the same throughout
+your program, it may be helpful to create a type alias:
+
+```rust title="type_alias" showLineNumbers 
+type MyMap = HashMap<u8, u32, 10, BuildHasherDefault<Poseidon2Hasher>>;
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/test_programs/execution_success/hashmap/src/main.nr#L201-L203" target="_blank" rel="noopener noreferrer">Source code: test_programs/execution_success/hashmap/src/main.nr#L201-L203</a></sub></sup>
+
+
+### with_hasher
+
+```rust title="with_hasher" showLineNumbers 
+pub fn with_hasher<H>(_build_hasher: B) -> Self
+    where
+        B: BuildHasher<H>,
+    {
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/collections/map.nr#L103-L108" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/collections/map.nr#L103-L108</a></sub></sup>
+
+
+Creates a hashmap with an existing `BuildHasher`. This can be used to ensure multiple
+hashmaps are created with the same hasher instance.
+
+Example:
+
+```rust title="with_hasher_example" showLineNumbers 
+let my_hasher: BuildHasherDefault<Poseidon2Hasher> = Default::default();
+    let hashmap: HashMap<u8, u32, 10, BuildHasherDefault<Poseidon2Hasher>> =
+        HashMap::with_hasher(my_hasher);
+    assert(hashmap.is_empty());
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/test_programs/execution_success/hashmap/src/main.nr#L211-L216" target="_blank" rel="noopener noreferrer">Source code: test_programs/execution_success/hashmap/src/main.nr#L211-L216</a></sub></sup>
+
+
+### get
+
+```rust title="get" showLineNumbers 
+pub fn get<H>(self, key: K) -> Option<V>
+    where
+        K: Eq + Hash,
+        B: BuildHasher<H>,
+        H: Hasher,
+    {
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/collections/map.nr#L465-L472" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/collections/map.nr#L465-L472</a></sub></sup>
+
+
+Retrieves a value from the hashmap, returning `Option::none()` if it was not found.
+
+Example:
+
+```rust title="get_example" showLineNumbers 
+fn get_example(map: HashMap<Field, Field, 5, BuildHasherDefault<Poseidon2Hasher>>) {
+    let x = map.get(12);
+
+    if x.is_some() {
+        assert(x.unwrap() == 42);
+    }
+}
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/test_programs/execution_success/hashmap/src/main.nr#L296-L304" target="_blank" rel="noopener noreferrer">Source code: test_programs/execution_success/hashmap/src/main.nr#L296-L304</a></sub></sup>
+
+
+### insert
+
+```rust title="insert" showLineNumbers 
+pub fn insert<H>(&mut self, key: K, value: V)
+    where
+        K: Eq + Hash,
+        B: BuildHasher<H>,
+        H: Hasher,
+    {
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/collections/map.nr#L507-L514" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/collections/map.nr#L507-L514</a></sub></sup>
+
+
+Inserts a new key-value pair into the map. If the key was already in the map, its
+previous value will be overridden with the newly provided one.
+
+Example:
+
+```rust title="insert_example" showLineNumbers 
+let mut map: HashMap<Field, Field, 5, BuildHasherDefault<Poseidon2Hasher>> = HashMap::default();
+    map.insert(12, 42);
+    assert(map.len() == 1);
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/test_programs/execution_success/hashmap/src/main.nr#L217-L221" target="_blank" rel="noopener noreferrer">Source code: test_programs/execution_success/hashmap/src/main.nr#L217-L221</a></sub></sup>
+
+
+### remove
+
+```rust title="remove" showLineNumbers 
+pub fn remove<H>(&mut self, key: K)
+    where
+        K: Eq + Hash,
+        B: BuildHasher<H>,
+        H: Hasher,
+    {
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/collections/map.nr#L563-L570" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/collections/map.nr#L563-L570</a></sub></sup>
+
+
+Removes the given key-value pair from the map. If the key was not already present
+in the map, this does nothing.
+
+Example:
+
+```rust title="remove_example" showLineNumbers 
+map.remove(12);
+    assert(map.is_empty());
+
+    // If a key was not present in the map, remove does nothing
+    map.remove(12);
+    assert(map.is_empty());
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/test_programs/execution_success/hashmap/src/main.nr#L224-L231" target="_blank" rel="noopener noreferrer">Source code: test_programs/execution_success/hashmap/src/main.nr#L224-L231</a></sub></sup>
+
+
+### is_empty
+
+```rust title="is_empty" showLineNumbers 
+pub fn is_empty(self) -> bool {
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/collections/map.nr#L167-L169" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/collections/map.nr#L167-L169</a></sub></sup>
+
+
+True if the length of the hash map is empty.
+
+Example:
+
+```rust title="is_empty_example" showLineNumbers 
+assert(map.is_empty());
+
+    map.insert(1, 2);
+    assert(!map.is_empty());
+
+    map.remove(1);
+    assert(map.is_empty());
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/test_programs/execution_success/hashmap/src/main.nr#L232-L240" target="_blank" rel="noopener noreferrer">Source code: test_programs/execution_success/hashmap/src/main.nr#L232-L240</a></sub></sup>
+
+
+### len
+
+```rust title="len" showLineNumbers 
+pub fn len(self) -> u32 {
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/collections/map.nr#L424-L426" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/collections/map.nr#L424-L426</a></sub></sup>
+
+
+Returns the current length of this hash map.
+
+Example:
+
+```rust title="len_example" showLineNumbers 
+// This is equivalent to checking map.is_empty()
+    assert(map.len() == 0);
+
+    map.insert(1, 2);
+    map.insert(3, 4);
+    map.insert(5, 6);
+    assert(map.len() == 3);
+
+    // 3 was already present as a key in the hash map, so the length is unchanged
+    map.insert(3, 7);
+    assert(map.len() == 3);
+
+    map.remove(1);
+    assert(map.len() == 2);
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/test_programs/execution_success/hashmap/src/main.nr#L241-L256" target="_blank" rel="noopener noreferrer">Source code: test_programs/execution_success/hashmap/src/main.nr#L241-L256</a></sub></sup>
+
+
+### capacity
+
+```rust title="capacity" showLineNumbers 
+pub fn capacity(_self: Self) -> u32 {
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/collections/map.nr#L446-L448" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/collections/map.nr#L446-L448</a></sub></sup>
+
+
+Returns the maximum capacity of this hashmap. This is always equal to the capacity
+specified in the hashmap's type.
+
+Unlike hashmaps in general purpose programming languages, hashmaps in Noir have a
+static capacity that does not increase as the map grows larger. Thus, this capacity
+is also the maximum possible element count that can be inserted into the hashmap.
+Due to hash collisions (modulo the hashmap length), it is likely the actual maximum
+element count will be lower than the full capacity.
+
+Example:
+
+```rust title="capacity_example" showLineNumbers 
+let empty_map: HashMap<Field, Field, 42, BuildHasherDefault<Poseidon2Hasher>> =
+        HashMap::default();
+    assert(empty_map.len() == 0);
+    assert(empty_map.capacity() == 42);
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/test_programs/execution_success/hashmap/src/main.nr#L257-L262" target="_blank" rel="noopener noreferrer">Source code: test_programs/execution_success/hashmap/src/main.nr#L257-L262</a></sub></sup>
+
+
+### clear
+
+```rust title="clear" showLineNumbers 
+pub fn clear(&mut self) {
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/collections/map.nr#L123-L125" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/collections/map.nr#L123-L125</a></sub></sup>
+
+
+Clears the hashmap, removing all key-value pairs from it.
+
+Example:
+
+```rust title="clear_example" showLineNumbers 
+assert(!map.is_empty());
+    map.clear();
+    assert(map.is_empty());
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/test_programs/execution_success/hashmap/src/main.nr#L263-L267" target="_blank" rel="noopener noreferrer">Source code: test_programs/execution_success/hashmap/src/main.nr#L263-L267</a></sub></sup>
+
+
+### contains_key
+
+```rust title="contains_key" showLineNumbers 
+pub fn contains_key<H>(self, key: K) -> bool
+    where
+        K: Hash + Eq,
+        B: BuildHasher<H>,
+        H: Hasher,
+    {
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/collections/map.nr#L143-L150" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/collections/map.nr#L143-L150</a></sub></sup>
+
+
+True if the hashmap contains the given key. Unlike `get`, this will not also return
+the value associated with the key.
+
+Example:
+
+```rust title="contains_key_example" showLineNumbers 
+if map.contains_key(7) {
+        let value = map.get(7);
+        assert(value.is_some());
+    } else {
+        println("No value for key 7!");
+    }
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/test_programs/execution_success/hashmap/src/main.nr#L268-L275" target="_blank" rel="noopener noreferrer">Source code: test_programs/execution_success/hashmap/src/main.nr#L268-L275</a></sub></sup>
+
+
+### entries
+
+```rust title="entries" showLineNumbers 
+pub fn entries(self) -> BoundedVec<(K, V), N> {
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/collections/map.nr#L191-L193" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/collections/map.nr#L191-L193</a></sub></sup>
+
+
+Returns a vector of each key-value pair present in the hashmap.
+
+The length of the returned vector is always equal to the length of the hashmap.
+
+Example:
+
+```rust title="entries_example" showLineNumbers 
+let entries = map.entries();
+
+    // The length of a hashmap may not be compile-time known, so we
+    // need to loop over its capacity instead
+    for i in 0..map.capacity() {
+        if i < entries.len() {
+            let (key, value) = entries.get(i);
+            println(f"{key} -> {value}");
+        }
+    }
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/test_programs/execution_success/hashmap/src/main.nr#L307-L318" target="_blank" rel="noopener noreferrer">Source code: test_programs/execution_success/hashmap/src/main.nr#L307-L318</a></sub></sup>
+
+
+### keys
+
+```rust title="keys" showLineNumbers 
+pub fn keys(self) -> BoundedVec<K, N> {
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/collections/map.nr#L227-L229" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/collections/map.nr#L227-L229</a></sub></sup>
+
+
+Returns a vector of each key present in the hashmap.
+
+The length of the returned vector is always equal to the length of the hashmap.
+
+Example:
+
+```rust title="keys_example" showLineNumbers 
+let keys = map.keys();
+
+    for i in 0..keys.max_len() {
+        if i < keys.len() {
+            let key = keys.get_unchecked(i);
+            let value = map.get(key).unwrap_unchecked();
+            println(f"{key} -> {value}");
+        }
+    }
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/test_programs/execution_success/hashmap/src/main.nr#L319-L329" target="_blank" rel="noopener noreferrer">Source code: test_programs/execution_success/hashmap/src/main.nr#L319-L329</a></sub></sup>
+
+
+### values
+
+```rust title="values" showLineNumbers 
+pub fn values(self) -> BoundedVec<V, N> {
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/collections/map.nr#L262-L264" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/collections/map.nr#L262-L264</a></sub></sup>
+
+
+Returns a vector of each value present in the hashmap.
+
+The length of the returned vector is always equal to the length of the hashmap.
+
+Example:
+
+```rust title="values_example" showLineNumbers 
+let values = map.values();
+
+    for i in 0..values.max_len() {
+        if i < values.len() {
+            let value = values.get_unchecked(i);
+            println(f"Found value {value}");
+        }
+    }
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/test_programs/execution_success/hashmap/src/main.nr#L330-L339" target="_blank" rel="noopener noreferrer">Source code: test_programs/execution_success/hashmap/src/main.nr#L330-L339</a></sub></sup>
+
+
+### iter_mut
+
+```rust title="iter_mut" showLineNumbers 
+pub fn iter_mut<H>(&mut self, f: fn(K, V) -> (K, V))
+    where
+        K: Eq + Hash,
+        B: BuildHasher<H>,
+        H: Hasher,
+    {
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/collections/map.nr#L297-L304" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/collections/map.nr#L297-L304</a></sub></sup>
+
+
+Iterates through each key-value pair of the HashMap, setting each key-value pair to the
+result returned from the given function.
+
+Note that since keys can be mutated, the HashMap needs to be rebuilt as it is iterated
+through. If this is not desired, use `iter_values_mut` if only values need to be mutated,
+or `entries` if neither keys nor values need to be mutated.
+
+The iteration order is left unspecified. As a result, if two keys are mutated to become
+equal, which of the two values that will be present for the key in the resulting map is also unspecified.
+
+Example:
+
+```rust title="iter_mut_example" showLineNumbers 
+// Add 1 to each key in the map, and double the value associated with that key.
+    map.iter_mut(|k, v| (k + 1, v * 2));
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/test_programs/execution_success/hashmap/src/main.nr#L343-L346" target="_blank" rel="noopener noreferrer">Source code: test_programs/execution_success/hashmap/src/main.nr#L343-L346</a></sub></sup>
+
+
+### iter_keys_mut
+
+```rust title="iter_keys_mut" showLineNumbers 
+pub fn iter_keys_mut<H>(&mut self, f: fn(K) -> K)
+    where
+        K: Eq + Hash,
+        B: BuildHasher<H>,
+        H: Hasher,
+    {
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/collections/map.nr#L335-L342" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/collections/map.nr#L335-L342</a></sub></sup>
+
+
+Iterates through the HashMap, mutating each key to the result returned from
+the given function.
+
+Note that since keys can be mutated, the HashMap needs to be rebuilt as it is iterated
+through. If only iteration is desired and the keys are not intended to be mutated,
+prefer using `entries` instead.
+
+The iteration order is left unspecified. As a result, if two keys are mutated to become
+equal, which of the two values that will be present for the key in the resulting map is also unspecified.
+
+Example:
+
+```rust title="iter_keys_mut_example" showLineNumbers 
+// Double each key, leaving the value associated with that key untouched
+    map.iter_keys_mut(|k| k * 2);
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/test_programs/execution_success/hashmap/src/main.nr#L347-L350" target="_blank" rel="noopener noreferrer">Source code: test_programs/execution_success/hashmap/src/main.nr#L347-L350</a></sub></sup>
+
+
+### iter_values_mut
+
+```rust title="iter_values_mut" showLineNumbers 
+pub fn iter_values_mut(&mut self, f: fn(V) -> V) {
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/collections/map.nr#L367-L369" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/collections/map.nr#L367-L369</a></sub></sup>
+
+
+Iterates through the HashMap, applying the given function to each value and mutating the
+value to equal the result. This function is more efficient than `iter_mut` and `iter_keys_mut`
+because the keys are untouched and the underlying hashmap thus does not need to be reordered.
+
+Example:
+
+```rust title="iter_values_mut_example" showLineNumbers 
+// Halve each value
+    map.iter_values_mut(|v| v / 2);
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/test_programs/execution_success/hashmap/src/main.nr#L351-L354" target="_blank" rel="noopener noreferrer">Source code: test_programs/execution_success/hashmap/src/main.nr#L351-L354</a></sub></sup>
+
+
+### retain
+
+```rust title="retain" showLineNumbers 
+pub fn retain(&mut self, f: fn(K, V) -> bool) {
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/collections/map.nr#L388-L390" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/collections/map.nr#L388-L390</a></sub></sup>
+
+
+Retains only the key-value pairs for which the given function returns true.
+Any key-value pairs for which the function returns false will be removed from the map.
+
+Example:
+
+```rust title="retain_example" showLineNumbers 
+map.retain(|k, v| (k != 0) & (v != 0));
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/test_programs/execution_success/hashmap/src/main.nr#L279-L281" target="_blank" rel="noopener noreferrer">Source code: test_programs/execution_success/hashmap/src/main.nr#L279-L281</a></sub></sup>
+
+
+## Trait Implementations
+
+### default
+
+```rust title="default" showLineNumbers 
+impl<K, V, let N: u32, B, H> Default for HashMap<K, V, N, B>
+where
+    B: BuildHasher<H> + Default,
+    H: Hasher + Default,
+{
+    /// Constructs an empty HashMap.
+    ///
+    /// Example:
+    ///
+    /// ```noir
+    /// let hashmap: HashMap<u8, u32, 10, BuildHasherDefault<Poseidon2Hasher>> = HashMap::default();
+    /// assert(hashmap.is_empty());
+    /// ```
+    fn default() -> Self {
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/collections/map.nr#L681-L696" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/collections/map.nr#L681-L696</a></sub></sup>
+
+
+Constructs an empty HashMap.
+
+Example:
+
+```rust title="default_example" showLineNumbers 
+let hashmap: HashMap<u8, u32, 10, BuildHasherDefault<Poseidon2Hasher>> = HashMap::default();
+    assert(hashmap.is_empty());
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/test_programs/execution_success/hashmap/src/main.nr#L207-L210" target="_blank" rel="noopener noreferrer">Source code: test_programs/execution_success/hashmap/src/main.nr#L207-L210</a></sub></sup>
+
+
+### eq
+
+```rust title="eq" showLineNumbers 
+impl<K, V, let N: u32, B, H> Eq for HashMap<K, V, N, B>
+where
+    K: Eq + Hash,
+    V: Eq,
+    B: BuildHasher<H>,
+    H: Hasher,
+{
+    /// Checks if two HashMaps are equal.
+    ///
+    /// Example:
+    ///
+    /// ```noir
+    /// let mut map1: HashMap<Field, u64, 4, BuildHasherDefault<Poseidon2Hasher>> = HashMap::default();
+    /// let mut map2: HashMap<Field, u64, 4, BuildHasherDefault<Poseidon2Hasher>> = HashMap::default();
+    ///
+    /// map1.insert(1, 2);
+    /// map1.insert(3, 4);
+    ///
+    /// map2.insert(3, 4);
+    /// map2.insert(1, 2);
+    ///
+    /// assert(map1 == map2);
+    /// ```
+    fn eq(self, other: HashMap<K, V, N, B>) -> bool {
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/collections/map.nr#L629-L654" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/collections/map.nr#L629-L654</a></sub></sup>
+
+
+Checks if two HashMaps are equal.
+
+Example:
+
+```rust title="eq_example" showLineNumbers 
+let mut map1: HashMap<Field, u64, 4, BuildHasherDefault<Poseidon2Hasher>> = HashMap::default();
+    let mut map2: HashMap<Field, u64, 4, BuildHasherDefault<Poseidon2Hasher>> = HashMap::default();
+
+    map1.insert(1, 2);
+    map1.insert(3, 4);
+
+    map2.insert(3, 4);
+    map2.insert(1, 2);
+
+    assert(map1 == map2);
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/test_programs/execution_success/hashmap/src/main.nr#L282-L293" target="_blank" rel="noopener noreferrer">Source code: test_programs/execution_success/hashmap/src/main.nr#L282-L293</a></sub></sup>
+
diff --git a/docs/versioned_docs/version-v0.39.0/noir/standard_library/containers/index.md b/docs/versioned_docs/version-v0.39.0/noir/standard_library/containers/index.md
new file mode 100644
index 00000000000..ea84c6d5c21
--- /dev/null
+++ b/docs/versioned_docs/version-v0.39.0/noir/standard_library/containers/index.md
@@ -0,0 +1,5 @@
+---
+title: Containers
+description: Container types provided by Noir's standard library for storing and retrieving data
+keywords: [containers, data types, vec, hashmap]
+---
diff --git a/docs/versioned_docs/version-v0.39.0/noir/standard_library/containers/vec.mdx b/docs/versioned_docs/version-v0.39.0/noir/standard_library/containers/vec.mdx
new file mode 100644
index 00000000000..475011922f8
--- /dev/null
+++ b/docs/versioned_docs/version-v0.39.0/noir/standard_library/containers/vec.mdx
@@ -0,0 +1,170 @@
+---
+title: Vectors
+description: Delve into the Vec data type in Noir. Learn about its methods, practical examples, and best practices for using Vectors in your Noir code.
+keywords: [noir, vector type, methods, examples, dynamic arrays]
+sidebar_position: 6
+---
+
+import Experimental from '@site/src/components/Notes/_experimental.mdx';
+
+<Experimental />
+
+A vector is a collection type similar to Rust's `Vec<T>` type. In Noir, it is a convenient way to use slices as mutable arrays.
+
+Example:
+
+```rust
+let mut vector: Vec<Field> = Vec::new();
+for i in 0..5 {
+    vector.push(i);
+}
+assert(vector.len() == 5);
+```
+
+## Methods
+
+### new
+
+Creates a new, empty vector.
+
+```rust
+pub fn new() -> Self
+```
+
+Example:
+
+```rust
+let empty_vector: Vec<Field> = Vec::new();
+assert(empty_vector.len() == 0);
+```
+
+### from_slice
+
+Creates a vector containing each element from a given slice. Mutations to the resulting vector will not affect the original slice.
+
+```rust
+pub fn from_slice(slice: [T]) -> Self
+```
+
+Example:
+
+```rust
+let slice: [Field] = &[1, 2, 3];
+let vector_from_slice = Vec::from_slice(slice);
+assert(vector_from_slice.len() == 3);
+```
+
+### len
+
+Returns the number of elements in the vector.
+
+```rust
+pub fn len(self) -> Field
+```
+
+Example:
+
+```rust
+let empty_vector: Vec<Field> = Vec::new();
+assert(empty_vector.len() == 0);
+```
+
+### get
+
+Retrieves an element from the vector at a given index. Panics if the index points beyond the vector's end.
+
+```rust
+pub fn get(self, index: Field) -> T
+```
+
+Example:
+
+```rust
+let vector: Vec<Field> = Vec::from_slice(&[10, 20, 30]);
+assert(vector.get(1) == 20);
+```
+
+### set
+
+```rust
+pub fn set(&mut self: Self, index: u64, value: T) {
+```
+
+Writes an element to the vector at the given index, starting from zero.
+
+Panics if the index points beyond the vector's end.
+
+Example:
+
+```rust
+let vector: Vec<Field> = Vec::from_slice(&[10, 20, 30]);
+assert(vector.get(1) == 20);
+vector.set(1, 42);
+assert(vector.get(1) == 42);
+```
+
+### push
+
+Adds a new element to the vector's end, returning a new vector with a length one greater than the original unmodified vector.
+
+```rust
+pub fn push(&mut self, elem: T)
+```
+
+Example:
+
+```rust
+let mut vector: Vec<Field> = Vec::new();
+vector.push(10);
+assert(vector.len() == 1);
+```
+
+### pop
+
+Removes an element from the vector's end, returning a new vector with a length one less than the original vector, along with the removed element. Panics if the vector's length is zero.
+
+```rust
+pub fn pop(&mut self) -> T
+```
+
+Example:
+
+```rust
+let mut vector = Vec::from_slice(&[10, 20]);
+let popped_elem = vector.pop();
+assert(popped_elem == 20);
+assert(vector.len() == 1);
+```
+
+### insert
+
+Inserts an element at a specified index, shifting subsequent elements to the right.
+
+```rust
+pub fn insert(&mut self, index: Field, elem: T)
+```
+
+Example:
+
+```rust
+let mut vector = Vec::from_slice(&[10, 30]);
+vector.insert(1, 20);
+assert(vector.get(1) == 20);
+```
+
+### remove
+
+Removes an element at a specified index, shifting subsequent elements to the left, and returns the removed element.
+
+```rust
+pub fn remove(&mut self, index: Field) -> T
+```
+
+Example:
+
+```rust
+let mut vector = Vec::from_slice(&[10, 20, 30]);
+let removed_elem = vector.remove(1);
+assert(removed_elem == 20);
+assert(vector.len() == 2);
+```
diff --git a/docs/versioned_docs/version-v0.39.0/noir/standard_library/cryptographic_primitives/_category_.json b/docs/versioned_docs/version-v0.39.0/noir/standard_library/cryptographic_primitives/_category_.json
new file mode 100644
index 00000000000..5d694210bbf
--- /dev/null
+++ b/docs/versioned_docs/version-v0.39.0/noir/standard_library/cryptographic_primitives/_category_.json
@@ -0,0 +1,5 @@
+{
+    "position": 0,
+    "collapsible": true,
+    "collapsed": true
+}
diff --git a/docs/versioned_docs/version-v0.39.0/noir/standard_library/cryptographic_primitives/ciphers.mdx b/docs/versioned_docs/version-v0.39.0/noir/standard_library/cryptographic_primitives/ciphers.mdx
new file mode 100644
index 00000000000..d6a5e1a79eb
--- /dev/null
+++ b/docs/versioned_docs/version-v0.39.0/noir/standard_library/cryptographic_primitives/ciphers.mdx
@@ -0,0 +1,32 @@
+---
+title: Ciphers
+description:
+  Learn about the implemented ciphers ready to use for any Noir project
+keywords:
+  [ciphers, Noir project, aes128, encrypt]
+sidebar_position: 0
+---
+
+import BlackBoxInfo from '@site/src/components/Notes/_blackbox';
+
+## aes128
+
+Given a plaintext as an array of bytes, returns the corresponding aes128 ciphertext (CBC mode). Input padding is automatically performed using PKCS#7, so that the output length is `input.len() + (16 - input.len() % 16)`.
+
+```rust title="aes128" showLineNumbers 
+pub fn aes128_encrypt<let N: u32>(input: [u8; N], iv: [u8; 16], key: [u8; 16]) -> [u8] {}
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/aes128.nr#L2-L4" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/aes128.nr#L2-L4</a></sub></sup>
+
+
+```rust
+fn main() {
+    let input: [u8; 4] = [0, 12, 3, 15] // Random bytes, will be padded to 16 bytes.
+    let iv: [u8; 16] = [0; 16]; // Initialisation vector
+    let key: [u8; 16] = [0; 16] // AES key
+    let ciphertext = std::aes128::aes128_encrypt(inputs.as_bytes(), iv.as_bytes(), key.as_bytes()); // In this case, the output length will be 16 bytes.
+}
+```
+
+
+<BlackBoxInfo to="../black_box_fns"/>
\ No newline at end of file
diff --git a/docs/versioned_docs/version-v0.39.0/noir/standard_library/cryptographic_primitives/ec_primitives.md b/docs/versioned_docs/version-v0.39.0/noir/standard_library/cryptographic_primitives/ec_primitives.md
new file mode 100644
index 00000000000..f262d8160d6
--- /dev/null
+++ b/docs/versioned_docs/version-v0.39.0/noir/standard_library/cryptographic_primitives/ec_primitives.md
@@ -0,0 +1,102 @@
+---
+title: Elliptic Curve Primitives
+keywords: [cryptographic primitives, Noir project]
+sidebar_position: 4
+---
+
+Data structures and methods on them that allow you to carry out computations involving elliptic
+curves over the (mathematical) field corresponding to `Field`. For the field currently at our
+disposal, applications would involve a curve embedded in BN254, e.g. the
+[Baby Jubjub curve](https://eips.ethereum.org/EIPS/eip-2494).
+
+## Data structures
+
+### Elliptic curve configurations
+
+(`std::ec::{tecurve,montcurve,swcurve}::{affine,curvegroup}::Curve`), i.e. the specific elliptic
+curve you want to use, which would be specified using any one of the methods
+`std::ec::{tecurve,montcurve,swcurve}::{affine,curvegroup}::new` which take the coefficients in the
+defining equation together with a generator point as parameters. You can find more detail in the
+comments in
+[`noir_stdlib/src/ec/mod.nr`](https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/ec/mod.nr), but
+the gist of it is that the elliptic curves of interest are usually expressed in one of the standard
+forms implemented here (Twisted Edwards, Montgomery and Short Weierstraß), and in addition to that,
+you could choose to use `affine` coordinates (Cartesian coordinates - the usual (x,y) - possibly
+together with a point at infinity) or `curvegroup` coordinates (some form of projective coordinates
+requiring more coordinates but allowing for more efficient implementations of elliptic curve
+operations). Conversions between all of these forms are provided, and under the hood these
+conversions are done whenever an operation is more efficient in a different representation (or a
+mixed coordinate representation is employed).
+
+### Points
+
+(`std::ec::{tecurve,montcurve,swcurve}::{affine,curvegroup}::Point`), i.e. points lying on the
+elliptic curve. For a curve configuration `c` and a point `p`, it may be checked that `p`
+does indeed lie on `c` by calling `c.contains(p1)`.
+
+## Methods
+
+(given a choice of curve representation, e.g. use `std::ec::tecurve::affine::Curve` and use
+`std::ec::tecurve::affine::Point`)
+
+- The **zero element** is given by `Point::zero()`, and we can verify whether a point `p: Point` is
+  zero by calling `p.is_zero()`.
+- **Equality**: Points `p1: Point` and `p2: Point` may be checked for equality by calling
+  `p1.eq(p2)`.
+- **Addition**: For `c: Curve` and points `p1: Point` and `p2: Point` on the curve, adding these two
+  points is accomplished by calling `c.add(p1,p2)`.
+- **Negation**: For a point `p: Point`, `p.negate()` is its negation.
+- **Subtraction**: For `c` and `p1`, `p2` as above, subtracting `p2` from `p1` is accomplished by
+  calling `c.subtract(p1,p2)`.
+- **Scalar multiplication**: For `c` as above, `p: Point` a point on the curve and `n: Field`,
+  scalar multiplication is given by `c.mul(n,p)`. If instead `n :: [u1; N]`, i.e. `n` is a bit
+  array, the `bit_mul` method may be used instead: `c.bit_mul(n,p)`
+- **Multi-scalar multiplication**: For `c` as above and arrays `n: [Field; N]` and `p: [Point; N]`,
+  multi-scalar multiplication is given by `c.msm(n,p)`.
+- **Coordinate representation conversions**: The `into_group` method converts a point or curve
+  configuration in the affine representation to one in the CurveGroup representation, and
+  `into_affine` goes in the other direction.
+- **Curve representation conversions**: `tecurve` and `montcurve` curves and points are equivalent
+  and may be converted between one another by calling `into_montcurve` or `into_tecurve` on their
+  configurations or points. `swcurve` is more general and a curve c of one of the other two types
+  may be converted to this representation by calling `c.into_swcurve()`, whereas a point `p` lying
+  on the curve given by `c` may be mapped to its corresponding `swcurve` point by calling
+  `c.map_into_swcurve(p)`.
+- **Map-to-curve methods**: The Elligator 2 method of mapping a field element `n: Field` into a
+  `tecurve` or `montcurve` with configuration `c` may be called as `c.elligator2_map(n)`. For all of
+  the curve configurations, the SWU map-to-curve method may be called as `c.swu_map(z,n)`, where
+  `z: Field` depends on `Field` and `c` and must be chosen by the user (the conditions it needs to
+  satisfy are specified in the comments
+  [here](https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/ec/mod.nr)).
+
+## Examples
+
+The
+[ec_baby_jubjub test](https://github.com/noir-lang/noir/blob/master/test_programs/compile_success_empty/ec_baby_jubjub/src/main.nr)
+illustrates all of the above primitives on various forms of the Baby Jubjub curve. A couple of more
+interesting examples in Noir would be:
+
+Public-key cryptography: Given an elliptic curve and a 'base point' on it, determine the public key
+from the private key. This is a matter of using scalar multiplication. In the case of Baby Jubjub,
+for example, this code would do:
+
+```rust
+use std::ec::tecurve::affine::{Curve, Point};
+
+fn bjj_pub_key(priv_key: Field) -> Point
+{
+
+ let bjj = Curve::new(168700, 168696, G::new(995203441582195749578291179787384436505546430278305826713579947235728471134,5472060717959818805561601436314318772137091100104008585924551046643952123905));
+
+ let base_pt = Point::new(5299619240641551281634865583518297030282874472190772894086521144482721001553, 16950150798460657717958625567821834550301663161624707787222815936182638968203);
+
+ bjj.mul(priv_key,base_pt)
+}
+```
+
+This would come in handy in a Merkle proof.
+
+- EdDSA signature verification: This is a matter of combining these primitives with a suitable hash
+  function. See
+  [feat(stdlib): EdDSA sig verification noir#1136](https://github.com/noir-lang/noir/pull/1136) for
+  the case of Baby Jubjub and the Poseidon hash function.
diff --git a/docs/versioned_docs/version-v0.39.0/noir/standard_library/cryptographic_primitives/ecdsa_sig_verification.mdx b/docs/versioned_docs/version-v0.39.0/noir/standard_library/cryptographic_primitives/ecdsa_sig_verification.mdx
new file mode 100644
index 00000000000..8d96027b42c
--- /dev/null
+++ b/docs/versioned_docs/version-v0.39.0/noir/standard_library/cryptographic_primitives/ecdsa_sig_verification.mdx
@@ -0,0 +1,98 @@
+---
+title: ECDSA Signature Verification
+description: Learn about the cryptographic primitives regarding ECDSA over the secp256k1 and secp256r1 curves
+keywords: [cryptographic primitives, Noir project, ecdsa, secp256k1, secp256r1, signatures]
+sidebar_position: 3
+---
+
+import BlackBoxInfo from '@site/src/components/Notes/_blackbox';
+
+Noir supports ECDSA signatures verification over the secp256k1 and secp256r1 curves.
+
+## ecdsa_secp256k1::verify_signature
+
+Verifier for ECDSA Secp256k1 signatures.
+See ecdsa_secp256k1::verify_signature_slice for a version that accepts slices directly.
+
+```rust title="ecdsa_secp256k1" showLineNumbers 
+pub fn verify_signature<let N: u32>(
+    public_key_x: [u8; 32],
+    public_key_y: [u8; 32],
+    signature: [u8; 64],
+    message_hash: [u8; N],
+) -> bool
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/ecdsa_secp256k1.nr#L2-L9" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/ecdsa_secp256k1.nr#L2-L9</a></sub></sup>
+
+
+example:
+
+```rust
+fn main(hashed_message : [u8;32], pub_key_x : [u8;32], pub_key_y : [u8;32], signature : [u8;64]) {
+     let valid_signature = std::ecdsa_secp256k1::verify_signature(pub_key_x, pub_key_y, signature, hashed_message);
+     assert(valid_signature);
+}
+```
+
+<BlackBoxInfo to="../black_box_fns" />
+
+## ecdsa_secp256k1::verify_signature_slice
+
+Verifier for ECDSA Secp256k1 signatures where the message is a slice.
+
+```rust title="ecdsa_secp256k1_slice" showLineNumbers 
+pub fn verify_signature_slice(
+    public_key_x: [u8; 32],
+    public_key_y: [u8; 32],
+    signature: [u8; 64],
+    message_hash: [u8],
+) -> bool
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/ecdsa_secp256k1.nr#L13-L20" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/ecdsa_secp256k1.nr#L13-L20</a></sub></sup>
+
+
+<BlackBoxInfo to="../black_box_fns"/>
+
+## ecdsa_secp256r1::verify_signature
+
+Verifier for ECDSA Secp256r1 signatures.
+See ecdsa_secp256r1::verify_signature_slice for a version that accepts slices directly.
+
+```rust title="ecdsa_secp256r1" showLineNumbers 
+pub fn verify_signature<let N: u32>(
+    public_key_x: [u8; 32],
+    public_key_y: [u8; 32],
+    signature: [u8; 64],
+    message_hash: [u8; N],
+) -> bool
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/ecdsa_secp256r1.nr#L2-L9" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/ecdsa_secp256r1.nr#L2-L9</a></sub></sup>
+
+
+example:
+
+```rust
+fn main(hashed_message : [u8;32], pub_key_x : [u8;32], pub_key_y : [u8;32], signature : [u8;64]) {
+     let valid_signature = std::ecdsa_secp256r1::verify_signature(pub_key_x, pub_key_y, signature, hashed_message);
+     assert(valid_signature);
+}
+```
+
+<BlackBoxInfo to="../black_box_fns"/>
+
+## ecdsa_secp256r1::verify_signature
+
+Verifier for ECDSA Secp256r1 signatures where the message is a slice.
+
+```rust title="ecdsa_secp256r1_slice" showLineNumbers 
+pub fn verify_signature_slice(
+    public_key_x: [u8; 32],
+    public_key_y: [u8; 32],
+    signature: [u8; 64],
+    message_hash: [u8],
+) -> bool
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/ecdsa_secp256r1.nr#L13-L20" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/ecdsa_secp256r1.nr#L13-L20</a></sub></sup>
+
+
+<BlackBoxInfo to="../black_box_fns"/>
diff --git a/docs/versioned_docs/version-v0.39.0/noir/standard_library/cryptographic_primitives/eddsa.mdx b/docs/versioned_docs/version-v0.39.0/noir/standard_library/cryptographic_primitives/eddsa.mdx
new file mode 100644
index 00000000000..b283de693c8
--- /dev/null
+++ b/docs/versioned_docs/version-v0.39.0/noir/standard_library/cryptographic_primitives/eddsa.mdx
@@ -0,0 +1,37 @@
+---
+title: EdDSA Verification
+description: Learn about the cryptographic primitives regarding EdDSA
+keywords: [cryptographic primitives, Noir project, eddsa, signatures]
+sidebar_position: 5
+---
+
+import BlackBoxInfo from '@site/src/components/Notes/_blackbox';
+
+## eddsa::eddsa_poseidon_verify
+
+Verifier for EdDSA signatures
+
+```rust
+fn eddsa_poseidon_verify(public_key_x : Field, public_key_y : Field, signature_s: Field, signature_r8_x: Field, signature_r8_y: Field, message: Field) -> bool
+```
+
+It is also possible to specify the hash algorithm used for the signature by using the `eddsa_verify` function by passing a type implementing the Hasher trait with the turbofish operator. 
+For instance, if you want to use Poseidon2 instead, you can do the following:
+```rust
+use std::hash::poseidon2::Poseidon2Hasher;
+
+eddsa_verify::<Poseidon2Hasher>(pub_key_a.x, pub_key_a.y, s_a, r8_a.x, r8_a.y, msg);
+```
+
+<BlackBoxInfo to="../black_box_fns"/>
+
+## eddsa::eddsa_to_pub
+
+Private to public key conversion.
+
+Returns `(pub_key_x, pub_key_y)`
+
+```rust
+fn eddsa_to_pub(secret : Field) -> (Field, Field)
+```
+
diff --git a/docs/versioned_docs/version-v0.39.0/noir/standard_library/cryptographic_primitives/embedded_curve_ops.mdx b/docs/versioned_docs/version-v0.39.0/noir/standard_library/cryptographic_primitives/embedded_curve_ops.mdx
new file mode 100644
index 00000000000..482a36932b9
--- /dev/null
+++ b/docs/versioned_docs/version-v0.39.0/noir/standard_library/cryptographic_primitives/embedded_curve_ops.mdx
@@ -0,0 +1,95 @@
+---
+title: Scalar multiplication
+description: See how you can perform scalar multiplication in Noir
+keywords: [cryptographic primitives, Noir project, scalar multiplication]
+sidebar_position: 1
+---
+
+import BlackBoxInfo from '@site/src/components/Notes/_blackbox';
+
+The following functions perform operations over the embedded curve whose coordinates are defined by the configured noir field.
+For the BN254 scalar field, this is BabyJubJub or Grumpkin.
+
+:::note
+Suffixes `_low` and `_high` denote low and high limbs of a scalar.
+:::
+
+## embedded_curve_ops::multi_scalar_mul
+
+Performs multi scalar multiplication over the embedded curve.
+The function accepts arbitrary amount of point-scalar pairs on the input, it multiplies the individual pairs over
+the curve and returns a sum of the resulting points.
+
+Points represented as x and y coordinates [x1, y1, x2, y2, ...], scalars as low and high limbs [low1, high1, low2, high2, ...].
+
+```rust title="multi_scalar_mul" showLineNumbers 
+pub fn multi_scalar_mul<let N: u32>(
+    points: [EmbeddedCurvePoint; N],
+    scalars: [EmbeddedCurveScalar; N],
+) -> EmbeddedCurvePoint
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/embedded_curve_ops.nr#L103-L108" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/embedded_curve_ops.nr#L103-L108</a></sub></sup>
+
+
+example
+
+```rust
+fn main(point_x: Field, point_y: Field, scalar_low: Field, scalar_high: Field) {
+    let point = std::embedded_curve_ops::multi_scalar_mul([point_x, point_y], [scalar_low, scalar_high]);
+    println(point);
+}
+```
+
+## embedded_curve_ops::fixed_base_scalar_mul
+
+Performs fixed base scalar multiplication over the embedded curve (multiplies input scalar with a generator point).
+The function accepts a single scalar on the input represented as 2 fields.
+
+```rust title="fixed_base_scalar_mul" showLineNumbers 
+pub fn fixed_base_scalar_mul(scalar: EmbeddedCurveScalar) -> EmbeddedCurvePoint
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/embedded_curve_ops.nr#L120-L122" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/embedded_curve_ops.nr#L120-L122</a></sub></sup>
+
+
+example
+
+```rust
+fn main(scalar_low: Field, scalar_high: Field) {
+    let point = std::embedded_curve_ops::fixed_base_scalar_mul(scalar_low, scalar_high);
+    println(point);
+}
+```
+
+## embedded_curve_ops::embedded_curve_add
+
+Adds two points on the embedded curve.
+This function takes two `EmbeddedCurvePoint` structures as parameters, representing points on the curve, and returns a new `EmbeddedCurvePoint` structure that represents their sum.
+
+### Parameters:
+- `point1` (`EmbeddedCurvePoint`): The first point to add.
+- `point2` (`EmbeddedCurvePoint`): The second point to add.
+
+### Returns:
+- `EmbeddedCurvePoint`: The resulting point after the addition of `point1` and `point2`.
+
+```rust title="embedded_curve_add" showLineNumbers 
+pub fn embedded_curve_add(
+    point1: EmbeddedCurvePoint,
+    point2: EmbeddedCurvePoint,
+) -> EmbeddedCurvePoint {
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/embedded_curve_ops.nr#L136-L141" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/embedded_curve_ops.nr#L136-L141</a></sub></sup>
+
+
+example
+
+```rust
+fn main() {
+    let point1 = EmbeddedCurvePoint { x: 1, y: 2 };
+    let point2 = EmbeddedCurvePoint { x: 3, y: 4 };
+    let result = std::embedded_curve_ops::embedded_curve_add(point1, point2);
+    println!("Resulting Point: ({}, {})", result.x, result.y);
+}
+```
+
+<BlackBoxInfo to="../black_box_fns"/>
diff --git a/docs/versioned_docs/version-v0.39.0/noir/standard_library/cryptographic_primitives/hashes.mdx b/docs/versioned_docs/version-v0.39.0/noir/standard_library/cryptographic_primitives/hashes.mdx
new file mode 100644
index 00000000000..541a1971561
--- /dev/null
+++ b/docs/versioned_docs/version-v0.39.0/noir/standard_library/cryptographic_primitives/hashes.mdx
@@ -0,0 +1,227 @@
+---
+title: Hash methods
+description:
+  Learn about the cryptographic primitives ready to use for any Noir project, including sha256,
+  blake2s and pedersen
+keywords:
+  [cryptographic primitives, Noir project, sha256, blake2s, pedersen, hash]
+sidebar_position: 0
+---
+
+import BlackBoxInfo from '@site/src/components/Notes/_blackbox';
+
+## sha256
+
+Given an array of bytes, returns the resulting sha256 hash.
+Specify a message_size to hash only the first `message_size` bytes of the input.
+
+```rust title="sha256" showLineNumbers 
+pub fn sha256<let N: u32>(input: [u8; N]) -> HASH
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/hash/sha256.nr#L47-L49" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/hash/sha256.nr#L47-L49</a></sub></sup>
+
+
+example:
+```rust title="sha256_var" showLineNumbers 
+let digest = std::hash::sha256_var([x as u8], 1);
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/test_programs/execution_success/sha256/src/main.nr#L15-L17" target="_blank" rel="noopener noreferrer">Source code: test_programs/execution_success/sha256/src/main.nr#L15-L17</a></sub></sup>
+
+
+```rust
+fn main() {
+    let x = [163, 117, 178, 149]; // some random bytes
+    let hash = std::sha256::sha256_var(x, 4);
+}
+```
+
+
+<BlackBoxInfo to="../black_box_fns"/>
+
+## blake2s
+
+Given an array of bytes, returns an array with the Blake2 hash
+
+```rust title="blake2s" showLineNumbers 
+pub fn blake2s<let N: u32>(input: [u8; N]) -> [u8; 32]
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/hash/mod.nr#L18-L20" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/hash/mod.nr#L18-L20</a></sub></sup>
+
+
+example:
+
+```rust
+fn main() {
+    let x = [163, 117, 178, 149]; // some random bytes
+    let hash = std::hash::blake2s(x);
+}
+```
+
+<BlackBoxInfo to="../black_box_fns"/>
+
+## blake3
+
+Given an array of bytes, returns an array with the Blake3 hash
+
+```rust title="blake3" showLineNumbers 
+pub fn blake3<let N: u32>(input: [u8; N]) -> [u8; 32]
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/hash/mod.nr#L24-L26" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/hash/mod.nr#L24-L26</a></sub></sup>
+
+
+example:
+
+```rust
+fn main() {
+    let x = [163, 117, 178, 149]; // some random bytes
+    let hash = std::hash::blake3(x);
+}
+```
+
+<BlackBoxInfo to="../black_box_fns"/>
+
+## pedersen_hash
+
+Given an array of Fields, returns the Pedersen hash.
+
+```rust title="pedersen_hash" showLineNumbers 
+pub fn pedersen_hash<let N: u32>(input: [Field; N]) -> Field
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/hash/mod.nr#L49-L51" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/hash/mod.nr#L49-L51</a></sub></sup>
+
+
+example:
+
+```rust title="pedersen-hash" showLineNumbers 
+fn main(x: Field, y: Field, expected_hash: Field) {
+    let hash = std::hash::pedersen_hash([x, y]);
+    assert_eq(hash, expected_hash);
+}
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/test_programs/execution_success/pedersen_hash/src/main.nr#L1-L6" target="_blank" rel="noopener noreferrer">Source code: test_programs/execution_success/pedersen_hash/src/main.nr#L1-L6</a></sub></sup>
+
+
+<BlackBoxInfo to="../black_box_fns" />
+
+## pedersen_commitment
+
+Given an array of Fields, returns the Pedersen commitment.
+
+```rust title="pedersen_commitment" showLineNumbers 
+pub fn pedersen_commitment<let N: u32>(input: [Field; N]) -> EmbeddedCurvePoint {
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/hash/mod.nr#L29-L31" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/hash/mod.nr#L29-L31</a></sub></sup>
+
+
+example:
+
+```rust title="pedersen-commitment" showLineNumbers 
+fn main(x: Field, y: Field, expected_commitment: std::embedded_curve_ops::EmbeddedCurvePoint) {
+    let commitment = std::hash::pedersen_commitment([x, y]);
+    assert_eq(commitment.x, expected_commitment.x);
+    assert_eq(commitment.y, expected_commitment.y);
+}
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/test_programs/execution_success/pedersen_commitment/src/main.nr#L1-L7" target="_blank" rel="noopener noreferrer">Source code: test_programs/execution_success/pedersen_commitment/src/main.nr#L1-L7</a></sub></sup>
+
+
+<BlackBoxInfo to="../black_box_fns"/>
+
+## keccak256
+
+Given an array of bytes (`u8`), returns the resulting keccak hash as an array of
+32 bytes (`[u8; 32]`). Specify a message_size to hash only the first
+`message_size` bytes of the input.
+
+```rust title="keccak256" showLineNumbers 
+pub fn keccak256<let N: u32>(input: [u8; N], message_size: u32) -> [u8; 32]
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/hash/mod.nr#L116-L118" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/hash/mod.nr#L116-L118</a></sub></sup>
+
+
+example:
+
+```rust title="keccak256" showLineNumbers 
+fn main(x: Field, result: [u8; 32]) {
+    // We use the `as` keyword here to denote the fact that we want to take just the first byte from the x Field
+    // The padding is taken care of by the program
+    let digest = std::hash::keccak256([x as u8], 1);
+    assert(digest == result);
+
+    //#1399: variable message size
+    let message_size = 4;
+    let hash_a = std::hash::keccak256([1, 2, 3, 4], message_size);
+    let hash_b = std::hash::keccak256([1, 2, 3, 4, 0, 0, 0, 0], message_size);
+
+    assert(hash_a == hash_b);
+
+    let message_size_big = 8;
+    let hash_c = std::hash::keccak256([1, 2, 3, 4, 0, 0, 0, 0], message_size_big);
+
+    assert(hash_a != hash_c);
+}
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/test_programs/execution_success/keccak256/src/main.nr#L1-L20" target="_blank" rel="noopener noreferrer">Source code: test_programs/execution_success/keccak256/src/main.nr#L1-L20</a></sub></sup>
+
+
+<BlackBoxInfo to="../black_box_fns"/>
+
+## poseidon
+
+Given an array of Fields, returns a new Field with the Poseidon Hash. Mind that you need to specify
+how many inputs are there to your Poseidon function.
+
+```rust
+// example for hash_1, hash_2 accepts an array of length 2, etc
+fn hash_1(input: [Field; 1]) -> Field
+```
+
+example:
+
+```rust title="poseidon" showLineNumbers 
+use std::hash::poseidon;
+
+fn main(x1: [Field; 2], y1: pub Field, x2: [Field; 4], y2: pub Field) {
+    let hash1 = poseidon::bn254::hash_2(x1);
+    assert(hash1 == y1);
+
+    let hash2 = poseidon::bn254::hash_4(x2);
+    assert(hash2 == y2);
+}
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/test_programs/execution_success/poseidon_bn254_hash/src/main.nr#L1-L11" target="_blank" rel="noopener noreferrer">Source code: test_programs/execution_success/poseidon_bn254_hash/src/main.nr#L1-L11</a></sub></sup>
+
+
+## poseidon 2
+
+Given an array of Fields, returns a new Field with the Poseidon2 Hash. Contrary to the Poseidon
+function, there is only one hash and you can specify a message_size to hash only the first 
+`message_size` bytes of the input,
+
+```rust
+// example for hashing the first three elements of the input
+Poseidon2::hash(input, 3);
+```
+
+example:
+
+```rust title="poseidon2" showLineNumbers 
+use std::hash::poseidon2;
+
+fn main(inputs: [Field; 4], expected_hash: Field) {
+    let hash = poseidon2::Poseidon2::hash(inputs, inputs.len());
+    assert_eq(hash, expected_hash);
+}
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/test_programs/execution_success/poseidon2/src/main.nr#L1-L8" target="_blank" rel="noopener noreferrer">Source code: test_programs/execution_success/poseidon2/src/main.nr#L1-L8</a></sub></sup>
+
+
+## hash_to_field
+
+```rust
+fn hash_to_field(_input : [Field]) -> Field {}
+```
+
+Calculates the `blake2s` hash of the inputs and returns the hash modulo the field modulus to return
+a value which can be represented as a `Field`.
+
diff --git a/docs/versioned_docs/version-v0.39.0/noir/standard_library/cryptographic_primitives/index.md b/docs/versioned_docs/version-v0.39.0/noir/standard_library/cryptographic_primitives/index.md
new file mode 100644
index 00000000000..650f30165d5
--- /dev/null
+++ b/docs/versioned_docs/version-v0.39.0/noir/standard_library/cryptographic_primitives/index.md
@@ -0,0 +1,14 @@
+---
+title: Cryptographic Primitives
+description:
+  Learn about the cryptographic primitives ready to use for any Noir project
+keywords:
+  [
+    cryptographic primitives,
+    Noir project,
+  ]
+---
+
+The Noir team is progressively adding new cryptographic primitives to the standard library. Reach out for news or if you would be interested in adding more of these calculations in Noir.
+
+Some methods are available thanks to the Aztec backend, not being performed using Noir. When using other backends, these methods may or may not be supplied.
diff --git a/docs/versioned_docs/version-v0.39.0/noir/standard_library/cryptographic_primitives/schnorr.mdx b/docs/versioned_docs/version-v0.39.0/noir/standard_library/cryptographic_primitives/schnorr.mdx
new file mode 100644
index 00000000000..030452645c5
--- /dev/null
+++ b/docs/versioned_docs/version-v0.39.0/noir/standard_library/cryptographic_primitives/schnorr.mdx
@@ -0,0 +1,64 @@
+---
+title: Schnorr Signatures
+description: Learn how you can verify Schnorr signatures using Noir
+keywords: [cryptographic primitives, Noir project, schnorr, signatures]
+sidebar_position: 2
+---
+
+import BlackBoxInfo from '@site/src/components/Notes/_blackbox';
+
+## schnorr::verify_signature
+
+Verifier for Schnorr signatures over the embedded curve (for BN254 it is Grumpkin).
+See schnorr::verify_signature_slice for a version that works directly on slices.
+
+```rust title="schnorr_verify" showLineNumbers 
+pub fn verify_signature<let N: u32>(
+    public_key_x: Field,
+    public_key_y: Field,
+    signature: [u8; 64],
+    message: [u8; N],
+) -> bool
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/schnorr.nr#L4-L11" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/schnorr.nr#L4-L11</a></sub></sup>
+
+
+where `_signature` can be generated like so using the npm package
+[@noir-lang/barretenberg](https://www.npmjs.com/package/@noir-lang/barretenberg)
+
+```js
+const { BarretenbergWasm } = require('@noir-lang/barretenberg/dest/wasm');
+const { Schnorr } = require('@noir-lang/barretenberg/dest/crypto/schnorr');
+
+...
+
+const barretenberg = await BarretenbergWasm.new();
+const schnorr = new Schnorr(barretenberg);
+const pubKey = schnorr.computePublicKey(privateKey);
+const message = ...
+const signature = Array.from(
+    schnorr.constructSignature(hash, privateKey).toBuffer()
+);
+
+...
+```
+
+<BlackBoxInfo to="../black_box_fns"/>
+
+## schnorr::verify_signature_slice
+
+Verifier for Schnorr signatures over the embedded curve (for BN254 it is Grumpkin)
+where the message is a slice. 
+
+```rust title="schnorr_verify_slice" showLineNumbers 
+pub fn verify_signature_slice(
+    public_key_x: Field,
+    public_key_y: Field,
+    signature: [u8; 64],
+    message: [u8],
+) -> bool
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/schnorr.nr#L15-L22" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/schnorr.nr#L15-L22</a></sub></sup>
+
+
+<BlackBoxInfo to="../black_box_fns"/>
diff --git a/docs/versioned_docs/version-v0.39.0/noir/standard_library/fmtstr.md b/docs/versioned_docs/version-v0.39.0/noir/standard_library/fmtstr.md
new file mode 100644
index 00000000000..19809d60261
--- /dev/null
+++ b/docs/versioned_docs/version-v0.39.0/noir/standard_library/fmtstr.md
@@ -0,0 +1,17 @@
+---
+title: fmtstr
+---
+
+`fmtstr<N, T>` is the type resulting from using format string (`f"..."`).
+
+## Methods
+
+### quoted_contents
+
+```rust title="quoted_contents" showLineNumbers 
+pub comptime fn quoted_contents(self) -> Quoted {}
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/meta/format_string.nr#L3-L5" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/meta/format_string.nr#L3-L5</a></sub></sup>
+
+
+Returns the format string contents (that is, without the leading and trailing double quotes) as a `Quoted` value.
\ No newline at end of file
diff --git a/docs/versioned_docs/version-v0.39.0/noir/standard_library/is_unconstrained.md b/docs/versioned_docs/version-v0.39.0/noir/standard_library/is_unconstrained.md
new file mode 100644
index 00000000000..51bb1bda8f1
--- /dev/null
+++ b/docs/versioned_docs/version-v0.39.0/noir/standard_library/is_unconstrained.md
@@ -0,0 +1,69 @@
+---
+title: Is Unconstrained Function
+description:
+  The is_unconstrained function returns wether the context at that point of the program is unconstrained or not.
+keywords:
+  [
+    unconstrained
+  ]
+---
+
+It's very common for functions in circuits to take unconstrained hints of an expensive computation and then verify it. This is done by running the hint in an unconstrained context and then verifying the result in a constrained context.
+
+When a function is marked as unconstrained, any subsequent functions that it calls will also be run in an unconstrained context. However, if we are implementing a library function, other users might call it within an unconstrained context or a constrained one. Generally, in an unconstrained context we prefer just computing the result instead of taking a hint of it and verifying it, since that'd mean doing the same computation twice:
+
+```rust 
+
+fn my_expensive_computation(){
+  ...
+}
+
+unconstrained fn my_expensive_computation_hint(){
+  my_expensive_computation()
+}
+
+pub fn external_interface(){
+  my_expensive_computation_hint();
+  // verify my_expensive_computation: If external_interface is called from unconstrained, this is redundant
+  ...
+}
+
+```
+
+In order to improve the performance in an unconstrained context you can use the function at `std::runtime::is_unconstrained() -> bool`:
+
+
+```rust 
+use dep::std::runtime::is_unconstrained;
+
+fn my_expensive_computation(){
+  ...
+}
+
+unconstrained fn my_expensive_computation_hint(){
+  my_expensive_computation()
+}
+
+pub fn external_interface(){
+  if is_unconstrained() {
+    my_expensive_computation();
+  } else {
+    my_expensive_computation_hint();
+    // verify my_expensive_computation
+    ...
+  }
+}
+
+```
+
+The is_unconstrained result is resolved at compile time, so in unconstrained contexts the compiler removes the else branch, and in constrained contexts the compiler removes the if branch, reducing the amount of compute necessary to run external_interface.
+
+Note that using `is_unconstrained` in a `comptime` context will also return `true`:
+
+```
+fn main() {
+    comptime {
+        assert(is_unconstrained());
+    }
+}
+```
diff --git a/docs/versioned_docs/version-v0.39.0/noir/standard_library/logging.md b/docs/versioned_docs/version-v0.39.0/noir/standard_library/logging.md
new file mode 100644
index 00000000000..db75ef9f86f
--- /dev/null
+++ b/docs/versioned_docs/version-v0.39.0/noir/standard_library/logging.md
@@ -0,0 +1,78 @@
+---
+title: Logging
+description:
+  Learn how to use the println statement for debugging in Noir with this tutorial. Understand the
+  basics of logging in Noir and how to implement it in your code.
+keywords:
+  [
+    noir logging,
+    println statement,
+    print statement,
+    debugging in noir,
+    noir std library,
+    logging tutorial,
+    basic logging in noir,
+    noir logging implementation,
+    noir debugging techniques,
+    rust,
+  ]
+---
+
+The standard library provides two familiar statements you can use: `println` and `print`. Despite being a limited implementation of rust's `println!` and `print!` macros, these constructs can be useful for debugging.
+
+You can print the output of both statements in your Noir code by using the `nargo execute` command or the `--show-output` flag when using `nargo test` (provided there are print statements in your tests).
+
+It is recommended to use `nargo execute` if you want to debug failing constraints with `println` or `print` statements. This is due to every input in a test being a constant rather than a witness, so we issue an error during compilation while we only print during execution (which comes after compilation). Neither `println`, nor `print` are callable for failed constraints caught at compile time.
+
+Both `print` and `println` are generic functions which can work on integers, fields, strings, and even structs or expressions. Note however, that slices are currently unsupported. For example:
+
+```rust
+struct Person {
+    age: Field,
+    height: Field,
+}
+
+fn main(age: Field, height: Field) {
+    let person = Person {
+        age: age,
+        height: height,
+    };
+    println(person);
+    println(age + height);
+    println("Hello world!");
+}
+```
+
+You can print different types in the same statement (including strings) with a type called `fmtstr`. It can be specified in the same way as a normal string, just prepended with an "f" character:
+
+```rust
+  let fmt_str = f"i: {i}, j: {j}";
+  println(fmt_str);
+
+  let s = myStruct { y: x, x: y };
+  println(s);
+
+  println(f"i: {i}, s: {s}");
+
+  println(x);
+  println([x, y]);
+
+  let foo = fooStruct { my_struct: s, foo: 15 };
+  println(f"s: {s}, foo: {foo}");
+
+  println(15);       // prints 0x0f, implicit Field
+  println(-1 as u8); // prints 255
+  println(-1 as i8); // prints -1
+```
+
+Examples shown above are interchangeable between the two `print` statements:
+
+```rust
+let person = Person { age : age, height : height };
+
+println(person);
+print(person);
+
+println("Hello world!"); // Prints with a newline at the end of the input
+print("Hello world!");   // Prints the input and keeps cursor on the same line
+```
diff --git a/docs/versioned_docs/version-v0.39.0/noir/standard_library/mem.md b/docs/versioned_docs/version-v0.39.0/noir/standard_library/mem.md
new file mode 100644
index 00000000000..95d36ac2a72
--- /dev/null
+++ b/docs/versioned_docs/version-v0.39.0/noir/standard_library/mem.md
@@ -0,0 +1,52 @@
+---
+title: Memory Module
+description:
+  This module contains functions which manipulate memory in a low-level way
+keywords:
+  [
+    mem, memory, zeroed, transmute, checked_transmute
+  ]
+---
+
+# `std::mem::zeroed`
+
+```rust
+fn zeroed<T>() -> T
+```
+
+Returns a zeroed value of any type.
+This function is generally unsafe to use as the zeroed bit pattern is not guaranteed to be valid for all types.
+It can however, be useful in cases when the value is guaranteed not to be used such as in a BoundedVec library implementing a growable vector, up to a certain length, backed by an array.
+The array can be initialized with zeroed values which are guaranteed to be inaccessible until the vector is pushed to.
+Similarly, enumerations in noir can be implemented using this method by providing zeroed values for the unused variants.
+
+This function currently supports the following types:
+
+- Field
+- Bool
+- Uint
+- Array
+- Slice
+- String
+- Tuple
+- Functions
+  
+Using it on other types could result in unexpected behavior.
+
+# `std::mem::checked_transmute`
+
+```rust
+fn checked_transmute<T, U>(value: T) -> U
+```
+
+Transmutes a value of one type into the same value but with a new type `U`.
+
+This function is safe to use since both types are asserted to be equal later during compilation after the concrete values for generic types become known.
+This function is useful for cases where the compiler may fails a type check that is expected to pass where
+a user knows the two types to be equal. For example, when using arithmetic generics there are cases the compiler
+does not see as equal, such as `[Field; N*(A + B)]` and `[Field; N*A + N*B]`, which users may know to be equal.
+In these cases, `checked_transmute` can be used to cast the value to the desired type while also preserving safety
+by checking this equality once `N`, `A`, `B` are fully resolved.
+
+Note that since this safety check is performed after type checking rather than during, no error is issued if the function
+containing `checked_transmute` is never called.
diff --git a/docs/versioned_docs/version-v0.39.0/noir/standard_library/merkle_trees.md b/docs/versioned_docs/version-v0.39.0/noir/standard_library/merkle_trees.md
new file mode 100644
index 00000000000..6a9ebf72ada
--- /dev/null
+++ b/docs/versioned_docs/version-v0.39.0/noir/standard_library/merkle_trees.md
@@ -0,0 +1,58 @@
+---
+title: Merkle Trees
+description: Learn about Merkle Trees in Noir with this tutorial. Explore the basics of computing a merkle root using a proof, with examples.
+keywords:
+  [
+    Merkle trees in Noir,
+    Noir programming language,
+    check membership,
+    computing root from leaf,
+    Noir Merkle tree implementation,
+    Merkle tree tutorial,
+    Merkle tree code examples,
+    Noir libraries,
+    pedersen hash.,
+  ]
+---
+
+## compute_merkle_root
+
+Returns the root of the tree from the provided leaf and its hash path, using a [Pedersen hash](./cryptographic_primitives/hashes.mdx#pedersen_hash).
+
+```rust
+fn compute_merkle_root(leaf : Field, index : Field, hash_path: [Field]) -> Field
+```
+
+example:
+
+```rust
+/**
+    // these values are for this example only
+    index = "0"
+    priv_key = "0x000000000000000000000000000000000000000000000000000000616c696365"
+    secret = "0x1929ea3ab8d9106a899386883d9428f8256cfedb3c4f6b66bf4aa4d28a79988f"
+    note_hash_path = [
+    "0x1e61bdae0f027b1b2159e1f9d3f8d00fa668a952dddd822fda80dc745d6f65cc",
+    "0x0e4223f3925f98934393c74975142bd73079ab0621f4ee133cee050a3c194f1a",
+    "0x2fd7bb412155bf8693a3bd2a3e7581a679c95c68a052f835dddca85fa1569a40"
+    ]
+ */
+fn main(index: Field, priv_key: Field, secret: Field, note_hash_path: [Field; 3]) {
+
+    let pubkey = std::scalar_mul::fixed_base_embedded_curve(priv_key);
+    let pubkey_x = pubkey[0];
+    let pubkey_y = pubkey[1];
+    let note_commitment = std::hash::pedersen(&[pubkey_x, pubkey_y, secret]);
+
+    let root = std::merkle::compute_merkle_root(note_commitment[0], index, note_hash_path.as_slice());
+    println(root);
+}
+```
+
+To check merkle tree membership:
+
+1. Include a merkle root as a program input.
+2. Compute the merkle root of a given leaf, index and hash path.
+3. Assert the merkle roots are equal.
+
+For more info about merkle trees, see the Wikipedia [page](https://en.wikipedia.org/wiki/Merkle_tree).
diff --git a/docs/versioned_docs/version-v0.39.0/noir/standard_library/meta/ctstring.md b/docs/versioned_docs/version-v0.39.0/noir/standard_library/meta/ctstring.md
new file mode 100644
index 00000000000..b76f873ca03
--- /dev/null
+++ b/docs/versioned_docs/version-v0.39.0/noir/standard_library/meta/ctstring.md
@@ -0,0 +1,100 @@
+---
+title: CtString
+---
+
+`std::meta::ctstring` contains methods on the built-in `CtString` type which is
+a compile-time, dynamically-sized string type. Compared to `str<N>` and `fmtstr<N, T>`,
+`CtString` is useful because its size does not need to be specified in its type. This
+can be used for formatting items at compile-time or general string handling in `comptime`
+code.
+
+Since `fmtstr`s can be converted into `CtString`s, you can make use of their formatting
+abilities in CtStrings by formatting in `fmtstr`s then converting the result to a CtString
+afterward.
+
+## Traits
+
+### AsCtString
+
+```rust title="as-ctstring" showLineNumbers 
+pub trait AsCtString {
+    comptime fn as_ctstring(self) -> CtString;
+}
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/meta/ctstring.nr#L43-L47" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/meta/ctstring.nr#L43-L47</a></sub></sup>
+
+
+Converts an object into a compile-time string.
+
+Implementations:
+
+```rust
+impl<let N: u32> AsCtString for str<N> { ... }
+impl<let N: u32, T> AsCtString for fmtstr<N, T> { ... }
+```
+
+## Methods
+
+### new
+
+```rust title="new" showLineNumbers 
+pub comptime fn new() -> Self {
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/meta/ctstring.nr#L4-L6" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/meta/ctstring.nr#L4-L6</a></sub></sup>
+
+
+Creates an empty `CtString`.
+
+### append_str
+
+```rust title="append_str" showLineNumbers 
+pub comptime fn append_str<let N: u32>(self, s: str<N>) -> Self {
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/meta/ctstring.nr#L11-L13" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/meta/ctstring.nr#L11-L13</a></sub></sup>
+
+
+Returns a new CtString with the given str appended onto the end.
+
+### append_fmtstr
+
+```rust title="append_fmtstr" showLineNumbers 
+pub comptime fn append_fmtstr<let N: u32, T>(self, s: fmtstr<N, T>) -> Self {
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/meta/ctstring.nr#L17-L19" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/meta/ctstring.nr#L17-L19</a></sub></sup>
+
+
+Returns a new CtString with the given fmtstr appended onto the end.
+
+### as_quoted_str
+
+```rust title="as_quoted_str" showLineNumbers 
+pub comptime fn as_quoted_str(self) -> Quoted {
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/meta/ctstring.nr#L26-L28" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/meta/ctstring.nr#L26-L28</a></sub></sup>
+
+
+Returns a quoted string literal from this string's contents.
+
+There is no direct conversion from a `CtString` to a `str<N>` since
+the size would not be known. To get around this, this function can
+be used in combination with macro insertion (`!`) to insert this string
+literal at this function's call site.
+
+Example:
+
+```rust title="as_quoted_str_example" showLineNumbers 
+let my_ctstring = "foo bar".as_ctstring();
+            let my_str = my_ctstring.as_quoted_str!();
+
+            assert_eq(crate::meta::type_of(my_str), quote { str<7> }.as_type());
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/meta/ctstring.nr#L92-L97" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/meta/ctstring.nr#L92-L97</a></sub></sup>
+
+
+## Trait Implementations
+
+```rust
+impl Eq for CtString
+impl Hash for CtString
+impl Append for CtString
+```
diff --git a/docs/versioned_docs/version-v0.39.0/noir/standard_library/meta/expr.md b/docs/versioned_docs/version-v0.39.0/noir/standard_library/meta/expr.md
new file mode 100644
index 00000000000..b6d395c6700
--- /dev/null
+++ b/docs/versioned_docs/version-v0.39.0/noir/standard_library/meta/expr.md
@@ -0,0 +1,380 @@
+---
+title: Expr
+---
+
+`std::meta::expr` contains methods on the built-in `Expr` type for quoted, syntactically valid expressions.
+
+## Methods
+
+### as_array
+
+```rust title="as_array" showLineNumbers 
+pub comptime fn as_array(self) -> Option<[Expr]> {}
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/meta/expr.nr#L10-L12" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/meta/expr.nr#L10-L12</a></sub></sup>
+
+
+If this expression is an array, this returns a slice of each element in the array.
+
+### as_assert
+
+```rust title="as_assert" showLineNumbers 
+pub comptime fn as_assert(self) -> Option<(Expr, Option<Expr>)> {}
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/meta/expr.nr#L16-L18" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/meta/expr.nr#L16-L18</a></sub></sup>
+
+
+If this expression is an assert, this returns the assert expression and the optional message.
+
+### as_assert_eq
+
+```rust title="as_assert_eq" showLineNumbers 
+pub comptime fn as_assert_eq(self) -> Option<(Expr, Expr, Option<Expr>)> {}
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/meta/expr.nr#L23-L25" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/meta/expr.nr#L23-L25</a></sub></sup>
+
+
+If this expression is an assert_eq, this returns the left-hand-side and right-hand-side
+expressions, together with the optional message.
+
+### as_assign
+
+```rust title="as_assign" showLineNumbers 
+pub comptime fn as_assign(self) -> Option<(Expr, Expr)> {}
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/meta/expr.nr#L30-L32" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/meta/expr.nr#L30-L32</a></sub></sup>
+
+
+If this expression is an assignment, this returns a tuple with the left hand side
+and right hand side in order.
+
+### as_binary_op
+
+```rust title="as_binary_op" showLineNumbers 
+pub comptime fn as_binary_op(self) -> Option<(Expr, BinaryOp, Expr)> {}
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/meta/expr.nr#L37-L39" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/meta/expr.nr#L37-L39</a></sub></sup>
+
+
+If this expression is a binary operator operation `<lhs> <op> <rhs>`,
+return the left-hand side, operator, and the right-hand side of the operation.
+
+### as_block
+
+```rust title="as_block" showLineNumbers 
+pub comptime fn as_block(self) -> Option<[Expr]> {}
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/meta/expr.nr#L44-L46" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/meta/expr.nr#L44-L46</a></sub></sup>
+
+
+If this expression is a block `{ stmt1; stmt2; ...; stmtN }`, return
+a slice containing each statement.
+
+### as_bool
+
+```rust title="as_bool" showLineNumbers 
+pub comptime fn as_bool(self) -> Option<bool> {}
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/meta/expr.nr#L50-L52" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/meta/expr.nr#L50-L52</a></sub></sup>
+
+
+If this expression is a boolean literal, return that literal.
+
+### as_cast
+
+```rust title="as_cast" showLineNumbers 
+#[builtin(expr_as_cast)]
+    pub comptime fn as_cast(self) -> Option<(Expr, UnresolvedType)> {}
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/meta/expr.nr#L56-L59" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/meta/expr.nr#L56-L59</a></sub></sup>
+
+
+If this expression is a cast expression (`expr as type`), returns the casted
+expression and the type to cast to.
+
+### as_comptime
+
+```rust title="as_comptime" showLineNumbers 
+pub comptime fn as_comptime(self) -> Option<[Expr]> {}
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/meta/expr.nr#L64-L66" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/meta/expr.nr#L64-L66</a></sub></sup>
+
+
+If this expression is a `comptime { stmt1; stmt2; ...; stmtN }` block,
+return each statement in the block.
+
+### as_constructor
+
+```rust title="as_constructor" showLineNumbers 
+pub comptime fn as_constructor(self) -> Option<(UnresolvedType, [(Quoted, Expr)])> {}
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/meta/expr.nr#L71-L73" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/meta/expr.nr#L71-L73</a></sub></sup>
+
+
+If this expression is a constructor `Type { field1: expr1, ..., fieldN: exprN }`,
+return the type and the fields.
+
+### as_for
+
+```rust title="as_for" showLineNumbers 
+pub comptime fn as_for(self) -> Option<(Quoted, Expr, Expr)> {}
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/meta/expr.nr#L78-L80" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/meta/expr.nr#L78-L80</a></sub></sup>
+
+
+If this expression is a for statement over a single expression, return the identifier,
+the expression and the for loop body.
+
+### as_for_range
+
+```rust title="as_for" showLineNumbers 
+pub comptime fn as_for(self) -> Option<(Quoted, Expr, Expr)> {}
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/meta/expr.nr#L78-L80" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/meta/expr.nr#L78-L80</a></sub></sup>
+
+
+If this expression is a for statement over a range, return the identifier,
+the range start, the range end and the for loop body.
+
+### as_function_call
+
+```rust title="as_function_call" showLineNumbers 
+pub comptime fn as_function_call(self) -> Option<(Expr, [Expr])> {}
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/meta/expr.nr#L92-L94" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/meta/expr.nr#L92-L94</a></sub></sup>
+
+
+If this expression is a function call `foo(arg1, ..., argN)`, return
+the function and a slice of each argument.
+
+### as_if
+
+```rust title="as_if" showLineNumbers 
+pub comptime fn as_if(self) -> Option<(Expr, Expr, Option<Expr>)> {}
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/meta/expr.nr#L100-L102" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/meta/expr.nr#L100-L102</a></sub></sup>
+
+
+If this expression is an `if condition { then_branch } else { else_branch }`,
+return the condition, then branch, and else branch. If there is no else branch,
+`None` is returned for that branch instead.
+
+### as_index
+
+```rust title="as_index" showLineNumbers 
+pub comptime fn as_index(self) -> Option<(Expr, Expr)> {}
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/meta/expr.nr#L107-L109" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/meta/expr.nr#L107-L109</a></sub></sup>
+
+
+If this expression is an index into an array `array[index]`, return the
+array and the index.
+
+### as_integer
+
+```rust title="as_integer" showLineNumbers 
+pub comptime fn as_integer(self) -> Option<(Field, bool)> {}
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/meta/expr.nr#L114-L116" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/meta/expr.nr#L114-L116</a></sub></sup>
+
+
+If this expression is an integer literal, return the integer as a field
+as well as whether the integer is negative (true) or not (false).
+
+### as_lambda
+
+```rust title="as_lambda" showLineNumbers 
+pub comptime fn as_lambda(
+        self,
+    ) -> Option<([(Expr, Option<UnresolvedType>)], Option<UnresolvedType>, Expr)> {}
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/meta/expr.nr#L120-L124" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/meta/expr.nr#L120-L124</a></sub></sup>
+
+
+If this expression is a lambda, returns the parameters, return type and body.
+
+### as_let
+
+```rust title="as_let" showLineNumbers 
+pub comptime fn as_let(self) -> Option<(Expr, Option<UnresolvedType>, Expr)> {}
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/meta/expr.nr#L129-L131" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/meta/expr.nr#L129-L131</a></sub></sup>
+
+
+If this expression is a let statement, returns the let pattern as an `Expr`,
+the optional type annotation, and the assigned expression.
+
+### as_member_access
+
+```rust title="as_member_access" showLineNumbers 
+pub comptime fn as_member_access(self) -> Option<(Expr, Quoted)> {}
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/meta/expr.nr#L136-L138" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/meta/expr.nr#L136-L138</a></sub></sup>
+
+
+If this expression is a member access `foo.bar`, return the struct/tuple
+expression and the field. The field will be represented as a quoted value.
+
+### as_method_call
+
+```rust title="as_method_call" showLineNumbers 
+pub comptime fn as_method_call(self) -> Option<(Expr, Quoted, [UnresolvedType], [Expr])> {}
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/meta/expr.nr#L143-L145" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/meta/expr.nr#L143-L145</a></sub></sup>
+
+
+If this expression is a method call `foo.bar::<generic1, ..., genericM>(arg1, ..., argN)`, return
+the receiver, method name, a slice of each generic argument, and a slice of each argument.
+
+### as_repeated_element_array
+
+```rust title="as_repeated_element_array" showLineNumbers 
+pub comptime fn as_repeated_element_array(self) -> Option<(Expr, Expr)> {}
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/meta/expr.nr#L150-L152" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/meta/expr.nr#L150-L152</a></sub></sup>
+
+
+If this expression is a repeated element array `[elem; length]`, return
+the repeated element and the length expressions.
+
+### as_repeated_element_slice
+
+```rust title="as_repeated_element_slice" showLineNumbers 
+pub comptime fn as_repeated_element_slice(self) -> Option<(Expr, Expr)> {}
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/meta/expr.nr#L157-L159" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/meta/expr.nr#L157-L159</a></sub></sup>
+
+
+If this expression is a repeated element slice `[elem; length]`, return
+the repeated element and the length expressions.
+
+### as_slice
+
+```rust title="as_slice" showLineNumbers 
+pub comptime fn as_slice(self) -> Option<[Expr]> {}
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/meta/expr.nr#L164-L166" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/meta/expr.nr#L164-L166</a></sub></sup>
+
+
+If this expression is a slice literal `&[elem1, ..., elemN]`,
+return each element of the slice.
+
+### as_tuple
+
+```rust title="as_tuple" showLineNumbers 
+pub comptime fn as_tuple(self) -> Option<[Expr]> {}
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/meta/expr.nr#L171-L173" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/meta/expr.nr#L171-L173</a></sub></sup>
+
+
+If this expression is a tuple `(field1, ..., fieldN)`,
+return each element of the tuple.
+
+### as_unary_op
+
+```rust title="as_unary_op" showLineNumbers 
+pub comptime fn as_unary_op(self) -> Option<(UnaryOp, Expr)> {}
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/meta/expr.nr#L178-L180" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/meta/expr.nr#L178-L180</a></sub></sup>
+
+
+If this expression is a unary operation `<op> <rhs>`,
+return the unary operator as well as the right-hand side expression.
+
+### as_unsafe
+
+```rust title="as_unsafe" showLineNumbers 
+pub comptime fn as_unsafe(self) -> Option<[Expr]> {}
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/meta/expr.nr#L185-L187" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/meta/expr.nr#L185-L187</a></sub></sup>
+
+
+If this expression is an `unsafe { stmt1; ...; stmtN }` block,
+return each statement inside in a slice.
+
+### has_semicolon
+
+```rust title="has_semicolon" showLineNumbers 
+pub comptime fn has_semicolon(self) -> bool {}
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/meta/expr.nr#L206-L208" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/meta/expr.nr#L206-L208</a></sub></sup>
+
+
+`true` if this expression is trailed by a semicolon. E.g.
+
+```
+comptime {
+    let expr1 = quote { 1 + 2 }.as_expr().unwrap();
+    let expr2 = quote { 1 + 2; }.as_expr().unwrap();
+
+    assert(expr1.as_binary_op().is_some());
+    assert(expr2.as_binary_op().is_some());
+
+    assert(!expr1.has_semicolon());
+    assert(expr2.has_semicolon());
+}
+```
+
+### is_break
+
+```rust title="is_break" showLineNumbers 
+pub comptime fn is_break(self) -> bool {}
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/meta/expr.nr#L212-L214" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/meta/expr.nr#L212-L214</a></sub></sup>
+
+
+`true` if this expression is `break`.
+
+### is_continue
+
+```rust title="is_continue" showLineNumbers 
+pub comptime fn is_continue(self) -> bool {}
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/meta/expr.nr#L218-L220" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/meta/expr.nr#L218-L220</a></sub></sup>
+
+
+`true` if this expression is `continue`.
+
+### modify
+
+```rust title="modify" showLineNumbers 
+pub comptime fn modify<Env>(self, f: fn[Env](Expr) -> Option<Expr>) -> Expr {
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/meta/expr.nr#L229-L231" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/meta/expr.nr#L229-L231</a></sub></sup>
+
+
+Applies a mapping function to this expression and to all of its sub-expressions.
+`f` will be applied to each sub-expression first, then applied to the expression itself.
+
+This happens recursively for every expression within `self`.
+
+For example, calling `modify` on `(&[1], &[2, 3])` with an `f` that returns `Option::some`
+for expressions that are integers, doubling them, would return `(&[2], &[4, 6])`.
+
+### quoted
+
+```rust title="quoted" showLineNumbers 
+pub comptime fn quoted(self) -> Quoted {
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/meta/expr.nr#L266-L268" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/meta/expr.nr#L266-L268</a></sub></sup>
+
+
+Returns this expression as a `Quoted` value. It's the same as `quote { $self }`.
+
+### resolve
+
+```rust title="resolve" showLineNumbers 
+pub comptime fn resolve(self, in_function: Option<FunctionDefinition>) -> TypedExpr {}
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/meta/expr.nr#L282-L284" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/meta/expr.nr#L282-L284</a></sub></sup>
+
+
+Resolves and type-checks this expression and returns the result as a `TypedExpr`. 
+
+The `in_function` argument specifies where the expression is resolved:
+- If it's `none`, the expression is resolved in the function where `resolve` was called
+- If it's `some`, the expression is resolved in the given function
+
+If any names used by this expression are not in scope or if there are any type errors, 
+this will give compiler errors as if the expression was written directly into 
+the current `comptime` function.
\ No newline at end of file
diff --git a/docs/versioned_docs/version-v0.39.0/noir/standard_library/meta/function_def.md b/docs/versioned_docs/version-v0.39.0/noir/standard_library/meta/function_def.md
new file mode 100644
index 00000000000..b7f2ebdb889
--- /dev/null
+++ b/docs/versioned_docs/version-v0.39.0/noir/standard_library/meta/function_def.md
@@ -0,0 +1,166 @@
+---
+title: FunctionDefinition
+---
+
+`std::meta::function_def` contains methods on the built-in `FunctionDefinition` type representing
+a function definition in the source program.
+
+## Methods
+
+### add_attribute
+
+```rust title="add_attribute" showLineNumbers 
+pub comptime fn add_attribute<let N: u32>(self, attribute: str<N>) {}
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/meta/function_def.nr#L3-L5" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/meta/function_def.nr#L3-L5</a></sub></sup>
+
+
+Adds an attribute to the function. This is only valid
+on functions in the current crate which have not yet been resolved.
+This means any functions called at compile-time are invalid targets for this method.
+
+### body
+
+```rust title="body" showLineNumbers 
+pub comptime fn body(self) -> Expr {}
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/meta/function_def.nr#L8-L10" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/meta/function_def.nr#L8-L10</a></sub></sup>
+
+
+Returns the body of the function as an expression. This is only valid
+on functions in the current crate which have not yet been resolved.
+This means any functions called at compile-time are invalid targets for this method.
+
+### has_named_attribute
+
+```rust title="has_named_attribute" showLineNumbers 
+pub comptime fn has_named_attribute<let N: u32>(self, name: str<N>) -> bool {}
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/meta/function_def.nr#L13-L15" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/meta/function_def.nr#L13-L15</a></sub></sup>
+
+
+Returns true if this function has a custom attribute with the given name.
+
+### is_unconstrained
+
+```rust title="is_unconstrained" showLineNumbers 
+pub comptime fn is_unconstrained(self) -> bool {}
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/meta/function_def.nr#L18-L20" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/meta/function_def.nr#L18-L20</a></sub></sup>
+
+
+Returns true if this function is unconstrained.
+
+### module
+
+```rust title="module" showLineNumbers 
+pub comptime fn module(self) -> Module {}
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/meta/function_def.nr#L23-L25" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/meta/function_def.nr#L23-L25</a></sub></sup>
+
+
+Returns the module where the function is defined.
+
+### name
+
+```rust title="name" showLineNumbers 
+pub comptime fn name(self) -> Quoted {}
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/meta/function_def.nr#L28-L30" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/meta/function_def.nr#L28-L30</a></sub></sup>
+
+
+Returns the name of the function.
+
+### parameters
+
+```rust title="parameters" showLineNumbers 
+pub comptime fn parameters(self) -> [(Quoted, Type)] {}
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/meta/function_def.nr#L33-L35" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/meta/function_def.nr#L33-L35</a></sub></sup>
+
+
+Returns each parameter of the function as a tuple of (parameter pattern, parameter type).
+
+### return_type
+
+```rust title="return_type" showLineNumbers 
+pub comptime fn return_type(self) -> Type {}
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/meta/function_def.nr#L38-L40" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/meta/function_def.nr#L38-L40</a></sub></sup>
+
+
+The return type of the function.
+
+### set_body
+
+```rust title="set_body" showLineNumbers 
+pub comptime fn set_body(self, body: Expr) {}
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/meta/function_def.nr#L43-L45" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/meta/function_def.nr#L43-L45</a></sub></sup>
+
+
+Mutate the function body to a new expression. This is only valid
+on functions in the current crate which have not yet been resolved.
+This means any functions called at compile-time are invalid targets for this method.
+
+### set_parameters
+
+```rust title="set_parameters" showLineNumbers 
+pub comptime fn set_parameters(self, parameters: [(Quoted, Type)]) {}
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/meta/function_def.nr#L48-L50" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/meta/function_def.nr#L48-L50</a></sub></sup>
+
+
+Mutates the function's parameters to a new set of parameters. This is only valid
+on functions in the current crate which have not yet been resolved.
+This means any functions called at compile-time are invalid targets for this method.
+
+Expects a slice of (parameter pattern, parameter type) for each parameter. Requires
+each parameter pattern to be a syntactically valid parameter.
+
+### set_return_type
+
+```rust title="set_return_type" showLineNumbers 
+pub comptime fn set_return_type(self, return_type: Type) {}
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/meta/function_def.nr#L53-L55" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/meta/function_def.nr#L53-L55</a></sub></sup>
+
+
+Mutates the function's return type to a new type. This is only valid
+on functions in the current crate which have not yet been resolved.
+This means any functions called at compile-time are invalid targets for this method.
+
+### set_return_public
+
+```rust title="set_return_public" showLineNumbers 
+pub comptime fn set_return_public(self, public: bool) {}
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/meta/function_def.nr#L58-L60" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/meta/function_def.nr#L58-L60</a></sub></sup>
+
+
+Mutates the function's return visibility to public (if `true` is given) or private (if `false` is given).
+This is only valid on functions in the current crate which have not yet been resolved.
+This means any functions called at compile-time are invalid targets for this method.
+
+### set_unconstrained
+
+```rust title="set_unconstrained" showLineNumbers 
+pub comptime fn set_unconstrained(self, value: bool) {}
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/meta/function_def.nr#L66-L68" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/meta/function_def.nr#L66-L68</a></sub></sup>
+
+
+Mutates the function to be unconstrained (if `true` is given) or not (if `false` is given).
+This is only valid on functions in the current crate which have not yet been resolved.
+This means any functions called at compile-time are invalid targets for this method.
+
+## Trait Implementations
+
+```rust
+impl Eq for FunctionDefinition
+impl Hash for FunctionDefinition
+```
+
+Note that each function is assigned a unique ID internally and this is what is used for
+equality and hashing. So even functions with identical signatures and bodies may not
+be equal in this sense if they were originally different items in the source program.
diff --git a/docs/versioned_docs/version-v0.39.0/noir/standard_library/meta/index.md b/docs/versioned_docs/version-v0.39.0/noir/standard_library/meta/index.md
new file mode 100644
index 00000000000..14544c07442
--- /dev/null
+++ b/docs/versioned_docs/version-v0.39.0/noir/standard_library/meta/index.md
@@ -0,0 +1,224 @@
+---
+title: Metaprogramming
+description: Noir's Metaprogramming API
+keywords: [metaprogramming, comptime, macros, macro, quote, unquote]
+---
+
+`std::meta` is the entry point for Noir's metaprogramming API. This consists of `comptime` functions
+and types used for inspecting and modifying Noir programs.
+
+## Functions
+
+### type_of
+
+```rust title="type_of" showLineNumbers 
+pub comptime fn type_of<T>(x: T) -> Type {}
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/meta/mod.nr#L27-L29" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/meta/mod.nr#L27-L29</a></sub></sup>
+
+
+Returns the type of a variable at compile-time.
+
+Example:
+```rust
+comptime {
+    let x: i32 = 1;
+    let x_type: Type = std::meta::type_of(x);
+
+    assert_eq(x_type, quote { i32 }.as_type());
+}
+```
+
+### unquote
+
+```rust title="unquote" showLineNumbers 
+pub comptime fn unquote(code: Quoted) -> Quoted {
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/meta/mod.nr#L19-L21" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/meta/mod.nr#L19-L21</a></sub></sup>
+
+
+Unquotes the passed-in token stream where this function was called.
+
+Example:
+```rust
+comptime {
+    let code = quote { 1 + 2 };
+
+    // let x = 1 + 2;
+    let x = unquote!(code);
+}
+```
+
+### derive
+
+```rust title="derive" showLineNumbers 
+#[varargs]
+pub comptime fn derive(s: StructDefinition, traits: [TraitDefinition]) -> Quoted {
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/meta/mod.nr#L48-L51" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/meta/mod.nr#L48-L51</a></sub></sup>
+
+
+Attribute placed on struct definitions.
+
+Creates a trait impl for each trait passed in as an argument.
+To do this, the trait must have a derive handler registered
+with `derive_via` beforehand. The traits in the stdlib that
+can be derived this way are `Eq`, `Ord`, `Default`, and `Hash`.
+
+Example:
+```rust
+#[derive(Eq, Default)]
+struct Foo<T> {
+    x: i32,
+    y: T,
+}
+
+fn main() {
+    let foo1 = Foo::default();
+    let foo2 = Foo { x: 0, y: &[0] };
+    assert_eq(foo1, foo2);
+}
+```
+
+### derive_via
+
+```rust title="derive_via_signature" showLineNumbers 
+pub comptime fn derive_via(t: TraitDefinition, f: DeriveFunction) {
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/meta/mod.nr#L68-L70" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/meta/mod.nr#L68-L70</a></sub></sup>
+
+
+Attribute placed on trait definitions.
+
+Registers a function to create impls for the given trait
+when the trait is used in a `derive` call. Users may use
+this to register their own functions to enable their traits
+to be derived by `derive`.
+
+Because this function requires a function as an argument which
+should produce a trait impl for any given struct, users may find
+it helpful to use a function like `std::meta::make_trait_impl` to
+help creating these impls.
+
+Example:
+```rust
+#[derive_via(derive_do_nothing)]
+trait DoNothing {
+    fn do_nothing(self);
+}
+
+comptime fn derive_do_nothing(s: StructDefinition) -> Quoted {
+    let typ = s.as_type();
+    quote {
+        impl DoNothing for $typ {
+            fn do_nothing(self) {
+                println("Nothing");
+            }
+        }
+    }
+}
+```
+
+As another example, `derive_eq` in the stdlib is used to derive the `Eq`
+trait for any struct. It makes use of `make_trait_impl` to do this:
+
+```rust title="derive_eq" showLineNumbers 
+comptime fn derive_eq(s: StructDefinition) -> Quoted {
+    let signature = quote { fn eq(_self: Self, _other: Self) -> bool };
+    let for_each_field = |name| quote { (_self.$name == _other.$name) };
+    let body = |fields| {
+        if s.fields().len() == 0 {
+            quote { true }
+        } else {
+            fields
+        }
+    };
+    crate::meta::make_trait_impl(
+        s,
+        quote { Eq },
+        signature,
+        for_each_field,
+        quote { & },
+        body,
+    )
+}
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/cmp.nr#L10-L30" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/cmp.nr#L10-L30</a></sub></sup>
+
+
+### make_trait_impl
+
+```rust title="make_trait_impl" showLineNumbers 
+pub comptime fn make_trait_impl<Env1, Env2>(
+    s: StructDefinition,
+    trait_name: Quoted,
+    function_signature: Quoted,
+    for_each_field: fn[Env1](Quoted) -> Quoted,
+    join_fields_with: Quoted,
+    body: fn[Env2](Quoted) -> Quoted,
+) -> Quoted {
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/meta/mod.nr#L87-L96" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/meta/mod.nr#L87-L96</a></sub></sup>
+
+
+A helper function to more easily create trait impls while deriving traits.
+
+Note that this function only works for traits which:
+1. Have only one method
+2. Have no generics on the trait itself.
+  - E.g. Using this on a trait such as `trait Foo<T> { ... }` will result in the
+    generated impl incorrectly missing the `T` generic.
+
+If your trait fits these criteria then `make_trait_impl` is likely the easiest
+way to write your derive handler. The arguments are as follows:
+
+- `s`: The struct to make the impl for
+- `trait_name`: The name of the trait to derive. E.g. `quote { Eq }`.
+- `function_signature`: The signature of the trait method to derive. E.g. `fn eq(self, other: Self) -> bool`.
+- `for_each_field`: An operation to be performed on each field. E.g. `|name| quote { (self.$name == other.$name) }`.
+- `join_fields_with`: A separator to join each result of `for_each_field` with.
+  E.g. `quote { & }`. You can also use an empty `quote {}` for no separator.
+- `body`: The result of the field operations are passed into this function for any final processing.
+  This is the place to insert any setup/teardown code the trait requires. If the trait doesn't require
+  any such code, you can return the body as-is: `|body| body`.
+
+Example deriving `Hash`:
+
+```rust title="derive_hash" showLineNumbers 
+comptime fn derive_hash(s: StructDefinition) -> Quoted {
+    let name = quote { Hash };
+    let signature = quote { fn hash<H>(_self: Self, _state: &mut H) where H: std::hash::Hasher };
+    let for_each_field = |name| quote { _self.$name.hash(_state); };
+    crate::meta::make_trait_impl(
+        s,
+        name,
+        signature,
+        for_each_field,
+        quote {},
+        |fields| fields,
+    )
+}
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/hash/mod.nr#L137-L151" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/hash/mod.nr#L137-L151</a></sub></sup>
+
+
+Example deriving `Ord`:
+
+```rust title="derive_ord" showLineNumbers 
+comptime fn derive_ord(s: StructDefinition) -> Quoted {
+    let signature = quote { fn cmp(_self: Self, _other: Self) -> std::cmp::Ordering };
+    let for_each_field = |name| quote {
+        if result == std::cmp::Ordering::equal() {
+            result = _self.$name.cmp(_other.$name);
+        }
+    };
+    let body = |fields| quote {
+        let mut result = std::cmp::Ordering::equal();
+        $fields
+        result
+    };
+    crate::meta::make_trait_impl(s, quote { Ord }, signature, for_each_field, quote {}, body)
+}
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/cmp.nr#L216-L231" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/cmp.nr#L216-L231</a></sub></sup>
+
diff --git a/docs/versioned_docs/version-v0.39.0/noir/standard_library/meta/module.md b/docs/versioned_docs/version-v0.39.0/noir/standard_library/meta/module.md
new file mode 100644
index 00000000000..f47231972b7
--- /dev/null
+++ b/docs/versioned_docs/version-v0.39.0/noir/standard_library/meta/module.md
@@ -0,0 +1,82 @@
+---
+title: Module
+---
+
+`std::meta::module` contains methods on the built-in `Module` type which represents a module in the source program.
+Note that this type represents a module generally, it isn't limited to only `mod my_submodule { ... }`
+declarations in the source program.
+
+## Methods
+
+### add_item
+
+```rust title="add_item" showLineNumbers 
+pub comptime fn add_item(self, item: Quoted) {}
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/meta/module.nr#L3-L5" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/meta/module.nr#L3-L5</a></sub></sup>
+
+
+Adds a top-level item (a function, a struct, a global, etc.) to the module. 
+Adding multiple items in one go is also valid if the `Quoted` value has multiple items in it.  
+Note that the items are type-checked as if they are inside the module they are being added to.
+
+### functions
+
+```rust title="functions" showLineNumbers 
+pub comptime fn functions(self) -> [FunctionDefinition] {}
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/meta/module.nr#L18-L20" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/meta/module.nr#L18-L20</a></sub></sup>
+
+
+Returns each function defined in the module.
+
+### has_named_attribute
+
+```rust title="has_named_attribute" showLineNumbers 
+pub comptime fn has_named_attribute<let N: u32>(self, name: str<N>) -> bool {}
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/meta/module.nr#L8-L10" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/meta/module.nr#L8-L10</a></sub></sup>
+
+
+Returns true if this module has a custom attribute with the given name.
+
+### is_contract
+
+```rust title="is_contract" showLineNumbers 
+pub comptime fn is_contract(self) -> bool {}
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/meta/module.nr#L13-L15" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/meta/module.nr#L13-L15</a></sub></sup>
+
+
+`true` if this module is a contract module (was declared via `contract foo { ... }`).
+
+### name
+
+```rust title="name" showLineNumbers 
+pub comptime fn name(self) -> Quoted {}
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/meta/module.nr#L28-L30" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/meta/module.nr#L28-L30</a></sub></sup>
+
+
+Returns the name of the module.
+
+### structs
+
+```rust title="structs" showLineNumbers 
+pub comptime fn structs(self) -> [StructDefinition] {}
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/meta/module.nr#L23-L25" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/meta/module.nr#L23-L25</a></sub></sup>
+
+
+Returns each struct defined in the module.
+
+## Trait Implementations
+
+```rust
+impl Eq for Module
+impl Hash for Module
+```
+
+Note that each module is assigned a unique ID internally and this is what is used for
+equality and hashing. So even modules with identical names and contents may not
+be equal in this sense if they were originally different items in the source program.
diff --git a/docs/versioned_docs/version-v0.39.0/noir/standard_library/meta/op.md b/docs/versioned_docs/version-v0.39.0/noir/standard_library/meta/op.md
new file mode 100644
index 00000000000..03ea49ad8ec
--- /dev/null
+++ b/docs/versioned_docs/version-v0.39.0/noir/standard_library/meta/op.md
@@ -0,0 +1,244 @@
+---
+title: UnaryOp and BinaryOp
+---
+
+`std::meta::op` contains the `UnaryOp` and `BinaryOp` types as well as methods on them.
+These types are used to represent a unary or binary operator respectively in Noir source code.
+
+## Types
+
+### UnaryOp
+
+Represents a unary operator. One of `-`, `!`, `&mut`, or `*`.
+
+### Methods
+
+#### is_minus
+
+```rust title="is_minus" showLineNumbers 
+pub fn is_minus(self) -> bool {
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/meta/op.nr#L24-L26" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/meta/op.nr#L24-L26</a></sub></sup>
+
+
+Returns `true` if this operator is `-`.
+
+#### is_not
+
+```rust title="is_not" showLineNumbers 
+pub fn is_not(self) -> bool {
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/meta/op.nr#L30-L32" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/meta/op.nr#L30-L32</a></sub></sup>
+
+
+`true` if this operator is `!`
+
+#### is_mutable_reference
+
+```rust title="is_mutable_reference" showLineNumbers 
+pub fn is_mutable_reference(self) -> bool {
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/meta/op.nr#L36-L38" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/meta/op.nr#L36-L38</a></sub></sup>
+
+
+`true` if this operator is `&mut`
+
+#### is_dereference
+
+```rust title="is_dereference" showLineNumbers 
+pub fn is_dereference(self) -> bool {
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/meta/op.nr#L42-L44" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/meta/op.nr#L42-L44</a></sub></sup>
+
+
+`true` if this operator is `*`
+
+#### quoted
+
+```rust title="unary_quoted" showLineNumbers 
+pub comptime fn quoted(self) -> Quoted {
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/meta/op.nr#L48-L50" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/meta/op.nr#L48-L50</a></sub></sup>
+
+
+Returns this operator as a `Quoted` value.
+
+### Trait Implementations
+
+```rust
+impl Eq for UnaryOp
+impl Hash for UnaryOp
+```
+
+### BinaryOp
+
+Represents a binary operator. One of `+`, `-`, `*`, `/`, `%`, `==`, `!=`, `<`, `<=`, `>`, `>=`, `&`, `|`, `^`, `>>`, or `<<`.
+
+### Methods
+
+#### is_add
+
+```rust title="is_add" showLineNumbers 
+pub fn is_add(self) -> bool {
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/meta/op.nr#L86-L88" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/meta/op.nr#L86-L88</a></sub></sup>
+
+
+`true` if this operator is `+`
+
+#### is_subtract
+
+```rust title="is_subtract" showLineNumbers 
+pub fn is_subtract(self) -> bool {
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/meta/op.nr#L92-L94" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/meta/op.nr#L92-L94</a></sub></sup>
+
+
+`true` if this operator is `-`
+
+#### is_multiply
+
+```rust title="is_multiply" showLineNumbers 
+pub fn is_multiply(self) -> bool {
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/meta/op.nr#L98-L100" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/meta/op.nr#L98-L100</a></sub></sup>
+
+
+`true` if this operator is `*`
+
+#### is_divide
+
+```rust title="is_divide" showLineNumbers 
+pub fn is_divide(self) -> bool {
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/meta/op.nr#L104-L106" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/meta/op.nr#L104-L106</a></sub></sup>
+
+
+`true` if this operator is `/`
+
+#### is_modulo
+
+```rust title="is_modulo" showLineNumbers 
+pub fn is_modulo(self) -> bool {
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/meta/op.nr#L176-L178" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/meta/op.nr#L176-L178</a></sub></sup>
+
+
+`true` if this operator is `%`
+
+#### is_equal
+
+```rust title="is_equal" showLineNumbers 
+pub fn is_equal(self) -> bool {
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/meta/op.nr#L110-L112" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/meta/op.nr#L110-L112</a></sub></sup>
+
+
+`true` if this operator is `==`
+
+#### is_not_equal
+
+```rust title="is_not_equal" showLineNumbers 
+pub fn is_not_equal(self) -> bool {
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/meta/op.nr#L116-L118" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/meta/op.nr#L116-L118</a></sub></sup>
+
+
+`true` if this operator is `!=`
+
+#### is_less_than
+
+```rust title="is_less_than" showLineNumbers 
+pub fn is_less_than(self) -> bool {
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/meta/op.nr#L122-L124" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/meta/op.nr#L122-L124</a></sub></sup>
+
+
+`true` if this operator is `<`
+
+#### is_less_than_or_equal
+
+```rust title="is_less_than_or_equal" showLineNumbers 
+pub fn is_less_than_or_equal(self) -> bool {
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/meta/op.nr#L128-L130" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/meta/op.nr#L128-L130</a></sub></sup>
+
+
+`true` if this operator is `<=`
+
+#### is_greater_than
+
+```rust title="is_greater_than" showLineNumbers 
+pub fn is_greater_than(self) -> bool {
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/meta/op.nr#L134-L136" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/meta/op.nr#L134-L136</a></sub></sup>
+
+
+`true` if this operator is `>`
+
+#### is_greater_than_or_equal
+
+```rust title="is_greater_than_or_equal" showLineNumbers 
+pub fn is_greater_than_or_equal(self) -> bool {
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/meta/op.nr#L140-L142" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/meta/op.nr#L140-L142</a></sub></sup>
+
+
+`true` if this operator is `>=`
+
+#### is_and
+
+```rust title="is_and" showLineNumbers 
+pub fn is_and(self) -> bool {
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/meta/op.nr#L146-L148" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/meta/op.nr#L146-L148</a></sub></sup>
+
+
+`true` if this operator is `&`
+
+#### is_or
+
+```rust title="is_or" showLineNumbers 
+pub fn is_or(self) -> bool {
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/meta/op.nr#L152-L154" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/meta/op.nr#L152-L154</a></sub></sup>
+
+
+`true` if this operator is `|`
+
+#### is_shift_right
+
+```rust title="is_shift_right" showLineNumbers 
+pub fn is_shift_right(self) -> bool {
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/meta/op.nr#L164-L166" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/meta/op.nr#L164-L166</a></sub></sup>
+
+
+`true` if this operator is `>>`
+
+#### is_shift_left
+
+```rust title="is_shift_right" showLineNumbers 
+pub fn is_shift_right(self) -> bool {
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/meta/op.nr#L164-L166" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/meta/op.nr#L164-L166</a></sub></sup>
+
+
+`true` if this operator is `<<`
+
+#### quoted
+
+```rust title="binary_quoted" showLineNumbers 
+pub comptime fn quoted(self) -> Quoted {
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/meta/op.nr#L182-L184" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/meta/op.nr#L182-L184</a></sub></sup>
+
+
+Returns this operator as a `Quoted` value.
+
+### Trait Implementations
+
+```rust
+impl Eq for BinaryOp
+impl Hash for BinaryOp
+```
diff --git a/docs/versioned_docs/version-v0.39.0/noir/standard_library/meta/quoted.md b/docs/versioned_docs/version-v0.39.0/noir/standard_library/meta/quoted.md
new file mode 100644
index 00000000000..d7acf23bc07
--- /dev/null
+++ b/docs/versioned_docs/version-v0.39.0/noir/standard_library/meta/quoted.md
@@ -0,0 +1,141 @@
+---
+title: Quoted
+---
+
+`std::meta::quoted` contains methods on the built-in `Quoted` type which represents
+quoted token streams and is the result of the `quote { ... }` expression.
+
+## Methods
+
+### as_expr
+
+```rust title="as_expr" showLineNumbers 
+pub comptime fn as_expr(self) -> Option<Expr> {}
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/meta/quoted.nr#L6-L8" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/meta/quoted.nr#L6-L8</a></sub></sup>
+
+
+Parses the quoted token stream as an expression. Returns `Option::none()` if
+the expression failed to parse.
+
+Example:
+
+```rust title="as_expr_example" showLineNumbers 
+#[test]
+    fn test_expr_as_function_call() {
+        comptime
+        {
+            let expr = quote { foo(42) }.as_expr().unwrap();
+            let (_function, args) = expr.as_function_call().unwrap();
+            assert_eq(args.len(), 1);
+            assert_eq(args[0].as_integer().unwrap(), (42, false));
+        }
+    }
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/test_programs/noir_test_success/comptime_expr/src/main.nr#L360-L371" target="_blank" rel="noopener noreferrer">Source code: test_programs/noir_test_success/comptime_expr/src/main.nr#L360-L371</a></sub></sup>
+
+
+### as_module
+
+```rust title="as_module" showLineNumbers 
+pub comptime fn as_module(self) -> Option<Module> {}
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/meta/quoted.nr#L11-L13" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/meta/quoted.nr#L11-L13</a></sub></sup>
+
+
+Interprets this token stream as a module path leading to the name of a module.
+Returns `Option::none()` if the module isn't found or this token stream cannot be parsed as a path.
+
+Example:
+
+```rust title="as_module_example" showLineNumbers 
+mod baz {
+    pub mod qux {}
+}
+
+#[test]
+fn as_module_test() {
+    comptime {
+        let my_mod = quote { baz::qux }.as_module().unwrap();
+        assert_eq(my_mod.name(), quote { qux });
+    }
+}
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/test_programs/compile_success_empty/comptime_module/src/main.nr#L115-L127" target="_blank" rel="noopener noreferrer">Source code: test_programs/compile_success_empty/comptime_module/src/main.nr#L115-L127</a></sub></sup>
+
+
+### as_trait_constraint
+
+```rust title="as_trait_constraint" showLineNumbers 
+pub comptime fn as_trait_constraint(self) -> TraitConstraint {}
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/meta/quoted.nr#L16-L18" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/meta/quoted.nr#L16-L18</a></sub></sup>
+
+
+Interprets this token stream as a trait constraint (without an object type).
+Note that this function panics instead of returning `Option::none()` if the token
+stream does not parse and resolve to a valid trait constraint.
+
+Example:
+
+```rust title="implements_example" showLineNumbers 
+pub fn function_with_where<T>(_x: T)
+where
+    T: SomeTrait<i32>,
+{
+    comptime {
+        let t = quote { T }.as_type();
+        let some_trait_i32 = quote { SomeTrait<i32> }.as_trait_constraint();
+        assert(t.implements(some_trait_i32));
+
+        assert(t.get_trait_impl(some_trait_i32).is_none());
+    }
+}
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/test_programs/compile_success_empty/comptime_type/src/main.nr#L160-L173" target="_blank" rel="noopener noreferrer">Source code: test_programs/compile_success_empty/comptime_type/src/main.nr#L160-L173</a></sub></sup>
+
+
+### as_type
+
+```rust title="as_type" showLineNumbers 
+pub comptime fn as_type(self) -> Type {}
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/meta/quoted.nr#L21-L23" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/meta/quoted.nr#L21-L23</a></sub></sup>
+
+
+Interprets this token stream as a resolved type. Panics if the token
+stream doesn't parse to a type or if the type isn't a valid type in scope.
+
+```rust title="implements_example" showLineNumbers 
+pub fn function_with_where<T>(_x: T)
+where
+    T: SomeTrait<i32>,
+{
+    comptime {
+        let t = quote { T }.as_type();
+        let some_trait_i32 = quote { SomeTrait<i32> }.as_trait_constraint();
+        assert(t.implements(some_trait_i32));
+
+        assert(t.get_trait_impl(some_trait_i32).is_none());
+    }
+}
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/test_programs/compile_success_empty/comptime_type/src/main.nr#L160-L173" target="_blank" rel="noopener noreferrer">Source code: test_programs/compile_success_empty/comptime_type/src/main.nr#L160-L173</a></sub></sup>
+
+
+### tokens
+
+```rust title="tokens" showLineNumbers 
+pub comptime fn tokens(self) -> [Quoted] {}
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/meta/quoted.nr#L26-L28" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/meta/quoted.nr#L26-L28</a></sub></sup>
+
+
+Returns a slice of the individual tokens that form this token stream.
+
+## Trait Implementations
+
+```rust
+impl Eq for Quoted
+impl Hash for Quoted
+```
diff --git a/docs/versioned_docs/version-v0.39.0/noir/standard_library/meta/struct_def.md b/docs/versioned_docs/version-v0.39.0/noir/standard_library/meta/struct_def.md
new file mode 100644
index 00000000000..fd609942f4e
--- /dev/null
+++ b/docs/versioned_docs/version-v0.39.0/noir/standard_library/meta/struct_def.md
@@ -0,0 +1,177 @@
+---
+title: StructDefinition
+---
+
+`std::meta::struct_def` contains methods on the built-in `StructDefinition` type.
+This type corresponds to `struct Name { field1: Type1, ... }` items in the source program.
+
+## Methods
+
+### add_attribute
+
+```rust title="add_attribute" showLineNumbers 
+pub comptime fn add_attribute<let N: u32>(self, attribute: str<N>) {}
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/meta/struct_def.nr#L3-L5" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/meta/struct_def.nr#L3-L5</a></sub></sup>
+
+
+Adds an attribute to the struct.
+
+### add_generic
+
+```rust title="add_generic" showLineNumbers 
+pub comptime fn add_generic<let N: u32>(self, generic_name: str<N>) -> Type {}
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/meta/struct_def.nr#L8-L10" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/meta/struct_def.nr#L8-L10</a></sub></sup>
+
+
+Adds an generic to the struct. Returns the new generic type.
+Errors if the given generic name isn't a single identifier or if
+the struct already has a generic with the same name.
+
+This method should be used carefully, if there is existing code referring
+to the struct type it may be checked before this function is called and
+see the struct with the original number of generics. This method should
+thus be preferred to use on code generated from other macros and structs
+that are not used in function signatures.
+
+Example:
+
+```rust title="add-generic-example" showLineNumbers 
+comptime fn add_generic(s: StructDefinition) {
+        assert_eq(s.generics().len(), 0);
+        let new_generic = s.add_generic("T");
+
+        let generics = s.generics();
+        assert_eq(generics.len(), 1);
+        assert_eq(generics[0], new_generic);
+    }
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/test_programs/compile_success_empty/comptime_struct_definition/src/main.nr#L35-L44" target="_blank" rel="noopener noreferrer">Source code: test_programs/compile_success_empty/comptime_struct_definition/src/main.nr#L35-L44</a></sub></sup>
+
+
+### as_type
+
+```rust title="as_type" showLineNumbers 
+pub comptime fn as_type(self) -> Type {}
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/meta/struct_def.nr#L15-L17" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/meta/struct_def.nr#L15-L17</a></sub></sup>
+
+
+Returns this struct as a type in the source program. If this struct has
+any generics, the generics are also included as-is.
+
+### generics
+
+```rust title="generics" showLineNumbers 
+pub comptime fn generics(self) -> [Type] {}
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/meta/struct_def.nr#L26-L28" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/meta/struct_def.nr#L26-L28</a></sub></sup>
+
+
+Returns each generic on this struct.
+
+Example:
+
+```
+#[example]
+struct Foo<T, U> {
+    bar: [T; 2],
+    baz: Baz<U, U>,
+}
+
+comptime fn example(foo: StructDefinition) {
+    assert_eq(foo.generics().len(), 2);
+
+    // Fails because `T` isn't in scope
+    // let t = quote { T }.as_type();
+    // assert_eq(foo.generics()[0], t);
+}
+```
+
+### fields
+
+```rust title="fields" showLineNumbers 
+pub comptime fn fields(self) -> [(Quoted, Type)] {}
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/meta/struct_def.nr#L33-L35" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/meta/struct_def.nr#L33-L35</a></sub></sup>
+
+
+Returns each field of this struct as a pair of (field name, field type).
+
+### has_named_attribute
+
+```rust title="has_named_attribute" showLineNumbers 
+pub comptime fn has_named_attribute<let N: u32>(self, name: str<N>) -> bool {}
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/meta/struct_def.nr#L20-L22" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/meta/struct_def.nr#L20-L22</a></sub></sup>
+
+
+Returns true if this struct has a custom attribute with the given name.
+
+### module
+
+```rust title="module" showLineNumbers 
+pub comptime fn module(self) -> Module {}
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/meta/struct_def.nr#L38-L40" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/meta/struct_def.nr#L38-L40</a></sub></sup>
+
+
+Returns the module where the struct is defined.
+
+### name
+
+```rust title="name" showLineNumbers 
+pub comptime fn name(self) -> Quoted {}
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/meta/struct_def.nr#L43-L45" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/meta/struct_def.nr#L43-L45</a></sub></sup>
+
+
+Returns the name of this struct
+
+Note that the returned quoted value will be just the struct name, it will
+not be the full path to the struct, nor will it include any generics.
+
+### set_fields
+
+```rust title="set_fields" showLineNumbers 
+pub comptime fn set_fields(self, new_fields: [(Quoted, Type)]) {}
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/meta/struct_def.nr#L52-L54" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/meta/struct_def.nr#L52-L54</a></sub></sup>
+
+
+Sets the fields of this struct to the given fields list where each element
+is a pair of the field's name and the field's type. Expects each field name
+to be a single identifier. Note that this will override any previous fields
+on this struct. If those should be preserved, use `.fields()` to retrieve the
+current fields on the struct type and append the new fields from there.
+
+Example:
+
+```rust
+// Change this struct to:
+// struct Foo {
+//     a: u32,
+//     b: i8,
+// }
+#[mangle_fields]
+struct Foo { x: Field }
+
+comptime fn mangle_fields(s: StructDefinition) {
+    s.set_fields(&[
+        (quote { a }, quote { u32 }.as_type()),
+        (quote { b }, quote { i8 }.as_type()),
+    ]);
+}
+```
+
+## Trait Implementations
+
+```rust
+impl Eq for StructDefinition
+impl Hash for StructDefinition
+```
+
+Note that each struct is assigned a unique ID internally and this is what is used for
+equality and hashing. So even structs with identical generics and fields may not
+be equal in this sense if they were originally different items in the source program.
diff --git a/docs/versioned_docs/version-v0.39.0/noir/standard_library/meta/trait_constraint.md b/docs/versioned_docs/version-v0.39.0/noir/standard_library/meta/trait_constraint.md
new file mode 100644
index 00000000000..3106f732b5a
--- /dev/null
+++ b/docs/versioned_docs/version-v0.39.0/noir/standard_library/meta/trait_constraint.md
@@ -0,0 +1,17 @@
+---
+title: TraitConstraint
+---
+
+`std::meta::trait_constraint` contains methods on the built-in `TraitConstraint` type which represents
+a trait constraint that can be used to search for a trait implementation. This is similar
+syntactically to just the trait itself, but can also contain generic arguments. E.g. `Eq`, `Default`,
+`BuildHasher<Poseidon2Hasher>`.
+
+This type currently has no public methods but it can be used alongside `Type` in `implements` or `get_trait_impl`.
+
+## Trait Implementations
+
+```rust
+impl Eq for TraitConstraint
+impl Hash for TraitConstraint
+```
diff --git a/docs/versioned_docs/version-v0.39.0/noir/standard_library/meta/trait_def.md b/docs/versioned_docs/version-v0.39.0/noir/standard_library/meta/trait_def.md
new file mode 100644
index 00000000000..e661d3af7f1
--- /dev/null
+++ b/docs/versioned_docs/version-v0.39.0/noir/standard_library/meta/trait_def.md
@@ -0,0 +1,26 @@
+---
+title: TraitDefinition
+---
+
+`std::meta::trait_def` contains methods on the built-in `TraitDefinition` type. This type
+represents trait definitions such as `trait Foo { .. }` at the top-level of a program.
+
+## Methods
+
+### as_trait_constraint
+
+```rust title="as_trait_constraint" showLineNumbers 
+pub comptime fn as_trait_constraint(_self: Self) -> TraitConstraint {}
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/meta/trait_def.nr#L6-L8" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/meta/trait_def.nr#L6-L8</a></sub></sup>
+
+
+Converts this trait into a trait constraint. If there are any generics on this
+trait, they will be kept as-is without instantiating or replacing them.
+
+## Trait Implementations
+
+```rust
+impl Eq for TraitDefinition
+impl Hash for TraitDefinition
+```
diff --git a/docs/versioned_docs/version-v0.39.0/noir/standard_library/meta/trait_impl.md b/docs/versioned_docs/version-v0.39.0/noir/standard_library/meta/trait_impl.md
new file mode 100644
index 00000000000..a527617c1e6
--- /dev/null
+++ b/docs/versioned_docs/version-v0.39.0/noir/standard_library/meta/trait_impl.md
@@ -0,0 +1,60 @@
+---
+title: TraitImpl
+---
+
+`std::meta::trait_impl` contains methods on the built-in `TraitImpl` type which represents a trait
+implementation such as `impl Foo for Bar { ... }`.
+
+## Methods
+
+### trait_generic_args
+
+```rust title="trait_generic_args" showLineNumbers 
+pub comptime fn trait_generic_args(self) -> [Type] {}
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/meta/trait_impl.nr#L3-L5" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/meta/trait_impl.nr#L3-L5</a></sub></sup>
+
+
+Returns any generic arguments on the trait of this trait implementation, if any.
+
+```rs
+impl Foo<i32, Field> for Bar { ... }
+
+comptime {
+    let bar_type = quote { Bar }.as_type();
+    let foo = quote { Foo<i32, Field> }.as_trait_constraint();
+
+    let my_impl: TraitImpl = bar_type.get_trait_impl(foo).unwrap();
+
+    let generics = my_impl.trait_generic_args();
+    assert_eq(generics.len(), 2);
+
+    assert_eq(generics[0], quote { i32 }.as_type());
+    assert_eq(generics[1], quote { Field }.as_type());
+}
+```
+
+### methods
+
+```rust title="methods" showLineNumbers 
+pub comptime fn methods(self) -> [FunctionDefinition] {}
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/meta/trait_impl.nr#L8-L10" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/meta/trait_impl.nr#L8-L10</a></sub></sup>
+
+
+Returns each method in this trait impl.
+
+Example:
+
+```rs
+comptime {
+    let i32_type = quote { i32 }.as_type();
+    let eq = quote { Eq }.as_trait_constraint();
+
+    let impl_eq_for_i32: TraitImpl = i32_type.get_trait_impl(eq).unwrap();
+    let methods = impl_eq_for_i32.methods();
+
+    assert_eq(methods.len(), 1);
+    assert_eq(methods[0].name(), quote { eq });
+}
+```
diff --git a/docs/versioned_docs/version-v0.39.0/noir/standard_library/meta/typ.md b/docs/versioned_docs/version-v0.39.0/noir/standard_library/meta/typ.md
new file mode 100644
index 00000000000..90222c222f5
--- /dev/null
+++ b/docs/versioned_docs/version-v0.39.0/noir/standard_library/meta/typ.md
@@ -0,0 +1,264 @@
+---
+title: Type
+---
+
+`std::meta::typ` contains methods on the built-in `Type` type used for representing
+a type in the source program.
+
+## Functions
+
+```rust title="fresh_type_variable" showLineNumbers 
+pub comptime fn fresh_type_variable() -> Type {}
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/meta/typ.nr#L57-L59" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/meta/typ.nr#L57-L59</a></sub></sup>
+
+
+Creates and returns an unbound type variable. This is a special kind of type internal
+to type checking which will type check with any other type. When it is type checked
+against another type it will also be set to that type. For example, if `a` is a type
+variable and we have the type equality `(a, i32) = (u8, i32)`, the compiler will set
+`a` equal to `u8`.
+
+Unbound type variables will often be rendered as `_` while printing them. Bound type
+variables will appear as the type they are bound to.
+
+This can be used in conjunction with functions which internally perform type checks
+such as `Type::implements` or `Type::get_trait_impl` to potentially grab some of the types used.
+
+Note that calling `Type::implements` or `Type::get_trait_impl` on a type variable will always
+fail.
+
+Example:
+
+```rust title="serialize-setup" showLineNumbers 
+trait Serialize<let N: u32> {}
+
+impl Serialize<1> for Field {}
+
+impl<T, let N: u32, let M: u32> Serialize<N * M> for [T; N]
+where
+    T: Serialize<M>,
+{}
+
+impl<T, U, let N: u32, let M: u32> Serialize<N + M> for (T, U)
+where
+    T: Serialize<N>,
+    U: Serialize<M>,
+{}
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/test_programs/compile_success_empty/comptime_type/src/main.nr#L14-L29" target="_blank" rel="noopener noreferrer">Source code: test_programs/compile_success_empty/comptime_type/src/main.nr#L14-L29</a></sub></sup>
+
+```rust title="fresh-type-variable-example" showLineNumbers 
+let typevar1 = std::meta::typ::fresh_type_variable();
+        let constraint = quote { Serialize<$typevar1> }.as_trait_constraint();
+        let field_type = quote { Field }.as_type();
+
+        // Search for a trait impl (binding typevar1 to 1 when the impl is found):
+        assert(field_type.implements(constraint));
+
+        // typevar1 should be bound to the "1" generic now:
+        assert_eq(typevar1.as_constant().unwrap(), 1);
+
+        // If we want to do the same with a different type, we need to
+        // create a new type variable now that `typevar1` is bound
+        let typevar2 = std::meta::typ::fresh_type_variable();
+        let constraint = quote { Serialize<$typevar2> }.as_trait_constraint();
+        let array_type = quote { [(Field, Field); 5] }.as_type();
+        assert(array_type.implements(constraint));
+
+        // Now typevar2 should be bound to the serialized pair size 2 times the array length 5
+        assert_eq(typevar2.as_constant().unwrap(), 10);
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/test_programs/compile_success_empty/comptime_type/src/main.nr#L129-L149" target="_blank" rel="noopener noreferrer">Source code: test_programs/compile_success_empty/comptime_type/src/main.nr#L129-L149</a></sub></sup>
+
+
+## Methods
+
+### as_array
+
+```rust title="as_array" showLineNumbers 
+pub comptime fn as_array(self) -> Option<(Type, Type)> {}
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/meta/typ.nr#L76-L78" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/meta/typ.nr#L76-L78</a></sub></sup>
+
+
+If this type is an array, return a pair of (element type, size type).
+
+Example:
+
+```rust
+comptime {
+    let array_type = quote { [Field; 3] }.as_type();
+    let (field_type, three_type) = array_type.as_array().unwrap();
+
+    assert(field_type.is_field());
+    assert_eq(three_type.as_constant().unwrap(), 3);
+}
+```
+
+### as_constant
+
+```rust title="as_constant" showLineNumbers 
+pub comptime fn as_constant(self) -> Option<u32> {}
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/meta/typ.nr#L83-L85" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/meta/typ.nr#L83-L85</a></sub></sup>
+
+
+If this type is a constant integer (such as the `3` in the array type `[Field; 3]`),
+return the numeric constant.
+
+### as_integer
+
+```rust title="as_integer" showLineNumbers 
+pub comptime fn as_integer(self) -> Option<(bool, u8)> {}
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/meta/typ.nr#L90-L92" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/meta/typ.nr#L90-L92</a></sub></sup>
+
+
+If this is an integer type, return a boolean which is `true`
+if the type is signed, as well as the number of bits of this integer type.
+
+### as_mutable_reference
+
+```rust title="as_mutable_reference" showLineNumbers 
+comptime fn as_mutable_reference(self) -> Option<Type> {}
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/meta/typ.nr#L96-L98" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/meta/typ.nr#L96-L98</a></sub></sup>
+
+
+If this is a mutable reference type `&mut T`, returns the mutable type `T`.
+
+### as_slice
+
+```rust title="as_slice" showLineNumbers 
+pub comptime fn as_slice(self) -> Option<Type> {}
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/meta/typ.nr#L102-L104" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/meta/typ.nr#L102-L104</a></sub></sup>
+
+
+If this is a slice type, return the element type of the slice.
+
+### as_str
+
+```rust title="as_str" showLineNumbers 
+pub comptime fn as_str(self) -> Option<Type> {}
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/meta/typ.nr#L108-L110" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/meta/typ.nr#L108-L110</a></sub></sup>
+
+
+If this is a `str<N>` type, returns the length `N` as a type.
+
+### as_struct
+
+```rust title="as_struct" showLineNumbers 
+pub comptime fn as_struct(self) -> Option<(StructDefinition, [Type])> {}
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/meta/typ.nr#L114-L116" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/meta/typ.nr#L114-L116</a></sub></sup>
+
+
+If this is a struct type, returns the struct in addition to
+any generic arguments on this type.
+
+### as_tuple
+
+```rust title="as_tuple" showLineNumbers 
+pub comptime fn as_tuple(self) -> Option<[Type]> {}
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/meta/typ.nr#L120-L122" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/meta/typ.nr#L120-L122</a></sub></sup>
+
+
+If this is a tuple type, returns each element type of the tuple.
+
+### get_trait_impl
+
+```rust title="get_trait_impl" showLineNumbers 
+pub comptime fn get_trait_impl(self, constraint: TraitConstraint) -> Option<TraitImpl> {}
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/meta/typ.nr#L143-L145" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/meta/typ.nr#L143-L145</a></sub></sup>
+
+
+Retrieves the trait implementation that implements the given
+trait constraint for this type. If the trait constraint is not
+found, `None` is returned. Note that since the concrete trait implementation
+for a trait constraint specified from a `where` clause is unknown,
+this function will return `None` in these cases. If you only want to know
+whether a type implements a trait, use `implements` instead.
+
+Example:
+
+```rust
+comptime {
+    let field_type = quote { Field }.as_type();
+    let default = quote { Default }.as_trait_constraint();
+
+    let the_impl: TraitImpl = field_type.get_trait_impl(default).unwrap();
+    assert(the_impl.methods().len(), 1);
+}
+```
+
+### implements
+
+```rust title="implements" showLineNumbers 
+pub comptime fn implements(self, constraint: TraitConstraint) -> bool {}
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/meta/typ.nr#L166-L168" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/meta/typ.nr#L166-L168</a></sub></sup>
+
+
+`true` if this type implements the given trait. Note that unlike
+`get_trait_impl` this will also return true for any `where` constraints
+in scope.
+
+Example:
+
+```rust
+fn foo<T>() where T: Default {
+    comptime {
+        let field_type = quote { Field }.as_type();
+        let default = quote { Default }.as_trait_constraint();
+        assert(field_type.implements(default));
+
+        let t = quote { T }.as_type();
+        assert(t.implements(default));
+    }
+}
+```
+
+### is_bool
+
+```rust title="is_bool" showLineNumbers 
+pub comptime fn is_bool(self) -> bool {}
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/meta/typ.nr#L172-L174" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/meta/typ.nr#L172-L174</a></sub></sup>
+
+
+`true` if this type is `bool`.
+
+### is_field
+
+```rust title="is_field" showLineNumbers 
+pub comptime fn is_field(self) -> bool {}
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/meta/typ.nr#L178-L180" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/meta/typ.nr#L178-L180</a></sub></sup>
+
+
+`true` if this type is `Field`.
+
+### is_unit
+
+```rust title="is_unit" showLineNumbers 
+comptime fn is_unit(self) -> bool {}
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/meta/typ.nr#L184-L186" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/meta/typ.nr#L184-L186</a></sub></sup>
+
+
+`true` if this type is the unit `()` type.
+
+## Trait Implementations
+
+```rust
+impl Eq for Type
+impl Hash for Type
+```
+Note that this is syntactic equality, this is not the same as whether two types will type check
+to be the same type. Unless type inference or generics are being used however, users should not
+typically have to worry about this distinction unless `std::meta::typ::fresh_type_variable` is used.
diff --git a/docs/versioned_docs/version-v0.39.0/noir/standard_library/meta/typed_expr.md b/docs/versioned_docs/version-v0.39.0/noir/standard_library/meta/typed_expr.md
new file mode 100644
index 00000000000..0db7dbfef61
--- /dev/null
+++ b/docs/versioned_docs/version-v0.39.0/noir/standard_library/meta/typed_expr.md
@@ -0,0 +1,27 @@
+---
+title: TypedExpr
+---
+
+`std::meta::typed_expr` contains methods on the built-in `TypedExpr` type for resolved and type-checked expressions.
+
+## Methods
+
+### get_type
+
+```rust title="as_function_definition" showLineNumbers 
+pub comptime fn as_function_definition(self) -> Option<FunctionDefinition> {}
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/meta/typed_expr.nr#L7-L9" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/meta/typed_expr.nr#L7-L9</a></sub></sup>
+
+
+If this expression refers to a function definitions, returns it. Otherwise returns `Option::none()`.
+
+### get_type
+
+```rust title="get_type" showLineNumbers 
+pub comptime fn get_type(self) -> Option<Type> {}
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/meta/typed_expr.nr#L13-L15" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/meta/typed_expr.nr#L13-L15</a></sub></sup>
+
+
+Returns the type of the expression, or `Option::none()` if there were errors when the expression was previously resolved.
\ No newline at end of file
diff --git a/docs/versioned_docs/version-v0.39.0/noir/standard_library/meta/unresolved_type.md b/docs/versioned_docs/version-v0.39.0/noir/standard_library/meta/unresolved_type.md
new file mode 100644
index 00000000000..2826ec5ec0f
--- /dev/null
+++ b/docs/versioned_docs/version-v0.39.0/noir/standard_library/meta/unresolved_type.md
@@ -0,0 +1,57 @@
+---
+title: UnresolvedType
+---
+
+`std::meta::unresolved_type` contains methods on the built-in `UnresolvedType` type for the syntax of types.
+
+## Methods
+
+### as_mutable_reference
+
+```rust title="as_mutable_reference" showLineNumbers 
+comptime fn as_mutable_reference(self) -> Option<UnresolvedType> {}
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/meta/unresolved_type.nr#L8-L10" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/meta/unresolved_type.nr#L8-L10</a></sub></sup>
+
+
+If this is a mutable reference type `&mut T`, returns the mutable type `T`.
+
+### as_slice
+
+```rust title="as_slice" showLineNumbers 
+comptime fn as_slice(self) -> Option<UnresolvedType> {}
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/meta/unresolved_type.nr#L14-L16" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/meta/unresolved_type.nr#L14-L16</a></sub></sup>
+
+
+If this is a slice `&[T]`, returns the element type `T`.
+
+### is_bool
+
+```rust title="is_bool" showLineNumbers 
+comptime fn is_bool(self) -> bool {}
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/meta/unresolved_type.nr#L20-L22" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/meta/unresolved_type.nr#L20-L22</a></sub></sup>
+
+
+Returns `true` if this type is `bool`.
+
+### is_field
+
+```rust title="is_field" showLineNumbers 
+pub comptime fn is_field(self) -> bool {}
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/meta/unresolved_type.nr#L26-L28" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/meta/unresolved_type.nr#L26-L28</a></sub></sup>
+
+
+Returns true if this type refers to the Field type.
+
+### is_unit
+
+```rust title="is_unit" showLineNumbers 
+comptime fn is_unit(self) -> bool {}
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/meta/unresolved_type.nr#L32-L34" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/meta/unresolved_type.nr#L32-L34</a></sub></sup>
+
+
+Returns true if this type is the unit `()` type.
diff --git a/docs/versioned_docs/version-v0.39.0/noir/standard_library/options.md b/docs/versioned_docs/version-v0.39.0/noir/standard_library/options.md
new file mode 100644
index 00000000000..a1bd4e1de5f
--- /dev/null
+++ b/docs/versioned_docs/version-v0.39.0/noir/standard_library/options.md
@@ -0,0 +1,101 @@
+---
+title: Option<T> Type
+---
+
+The `Option<T>` type is a way to express that a value might be present (`Some(T))` or absent (`None`). It's a safer way to handle potential absence of values, compared to using nulls in many other languages.
+
+```rust
+struct Option<T> {
+    None,
+    Some(T),
+}
+```
+
+The `Option` type, already imported into your Noir program, can be used directly:
+
+```rust
+fn main() {
+    let none = Option::none();
+    let some = Option::some(3);
+}
+```
+
+See [this test](https://github.com/noir-lang/noir/blob/5cbfb9c4a06c8865c98ff2b594464b037d821a5c/crates/nargo_cli/tests/test_data/option/src/main.nr) for a more comprehensive set of examples of each of the methods described below.
+
+## Methods
+
+### none
+
+Constructs a none value.
+
+### some
+
+Constructs a some wrapper around a given value.
+
+### is_none
+
+Returns true if the Option is None.
+
+### is_some
+
+Returns true of the Option is Some.
+
+### unwrap
+
+Asserts `self.is_some()` and returns the wrapped value.
+
+### unwrap_unchecked
+
+Returns the inner value without asserting `self.is_some()`. This method can be useful within an if condition when we already know that `option.is_some()`. If the option is None, there is no guarantee what value will be returned, only that it will be of type T for an `Option<T>`.
+
+### unwrap_or
+
+Returns the wrapped value if `self.is_some()`. Otherwise, returns the given default value.
+
+### unwrap_or_else
+
+Returns the wrapped value if `self.is_some()`. Otherwise, calls the given function to return a default value.
+
+### expect
+
+Asserts `self.is_some()` with a provided custom message and returns the contained `Some` value. The custom message is expected to be a format string.
+
+### map
+
+If self is `Some(x)`, this returns `Some(f(x))`. Otherwise, this returns `None`.
+
+### map_or
+
+If self is `Some(x)`, this returns `f(x)`. Otherwise, this returns the given default value.
+
+### map_or_else
+
+If self is `Some(x)`, this returns `f(x)`. Otherwise, this returns `default()`.
+
+### and
+
+Returns None if self is None. Otherwise, this returns `other`.
+
+### and_then
+
+If self is None, this returns None. Otherwise, this calls the given function with the Some value contained within self, and returns the result of that call. In some languages this function is called `flat_map` or `bind`.
+
+### or
+
+If self is Some, return self. Otherwise, return `other`.
+
+### or_else
+
+If self is Some, return self. Otherwise, return `default()`.
+
+### xor
+
+If only one of the two Options is Some, return that option. Otherwise, if both options are Some or both are None, None is returned.
+
+### filter
+
+Returns `Some(x)` if self is `Some(x)` and `predicate(x)` is true. Otherwise, this returns `None`.
+
+### flatten
+
+Flattens an `Option<Option<T>>` into a `Option<T>`. This returns `None` if the outer Option is None. Otherwise, this returns the inner Option.
diff --git a/docs/versioned_docs/version-v0.39.0/noir/standard_library/recursion.mdx b/docs/versioned_docs/version-v0.39.0/noir/standard_library/recursion.mdx
new file mode 100644
index 00000000000..fcb36278060
--- /dev/null
+++ b/docs/versioned_docs/version-v0.39.0/noir/standard_library/recursion.mdx
@@ -0,0 +1,67 @@
+---
+title: Recursive Proofs
+description: Learn about how to write recursive proofs in Noir.
+keywords: [recursion, recursive proofs, verification_key, verify_proof]
+---
+
+import BlackBoxInfo from '@site/src/components/Notes/_blackbox';
+
+Noir supports recursively verifying proofs, meaning you verify the proof of a Noir program in another Noir program. This enables creating proofs of arbitrary size by doing step-wise verification of smaller components of a large proof.
+
+Read [the explainer on recursion](../../explainers/explainer-recursion.md) to know more about this function and the [guide on how to use it.](../../how_to/how-to-recursion.md)
+
+## Verifying Recursive Proofs
+
+```rust
+#[foreign(recursive_aggregation)]
+pub fn verify_proof(verification_key: [Field], proof: [Field], public_inputs: [Field], key_hash: Field) {}
+```
+
+<BlackBoxInfo to="black_box_fns"/>
+
+## Example usage
+
+```rust
+
+fn main(
+    verification_key : [Field; 114],
+    proof : [Field; 93],
+    public_inputs : [Field; 1],
+    key_hash : Field,
+    proof_b : [Field; 93],
+) {
+    std::verify_proof(
+        verification_key,
+        proof,
+        public_inputs,
+        key_hash
+    );
+
+    std::verify_proof(
+        verification_key,
+        proof_b,
+        public_inputs,
+        key_hash
+    );
+}
+```
+
+You can see a full example of recursive proofs in [this example recursion demo repo](https://github.com/noir-lang/noir-examples/tree/master/recursion).
+
+## Parameters
+
+### `verification_key`
+
+The verification key for the zk program that is being verified.
+
+### `proof`
+
+The proof for the zk program that is being verified.
+
+### `public_inputs`
+
+These represent the public inputs of the proof we are verifying.
+
+### `key_hash`
+
+A key hash is used to check the validity of the verification key. The circuit implementing this opcode can use this hash to ensure that the key provided to the circuit matches the key produced by the circuit creator.
diff --git a/docs/versioned_docs/version-v0.39.0/noir/standard_library/traits.md b/docs/versioned_docs/version-v0.39.0/noir/standard_library/traits.md
new file mode 100644
index 00000000000..ee20f9cd949
--- /dev/null
+++ b/docs/versioned_docs/version-v0.39.0/noir/standard_library/traits.md
@@ -0,0 +1,628 @@
+---
+title: Traits
+description: Noir's stdlib provides a few commonly used traits.
+keywords: [traits, trait, interface, protocol, default, add, eq]
+---
+
+## `std::default`
+
+### `std::default::Default`
+
+```rust title="default-trait" showLineNumbers 
+pub trait Default {
+    fn default() -> Self;
+}
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/default.nr#L4-L8" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/default.nr#L4-L8</a></sub></sup>
+
+
+Constructs a default value of a type.
+
+Implementations:
+```rust
+impl Default for Field { .. }
+
+impl Default for i8 { .. }
+impl Default for i16 { .. }
+impl Default for i32 { .. }
+impl Default for i64 { .. }
+
+impl Default for u8 { .. }
+impl Default for u16 { .. }
+impl Default for u32 { .. }
+impl Default for u64 { .. }
+
+impl Default for () { .. }
+impl Default for bool { .. }
+
+impl<T, N> Default for [T; N]
+    where T: Default { .. }
+
+impl<T> Default for [T] { .. }
+
+impl<A, B> Default for (A, B)
+    where A: Default, B: Default { .. }
+
+impl<A, B, C> Default for (A, B, C)
+    where A: Default, B: Default, C: Default { .. }
+
+impl<A, B, C, D> Default for (A, B, C, D)
+    where A: Default, B: Default, C: Default, D: Default { .. }
+
+impl<A, B, C, D, E> Default for (A, B, C, D, E)
+    where A: Default, B: Default, C: Default, D: Default, E: Default { .. }
+```
+
+For primitive integer types, the return value of `default` is `0`. Container
+types such as arrays are filled with default values of their element type,
+except slices whose length is unknown and thus defaulted to zero.
+
+---
+
+## `std::convert`
+
+### `std::convert::From`
+
+```rust title="from-trait" showLineNumbers 
+pub trait From<T> {
+    fn from(input: T) -> Self;
+}
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/convert.nr#L1-L5" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/convert.nr#L1-L5</a></sub></sup>
+
+
+The `From` trait defines how to convert from a given type `T` to the type on which the trait is implemented.
+
+The Noir standard library provides a number of implementations of `From` between primitive types.
+```rust title="from-impls" showLineNumbers 
+// Unsigned integers
+
+impl From<u8> for u32 {
+    fn from(value: u8) -> u32 {
+        value as u32
+    }
+}
+
+impl From<u8> for u64 {
+    fn from(value: u8) -> u64 {
+        value as u64
+    }
+}
+impl From<u32> for u64 {
+    fn from(value: u32) -> u64 {
+        value as u64
+    }
+}
+
+impl From<u8> for Field {
+    fn from(value: u8) -> Field {
+        value as Field
+    }
+}
+impl From<u32> for Field {
+    fn from(value: u32) -> Field {
+        value as Field
+    }
+}
+impl From<u64> for Field {
+    fn from(value: u64) -> Field {
+        value as Field
+    }
+}
+
+// Signed integers
+
+impl From<i8> for i32 {
+    fn from(value: i8) -> i32 {
+        value as i32
+    }
+}
+
+impl From<i8> for i64 {
+    fn from(value: i8) -> i64 {
+        value as i64
+    }
+}
+impl From<i32> for i64 {
+    fn from(value: i32) -> i64 {
+        value as i64
+    }
+}
+
+// Booleans
+impl From<bool> for u8 {
+    fn from(value: bool) -> u8 {
+        value as u8
+    }
+}
+impl From<bool> for u32 {
+    fn from(value: bool) -> u32 {
+        value as u32
+    }
+}
+impl From<bool> for u64 {
+    fn from(value: bool) -> u64 {
+        value as u64
+    }
+}
+impl From<bool> for i8 {
+    fn from(value: bool) -> i8 {
+        value as i8
+    }
+}
+impl From<bool> for i32 {
+    fn from(value: bool) -> i32 {
+        value as i32
+    }
+}
+impl From<bool> for i64 {
+    fn from(value: bool) -> i64 {
+        value as i64
+    }
+}
+impl From<bool> for Field {
+    fn from(value: bool) -> Field {
+        value as Field
+    }
+}
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/convert.nr#L28-L119" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/convert.nr#L28-L119</a></sub></sup>
+
+
+#### When to implement `From`
+
+As a general rule of thumb, `From` may be implemented in the [situations where it would be suitable in Rust](https://doc.rust-lang.org/std/convert/trait.From.html#when-to-implement-from):
+
+- The conversion is *infallible*: Noir does not provide an equivalent to Rust's `TryFrom`, if the conversion can fail then provide a named method instead.
+- The conversion is *lossless*: semantically, it should not lose or discard information. For example, `u32: From<u16>` can losslessly convert any `u16` into a valid `u32` such that the original `u16` can be recovered. On the other hand, `u16: From<u32>` should not be implemented as `2**16` is a `u32` which cannot be losslessly converted into a `u16`.
+- The conversion is *value-preserving*: the conceptual kind and meaning of the resulting value is the same, even though the Noir type and technical representation might be different. While it's possible to infallibly and losslessly convert a `u8` into a `str<2>` hex representation, `4u8` and `"04"` are too different for `str<2>: From<u8>` to be implemented.
+- The conversion is *obvious*: it's the only reasonable conversion between the two types. If there's ambiguity on how to convert between them such that the same input could potentially map to two different values then a named method should be used. For instance rather than implementing `U128: From<[u8; 16]>`, the methods `U128::from_le_bytes` and `U128::from_be_bytes` are used as otherwise the endianness of the array would be ambiguous, resulting in two potential values of `U128` from the same byte array.
+
+One additional recommendation specific to Noir is:
+- The conversion is *efficient*: it's relatively cheap to convert between the two types. Due to being a ZK DSL, it's more important to avoid unnecessary computation compared to Rust. If the implementation of `From` would encourage users to perform unnecessary conversion, resulting in additional proving time, then it may be preferable to expose functionality such that this conversion may be avoided.
+
+### `std::convert::Into`
+
+The `Into` trait is defined as the reciprocal of `From`. It should be easy to convince yourself that if we can convert to type `A` from type `B`, then it's possible to convert type `B` into type `A`.
+
+For this reason, implementing `From` on a type will automatically generate a matching `Into` implementation. One should always prefer implementing `From` over `Into` as implementing `Into` will not generate a matching `From` implementation.
+
+```rust title="into-trait" showLineNumbers 
+pub trait Into<T> {
+    fn into(self) -> T;
+}
+
+impl<T, U> Into<T> for U
+where
+    T: From<U>,
+{
+    fn into(self) -> T {
+        T::from(self)
+    }
+}
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/convert.nr#L13-L26" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/convert.nr#L13-L26</a></sub></sup>
+
+
+`Into` is most useful when passing function arguments where the types don't quite match up with what the function expects. In this case, the compiler has enough type information to perform the necessary conversion by just appending `.into()` onto the arguments in question.
+
+---
+
+## `std::cmp`
+
+### `std::cmp::Eq`
+
+```rust title="eq-trait" showLineNumbers 
+pub trait Eq {
+    fn eq(self, other: Self) -> bool;
+}
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/cmp.nr#L4-L8" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/cmp.nr#L4-L8</a></sub></sup>
+
+
+Returns `true` if `self` is equal to `other`. Implementing this trait on a type
+allows the type to be used with `==` and `!=`.
+
+Implementations:
+```rust
+impl Eq for Field { .. }
+
+impl Eq for i8 { .. }
+impl Eq for i16 { .. }
+impl Eq for i32 { .. }
+impl Eq for i64 { .. }
+
+impl Eq for u8 { .. }
+impl Eq for u16 { .. }
+impl Eq for u32 { .. }
+impl Eq for u64 { .. }
+
+impl Eq for () { .. }
+impl Eq for bool { .. }
+
+impl<T, N> Eq for [T; N]
+    where T: Eq { .. }
+
+impl<T> Eq for [T]
+    where T: Eq { .. }
+
+impl<A, B> Eq for (A, B)
+    where A: Eq, B: Eq { .. }
+
+impl<A, B, C> Eq for (A, B, C)
+    where A: Eq, B: Eq, C: Eq { .. }
+
+impl<A, B, C, D> Eq for (A, B, C, D)
+    where A: Eq, B: Eq, C: Eq, D: Eq { .. }
+
+impl<A, B, C, D, E> Eq for (A, B, C, D, E)
+    where A: Eq, B: Eq, C: Eq, D: Eq, E: Eq { .. }
+```
+
+### `std::cmp::Ord`
+
+```rust title="ord-trait" showLineNumbers 
+pub trait Ord {
+    fn cmp(self, other: Self) -> Ordering;
+}
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/cmp.nr#L210-L214" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/cmp.nr#L210-L214</a></sub></sup>
+
+
+`a.cmp(b)` compares two values returning `Ordering::less()` if `a < b`,
+`Ordering::equal()` if `a == b`, or `Ordering::greater()` if `a > b`.
+Implementing this trait on a type allows `<`, `<=`, `>`, and `>=` to be
+used on values of the type.
+
+`std::cmp` also provides `max` and `min` functions for any type which implements the `Ord` trait.
+
+Implementations:
+
+```rust
+impl Ord for u8 { .. }
+impl Ord for u16 { .. }
+impl Ord for u32 { .. }
+impl Ord for u64 { .. }
+
+impl Ord for i8 { .. }
+impl Ord for i16 { .. }
+impl Ord for i32 { .. }
+
+impl Ord for i64 { .. }
+
+impl Ord for () { .. }
+impl Ord for bool { .. }
+
+impl<T, N> Ord for [T; N]
+    where T: Ord { .. }
+
+impl<T> Ord for [T]
+    where T: Ord { .. }
+
+impl<A, B> Ord for (A, B)
+    where A: Ord, B: Ord { .. }
+
+impl<A, B, C> Ord for (A, B, C)
+    where A: Ord, B: Ord, C: Ord { .. }
+
+impl<A, B, C, D> Ord for (A, B, C, D)
+    where A: Ord, B: Ord, C: Ord, D: Ord { .. }
+
+impl<A, B, C, D, E> Ord for (A, B, C, D, E)
+    where A: Ord, B: Ord, C: Ord, D: Ord, E: Ord { .. }
+```
+
+---
+
+## `std::ops`
+
+### `std::ops::Add`, `std::ops::Sub`, `std::ops::Mul`, and `std::ops::Div`
+
+These traits abstract over addition, subtraction, multiplication, and division respectively.
+Implementing these traits for a given type will also allow that type to be used with the corresponding operator
+for that trait (`+` for Add, etc) in addition to the normal method names.
+
+```rust title="add-trait" showLineNumbers 
+pub trait Add {
+    fn add(self, other: Self) -> Self;
+}
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/ops/arith.nr#L1-L5" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/ops/arith.nr#L1-L5</a></sub></sup>
+
+```rust title="sub-trait" showLineNumbers 
+pub trait Sub {
+    fn sub(self, other: Self) -> Self;
+}
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/ops/arith.nr#L60-L64" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/ops/arith.nr#L60-L64</a></sub></sup>
+
+```rust title="mul-trait" showLineNumbers 
+pub trait Mul {
+    fn mul(self, other: Self) -> Self;
+}
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/ops/arith.nr#L119-L123" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/ops/arith.nr#L119-L123</a></sub></sup>
+
+```rust title="div-trait" showLineNumbers 
+pub trait Div {
+    fn div(self, other: Self) -> Self;
+}
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/ops/arith.nr#L178-L182" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/ops/arith.nr#L178-L182</a></sub></sup>
+
+
+The implementations block below is given for the `Add` trait, but the same types that implement
+`Add` also implement `Sub`, `Mul`, and `Div`.
+
+Implementations:
+```rust
+impl Add for Field { .. }
+
+impl Add for i8 { .. }
+impl Add for i16 { .. }
+impl Add for i32 { .. }
+impl Add for i64 { .. }
+
+impl Add for u8 { .. }
+impl Add for u16 { .. }
+impl Add for u32 { .. }
+impl Add for u64 { .. }
+```
+
+### `std::ops::Rem`
+
+```rust title="rem-trait" showLineNumbers 
+pub trait Rem {
+    fn rem(self, other: Self) -> Self;
+}
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/ops/arith.nr#L237-L241" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/ops/arith.nr#L237-L241</a></sub></sup>
+
+
+`Rem::rem(a, b)` is the remainder function returning the result of what is
+left after dividing `a` and `b`. Implementing `Rem` allows the `%` operator
+to be used with the implementation type.
+
+Unlike other numeric traits, `Rem` is not implemented for `Field`.
+
+Implementations:
+```rust
+impl Rem for u8 { fn rem(self, other: u8) -> u8 { self % other } }
+impl Rem for u16 { fn rem(self, other: u16) -> u16 { self % other } }
+impl Rem for u32 { fn rem(self, other: u32) -> u32 { self % other } }
+impl Rem for u64 { fn rem(self, other: u64) -> u64 { self % other } }
+
+impl Rem for i8 { fn rem(self, other: i8) -> i8 { self % other } }
+impl Rem for i16 { fn rem(self, other: i16) -> i16 { self % other } }
+impl Rem for i32 { fn rem(self, other: i32) -> i32 { self % other } }
+impl Rem for i64 { fn rem(self, other: i64) -> i64 { self % other } }
+```
+
+### `std::ops::Neg`
+
+```rust title="neg-trait" showLineNumbers 
+pub trait Neg {
+    fn neg(self) -> Self;
+}
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/ops/arith.nr#L290-L294" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/ops/arith.nr#L290-L294</a></sub></sup>
+
+
+`Neg::neg` is equivalent to the unary negation operator `-`.
+
+Implementations:
+```rust title="neg-trait-impls" showLineNumbers 
+impl Neg for Field {
+    fn neg(self) -> Field {
+        -self
+    }
+}
+
+impl Neg for i8 {
+    fn neg(self) -> i8 {
+        -self
+    }
+}
+impl Neg for i16 {
+    fn neg(self) -> i16 {
+        -self
+    }
+}
+impl Neg for i32 {
+    fn neg(self) -> i32 {
+        -self
+    }
+}
+impl Neg for i64 {
+    fn neg(self) -> i64 {
+        -self
+    }
+}
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/ops/arith.nr#L296-L323" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/ops/arith.nr#L296-L323</a></sub></sup>
+
+
+### `std::ops::Not`
+
+```rust title="not-trait" showLineNumbers 
+pub trait Not {
+    fn not(self: Self) -> Self;
+}
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/ops/bit.nr#L1-L5" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/ops/bit.nr#L1-L5</a></sub></sup>
+
+
+`Not::not` is equivalent to the unary bitwise NOT operator `!`.
+
+Implementations:
+```rust title="not-trait-impls" showLineNumbers 
+impl Not for bool {
+    fn not(self) -> bool {
+        !self
+    }
+}
+
+impl Not for u64 {
+    fn not(self) -> u64 {
+        !self
+    }
+}
+impl Not for u32 {
+    fn not(self) -> u32 {
+        !self
+    }
+}
+impl Not for u16 {
+    fn not(self) -> u16 {
+        !self
+    }
+}
+impl Not for u8 {
+    fn not(self) -> u8 {
+        !self
+    }
+}
+impl Not for u1 {
+    fn not(self) -> u1 {
+        !self
+    }
+}
+
+impl Not for i8 {
+    fn not(self) -> i8 {
+        !self
+    }
+}
+impl Not for i16 {
+    fn not(self) -> i16 {
+        !self
+    }
+}
+impl Not for i32 {
+    fn not(self) -> i32 {
+        !self
+    }
+}
+impl Not for i64 {
+    fn not(self) -> i64 {
+        !self
+    }
+}
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/ops/bit.nr#L7-L60" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/ops/bit.nr#L7-L60</a></sub></sup>
+
+
+### `std::ops::{ BitOr, BitAnd, BitXor }`
+
+```rust title="bitor-trait" showLineNumbers 
+pub trait BitOr {
+    fn bitor(self, other: Self) -> Self;
+}
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/ops/bit.nr#L62-L66" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/ops/bit.nr#L62-L66</a></sub></sup>
+
+```rust title="bitand-trait" showLineNumbers 
+pub trait BitAnd {
+    fn bitand(self, other: Self) -> Self;
+}
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/ops/bit.nr#L121-L125" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/ops/bit.nr#L121-L125</a></sub></sup>
+
+```rust title="bitxor-trait" showLineNumbers 
+pub trait BitXor {
+    fn bitxor(self, other: Self) -> Self;
+}
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/ops/bit.nr#L180-L184" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/ops/bit.nr#L180-L184</a></sub></sup>
+
+
+Traits for the bitwise operations `|`, `&`, and `^`.
+
+Implementing `BitOr`, `BitAnd` or `BitXor` for a type allows the `|`, `&`, or `^` operator respectively
+to be used with the type.
+
+The implementations block below is given for the `BitOr` trait, but the same types that implement
+`BitOr` also implement `BitAnd` and `BitXor`.
+
+Implementations:
+```rust
+impl BitOr for bool { fn bitor(self, other: bool) -> bool { self | other } }
+
+impl BitOr for u8 { fn bitor(self, other: u8) -> u8 { self | other } }
+impl BitOr for u16 { fn bitor(self, other: u16) -> u16 { self | other } }
+impl BitOr for u32 { fn bitor(self, other: u32) -> u32 { self | other } }
+impl BitOr for u64 { fn bitor(self, other: u64) -> u64 { self | other } }
+
+impl BitOr for i8 { fn bitor(self, other: i8) -> i8 { self | other } }
+impl BitOr for i16 { fn bitor(self, other: i16) -> i16 { self | other } }
+impl BitOr for i32 { fn bitor(self, other: i32) -> i32 { self | other } }
+impl BitOr for i64 { fn bitor(self, other: i64) -> i64 { self | other } }
+```
+
+### `std::ops::{ Shl, Shr }`
+
+```rust title="shl-trait" showLineNumbers 
+pub trait Shl {
+    fn shl(self, other: u8) -> Self;
+}
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/ops/bit.nr#L239-L243" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/ops/bit.nr#L239-L243</a></sub></sup>
+
+```rust title="shr-trait" showLineNumbers 
+pub trait Shr {
+    fn shr(self, other: u8) -> Self;
+}
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/ops/bit.nr#L292-L296" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/ops/bit.nr#L292-L296</a></sub></sup>
+
+
+Traits for a bit shift left and bit shift right.
+
+Implementing `Shl` for a type allows the left shift operator (`<<`) to be used with the implementation type.
+Similarly, implementing `Shr` allows the right shift operator (`>>`) to be used with the type.
+
+Note that bit shifting is not currently implemented for signed types.
+
+The implementations block below is given for the `Shl` trait, but the same types that implement
+`Shl` also implement `Shr`.
+
+Implementations:
+```rust
+impl Shl for u8 { fn shl(self, other: u8) -> u8 { self << other } }
+impl Shl for u16 { fn shl(self, other: u16) -> u16 { self << other } }
+impl Shl for u32 { fn shl(self, other: u32) -> u32 { self << other } }
+impl Shl for u64 { fn shl(self, other: u64) -> u64 { self << other } }
+```
+
+---
+
+## `std::append`
+
+### `std::append::Append`
+
+`Append` can abstract over types that can be appended to - usually container types:
+
+```rust title="append-trait" showLineNumbers 
+pub trait Append {
+    fn empty() -> Self;
+    fn append(self, other: Self) -> Self;
+}
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/append.nr#L9-L14" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/append.nr#L9-L14</a></sub></sup>
+
+
+`Append` requires two methods:
+
+- `empty`: Constructs an empty value of `Self`.
+- `append`: Append two values together, returning the result.
+
+Additionally, it is expected that for any implementation:
+
+- `T::empty().append(x) == x`
+- `x.append(T::empty()) == x`
+
+Implementations:
+```rust
+impl<T> Append for [T]
+impl Append for Quoted
+```
diff --git a/docs/versioned_docs/version-v0.39.0/reference/NoirJS/noir_js/.nojekyll b/docs/versioned_docs/version-v0.39.0/reference/NoirJS/noir_js/.nojekyll
new file mode 100644
index 00000000000..e2ac6616add
--- /dev/null
+++ b/docs/versioned_docs/version-v0.39.0/reference/NoirJS/noir_js/.nojekyll
@@ -0,0 +1 @@
+TypeDoc added this file to prevent GitHub Pages from using Jekyll. You can turn off this behavior by setting the `githubPages` option to false.
\ No newline at end of file
diff --git a/docs/versioned_docs/version-v0.39.0/reference/NoirJS/noir_js/classes/Noir.md b/docs/versioned_docs/version-v0.39.0/reference/NoirJS/noir_js/classes/Noir.md
new file mode 100644
index 00000000000..ead255bc504
--- /dev/null
+++ b/docs/versioned_docs/version-v0.39.0/reference/NoirJS/noir_js/classes/Noir.md
@@ -0,0 +1,52 @@
+# Noir
+
+## Constructors
+
+### new Noir(circuit)
+
+```ts
+new Noir(circuit): Noir
+```
+
+#### Parameters
+
+| Parameter | Type |
+| :------ | :------ |
+| `circuit` | `CompiledCircuit` |
+
+#### Returns
+
+[`Noir`](Noir.md)
+
+## Methods
+
+### execute()
+
+```ts
+execute(inputs, foreignCallHandler?): Promise<object>
+```
+
+#### Parameters
+
+| Parameter | Type |
+| :------ | :------ |
+| `inputs` | `InputMap` |
+| `foreignCallHandler`? | [`ForeignCallHandler`](../type-aliases/ForeignCallHandler.md) |
+
+#### Returns
+
+`Promise`\<`object`\>
+
+#### Description
+
+Allows to execute a circuit to get its witness and return value.
+
+#### Example
+
+```typescript
+async execute(inputs)
+```
+
+***
+
+Generated using [typedoc-plugin-markdown](https://www.npmjs.com/package/typedoc-plugin-markdown) and [TypeDoc](https://typedoc.org/)
diff --git a/docs/versioned_docs/version-v0.39.0/reference/NoirJS/noir_js/functions/and.md b/docs/versioned_docs/version-v0.39.0/reference/NoirJS/noir_js/functions/and.md
new file mode 100644
index 00000000000..c783283e396
--- /dev/null
+++ b/docs/versioned_docs/version-v0.39.0/reference/NoirJS/noir_js/functions/and.md
@@ -0,0 +1,22 @@
+# and()
+
+```ts
+and(lhs, rhs): string
+```
+
+Performs a bitwise AND operation between `lhs` and `rhs`
+
+## Parameters
+
+| Parameter | Type | Description |
+| :------ | :------ | :------ |
+| `lhs` | `string` |  |
+| `rhs` | `string` |  |
+
+## Returns
+
+`string`
+
+***
+
+Generated using [typedoc-plugin-markdown](https://www.npmjs.com/package/typedoc-plugin-markdown) and [TypeDoc](https://typedoc.org/)
diff --git a/docs/versioned_docs/version-v0.39.0/reference/NoirJS/noir_js/functions/blake2s256.md b/docs/versioned_docs/version-v0.39.0/reference/NoirJS/noir_js/functions/blake2s256.md
new file mode 100644
index 00000000000..7882d0da8d5
--- /dev/null
+++ b/docs/versioned_docs/version-v0.39.0/reference/NoirJS/noir_js/functions/blake2s256.md
@@ -0,0 +1,21 @@
+# blake2s256()
+
+```ts
+blake2s256(inputs): Uint8Array
+```
+
+Calculates the Blake2s256 hash of the input bytes
+
+## Parameters
+
+| Parameter | Type | Description |
+| :------ | :------ | :------ |
+| `inputs` | `Uint8Array` |  |
+
+## Returns
+
+`Uint8Array`
+
+***
+
+Generated using [typedoc-plugin-markdown](https://www.npmjs.com/package/typedoc-plugin-markdown) and [TypeDoc](https://typedoc.org/)
diff --git a/docs/versioned_docs/version-v0.39.0/reference/NoirJS/noir_js/functions/ecdsa_secp256k1_verify.md b/docs/versioned_docs/version-v0.39.0/reference/NoirJS/noir_js/functions/ecdsa_secp256k1_verify.md
new file mode 100644
index 00000000000..5e3cd53e9d3
--- /dev/null
+++ b/docs/versioned_docs/version-v0.39.0/reference/NoirJS/noir_js/functions/ecdsa_secp256k1_verify.md
@@ -0,0 +1,28 @@
+# ecdsa\_secp256k1\_verify()
+
+```ts
+ecdsa_secp256k1_verify(
+   hashed_msg, 
+   public_key_x_bytes, 
+   public_key_y_bytes, 
+   signature): boolean
+```
+
+Verifies a ECDSA signature over the secp256k1 curve.
+
+## Parameters
+
+| Parameter | Type | Description |
+| :------ | :------ | :------ |
+| `hashed_msg` | `Uint8Array` |  |
+| `public_key_x_bytes` | `Uint8Array` |  |
+| `public_key_y_bytes` | `Uint8Array` |  |
+| `signature` | `Uint8Array` |  |
+
+## Returns
+
+`boolean`
+
+***
+
+Generated using [typedoc-plugin-markdown](https://www.npmjs.com/package/typedoc-plugin-markdown) and [TypeDoc](https://typedoc.org/)
diff --git a/docs/versioned_docs/version-v0.39.0/reference/NoirJS/noir_js/functions/ecdsa_secp256r1_verify.md b/docs/versioned_docs/version-v0.39.0/reference/NoirJS/noir_js/functions/ecdsa_secp256r1_verify.md
new file mode 100644
index 00000000000..0b20ff68957
--- /dev/null
+++ b/docs/versioned_docs/version-v0.39.0/reference/NoirJS/noir_js/functions/ecdsa_secp256r1_verify.md
@@ -0,0 +1,28 @@
+# ecdsa\_secp256r1\_verify()
+
+```ts
+ecdsa_secp256r1_verify(
+   hashed_msg, 
+   public_key_x_bytes, 
+   public_key_y_bytes, 
+   signature): boolean
+```
+
+Verifies a ECDSA signature over the secp256r1 curve.
+
+## Parameters
+
+| Parameter | Type | Description |
+| :------ | :------ | :------ |
+| `hashed_msg` | `Uint8Array` |  |
+| `public_key_x_bytes` | `Uint8Array` |  |
+| `public_key_y_bytes` | `Uint8Array` |  |
+| `signature` | `Uint8Array` |  |
+
+## Returns
+
+`boolean`
+
+***
+
+Generated using [typedoc-plugin-markdown](https://www.npmjs.com/package/typedoc-plugin-markdown) and [TypeDoc](https://typedoc.org/)
diff --git a/docs/versioned_docs/version-v0.39.0/reference/NoirJS/noir_js/functions/xor.md b/docs/versioned_docs/version-v0.39.0/reference/NoirJS/noir_js/functions/xor.md
new file mode 100644
index 00000000000..8d762b895d3
--- /dev/null
+++ b/docs/versioned_docs/version-v0.39.0/reference/NoirJS/noir_js/functions/xor.md
@@ -0,0 +1,22 @@
+# xor()
+
+```ts
+xor(lhs, rhs): string
+```
+
+Performs a bitwise XOR operation between `lhs` and `rhs`
+
+## Parameters
+
+| Parameter | Type | Description |
+| :------ | :------ | :------ |
+| `lhs` | `string` |  |
+| `rhs` | `string` |  |
+
+## Returns
+
+`string`
+
+***
+
+Generated using [typedoc-plugin-markdown](https://www.npmjs.com/package/typedoc-plugin-markdown) and [TypeDoc](https://typedoc.org/)
diff --git a/docs/versioned_docs/version-v0.39.0/reference/NoirJS/noir_js/index.md b/docs/versioned_docs/version-v0.39.0/reference/NoirJS/noir_js/index.md
new file mode 100644
index 00000000000..4de7a696991
--- /dev/null
+++ b/docs/versioned_docs/version-v0.39.0/reference/NoirJS/noir_js/index.md
@@ -0,0 +1,47 @@
+# noir_js
+
+## Exports
+
+### Classes
+
+| Class | Description |
+| :------ | :------ |
+| [Noir](classes/Noir.md) | - |
+
+### Type Aliases
+
+| Type alias | Description |
+| :------ | :------ |
+| [ErrorWithPayload](type-aliases/ErrorWithPayload.md) | - |
+| [ForeignCallHandler](type-aliases/ForeignCallHandler.md) | A callback which performs an foreign call and returns the response. |
+| [ForeignCallInput](type-aliases/ForeignCallInput.md) | - |
+| [ForeignCallOutput](type-aliases/ForeignCallOutput.md) | - |
+| [WitnessMap](type-aliases/WitnessMap.md) | - |
+
+### Functions
+
+| Function | Description |
+| :------ | :------ |
+| [and](functions/and.md) | Performs a bitwise AND operation between `lhs` and `rhs` |
+| [blake2s256](functions/blake2s256.md) | Calculates the Blake2s256 hash of the input bytes |
+| [ecdsa\_secp256k1\_verify](functions/ecdsa_secp256k1_verify.md) | Verifies a ECDSA signature over the secp256k1 curve. |
+| [ecdsa\_secp256r1\_verify](functions/ecdsa_secp256r1_verify.md) | Verifies a ECDSA signature over the secp256r1 curve. |
+| [xor](functions/xor.md) | Performs a bitwise XOR operation between `lhs` and `rhs` |
+
+## References
+
+### CompiledCircuit
+
+Renames and re-exports [InputMap](index.md#inputmap)
+
+## Variables
+
+### InputMap
+
+```ts
+InputMap: any;
+```
+
+***
+
+Generated using [typedoc-plugin-markdown](https://www.npmjs.com/package/typedoc-plugin-markdown) and [TypeDoc](https://typedoc.org/)
diff --git a/docs/versioned_docs/version-v0.39.0/reference/NoirJS/noir_js/type-aliases/ErrorWithPayload.md b/docs/versioned_docs/version-v0.39.0/reference/NoirJS/noir_js/type-aliases/ErrorWithPayload.md
new file mode 100644
index 00000000000..e8c2f4aef3d
--- /dev/null
+++ b/docs/versioned_docs/version-v0.39.0/reference/NoirJS/noir_js/type-aliases/ErrorWithPayload.md
@@ -0,0 +1,15 @@
+# ErrorWithPayload
+
+```ts
+type ErrorWithPayload: ExecutionError & object;
+```
+
+## Type declaration
+
+| Member | Type | Description |
+| :------ | :------ | :------ |
+| `decodedAssertionPayload` | `any` | - |
+
+***
+
+Generated using [typedoc-plugin-markdown](https://www.npmjs.com/package/typedoc-plugin-markdown) and [TypeDoc](https://typedoc.org/)
diff --git a/docs/versioned_docs/version-v0.39.0/reference/NoirJS/noir_js/type-aliases/ForeignCallHandler.md b/docs/versioned_docs/version-v0.39.0/reference/NoirJS/noir_js/type-aliases/ForeignCallHandler.md
new file mode 100644
index 00000000000..812b8b16481
--- /dev/null
+++ b/docs/versioned_docs/version-v0.39.0/reference/NoirJS/noir_js/type-aliases/ForeignCallHandler.md
@@ -0,0 +1,24 @@
+# ForeignCallHandler
+
+```ts
+type ForeignCallHandler: (name, inputs) => Promise<ForeignCallOutput[]>;
+```
+
+A callback which performs an foreign call and returns the response.
+
+## Parameters
+
+| Parameter | Type | Description |
+| :------ | :------ | :------ |
+| `name` | `string` | The identifier for the type of foreign call being performed. |
+| `inputs` | [`ForeignCallInput`](ForeignCallInput.md)[] | An array of hex encoded inputs to the foreign call. |
+
+## Returns
+
+`Promise`\<[`ForeignCallOutput`](ForeignCallOutput.md)[]\>
+
+outputs - An array of hex encoded outputs containing the results of the foreign call.
+
+***
+
+Generated using [typedoc-plugin-markdown](https://www.npmjs.com/package/typedoc-plugin-markdown) and [TypeDoc](https://typedoc.org/)
diff --git a/docs/versioned_docs/version-v0.39.0/reference/NoirJS/noir_js/type-aliases/ForeignCallInput.md b/docs/versioned_docs/version-v0.39.0/reference/NoirJS/noir_js/type-aliases/ForeignCallInput.md
new file mode 100644
index 00000000000..dd95809186a
--- /dev/null
+++ b/docs/versioned_docs/version-v0.39.0/reference/NoirJS/noir_js/type-aliases/ForeignCallInput.md
@@ -0,0 +1,9 @@
+# ForeignCallInput
+
+```ts
+type ForeignCallInput: string[];
+```
+
+***
+
+Generated using [typedoc-plugin-markdown](https://www.npmjs.com/package/typedoc-plugin-markdown) and [TypeDoc](https://typedoc.org/)
diff --git a/docs/versioned_docs/version-v0.39.0/reference/NoirJS/noir_js/type-aliases/ForeignCallOutput.md b/docs/versioned_docs/version-v0.39.0/reference/NoirJS/noir_js/type-aliases/ForeignCallOutput.md
new file mode 100644
index 00000000000..b71fb78a946
--- /dev/null
+++ b/docs/versioned_docs/version-v0.39.0/reference/NoirJS/noir_js/type-aliases/ForeignCallOutput.md
@@ -0,0 +1,9 @@
+# ForeignCallOutput
+
+```ts
+type ForeignCallOutput: string | string[];
+```
+
+***
+
+Generated using [typedoc-plugin-markdown](https://www.npmjs.com/package/typedoc-plugin-markdown) and [TypeDoc](https://typedoc.org/)
diff --git a/docs/versioned_docs/version-v0.39.0/reference/NoirJS/noir_js/type-aliases/WitnessMap.md b/docs/versioned_docs/version-v0.39.0/reference/NoirJS/noir_js/type-aliases/WitnessMap.md
new file mode 100644
index 00000000000..258c46f9d0c
--- /dev/null
+++ b/docs/versioned_docs/version-v0.39.0/reference/NoirJS/noir_js/type-aliases/WitnessMap.md
@@ -0,0 +1,9 @@
+# WitnessMap
+
+```ts
+type WitnessMap: Map<number, string>;
+```
+
+***
+
+Generated using [typedoc-plugin-markdown](https://www.npmjs.com/package/typedoc-plugin-markdown) and [TypeDoc](https://typedoc.org/)
diff --git a/docs/versioned_docs/version-v0.39.0/reference/NoirJS/noir_js/typedoc-sidebar.cjs b/docs/versioned_docs/version-v0.39.0/reference/NoirJS/noir_js/typedoc-sidebar.cjs
new file mode 100644
index 00000000000..4796b5abaa8
--- /dev/null
+++ b/docs/versioned_docs/version-v0.39.0/reference/NoirJS/noir_js/typedoc-sidebar.cjs
@@ -0,0 +1,4 @@
+// @ts-check
+/** @type {import('@docusaurus/plugin-content-docs').SidebarsConfig} */
+const typedocSidebar = { items: [{"type":"category","label":"Classes","items":[{"type":"doc","id":"reference/NoirJS/noir_js/classes/Noir","label":"Noir"}]},{"type":"category","label":"Type Aliases","items":[{"type":"doc","id":"reference/NoirJS/noir_js/type-aliases/ErrorWithPayload","label":"ErrorWithPayload"},{"type":"doc","id":"reference/NoirJS/noir_js/type-aliases/ForeignCallHandler","label":"ForeignCallHandler"},{"type":"doc","id":"reference/NoirJS/noir_js/type-aliases/ForeignCallInput","label":"ForeignCallInput"},{"type":"doc","id":"reference/NoirJS/noir_js/type-aliases/ForeignCallOutput","label":"ForeignCallOutput"},{"type":"doc","id":"reference/NoirJS/noir_js/type-aliases/WitnessMap","label":"WitnessMap"}]},{"type":"category","label":"Functions","items":[{"type":"doc","id":"reference/NoirJS/noir_js/functions/and","label":"and"},{"type":"doc","id":"reference/NoirJS/noir_js/functions/blake2s256","label":"blake2s256"},{"type":"doc","id":"reference/NoirJS/noir_js/functions/ecdsa_secp256k1_verify","label":"ecdsa_secp256k1_verify"},{"type":"doc","id":"reference/NoirJS/noir_js/functions/ecdsa_secp256r1_verify","label":"ecdsa_secp256r1_verify"},{"type":"doc","id":"reference/NoirJS/noir_js/functions/xor","label":"xor"}]}]};
+module.exports = typedocSidebar.items;
\ No newline at end of file
diff --git a/docs/versioned_docs/version-v0.39.0/reference/NoirJS/noir_wasm/.nojekyll b/docs/versioned_docs/version-v0.39.0/reference/NoirJS/noir_wasm/.nojekyll
new file mode 100644
index 00000000000..e2ac6616add
--- /dev/null
+++ b/docs/versioned_docs/version-v0.39.0/reference/NoirJS/noir_wasm/.nojekyll
@@ -0,0 +1 @@
+TypeDoc added this file to prevent GitHub Pages from using Jekyll. You can turn off this behavior by setting the `githubPages` option to false.
\ No newline at end of file
diff --git a/docs/versioned_docs/version-v0.39.0/reference/NoirJS/noir_wasm/functions/compile.md b/docs/versioned_docs/version-v0.39.0/reference/NoirJS/noir_wasm/functions/compile.md
new file mode 100644
index 00000000000..6faf763b37f
--- /dev/null
+++ b/docs/versioned_docs/version-v0.39.0/reference/NoirJS/noir_wasm/functions/compile.md
@@ -0,0 +1,51 @@
+# compile()
+
+```ts
+compile(
+   fileManager, 
+   projectPath?, 
+   logFn?, 
+debugLogFn?): Promise<ProgramCompilationArtifacts>
+```
+
+Compiles a Noir project
+
+## Parameters
+
+| Parameter | Type | Description |
+| :------ | :------ | :------ |
+| `fileManager` | `FileManager` | The file manager to use |
+| `projectPath`? | `string` | The path to the project inside the file manager. Defaults to the root of the file manager |
+| `logFn`? | `LogFn` | A logging function. If not provided, console.log will be used |
+| `debugLogFn`? | `LogFn` | A debug logging function. If not provided, logFn will be used |
+
+## Returns
+
+`Promise`\<[`ProgramCompilationArtifacts`](../index.md#programcompilationartifacts)\>
+
+## Example
+
+```typescript
+// Node.js
+
+import { compile_program, createFileManager } from '@noir-lang/noir_wasm';
+
+const fm = createFileManager(myProjectPath);
+const myCompiledCode = await compile_program(fm);
+```
+
+```typescript
+// Browser
+
+import { compile_program, createFileManager } from '@noir-lang/noir_wasm';
+
+const fm = createFileManager('/');
+for (const path of files) {
+  await fm.writeFile(path, await getFileAsStream(path));
+}
+const myCompiledCode = await compile_program(fm);
+```
+
+***
+
+Generated using [typedoc-plugin-markdown](https://www.npmjs.com/package/typedoc-plugin-markdown) and [TypeDoc](https://typedoc.org/)
diff --git a/docs/versioned_docs/version-v0.39.0/reference/NoirJS/noir_wasm/functions/compile_contract.md b/docs/versioned_docs/version-v0.39.0/reference/NoirJS/noir_wasm/functions/compile_contract.md
new file mode 100644
index 00000000000..7d0b39a43ef
--- /dev/null
+++ b/docs/versioned_docs/version-v0.39.0/reference/NoirJS/noir_wasm/functions/compile_contract.md
@@ -0,0 +1,51 @@
+# compile\_contract()
+
+```ts
+compile_contract(
+   fileManager, 
+   projectPath?, 
+   logFn?, 
+debugLogFn?): Promise<ContractCompilationArtifacts>
+```
+
+Compiles a Noir project
+
+## Parameters
+
+| Parameter | Type | Description |
+| :------ | :------ | :------ |
+| `fileManager` | `FileManager` | The file manager to use |
+| `projectPath`? | `string` | The path to the project inside the file manager. Defaults to the root of the file manager |
+| `logFn`? | `LogFn` | A logging function. If not provided, console.log will be used |
+| `debugLogFn`? | `LogFn` | A debug logging function. If not provided, logFn will be used |
+
+## Returns
+
+`Promise`\<[`ContractCompilationArtifacts`](../index.md#contractcompilationartifacts)\>
+
+## Example
+
+```typescript
+// Node.js
+
+import { compile_contract, createFileManager } from '@noir-lang/noir_wasm';
+
+const fm = createFileManager(myProjectPath);
+const myCompiledCode = await compile_contract(fm);
+```
+
+```typescript
+// Browser
+
+import { compile_contract, createFileManager } from '@noir-lang/noir_wasm';
+
+const fm = createFileManager('/');
+for (const path of files) {
+  await fm.writeFile(path, await getFileAsStream(path));
+}
+const myCompiledCode = await compile_contract(fm);
+```
+
+***
+
+Generated using [typedoc-plugin-markdown](https://www.npmjs.com/package/typedoc-plugin-markdown) and [TypeDoc](https://typedoc.org/)
diff --git a/docs/versioned_docs/version-v0.39.0/reference/NoirJS/noir_wasm/functions/createFileManager.md b/docs/versioned_docs/version-v0.39.0/reference/NoirJS/noir_wasm/functions/createFileManager.md
new file mode 100644
index 00000000000..7e65c1d69c7
--- /dev/null
+++ b/docs/versioned_docs/version-v0.39.0/reference/NoirJS/noir_wasm/functions/createFileManager.md
@@ -0,0 +1,21 @@
+# createFileManager()
+
+```ts
+createFileManager(dataDir): FileManager
+```
+
+Creates a new FileManager instance based on fs in node and memfs in the browser (via webpack alias)
+
+## Parameters
+
+| Parameter | Type | Description |
+| :------ | :------ | :------ |
+| `dataDir` | `string` | root of the file system |
+
+## Returns
+
+`FileManager`
+
+***
+
+Generated using [typedoc-plugin-markdown](https://www.npmjs.com/package/typedoc-plugin-markdown) and [TypeDoc](https://typedoc.org/)
diff --git a/docs/versioned_docs/version-v0.39.0/reference/NoirJS/noir_wasm/functions/inflateDebugSymbols.md b/docs/versioned_docs/version-v0.39.0/reference/NoirJS/noir_wasm/functions/inflateDebugSymbols.md
new file mode 100644
index 00000000000..fcea9275341
--- /dev/null
+++ b/docs/versioned_docs/version-v0.39.0/reference/NoirJS/noir_wasm/functions/inflateDebugSymbols.md
@@ -0,0 +1,21 @@
+# inflateDebugSymbols()
+
+```ts
+inflateDebugSymbols(debugSymbols): any
+```
+
+Decompresses and decodes the debug symbols
+
+## Parameters
+
+| Parameter | Type | Description |
+| :------ | :------ | :------ |
+| `debugSymbols` | `string` | The base64 encoded debug symbols |
+
+## Returns
+
+`any`
+
+***
+
+Generated using [typedoc-plugin-markdown](https://www.npmjs.com/package/typedoc-plugin-markdown) and [TypeDoc](https://typedoc.org/)
diff --git a/docs/versioned_docs/version-v0.39.0/reference/NoirJS/noir_wasm/index.md b/docs/versioned_docs/version-v0.39.0/reference/NoirJS/noir_wasm/index.md
new file mode 100644
index 00000000000..b6e0f9d1bc0
--- /dev/null
+++ b/docs/versioned_docs/version-v0.39.0/reference/NoirJS/noir_wasm/index.md
@@ -0,0 +1,49 @@
+# noir_wasm
+
+## Exports
+
+### Functions
+
+| Function | Description |
+| :------ | :------ |
+| [compile](functions/compile.md) | Compiles a Noir project |
+| [compile\_contract](functions/compile_contract.md) | Compiles a Noir project |
+| [createFileManager](functions/createFileManager.md) | Creates a new FileManager instance based on fs in node and memfs in the browser (via webpack alias) |
+| [inflateDebugSymbols](functions/inflateDebugSymbols.md) | Decompresses and decodes the debug symbols |
+
+## References
+
+### compile\_program
+
+Renames and re-exports [compile](functions/compile.md)
+
+## Interfaces
+
+### ContractCompilationArtifacts
+
+The compilation artifacts of a given contract.
+
+#### Properties
+
+| Property | Type | Description |
+| :------ | :------ | :------ |
+| `contract` | `ContractArtifact` | The compiled contract. |
+| `warnings` | `unknown`[] | Compilation warnings. |
+
+***
+
+### ProgramCompilationArtifacts
+
+The compilation artifacts of a given program.
+
+#### Properties
+
+| Property | Type | Description |
+| :------ | :------ | :------ |
+| `name` | `string` | not part of the compilation output, injected later |
+| `program` | `ProgramArtifact` | The compiled contract. |
+| `warnings` | `unknown`[] | Compilation warnings. |
+
+***
+
+Generated using [typedoc-plugin-markdown](https://www.npmjs.com/package/typedoc-plugin-markdown) and [TypeDoc](https://typedoc.org/)
diff --git a/docs/versioned_docs/version-v0.39.0/reference/NoirJS/noir_wasm/typedoc-sidebar.cjs b/docs/versioned_docs/version-v0.39.0/reference/NoirJS/noir_wasm/typedoc-sidebar.cjs
new file mode 100644
index 00000000000..e0870710349
--- /dev/null
+++ b/docs/versioned_docs/version-v0.39.0/reference/NoirJS/noir_wasm/typedoc-sidebar.cjs
@@ -0,0 +1,4 @@
+// @ts-check
+/** @type {import('@docusaurus/plugin-content-docs').SidebarsConfig} */
+const typedocSidebar = { items: [{"type":"doc","id":"reference/NoirJS/noir_wasm/index","label":"API"},{"type":"category","label":"Functions","items":[{"type":"doc","id":"reference/NoirJS/noir_wasm/functions/compile","label":"compile"},{"type":"doc","id":"reference/NoirJS/noir_wasm/functions/compile_contract","label":"compile_contract"},{"type":"doc","id":"reference/NoirJS/noir_wasm/functions/createFileManager","label":"createFileManager"},{"type":"doc","id":"reference/NoirJS/noir_wasm/functions/inflateDebugSymbols","label":"inflateDebugSymbols"}]}]};
+module.exports = typedocSidebar.items;
\ No newline at end of file
diff --git a/docs/versioned_docs/version-v0.39.0/reference/_category_.json b/docs/versioned_docs/version-v0.39.0/reference/_category_.json
new file mode 100644
index 00000000000..5b6a20a609a
--- /dev/null
+++ b/docs/versioned_docs/version-v0.39.0/reference/_category_.json
@@ -0,0 +1,5 @@
+{
+    "position": 4,
+    "collapsible": true,
+    "collapsed": true
+}
diff --git a/docs/versioned_docs/version-v0.39.0/reference/debugger/_category_.json b/docs/versioned_docs/version-v0.39.0/reference/debugger/_category_.json
new file mode 100644
index 00000000000..27869205ad3
--- /dev/null
+++ b/docs/versioned_docs/version-v0.39.0/reference/debugger/_category_.json
@@ -0,0 +1,6 @@
+{
+    "label": "Debugger",
+    "position": 1,
+    "collapsible": true,
+    "collapsed": true
+}
diff --git a/docs/versioned_docs/version-v0.39.0/reference/debugger/debugger_known_limitations.md b/docs/versioned_docs/version-v0.39.0/reference/debugger/debugger_known_limitations.md
new file mode 100644
index 00000000000..936d416ac4b
--- /dev/null
+++ b/docs/versioned_docs/version-v0.39.0/reference/debugger/debugger_known_limitations.md
@@ -0,0 +1,59 @@
+---
+title: Known limitations
+description:
+  An overview of known limitations of the current version of the Noir debugger
+keywords:
+  [
+    Nargo,
+    Noir Debugger,
+    VS Code,
+  ]
+sidebar_position: 2
+---
+
+# Debugger Known Limitations
+
+There are currently some limits to what the debugger can observe. 
+
+## Mutable references
+
+The debugger is currently blind to any state mutated via a mutable reference. For example, in:
+
+```
+let mut x = 1;
+let y = &mut x;
+*y = 2;
+```
+
+The update on `x` will not be observed by the debugger. That means, when running `vars` from the debugger REPL, or inspecting the _local variables_ pane in the VS Code debugger, `x` will appear with value 1 despite having executed `*y = 2;`.
+
+## Variables of type function or mutable references are opaque
+
+When inspecting variables, any variable of type `Function` or `MutableReference` will render its value as `<<function>>` or `<<mutable ref>>`.
+
+## Debugger instrumentation affects resulting ACIR
+                      
+In order to make the state of local variables observable, the debugger compiles Noir circuits interleaving foreign calls that track any mutations to them. While this works (except in the cases described above) and doesn't introduce any behavior changes, it does as a side effect produce bigger bytecode. In particular, when running the command `opcodes` on the REPL debugger, you will notice Unconstrained VM blocks that look like this:
+
+```
+...
+5    BRILLIG inputs=[Single(Expression { mul_terms: [], linear_combinations: [], q_c: 2 }), Single(Expression { mul_terms: [], linear_combinations: [(1, Witness(2))], q_c: 0 })]
+       |       outputs=[]
+  5.0  |   Mov { destination: RegisterIndex(2), source: RegisterIndex(0) }
+  5.1  |   Mov { destination: RegisterIndex(3), source: RegisterIndex(1) }
+  5.2  |   Const { destination: RegisterIndex(0), value: Value { inner: 0 } }
+  5.3  |   Const { destination: RegisterIndex(1), value: Value { inner: 0 } }
+  5.4  |   Mov { destination: RegisterIndex(2), source: RegisterIndex(2) }
+  5.5  |   Mov { destination: RegisterIndex(3), source: RegisterIndex(3) }
+  5.6  |   Call { location: 8 }
+  5.7  |   Stop
+  5.8  |   ForeignCall { function: "__debug_var_assign", destinations: [], inputs: [RegisterIndex(RegisterIndex(2)), RegisterIndex(RegisterIndex(3))] }
+...
+```               
+                                    
+If you are interested in debugging/inspecting compiled ACIR without these synthetic changes, you can invoke the REPL debugger with the `--skip-instrumentation` flag or launch the VS Code debugger with the `skipConfiguration` property set to true in its launch configuration. You can find more details about those in the [Debugger REPL reference](debugger_repl.md) and the [VS Code Debugger reference](debugger_vscode.md).
+
+:::note
+Skipping debugger instrumentation means you won't be able to inspect values of local variables.
+:::
+
diff --git a/docs/versioned_docs/version-v0.39.0/reference/debugger/debugger_repl.md b/docs/versioned_docs/version-v0.39.0/reference/debugger/debugger_repl.md
new file mode 100644
index 00000000000..46e2011304e
--- /dev/null
+++ b/docs/versioned_docs/version-v0.39.0/reference/debugger/debugger_repl.md
@@ -0,0 +1,360 @@
+---
+title: REPL Debugger
+description:
+  Noir Debugger REPL options and commands. 
+keywords:
+  [
+    Nargo,
+    Noir CLI,
+    Noir Debugger,
+    REPL,
+  ]
+sidebar_position: 1
+---
+
+## Running the REPL debugger
+
+`nargo debug [OPTIONS] [WITNESS_NAME]`
+
+Runs the Noir REPL debugger. If a `WITNESS_NAME` is provided the debugger writes the resulting execution witness to a `WITNESS_NAME` file.
+
+### Options
+
+| Option                | Description                                                  |
+| --------------------- | ------------------------------------------------------------ |
+| `-p, --prover-name <PROVER_NAME>` | The name of the toml file which contains the inputs for the prover [default: Prover]|
+| `--package <PACKAGE>` | The name of the package to debug                             |
+| `--print-acir`        | Display the ACIR for compiled circuit                        |
+| `--deny-warnings`     | Treat all warnings as errors                                 |
+| `--silence-warnings`  | Suppress warnings                                            |
+| `-h, --help`          | Print help                                                   |
+
+None of these options are required.
+
+:::note
+Since the debugger starts by compiling the target package, all Noir compiler options are also available. Check out the [compiler reference](../nargo_commands.md#nargo-compile) to learn more about the compiler options.
+:::
+
+## REPL commands
+
+Once the debugger is running, it accepts the following commands.
+
+#### `help` (h)
+
+Displays the menu of available commands.
+
+```
+> help
+Available commands:
+
+  opcodes                          display ACIR opcodes
+  into                             step into to the next opcode
+  next                             step until a new source location is reached
+  out                              step until a new source location is reached
+                                   and the current stack frame is finished
+  break LOCATION:OpcodeLocation    add a breakpoint at an opcode location
+  over                             step until a new source location is reached
+                                   without diving into function calls
+  restart                          restart the debugging session
+  delete LOCATION:OpcodeLocation   delete breakpoint at an opcode location
+  witness                          show witness map
+  witness index:u32                display a single witness from the witness map
+  witness index:u32 value:String   update a witness with the given value
+  memset index:usize value:String  update a memory cell with the given
+                                   value
+  continue                         continue execution until the end of the
+                                   program
+  vars                             show variable values available at this point
+                                   in execution
+  stacktrace                       display the current stack trace
+  memory                           show memory (valid when executing unconstrained code)                                 value
+  step                             step to the next ACIR opcode
+
+Other commands:
+
+  help  Show this help message
+  quit  Quit repl
+
+```
+
+### Stepping through programs
+
+#### `next` (n)
+
+Step until the next Noir source code location. While other commands, such as [`into`](#into-i) and [`step`](#step-s), allow for finer grained control of the program's execution at the opcode level, `next` is source code centric. For example:
+
+```
+3    ...
+4    fn main(x: u32) {
+5        assert(entry_point(x) == 2);
+6        swap_entry_point(x, x + 1);
+7 ->     assert(deep_entry_point(x) == 4);
+8        multiple_values_entry_point(x);
+9    }
+```
+
+
+Using `next` here would cause the debugger to jump to the definition of `deep_entry_point` (if available). 
+
+If you want to step over `deep_entry_point` and go straight to line 8, use [the `over` command](#over) instead.
+
+#### `over`
+
+Step until the next source code location, without diving into function calls. For example:
+
+```
+3    ...
+4    fn main(x: u32) {
+5        assert(entry_point(x) == 2);
+6        swap_entry_point(x, x + 1);
+7 ->     assert(deep_entry_point(x) == 4);
+8        multiple_values_entry_point(x);
+9    }
+```
+
+
+Using `over` here would cause the debugger to execute until line 8 (`multiple_values_entry_point(x);`).
+
+If you want to step into `deep_entry_point` instead, use [the `next` command](#next-n).
+
+#### `out`
+
+Step until the end of the current function call. For example:
+
+```
+  3    ...
+  4    fn main(x: u32) {
+  5        assert(entry_point(x) == 2);
+  6        swap_entry_point(x, x + 1);
+  7 ->     assert(deep_entry_point(x) == 4);
+  8        multiple_values_entry_point(x);
+  9    }
+ 10    
+ 11    unconstrained fn returns_multiple_values(x: u32) -> (u32, u32, u32, u32) {
+ 12    ...
+ ...
+ 55    
+ 56    unconstrained fn deep_entry_point(x: u32) -> u32 {
+ 57 ->     level_1(x + 1)
+ 58    }
+
+```
+
+Running `out` here will resume execution until line 8.
+
+#### `step` (s)
+
+Skips to the next ACIR code. A compiled Noir program is a sequence of ACIR opcodes. However, an unconstrained VM opcode denotes the start of an unconstrained code block, to be executed by the unconstrained VM. For example (redacted for brevity):
+
+```
+0  BLACKBOX::RANGE [(_0, num_bits: 32)] [ ]
+1 ->  BRILLIG inputs=[Single(Expression { mul_terms: [], linear_combinations: [(1, Witness(0))], q_c: 0 })] outputs=[Simple(Witness(1))]
+	1.0  |   Mov { destination: RegisterIndex(2), source: RegisterIndex(0) }
+	1.1  |   Const { destination: RegisterIndex(0), value: Value { inner: 0 } }
+	1.2  |   Const { destination: RegisterIndex(1), value: Value { inner: 0 } }
+	1.3  |   Mov { destination: RegisterIndex(2), source: RegisterIndex(2) }
+	1.4  |   Call { location: 7 }
+	...
+	1.43 |   Return
+2    EXPR [ (1, _1) -2 ]
+```
+
+The `->` here shows the debugger paused at an ACIR opcode: `BRILLIG`, at index 1, which denotes an unconstrained code block is about to start.
+
+Using the `step` command at this point would result in the debugger stopping at ACIR opcode 2, `EXPR`, skipping unconstrained computation steps.
+
+Use [the `into` command](#into-i) instead if you want to follow unconstrained computation step by step.
+
+#### `into` (i)
+
+Steps into the next opcode. A compiled Noir program is a sequence of ACIR opcodes. However, a BRILLIG opcode denotes the start of an unconstrained code block, to be executed by the unconstrained VM. For example (redacted for brevity):
+
+```
+0  BLACKBOX::RANGE [(_0, num_bits: 32)] [ ]
+1 ->  BRILLIG inputs=[Single(Expression { mul_terms: [], linear_combinations: [(1, Witness(0))], q_c: 0 })] outputs=[Simple(Witness(1))]
+	1.0  |   Mov { destination: RegisterIndex(2), source: RegisterIndex(0) }
+	1.1  |   Const { destination: RegisterIndex(0), value: Value { inner: 0 } }
+	1.2  |   Const { destination: RegisterIndex(1), value: Value { inner: 0 } }
+	1.3  |   Mov { destination: RegisterIndex(2), source: RegisterIndex(2) }
+	1.4  |   Call { location: 7 }
+	...
+	1.43 |   Return
+2    EXPR [ (1, _1) -2 ]
+``` 
+
+The `->` here shows the debugger paused at an ACIR opcode: `BRILLIG`, at index 1, which denotes an unconstrained code block is about to start.
+
+Using the `into` command at this point would result in the debugger stopping at opcode 1.0, `Mov ...`, allowing the debugger user to follow unconstrained computation step by step.
+
+Use [the `step` command](#step-s) instead if you want to skip to the next ACIR code directly.
+
+#### `continue` (c)
+
+Continues execution until the next breakpoint, or the end of the program.
+
+#### `restart` (res)
+
+Interrupts execution, and restarts a new debugging session from scratch.
+
+#### `opcodes` (o)
+
+Display the program's ACIR opcode sequence. For example:
+
+```
+0  BLACKBOX::RANGE [(_0, num_bits: 32)] [ ]
+1 ->  BRILLIG inputs=[Single(Expression { mul_terms: [], linear_combinations: [(1, Witness(0))], q_c: 0 })] outputs=[Simple(Witness(1))]
+	1.0  |   Mov { destination: RegisterIndex(2), source: RegisterIndex(0) }
+	1.1  |   Const { destination: RegisterIndex(0), value: Value { inner: 0 } }
+	1.2  |   Const { destination: RegisterIndex(1), value: Value { inner: 0 } }
+	1.3  |   Mov { destination: RegisterIndex(2), source: RegisterIndex(2) }
+	1.4  |   Call { location: 7 }
+	...
+	1.43 |   Return
+2     EXPR [ (1, _1) -2 ]
+```
+
+### Breakpoints
+
+#### `break [Opcode]` (or shorthand `b [Opcode]`)
+
+Sets a breakpoint on the specified opcode index. To get a list of the program opcode numbers, see [the `opcode` command](#opcodes-o). For example:
+
+```
+0  BLACKBOX::RANGE [(_0, num_bits: 32)] [ ]
+1 ->  BRILLIG inputs=[Single(Expression { mul_terms: [], linear_combinations: [(1, Witness(0))], q_c: 0 })] outputs=[Simple(Witness(1))]
+	1.0  |   Mov { destination: RegisterIndex(2), source: RegisterIndex(0) }
+	1.1  |   Const { destination: RegisterIndex(0), value: Value { inner: 0 } }
+	1.2  |   Const { destination: RegisterIndex(1), value: Value { inner: 0 } }
+	1.3  |   Mov { destination: RegisterIndex(2), source: RegisterIndex(2) }
+	1.4  |   Call { location: 7 }
+	...
+	1.43 |   Return
+2    EXPR [ (1, _1) -2 ]
+```
+
+In this example, issuing a `break 1.2` command adds break on opcode 1.2, as denoted by the `*` character:
+
+```
+0  BLACKBOX::RANGE [(_0, num_bits: 32)] [ ]
+1 ->  BRILLIG inputs=[Single(Expression { mul_terms: [], linear_combinations: [(1, Witness(0))], q_c: 0 })] outputs=[Simple(Witness(1))]
+	1.0  |   Mov { destination: RegisterIndex(2), source: RegisterIndex(0) }
+	1.1  |   Const { destination: RegisterIndex(0), value: Value { inner: 0 } }
+	1.2  | * Const { destination: RegisterIndex(1), value: Value { inner: 0 } }
+	1.3  |   Mov { destination: RegisterIndex(2), source: RegisterIndex(2) }
+	1.4  |   Call { location: 7 }
+	...
+	1.43 |   Return
+2    EXPR [ (1, _1) -2 ]
+```
+
+Running [the `continue` command](#continue-c) at this point would cause the debugger to execute the program until opcode 1.2.
+
+#### `delete [Opcode]` (or shorthand `d [Opcode]`)
+
+Deletes a breakpoint at an opcode location. Usage is analogous to [the `break` command](#).
+
+### Variable inspection
+
+#### vars
+
+Show variable values available at this point in execution.
+
+:::note
+The ability to inspect variable values from the debugger depends on compilation to be run in a special debug instrumentation mode. This instrumentation weaves variable tracing code with the original source code. 
+
+So variable value inspection comes at the expense of making the resulting ACIR bytecode bigger and harder to understand and optimize.
+
+If you find this compromise unacceptable, you can run the debugger with the flag `--skip-debug-instrumentation`. This will compile your circuit without any additional debug information, so the resulting ACIR bytecode will be identical to the one produced by standard Noir compilation. However, if you opt for this, the `vars` command will not be available while debugging.
+:::
+
+
+### Stacktrace
+
+#### `stacktrace`
+
+Displays the current stack trace.
+
+
+### Witness map
+
+#### `witness` (w)
+
+Show witness map. For example:
+
+```
+_0 = 0
+_1 = 2
+_2 = 1
+```
+
+#### `witness [Witness Index]`
+
+Display a single witness from the witness map. For example:
+
+```
+> witness 1
+_1 = 2
+```
+
+#### `witness [Witness Index] [New value]`
+
+Overwrite the given index with a new value. For example:
+
+```
+> witness 1 3
+_1 = 3
+```
+
+
+### Unconstrained VM memory
+
+#### `memory`
+
+Show unconstrained VM memory state. For example:
+
+```
+> memory
+At opcode 1.13: Store { destination_pointer: RegisterIndex(0), source: RegisterIndex(3) }
+...
+> registers
+0 = 0
+1 = 10
+2 = 0
+3 = 1
+4 = 1
+5 = 2³²
+6 = 1
+> into
+At opcode 1.14: Const { destination: RegisterIndex(5), value: Value { inner: 1 } }
+...
+> memory
+0 = 1
+>
+```
+
+In the example above: we start with clean memory, then step through a `Store` opcode which stores the value of register 3 (1) into the memory address stored in register 0 (0). Thus now `memory` shows memory address 0 contains value 1.
+
+:::note
+This command is only functional while the debugger is executing unconstrained code.
+:::
+
+#### `memset [Memory address] [New value]`
+
+Update a memory cell with the given value. For example:
+
+```
+> memory
+0 = 1
+> memset 0 2
+> memory
+0 = 2
+> memset 1 4
+> memory
+0 = 2
+1 = 4
+>
+```
+
+:::note
+This command is only functional while the debugger is executing unconstrained code.
+:::
\ No newline at end of file
diff --git a/docs/versioned_docs/version-v0.39.0/reference/debugger/debugger_vscode.md b/docs/versioned_docs/version-v0.39.0/reference/debugger/debugger_vscode.md
new file mode 100644
index 00000000000..c027332b3b0
--- /dev/null
+++ b/docs/versioned_docs/version-v0.39.0/reference/debugger/debugger_vscode.md
@@ -0,0 +1,82 @@
+---
+title: VS Code Debugger
+description:
+  VS Code Debugger configuration and features.
+keywords:
+  [
+    Nargo,
+    Noir CLI,
+    Noir Debugger,
+    VS Code,
+    IDE,
+  ]
+sidebar_position: 0
+---
+
+# VS Code Noir Debugger Reference
+
+The Noir debugger enabled by the vscode-noir extension ships with default settings such that the most common scenario should run without any additional configuration steps.
+
+These defaults can nevertheless be overridden by defining a launch configuration file. This page provides a reference for the properties you can override via a launch configuration file, as well as documenting the Nargo `dap` command, which is a dependency of the VS Code Noir debugger. 
+
+
+## Creating and editing launch configuration files
+
+To create a launch configuration file from VS Code, open the _debug pane_, and click on _create a launch.json file_. 
+
+![Creating a launch configuration file](@site/static/img/debugger/ref1-create-launch.png)
+
+A `launch.json` file will be created, populated with basic defaults. 
+
+### Noir Debugger launch.json properties
+
+#### projectFolder
+
+_String, optional._
+
+Absolute path to the Nargo project to debug. By default, it is dynamically determined by looking for the nearest `Nargo.toml` file to the active file at the moment of launching the debugger. 
+
+#### proverName
+
+_String, optional._
+
+Name of the prover input to use. Defaults to `Prover`, which looks for a file named `Prover.toml` at the `projectFolder`.
+
+#### generateAcir
+
+_Boolean, optional._
+
+If true, generate ACIR opcodes instead of unconstrained opcodes which will be closer to release binaries but less convenient for debugging. Defaults to `false`.
+                
+#### skipInstrumentation
+
+_Boolean, optional._
+
+Skips variables debugging instrumentation of code, making debugging less convenient but the resulting binary smaller and closer to production. Defaults to `false`.
+
+:::note
+Skipping instrumentation causes the debugger to be unable to inspect local variables.
+:::
+
+## `nargo dap [OPTIONS]`
+
+When run without any option flags, it starts the Nargo Debug Adapter Protocol server, which acts as the debugging backend for the VS Code Noir Debugger. 
+
+All option flags are related to preflight checks. The Debug Adapter Protocol specifies how errors are to be informed from a running DAP server, but it doesn't specify mechanisms to communicate server initialization errors between the DAP server and its client IDE. 
+
+Thus `nargo dap` ships with a _preflight check_ mode. If flag `--preflight-check` and the rest of the `--preflight-*` flags are provided, Nargo will run the same initialization routine except it will not start the DAP server.
+
+`vscode-noir` will then run `nargo dap` in preflight check mode first before a debugging session starts. If the preflight check ends in error, vscode-noir will present stderr and stdout output from this process through its own Output pane in VS Code. This makes it possible for users to diagnose what pieces of configuration might be wrong or missing in case of initialization errors.
+
+If the preflight check succeeds, `vscode-noir` proceeds to start the DAP server normally but running `nargo dap` without any additional flags.
+
+### Options
+
+| Option                                  | Description                                                                         |
+| --------------------------------------------------------- | --------------------------------------------------------------------------------------------------------- |
+| `--preflight-check`                     | If present, dap runs in preflight check mode.                               |
+| `--preflight-project-folder <PREFLIGHT_PROJECT_FOLDER>`   | Absolute path to the project to debug for preflight check.                        |
+| `--preflight-prover-name <PREFLIGHT_PROVER_NAME>`       | Name of prover file to use for preflight check                              |
+| `--preflight-generate-acir`                 | Optional. If present, compile in ACIR mode while running preflight check.                                 |
+| `--preflight-skip-instrumentation`            | Optional. If present, compile without introducing debug instrumentation while running preflight check.  |
+| `-h, --help`                            | Print help.                                               |
diff --git a/docs/versioned_docs/version-v0.39.0/reference/nargo_commands.md b/docs/versioned_docs/version-v0.39.0/reference/nargo_commands.md
new file mode 100644
index 00000000000..8842fad6647
--- /dev/null
+++ b/docs/versioned_docs/version-v0.39.0/reference/nargo_commands.md
@@ -0,0 +1,474 @@
+---
+title: Nargo
+description:
+  Noir CLI Commands for Noir Prover and Verifier to create, execute, prove and verify programs,
+  generate Solidity verifier smart contract and compile into JSON file containing ACIR
+  representation and ABI of circuit.
+keywords:
+  [
+    Nargo,
+    Noir CLI,
+    Noir Prover,
+    Noir Verifier,
+    generate Solidity verifier,
+    compile JSON file,
+    ACIR representation,
+    ABI of circuit,
+    TypeScript,
+  ]
+sidebar_position: 0
+---
+
+# Command-Line Help for `nargo`
+
+This document contains the help content for the `nargo` command-line program.
+
+**Command Overview:**
+
+* [`nargo`↴](#nargo)
+* [`nargo check`↴](#nargo-check)
+* [`nargo fmt`↴](#nargo-fmt)
+* [`nargo compile`↴](#nargo-compile)
+* [`nargo new`↴](#nargo-new)
+* [`nargo init`↴](#nargo-init)
+* [`nargo execute`↴](#nargo-execute)
+* [`nargo debug`↴](#nargo-debug)
+* [`nargo test`↴](#nargo-test)
+* [`nargo info`↴](#nargo-info)
+* [`nargo lsp`↴](#nargo-lsp)
+* [`nargo generate-completion-script`↴](#nargo-generate-completion-script)
+
+## `nargo`
+
+Noir's package manager
+
+**Usage:** `nargo <COMMAND>`
+
+###### **Subcommands:**
+
+* `check` — Checks the constraint system for errors
+* `fmt` — Format the Noir files in a workspace
+* `compile` — Compile the program and its secret execution trace into ACIR format
+* `new` — Create a Noir project in a new directory
+* `init` — Create a Noir project in the current directory
+* `execute` — Executes a circuit to calculate its return value
+* `debug` — Executes a circuit in debug mode
+* `test` — Run the tests for this program
+* `info` — Provides detailed information on each of a program's function (represented by a single circuit)
+* `lsp` — Starts the Noir LSP server
+* `generate-completion-script` — Generates a shell completion script for your favorite shell
+
+###### **Options:**
+
+
+
+
+## `nargo check`
+
+Checks the constraint system for errors
+
+**Usage:** `nargo check [OPTIONS]`
+
+###### **Options:**
+
+* `--package <PACKAGE>` — The name of the package to check
+* `--workspace` — Check all packages in the workspace
+
+  Possible values: `true`, `false`
+
+* `--overwrite` — Force overwrite of existing files
+
+  Possible values: `true`, `false`
+
+* `--expression-width <EXPRESSION_WIDTH>` — Specify the backend expression width that should be targeted
+* `--bounded-codegen` — Generate ACIR with the target backend expression width. The default is to generate ACIR without a bound and split expressions after code generation. Activating this flag can sometimes provide optimizations for certain programs
+
+  Default value: `false`
+
+  Possible values: `true`, `false`
+
+* `--force` — Force a full recompilation
+
+  Possible values: `true`, `false`
+
+* `--print-acir` — Display the ACIR for compiled circuit
+
+  Possible values: `true`, `false`
+
+* `--deny-warnings` — Treat all warnings as errors
+
+  Possible values: `true`, `false`
+
+* `--silence-warnings` — Suppress warnings
+
+  Possible values: `true`, `false`
+
+* `--debug-comptime-in-file <DEBUG_COMPTIME_IN_FILE>` — Enable printing results of comptime evaluation: provide a path suffix for the module to debug, e.g. "package_name/src/main.nr"
+* `--skip-underconstrained-check` — Flag to turn off the compiler check for under constrained values. Warning: This can improve compilation speed but can also lead to correctness errors. This check should always be run on production code
+
+  Possible values: `true`, `false`
+
+
+
+
+## `nargo fmt`
+
+Format the Noir files in a workspace
+
+**Usage:** `nargo fmt [OPTIONS]`
+
+###### **Options:**
+
+* `--check` — Run noirfmt in check mode
+
+  Possible values: `true`, `false`
+
+
+
+
+## `nargo compile`
+
+Compile the program and its secret execution trace into ACIR format
+
+**Usage:** `nargo compile [OPTIONS]`
+
+###### **Options:**
+
+* `--package <PACKAGE>` — The name of the package to compile
+* `--workspace` — Compile all packages in the workspace
+
+  Possible values: `true`, `false`
+
+* `--expression-width <EXPRESSION_WIDTH>` — Specify the backend expression width that should be targeted
+* `--bounded-codegen` — Generate ACIR with the target backend expression width. The default is to generate ACIR without a bound and split expressions after code generation. Activating this flag can sometimes provide optimizations for certain programs
+
+  Default value: `false`
+
+  Possible values: `true`, `false`
+
+* `--force` — Force a full recompilation
+
+  Possible values: `true`, `false`
+
+* `--print-acir` — Display the ACIR for compiled circuit
+
+  Possible values: `true`, `false`
+
+* `--deny-warnings` — Treat all warnings as errors
+
+  Possible values: `true`, `false`
+
+* `--silence-warnings` — Suppress warnings
+
+  Possible values: `true`, `false`
+
+* `--debug-comptime-in-file <DEBUG_COMPTIME_IN_FILE>` — Enable printing results of comptime evaluation: provide a path suffix for the module to debug, e.g. "package_name/src/main.nr"
+* `--skip-underconstrained-check` — Flag to turn off the compiler check for under constrained values. Warning: This can improve compilation speed but can also lead to correctness errors. This check should always be run on production code
+
+  Possible values: `true`, `false`
+
+
+
+
+## `nargo new`
+
+Create a Noir project in a new directory
+
+**Usage:** `nargo new [OPTIONS] <PATH>`
+
+###### **Arguments:**
+
+* `<PATH>` — The path to save the new project
+
+###### **Options:**
+
+* `--name <NAME>` — Name of the package [default: package directory name]
+* `--lib` — Use a library template
+
+  Possible values: `true`, `false`
+
+* `--bin` — Use a binary template [default]
+
+  Possible values: `true`, `false`
+
+* `--contract` — Use a contract template
+
+  Possible values: `true`, `false`
+
+
+
+
+## `nargo init`
+
+Create a Noir project in the current directory
+
+**Usage:** `nargo init [OPTIONS]`
+
+###### **Options:**
+
+* `--name <NAME>` — Name of the package [default: current directory name]
+* `--lib` — Use a library template
+
+  Possible values: `true`, `false`
+
+* `--bin` — Use a binary template [default]
+
+  Possible values: `true`, `false`
+
+* `--contract` — Use a contract template
+
+  Possible values: `true`, `false`
+
+
+
+
+## `nargo execute`
+
+Executes a circuit to calculate its return value
+
+**Usage:** `nargo execute [OPTIONS] [WITNESS_NAME]`
+
+###### **Arguments:**
+
+* `<WITNESS_NAME>` — Write the execution witness to named file
+
+Defaults to the name of the package being executed.
+
+###### **Options:**
+
+* `-p`, `--prover-name <PROVER_NAME>` — The name of the toml file which contains the inputs for the prover
+
+  Default value: `Prover`
+* `--package <PACKAGE>` — The name of the package to execute
+* `--workspace` — Execute all packages in the workspace
+
+  Possible values: `true`, `false`
+
+* `--expression-width <EXPRESSION_WIDTH>` — Specify the backend expression width that should be targeted
+* `--bounded-codegen` — Generate ACIR with the target backend expression width. The default is to generate ACIR without a bound and split expressions after code generation. Activating this flag can sometimes provide optimizations for certain programs
+
+  Default value: `false`
+
+  Possible values: `true`, `false`
+
+* `--force` — Force a full recompilation
+
+  Possible values: `true`, `false`
+
+* `--print-acir` — Display the ACIR for compiled circuit
+
+  Possible values: `true`, `false`
+
+* `--deny-warnings` — Treat all warnings as errors
+
+  Possible values: `true`, `false`
+
+* `--silence-warnings` — Suppress warnings
+
+  Possible values: `true`, `false`
+
+* `--debug-comptime-in-file <DEBUG_COMPTIME_IN_FILE>` — Enable printing results of comptime evaluation: provide a path suffix for the module to debug, e.g. "package_name/src/main.nr"
+* `--skip-underconstrained-check` — Flag to turn off the compiler check for under constrained values. Warning: This can improve compilation speed but can also lead to correctness errors. This check should always be run on production code
+
+  Possible values: `true`, `false`
+
+* `--oracle-resolver <ORACLE_RESOLVER>` — JSON RPC url to solve oracle calls
+
+
+
+## `nargo debug`
+
+Executes a circuit in debug mode
+
+**Usage:** `nargo debug [OPTIONS] [WITNESS_NAME]`
+
+###### **Arguments:**
+
+* `<WITNESS_NAME>` — Write the execution witness to named file
+
+###### **Options:**
+
+* `-p`, `--prover-name <PROVER_NAME>` — The name of the toml file which contains the inputs for the prover
+
+  Default value: `Prover`
+* `--package <PACKAGE>` — The name of the package to execute
+* `--expression-width <EXPRESSION_WIDTH>` — Specify the backend expression width that should be targeted
+* `--bounded-codegen` — Generate ACIR with the target backend expression width. The default is to generate ACIR without a bound and split expressions after code generation. Activating this flag can sometimes provide optimizations for certain programs
+
+  Default value: `false`
+
+  Possible values: `true`, `false`
+
+* `--force` — Force a full recompilation
+
+  Possible values: `true`, `false`
+
+* `--print-acir` — Display the ACIR for compiled circuit
+
+  Possible values: `true`, `false`
+
+* `--deny-warnings` — Treat all warnings as errors
+
+  Possible values: `true`, `false`
+
+* `--silence-warnings` — Suppress warnings
+
+  Possible values: `true`, `false`
+
+* `--debug-comptime-in-file <DEBUG_COMPTIME_IN_FILE>` — Enable printing results of comptime evaluation: provide a path suffix for the module to debug, e.g. "package_name/src/main.nr"
+* `--skip-underconstrained-check` — Flag to turn off the compiler check for under constrained values. Warning: This can improve compilation speed but can also lead to correctness errors. This check should always be run on production code
+
+  Possible values: `true`, `false`
+
+* `--acir-mode` — Force ACIR output (disabling instrumentation)
+
+  Possible values: `true`, `false`
+
+* `--skip-instrumentation <SKIP_INSTRUMENTATION>` — Disable vars debug instrumentation (enabled by default)
+
+  Possible values: `true`, `false`
+
+
+
+
+## `nargo test`
+
+Run the tests for this program
+
+**Usage:** `nargo test [OPTIONS] [TEST_NAME]`
+
+###### **Arguments:**
+
+* `<TEST_NAME>` — If given, only tests with names containing this string will be run
+
+###### **Options:**
+
+* `--show-output` — Display output of `println` statements
+
+  Possible values: `true`, `false`
+
+* `--exact` — Only run tests that match exactly
+
+  Possible values: `true`, `false`
+
+* `--package <PACKAGE>` — The name of the package to test
+* `--workspace` — Test all packages in the workspace
+
+  Possible values: `true`, `false`
+
+* `--expression-width <EXPRESSION_WIDTH>` — Specify the backend expression width that should be targeted
+* `--bounded-codegen` — Generate ACIR with the target backend expression width. The default is to generate ACIR without a bound and split expressions after code generation. Activating this flag can sometimes provide optimizations for certain programs
+
+  Default value: `false`
+
+  Possible values: `true`, `false`
+
+* `--force` — Force a full recompilation
+
+  Possible values: `true`, `false`
+
+* `--print-acir` — Display the ACIR for compiled circuit
+
+  Possible values: `true`, `false`
+
+* `--deny-warnings` — Treat all warnings as errors
+
+  Possible values: `true`, `false`
+
+* `--silence-warnings` — Suppress warnings
+
+  Possible values: `true`, `false`
+
+* `--debug-comptime-in-file <DEBUG_COMPTIME_IN_FILE>` — Enable printing results of comptime evaluation: provide a path suffix for the module to debug, e.g. "package_name/src/main.nr"
+* `--skip-underconstrained-check` — Flag to turn off the compiler check for under constrained values. Warning: This can improve compilation speed but can also lead to correctness errors. This check should always be run on production code
+
+  Possible values: `true`, `false`
+
+* `--oracle-resolver <ORACLE_RESOLVER>` — JSON RPC url to solve oracle calls
+
+
+
+## `nargo info`
+
+Provides detailed information on each of a program's function (represented by a single circuit)
+
+Current information provided per circuit: 1. The number of ACIR opcodes 2. Counts the final number gates in the circuit used by a backend
+
+**Usage:** `nargo info [OPTIONS]`
+
+###### **Options:**
+
+* `--package <PACKAGE>` — The name of the package to detail
+* `--workspace` — Detail all packages in the workspace
+
+  Possible values: `true`, `false`
+
+* `--profile-execution`
+
+  Possible values: `true`, `false`
+
+* `-p`, `--prover-name <PROVER_NAME>` — The name of the toml file which contains the inputs for the prover
+
+  Default value: `Prover`
+* `--expression-width <EXPRESSION_WIDTH>` — Specify the backend expression width that should be targeted
+* `--bounded-codegen` — Generate ACIR with the target backend expression width. The default is to generate ACIR without a bound and split expressions after code generation. Activating this flag can sometimes provide optimizations for certain programs
+
+  Default value: `false`
+
+  Possible values: `true`, `false`
+
+* `--force` — Force a full recompilation
+
+  Possible values: `true`, `false`
+
+* `--print-acir` — Display the ACIR for compiled circuit
+
+  Possible values: `true`, `false`
+
+* `--deny-warnings` — Treat all warnings as errors
+
+  Possible values: `true`, `false`
+
+* `--silence-warnings` — Suppress warnings
+
+  Possible values: `true`, `false`
+
+* `--debug-comptime-in-file <DEBUG_COMPTIME_IN_FILE>` — Enable printing results of comptime evaluation: provide a path suffix for the module to debug, e.g. "package_name/src/main.nr"
+* `--skip-underconstrained-check` — Flag to turn off the compiler check for under constrained values. Warning: This can improve compilation speed but can also lead to correctness errors. This check should always be run on production code
+
+  Possible values: `true`, `false`
+
+
+
+
+## `nargo lsp`
+
+Starts the Noir LSP server
+
+Starts an LSP server which allows IDEs such as VS Code to display diagnostics in Noir source.
+
+VS Code Noir Language Support: https://marketplace.visualstudio.com/items?itemName=noir-lang.vscode-noir
+
+**Usage:** `nargo lsp`
+
+
+
+## `nargo generate-completion-script`
+
+Generates a shell completion script for your favorite shell
+
+**Usage:** `nargo generate-completion-script <SHELL>`
+
+###### **Arguments:**
+
+* `<SHELL>` — The shell to generate completions for. One of: bash, elvish, fish, powershell, zsh
+
+
+
+<hr/>
+
+<small><i>
+    This document was generated automatically by
+    <a href="https://crates.io/crates/clap-markdown"><code>clap-markdown</code></a>.
+</i></small>
+
diff --git a/docs/versioned_docs/version-v0.39.0/reference/noir_codegen.md b/docs/versioned_docs/version-v0.39.0/reference/noir_codegen.md
new file mode 100644
index 00000000000..e4c362f9610
--- /dev/null
+++ b/docs/versioned_docs/version-v0.39.0/reference/noir_codegen.md
@@ -0,0 +1,116 @@
+---
+title: Noir Codegen for TypeScript
+description: Learn how to use Noir codegen to generate TypeScript bindings 
+keywords: [Nargo, Noir, compile, TypeScript]
+sidebar_position: 3
+---
+
+When using TypeScript, it is extra work to interpret Noir program outputs in a type-safe way. Third party libraries may exist for popular Noir programs, but they are either hard to find or unmaintained.
+
+Now you can generate TypeScript bindings for your Noir programs in two steps:
+
+1. Exporting Noir functions using `nargo export`
+2. Using the TypeScript module `noir_codegen` to generate TypeScript binding
+
+**Note:** you can only export functions from a Noir *library* (not binary or contract program types).
+
+## Installation
+
+### Your TypeScript project
+
+If you don't already have a TypeScript project you can add the module with `yarn` (or `npm`), then initialize it:
+
+```bash
+yarn add typescript -D
+npx tsc --init
+```
+
+### Add TypeScript module - `noir_codegen`
+
+The following command will add the module to your project's devDependencies:
+
+```bash
+yarn add @noir-lang/noir_codegen -D
+```
+
+### Nargo library
+
+Make sure you have Nargo, v0.25.0 or greater, installed. If you don't, follow the [installation guide](../getting_started/noir_installation.md).
+
+If you're in a new project, make a `circuits` folder and create a new Noir library:
+
+```bash
+mkdir circuits && cd circuits
+nargo new --lib myNoirLib
+```
+
+## Usage
+
+### Export ABI of specified functions
+
+First go to the `.nr` files in your Noir library, and add the `#[export]` macro to each function that you want to use in TypeScript.
+
+```rust
+#[export]
+fn your_function(...
+```
+
+From your Noir library (where `Nargo.toml` is), run the following command:
+
+```bash
+nargo export
+```
+
+You will now have an `export` directory with a .json file per exported function.
+
+You can also specify the directory of Noir programs using `--program-dir`, for example:
+
+```bash
+nargo export --program-dir=./circuits/myNoirLib
+```
+
+### Generate TypeScript bindings from exported functions
+
+To use the `noir-codegen` package we added to the TypeScript project:
+
+```bash
+yarn noir-codegen ./export/your_function.json
+```
+
+This creates an `exports` directory with an `index.ts` file containing all exported functions.
+
+**Note:** adding `--out-dir` allows you to specify an output dir for your TypeScript bindings to go. Eg:
+
+```bash
+yarn noir-codegen ./export/*.json --out-dir ./path/to/output/dir
+```
+
+## Example .nr function to .ts output
+
+Consider a Noir library with this function:
+
+```rust
+#[export]
+fn not_equal(x: Field, y: Field) -> bool {
+    x != y
+}
+```
+
+After the export and codegen steps, you should have an `index.ts` like:
+
+```typescript
+export type Field = string;
+
+
+export const is_equal_circuit: CompiledCircuit = 
+{"abi":{"parameters":[{"name":"x","type":{"kind":"field"},"visibility":"private"},{"name":"y","type":{"kind":"field"},"visibility":"private"}],"return_type":{"abi_type":{"kind":"boolean"},"visibility":"private"}},"bytecode":"H4sIAAAAAAAA/7WUMQ7DIAxFQ0Krrr2JjSGYLVcpKrn/CaqqDQN12WK+hPBgmWd/wEyHbF1SS923uhOs3pfoChI+wKXMAXzIKyNj4PB0TFTYc0w5RUjoqeAeEu1wqK0F54RGkWvW44LPzExnlkbMEs4JNZmN8PxS42uHv82T8a3Jeyn2Ks+VLPcO558HmyLMCDOXAXXtpPt4R/Rt9T36ss6dS9HGPx/eG17nGegKBQAA"};
+
+export async function is_equal(x: Field, y: Field, foreignCallHandler?: ForeignCallHandler): Promise<boolean> {
+  const program = new Noir(is_equal_circuit);
+  const args: InputMap = { x, y };
+  const { returnValue } = await program.execute(args, foreignCallHandler);
+  return returnValue as boolean;
+}
+```
+
+Now the `is_equal()` function and relevant types are readily available for use in TypeScript.
diff --git a/docs/versioned_docs/version-v0.39.0/tooling/debugger.md b/docs/versioned_docs/version-v0.39.0/tooling/debugger.md
new file mode 100644
index 00000000000..200b5fc423a
--- /dev/null
+++ b/docs/versioned_docs/version-v0.39.0/tooling/debugger.md
@@ -0,0 +1,26 @@
+---
+title: Debugger
+description: Learn about the Noir Debugger, in its REPL or VS Code versions.
+keywords: [Nargo, VSCode, Visual Studio Code, REPL, Debugger]
+sidebar_position: 2
+---
+
+# Noir Debugger
+
+There are currently two ways of debugging Noir programs:
+
+1. From VS Code, via the [vscode-noir](https://github.com/noir-lang/vscode-noir) extension. You can install it via the [Visual Studio Marketplace](https://marketplace.visualstudio.com/items?itemName=noir-lang.vscode-noir).
+2. Via the REPL debugger, which ships with Nargo.
+
+In order to use either version of the debugger, you will need to install recent enough versions of Noir, [Nargo](../getting_started/noir_installation.md) and vscode-noir:
+
+- Noir & Nargo ≥0.28.0
+- Noir's VS Code extension ≥0.0.11
+
+:::info
+At the moment, the debugger supports debugging binary projects, but not contracts.
+:::
+
+We cover the VS Code Noir debugger more in depth in [its VS Code debugger how-to guide](../how_to/debugger/debugging_with_vs_code.md) and [the reference](../reference/debugger/debugger_vscode.md).
+
+The REPL debugger is discussed at length in [the REPL debugger how-to guide](../how_to/debugger/debugging_with_the_repl.md) and [the reference](../reference/debugger/debugger_repl.md).
diff --git a/docs/versioned_docs/version-v0.39.0/tooling/language_server.md b/docs/versioned_docs/version-v0.39.0/tooling/language_server.md
new file mode 100644
index 00000000000..81e0356ef8a
--- /dev/null
+++ b/docs/versioned_docs/version-v0.39.0/tooling/language_server.md
@@ -0,0 +1,43 @@
+---
+title: Language Server
+description: Learn about the Noir Language Server, how to install the components, and configuration that may be required.
+keywords: [Nargo, Language Server, LSP, VSCode, Visual Studio Code]
+sidebar_position: 0
+---
+
+This section helps you install and configure the Noir Language Server.
+
+The Language Server Protocol (LSP) has two components, the [Server](#language-server) and the [Client](#language-client). Below we describe each in the context of Noir.
+
+## Language Server
+
+The Server component is provided by the Nargo command line tool that you installed at the beginning of this guide.
+As long as Nargo is installed and you've used it to run other commands in this guide, it should be good to go!
+
+If you'd like to verify that the `nargo lsp` command is available, you can run `nargo --help` and look for `lsp` in the list of commands. If you see it, you're using a version of Noir with LSP support.
+
+## Language Client
+
+The Client component is usually an editor plugin that launches the Server. It communicates LSP messages between the editor and the Server. For example, when you save a file, the Client will alert the Server, so it can try to compile the project and report any errors.
+
+Currently, Noir provides a Language Client for Visual Studio Code via the [vscode-noir](https://github.com/noir-lang/vscode-noir) extension. You can install it via the [Visual Studio Marketplace](https://marketplace.visualstudio.com/items?itemName=noir-lang.vscode-noir).
+
+> **Note:** Noir's Language Server Protocol support currently assumes users' VSCode workspace root to be the same as users' Noir project root (i.e. where Nargo.toml lies).
+>
+> If LSP features seem to be missing / malfunctioning, make sure you are opening your Noir project directly (instead of as a sub-folder) in your VSCode instance.
+
+When your language server is running correctly and the VSCode plugin is installed, you should see handy codelens buttons for compilation, measuring circuit size, execution, and tests:
+
+![Compile and Execute](@site/static/img/codelens_compile_execute.png)
+![Run test](@site/static/img/codelens_run_test.png)
+
+You should also see your tests in the `testing` panel:
+
+![Testing panel](@site/static/img/codelens_testing_panel.png)
+
+### Configuration
+
+- **Noir: Enable LSP** - If checked, the extension will launch the Language Server via `nargo lsp` and communicate with it.
+- **Noir: Nargo Flags** - Additional flags may be specified if you require them to be added when the extension calls `nargo lsp`.
+- **Noir: Nargo Path** - An absolute path to a Nargo binary with the `lsp` command. This may be useful if Nargo is not within the `PATH` of your editor.
+- **Noir > Trace: Server** - Setting this to `"messages"` or `"verbose"` will log LSP messages between the Client and Server. Useful for debugging.
diff --git a/docs/versioned_docs/version-v0.39.0/tooling/testing.md b/docs/versioned_docs/version-v0.39.0/tooling/testing.md
new file mode 100644
index 00000000000..866677da567
--- /dev/null
+++ b/docs/versioned_docs/version-v0.39.0/tooling/testing.md
@@ -0,0 +1,79 @@
+---
+title: Testing in Noir
+description: Learn how to use Nargo to test your Noir program in a quick and easy way
+keywords: [Nargo, testing, Noir, compile, test]
+sidebar_position: 1
+---
+
+You can test your Noir programs using Noir circuits.
+
+Nargo will automatically compile and run any functions which have the decorator `#[test]` on them if
+you run `nargo test`.
+
+For example if you have a program like:
+
+```rust
+fn add(x: u64, y: u64) -> u64 {
+    x + y
+}
+#[test]
+fn test_add() {
+    assert(add(2,2) == 4);
+    assert(add(0,1) == 1);
+    assert(add(1,0) == 1);
+}
+```
+
+Running `nargo test` will test that the `test_add` function can be executed while satisfying all
+the constraints which allows you to test that add returns the expected values. Test functions can't
+have any arguments currently.
+
+### Test fail
+
+You can write tests that are expected to fail by using the decorator `#[test(should_fail)]`. For example:
+
+```rust
+fn add(x: u64, y: u64) -> u64 {
+    x + y
+}
+#[test(should_fail)]
+fn test_add() {
+    assert(add(2,2) == 5);
+}
+```
+
+You can be more specific and make it fail with a specific reason by using `should_fail_with = "<the reason for failure>"`:
+
+```rust
+fn main(african_swallow_avg_speed : Field) {
+    assert(african_swallow_avg_speed == 65, "What is the airspeed velocity of an unladen swallow");
+}
+
+#[test]
+fn test_king_arthur() {
+    main(65);
+}
+
+#[test(should_fail_with = "What is the airspeed velocity of an unladen swallow")]
+fn test_bridgekeeper() {
+    main(32);
+}
+```
+
+The string given to `should_fail_with` doesn't need to exactly match the failure reason, it just needs to be a substring of it:
+
+```rust
+fn main(african_swallow_avg_speed : Field) {
+    assert(african_swallow_avg_speed == 65, "What is the airspeed velocity of an unladen swallow");
+}
+
+#[test]
+fn test_king_arthur() {
+    main(65);
+}
+
+#[test(should_fail_with = "airspeed velocity")]
+fn test_bridgekeeper() {
+    main(32);
+}
+```
\ No newline at end of file
diff --git a/docs/versioned_docs/version-v0.39.0/tutorials/noirjs_app.md b/docs/versioned_docs/version-v0.39.0/tutorials/noirjs_app.md
new file mode 100644
index 00000000000..6e69ea0bbed
--- /dev/null
+++ b/docs/versioned_docs/version-v0.39.0/tutorials/noirjs_app.md
@@ -0,0 +1,366 @@
+---
+title: Building a web app with NoirJS
+description: Learn how to setup a new app that uses Noir to generate and verify zero-knowledge SNARK proofs in a typescript or javascript environment.
+keywords: [how to, guide, javascript, typescript, noir, barretenberg, zero-knowledge, proofs, app]
+sidebar_position: 0
+pagination_next: noir/concepts/data_types/index
+---
+
+NoirJS is a set of packages meant to work both in a browser and a server environment. In this tutorial, we will build a simple web app using them. From here, you should get an idea on how to proceed with your own Noir projects!
+
+You can find the complete app code for this guide [here](https://github.com/noir-lang/tiny-noirjs-app).
+
+## Setup
+
+:::note
+
+Feel free to use whatever versions, just keep in mind that Nargo and the NoirJS packages are meant to be in sync. For example, Nargo 0.31.x matches `noir_js@0.31.x`, etc.
+
+In this guide, we will be pinned to 0.31.0.
+
+:::
+
+Before we start, we want to make sure we have Node, Nargo and the Barretenberg proving system (`bb`) installed.
+
+We start by opening a terminal and executing `node --version`. If we don't get an output like `v20.10.0`, that means node is not installed. Let's do that by following the handy [nvm guide](https://github.com/nvm-sh/nvm?tab=readme-ov-file#install--update-script).
+
+As for `Nargo`, we can follow the [Nargo guide](../getting_started/quick_start.md) to install it. If you're lazy, just paste this on a terminal and run `noirup`:
+
+```sh
+curl -L https://raw.githubusercontent.com/noir-lang/noirup/main/install | bash
+```
+
+Follow the instructions on [this page](https://github.com/AztecProtocol/aztec-packages/tree/master/barretenberg/cpp/src/barretenberg/bb#installation) to install `bb`.
+Version 0.41.0 is compatible with `nargo` version 0.31.0, which you can install with `bbup -v 0.41.0` once `bbup` is installed.
+
+Easy enough. Onwards!
+
+## Our project
+
+ZK is a powerful technology. An app that doesn't reveal one of the inputs to _anyone_ is almost unbelievable, yet Noir makes it as easy as a single line of code.
+
+In fact, it's so simple that it comes nicely packaged in `nargo`. Let's do that!
+
+### Nargo
+
+Run:
+
+```bash
+nargo new circuit
+```
+
+And... That's about it. Your program is ready to be compiled and run.
+
+To compile, let's `cd` into the `circuit` folder to enter our project, and call:
+
+```bash
+nargo compile
+```
+
+This compiles our circuit into `json` format and add it to a new `target` folder.
+
+:::info
+
+At this point in the tutorial, your folder structure should look like this:
+
+```tree
+.
+└── circuit <---- our working directory
+    ├── Nargo.toml
+    ├── src
+    │   └── main.nr
+    └── target
+        └── circuit.json
+```
+
+:::
+
+### Node and Vite
+
+If you want to explore Nargo, feel free to go on a side-quest now and follow the steps in the
+[getting started](../getting_started/quick_start.md) guide. However, we want our app to run on the browser, so we need Vite.
+
+Vite is a powerful tool to generate static websites. While it provides all kinds of features, let's just go barebones with some good old vanilla JS.
+
+To do this this, go back to the previous folder (`cd ..`) and create a new vite project by running `npm create vite` and choosing "Vanilla" and "Javascript".
+
+A wild `vite-project` directory should now appear in your root folder! Let's not waste any time and dive right in:
+
+```bash
+cd vite-project
+```
+
+### Setting Up Vite and Configuring the Project
+
+Before we proceed with any coding, let's get our environment tailored for Noir. We'll start by laying down the foundations with a `vite.config.js` file. This little piece of configuration is our secret sauce for making sure everything meshes well with the NoirJS libraries and other special setups we might need, like handling WebAssembly modules. Here’s how you get that going:
+
+#### Creating the vite.config.js
+
+In your freshly minted `vite-project` folder, create a new file named `vite.config.js` and open it in your code editor. Paste the following to set the stage:
+
+```javascript
+import { defineConfig } from 'vite';
+import copy from 'rollup-plugin-copy';
+import fs from 'fs';
+import path from 'path';
+
+const wasmContentTypePlugin = {
+  name: 'wasm-content-type-plugin',
+  configureServer(server) {
+    server.middlewares.use(async (req, res, next) => {
+      if (req.url.endsWith('.wasm')) {
+        res.setHeader('Content-Type', 'application/wasm');
+        const newPath = req.url.replace('deps', 'dist');
+        const targetPath = path.join(__dirname, newPath);
+        const wasmContent = fs.readFileSync(targetPath);
+        return res.end(wasmContent);
+      }
+      next();
+    });
+  },
+};
+
+export default defineConfig(({ command }) => {
+  if (command === 'serve') {
+    return {
+      build: {
+        target: 'esnext',
+        rollupOptions: {
+          external: ['@aztec/bb.js']
+        }
+      },
+      optimizeDeps: {
+        esbuildOptions: {
+          target: 'esnext'
+        }
+      },
+      plugins: [
+        copy({
+          targets: [{ src: 'node_modules/**/*.wasm', dest: 'node_modules/.vite/dist' }],
+          copySync: true,
+          hook: 'buildStart',
+        }),
+        command === 'serve' ? wasmContentTypePlugin : [],
+      ],
+    };
+  }
+
+  return {};
+});
+```
+
+#### Install Dependencies
+
+Now that our stage is set, install the necessary NoirJS packages along with our other dependencies:
+
+```bash
+npm install && npm install @noir-lang/backend_barretenberg@0.31.0 @noir-lang/noir_js@0.31.0
+npm install rollup-plugin-copy --save-dev
+```
+
+:::info
+
+At this point in the tutorial, your folder structure should look like this:
+
+```tree
+.
+└── circuit
+    └── ...etc...
+└── vite-project <---- our working directory
+    └── ...etc...
+```
+
+:::
+
+#### Some cleanup
+
+`npx create vite` is amazing but it creates a bunch of files we don't really need for our simple example. Actually, let's just delete everything except for `vite.config.js`, `index.html`, `main.js` and `package.json`. I feel lighter already.
+
+![my heart is ready for you, noir.js](@site/static/img/memes/titanic.jpeg)
+
+## HTML
+
+Our app won't run like this, of course. We need some working HTML, at least. Let's open our broken-hearted `index.html` and replace everything with this code snippet:
+
+```html
+<!DOCTYPE html>
+<head>
+  <style>
+    .outer {
+        display: flex;
+        justify-content: space-between;
+        width: 100%;
+    }
+    .inner {
+        width: 45%;
+        border: 1px solid black;
+        padding: 10px;
+        word-wrap: break-word;
+    }
+  </style>
+</head>
+<body>
+  <script type="module" src="/main.js"></script>
+  <h1>Noir app</h1>
+  <div class="input-area">
+    <input id="guessInput" type="number" placeholder="Enter your guess" />
+    <button id="submitGuess">Submit Guess</button>
+  </div>
+  <div class="outer">
+    <div id="logs" class="inner"><h2>Logs</h2></div>
+    <div id="results" class="inner"><h2>Proof</h2></div>
+  </div>
+</body>
+</html>
+```
+
+It _could_ be a beautiful UI... Depending on which universe you live in.
+
+## Some good old vanilla Javascript
+
+Our love for Noir needs undivided attention, so let's just open `main.js` and delete everything (this is where the romantic scenery becomes a bit creepy).
+
+Start by pasting in this boilerplate code:
+
+```js
+function display(container, msg) {
+  const c = document.getElementById(container);
+  const p = document.createElement('p');
+  p.textContent = msg;
+  c.appendChild(p);
+}
+
+document.getElementById('submitGuess').addEventListener('click', async () => {
+  try {
+    // here's where love happens
+  } catch (err) {
+    display('logs', 'Oh 💔 Wrong guess');
+  }
+});
+```
+
+The display function doesn't do much. We're simply manipulating our website to see stuff happening. For example, if the proof fails, it will simply log a broken heart 😢
+
+:::info
+
+At this point in the tutorial, your folder structure should look like this:
+
+```tree
+.
+└── circuit
+    └── ...same as above
+└── vite-project
+    ├── vite.config.js
+    ├── main.js
+    ├── package.json
+    └── index.html
+```
+
+You'll see other files and folders showing up (like `package-lock.json`, `node_modules`) but you shouldn't have to care about those.
+
+:::
+
+## Some NoirJS
+
+We're starting with the good stuff now. If you've compiled the circuit as described above, you should have a `json` file we want to import at the very top of our `main.js` file:
+
+```ts
+import circuit from '../circuit/target/circuit.json';
+```
+
+[Noir is backend-agnostic](../index.mdx#whats-new-about-noir). We write Noir, but we also need a proving backend. That's why we need to import and instantiate the two dependencies we installed above: `BarretenbergBackend` and `Noir`. Let's import them right below:
+
+```js
+import { BarretenbergBackend, BarretenbergVerifier as Verifier } from '@noir-lang/backend_barretenberg';
+import { Noir } from '@noir-lang/noir_js';
+```
+
+And instantiate them inside our try-catch block:
+
+```ts
+// try {
+const backend = new BarretenbergBackend(circuit);
+const noir = new Noir(circuit);
+// }
+```
+
+:::note
+
+For the remainder of the tutorial, everything will be happening inside the `try` block
+
+:::
+
+## Our app
+
+Now for the app itself. We're capturing whatever is in the input when people press the submit button. Just add this:
+
+```js
+const x = parseInt(document.getElementById('guessInput').value);
+const input = { x, y: 2 };
+```
+
+Now we're ready to prove stuff! Let's feed some inputs to our circuit and calculate the proof:
+
+```js
+await setup(); // let's squeeze our wasm inits here
+
+display('logs', 'Generating proof... ⌛');
+const { witness } = await noir.execute(input);
+const proof = await backend.generateProof(witness);
+display('logs', 'Generating proof... ✅');
+display('results', proof.proof);
+```
+
+You're probably eager to see stuff happening, so go and run your app now!
+
+From your terminal, run `npm run dev`. If it doesn't open a browser for you, just visit `localhost:5173`. You should now see the worst UI ever, with an ugly input.
+
+![Getting Started 0](@site/static/img/noir_getting_started_1.png)
+
+Now, our circuit says `fn main(x: Field, y: pub Field)`. This means only the `y` value is public, and it's hardcoded above: `input = { x, y: 2 }`. In other words, you won't need to send your secret`x` to the verifier!
+
+By inputting any number other than 2 in the input box and clicking "submit", you should get a valid proof. Otherwise the proof won't even generate correctly. By the way, if you're human, you shouldn't be able to understand anything on the "proof" box. That's OK. We like you, human ❤️.
+
+## Verifying
+
+Time to celebrate, yes! But we shouldn't trust machines so blindly. Let's add these lines to see our proof being verified:
+
+```js
+display('logs', 'Verifying proof... ⌛');
+const isValid = await backend.verifyProof(proof);
+
+// or to cache and use the verification key:
+// const verificationKey = await backend.getVerificationKey();
+// const verifier = new Verifier();
+// const isValid = await verifier.verifyProof(proof, verificationKey);
+
+if (isValid) display('logs', 'Verifying proof... ✅');
+```
+
+You have successfully generated a client-side Noir web app!
+
+![coded app without math knowledge](@site/static/img/memes/flextape.jpeg)
+
+## Further Reading
+
+You can see how noirjs is used in a full stack Next.js hardhat application in the [noir-starter repo here](https://github.com/noir-lang/noir-starter/tree/main/vite-hardhat). The example shows how to calculate a proof in the browser and verify it with a deployed Solidity verifier contract from noirjs.
+
+You should also check out the more advanced examples in the [noir-examples repo](https://github.com/noir-lang/noir-examples), where you'll find reference usage for some cool apps.
+
+## UltraHonk Backend
+
+Barretenberg has recently exposed a new UltraHonk backend. We can use UltraHonk in NoirJS after version 0.33.0. Everything will be the same as the tutorial above, except that the class we need to import will change:
+
+```js
+import { UltraHonkBackend, UltraHonkVerifier as Verifier } from '@noir-lang/backend_barretenberg';
+```
+
+The backend will then be instantiated as such:
+
+```js
+const backend = new UltraHonkBackend(circuit);
+```
+
+Then all the commands to prove and verify your circuit will be same.
+
+The only feature currently unsupported with UltraHonk are [recursive proofs](../explainers/explainer-recursion.md).
diff --git a/docs/versioned_docs/version-v1.0.0-beta.0/explainers/cspell.json b/docs/versioned_docs/version-v1.0.0-beta.0/explainers/cspell.json
new file mode 100644
index 00000000000..c60b0a597b1
--- /dev/null
+++ b/docs/versioned_docs/version-v1.0.0-beta.0/explainers/cspell.json
@@ -0,0 +1,5 @@
+{
+    "words": [
+        "Cryptdoku"
+    ]
+}
diff --git a/docs/versioned_docs/version-v1.0.0-beta.0/explainers/explainer-oracle.md b/docs/versioned_docs/version-v1.0.0-beta.0/explainers/explainer-oracle.md
new file mode 100644
index 00000000000..821e1f95c04
--- /dev/null
+++ b/docs/versioned_docs/version-v1.0.0-beta.0/explainers/explainer-oracle.md
@@ -0,0 +1,57 @@
+---
+title: Oracles
+description: This guide provides an in-depth understanding of how Oracles work in Noir programming. Learn how to use outside calculations in your programs, constrain oracles, and understand their uses and limitations.
+keywords:
+  - Noir Programming
+  - Oracles
+  - JSON-RPC
+  - Foreign Call Handlers
+  - Constrained Functions
+  - Blockchain Programming
+sidebar_position: 1
+---
+
+If you've seen "The Matrix" you may recall "The Oracle" as Gloria Foster smoking cigarettes and baking cookies. While she appears to "know things", she is actually providing a calculation of a pre-determined future. Noir Oracles are similar, in a way. They don't calculate the future (yet), but they allow you to use outside calculations in your programs.
+
+![matrix oracle prediction](@site/static/img/memes/matrix_oracle.jpeg)
+
+A Noir program is usually self-contained. You can pass certain inputs to it, and it will generate a deterministic output for those inputs. But what if you wanted to defer some calculation to an outside process or source?
+
+Oracles are functions that provide this feature.
+
+## Use cases
+
+An example usage for Oracles is proving something on-chain. For example, proving that the ETH-USDC quote was below a certain target at a certain block time. Or even making more complex proofs like proving the ownership of an NFT as an anonymous login method.
+
+Another interesting use case is to defer expensive calculations to be made outside of the Noir program, and then constraining the result; similar to the use of [unconstrained functions](../noir/concepts//unconstrained.md).
+
+In short, anything that can be constrained in a Noir program but needs to be fetched from an external source is a great candidate to be used in oracles.
+
+## Constraining oracles
+
+Just like in The Matrix, Oracles are powerful. But with great power, comes great responsibility. Just because you're using them in a Noir program doesn't mean they're true. Noir has no superpowers. If you want to prove that Portugal won the Euro Cup 2016, you're still relying on potentially untrusted information.
+
+To give a concrete example, Alice wants to login to the [NounsDAO](https://nouns.wtf/) forum with her username "noir_nouner" by proving she owns a noun without revealing her ethereum address. Her Noir program could have an oracle call like this:
+
+```rust
+#[oracle(getNoun)]
+unconstrained fn get_noun(address: Field) -> Field
+```
+
+This oracle could naively resolve with the number of Nouns she possesses. However, it is useless as a trusted source, as the oracle could resolve to anything Alice wants. In order to make this oracle call actually useful, Alice would need to constrain the response from the oracle, by proving her address and the noun count belongs to the state tree of the contract.
+
+In short, **Oracles don't prove anything. Your Noir program does.**
+
+:::danger
+
+If you don't constrain the return of your oracle, you could be clearly opening an attack vector on your Noir program. Make double-triple sure that the return of an oracle call is constrained!
+
+:::
+
+## How to use Oracles
+
+On CLI, Nargo resolves oracles by making JSON RPC calls, which means it would require an RPC node to be running.
+
+In JavaScript, NoirJS accepts and resolves arbitrary call handlers (that is, not limited to JSON) as long as they match the expected types the developer defines. Refer to [Foreign Call Handler](../reference/NoirJS/noir_js/type-aliases/ForeignCallHandler.md) to learn more about NoirJS's call handling.
+
+If you want to build using oracles, follow through to the [oracle guide](../how_to/how-to-oracles.md) for a simple example on how to do that.
diff --git a/docs/versioned_docs/version-v1.0.0-beta.0/explainers/explainer-recursion.md b/docs/versioned_docs/version-v1.0.0-beta.0/explainers/explainer-recursion.md
new file mode 100644
index 00000000000..df8529ef4e0
--- /dev/null
+++ b/docs/versioned_docs/version-v1.0.0-beta.0/explainers/explainer-recursion.md
@@ -0,0 +1,176 @@
+---
+title: Recursive proofs
+description: Explore the concept of recursive proofs in Zero-Knowledge programming. Understand how recursion works in Noir, a language for writing smart contracts on the EVM blockchain. Learn through practical examples like Alice and Bob's guessing game, Charlie's recursive merkle tree, and Daniel's reusable components. Discover how to use recursive proofs to optimize computational resources and improve efficiency.
+
+keywords:
+  [
+    "Recursive Proofs",
+    "Zero-Knowledge Programming",
+    "Noir",
+    "EVM Blockchain",
+    "Smart Contracts",
+    "Recursion in Noir",
+    "Alice and Bob Guessing Game",
+    "Recursive Merkle Tree",
+    "Reusable Components",
+    "Optimizing Computational Resources",
+    "Improving Efficiency",
+    "Verification Key",
+    "Aggregation",
+    "Recursive zkSNARK schemes",
+    "PLONK",
+    "Proving and Verification Keys"
+  ]
+sidebar_position: 1
+pagination_next: how_to/how-to-recursion
+---
+
+In programming, we tend to think of recursion as something calling itself. A classic example would be the calculation of the factorial of a number:
+
+```js
+function factorial(n) {
+    if (n === 0 || n === 1) {
+        return 1;
+    } else {
+        return n * factorial(n - 1);
+    }
+}
+```
+
+In this case, while `n` is not `1`, this function will keep calling itself until it hits the base case, bubbling up the result on the call stack:
+
+```md
+        Is `n` 1?  <---------
+           /\               /
+          /  \         n = n -1 
+         /    \           /
+       Yes     No --------
+```
+
+In Zero-Knowledge, recursion has some similarities.
+
+It is not a Noir function calling itself, but a proof being used as an input to another circuit. In short, you verify one proof *inside* another proof, returning the proof that both proofs are valid.
+
+This means that, given enough computational resources, you can prove the correctness of any arbitrary number of proofs in a single proof. This could be useful to design state channels (for which a common example would be [Bitcoin's Lightning Network](https://en.wikipedia.org/wiki/Lightning_Network)), to save on gas costs by settling one proof on-chain, or simply to make business logic less dependent on a consensus mechanism.
+
+## Examples
+
+Let us look at some of these examples
+
+### Alice and Bob - Guessing game
+
+Alice and Bob are friends, and they like guessing games. They want to play a guessing game online, but for that, they need a trusted third-party that knows both of their secrets and finishes the game once someone wins.
+
+So, they use zero-knowledge proofs. Alice tries to guess Bob's number, and Bob will generate a ZK proof stating whether she succeeded or failed.
+
+This ZK proof can go on a smart contract, revealing the winner and even giving prizes. However, this means every turn needs to be verified on-chain. This incurs some cost and waiting time that may simply make the game too expensive or time-consuming to be worth it.
+
+As a solution, Alice proposes the following: "what if Bob generates his proof, and instead of sending it on-chain, I verify it *within* my own proof before playing my own turn?".
+
+She can then generate a proof that she verified his proof, and so on.
+
+```md
+      Did you fail?  <--------------------------
+           / \                                  /
+          /   \                             n = n -1 
+         /     \                              /
+       Yes      No                           /
+        |        |                          /
+        |        |                         /
+        |      You win                    /
+        |                                /
+        |                               /
+Generate proof of that                 /
+        +                             /
+    my own guess     ----------------
+```
+
+### Charlie - Recursive merkle tree
+
+Charlie is a concerned citizen, and wants to be sure his vote in an election is accounted for. He votes with a ZK proof, but he has no way of knowing that his ZK proof was included in the total vote count!
+
+If the vote collector puts all of the votes into a [Merkle tree](https://en.wikipedia.org/wiki/Merkle_tree), everyone can prove the verification of two proofs within one proof, as such:
+
+```md
+                    abcd
+           __________|______________
+          |                         |
+         ab                         cd 
+     _____|_____              ______|______
+    |           |            |             |              
+  alice        bob        charlie        daniel 
+```
+
+Doing this recursively allows us to arrive on a final proof `abcd` which if true, verifies the correctness of all the votes.
+
+### Daniel - Reusable components
+
+Daniel has a big circuit and a big headache. A part of his circuit is a setup phase that finishes with some assertions that need to be made. But that section alone takes most of the proving time, and is largely independent of the rest of the circuit.
+
+He might find it more efficient to generate a proof for that setup phase separately, and verify that proof recursively in the actual business logic section of his circuit. This will allow for parallelization of both proofs, which results in a considerable speedup.
+
+## What params do I need
+
+As you can see in the [recursion reference](noir/standard_library/recursion.mdx), a simple recursive proof requires:
+
+- The proof to verify
+- The Verification Key of the circuit that generated the proof
+- A hash of this verification key, as it's needed for some backends
+- The public inputs for the proof
+
+:::info
+
+Recursive zkSNARK schemes do not necessarily "verify a proof" in the sense that you expect a true or false to be spit out by the verifier. Rather an aggregation object is built over the public inputs.
+
+So, taking the example of Alice and Bob and their guessing game:
+
+- Alice makes her guess. Her proof is *not* recursive: it doesn't verify any proof within it! It's just a standard `assert(x != y)` circuit
+- Bob verifies Alice's proof and makes his own guess. In this circuit, he doesn't exactly *prove* the verification of Alice's proof. Instead, he *aggregates* his proof to Alice's proof. The actual verification is done when the full proof is verified, for example when using `nargo verify` or through the verifier smart contract.
+
+We can imagine recursive proofs a [relay race](https://en.wikipedia.org/wiki/Relay_race). The first runner doesn't have to receive the baton from anyone else, as he/she already starts with it. But when his/her turn is over, the next runner needs to receive it, run a bit more, and pass it along. Even though every runner could theoretically verify the baton mid-run (why not? 🏃🔍), only at the end of the race does the referee verify that the whole race is valid.
+
+:::
+
+## Some architecture
+
+As with everything in computer science, there's no one-size-fits all. But there are some patterns that could help understanding and implementing them. To give three examples:
+
+### Adding some logic to a proof verification
+
+This would be an approach for something like our guessing game, where proofs are sent back and forth and are verified by each opponent. This circuit would be divided in two sections:
+
+- A `recursive verification` section, which would be just the call to `std::verify_proof`, and that would be skipped on the first move (since there's no proof to verify)
+- A `guessing` section, which is basically the logic part where the actual guessing happens
+
+In such a situation, and assuming Alice is first, she would skip the first part and try to guess Bob's number. Bob would then verify her proof on the first section of his run, and try to guess Alice's number on the second part, and so on.
+
+### Aggregating proofs
+
+In some one-way interaction situations, recursion would allow for aggregation of simple proofs that don't need to be immediately verified on-chain or elsewhere.
+
+To give a practical example, a barman wouldn't need to verify a "proof-of-age" on-chain every time he serves alcohol to a customer. Instead, the architecture would comprise two circuits:
+
+- A `main`, non-recursive circuit with some logic
+- A `recursive` circuit meant to verify two proofs in one proof
+
+The customer's proofs would be intermediate, and made on their phones, and the barman could just verify them locally. He would then aggregate them into a final proof sent on-chain (or elsewhere) at the end of the day.
+
+### Recursively verifying different circuits
+
+Nothing prevents you from verifying different circuits in a recursive proof, for example:
+
+- A `circuit1` circuit
+- A `circuit2` circuit
+- A `recursive` circuit
+
+In this example, a regulator could verify that taxes were paid for a specific purchase by aggregating both a `payer` circuit (proving that a purchase was made and taxes were paid), and a `receipt` circuit (proving that the payment was received)
+
+## How fast is it
+
+At the time of writing, verifying recursive proofs is surprisingly fast. This is because most of the time is spent on generating the verification key that will be used to generate the next proof. So you are able to cache the verification key and reuse it later.
+
+Currently, Noir JS packages don't expose the functionality of loading proving and verification keys, but that feature exists in the underlying `bb.js` package.
+
+## How can I try it
+
+Learn more about using recursion in Nargo and NoirJS in the [how-to guide](../how_to/how-to-recursion.md) and see a full example in [noir-examples](https://github.com/noir-lang/noir-examples).
diff --git a/docs/versioned_docs/version-v1.0.0-beta.0/explainers/explainer-writing-noir.md b/docs/versioned_docs/version-v1.0.0-beta.0/explainers/explainer-writing-noir.md
new file mode 100644
index 00000000000..3ce4245dc45
--- /dev/null
+++ b/docs/versioned_docs/version-v1.0.0-beta.0/explainers/explainer-writing-noir.md
@@ -0,0 +1,177 @@
+---
+title: Thinking in Circuits
+description: Considerations when writing Noir programs
+keywords: [Noir, programming, rust]
+tags: [Optimization]
+sidebar_position: 0
+---
+
+
+This article intends to set you up with key concepts essential for writing more viable applications that use zero knowledge proofs, namely around efficient circuits.
+
+## Context - 'Efficient' is subjective
+
+When writing a web application for a performant computer with high-speed internet connection, writing efficient code sometimes is seen as an afterthought only if needed. Large multiplications running at the innermost of nested loops may not even be on a dev's radar.
+When writing firmware for a battery-powered microcontroller, you think of cpu cycles as rations to keep within a product's power budget.
+
+> Code is written to create applications that perform specific tasks within specific constraints
+
+And these constraints differ depending on where the compiled code is execute.
+
+### The Ethereum Virtual Machine (EVM)
+
+In scenarios where extremely low gas costs are required for an Ethereum application to be viable/competitive, Ethereum smart contract developers get into what is colloquially known as: "*gas golfing*". Finding the lowest execution cost of their compiled code (EVM bytecode) to achieve a specific task.
+
+The equivalent optimization task when writing zk circuits is affectionately referred to as "*gate golfing*", finding the lowest gate representation of the compiled Noir code.
+
+### Coding for circuits - a paradigm shift
+
+In zero knowledge cryptography, code is compiled to "circuits" consisting of arithmetic gates, and gate count is the significant cost. Depending on the proving system this is linearly proportionate to proving time, and so from a product point this should be kept as low as possible.
+
+Whilst writing efficient code for web apps and Solidity has a few key differences, writing efficient circuits have a different set of considerations. It is a bit of a paradigm shift, like writing code for GPUs for the first time...
+
+For example, drawing a circle at (0, 0) of radius `r`:
+- For a single CPU thread,
+```
+for theta in 0..2*pi {
+  let x = r * cos(theta);
+  let y = r * sin(theta);
+  draw(x, y);
+} // note: would do 0 - pi/2 and draw +ve/-ve x and y.
+```
+
+- For GPUs (simultaneous parallel calls with x, y across image),
+```
+if (x^2 + y^2 = r^2) {
+  draw(x, y);
+}
+```
+
+([Related](https://www.youtube.com/watch?v=-P28LKWTzrI))
+
+Whilst this CPU -> GPU does not translate to circuits exactly, it is intended to exemplify the difference in intuition when coding for different machine capabilities/constraints.
+
+### Context Takeaway
+
+For those coming from a primarily web app background, this article will explain what you need to consider when writing circuits. Furthermore, for those experienced writing efficient machine code, prepare to shift what you think is efficient 😬
+
+## Translating from Rust
+
+For some applications using Noir, existing code might be a convenient starting point to then proceed to optimize the gate count of.
+
+:::note
+Many valuable functions and algorithms have been written in more established languages (C/C++), and converted to modern ones (like Rust).
+:::
+
+Fortunately for Noir developers, when needing a particular function a Rust implementation can be readily compiled into Noir with some key changes. While the compiler does a decent amount of optimizations, it won't be able to change code that has been optimized for clock-cycles into code optimized for arithmetic gates.
+
+A few things to do when converting Rust code to Noir:
+- `println!` is not a macro, use `println` function (same for `assert_eq`)
+- No early `return` in function. Use constrain via assertion instead
+- No passing by reference. Remove `&` operator to pass by value (copy)
+- No boolean operators (`&&`, `||`). Use bitwise operators (`&`, `|`) with boolean values
+- No type `usize`. Use types `u8`, `u32`, `u64`, ... 
+- `main` return must be public, `pub`
+- No `const`, use `global`
+- Noir's LSP is your friend, so error message should be informative enough to resolve syntax issues.
+
+## Writing efficient Noir for performant products
+
+The following points help refine our understanding over time.
+
+:::note
+A Noir program makes a statement that can be verified.
+:::
+
+It compiles to a structure that represents the calculation, and can assert results within the calculation at any stage (via the `constrain` keyword).
+
+A Noir program compiles to an Abstract Circuit Intermediate Representation which is:
+ - Conceptually a tree structure
+ - Leaves (inputs) are the `Field` type
+ - Nodes contain arithmetic operations to combine them (gates)
+ - The root is the final result (return value)
+
+:::tip
+The command `nargo info` shows the programs circuit size, and is useful to compare the value of changes made.
+You can dig deeper and use the `--print-acir` param to take a closer look at individual ACIR opcodes, and the proving backend to see its gate count (eg for barretenberg, `bb gates -b ./target/program.json`).
+:::
+
+### Use the `Field` type
+
+Since the native type of values in circuits are `Field`s, using them for variables in Noir means less gates converting them under the hood.
+Some things to be mindful of when using a Field type for a regular integer value:
+- A variable of type `Field` can be cast `as` an integer type (eg `u8`, `u64`)
+  - Note: this retains only the bits of the integer type. Eg a Field value of 260 as a `u8` becomes 4
+- For Field types arithmetic operations meaningfully overflow/underflow, yet for integer types they are checked according to their size
+- Comparisons and bitwise operations do not exist for `Field`s, cast to an appropriately sized integer type when you need to
+
+:::tip
+Where possible, use `Field` type for values. Using smaller value types, and bit-packing strategies, will result in MORE gates
+:::
+
+
+### Use Arithmetic over non-arithmetic operations
+
+Since circuits are made of arithmetic gates, the cost of arithmetic operations tends to be one gate. Whereas for procedural code, they represent several clock cycles.
+
+Inversely, non-arithmetic operators are achieved with multiple gates, vs 1 clock cycle for procedural code.
+
+| (cost\op)  | arithmetic<br>(`*`, `+`) | bit-wise ops<br>(eg `<`, `\|`, `>>`) |
+| - | - | - |
+| **cycles** | 10+ | 1 |
+| **gates**  | 1 | 10+ |
+
+Bit-wise operations (e.g. bit shifts `<<` and `>>`), albeit commonly used in general programming and especially for clock cycle optimizations, are on the contrary expensive in gates when performed within circuits.
+
+Translate away from bit shifts when writing constrained functions for the best performance.
+
+On the flip side, feel free to use bit shifts in unconstrained functions and tests if necessary, as they are executed outside of circuits and does not induce performance hits.
+
+### Use static over dynamic values
+
+Another general theme that manifests in different ways is that static reads are represented with less gates than dynamic ones.
+
+Reading from read-only memory (ROM) adds less gates than random-access memory (RAM), 2 vs ~3.25 due to the additional bounds checks. Arrays of fixed length (albeit used at a lower capacity), will generate less gates than dynamic storage.
+
+Related to this, if an index used to access an array is not known at compile time (ie unknown until run time), then ROM will be converted to RAM, expanding the gate count.
+
+:::tip
+Use arrays and indices that are known at compile time where possible.
+Using `assert_constant(i);` before an index, `i`, is used in an array will give a compile error if `i` is NOT known at compile time.
+:::
+
+### Leverage unconstrained execution
+
+Constrained verification can leverage unconstrained execution, this is especially useful for operations that are represented by many gates.
+Use an [unconstrained function](../noir/concepts/unconstrained.md) to perform gate-heavy calculations, then verify and constrain the result.
+
+Eg division generates more gates than multiplication, so calculating the quotient in an unconstrained function then constraining the product for the quotient and divisor (+ any remainder) equals the dividend will be more efficient.
+
+Use `  if is_unconstrained() { /`, to conditionally execute code if being called in an unconstrained vs constrained way.
+
+## Advanced
+
+Unless you're well into the depth of gate optimization, this advanced section can be ignored.
+
+### Combine arithmetic operations
+
+A Noir program can be honed further by combining arithmetic operators in a way that makes the most of each constraint of the backend proving system. This is in scenarios where the backend might not be doing this perfectly.
+
+Eg Barretenberg backend (current default for Noir) is a width-4 PLONKish constraint system
+$ w_1*w_2*q_m + w_1*q_1 + w_2*q_2 + w_3*q_3 + w_4*q_4 + q_c = 0 $
+
+Here we see there is one occurrence of witness 1 and 2 ($w_1$, $w_2$) being multiplied together, with addition to witnesses 1-4 ($w_1$ .. $w_4$) multiplied by 4 corresponding circuit constants ($q_1$ .. $q_4$) (plus a final circuit constant, $q_c$).
+
+Use `nargo info --print-acir`, to inspect the ACIR opcodes (and the proving system for gates), and it may present opportunities to amend the order of operations and reduce the number of constraints.
+
+#### Variable as witness vs expression
+
+If you've come this far and really know what you're doing at the equation level, a temporary lever (that will become unnecessary/useless over time) is: `std::as_witness`. This informs the compiler to save a variable as a witness not an expression.
+
+The compiler will mostly be correct and optimal, but this may help some near term edge cases that are yet to optimize.
+Note: When used incorrectly it will create **less** efficient circuits (higher gate count).
+
+## References
+- Guillaume's ["`Cryptdoku`" talk](https://www.youtube.com/watch?v=MrQyzuogxgg) (Jun'23)
+- Tips from Tom, Jake and Zac.
+- [Idiomatic Noir](https://www.vlayer.xyz/blog/idiomatic-noir-part-1-collections) blog post
diff --git a/docs/versioned_docs/version-v1.0.0-beta.0/getting_started/noir_installation.md b/docs/versioned_docs/version-v1.0.0-beta.0/getting_started/noir_installation.md
new file mode 100644
index 00000000000..a5c7e649278
--- /dev/null
+++ b/docs/versioned_docs/version-v1.0.0-beta.0/getting_started/noir_installation.md
@@ -0,0 +1,106 @@
+---
+title: Standalone Noir Installation
+description: There are different ways to install Nargo, the one-stop shop and command-line tool for developing Noir programs. This guide explains how to specify which version to install when using noirup, and using WSL for windows.
+keywords: [
+    Installation
+    Nargo
+    Noirup
+    Binaries
+    Compiling from Source
+    WSL for Windows
+    macOS
+    Linux
+    Nix
+    Direnv
+    Uninstalling Nargo
+  ]
+sidebar_position: 2
+---
+
+Noirup is the endorsed method for installing Nargo, streamlining the process of fetching binaries or compiling from source. It supports a range of options to cater to your specific needs, from nightly builds and specific versions to compiling from various sources.
+
+### Installing Noirup
+
+First, ensure you have `noirup` installed:
+
+```sh
+curl -L https://raw.githubusercontent.com/noir-lang/noirup/main/install | bash
+```
+
+### Fetching Binaries
+
+With `noirup`, you can easily switch between different Nargo versions, including nightly builds:
+
+- **Nightly Version**: Install the latest nightly build.
+
+  ```sh
+  noirup --version nightly
+  ```
+
+- **Specific Version**: Install a specific version of Nargo.
+
+  ```sh
+  noirup --version <version>
+  ```
+
+### Compiling from Source
+
+`noirup` also enables compiling Nargo from various sources:
+
+- **From a Specific Branch**: Install from the latest commit on a branch.
+
+  ```sh
+  noirup --branch <branch-name>
+  ```
+
+- **From a Fork**: Install from the main branch of a fork.
+
+  ```sh
+  noirup --repo <username/repo>
+  ```
+
+- **From a Specific Branch in a Fork**: Install from a specific branch in a fork.
+
+  ```sh
+  noirup --repo <username/repo> --branch <branch-name>
+  ```
+
+- **From a Specific Pull Request**: Install from a specific PR.
+
+  ```sh
+  noirup --pr <pr-number>
+  ```
+
+- **From a Specific Commit**: Install from a specific commit.
+
+  ```sh
+  noirup -C <commit-hash>
+  ```
+
+- **From Local Source**: Compile and install from a local directory.
+
+  ```sh
+  noirup --path ./path/to/local/source
+  ```
+
+## Installation on Windows
+
+The default backend for Noir (Barretenberg) doesn't provide Windows binaries at this time. For that reason, Noir cannot be installed natively. However, it is available by using Windows Subsystem for Linux (WSL).
+
+Step 1: Follow the instructions [here](https://learn.microsoft.com/en-us/windows/wsl/install) to install and run WSL.
+
+step 2: Follow the [Noirup instructions](#installing-noirup).
+
+## Setting up shell completions
+
+Once `nargo` is installed, you can [set up shell completions for it](setting_up_shell_completions).
+
+## Uninstalling Nargo
+
+If you installed Nargo with `noirup`, you can uninstall Nargo by removing the files in `~/.nargo`, `~/nargo`, and `~/noir_cache`. This ensures that all installed binaries, configurations, and cache related to Nargo are fully removed from your system.
+
+```bash
+rm -r ~/.nargo
+rm -r ~/nargo
+rm -r ~/noir_cache
+```
diff --git a/docs/versioned_docs/version-v1.0.0-beta.0/getting_started/project_breakdown.md b/docs/versioned_docs/version-v1.0.0-beta.0/getting_started/project_breakdown.md
new file mode 100644
index 00000000000..e442e377040
--- /dev/null
+++ b/docs/versioned_docs/version-v1.0.0-beta.0/getting_started/project_breakdown.md
@@ -0,0 +1,159 @@
+---
+title: Project Breakdown
+description:
+  Learn about the anatomy of a Nargo project, including the purpose of the Prover TOML
+  file, and how to prove and verify your program.
+keywords:
+  [Nargo, Nargo project, Prover.toml, proof verification, private asset transfer]
+sidebar_position: 1
+---
+
+This section breaks down our hello world program from the previous section.
+
+## Anatomy of a Nargo Project
+
+Upon creating a new project with `nargo new` and building the in/output files with `nargo check`
+commands, you would get a minimal Nargo project of the following structure:
+
+    - src
+    - Prover.toml
+    - Nargo.toml
+
+The source directory _src_ holds the source code for your Noir program. By default only a _main.nr_
+file will be generated within it.
+
+### Prover.toml
+
+_Prover.toml_ is used for specifying the input values for executing and proving the program. You can specify `toml` files with different names by using the `--prover-name` or `-p` flags, see the [Prover](#provertoml) section below. Optionally you may specify expected output values for prove-time checking as well.
+
+### Nargo.toml
+
+_Nargo.toml_ contains the environmental options of your project. It contains a "package" section and a "dependencies" section.
+
+Example Nargo.toml:
+
+```toml
+[package]
+name = "noir_starter"
+type = "bin"
+authors = ["Alice"]
+compiler_version = "0.9.0"
+description = "Getting started with Noir"
+entry = "circuit/main.nr"
+license = "MIT"
+
+[dependencies]
+ecrecover = {tag = "v0.9.0", git = "https://github.com/colinnielsen/ecrecover-noir.git"}
+```
+
+Nargo.toml for a [workspace](../noir/modules_packages_crates/workspaces.md) will look a bit different. For example:
+
+```toml
+[workspace]
+members = ["crates/a", "crates/b"]
+default-member = "crates/a"
+```
+
+#### Package section
+
+The package section defines a number of fields including:
+
+- `name` (**required**) - the name of the package
+- `type` (**required**) - can be "bin", "lib", or "contract" to specify whether its a binary, library or Aztec contract
+- `authors` (optional) - authors of the project
+- `compiler_version` - specifies the version of the compiler to use. This is enforced by the compiler and follow's [Rust's versioning](https://doc.rust-lang.org/cargo/reference/manifest.html#the-version-field), so a `compiler_version = 0.18.0` will enforce Nargo version 0.18.0, `compiler_version = ^0.18.0` will enforce anything above 0.18.0 but below 0.19.0, etc. For more information, see how [Rust handles these operators](https://docs.rs/semver/latest/semver/enum.Op.html)
+- `description` (optional)
+- `entry` (optional) - a relative filepath to use as the entry point into your package (overrides the default of `src/lib.nr` or `src/main.nr`)
+- `backend` (optional)
+- `license` (optional)
+- `expression_width` (optional) - Sets the default backend expression width. This field will override the default backend expression width specified by the Noir compiler (currently set to width 4).
+
+#### Dependencies section
+
+This is where you will specify any dependencies for your project. See the [Dependencies page](../noir/modules_packages_crates/dependencies.md) for more info.
+
+`./proofs/` and `./contract/` directories will not be immediately visible until you create a proof or
+verifier contract respectively.
+
+### main.nr
+
+The _main.nr_ file contains a `main` method, this method is the entry point into your Noir program.
+
+In our sample program, _main.nr_ looks like this:
+
+```rust
+fn main(x : Field, y : Field) {
+    assert(x != y);
+}
+```
+
+The parameters `x` and `y` can be seen as the API for the program and must be supplied by the prover. Since neither `x` nor `y` is marked as public, the verifier does not supply any inputs, when verifying the proof.
+
+The prover supplies the values for `x` and `y` in the _Prover.toml_ file.
+
+As for the program body, `assert` ensures that the condition to be satisfied (e.g. `x != y`) is constrained by the proof of the execution of said program (i.e. if the condition was not met, the verifier would reject the proof as an invalid proof).
+
+### Prover.toml
+
+The _Prover.toml_ file is a file which the prover uses to supply the inputs to the Noir program (both private and public).
+
+In our hello world program the _Prover.toml_ file looks like this:
+
+```toml
+x = "1"
+y = "2"
+```
+
+When the command `nargo execute` is executed, nargo will execute the Noir program using the inputs specified in `Prover.toml`, aborting if it finds that these do not satisfy the constraints defined by `main`. In this example, `x` and `y` must satisfy the inequality constraint `assert(x != y)`.
+
+If an output name is specified such as `nargo execute foo`, the witness generated by this execution will be written to `./target/foo.gz`. This can then be used to generate a proof of the execution.
+
+#### Arrays of Structs
+
+The following code shows how to pass an array of structs to a Noir program to generate a proof.
+
+```rust
+// main.nr
+struct Foo {
+    bar: Field,
+    baz: Field,
+}
+
+fn main(foos: [Foo; 3]) -> pub Field {
+    foos[2].bar + foos[2].baz
+}
+```
+
+Prover.toml:
+
+```toml
+[[foos]] # foos[0]
+bar = 0
+baz = 0
+
+[[foos]] # foos[1]
+bar = 0
+baz = 0
+
+[[foos]] # foos[2]
+bar = 1
+baz = 2
+```
+
+#### Custom toml files
+
+You can specify a `toml` file with a different name to use for execution by using the `--prover-name` or `-p` flags.
+
+This command looks for proof inputs in the default **Prover.toml** and generates the witness and saves it at `./target/foo.gz`:
+
+```bash
+nargo execute foo
+```
+
+This command looks for proof inputs in the custom **OtherProver.toml** and generates the witness and saves it at `./target/bar.gz`:
+
+```bash
+nargo execute -p OtherProver bar
+```
+
+Now that you understand the concepts, you'll probably want some editor feedback while you are writing more complex code.
diff --git a/docs/versioned_docs/version-v1.0.0-beta.0/getting_started/quick_start.md b/docs/versioned_docs/version-v1.0.0-beta.0/getting_started/quick_start.md
new file mode 100644
index 00000000000..c693624eb82
--- /dev/null
+++ b/docs/versioned_docs/version-v1.0.0-beta.0/getting_started/quick_start.md
@@ -0,0 +1,126 @@
+---
+title: Quick Start
+tags: []
+sidebar_position: 0
+---
+
+## Installation
+
+### Noir
+
+The easiest way to develop with Noir is using Nargo the CLI tool. It provides you the ability to start new projects, compile, execute and test Noir programs from the terminal.
+
+You can use `noirup` the installation script to quickly install and update Nargo:
+
+```bash
+curl -L noirup.dev | bash
+noirup
+```
+
+Once installed, you can [set up shell completions for the `nargo` command](setting_up_shell_completions).
+
+### Proving backend
+
+After installing Noir, we install a proving backend to work with our Noir programs.
+
+Proving backends provide you the abilities to generate proofs, verify proofs, generate smart contracts and more for your Noir programs.
+
+Different proving backends provide different tools for working with Noir programs, here we will use the [Barretenberg proving backend](https://github.com/AztecProtocol/aztec-packages/tree/master/barretenberg) developed by Aztec Labs as an example.
+
+You can use the `bbup` installation script to quickly install and update BB, Barretenberg's CLI tool:
+
+You can find the full list of proving backends compatible with Noir in Awesome Noir.
+
+```bash
+curl -L bbup.dev | bash
+bbup
+```
+
+For the full list of proving backends compatible with Noir, visit [Awesome Noir](https://github.com/noir-lang/awesome-noir/?tab=readme-ov-file#proving-backends).
+
+## Nargo
+
+Nargo provides the ability to initiate and execute Noir projects. Let's initialize the traditional `hello_world`:
+
+```sh
+nargo new hello_world
+```
+
+Two files will be created.
+
+- `src/main.nr` contains a simple boilerplate circuit
+- `Nargo.toml` contains environmental options, such as name, author, dependencies, and others.
+
+Glancing at _main.nr_ , we can see that inputs in Noir are private by default, but can be labeled public using the keyword `pub`. This means that we will _assert_ that we know a value `x` which is different from `y` without revealing `x`:
+
+```rust
+fn main(x : Field, y : pub Field) {
+    assert(x != y);
+}
+```
+
+To learn more about private and public values, check the [Data Types](../noir/concepts/data_types/index.md) section.
+
+### Compiling and executing
+
+We can now use `nargo` to generate a _Prover.toml_ file, where our input values will be specified:
+
+```sh
+cd hello_world
+nargo check
+
+Let's feed some valid values into this file:
+
+```toml
+x = "1"
+y = "2"
+```
+
+We're now ready to compile and execute our Noir program. By default the `nargo execute` command will do both, and generate the `witness` that we need to feed to our proving backend:
+
+```sh
+nargo execute
+```
+
+The witness corresponding to this execution will then be written to the file _./target/witness-name.gz_.
+
+The command also automatically compiles your Noir program if it was not already / was edited, which you may notice the compiled artifacts being written to the file _./target/hello_world.json_.
+
+With circuit compiled and witness generated, we're ready to prove.
+
+## Proving backend
+ 
+Different proving backends may provide different tools and commands to work with Noir programs. Here Barretenberg's `bb` CLI tool is used as an example:
+
+```sh
+bb prove -b ./target/hello_world.json -w ./target/hello_world.gz -o ./target/proof
+```
+
+:::tip
+
+Naming can be confusing, specially as you pass them to the `bb` commands. If unsure, it won't hurt to delete the target folder and start anew to make sure you're using the most recent versions of the compiled circuit and witness.
+
+:::
+
+The proof is now generated in the `target` folder. To verify it we first need to compute the verification key from the compiled circuit, and use it to verify:
+
+```sh
+bb write_vk -b ./target/hello_world.json -o ./target/vk
+bb verify -k ./target/vk -p ./target/proof
+```
+
+:::info
+
+Notice that in order to verify a proof, the verifier knows nothing but the circuit, which is compiled and used to generate the verification key. This is obviously quite important: private inputs remain private.
+
+As for the public inputs, you may have noticed they haven't been specified. This behavior varies with each particular backend, but barretenberg typically attaches them to the proof. You can see them by parsing and splitting it. For example for if your public inputs are 32 bytes:
+
+```bash
+head -c 32 ./target/proof | od -An -v -t x1 | tr -d $' \n'
+```
+
+:::
+
+Congratulations, you have now created and verified a proof for your very first Noir program!
+
+In the [next section](./project_breakdown.md), we will go into more detail on each step performed.
diff --git a/docs/versioned_docs/version-v1.0.0-beta.0/getting_started/setting_up_shell_completions.md b/docs/versioned_docs/version-v1.0.0-beta.0/getting_started/setting_up_shell_completions.md
new file mode 100644
index 00000000000..0447321cbab
--- /dev/null
+++ b/docs/versioned_docs/version-v1.0.0-beta.0/getting_started/setting_up_shell_completions.md
@@ -0,0 +1,87 @@
+---
+title: Setting up shell completions
+tags: []
+sidebar_position: 3
+---
+
+The `nargo` binary provides a command to generate shell completions:
+
+```bash
+nargo generate-completion-script [shell]
+```
+
+where `shell` must be one of `bash`, `elvish`, `fish`, `powershell`, and `zsh`.
+
+Below we explain how to install them in some popular shells.
+
+## Installing Zsh Completions
+
+If you have `oh-my-zsh` installed, you might already have a directory of automatically loading completion scripts — `.oh-my-zsh/completions`.
+If not, first create it:
+
+```bash
+mkdir -p ~/.oh-my-zsh/completions`
+```
+
+Then copy the completion script to that directory:
+
+```bash
+nargo generate-completion-script zsh > ~/.oh-my-zsh/completions/_nargo
+```
+
+Without `oh-my-zsh`, you’ll need to add a path for completion scripts to your function path, and turn on completion script auto-loading. 
+First, add these lines to `~/.zshrc`:
+
+```bash
+fpath=(~/.zsh/completions $fpath)
+autoload -U compinit
+compinit
+```
+
+Next, create a directory at `~/.zsh/completions`:
+
+```bash
+mkdir -p ~/.zsh/completions
+```
+
+Then copy the completion script to that directory:
+
+```bash
+nargo generate-completion-script zsh > ~/.zsh/completions/_nargo
+```
+
+## Installing Bash Completions
+
+If you have [bash-completion](https://github.com/scop/bash-completion) installed, you can just copy the completion script to the `/usr/local/etc/bash_completion.d` directory:
+
+```bash
+nargo generate-completion-script bash > /usr/local/etc/bash_completion.d/nargo
+```
+
+Without `bash-completion`, you’ll need to source the completion script directly. 
+First create a directory such as `~/.bash_completions/`:
+
+```bash
+mkdir ~/.bash_completions/
+```
+
+Copy the completion script to that directory:
+
+```bash
+nargo generate-completion-script bash > ~/.bash_completions/nargo.bash
+```
+
+Then add the following line to `~/.bash_profile` or `~/.bashrc`:
+
+
+```bash
+source ~/.bash_completions/nargo.bash
+```
+
+## Installing Fish Completions
+
+Copy the completion script to any path listed in the environment variable `$fish_completion_path`. For example, a typical location is `~/.config/fish/completions/nargo.fish`:
+
+```bash
+nargo generate-completion-script fish > ~/.config/fish/completions/nargo.fish
+```
diff --git a/docs/versioned_docs/version-v1.0.0-beta.0/how_to/_category_.json b/docs/versioned_docs/version-v1.0.0-beta.0/how_to/_category_.json
new file mode 100644
index 00000000000..23b560f610b
--- /dev/null
+++ b/docs/versioned_docs/version-v1.0.0-beta.0/how_to/_category_.json
@@ -0,0 +1,5 @@
+{
+    "position": 1,
+    "collapsible": true,
+    "collapsed": true
+}
diff --git a/docs/versioned_docs/version-v1.0.0-beta.0/how_to/debugger/_category_.json b/docs/versioned_docs/version-v1.0.0-beta.0/how_to/debugger/_category_.json
new file mode 100644
index 00000000000..cc2cbb1c253
--- /dev/null
+++ b/docs/versioned_docs/version-v1.0.0-beta.0/how_to/debugger/_category_.json
@@ -0,0 +1,6 @@
+{
+    "label": "Debugging",
+    "position": 5,
+    "collapsible": true,
+    "collapsed": true
+}
diff --git a/docs/versioned_docs/version-v1.0.0-beta.0/how_to/debugger/debugging_with_the_repl.md b/docs/versioned_docs/version-v1.0.0-beta.0/how_to/debugger/debugging_with_the_repl.md
new file mode 100644
index 00000000000..1d64dae3f37
--- /dev/null
+++ b/docs/versioned_docs/version-v1.0.0-beta.0/how_to/debugger/debugging_with_the_repl.md
@@ -0,0 +1,164 @@
+---
+title: Using the REPL Debugger
+description:
+  Step-by-step guide on how to debug your Noir circuits with the REPL Debugger. 
+keywords:
+  [
+    Nargo,
+    Noir CLI,
+    Noir Debugger,
+    REPL,
+  ]
+sidebar_position: 1
+---
+
+#### Pre-requisites
+
+In order to use the REPL debugger, first you need to install recent enough versions of Nargo and vscode-noir. 
+
+## Debugging a simple circuit
+
+Let's debug a simple circuit:
+
+```rust
+fn main(x : Field, y : pub Field) {
+    assert(x != y);
+}
+```
+
+To start the REPL debugger, using a terminal, go to a Noir circuit's home directory. Then:
+
+`$ nargo debug`
+
+You should be seeing this in your terminal:
+
+```
+[main] Starting debugger
+At ~/noir-examples/recursion/circuits/main/src/main.nr:1:9
+  1 -> fn main(x : Field, y : pub Field) {
+  2        assert(x != y);
+  3    }
+> 
+```
+
+The debugger displays the current Noir code location, and it is now waiting for us to drive it.
+
+Let's first take a look at the available commands. For that we'll use the `help` command.
+
+```
+> help
+Available commands:
+
+  opcodes                          display ACIR opcodes
+  into                             step into to the next opcode
+  next                             step until a new source location is reached
+  out                              step until a new source location is reached
+                                   and the current stack frame is finished
+  break LOCATION:OpcodeLocation    add a breakpoint at an opcode location
+  over                             step until a new source location is reached
+                                   without diving into function calls
+  restart                          restart the debugging session
+  delete LOCATION:OpcodeLocation   delete breakpoint at an opcode location
+  witness                          show witness map
+  witness index:u32                display a single witness from the witness map
+  witness index:u32 value:String   update a witness with the given value
+  memset index:usize value:String  update a memory cell with the given
+                                   value
+  continue                         continue execution until the end of the
+                                   program
+  vars                             show variable values available at this point
+                                   in execution
+  stacktrace                       display the current stack trace
+  memory                           show memory (valid when executing unconstrained code)
+  step                             step to the next ACIR opcode
+
+Other commands:
+
+  help  Show this help message
+  quit  Quit repl
+
+```
+
+Some commands operate only for unconstrained functions, such as `memory` and `memset`. If you try to use them while execution is paused at an ACIR opcode, the debugger will simply inform you that you are not executing unconstrained code:
+
+```
+> memory
+Unconstrained VM memory not available
+> 
+```
+
+Before continuing, we can take a look at the initial witness map:
+
+```
+> witness
+_0 = 1
+_1 = 2
+>
+```
+
+Cool, since `x==1`, `y==2`, and we want to check that `x != y`, our circuit should succeed. At this point we could intervene and use the witness setter command to change one of the witnesses. Let's set `y=3`, then back to 2, so we don't affect the expected result:
+
+```
+> witness
+_0 = 1
+_1 = 2
+> witness 1 3
+_1 = 3
+> witness
+_0 = 1
+_1 = 3
+> witness 1 2
+_1 = 2
+> witness
+_0 = 1
+_1 = 2
+>
+```
+
+Now we can inspect the current state of local variables. For that we use the `vars` command. 
+
+```
+> vars
+>
+```
+
+We currently have no vars in context, since we are at the entry point of the program. Let's use `next` to execute until the next point in the program.
+
+```
+> vars
+> next
+At ~/noir-examples/recursion/circuits/main/src/main.nr:1:20
+  1 -> fn main(x : Field, y : pub Field) {
+  2        assert(x != y);
+  3    }
+> vars
+x:Field = 0x01
+```
+
+As a result of stepping, the variable `x`, whose initial value comes from the witness map, is now in context and returned by `vars`.
+
+```
+> next
+  1    fn main(x : Field, y : pub Field) {
+  2 ->     assert(x != y);
+  3    }
+> vars
+y:Field = 0x02
+x:Field = 0x01
+```
+
+Stepping again we can finally see both variables and their values. And now we can see that the next assertion should succeed.
+
+Let's continue to the end:
+
+```
+> continue
+(Continuing execution...)
+Finished execution
+> q
+[main] Circuit witness successfully solved
+```
+
+Upon quitting the debugger after a solved circuit, the resulting circuit witness gets saved, equivalent to what would happen if we had run the same circuit with `nargo execute`.
+
+We just went through the basics of debugging using Noir REPL debugger. For a comprehensive reference, check out [the reference page](../../reference/debugger/debugger_repl.md).
diff --git a/docs/versioned_docs/version-v1.0.0-beta.0/how_to/debugger/debugging_with_vs_code.md b/docs/versioned_docs/version-v1.0.0-beta.0/how_to/debugger/debugging_with_vs_code.md
new file mode 100644
index 00000000000..a5858c1a5eb
--- /dev/null
+++ b/docs/versioned_docs/version-v1.0.0-beta.0/how_to/debugger/debugging_with_vs_code.md
@@ -0,0 +1,68 @@
+---
+title: Using the VS Code Debugger
+description:
+  Step by step guide on how to debug your Noir circuits with the VS Code Debugger configuration and features.
+keywords:
+  [
+    Nargo,
+    Noir CLI,
+    Noir Debugger,
+    VS Code,
+    IDE,
+  ]
+sidebar_position: 0
+---
+
+This guide will show you how to use VS Code with the vscode-noir extension to debug a Noir project. 
+
+#### Pre-requisites
+
+- Nargo
+- vscode-noir
+- A Noir project with a `Nargo.toml`, `Prover.toml` and at least one Noir (`.nr`) containing an entry point function (typically `main`).
+
+## Running the debugger
+
+The easiest way to start debugging is to open the file you want to debug, and press `F5`. This will cause the debugger to launch, using your `Prover.toml` file as input.
+
+You should see something like this:
+
+![Debugger launched](@site/static/img/debugger/1-started.png)
+
+Let's inspect the state of the program. For that, we open VS Code's _Debug pane_. Look for this icon:
+
+![Debug pane icon](@site/static/img/debugger/2-icon.png)
+
+You will now see two categories of variables: Locals and Witness Map.
+
+![Debug pane expanded](@site/static/img/debugger/3-debug-pane.png)
+
+1. **Locals**: variables of your program. At this point in execution this section is empty, but as we step through the code it will get populated by `x`, `result`, `digest`, etc. 
+
+2. **Witness map**: these are initially populated from your project's `Prover.toml` file. In this example, they will be used to populate `x` and `result` at the beginning of the `main` function.
+
+Most of the time you will probably be focusing mostly on locals, as they represent the high level state of your program. 
+
+You might be interested in inspecting the witness map in case you are trying to solve a really low level issue in the compiler or runtime itself, so this concerns mostly advanced or niche users.
+
+Let's step through the program, by using the debugger buttons or their corresponding keyboard shortcuts.
+
+![Debugger buttons](@site/static/img/debugger/4-debugger-buttons.png)
+
+Now we can see in the variables pane that there's values for `digest`, `result` and `x`.
+
+![Inspecting locals](@site/static/img/debugger/5-assert.png)
+
+We can also inspect the values of variables by directly hovering on them on the code.
+
+![Hover locals](@site/static/img/debugger/6-hover.png)
+
+Let's set a break point at the `keccak256` function, so we can continue execution up to the point when it's first invoked without having to go one step at a time. 
+
+We just need to click the to the right of the line number 18. Once the breakpoint appears, we can click the `continue` button or use its corresponding keyboard shortcut (`F5` by default).
+
+![Breakpoint](@site/static/img/debugger/7-break.png)
+
+Now we are debugging the `keccak256` function, notice the _Call Stack pane_ at the lower right. This lets us inspect the current call stack of our process.
+
+That covers most of the current debugger functionalities. Check out [the reference](../../reference/debugger/debugger_vscode.md) for more details on how to configure the debugger.
\ No newline at end of file
diff --git a/docs/versioned_docs/version-v1.0.0-beta.0/how_to/how-to-oracles.md b/docs/versioned_docs/version-v1.0.0-beta.0/how_to/how-to-oracles.md
new file mode 100644
index 00000000000..0bb8743e361
--- /dev/null
+++ b/docs/versioned_docs/version-v1.0.0-beta.0/how_to/how-to-oracles.md
@@ -0,0 +1,275 @@
+---
+title: How to use Oracles
+description: Learn how to use oracles in your Noir program with examples in both Nargo and NoirJS. This guide also covers writing a JSON RPC server and providing custom foreign call handlers for NoirJS.
+keywords:
+  - Noir Programming
+  - Oracles
+  - Nargo
+  - NoirJS
+  - JSON RPC Server
+  - Foreign Call Handlers
+sidebar_position: 1
+---
+
+This guide shows you how to use oracles in your Noir program. For the sake of clarity, it assumes that:
+
+- You have read the [explainer on Oracles](../explainers/explainer-oracle.md) and are comfortable with the concept.
+- You have a Noir program to add oracles to. You can create one using the [vite-hardhat starter](https://github.com/noir-lang/noir-starter/tree/main/vite-hardhat) as a boilerplate.
+- You understand the concept of a JSON-RPC server. Visit the [JSON-RPC website](https://www.jsonrpc.org/) if you need a refresher.
+- You are comfortable with server-side JavaScript (e.g. Node.js, managing packages, etc.).
+
+## Rundown
+
+This guide has 3 major steps:
+
+1. How to modify our Noir program to make use of oracle calls as unconstrained functions
+2. How to write a JSON RPC Server to resolve these oracle calls with Nargo
+3. How to use them in Nargo and how to provide a custom resolver in NoirJS
+
+## Step 1 - Modify your Noir program
+
+An oracle is defined in a Noir program by defining two methods:
+
+- An unconstrained method - This tells the compiler that it is executing an [unconstrained function](../noir/concepts//unconstrained.md).
+- A decorated oracle method - This tells the compiler that this method is an RPC call.
+
+An example of an oracle that returns a `Field` would be:
+
+```rust
+#[oracle(getSqrt)]
+unconstrained fn sqrt(number: Field) -> Field { }
+
+unconstrained fn get_sqrt(number: Field) -> Field {
+    sqrt(number)
+}
+```
+
+In this example, we're wrapping our oracle function in an unconstrained method, and decorating it with `oracle(getSqrt)`. We can then call the unconstrained function as we would call any other function:
+
+```rust
+fn main(input: Field) {
+    let sqrt = get_sqrt(input);
+}
+```
+
+In the next section, we will make this `getSqrt` (defined on the `sqrt` decorator) be a method of the RPC server Noir will use.
+
+:::danger
+
+As explained in the [Oracle Explainer](../explainers/explainer-oracle.md), this `main` function is unsafe unless you constrain its return value. For example:
+
+```rust
+fn main(input: Field) {
+    let sqrt = get_sqrt(input);
+    assert(sqrt.pow_32(2) as u64 == input as u64); // <---- constrain the return of an oracle!
+}
+```
+
+:::
+
+:::info
+
+Currently, oracles only work with single params or array params. For example:
+
+```rust
+#[oracle(getSqrt)]
+unconstrained fn sqrt([Field; 2]) -> [Field; 2] { }
+```
+
+:::
+
+## Step 2 - Write an RPC server
+
+Brillig will call *one* RPC server. Most likely you will have to write your own, and you can do it in whatever language you prefer. In this guide, we will do it in Javascript.
+
+Let's use the above example of an oracle that consumes an array with two `Field` and returns their square roots:
+
+```rust
+#[oracle(getSqrt)]
+unconstrained fn sqrt(input: [Field; 2]) -> [Field; 2] { }
+
+unconstrained fn get_sqrt(input: [Field; 2]) -> [Field; 2] {
+    sqrt(input)
+}
+
+fn main(input: [Field; 2]) {
+    let sqrt = get_sqrt(input);
+    assert(sqrt[0].pow_32(2) as u64 == input[0] as u64);
+    assert(sqrt[1].pow_32(2) as u64 == input[1] as u64);
+}
+
+#[test]
+fn test() {
+    let input = [4, 16];
+    main(input);
+}
+```
+
+:::info
+
+Why square root?
+
+In general, computing square roots is computationally more expensive than multiplications, which takes a toll when speaking about ZK applications. In this case, instead of calculating the square root in Noir, we are using our oracle to offload that computation to be made in plain. In our circuit we can simply multiply the two values.
+
+:::
+
+Now, we should write the correspondent RPC server, starting with the [default JSON-RPC 2.0 boilerplate](https://www.npmjs.com/package/json-rpc-2.0#example):
+
+```js
+import { JSONRPCServer } from "json-rpc-2.0";
+import express from "express";
+import bodyParser from "body-parser";
+
+const app = express();
+app.use(bodyParser.json());
+
+const server = new JSONRPCServer();
+app.post("/", (req, res) => {
+ const jsonRPCRequest = req.body;
+ server.receive(jsonRPCRequest).then((jsonRPCResponse) => {
+  if (jsonRPCResponse) {
+   res.json(jsonRPCResponse);
+  } else {
+   res.sendStatus(204);
+  }
+ });
+});
+
+app.listen(5555);
+```
+
+Now, we will add our `getSqrt` method, as expected by the `#[oracle(getSqrt)]` decorator in our Noir code. It maps through the params array and returns their square roots:
+
+```js
+server.addMethod("resolve_foreign_call", async (params) => {
+    if (params[0].function !== "getSqrt") {
+        throw Error("Unexpected foreign call")
+    };
+    const values = params[0].inputs[0].map((field) => {
+        return `${Math.sqrt(parseInt(field, 16))}`;
+    });
+    return { values: [values] };
+});
+```
+
+If you're using Typescript, the following types may be helpful in understanding the expected return value and making sure they're easy to follow:
+
+```js
+export type ForeignCallSingle = string;
+
+export type ForeignCallArray = string[];
+
+export type ForeignCallResult = {
+  values: (ForeignCallSingle | ForeignCallArray)[];
+};
+```
+
+:::info Multidimensional Arrays
+
+If the Oracle function is returning an array containing other arrays, such as `[['1','2],['3','4']]`, you need to provide the values in JSON as flattened values. In the previous example, it would be `['1', '2', '3', '4']`. In the Noir program, the Oracle signature can use a nested type, the flattened values will be automatically converted to the nested type.
+
+:::
+
+## Step 3 - Usage with Nargo
+
+Using the [`nargo` CLI tool](../reference/nargo_commands.md), you can use oracles in the `nargo test` and `nargo execute`  commands by passing a value to `--oracle-resolver`. For example:
+
+```bash
+nargo test --oracle-resolver http://localhost:5555
+```
+
+This tells `nargo` to use your RPC Server URL whenever it finds an oracle decorator.
+
+## Step 4 - Usage with NoirJS
+
+In a JS environment, an RPC server is not strictly necessary, as you may want to resolve your oracles without needing any JSON call at all. NoirJS simply expects that you pass a callback function when you generate proofs, and that callback function can be anything.
+
+For example, if your Noir program expects the host machine to provide CPU pseudo-randomness, you could simply pass it as the `foreignCallHandler`. You don't strictly need to create an RPC server to serve pseudo-randomness, as you may as well get it directly in your app:
+
+```js
+const foreignCallHandler = (name, inputs) => crypto.randomBytes(16) // etc
+
+await noir.execute(inputs, foreignCallHandler)
+```
+
+As one can see, in NoirJS, the [`foreignCallHandler`](../reference/NoirJS/noir_js/type-aliases/ForeignCallHandler.md) function simply means "a callback function that returns a value of type [`ForeignCallOutput`](../reference/NoirJS/noir_js/type-aliases/ForeignCallOutput.md). It doesn't have to be an RPC call like in the case for Nargo.
+
+:::tip
+
+Does this mean you don't have to write an RPC server like in [Step #2](#step-2---write-an-rpc-server)?
+
+You don't technically have to, but then how would you run `nargo test`? To use both `Nargo` and `NoirJS` in your development flow, you will have to write a JSON RPC server.
+
+:::
+
+In this case, let's make `foreignCallHandler` call the JSON RPC Server we created in [Step #2](#step-2---write-an-rpc-server), by making it a JSON RPC Client.
+
+For example, using the same `getSqrt` program in [Step #1](#step-1---modify-your-noir-program) (comments in the code):
+
+```js
+import { JSONRPCClient } from "json-rpc-2.0";
+
+// declaring the JSONRPCClient
+const client = new JSONRPCClient((jsonRPCRequest) => {
+// hitting the same JSON RPC Server we coded above
+ return fetch("http://localhost:5555", {
+  method: "POST",
+  headers: {
+   "content-type": "application/json",
+  },
+  body: JSON.stringify(jsonRPCRequest),
+ }).then((response) => {
+  if (response.status === 200) {
+   return response
+    .json()
+    .then((jsonRPCResponse) => client.receive(jsonRPCResponse));
+  } else if (jsonRPCRequest.id !== undefined) {
+   return Promise.reject(new Error(response.statusText));
+  }
+ });
+});
+
+// declaring a function that takes the name of the foreign call (getSqrt) and the inputs
+const foreignCallHandler = async (name, input) => {
+  const inputs = input[0].map((i) => i.toString("hex"))
+  // notice that the "inputs" parameter contains *all* the inputs
+  // in this case we to make the RPC request with the first parameter "numbers", which would be input[0]
+  const oracleReturn = await client.request("resolve_foreign_call", [
+    {
+      function: name,
+      inputs: [inputs]
+    },
+  ]);
+  return [oracleReturn.values[0]];
+};
+
+// the rest of your NoirJS code
+const input = { input: [4, 16] };
+const { witness } = await noir.execute(input, foreignCallHandler);
+```
+
+:::tip
+
+If you're in a NoirJS environment running your RPC server together with a frontend app, you'll probably hit a familiar problem in full-stack development: requests being blocked by [CORS](https://developer.mozilla.org/en-US/docs/Web/HTTP/CORS) policy. For development only, you can simply install and use the [`cors` npm package](https://www.npmjs.com/package/cors) to get around the problem:
+
+```bash
+yarn add cors
+```
+
+and use it as a middleware:
+
+```js
+import cors from "cors";
+
+const app = express();
+app.use(cors())
+```
+
+:::
+
+## Conclusion
+
+Hopefully by the end of this guide, you should be able to:
+
+- Write your own logic around Oracles and how to write a JSON RPC server to make them work with your Nargo commands.
+- Provide custom foreign call handlers for NoirJS.
diff --git a/docs/versioned_docs/version-v1.0.0-beta.0/how_to/how-to-recursion.md b/docs/versioned_docs/version-v1.0.0-beta.0/how_to/how-to-recursion.md
new file mode 100644
index 00000000000..399e4d4b38a
--- /dev/null
+++ b/docs/versioned_docs/version-v1.0.0-beta.0/how_to/how-to-recursion.md
@@ -0,0 +1,172 @@
+---
+title: How to use recursion on NoirJS
+description: Learn how to implement recursion with NoirJS, a powerful tool for creating smart contracts on the EVM blockchain. This guide assumes familiarity with NoirJS, solidity verifiers, and the Barretenberg proving backend. Discover how to generate both final and intermediate proofs using `noir_js` and `bb.js`.
+keywords:
+  [
+    "NoirJS",
+    "EVM blockchain",
+    "smart contracts",
+    "recursion",
+    "solidity verifiers",
+    "Barretenberg backend",
+    "noir_js",
+    "intermediate proofs",
+    "final proofs",
+    "nargo compile",
+    "json import",
+    "recursive circuit",
+    "recursive app"
+  ]
+sidebar_position: 1
+---
+
+This guide shows you how to use recursive proofs in your NoirJS app. For the sake of clarity, it is assumed that:
+
+- You already have a NoirJS app. If you don't, please visit the [NoirJS tutorial](../tutorials/noirjs_app.md) and the [reference](../reference/NoirJS/noir_js/index.md).
+- You are familiar with what are recursive proofs and you have read the [recursion explainer](../explainers/explainer-recursion.md)
+- You already built a recursive circuit following [the reference](../noir/standard_library/recursion.mdx), and understand how it works.
+
+It is also assumed that you're not using `noir_wasm` for compilation, and instead you've used [`nargo compile`](../reference/nargo_commands.md) to generate the `json` you're now importing into your project. However, the guide should work just the same if you're using `noir_wasm`.
+
+:::info
+
+As you've read in the [explainer](../explainers/explainer-recursion.md), a recursive proof is an intermediate proof. This means that it doesn't necessarily generate the final step that makes it verifiable in a smart contract. However, it is easy to verify within another circuit.
+
+:::
+
+In a standard recursive app, you're also dealing with at least two circuits. For the purpose of this guide, we will assume the following:
+
+- `main`: a circuit of type `assert(x != y)`, which we want to embed in another circuit recursively. For example when proving with the `bb` tool, we can use the `--recursive` CLI option to tell the backend that it should generate proofs that are friendly for verification within another circuit.
+- `recursive`: a circuit that verifies `main`
+
+For a full example of how recursive proofs work, please refer to the [noir-examples](https://github.com/noir-lang/noir-examples) repository. We will *not* be using it as a reference for this guide.
+
+## Step 1: Setup
+
+In a common NoirJS app, you need to instantiate a backend with something like `const backend = new Backend(circuit)`. Then you feed it to the `noir_js` interface.
+
+For recursion, this doesn't happen, and the only need for `noir_js` is only to `execute` a circuit and get its witness and return value. Everything else is not interfaced, so it needs to happen on the `backend` object.
+
+It is also recommended that you instantiate the backend with as many threads as possible, to allow for maximum concurrency:
+
+```js
+const backend = new UltraPlonkBackend(circuit, { threads: 8 }, { recursive: true })
+```
+
+:::tip
+You can use the [`os.cpus()`](https://nodejs.org/api/os.html#oscpus) object in `nodejs` or [`navigator.hardwareConcurrency`](https://developer.mozilla.org/en-US/docs/Web/API/Navigator/hardwareConcurrency) on the browser to make the most out of those glorious cpu cores
+:::
+
+## Step 2: Generating the witness and the proof for `main`
+
+After instantiating the backend, you should also instantiate `noir_js`. We will use it to execute the circuit and get the witness.
+
+```js
+const noir = new Noir(circuit)
+const { witness } = noir.execute(input)
+```
+
+With this witness, you are now able to generate the intermediate proof for the main circuit:
+
+```js
+const { proof, publicInputs } = await backend.generateProof(witness)
+```
+
+:::warning
+
+Always keep in mind what is actually happening on your development process, otherwise you'll quickly become confused about what circuit we are actually running and why!
+
+In this case, you can imagine that Alice (running the `main` circuit) is proving something to Bob (running the `recursive` circuit), and Bob is verifying her proof within his proof.
+
+With this in mind, it becomes clear that our intermediate proof is the one *meant to be verified within another circuit*, so it must be Alice's. Actually, the only final proof in this theoretical scenario would be the last one, sent on-chain.
+
+:::
+
+## Step 3 - Verification and proof artifacts
+
+Optionally, you are able to verify the intermediate proof:
+
+```js
+const verified = await backend.verifyProof({ proof, publicInputs })
+```
+
+This can be useful to make sure our intermediate proof was correctly generated. But the real goal is to do it within another circuit. For that, we need to generate  recursive proof artifacts that will be passed to the circuit that is verifying the proof we just generated. Instead of passing the proof and verification key as a byte array, we pass them as fields which makes it cheaper to verify in a circuit:
+
+```js
+const { proofAsFields, vkAsFields, vkHash } = await backend.generateRecursiveProofArtifacts( { publicInputs, proof }, publicInputsCount)
+```
+
+This call takes the public inputs and the proof, but also the public inputs count. While this is easily retrievable by simply counting the `publicInputs` length, the backend interface doesn't currently abstract it away.
+
+:::info
+
+The `proofAsFields` has a constant size `[Field; 93]` and verification keys in Barretenberg are always `[Field; 114]`.
+
+:::
+
+:::warning
+
+One common mistake is to forget *who* makes this call.
+
+In a situation where Alice is generating the `main` proof, if she generates the proof artifacts and sends them to Bob, which gladly takes them as true, this would mean Alice could prove anything!
+
+Instead, Bob needs to make sure *he* extracts the proof artifacts, using his own instance of the `main` circuit backend. This way, Alice has to provide a valid proof for the correct `main` circuit.
+
+:::
+
+## Step 4 - Recursive proof generation
+
+With the artifacts, generating a recursive proof is no different from a normal proof. You simply use the `backend` (with the recursive circuit) to generate it:
+
+```js
+const recursiveInputs = {
+    verification_key: vkAsFields, // array of length 114
+    proof: proofAsFields, // array of length 93 + size of public inputs
+    publicInputs: [mainInput.y], // using the example above, where `y` is the only public input
+    key_hash: vkHash,
+}
+
+const { witness, returnValue } = noir.execute(recursiveInputs) // we're executing the recursive circuit now!
+const { proof, publicInputs } = backend.generateProof(witness)
+const verified = backend.verifyProof({ proof, publicInputs })
+```
+
+You can obviously chain this proof into another proof. In fact, if you're using recursive proofs, you're probably interested of using them this way!
+
+:::tip
+
+Managing circuits and "who does what" can be confusing. To make sure your naming is consistent, you can keep them in an object. For example:
+
+```js
+const circuits = {
+  main: mainJSON,
+  recursive: recursiveJSON
+}
+const backends = {
+  main: new BarretenbergBackend(circuits.main),
+  recursive: new BarretenbergBackend(circuits.recursive)
+}
+const noir_programs = {
+  main: new Noir(circuits.main),
+  recursive: new Noir(circuits.recursive)
+}
+```
+
+This allows you to neatly call exactly the method you want without conflicting names:
+
+```js
+// Alice runs this 👇
+const { witness: mainWitness } = await noir_programs.main.execute(input)
+const proof = await backends.main.generateProof(mainWitness)
+
+// Bob runs this 👇
+const verified = await backends.main.verifyProof(proof)
+const { proofAsFields, vkAsFields, vkHash } = await backends.main.generateRecursiveProofArtifacts(
+    proof,
+    numPublicInputs,
+);
+const { witness: recursiveWitness } = await noir_programs.recursive.execute(recursiveInputs)
+const recursiveProof = await backends.recursive.generateProof(recursiveWitness);
+```
+
+:::
diff --git a/docs/versioned_docs/version-v1.0.0-beta.0/how_to/how-to-solidity-verifier.md b/docs/versioned_docs/version-v1.0.0-beta.0/how_to/how-to-solidity-verifier.md
new file mode 100644
index 00000000000..2cc0f8e57ce
--- /dev/null
+++ b/docs/versioned_docs/version-v1.0.0-beta.0/how_to/how-to-solidity-verifier.md
@@ -0,0 +1,259 @@
+---
+title: Generate a Solidity Verifier
+description:
+  Learn how to run the verifier as a smart contract on the blockchain. Compile a Solidity verifier
+  contract for your Noir program and deploy it on any EVM blockchain acting as a verifier smart
+  contract. Read more to find out
+keywords:
+  [
+    solidity verifier,
+    smart contract,
+    blockchain,
+    compiler,
+    plonk_vk.sol,
+    EVM blockchain,
+    verifying Noir programs,
+    proving backend,
+    Barretenberg,
+  ]
+sidebar_position: 0
+pagination_next: tutorials/noirjs_app
+---
+
+Noir has the ability to generate a verifier contract in Solidity, which can be deployed in many EVM-compatible blockchains such as Ethereum.
+
+This allows for a powerful feature set, as one can make use of the conciseness and the privacy provided by Noir in an immutable ledger. Applications can range from simple P2P guessing games, to complex private DeFi interactions.
+
+This guide shows you how to generate a Solidity Verifier and deploy it on the [Remix IDE](https://remix.ethereum.org/). It is assumed that:
+
+- You are comfortable with the Solidity programming language and understand how contracts are deployed on the Ethereum network
+- You have Noir installed and you have a Noir program. If you don't, [get started](../getting_started/quick_start.md) with Nargo and the example Hello Noir circuit
+- You are comfortable navigating RemixIDE. If you aren't or you need a refresher, you can find some video tutorials [here](https://www.youtube.com/channel/UCjTUPyFEr2xDGN6Cg8nKDaA) that could help you.
+
+## Rundown
+
+Generating a Solidity Verifier contract is actually a one-command process. However, compiling it and deploying it can have some caveats. Here's the rundown of this guide:
+
+1. How to generate a solidity smart contract
+2. How to compile the smart contract in the RemixIDE
+3. How to deploy it to a testnet
+
+## Step 1 - Generate a contract
+
+This is by far the most straightforward step. Just run:
+
+```sh
+nargo compile
+```
+
+This will compile your source code into a Noir build artifact to be stored in the `./target` directory, you can then generate the smart contract using the commands:
+
+```sh
+# Here we pass the path to the newly generated Noir artifact.
+bb write_vk -b ./target/<noir_artifact_name>.json
+bb contract
+```
+
+replacing `<noir_artifact_name>` with the name of your Noir project. A new `contract` folder would then be generated in your project directory, containing the Solidity
+file `contract.sol`. It can be deployed to any EVM blockchain acting as a verifier smart contract.
+
+You can find more information about `bb` and the default Noir proving backend on [this page](../getting_started/quick_start.md#proving-backend).
+
+:::info
+
+It is possible to generate verifier contracts of Noir programs for other smart contract platforms as long as the proving backend supplies an implementation.
+
+Barretenberg, the default proving backend for Nargo, supports generation of verifier contracts, for the time being these are only in Solidity.
+:::
+
+## Step 2 - Compiling
+
+We will mostly skip the details of RemixIDE, as the UI can change from version to version. For now, we can just open
+<a href="https://remix.ethereum.org" target="_blank">Remix</a> and create a blank workspace.
+
+![Create Workspace](@site/static/img/how-tos/solidity_verifier_1.png)
+
+We will create a new file to contain the contract Nargo generated, and copy-paste its content.
+
+:::warning
+
+You'll likely see a warning advising you to not trust pasted code. While it is an important warning, it is irrelevant in the context of this guide and can be ignored. We will not be deploying anywhere near a mainnet.
+
+:::
+
+To compile our the verifier, we can navigate to the compilation tab:
+
+![Compilation Tab](@site/static/img/how-tos/solidity_verifier_2.png)
+
+Remix should automatically match a suitable compiler version. However, hitting the "Compile" button will most likely generate a "Stack too deep" error:
+
+![Stack too deep](@site/static/img/how-tos/solidity_verifier_3.png)
+
+This is due to the verify function needing to put many variables on the stack, but enabling the optimizer resolves the issue. To do this, let's open the "Advanced Configurations" tab and enable optimization. The default 200 runs will suffice.
+
+:::info
+
+This time we will see a warning about an unused function parameter. This is expected, as the `verify` function doesn't use the `_proof` parameter inside a solidity block, it is loaded from calldata and used in assembly.
+
+:::
+
+![Compilation success](@site/static/img/how-tos/solidity_verifier_4.png)
+
+## Step 3 - Deploying
+
+At this point we should have a compiled contract ready to deploy. If we navigate to the deploy section in Remix, we will see many different environments we can deploy to. The steps to deploy on each environment would be out-of-scope for this guide, so we will just use the default Remix VM.
+
+Looking closely, we will notice that our "Solidity Verifier" is actually three contracts working together:
+
+- An `UltraVerificationKey` library which simply stores the verification key for our circuit.
+- An abstract contract `BaseUltraVerifier` containing most of the verifying logic.
+- A main `UltraVerifier` contract that inherits from the Base and uses the Key contract.
+
+Remix will take care of the dependencies for us so we can simply deploy the UltraVerifier contract by selecting it and hitting "deploy":
+
+![Deploying UltraVerifier](@site/static/img/how-tos/solidity_verifier_5.png)
+
+A contract will show up in the "Deployed Contracts" section, where we can retrieve the Verification Key Hash. This is particularly useful for double-checking that the deployer contract is the correct one.
+
+:::note
+
+Why "UltraVerifier"?
+
+To be precise, the Noir compiler (`nargo`) doesn't generate the verifier contract directly. It compiles the Noir code into an intermediate language (ACIR), which is then executed by the backend. So it is the backend that returns the verifier smart contract, not Noir.
+
+In this case, the Barretenberg Backend uses the UltraPlonk proving system, hence the "UltraVerifier" name.
+
+:::
+
+## Step 4 - Verifying
+
+To verify a proof using the Solidity verifier contract, we call the `verify` function in this extended contract:
+
+```solidity
+function verify(bytes calldata _proof, bytes32[] calldata _publicInputs) external view returns (bool)
+```
+
+When using the default example in the [Hello Noir](../getting_started/quick_start.md) guide, the easiest way to confirm that the verifier contract is doing its job is by calling the `verify` function via remix with the required parameters. Note that the public inputs must be passed in separately to the rest of the proof so we must split the proof as returned from `bb`.
+
+First generate a proof with `bb` at the location `./proof` using the steps in [get started](../getting_started/quick_start.md), this proof is in a binary format but we want to convert it into a hex string to pass into Remix, this can be done with the
+
+```bash
+# This value must be changed to match the number of public inputs (including return values!) in your program.
+NUM_PUBLIC_INPUTS=1
+PUBLIC_INPUT_BYTES=32*NUM_PUBLIC_INPUTS
+HEX_PUBLIC_INPUTS=$(head -c $PUBLIC_INPUT_BYTES ./proof | od -An -v -t x1 | tr -d $' \n')
+HEX_PROOF=$(tail -c +$(($PUBLIC_INPUT_BYTES + 1)) ./proof | od -An -v -t x1 | tr -d $' \n')
+
+echo "Public inputs:"
+echo $HEX_PUBLIC_INPUTS
+
+echo "Proof:"
+echo "0x$HEX_PROOF"
+```
+
+Remix expects that the public inputs will be split into an array of `bytes32` values so `HEX_PUBLIC_INPUTS` needs to be split up into 32 byte chunks which are prefixed with `0x` accordingly.
+
+A programmatic example of how the `verify` function is called can be seen in the example zk voting application [here](https://github.com/noir-lang/noir-examples/blob/33e598c257e2402ea3a6b68dd4c5ad492bce1b0a/foundry-voting/src/zkVote.sol#L35):
+
+```solidity
+function castVote(bytes calldata proof, uint proposalId, uint vote, bytes32 nullifierHash) public returns (bool) {
+  // ...
+  bytes32[] memory publicInputs = new bytes32[](4);
+  publicInputs[0] = merkleRoot;
+  publicInputs[1] = bytes32(proposalId);
+  publicInputs[2] = bytes32(vote);
+  publicInputs[3] = nullifierHash;
+  require(verifier.verify(proof, publicInputs), "Invalid proof");
+```
+
+:::info[Return Values]
+
+A circuit doesn't have the concept of a return value. Return values are just syntactic sugar in Noir.
+
+Under the hood, the return value is passed as an input to the circuit and is checked at the end of the circuit program.
+
+For example, if you have Noir program like this:
+
+```rust
+fn main(
+    // Public inputs
+    pubkey_x: pub Field,
+    pubkey_y: pub Field,
+    // Private inputs
+    priv_key: Field,
+) -> pub Field
+```
+
+the `verify` function will expect the public inputs array (second function parameter) to be of length 3, the two inputs and the return value.
+
+Passing only two inputs will result in an error such as `PUBLIC_INPUT_COUNT_INVALID(3, 2)`.
+
+In this case, the inputs parameter to `verify` would be an array ordered as `[pubkey_x, pubkey_y, return`.
+
+:::
+
+:::tip[Structs]
+
+You can pass structs to the verifier contract. They will be flattened so that the array of inputs is 1-dimensional array.
+
+For example, consider the following program:
+
+```rust
+struct Type1 {
+  val1: Field,
+  val2: Field,
+}
+
+struct Nested {
+  t1: Type1,
+  is_true: bool,
+}
+
+fn main(x: pub Field, nested: pub Nested, y: pub Field) {
+  //...
+}
+```
+
+The order of these inputs would be flattened to: `[x, nested.t1.val1, nested.t1.val2, nested.is_true, y]`
+
+:::
+
+The other function you can call is our entrypoint `verify` function, as defined above.
+
+:::tip
+
+It's worth noticing that the `verify` function is actually a `view` function. A `view` function does not alter the blockchain state, so it doesn't need to be distributed (i.e. it will run only on the executing node), and therefore doesn't cost any gas.
+
+This can be particularly useful in some situations. If Alice generated a proof and wants Bob to verify its correctness, Bob doesn't need to run Nargo, NoirJS, or any Noir specific infrastructure. He can simply make a call to the blockchain with the proof and verify it is correct without paying any gas.
+
+It would be incorrect to say that a Noir proof verification costs any gas at all. However, most of the time the result of `verify` is used to modify state (for example, to update a balance, a game state, etc). In that case the whole network needs to execute it, which does incur gas costs (calldata and execution, but not storage).
+
+:::
+
+## A Note on EVM chains
+
+Noir proof verification requires the ecMul, ecAdd and ecPairing precompiles. Not all EVM chains support EC Pairings, notably some of the ZK-EVMs. This means that you won't be able to use the verifier contract in all of them. You can find an incomplete list of which EVM chains support these precompiles [here](https://www.evmdiff.com/features?feature=precompiles).
+
+For example, chains like `zkSync ERA` and `Polygon zkEVM` do not currently support these precompiles, so proof verification via Solidity verifier contracts won't work. Here's a quick list of EVM chains that have been tested and are known to work:
+
+- Optimism
+- Arbitrum
+- Polygon PoS
+- Scroll
+- Celo
+- BSC
+- Blast L2
+- Avalanche C-Chain
+- Mode
+- Linea
+- Moonbeam
+
+If you test any other chains, please open a PR on this page to update the list. See [this doc](https://github.com/noir-lang/noir-starter/tree/main/with-foundry#testing-on-chain) for more info about testing verifier contracts on different EVM chains.
+
+## What's next
+
+Now that you know how to call a Noir Solidity Verifier on a smart contract using Remix, you should be comfortable with using it with some programmatic frameworks, such as [hardhat](https://github.com/noir-lang/noir-starter/tree/main/vite-hardhat) and [foundry](https://github.com/noir-lang/noir-starter/tree/main/with-foundry).
+
+You can find other tools, examples, boilerplates and libraries in the [awesome-noir](https://github.com/noir-lang/awesome-noir) repository.
+
+You should also be ready to write and deploy your first NoirJS app and start generating proofs on websites, phones, and NodeJS environments! Head on to the [NoirJS tutorial](../tutorials/noirjs_app.md) to learn how to do that.
diff --git a/docs/versioned_docs/version-v1.0.0-beta.0/how_to/merkle-proof.mdx b/docs/versioned_docs/version-v1.0.0-beta.0/how_to/merkle-proof.mdx
new file mode 100644
index 00000000000..0a128adb2de
--- /dev/null
+++ b/docs/versioned_docs/version-v1.0.0-beta.0/how_to/merkle-proof.mdx
@@ -0,0 +1,48 @@
+---
+title: Prove Merkle Tree Membership
+description:
+  Learn how to use merkle membership proof in Noir to prove that a given leaf is a member of a
+  merkle tree with a specified root, at a given index.
+keywords:
+  [merkle proof, merkle membership proof, Noir, rust, hash function, Pedersen, sha256, merkle tree]
+sidebar_position: 4
+---
+
+Let's walk through an example of a merkle membership proof in Noir that proves that a given leaf is
+in a merkle tree.
+
+```rust
+
+fn main(message : [Field; 62], index : Field, hashpath : [Field; 40], root : Field) {
+    let leaf = std::hash::hash_to_field(message.as_slice());
+    let merkle_root = std::merkle::compute_merkle_root(leaf, index, hashpath);
+    assert(merkle_root == root);
+}
+
+```
+
+The message is hashed using `hash_to_field`. The specific hash function that is being used is chosen
+by the backend. The only requirement is that this hash function can heuristically be used as a
+random oracle. If only collision resistance is needed, then one can call `std::hash::pedersen_hash`
+instead.
+
+```rust
+let leaf = std::hash::hash_to_field(message.as_slice());
+```
+
+The leaf is then passed to a compute_merkle_root function with the root, index and hashpath. The returned root can then be asserted to be the same as the provided root.
+
+```rust
+let merkle_root = std::merkle::compute_merkle_root(leaf, index, hashpath);
+assert (merkle_root == root);
+```
+
+> **Note:** It is possible to re-implement the merkle tree implementation without standard library.
+> However, for most usecases, it is enough. In general, the standard library will always opt to be
+> as conservative as possible, while striking a balance with efficiency.
+
+An example, the merkle membership proof, only requires a hash function that has collision
+resistance, hence a hash function like Pedersen is allowed, which in most cases is more efficient
+than the even more conservative sha256.
+
+[View an example on the starter repo](https://github.com/noir-lang/noir-examples/blob/3ea09545cabfa464124ec2f3ea8e60c608abe6df/stealthdrop/circuits/src/main.nr#L20)
diff --git a/docs/versioned_docs/version-v1.0.0-beta.0/how_to/using-devcontainers.mdx b/docs/versioned_docs/version-v1.0.0-beta.0/how_to/using-devcontainers.mdx
new file mode 100644
index 00000000000..727ec6ca667
--- /dev/null
+++ b/docs/versioned_docs/version-v1.0.0-beta.0/how_to/using-devcontainers.mdx
@@ -0,0 +1,110 @@
+---
+title: Developer Containers and Codespaces
+description: "Learn how to set up a devcontainer in your GitHub repository for a seamless coding experience with Codespaces. Follow our easy 8-step guide to create your own Noir environment without installing Nargo locally."
+keywords: ["Devcontainer", "Codespaces", "GitHub", "Noir Environment", "Docker Image", "Development Environment", "Remote Coding", "GitHub Codespaces", "Noir Programming", "Nargo", "VSCode Extensions", "Noirup"]
+sidebar_position: 1
+---
+
+Adding a developer container configuration file to your Noir project is one of the easiest way to unlock coding in browser.
+
+## What's a devcontainer after all?
+
+A [Developer Container](https://containers.dev/) (devcontainer for short) is a Docker image that comes preloaded with tools, extensions, and other tools you need to quickly get started or continue a project, without having to install Nargo locally. Think of it as a development environment in a box.
+
+There are many advantages to this:
+
+- It's platform and architecture agnostic
+- You don't need to have an IDE installed, or Nargo, or use a terminal at all
+- It's safer for using on a public machine or public network
+
+One of the best ways of using devcontainers is... not using your machine at all, for maximum control, performance, and ease of use.
+Enter Codespaces.
+
+## Codespaces
+
+If a devcontainer is just a Docker image, then what stops you from provisioning a `p3dn.24xlarge` AWS EC2 instance with 92 vCPUs and 768 GiB RAM and using it to prove your 10-gate SNARK proof? 
+
+Nothing! Except perhaps the 30-40$ per hour it will cost you. 
+
+The problem is that provisioning takes time, and I bet you don't want to see the AWS console every time you want to code something real quick.
+
+Fortunately, there's an easy and free way to get a decent remote machine ready and loaded in less than 2 minutes: Codespaces. [Codespaces is a Github feature](https://github.com/features/codespaces) that allows you to code in a remote machine by using devcontainers, and it's pretty cool:
+
+- You can start coding Noir in less than a minute
+- It uses the resources of a remote machine, so you can code on your grandma's phone if needed be
+- It makes it easy to share work with your frens
+- It's fully reusable, you can stop and restart whenever you need to
+
+:::info
+
+Don't take out your wallet just yet. Free GitHub accounts get about [15-60 hours of coding](https://github.com/features/codespaces) for free per month, depending on the size of your provisioned machine.
+
+:::
+
+## Tell me it's _actually_ easy
+
+It is!
+
+Github comes with a default codespace and you can use it to code your own devcontainer. That's exactly what we will be doing in this guide.
+
+<video width="100%" height="auto" controls>
+  <source src={require('@site/static/video/how-tos/devcontainer.mp4').default} type="video/mp4" />
+  Your browser does not support the video tag.
+</video>
+
+8 simple steps:
+
+#### 1. <a href="https://github.com/new" target="_blank">Create a new repository</a> on GitHub.
+
+#### 2. Click "Start coding with Codespaces". This will use the default image.
+
+#### 3. Create a folder called `.devcontainer` in the root of your repository.
+
+#### 4. Create a Dockerfile in that folder, and paste the following code:
+
+```docker
+FROM --platform=linux/amd64 node:lts-bookworm-slim
+SHELL ["/bin/bash", "-c"]
+RUN apt update && apt install -y curl bash git tar gzip libc++-dev
+RUN curl -L https://raw.githubusercontent.com/noir-lang/noirup/main/install | bash
+ENV PATH="/root/.nargo/bin:$PATH"
+RUN noirup
+ENTRYPOINT ["nargo"]
+```
+#### 5. Create a file called `devcontainer.json` in the same folder, and paste the following code:
+
+```json
+{
+ "name": "Noir on Codespaces",
+ "build": {
+    "context": ".",
+    "dockerfile": "Dockerfile"
+  },
+  "customizations": {
+    "vscode": {
+      "extensions": ["noir-lang.vscode-noir"]
+    }
+  }
+}
+```
+#### 6. Commit and push your changes
+
+This will pull the new image and build it, so it could take a minute or so
+
+#### 8. Done! 
+Just wait for the build to finish, and there's your easy Noir environment.
+
+
+Refer to [noir-starter](https://github.com/noir-lang/noir-starter/) as an example of how devcontainers can be used together with codespaces.
+
+
+
+## How do I use it?
+
+Using the codespace is obviously much easier than setting it up. 
+Just navigate to your repository and click "Code" -> "Open with Codespaces". It should take a few seconds to load, and you're ready to go.
+
+:::info
+
+If you really like the experience, you can add a badge to your readme, links to existing codespaces, and more. 
+Check out the [official docs](https://docs.github.com/en/codespaces/setting-up-your-project-for-codespaces/setting-up-your-repository/facilitating-quick-creation-and-resumption-of-codespaces) for more info.
diff --git a/docs/versioned_docs/version-v1.0.0-beta.0/index.mdx b/docs/versioned_docs/version-v1.0.0-beta.0/index.mdx
new file mode 100644
index 00000000000..5c116a73b3f
--- /dev/null
+++ b/docs/versioned_docs/version-v1.0.0-beta.0/index.mdx
@@ -0,0 +1,76 @@
+---
+title: Noir Lang
+hide_title: true
+description:
+  Learn about the public alpha release of Noir, a domain specific language heavily influenced by Rust that compiles to
+  an intermediate language which can be compiled to an arithmetic circuit or a rank-1 constraint system.
+keywords:
+    [Noir,
+    Domain Specific Language,
+    Rust,
+    Intermediate Language,
+    Arithmetic Circuit,
+    Rank-1 Constraint System,
+    Ethereum Developers,
+    Protocol Developers,
+    Blockchain Developers,
+    Proving System,
+    Smart Contract Language]
+sidebar_position: 0
+---
+
+import Tabs from '@theme/Tabs';
+import TabItem from '@theme/TabItem';
+import ThemedImage from '@theme/ThemedImage';
+import useBaseUrl from '@docusaurus/useBaseUrl';
+
+<ThemedImage
+  sources={{
+    light: useBaseUrl("/img/logoDark.png"),
+    dark: useBaseUrl("/img/logo.png"),
+  }}
+  style={{display: "block", width: "50%", margin: "2rem auto"}} 
+  alt="Noir Logo" 
+/>
+
+Noir is an open-source Domain-Specific Language for safe and seamless construction of privacy-preserving Zero-Knowledge programs, requiring no previous knowledge on the underlying mathematics or cryptography.
+
+ZK programs are programs that can generate short proofs of statements without revealing all inputs to the statements. You can read more about Zero-Knowledge Proofs [here](https://dev.to/spalladino/a-beginners-intro-to-coding-zero-knowledge-proofs-c56).
+
+## What's new about Noir?
+
+Noir works differently from most ZK languages by taking a two-pronged path. First, it compiles the program to an adaptable intermediate language known as ACIR. From there, depending on a given project's needs, ACIR can be further compiled into an arithmetic circuit for integration with the proving backend.
+
+:::info
+
+Noir is backend agnostic, which means it makes no assumptions on which proving backend powers the ZK proof. Being the language that powers [Aztec Contracts](https://docs.aztec.network/developers/contracts/main), it defaults to Aztec's Barretenberg proving backend.
+
+However, the ACIR output can be transformed to be compatible with other PLONK-based backends, or into a [rank-1 constraint system](https://www.rareskills.io/post/rank-1-constraint-system) suitable for backends such as Arkwork's Marlin.
+
+:::
+
+## Who is Noir for?
+
+Noir can be used both in complex cloud-based backends and in user's smartphones, requiring no knowledge on the underlying math or cryptography. From authorization systems that keep a password in the user's device, to complex on-chain verification of recursive proofs, Noir is designed to abstract away complexity without any significant overhead. Here are some examples of situations where Noir can be used:
+
+<Tabs>
+  <TabItem value="Aztec Contracts" label="Aztec Contracts" default>
+    <img src={require("@site/static/img/aztec_logo.png").default} style={{display: "block", width: "50%", margin: "2rem auto"}} alt="Noir Logo"  />
+    
+    Aztec Contracts leverage Noir to allow for the storage and execution of private information. Writing an Aztec Contract is as easy as writing Noir, and Aztec developers can easily interact with the network storage and execution through the [Aztec.nr](https://docs.aztec.network/developers/contracts/main) library.
+  </TabItem>
+  <TabItem value="Solidity Verifiers" label="Solidity Verifiers">
+    <img src={require("@site/static/img/solidity_verifier_ex.png").default} style={{display: "block", margin: "2rem auto"}} alt="Soliditry Verifier Example"  />
+    Noir can auto-generate Solidity verifier contracts that verify Noir proofs. This allows for non-interactive verification of proofs containing private information in an immutable system. This feature powers a multitude of use-case scenarios, from P2P chess tournaments, to [Aztec Layer-2 Blockchain](https://docs.aztec.network/)
+  </TabItem>
+  <TabItem value="Full-Stack Development" label="Full-Stack Development">
+    Aztec Labs developed NoirJS, an easy interface to generate and verify Noir proofs in a Javascript environment. This allows for Noir to be used in webpages, mobile apps, games, and any other environment supporting JS execution in a standalone manner.
+  </TabItem>
+</Tabs>
+
+
+## Libraries
+
+Noir is meant to be easy to extend by simply importing Noir libraries just like in Rust. 
+The [awesome-noir repo](https://github.com/noir-lang/awesome-noir#libraries) is a collection of libraries developed by the Noir community.
+Writing a new library is easy and makes code be composable and easy to reuse. See the section on [dependencies](noir/modules_packages_crates/dependencies.md) for more information.
diff --git a/docs/versioned_docs/version-v1.0.0-beta.0/migration_notes.md b/docs/versioned_docs/version-v1.0.0-beta.0/migration_notes.md
new file mode 100644
index 00000000000..6bd740024e5
--- /dev/null
+++ b/docs/versioned_docs/version-v1.0.0-beta.0/migration_notes.md
@@ -0,0 +1,105 @@
+---
+title: Migration notes
+description: Read about migration notes from previous versions, which could solve problems while updating
+keywords: [Noir, notes, migration, updating, upgrading]
+---
+
+Noir is in full-speed development. Things break fast, wild, and often. This page attempts to leave some notes on errors you might encounter when upgrading and how to resolve them until proper patches are built.
+
+### `backend encountered an error: libc++.so.1`
+
+Depending on your OS, you may encounter the following error when running `nargo prove` for the first time:
+
+```text
+The backend encountered an error: "/home/codespace/.nargo/backends/acvm-backend-barretenberg/backend_binary: error while loading shared libraries: libc++.so.1: cannot open shared object file: No such file or directory\n"
+```
+
+Install the `libc++-dev` library with:
+
+```bash
+sudo apt install libc++-dev
+```
+
+## ≥0.19
+
+### Enforcing `compiler_version`
+
+From this version on, the compiler will check for the `compiler_version` field in `Nargo.toml`, and will error if it doesn't match the current Nargo version in use.
+
+To update, please make sure this field in `Nargo.toml` matches the output of `nargo --version`.
+
+## ≥0.14
+
+The index of the [for loops](noir/concepts/control_flow.md#loops) is now of type `u64` instead of `Field`. An example refactor would be:
+
+```rust
+for i in 0..10 {
+    let i = i as Field;
+}
+```
+
+## ≥v0.11.0 and Nargo backend
+
+From this version onwards, Nargo starts managing backends through the `nargo backend` command. Upgrading to the versions per usual steps might lead to:
+
+### `backend encountered an error`
+
+This is likely due to the existing locally installed version of proving backend (e.g. barretenberg) is incompatible with the version of Nargo in use.
+
+To fix the issue:
+
+1. Uninstall the existing backend
+
+```bash
+nargo backend uninstall acvm-backend-barretenberg
+```
+
+You may replace _acvm-backend-barretenberg_ with the name of your backend listed in `nargo backend ls` or in ~/.nargo/backends.
+
+2. Reinstall a compatible version of the proving backend.
+
+If you are using the default barretenberg backend, simply run:
+
+```
+nargo prove
+```
+
+with your Noir program.
+
+This will trigger the download and installation of the latest version of barretenberg compatible with your Nargo in use.
+
+### `backend encountered an error: illegal instruction`
+
+On certain Intel-based systems, an `illegal instruction` error may arise due to incompatibility of barretenberg with certain CPU instructions.
+
+To fix the issue:
+
+1. Uninstall the existing backend
+
+```bash
+nargo backend uninstall acvm-backend-barretenberg
+```
+
+You may replace _acvm-backend-barretenberg_ with the name of your backend listed in `nargo backend ls` or in ~/.nargo/backends.
+
+2. Reinstall a compatible version of the proving backend.
+
+If you are using the default barretenberg backend, simply run:
+
+```
+nargo backend install acvm-backend-barretenberg https://github.com/noir-lang/barretenberg-js-binary/raw/master/run-bb.tar.gz
+```
+
+This downloads and installs a specific bb.js based version of barretenberg binary from GitHub.
+
+The gzipped file is running [this bash script](https://github.com/noir-lang/barretenberg-js-binary/blob/master/run-bb-js.sh), where we need to gzip it as the Nargo currently expect the backend to be zipped up.
+
+Then run:
+
+```
+DESIRED_BINARY_VERSION=0.8.1 nargo info
+```
+
+This overrides the bb native binary with a bb.js node application instead, which should be compatible with most if not all hardware. This does come with the drawback of being generally slower than native binary.
+
+0.8.1 indicates bb.js version 0.8.1, so if you change that it will update to a different version or the default version in the script if none was supplied.
diff --git a/docs/versioned_docs/version-v1.0.0-beta.0/noir/concepts/_category_.json b/docs/versioned_docs/version-v1.0.0-beta.0/noir/concepts/_category_.json
new file mode 100644
index 00000000000..7da08f8a8c5
--- /dev/null
+++ b/docs/versioned_docs/version-v1.0.0-beta.0/noir/concepts/_category_.json
@@ -0,0 +1,6 @@
+{
+    "label": "Concepts",
+    "position": 0,
+    "collapsible": true,
+    "collapsed": true
+}
\ No newline at end of file
diff --git a/docs/versioned_docs/version-v1.0.0-beta.0/noir/concepts/assert.md b/docs/versioned_docs/version-v1.0.0-beta.0/noir/concepts/assert.md
new file mode 100644
index 00000000000..2132de42072
--- /dev/null
+++ b/docs/versioned_docs/version-v1.0.0-beta.0/noir/concepts/assert.md
@@ -0,0 +1,78 @@
+---
+title: Assert Function
+description:
+  Learn about the `assert` and `static_assert` functions in Noir, which can be used to explicitly
+  constrain the predicate or comparison expression that follows to be true, and what happens if
+  the expression is false at runtime or compile-time, respectively.
+keywords: [Noir programming language, assert statement, predicate expression, comparison expression]
+sidebar_position: 4
+---
+
+Noir includes a special `assert` function which will explicitly constrain the predicate/comparison
+expression that follows to be true. If this expression is false at runtime, the program will fail to
+be proven. Example:
+
+```rust
+fn main(x : Field, y : Field) {
+    assert(x == y);
+}
+```
+
+> Assertions only work for predicate operations, such as `==`. If there's any ambiguity on the operation, the program will fail to compile. For example, it is unclear if `assert(x + y)` would check for `x + y == 0` or simply would return `true`.
+
+You can optionally provide a message to be logged when the assertion fails:
+
+```rust
+assert(x == y, "x and y are not equal");
+```
+
+Aside string literals, the optional message can be a format string or any other type supported as input for Noir's [print](../standard_library/logging.md) functions. This feature lets you incorporate runtime variables into your failed assertion logs:
+
+```rust
+assert(x == y, f"Expected x == y, but got {x} == {y}");
+```
+
+Using a variable as an assertion message directly:
+
+```rust
+struct myStruct {
+  myField: Field
+}
+
+let s = myStruct { myField: y };
+assert(s.myField == x, s);
+```
+
+There is also a special `static_assert` function that behaves like `assert`,
+but that runs at compile-time.
+
+```rust
+fn main(xs: [Field; 3]) {
+    let x = 2 + 2;
+    let y = 4;
+    static_assert(x == y, "expected 2 + 2 to equal 4");
+
+    // This passes since the length of `xs` is known at compile-time
+    static_assert(xs.len() == 3, "expected the input to have 3 elements");
+}
+```
+
+This function fails when passed a dynamic (run-time) argument:
+
+```rust
+fn main(x : Field, y : Field) {
+    // this fails because `x` is not known at compile-time
+    static_assert(x == 2, "expected x to be known at compile-time and equal to 2");
+
+    let mut example_slice = &[];
+    if y == 4 {
+        example_slice = example_slice.push_back(0);
+    }
+
+    // This fails because the length of `example_slice` is not known at
+    // compile-time
+    let error_message = "expected an empty slice, known at compile-time";
+    static_assert(example_slice.len() == 0, error_message);
+}
+```
+
diff --git a/docs/versioned_docs/version-v1.0.0-beta.0/noir/concepts/comments.md b/docs/versioned_docs/version-v1.0.0-beta.0/noir/concepts/comments.md
new file mode 100644
index 00000000000..b51a85f5c94
--- /dev/null
+++ b/docs/versioned_docs/version-v1.0.0-beta.0/noir/concepts/comments.md
@@ -0,0 +1,33 @@
+---
+title: Comments
+description:
+  Learn how to write comments in Noir programming language. A comment is a line of code that is
+  ignored by the compiler, but it can be read by programmers. Single-line and multi-line comments
+  are supported in Noir.
+keywords: [Noir programming language, comments, single-line comments, multi-line comments]
+sidebar_position: 10
+---
+
+A comment is a line in your codebase which the compiler ignores, however it can be read by
+programmers.
+
+Here is a single line comment:
+
+```rust
+// This is a comment and is ignored
+```
+
+`//` is used to tell the compiler to ignore the rest of the line.
+
+Noir also supports multi-line block comments. Start a block comment with `/*` and end the block with `*/`.
+
+Noir does not natively support doc comments. You may be able to use [Rust doc comments](https://doc.rust-lang.org/reference/comments.html) in your code to leverage some Rust documentation build tools with Noir code.
+
+```rust
+/*
+  This is a block comment describing a complex function.
+*/
+fn main(x : Field, y : pub Field) {
+    assert(x != y);
+}
+```
diff --git a/docs/versioned_docs/version-v1.0.0-beta.0/noir/concepts/comptime.md b/docs/versioned_docs/version-v1.0.0-beta.0/noir/concepts/comptime.md
new file mode 100644
index 00000000000..2ceb030c7e1
--- /dev/null
+++ b/docs/versioned_docs/version-v1.0.0-beta.0/noir/concepts/comptime.md
@@ -0,0 +1,445 @@
+---
+title: Compile-time Code & Metaprogramming
+description: Learn how to use metaprogramming in Noir to create macros or derive your own traits
+keywords: [Noir, comptime, compile-time, metaprogramming, macros, quote, unquote]
+sidebar_position: 15
+---
+
+## Overview
+
+Metaprogramming in Noir is comprised of three parts:
+1. `comptime` code
+2. Quoting and unquoting
+3. The metaprogramming API in `std::meta`
+
+Each of these are explained in more detail in the next sections but the wide picture is that
+`comptime` allows us to write code which runs at compile-time. In this `comptime` code we
+can quote and unquote snippets of the program, manipulate them, and insert them in other
+parts of the program. Comptime functions which do this are said to be macros. Additionally,
+there's a compile-time API of built-in types and functions provided by the compiler which allows
+for greater analysis and modification of programs.
+
+---
+
+## Comptime
+
+`comptime` is a new keyword in Noir which marks an item as executing or existing at compile-time. It can be used in several ways:
+
+- `comptime fn` to define functions which execute exclusively during compile-time.
+- `comptime global` to define a global variable which is evaluated at compile-time.
+  - Unlike runtime globals, `comptime global`s can be mutable.
+- `comptime { ... }` to execute a block of statements during compile-time.
+- `comptime let` to define a variable whose value is evaluated at compile-time.
+- `comptime for` to run a for loop at compile-time. Syntax sugar for `comptime { for .. }`.
+
+### Scoping
+
+Note that while in a `comptime` context, any runtime variables _local to the current function_ are never visible.
+
+### Evaluating
+
+Evaluation rules of `comptime` follows the normal unconstrained evaluation rules for other Noir code. There are a few things to note though:
+
+- Certain built-in functions may not be available, although more may be added over time.
+- Evaluation order of global items is currently unspecified. For example, given the following two functions we can't guarantee
+which `println` will execute first. The ordering of the two printouts will be arbitrary, but should be stable across multiple compilations with the same `nargo` version as long as the program is also unchanged.
+
+```rust
+fn one() {
+    comptime { println("one"); }
+}
+
+fn two() {
+    comptime { println("two"); }
+}
+```
+
+- Since evaluation order is unspecified, care should be taken when using mutable globals so that they do not rely on a particular ordering.
+For example, using globals to generate unique ids should be fine but relying on certain ids always being produced (especially after edits to the program) should be avoided.
+- Although most ordering of globals is unspecified, two are:
+  - Dependencies of a crate will always be evaluated before the dependent crate.
+  - Any annotations on a function will be run before the function itself is resolved. This is to allow the annotation to modify the function if necessary. Note that if the
+    function itself was called at compile-time previously, it will already be resolved and cannot be modified. To prevent accidentally calling functions you wish to modify
+    at compile-time, it may be helpful to sort your `comptime` annotation functions into a different crate along with any dependencies they require.
+
+### Lowering
+
+When a `comptime` value is used in runtime code it must be lowered into a runtime value. This means replacing the expression with the literal that it evaluated to. For example, the code:
+
+```rust
+struct Foo { array: [Field; 2], len: u32 }
+
+fn main() {
+    println(comptime {
+        let mut foo = std::mem::zeroed::<Foo>();
+        foo.array[0] = 4;
+        foo.len = 1;
+        foo
+    });
+}
+```
+
+will be converted to the following after `comptime` expressions are evaluated:
+
+```rust
+struct Foo { array: [Field; 2], len: u32 }
+
+fn main() {
+    println(Foo { array: [4, 0], len: 1 });
+}
+```
+
+Not all types of values can be lowered. For example, `Type`s and `TypeDefinition`s (among other types) cannot be lowered at all.
+
+```rust
+fn main() {
+    // There's nothing we could inline here to create a Type value at runtime
+    // let _ = get_type!();
+}
+
+comptime fn get_type() -> Type { ... }
+```
+
+---
+
+## (Quasi) Quote
+
+Macros in Noir are `comptime` functions which return code as a value which is inserted into the call site when it is lowered there.
+A code value in this case is of type `Quoted` and can be created by a `quote { ... }` expression.
+More specifically, the code value `quote` creates is a token stream - a representation of source code as a series of words, numbers, string literals, or operators.
+For example, the expression `quote { Hi "there reader"! }` would quote three tokens: the word "hi", the string "there reader", and an exclamation mark.
+You'll note that snippets that would otherwise be invalid syntax can still be quoted.
+
+When a `Quoted` value is used in runtime code, it is lowered into a `quote { ... }` expression. Since this expression is only valid
+in compile-time code however, we'd get an error if we tried this. Instead, we can use macro insertion to insert each token into the
+program at that point, and parse it as an expression. To do this, we have to add a `!` after the function name returning the `Quoted` value.
+If the value was created locally and there is no function returning it, `std::meta::unquote!(_)` can be used instead.
+Calling such a function at compile-time without `!` will just return the `Quoted` value to be further manipulated. For example:
+
+```rust title="quote-example" showLineNumbers 
+comptime fn quote_one() -> Quoted {
+        quote { 1 }
+    }
+
+    #[test]
+    fn returning_versus_macro_insertion() {
+        comptime {
+            // let _a: Quoted = quote { 1 };
+            let _a: Quoted = quote_one();
+
+            // let _b: Field = 1;
+            let _b: Field = quote_one!();
+
+            // Since integers default to fields, if we
+            // want a different type we have to explicitly cast
+            // let _c: i32 = 1 as i32;
+            let _c: i32 = quote_one!() as i32;
+        }
+    }
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/meta/mod.nr#L120-L140" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/meta/mod.nr#L120-L140</a></sub></sup>
+
+
+For those familiar with quoting from other languages (primarily lisps), Noir's `quote` is actually a _quasiquote_.
+This means we can escape the quoting by using the unquote operator to splice values in the middle of quoted code.
+
+## Unquote
+
+The unquote operator `$` is usable within a `quote` expression.
+It takes a variable as an argument, evaluates the variable, and splices the resulting value into the quoted token stream at that point. For example,
+
+```rust
+comptime {
+    let x = 1 + 2;
+    let y = quote { $x + 4 };
+}
+```
+
+The value of `y` above will be the token stream containing `3`, `+`, and `4`. We can also use this to combine `Quoted` values into larger token streams:
+
+```rust
+comptime {
+    let x = quote { 1 + 2 };
+    let y = quote { $x + 4 };
+}
+```
+
+The value of `y` above is now the token stream containing five tokens: `1 + 2 + 4`.
+
+Note that to unquote something, a variable name _must_ follow the `$` operator in a token stream.
+If it is an expression (even a parenthesized one), it will do nothing. Most likely a parse error will be given when the macro is later unquoted.
+
+Unquoting can also be avoided by escaping the `$` with a backslash:
+
+```
+comptime {
+    let x = quote { 1 + 2 };
+
+    // y contains the four tokens: `$x + 4`
+    let y = quote { \$x + 4 };
+}
+```
+
+---
+
+## Annotations
+
+Annotations provide a way to run a `comptime` function on an item in the program.
+When you use an annotation, the function with the same name will be called with that item as an argument:
+
+```rust
+#[my_struct_annotation]
+struct Foo {}
+
+comptime fn my_struct_annotation(s: StructDefinition) {
+    println("Called my_struct_annotation!");
+}
+
+#[my_function_annotation]
+fn foo() {}
+
+comptime fn my_function_annotation(f: FunctionDefinition) {
+    println("Called my_function_annotation!");
+}
+```
+
+Anything returned from one of these functions will be inserted at top-level along with the original item.
+Note that expressions are not valid at top-level so you'll get an error trying to return `3` or similar just as if you tried to write a program containing `3; struct Foo {}`.
+You can insert other top-level items such as trait impls, structs, or functions this way though.
+For example, this is the mechanism used to insert additional trait implementations into the program when deriving a trait impl from a struct:
+
+```rust title="derive-field-count-example" showLineNumbers 
+trait FieldCount {
+        fn field_count() -> u32;
+    }
+
+    #[derive_field_count]
+    struct Bar {
+        x: Field,
+        y: [Field; 2],
+    }
+
+    comptime fn derive_field_count(s: StructDefinition) -> Quoted {
+        let typ = s.as_type();
+        let field_count = s.fields().len();
+        quote {
+            impl FieldCount for $typ {
+                fn field_count() -> u32 {
+                    $field_count
+                }
+            }
+        }
+    }
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/meta/mod.nr#L142-L164" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/meta/mod.nr#L142-L164</a></sub></sup>
+
+
+### Calling annotations with additional arguments
+
+Arguments may optionally be given to annotations.
+When this is done, these additional arguments are passed to the annotation function after the item argument.
+
+```rust title="annotation-arguments-example" showLineNumbers 
+#[assert_field_is_type(quote { i32 }.as_type())]
+    struct MyStruct {
+        my_field: i32,
+    }
+
+    comptime fn assert_field_is_type(s: StructDefinition, typ: Type) {
+        // Assert the first field in `s` has type `typ`
+        let fields = s.fields();
+        assert_eq(fields[0].1, typ);
+    }
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/meta/mod.nr#L166-L177" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/meta/mod.nr#L166-L177</a></sub></sup>
+
+
+We can also take any number of arguments by adding the `varargs` annotation:
+
+```rust title="annotation-varargs-example" showLineNumbers 
+#[assert_three_args(1, 2, 3)]
+    struct MyOtherStruct {
+        my_other_field: u32,
+    }
+
+    #[varargs]
+    comptime fn assert_three_args(_s: StructDefinition, args: [Field]) {
+        assert_eq(args.len(), 3);
+    }
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/meta/mod.nr#L179-L189" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/meta/mod.nr#L179-L189</a></sub></sup>
+
+
+---
+
+## Comptime API
+
+Although `comptime`, `quote`, and unquoting provide a flexible base for writing macros,
+Noir's true metaprogramming ability comes from being able to interact with the compiler through a compile-time API.
+This API can be accessed through built-in functions in `std::meta` as well as on methods of several `comptime` types.
+
+The following is an incomplete list of some `comptime` types along with some useful methods on them. You can see more in the standard library [Metaprogramming section](../standard_library/meta).
+
+- `Quoted`: A token stream
+- `Type`: The type of a Noir type
+  - `fn implements(self, constraint: TraitConstraint) -> bool`
+    - Returns true if `self` implements the given trait constraint
+- `Expr`: A syntactically valid expression. Can be used to recur on a program's parse tree to inspect how it is structured.
+  - Methods:
+    - `fn as_function_call(self) -> Option<(Expr, [Expr])>`
+      - If this is a function call expression, return `(function, arguments)`
+    - `fn as_block(self) -> Option<[Expr]>`
+      - If this is a block, return each statement in the block
+- `FunctionDefinition`: A function definition
+  - Methods:
+    - `fn parameters(self) -> [(Quoted, Type)]`
+      - Returns a slice of `(name, type)` pairs for each parameter
+- `StructDefinition`: A struct definition
+  - Methods:
+    - `fn as_type(self) -> Type`
+      - Returns this `StructDefinition` as a `Type`. Any generics are kept as-is
+    - `fn generics(self) -> [Quoted]`
+      - Return the name of each generic on this struct
+    - `fn fields(self) -> [(Quoted, Type)]`
+      - Return the name and type of each field
+- `TraitConstraint`: A trait constraint such as `From<Field>`
+- `TypedExpr`: A type-checked expression.
+- `UnresolvedType`: A syntactic notation that refers to a Noir type that hasn't been resolved yet
+
+There are many more functions available by exploring the `std::meta` module and its submodules.
+Using these methods is the key to writing powerful metaprogramming libraries.
+
+### `#[use_callers_scope]`
+
+Since certain functions such as `Quoted::as_type`, `Expression::as_type`, or `Quoted::as_trait_constraint` will attempt
+to resolve their contents in a particular scope - it can be useful to change the scope they resolve in. By default
+these functions will resolve in the current function's scope which is usually the attribute function they are called in.
+If you're working on a library however, this may be a completely different module or crate to the item you're trying to
+use the attribute on. If you want to be able to use `Quoted::as_type` to refer to types local to the caller's scope for
+example, you can annotate your attribute function with `#[use_callers_scope]`. This will ensure your attribute, and any
+closures it uses, can refer to anything in the caller's scope. `#[use_callers_scope]` also works recursively. So if both
+your attribute function and a helper function it calls use it, then they can both refer to the same original caller.
+
+---
+
+## Example: Derive
+
+Using all of the above, we can write a `derive` macro that behaves similarly to Rust's but is not built into the language.
+From the user's perspective it will look like this:
+
+```rust
+// Example usage
+#[derive(Default, Eq, Ord)]
+struct MyStruct { my_field: u32 }
+```
+
+To implement `derive` we'll have to create a `comptime` function that accepts
+a variable amount of traits.
+
+```rust title="derive_example" showLineNumbers 
+// These are needed for the unconstrained hashmap we're using to store derive functions
+use crate::collections::umap::UHashMap;
+use crate::hash::BuildHasherDefault;
+use crate::hash::poseidon2::Poseidon2Hasher;
+
+// A derive function is one that given a struct definition can
+// create us a quoted trait impl from it.
+pub type DeriveFunction = fn(StructDefinition) -> Quoted;
+
+// We'll keep a global HANDLERS map to keep track of the derive handler for each trait
+comptime mut global HANDLERS: UHashMap<TraitDefinition, DeriveFunction, BuildHasherDefault<Poseidon2Hasher>> =
+    UHashMap::default();
+
+// Given a struct and a slice of traits to derive, create trait impls for each.
+// This function is as simple as iterating over the slice, checking if we have a trait
+// handler registered for the given trait, calling it, and appending the result.
+#[varargs]
+pub comptime fn derive(s: StructDefinition, traits: [TraitDefinition]) -> Quoted {
+    let mut result = quote {};
+
+    for trait_to_derive in traits {
+        let handler = unsafe { HANDLERS.get(trait_to_derive) };
+        assert(handler.is_some(), f"No derive function registered for `{trait_to_derive}`");
+
+        let trait_impl = handler.unwrap()(s);
+        result = quote { $result $trait_impl };
+    }
+
+    result
+}
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/meta/mod.nr#L31-L64" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/meta/mod.nr#L31-L64</a></sub></sup>
+
+
+Registering a derive function could be done as follows:
+
+```rust title="derive_via" showLineNumbers 
+// To register a handler for a trait, just add it to our handlers map
+pub comptime fn derive_via(t: TraitDefinition, f: DeriveFunction) {
+    HANDLERS.insert(t, f);
+}
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/meta/mod.nr#L66-L73" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/meta/mod.nr#L66-L73</a></sub></sup>
+
+
+```rust title="big-derive-usage-example" showLineNumbers 
+// Finally, to register a handler we call the above function as an annotation
+    // with our handler function.
+    #[derive_via(derive_do_nothing)]
+    trait DoNothing {
+        fn do_nothing(self);
+    }
+
+    comptime fn derive_do_nothing(s: StructDefinition) -> Quoted {
+        // This is simplified since we don't handle generics or where clauses!
+        // In a real example we'd likely also need to introduce each of
+        // `s.generics()` as well as a trait constraint for each generic
+        // to ensure they also implement the trait.
+        let typ = s.as_type();
+        quote {
+            impl DoNothing for $typ {
+                fn do_nothing(self) {
+                    // Traits can't tell us what to do
+                    println("something");
+                }
+            }
+        }
+    }
+
+    // Since `DoNothing` is a simple trait which:
+    // 1. Only has one method
+    // 2. Does not have any generics on the trait itself
+    // We can use `std::meta::make_trait_impl` to help us out.
+    // This helper function will generate our impl for us along with any
+    // necessary where clauses and still provides a flexible interface
+    // for us to work on each field on the struct.
+    comptime fn derive_do_nothing_alt(s: StructDefinition) -> Quoted {
+        let trait_name = quote { DoNothing };
+        let method_signature = quote { fn do_nothing(self) };
+
+        // Call `do_nothing` recursively on each field in the struct
+        let for_each_field = |field_name| quote { self.$field_name.do_nothing(); };
+
+        // Some traits like Eq want to join each field expression with something like `&`.
+        // We don't need that here
+        let join_fields_with = quote {};
+
+        // The body function is a spot to insert any extra setup/teardown needed.
+        // We'll insert our println here. Since we recur on each field, we should see
+        // one println for the struct itself, followed by a println for every field (recursively).
+        let body = |body| quote {
+            println("something");
+            $body
+        };
+        crate::meta::make_trait_impl(
+            s,
+            trait_name,
+            method_signature,
+            for_each_field,
+            join_fields_with,
+            body,
+        )
+    }
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/meta/mod.nr#L191-L249" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/meta/mod.nr#L191-L249</a></sub></sup>
+
diff --git a/docs/versioned_docs/version-v1.0.0-beta.0/noir/concepts/control_flow.md b/docs/versioned_docs/version-v1.0.0-beta.0/noir/concepts/control_flow.md
new file mode 100644
index 00000000000..b365bb22728
--- /dev/null
+++ b/docs/versioned_docs/version-v1.0.0-beta.0/noir/concepts/control_flow.md
@@ -0,0 +1,79 @@
+---
+title: Control Flow
+description:
+  Learn how to use loops and if expressions in the Noir programming language. Discover the syntax
+  and examples for for loops and if-else statements.
+keywords: [Noir programming language, loops, for loop, if-else statements, Rust syntax]
+sidebar_position: 2
+---
+
+## If Expressions
+
+Noir supports `if-else` statements. The syntax is most similar to Rust's where it is not required
+for the statement's conditional to be surrounded by parentheses.
+
+```rust
+let a = 0;
+let mut x: u32 = 0;
+
+if a == 0 {
+    if a != 0 {
+        x = 6;
+    } else {
+        x = 2;
+    }
+} else {
+    x = 5;
+    assert(x == 5);
+}
+assert(x == 2);
+```
+
+## Loops
+
+Noir has one kind of loop: the `for` loop. `for` loops allow you to repeat a block of code multiple
+times.
+
+The following block of code between the braces is run 10 times.
+
+```rust
+for i in 0..10 {
+    // do something
+}
+```
+
+Alternatively, `start..=end` can be used for a range that is inclusive on both ends.
+
+The index for loops is of type `u64`.
+
+### Break and Continue
+
+In unconstrained code, `break` and `continue` are also allowed in `for` loops. These are only allowed
+in unconstrained code since normal constrained code requires that Noir knows exactly how many iterations
+a loop may have. `break` and `continue` can be used like so:
+
+```rust
+for i in 0 .. 10 {
+    println("Iteration start")
+
+    if i == 2 {
+        continue;
+    }
+
+    if i == 5 {
+        break;
+    }
+
+    println(i);
+}
+println("Loop end")
+```
+
+When used, `break` will end the current loop early and jump to the statement after the for loop. In the example
+above, the `break` will stop the loop and jump to the `println("Loop end")`.
+
+`continue` will stop the current iteration of the loop, and jump to the start of the next iteration. In the example
+above, `continue` will jump to `println("Iteration start")` when used. Note that the loop continues as normal after this.
+The iteration variable `i` is still increased by one as normal when `continue` is used.
+
+`break` and `continue` cannot currently be used to jump out of more than a single loop at a time.
diff --git a/docs/versioned_docs/version-v1.0.0-beta.0/noir/concepts/data_bus.mdx b/docs/versioned_docs/version-v1.0.0-beta.0/noir/concepts/data_bus.mdx
new file mode 100644
index 00000000000..e55e58622ce
--- /dev/null
+++ b/docs/versioned_docs/version-v1.0.0-beta.0/noir/concepts/data_bus.mdx
@@ -0,0 +1,23 @@
+---
+title: Data Bus
+sidebar_position: 13
+---
+import Experimental from '@site/src/components/Notes/_experimental.mdx';
+
+<Experimental />
+
+The data bus is an optimization that the backend can use to make recursion more efficient.
+In order to use it, you must define some inputs of the program entry points (usually the `main()`
+function) with the `call_data` modifier, and the return values with the `return_data` modifier.
+These modifiers are incompatible with `pub` and `mut` modifiers.
+
+## Example
+
+```rust
+fn main(mut x: u32, y: call_data u32, z: call_data [u32;4] ) -> return_data u32 {
+  let a = z[x];
+  a+y
+}
+```
+
+As a result, both call_data and return_data will be treated as private inputs and encapsulated into a read-only array each, for the backend to process.
diff --git a/docs/versioned_docs/version-v1.0.0-beta.0/noir/concepts/data_types/_category_.json b/docs/versioned_docs/version-v1.0.0-beta.0/noir/concepts/data_types/_category_.json
new file mode 100644
index 00000000000..5d694210bbf
--- /dev/null
+++ b/docs/versioned_docs/version-v1.0.0-beta.0/noir/concepts/data_types/_category_.json
@@ -0,0 +1,5 @@
+{
+    "position": 0,
+    "collapsible": true,
+    "collapsed": true
+}
diff --git a/docs/versioned_docs/version-v1.0.0-beta.0/noir/concepts/data_types/arrays.md b/docs/versioned_docs/version-v1.0.0-beta.0/noir/concepts/data_types/arrays.md
new file mode 100644
index 00000000000..289145a8c4d
--- /dev/null
+++ b/docs/versioned_docs/version-v1.0.0-beta.0/noir/concepts/data_types/arrays.md
@@ -0,0 +1,276 @@
+---
+title: Arrays
+description:
+  Dive into the Array data type in Noir. Grasp its methods, practical examples, and best practices for efficiently using Arrays in your Noir code.
+keywords:
+  [
+    noir,
+    array type,
+    methods,
+    examples,
+    indexing,
+  ]
+sidebar_position: 4
+---
+
+An array is one way of grouping together values into one compound type. Array types can be inferred
+or explicitly specified via the syntax `[<Type>; <Size>]`:
+
+```rust
+fn main(x : Field, y : Field) {
+    let my_arr = [x, y];
+    let your_arr: [Field; 2] = [x, y];
+}
+```
+
+Here, both `my_arr` and `your_arr` are instantiated as an array containing two `Field` elements.
+
+Array elements can be accessed using indexing:
+
+```rust
+fn main() {
+    let a = [1, 2, 3, 4, 5];
+
+    let first = a[0];
+    let second = a[1];
+}
+```
+
+All elements in an array must be of the same type (i.e. homogeneous). That is, an array cannot group
+a `Field` value and a `u8` value together for example.
+
+You can write mutable arrays, like:
+
+```rust
+fn main() {
+    let mut arr = [1, 2, 3, 4, 5];
+    assert(arr[0] == 1);
+
+    arr[0] = 42;
+    assert(arr[0] == 42);
+}
+```
+
+You can instantiate a new array of a fixed size with the same value repeated for each element. The following example instantiates an array of length 32 where each element is of type Field and has the value 0.
+
+```rust
+let array: [Field; 32] = [0; 32];
+```
+
+Like in Rust, arrays in Noir are a fixed size. However, if you wish to convert an array to a [slice](./slices.mdx), you can just call `as_slice` on your array:
+
+```rust
+let array: [Field; 32] = [0; 32];
+let sl = array.as_slice()
+```
+
+You can define multidimensional arrays:
+
+```rust
+let array : [[Field; 2]; 2];
+let element = array[0][0];
+```
+
+However, multidimensional slices are not supported. For example, the following code will error at compile time:
+
+```rust
+let slice : [[Field]] = &[];
+```
+
+## Types
+
+You can create arrays of primitive types or structs. There is not yet support for nested arrays
+(arrays of arrays) or arrays of structs that contain arrays.
+
+## Methods
+
+For convenience, the STD provides some ready-to-use, common methods for arrays.
+Each of these functions are located within the generic impl `impl<T, N> [T; N] {`.
+So anywhere `self` appears, it refers to the variable `self: [T; N]`.
+
+### len
+
+Returns the length of an array
+
+```rust
+fn len(self) -> Field
+```
+
+example
+
+```rust
+fn main() {
+    let array = [42, 42];
+    assert(array.len() == 2);
+}
+```
+
+### sort
+
+Returns a new sorted array. The original array remains untouched. Notice that this function will
+only work for arrays of fields or integers, not for any arbitrary type. This is because the sorting
+logic it uses internally is optimized specifically for these values. If you need a sort function to
+sort any type, you should use the function `sort_via` described below.
+
+```rust
+fn sort(self) -> [T; N]
+```
+
+example
+
+```rust
+fn main() {
+    let arr = [42, 32];
+    let sorted = arr.sort();
+    assert(sorted == [32, 42]);
+}
+```
+
+### sort_via
+
+Sorts the array with a custom comparison function. The ordering function must return true if the first argument should be sorted to be before the second argument or is equal to the second argument.
+
+Using this method with an operator like `<` that does not return `true` for equal values will result in an assertion failure for arrays with equal elements.
+
+```rust
+fn sort_via(self, ordering: fn(T, T) -> bool) -> [T; N]
+```
+
+example
+
+```rust
+fn main() {
+    let arr = [42, 32]
+    let sorted_ascending = arr.sort_via(|a, b| a <= b);
+    assert(sorted_ascending == [32, 42]); // verifies
+
+    let sorted_descending = arr.sort_via(|a, b| a >= b);
+    assert(sorted_descending == [32, 42]); // does not verify
+}
+```
+
+### map
+
+Applies a function to each element of the array, returning a new array containing the mapped elements.
+
+```rust
+fn map<U>(self, f: fn(T) -> U) -> [U; N]
+```
+
+example
+
+```rust
+let a = [1, 2, 3];
+let b = a.map(|a| a * 2); // b is now [2, 4, 6]
+```
+
+### fold
+
+Applies a function to each element of the array, returning the final accumulated value. The first
+parameter is the initial value.
+
+```rust
+fn fold<U>(self, mut accumulator: U, f: fn(U, T) -> U) -> U
+```
+
+This is a left fold, so the given function will be applied to the accumulator and first element of
+the array, then the second, and so on. For a given call the expected result would be equivalent to:
+
+```rust
+let a1 = [1];
+let a2 = [1, 2];
+let a3 = [1, 2, 3];
+
+let f = |a, b| a - b;
+a1.fold(10, f)  //=> f(10, 1)
+a2.fold(10, f)  //=> f(f(10, 1), 2)
+a3.fold(10, f)  //=> f(f(f(10, 1), 2), 3)
+```
+
+example:
+
+```rust
+
+fn main() {
+    let arr = [2, 2, 2, 2, 2];
+    let folded = arr.fold(0, |a, b| a + b);
+    assert(folded == 10);
+}
+
+```
+
+### reduce
+
+Same as fold, but uses the first element as the starting element.
+
+Requires `self` to be non-empty.
+
+```rust
+fn reduce(self, f: fn(T, T) -> T) -> T
+```
+
+example:
+
+```rust
+fn main() {
+    let arr = [2, 2, 2, 2, 2];
+    let reduced = arr.reduce(|a, b| a + b);
+    assert(reduced == 10);
+}
+```
+
+### all
+
+Returns true if all the elements satisfy the given predicate
+
+```rust
+fn all(self, predicate: fn(T) -> bool) -> bool
+```
+
+example:
+
+```rust
+fn main() {
+    let arr = [2, 2, 2, 2, 2];
+    let all = arr.all(|a| a == 2);
+    assert(all);
+}
+```
+
+### any
+
+Returns true if any of the elements satisfy the given predicate
+
+```rust
+fn any(self, predicate: fn(T) -> bool) -> bool
+```
+
+example:
+
+```rust
+fn main() {
+    let arr = [2, 2, 2, 2, 5];
+    let any = arr.any(|a| a == 5);
+    assert(any);
+}
+```
+
+### as_str_unchecked
+
+Converts a byte array of type `[u8; N]` to a string. Note that this performs no UTF-8 validation -
+the given array is interpreted as-is as a string.
+
+```rust
+impl<let N: u32> [u8; N] {
+    pub fn as_str_unchecked(self) -> str<N>
+}
+```
+
+example:
+
+```rust
+fn main() {
+    let hi = [104, 105].as_str_unchecked();
+    assert_eq(hi, "hi");
+}
+```
diff --git a/docs/versioned_docs/version-v1.0.0-beta.0/noir/concepts/data_types/booleans.md b/docs/versioned_docs/version-v1.0.0-beta.0/noir/concepts/data_types/booleans.md
new file mode 100644
index 00000000000..2507af710e7
--- /dev/null
+++ b/docs/versioned_docs/version-v1.0.0-beta.0/noir/concepts/data_types/booleans.md
@@ -0,0 +1,28 @@
+---
+title: Booleans
+description:
+  Delve into the Boolean data type in Noir. Understand its methods, practical examples, and best practices for using Booleans in your Noir programs.
+keywords:
+  [
+    noir,
+    boolean type,
+    methods,
+    examples,
+    logical operations,
+  ]
+sidebar_position: 2
+---
+
+
+The `bool` type in Noir has two possible values: `true` and `false`:
+
+```rust
+fn main() {
+    let t = true;
+    let f: bool = false;
+}
+```
+
+The boolean type is most commonly used in conditionals like `if` expressions and `assert`
+statements. More about conditionals is covered in the [Control Flow](../control_flow.md) and
+[Assert Function](../assert.md) sections.
diff --git a/docs/versioned_docs/version-v1.0.0-beta.0/noir/concepts/data_types/fields.md b/docs/versioned_docs/version-v1.0.0-beta.0/noir/concepts/data_types/fields.md
new file mode 100644
index 00000000000..b9b56f7ecc3
--- /dev/null
+++ b/docs/versioned_docs/version-v1.0.0-beta.0/noir/concepts/data_types/fields.md
@@ -0,0 +1,246 @@
+---
+title: Fields
+description:
+  Dive deep into the Field data type in Noir. Understand its methods, practical examples, and best practices to effectively use Fields in your Noir programs.
+keywords:
+  [
+    noir,
+    field type,
+    methods,
+    examples,
+    best practices,
+  ]
+sidebar_position: 0
+---
+
+The field type corresponds to the native field type of the proving backend.
+
+The size of a Noir field depends on the elliptic curve's finite field for the proving backend
+adopted. For example, a field would be a 254-bit integer when paired with the default backend that
+spans the Grumpkin curve.
+
+Fields support integer arithmetic and are often used as the default numeric type in Noir:
+
+```rust
+fn main(x : Field, y : Field)  {
+    let z = x + y;
+}
+```
+
+`x`, `y` and `z` are all private fields in this example. Using the `let` keyword we defined a new
+private value `z` constrained to be equal to `x + y`.
+
+If proving efficiency is of priority, fields should be used as a default for solving problems.
+Smaller integer types (e.g. `u64`) incur extra range constraints.
+
+## Methods
+
+After declaring a Field, you can use these common methods on it:
+
+### to_le_bits
+
+Transforms the field into an array of bits, Little Endian.
+
+```rust title="to_le_bits" showLineNumbers 
+pub fn to_le_bits<let N: u32>(self: Self) -> [u1; N] {}
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/field/mod.nr#L32-L34" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/field/mod.nr#L32-L34</a></sub></sup>
+
+
+example:
+
+```rust title="to_le_bits_example" showLineNumbers 
+fn test_to_le_bits() {
+        let field = 2;
+        let bits: [u1; 8] = field.to_le_bits();
+        assert_eq(bits, [0, 1, 0, 0, 0, 0, 0, 0]);
+    }
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/field/mod.nr#L276-L282" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/field/mod.nr#L276-L282</a></sub></sup>
+
+
+
+### to_be_bits
+
+Transforms the field into an array of bits, Big Endian.
+
+```rust title="to_be_bits" showLineNumbers 
+pub fn to_be_bits<let N: u32>(self: Self) -> [u1; N] {}
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/field/mod.nr#L48-L50" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/field/mod.nr#L48-L50</a></sub></sup>
+
+
+example:
+
+```rust title="to_be_bits_example" showLineNumbers 
+fn test_to_be_bits() {
+        let field = 2;
+        let bits: [u1; 8] = field.to_be_bits();
+        assert_eq(bits, [0, 0, 0, 0, 0, 0, 1, 0]);
+    }
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/field/mod.nr#L267-L273" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/field/mod.nr#L267-L273</a></sub></sup>
+
+
+
+### to_le_bytes
+
+Transforms into an array of bytes, Little Endian
+
+```rust title="to_le_bytes" showLineNumbers 
+pub fn to_le_bytes<let N: u32>(self: Self) -> [u8; N] {
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/field/mod.nr#L61-L63" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/field/mod.nr#L61-L63</a></sub></sup>
+
+
+example:
+
+```rust title="to_le_bytes_example" showLineNumbers 
+fn test_to_le_bytes() {
+        let field = 2;
+        let bytes: [u8; 8] = field.to_le_bytes();
+        assert_eq(bytes, [2, 0, 0, 0, 0, 0, 0, 0]);
+        assert_eq(Field::from_le_bytes::<8>(bytes), field);
+    }
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/field/mod.nr#L295-L302" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/field/mod.nr#L295-L302</a></sub></sup>
+
+
+### to_be_bytes
+
+Transforms into an array of bytes, Big Endian
+
+```rust title="to_be_bytes" showLineNumbers 
+pub fn to_be_bytes<let N: u32>(self: Self) -> [u8; N] {
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/field/mod.nr#L94-L96" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/field/mod.nr#L94-L96</a></sub></sup>
+
+
+example:
+
+```rust title="to_be_bytes_example" showLineNumbers 
+fn test_to_be_bytes() {
+        let field = 2;
+        let bytes: [u8; 8] = field.to_be_bytes();
+        assert_eq(bytes, [0, 0, 0, 0, 0, 0, 0, 2]);
+        assert_eq(Field::from_be_bytes::<8>(bytes), field);
+    }
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/field/mod.nr#L285-L292" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/field/mod.nr#L285-L292</a></sub></sup>
+
+
+
+### to_le_radix
+
+Decomposes into an array over the specified base, Little Endian
+
+```rust title="to_le_radix" showLineNumbers 
+pub fn to_le_radix<let N: u32>(self: Self, radix: u32) -> [u8; N] {
+        // Brillig does not need an immediate radix
+        if !crate::runtime::is_unconstrained() {
+            crate::assert_constant(radix);
+        }
+        self.__to_le_radix(radix)
+    }
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/field/mod.nr#L118-L126" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/field/mod.nr#L118-L126</a></sub></sup>
+
+
+
+example:
+
+```rust title="to_le_radix_example" showLineNumbers 
+fn test_to_le_radix() {
+        let field = 2;
+        let bytes: [u8; 8] = field.to_le_radix(256);
+        assert_eq(bytes, [2, 0, 0, 0, 0, 0, 0, 0]);
+        assert_eq(Field::from_le_bytes::<8>(bytes), field);
+    }
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/field/mod.nr#L315-L322" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/field/mod.nr#L315-L322</a></sub></sup>
+
+
+
+### to_be_radix
+
+Decomposes into an array over the specified base, Big Endian
+
+```rust title="to_be_radix" showLineNumbers 
+pub fn to_be_radix<let N: u32>(self: Self, radix: u32) -> [u8; N] {
+        // Brillig does not need an immediate radix
+        if !crate::runtime::is_unconstrained() {
+            crate::assert_constant(radix);
+        }
+        self.__to_be_radix(radix)
+    }
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/field/mod.nr#L128-L136" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/field/mod.nr#L128-L136</a></sub></sup>
+
+
+example:
+
+```rust title="to_be_radix_example" showLineNumbers 
+fn test_to_be_radix() {
+        let field = 2;
+        let bytes: [u8; 8] = field.to_be_radix(256);
+        assert_eq(bytes, [0, 0, 0, 0, 0, 0, 0, 2]);
+        assert_eq(Field::from_be_bytes::<8>(bytes), field);
+    }
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/field/mod.nr#L305-L312" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/field/mod.nr#L305-L312</a></sub></sup>
+
+
+
+### pow_32
+
+Returns the value to the power of the specified exponent
+
+```rust
+fn pow_32(self, exponent: Field) -> Field
+```
+
+example:
+
+```rust
+fn main() {
+    let field = 2
+    let pow = field.pow_32(4);
+    assert(pow == 16);
+}
+```
+
+### assert_max_bit_size
+
+Adds a constraint to specify that the field can be represented with `bit_size` number of bits
+
+```rust title="assert_max_bit_size" showLineNumbers 
+pub fn assert_max_bit_size<let BIT_SIZE: u32>(self) {
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/field/mod.nr#L10-L12" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/field/mod.nr#L10-L12</a></sub></sup>
+
+
+example:
+
+```rust
+fn main() {
+    let field = 2
+    field.assert_max_bit_size(32);
+}
+```
+
+### sgn0
+
+Parity of (prime) Field element, i.e. sgn0(x mod p) = 0 if x ∈ \{0, ..., p-1\} is even, otherwise sgn0(x mod p) = 1.
+
+```rust
+fn sgn0(self) -> u1
+```
+
+
+### lt
+
+Returns true if the field is less than the other field
+
+```rust
+pub fn lt(self, another: Field) -> bool
+```
diff --git a/docs/versioned_docs/version-v1.0.0-beta.0/noir/concepts/data_types/function_types.md b/docs/versioned_docs/version-v1.0.0-beta.0/noir/concepts/data_types/function_types.md
new file mode 100644
index 00000000000..f6121af17e2
--- /dev/null
+++ b/docs/versioned_docs/version-v1.0.0-beta.0/noir/concepts/data_types/function_types.md
@@ -0,0 +1,26 @@
+---
+title: Function types
+sidebar_position: 10
+---
+
+Noir supports higher-order functions. The syntax for a function type is as follows:
+
+```rust
+fn(arg1_type, arg2_type, ...) -> return_type
+```
+
+Example:
+
+```rust
+fn assert_returns_100(f: fn() -> Field) { // f takes no args and returns a Field
+    assert(f() == 100);
+}
+
+fn main() {
+    assert_returns_100(|| 100); // ok
+    assert_returns_100(|| 150); // fails
+}
+```
+
+A function type also has an optional capture environment - this is necessary to support closures.
+See [Lambdas](../lambdas.md) for more details.
diff --git a/docs/versioned_docs/version-v1.0.0-beta.0/noir/concepts/data_types/index.md b/docs/versioned_docs/version-v1.0.0-beta.0/noir/concepts/data_types/index.md
new file mode 100644
index 00000000000..0f2db2b2d75
--- /dev/null
+++ b/docs/versioned_docs/version-v1.0.0-beta.0/noir/concepts/data_types/index.md
@@ -0,0 +1,126 @@
+---
+title: Data Types
+description:
+  Get a clear understanding of the two categories of Noir data types - primitive types and compound
+  types. Learn about their characteristics, differences, and how to use them in your Noir
+  programming.
+keywords:
+  [
+    noir,
+    data types,
+    primitive types,
+    compound types,
+    private types,
+    public types,
+  ]
+---
+
+Every value in Noir has a type, which determines which operations are valid for it.
+
+All values in Noir are fundamentally composed of `Field` elements. For a more approachable
+developing experience, abstractions are added on top to introduce different data types in Noir.
+
+Noir has two category of data types: primitive types (e.g. `Field`, integers, `bool`) and compound
+types that group primitive types (e.g. arrays, tuples, structs). Each value can either be private or
+public.
+
+## Private & Public Types
+
+A **private value** is known only to the Prover, while a **public value** is known by both the
+Prover and Verifier. Mark values as `private` when the value should only be known to the prover. All
+primitive types (including individual fields of compound types) in Noir are private by default, and
+can be marked public when certain values are intended to be revealed to the Verifier.
+
+> **Note:** For public values defined in Noir programs paired with smart contract verifiers, once
+> the proofs are verified on-chain the values can be considered known to everyone that has access to
+> that blockchain.
+
+Public data types are treated no differently to private types apart from the fact that their values
+will be revealed in proofs generated. Simply changing the value of a public type will not change the
+circuit (where the same goes for changing values of private types as well).
+
+_Private values_ are also referred to as _witnesses_ sometimes.
+
+> **Note:** The terms private and public when applied to a type (e.g. `pub Field`) have a different
+> meaning than when applied to a function (e.g. `pub fn foo() {}`).
+>
+> The former is a visibility modifier for the Prover to interpret if a value should be made known to
+> the Verifier, while the latter is a visibility modifier for the compiler to interpret if a
+> function should be made accessible to external Noir programs like in other languages.
+
+### pub Modifier
+
+All data types in Noir are private by default. Types are explicitly declared as public using the
+`pub` modifier:
+
+```rust
+fn main(x : Field, y : pub Field) -> pub Field {
+    x + y
+}
+```
+
+In this example, `x` is **private** while `y` and `x + y` (the return value) are **public**. Note
+that visibility is handled **per variable**, so it is perfectly valid to have one input that is
+private and another that is public.
+
+> **Note:** Public types can only be declared through parameters on `main`.
+
+## Type Aliases
+
+A type alias is a new name for an existing type. Type aliases are declared with the keyword `type`:
+
+```rust
+type Id = u8;
+
+fn main() {
+    let id: Id = 1;
+    let zero: u8 = 0;
+    assert(zero + 1 == id);
+}
+```
+
+Type aliases can also be used with [generics](../generics.md):
+
+```rust
+type Id<Size> = Size;
+
+fn main() {
+    let id: Id<u32> = 1;
+    let zero: u32 = 0;
+    assert(zero + 1 == id);
+}
+```
+
+Type aliases can even refer to other aliases. An error will be issued if they form a cycle:
+
+```rust
+// Ok!
+type A = B;
+type B = Field;
+
+type Bad1 = Bad2;
+
+// error: Dependency cycle found
+type Bad2 = Bad1;
+//   ^^^^^^^^^^^ 'Bad2' recursively depends on itself: Bad2 -> Bad1 -> Bad2
+```
+
+By default, like functions, type aliases are private to the module they exist in. You can use `pub`
+to make the type alias public or `pub(crate)` to make it public to just its crate:
+
+```rust
+// This type alias is now public
+pub type Id = u8;
+```
+
+## Wildcard Type
+Noir can usually infer the type of the variable from the context, so specifying the type of a variable is only required when it cannot be inferred. However, specifying a complex type can be tedious, especially when it has multiple generic arguments. Often some of the generic types can be inferred from the context, and Noir only needs a hint to properly infer the other types. We can partially specify a variable's type by using `_` as a marker, indicating where we still want the compiler to infer the type.
+
+```rust
+let a: [_; 4] = foo(b);
+```
+ 
+
+### BigInt
+
+You can achieve BigInt functionality using the [Noir BigInt](https://github.com/shuklaayush/noir-bigint) library.
diff --git a/docs/versioned_docs/version-v1.0.0-beta.0/noir/concepts/data_types/integers.md b/docs/versioned_docs/version-v1.0.0-beta.0/noir/concepts/data_types/integers.md
new file mode 100644
index 00000000000..a1d59bf3166
--- /dev/null
+++ b/docs/versioned_docs/version-v1.0.0-beta.0/noir/concepts/data_types/integers.md
@@ -0,0 +1,156 @@
+---
+title: Integers
+description: Explore the Integer data type in Noir. Learn about its methods, see real-world examples, and grasp how to efficiently use Integers in your Noir code.
+keywords: [noir, integer types, methods, examples, arithmetic]
+sidebar_position: 1
+---
+
+An integer type is a range constrained field type.
+The Noir frontend supports both unsigned and signed integer types.
+The allowed sizes are 1, 8, 16, 32 and 64 bits.
+
+:::info
+
+When an integer is defined in Noir without a specific type, it will default to `Field`.
+
+The one exception is for loop indices which default to `u64` since comparisons on `Field`s are not possible.
+
+:::
+
+## Unsigned Integers
+
+An unsigned integer type is specified first with the letter `u` (indicating its unsigned nature) followed by its bit size (e.g. `8`):
+
+```rust
+fn main() {
+    let x: u8 = 1;
+    let y: u8 = 1;
+    let z = x + y;
+    assert (z == 2);
+}
+```
+
+The bit size determines the maximum value the integer type can store. For example, a `u8` variable can store a value in the range of 0 to 255 (i.e. $\\2^{8}-1\\$).
+
+## Signed Integers
+
+A signed integer type is specified first with the letter `i` (which stands for integer) followed by its bit size (e.g. `8`):
+
+```rust
+fn main() {
+    let x: i8 = -1;
+    let y: i8 = -1;
+    let z = x + y;
+    assert (z == -2);
+}
+```
+
+The bit size determines the maximum and minimum range of value the integer type can store. For example, an `i8` variable can store a value in the range of -128 to 127 (i.e. $\\-2^{7}\\$ to $\\2^{7}-1\\$).
+
+## 128 bits Unsigned Integers
+
+The built-in structure `U128` allows you to use 128-bit unsigned integers almost like a native integer type. However, there are some differences to keep in mind:
+- You cannot cast between a native integer and `U128`
+- There is a higher performance cost when using `U128`, compared to a native type.
+
+Conversion between unsigned integer types and U128 are done through the use of `from_integer` and `to_integer` functions. `from_integer` also accepts the `Field` type as input.
+
+```rust
+fn main() {
+    let x = U128::from_integer(23);
+    let y = U128::from_hex("0x7");
+    let z = x + y;
+    assert(z.to_integer() == 30);
+}
+```
+
+`U128` is implemented with two 64 bits limbs, representing the low and high bits, which explains the performance cost. You should expect `U128` to be twice more costly for addition and four times more costly for multiplication.
+You can construct a U128 from its limbs:
+```rust
+fn main(x: u64, y: u64) {
+    let x = U128::from_u64s_be(x,y);
+    assert(z.hi == x as Field);
+    assert(z.lo == y as Field);
+}
+```
+
+Note that the limbs are stored as Field elements in order to avoid unnecessary conversions.
+Apart from this, most operations will work as usual:
+
+```rust
+fn main(x: U128, y: U128) {
+    // multiplication
+    let c = x * y;
+    // addition and subtraction
+    let c = c - x + y;
+    // division
+    let c = x / y;
+    // bit operation;
+    let c = x & y | y;
+    // bit shift
+    let c = x << y;
+    // comparisons;
+    let c = x < y;
+    let c = x == y;
+}
+```
+
+## Overflows
+
+Computations that exceed the type boundaries will result in overflow errors. This happens with both signed and unsigned integers. For example, attempting to prove:
+
+```rust
+fn main(x: u8, y: u8) {
+    let z = x + y;
+}
+```
+
+With:
+
+```toml
+x = "255"
+y = "1"
+```
+
+Would result in:
+
+```
+$ nargo execute
+error: Assertion failed: 'attempt to add with overflow'
+┌─ ~/src/main.nr:9:13
+│
+│     let z = x + y;
+│             -----
+│
+= Call stack:
+  ...
+```
+
+A similar error would happen with signed integers:
+
+```rust
+fn main() {
+    let x: i8 = -118;
+    let y: i8 = -11;
+    let z = x + y;
+}
+```
+
+### Wrapping methods
+
+Although integer overflow is expected to error, some use-cases rely on wrapping. For these use-cases, the standard library provides `wrapping` variants of certain common operations:
+
+```rust
+fn wrapping_add<T>(x: T, y: T) -> T;
+fn wrapping_sub<T>(x: T, y: T) -> T;
+fn wrapping_mul<T>(x: T, y: T) -> T;
+```
+
+Example of how it is used:
+
+```rust
+
+fn main(x: u8, y: u8) -> pub u8 {
+    std::wrapping_add(x, y)
+}
+```
diff --git a/docs/versioned_docs/version-v1.0.0-beta.0/noir/concepts/data_types/references.md b/docs/versioned_docs/version-v1.0.0-beta.0/noir/concepts/data_types/references.md
new file mode 100644
index 00000000000..a5293d11cfb
--- /dev/null
+++ b/docs/versioned_docs/version-v1.0.0-beta.0/noir/concepts/data_types/references.md
@@ -0,0 +1,23 @@
+---
+title: References
+sidebar_position: 9
+---
+
+Noir supports first-class references. References are a bit like pointers: they point to a specific address that can be followed to access the data stored at that address. You can use Rust-like syntax to use pointers in Noir: the `&` operator references the variable, the `*` operator dereferences it.
+
+Example:
+
+```rust
+fn main() {
+    let mut x = 2;
+
+    // you can reference x as &mut and pass it to multiplyBy2
+    multiplyBy2(&mut x);
+}
+
+// you can access &mut here
+fn multiplyBy2(x: &mut Field) {
+    // and dereference it with *
+    *x = *x * 2;
+}
+```
diff --git a/docs/versioned_docs/version-v1.0.0-beta.0/noir/concepts/data_types/slices.mdx b/docs/versioned_docs/version-v1.0.0-beta.0/noir/concepts/data_types/slices.mdx
new file mode 100644
index 00000000000..cfee564a302
--- /dev/null
+++ b/docs/versioned_docs/version-v1.0.0-beta.0/noir/concepts/data_types/slices.mdx
@@ -0,0 +1,358 @@
+---
+title: Slices
+description: Explore the Slice data type in Noir. Understand its methods, see real-world examples, and learn how to effectively use Slices in your Noir programs.
+keywords: [noir, slice type, methods, examples, subarrays]
+sidebar_position: 5
+---
+
+import Experimental from '@site/src/components/Notes/_experimental.mdx';
+
+<Experimental />
+
+A slice is a dynamically-sized view into a sequence of elements. They can be resized at runtime, but because they don't own the data, they cannot be returned from a circuit. You can treat slices as arrays without a constrained size.
+
+```rust
+fn main() -> pub u32 {
+    let mut slice: [Field] = &[0; 2];
+
+    let mut new_slice = slice.push_back(6);
+    new_slice.len()
+}
+```
+
+To write a slice literal, use a preceding ampersand as in: `&[0; 2]` or
+`&[1, 2, 3]`.
+
+It is important to note that slices are not references to arrays. In Noir,
+`&[..]` is more similar to an immutable, growable vector.
+
+View the corresponding test file [here][test-file].
+
+[test-file]: https://github.com/noir-lang/noir/blob/f387ec1475129732f72ba294877efdf6857135ac/crates/nargo_cli/tests/test_data_ssa_refactor/slices/src/main.nr
+
+## Methods
+
+For convenience, the STD provides some ready-to-use, common methods for slices:
+
+### push_back
+
+Pushes a new element to the end of the slice, returning a new slice with a length one greater than the original unmodified slice.
+
+```rust
+fn push_back<T>(_self: [T], _elem: T) -> [T]
+```
+
+example:
+
+```rust
+fn main() -> pub Field {
+    let mut slice: [Field] = &[0; 2];
+
+    let mut new_slice = slice.push_back(6);
+    new_slice.len()
+}
+```
+
+View the corresponding test file [here][test-file].
+
+### push_front
+
+Returns a new array with the specified element inserted at index 0. The existing elements indexes are incremented by 1.
+
+```rust
+fn push_front(_self: Self, _elem: T) -> Self
+```
+
+Example:
+
+```rust
+let mut new_slice: [Field] = &[];
+new_slice = new_slice.push_front(20);
+assert(new_slice[0] == 20); // returns true
+```
+
+View the corresponding test file [here][test-file].
+
+### pop_front
+
+Returns a tuple of two items, the first element of the array and the rest of the array.
+
+```rust
+fn pop_front(_self: Self) -> (T, Self)
+```
+
+Example:
+
+```rust
+let (first_elem, rest_of_slice) = slice.pop_front();
+```
+
+View the corresponding test file [here][test-file].
+
+### pop_back
+
+Returns a tuple of two items, the beginning of the array with the last element omitted and the last element.
+
+```rust
+fn pop_back(_self: Self) -> (Self, T)
+```
+
+Example:
+
+```rust
+let (popped_slice, last_elem) = slice.pop_back();
+```
+
+View the corresponding test file [here][test-file].
+
+### append
+
+Loops over a slice and adds it to the end of another.
+
+```rust
+fn append(mut self, other: Self) -> Self
+```
+
+Example:
+
+```rust
+let append = &[1, 2].append(&[3, 4, 5]);
+```
+
+### insert
+
+Inserts an element at a specified index and shifts all following elements by 1.
+
+```rust
+fn insert(_self: Self, _index: Field, _elem: T) -> Self
+```
+
+Example:
+
+```rust
+new_slice = rest_of_slice.insert(2, 100);
+assert(new_slice[2] == 100);
+```
+
+View the corresponding test file [here][test-file].
+
+### remove
+
+Remove an element at a specified index, shifting all elements after it to the left, returning the altered slice and the removed element.
+
+```rust
+fn remove(_self: Self, _index: Field) -> (Self, T)
+```
+
+Example:
+
+```rust
+let (remove_slice, removed_elem) = slice.remove(3);
+```
+
+### len
+
+Returns the length of a slice
+
+```rust
+fn len(self) -> Field
+```
+
+Example:
+
+```rust
+fn main() {
+    let slice = &[42, 42];
+    assert(slice.len() == 2);
+}
+```
+
+### as_array
+
+Converts this slice into an array.
+
+Make sure to specify the size of the resulting array.
+Panics if the resulting array length is different than the slice's length.
+
+```rust
+fn as_array<let N: u32>(self) -> [T; N]
+```
+
+Example:
+
+```rust
+fn main() {
+    let slice = &[5, 6];
+
+    // Always specify the length of the resulting array!
+    let array: [Field; 2] = slice.as_array();
+
+    assert(array[0] == slice[0]);
+    assert(array[1] == slice[1]);
+}
+```
+
+### map
+
+Applies a function to each element of the slice, returning a new slice containing the mapped elements.
+
+```rust
+fn map<U, Env>(self, f: fn[Env](T) -> U) -> [U]
+```
+
+example
+
+```rust
+let a = &[1, 2, 3];
+let b = a.map(|a| a * 2); // b is now &[2, 4, 6]
+```
+
+### fold
+
+Applies a function to each element of the slice, returning the final accumulated value. The first
+parameter is the initial value.
+
+```rust
+fn fold<U, Env>(self, mut accumulator: U, f: fn[Env](U, T) -> U) -> U
+```
+
+This is a left fold, so the given function will be applied to the accumulator and first element of
+the slice, then the second, and so on. For a given call the expected result would be equivalent to:
+
+```rust
+let a1 = &[1];
+let a2 = &[1, 2];
+let a3 = &[1, 2, 3];
+
+let f = |a, b| a - b;
+a1.fold(10, f)  //=> f(10, 1)
+a2.fold(10, f)  //=> f(f(10, 1), 2)
+a3.fold(10, f)  //=> f(f(f(10, 1), 2), 3)
+```
+
+example:
+
+```rust
+
+fn main() {
+    let slice = &[2, 2, 2, 2, 2];
+    let folded = slice.fold(0, |a, b| a + b);
+    assert(folded == 10);
+}
+
+```
+
+### reduce
+
+Same as fold, but uses the first element as the starting element.
+
+```rust
+fn reduce<Env>(self, f: fn[Env](T, T) -> T) -> T
+```
+
+example:
+
+```rust
+fn main() {
+    let slice = &[2, 2, 2, 2, 2];
+    let reduced = slice.reduce(|a, b| a + b);
+    assert(reduced == 10);
+}
+```
+
+### filter
+
+Returns a new slice containing only elements for which the given predicate returns true.
+
+```rust
+fn filter<Env>(self, f: fn[Env](T) -> bool) -> Self
+```
+
+example:
+
+```rust
+fn main() {
+    let slice = &[1, 2, 3, 4, 5];
+    let odds = slice.filter(|x| x % 2 == 1);
+    assert_eq(odds, &[1, 3, 5]);
+}
+```
+
+### join
+
+Flatten each element in the slice into one value, separated by `separator`.
+
+Note that although slices implement `Append`, `join` cannot be used on slice
+elements since nested slices are prohibited.
+
+```rust
+fn join(self, separator: T) -> T where T: Append
+```
+
+example:
+
+```rust
+struct Accumulator {
+    total: Field,
+}
+
+// "Append" two accumulators by adding them
+impl Append for Accumulator {
+    fn empty() -> Self {
+        Self { total: 0 }
+    }
+
+    fn append(self, other: Self) -> Self {
+        Self { total: self.total + other.total }
+    }
+}
+
+fn main() {
+    let slice = &[1, 2, 3, 4, 5].map(|total| Accumulator { total });
+
+    let result = slice.join(Accumulator::empty());
+    assert_eq(result, Accumulator { total: 15 });
+
+    // We can use a non-empty separator to insert additional elements to sum:
+    let separator = Accumulator { total: 10 };
+    let result = slice.join(separator);
+    assert_eq(result, Accumulator { total: 55 });
+}
+```
+
+### all
+
+Returns true if all the elements satisfy the given predicate
+
+```rust
+fn all<Env>(self, predicate: fn[Env](T) -> bool) -> bool
+```
+
+example:
+
+```rust
+fn main() {
+    let slice = &[2, 2, 2, 2, 2];
+    let all = slice.all(|a| a == 2);
+    assert(all);
+}
+```
+
+### any
+
+Returns true if any of the elements satisfy the given predicate
+
+```rust
+fn any<Env>(self, predicate: fn[Env](T) -> bool) -> bool
+```
+
+example:
+
+```rust
+fn main() {
+    let slice = &[2, 2, 2, 2, 5];
+    let any = slice.any(|a| a == 5);
+    assert(any);
+}
+
+```
diff --git a/docs/versioned_docs/version-v1.0.0-beta.0/noir/concepts/data_types/strings.md b/docs/versioned_docs/version-v1.0.0-beta.0/noir/concepts/data_types/strings.md
new file mode 100644
index 00000000000..1fdee42425e
--- /dev/null
+++ b/docs/versioned_docs/version-v1.0.0-beta.0/noir/concepts/data_types/strings.md
@@ -0,0 +1,79 @@
+---
+title: Strings
+description:
+  Discover the String data type in Noir. Learn about its methods, see real-world examples, and understand how to effectively manipulate and use Strings in Noir.
+keywords:
+  [
+    noir,
+    string type,
+    methods,
+    examples,
+    concatenation,
+  ]
+sidebar_position: 3
+---
+
+
+The string type is a fixed length value defined with `str<N>`.
+
+You can use strings in `assert()` functions or print them with
+`println()`. See more about [Logging](../../standard_library/logging.md).
+
+```rust
+
+fn main(message : pub str<11>, hex_as_string : str<4>) {
+    println(message);
+    assert(message == "hello world");
+    assert(hex_as_string == "0x41");
+}
+```
+
+You can convert a `str<N>` to a byte array by calling `as_bytes()`
+or a vector by calling `as_bytes_vec()`.
+
+```rust
+fn main() {
+    let message = "hello world";
+    let message_bytes = message.as_bytes();
+    let mut message_vec = message.as_bytes_vec();
+    assert(message_bytes.len() == 11);
+    assert(message_bytes[0] == 104);
+    assert(message_bytes[0] == message_vec.get(0));
+}
+```
+
+## Escape characters
+
+You can use escape characters for your strings:
+
+| Escape Sequence | Description     |
+|-----------------|-----------------|
+| `\r`            | Carriage Return |
+| `\n`            | Newline         |
+| `\t`            | Tab             |
+| `\0`            | Null Character  |
+| `\"`            | Double Quote    |
+| `\\`            | Backslash       |
+
+Example:
+
+```rust
+let s = "Hello \"world" // prints "Hello "world"
+let s = "hey \tyou"; // prints "hey   you"
+```
+
+## Raw strings
+
+A raw string begins with the letter `r` and is optionally delimited by a number of hashes `#`.
+
+Escape characters are *not* processed within raw strings. All contents are interpreted literally.
+
+Example:
+
+```rust
+let s = r"Hello world";
+let s = r#"Simon says "hello world""#;
+
+// Any number of hashes may be used (>= 1) as long as the string also terminates with the same number of hashes
+let s = r#####"One "#, Two "##, Three "###, Four "####, Five will end the string."#####; 
+```
diff --git a/docs/versioned_docs/version-v1.0.0-beta.0/noir/concepts/data_types/structs.md b/docs/versioned_docs/version-v1.0.0-beta.0/noir/concepts/data_types/structs.md
new file mode 100644
index 00000000000..29951ae843a
--- /dev/null
+++ b/docs/versioned_docs/version-v1.0.0-beta.0/noir/concepts/data_types/structs.md
@@ -0,0 +1,96 @@
+---
+title: Structs
+description:
+  Explore the Struct data type in Noir. Learn about its methods, see real-world examples, and grasp how to effectively define and use Structs in your Noir programs.
+keywords:
+  [
+    noir,
+    struct type,
+    methods,
+    examples,
+    data structures,
+  ]
+sidebar_position: 8
+---
+
+A struct also allows for grouping multiple values of different types. Unlike tuples, we can also
+name each field.
+
+> **Note:** The usage of _field_ here refers to each element of the struct and is unrelated to the
+> field type of Noir.
+
+Defining a struct requires giving it a name and listing each field within as `<Key>: <Type>` pairs:
+
+```rust
+struct Animal {
+    hands: Field,
+    legs: Field,
+    eyes: u8,
+}
+```
+
+An instance of a struct can then be created with actual values in `<Key>: <Value>` pairs in any
+order. Struct fields are accessible using their given names:
+
+```rust
+fn main() {
+    let legs = 4;
+
+    let dog = Animal {
+        eyes: 2,
+        hands: 0,
+        legs,
+    };
+
+    let zero = dog.hands;
+}
+```
+
+Structs can also be destructured in a pattern, binding each field to a new variable:
+
+```rust
+fn main() {
+    let Animal { hands, legs: feet, eyes } = get_octopus();
+
+    let ten = hands + feet + eyes as u8;
+}
+
+fn get_octopus() -> Animal {
+    let octopus = Animal {
+        hands: 0,
+        legs: 8,
+        eyes: 2,
+    };
+
+    octopus
+}
+```
+
+The new variables can be bound with names different from the original struct field names, as
+showcased in the `legs --> feet` binding in the example above.
+
+### Visibility
+
+By default, like functions, structs are private to the module they exist in. You can use `pub`
+to make the struct public or `pub(crate)` to make it public to just its crate:
+
+```rust
+// This struct is now public
+pub struct Animal {
+    hands: Field,
+    legs: Field,
+    eyes: u8,
+}
+```
+
+The same applies to struct fields: by default they are private to the module they exist in,
+but they can be made `pub` or `pub(crate)`:
+
+```rust
+// This struct is now public
+pub struct Animal {
+    hands: Field,           // private to its module
+    pub(crate) legs: Field, // accessible from the entire crate
+    pub eyes: u8,           // accessible from anywhere
+}
+```
\ No newline at end of file
diff --git a/docs/versioned_docs/version-v1.0.0-beta.0/noir/concepts/data_types/tuples.md b/docs/versioned_docs/version-v1.0.0-beta.0/noir/concepts/data_types/tuples.md
new file mode 100644
index 00000000000..2ec5c9c4113
--- /dev/null
+++ b/docs/versioned_docs/version-v1.0.0-beta.0/noir/concepts/data_types/tuples.md
@@ -0,0 +1,48 @@
+---
+title: Tuples
+description:
+  Dive into the Tuple data type in Noir. Understand its methods, practical examples, and best practices for efficiently using Tuples in your Noir code.
+keywords:
+  [
+    noir,
+    tuple type,
+    methods,
+    examples,
+    multi-value containers,
+  ]
+sidebar_position: 7
+---
+
+A tuple collects multiple values like an array, but with the added ability to collect values of
+different types:
+
+```rust
+fn main() {
+    let tup: (u8, u64, Field) = (255, 500, 1000);
+}
+```
+
+One way to access tuple elements is via destructuring using pattern matching:
+
+```rust
+fn main() {
+    let tup = (1, 2);
+
+    let (one, two) = tup;
+
+    let three = one + two;
+}
+```
+
+Another way to access tuple elements is via direct member access, using a period (`.`) followed by
+the index of the element we want to access. Index `0` corresponds to the first tuple element, `1` to
+the second and so on:
+
+```rust
+fn main() {
+    let tup = (5, 6, 7, 8);
+
+    let five = tup.0;
+    let eight = tup.3;
+}
+```
diff --git a/docs/versioned_docs/version-v1.0.0-beta.0/noir/concepts/functions.md b/docs/versioned_docs/version-v1.0.0-beta.0/noir/concepts/functions.md
new file mode 100644
index 00000000000..f656cdfd97a
--- /dev/null
+++ b/docs/versioned_docs/version-v1.0.0-beta.0/noir/concepts/functions.md
@@ -0,0 +1,226 @@
+---
+title: Functions
+description:
+  Learn how to declare functions and methods in Noir, a programming language with Rust semantics.
+  This guide covers parameter declaration, return types, call expressions, and more.
+keywords: [Noir, Rust, functions, methods, parameter declaration, return types, call expressions]
+sidebar_position: 1
+---
+
+Functions in Noir follow the same semantics of Rust, though Noir does not support early returns.
+
+To declare a function the `fn` keyword is used.
+
+```rust
+fn foo() {}
+```
+
+By default, functions are visible only within the package they are defined. To make them visible outside of that package (for example, as part of a [library](../modules_packages_crates/crates_and_packages.md#libraries)), you should mark them as `pub`:
+
+```rust
+pub fn foo() {}
+```
+
+You can also restrict the visibility of the function to only the crate it was defined in, by specifying `pub(crate)`:
+
+```rust
+pub(crate) fn foo() {}  //foo can only be called within its crate
+```
+
+All parameters in a function must have a type and all types are known at compile time. The parameter
+is pre-pended with a colon and the parameter type. Multiple parameters are separated using a comma.
+
+```rust
+fn foo(x : Field, y : Field){}
+```
+
+The return type of a function can be stated by using the `->` arrow notation. The function below
+states that the foo function must return a `Field`. If the function returns no value, then the arrow
+is omitted.
+
+```rust
+fn foo(x : Field, y : Field) -> Field {
+    x + y
+}
+```
+
+Note that a `return` keyword is unneeded in this case - the last expression in a function's body is
+returned.
+
+## Main function
+
+If you're writing a binary, the `main` function is the starting point of your program. You can pass all types of expressions to it, as long as they have a fixed size at compile time:
+
+```rust
+fn main(x : Field) // this is fine: passing a Field
+fn main(x : [Field; 2]) // this is also fine: passing a Field with known size at compile-time
+fn main(x : (Field, bool)) // 👌: passing a (Field, bool) tuple means size 2
+fn main(x : str<5>) // this is fine, as long as you pass a string of size 5
+
+fn main(x : Vec<Field>) // can't compile, has variable size
+fn main(x : [Field]) // can't compile, has variable size
+fn main(....// i think you got it by now
+```
+
+Keep in mind [tests](../../tooling/testing.md) don't differentiate between `main` and any other function. The following snippet passes tests, but won't compile or prove:
+
+```rust
+fn main(x : [Field]) {
+    assert(x[0] == 1);
+}
+
+#[test]
+fn test_one() {
+    main(&[1, 2]);
+}
+```
+
+```bash
+$ nargo test
+[testing] Running 1 test functions
+[testing] Testing test_one... ok
+[testing] All tests passed
+
+$ nargo check
+The application panicked (crashed).
+Message:  Cannot have variable sized arrays as a parameter to main
+```
+
+## Call Expressions
+
+Calling a function in Noir is executed by using the function name and passing in the necessary
+arguments.
+
+Below we show how to call the `foo` function from the `main` function using a call expression:
+
+```rust
+fn main(x : Field, y : Field) {
+    let z = foo(x);
+}
+
+fn foo(x : Field) -> Field {
+    x + x
+}
+```
+
+## Methods
+
+You can define methods in Noir on any struct type in scope.
+
+```rust
+struct MyStruct {
+    foo: Field,
+    bar: Field,
+}
+
+impl MyStruct {
+    fn new(foo: Field) -> MyStruct {
+        MyStruct {
+            foo,
+            bar: 2,
+        }
+    }
+
+    fn sum(self) -> Field {
+        self.foo + self.bar
+    }
+}
+
+fn main() {
+    let s = MyStruct::new(40);
+    assert(s.sum() == 42);
+}
+```
+
+Methods are just syntactic sugar for functions, so if we wanted to we could also call `sum` as
+follows:
+
+```rust
+assert(MyStruct::sum(s) == 42);
+```
+
+It is also possible to specialize which method is chosen depending on the [generic](./generics.md) type that is used. In this example, the `foo` function returns different values depending on its type:
+
+```rust
+struct Foo<T> {}
+
+impl Foo<u32> {
+    fn foo(self) -> Field { 1 }
+}
+
+impl Foo<u64> {
+    fn foo(self) -> Field { 2 }
+}
+
+fn main() {
+    let f1: Foo<u32> = Foo{};
+    let f2: Foo<u64> = Foo{};
+    assert(f1.foo() + f2.foo() == 3);
+}
+```
+
+Also note that impls with the same method name defined in them cannot overlap. For example, if we already have `foo` defined for `Foo<u32>` and `Foo<u64>` like we do above, we cannot also define `foo` in an `impl<T> Foo<T>` since it would be ambiguous which version of `foo` to choose.
+
+```rust
+// Including this impl in the same project as the above snippet would
+// cause an overlapping impls error
+impl<T> Foo<T> {
+    fn foo(self) -> Field { 3 }
+}
+```
+
+## Lambdas
+
+Lambdas are anonymous functions. They follow the syntax of Rust - `|arg1, arg2, ..., argN| return_expression`.
+
+```rust
+let add_50 = |val| val + 50;
+assert(add_50(100) == 150);
+```
+
+See [Lambdas](./lambdas.md) for more details.
+
+## Attributes
+
+Attributes are metadata that can be applied to a function, using the following syntax: `#[attribute(value)]`.
+
+Supported attributes include:
+
+- **builtin**: the function is implemented by the compiler, for efficiency purposes.
+- **deprecated**: mark the function as _deprecated_. Calling the function will generate a warning: `warning: use of deprecated function`
+- **field**: Used to enable conditional compilation of code depending on the field size. See below for more details
+- **oracle**: mark the function as _oracle_; meaning it is an external unconstrained function, implemented in noir_js. See [Unconstrained](./unconstrained.md) and [NoirJS](../../reference/NoirJS/noir_js/index.md) for more details.
+- **test**: mark the function as unit tests. See [Tests](../../tooling/testing.md) for more details
+
+### Field Attribute
+
+The field attribute defines which field the function is compatible for. The function is conditionally compiled, under the condition that the field attribute matches the Noir native field.
+The field can be defined implicitly, by using the name of the elliptic curve usually associated to it - for instance bn254, bls12_381 - or explicitly by using the field (prime) order, in decimal or hexadecimal form.
+As a result, it is possible to define multiple versions of a function with each version specialized for a different field attribute. This can be useful when a function requires different parameters depending on the underlying elliptic curve.
+
+Example: we define the function `foo()` three times below. Once for the default Noir bn254 curve, once for the field $\mathbb F_{23}$, which will normally never be used by Noir, and once again for the bls12_381 curve.
+
+```rust
+#[field(bn254)]
+fn foo() -> u32 {
+    1
+}
+
+#[field(23)]
+fn foo() -> u32 {
+    2
+}
+
+// This commented code would not compile as foo would be defined twice because it is the same field as bn254
+// #[field(21888242871839275222246405745257275088548364400416034343698204186575808495617)]
+// fn foo() -> u32 {
+//     2
+// }
+
+#[field(bls12_381)]
+fn foo() -> u32 {
+    3
+}
+```
+
+If the field name is not known to Noir, it will discard the function. Field names are case insensitive.
diff --git a/docs/versioned_docs/version-v1.0.0-beta.0/noir/concepts/generics.md b/docs/versioned_docs/version-v1.0.0-beta.0/noir/concepts/generics.md
new file mode 100644
index 00000000000..c180a0ce7e6
--- /dev/null
+++ b/docs/versioned_docs/version-v1.0.0-beta.0/noir/concepts/generics.md
@@ -0,0 +1,251 @@
+---
+title: Generics
+description: Learn how to use Generics in Noir
+keywords: [Noir, Rust, generics, functions, structs]
+sidebar_position: 7
+---
+
+Generics allow you to use the same functions with multiple different concrete data types. You can
+read more about the concept of generics in the Rust documentation
+[here](https://doc.rust-lang.org/book/ch10-01-syntax.html).
+
+Here is a trivial example showing the identity function that supports any type. In Rust, it is
+common to refer to the most general type as `T`. We follow the same convention in Noir.
+
+```rust
+fn id<T>(x: T) -> T  {
+    x
+}
+```
+
+## Numeric Generics
+
+If we want to be generic over array lengths (which are type-level integers), we can use numeric
+generics. Using these looks similar to using regular generics, but introducing them into scope
+requires declaring them with `let MyGenericName: IntegerType`. This can be done anywhere a normal
+generic is declared. Instead of types, these generics resolve to integers at compile-time.
+Here's an example of a struct that is generic over the size of the array it contains internally:
+
+```rust
+struct BigInt<let N: u32> {
+    limbs: [u32; N],
+}
+
+impl<let N: u32> BigInt<N> {
+    // `N` is in scope of all methods in the impl
+    fn first(first: BigInt<N>, second: BigInt<N>) -> Self {
+        assert(first.limbs != second.limbs);
+        first
+
+    fn second(first: BigInt<N>, second: Self) -> Self {
+        assert(first.limbs != second.limbs);
+        second
+    }
+}
+```
+
+## In Structs
+
+Generics are useful for specifying types in structs. For example, we can specify that a field in a
+struct will be of a certain generic type. In this case `value` is of type `T`.
+
+```rust
+struct RepeatedValue<T> {
+    value: T,
+    count: Field,
+}
+
+impl<T> RepeatedValue<T> {
+    fn print(self) {
+        for _i in 0 .. self.count {
+            println(self.value);
+        }
+    }
+}
+
+fn main() {
+    let repeated = RepeatedValue { value: "Hello!", count: 2 };
+    repeated.print();
+}
+```
+
+The `print` function will print `Hello!` an arbitrary number of times, twice in this case.
+
+## Calling functions on generic parameters
+
+Since a generic type `T` can represent any type, how can we call functions on the underlying type?
+In other words, how can we go from "any type `T`" to "any type `T` that has certain methods available?"
+
+This is what [traits](../concepts/traits.md) are for in Noir. Here's an example of a function generic over
+any type `T` that implements the `Eq` trait for equality:
+
+```rust
+fn first_element_is_equal<T, let N: u32>(array1: [T; N], array2: [T; N]) -> bool 
+    where T: Eq
+{
+    if (array1.len() == 0) | (array2.len() == 0) {
+        true
+    } else {
+        array1[0] == array2[0]
+    }
+}
+
+fn main() {
+    assert(first_element_is_equal([1, 2, 3], [1, 5, 6]));
+
+    // We can use first_element_is_equal for arrays of any type
+    // as long as we have an Eq impl for the types we pass in
+    let array = [MyStruct::new(), MyStruct::new()];
+    assert(array_eq(array, array, MyStruct::eq));
+}
+
+impl Eq for MyStruct {
+    fn eq(self, other: MyStruct) -> bool {
+        self.foo == other.foo
+    }
+}
+```
+
+You can find more details on traits and trait implementations on the [traits page](../concepts/traits.md).
+
+## Manually Specifying Generics with the Turbofish Operator
+
+There are times when the compiler cannot reasonably infer what type should be used for a generic, or when the developer themselves may want to manually distinguish generic type parameters. This is where the `::<>` turbofish operator comes into play.
+
+The `::<>` operator can follow a variable or path and can be used to manually specify generic arguments within the angle brackets.
+The name "turbofish" comes from that `::<>` looks like a little fish.
+
+Examples:
+```rust
+fn main() {
+    let mut slice = [];
+    slice = slice.push_back(1);
+    slice = slice.push_back(2);
+    // Without turbofish a type annotation would be needed on the left hand side
+    let array = slice.as_array::<2>();
+}
+```
+
+
+```rust
+trait MyTrait {
+    fn ten() -> Self;
+}
+
+impl MyTrait for Field {
+    fn ten() -> Self { 10 }
+}
+
+struct Foo<T> {
+    inner: T
+}
+        
+impl<T> Foo<T> {
+    fn generic_method<U>(_self: Self) -> U where U: MyTrait {
+        U::ten()
+    }
+}
+        
+fn example() {
+    let foo: Foo<Field> = Foo { inner: 1 };
+    // Using a type other than `Field` here (e.g. u32) would fail as 
+    // there is no matching impl for `u32: MyTrait`. 
+    //
+    // Substituting the `10` on the left hand side of this assert
+    // with `10 as u32` would also fail with a type mismatch as we 
+    // are expecting a `Field` from the right hand side.
+    assert(10 as u32 == foo.generic_method::<Field>());
+}
+```
+
+## Arithmetic Generics
+
+In addition to numeric generics, Noir also allows a limited form of arithmetic on generics.
+When you have a numeric generic such as `N`, you can use the following operators on it in a
+type position: `+`, `-`, `*`, `/`, and `%`.
+
+Note that type checking arithmetic generics is a best effort guess from the compiler and there
+are many cases of types that are equal that the compiler may not see as such. For example,
+we know that `T * (N + M)` should be equal to `T*N + T*M` but the compiler does not currently
+apply the distributive law and thus sees these as different types.
+
+Even with this limitation though, the compiler can handle common cases decently well:
+
+```rust
+trait Serialize<let N: u32> {
+    fn serialize(self) -> [Field; N];
+}
+
+impl Serialize<1> for Field {
+    fn serialize(self) -> [Field; 1] {
+        [self]
+    }
+}
+
+impl<T, let N: u32, let M: u32> Serialize<N * M> for [T; N]
+    where T: Serialize<M> { .. }
+
+impl<T, U, let N: u32, let M: u32> Serialize<N + M> for (T, U)
+    where T: Serialize<N>, U: Serialize<M> { .. }
+
+fn main() {
+    let data = (1, [2, 3, 4]);
+    assert_eq(data.serialize().len(), 4);
+}
+```
+
+Note that if there is any over or underflow the types will fail to unify:
+
+```rust title="underflow-example" showLineNumbers 
+fn pop<let N: u32>(array: [Field; N]) -> [Field; N - 1] {
+    let mut result: [Field; N - 1] = std::mem::zeroed();
+    for i in 0..N - 1 {
+        result[i] = array[i];
+    }
+    result
+}
+
+fn main() {
+    // error: Could not determine array length `(0 - 1)`
+    pop([]);
+}
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/test_programs/compile_failure/arithmetic_generics_underflow/src/main.nr#L1-L14" target="_blank" rel="noopener noreferrer">Source code: test_programs/compile_failure/arithmetic_generics_underflow/src/main.nr#L1-L14</a></sub></sup>
+
+
+This also applies if there is underflow in an intermediate calculation:
+
+```rust title="intermediate-underflow-example" showLineNumbers 
+fn main() {
+    // From main it looks like there's nothing sketchy going on
+    seems_fine([]);
+}
+
+// Since `seems_fine` says it can receive and return any length N
+fn seems_fine<let N: u32>(array: [Field; N]) -> [Field; N] {
+    // But inside `seems_fine` we pop from the array which
+    // requires the length to be greater than zero.
+
+    // error: Could not determine array length `(0 - 1)`
+    push_zero(pop(array))
+}
+
+fn pop<let N: u32>(array: [Field; N]) -> [Field; N - 1] {
+    let mut result: [Field; N - 1] = std::mem::zeroed();
+    for i in 0..N - 1 {
+        result[i] = array[i];
+    }
+    result
+}
+
+fn push_zero<let N: u32>(array: [Field; N]) -> [Field; N + 1] {
+    let mut result: [Field; N + 1] = std::mem::zeroed();
+    for i in 0..N {
+        result[i] = array[i];
+    }
+    // index N is already zeroed
+    result
+}
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/test_programs/compile_failure/arithmetic_generics_intermediate_underflow/src/main.nr#L1-L32" target="_blank" rel="noopener noreferrer">Source code: test_programs/compile_failure/arithmetic_generics_intermediate_underflow/src/main.nr#L1-L32</a></sub></sup>
+
diff --git a/docs/versioned_docs/version-v1.0.0-beta.0/noir/concepts/globals.md b/docs/versioned_docs/version-v1.0.0-beta.0/noir/concepts/globals.md
new file mode 100644
index 00000000000..c64b6c53746
--- /dev/null
+++ b/docs/versioned_docs/version-v1.0.0-beta.0/noir/concepts/globals.md
@@ -0,0 +1,82 @@
+---
+title: Global Variables
+description:
+  Learn about global variables in Noir. Discover how
+  to declare, modify, and use them in your programs.
+keywords: [noir programming language, globals, global variables, constants]
+sidebar_position: 8
+---
+
+## Globals
+
+
+Noir supports global variables. The global's type must be specified by the user:
+
+```rust
+global N: Field = 5;
+
+global TUPLE: (Field, Field) = (3, 2);
+
+fn main() {
+    assert(N == 5);
+    assert(N == TUPLE.0 + TUPLE.1);
+}
+```
+
+:::info
+
+Globals can be defined as any expression, so long as they don't depend on themselves - otherwise there would be a dependency cycle! For example:
+
+```rust
+global T: u32 = foo(T); // dependency error
+```
+
+:::
+
+
+If they are initialized to a literal integer, globals can be used to specify an array's length:
+
+```rust
+global N: u32 = 2;
+
+fn main(y : [Field; N]) {
+    assert(y[0] == y[1])
+}
+```
+
+A global from another module can be imported or referenced externally like any other name:
+
+```rust
+global N: Field = 20;
+
+fn main() {
+    assert(my_submodule::N != N);
+}
+
+mod my_submodule {
+    global N: Field = 10;
+}
+```
+
+When a global is used, Noir replaces the name with its definition on each occurrence.
+This means globals defined using function calls will repeat the call each time they're used:
+
+```rust
+global RESULT: [Field; 100] = foo();
+
+fn foo() -> [Field; 100] { ... }
+```
+
+This is usually fine since Noir will generally optimize any function call that does not
+refer to a program input into a constant. It should be kept in mind however, if the called
+function performs side-effects like `println`, as these will still occur on each use.
+
+### Visibility
+
+By default, like functions, globals are private to the module they exist in. You can use `pub`
+to make the global public or `pub(crate)` to make it public to just its crate:
+
+```rust
+// This global is now public
+pub global N: u32 = 5;
+```
diff --git a/docs/versioned_docs/version-v1.0.0-beta.0/noir/concepts/lambdas.md b/docs/versioned_docs/version-v1.0.0-beta.0/noir/concepts/lambdas.md
new file mode 100644
index 00000000000..be3c7e0b5ca
--- /dev/null
+++ b/docs/versioned_docs/version-v1.0.0-beta.0/noir/concepts/lambdas.md
@@ -0,0 +1,81 @@
+---
+title: Lambdas
+description: Learn how to use anonymous functions in Noir programming language.
+keywords: [Noir programming language, lambda, closure, function, anonymous function]
+sidebar_position: 9
+---
+
+## Introduction
+
+Lambdas are anonymous functions. The syntax is `|arg1, arg2, ..., argN| return_expression`.
+
+```rust
+let add_50 = |val| val + 50;
+assert(add_50(100) == 150);
+```
+
+A block can be used as the body of a lambda, allowing you to declare local variables inside it:
+
+```rust
+let cool = || {
+  let x = 100;
+  let y = 100;
+  x + y
+}
+
+assert(cool() == 200);
+```
+
+## Closures
+
+Inside the body of a lambda, you can use variables defined in the enclosing function. Such lambdas are called **closures**. In this example `x` is defined inside `main` and is accessed from within the lambda:
+
+```rust
+fn main() {
+  let x = 100;
+  let closure = || x + 150;
+  assert(closure() == 250);
+}
+```
+
+## Passing closures to higher-order functions
+
+It may catch you by surprise that the following code fails to compile:
+
+```rust
+fn foo(f: fn () -> Field) -> Field {
+ f()
+}
+
+fn main() {
+  let (x, y) = (50, 50);
+  assert(foo(|| x + y) == 100); // error :(
+}
+```
+
+The reason is that the closure's capture environment affects its type - we have a closure that captures two Fields and `foo`
+expects a regular function as an argument - those are incompatible.
+:::note
+
+Variables contained within the `||` are the closure's parameters, and the expression that follows it is the closure's body. The capture environment is comprised of any variables used in the closure's body that are not parameters.
+
+E.g. in |x| x + y, y would be a captured variable, but x would not be, since it is a parameter of the closure.
+
+:::
+The syntax for the type of a closure is `fn[env](args) -> ret_type`, where `env` is the capture environment of the closure -
+in this example that's `(Field, Field)`.
+
+The best solution in our case is to make `foo` generic over the environment type of its parameter, so that it can be called
+with closures with any environment, as well as with regular functions:
+
+```rust
+fn foo<Env>(f: fn[Env]() -> Field) -> Field {
+ f()
+}
+
+fn main() {
+  let (x, y) = (50, 50);
+  assert(foo(|| x + y) == 100); // compiles fine
+  assert(foo(|| 60) == 60);     // compiles fine
+}
+```
diff --git a/docs/versioned_docs/version-v1.0.0-beta.0/noir/concepts/mutability.md b/docs/versioned_docs/version-v1.0.0-beta.0/noir/concepts/mutability.md
new file mode 100644
index 00000000000..fdeef6a87c5
--- /dev/null
+++ b/docs/versioned_docs/version-v1.0.0-beta.0/noir/concepts/mutability.md
@@ -0,0 +1,121 @@
+---
+title: Mutability
+description:
+  Learn about mutable variables in Noir. Discover how
+  to declare, modify, and use them in your programs.
+keywords: [noir programming language, mutability in noir, mutable variables]
+sidebar_position: 8
+---
+
+Variables in noir can be declared mutable via the `mut` keyword. Mutable variables can be reassigned
+to via an assignment expression.
+
+```rust
+let x = 2;
+x = 3; // error: x must be mutable to be assigned to
+
+let mut y = 3;
+let y = 4; // OK
+```
+
+The `mut` modifier can also apply to patterns:
+
+```rust
+let (a, mut b) = (1, 2);
+a = 11; // error: a must be mutable to be assigned to
+b = 12; // OK
+
+let mut (c, d) = (3, 4);
+c = 13; // OK
+d = 14; // OK
+
+// etc.
+let MyStruct { x: mut y } = MyStruct { x: a };
+// y is now in scope
+```
+
+Note that mutability in noir is local and everything is passed by value, so if a called function
+mutates its parameters then the parent function will keep the old value of the parameters.
+
+```rust
+fn main() -> pub Field {
+    let x = 3;
+    helper(x);
+    x // x is still 3
+}
+
+fn helper(mut x: i32) {
+    x = 4;
+}
+```
+
+## Non-local mutability
+
+Non-local mutability can be achieved through the mutable reference type `&mut T`:
+
+```rust
+fn set_to_zero(x: &mut Field) {
+    *x = 0;
+}
+
+fn main() {
+    let mut y = 42;
+    set_to_zero(&mut y);
+    assert(*y == 0);
+}
+```
+
+When creating a mutable reference, the original variable being referred to (`y` in this
+example) must also be mutable. Since mutable references are a reference type, they must
+be explicitly dereferenced via `*` to retrieve the underlying value. Note that this yields
+a copy of the value, so mutating this copy will not change the original value behind the
+reference:
+
+```rust
+fn main() {
+    let mut x = 1;
+    let x_ref = &mut x;
+
+    let mut y = *x_ref;
+    let y_ref = &mut y;
+
+    x = 2;
+    *x_ref = 3;
+
+    y = 4;
+    *y_ref = 5;
+
+    assert(x == 3);
+    assert(*x_ref == 3);
+    assert(y == 5);
+    assert(*y_ref == 5);
+}
+```
+
+Note that types in Noir are actually deeply immutable so the copy that occurs when
+dereferencing is only a conceptual copy - no additional constraints will occur.
+
+Mutable references can also be stored within structs. Note that there is also
+no lifetime parameter on these unlike rust. This is because the allocated memory
+always lasts the entire program - as if it were an array of one element.
+
+```rust
+struct Foo {
+    x: &mut Field
+}
+
+impl Foo {
+    fn incr(mut self) {
+        *self.x += 1;
+    }
+}
+
+fn main() {
+    let foo = Foo { x: &mut 0 };
+    foo.incr();
+    assert(*foo.x == 1);
+}
+```
+
+In general, you should avoid non-local & shared mutability unless it is needed. Sticking
+to only local mutability will improve readability and potentially improve compiler optimizations as well.
diff --git a/docs/versioned_docs/version-v1.0.0-beta.0/noir/concepts/ops.md b/docs/versioned_docs/version-v1.0.0-beta.0/noir/concepts/ops.md
new file mode 100644
index 00000000000..c35c36c38a9
--- /dev/null
+++ b/docs/versioned_docs/version-v1.0.0-beta.0/noir/concepts/ops.md
@@ -0,0 +1,98 @@
+---
+title: Logical Operations
+description:
+  Learn about the supported arithmetic and logical operations in the Noir programming language.
+  Discover how to perform operations on private input types, integers, and booleans.
+keywords:
+  [
+    Noir programming language,
+    supported operations,
+    arithmetic operations,
+    logical operations,
+    predicate operators,
+    bitwise operations,
+    short-circuiting,
+    backend,
+  ]
+sidebar_position: 3
+---
+
+# Operations
+
+## Table of Supported Operations
+
+| Operation |                          Description                           |                           Requirements |
+| :-------- | :------------------------------------------------------------: | -------------------------------------: |
+| +         |             Adds two private input types together              |            Types must be private input |
+| -         |           Subtracts two private input types together           |            Types must be private input |
+| \*        |          Multiplies two private input types together           |            Types must be private input |
+| /         |            Divides two private input types together            |            Types must be private input |
+| ^         |              XOR two private input types together              |                  Types must be integer |
+| &         |              AND two private input types together              |                  Types must be integer |
+| \|        |              OR two private input types together               |                  Types must be integer |
+| \<\<        |        Left shift an integer by another integer amount         | Types must be integer, shift must be u8 |
+| >>        |        Right shift an integer by another integer amount        | Types must be integer, shift must be u8 |
+| !         |                     Bitwise not of a value                     |        Type must be integer or boolean |
+| \<         |       returns a bool if one value is less than the other       | Upper bound must have a known bit size |
+| \<=        | returns a bool if one value is less than or equal to the other | Upper bound must have a known bit size |
+| >         |       returns a bool if one value is more than the other       | Upper bound must have a known bit size |
+| >=        | returns a bool if one value is more than or equal to the other | Upper bound must have a known bit size |
+| ==        |       returns a bool if one value is equal to the other        |       Both types must not be constants |
+| !=        |     returns a bool if one value is not equal to the other      |       Both types must not be constants |
+
+### Predicate Operators
+
+`<,<=, !=, == , >, >=` are known as predicate/comparison operations because they compare two values.
+This differs from the operations such as `+` where the operands are used in _computation_.
+
+### Bitwise Operations Example
+
+```rust
+fn main(x : Field) {
+    let y = x as u32;
+    let z = y & y;
+}
+```
+
+`z` is implicitly constrained to be the result of `y & y`. The `&` operand is used to denote bitwise
+`&`.
+
+> `x & x` would not compile as `x` is a `Field` and not an integer type.
+
+### Logical Operators
+
+Noir has no support for the logical operators `||` and `&&`. This is because encoding the
+short-circuiting that these operators require can be inefficient for Noir's backend. Instead you can
+use the bitwise operators `|` and `&` which operate identically for booleans, just without the
+short-circuiting.
+
+```rust
+let my_val = 5;
+
+let mut flag = 1;
+if (my_val > 6) | (my_val == 0) {
+    flag = 0;
+}
+assert(flag == 1);
+
+if (my_val != 10) & (my_val < 50) {
+    flag = 0;
+}
+assert(flag == 0);
+```
+
+### Shorthand operators
+
+Noir shorthand operators for most of the above operators, namely `+=, -=, *=, /=, %=, &=, |=, ^=, <<=`, and `>>=`. These allow for more concise syntax. For example:
+
+```rust
+let mut i = 0;
+i = i + 1;
+```
+
+could be written as:
+
+```rust
+let mut i = 0;
+i += 1;
+```
diff --git a/docs/versioned_docs/version-v1.0.0-beta.0/noir/concepts/oracles.mdx b/docs/versioned_docs/version-v1.0.0-beta.0/noir/concepts/oracles.mdx
new file mode 100644
index 00000000000..77a2ac1550a
--- /dev/null
+++ b/docs/versioned_docs/version-v1.0.0-beta.0/noir/concepts/oracles.mdx
@@ -0,0 +1,29 @@
+---
+title: Oracles
+description: Dive into how Noir supports Oracles via RPC calls, and learn how to declare an Oracle in Noir with our comprehensive guide.
+keywords:
+  - Noir
+  - Oracles
+  - RPC Calls
+  - Unconstrained Functions
+  - Programming
+  - Blockchain
+sidebar_position: 6
+---
+
+import Experimental from '@site/src/components/Notes/_experimental.mdx';
+
+<Experimental />
+
+Noir has support for Oracles via RPC calls. This means Noir will make an RPC call and use the return value for proof generation.
+
+Since Oracles are not resolved by Noir, they are [`unconstrained` functions](./unconstrained.md)
+
+You can declare an Oracle through the `#[oracle(<name>)]` flag. Example:
+
+```rust
+#[oracle(get_number_sequence)]
+unconstrained fn get_number_sequence(_size: Field) -> [Field] {}
+```
+
+The timeout for when using an external RPC oracle resolver can be set with the `NARGO_FOREIGN_CALL_TIMEOUT` environment variable. This timeout is in units of milliseconds.
diff --git a/docs/versioned_docs/version-v1.0.0-beta.0/noir/concepts/shadowing.md b/docs/versioned_docs/version-v1.0.0-beta.0/noir/concepts/shadowing.md
new file mode 100644
index 00000000000..5ce6130d201
--- /dev/null
+++ b/docs/versioned_docs/version-v1.0.0-beta.0/noir/concepts/shadowing.md
@@ -0,0 +1,44 @@
+---
+title: Shadowing
+sidebar_position: 12
+---
+
+Noir allows for inheriting variables' values and re-declaring them with the same name similar to Rust, known as shadowing.
+
+For example, the following function is valid in Noir:
+
+```rust
+fn main() {
+    let x = 5;
+
+    {
+        let x = x * 2;
+        assert (x == 10);
+    }
+
+    assert (x == 5);
+}
+```
+
+In this example, a variable x is first defined with the value 5.
+
+The local scope that follows shadows the original x, i.e. creates a local mutable x based on the value of the original x. It is given a value of 2 times the original x.
+
+When we return to the main scope, x once again refers to just the original x, which stays at the value of 5.
+
+## Temporal mutability
+
+One way that shadowing is useful, in addition to ergonomics across scopes, is for temporarily mutating variables.
+
+```rust
+fn main() {
+    let age = 30;
+    // age = age + 5; // Would error as `age` is immutable by default.
+
+    let mut age = age + 5; // Temporarily mutates `age` with a new value.
+
+    let age = age; // Locks `age`'s mutability again.
+
+    assert (age == 35);
+}
+```
diff --git a/docs/versioned_docs/version-v1.0.0-beta.0/noir/concepts/traits.md b/docs/versioned_docs/version-v1.0.0-beta.0/noir/concepts/traits.md
new file mode 100644
index 00000000000..b6c0a886eb0
--- /dev/null
+++ b/docs/versioned_docs/version-v1.0.0-beta.0/noir/concepts/traits.md
@@ -0,0 +1,584 @@
+---
+title: Traits
+description:
+  Traits in Noir can be used to abstract out a common interface for functions across
+  several data types.
+keywords: [noir programming language, traits, interfaces, generic, protocol]
+sidebar_position: 14
+---
+
+## Overview
+
+Traits in Noir are a useful abstraction similar to interfaces or protocols in other languages. Each trait defines
+the interface of several methods contained within the trait. Types can then implement this trait by providing
+implementations for these methods. For example in the program:
+
+```rust
+struct Rectangle {
+    width: Field,
+    height: Field,
+}
+
+impl Rectangle {
+    fn area(self) -> Field {
+        self.width * self.height
+    }
+}
+
+fn log_area(r: Rectangle) {
+    println(r.area());
+}
+```
+
+We have a function `log_area` to log the area of a `Rectangle`. Now how should we change the program if we want this
+function to work on `Triangle`s as well?:
+
+```rust
+struct Triangle {
+    width: Field,
+    height: Field,
+}
+
+impl Triangle {
+    fn area(self) -> Field {
+        self.width * self.height / 2
+    }
+}
+```
+
+Making `log_area` generic over all types `T` would be invalid since not all types have an `area` method. Instead, we can
+introduce a new `Area` trait and make `log_area` generic over all types `T` that implement `Area`:
+
+```rust
+trait Area {
+    fn area(self) -> Field;
+}
+
+fn log_area<T>(shape: T) where T: Area {
+    println(shape.area());
+}
+```
+
+We also need to explicitly implement `Area` for `Rectangle` and `Triangle`. We can do that by changing their existing
+impls slightly. Note that the parameter types and return type of each of our `area` methods must match those defined
+by the `Area` trait.
+
+```rust
+impl Area for Rectangle {
+    fn area(self) -> Field {
+        self.width * self.height
+    }
+}
+
+impl Area for Triangle {
+    fn area(self) -> Field {
+        self.width * self.height / 2
+    }
+}
+```
+
+Now we have a working program that is generic over any type of Shape that is used! Others can even use this program
+as a library with their own types - such as `Circle` - as long as they also implement `Area` for these types.
+
+## Where Clauses
+
+As seen in `log_area` above, when we want to create a function or method that is generic over any type that implements
+a trait, we can add a where clause to the generic function.
+
+```rust
+fn log_area<T>(shape: T) where T: Area {
+    println(shape.area());
+}
+```
+
+It is also possible to apply multiple trait constraints on the same variable at once by combining traits with the `+`
+operator. Similarly, we can have multiple trait constraints by separating each with a comma:
+
+```rust
+fn foo<T, U>(elements: [T], thing: U) where
+    T: Default + Add + Eq,
+    U: Bar,
+{
+    let mut sum = T::default();
+
+    for element in elements {
+        sum += element;
+    }
+
+    if sum == T::default() {
+        thing.bar();
+    }
+}
+```
+
+## Generic Implementations
+
+You can add generics to a trait implementation by adding the generic list after the `impl` keyword:
+
+```rust
+trait Second {
+    fn second(self) -> Field;
+}
+
+impl<T> Second for (T, Field) {
+    fn second(self) -> Field {
+        self.1
+    }
+}
+```
+
+You can also implement a trait for every type this way:
+
+```rust
+trait Debug {
+    fn debug(self);
+}
+
+impl<T> Debug for T {
+    fn debug(self) {
+        println(self);
+    }
+}
+
+fn main() {
+    1.debug();
+}
+```
+
+### Generic Trait Implementations With Where Clauses
+
+Where clauses can be placed on trait implementations themselves to restrict generics in a similar way.
+For example, while `impl<T> Foo for T` implements the trait `Foo` for every type, `impl<T> Foo for T where T: Bar`
+will implement `Foo` only for types that also implement `Bar`. This is often used for implementing generic types.
+For example, here is the implementation for array equality:
+
+```rust
+impl<T, let N: u32> Eq for [T; let N: u32] where T: Eq {
+    // Test if two arrays have the same elements.
+    // Because both arrays must have length N, we know their lengths already match.
+    fn eq(self, other: Self) -> bool {
+        let mut result = true;
+
+        for i in 0 .. self.len() {
+            // The T: Eq constraint is needed to call == on the array elements here
+            result &= self[i] == other[i];
+        }
+
+        result
+    }
+}
+```
+
+Where clauses can also be placed on struct implementations. 
+For example, here is a method utilizing a generic type that implements the equality trait.
+
+```rust
+struct Foo<T> {
+    a: u32,
+    b: T,
+}
+
+impl<T> Foo<T> where T: Eq {
+    fn eq(self, other: Self) -> bool {
+        (self.a == other.a) & self.b.eq(other.b)
+    }
+}
+```
+
+## Generic Traits
+
+Traits themselves can also be generic by placing the generic arguments after the trait name. These generics are in
+scope of every item within the trait.
+
+```rust
+trait Into<T> {
+    // Convert `self` to type `T`
+    fn into(self) -> T;
+}
+```
+
+When implementing generic traits the generic arguments of the trait must be specified. This is also true anytime
+when referencing a generic trait (e.g. in a `where` clause).
+
+```rust
+struct MyStruct {
+    array: [Field; 2],
+}
+
+impl Into<[Field; 2]> for MyStruct {
+    fn into(self) -> [Field; 2] {
+        self.array
+    }
+}
+
+fn as_array<T>(x: T) -> [Field; 2] 
+    where T: Into<[Field; 2]>
+{
+    x.into()
+}
+
+fn main() {
+    let array = [1, 2];
+    let my_struct = MyStruct { array };
+
+    assert_eq(as_array(my_struct), array);
+}
+```
+
+### Associated Types and Constants
+
+Traits also support associated types and constraints which can be thought of as additional generics that are referred to by name.
+
+Here's an example of a trait with an associated type `Foo` and a constant `Bar`:
+
+```rust
+trait MyTrait {
+    type Foo;
+
+    let Bar: u32;
+}
+```
+
+Now when we're implementing `MyTrait` we also have to provide values for `Foo` and `Bar`:
+
+```rust
+impl MyTrait for Field {
+    type Foo = i32;
+
+    let Bar: u32 = 11;
+}
+```
+
+Since associated constants can also be used in a type position, its values are limited to only other
+expression kinds allowed in numeric generics.
+
+Note that currently all associated types and constants must be explicitly specified in a trait constraint.
+If we leave out any, we'll get an error that we're missing one:
+
+```rust
+// Error! Constraint is missing associated constant for `Bar`
+fn foo<T>(x: T) where T: MyTrait<Foo = i32> {
+    ...
+}
+```
+
+Because all associated types and constants must be explicitly specified, they are essentially named generics,
+although this is set to change in the future. Future versions of Noir will allow users to elide associated types
+in trait constraints similar to Rust. When this is done, you may still refer to their value with the `<Type as Trait>::AssociatedType`
+syntax:
+
+```rust
+// Only valid in future versions of Noir:
+fn foo<T>(x: T) where T: MyTrait {
+    let _: <T as MyTrait>::Foo = ...;
+}
+```
+
+The type as trait syntax is possible in Noir today but is less useful when each type must be explicitly specified anyway:
+
+```rust
+fn foo<T, F, let B: u32>(x: T) where T: MyTrait<Foo = F, Bar = B> {
+    // Works, but could just use F directly
+    let _: <T as MyTrait<Foo = F, Bar = B>>::Foo = ...;
+
+    let _: F = ...;
+}
+```
+
+## Trait Methods With No `self`
+
+A trait can contain any number of methods, each of which have access to the `Self` type which represents each type
+that eventually implements the trait. Similarly, the `self` variable is available as well but is not required to be used.
+For example, we can define a trait to create a default value for a type. This trait will need to return the `Self` type
+but doesn't need to take any parameters:
+
+```rust
+trait Default {
+    fn default() -> Self;
+}
+```
+
+Implementing this trait can be done similarly to any other trait:
+
+```rust
+impl Default for Field {
+    fn default() -> Field {
+        0
+    }
+}
+
+struct MyType {}
+
+impl Default for MyType {
+    fn default() -> Field {
+        MyType {}
+    }
+}
+```
+
+However, since there is no `self` parameter, we cannot call it via the method call syntax `object.method()`.
+Instead, we'll need to refer to the function directly. This can be done either by referring to the
+specific impl `MyType::default()` or referring to the trait itself `Default::default()`. In the later
+case, type inference determines the impl that is selected.
+
+```rust
+let my_struct = MyStruct::default();
+
+let x: Field = Default::default();
+let result = x + Default::default();
+```
+
+:::warning
+
+```rust
+let _ = Default::default();
+```
+
+If type inference cannot select which impl to use because of an ambiguous `Self` type, an impl will be
+arbitrarily selected. This occurs most often when the result of a trait function call with no parameters
+is unused. To avoid this, when calling a trait function with no `self` or `Self` parameters or return type,
+always refer to it via the implementation type's namespace - e.g. `MyType::default()`.
+This is set to change to an error in future Noir versions.
+
+:::
+
+## Default Method Implementations
+
+A trait can also have default implementations of its methods by giving a body to the desired functions.
+Note that this body must be valid for all types that may implement the trait. As a result, the only
+valid operations on `self` will be operations valid for any type or other operations on the trait itself.
+
+```rust
+trait Numeric {
+    fn add(self, other: Self) -> Self;
+
+    // Default implementation of double is (self + self)
+    fn double(self) -> Self {
+        self.add(self)
+    }
+}
+```
+
+When implementing a trait with default functions, a type may choose to implement only the required functions:
+
+```rust
+impl Numeric for Field {
+    fn add(self, other: Field) -> Field {
+        self + other
+    }
+}
+```
+
+Or it may implement the optional methods as well:
+
+```rust
+impl Numeric for u32 {
+    fn add(self, other: u32) -> u32 {
+        self + other
+    }
+
+    fn double(self) -> u32 {
+        self * 2
+    }
+}
+```
+
+## Impl Specialization
+
+When implementing traits for a generic type it is possible to implement the trait for only a certain combination
+of generics. This can be either as an optimization or because those specific generics are required to implement the trait.
+
+```rust
+trait Sub {
+    fn sub(self, other: Self) -> Self;
+}
+
+struct NonZero<T> {
+    value: T,
+}
+
+impl Sub for NonZero<Field> {
+    fn sub(self, other: Self) -> Self {
+        let value = self.value - other.value;
+        assert(value != 0);
+        NonZero { value }
+    }
+}
+```
+
+## Overlapping Implementations
+
+Overlapping implementations are disallowed by Noir to ensure Noir's decision on which impl to select is never ambiguous.
+This means if a trait `Foo` is already implemented
+by a type `Bar<T>` for all `T`, then we cannot also have a separate impl for `Bar<Field>` (or any other
+type argument). Similarly, if there is an impl for all `T` such as `impl<T> Debug for T`, we cannot create
+any more impls to `Debug` for other types since it would be ambiguous which impl to choose for any given
+method call.
+
+```rust
+trait Trait {}
+
+// Previous impl defined here
+impl<A, B> Trait for (A, B) {}
+
+// error: Impl for type `(Field, Field)` overlaps with existing impl
+impl Trait for (Field, Field) {}
+```
+
+## Trait Coherence
+
+Another restriction on trait implementations is coherence. This restriction ensures other crates cannot create
+impls that may overlap with other impls, even if several unrelated crates are used as dependencies in the same
+program.
+
+The coherence restriction is: to implement a trait, either the trait itself or the object type must be declared
+in the crate the impl is in.
+
+In practice this often comes up when using types provided by libraries. If a library provides a type `Foo` that does
+not implement a trait in the standard library such as `Default`, you may not `impl Default for Foo` in your own crate.
+While restrictive, this prevents later issues or silent changes in the program if the `Foo` library later added its
+own impl for `Default`. If you are a user of the `Foo` library in this scenario and need a trait not implemented by the
+library your choices are to either submit a patch to the library or use the newtype pattern.
+
+### The Newtype Pattern
+
+The newtype pattern gets around the coherence restriction by creating a new wrapper type around the library type
+that we cannot create `impl`s for. Since the new wrapper type is defined in our current crate, we can create
+impls for any trait we need on it.
+
+```rust
+struct Wrapper {
+    foo: some_library::Foo,
+}
+
+impl Default for Wrapper {
+    fn default() -> Wrapper {
+        Wrapper {
+            foo: some_library::Foo::new(),
+        }
+    }
+}
+```
+
+Since we have an impl for our own type, the behavior of this code will not change even if `some_library` is updated
+to provide its own `impl Default for Foo`. The downside of this pattern is that it requires extra wrapping and
+unwrapping of values when converting to and from the `Wrapper` and `Foo` types.
+
+### Trait Inheritance
+
+Sometimes, you might need one trait to use another trait’s functionality (like "inheritance" in some other languages). In this case, you can specify this relationship by listing any child traits after the parent trait's name and a colon. Now, whenever the parent trait is implemented it will require the child traits to be implemented as well. A parent trait is also called a "super trait."
+
+```rust
+trait Person {
+    fn name(self) -> String;
+}
+
+// Person is a supertrait of Student.
+// Implementing Student requires you to also impl Person.
+trait Student: Person {
+    fn university(self) -> String;
+}
+
+trait Programmer {
+    fn fav_language(self) -> String;
+}
+
+// CompSciStudent (computer science student) is a subtrait of both Programmer 
+// and Student. Implementing CompSciStudent requires you to impl both supertraits.
+trait CompSciStudent: Programmer + Student {
+    fn git_username(self) -> String;
+}
+```
+
+### Trait Aliases
+
+Similar to the proposed Rust feature for [trait aliases](https://github.com/rust-lang/rust/blob/4d215e2426d52ca8d1af166d5f6b5e172afbff67/src/doc/unstable-book/src/language-features/trait-alias.md),
+Noir supports aliasing one or more traits and using those aliases wherever
+traits would normally be used.
+
+```rust
+trait Foo {
+    fn foo(self) -> Self;
+}
+
+trait Bar {
+    fn bar(self) -> Self;
+}
+
+// Equivalent to:
+// trait Baz: Foo + Bar {}
+//
+// impl<T> Baz for T where T: Foo + Bar {}
+trait Baz = Foo + Bar;
+
+// We can use `Baz` to refer to `Foo + Bar`
+fn baz<T>(x: T) -> T where T: Baz {
+    x.foo().bar()
+}
+```
+
+#### Generic Trait Aliases
+
+Trait aliases can also be generic by placing the generic arguments after the
+trait name. These generics are in scope of every item within the trait alias.
+
+```rust
+trait Foo {
+    fn foo(self) -> Self;
+}
+
+trait Bar<T> {
+    fn bar(self) -> T;
+}
+
+// Equivalent to:
+// trait Baz<T>: Foo + Bar<T> {}
+//
+// impl<T, U> Baz<T> for U where U: Foo + Bar<T> {}
+trait Baz<T> = Foo + Bar<T>;
+```
+
+#### Trait Alias Where Clauses
+
+Trait aliases support where clauses to add trait constraints to any of their
+generic arguments, e.g. ensuring `T: Baz` for a trait alias `Qux<T>`.
+
+```rust
+trait Foo {
+    fn foo(self) -> Self;
+}
+
+trait Bar<T> {
+    fn bar(self) -> T;
+}
+
+trait Baz {
+    fn baz(self) -> bool;
+}
+
+// Equivalent to:
+// trait Qux<T>: Foo + Bar<T> where T: Baz {}
+//
+// impl<T, U> Qux<T> for U where
+//     U: Foo + Bar<T>,
+//     T: Baz,
+// {}
+trait Qux<T> = Foo + Bar<T> where T: Baz;
+```
+
+Note that while trait aliases support where clauses,
+the equivalent traits can fail due to [#6467](https://github.com/noir-lang/noir/issues/6467)
+
+### Visibility
+
+By default, like functions, traits and trait aliases are private to the module
+they exist in. You can use `pub` to make the trait public or `pub(crate)` to make
+it public to just its crate:
+
+```rust
+// This trait is now public
+pub trait Trait {}
+
+// This trait alias is now public
+pub trait Baz = Foo + Bar;
+```
diff --git a/docs/versioned_docs/version-v1.0.0-beta.0/noir/concepts/unconstrained.md b/docs/versioned_docs/version-v1.0.0-beta.0/noir/concepts/unconstrained.md
new file mode 100644
index 00000000000..b5221b8d2dd
--- /dev/null
+++ b/docs/versioned_docs/version-v1.0.0-beta.0/noir/concepts/unconstrained.md
@@ -0,0 +1,104 @@
+---
+title: Unconstrained Functions
+description: "Learn about what unconstrained functions in Noir are, how to use them and when you'd want to."
+
+keywords: [Noir programming language, unconstrained, open]
+sidebar_position: 5
+---
+
+Unconstrained functions are functions which do not constrain any of the included computation and allow for non-deterministic computation.
+
+## Why?
+
+Zero-knowledge (ZK) domain-specific languages (DSL) enable developers to generate ZK proofs from their programs by compiling code down to the constraints of an NP complete language (such as R1CS or PLONKish languages). However, the hard bounds of a constraint system can be very limiting to the functionality of a ZK DSL.
+
+Enabling a circuit language to perform unconstrained execution is a powerful tool. Said another way, unconstrained execution lets developers generate witnesses from code that does not generate any constraints. Being able to execute logic outside of a circuit is critical for both circuit performance and constructing proofs on information that is external to a circuit.
+
+Fetching information from somewhere external to a circuit can also be used to enable developers to improve circuit efficiency.
+
+A ZK DSL does not just prove computation, but proves that some computation was handled correctly. Thus, it is necessary that when we switch from performing some operation directly inside of a circuit to inside of an unconstrained environment that the appropriate constraints are still laid down elsewhere in the circuit.
+
+## Example
+
+An in depth example might help drive the point home. This example comes from the excellent [post](https://discord.com/channels/1113924620781883405/1124022445054111926/1128747641853972590) by Tom in the Noir Discord.
+
+Let's look at how we can optimize a function to turn a `u72` into an array of `u8`s.
+
+```rust
+fn main(num: u72) -> pub [u8; 8] {
+    let mut out: [u8; 8] = [0; 8];
+    for i in 0..8 {
+        out[i] = (num >> (56 - (i * 8)) as u72 & 0xff) as u8;
+    }
+
+    out
+}
+```
+
+```
+Total ACIR opcodes generated for language PLONKCSat { width: 3 }: 91
+Backend circuit size: 3619
+```
+
+A lot of the operations in this function are optimized away by the compiler (all the bit-shifts turn into divisions by constants). However we can save a bunch of gates by casting to u8 a bit earlier. This automatically truncates the bit-shifted value to fit in a u8 which allows us to remove the AND against 0xff. This saves us ~480 gates in total.
+
+```rust
+fn main(num: u72) -> pub [u8; 8] {
+    let mut out: [u8; 8] = [0; 8];
+    for i in 0..8 {
+        out[i] = (num >> (56 - (i * 8)) as u8;
+    }
+
+    out
+}
+```
+
+```
+Total ACIR opcodes generated for language PLONKCSat { width: 3 }: 75
+Backend circuit size: 3143
+```
+
+Those are some nice savings already but we can do better. This code is all constrained so we're proving every step of calculating out using num, but we don't actually care about how we calculate this, just that it's correct. This is where brillig comes in.
+
+It turns out that truncating a u72 into a u8 is hard to do inside a snark, each time we do as u8 we lay down 4 ACIR opcodes which get converted into multiple gates. It's actually much easier to calculate num from out than the other way around. All we need to do is multiply each element of out by a constant and add them all together, both relatively easy operations inside a snark.
+
+We can then run `u72_to_u8` as unconstrained brillig code in order to calculate out, then use that result in our constrained function and assert that if we were to do the reverse calculation we'd get back num. This looks a little like the below:
+
+```rust
+fn main(num: u72) -> pub [u8; 8] {
+    let out = unsafe { 
+        u72_to_u8(num) 
+    };
+
+    let mut reconstructed_num: u72 = 0;
+    for i in 0..8 {
+        reconstructed_num += (out[i] as u72 << (56 - (8 * i)));
+    }
+    assert(num == reconstructed_num);
+    out
+}
+
+unconstrained fn u72_to_u8(num: u72) -> [u8; 8] {
+    let mut out: [u8; 8] = [0; 8];
+    for i in 0..8 {
+        out[i] = (num >> (56 - (i * 8))) as u8;
+    }
+    out
+}
+```
+
+```
+Total ACIR opcodes generated for language PLONKCSat { width: 3 }: 78
+Backend circuit size: 2902
+```
+
+This ends up taking off another ~250 gates from our circuit! We've ended up with more ACIR opcodes than before but they're easier for the backend to prove (resulting in fewer gates).
+
+Note that in order to invoke unconstrained functions we need to wrap them in an `unsafe` block,
+to make it clear that the call is unconstrained.
+
+Generally we want to use brillig whenever there's something that's easy to verify but hard to compute within the circuit. For example, if you wanted to calculate a square root of a number it'll be a much better idea to calculate this in brillig and then assert that if you square the result you get back your number.
+
+## Break and Continue
+
+In addition to loops over runtime bounds, `break` and `continue` are also available in unconstrained code. See [break and continue](../concepts/control_flow.md#break-and-continue)
diff --git a/docs/versioned_docs/version-v1.0.0-beta.0/noir/modules_packages_crates/_category_.json b/docs/versioned_docs/version-v1.0.0-beta.0/noir/modules_packages_crates/_category_.json
new file mode 100644
index 00000000000..1debcfe7675
--- /dev/null
+++ b/docs/versioned_docs/version-v1.0.0-beta.0/noir/modules_packages_crates/_category_.json
@@ -0,0 +1,6 @@
+{
+    "label": "Modules, Packages and Crates",
+    "position": 2,
+    "collapsible": true,
+    "collapsed": true
+}
diff --git a/docs/versioned_docs/version-v1.0.0-beta.0/noir/modules_packages_crates/crates_and_packages.md b/docs/versioned_docs/version-v1.0.0-beta.0/noir/modules_packages_crates/crates_and_packages.md
new file mode 100644
index 00000000000..95ee9f52ab2
--- /dev/null
+++ b/docs/versioned_docs/version-v1.0.0-beta.0/noir/modules_packages_crates/crates_and_packages.md
@@ -0,0 +1,43 @@
+---
+title: Crates and Packages
+description: Learn how to use Crates and Packages in your Noir project
+keywords: [Nargo, dependencies, package management, crates, package]
+sidebar_position: 0
+---
+
+## Crates
+
+A crate is the smallest amount of code that the Noir compiler considers at a time.
+Crates can contain modules, and the modules may be defined in other files that get compiled with the crate, as we’ll see in the coming sections.
+
+### Crate Types
+
+A Noir crate can come in several forms: binaries, libraries or contracts.
+
+#### Binaries
+
+_Binary crates_ are programs which you can compile to an ACIR circuit which you can then create proofs against. Each must have a function called `main` that defines the ACIR circuit which is to be proved.
+
+#### Libraries
+
+_Library crates_ don't have a `main` function and they don't compile down to ACIR. Instead they define functionality intended to be shared with multiple projects, and eventually included in a binary crate.
+
+#### Contracts
+
+Contract crates are similar to binary crates in that they compile to ACIR which you can create proofs against. They are different in that they do not have a single `main` function, but are a collection of functions to be deployed to the [Aztec network](https://aztec.network). You can learn more about the technical details of Aztec in the [monorepo](https://github.com/AztecProtocol/aztec-packages) or contract [examples](https://github.com/AztecProtocol/aztec-packages/tree/master/noir-projects/noir-contracts/contracts).
+
+### Crate Root
+
+Every crate has a root, which is the source file that the compiler starts, this is also known as the root module. The Noir compiler does not enforce any conditions on the name of the file which is the crate root, however if you are compiling via Nargo the crate root must be called `lib.nr` or `main.nr` for library or binary crates respectively.
+
+## Packages
+
+A Nargo _package_ is a collection of one of more crates that provides a set of functionality. A package must include a Nargo.toml file.
+
+A package _must_ contain either a library or a binary crate, but not both.
+
+### Differences from Cargo Packages
+
+One notable difference between Rust's Cargo and Noir's Nargo is that while Cargo allows a package to contain an unlimited number of binary crates and a single library crate, Nargo currently only allows a package to contain a single crate.
+
+In future this restriction may be lifted to allow a Nargo package to contain both a binary and library crate or multiple binary crates.
diff --git a/docs/versioned_docs/version-v1.0.0-beta.0/noir/modules_packages_crates/dependencies.md b/docs/versioned_docs/version-v1.0.0-beta.0/noir/modules_packages_crates/dependencies.md
new file mode 100644
index 00000000000..24e02de08fe
--- /dev/null
+++ b/docs/versioned_docs/version-v1.0.0-beta.0/noir/modules_packages_crates/dependencies.md
@@ -0,0 +1,124 @@
+---
+title: Dependencies
+description:
+  Learn how to specify and manage dependencies in Nargo, allowing you to upload packages to GitHub
+  and use them easily in your project.
+keywords: [Nargo, dependencies, GitHub, package management, versioning]
+sidebar_position: 1
+---
+
+Nargo allows you to upload packages to GitHub and use them as dependencies.
+
+## Specifying a dependency
+
+Specifying a dependency requires a tag to a specific commit and the git url to the url containing
+the package.
+
+Currently, there are no requirements on the tag contents. If requirements are added, it would follow
+semver 2.0 guidelines.
+
+> Note: Without a `tag` , there would be no versioning and dependencies would change each time you
+> compile your project.
+
+For example, to add the [ecrecover-noir library](https://github.com/colinnielsen/ecrecover-noir) to your project, add it to `Nargo.toml`:
+
+```toml
+# Nargo.toml
+
+[dependencies]
+ecrecover = {tag = "v0.8.0", git = "https://github.com/colinnielsen/ecrecover-noir"}
+```
+
+If the module is in a subdirectory, you can define a subdirectory in your git repository, for example:
+
+```toml
+# Nargo.toml
+
+[dependencies]
+easy_private_token_contract = {tag ="v0.1.0-alpha62", git = "https://github.com/AztecProtocol/aztec-packages", directory = "noir-contracts/contracts/easy_private_token_contract"}
+```
+
+## Specifying a local dependency
+
+You can also specify dependencies that are local to your machine.
+
+For example, this file structure has a library and binary crate
+
+```tree
+├── binary_crate
+│   ├── Nargo.toml
+│   └── src
+│       └── main.nr
+└── lib_a
+    ├── Nargo.toml
+    └── src
+        └── lib.nr
+```
+
+Inside of the binary crate, you can specify:
+
+```toml
+# Nargo.toml
+
+[dependencies]
+lib_a = { path = "../lib_a" }
+```
+
+## Importing dependencies
+
+You can import a dependency to a Noir file using the following syntax. For example, to import the
+ecrecover-noir library and local lib_a referenced above:
+
+```rust
+use ecrecover;
+use lib_a;
+```
+
+You can also import only the specific parts of dependency that you want to use, like so:
+
+```rust
+use std::hash::sha256;
+use std::scalar_mul::fixed_base_embedded_curve;
+```
+
+Lastly, as demonstrated in the
+[elliptic curve example](../standard_library/cryptographic_primitives/ec_primitives.md#examples), you
+can import multiple items in the same line by enclosing them in curly braces:
+
+```rust
+use std::ec::tecurve::affine::{Curve, Point};
+```
+
+We don't have a way to consume libraries from inside a [workspace](./workspaces.md) as external dependencies right now.
+
+Inside a workspace, these are consumed as `{ path = "../to_lib" }` dependencies in Nargo.toml.
+
+## Dependencies of Dependencies
+
+Note that when you import a dependency, you also get access to all of the dependencies of that package.
+
+For example, the [phy_vector](https://github.com/resurgencelabs/phy_vector) library imports an [fraction](https://github.com/resurgencelabs/fraction) library. If you're importing the phy_vector library, then you can access the functions in fractions library like so:
+
+```rust
+use phy_vector;
+
+fn main(x : Field, y : pub Field) {
+  //...
+  let f = phy_vector::fraction::toFraction(true, 2, 1);
+  //...
+}
+```
+
+## Available Libraries
+
+Noir does not currently have an official package manager. You can find a list of available Noir libraries in the [awesome-noir repo here](https://github.com/noir-lang/awesome-noir#libraries).
+
+Some libraries that are available today include:
+
+- [Standard Library](https://github.com/noir-lang/noir/tree/master/noir_stdlib) - the Noir Standard Library
+- [Ethereum Storage Proof Verification](https://github.com/aragonzkresearch/noir-trie-proofs) - a library that contains the primitives necessary for RLP decoding (in the form of look-up table construction) and Ethereum state and storage proof verification (or verification of any trie proof involving 32-byte long keys)
+- [BigInt](https://github.com/shuklaayush/noir-bigint) - a library that provides a custom BigUint56 data type, allowing for computations on large unsigned integers
+- [ECrecover](https://github.com/colinnielsen/ecrecover-noir/tree/main) - a library to verify an ECDSA signature and return the source Ethereum address
+- [Sparse Merkle Tree Verifier](https://github.com/vocdoni/smtverifier-noir/tree/main) - a library for verification of sparse Merkle trees
+- [Signed Int](https://github.com/resurgencelabs/signed_int) - a library for accessing a custom Signed Integer data type, allowing access to negative numbers on Noir
+- [Fraction](https://github.com/resurgencelabs/fraction) - a library for accessing fractional number data type in Noir, allowing results that aren't whole numbers
diff --git a/docs/versioned_docs/version-v1.0.0-beta.0/noir/modules_packages_crates/modules.md b/docs/versioned_docs/version-v1.0.0-beta.0/noir/modules_packages_crates/modules.md
new file mode 100644
index 00000000000..14aa1f0579a
--- /dev/null
+++ b/docs/versioned_docs/version-v1.0.0-beta.0/noir/modules_packages_crates/modules.md
@@ -0,0 +1,221 @@
+---
+title: Modules
+description:
+  Learn how to organize your files using modules in Noir, following the same convention as Rust's
+  module system. Examples included.
+keywords: [Noir, Rust, modules, organizing files, sub-modules]
+sidebar_position: 2
+---
+
+Noir's module system follows the same convention as the _newer_ version of Rust's module system.
+
+## Purpose of Modules
+
+Modules are used to organize files. Without modules all of your code would need to live in a single
+file. In Noir, the compiler does not automatically scan all of your files to detect modules. This
+must be done explicitly by the developer.
+
+## Examples
+
+### Importing a module in the crate root
+
+Filename : `src/main.nr`
+
+```rust
+mod foo;
+
+fn main() {
+    foo::hello_world();
+}
+```
+
+Filename : `src/foo.nr`
+
+```rust
+fn from_foo() {}
+```
+
+In the above snippet, the crate root is the `src/main.nr` file. The compiler sees the module
+declaration `mod foo` which prompts it to look for a foo.nr file.
+
+Visually this module hierarchy looks like the following :
+
+```
+crate
+ ├── main
+ │
+ └── foo
+      └── from_foo
+
+```
+
+The module filename may also be the name of the module as a directory with the contents in a 
+file named `mod.nr` within that directory. The above example can alternatively be expressed like this:
+
+Filename : `src/main.nr`
+
+```rust
+mod foo;
+
+fn main() {
+    foo::hello_world();
+}
+```
+
+Filename : `src/foo/mod.nr`
+
+```rust
+fn from_foo() {}
+```
+
+Note that it's an error to have both files `src/foo.nr` and `src/foo/mod.nr` in the filesystem.
+
+### Importing a module throughout the tree
+
+All modules are accessible from the `crate::` namespace.
+
+```
+crate
+ ├── bar
+ ├── foo
+ └── main
+
+```
+
+In the above snippet, if `bar` would like to use functions in `foo`, it can do so by `use crate::foo::function_name`.
+
+### Sub-modules
+
+Filename : `src/main.nr`
+
+```rust
+mod foo;
+
+fn main() {
+    foo::from_foo();
+}
+```
+
+Filename : `src/foo.nr`
+
+```rust
+mod bar;
+fn from_foo() {}
+```
+
+Filename : `src/foo/bar.nr`
+
+```rust
+fn from_bar() {}
+```
+
+In the above snippet, we have added an extra module to the module tree; `bar`. `bar` is a submodule
+of `foo` hence we declare bar in `foo.nr` with `mod bar`. Since `foo` is not the crate root, the
+compiler looks for the file associated with the `bar` module in `src/foo/bar.nr`
+
+Visually the module hierarchy looks as follows:
+
+```
+crate
+ ├── main
+ │
+ └── foo
+      ├── from_foo
+      └── bar
+           └── from_bar
+```
+
+Similar to importing a module in the crate root, modules can be placed in a `mod.nr` file, like this:
+
+Filename : `src/main.nr`
+
+```rust
+mod foo;
+
+fn main() {
+    foo::from_foo();
+}
+```
+
+Filename : `src/foo/mod.nr`
+
+```rust
+mod bar;
+fn from_foo() {}
+```
+
+Filename : `src/foo/bar/mod.nr`
+
+```rust
+fn from_bar() {}
+```
+
+### Referencing a parent module 
+
+Given a submodule, you can refer to its parent module using the `super` keyword.
+
+Filename : `src/main.nr`
+
+```rust
+mod foo;
+
+fn main() {
+    foo::from_foo();
+}
+```
+
+Filename : `src/foo.nr`
+
+```rust
+mod bar;
+
+fn from_foo() {}
+```
+
+Filename : `src/foo/bar.nr`
+
+```rust
+// Same as bar::from_foo
+use super::from_foo; 
+
+fn from_bar() {
+    from_foo();        // invokes super::from_foo(), which is bar::from_foo()
+    super::from_foo(); // also invokes bar::from_foo()
+}
+```
+
+### `use` visibility
+
+`use` declarations are private to the containing module, by default. However, like functions, 
+they can be marked as `pub` or `pub(crate)`. Such a use declaration serves to _re-export_ a name. 
+A public `use` declaration can therefore redirect some public name to a different target definition: 
+even a definition with a private canonical path, inside a different module.
+
+An example of re-exporting:
+
+```rust
+mod some_module {
+    pub use foo::{bar, baz};
+    mod foo {
+        pub fn bar() {}
+        pub fn baz() {}
+    }
+}
+
+fn main() {
+    some_module::bar();
+    some_module::baz();
+}
+```
+
+In this example, the module `some_module` re-exports two public names defined in `foo`.
+
+### Visibility
+
+By default, like functions, modules are private to the module (or crate) they exist in. You can use `pub`
+to make the module public or `pub(crate)` to make it public to just its crate:
+
+```rust
+// This module is now public and can be seen by other crates.
+pub mod foo;
+```
\ No newline at end of file
diff --git a/docs/versioned_docs/version-v1.0.0-beta.0/noir/modules_packages_crates/workspaces.md b/docs/versioned_docs/version-v1.0.0-beta.0/noir/modules_packages_crates/workspaces.md
new file mode 100644
index 00000000000..513497f12bf
--- /dev/null
+++ b/docs/versioned_docs/version-v1.0.0-beta.0/noir/modules_packages_crates/workspaces.md
@@ -0,0 +1,42 @@
+---
+title: Workspaces
+sidebar_position: 3
+---
+
+Workspaces are a feature of nargo that allow you to manage multiple related Noir packages in a single repository. A workspace is essentially a group of related projects that share common build output directories and configurations.
+
+Each Noir project (with it's own Nargo.toml file) can be thought of as a package. Each package is expected to contain exactly one "named circuit", being the "name" defined in Nargo.toml with the program logic defined in `./src/main.nr`.
+
+For a project with the following structure:
+
+```tree
+├── crates
+│   ├── a
+│   │   ├── Nargo.toml
+│   │   └── Prover.toml
+│   │   └── src
+│   │       └── main.nr
+│   └── b
+│       ├── Nargo.toml
+│       └── Prover.toml
+│       └── src
+│           └── main.nr
+│
+└── Nargo.toml
+```
+
+You can define a workspace in Nargo.toml like so:
+
+```toml
+[workspace]
+members = ["crates/a", "crates/b"]
+default-member = "crates/a"
+```
+
+`members` indicates which packages are included in the workspace. As such, all member packages of a workspace will be processed when the `--workspace` flag is used with various commands or if a `default-member` is not specified.
+
+`default-member` indicates which package various commands process by default.
+
+Libraries can be defined in a workspace. Inside a workspace, these are consumed as `{ path = "../to_lib" }` dependencies in Nargo.toml.
+
+Inside a workspace, these are consumed as `{ path = "../to_lib" }` dependencies in Nargo.toml.
diff --git a/docs/versioned_docs/version-v1.0.0-beta.0/noir/standard_library/_category_.json b/docs/versioned_docs/version-v1.0.0-beta.0/noir/standard_library/_category_.json
new file mode 100644
index 00000000000..af04c0933fd
--- /dev/null
+++ b/docs/versioned_docs/version-v1.0.0-beta.0/noir/standard_library/_category_.json
@@ -0,0 +1,6 @@
+{
+    "label": "Standard Library",
+    "position": 1,
+    "collapsible": true,
+    "collapsed": true
+}
diff --git a/docs/versioned_docs/version-v1.0.0-beta.0/noir/standard_library/bigint.md b/docs/versioned_docs/version-v1.0.0-beta.0/noir/standard_library/bigint.md
new file mode 100644
index 00000000000..05c3011634f
--- /dev/null
+++ b/docs/versioned_docs/version-v1.0.0-beta.0/noir/standard_library/bigint.md
@@ -0,0 +1,127 @@
+---
+title: Big Integers
+description: How to use big integers from Noir standard library
+keywords:
+  [
+    Big Integer,
+    Noir programming language,
+    Noir libraries,
+  ]
+---
+
+The BigInt module in the standard library exposes some class of integers which do not fit (well) into a Noir native field. It implements modulo arithmetic, modulo a 'big' prime number.
+
+:::note
+
+The module can currently be considered as `Field`s with fixed modulo sizes used by a set of elliptic curves, in addition to just the native curve. [More work](https://github.com/noir-lang/noir/issues/510) is needed to achieve arbitrarily sized big integers.
+
+:::note
+
+`nargo` can be built with `--profile release-pedantic` to enable extra overflow checks which may affect `BigInt` results in some cases.
+Consider the [`noir-bignum`](https://github.com/noir-lang/noir-bignum) library for an optimized alternative approach.
+
+:::
+
+Currently 6 classes of integers (i.e 'big' prime numbers) are available in the module, namely:
+
+- BN254 Fq: Bn254Fq
+- BN254 Fr: Bn254Fr
+- Secp256k1 Fq: Secpk1Fq
+- Secp256k1 Fr: Secpk1Fr
+- Secp256r1 Fr: Secpr1Fr
+- Secp256r1 Fq: Secpr1Fq
+
+Where XXX Fq and XXX Fr denote respectively the order of the base and scalar field of the (usual) elliptic curve XXX.
+For instance the big integer 'Secpk1Fq' in the standard library refers to integers modulo $2^{256}-2^{32}-977$.
+
+Feel free to explore the source code for the other primes:
+
+```rust title="big_int_definition" showLineNumbers 
+pub struct BigInt {
+    pointer: u32,
+    modulus: u32,
+}
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/bigint.nr#L28-L33" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/bigint.nr#L28-L33</a></sub></sup>
+
+
+## Example usage
+
+A common use-case is when constructing a big integer from its bytes representation, and performing arithmetic operations on it:
+
+```rust title="big_int_example" showLineNumbers 
+fn big_int_example(x: u8, y: u8) {
+    let a = Secpk1Fq::from_le_bytes(&[x, y, 0, 45, 2]);
+    let b = Secpk1Fq::from_le_bytes(&[y, x, 9]);
+    let c = (a + b) * b / a;
+    let d = c.to_le_bytes();
+    println(d[0]);
+}
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/test_programs/execution_success/bigint/src/main.nr#L74-L82" target="_blank" rel="noopener noreferrer">Source code: test_programs/execution_success/bigint/src/main.nr#L74-L82</a></sub></sup>
+
+
+## Methods
+
+The available operations for each big integer are:
+
+### from_le_bytes
+
+Construct a big integer from its little-endian bytes representation. Example:
+
+```rust
+ // Construct a big integer from a slice of bytes
+ let a = Secpk1Fq::from_le_bytes(&[x, y, 0, 45, 2]);
+ // Construct a big integer from an array of 32 bytes
+ let a = Secpk1Fq::from_le_bytes_32([1;32]);
+ ```
+
+Sure, here's the formatted version of the remaining methods:
+
+### to_le_bytes
+
+Return the little-endian bytes representation of a big integer. Example:
+
+```rust
+let bytes = a.to_le_bytes();
+```
+
+### add
+
+Add two big integers. Example:
+
+```rust
+let sum = a + b;
+```
+
+### sub
+
+Subtract two big integers. Example:
+
+```rust
+let difference = a - b;
+```
+
+### mul
+
+Multiply two big integers. Example:
+
+```rust
+let product = a * b;
+```
+
+### div
+
+Divide two big integers. Note that division is field division and not euclidean division. Example:
+
+```rust
+let quotient = a / b;
+```
+
+### eq
+
+Compare two big integers. Example:
+
+```rust
+let are_equal = a == b;
+```
diff --git a/docs/versioned_docs/version-v1.0.0-beta.0/noir/standard_library/black_box_fns.md b/docs/versioned_docs/version-v1.0.0-beta.0/noir/standard_library/black_box_fns.md
new file mode 100644
index 00000000000..d6079ab182c
--- /dev/null
+++ b/docs/versioned_docs/version-v1.0.0-beta.0/noir/standard_library/black_box_fns.md
@@ -0,0 +1,32 @@
+---
+title: Black Box Functions
+description: Black box functions are functions in Noir that rely on backends implementing support for specialized constraints.
+keywords: [noir, black box functions]
+---
+
+Black box functions are functions in Noir that rely on backends implementing support for specialized constraints. This makes certain zk-snark unfriendly computations cheaper than if they were implemented in Noir.
+
+The ACVM spec defines a set of blackbox functions which backends will be expected to implement. This allows backends to use optimized implementations of these constraints if they have them, however they may also fallback to less efficient naive implementations if not.
+
+## Function list
+
+Here is a list of the current black box functions:
+
+- [AES128](./cryptographic_primitives/ciphers.mdx#aes128)
+- [SHA256](./cryptographic_primitives/hashes.mdx#sha256)
+- [Schnorr signature verification](./cryptographic_primitives/schnorr.mdx)
+- [Blake2s](./cryptographic_primitives/hashes.mdx#blake2s)
+- [Blake3](./cryptographic_primitives/hashes.mdx#blake3)
+- [Pedersen Hash](./cryptographic_primitives/hashes.mdx#pedersen_hash)
+- [Pedersen Commitment](./cryptographic_primitives/hashes.mdx#pedersen_commitment)
+- [ECDSA signature verification](./cryptographic_primitives/ecdsa_sig_verification.mdx)
+- [Embedded curve operations (MSM, addition, ...)](./cryptographic_primitives/embedded_curve_ops.mdx)
+- AND
+- XOR
+- RANGE
+- [Keccak256](./cryptographic_primitives/hashes.mdx#keccak256)
+- [Recursive proof verification](./recursion.mdx)
+
+Most black box functions are included as part of the Noir standard library, however `AND`, `XOR` and `RANGE` are used as part of the Noir language syntax. For instance, using the bitwise operator `&` will invoke the `AND` black box function.
+
+You can view the black box functions defined in the ACVM code [here](https://github.com/noir-lang/noir/blob/master/acvm-repo/acir/src/circuit/black_box_functions.rs).
diff --git a/docs/versioned_docs/version-v1.0.0-beta.0/noir/standard_library/bn254.md b/docs/versioned_docs/version-v1.0.0-beta.0/noir/standard_library/bn254.md
new file mode 100644
index 00000000000..3294f005dbb
--- /dev/null
+++ b/docs/versioned_docs/version-v1.0.0-beta.0/noir/standard_library/bn254.md
@@ -0,0 +1,46 @@
+---
+title: Bn254 Field Library
+---
+
+Noir provides a module in standard library with some optimized functions for bn254 Fr in `std::field::bn254`.
+
+## decompose
+
+```rust
+fn decompose(x: Field) -> (Field, Field) {}
+```
+
+Decomposes a single field into two fields, low and high. The low field contains the lower 16 bytes of the input field and the high field contains the upper 16 bytes of the input field. Both field results are range checked to 128 bits.
+
+
+## assert_gt
+
+```rust
+fn assert_gt(a: Field, b: Field) {}
+```
+
+Asserts that a > b. This will generate less constraints than using `assert(gt(a, b))`.
+
+## assert_lt
+
+```rust
+fn assert_lt(a: Field, b: Field) {}
+```
+
+Asserts that a < b. This will generate less constraints than using `assert(lt(a, b))`.
+
+## gt
+
+```rust
+fn gt(a: Field, b: Field) -> bool  {}
+```
+
+Returns true if a > b.
+
+## lt
+
+```rust
+fn lt(a: Field, b: Field) -> bool  {}
+```
+
+Returns true if a < b.
\ No newline at end of file
diff --git a/docs/versioned_docs/version-v1.0.0-beta.0/noir/standard_library/containers/boundedvec.md b/docs/versioned_docs/version-v1.0.0-beta.0/noir/standard_library/containers/boundedvec.md
new file mode 100644
index 00000000000..509b214bf3a
--- /dev/null
+++ b/docs/versioned_docs/version-v1.0.0-beta.0/noir/standard_library/containers/boundedvec.md
@@ -0,0 +1,419 @@
+---
+title: Bounded Vectors
+keywords: [noir, vector, bounded vector, slice]
+sidebar_position: 1
+---
+
+A `BoundedVec<T, MaxLen>` is a growable storage similar to a `Vec<T>` except that it
+is bounded with a maximum possible length. Unlike `Vec`, `BoundedVec` is not implemented
+via slices and thus is not subject to the same restrictions slices are (notably, nested
+slices - and thus nested vectors as well - are disallowed).
+
+Since a BoundedVec is backed by a normal array under the hood, growing the BoundedVec by
+pushing an additional element is also more efficient - the length only needs to be increased
+by one.
+
+For these reasons `BoundedVec<T, N>` should generally be preferred over `Vec<T>` when there
+is a reasonable maximum bound that can be placed on the vector.
+
+Example:
+
+```rust
+let mut vector: BoundedVec<Field, 10> = BoundedVec::new();
+for i in 0..5 {
+    vector.push(i);
+}
+assert(vector.len() == 5);
+assert(vector.max_len() == 10);
+```
+
+## Methods
+
+### new
+
+```rust
+pub fn new() -> Self
+```
+
+Creates a new, empty vector of length zero.
+
+Since this container is backed by an array internally, it still needs an initial value
+to give each element. To resolve this, each element is zeroed internally. This value
+is guaranteed to be inaccessible unless `get_unchecked` is used.
+
+Example:
+
+```rust
+let empty_vector: BoundedVec<Field, 10> = BoundedVec::new();
+assert(empty_vector.len() == 0);
+```
+
+Note that whenever calling `new` the maximum length of the vector should always be specified
+via a type signature:
+
+```rust title="new_example" showLineNumbers 
+fn good() -> BoundedVec<Field, 10> {
+    // Ok! MaxLen is specified with a type annotation
+    let v1: BoundedVec<Field, 3> = BoundedVec::new();
+    let v2 = BoundedVec::new();
+
+    // Ok! MaxLen is known from the type of `good`'s return value
+    v2
+}
+
+fn bad() {
+    // Error: Type annotation needed
+    // The compiler can't infer `MaxLen` from this code.
+    let mut v3 = BoundedVec::new();
+    v3.push(5);
+}
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/test_programs/noir_test_success/bounded_vec/src/main.nr#L11-L27" target="_blank" rel="noopener noreferrer">Source code: test_programs/noir_test_success/bounded_vec/src/main.nr#L11-L27</a></sub></sup>
+
+
+This defaulting of `MaxLen` (and numeric generics in general) to zero may change in future noir versions
+but for now make sure to use type annotations when using bounded vectors. Otherwise, you will receive a constraint failure at runtime when the vec is pushed to.
+
+### get
+
+```rust
+pub fn get(self, index: u64) -> T {
+```
+
+Retrieves an element from the vector at the given index, starting from zero.
+
+If the given index is equal to or greater than the length of the vector, this
+will issue a constraint failure.
+
+Example:
+
+```rust
+fn foo<N>(v: BoundedVec<u32, N>) {
+    let first = v.get(0);
+    let last = v.get(v.len() - 1);
+    assert(first != last);
+}
+```
+
+### get_unchecked
+
+```rust
+pub fn get_unchecked(self, index: u64) -> T {
+```
+
+Retrieves an element from the vector at the given index, starting from zero, without
+performing a bounds check.
+
+Since this function does not perform a bounds check on length before accessing the element,
+it is unsafe! Use at your own risk!
+
+Example:
+
+```rust title="get_unchecked_example" showLineNumbers 
+fn sum_of_first_three<let N: u32>(v: BoundedVec<u32, N>) -> u32 {
+    // Always ensure the length is larger than the largest
+    // index passed to get_unchecked
+    assert(v.len() > 2);
+    let first = v.get_unchecked(0);
+    let second = v.get_unchecked(1);
+    let third = v.get_unchecked(2);
+    first + second + third
+}
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/test_programs/noir_test_success/bounded_vec/src/main.nr#L54-L64" target="_blank" rel="noopener noreferrer">Source code: test_programs/noir_test_success/bounded_vec/src/main.nr#L54-L64</a></sub></sup>
+
+
+### set
+
+```rust
+pub fn set(&mut self: Self, index: u64, value: T) {
+```
+
+Writes an element to the vector at the given index, starting from zero.
+
+If the given index is equal to or greater than the length of the vector, this will issue a constraint failure.
+
+Example:
+
+```rust
+fn foo<N>(v: BoundedVec<u32, N>) {
+    let first = v.get(0);
+    assert(first != 42);
+    v.set(0, 42);
+    let new_first = v.get(0);
+    assert(new_first == 42);
+}
+```
+
+### set_unchecked
+
+```rust
+pub fn set_unchecked(&mut self: Self, index: u64, value: T) -> T {
+```
+
+Writes an element to the vector at the given index, starting from zero, without performing a bounds check.
+
+Since this function does not perform a bounds check on length before accessing the element, it is unsafe! Use at your own risk!
+
+Example:
+
+```rust title="set_unchecked_example" showLineNumbers 
+fn set_unchecked_example() {
+    let mut vec: BoundedVec<u32, 5> = BoundedVec::new();
+    vec.extend_from_array([1, 2]);
+
+    // Here we're safely writing within the valid range of `vec`
+    // `vec` now has the value [42, 2]
+    vec.set_unchecked(0, 42);
+
+    // We can then safely read this value back out of `vec`.
+    // Notice that we use the checked version of `get` which would prevent reading unsafe values.
+    assert_eq(vec.get(0), 42);
+
+    // We've now written past the end of `vec`.
+    // As this index is still within the maximum potential length of `v`,
+    // it won't cause a constraint failure.
+    vec.set_unchecked(2, 42);
+    println(vec);
+
+    // This will write past the end of the maximum potential length of `vec`,
+    // it will then trigger a constraint failure.
+    vec.set_unchecked(5, 42);
+    println(vec);
+}
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/test_programs/noir_test_success/bounded_vec/src/main.nr#L67-L91" target="_blank" rel="noopener noreferrer">Source code: test_programs/noir_test_success/bounded_vec/src/main.nr#L67-L91</a></sub></sup>
+
+
+
+### push
+
+```rust
+pub fn push(&mut self, elem: T) {
+```
+
+Pushes an element to the end of the vector. This increases the length
+of the vector by one.
+
+Panics if the new length of the vector will be greater than the max length.
+
+Example:
+
+```rust title="bounded-vec-push-example" showLineNumbers 
+let mut v: BoundedVec<Field, 2> = BoundedVec::new();
+
+    v.push(1);
+    v.push(2);
+
+    // Panics with failed assertion "push out of bounds"
+    v.push(3);
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/test_programs/noir_test_success/bounded_vec/src/main.nr#L95-L103" target="_blank" rel="noopener noreferrer">Source code: test_programs/noir_test_success/bounded_vec/src/main.nr#L95-L103</a></sub></sup>
+
+
+### pop
+
+```rust
+pub fn pop(&mut self) -> T
+```
+
+Pops the element at the end of the vector. This will decrease the length
+of the vector by one.
+
+Panics if the vector is empty.
+
+Example:
+
+```rust title="bounded-vec-pop-example" showLineNumbers 
+let mut v: BoundedVec<Field, 2> = BoundedVec::new();
+    v.push(1);
+    v.push(2);
+
+    let two = v.pop();
+    let one = v.pop();
+
+    assert(two == 2);
+    assert(one == 1);
+    // error: cannot pop from an empty vector
+    // let _ = v.pop();
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/test_programs/noir_test_success/bounded_vec/src/main.nr#L108-L120" target="_blank" rel="noopener noreferrer">Source code: test_programs/noir_test_success/bounded_vec/src/main.nr#L108-L120</a></sub></sup>
+
+
+### len
+
+```rust
+pub fn len(self) -> u64 {
+```
+
+Returns the current length of this vector
+
+Example:
+
+```rust title="bounded-vec-len-example" showLineNumbers 
+let mut v: BoundedVec<Field, 4> = BoundedVec::new();
+    assert(v.len() == 0);
+
+    v.push(100);
+    assert(v.len() == 1);
+
+    v.push(200);
+    v.push(300);
+    v.push(400);
+    assert(v.len() == 4);
+
+    let _ = v.pop();
+    let _ = v.pop();
+    assert(v.len() == 2);
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/test_programs/noir_test_success/bounded_vec/src/main.nr#L125-L140" target="_blank" rel="noopener noreferrer">Source code: test_programs/noir_test_success/bounded_vec/src/main.nr#L125-L140</a></sub></sup>
+
+
+### max_len
+
+```rust
+pub fn max_len(_self: BoundedVec<T, MaxLen>) -> u64 {
+```
+
+Returns the maximum length of this vector. This is always
+equal to the `MaxLen` parameter this vector was initialized with.
+
+Example:
+
+```rust title="bounded-vec-max-len-example" showLineNumbers 
+let mut v: BoundedVec<Field, 5> = BoundedVec::new();
+
+    assert(v.max_len() == 5);
+    v.push(10);
+    assert(v.max_len() == 5);
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/test_programs/noir_test_success/bounded_vec/src/main.nr#L145-L151" target="_blank" rel="noopener noreferrer">Source code: test_programs/noir_test_success/bounded_vec/src/main.nr#L145-L151</a></sub></sup>
+
+
+### storage
+
+```rust
+pub fn storage(self) -> [T; MaxLen] {
+```
+
+Returns the internal array within this vector.
+Since arrays in Noir are immutable, mutating the returned storage array will not mutate
+the storage held internally by this vector.
+
+Note that uninitialized elements may be zeroed out!
+
+Example:
+
+```rust title="bounded-vec-storage-example" showLineNumbers 
+let mut v: BoundedVec<Field, 5> = BoundedVec::new();
+
+    assert(v.storage() == [0, 0, 0, 0, 0]);
+
+    v.push(57);
+    assert(v.storage() == [57, 0, 0, 0, 0]);
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/test_programs/noir_test_success/bounded_vec/src/main.nr#L156-L163" target="_blank" rel="noopener noreferrer">Source code: test_programs/noir_test_success/bounded_vec/src/main.nr#L156-L163</a></sub></sup>
+
+
+### extend_from_array
+
+```rust
+pub fn extend_from_array<Len>(&mut self, array: [T; Len])
+```
+
+Pushes each element from the given array to this vector.
+
+Panics if pushing each element would cause the length of this vector
+to exceed the maximum length.
+
+Example:
+
+```rust title="bounded-vec-extend-from-array-example" showLineNumbers 
+let mut vec: BoundedVec<Field, 3> = BoundedVec::new();
+    vec.extend_from_array([2, 4]);
+
+    assert(vec.len == 2);
+    assert(vec.get(0) == 2);
+    assert(vec.get(1) == 4);
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/test_programs/noir_test_success/bounded_vec/src/main.nr#L168-L175" target="_blank" rel="noopener noreferrer">Source code: test_programs/noir_test_success/bounded_vec/src/main.nr#L168-L175</a></sub></sup>
+
+
+### extend_from_bounded_vec
+
+```rust
+pub fn extend_from_bounded_vec<Len>(&mut self, vec: BoundedVec<T, Len>)
+```
+
+Pushes each element from the other vector to this vector. The length of
+the other vector is left unchanged.
+
+Panics if pushing each element would cause the length of this vector
+to exceed the maximum length.
+
+Example:
+
+```rust title="bounded-vec-extend-from-bounded-vec-example" showLineNumbers 
+let mut v1: BoundedVec<Field, 5> = BoundedVec::new();
+    let mut v2: BoundedVec<Field, 7> = BoundedVec::new();
+
+    v2.extend_from_array([1, 2, 3]);
+    v1.extend_from_bounded_vec(v2);
+
+    assert(v1.storage() == [1, 2, 3, 0, 0]);
+    assert(v2.storage() == [1, 2, 3, 0, 0, 0, 0]);
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/test_programs/noir_test_success/bounded_vec/src/main.nr#L180-L189" target="_blank" rel="noopener noreferrer">Source code: test_programs/noir_test_success/bounded_vec/src/main.nr#L180-L189</a></sub></sup>
+
+
+### from_array
+
+```rust
+pub fn from_array<Len>(array: [T; Len]) -> Self
+```
+
+Creates a new vector, populating it with values derived from an array input. 
+The maximum length of the vector is determined based on the type signature.
+
+Example:
+```rust
+let bounded_vec: BoundedVec<Field, 10> = BoundedVec::from_array([1, 2, 3])
+```
+
+### map
+
+```rust
+pub fn map<U, Env>(self, f: fn[Env](T) -> U) -> BoundedVec<U, MaxLen>
+```
+
+Creates a new vector of equal size by calling a closure on each element in this vector.  
+
+Example:
+
+```rust title="bounded-vec-map-example" showLineNumbers 
+let vec: BoundedVec<u32, 4> = BoundedVec::from_array([1, 2, 3, 4]);
+            let result = vec.map(|value| value * 2);
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/collections/bounded_vec.nr#L495-L498" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/collections/bounded_vec.nr#L495-L498</a></sub></sup>
+
+
+### any
+
+```rust
+pub fn any<Env>(self, predicate: fn[Env](T) -> bool) -> bool
+```
+
+Returns true if the given predicate returns true for any element
+in this vector.
+
+Example:
+
+```rust title="bounded-vec-any-example" showLineNumbers 
+let mut v: BoundedVec<u32, 3> = BoundedVec::new();
+    v.extend_from_array([2, 4, 6]);
+
+    let all_even = !v.any(|elem: u32| elem % 2 != 0);
+    assert(all_even);
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/test_programs/noir_test_success/bounded_vec/src/main.nr#L256-L262" target="_blank" rel="noopener noreferrer">Source code: test_programs/noir_test_success/bounded_vec/src/main.nr#L256-L262</a></sub></sup>
+
diff --git a/docs/versioned_docs/version-v1.0.0-beta.0/noir/standard_library/containers/hashmap.md b/docs/versioned_docs/version-v1.0.0-beta.0/noir/standard_library/containers/hashmap.md
new file mode 100644
index 00000000000..395cc312705
--- /dev/null
+++ b/docs/versioned_docs/version-v1.0.0-beta.0/noir/standard_library/containers/hashmap.md
@@ -0,0 +1,587 @@
+---
+title: HashMap
+keywords: [noir, map, hash, hashmap]
+sidebar_position: 1
+---
+
+`HashMap<Key, Value, MaxLen, Hasher>` is used to efficiently store and look up key-value pairs.
+
+`HashMap` is a bounded type which can store anywhere from zero to `MaxLen` total elements.
+Note that due to hash collisions, the actual maximum number of elements stored by any particular
+hashmap is likely lower than `MaxLen`. This is true even with cryptographic hash functions since
+every hash value will be performed modulo `MaxLen`.
+
+Example:
+
+```rust
+// Create a mapping from Fields to u32s with a maximum length of 12
+// using a poseidon2 hasher
+use std::hash::poseidon2::Poseidon2Hasher;
+let mut map: HashMap<Field, u32, 12, BuildHasherDefault<Poseidon2Hasher>> = HashMap::default();
+
+map.insert(1, 2);
+map.insert(3, 4);
+
+let two = map.get(1).unwrap();
+```
+
+## Methods
+
+### default
+
+```rust title="default" showLineNumbers 
+impl<K, V, let N: u32, B, H> Default for HashMap<K, V, N, B>
+where
+    B: BuildHasher<H> + Default,
+    H: Hasher + Default,
+{
+    /// Constructs an empty HashMap.
+    ///
+    /// Example:
+    ///
+    /// ```noir
+    /// let hashmap: HashMap<u8, u32, 10, BuildHasherDefault<Poseidon2Hasher>> = HashMap::default();
+    /// assert(hashmap.is_empty());
+    /// ```
+    fn default() -> Self {
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/collections/map.nr#L681-L696" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/collections/map.nr#L681-L696</a></sub></sup>
+
+
+Creates a fresh, empty HashMap.
+
+When using this function, always make sure to specify the maximum size of the hash map.
+
+This is the same `default` from the `Default` implementation given further below. It is
+repeated here for convenience since it is the recommended way to create a hashmap.
+
+Example:
+
+```rust title="default_example" showLineNumbers 
+let hashmap: HashMap<u8, u32, 10, BuildHasherDefault<Poseidon2Hasher>> = HashMap::default();
+    assert(hashmap.is_empty());
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/test_programs/execution_success/hashmap/src/main.nr#L207-L210" target="_blank" rel="noopener noreferrer">Source code: test_programs/execution_success/hashmap/src/main.nr#L207-L210</a></sub></sup>
+
+
+Because `HashMap` has so many generic arguments that are likely to be the same throughout
+your program, it may be helpful to create a type alias:
+
+```rust title="type_alias" showLineNumbers 
+type MyMap = HashMap<u8, u32, 10, BuildHasherDefault<Poseidon2Hasher>>;
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/test_programs/execution_success/hashmap/src/main.nr#L201-L203" target="_blank" rel="noopener noreferrer">Source code: test_programs/execution_success/hashmap/src/main.nr#L201-L203</a></sub></sup>
+
+
+### with_hasher
+
+```rust title="with_hasher" showLineNumbers 
+pub fn with_hasher<H>(_build_hasher: B) -> Self
+    where
+        B: BuildHasher<H>,
+    {
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/collections/map.nr#L103-L108" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/collections/map.nr#L103-L108</a></sub></sup>
+
+
+Creates a hashmap with an existing `BuildHasher`. This can be used to ensure multiple
+hashmaps are created with the same hasher instance.
+
+Example:
+
+```rust title="with_hasher_example" showLineNumbers 
+let my_hasher: BuildHasherDefault<Poseidon2Hasher> = Default::default();
+    let hashmap: HashMap<u8, u32, 10, BuildHasherDefault<Poseidon2Hasher>> =
+        HashMap::with_hasher(my_hasher);
+    assert(hashmap.is_empty());
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/test_programs/execution_success/hashmap/src/main.nr#L211-L216" target="_blank" rel="noopener noreferrer">Source code: test_programs/execution_success/hashmap/src/main.nr#L211-L216</a></sub></sup>
+
+
+### get
+
+```rust title="get" showLineNumbers 
+pub fn get<H>(self, key: K) -> Option<V>
+    where
+        K: Eq + Hash,
+        B: BuildHasher<H>,
+        H: Hasher,
+    {
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/collections/map.nr#L465-L472" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/collections/map.nr#L465-L472</a></sub></sup>
+
+
+Retrieves a value from the hashmap, returning `Option::none()` if it was not found.
+
+Example:
+
+```rust title="get_example" showLineNumbers 
+fn get_example(map: HashMap<Field, Field, 5, BuildHasherDefault<Poseidon2Hasher>>) {
+    let x = map.get(12);
+
+    if x.is_some() {
+        assert(x.unwrap() == 42);
+    }
+}
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/test_programs/execution_success/hashmap/src/main.nr#L296-L304" target="_blank" rel="noopener noreferrer">Source code: test_programs/execution_success/hashmap/src/main.nr#L296-L304</a></sub></sup>
+
+
+### insert
+
+```rust title="insert" showLineNumbers 
+pub fn insert<H>(&mut self, key: K, value: V)
+    where
+        K: Eq + Hash,
+        B: BuildHasher<H>,
+        H: Hasher,
+    {
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/collections/map.nr#L507-L514" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/collections/map.nr#L507-L514</a></sub></sup>
+
+
+Inserts a new key-value pair into the map. If the key was already in the map, its
+previous value will be overridden with the newly provided one.
+
+Example:
+
+```rust title="insert_example" showLineNumbers 
+let mut map: HashMap<Field, Field, 5, BuildHasherDefault<Poseidon2Hasher>> = HashMap::default();
+    map.insert(12, 42);
+    assert(map.len() == 1);
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/test_programs/execution_success/hashmap/src/main.nr#L217-L221" target="_blank" rel="noopener noreferrer">Source code: test_programs/execution_success/hashmap/src/main.nr#L217-L221</a></sub></sup>
+
+
+### remove
+
+```rust title="remove" showLineNumbers 
+pub fn remove<H>(&mut self, key: K)
+    where
+        K: Eq + Hash,
+        B: BuildHasher<H>,
+        H: Hasher,
+    {
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/collections/map.nr#L563-L570" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/collections/map.nr#L563-L570</a></sub></sup>
+
+
+Removes the given key-value pair from the map. If the key was not already present
+in the map, this does nothing.
+
+Example:
+
+```rust title="remove_example" showLineNumbers 
+map.remove(12);
+    assert(map.is_empty());
+
+    // If a key was not present in the map, remove does nothing
+    map.remove(12);
+    assert(map.is_empty());
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/test_programs/execution_success/hashmap/src/main.nr#L224-L231" target="_blank" rel="noopener noreferrer">Source code: test_programs/execution_success/hashmap/src/main.nr#L224-L231</a></sub></sup>
+
+
+### is_empty
+
+```rust title="is_empty" showLineNumbers 
+pub fn is_empty(self) -> bool {
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/collections/map.nr#L167-L169" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/collections/map.nr#L167-L169</a></sub></sup>
+
+
+True if the length of the hash map is empty.
+
+Example:
+
+```rust title="is_empty_example" showLineNumbers 
+assert(map.is_empty());
+
+    map.insert(1, 2);
+    assert(!map.is_empty());
+
+    map.remove(1);
+    assert(map.is_empty());
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/test_programs/execution_success/hashmap/src/main.nr#L232-L240" target="_blank" rel="noopener noreferrer">Source code: test_programs/execution_success/hashmap/src/main.nr#L232-L240</a></sub></sup>
+
+
+### len
+
+```rust title="len" showLineNumbers 
+pub fn len(self) -> u32 {
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/collections/map.nr#L424-L426" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/collections/map.nr#L424-L426</a></sub></sup>
+
+
+Returns the current length of this hash map.
+
+Example:
+
+```rust title="len_example" showLineNumbers 
+// This is equivalent to checking map.is_empty()
+    assert(map.len() == 0);
+
+    map.insert(1, 2);
+    map.insert(3, 4);
+    map.insert(5, 6);
+    assert(map.len() == 3);
+
+    // 3 was already present as a key in the hash map, so the length is unchanged
+    map.insert(3, 7);
+    assert(map.len() == 3);
+
+    map.remove(1);
+    assert(map.len() == 2);
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/test_programs/execution_success/hashmap/src/main.nr#L241-L256" target="_blank" rel="noopener noreferrer">Source code: test_programs/execution_success/hashmap/src/main.nr#L241-L256</a></sub></sup>
+
+
+### capacity
+
+```rust title="capacity" showLineNumbers 
+pub fn capacity(_self: Self) -> u32 {
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/collections/map.nr#L446-L448" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/collections/map.nr#L446-L448</a></sub></sup>
+
+
+Returns the maximum capacity of this hashmap. This is always equal to the capacity
+specified in the hashmap's type.
+
+Unlike hashmaps in general purpose programming languages, hashmaps in Noir have a
+static capacity that does not increase as the map grows larger. Thus, this capacity
+is also the maximum possible element count that can be inserted into the hashmap.
+Due to hash collisions (modulo the hashmap length), it is likely the actual maximum
+element count will be lower than the full capacity.
+
+Example:
+
+```rust title="capacity_example" showLineNumbers 
+let empty_map: HashMap<Field, Field, 42, BuildHasherDefault<Poseidon2Hasher>> =
+        HashMap::default();
+    assert(empty_map.len() == 0);
+    assert(empty_map.capacity() == 42);
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/test_programs/execution_success/hashmap/src/main.nr#L257-L262" target="_blank" rel="noopener noreferrer">Source code: test_programs/execution_success/hashmap/src/main.nr#L257-L262</a></sub></sup>
+
+
+### clear
+
+```rust title="clear" showLineNumbers 
+pub fn clear(&mut self) {
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/collections/map.nr#L123-L125" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/collections/map.nr#L123-L125</a></sub></sup>
+
+
+Clears the hashmap, removing all key-value pairs from it.
+
+Example:
+
+```rust title="clear_example" showLineNumbers 
+assert(!map.is_empty());
+    map.clear();
+    assert(map.is_empty());
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/test_programs/execution_success/hashmap/src/main.nr#L263-L267" target="_blank" rel="noopener noreferrer">Source code: test_programs/execution_success/hashmap/src/main.nr#L263-L267</a></sub></sup>
+
+
+### contains_key
+
+```rust title="contains_key" showLineNumbers 
+pub fn contains_key<H>(self, key: K) -> bool
+    where
+        K: Hash + Eq,
+        B: BuildHasher<H>,
+        H: Hasher,
+    {
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/collections/map.nr#L143-L150" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/collections/map.nr#L143-L150</a></sub></sup>
+
+
+True if the hashmap contains the given key. Unlike `get`, this will not also return
+the value associated with the key.
+
+Example:
+
+```rust title="contains_key_example" showLineNumbers 
+if map.contains_key(7) {
+        let value = map.get(7);
+        assert(value.is_some());
+    } else {
+        println("No value for key 7!");
+    }
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/test_programs/execution_success/hashmap/src/main.nr#L268-L275" target="_blank" rel="noopener noreferrer">Source code: test_programs/execution_success/hashmap/src/main.nr#L268-L275</a></sub></sup>
+
+
+### entries
+
+```rust title="entries" showLineNumbers 
+pub fn entries(self) -> BoundedVec<(K, V), N> {
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/collections/map.nr#L191-L193" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/collections/map.nr#L191-L193</a></sub></sup>
+
+
+Returns a vector of each key-value pair present in the hashmap.
+
+The length of the returned vector is always equal to the length of the hashmap.
+
+Example:
+
+```rust title="entries_example" showLineNumbers 
+let entries = map.entries();
+
+    // The length of a hashmap may not be compile-time known, so we
+    // need to loop over its capacity instead
+    for i in 0..map.capacity() {
+        if i < entries.len() {
+            let (key, value) = entries.get(i);
+            println(f"{key} -> {value}");
+        }
+    }
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/test_programs/execution_success/hashmap/src/main.nr#L307-L318" target="_blank" rel="noopener noreferrer">Source code: test_programs/execution_success/hashmap/src/main.nr#L307-L318</a></sub></sup>
+
+
+### keys
+
+```rust title="keys" showLineNumbers 
+pub fn keys(self) -> BoundedVec<K, N> {
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/collections/map.nr#L227-L229" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/collections/map.nr#L227-L229</a></sub></sup>
+
+
+Returns a vector of each key present in the hashmap.
+
+The length of the returned vector is always equal to the length of the hashmap.
+
+Example:
+
+```rust title="keys_example" showLineNumbers 
+let keys = map.keys();
+
+    for i in 0..keys.max_len() {
+        if i < keys.len() {
+            let key = keys.get_unchecked(i);
+            let value = map.get(key).unwrap_unchecked();
+            println(f"{key} -> {value}");
+        }
+    }
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/test_programs/execution_success/hashmap/src/main.nr#L319-L329" target="_blank" rel="noopener noreferrer">Source code: test_programs/execution_success/hashmap/src/main.nr#L319-L329</a></sub></sup>
+
+
+### values
+
+```rust title="values" showLineNumbers 
+pub fn values(self) -> BoundedVec<V, N> {
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/collections/map.nr#L262-L264" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/collections/map.nr#L262-L264</a></sub></sup>
+
+
+Returns a vector of each value present in the hashmap.
+
+The length of the returned vector is always equal to the length of the hashmap.
+
+Example:
+
+```rust title="values_example" showLineNumbers 
+let values = map.values();
+
+    for i in 0..values.max_len() {
+        if i < values.len() {
+            let value = values.get_unchecked(i);
+            println(f"Found value {value}");
+        }
+    }
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/test_programs/execution_success/hashmap/src/main.nr#L330-L339" target="_blank" rel="noopener noreferrer">Source code: test_programs/execution_success/hashmap/src/main.nr#L330-L339</a></sub></sup>
+
+
+### iter_mut
+
+```rust title="iter_mut" showLineNumbers 
+pub fn iter_mut<H>(&mut self, f: fn(K, V) -> (K, V))
+    where
+        K: Eq + Hash,
+        B: BuildHasher<H>,
+        H: Hasher,
+    {
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/collections/map.nr#L297-L304" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/collections/map.nr#L297-L304</a></sub></sup>
+
+
+Iterates through each key-value pair of the HashMap, setting each key-value pair to the
+result returned from the given function.
+
+Note that since keys can be mutated, the HashMap needs to be rebuilt as it is iterated
+through. If this is not desired, use `iter_values_mut` if only values need to be mutated,
+or `entries` if neither keys nor values need to be mutated.
+
+The iteration order is left unspecified. As a result, if two keys are mutated to become
+equal, which of the two values that will be present for the key in the resulting map is also unspecified.
+
+Example:
+
+```rust title="iter_mut_example" showLineNumbers 
+// Add 1 to each key in the map, and double the value associated with that key.
+    map.iter_mut(|k, v| (k + 1, v * 2));
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/test_programs/execution_success/hashmap/src/main.nr#L343-L346" target="_blank" rel="noopener noreferrer">Source code: test_programs/execution_success/hashmap/src/main.nr#L343-L346</a></sub></sup>
+
+
+### iter_keys_mut
+
+```rust title="iter_keys_mut" showLineNumbers 
+pub fn iter_keys_mut<H>(&mut self, f: fn(K) -> K)
+    where
+        K: Eq + Hash,
+        B: BuildHasher<H>,
+        H: Hasher,
+    {
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/collections/map.nr#L335-L342" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/collections/map.nr#L335-L342</a></sub></sup>
+
+
+Iterates through the HashMap, mutating each key to the result returned from
+the given function.
+
+Note that since keys can be mutated, the HashMap needs to be rebuilt as it is iterated
+through. If only iteration is desired and the keys are not intended to be mutated,
+prefer using `entries` instead.
+
+The iteration order is left unspecified. As a result, if two keys are mutated to become
+equal, which of the two values that will be present for the key in the resulting map is also unspecified.
+
+Example:
+
+```rust title="iter_keys_mut_example" showLineNumbers 
+// Double each key, leaving the value associated with that key untouched
+    map.iter_keys_mut(|k| k * 2);
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/test_programs/execution_success/hashmap/src/main.nr#L347-L350" target="_blank" rel="noopener noreferrer">Source code: test_programs/execution_success/hashmap/src/main.nr#L347-L350</a></sub></sup>
+
+
+### iter_values_mut
+
+```rust title="iter_values_mut" showLineNumbers 
+pub fn iter_values_mut(&mut self, f: fn(V) -> V) {
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/collections/map.nr#L367-L369" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/collections/map.nr#L367-L369</a></sub></sup>
+
+
+Iterates through the HashMap, applying the given function to each value and mutating the
+value to equal the result. This function is more efficient than `iter_mut` and `iter_keys_mut`
+because the keys are untouched and the underlying hashmap thus does not need to be reordered.
+
+Example:
+
+```rust title="iter_values_mut_example" showLineNumbers 
+// Halve each value
+    map.iter_values_mut(|v| v / 2);
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/test_programs/execution_success/hashmap/src/main.nr#L351-L354" target="_blank" rel="noopener noreferrer">Source code: test_programs/execution_success/hashmap/src/main.nr#L351-L354</a></sub></sup>
+
+
+### retain
+
+```rust title="retain" showLineNumbers 
+pub fn retain(&mut self, f: fn(K, V) -> bool) {
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/collections/map.nr#L388-L390" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/collections/map.nr#L388-L390</a></sub></sup>
+
+
+Retains only the key-value pairs for which the given function returns true.
+Any key-value pairs for which the function returns false will be removed from the map.
+
+Example:
+
+```rust title="retain_example" showLineNumbers 
+map.retain(|k, v| (k != 0) & (v != 0));
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/test_programs/execution_success/hashmap/src/main.nr#L279-L281" target="_blank" rel="noopener noreferrer">Source code: test_programs/execution_success/hashmap/src/main.nr#L279-L281</a></sub></sup>
+
+
+## Trait Implementations
+
+### default
+
+```rust title="default" showLineNumbers 
+impl<K, V, let N: u32, B, H> Default for HashMap<K, V, N, B>
+where
+    B: BuildHasher<H> + Default,
+    H: Hasher + Default,
+{
+    /// Constructs an empty HashMap.
+    ///
+    /// Example:
+    ///
+    /// ```noir
+    /// let hashmap: HashMap<u8, u32, 10, BuildHasherDefault<Poseidon2Hasher>> = HashMap::default();
+    /// assert(hashmap.is_empty());
+    /// ```
+    fn default() -> Self {
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/collections/map.nr#L681-L696" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/collections/map.nr#L681-L696</a></sub></sup>
+
+
+Constructs an empty HashMap.
+
+Example:
+
+```rust title="default_example" showLineNumbers 
+let hashmap: HashMap<u8, u32, 10, BuildHasherDefault<Poseidon2Hasher>> = HashMap::default();
+    assert(hashmap.is_empty());
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/test_programs/execution_success/hashmap/src/main.nr#L207-L210" target="_blank" rel="noopener noreferrer">Source code: test_programs/execution_success/hashmap/src/main.nr#L207-L210</a></sub></sup>
+
+
+### eq
+
+```rust title="eq" showLineNumbers 
+impl<K, V, let N: u32, B, H> Eq for HashMap<K, V, N, B>
+where
+    K: Eq + Hash,
+    V: Eq,
+    B: BuildHasher<H>,
+    H: Hasher,
+{
+    /// Checks if two HashMaps are equal.
+    ///
+    /// Example:
+    ///
+    /// ```noir
+    /// let mut map1: HashMap<Field, u64, 4, BuildHasherDefault<Poseidon2Hasher>> = HashMap::default();
+    /// let mut map2: HashMap<Field, u64, 4, BuildHasherDefault<Poseidon2Hasher>> = HashMap::default();
+    ///
+    /// map1.insert(1, 2);
+    /// map1.insert(3, 4);
+    ///
+    /// map2.insert(3, 4);
+    /// map2.insert(1, 2);
+    ///
+    /// assert(map1 == map2);
+    /// ```
+    fn eq(self, other: HashMap<K, V, N, B>) -> bool {
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/collections/map.nr#L629-L654" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/collections/map.nr#L629-L654</a></sub></sup>
+
+
+Checks if two HashMaps are equal.
+
+Example:
+
+```rust title="eq_example" showLineNumbers 
+let mut map1: HashMap<Field, u64, 4, BuildHasherDefault<Poseidon2Hasher>> = HashMap::default();
+    let mut map2: HashMap<Field, u64, 4, BuildHasherDefault<Poseidon2Hasher>> = HashMap::default();
+
+    map1.insert(1, 2);
+    map1.insert(3, 4);
+
+    map2.insert(3, 4);
+    map2.insert(1, 2);
+
+    assert(map1 == map2);
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/test_programs/execution_success/hashmap/src/main.nr#L282-L293" target="_blank" rel="noopener noreferrer">Source code: test_programs/execution_success/hashmap/src/main.nr#L282-L293</a></sub></sup>
+
diff --git a/docs/versioned_docs/version-v1.0.0-beta.0/noir/standard_library/containers/index.md b/docs/versioned_docs/version-v1.0.0-beta.0/noir/standard_library/containers/index.md
new file mode 100644
index 00000000000..ea84c6d5c21
--- /dev/null
+++ b/docs/versioned_docs/version-v1.0.0-beta.0/noir/standard_library/containers/index.md
@@ -0,0 +1,5 @@
+---
+title: Containers
+description: Container types provided by Noir's standard library for storing and retrieving data
+keywords: [containers, data types, vec, hashmap]
+---
diff --git a/docs/versioned_docs/version-v1.0.0-beta.0/noir/standard_library/containers/vec.mdx b/docs/versioned_docs/version-v1.0.0-beta.0/noir/standard_library/containers/vec.mdx
new file mode 100644
index 00000000000..475011922f8
--- /dev/null
+++ b/docs/versioned_docs/version-v1.0.0-beta.0/noir/standard_library/containers/vec.mdx
@@ -0,0 +1,170 @@
+---
+title: Vectors
+description: Delve into the Vec data type in Noir. Learn about its methods, practical examples, and best practices for using Vectors in your Noir code.
+keywords: [noir, vector type, methods, examples, dynamic arrays]
+sidebar_position: 6
+---
+
+import Experimental from '@site/src/components/Notes/_experimental.mdx';
+
+<Experimental />
+
+A vector is a collection type similar to Rust's `Vec<T>` type. In Noir, it is a convenient way to use slices as mutable arrays.
+
+Example:
+
+```rust
+let mut vector: Vec<Field> = Vec::new();
+for i in 0..5 {
+    vector.push(i);
+}
+assert(vector.len() == 5);
+```
+
+## Methods
+
+### new
+
+Creates a new, empty vector.
+
+```rust
+pub fn new() -> Self
+```
+
+Example:
+
+```rust
+let empty_vector: Vec<Field> = Vec::new();
+assert(empty_vector.len() == 0);
+```
+
+### from_slice
+
+Creates a vector containing each element from a given slice. Mutations to the resulting vector will not affect the original slice.
+
+```rust
+pub fn from_slice(slice: [T]) -> Self
+```
+
+Example:
+
+```rust
+let slice: [Field] = &[1, 2, 3];
+let vector_from_slice = Vec::from_slice(slice);
+assert(vector_from_slice.len() == 3);
+```
+
+### len
+
+Returns the number of elements in the vector.
+
+```rust
+pub fn len(self) -> Field
+```
+
+Example:
+
+```rust
+let empty_vector: Vec<Field> = Vec::new();
+assert(empty_vector.len() == 0);
+```
+
+### get
+
+Retrieves an element from the vector at a given index. Panics if the index points beyond the vector's end.
+
+```rust
+pub fn get(self, index: Field) -> T
+```
+
+Example:
+
+```rust
+let vector: Vec<Field> = Vec::from_slice(&[10, 20, 30]);
+assert(vector.get(1) == 20);
+```
+
+### set
+
+```rust
+pub fn set(&mut self: Self, index: u64, value: T) {
+```
+
+Writes an element to the vector at the given index, starting from zero.
+
+Panics if the index points beyond the vector's end.
+
+Example:
+
+```rust
+let vector: Vec<Field> = Vec::from_slice(&[10, 20, 30]);
+assert(vector.get(1) == 20);
+vector.set(1, 42);
+assert(vector.get(1) == 42);
+```
+
+### push
+
+Adds a new element to the vector's end, returning a new vector with a length one greater than the original unmodified vector.
+
+```rust
+pub fn push(&mut self, elem: T)
+```
+
+Example:
+
+```rust
+let mut vector: Vec<Field> = Vec::new();
+vector.push(10);
+assert(vector.len() == 1);
+```
+
+### pop
+
+Removes an element from the vector's end, returning a new vector with a length one less than the original vector, along with the removed element. Panics if the vector's length is zero.
+
+```rust
+pub fn pop(&mut self) -> T
+```
+
+Example:
+
+```rust
+let mut vector = Vec::from_slice(&[10, 20]);
+let popped_elem = vector.pop();
+assert(popped_elem == 20);
+assert(vector.len() == 1);
+```
+
+### insert
+
+Inserts an element at a specified index, shifting subsequent elements to the right.
+
+```rust
+pub fn insert(&mut self, index: Field, elem: T)
+```
+
+Example:
+
+```rust
+let mut vector = Vec::from_slice(&[10, 30]);
+vector.insert(1, 20);
+assert(vector.get(1) == 20);
+```
+
+### remove
+
+Removes an element at a specified index, shifting subsequent elements to the left, and returns the removed element.
+
+```rust
+pub fn remove(&mut self, index: Field) -> T
+```
+
+Example:
+
+```rust
+let mut vector = Vec::from_slice(&[10, 20, 30]);
+let removed_elem = vector.remove(1);
+assert(removed_elem == 20);
+assert(vector.len() == 2);
+```
diff --git a/docs/versioned_docs/version-v1.0.0-beta.0/noir/standard_library/cryptographic_primitives/_category_.json b/docs/versioned_docs/version-v1.0.0-beta.0/noir/standard_library/cryptographic_primitives/_category_.json
new file mode 100644
index 00000000000..5d694210bbf
--- /dev/null
+++ b/docs/versioned_docs/version-v1.0.0-beta.0/noir/standard_library/cryptographic_primitives/_category_.json
@@ -0,0 +1,5 @@
+{
+    "position": 0,
+    "collapsible": true,
+    "collapsed": true
+}
diff --git a/docs/versioned_docs/version-v1.0.0-beta.0/noir/standard_library/cryptographic_primitives/ciphers.mdx b/docs/versioned_docs/version-v1.0.0-beta.0/noir/standard_library/cryptographic_primitives/ciphers.mdx
new file mode 100644
index 00000000000..d6a5e1a79eb
--- /dev/null
+++ b/docs/versioned_docs/version-v1.0.0-beta.0/noir/standard_library/cryptographic_primitives/ciphers.mdx
@@ -0,0 +1,32 @@
+---
+title: Ciphers
+description:
+  Learn about the implemented ciphers ready to use for any Noir project
+keywords:
+  [ciphers, Noir project, aes128, encrypt]
+sidebar_position: 0
+---
+
+import BlackBoxInfo from '@site/src/components/Notes/_blackbox';
+
+## aes128
+
+Given a plaintext as an array of bytes, returns the corresponding aes128 ciphertext (CBC mode). Input padding is automatically performed using PKCS#7, so that the output length is `input.len() + (16 - input.len() % 16)`.
+
+```rust title="aes128" showLineNumbers 
+pub fn aes128_encrypt<let N: u32>(input: [u8; N], iv: [u8; 16], key: [u8; 16]) -> [u8] {}
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/aes128.nr#L2-L4" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/aes128.nr#L2-L4</a></sub></sup>
+
+
+```rust
+fn main() {
+    let input: [u8; 4] = [0, 12, 3, 15] // Random bytes, will be padded to 16 bytes.
+    let iv: [u8; 16] = [0; 16]; // Initialisation vector
+    let key: [u8; 16] = [0; 16] // AES key
+    let ciphertext = std::aes128::aes128_encrypt(inputs.as_bytes(), iv.as_bytes(), key.as_bytes()); // In this case, the output length will be 16 bytes.
+}
+```
+
+
+<BlackBoxInfo to="../black_box_fns"/>
\ No newline at end of file
diff --git a/docs/versioned_docs/version-v1.0.0-beta.0/noir/standard_library/cryptographic_primitives/ec_primitives.md b/docs/versioned_docs/version-v1.0.0-beta.0/noir/standard_library/cryptographic_primitives/ec_primitives.md
new file mode 100644
index 00000000000..00b8071487e
--- /dev/null
+++ b/docs/versioned_docs/version-v1.0.0-beta.0/noir/standard_library/cryptographic_primitives/ec_primitives.md
@@ -0,0 +1,101 @@
+---
+title: Elliptic Curve Primitives
+keywords: [cryptographic primitives, Noir project]
+sidebar_position: 4
+---
+
+Data structures and methods on them that allow you to carry out computations involving elliptic
+curves over the (mathematical) field corresponding to `Field`. For the field currently at our
+disposal, applications would involve a curve embedded in BN254, e.g. the
+[Baby Jubjub curve](https://eips.ethereum.org/EIPS/eip-2494).
+
+## Data structures
+
+### Elliptic curve configurations
+
+(`std::ec::{tecurve,montcurve,swcurve}::{affine,curvegroup}::Curve`), i.e. the specific elliptic
+curve you want to use, which would be specified using any one of the methods
+`std::ec::{tecurve,montcurve,swcurve}::{affine,curvegroup}::new` which take the coefficients in the
+defining equation together with a generator point as parameters. You can find more detail in the
+comments in
+[`noir_stdlib/src/ec/mod.nr`](https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/ec/mod.nr), but
+the gist of it is that the elliptic curves of interest are usually expressed in one of the standard
+forms implemented here (Twisted Edwards, Montgomery and Short Weierstraß), and in addition to that,
+you could choose to use `affine` coordinates (Cartesian coordinates - the usual (x,y) - possibly
+together with a point at infinity) or `curvegroup` coordinates (some form of projective coordinates
+requiring more coordinates but allowing for more efficient implementations of elliptic curve
+operations). Conversions between all of these forms are provided, and under the hood these
+conversions are done whenever an operation is more efficient in a different representation (or a
+mixed coordinate representation is employed).
+
+### Points
+
+(`std::ec::{tecurve,montcurve,swcurve}::{affine,curvegroup}::Point`), i.e. points lying on the
+elliptic curve. For a curve configuration `c` and a point `p`, it may be checked that `p`
+does indeed lie on `c` by calling `c.contains(p1)`.
+
+## Methods
+
+(given a choice of curve representation, e.g. use `std::ec::tecurve::affine::Curve` and use
+`std::ec::tecurve::affine::Point`)
+
+- The **zero element** is given by `Point::zero()`, and we can verify whether a point `p: Point` is
+  zero by calling `p.is_zero()`.
+- **Equality**: Points `p1: Point` and `p2: Point` may be checked for equality by calling
+  `p1.eq(p2)`.
+- **Addition**: For `c: Curve` and points `p1: Point` and `p2: Point` on the curve, adding these two
+  points is accomplished by calling `c.add(p1,p2)`.
+- **Negation**: For a point `p: Point`, `p.negate()` is its negation.
+- **Subtraction**: For `c` and `p1`, `p2` as above, subtracting `p2` from `p1` is accomplished by
+  calling `c.subtract(p1,p2)`.
+- **Scalar multiplication**: For `c` as above, `p: Point` a point on the curve and `n: Field`,
+  scalar multiplication is given by `c.mul(n,p)`. If instead `n :: [u1; N]`, i.e. `n` is a bit
+  array, the `bit_mul` method may be used instead: `c.bit_mul(n,p)`
+- **Multi-scalar multiplication**: For `c` as above and arrays `n: [Field; N]` and `p: [Point; N]`,
+  multi-scalar multiplication is given by `c.msm(n,p)`.
+- **Coordinate representation conversions**: The `into_group` method converts a point or curve
+  configuration in the affine representation to one in the CurveGroup representation, and
+  `into_affine` goes in the other direction.
+- **Curve representation conversions**: `tecurve` and `montcurve` curves and points are equivalent
+  and may be converted between one another by calling `into_montcurve` or `into_tecurve` on their
+  configurations or points. `swcurve` is more general and a curve c of one of the other two types
+  may be converted to this representation by calling `c.into_swcurve()`, whereas a point `p` lying
+  on the curve given by `c` may be mapped to its corresponding `swcurve` point by calling
+  `c.map_into_swcurve(p)`.
+- **Map-to-curve methods**: The Elligator 2 method of mapping a field element `n: Field` into a
+  `tecurve` or `montcurve` with configuration `c` may be called as `c.elligator2_map(n)`. For all of
+  the curve configurations, the SWU map-to-curve method may be called as `c.swu_map(z,n)`, where
+  `z: Field` depends on `Field` and `c` and must be chosen by the user (the conditions it needs to
+  satisfy are specified in the comments
+  [here](https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/ec/mod.nr)).
+
+## Examples
+
+The
+[ec_baby_jubjub test](https://github.com/noir-lang/noir/blob/master/test_programs/compile_success_empty/ec_baby_jubjub/src/main.nr)
+illustrates all of the above primitives on various forms of the Baby Jubjub curve. A couple of more
+interesting examples in Noir would be:
+
+Public-key cryptography: Given an elliptic curve and a 'base point' on it, determine the public key
+from the private key. This is a matter of using scalar multiplication. In the case of Baby Jubjub,
+for example, this code would do:
+
+```rust
+use std::ec::tecurve::affine::{Curve, Point};
+
+fn bjj_pub_key(priv_key: Field) -> Point
+{
+
+ let bjj = Curve::new(168700, 168696, G::new(995203441582195749578291179787384436505546430278305826713579947235728471134,5472060717959818805561601436314318772137091100104008585924551046643952123905));
+
+ let base_pt = Point::new(5299619240641551281634865583518297030282874472190772894086521144482721001553, 16950150798460657717958625567821834550301663161624707787222815936182638968203);
+
+ bjj.mul(priv_key,base_pt)
+}
+```
+
+This would come in handy in a Merkle proof.
+
+- EdDSA signature verification: This is a matter of combining these primitives with a suitable hash
+  function. See the [eddsa](https://github.com/noir-lang/eddsa) library an example of eddsa signature verification
+  over the Baby Jubjub curve.
diff --git a/docs/versioned_docs/version-v1.0.0-beta.0/noir/standard_library/cryptographic_primitives/ecdsa_sig_verification.mdx b/docs/versioned_docs/version-v1.0.0-beta.0/noir/standard_library/cryptographic_primitives/ecdsa_sig_verification.mdx
new file mode 100644
index 00000000000..8d96027b42c
--- /dev/null
+++ b/docs/versioned_docs/version-v1.0.0-beta.0/noir/standard_library/cryptographic_primitives/ecdsa_sig_verification.mdx
@@ -0,0 +1,98 @@
+---
+title: ECDSA Signature Verification
+description: Learn about the cryptographic primitives regarding ECDSA over the secp256k1 and secp256r1 curves
+keywords: [cryptographic primitives, Noir project, ecdsa, secp256k1, secp256r1, signatures]
+sidebar_position: 3
+---
+
+import BlackBoxInfo from '@site/src/components/Notes/_blackbox';
+
+Noir supports ECDSA signatures verification over the secp256k1 and secp256r1 curves.
+
+## ecdsa_secp256k1::verify_signature
+
+Verifier for ECDSA Secp256k1 signatures.
+See ecdsa_secp256k1::verify_signature_slice for a version that accepts slices directly.
+
+```rust title="ecdsa_secp256k1" showLineNumbers 
+pub fn verify_signature<let N: u32>(
+    public_key_x: [u8; 32],
+    public_key_y: [u8; 32],
+    signature: [u8; 64],
+    message_hash: [u8; N],
+) -> bool
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/ecdsa_secp256k1.nr#L2-L9" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/ecdsa_secp256k1.nr#L2-L9</a></sub></sup>
+
+
+example:
+
+```rust
+fn main(hashed_message : [u8;32], pub_key_x : [u8;32], pub_key_y : [u8;32], signature : [u8;64]) {
+     let valid_signature = std::ecdsa_secp256k1::verify_signature(pub_key_x, pub_key_y, signature, hashed_message);
+     assert(valid_signature);
+}
+```
+
+<BlackBoxInfo to="../black_box_fns" />
+
+## ecdsa_secp256k1::verify_signature_slice
+
+Verifier for ECDSA Secp256k1 signatures where the message is a slice.
+
+```rust title="ecdsa_secp256k1_slice" showLineNumbers 
+pub fn verify_signature_slice(
+    public_key_x: [u8; 32],
+    public_key_y: [u8; 32],
+    signature: [u8; 64],
+    message_hash: [u8],
+) -> bool
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/ecdsa_secp256k1.nr#L13-L20" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/ecdsa_secp256k1.nr#L13-L20</a></sub></sup>
+
+
+<BlackBoxInfo to="../black_box_fns"/>
+
+## ecdsa_secp256r1::verify_signature
+
+Verifier for ECDSA Secp256r1 signatures.
+See ecdsa_secp256r1::verify_signature_slice for a version that accepts slices directly.
+
+```rust title="ecdsa_secp256r1" showLineNumbers 
+pub fn verify_signature<let N: u32>(
+    public_key_x: [u8; 32],
+    public_key_y: [u8; 32],
+    signature: [u8; 64],
+    message_hash: [u8; N],
+) -> bool
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/ecdsa_secp256r1.nr#L2-L9" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/ecdsa_secp256r1.nr#L2-L9</a></sub></sup>
+
+
+example:
+
+```rust
+fn main(hashed_message : [u8;32], pub_key_x : [u8;32], pub_key_y : [u8;32], signature : [u8;64]) {
+     let valid_signature = std::ecdsa_secp256r1::verify_signature(pub_key_x, pub_key_y, signature, hashed_message);
+     assert(valid_signature);
+}
+```
+
+<BlackBoxInfo to="../black_box_fns"/>
+
+## ecdsa_secp256r1::verify_signature
+
+Verifier for ECDSA Secp256r1 signatures where the message is a slice.
+
+```rust title="ecdsa_secp256r1_slice" showLineNumbers 
+pub fn verify_signature_slice(
+    public_key_x: [u8; 32],
+    public_key_y: [u8; 32],
+    signature: [u8; 64],
+    message_hash: [u8],
+) -> bool
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/ecdsa_secp256r1.nr#L13-L20" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/ecdsa_secp256r1.nr#L13-L20</a></sub></sup>
+
+
+<BlackBoxInfo to="../black_box_fns"/>
diff --git a/docs/versioned_docs/version-v1.0.0-beta.0/noir/standard_library/cryptographic_primitives/embedded_curve_ops.mdx b/docs/versioned_docs/version-v1.0.0-beta.0/noir/standard_library/cryptographic_primitives/embedded_curve_ops.mdx
new file mode 100644
index 00000000000..482a36932b9
--- /dev/null
+++ b/docs/versioned_docs/version-v1.0.0-beta.0/noir/standard_library/cryptographic_primitives/embedded_curve_ops.mdx
@@ -0,0 +1,95 @@
+---
+title: Scalar multiplication
+description: See how you can perform scalar multiplication in Noir
+keywords: [cryptographic primitives, Noir project, scalar multiplication]
+sidebar_position: 1
+---
+
+import BlackBoxInfo from '@site/src/components/Notes/_blackbox';
+
+The following functions perform operations over the embedded curve whose coordinates are defined by the configured noir field.
+For the BN254 scalar field, this is BabyJubJub or Grumpkin.
+
+:::note
+Suffixes `_low` and `_high` denote low and high limbs of a scalar.
+:::
+
+## embedded_curve_ops::multi_scalar_mul
+
+Performs multi scalar multiplication over the embedded curve.
+The function accepts arbitrary amount of point-scalar pairs on the input, it multiplies the individual pairs over
+the curve and returns a sum of the resulting points.
+
+Points represented as x and y coordinates [x1, y1, x2, y2, ...], scalars as low and high limbs [low1, high1, low2, high2, ...].
+
+```rust title="multi_scalar_mul" showLineNumbers 
+pub fn multi_scalar_mul<let N: u32>(
+    points: [EmbeddedCurvePoint; N],
+    scalars: [EmbeddedCurveScalar; N],
+) -> EmbeddedCurvePoint
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/embedded_curve_ops.nr#L103-L108" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/embedded_curve_ops.nr#L103-L108</a></sub></sup>
+
+
+example
+
+```rust
+fn main(point_x: Field, point_y: Field, scalar_low: Field, scalar_high: Field) {
+    let point = std::embedded_curve_ops::multi_scalar_mul([point_x, point_y], [scalar_low, scalar_high]);
+    println(point);
+}
+```
+
+## embedded_curve_ops::fixed_base_scalar_mul
+
+Performs fixed base scalar multiplication over the embedded curve (multiplies input scalar with a generator point).
+The function accepts a single scalar on the input represented as 2 fields.
+
+```rust title="fixed_base_scalar_mul" showLineNumbers 
+pub fn fixed_base_scalar_mul(scalar: EmbeddedCurveScalar) -> EmbeddedCurvePoint
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/embedded_curve_ops.nr#L120-L122" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/embedded_curve_ops.nr#L120-L122</a></sub></sup>
+
+
+example
+
+```rust
+fn main(scalar_low: Field, scalar_high: Field) {
+    let point = std::embedded_curve_ops::fixed_base_scalar_mul(scalar_low, scalar_high);
+    println(point);
+}
+```
+
+## embedded_curve_ops::embedded_curve_add
+
+Adds two points on the embedded curve.
+This function takes two `EmbeddedCurvePoint` structures as parameters, representing points on the curve, and returns a new `EmbeddedCurvePoint` structure that represents their sum.
+
+### Parameters:
+- `point1` (`EmbeddedCurvePoint`): The first point to add.
+- `point2` (`EmbeddedCurvePoint`): The second point to add.
+
+### Returns:
+- `EmbeddedCurvePoint`: The resulting point after the addition of `point1` and `point2`.
+
+```rust title="embedded_curve_add" showLineNumbers 
+pub fn embedded_curve_add(
+    point1: EmbeddedCurvePoint,
+    point2: EmbeddedCurvePoint,
+) -> EmbeddedCurvePoint {
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/embedded_curve_ops.nr#L136-L141" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/embedded_curve_ops.nr#L136-L141</a></sub></sup>
+
+
+example
+
+```rust
+fn main() {
+    let point1 = EmbeddedCurvePoint { x: 1, y: 2 };
+    let point2 = EmbeddedCurvePoint { x: 3, y: 4 };
+    let result = std::embedded_curve_ops::embedded_curve_add(point1, point2);
+    println!("Resulting Point: ({}, {})", result.x, result.y);
+}
+```
+
+<BlackBoxInfo to="../black_box_fns"/>
diff --git a/docs/versioned_docs/version-v1.0.0-beta.0/noir/standard_library/cryptographic_primitives/hashes.mdx b/docs/versioned_docs/version-v1.0.0-beta.0/noir/standard_library/cryptographic_primitives/hashes.mdx
new file mode 100644
index 00000000000..541a1971561
--- /dev/null
+++ b/docs/versioned_docs/version-v1.0.0-beta.0/noir/standard_library/cryptographic_primitives/hashes.mdx
@@ -0,0 +1,227 @@
+---
+title: Hash methods
+description:
+  Learn about the cryptographic primitives ready to use for any Noir project, including sha256,
+  blake2s and pedersen
+keywords:
+  [cryptographic primitives, Noir project, sha256, blake2s, pedersen, hash]
+sidebar_position: 0
+---
+
+import BlackBoxInfo from '@site/src/components/Notes/_blackbox';
+
+## sha256
+
+Given an array of bytes, returns the resulting sha256 hash.
+Specify a message_size to hash only the first `message_size` bytes of the input.
+
+```rust title="sha256" showLineNumbers 
+pub fn sha256<let N: u32>(input: [u8; N]) -> HASH
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/hash/sha256.nr#L47-L49" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/hash/sha256.nr#L47-L49</a></sub></sup>
+
+
+example:
+```rust title="sha256_var" showLineNumbers 
+let digest = std::hash::sha256_var([x as u8], 1);
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/test_programs/execution_success/sha256/src/main.nr#L15-L17" target="_blank" rel="noopener noreferrer">Source code: test_programs/execution_success/sha256/src/main.nr#L15-L17</a></sub></sup>
+
+
+```rust
+fn main() {
+    let x = [163, 117, 178, 149]; // some random bytes
+    let hash = std::sha256::sha256_var(x, 4);
+}
+```
+
+
+<BlackBoxInfo to="../black_box_fns"/>
+
+## blake2s
+
+Given an array of bytes, returns an array with the Blake2 hash
+
+```rust title="blake2s" showLineNumbers 
+pub fn blake2s<let N: u32>(input: [u8; N]) -> [u8; 32]
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/hash/mod.nr#L18-L20" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/hash/mod.nr#L18-L20</a></sub></sup>
+
+
+example:
+
+```rust
+fn main() {
+    let x = [163, 117, 178, 149]; // some random bytes
+    let hash = std::hash::blake2s(x);
+}
+```
+
+<BlackBoxInfo to="../black_box_fns"/>
+
+## blake3
+
+Given an array of bytes, returns an array with the Blake3 hash
+
+```rust title="blake3" showLineNumbers 
+pub fn blake3<let N: u32>(input: [u8; N]) -> [u8; 32]
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/hash/mod.nr#L24-L26" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/hash/mod.nr#L24-L26</a></sub></sup>
+
+
+example:
+
+```rust
+fn main() {
+    let x = [163, 117, 178, 149]; // some random bytes
+    let hash = std::hash::blake3(x);
+}
+```
+
+<BlackBoxInfo to="../black_box_fns"/>
+
+## pedersen_hash
+
+Given an array of Fields, returns the Pedersen hash.
+
+```rust title="pedersen_hash" showLineNumbers 
+pub fn pedersen_hash<let N: u32>(input: [Field; N]) -> Field
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/hash/mod.nr#L49-L51" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/hash/mod.nr#L49-L51</a></sub></sup>
+
+
+example:
+
+```rust title="pedersen-hash" showLineNumbers 
+fn main(x: Field, y: Field, expected_hash: Field) {
+    let hash = std::hash::pedersen_hash([x, y]);
+    assert_eq(hash, expected_hash);
+}
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/test_programs/execution_success/pedersen_hash/src/main.nr#L1-L6" target="_blank" rel="noopener noreferrer">Source code: test_programs/execution_success/pedersen_hash/src/main.nr#L1-L6</a></sub></sup>
+
+
+<BlackBoxInfo to="../black_box_fns" />
+
+## pedersen_commitment
+
+Given an array of Fields, returns the Pedersen commitment.
+
+```rust title="pedersen_commitment" showLineNumbers 
+pub fn pedersen_commitment<let N: u32>(input: [Field; N]) -> EmbeddedCurvePoint {
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/hash/mod.nr#L29-L31" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/hash/mod.nr#L29-L31</a></sub></sup>
+
+
+example:
+
+```rust title="pedersen-commitment" showLineNumbers 
+fn main(x: Field, y: Field, expected_commitment: std::embedded_curve_ops::EmbeddedCurvePoint) {
+    let commitment = std::hash::pedersen_commitment([x, y]);
+    assert_eq(commitment.x, expected_commitment.x);
+    assert_eq(commitment.y, expected_commitment.y);
+}
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/test_programs/execution_success/pedersen_commitment/src/main.nr#L1-L7" target="_blank" rel="noopener noreferrer">Source code: test_programs/execution_success/pedersen_commitment/src/main.nr#L1-L7</a></sub></sup>
+
+
+<BlackBoxInfo to="../black_box_fns"/>
+
+## keccak256
+
+Given an array of bytes (`u8`), returns the resulting keccak hash as an array of
+32 bytes (`[u8; 32]`). Specify a message_size to hash only the first
+`message_size` bytes of the input.
+
+```rust title="keccak256" showLineNumbers 
+pub fn keccak256<let N: u32>(input: [u8; N], message_size: u32) -> [u8; 32]
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/hash/mod.nr#L116-L118" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/hash/mod.nr#L116-L118</a></sub></sup>
+
+
+example:
+
+```rust title="keccak256" showLineNumbers 
+fn main(x: Field, result: [u8; 32]) {
+    // We use the `as` keyword here to denote the fact that we want to take just the first byte from the x Field
+    // The padding is taken care of by the program
+    let digest = std::hash::keccak256([x as u8], 1);
+    assert(digest == result);
+
+    //#1399: variable message size
+    let message_size = 4;
+    let hash_a = std::hash::keccak256([1, 2, 3, 4], message_size);
+    let hash_b = std::hash::keccak256([1, 2, 3, 4, 0, 0, 0, 0], message_size);
+
+    assert(hash_a == hash_b);
+
+    let message_size_big = 8;
+    let hash_c = std::hash::keccak256([1, 2, 3, 4, 0, 0, 0, 0], message_size_big);
+
+    assert(hash_a != hash_c);
+}
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/test_programs/execution_success/keccak256/src/main.nr#L1-L20" target="_blank" rel="noopener noreferrer">Source code: test_programs/execution_success/keccak256/src/main.nr#L1-L20</a></sub></sup>
+
+
+<BlackBoxInfo to="../black_box_fns"/>
+
+## poseidon
+
+Given an array of Fields, returns a new Field with the Poseidon Hash. Mind that you need to specify
+how many inputs are there to your Poseidon function.
+
+```rust
+// example for hash_1, hash_2 accepts an array of length 2, etc
+fn hash_1(input: [Field; 1]) -> Field
+```
+
+example:
+
+```rust title="poseidon" showLineNumbers 
+use std::hash::poseidon;
+
+fn main(x1: [Field; 2], y1: pub Field, x2: [Field; 4], y2: pub Field) {
+    let hash1 = poseidon::bn254::hash_2(x1);
+    assert(hash1 == y1);
+
+    let hash2 = poseidon::bn254::hash_4(x2);
+    assert(hash2 == y2);
+}
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/test_programs/execution_success/poseidon_bn254_hash/src/main.nr#L1-L11" target="_blank" rel="noopener noreferrer">Source code: test_programs/execution_success/poseidon_bn254_hash/src/main.nr#L1-L11</a></sub></sup>
+
+
+## poseidon 2
+
+Given an array of Fields, returns a new Field with the Poseidon2 Hash. Contrary to the Poseidon
+function, there is only one hash and you can specify a message_size to hash only the first 
+`message_size` bytes of the input,
+
+```rust
+// example for hashing the first three elements of the input
+Poseidon2::hash(input, 3);
+```
+
+example:
+
+```rust title="poseidon2" showLineNumbers 
+use std::hash::poseidon2;
+
+fn main(inputs: [Field; 4], expected_hash: Field) {
+    let hash = poseidon2::Poseidon2::hash(inputs, inputs.len());
+    assert_eq(hash, expected_hash);
+}
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/test_programs/execution_success/poseidon2/src/main.nr#L1-L8" target="_blank" rel="noopener noreferrer">Source code: test_programs/execution_success/poseidon2/src/main.nr#L1-L8</a></sub></sup>
+
+
+## hash_to_field
+
+```rust
+fn hash_to_field(_input : [Field]) -> Field {}
+```
+
+Calculates the `blake2s` hash of the inputs and returns the hash modulo the field modulus to return
+a value which can be represented as a `Field`.
+
diff --git a/docs/versioned_docs/version-v1.0.0-beta.0/noir/standard_library/cryptographic_primitives/index.md b/docs/versioned_docs/version-v1.0.0-beta.0/noir/standard_library/cryptographic_primitives/index.md
new file mode 100644
index 00000000000..650f30165d5
--- /dev/null
+++ b/docs/versioned_docs/version-v1.0.0-beta.0/noir/standard_library/cryptographic_primitives/index.md
@@ -0,0 +1,14 @@
+---
+title: Cryptographic Primitives
+description:
+  Learn about the cryptographic primitives ready to use for any Noir project
+keywords:
+  [
+    cryptographic primitives,
+    Noir project,
+  ]
+---
+
+The Noir team is progressively adding new cryptographic primitives to the standard library. Reach out for news or if you would be interested in adding more of these calculations in Noir.
+
+Some methods are available thanks to the Aztec backend, not being performed using Noir. When using other backends, these methods may or may not be supplied.
diff --git a/docs/versioned_docs/version-v1.0.0-beta.0/noir/standard_library/cryptographic_primitives/schnorr.mdx b/docs/versioned_docs/version-v1.0.0-beta.0/noir/standard_library/cryptographic_primitives/schnorr.mdx
new file mode 100644
index 00000000000..030452645c5
--- /dev/null
+++ b/docs/versioned_docs/version-v1.0.0-beta.0/noir/standard_library/cryptographic_primitives/schnorr.mdx
@@ -0,0 +1,64 @@
+---
+title: Schnorr Signatures
+description: Learn how you can verify Schnorr signatures using Noir
+keywords: [cryptographic primitives, Noir project, schnorr, signatures]
+sidebar_position: 2
+---
+
+import BlackBoxInfo from '@site/src/components/Notes/_blackbox';
+
+## schnorr::verify_signature
+
+Verifier for Schnorr signatures over the embedded curve (for BN254 it is Grumpkin).
+See schnorr::verify_signature_slice for a version that works directly on slices.
+
+```rust title="schnorr_verify" showLineNumbers 
+pub fn verify_signature<let N: u32>(
+    public_key_x: Field,
+    public_key_y: Field,
+    signature: [u8; 64],
+    message: [u8; N],
+) -> bool
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/schnorr.nr#L4-L11" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/schnorr.nr#L4-L11</a></sub></sup>
+
+
+where `_signature` can be generated like so using the npm package
+[@noir-lang/barretenberg](https://www.npmjs.com/package/@noir-lang/barretenberg)
+
+```js
+const { BarretenbergWasm } = require('@noir-lang/barretenberg/dest/wasm');
+const { Schnorr } = require('@noir-lang/barretenberg/dest/crypto/schnorr');
+
+...
+
+const barretenberg = await BarretenbergWasm.new();
+const schnorr = new Schnorr(barretenberg);
+const pubKey = schnorr.computePublicKey(privateKey);
+const message = ...
+const signature = Array.from(
+    schnorr.constructSignature(hash, privateKey).toBuffer()
+);
+
+...
+```
+
+<BlackBoxInfo to="../black_box_fns"/>
+
+## schnorr::verify_signature_slice
+
+Verifier for Schnorr signatures over the embedded curve (for BN254 it is Grumpkin)
+where the message is a slice. 
+
+```rust title="schnorr_verify_slice" showLineNumbers 
+pub fn verify_signature_slice(
+    public_key_x: Field,
+    public_key_y: Field,
+    signature: [u8; 64],
+    message: [u8],
+) -> bool
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/schnorr.nr#L15-L22" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/schnorr.nr#L15-L22</a></sub></sup>
+
+
+<BlackBoxInfo to="../black_box_fns"/>
diff --git a/docs/versioned_docs/version-v1.0.0-beta.0/noir/standard_library/fmtstr.md b/docs/versioned_docs/version-v1.0.0-beta.0/noir/standard_library/fmtstr.md
new file mode 100644
index 00000000000..19809d60261
--- /dev/null
+++ b/docs/versioned_docs/version-v1.0.0-beta.0/noir/standard_library/fmtstr.md
@@ -0,0 +1,17 @@
+---
+title: fmtstr
+---
+
+`fmtstr<N, T>` is the type resulting from using format string (`f"..."`).
+
+## Methods
+
+### quoted_contents
+
+```rust title="quoted_contents" showLineNumbers 
+pub comptime fn quoted_contents(self) -> Quoted {}
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/meta/format_string.nr#L3-L5" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/meta/format_string.nr#L3-L5</a></sub></sup>
+
+
+Returns the format string contents (that is, without the leading and trailing double quotes) as a `Quoted` value.
\ No newline at end of file
diff --git a/docs/versioned_docs/version-v1.0.0-beta.0/noir/standard_library/is_unconstrained.md b/docs/versioned_docs/version-v1.0.0-beta.0/noir/standard_library/is_unconstrained.md
new file mode 100644
index 00000000000..51bb1bda8f1
--- /dev/null
+++ b/docs/versioned_docs/version-v1.0.0-beta.0/noir/standard_library/is_unconstrained.md
@@ -0,0 +1,69 @@
+---
+title: Is Unconstrained Function
+description:
+  The is_unconstrained function returns wether the context at that point of the program is unconstrained or not.
+keywords:
+  [
+    unconstrained
+  ]
+---
+
+It's very common for functions in circuits to take unconstrained hints of an expensive computation and then verify it. This is done by running the hint in an unconstrained context and then verifying the result in a constrained context.
+
+When a function is marked as unconstrained, any subsequent functions that it calls will also be run in an unconstrained context. However, if we are implementing a library function, other users might call it within an unconstrained context or a constrained one. Generally, in an unconstrained context we prefer just computing the result instead of taking a hint of it and verifying it, since that'd mean doing the same computation twice:
+
+```rust 
+
+fn my_expensive_computation(){
+  ...
+}
+
+unconstrained fn my_expensive_computation_hint(){
+  my_expensive_computation()
+}
+
+pub fn external_interface(){
+  my_expensive_computation_hint();
+  // verify my_expensive_computation: If external_interface is called from unconstrained, this is redundant
+  ...
+}
+
+```
+
+In order to improve the performance in an unconstrained context you can use the function at `std::runtime::is_unconstrained() -> bool`:
+
+
+```rust 
+use dep::std::runtime::is_unconstrained;
+
+fn my_expensive_computation(){
+  ...
+}
+
+unconstrained fn my_expensive_computation_hint(){
+  my_expensive_computation()
+}
+
+pub fn external_interface(){
+  if is_unconstrained() {
+    my_expensive_computation();
+  } else {
+    my_expensive_computation_hint();
+    // verify my_expensive_computation
+    ...
+  }
+}
+
+```
+
+The is_unconstrained result is resolved at compile time, so in unconstrained contexts the compiler removes the else branch, and in constrained contexts the compiler removes the if branch, reducing the amount of compute necessary to run external_interface.
+
+Note that using `is_unconstrained` in a `comptime` context will also return `true`:
+
+```
+fn main() {
+    comptime {
+        assert(is_unconstrained());
+    }
+}
+```
diff --git a/docs/versioned_docs/version-v1.0.0-beta.0/noir/standard_library/logging.md b/docs/versioned_docs/version-v1.0.0-beta.0/noir/standard_library/logging.md
new file mode 100644
index 00000000000..db75ef9f86f
--- /dev/null
+++ b/docs/versioned_docs/version-v1.0.0-beta.0/noir/standard_library/logging.md
@@ -0,0 +1,78 @@
+---
+title: Logging
+description:
+  Learn how to use the println statement for debugging in Noir with this tutorial. Understand the
+  basics of logging in Noir and how to implement it in your code.
+keywords:
+  [
+    noir logging,
+    println statement,
+    print statement,
+    debugging in noir,
+    noir std library,
+    logging tutorial,
+    basic logging in noir,
+    noir logging implementation,
+    noir debugging techniques,
+    rust,
+  ]
+---
+
+The standard library provides two familiar statements you can use: `println` and `print`. Despite being a limited implementation of rust's `println!` and `print!` macros, these constructs can be useful for debugging.
+
+You can print the output of both statements in your Noir code by using the `nargo execute` command or the `--show-output` flag when using `nargo test` (provided there are print statements in your tests).
+
+It is recommended to use `nargo execute` if you want to debug failing constraints with `println` or `print` statements. This is due to every input in a test being a constant rather than a witness, so we issue an error during compilation while we only print during execution (which comes after compilation). Neither `println`, nor `print` are callable for failed constraints caught at compile time.
+
+Both `print` and `println` are generic functions which can work on integers, fields, strings, and even structs or expressions. Note however, that slices are currently unsupported. For example:
+
+```rust
+struct Person {
+    age: Field,
+    height: Field,
+}
+
+fn main(age: Field, height: Field) {
+    let person = Person {
+        age: age,
+        height: height,
+    };
+    println(person);
+    println(age + height);
+    println("Hello world!");
+}
+```
+
+You can print different types in the same statement (including strings) with a type called `fmtstr`. It can be specified in the same way as a normal string, just prepended with an "f" character:
+
+```rust
+  let fmt_str = f"i: {i}, j: {j}";
+  println(fmt_str);
+
+  let s = myStruct { y: x, x: y };
+  println(s);
+
+  println(f"i: {i}, s: {s}");
+
+  println(x);
+  println([x, y]);
+
+  let foo = fooStruct { my_struct: s, foo: 15 };
+  println(f"s: {s}, foo: {foo}");
+
+  println(15);       // prints 0x0f, implicit Field
+  println(-1 as u8); // prints 255
+  println(-1 as i8); // prints -1
+```
+
+Examples shown above are interchangeable between the two `print` statements:
+
+```rust
+let person = Person { age : age, height : height };
+
+println(person);
+print(person);
+
+println("Hello world!"); // Prints with a newline at the end of the input
+print("Hello world!");   // Prints the input and keeps cursor on the same line
+```
diff --git a/docs/versioned_docs/version-v1.0.0-beta.0/noir/standard_library/mem.md b/docs/versioned_docs/version-v1.0.0-beta.0/noir/standard_library/mem.md
new file mode 100644
index 00000000000..3619550273e
--- /dev/null
+++ b/docs/versioned_docs/version-v1.0.0-beta.0/noir/standard_library/mem.md
@@ -0,0 +1,82 @@
+---
+title: Memory Module
+description:
+  This module contains functions which manipulate memory in a low-level way
+keywords:
+  [
+    mem, memory, zeroed, transmute, checked_transmute
+  ]
+---
+
+# `std::mem::zeroed`
+
+```rust
+fn zeroed<T>() -> T
+```
+
+Returns a zeroed value of any type.
+This function is generally unsafe to use as the zeroed bit pattern is not guaranteed to be valid for all types.
+It can however, be useful in cases when the value is guaranteed not to be used such as in a BoundedVec library implementing a growable vector, up to a certain length, backed by an array.
+The array can be initialized with zeroed values which are guaranteed to be inaccessible until the vector is pushed to.
+Similarly, enumerations in noir can be implemented using this method by providing zeroed values for the unused variants.
+
+This function currently supports the following types:
+
+- Field
+- Bool
+- Uint
+- Array
+- Slice
+- String
+- Tuple
+- Functions
+  
+Using it on other types could result in unexpected behavior.
+
+# `std::mem::checked_transmute`
+
+```rust
+fn checked_transmute<T, U>(value: T) -> U
+```
+
+Transmutes a value of one type into the same value but with a new type `U`.
+
+This function is safe to use since both types are asserted to be equal later during compilation after the concrete values for generic types become known.
+This function is useful for cases where the compiler may fails a type check that is expected to pass where
+a user knows the two types to be equal. For example, when using arithmetic generics there are cases the compiler
+does not see as equal, such as `[Field; N*(A + B)]` and `[Field; N*A + N*B]`, which users may know to be equal.
+In these cases, `checked_transmute` can be used to cast the value to the desired type while also preserving safety
+by checking this equality once `N`, `A`, `B` are fully resolved.
+
+Note that since this safety check is performed after type checking rather than during, no error is issued if the function
+containing `checked_transmute` is never called.
+
+# `std::mem::array_refcount`
+
+```rust
+fn array_refcount<T, let N: u32>(array: [T; N]) -> u32 {}
+```
+
+Returns the internal reference count of an array value in unconstrained code.
+
+Arrays only have reference count in unconstrained code - using this anywhere
+else will return zero.
+
+This function is mostly intended for debugging compiler optimizations but can also be used
+to find where array copies may be happening in unconstrained code by placing it before array
+mutations.
+
+# `std::mem::slice_refcount`
+
+```rust
+fn slice_refcount<T>(slice: [T]) -> u32 {}
+```
+
+Returns the internal reference count of a slice value in unconstrained code.
+
+Slices only have reference count in unconstrained code - using this anywhere
+else will return zero.
+
+This function is mostly intended for debugging compiler optimizations but can also be used
+to find where slice copies may be happening in unconstrained code by placing it before slice
+mutations.
diff --git a/docs/versioned_docs/version-v1.0.0-beta.0/noir/standard_library/merkle_trees.md b/docs/versioned_docs/version-v1.0.0-beta.0/noir/standard_library/merkle_trees.md
new file mode 100644
index 00000000000..6a9ebf72ada
--- /dev/null
+++ b/docs/versioned_docs/version-v1.0.0-beta.0/noir/standard_library/merkle_trees.md
@@ -0,0 +1,58 @@
+---
+title: Merkle Trees
+description: Learn about Merkle Trees in Noir with this tutorial. Explore the basics of computing a merkle root using a proof, with examples.
+keywords:
+  [
+    Merkle trees in Noir,
+    Noir programming language,
+    check membership,
+    computing root from leaf,
+    Noir Merkle tree implementation,
+    Merkle tree tutorial,
+    Merkle tree code examples,
+    Noir libraries,
+    pedersen hash.,
+  ]
+---
+
+## compute_merkle_root
+
+Returns the root of the tree from the provided leaf and its hash path, using a [Pedersen hash](./cryptographic_primitives/hashes.mdx#pedersen_hash).
+
+```rust
+fn compute_merkle_root(leaf : Field, index : Field, hash_path: [Field]) -> Field
+```
+
+example:
+
+```rust
+/**
+    // these values are for this example only
+    index = "0"
+    priv_key = "0x000000000000000000000000000000000000000000000000000000616c696365"
+    secret = "0x1929ea3ab8d9106a899386883d9428f8256cfedb3c4f6b66bf4aa4d28a79988f"
+    note_hash_path = [
+    "0x1e61bdae0f027b1b2159e1f9d3f8d00fa668a952dddd822fda80dc745d6f65cc",
+    "0x0e4223f3925f98934393c74975142bd73079ab0621f4ee133cee050a3c194f1a",
+    "0x2fd7bb412155bf8693a3bd2a3e7581a679c95c68a052f835dddca85fa1569a40"
+    ]
+ */
+fn main(index: Field, priv_key: Field, secret: Field, note_hash_path: [Field; 3]) {
+
+    let pubkey = std::scalar_mul::fixed_base_embedded_curve(priv_key);
+    let pubkey_x = pubkey[0];
+    let pubkey_y = pubkey[1];
+    let note_commitment = std::hash::pedersen(&[pubkey_x, pubkey_y, secret]);
+
+    let root = std::merkle::compute_merkle_root(note_commitment[0], index, note_hash_path.as_slice());
+    println(root);
+}
+```
+
+To check merkle tree membership:
+
+1. Include a merkle root as a program input.
+2. Compute the merkle root of a given leaf, index and hash path.
+3. Assert the merkle roots are equal.
+
+For more info about merkle trees, see the Wikipedia [page](https://en.wikipedia.org/wiki/Merkle_tree).
diff --git a/docs/versioned_docs/version-v1.0.0-beta.0/noir/standard_library/meta/ctstring.md b/docs/versioned_docs/version-v1.0.0-beta.0/noir/standard_library/meta/ctstring.md
new file mode 100644
index 00000000000..b76f873ca03
--- /dev/null
+++ b/docs/versioned_docs/version-v1.0.0-beta.0/noir/standard_library/meta/ctstring.md
@@ -0,0 +1,100 @@
+---
+title: CtString
+---
+
+`std::meta::ctstring` contains methods on the built-in `CtString` type which is
+a compile-time, dynamically-sized string type. Compared to `str<N>` and `fmtstr<N, T>`,
+`CtString` is useful because its size does not need to be specified in its type. This
+can be used for formatting items at compile-time or general string handling in `comptime`
+code.
+
+Since `fmtstr`s can be converted into `CtString`s, you can make use of their formatting
+abilities in CtStrings by formatting in `fmtstr`s then converting the result to a CtString
+afterward.
+
+## Traits
+
+### AsCtString
+
+```rust title="as-ctstring" showLineNumbers 
+pub trait AsCtString {
+    comptime fn as_ctstring(self) -> CtString;
+}
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/meta/ctstring.nr#L43-L47" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/meta/ctstring.nr#L43-L47</a></sub></sup>
+
+
+Converts an object into a compile-time string.
+
+Implementations:
+
+```rust
+impl<let N: u32> AsCtString for str<N> { ... }
+impl<let N: u32, T> AsCtString for fmtstr<N, T> { ... }
+```
+
+## Methods
+
+### new
+
+```rust title="new" showLineNumbers 
+pub comptime fn new() -> Self {
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/meta/ctstring.nr#L4-L6" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/meta/ctstring.nr#L4-L6</a></sub></sup>
+
+
+Creates an empty `CtString`.
+
+### append_str
+
+```rust title="append_str" showLineNumbers 
+pub comptime fn append_str<let N: u32>(self, s: str<N>) -> Self {
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/meta/ctstring.nr#L11-L13" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/meta/ctstring.nr#L11-L13</a></sub></sup>
+
+
+Returns a new CtString with the given str appended onto the end.
+
+### append_fmtstr
+
+```rust title="append_fmtstr" showLineNumbers 
+pub comptime fn append_fmtstr<let N: u32, T>(self, s: fmtstr<N, T>) -> Self {
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/meta/ctstring.nr#L17-L19" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/meta/ctstring.nr#L17-L19</a></sub></sup>
+
+
+Returns a new CtString with the given fmtstr appended onto the end.
+
+### as_quoted_str
+
+```rust title="as_quoted_str" showLineNumbers 
+pub comptime fn as_quoted_str(self) -> Quoted {
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/meta/ctstring.nr#L26-L28" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/meta/ctstring.nr#L26-L28</a></sub></sup>
+
+
+Returns a quoted string literal from this string's contents.
+
+There is no direct conversion from a `CtString` to a `str<N>` since
+the size would not be known. To get around this, this function can
+be used in combination with macro insertion (`!`) to insert this string
+literal at this function's call site.
+
+Example:
+
+```rust title="as_quoted_str_example" showLineNumbers 
+let my_ctstring = "foo bar".as_ctstring();
+            let my_str = my_ctstring.as_quoted_str!();
+
+            assert_eq(crate::meta::type_of(my_str), quote { str<7> }.as_type());
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/meta/ctstring.nr#L92-L97" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/meta/ctstring.nr#L92-L97</a></sub></sup>
+
+
+## Trait Implementations
+
+```rust
+impl Eq for CtString
+impl Hash for CtString
+impl Append for CtString
+```
diff --git a/docs/versioned_docs/version-v1.0.0-beta.0/noir/standard_library/meta/expr.md b/docs/versioned_docs/version-v1.0.0-beta.0/noir/standard_library/meta/expr.md
new file mode 100644
index 00000000000..b6d395c6700
--- /dev/null
+++ b/docs/versioned_docs/version-v1.0.0-beta.0/noir/standard_library/meta/expr.md
@@ -0,0 +1,380 @@
+---
+title: Expr
+---
+
+`std::meta::expr` contains methods on the built-in `Expr` type for quoted, syntactically valid expressions.
+
+## Methods
+
+### as_array
+
+```rust title="as_array" showLineNumbers 
+pub comptime fn as_array(self) -> Option<[Expr]> {}
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/meta/expr.nr#L10-L12" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/meta/expr.nr#L10-L12</a></sub></sup>
+
+
+If this expression is an array, this returns a slice of each element in the array.
+
+### as_assert
+
+```rust title="as_assert" showLineNumbers 
+pub comptime fn as_assert(self) -> Option<(Expr, Option<Expr>)> {}
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/meta/expr.nr#L16-L18" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/meta/expr.nr#L16-L18</a></sub></sup>
+
+
+If this expression is an assert, this returns the assert expression and the optional message.
+
+### as_assert_eq
+
+```rust title="as_assert_eq" showLineNumbers 
+pub comptime fn as_assert_eq(self) -> Option<(Expr, Expr, Option<Expr>)> {}
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/meta/expr.nr#L23-L25" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/meta/expr.nr#L23-L25</a></sub></sup>
+
+
+If this expression is an assert_eq, this returns the left-hand-side and right-hand-side
+expressions, together with the optional message.
+
+### as_assign
+
+```rust title="as_assign" showLineNumbers 
+pub comptime fn as_assign(self) -> Option<(Expr, Expr)> {}
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/meta/expr.nr#L30-L32" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/meta/expr.nr#L30-L32</a></sub></sup>
+
+
+If this expression is an assignment, this returns a tuple with the left hand side
+and right hand side in order.
+
+### as_binary_op
+
+```rust title="as_binary_op" showLineNumbers 
+pub comptime fn as_binary_op(self) -> Option<(Expr, BinaryOp, Expr)> {}
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/meta/expr.nr#L37-L39" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/meta/expr.nr#L37-L39</a></sub></sup>
+
+
+If this expression is a binary operator operation `<lhs> <op> <rhs>`,
+return the left-hand side, operator, and the right-hand side of the operation.
+
+### as_block
+
+```rust title="as_block" showLineNumbers 
+pub comptime fn as_block(self) -> Option<[Expr]> {}
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/meta/expr.nr#L44-L46" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/meta/expr.nr#L44-L46</a></sub></sup>
+
+
+If this expression is a block `{ stmt1; stmt2; ...; stmtN }`, return
+a slice containing each statement.
+
+### as_bool
+
+```rust title="as_bool" showLineNumbers 
+pub comptime fn as_bool(self) -> Option<bool> {}
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/meta/expr.nr#L50-L52" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/meta/expr.nr#L50-L52</a></sub></sup>
+
+
+If this expression is a boolean literal, return that literal.
+
+### as_cast
+
+```rust title="as_cast" showLineNumbers 
+#[builtin(expr_as_cast)]
+    pub comptime fn as_cast(self) -> Option<(Expr, UnresolvedType)> {}
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/meta/expr.nr#L56-L59" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/meta/expr.nr#L56-L59</a></sub></sup>
+
+
+If this expression is a cast expression (`expr as type`), returns the casted
+expression and the type to cast to.
+
+### as_comptime
+
+```rust title="as_comptime" showLineNumbers 
+pub comptime fn as_comptime(self) -> Option<[Expr]> {}
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/meta/expr.nr#L64-L66" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/meta/expr.nr#L64-L66</a></sub></sup>
+
+
+If this expression is a `comptime { stmt1; stmt2; ...; stmtN }` block,
+return each statement in the block.
+
+### as_constructor
+
+```rust title="as_constructor" showLineNumbers 
+pub comptime fn as_constructor(self) -> Option<(UnresolvedType, [(Quoted, Expr)])> {}
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/meta/expr.nr#L71-L73" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/meta/expr.nr#L71-L73</a></sub></sup>
+
+
+If this expression is a constructor `Type { field1: expr1, ..., fieldN: exprN }`,
+return the type and the fields.
+
+### as_for
+
+```rust title="as_for" showLineNumbers 
+pub comptime fn as_for(self) -> Option<(Quoted, Expr, Expr)> {}
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/meta/expr.nr#L78-L80" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/meta/expr.nr#L78-L80</a></sub></sup>
+
+
+If this expression is a for statement over a single expression, return the identifier,
+the expression and the for loop body.
+
+### as_for_range
+
+```rust title="as_for" showLineNumbers 
+pub comptime fn as_for(self) -> Option<(Quoted, Expr, Expr)> {}
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/meta/expr.nr#L78-L80" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/meta/expr.nr#L78-L80</a></sub></sup>
+
+
+If this expression is a for statement over a range, return the identifier,
+the range start, the range end and the for loop body.
+
+### as_function_call
+
+```rust title="as_function_call" showLineNumbers 
+pub comptime fn as_function_call(self) -> Option<(Expr, [Expr])> {}
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/meta/expr.nr#L92-L94" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/meta/expr.nr#L92-L94</a></sub></sup>
+
+
+If this expression is a function call `foo(arg1, ..., argN)`, return
+the function and a slice of each argument.
+
+### as_if
+
+```rust title="as_if" showLineNumbers 
+pub comptime fn as_if(self) -> Option<(Expr, Expr, Option<Expr>)> {}
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/meta/expr.nr#L100-L102" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/meta/expr.nr#L100-L102</a></sub></sup>
+
+
+If this expression is an `if condition { then_branch } else { else_branch }`,
+return the condition, then branch, and else branch. If there is no else branch,
+`None` is returned for that branch instead.
+
+### as_index
+
+```rust title="as_index" showLineNumbers 
+pub comptime fn as_index(self) -> Option<(Expr, Expr)> {}
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/meta/expr.nr#L107-L109" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/meta/expr.nr#L107-L109</a></sub></sup>
+
+
+If this expression is an index into an array `array[index]`, return the
+array and the index.
+
+### as_integer
+
+```rust title="as_integer" showLineNumbers 
+pub comptime fn as_integer(self) -> Option<(Field, bool)> {}
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/meta/expr.nr#L114-L116" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/meta/expr.nr#L114-L116</a></sub></sup>
+
+
+If this expression is an integer literal, return the integer as a field
+as well as whether the integer is negative (true) or not (false).
+
+### as_lambda
+
+```rust title="as_lambda" showLineNumbers 
+pub comptime fn as_lambda(
+        self,
+    ) -> Option<([(Expr, Option<UnresolvedType>)], Option<UnresolvedType>, Expr)> {}
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/meta/expr.nr#L120-L124" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/meta/expr.nr#L120-L124</a></sub></sup>
+
+
+If this expression is a lambda, returns the parameters, return type and body.
+
+### as_let
+
+```rust title="as_let" showLineNumbers 
+pub comptime fn as_let(self) -> Option<(Expr, Option<UnresolvedType>, Expr)> {}
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/meta/expr.nr#L129-L131" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/meta/expr.nr#L129-L131</a></sub></sup>
+
+
+If this expression is a let statement, returns the let pattern as an `Expr`,
+the optional type annotation, and the assigned expression.
+
+### as_member_access
+
+```rust title="as_member_access" showLineNumbers 
+pub comptime fn as_member_access(self) -> Option<(Expr, Quoted)> {}
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/meta/expr.nr#L136-L138" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/meta/expr.nr#L136-L138</a></sub></sup>
+
+
+If this expression is a member access `foo.bar`, return the struct/tuple
+expression and the field. The field will be represented as a quoted value.
+
+### as_method_call
+
+```rust title="as_method_call" showLineNumbers 
+pub comptime fn as_method_call(self) -> Option<(Expr, Quoted, [UnresolvedType], [Expr])> {}
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/meta/expr.nr#L143-L145" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/meta/expr.nr#L143-L145</a></sub></sup>
+
+
+If this expression is a method call `foo.bar::<generic1, ..., genericM>(arg1, ..., argN)`, return
+the receiver, method name, a slice of each generic argument, and a slice of each argument.
+
+### as_repeated_element_array
+
+```rust title="as_repeated_element_array" showLineNumbers 
+pub comptime fn as_repeated_element_array(self) -> Option<(Expr, Expr)> {}
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/meta/expr.nr#L150-L152" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/meta/expr.nr#L150-L152</a></sub></sup>
+
+
+If this expression is a repeated element array `[elem; length]`, return
+the repeated element and the length expressions.
+
+### as_repeated_element_slice
+
+```rust title="as_repeated_element_slice" showLineNumbers 
+pub comptime fn as_repeated_element_slice(self) -> Option<(Expr, Expr)> {}
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/meta/expr.nr#L157-L159" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/meta/expr.nr#L157-L159</a></sub></sup>
+
+
+If this expression is a repeated element slice `[elem; length]`, return
+the repeated element and the length expressions.
+
+### as_slice
+
+```rust title="as_slice" showLineNumbers 
+pub comptime fn as_slice(self) -> Option<[Expr]> {}
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/meta/expr.nr#L164-L166" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/meta/expr.nr#L164-L166</a></sub></sup>
+
+
+If this expression is a slice literal `&[elem1, ..., elemN]`,
+return each element of the slice.
+
+### as_tuple
+
+```rust title="as_tuple" showLineNumbers 
+pub comptime fn as_tuple(self) -> Option<[Expr]> {}
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/meta/expr.nr#L171-L173" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/meta/expr.nr#L171-L173</a></sub></sup>
+
+
+If this expression is a tuple `(field1, ..., fieldN)`,
+return each element of the tuple.
+
+### as_unary_op
+
+```rust title="as_unary_op" showLineNumbers 
+pub comptime fn as_unary_op(self) -> Option<(UnaryOp, Expr)> {}
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/meta/expr.nr#L178-L180" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/meta/expr.nr#L178-L180</a></sub></sup>
+
+
+If this expression is a unary operation `<op> <rhs>`,
+return the unary operator as well as the right-hand side expression.
+
+### as_unsafe
+
+```rust title="as_unsafe" showLineNumbers 
+pub comptime fn as_unsafe(self) -> Option<[Expr]> {}
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/meta/expr.nr#L185-L187" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/meta/expr.nr#L185-L187</a></sub></sup>
+
+
+If this expression is an `unsafe { stmt1; ...; stmtN }` block,
+return each statement inside in a slice.
+
+### has_semicolon
+
+```rust title="has_semicolon" showLineNumbers 
+pub comptime fn has_semicolon(self) -> bool {}
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/meta/expr.nr#L206-L208" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/meta/expr.nr#L206-L208</a></sub></sup>
+
+
+`true` if this expression is trailed by a semicolon. E.g.
+
+```
+comptime {
+    let expr1 = quote { 1 + 2 }.as_expr().unwrap();
+    let expr2 = quote { 1 + 2; }.as_expr().unwrap();
+
+    assert(expr1.as_binary_op().is_some());
+    assert(expr2.as_binary_op().is_some());
+
+    assert(!expr1.has_semicolon());
+    assert(expr2.has_semicolon());
+}
+```
+
+### is_break
+
+```rust title="is_break" showLineNumbers 
+pub comptime fn is_break(self) -> bool {}
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/meta/expr.nr#L212-L214" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/meta/expr.nr#L212-L214</a></sub></sup>
+
+
+`true` if this expression is `break`.
+
+### is_continue
+
+```rust title="is_continue" showLineNumbers 
+pub comptime fn is_continue(self) -> bool {}
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/meta/expr.nr#L218-L220" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/meta/expr.nr#L218-L220</a></sub></sup>
+
+
+`true` if this expression is `continue`.
+
+### modify
+
+```rust title="modify" showLineNumbers 
+pub comptime fn modify<Env>(self, f: fn[Env](Expr) -> Option<Expr>) -> Expr {
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/meta/expr.nr#L229-L231" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/meta/expr.nr#L229-L231</a></sub></sup>
+
+
+Applies a mapping function to this expression and to all of its sub-expressions.
+`f` will be applied to each sub-expression first, then applied to the expression itself.
+
+This happens recursively for every expression within `self`.
+
+For example, calling `modify` on `(&[1], &[2, 3])` with an `f` that returns `Option::some`
+for expressions that are integers, doubling them, would return `(&[2], &[4, 6])`.
+
+### quoted
+
+```rust title="quoted" showLineNumbers 
+pub comptime fn quoted(self) -> Quoted {
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/meta/expr.nr#L266-L268" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/meta/expr.nr#L266-L268</a></sub></sup>
+
+
+Returns this expression as a `Quoted` value. It's the same as `quote { $self }`.
+
+### resolve
+
+```rust title="resolve" showLineNumbers 
+pub comptime fn resolve(self, in_function: Option<FunctionDefinition>) -> TypedExpr {}
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/meta/expr.nr#L282-L284" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/meta/expr.nr#L282-L284</a></sub></sup>
+
+
+Resolves and type-checks this expression and returns the result as a `TypedExpr`. 
+
+The `in_function` argument specifies where the expression is resolved:
+- If it's `none`, the expression is resolved in the function where `resolve` was called
+- If it's `some`, the expression is resolved in the given function
+
+If any names used by this expression are not in scope or if there are any type errors, 
+this will give compiler errors as if the expression was written directly into 
+the current `comptime` function.
\ No newline at end of file
diff --git a/docs/versioned_docs/version-v1.0.0-beta.0/noir/standard_library/meta/function_def.md b/docs/versioned_docs/version-v1.0.0-beta.0/noir/standard_library/meta/function_def.md
new file mode 100644
index 00000000000..b7f2ebdb889
--- /dev/null
+++ b/docs/versioned_docs/version-v1.0.0-beta.0/noir/standard_library/meta/function_def.md
@@ -0,0 +1,166 @@
+---
+title: FunctionDefinition
+---
+
+`std::meta::function_def` contains methods on the built-in `FunctionDefinition` type representing
+a function definition in the source program.
+
+## Methods
+
+### add_attribute
+
+```rust title="add_attribute" showLineNumbers 
+pub comptime fn add_attribute<let N: u32>(self, attribute: str<N>) {}
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/meta/function_def.nr#L3-L5" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/meta/function_def.nr#L3-L5</a></sub></sup>
+
+
+Adds an attribute to the function. This is only valid
+on functions in the current crate which have not yet been resolved.
+This means any functions called at compile-time are invalid targets for this method.
+
+### body
+
+```rust title="body" showLineNumbers 
+pub comptime fn body(self) -> Expr {}
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/meta/function_def.nr#L8-L10" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/meta/function_def.nr#L8-L10</a></sub></sup>
+
+
+Returns the body of the function as an expression. This is only valid
+on functions in the current crate which have not yet been resolved.
+This means any functions called at compile-time are invalid targets for this method.
+
+### has_named_attribute
+
+```rust title="has_named_attribute" showLineNumbers 
+pub comptime fn has_named_attribute<let N: u32>(self, name: str<N>) -> bool {}
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/meta/function_def.nr#L13-L15" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/meta/function_def.nr#L13-L15</a></sub></sup>
+
+
+Returns true if this function has a custom attribute with the given name.
+
+### is_unconstrained
+
+```rust title="is_unconstrained" showLineNumbers 
+pub comptime fn is_unconstrained(self) -> bool {}
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/meta/function_def.nr#L18-L20" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/meta/function_def.nr#L18-L20</a></sub></sup>
+
+
+Returns true if this function is unconstrained.
+
+### module
+
+```rust title="module" showLineNumbers 
+pub comptime fn module(self) -> Module {}
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/meta/function_def.nr#L23-L25" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/meta/function_def.nr#L23-L25</a></sub></sup>
+
+
+Returns the module where the function is defined.
+
+### name
+
+```rust title="name" showLineNumbers 
+pub comptime fn name(self) -> Quoted {}
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/meta/function_def.nr#L28-L30" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/meta/function_def.nr#L28-L30</a></sub></sup>
+
+
+Returns the name of the function.
+
+### parameters
+
+```rust title="parameters" showLineNumbers 
+pub comptime fn parameters(self) -> [(Quoted, Type)] {}
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/meta/function_def.nr#L33-L35" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/meta/function_def.nr#L33-L35</a></sub></sup>
+
+
+Returns each parameter of the function as a tuple of (parameter pattern, parameter type).
+
+### return_type
+
+```rust title="return_type" showLineNumbers 
+pub comptime fn return_type(self) -> Type {}
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/meta/function_def.nr#L38-L40" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/meta/function_def.nr#L38-L40</a></sub></sup>
+
+
+The return type of the function.
+
+### set_body
+
+```rust title="set_body" showLineNumbers 
+pub comptime fn set_body(self, body: Expr) {}
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/meta/function_def.nr#L43-L45" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/meta/function_def.nr#L43-L45</a></sub></sup>
+
+
+Mutate the function body to a new expression. This is only valid
+on functions in the current crate which have not yet been resolved.
+This means any functions called at compile-time are invalid targets for this method.
+
+### set_parameters
+
+```rust title="set_parameters" showLineNumbers 
+pub comptime fn set_parameters(self, parameters: [(Quoted, Type)]) {}
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/meta/function_def.nr#L48-L50" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/meta/function_def.nr#L48-L50</a></sub></sup>
+
+
+Mutates the function's parameters to a new set of parameters. This is only valid
+on functions in the current crate which have not yet been resolved.
+This means any functions called at compile-time are invalid targets for this method.
+
+Expects a slice of (parameter pattern, parameter type) for each parameter. Requires
+each parameter pattern to be a syntactically valid parameter.
+
+### set_return_type
+
+```rust title="set_return_type" showLineNumbers 
+pub comptime fn set_return_type(self, return_type: Type) {}
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/meta/function_def.nr#L53-L55" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/meta/function_def.nr#L53-L55</a></sub></sup>
+
+
+Mutates the function's return type to a new type. This is only valid
+on functions in the current crate which have not yet been resolved.
+This means any functions called at compile-time are invalid targets for this method.
+
+### set_return_public
+
+```rust title="set_return_public" showLineNumbers 
+pub comptime fn set_return_public(self, public: bool) {}
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/meta/function_def.nr#L58-L60" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/meta/function_def.nr#L58-L60</a></sub></sup>
+
+
+Mutates the function's return visibility to public (if `true` is given) or private (if `false` is given).
+This is only valid on functions in the current crate which have not yet been resolved.
+This means any functions called at compile-time are invalid targets for this method.
+
+### set_unconstrained
+
+```rust title="set_unconstrained" showLineNumbers 
+pub comptime fn set_unconstrained(self, value: bool) {}
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/meta/function_def.nr#L66-L68" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/meta/function_def.nr#L66-L68</a></sub></sup>
+
+
+Mutates the function to be unconstrained (if `true` is given) or not (if `false` is given).
+This is only valid on functions in the current crate which have not yet been resolved.
+This means any functions called at compile-time are invalid targets for this method.
+
+## Trait Implementations
+
+```rust
+impl Eq for FunctionDefinition
+impl Hash for FunctionDefinition
+```
+
+Note that each function is assigned a unique ID internally and this is what is used for
+equality and hashing. So even functions with identical signatures and bodies may not
+be equal in this sense if they were originally different items in the source program.
diff --git a/docs/versioned_docs/version-v1.0.0-beta.0/noir/standard_library/meta/index.md b/docs/versioned_docs/version-v1.0.0-beta.0/noir/standard_library/meta/index.md
new file mode 100644
index 00000000000..14544c07442
--- /dev/null
+++ b/docs/versioned_docs/version-v1.0.0-beta.0/noir/standard_library/meta/index.md
@@ -0,0 +1,224 @@
+---
+title: Metaprogramming
+description: Noir's Metaprogramming API
+keywords: [metaprogramming, comptime, macros, macro, quote, unquote]
+---
+
+`std::meta` is the entry point for Noir's metaprogramming API. This consists of `comptime` functions
+and types used for inspecting and modifying Noir programs.
+
+## Functions
+
+### type_of
+
+```rust title="type_of" showLineNumbers 
+pub comptime fn type_of<T>(x: T) -> Type {}
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/meta/mod.nr#L27-L29" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/meta/mod.nr#L27-L29</a></sub></sup>
+
+
+Returns the type of a variable at compile-time.
+
+Example:
+```rust
+comptime {
+    let x: i32 = 1;
+    let x_type: Type = std::meta::type_of(x);
+
+    assert_eq(x_type, quote { i32 }.as_type());
+}
+```
+
+### unquote
+
+```rust title="unquote" showLineNumbers 
+pub comptime fn unquote(code: Quoted) -> Quoted {
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/meta/mod.nr#L19-L21" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/meta/mod.nr#L19-L21</a></sub></sup>
+
+
+Unquotes the passed-in token stream where this function was called.
+
+Example:
+```rust
+comptime {
+    let code = quote { 1 + 2 };
+
+    // let x = 1 + 2;
+    let x = unquote!(code);
+}
+```
+
+### derive
+
+```rust title="derive" showLineNumbers 
+#[varargs]
+pub comptime fn derive(s: StructDefinition, traits: [TraitDefinition]) -> Quoted {
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/meta/mod.nr#L48-L51" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/meta/mod.nr#L48-L51</a></sub></sup>
+
+
+Attribute placed on struct definitions.
+
+Creates a trait impl for each trait passed in as an argument.
+To do this, the trait must have a derive handler registered
+with `derive_via` beforehand. The traits in the stdlib that
+can be derived this way are `Eq`, `Ord`, `Default`, and `Hash`.
+
+Example:
+```rust
+#[derive(Eq, Default)]
+struct Foo<T> {
+    x: i32,
+    y: T,
+}
+
+fn main() {
+    let foo1 = Foo::default();
+    let foo2 = Foo { x: 0, y: &[0] };
+    assert_eq(foo1, foo2);
+}
+```
+
+### derive_via
+
+```rust title="derive_via_signature" showLineNumbers 
+pub comptime fn derive_via(t: TraitDefinition, f: DeriveFunction) {
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/meta/mod.nr#L68-L70" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/meta/mod.nr#L68-L70</a></sub></sup>
+
+
+Attribute placed on trait definitions.
+
+Registers a function to create impls for the given trait
+when the trait is used in a `derive` call. Users may use
+this to register their own functions to enable their traits
+to be derived by `derive`.
+
+Because this function requires a function as an argument which
+should produce a trait impl for any given struct, users may find
+it helpful to use a function like `std::meta::make_trait_impl` to
+help creating these impls.
+
+Example:
+```rust
+#[derive_via(derive_do_nothing)]
+trait DoNothing {
+    fn do_nothing(self);
+}
+
+comptime fn derive_do_nothing(s: StructDefinition) -> Quoted {
+    let typ = s.as_type();
+    quote {
+        impl DoNothing for $typ {
+            fn do_nothing(self) {
+                println("Nothing");
+            }
+        }
+    }
+}
+```
+
+As another example, `derive_eq` in the stdlib is used to derive the `Eq`
+trait for any struct. It makes use of `make_trait_impl` to do this:
+
+```rust title="derive_eq" showLineNumbers 
+comptime fn derive_eq(s: StructDefinition) -> Quoted {
+    let signature = quote { fn eq(_self: Self, _other: Self) -> bool };
+    let for_each_field = |name| quote { (_self.$name == _other.$name) };
+    let body = |fields| {
+        if s.fields().len() == 0 {
+            quote { true }
+        } else {
+            fields
+        }
+    };
+    crate::meta::make_trait_impl(
+        s,
+        quote { Eq },
+        signature,
+        for_each_field,
+        quote { & },
+        body,
+    )
+}
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/cmp.nr#L10-L30" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/cmp.nr#L10-L30</a></sub></sup>
+
+
+### make_trait_impl
+
+```rust title="make_trait_impl" showLineNumbers 
+pub comptime fn make_trait_impl<Env1, Env2>(
+    s: StructDefinition,
+    trait_name: Quoted,
+    function_signature: Quoted,
+    for_each_field: fn[Env1](Quoted) -> Quoted,
+    join_fields_with: Quoted,
+    body: fn[Env2](Quoted) -> Quoted,
+) -> Quoted {
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/meta/mod.nr#L87-L96" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/meta/mod.nr#L87-L96</a></sub></sup>
+
+
+A helper function to more easily create trait impls while deriving traits.
+
+Note that this function only works for traits which:
+1. Have only one method
+2. Have no generics on the trait itself.
+  - E.g. Using this on a trait such as `trait Foo<T> { ... }` will result in the
+    generated impl incorrectly missing the `T` generic.
+
+If your trait fits these criteria then `make_trait_impl` is likely the easiest
+way to write your derive handler. The arguments are as follows:
+
+- `s`: The struct to make the impl for
+- `trait_name`: The name of the trait to derive. E.g. `quote { Eq }`.
+- `function_signature`: The signature of the trait method to derive. E.g. `fn eq(self, other: Self) -> bool`.
+- `for_each_field`: An operation to be performed on each field. E.g. `|name| quote { (self.$name == other.$name) }`.
+- `join_fields_with`: A separator to join each result of `for_each_field` with.
+  E.g. `quote { & }`. You can also use an empty `quote {}` for no separator.
+- `body`: The result of the field operations are passed into this function for any final processing.
+  This is the place to insert any setup/teardown code the trait requires. If the trait doesn't require
+  any such code, you can return the body as-is: `|body| body`.
+
+Example deriving `Hash`:
+
+```rust title="derive_hash" showLineNumbers 
+comptime fn derive_hash(s: StructDefinition) -> Quoted {
+    let name = quote { Hash };
+    let signature = quote { fn hash<H>(_self: Self, _state: &mut H) where H: std::hash::Hasher };
+    let for_each_field = |name| quote { _self.$name.hash(_state); };
+    crate::meta::make_trait_impl(
+        s,
+        name,
+        signature,
+        for_each_field,
+        quote {},
+        |fields| fields,
+    )
+}
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/hash/mod.nr#L137-L151" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/hash/mod.nr#L137-L151</a></sub></sup>
+
+
+Example deriving `Ord`:
+
+```rust title="derive_ord" showLineNumbers 
+comptime fn derive_ord(s: StructDefinition) -> Quoted {
+    let signature = quote { fn cmp(_self: Self, _other: Self) -> std::cmp::Ordering };
+    let for_each_field = |name| quote {
+        if result == std::cmp::Ordering::equal() {
+            result = _self.$name.cmp(_other.$name);
+        }
+    };
+    let body = |fields| quote {
+        let mut result = std::cmp::Ordering::equal();
+        $fields
+        result
+    };
+    crate::meta::make_trait_impl(s, quote { Ord }, signature, for_each_field, quote {}, body)
+}
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/cmp.nr#L216-L231" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/cmp.nr#L216-L231</a></sub></sup>
+
diff --git a/docs/versioned_docs/version-v1.0.0-beta.0/noir/standard_library/meta/module.md b/docs/versioned_docs/version-v1.0.0-beta.0/noir/standard_library/meta/module.md
new file mode 100644
index 00000000000..f47231972b7
--- /dev/null
+++ b/docs/versioned_docs/version-v1.0.0-beta.0/noir/standard_library/meta/module.md
@@ -0,0 +1,82 @@
+---
+title: Module
+---
+
+`std::meta::module` contains methods on the built-in `Module` type which represents a module in the source program.
+Note that this type represents a module generally, it isn't limited to only `mod my_submodule { ... }`
+declarations in the source program.
+
+## Methods
+
+### add_item
+
+```rust title="add_item" showLineNumbers 
+pub comptime fn add_item(self, item: Quoted) {}
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/meta/module.nr#L3-L5" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/meta/module.nr#L3-L5</a></sub></sup>
+
+
+Adds a top-level item (a function, a struct, a global, etc.) to the module. 
+Adding multiple items in one go is also valid if the `Quoted` value has multiple items in it.  
+Note that the items are type-checked as if they are inside the module they are being added to.
+
+### functions
+
+```rust title="functions" showLineNumbers 
+pub comptime fn functions(self) -> [FunctionDefinition] {}
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/meta/module.nr#L18-L20" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/meta/module.nr#L18-L20</a></sub></sup>
+
+
+Returns each function defined in the module.
+
+### has_named_attribute
+
+```rust title="has_named_attribute" showLineNumbers 
+pub comptime fn has_named_attribute<let N: u32>(self, name: str<N>) -> bool {}
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/meta/module.nr#L8-L10" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/meta/module.nr#L8-L10</a></sub></sup>
+
+
+Returns true if this module has a custom attribute with the given name.
+
+### is_contract
+
+```rust title="is_contract" showLineNumbers 
+pub comptime fn is_contract(self) -> bool {}
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/meta/module.nr#L13-L15" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/meta/module.nr#L13-L15</a></sub></sup>
+
+
+`true` if this module is a contract module (was declared via `contract foo { ... }`).
+
+### name
+
+```rust title="name" showLineNumbers 
+pub comptime fn name(self) -> Quoted {}
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/meta/module.nr#L28-L30" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/meta/module.nr#L28-L30</a></sub></sup>
+
+
+Returns the name of the module.
+
+### structs
+
+```rust title="structs" showLineNumbers 
+pub comptime fn structs(self) -> [StructDefinition] {}
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/meta/module.nr#L23-L25" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/meta/module.nr#L23-L25</a></sub></sup>
+
+
+Returns each struct defined in the module.
+
+## Trait Implementations
+
+```rust
+impl Eq for Module
+impl Hash for Module
+```
+
+Note that each module is assigned a unique ID internally and this is what is used for
+equality and hashing. So even modules with identical names and contents may not
+be equal in this sense if they were originally different items in the source program.
diff --git a/docs/versioned_docs/version-v1.0.0-beta.0/noir/standard_library/meta/op.md b/docs/versioned_docs/version-v1.0.0-beta.0/noir/standard_library/meta/op.md
new file mode 100644
index 00000000000..03ea49ad8ec
--- /dev/null
+++ b/docs/versioned_docs/version-v1.0.0-beta.0/noir/standard_library/meta/op.md
@@ -0,0 +1,244 @@
+---
+title: UnaryOp and BinaryOp
+---
+
+`std::meta::op` contains the `UnaryOp` and `BinaryOp` types as well as methods on them.
+These types are used to represent a unary or binary operator respectively in Noir source code.
+
+## Types
+
+### UnaryOp
+
+Represents a unary operator. One of `-`, `!`, `&mut`, or `*`.
+
+### Methods
+
+#### is_minus
+
+```rust title="is_minus" showLineNumbers 
+pub fn is_minus(self) -> bool {
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/meta/op.nr#L24-L26" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/meta/op.nr#L24-L26</a></sub></sup>
+
+
+Returns `true` if this operator is `-`.
+
+#### is_not
+
+```rust title="is_not" showLineNumbers 
+pub fn is_not(self) -> bool {
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/meta/op.nr#L30-L32" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/meta/op.nr#L30-L32</a></sub></sup>
+
+
+`true` if this operator is `!`
+
+#### is_mutable_reference
+
+```rust title="is_mutable_reference" showLineNumbers 
+pub fn is_mutable_reference(self) -> bool {
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/meta/op.nr#L36-L38" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/meta/op.nr#L36-L38</a></sub></sup>
+
+
+`true` if this operator is `&mut`
+
+#### is_dereference
+
+```rust title="is_dereference" showLineNumbers 
+pub fn is_dereference(self) -> bool {
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/meta/op.nr#L42-L44" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/meta/op.nr#L42-L44</a></sub></sup>
+
+
+`true` if this operator is `*`
+
+#### quoted
+
+```rust title="unary_quoted" showLineNumbers 
+pub comptime fn quoted(self) -> Quoted {
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/meta/op.nr#L48-L50" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/meta/op.nr#L48-L50</a></sub></sup>
+
+
+Returns this operator as a `Quoted` value.
+
+### Trait Implementations
+
+```rust
+impl Eq for UnaryOp
+impl Hash for UnaryOp
+```
+
+### BinaryOp
+
+Represents a binary operator. One of `+`, `-`, `*`, `/`, `%`, `==`, `!=`, `<`, `<=`, `>`, `>=`, `&`, `|`, `^`, `>>`, or `<<`.
+
+### Methods
+
+#### is_add
+
+```rust title="is_add" showLineNumbers 
+pub fn is_add(self) -> bool {
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/meta/op.nr#L86-L88" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/meta/op.nr#L86-L88</a></sub></sup>
+
+
+`true` if this operator is `+`
+
+#### is_subtract
+
+```rust title="is_subtract" showLineNumbers 
+pub fn is_subtract(self) -> bool {
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/meta/op.nr#L92-L94" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/meta/op.nr#L92-L94</a></sub></sup>
+
+
+`true` if this operator is `-`
+
+#### is_multiply
+
+```rust title="is_multiply" showLineNumbers 
+pub fn is_multiply(self) -> bool {
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/meta/op.nr#L98-L100" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/meta/op.nr#L98-L100</a></sub></sup>
+
+
+`true` if this operator is `*`
+
+#### is_divide
+
+```rust title="is_divide" showLineNumbers 
+pub fn is_divide(self) -> bool {
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/meta/op.nr#L104-L106" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/meta/op.nr#L104-L106</a></sub></sup>
+
+
+`true` if this operator is `/`
+
+#### is_modulo
+
+```rust title="is_modulo" showLineNumbers 
+pub fn is_modulo(self) -> bool {
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/meta/op.nr#L176-L178" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/meta/op.nr#L176-L178</a></sub></sup>
+
+
+`true` if this operator is `%`
+
+#### is_equal
+
+```rust title="is_equal" showLineNumbers 
+pub fn is_equal(self) -> bool {
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/meta/op.nr#L110-L112" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/meta/op.nr#L110-L112</a></sub></sup>
+
+
+`true` if this operator is `==`
+
+#### is_not_equal
+
+```rust title="is_not_equal" showLineNumbers 
+pub fn is_not_equal(self) -> bool {
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/meta/op.nr#L116-L118" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/meta/op.nr#L116-L118</a></sub></sup>
+
+
+`true` if this operator is `!=`
+
+#### is_less_than
+
+```rust title="is_less_than" showLineNumbers 
+pub fn is_less_than(self) -> bool {
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/meta/op.nr#L122-L124" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/meta/op.nr#L122-L124</a></sub></sup>
+
+
+`true` if this operator is `<`
+
+#### is_less_than_or_equal
+
+```rust title="is_less_than_or_equal" showLineNumbers 
+pub fn is_less_than_or_equal(self) -> bool {
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/meta/op.nr#L128-L130" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/meta/op.nr#L128-L130</a></sub></sup>
+
+
+`true` if this operator is `<=`
+
+#### is_greater_than
+
+```rust title="is_greater_than" showLineNumbers 
+pub fn is_greater_than(self) -> bool {
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/meta/op.nr#L134-L136" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/meta/op.nr#L134-L136</a></sub></sup>
+
+
+`true` if this operator is `>`
+
+#### is_greater_than_or_equal
+
+```rust title="is_greater_than_or_equal" showLineNumbers 
+pub fn is_greater_than_or_equal(self) -> bool {
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/meta/op.nr#L140-L142" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/meta/op.nr#L140-L142</a></sub></sup>
+
+
+`true` if this operator is `>=`
+
+#### is_and
+
+```rust title="is_and" showLineNumbers 
+pub fn is_and(self) -> bool {
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/meta/op.nr#L146-L148" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/meta/op.nr#L146-L148</a></sub></sup>
+
+
+`true` if this operator is `&`
+
+#### is_or
+
+```rust title="is_or" showLineNumbers 
+pub fn is_or(self) -> bool {
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/meta/op.nr#L152-L154" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/meta/op.nr#L152-L154</a></sub></sup>
+
+
+`true` if this operator is `|`
+
+#### is_shift_right
+
+```rust title="is_shift_right" showLineNumbers 
+pub fn is_shift_right(self) -> bool {
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/meta/op.nr#L164-L166" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/meta/op.nr#L164-L166</a></sub></sup>
+
+
+`true` if this operator is `>>`
+
+#### is_shift_left
+
+```rust title="is_shift_right" showLineNumbers 
+pub fn is_shift_right(self) -> bool {
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/meta/op.nr#L164-L166" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/meta/op.nr#L164-L166</a></sub></sup>
+
+
+`true` if this operator is `<<`
+
+#### quoted
+
+```rust title="binary_quoted" showLineNumbers 
+pub comptime fn quoted(self) -> Quoted {
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/meta/op.nr#L182-L184" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/meta/op.nr#L182-L184</a></sub></sup>
+
+
+Returns this operator as a `Quoted` value.
+
+### Trait Implementations
+
+```rust
+impl Eq for BinaryOp
+impl Hash for BinaryOp
+```
diff --git a/docs/versioned_docs/version-v1.0.0-beta.0/noir/standard_library/meta/quoted.md b/docs/versioned_docs/version-v1.0.0-beta.0/noir/standard_library/meta/quoted.md
new file mode 100644
index 00000000000..d7acf23bc07
--- /dev/null
+++ b/docs/versioned_docs/version-v1.0.0-beta.0/noir/standard_library/meta/quoted.md
@@ -0,0 +1,141 @@
+---
+title: Quoted
+---
+
+`std::meta::quoted` contains methods on the built-in `Quoted` type which represents
+quoted token streams and is the result of the `quote { ... }` expression.
+
+## Methods
+
+### as_expr
+
+```rust title="as_expr" showLineNumbers 
+pub comptime fn as_expr(self) -> Option<Expr> {}
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/meta/quoted.nr#L6-L8" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/meta/quoted.nr#L6-L8</a></sub></sup>
+
+
+Parses the quoted token stream as an expression. Returns `Option::none()` if
+the expression failed to parse.
+
+Example:
+
+```rust title="as_expr_example" showLineNumbers 
+#[test]
+    fn test_expr_as_function_call() {
+        comptime
+        {
+            let expr = quote { foo(42) }.as_expr().unwrap();
+            let (_function, args) = expr.as_function_call().unwrap();
+            assert_eq(args.len(), 1);
+            assert_eq(args[0].as_integer().unwrap(), (42, false));
+        }
+    }
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/test_programs/noir_test_success/comptime_expr/src/main.nr#L360-L371" target="_blank" rel="noopener noreferrer">Source code: test_programs/noir_test_success/comptime_expr/src/main.nr#L360-L371</a></sub></sup>
+
+
+### as_module
+
+```rust title="as_module" showLineNumbers 
+pub comptime fn as_module(self) -> Option<Module> {}
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/meta/quoted.nr#L11-L13" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/meta/quoted.nr#L11-L13</a></sub></sup>
+
+
+Interprets this token stream as a module path leading to the name of a module.
+Returns `Option::none()` if the module isn't found or this token stream cannot be parsed as a path.
+
+Example:
+
+```rust title="as_module_example" showLineNumbers 
+mod baz {
+    pub mod qux {}
+}
+
+#[test]
+fn as_module_test() {
+    comptime {
+        let my_mod = quote { baz::qux }.as_module().unwrap();
+        assert_eq(my_mod.name(), quote { qux });
+    }
+}
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/test_programs/compile_success_empty/comptime_module/src/main.nr#L115-L127" target="_blank" rel="noopener noreferrer">Source code: test_programs/compile_success_empty/comptime_module/src/main.nr#L115-L127</a></sub></sup>
+
+
+### as_trait_constraint
+
+```rust title="as_trait_constraint" showLineNumbers 
+pub comptime fn as_trait_constraint(self) -> TraitConstraint {}
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/meta/quoted.nr#L16-L18" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/meta/quoted.nr#L16-L18</a></sub></sup>
+
+
+Interprets this token stream as a trait constraint (without an object type).
+Note that this function panics instead of returning `Option::none()` if the token
+stream does not parse and resolve to a valid trait constraint.
+
+Example:
+
+```rust title="implements_example" showLineNumbers 
+pub fn function_with_where<T>(_x: T)
+where
+    T: SomeTrait<i32>,
+{
+    comptime {
+        let t = quote { T }.as_type();
+        let some_trait_i32 = quote { SomeTrait<i32> }.as_trait_constraint();
+        assert(t.implements(some_trait_i32));
+
+        assert(t.get_trait_impl(some_trait_i32).is_none());
+    }
+}
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/test_programs/compile_success_empty/comptime_type/src/main.nr#L160-L173" target="_blank" rel="noopener noreferrer">Source code: test_programs/compile_success_empty/comptime_type/src/main.nr#L160-L173</a></sub></sup>
+
+
+### as_type
+
+```rust title="as_type" showLineNumbers 
+pub comptime fn as_type(self) -> Type {}
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/meta/quoted.nr#L21-L23" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/meta/quoted.nr#L21-L23</a></sub></sup>
+
+
+Interprets this token stream as a resolved type. Panics if the token
+stream doesn't parse to a type or if the type isn't a valid type in scope.
+
+```rust title="implements_example" showLineNumbers 
+pub fn function_with_where<T>(_x: T)
+where
+    T: SomeTrait<i32>,
+{
+    comptime {
+        let t = quote { T }.as_type();
+        let some_trait_i32 = quote { SomeTrait<i32> }.as_trait_constraint();
+        assert(t.implements(some_trait_i32));
+
+        assert(t.get_trait_impl(some_trait_i32).is_none());
+    }
+}
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/test_programs/compile_success_empty/comptime_type/src/main.nr#L160-L173" target="_blank" rel="noopener noreferrer">Source code: test_programs/compile_success_empty/comptime_type/src/main.nr#L160-L173</a></sub></sup>
+
+
+### tokens
+
+```rust title="tokens" showLineNumbers 
+pub comptime fn tokens(self) -> [Quoted] {}
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/meta/quoted.nr#L26-L28" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/meta/quoted.nr#L26-L28</a></sub></sup>
+
+
+Returns a slice of the individual tokens that form this token stream.
+
+## Trait Implementations
+
+```rust
+impl Eq for Quoted
+impl Hash for Quoted
+```
diff --git a/docs/versioned_docs/version-v1.0.0-beta.0/noir/standard_library/meta/struct_def.md b/docs/versioned_docs/version-v1.0.0-beta.0/noir/standard_library/meta/struct_def.md
new file mode 100644
index 00000000000..fd609942f4e
--- /dev/null
+++ b/docs/versioned_docs/version-v1.0.0-beta.0/noir/standard_library/meta/struct_def.md
@@ -0,0 +1,177 @@
+---
+title: StructDefinition
+---
+
+`std::meta::struct_def` contains methods on the built-in `StructDefinition` type.
+This type corresponds to `struct Name { field1: Type1, ... }` items in the source program.
+
+## Methods
+
+### add_attribute
+
+```rust title="add_attribute" showLineNumbers 
+pub comptime fn add_attribute<let N: u32>(self, attribute: str<N>) {}
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/meta/struct_def.nr#L3-L5" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/meta/struct_def.nr#L3-L5</a></sub></sup>
+
+
+Adds an attribute to the struct.
+
+### add_generic
+
+```rust title="add_generic" showLineNumbers 
+pub comptime fn add_generic<let N: u32>(self, generic_name: str<N>) -> Type {}
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/meta/struct_def.nr#L8-L10" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/meta/struct_def.nr#L8-L10</a></sub></sup>
+
+
+Adds an generic to the struct. Returns the new generic type.
+Errors if the given generic name isn't a single identifier or if
+the struct already has a generic with the same name.
+
+This method should be used carefully, if there is existing code referring
+to the struct type it may be checked before this function is called and
+see the struct with the original number of generics. This method should
+thus be preferred to use on code generated from other macros and structs
+that are not used in function signatures.
+
+Example:
+
+```rust title="add-generic-example" showLineNumbers 
+comptime fn add_generic(s: StructDefinition) {
+        assert_eq(s.generics().len(), 0);
+        let new_generic = s.add_generic("T");
+
+        let generics = s.generics();
+        assert_eq(generics.len(), 1);
+        assert_eq(generics[0], new_generic);
+    }
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/test_programs/compile_success_empty/comptime_struct_definition/src/main.nr#L35-L44" target="_blank" rel="noopener noreferrer">Source code: test_programs/compile_success_empty/comptime_struct_definition/src/main.nr#L35-L44</a></sub></sup>
+
+
+### as_type
+
+```rust title="as_type" showLineNumbers 
+pub comptime fn as_type(self) -> Type {}
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/meta/struct_def.nr#L15-L17" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/meta/struct_def.nr#L15-L17</a></sub></sup>
+
+
+Returns this struct as a type in the source program. If this struct has
+any generics, the generics are also included as-is.
+
+### generics
+
+```rust title="generics" showLineNumbers 
+pub comptime fn generics(self) -> [Type] {}
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/meta/struct_def.nr#L26-L28" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/meta/struct_def.nr#L26-L28</a></sub></sup>
+
+
+Returns each generic on this struct.
+
+Example:
+
+```
+#[example]
+struct Foo<T, U> {
+    bar: [T; 2],
+    baz: Baz<U, U>,
+}
+
+comptime fn example(foo: StructDefinition) {
+    assert_eq(foo.generics().len(), 2);
+
+    // Fails because `T` isn't in scope
+    // let t = quote { T }.as_type();
+    // assert_eq(foo.generics()[0], t);
+}
+```
+
+### fields
+
+```rust title="fields" showLineNumbers 
+pub comptime fn fields(self) -> [(Quoted, Type)] {}
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/meta/struct_def.nr#L33-L35" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/meta/struct_def.nr#L33-L35</a></sub></sup>
+
+
+Returns each field of this struct as a pair of (field name, field type).
+
+### has_named_attribute
+
+```rust title="has_named_attribute" showLineNumbers 
+pub comptime fn has_named_attribute<let N: u32>(self, name: str<N>) -> bool {}
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/meta/struct_def.nr#L20-L22" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/meta/struct_def.nr#L20-L22</a></sub></sup>
+
+
+Returns true if this struct has a custom attribute with the given name.
+
+### module
+
+```rust title="module" showLineNumbers 
+pub comptime fn module(self) -> Module {}
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/meta/struct_def.nr#L38-L40" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/meta/struct_def.nr#L38-L40</a></sub></sup>
+
+
+Returns the module where the struct is defined.
+
+### name
+
+```rust title="name" showLineNumbers 
+pub comptime fn name(self) -> Quoted {}
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/meta/struct_def.nr#L43-L45" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/meta/struct_def.nr#L43-L45</a></sub></sup>
+
+
+Returns the name of this struct
+
+Note that the returned quoted value will be just the struct name, it will
+not be the full path to the struct, nor will it include any generics.
+
+### set_fields
+
+```rust title="set_fields" showLineNumbers 
+pub comptime fn set_fields(self, new_fields: [(Quoted, Type)]) {}
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/meta/struct_def.nr#L52-L54" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/meta/struct_def.nr#L52-L54</a></sub></sup>
+
+
+Sets the fields of this struct to the given fields list where each element
+is a pair of the field's name and the field's type. Expects each field name
+to be a single identifier. Note that this will override any previous fields
+on this struct. If those should be preserved, use `.fields()` to retrieve the
+current fields on the struct type and append the new fields from there.
+
+Example:
+
+```rust
+// Change this struct to:
+// struct Foo {
+//     a: u32,
+//     b: i8,
+// }
+#[mangle_fields]
+struct Foo { x: Field }
+
+comptime fn mangle_fields(s: StructDefinition) {
+    s.set_fields(&[
+        (quote { a }, quote { u32 }.as_type()),
+        (quote { b }, quote { i8 }.as_type()),
+    ]);
+}
+```
+
+## Trait Implementations
+
+```rust
+impl Eq for StructDefinition
+impl Hash for StructDefinition
+```
+
+Note that each struct is assigned a unique ID internally and this is what is used for
+equality and hashing. So even structs with identical generics and fields may not
+be equal in this sense if they were originally different items in the source program.
diff --git a/docs/versioned_docs/version-v1.0.0-beta.0/noir/standard_library/meta/trait_constraint.md b/docs/versioned_docs/version-v1.0.0-beta.0/noir/standard_library/meta/trait_constraint.md
new file mode 100644
index 00000000000..3106f732b5a
--- /dev/null
+++ b/docs/versioned_docs/version-v1.0.0-beta.0/noir/standard_library/meta/trait_constraint.md
@@ -0,0 +1,17 @@
+---
+title: TraitConstraint
+---
+
+`std::meta::trait_constraint` contains methods on the built-in `TraitConstraint` type which represents
+a trait constraint that can be used to search for a trait implementation. This is similar
+syntactically to just the trait itself, but can also contain generic arguments. E.g. `Eq`, `Default`,
+`BuildHasher<Poseidon2Hasher>`.
+
+This type currently has no public methods but it can be used alongside `Type` in `implements` or `get_trait_impl`.
+
+## Trait Implementations
+
+```rust
+impl Eq for TraitConstraint
+impl Hash for TraitConstraint
+```
diff --git a/docs/versioned_docs/version-v1.0.0-beta.0/noir/standard_library/meta/trait_def.md b/docs/versioned_docs/version-v1.0.0-beta.0/noir/standard_library/meta/trait_def.md
new file mode 100644
index 00000000000..e661d3af7f1
--- /dev/null
+++ b/docs/versioned_docs/version-v1.0.0-beta.0/noir/standard_library/meta/trait_def.md
@@ -0,0 +1,26 @@
+---
+title: TraitDefinition
+---
+
+`std::meta::trait_def` contains methods on the built-in `TraitDefinition` type. This type
+represents trait definitions such as `trait Foo { .. }` at the top-level of a program.
+
+## Methods
+
+### as_trait_constraint
+
+```rust title="as_trait_constraint" showLineNumbers 
+pub comptime fn as_trait_constraint(_self: Self) -> TraitConstraint {}
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/meta/trait_def.nr#L6-L8" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/meta/trait_def.nr#L6-L8</a></sub></sup>
+
+
+Converts this trait into a trait constraint. If there are any generics on this
+trait, they will be kept as-is without instantiating or replacing them.
+
+## Trait Implementations
+
+```rust
+impl Eq for TraitDefinition
+impl Hash for TraitDefinition
+```
diff --git a/docs/versioned_docs/version-v1.0.0-beta.0/noir/standard_library/meta/trait_impl.md b/docs/versioned_docs/version-v1.0.0-beta.0/noir/standard_library/meta/trait_impl.md
new file mode 100644
index 00000000000..a527617c1e6
--- /dev/null
+++ b/docs/versioned_docs/version-v1.0.0-beta.0/noir/standard_library/meta/trait_impl.md
@@ -0,0 +1,60 @@
+---
+title: TraitImpl
+---
+
+`std::meta::trait_impl` contains methods on the built-in `TraitImpl` type which represents a trait
+implementation such as `impl Foo for Bar { ... }`.
+
+## Methods
+
+### trait_generic_args
+
+```rust title="trait_generic_args" showLineNumbers 
+pub comptime fn trait_generic_args(self) -> [Type] {}
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/meta/trait_impl.nr#L3-L5" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/meta/trait_impl.nr#L3-L5</a></sub></sup>
+
+
+Returns any generic arguments on the trait of this trait implementation, if any.
+
+```rs
+impl Foo<i32, Field> for Bar { ... }
+
+comptime {
+    let bar_type = quote { Bar }.as_type();
+    let foo = quote { Foo<i32, Field> }.as_trait_constraint();
+
+    let my_impl: TraitImpl = bar_type.get_trait_impl(foo).unwrap();
+
+    let generics = my_impl.trait_generic_args();
+    assert_eq(generics.len(), 2);
+
+    assert_eq(generics[0], quote { i32 }.as_type());
+    assert_eq(generics[1], quote { Field }.as_type());
+}
+```
+
+### methods
+
+```rust title="methods" showLineNumbers 
+pub comptime fn methods(self) -> [FunctionDefinition] {}
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/meta/trait_impl.nr#L8-L10" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/meta/trait_impl.nr#L8-L10</a></sub></sup>
+
+
+Returns each method in this trait impl.
+
+Example:
+
+```rs
+comptime {
+    let i32_type = quote { i32 }.as_type();
+    let eq = quote { Eq }.as_trait_constraint();
+
+    let impl_eq_for_i32: TraitImpl = i32_type.get_trait_impl(eq).unwrap();
+    let methods = impl_eq_for_i32.methods();
+
+    assert_eq(methods.len(), 1);
+    assert_eq(methods[0].name(), quote { eq });
+}
+```
diff --git a/docs/versioned_docs/version-v1.0.0-beta.0/noir/standard_library/meta/typ.md b/docs/versioned_docs/version-v1.0.0-beta.0/noir/standard_library/meta/typ.md
new file mode 100644
index 00000000000..90222c222f5
--- /dev/null
+++ b/docs/versioned_docs/version-v1.0.0-beta.0/noir/standard_library/meta/typ.md
@@ -0,0 +1,264 @@
+---
+title: Type
+---
+
+`std::meta::typ` contains methods on the built-in `Type` type used for representing
+a type in the source program.
+
+## Functions
+
+```rust title="fresh_type_variable" showLineNumbers 
+pub comptime fn fresh_type_variable() -> Type {}
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/meta/typ.nr#L57-L59" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/meta/typ.nr#L57-L59</a></sub></sup>
+
+
+Creates and returns an unbound type variable. This is a special kind of type internal
+to type checking which will type check with any other type. When it is type checked
+against another type it will also be set to that type. For example, if `a` is a type
+variable and we have the type equality `(a, i32) = (u8, i32)`, the compiler will set
+`a` equal to `u8`.
+
+Unbound type variables will often be rendered as `_` while printing them. Bound type
+variables will appear as the type they are bound to.
+
+This can be used in conjunction with functions which internally perform type checks
+such as `Type::implements` or `Type::get_trait_impl` to potentially grab some of the types used.
+
+Note that calling `Type::implements` or `Type::get_trait_impl` on a type variable will always
+fail.
+
+Example:
+
+```rust title="serialize-setup" showLineNumbers 
+trait Serialize<let N: u32> {}
+
+impl Serialize<1> for Field {}
+
+impl<T, let N: u32, let M: u32> Serialize<N * M> for [T; N]
+where
+    T: Serialize<M>,
+{}
+
+impl<T, U, let N: u32, let M: u32> Serialize<N + M> for (T, U)
+where
+    T: Serialize<N>,
+    U: Serialize<M>,
+{}
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/test_programs/compile_success_empty/comptime_type/src/main.nr#L14-L29" target="_blank" rel="noopener noreferrer">Source code: test_programs/compile_success_empty/comptime_type/src/main.nr#L14-L29</a></sub></sup>
+
+```rust title="fresh-type-variable-example" showLineNumbers 
+let typevar1 = std::meta::typ::fresh_type_variable();
+        let constraint = quote { Serialize<$typevar1> }.as_trait_constraint();
+        let field_type = quote { Field }.as_type();
+
+        // Search for a trait impl (binding typevar1 to 1 when the impl is found):
+        assert(field_type.implements(constraint));
+
+        // typevar1 should be bound to the "1" generic now:
+        assert_eq(typevar1.as_constant().unwrap(), 1);
+
+        // If we want to do the same with a different type, we need to
+        // create a new type variable now that `typevar1` is bound
+        let typevar2 = std::meta::typ::fresh_type_variable();
+        let constraint = quote { Serialize<$typevar2> }.as_trait_constraint();
+        let array_type = quote { [(Field, Field); 5] }.as_type();
+        assert(array_type.implements(constraint));
+
+        // Now typevar2 should be bound to the serialized pair size 2 times the array length 5
+        assert_eq(typevar2.as_constant().unwrap(), 10);
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/test_programs/compile_success_empty/comptime_type/src/main.nr#L129-L149" target="_blank" rel="noopener noreferrer">Source code: test_programs/compile_success_empty/comptime_type/src/main.nr#L129-L149</a></sub></sup>
+
+
+## Methods
+
+### as_array
+
+```rust title="as_array" showLineNumbers 
+pub comptime fn as_array(self) -> Option<(Type, Type)> {}
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/meta/typ.nr#L76-L78" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/meta/typ.nr#L76-L78</a></sub></sup>
+
+
+If this type is an array, return a pair of (element type, size type).
+
+Example:
+
+```rust
+comptime {
+    let array_type = quote { [Field; 3] }.as_type();
+    let (field_type, three_type) = array_type.as_array().unwrap();
+
+    assert(field_type.is_field());
+    assert_eq(three_type.as_constant().unwrap(), 3);
+}
+```
+
+### as_constant
+
+```rust title="as_constant" showLineNumbers 
+pub comptime fn as_constant(self) -> Option<u32> {}
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/meta/typ.nr#L83-L85" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/meta/typ.nr#L83-L85</a></sub></sup>
+
+
+If this type is a constant integer (such as the `3` in the array type `[Field; 3]`),
+return the numeric constant.
+
+### as_integer
+
+```rust title="as_integer" showLineNumbers 
+pub comptime fn as_integer(self) -> Option<(bool, u8)> {}
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/meta/typ.nr#L90-L92" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/meta/typ.nr#L90-L92</a></sub></sup>
+
+
+If this is an integer type, return a boolean which is `true`
+if the type is signed, as well as the number of bits of this integer type.
+
+### as_mutable_reference
+
+```rust title="as_mutable_reference" showLineNumbers 
+comptime fn as_mutable_reference(self) -> Option<Type> {}
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/meta/typ.nr#L96-L98" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/meta/typ.nr#L96-L98</a></sub></sup>
+
+
+If this is a mutable reference type `&mut T`, returns the mutable type `T`.
+
+### as_slice
+
+```rust title="as_slice" showLineNumbers 
+pub comptime fn as_slice(self) -> Option<Type> {}
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/meta/typ.nr#L102-L104" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/meta/typ.nr#L102-L104</a></sub></sup>
+
+
+If this is a slice type, return the element type of the slice.
+
+### as_str
+
+```rust title="as_str" showLineNumbers 
+pub comptime fn as_str(self) -> Option<Type> {}
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/meta/typ.nr#L108-L110" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/meta/typ.nr#L108-L110</a></sub></sup>
+
+
+If this is a `str<N>` type, returns the length `N` as a type.
+
+### as_struct
+
+```rust title="as_struct" showLineNumbers 
+pub comptime fn as_struct(self) -> Option<(StructDefinition, [Type])> {}
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/meta/typ.nr#L114-L116" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/meta/typ.nr#L114-L116</a></sub></sup>
+
+
+If this is a struct type, returns the struct in addition to
+any generic arguments on this type.
+
+### as_tuple
+
+```rust title="as_tuple" showLineNumbers 
+pub comptime fn as_tuple(self) -> Option<[Type]> {}
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/meta/typ.nr#L120-L122" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/meta/typ.nr#L120-L122</a></sub></sup>
+
+
+If this is a tuple type, returns each element type of the tuple.
+
+### get_trait_impl
+
+```rust title="get_trait_impl" showLineNumbers 
+pub comptime fn get_trait_impl(self, constraint: TraitConstraint) -> Option<TraitImpl> {}
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/meta/typ.nr#L143-L145" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/meta/typ.nr#L143-L145</a></sub></sup>
+
+
+Retrieves the trait implementation that implements the given
+trait constraint for this type. If the trait constraint is not
+found, `None` is returned. Note that since the concrete trait implementation
+for a trait constraint specified from a `where` clause is unknown,
+this function will return `None` in these cases. If you only want to know
+whether a type implements a trait, use `implements` instead.
+
+Example:
+
+```rust
+comptime {
+    let field_type = quote { Field }.as_type();
+    let default = quote { Default }.as_trait_constraint();
+
+    let the_impl: TraitImpl = field_type.get_trait_impl(default).unwrap();
+    assert(the_impl.methods().len(), 1);
+}
+```
+
+### implements
+
+```rust title="implements" showLineNumbers 
+pub comptime fn implements(self, constraint: TraitConstraint) -> bool {}
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/meta/typ.nr#L166-L168" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/meta/typ.nr#L166-L168</a></sub></sup>
+
+
+`true` if this type implements the given trait. Note that unlike
+`get_trait_impl` this will also return true for any `where` constraints
+in scope.
+
+Example:
+
+```rust
+fn foo<T>() where T: Default {
+    comptime {
+        let field_type = quote { Field }.as_type();
+        let default = quote { Default }.as_trait_constraint();
+        assert(field_type.implements(default));
+
+        let t = quote { T }.as_type();
+        assert(t.implements(default));
+    }
+}
+```
+
+### is_bool
+
+```rust title="is_bool" showLineNumbers 
+pub comptime fn is_bool(self) -> bool {}
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/meta/typ.nr#L172-L174" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/meta/typ.nr#L172-L174</a></sub></sup>
+
+
+`true` if this type is `bool`.
+
+### is_field
+
+```rust title="is_field" showLineNumbers 
+pub comptime fn is_field(self) -> bool {}
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/meta/typ.nr#L178-L180" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/meta/typ.nr#L178-L180</a></sub></sup>
+
+
+`true` if this type is `Field`.
+
+### is_unit
+
+```rust title="is_unit" showLineNumbers 
+comptime fn is_unit(self) -> bool {}
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/meta/typ.nr#L184-L186" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/meta/typ.nr#L184-L186</a></sub></sup>
+
+
+`true` if this type is the unit `()` type.
+
+## Trait Implementations
+
+```rust
+impl Eq for Type
+impl Hash for Type
+```
+Note that this is syntactic equality, this is not the same as whether two types will type check
+to be the same type. Unless type inference or generics are being used however, users should not
+typically have to worry about this distinction unless `std::meta::typ::fresh_type_variable` is used.
diff --git a/docs/versioned_docs/version-v1.0.0-beta.0/noir/standard_library/meta/typed_expr.md b/docs/versioned_docs/version-v1.0.0-beta.0/noir/standard_library/meta/typed_expr.md
new file mode 100644
index 00000000000..0db7dbfef61
--- /dev/null
+++ b/docs/versioned_docs/version-v1.0.0-beta.0/noir/standard_library/meta/typed_expr.md
@@ -0,0 +1,27 @@
+---
+title: TypedExpr
+---
+
+`std::meta::typed_expr` contains methods on the built-in `TypedExpr` type for resolved and type-checked expressions.
+
+## Methods
+
+### get_type
+
+```rust title="as_function_definition" showLineNumbers 
+pub comptime fn as_function_definition(self) -> Option<FunctionDefinition> {}
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/meta/typed_expr.nr#L7-L9" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/meta/typed_expr.nr#L7-L9</a></sub></sup>
+
+
+If this expression refers to a function definitions, returns it. Otherwise returns `Option::none()`.
+
+### get_type
+
+```rust title="get_type" showLineNumbers 
+pub comptime fn get_type(self) -> Option<Type> {}
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/meta/typed_expr.nr#L13-L15" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/meta/typed_expr.nr#L13-L15</a></sub></sup>
+
+
+Returns the type of the expression, or `Option::none()` if there were errors when the expression was previously resolved.
\ No newline at end of file
diff --git a/docs/versioned_docs/version-v1.0.0-beta.0/noir/standard_library/meta/unresolved_type.md b/docs/versioned_docs/version-v1.0.0-beta.0/noir/standard_library/meta/unresolved_type.md
new file mode 100644
index 00000000000..2826ec5ec0f
--- /dev/null
+++ b/docs/versioned_docs/version-v1.0.0-beta.0/noir/standard_library/meta/unresolved_type.md
@@ -0,0 +1,57 @@
+---
+title: UnresolvedType
+---
+
+`std::meta::unresolved_type` contains methods on the built-in `UnresolvedType` type for the syntax of types.
+
+## Methods
+
+### as_mutable_reference
+
+```rust title="as_mutable_reference" showLineNumbers 
+comptime fn as_mutable_reference(self) -> Option<UnresolvedType> {}
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/meta/unresolved_type.nr#L8-L10" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/meta/unresolved_type.nr#L8-L10</a></sub></sup>
+
+
+If this is a mutable reference type `&mut T`, returns the mutable type `T`.
+
+### as_slice
+
+```rust title="as_slice" showLineNumbers 
+comptime fn as_slice(self) -> Option<UnresolvedType> {}
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/meta/unresolved_type.nr#L14-L16" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/meta/unresolved_type.nr#L14-L16</a></sub></sup>
+
+
+If this is a slice `&[T]`, returns the element type `T`.
+
+### is_bool
+
+```rust title="is_bool" showLineNumbers 
+comptime fn is_bool(self) -> bool {}
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/meta/unresolved_type.nr#L20-L22" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/meta/unresolved_type.nr#L20-L22</a></sub></sup>
+
+
+Returns `true` if this type is `bool`.
+
+### is_field
+
+```rust title="is_field" showLineNumbers 
+pub comptime fn is_field(self) -> bool {}
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/meta/unresolved_type.nr#L26-L28" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/meta/unresolved_type.nr#L26-L28</a></sub></sup>
+
+
+Returns true if this type refers to the Field type.
+
+### is_unit
+
+```rust title="is_unit" showLineNumbers 
+comptime fn is_unit(self) -> bool {}
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/meta/unresolved_type.nr#L32-L34" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/meta/unresolved_type.nr#L32-L34</a></sub></sup>
+
+
+Returns true if this type is the unit `()` type.
diff --git a/docs/versioned_docs/version-v1.0.0-beta.0/noir/standard_library/options.md b/docs/versioned_docs/version-v1.0.0-beta.0/noir/standard_library/options.md
new file mode 100644
index 00000000000..a1bd4e1de5f
--- /dev/null
+++ b/docs/versioned_docs/version-v1.0.0-beta.0/noir/standard_library/options.md
@@ -0,0 +1,101 @@
+---
+title: Option<T> Type
+---
+
+The `Option<T>` type is a way to express that a value might be present (`Some(T))` or absent (`None`). It's a safer way to handle potential absence of values, compared to using nulls in many other languages.
+
+```rust
+struct Option<T> {
+    None,
+    Some(T),
+}
+```
+
+The `Option` type, already imported into your Noir program, can be used directly:
+
+```rust
+fn main() {
+    let none = Option::none();
+    let some = Option::some(3);
+}
+```
+
+See [this test](https://github.com/noir-lang/noir/blob/5cbfb9c4a06c8865c98ff2b594464b037d821a5c/crates/nargo_cli/tests/test_data/option/src/main.nr) for a more comprehensive set of examples of each of the methods described below.
+
+## Methods
+
+### none
+
+Constructs a none value.
+
+### some
+
+Constructs a some wrapper around a given value.
+
+### is_none
+
+Returns true if the Option is None.
+
+### is_some
+
+Returns true of the Option is Some.
+
+### unwrap
+
+Asserts `self.is_some()` and returns the wrapped value.
+
+### unwrap_unchecked
+
+Returns the inner value without asserting `self.is_some()`. This method can be useful within an if condition when we already know that `option.is_some()`. If the option is None, there is no guarantee what value will be returned, only that it will be of type T for an `Option<T>`.
+
+### unwrap_or
+
+Returns the wrapped value if `self.is_some()`. Otherwise, returns the given default value.
+
+### unwrap_or_else
+
+Returns the wrapped value if `self.is_some()`. Otherwise, calls the given function to return a default value.
+
+### expect
+
+Asserts `self.is_some()` with a provided custom message and returns the contained `Some` value. The custom message is expected to be a format string.
+
+### map
+
+If self is `Some(x)`, this returns `Some(f(x))`. Otherwise, this returns `None`.
+
+### map_or
+
+If self is `Some(x)`, this returns `f(x)`. Otherwise, this returns the given default value.
+
+### map_or_else
+
+If self is `Some(x)`, this returns `f(x)`. Otherwise, this returns `default()`.
+
+### and
+
+Returns None if self is None. Otherwise, this returns `other`.
+
+### and_then
+
+If self is None, this returns None. Otherwise, this calls the given function with the Some value contained within self, and returns the result of that call. In some languages this function is called `flat_map` or `bind`.
+
+### or
+
+If self is Some, return self. Otherwise, return `other`.
+
+### or_else
+
+If self is Some, return self. Otherwise, return `default()`.
+
+### xor
+
+If only one of the two Options is Some, return that option. Otherwise, if both options are Some or both are None, None is returned.
+
+### filter
+
+Returns `Some(x)` if self is `Some(x)` and `predicate(x)` is true. Otherwise, this returns `None`.
+
+### flatten
+
+Flattens an `Option<Option<T>>` into a `Option<T>`. This returns `None` if the outer Option is None. Otherwise, this returns the inner Option.
diff --git a/docs/versioned_docs/version-v1.0.0-beta.0/noir/standard_library/recursion.mdx b/docs/versioned_docs/version-v1.0.0-beta.0/noir/standard_library/recursion.mdx
new file mode 100644
index 00000000000..fcb36278060
--- /dev/null
+++ b/docs/versioned_docs/version-v1.0.0-beta.0/noir/standard_library/recursion.mdx
@@ -0,0 +1,67 @@
+---
+title: Recursive Proofs
+description: Learn about how to write recursive proofs in Noir.
+keywords: [recursion, recursive proofs, verification_key, verify_proof]
+---
+
+import BlackBoxInfo from '@site/src/components/Notes/_blackbox';
+
+Noir supports recursively verifying proofs, meaning you verify the proof of a Noir program in another Noir program. This enables creating proofs of arbitrary size by doing step-wise verification of smaller components of a large proof.
+
+Read [the explainer on recursion](../../explainers/explainer-recursion.md) to know more about this function and the [guide on how to use it.](../../how_to/how-to-recursion.md)
+
+## Verifying Recursive Proofs
+
+```rust
+#[foreign(recursive_aggregation)]
+pub fn verify_proof(verification_key: [Field], proof: [Field], public_inputs: [Field], key_hash: Field) {}
+```
+
+<BlackBoxInfo to="black_box_fns"/>
+
+## Example usage
+
+```rust
+
+fn main(
+    verification_key : [Field; 114],
+    proof : [Field; 93],
+    public_inputs : [Field; 1],
+    key_hash : Field,
+    proof_b : [Field; 93],
+) {
+    std::verify_proof(
+        verification_key,
+        proof,
+        public_inputs,
+        key_hash
+    );
+
+    std::verify_proof(
+        verification_key,
+        proof_b,
+        public_inputs,
+        key_hash
+    );
+}
+```
+
+You can see a full example of recursive proofs in [this example recursion demo repo](https://github.com/noir-lang/noir-examples/tree/master/recursion).
+
+## Parameters
+
+### `verification_key`
+
+The verification key for the zk program that is being verified.
+
+### `proof`
+
+The proof for the zk program that is being verified.
+
+### `public_inputs`
+
+These represent the public inputs of the proof we are verifying.
+
+### `key_hash`
+
+A key hash is used to check the validity of the verification key. The circuit implementing this opcode can use this hash to ensure that the key provided to the circuit matches the key produced by the circuit creator.
diff --git a/docs/versioned_docs/version-v1.0.0-beta.0/noir/standard_library/traits.md b/docs/versioned_docs/version-v1.0.0-beta.0/noir/standard_library/traits.md
new file mode 100644
index 00000000000..ee20f9cd949
--- /dev/null
+++ b/docs/versioned_docs/version-v1.0.0-beta.0/noir/standard_library/traits.md
@@ -0,0 +1,628 @@
+---
+title: Traits
+description: Noir's stdlib provides a few commonly used traits.
+keywords: [traits, trait, interface, protocol, default, add, eq]
+---
+
+## `std::default`
+
+### `std::default::Default`
+
+```rust title="default-trait" showLineNumbers 
+pub trait Default {
+    fn default() -> Self;
+}
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/default.nr#L4-L8" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/default.nr#L4-L8</a></sub></sup>
+
+
+Constructs a default value of a type.
+
+Implementations:
+```rust
+impl Default for Field { .. }
+
+impl Default for i8 { .. }
+impl Default for i16 { .. }
+impl Default for i32 { .. }
+impl Default for i64 { .. }
+
+impl Default for u8 { .. }
+impl Default for u16 { .. }
+impl Default for u32 { .. }
+impl Default for u64 { .. }
+
+impl Default for () { .. }
+impl Default for bool { .. }
+
+impl<T, N> Default for [T; N]
+    where T: Default { .. }
+
+impl<T> Default for [T] { .. }
+
+impl<A, B> Default for (A, B)
+    where A: Default, B: Default { .. }
+
+impl<A, B, C> Default for (A, B, C)
+    where A: Default, B: Default, C: Default { .. }
+
+impl<A, B, C, D> Default for (A, B, C, D)
+    where A: Default, B: Default, C: Default, D: Default { .. }
+
+impl<A, B, C, D, E> Default for (A, B, C, D, E)
+    where A: Default, B: Default, C: Default, D: Default, E: Default { .. }
+```
+
+For primitive integer types, the return value of `default` is `0`. Container
+types such as arrays are filled with default values of their element type,
+except slices whose length is unknown and thus defaulted to zero.
+
+---
+
+## `std::convert`
+
+### `std::convert::From`
+
+```rust title="from-trait" showLineNumbers 
+pub trait From<T> {
+    fn from(input: T) -> Self;
+}
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/convert.nr#L1-L5" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/convert.nr#L1-L5</a></sub></sup>
+
+
+The `From` trait defines how to convert from a given type `T` to the type on which the trait is implemented.
+
+The Noir standard library provides a number of implementations of `From` between primitive types.
+```rust title="from-impls" showLineNumbers 
+// Unsigned integers
+
+impl From<u8> for u32 {
+    fn from(value: u8) -> u32 {
+        value as u32
+    }
+}
+
+impl From<u8> for u64 {
+    fn from(value: u8) -> u64 {
+        value as u64
+    }
+}
+impl From<u32> for u64 {
+    fn from(value: u32) -> u64 {
+        value as u64
+    }
+}
+
+impl From<u8> for Field {
+    fn from(value: u8) -> Field {
+        value as Field
+    }
+}
+impl From<u32> for Field {
+    fn from(value: u32) -> Field {
+        value as Field
+    }
+}
+impl From<u64> for Field {
+    fn from(value: u64) -> Field {
+        value as Field
+    }
+}
+
+// Signed integers
+
+impl From<i8> for i32 {
+    fn from(value: i8) -> i32 {
+        value as i32
+    }
+}
+
+impl From<i8> for i64 {
+    fn from(value: i8) -> i64 {
+        value as i64
+    }
+}
+impl From<i32> for i64 {
+    fn from(value: i32) -> i64 {
+        value as i64
+    }
+}
+
+// Booleans
+impl From<bool> for u8 {
+    fn from(value: bool) -> u8 {
+        value as u8
+    }
+}
+impl From<bool> for u32 {
+    fn from(value: bool) -> u32 {
+        value as u32
+    }
+}
+impl From<bool> for u64 {
+    fn from(value: bool) -> u64 {
+        value as u64
+    }
+}
+impl From<bool> for i8 {
+    fn from(value: bool) -> i8 {
+        value as i8
+    }
+}
+impl From<bool> for i32 {
+    fn from(value: bool) -> i32 {
+        value as i32
+    }
+}
+impl From<bool> for i64 {
+    fn from(value: bool) -> i64 {
+        value as i64
+    }
+}
+impl From<bool> for Field {
+    fn from(value: bool) -> Field {
+        value as Field
+    }
+}
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/convert.nr#L28-L119" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/convert.nr#L28-L119</a></sub></sup>
+
+
+#### When to implement `From`
+
+As a general rule of thumb, `From` may be implemented in the [situations where it would be suitable in Rust](https://doc.rust-lang.org/std/convert/trait.From.html#when-to-implement-from):
+
+- The conversion is *infallible*: Noir does not provide an equivalent to Rust's `TryFrom`, if the conversion can fail then provide a named method instead.
+- The conversion is *lossless*: semantically, it should not lose or discard information. For example, `u32: From<u16>` can losslessly convert any `u16` into a valid `u32` such that the original `u16` can be recovered. On the other hand, `u16: From<u32>` should not be implemented as `2**16` is a `u32` which cannot be losslessly converted into a `u16`.
+- The conversion is *value-preserving*: the conceptual kind and meaning of the resulting value is the same, even though the Noir type and technical representation might be different. While it's possible to infallibly and losslessly convert a `u8` into a `str<2>` hex representation, `4u8` and `"04"` are too different for `str<2>: From<u8>` to be implemented.
+- The conversion is *obvious*: it's the only reasonable conversion between the two types. If there's ambiguity on how to convert between them such that the same input could potentially map to two different values then a named method should be used. For instance rather than implementing `U128: From<[u8; 16]>`, the methods `U128::from_le_bytes` and `U128::from_be_bytes` are used as otherwise the endianness of the array would be ambiguous, resulting in two potential values of `U128` from the same byte array.
+
+One additional recommendation specific to Noir is:
+- The conversion is *efficient*: it's relatively cheap to convert between the two types. Due to being a ZK DSL, it's more important to avoid unnecessary computation compared to Rust. If the implementation of `From` would encourage users to perform unnecessary conversion, resulting in additional proving time, then it may be preferable to expose functionality such that this conversion may be avoided.
+
+### `std::convert::Into`
+
+The `Into` trait is defined as the reciprocal of `From`. It should be easy to convince yourself that if we can convert to type `A` from type `B`, then it's possible to convert type `B` into type `A`.
+
+For this reason, implementing `From` on a type will automatically generate a matching `Into` implementation. One should always prefer implementing `From` over `Into` as implementing `Into` will not generate a matching `From` implementation.
+
+```rust title="into-trait" showLineNumbers 
+pub trait Into<T> {
+    fn into(self) -> T;
+}
+
+impl<T, U> Into<T> for U
+where
+    T: From<U>,
+{
+    fn into(self) -> T {
+        T::from(self)
+    }
+}
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/convert.nr#L13-L26" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/convert.nr#L13-L26</a></sub></sup>
+
+
+`Into` is most useful when passing function arguments where the types don't quite match up with what the function expects. In this case, the compiler has enough type information to perform the necessary conversion by just appending `.into()` onto the arguments in question.
+
+---
+
+## `std::cmp`
+
+### `std::cmp::Eq`
+
+```rust title="eq-trait" showLineNumbers 
+pub trait Eq {
+    fn eq(self, other: Self) -> bool;
+}
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/cmp.nr#L4-L8" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/cmp.nr#L4-L8</a></sub></sup>
+
+
+Returns `true` if `self` is equal to `other`. Implementing this trait on a type
+allows the type to be used with `==` and `!=`.
+
+Implementations:
+```rust
+impl Eq for Field { .. }
+
+impl Eq for i8 { .. }
+impl Eq for i16 { .. }
+impl Eq for i32 { .. }
+impl Eq for i64 { .. }
+
+impl Eq for u8 { .. }
+impl Eq for u16 { .. }
+impl Eq for u32 { .. }
+impl Eq for u64 { .. }
+
+impl Eq for () { .. }
+impl Eq for bool { .. }
+
+impl<T, N> Eq for [T; N]
+    where T: Eq { .. }
+
+impl<T> Eq for [T]
+    where T: Eq { .. }
+
+impl<A, B> Eq for (A, B)
+    where A: Eq, B: Eq { .. }
+
+impl<A, B, C> Eq for (A, B, C)
+    where A: Eq, B: Eq, C: Eq { .. }
+
+impl<A, B, C, D> Eq for (A, B, C, D)
+    where A: Eq, B: Eq, C: Eq, D: Eq { .. }
+
+impl<A, B, C, D, E> Eq for (A, B, C, D, E)
+    where A: Eq, B: Eq, C: Eq, D: Eq, E: Eq { .. }
+```
+
+### `std::cmp::Ord`
+
+```rust title="ord-trait" showLineNumbers 
+pub trait Ord {
+    fn cmp(self, other: Self) -> Ordering;
+}
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/cmp.nr#L210-L214" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/cmp.nr#L210-L214</a></sub></sup>
+
+
+`a.cmp(b)` compares two values returning `Ordering::less()` if `a < b`,
+`Ordering::equal()` if `a == b`, or `Ordering::greater()` if `a > b`.
+Implementing this trait on a type allows `<`, `<=`, `>`, and `>=` to be
+used on values of the type.
+
+`std::cmp` also provides `max` and `min` functions for any type which implements the `Ord` trait.
+
+Implementations:
+
+```rust
+impl Ord for u8 { .. }
+impl Ord for u16 { .. }
+impl Ord for u32 { .. }
+impl Ord for u64 { .. }
+
+impl Ord for i8 { .. }
+impl Ord for i16 { .. }
+impl Ord for i32 { .. }
+
+impl Ord for i64 { .. }
+
+impl Ord for () { .. }
+impl Ord for bool { .. }
+
+impl<T, N> Ord for [T; N]
+    where T: Ord { .. }
+
+impl<T> Ord for [T]
+    where T: Ord { .. }
+
+impl<A, B> Ord for (A, B)
+    where A: Ord, B: Ord { .. }
+
+impl<A, B, C> Ord for (A, B, C)
+    where A: Ord, B: Ord, C: Ord { .. }
+
+impl<A, B, C, D> Ord for (A, B, C, D)
+    where A: Ord, B: Ord, C: Ord, D: Ord { .. }
+
+impl<A, B, C, D, E> Ord for (A, B, C, D, E)
+    where A: Ord, B: Ord, C: Ord, D: Ord, E: Ord { .. }
+```
+
+---
+
+## `std::ops`
+
+### `std::ops::Add`, `std::ops::Sub`, `std::ops::Mul`, and `std::ops::Div`
+
+These traits abstract over addition, subtraction, multiplication, and division respectively.
+Implementing these traits for a given type will also allow that type to be used with the corresponding operator
+for that trait (`+` for Add, etc) in addition to the normal method names.
+
+```rust title="add-trait" showLineNumbers 
+pub trait Add {
+    fn add(self, other: Self) -> Self;
+}
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/ops/arith.nr#L1-L5" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/ops/arith.nr#L1-L5</a></sub></sup>
+
+```rust title="sub-trait" showLineNumbers 
+pub trait Sub {
+    fn sub(self, other: Self) -> Self;
+}
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/ops/arith.nr#L60-L64" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/ops/arith.nr#L60-L64</a></sub></sup>
+
+```rust title="mul-trait" showLineNumbers 
+pub trait Mul {
+    fn mul(self, other: Self) -> Self;
+}
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/ops/arith.nr#L119-L123" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/ops/arith.nr#L119-L123</a></sub></sup>
+
+```rust title="div-trait" showLineNumbers 
+pub trait Div {
+    fn div(self, other: Self) -> Self;
+}
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/ops/arith.nr#L178-L182" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/ops/arith.nr#L178-L182</a></sub></sup>
+
+
+The implementations block below is given for the `Add` trait, but the same types that implement
+`Add` also implement `Sub`, `Mul`, and `Div`.
+
+Implementations:
+```rust
+impl Add for Field { .. }
+
+impl Add for i8 { .. }
+impl Add for i16 { .. }
+impl Add for i32 { .. }
+impl Add for i64 { .. }
+
+impl Add for u8 { .. }
+impl Add for u16 { .. }
+impl Add for u32 { .. }
+impl Add for u64 { .. }
+```
+
+### `std::ops::Rem`
+
+```rust title="rem-trait" showLineNumbers 
+pub trait Rem {
+    fn rem(self, other: Self) -> Self;
+}
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/ops/arith.nr#L237-L241" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/ops/arith.nr#L237-L241</a></sub></sup>
+
+
+`Rem::rem(a, b)` is the remainder function returning the result of what is
+left after dividing `a` and `b`. Implementing `Rem` allows the `%` operator
+to be used with the implementation type.
+
+Unlike other numeric traits, `Rem` is not implemented for `Field`.
+
+Implementations:
+```rust
+impl Rem for u8 { fn rem(self, other: u8) -> u8 { self % other } }
+impl Rem for u16 { fn rem(self, other: u16) -> u16 { self % other } }
+impl Rem for u32 { fn rem(self, other: u32) -> u32 { self % other } }
+impl Rem for u64 { fn rem(self, other: u64) -> u64 { self % other } }
+
+impl Rem for i8 { fn rem(self, other: i8) -> i8 { self % other } }
+impl Rem for i16 { fn rem(self, other: i16) -> i16 { self % other } }
+impl Rem for i32 { fn rem(self, other: i32) -> i32 { self % other } }
+impl Rem for i64 { fn rem(self, other: i64) -> i64 { self % other } }
+```
+
+### `std::ops::Neg`
+
+```rust title="neg-trait" showLineNumbers 
+pub trait Neg {
+    fn neg(self) -> Self;
+}
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/ops/arith.nr#L290-L294" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/ops/arith.nr#L290-L294</a></sub></sup>
+
+
+`Neg::neg` is equivalent to the unary negation operator `-`.
+
+Implementations:
+```rust title="neg-trait-impls" showLineNumbers 
+impl Neg for Field {
+    fn neg(self) -> Field {
+        -self
+    }
+}
+
+impl Neg for i8 {
+    fn neg(self) -> i8 {
+        -self
+    }
+}
+impl Neg for i16 {
+    fn neg(self) -> i16 {
+        -self
+    }
+}
+impl Neg for i32 {
+    fn neg(self) -> i32 {
+        -self
+    }
+}
+impl Neg for i64 {
+    fn neg(self) -> i64 {
+        -self
+    }
+}
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/ops/arith.nr#L296-L323" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/ops/arith.nr#L296-L323</a></sub></sup>
+
+
+### `std::ops::Not`
+
+```rust title="not-trait" showLineNumbers 
+pub trait Not {
+    fn not(self: Self) -> Self;
+}
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/ops/bit.nr#L1-L5" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/ops/bit.nr#L1-L5</a></sub></sup>
+
+
+`Not::not` is equivalent to the unary bitwise NOT operator `!`.
+
+Implementations:
+```rust title="not-trait-impls" showLineNumbers 
+impl Not for bool {
+    fn not(self) -> bool {
+        !self
+    }
+}
+
+impl Not for u64 {
+    fn not(self) -> u64 {
+        !self
+    }
+}
+impl Not for u32 {
+    fn not(self) -> u32 {
+        !self
+    }
+}
+impl Not for u16 {
+    fn not(self) -> u16 {
+        !self
+    }
+}
+impl Not for u8 {
+    fn not(self) -> u8 {
+        !self
+    }
+}
+impl Not for u1 {
+    fn not(self) -> u1 {
+        !self
+    }
+}
+
+impl Not for i8 {
+    fn not(self) -> i8 {
+        !self
+    }
+}
+impl Not for i16 {
+    fn not(self) -> i16 {
+        !self
+    }
+}
+impl Not for i32 {
+    fn not(self) -> i32 {
+        !self
+    }
+}
+impl Not for i64 {
+    fn not(self) -> i64 {
+        !self
+    }
+}
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/ops/bit.nr#L7-L60" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/ops/bit.nr#L7-L60</a></sub></sup>
+
+
+### `std::ops::{ BitOr, BitAnd, BitXor }`
+
+```rust title="bitor-trait" showLineNumbers 
+pub trait BitOr {
+    fn bitor(self, other: Self) -> Self;
+}
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/ops/bit.nr#L62-L66" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/ops/bit.nr#L62-L66</a></sub></sup>
+
+```rust title="bitand-trait" showLineNumbers 
+pub trait BitAnd {
+    fn bitand(self, other: Self) -> Self;
+}
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/ops/bit.nr#L121-L125" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/ops/bit.nr#L121-L125</a></sub></sup>
+
+```rust title="bitxor-trait" showLineNumbers 
+pub trait BitXor {
+    fn bitxor(self, other: Self) -> Self;
+}
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/ops/bit.nr#L180-L184" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/ops/bit.nr#L180-L184</a></sub></sup>
+
+
+Traits for the bitwise operations `|`, `&`, and `^`.
+
+Implementing `BitOr`, `BitAnd` or `BitXor` for a type allows the `|`, `&`, or `^` operator respectively
+to be used with the type.
+
+The implementations block below is given for the `BitOr` trait, but the same types that implement
+`BitOr` also implement `BitAnd` and `BitXor`.
+
+Implementations:
+```rust
+impl BitOr for bool { fn bitor(self, other: bool) -> bool { self | other } }
+
+impl BitOr for u8 { fn bitor(self, other: u8) -> u8 { self | other } }
+impl BitOr for u16 { fn bitor(self, other: u16) -> u16 { self | other } }
+impl BitOr for u32 { fn bitor(self, other: u32) -> u32 { self | other } }
+impl BitOr for u64 { fn bitor(self, other: u64) -> u64 { self | other } }
+
+impl BitOr for i8 { fn bitor(self, other: i8) -> i8 { self | other } }
+impl BitOr for i16 { fn bitor(self, other: i16) -> i16 { self | other } }
+impl BitOr for i32 { fn bitor(self, other: i32) -> i32 { self | other } }
+impl BitOr for i64 { fn bitor(self, other: i64) -> i64 { self | other } }
+```
+
+### `std::ops::{ Shl, Shr }`
+
+```rust title="shl-trait" showLineNumbers 
+pub trait Shl {
+    fn shl(self, other: u8) -> Self;
+}
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/ops/bit.nr#L239-L243" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/ops/bit.nr#L239-L243</a></sub></sup>
+
+```rust title="shr-trait" showLineNumbers 
+pub trait Shr {
+    fn shr(self, other: u8) -> Self;
+}
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/ops/bit.nr#L292-L296" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/ops/bit.nr#L292-L296</a></sub></sup>
+
+
+Traits for a bit shift left and bit shift right.
+
+Implementing `Shl` for a type allows the left shift operator (`<<`) to be used with the implementation type.
+Similarly, implementing `Shr` allows the right shift operator (`>>`) to be used with the type.
+
+Note that bit shifting is not currently implemented for signed types.
+
+The implementations block below is given for the `Shl` trait, but the same types that implement
+`Shl` also implement `Shr`.
+
+Implementations:
+```rust
+impl Shl for u8 { fn shl(self, other: u8) -> u8 { self << other } }
+impl Shl for u16 { fn shl(self, other: u16) -> u16 { self << other } }
+impl Shl for u32 { fn shl(self, other: u32) -> u32 { self << other } }
+impl Shl for u64 { fn shl(self, other: u64) -> u64 { self << other } }
+```
+
+---
+
+## `std::append`
+
+### `std::append::Append`
+
+`Append` can abstract over types that can be appended to - usually container types:
+
+```rust title="append-trait" showLineNumbers 
+pub trait Append {
+    fn empty() -> Self;
+    fn append(self, other: Self) -> Self;
+}
+```
+> <sup><sub><a href="https://github.com/noir-lang/noir/blob/master/noir_stdlib/src/append.nr#L9-L14" target="_blank" rel="noopener noreferrer">Source code: noir_stdlib/src/append.nr#L9-L14</a></sub></sup>
+
+
+`Append` requires two methods:
+
+- `empty`: Constructs an empty value of `Self`.
+- `append`: Append two values together, returning the result.
+
+Additionally, it is expected that for any implementation:
+
+- `T::empty().append(x) == x`
+- `x.append(T::empty()) == x`
+
+Implementations:
+```rust
+impl<T> Append for [T]
+impl Append for Quoted
+```
diff --git a/docs/versioned_docs/version-v1.0.0-beta.0/reference/NoirJS/noir_js/.nojekyll b/docs/versioned_docs/version-v1.0.0-beta.0/reference/NoirJS/noir_js/.nojekyll
new file mode 100644
index 00000000000..e2ac6616add
--- /dev/null
+++ b/docs/versioned_docs/version-v1.0.0-beta.0/reference/NoirJS/noir_js/.nojekyll
@@ -0,0 +1 @@
+TypeDoc added this file to prevent GitHub Pages from using Jekyll. You can turn off this behavior by setting the `githubPages` option to false.
\ No newline at end of file
diff --git a/docs/versioned_docs/version-v1.0.0-beta.0/reference/NoirJS/noir_js/classes/Noir.md b/docs/versioned_docs/version-v1.0.0-beta.0/reference/NoirJS/noir_js/classes/Noir.md
new file mode 100644
index 00000000000..ead255bc504
--- /dev/null
+++ b/docs/versioned_docs/version-v1.0.0-beta.0/reference/NoirJS/noir_js/classes/Noir.md
@@ -0,0 +1,52 @@
+# Noir
+
+## Constructors
+
+### new Noir(circuit)
+
+```ts
+new Noir(circuit): Noir
+```
+
+#### Parameters
+
+| Parameter | Type |
+| :------ | :------ |
+| `circuit` | `CompiledCircuit` |
+
+#### Returns
+
+[`Noir`](Noir.md)
+
+## Methods
+
+### execute()
+
+```ts
+execute(inputs, foreignCallHandler?): Promise<object>
+```
+
+#### Parameters
+
+| Parameter | Type |
+| :------ | :------ |
+| `inputs` | `InputMap` |
+| `foreignCallHandler`? | [`ForeignCallHandler`](../type-aliases/ForeignCallHandler.md) |
+
+#### Returns
+
+`Promise`\<`object`\>
+
+#### Description
+
+Allows to execute a circuit to get its witness and return value.
+
+#### Example
+
+```typescript
+async execute(inputs)
+```
+
+***
+
+Generated using [typedoc-plugin-markdown](https://www.npmjs.com/package/typedoc-plugin-markdown) and [TypeDoc](https://typedoc.org/)
diff --git a/docs/versioned_docs/version-v1.0.0-beta.0/reference/NoirJS/noir_js/functions/and.md b/docs/versioned_docs/version-v1.0.0-beta.0/reference/NoirJS/noir_js/functions/and.md
new file mode 100644
index 00000000000..c783283e396
--- /dev/null
+++ b/docs/versioned_docs/version-v1.0.0-beta.0/reference/NoirJS/noir_js/functions/and.md
@@ -0,0 +1,22 @@
+# and()
+
+```ts
+and(lhs, rhs): string
+```
+
+Performs a bitwise AND operation between `lhs` and `rhs`
+
+## Parameters
+
+| Parameter | Type | Description |
+| :------ | :------ | :------ |
+| `lhs` | `string` |  |
+| `rhs` | `string` |  |
+
+## Returns
+
+`string`
+
+***
+
+Generated using [typedoc-plugin-markdown](https://www.npmjs.com/package/typedoc-plugin-markdown) and [TypeDoc](https://typedoc.org/)
diff --git a/docs/versioned_docs/version-v1.0.0-beta.0/reference/NoirJS/noir_js/functions/blake2s256.md b/docs/versioned_docs/version-v1.0.0-beta.0/reference/NoirJS/noir_js/functions/blake2s256.md
new file mode 100644
index 00000000000..7882d0da8d5
--- /dev/null
+++ b/docs/versioned_docs/version-v1.0.0-beta.0/reference/NoirJS/noir_js/functions/blake2s256.md
@@ -0,0 +1,21 @@
+# blake2s256()
+
+```ts
+blake2s256(inputs): Uint8Array
+```
+
+Calculates the Blake2s256 hash of the input bytes
+
+## Parameters
+
+| Parameter | Type | Description |
+| :------ | :------ | :------ |
+| `inputs` | `Uint8Array` |  |
+
+## Returns
+
+`Uint8Array`
+
+***
+
+Generated using [typedoc-plugin-markdown](https://www.npmjs.com/package/typedoc-plugin-markdown) and [TypeDoc](https://typedoc.org/)
diff --git a/docs/versioned_docs/version-v1.0.0-beta.0/reference/NoirJS/noir_js/functions/ecdsa_secp256k1_verify.md b/docs/versioned_docs/version-v1.0.0-beta.0/reference/NoirJS/noir_js/functions/ecdsa_secp256k1_verify.md
new file mode 100644
index 00000000000..5e3cd53e9d3
--- /dev/null
+++ b/docs/versioned_docs/version-v1.0.0-beta.0/reference/NoirJS/noir_js/functions/ecdsa_secp256k1_verify.md
@@ -0,0 +1,28 @@
+# ecdsa\_secp256k1\_verify()
+
+```ts
+ecdsa_secp256k1_verify(
+   hashed_msg, 
+   public_key_x_bytes, 
+   public_key_y_bytes, 
+   signature): boolean
+```
+
+Verifies a ECDSA signature over the secp256k1 curve.
+
+## Parameters
+
+| Parameter | Type | Description |
+| :------ | :------ | :------ |
+| `hashed_msg` | `Uint8Array` |  |
+| `public_key_x_bytes` | `Uint8Array` |  |
+| `public_key_y_bytes` | `Uint8Array` |  |
+| `signature` | `Uint8Array` |  |
+
+## Returns
+
+`boolean`
+
+***
+
+Generated using [typedoc-plugin-markdown](https://www.npmjs.com/package/typedoc-plugin-markdown) and [TypeDoc](https://typedoc.org/)
diff --git a/docs/versioned_docs/version-v1.0.0-beta.0/reference/NoirJS/noir_js/functions/ecdsa_secp256r1_verify.md b/docs/versioned_docs/version-v1.0.0-beta.0/reference/NoirJS/noir_js/functions/ecdsa_secp256r1_verify.md
new file mode 100644
index 00000000000..0b20ff68957
--- /dev/null
+++ b/docs/versioned_docs/version-v1.0.0-beta.0/reference/NoirJS/noir_js/functions/ecdsa_secp256r1_verify.md
@@ -0,0 +1,28 @@
+# ecdsa\_secp256r1\_verify()
+
+```ts
+ecdsa_secp256r1_verify(
+   hashed_msg, 
+   public_key_x_bytes, 
+   public_key_y_bytes, 
+   signature): boolean
+```
+
+Verifies a ECDSA signature over the secp256r1 curve.
+
+## Parameters
+
+| Parameter | Type | Description |
+| :------ | :------ | :------ |
+| `hashed_msg` | `Uint8Array` |  |
+| `public_key_x_bytes` | `Uint8Array` |  |
+| `public_key_y_bytes` | `Uint8Array` |  |
+| `signature` | `Uint8Array` |  |
+
+## Returns
+
+`boolean`
+
+***
+
+Generated using [typedoc-plugin-markdown](https://www.npmjs.com/package/typedoc-plugin-markdown) and [TypeDoc](https://typedoc.org/)
diff --git a/docs/versioned_docs/version-v1.0.0-beta.0/reference/NoirJS/noir_js/functions/xor.md b/docs/versioned_docs/version-v1.0.0-beta.0/reference/NoirJS/noir_js/functions/xor.md
new file mode 100644
index 00000000000..8d762b895d3
--- /dev/null
+++ b/docs/versioned_docs/version-v1.0.0-beta.0/reference/NoirJS/noir_js/functions/xor.md
@@ -0,0 +1,22 @@
+# xor()
+
+```ts
+xor(lhs, rhs): string
+```
+
+Performs a bitwise XOR operation between `lhs` and `rhs`
+
+## Parameters
+
+| Parameter | Type | Description |
+| :------ | :------ | :------ |
+| `lhs` | `string` |  |
+| `rhs` | `string` |  |
+
+## Returns
+
+`string`
+
+***
+
+Generated using [typedoc-plugin-markdown](https://www.npmjs.com/package/typedoc-plugin-markdown) and [TypeDoc](https://typedoc.org/)
diff --git a/docs/versioned_docs/version-v1.0.0-beta.0/reference/NoirJS/noir_js/index.md b/docs/versioned_docs/version-v1.0.0-beta.0/reference/NoirJS/noir_js/index.md
new file mode 100644
index 00000000000..4de7a696991
--- /dev/null
+++ b/docs/versioned_docs/version-v1.0.0-beta.0/reference/NoirJS/noir_js/index.md
@@ -0,0 +1,47 @@
+# noir_js
+
+## Exports
+
+### Classes
+
+| Class | Description |
+| :------ | :------ |
+| [Noir](classes/Noir.md) | - |
+
+### Type Aliases
+
+| Type alias | Description |
+| :------ | :------ |
+| [ErrorWithPayload](type-aliases/ErrorWithPayload.md) | - |
+| [ForeignCallHandler](type-aliases/ForeignCallHandler.md) | A callback which performs an foreign call and returns the response. |
+| [ForeignCallInput](type-aliases/ForeignCallInput.md) | - |
+| [ForeignCallOutput](type-aliases/ForeignCallOutput.md) | - |
+| [WitnessMap](type-aliases/WitnessMap.md) | - |
+
+### Functions
+
+| Function | Description |
+| :------ | :------ |
+| [and](functions/and.md) | Performs a bitwise AND operation between `lhs` and `rhs` |
+| [blake2s256](functions/blake2s256.md) | Calculates the Blake2s256 hash of the input bytes |
+| [ecdsa\_secp256k1\_verify](functions/ecdsa_secp256k1_verify.md) | Verifies a ECDSA signature over the secp256k1 curve. |
+| [ecdsa\_secp256r1\_verify](functions/ecdsa_secp256r1_verify.md) | Verifies a ECDSA signature over the secp256r1 curve. |
+| [xor](functions/xor.md) | Performs a bitwise XOR operation between `lhs` and `rhs` |
+
+## References
+
+### CompiledCircuit
+
+Renames and re-exports [InputMap](index.md#inputmap)
+
+## Variables
+
+### InputMap
+
+```ts
+InputMap: any;
+```
+
+***
+
+Generated using [typedoc-plugin-markdown](https://www.npmjs.com/package/typedoc-plugin-markdown) and [TypeDoc](https://typedoc.org/)
diff --git a/docs/versioned_docs/version-v1.0.0-beta.0/reference/NoirJS/noir_js/type-aliases/ErrorWithPayload.md b/docs/versioned_docs/version-v1.0.0-beta.0/reference/NoirJS/noir_js/type-aliases/ErrorWithPayload.md
new file mode 100644
index 00000000000..e8c2f4aef3d
--- /dev/null
+++ b/docs/versioned_docs/version-v1.0.0-beta.0/reference/NoirJS/noir_js/type-aliases/ErrorWithPayload.md
@@ -0,0 +1,15 @@
+# ErrorWithPayload
+
+```ts
+type ErrorWithPayload: ExecutionError & object;
+```
+
+## Type declaration
+
+| Member | Type | Description |
+| :------ | :------ | :------ |
+| `decodedAssertionPayload` | `any` | - |
+
+***
+
+Generated using [typedoc-plugin-markdown](https://www.npmjs.com/package/typedoc-plugin-markdown) and [TypeDoc](https://typedoc.org/)
diff --git a/docs/versioned_docs/version-v1.0.0-beta.0/reference/NoirJS/noir_js/type-aliases/ForeignCallHandler.md b/docs/versioned_docs/version-v1.0.0-beta.0/reference/NoirJS/noir_js/type-aliases/ForeignCallHandler.md
new file mode 100644
index 00000000000..812b8b16481
--- /dev/null
+++ b/docs/versioned_docs/version-v1.0.0-beta.0/reference/NoirJS/noir_js/type-aliases/ForeignCallHandler.md
@@ -0,0 +1,24 @@
+# ForeignCallHandler
+
+```ts
+type ForeignCallHandler: (name, inputs) => Promise<ForeignCallOutput[]>;
+```
+
+A callback which performs an foreign call and returns the response.
+
+## Parameters
+
+| Parameter | Type | Description |
+| :------ | :------ | :------ |
+| `name` | `string` | The identifier for the type of foreign call being performed. |
+| `inputs` | [`ForeignCallInput`](ForeignCallInput.md)[] | An array of hex encoded inputs to the foreign call. |
+
+## Returns
+
+`Promise`\<[`ForeignCallOutput`](ForeignCallOutput.md)[]\>
+
+outputs - An array of hex encoded outputs containing the results of the foreign call.
+
+***
+
+Generated using [typedoc-plugin-markdown](https://www.npmjs.com/package/typedoc-plugin-markdown) and [TypeDoc](https://typedoc.org/)
diff --git a/docs/versioned_docs/version-v1.0.0-beta.0/reference/NoirJS/noir_js/type-aliases/ForeignCallInput.md b/docs/versioned_docs/version-v1.0.0-beta.0/reference/NoirJS/noir_js/type-aliases/ForeignCallInput.md
new file mode 100644
index 00000000000..dd95809186a
--- /dev/null
+++ b/docs/versioned_docs/version-v1.0.0-beta.0/reference/NoirJS/noir_js/type-aliases/ForeignCallInput.md
@@ -0,0 +1,9 @@
+# ForeignCallInput
+
+```ts
+type ForeignCallInput: string[];
+```
+
+***
+
+Generated using [typedoc-plugin-markdown](https://www.npmjs.com/package/typedoc-plugin-markdown) and [TypeDoc](https://typedoc.org/)
diff --git a/docs/versioned_docs/version-v1.0.0-beta.0/reference/NoirJS/noir_js/type-aliases/ForeignCallOutput.md b/docs/versioned_docs/version-v1.0.0-beta.0/reference/NoirJS/noir_js/type-aliases/ForeignCallOutput.md
new file mode 100644
index 00000000000..b71fb78a946
--- /dev/null
+++ b/docs/versioned_docs/version-v1.0.0-beta.0/reference/NoirJS/noir_js/type-aliases/ForeignCallOutput.md
@@ -0,0 +1,9 @@
+# ForeignCallOutput
+
+```ts
+type ForeignCallOutput: string | string[];
+```
+
+***
+
+Generated using [typedoc-plugin-markdown](https://www.npmjs.com/package/typedoc-plugin-markdown) and [TypeDoc](https://typedoc.org/)
diff --git a/docs/versioned_docs/version-v1.0.0-beta.0/reference/NoirJS/noir_js/type-aliases/WitnessMap.md b/docs/versioned_docs/version-v1.0.0-beta.0/reference/NoirJS/noir_js/type-aliases/WitnessMap.md
new file mode 100644
index 00000000000..258c46f9d0c
--- /dev/null
+++ b/docs/versioned_docs/version-v1.0.0-beta.0/reference/NoirJS/noir_js/type-aliases/WitnessMap.md
@@ -0,0 +1,9 @@
+# WitnessMap
+
+```ts
+type WitnessMap: Map<number, string>;
+```
+
+***
+
+Generated using [typedoc-plugin-markdown](https://www.npmjs.com/package/typedoc-plugin-markdown) and [TypeDoc](https://typedoc.org/)
diff --git a/docs/versioned_docs/version-v1.0.0-beta.0/reference/NoirJS/noir_js/typedoc-sidebar.cjs b/docs/versioned_docs/version-v1.0.0-beta.0/reference/NoirJS/noir_js/typedoc-sidebar.cjs
new file mode 100644
index 00000000000..4796b5abaa8
--- /dev/null
+++ b/docs/versioned_docs/version-v1.0.0-beta.0/reference/NoirJS/noir_js/typedoc-sidebar.cjs
@@ -0,0 +1,4 @@
+// @ts-check
+/** @type {import('@docusaurus/plugin-content-docs').SidebarsConfig} */
+const typedocSidebar = { items: [{"type":"category","label":"Classes","items":[{"type":"doc","id":"reference/NoirJS/noir_js/classes/Noir","label":"Noir"}]},{"type":"category","label":"Type Aliases","items":[{"type":"doc","id":"reference/NoirJS/noir_js/type-aliases/ErrorWithPayload","label":"ErrorWithPayload"},{"type":"doc","id":"reference/NoirJS/noir_js/type-aliases/ForeignCallHandler","label":"ForeignCallHandler"},{"type":"doc","id":"reference/NoirJS/noir_js/type-aliases/ForeignCallInput","label":"ForeignCallInput"},{"type":"doc","id":"reference/NoirJS/noir_js/type-aliases/ForeignCallOutput","label":"ForeignCallOutput"},{"type":"doc","id":"reference/NoirJS/noir_js/type-aliases/WitnessMap","label":"WitnessMap"}]},{"type":"category","label":"Functions","items":[{"type":"doc","id":"reference/NoirJS/noir_js/functions/and","label":"and"},{"type":"doc","id":"reference/NoirJS/noir_js/functions/blake2s256","label":"blake2s256"},{"type":"doc","id":"reference/NoirJS/noir_js/functions/ecdsa_secp256k1_verify","label":"ecdsa_secp256k1_verify"},{"type":"doc","id":"reference/NoirJS/noir_js/functions/ecdsa_secp256r1_verify","label":"ecdsa_secp256r1_verify"},{"type":"doc","id":"reference/NoirJS/noir_js/functions/xor","label":"xor"}]}]};
+module.exports = typedocSidebar.items;
\ No newline at end of file
diff --git a/docs/versioned_docs/version-v1.0.0-beta.0/reference/NoirJS/noir_wasm/.nojekyll b/docs/versioned_docs/version-v1.0.0-beta.0/reference/NoirJS/noir_wasm/.nojekyll
new file mode 100644
index 00000000000..e2ac6616add
--- /dev/null
+++ b/docs/versioned_docs/version-v1.0.0-beta.0/reference/NoirJS/noir_wasm/.nojekyll
@@ -0,0 +1 @@
+TypeDoc added this file to prevent GitHub Pages from using Jekyll. You can turn off this behavior by setting the `githubPages` option to false.
\ No newline at end of file
diff --git a/docs/versioned_docs/version-v1.0.0-beta.0/reference/NoirJS/noir_wasm/functions/compile.md b/docs/versioned_docs/version-v1.0.0-beta.0/reference/NoirJS/noir_wasm/functions/compile.md
new file mode 100644
index 00000000000..6faf763b37f
--- /dev/null
+++ b/docs/versioned_docs/version-v1.0.0-beta.0/reference/NoirJS/noir_wasm/functions/compile.md
@@ -0,0 +1,51 @@
+# compile()
+
+```ts
+compile(
+   fileManager, 
+   projectPath?, 
+   logFn?, 
+debugLogFn?): Promise<ProgramCompilationArtifacts>
+```
+
+Compiles a Noir project
+
+## Parameters
+
+| Parameter | Type | Description |
+| :------ | :------ | :------ |
+| `fileManager` | `FileManager` | The file manager to use |
+| `projectPath`? | `string` | The path to the project inside the file manager. Defaults to the root of the file manager |
+| `logFn`? | `LogFn` | A logging function. If not provided, console.log will be used |
+| `debugLogFn`? | `LogFn` | A debug logging function. If not provided, logFn will be used |
+
+## Returns
+
+`Promise`\<[`ProgramCompilationArtifacts`](../index.md#programcompilationartifacts)\>
+
+## Example
+
+```typescript
+// Node.js
+
+import { compile_program, createFileManager } from '@noir-lang/noir_wasm';
+
+const fm = createFileManager(myProjectPath);
+const myCompiledCode = await compile_program(fm);
+```
+
+```typescript
+// Browser
+
+import { compile_program, createFileManager } from '@noir-lang/noir_wasm';
+
+const fm = createFileManager('/');
+for (const path of files) {
+  await fm.writeFile(path, await getFileAsStream(path));
+}
+const myCompiledCode = await compile_program(fm);
+```
+
+***
+
+Generated using [typedoc-plugin-markdown](https://www.npmjs.com/package/typedoc-plugin-markdown) and [TypeDoc](https://typedoc.org/)
diff --git a/docs/versioned_docs/version-v1.0.0-beta.0/reference/NoirJS/noir_wasm/functions/compile_contract.md b/docs/versioned_docs/version-v1.0.0-beta.0/reference/NoirJS/noir_wasm/functions/compile_contract.md
new file mode 100644
index 00000000000..7d0b39a43ef
--- /dev/null
+++ b/docs/versioned_docs/version-v1.0.0-beta.0/reference/NoirJS/noir_wasm/functions/compile_contract.md
@@ -0,0 +1,51 @@
+# compile\_contract()
+
+```ts
+compile_contract(
+   fileManager, 
+   projectPath?, 
+   logFn?, 
+debugLogFn?): Promise<ContractCompilationArtifacts>
+```
+
+Compiles a Noir project
+
+## Parameters
+
+| Parameter | Type | Description |
+| :------ | :------ | :------ |
+| `fileManager` | `FileManager` | The file manager to use |
+| `projectPath`? | `string` | The path to the project inside the file manager. Defaults to the root of the file manager |
+| `logFn`? | `LogFn` | A logging function. If not provided, console.log will be used |
+| `debugLogFn`? | `LogFn` | A debug logging function. If not provided, logFn will be used |
+
+## Returns
+
+`Promise`\<[`ContractCompilationArtifacts`](../index.md#contractcompilationartifacts)\>
+
+## Example
+
+```typescript
+// Node.js
+
+import { compile_contract, createFileManager } from '@noir-lang/noir_wasm';
+
+const fm = createFileManager(myProjectPath);
+const myCompiledCode = await compile_contract(fm);
+```
+
+```typescript
+// Browser
+
+import { compile_contract, createFileManager } from '@noir-lang/noir_wasm';
+
+const fm = createFileManager('/');
+for (const path of files) {
+  await fm.writeFile(path, await getFileAsStream(path));
+}
+const myCompiledCode = await compile_contract(fm);
+```
+
+***
+
+Generated using [typedoc-plugin-markdown](https://www.npmjs.com/package/typedoc-plugin-markdown) and [TypeDoc](https://typedoc.org/)
diff --git a/docs/versioned_docs/version-v1.0.0-beta.0/reference/NoirJS/noir_wasm/functions/createFileManager.md b/docs/versioned_docs/version-v1.0.0-beta.0/reference/NoirJS/noir_wasm/functions/createFileManager.md
new file mode 100644
index 00000000000..7e65c1d69c7
--- /dev/null
+++ b/docs/versioned_docs/version-v1.0.0-beta.0/reference/NoirJS/noir_wasm/functions/createFileManager.md
@@ -0,0 +1,21 @@
+# createFileManager()
+
+```ts
+createFileManager(dataDir): FileManager
+```
+
+Creates a new FileManager instance based on fs in node and memfs in the browser (via webpack alias)
+
+## Parameters
+
+| Parameter | Type | Description |
+| :------ | :------ | :------ |
+| `dataDir` | `string` | root of the file system |
+
+## Returns
+
+`FileManager`
+
+***
+
+Generated using [typedoc-plugin-markdown](https://www.npmjs.com/package/typedoc-plugin-markdown) and [TypeDoc](https://typedoc.org/)
diff --git a/docs/versioned_docs/version-v1.0.0-beta.0/reference/NoirJS/noir_wasm/functions/inflateDebugSymbols.md b/docs/versioned_docs/version-v1.0.0-beta.0/reference/NoirJS/noir_wasm/functions/inflateDebugSymbols.md
new file mode 100644
index 00000000000..fcea9275341
--- /dev/null
+++ b/docs/versioned_docs/version-v1.0.0-beta.0/reference/NoirJS/noir_wasm/functions/inflateDebugSymbols.md
@@ -0,0 +1,21 @@
+# inflateDebugSymbols()
+
+```ts
+inflateDebugSymbols(debugSymbols): any
+```
+
+Decompresses and decodes the debug symbols
+
+## Parameters
+
+| Parameter | Type | Description |
+| :------ | :------ | :------ |
+| `debugSymbols` | `string` | The base64 encoded debug symbols |
+
+## Returns
+
+`any`
+
+***
+
+Generated using [typedoc-plugin-markdown](https://www.npmjs.com/package/typedoc-plugin-markdown) and [TypeDoc](https://typedoc.org/)
diff --git a/docs/versioned_docs/version-v1.0.0-beta.0/reference/NoirJS/noir_wasm/index.md b/docs/versioned_docs/version-v1.0.0-beta.0/reference/NoirJS/noir_wasm/index.md
new file mode 100644
index 00000000000..b6e0f9d1bc0
--- /dev/null
+++ b/docs/versioned_docs/version-v1.0.0-beta.0/reference/NoirJS/noir_wasm/index.md
@@ -0,0 +1,49 @@
+# noir_wasm
+
+## Exports
+
+### Functions
+
+| Function | Description |
+| :------ | :------ |
+| [compile](functions/compile.md) | Compiles a Noir project |
+| [compile\_contract](functions/compile_contract.md) | Compiles a Noir project |
+| [createFileManager](functions/createFileManager.md) | Creates a new FileManager instance based on fs in node and memfs in the browser (via webpack alias) |
+| [inflateDebugSymbols](functions/inflateDebugSymbols.md) | Decompresses and decodes the debug symbols |
+
+## References
+
+### compile\_program
+
+Renames and re-exports [compile](functions/compile.md)
+
+## Interfaces
+
+### ContractCompilationArtifacts
+
+The compilation artifacts of a given contract.
+
+#### Properties
+
+| Property | Type | Description |
+| :------ | :------ | :------ |
+| `contract` | `ContractArtifact` | The compiled contract. |
+| `warnings` | `unknown`[] | Compilation warnings. |
+
+***
+
+### ProgramCompilationArtifacts
+
+The compilation artifacts of a given program.
+
+#### Properties
+
+| Property | Type | Description |
+| :------ | :------ | :------ |
+| `name` | `string` | not part of the compilation output, injected later |
+| `program` | `ProgramArtifact` | The compiled contract. |
+| `warnings` | `unknown`[] | Compilation warnings. |
+
+***
+
+Generated using [typedoc-plugin-markdown](https://www.npmjs.com/package/typedoc-plugin-markdown) and [TypeDoc](https://typedoc.org/)
diff --git a/docs/versioned_docs/version-v1.0.0-beta.0/reference/NoirJS/noir_wasm/typedoc-sidebar.cjs b/docs/versioned_docs/version-v1.0.0-beta.0/reference/NoirJS/noir_wasm/typedoc-sidebar.cjs
new file mode 100644
index 00000000000..e0870710349
--- /dev/null
+++ b/docs/versioned_docs/version-v1.0.0-beta.0/reference/NoirJS/noir_wasm/typedoc-sidebar.cjs
@@ -0,0 +1,4 @@
+// @ts-check
+/** @type {import('@docusaurus/plugin-content-docs').SidebarsConfig} */
+const typedocSidebar = { items: [{"type":"doc","id":"reference/NoirJS/noir_wasm/index","label":"API"},{"type":"category","label":"Functions","items":[{"type":"doc","id":"reference/NoirJS/noir_wasm/functions/compile","label":"compile"},{"type":"doc","id":"reference/NoirJS/noir_wasm/functions/compile_contract","label":"compile_contract"},{"type":"doc","id":"reference/NoirJS/noir_wasm/functions/createFileManager","label":"createFileManager"},{"type":"doc","id":"reference/NoirJS/noir_wasm/functions/inflateDebugSymbols","label":"inflateDebugSymbols"}]}]};
+module.exports = typedocSidebar.items;
\ No newline at end of file
diff --git a/docs/versioned_docs/version-v1.0.0-beta.0/reference/_category_.json b/docs/versioned_docs/version-v1.0.0-beta.0/reference/_category_.json
new file mode 100644
index 00000000000..5b6a20a609a
--- /dev/null
+++ b/docs/versioned_docs/version-v1.0.0-beta.0/reference/_category_.json
@@ -0,0 +1,5 @@
+{
+    "position": 4,
+    "collapsible": true,
+    "collapsed": true
+}
diff --git a/docs/versioned_docs/version-v1.0.0-beta.0/reference/debugger/_category_.json b/docs/versioned_docs/version-v1.0.0-beta.0/reference/debugger/_category_.json
new file mode 100644
index 00000000000..27869205ad3
--- /dev/null
+++ b/docs/versioned_docs/version-v1.0.0-beta.0/reference/debugger/_category_.json
@@ -0,0 +1,6 @@
+{
+    "label": "Debugger",
+    "position": 1,
+    "collapsible": true,
+    "collapsed": true
+}
diff --git a/docs/versioned_docs/version-v1.0.0-beta.0/reference/debugger/debugger_known_limitations.md b/docs/versioned_docs/version-v1.0.0-beta.0/reference/debugger/debugger_known_limitations.md
new file mode 100644
index 00000000000..936d416ac4b
--- /dev/null
+++ b/docs/versioned_docs/version-v1.0.0-beta.0/reference/debugger/debugger_known_limitations.md
@@ -0,0 +1,59 @@
+---
+title: Known limitations
+description:
+  An overview of known limitations of the current version of the Noir debugger
+keywords:
+  [
+    Nargo,
+    Noir Debugger,
+    VS Code,
+  ]
+sidebar_position: 2
+---
+
+# Debugger Known Limitations
+
+There are currently some limits to what the debugger can observe. 
+
+## Mutable references
+
+The debugger is currently blind to any state mutated via a mutable reference. For example, in:
+
+```
+let mut x = 1;
+let y = &mut x;
+*y = 2;
+```
+
+The update on `x` will not be observed by the debugger. That means, when running `vars` from the debugger REPL, or inspecting the _local variables_ pane in the VS Code debugger, `x` will appear with value 1 despite having executed `*y = 2;`.
+
+## Variables of type function or mutable references are opaque
+
+When inspecting variables, any variable of type `Function` or `MutableReference` will render its value as `<<function>>` or `<<mutable ref>>`.
+
+## Debugger instrumentation affects resulting ACIR
+                      
+In order to make the state of local variables observable, the debugger compiles Noir circuits interleaving foreign calls that track any mutations to them. While this works (except in the cases described above) and doesn't introduce any behavior changes, it does as a side effect produce bigger bytecode. In particular, when running the command `opcodes` on the REPL debugger, you will notice Unconstrained VM blocks that look like this:
+
+```
+...
+5    BRILLIG inputs=[Single(Expression { mul_terms: [], linear_combinations: [], q_c: 2 }), Single(Expression { mul_terms: [], linear_combinations: [(1, Witness(2))], q_c: 0 })]
+       |       outputs=[]
+  5.0  |   Mov { destination: RegisterIndex(2), source: RegisterIndex(0) }
+  5.1  |   Mov { destination: RegisterIndex(3), source: RegisterIndex(1) }
+  5.2  |   Const { destination: RegisterIndex(0), value: Value { inner: 0 } }
+  5.3  |   Const { destination: RegisterIndex(1), value: Value { inner: 0 } }
+  5.4  |   Mov { destination: RegisterIndex(2), source: RegisterIndex(2) }
+  5.5  |   Mov { destination: RegisterIndex(3), source: RegisterIndex(3) }
+  5.6  |   Call { location: 8 }
+  5.7  |   Stop
+  5.8  |   ForeignCall { function: "__debug_var_assign", destinations: [], inputs: [RegisterIndex(RegisterIndex(2)), RegisterIndex(RegisterIndex(3))] }
+...
+```               
+                                    
+If you are interested in debugging/inspecting compiled ACIR without these synthetic changes, you can invoke the REPL debugger with the `--skip-instrumentation` flag or launch the VS Code debugger with the `skipConfiguration` property set to true in its launch configuration. You can find more details about those in the [Debugger REPL reference](debugger_repl.md) and the [VS Code Debugger reference](debugger_vscode.md).
+
+:::note
+Skipping debugger instrumentation means you won't be able to inspect values of local variables.
+:::
+
diff --git a/docs/versioned_docs/version-v1.0.0-beta.0/reference/debugger/debugger_repl.md b/docs/versioned_docs/version-v1.0.0-beta.0/reference/debugger/debugger_repl.md
new file mode 100644
index 00000000000..46e2011304e
--- /dev/null
+++ b/docs/versioned_docs/version-v1.0.0-beta.0/reference/debugger/debugger_repl.md
@@ -0,0 +1,360 @@
+---
+title: REPL Debugger
+description:
+  Noir Debugger REPL options and commands. 
+keywords:
+  [
+    Nargo,
+    Noir CLI,
+    Noir Debugger,
+    REPL,
+  ]
+sidebar_position: 1
+---
+
+## Running the REPL debugger
+
+`nargo debug [OPTIONS] [WITNESS_NAME]`
+
+Runs the Noir REPL debugger. If a `WITNESS_NAME` is provided the debugger writes the resulting execution witness to a `WITNESS_NAME` file.
+
+### Options
+
+| Option                | Description                                                  |
+| --------------------- | ------------------------------------------------------------ |
+| `-p, --prover-name <PROVER_NAME>` | The name of the toml file which contains the inputs for the prover [default: Prover]|
+| `--package <PACKAGE>` | The name of the package to debug                             |
+| `--print-acir`        | Display the ACIR for compiled circuit                        |
+| `--deny-warnings`     | Treat all warnings as errors                                 |
+| `--silence-warnings`  | Suppress warnings                                            |
+| `-h, --help`          | Print help                                                   |
+
+None of these options are required.
+
+:::note
+Since the debugger starts by compiling the target package, all Noir compiler options are also available. Check out the [compiler reference](../nargo_commands.md#nargo-compile) to learn more about the compiler options.
+:::
+
+## REPL commands
+
+Once the debugger is running, it accepts the following commands.
+
+#### `help` (h)
+
+Displays the menu of available commands.
+
+```
+> help
+Available commands:
+
+  opcodes                          display ACIR opcodes
+  into                             step into to the next opcode
+  next                             step until a new source location is reached
+  out                              step until a new source location is reached
+                                   and the current stack frame is finished
+  break LOCATION:OpcodeLocation    add a breakpoint at an opcode location
+  over                             step until a new source location is reached
+                                   without diving into function calls
+  restart                          restart the debugging session
+  delete LOCATION:OpcodeLocation   delete breakpoint at an opcode location
+  witness                          show witness map
+  witness index:u32                display a single witness from the witness map
+  witness index:u32 value:String   update a witness with the given value
+  memset index:usize value:String  update a memory cell with the given
+                                   value
+  continue                         continue execution until the end of the
+                                   program
+  vars                             show variable values available at this point
+                                   in execution
+  stacktrace                       display the current stack trace
+  memory                           show memory (valid when executing unconstrained code)                                 value
+  step                             step to the next ACIR opcode
+
+Other commands:
+
+  help  Show this help message
+  quit  Quit repl
+
+```
+
+### Stepping through programs
+
+#### `next` (n)
+
+Step until the next Noir source code location. While other commands, such as [`into`](#into-i) and [`step`](#step-s), allow for finer grained control of the program's execution at the opcode level, `next` is source code centric. For example:
+
+```
+3    ...
+4    fn main(x: u32) {
+5        assert(entry_point(x) == 2);
+6        swap_entry_point(x, x + 1);
+7 ->     assert(deep_entry_point(x) == 4);
+8        multiple_values_entry_point(x);
+9    }
+```
+
+
+Using `next` here would cause the debugger to jump to the definition of `deep_entry_point` (if available). 
+
+If you want to step over `deep_entry_point` and go straight to line 8, use [the `over` command](#over) instead.
+
+#### `over`
+
+Step until the next source code location, without diving into function calls. For example:
+
+```
+3    ...
+4    fn main(x: u32) {
+5        assert(entry_point(x) == 2);
+6        swap_entry_point(x, x + 1);
+7 ->     assert(deep_entry_point(x) == 4);
+8        multiple_values_entry_point(x);
+9    }
+```
+
+
+Using `over` here would cause the debugger to execute until line 8 (`multiple_values_entry_point(x);`).
+
+If you want to step into `deep_entry_point` instead, use [the `next` command](#next-n).
+
+#### `out`
+
+Step until the end of the current function call. For example:
+
+```
+  3    ...
+  4    fn main(x: u32) {
+  5        assert(entry_point(x) == 2);
+  6        swap_entry_point(x, x + 1);
+  7 ->     assert(deep_entry_point(x) == 4);
+  8        multiple_values_entry_point(x);
+  9    }
+ 10    
+ 11    unconstrained fn returns_multiple_values(x: u32) -> (u32, u32, u32, u32) {
+ 12    ...
+ ...
+ 55    
+ 56    unconstrained fn deep_entry_point(x: u32) -> u32 {
+ 57 ->     level_1(x + 1)
+ 58    }
+
+```
+
+Running `out` here will resume execution until line 8.
+
+#### `step` (s)
+
+Skips to the next ACIR code. A compiled Noir program is a sequence of ACIR opcodes. However, an unconstrained VM opcode denotes the start of an unconstrained code block, to be executed by the unconstrained VM. For example (redacted for brevity):
+
+```
+0  BLACKBOX::RANGE [(_0, num_bits: 32)] [ ]
+1 ->  BRILLIG inputs=[Single(Expression { mul_terms: [], linear_combinations: [(1, Witness(0))], q_c: 0 })] outputs=[Simple(Witness(1))]
+	1.0  |   Mov { destination: RegisterIndex(2), source: RegisterIndex(0) }
+	1.1  |   Const { destination: RegisterIndex(0), value: Value { inner: 0 } }
+	1.2  |   Const { destination: RegisterIndex(1), value: Value { inner: 0 } }
+	1.3  |   Mov { destination: RegisterIndex(2), source: RegisterIndex(2) }
+	1.4  |   Call { location: 7 }
+	...
+	1.43 |   Return
+2    EXPR [ (1, _1) -2 ]
+```
+
+The `->` here shows the debugger paused at an ACIR opcode: `BRILLIG`, at index 1, which denotes an unconstrained code block is about to start.
+
+Using the `step` command at this point would result in the debugger stopping at ACIR opcode 2, `EXPR`, skipping unconstrained computation steps.
+
+Use [the `into` command](#into-i) instead if you want to follow unconstrained computation step by step.
+
+#### `into` (i)
+
+Steps into the next opcode. A compiled Noir program is a sequence of ACIR opcodes. However, a BRILLIG opcode denotes the start of an unconstrained code block, to be executed by the unconstrained VM. For example (redacted for brevity):
+
+```
+0  BLACKBOX::RANGE [(_0, num_bits: 32)] [ ]
+1 ->  BRILLIG inputs=[Single(Expression { mul_terms: [], linear_combinations: [(1, Witness(0))], q_c: 0 })] outputs=[Simple(Witness(1))]
+	1.0  |   Mov { destination: RegisterIndex(2), source: RegisterIndex(0) }
+	1.1  |   Const { destination: RegisterIndex(0), value: Value { inner: 0 } }
+	1.2  |   Const { destination: RegisterIndex(1), value: Value { inner: 0 } }
+	1.3  |   Mov { destination: RegisterIndex(2), source: RegisterIndex(2) }
+	1.4  |   Call { location: 7 }
+	...
+	1.43 |   Return
+2    EXPR [ (1, _1) -2 ]
+``` 
+
+The `->` here shows the debugger paused at an ACIR opcode: `BRILLIG`, at index 1, which denotes an unconstrained code block is about to start.
+
+Using the `into` command at this point would result in the debugger stopping at opcode 1.0, `Mov ...`, allowing the debugger user to follow unconstrained computation step by step.
+
+Use [the `step` command](#step-s) instead if you want to skip to the next ACIR code directly.
+
+#### `continue` (c)
+
+Continues execution until the next breakpoint, or the end of the program.
+
+#### `restart` (res)
+
+Interrupts execution, and restarts a new debugging session from scratch.
+
+#### `opcodes` (o)
+
+Display the program's ACIR opcode sequence. For example:
+
+```
+0  BLACKBOX::RANGE [(_0, num_bits: 32)] [ ]
+1 ->  BRILLIG inputs=[Single(Expression { mul_terms: [], linear_combinations: [(1, Witness(0))], q_c: 0 })] outputs=[Simple(Witness(1))]
+	1.0  |   Mov { destination: RegisterIndex(2), source: RegisterIndex(0) }
+	1.1  |   Const { destination: RegisterIndex(0), value: Value { inner: 0 } }
+	1.2  |   Const { destination: RegisterIndex(1), value: Value { inner: 0 } }
+	1.3  |   Mov { destination: RegisterIndex(2), source: RegisterIndex(2) }
+	1.4  |   Call { location: 7 }
+	...
+	1.43 |   Return
+2     EXPR [ (1, _1) -2 ]
+```
+
+### Breakpoints
+
+#### `break [Opcode]` (or shorthand `b [Opcode]`)
+
+Sets a breakpoint on the specified opcode index. To get a list of the program opcode numbers, see [the `opcode` command](#opcodes-o). For example:
+
+```
+0  BLACKBOX::RANGE [(_0, num_bits: 32)] [ ]
+1 ->  BRILLIG inputs=[Single(Expression { mul_terms: [], linear_combinations: [(1, Witness(0))], q_c: 0 })] outputs=[Simple(Witness(1))]
+	1.0  |   Mov { destination: RegisterIndex(2), source: RegisterIndex(0) }
+	1.1  |   Const { destination: RegisterIndex(0), value: Value { inner: 0 } }
+	1.2  |   Const { destination: RegisterIndex(1), value: Value { inner: 0 } }
+	1.3  |   Mov { destination: RegisterIndex(2), source: RegisterIndex(2) }
+	1.4  |   Call { location: 7 }
+	...
+	1.43 |   Return
+2    EXPR [ (1, _1) -2 ]
+```
+
+In this example, issuing a `break 1.2` command adds break on opcode 1.2, as denoted by the `*` character:
+
+```
+0  BLACKBOX::RANGE [(_0, num_bits: 32)] [ ]
+1 ->  BRILLIG inputs=[Single(Expression { mul_terms: [], linear_combinations: [(1, Witness(0))], q_c: 0 })] outputs=[Simple(Witness(1))]
+	1.0  |   Mov { destination: RegisterIndex(2), source: RegisterIndex(0) }
+	1.1  |   Const { destination: RegisterIndex(0), value: Value { inner: 0 } }
+	1.2  | * Const { destination: RegisterIndex(1), value: Value { inner: 0 } }
+	1.3  |   Mov { destination: RegisterIndex(2), source: RegisterIndex(2) }
+	1.4  |   Call { location: 7 }
+	...
+	1.43 |   Return
+2    EXPR [ (1, _1) -2 ]
+```
+
+Running [the `continue` command](#continue-c) at this point would cause the debugger to execute the program until opcode 1.2.
+
+#### `delete [Opcode]` (or shorthand `d [Opcode]`)
+
+Deletes a breakpoint at an opcode location. Usage is analogous to [the `break` command](#).
+
+### Variable inspection
+
+#### vars
+
+Show variable values available at this point in execution.
+
+:::note
+The ability to inspect variable values from the debugger depends on compilation to be run in a special debug instrumentation mode. This instrumentation weaves variable tracing code with the original source code. 
+
+So variable value inspection comes at the expense of making the resulting ACIR bytecode bigger and harder to understand and optimize.
+
+If you find this compromise unacceptable, you can run the debugger with the flag `--skip-debug-instrumentation`. This will compile your circuit without any additional debug information, so the resulting ACIR bytecode will be identical to the one produced by standard Noir compilation. However, if you opt for this, the `vars` command will not be available while debugging.
+:::
+
+
+### Stacktrace
+
+#### `stacktrace`
+
+Displays the current stack trace.
+
+
+### Witness map
+
+#### `witness` (w)
+
+Show witness map. For example:
+
+```
+_0 = 0
+_1 = 2
+_2 = 1
+```
+
+#### `witness [Witness Index]`
+
+Display a single witness from the witness map. For example:
+
+```
+> witness 1
+_1 = 2
+```
+
+#### `witness [Witness Index] [New value]`
+
+Overwrite the given index with a new value. For example:
+
+```
+> witness 1 3
+_1 = 3
+```
+
+
+### Unconstrained VM memory
+
+#### `memory`
+
+Show unconstrained VM memory state. For example:
+
+```
+> memory
+At opcode 1.13: Store { destination_pointer: RegisterIndex(0), source: RegisterIndex(3) }
+...
+> registers
+0 = 0
+1 = 10
+2 = 0
+3 = 1
+4 = 1
+5 = 2³²
+6 = 1
+> into
+At opcode 1.14: Const { destination: RegisterIndex(5), value: Value { inner: 1 } }
+...
+> memory
+0 = 1
+>
+```
+
+In the example above: we start with clean memory, then step through a `Store` opcode which stores the value of register 3 (1) into the memory address stored in register 0 (0). Thus now `memory` shows memory address 0 contains value 1.
+
+:::note
+This command is only functional while the debugger is executing unconstrained code.
+:::
+
+#### `memset [Memory address] [New value]`
+
+Update a memory cell with the given value. For example:
+
+```
+> memory
+0 = 1
+> memset 0 2
+> memory
+0 = 2
+> memset 1 4
+> memory
+0 = 2
+1 = 4
+>
+```
+
+:::note
+This command is only functional while the debugger is executing unconstrained code.
+:::
\ No newline at end of file
diff --git a/docs/versioned_docs/version-v1.0.0-beta.0/reference/debugger/debugger_vscode.md b/docs/versioned_docs/version-v1.0.0-beta.0/reference/debugger/debugger_vscode.md
new file mode 100644
index 00000000000..c027332b3b0
--- /dev/null
+++ b/docs/versioned_docs/version-v1.0.0-beta.0/reference/debugger/debugger_vscode.md
@@ -0,0 +1,82 @@
+---
+title: VS Code Debugger
+description:
+  VS Code Debugger configuration and features.
+keywords:
+  [
+    Nargo,
+    Noir CLI,
+    Noir Debugger,
+    VS Code,
+    IDE,
+  ]
+sidebar_position: 0
+---
+
+# VS Code Noir Debugger Reference
+
+The Noir debugger enabled by the vscode-noir extension ships with default settings such that the most common scenario should run without any additional configuration steps.
+
+These defaults can nevertheless be overridden by defining a launch configuration file. This page provides a reference for the properties you can override via a launch configuration file, as well as documenting the Nargo `dap` command, which is a dependency of the VS Code Noir debugger. 
+
+
+## Creating and editing launch configuration files
+
+To create a launch configuration file from VS Code, open the _debug pane_, and click on _create a launch.json file_. 
+
+![Creating a launch configuration file](@site/static/img/debugger/ref1-create-launch.png)
+
+A `launch.json` file will be created, populated with basic defaults. 
+
+### Noir Debugger launch.json properties
+
+#### projectFolder
+
+_String, optional._
+
+Absolute path to the Nargo project to debug. By default, it is dynamically determined by looking for the nearest `Nargo.toml` file to the active file at the moment of launching the debugger. 
+
+#### proverName
+
+_String, optional._
+
+Name of the prover input to use. Defaults to `Prover`, which looks for a file named `Prover.toml` at the `projectFolder`.
+
+#### generateAcir
+
+_Boolean, optional._
+
+If true, generate ACIR opcodes instead of unconstrained opcodes which will be closer to release binaries but less convenient for debugging. Defaults to `false`.
+                
+#### skipInstrumentation
+
+_Boolean, optional._
+
+Skips variables debugging instrumentation of code, making debugging less convenient but the resulting binary smaller and closer to production. Defaults to `false`.
+
+:::note
+Skipping instrumentation causes the debugger to be unable to inspect local variables.
+:::
+
+## `nargo dap [OPTIONS]`
+
+When run without any option flags, it starts the Nargo Debug Adapter Protocol server, which acts as the debugging backend for the VS Code Noir Debugger. 
+
+All option flags are related to preflight checks. The Debug Adapter Protocol specifies how errors are to be informed from a running DAP server, but it doesn't specify mechanisms to communicate server initialization errors between the DAP server and its client IDE. 
+
+Thus `nargo dap` ships with a _preflight check_ mode. If flag `--preflight-check` and the rest of the `--preflight-*` flags are provided, Nargo will run the same initialization routine except it will not start the DAP server.
+
+`vscode-noir` will then run `nargo dap` in preflight check mode first before a debugging session starts. If the preflight check ends in error, vscode-noir will present stderr and stdout output from this process through its own Output pane in VS Code. This makes it possible for users to diagnose what pieces of configuration might be wrong or missing in case of initialization errors.
+
+If the preflight check succeeds, `vscode-noir` proceeds to start the DAP server normally but running `nargo dap` without any additional flags.
+
+### Options
+
+| Option                                  | Description                                                                         |
+| --------------------------------------------------------- | --------------------------------------------------------------------------------------------------------- |
+| `--preflight-check`                     | If present, dap runs in preflight check mode.                               |
+| `--preflight-project-folder <PREFLIGHT_PROJECT_FOLDER>`   | Absolute path to the project to debug for preflight check.                        |
+| `--preflight-prover-name <PREFLIGHT_PROVER_NAME>`       | Name of prover file to use for preflight check                              |
+| `--preflight-generate-acir`                 | Optional. If present, compile in ACIR mode while running preflight check.                                 |
+| `--preflight-skip-instrumentation`            | Optional. If present, compile without introducing debug instrumentation while running preflight check.  |
+| `-h, --help`                            | Print help.                                               |
diff --git a/docs/versioned_docs/version-v1.0.0-beta.0/reference/nargo_commands.md b/docs/versioned_docs/version-v1.0.0-beta.0/reference/nargo_commands.md
new file mode 100644
index 00000000000..8842fad6647
--- /dev/null
+++ b/docs/versioned_docs/version-v1.0.0-beta.0/reference/nargo_commands.md
@@ -0,0 +1,474 @@
+---
+title: Nargo
+description:
+  Noir CLI Commands for Noir Prover and Verifier to create, execute, prove and verify programs,
+  generate Solidity verifier smart contract and compile into JSON file containing ACIR
+  representation and ABI of circuit.
+keywords:
+  [
+    Nargo,
+    Noir CLI,
+    Noir Prover,
+    Noir Verifier,
+    generate Solidity verifier,
+    compile JSON file,
+    ACIR representation,
+    ABI of circuit,
+    TypeScript,
+  ]
+sidebar_position: 0
+---
+
+# Command-Line Help for `nargo`
+
+This document contains the help content for the `nargo` command-line program.
+
+**Command Overview:**
+
+* [`nargo`↴](#nargo)
+* [`nargo check`↴](#nargo-check)
+* [`nargo fmt`↴](#nargo-fmt)
+* [`nargo compile`↴](#nargo-compile)
+* [`nargo new`↴](#nargo-new)
+* [`nargo init`↴](#nargo-init)
+* [`nargo execute`↴](#nargo-execute)
+* [`nargo debug`↴](#nargo-debug)
+* [`nargo test`↴](#nargo-test)
+* [`nargo info`↴](#nargo-info)
+* [`nargo lsp`↴](#nargo-lsp)
+* [`nargo generate-completion-script`↴](#nargo-generate-completion-script)
+
+## `nargo`
+
+Noir's package manager
+
+**Usage:** `nargo <COMMAND>`
+
+###### **Subcommands:**
+
+* `check` — Checks the constraint system for errors
+* `fmt` — Format the Noir files in a workspace
+* `compile` — Compile the program and its secret execution trace into ACIR format
+* `new` — Create a Noir project in a new directory
+* `init` — Create a Noir project in the current directory
+* `execute` — Executes a circuit to calculate its return value
+* `debug` — Executes a circuit in debug mode
+* `test` — Run the tests for this program
+* `info` — Provides detailed information on each of a program's function (represented by a single circuit)
+* `lsp` — Starts the Noir LSP server
+* `generate-completion-script` — Generates a shell completion script for your favorite shell
+
+###### **Options:**
+
+
+
+
+## `nargo check`
+
+Checks the constraint system for errors
+
+**Usage:** `nargo check [OPTIONS]`
+
+###### **Options:**
+
+* `--package <PACKAGE>` — The name of the package to check
+* `--workspace` — Check all packages in the workspace
+
+  Possible values: `true`, `false`
+
+* `--overwrite` — Force overwrite of existing files
+
+  Possible values: `true`, `false`
+
+* `--expression-width <EXPRESSION_WIDTH>` — Specify the backend expression width that should be targeted
+* `--bounded-codegen` — Generate ACIR with the target backend expression width. The default is to generate ACIR without a bound and split expressions after code generation. Activating this flag can sometimes provide optimizations for certain programs
+
+  Default value: `false`
+
+  Possible values: `true`, `false`
+
+* `--force` — Force a full recompilation
+
+  Possible values: `true`, `false`
+
+* `--print-acir` — Display the ACIR for compiled circuit
+
+  Possible values: `true`, `false`
+
+* `--deny-warnings` — Treat all warnings as errors
+
+  Possible values: `true`, `false`
+
+* `--silence-warnings` — Suppress warnings
+
+  Possible values: `true`, `false`
+
+* `--debug-comptime-in-file <DEBUG_COMPTIME_IN_FILE>` — Enable printing results of comptime evaluation: provide a path suffix for the module to debug, e.g. "package_name/src/main.nr"
+* `--skip-underconstrained-check` — Flag to turn off the compiler check for under constrained values. Warning: This can improve compilation speed but can also lead to correctness errors. This check should always be run on production code
+
+  Possible values: `true`, `false`
+
+
+
+
+## `nargo fmt`
+
+Format the Noir files in a workspace
+
+**Usage:** `nargo fmt [OPTIONS]`
+
+###### **Options:**
+
+* `--check` — Run noirfmt in check mode
+
+  Possible values: `true`, `false`
+
+
+
+
+## `nargo compile`
+
+Compile the program and its secret execution trace into ACIR format
+
+**Usage:** `nargo compile [OPTIONS]`
+
+###### **Options:**
+
+* `--package <PACKAGE>` — The name of the package to compile
+* `--workspace` — Compile all packages in the workspace
+
+  Possible values: `true`, `false`
+
+* `--expression-width <EXPRESSION_WIDTH>` — Specify the backend expression width that should be targeted
+* `--bounded-codegen` — Generate ACIR with the target backend expression width. The default is to generate ACIR without a bound and split expressions after code generation. Activating this flag can sometimes provide optimizations for certain programs
+
+  Default value: `false`
+
+  Possible values: `true`, `false`
+
+* `--force` — Force a full recompilation
+
+  Possible values: `true`, `false`
+
+* `--print-acir` — Display the ACIR for compiled circuit
+
+  Possible values: `true`, `false`
+
+* `--deny-warnings` — Treat all warnings as errors
+
+  Possible values: `true`, `false`
+
+* `--silence-warnings` — Suppress warnings
+
+  Possible values: `true`, `false`
+
+* `--debug-comptime-in-file <DEBUG_COMPTIME_IN_FILE>` — Enable printing results of comptime evaluation: provide a path suffix for the module to debug, e.g. "package_name/src/main.nr"
+* `--skip-underconstrained-check` — Flag to turn off the compiler check for under constrained values. Warning: This can improve compilation speed but can also lead to correctness errors. This check should always be run on production code
+
+  Possible values: `true`, `false`
+
+
+
+
+## `nargo new`
+
+Create a Noir project in a new directory
+
+**Usage:** `nargo new [OPTIONS] <PATH>`
+
+###### **Arguments:**
+
+* `<PATH>` — The path to save the new project
+
+###### **Options:**
+
+* `--name <NAME>` — Name of the package [default: package directory name]
+* `--lib` — Use a library template
+
+  Possible values: `true`, `false`
+
+* `--bin` — Use a binary template [default]
+
+  Possible values: `true`, `false`
+
+* `--contract` — Use a contract template
+
+  Possible values: `true`, `false`
+
+
+
+
+## `nargo init`
+
+Create a Noir project in the current directory
+
+**Usage:** `nargo init [OPTIONS]`
+
+###### **Options:**
+
+* `--name <NAME>` — Name of the package [default: current directory name]
+* `--lib` — Use a library template
+
+  Possible values: `true`, `false`
+
+* `--bin` — Use a binary template [default]
+
+  Possible values: `true`, `false`
+
+* `--contract` — Use a contract template
+
+  Possible values: `true`, `false`
+
+
+
+
+## `nargo execute`
+
+Executes a circuit to calculate its return value
+
+**Usage:** `nargo execute [OPTIONS] [WITNESS_NAME]`
+
+###### **Arguments:**
+
+* `<WITNESS_NAME>` — Write the execution witness to named file
+
+Defaults to the name of the package being executed.
+
+###### **Options:**
+
+* `-p`, `--prover-name <PROVER_NAME>` — The name of the toml file which contains the inputs for the prover
+
+  Default value: `Prover`
+* `--package <PACKAGE>` — The name of the package to execute
+* `--workspace` — Execute all packages in the workspace
+
+  Possible values: `true`, `false`
+
+* `--expression-width <EXPRESSION_WIDTH>` — Specify the backend expression width that should be targeted
+* `--bounded-codegen` — Generate ACIR with the target backend expression width. The default is to generate ACIR without a bound and split expressions after code generation. Activating this flag can sometimes provide optimizations for certain programs
+
+  Default value: `false`
+
+  Possible values: `true`, `false`
+
+* `--force` — Force a full recompilation
+
+  Possible values: `true`, `false`
+
+* `--print-acir` — Display the ACIR for compiled circuit
+
+  Possible values: `true`, `false`
+
+* `--deny-warnings` — Treat all warnings as errors
+
+  Possible values: `true`, `false`
+
+* `--silence-warnings` — Suppress warnings
+
+  Possible values: `true`, `false`
+
+* `--debug-comptime-in-file <DEBUG_COMPTIME_IN_FILE>` — Enable printing results of comptime evaluation: provide a path suffix for the module to debug, e.g. "package_name/src/main.nr"
+* `--skip-underconstrained-check` — Flag to turn off the compiler check for under constrained values. Warning: This can improve compilation speed but can also lead to correctness errors. This check should always be run on production code
+
+  Possible values: `true`, `false`
+
+* `--oracle-resolver <ORACLE_RESOLVER>` — JSON RPC url to solve oracle calls
+
+
+
+## `nargo debug`
+
+Executes a circuit in debug mode
+
+**Usage:** `nargo debug [OPTIONS] [WITNESS_NAME]`
+
+###### **Arguments:**
+
+* `<WITNESS_NAME>` — Write the execution witness to named file
+
+###### **Options:**
+
+* `-p`, `--prover-name <PROVER_NAME>` — The name of the toml file which contains the inputs for the prover
+
+  Default value: `Prover`
+* `--package <PACKAGE>` — The name of the package to execute
+* `--expression-width <EXPRESSION_WIDTH>` — Specify the backend expression width that should be targeted
+* `--bounded-codegen` — Generate ACIR with the target backend expression width. The default is to generate ACIR without a bound and split expressions after code generation. Activating this flag can sometimes provide optimizations for certain programs
+
+  Default value: `false`
+
+  Possible values: `true`, `false`
+
+* `--force` — Force a full recompilation
+
+  Possible values: `true`, `false`
+
+* `--print-acir` — Display the ACIR for compiled circuit
+
+  Possible values: `true`, `false`
+
+* `--deny-warnings` — Treat all warnings as errors
+
+  Possible values: `true`, `false`
+
+* `--silence-warnings` — Suppress warnings
+
+  Possible values: `true`, `false`
+
+* `--debug-comptime-in-file <DEBUG_COMPTIME_IN_FILE>` — Enable printing results of comptime evaluation: provide a path suffix for the module to debug, e.g. "package_name/src/main.nr"
+* `--skip-underconstrained-check` — Flag to turn off the compiler check for under constrained values. Warning: This can improve compilation speed but can also lead to correctness errors. This check should always be run on production code
+
+  Possible values: `true`, `false`
+
+* `--acir-mode` — Force ACIR output (disabling instrumentation)
+
+  Possible values: `true`, `false`
+
+* `--skip-instrumentation <SKIP_INSTRUMENTATION>` — Disable vars debug instrumentation (enabled by default)
+
+  Possible values: `true`, `false`
+
+
+
+
+## `nargo test`
+
+Run the tests for this program
+
+**Usage:** `nargo test [OPTIONS] [TEST_NAME]`
+
+###### **Arguments:**
+
+* `<TEST_NAME>` — If given, only tests with names containing this string will be run
+
+###### **Options:**
+
+* `--show-output` — Display output of `println` statements
+
+  Possible values: `true`, `false`
+
+* `--exact` — Only run tests that match exactly
+
+  Possible values: `true`, `false`
+
+* `--package <PACKAGE>` — The name of the package to test
+* `--workspace` — Test all packages in the workspace
+
+  Possible values: `true`, `false`
+
+* `--expression-width <EXPRESSION_WIDTH>` — Specify the backend expression width that should be targeted
+* `--bounded-codegen` — Generate ACIR with the target backend expression width. The default is to generate ACIR without a bound and split expressions after code generation. Activating this flag can sometimes provide optimizations for certain programs
+
+  Default value: `false`
+
+  Possible values: `true`, `false`
+
+* `--force` — Force a full recompilation
+
+  Possible values: `true`, `false`
+
+* `--print-acir` — Display the ACIR for compiled circuit
+
+  Possible values: `true`, `false`
+
+* `--deny-warnings` — Treat all warnings as errors
+
+  Possible values: `true`, `false`
+
+* `--silence-warnings` — Suppress warnings
+
+  Possible values: `true`, `false`
+
+* `--debug-comptime-in-file <DEBUG_COMPTIME_IN_FILE>` — Enable printing results of comptime evaluation: provide a path suffix for the module to debug, e.g. "package_name/src/main.nr"
+* `--skip-underconstrained-check` — Flag to turn off the compiler check for under constrained values. Warning: This can improve compilation speed but can also lead to correctness errors. This check should always be run on production code
+
+  Possible values: `true`, `false`
+
+* `--oracle-resolver <ORACLE_RESOLVER>` — JSON RPC url to solve oracle calls
+
+
+
+## `nargo info`
+
+Provides detailed information on each of a program's function (represented by a single circuit)
+
+Current information provided per circuit: 1. The number of ACIR opcodes 2. Counts the final number gates in the circuit used by a backend
+
+**Usage:** `nargo info [OPTIONS]`
+
+###### **Options:**
+
+* `--package <PACKAGE>` — The name of the package to detail
+* `--workspace` — Detail all packages in the workspace
+
+  Possible values: `true`, `false`
+
+* `--profile-execution`
+
+  Possible values: `true`, `false`
+
+* `-p`, `--prover-name <PROVER_NAME>` — The name of the toml file which contains the inputs for the prover
+
+  Default value: `Prover`
+* `--expression-width <EXPRESSION_WIDTH>` — Specify the backend expression width that should be targeted
+* `--bounded-codegen` — Generate ACIR with the target backend expression width. The default is to generate ACIR without a bound and split expressions after code generation. Activating this flag can sometimes provide optimizations for certain programs
+
+  Default value: `false`
+
+  Possible values: `true`, `false`
+
+* `--force` — Force a full recompilation
+
+  Possible values: `true`, `false`
+
+* `--print-acir` — Display the ACIR for compiled circuit
+
+  Possible values: `true`, `false`
+
+* `--deny-warnings` — Treat all warnings as errors
+
+  Possible values: `true`, `false`
+
+* `--silence-warnings` — Suppress warnings
+
+  Possible values: `true`, `false`
+
+* `--debug-comptime-in-file <DEBUG_COMPTIME_IN_FILE>` — Enable printing results of comptime evaluation: provide a path suffix for the module to debug, e.g. "package_name/src/main.nr"
+* `--skip-underconstrained-check` — Flag to turn off the compiler check for under constrained values. Warning: This can improve compilation speed but can also lead to correctness errors. This check should always be run on production code
+
+  Possible values: `true`, `false`
+
+
+
+
+## `nargo lsp`
+
+Starts the Noir LSP server
+
+Starts an LSP server which allows IDEs such as VS Code to display diagnostics in Noir source.
+
+VS Code Noir Language Support: https://marketplace.visualstudio.com/items?itemName=noir-lang.vscode-noir
+
+**Usage:** `nargo lsp`
+
+
+
+## `nargo generate-completion-script`
+
+Generates a shell completion script for your favorite shell
+
+**Usage:** `nargo generate-completion-script <SHELL>`
+
+###### **Arguments:**
+
+* `<SHELL>` — The shell to generate completions for. One of: bash, elvish, fish, powershell, zsh
+
+
+
+<hr/>
+
+<small><i>
+    This document was generated automatically by
+    <a href="https://crates.io/crates/clap-markdown"><code>clap-markdown</code></a>.
+</i></small>
+
diff --git a/docs/versioned_docs/version-v1.0.0-beta.0/reference/noir_codegen.md b/docs/versioned_docs/version-v1.0.0-beta.0/reference/noir_codegen.md
new file mode 100644
index 00000000000..e4c362f9610
--- /dev/null
+++ b/docs/versioned_docs/version-v1.0.0-beta.0/reference/noir_codegen.md
@@ -0,0 +1,116 @@
+---
+title: Noir Codegen for TypeScript
+description: Learn how to use Noir codegen to generate TypeScript bindings 
+keywords: [Nargo, Noir, compile, TypeScript]
+sidebar_position: 3
+---
+
+When using TypeScript, it is extra work to interpret Noir program outputs in a type-safe way. Third party libraries may exist for popular Noir programs, but they are either hard to find or unmaintained.
+
+Now you can generate TypeScript bindings for your Noir programs in two steps:
+
+1. Exporting Noir functions using `nargo export`
+2. Using the TypeScript module `noir_codegen` to generate TypeScript binding
+
+**Note:** you can only export functions from a Noir *library* (not binary or contract program types).
+
+## Installation
+
+### Your TypeScript project
+
+If you don't already have a TypeScript project you can add the module with `yarn` (or `npm`), then initialize it:
+
+```bash
+yarn add typescript -D
+npx tsc --init
+```
+
+### Add TypeScript module - `noir_codegen`
+
+The following command will add the module to your project's devDependencies:
+
+```bash
+yarn add @noir-lang/noir_codegen -D
+```
+
+### Nargo library
+
+Make sure you have Nargo, v0.25.0 or greater, installed. If you don't, follow the [installation guide](../getting_started/noir_installation.md).
+
+If you're in a new project, make a `circuits` folder and create a new Noir library:
+
+```bash
+mkdir circuits && cd circuits
+nargo new --lib myNoirLib
+```
+
+## Usage
+
+### Export ABI of specified functions
+
+First go to the `.nr` files in your Noir library, and add the `#[export]` macro to each function that you want to use in TypeScript.
+
+```rust
+#[export]
+fn your_function(...
+```
+
+From your Noir library (where `Nargo.toml` is), run the following command:
+
+```bash
+nargo export
+```
+
+You will now have an `export` directory with a .json file per exported function.
+
+You can also specify the directory of Noir programs using `--program-dir`, for example:
+
+```bash
+nargo export --program-dir=./circuits/myNoirLib
+```
+
+### Generate TypeScript bindings from exported functions
+
+To use the `noir-codegen` package we added to the TypeScript project:
+
+```bash
+yarn noir-codegen ./export/your_function.json
+```
+
+This creates an `exports` directory with an `index.ts` file containing all exported functions.
+
+**Note:** adding `--out-dir` allows you to specify an output dir for your TypeScript bindings to go. Eg:
+
+```bash
+yarn noir-codegen ./export/*.json --out-dir ./path/to/output/dir
+```
+
+## Example .nr function to .ts output
+
+Consider a Noir library with this function:
+
+```rust
+#[export]
+fn not_equal(x: Field, y: Field) -> bool {
+    x != y
+}
+```
+
+After the export and codegen steps, you should have an `index.ts` like:
+
+```typescript
+export type Field = string;
+
+
+export const is_equal_circuit: CompiledCircuit = 
+{"abi":{"parameters":[{"name":"x","type":{"kind":"field"},"visibility":"private"},{"name":"y","type":{"kind":"field"},"visibility":"private"}],"return_type":{"abi_type":{"kind":"boolean"},"visibility":"private"}},"bytecode":"H4sIAAAAAAAA/7WUMQ7DIAxFQ0Krrr2JjSGYLVcpKrn/CaqqDQN12WK+hPBgmWd/wEyHbF1SS923uhOs3pfoChI+wKXMAXzIKyNj4PB0TFTYc0w5RUjoqeAeEu1wqK0F54RGkWvW44LPzExnlkbMEs4JNZmN8PxS42uHv82T8a3Jeyn2Ks+VLPcO558HmyLMCDOXAXXtpPt4R/Rt9T36ss6dS9HGPx/eG17nGegKBQAA"};
+
+export async function is_equal(x: Field, y: Field, foreignCallHandler?: ForeignCallHandler): Promise<boolean> {
+  const program = new Noir(is_equal_circuit);
+  const args: InputMap = { x, y };
+  const { returnValue } = await program.execute(args, foreignCallHandler);
+  return returnValue as boolean;
+}
+```
+
+Now the `is_equal()` function and relevant types are readily available for use in TypeScript.
diff --git a/docs/versioned_docs/version-v1.0.0-beta.0/tooling/debugger.md b/docs/versioned_docs/version-v1.0.0-beta.0/tooling/debugger.md
new file mode 100644
index 00000000000..200b5fc423a
--- /dev/null
+++ b/docs/versioned_docs/version-v1.0.0-beta.0/tooling/debugger.md
@@ -0,0 +1,26 @@
+---
+title: Debugger
+description: Learn about the Noir Debugger, in its REPL or VS Code versions.
+keywords: [Nargo, VSCode, Visual Studio Code, REPL, Debugger]
+sidebar_position: 2
+---
+
+# Noir Debugger
+
+There are currently two ways of debugging Noir programs:
+
+1. From VS Code, via the [vscode-noir](https://github.com/noir-lang/vscode-noir) extension. You can install it via the [Visual Studio Marketplace](https://marketplace.visualstudio.com/items?itemName=noir-lang.vscode-noir).
+2. Via the REPL debugger, which ships with Nargo.
+
+In order to use either version of the debugger, you will need to install recent enough versions of Noir, [Nargo](../getting_started/noir_installation.md) and vscode-noir:
+
+- Noir & Nargo ≥0.28.0
+- Noir's VS Code extension ≥0.0.11
+
+:::info
+At the moment, the debugger supports debugging binary projects, but not contracts.
+:::
+
+We cover the VS Code Noir debugger more in depth in [its VS Code debugger how-to guide](../how_to/debugger/debugging_with_vs_code.md) and [the reference](../reference/debugger/debugger_vscode.md).
+
+The REPL debugger is discussed at length in [the REPL debugger how-to guide](../how_to/debugger/debugging_with_the_repl.md) and [the reference](../reference/debugger/debugger_repl.md).
diff --git a/docs/versioned_docs/version-v1.0.0-beta.0/tooling/language_server.md b/docs/versioned_docs/version-v1.0.0-beta.0/tooling/language_server.md
new file mode 100644
index 00000000000..81e0356ef8a
--- /dev/null
+++ b/docs/versioned_docs/version-v1.0.0-beta.0/tooling/language_server.md
@@ -0,0 +1,43 @@
+---
+title: Language Server
+description: Learn about the Noir Language Server, how to install the components, and configuration that may be required.
+keywords: [Nargo, Language Server, LSP, VSCode, Visual Studio Code]
+sidebar_position: 0
+---
+
+This section helps you install and configure the Noir Language Server.
+
+The Language Server Protocol (LSP) has two components, the [Server](#language-server) and the [Client](#language-client). Below we describe each in the context of Noir.
+
+## Language Server
+
+The Server component is provided by the Nargo command line tool that you installed at the beginning of this guide.
+As long as Nargo is installed and you've used it to run other commands in this guide, it should be good to go!
+
+If you'd like to verify that the `nargo lsp` command is available, you can run `nargo --help` and look for `lsp` in the list of commands. If you see it, you're using a version of Noir with LSP support.
+
+## Language Client
+
+The Client component is usually an editor plugin that launches the Server. It communicates LSP messages between the editor and the Server. For example, when you save a file, the Client will alert the Server, so it can try to compile the project and report any errors.
+
+Currently, Noir provides a Language Client for Visual Studio Code via the [vscode-noir](https://github.com/noir-lang/vscode-noir) extension. You can install it via the [Visual Studio Marketplace](https://marketplace.visualstudio.com/items?itemName=noir-lang.vscode-noir).
+
+> **Note:** Noir's Language Server Protocol support currently assumes users' VSCode workspace root to be the same as users' Noir project root (i.e. where Nargo.toml lies).
+>
+> If LSP features seem to be missing / malfunctioning, make sure you are opening your Noir project directly (instead of as a sub-folder) in your VSCode instance.
+
+When your language server is running correctly and the VSCode plugin is installed, you should see handy codelens buttons for compilation, measuring circuit size, execution, and tests:
+
+![Compile and Execute](@site/static/img/codelens_compile_execute.png)
+![Run test](@site/static/img/codelens_run_test.png)
+
+You should also see your tests in the `testing` panel:
+
+![Testing panel](@site/static/img/codelens_testing_panel.png)
+
+### Configuration
+
+- **Noir: Enable LSP** - If checked, the extension will launch the Language Server via `nargo lsp` and communicate with it.
+- **Noir: Nargo Flags** - Additional flags may be specified if you require them to be added when the extension calls `nargo lsp`.
+- **Noir: Nargo Path** - An absolute path to a Nargo binary with the `lsp` command. This may be useful if Nargo is not within the `PATH` of your editor.
+- **Noir > Trace: Server** - Setting this to `"messages"` or `"verbose"` will log LSP messages between the Client and Server. Useful for debugging.
diff --git a/docs/versioned_docs/version-v1.0.0-beta.0/tooling/testing.md b/docs/versioned_docs/version-v1.0.0-beta.0/tooling/testing.md
new file mode 100644
index 00000000000..866677da567
--- /dev/null
+++ b/docs/versioned_docs/version-v1.0.0-beta.0/tooling/testing.md
@@ -0,0 +1,79 @@
+---
+title: Testing in Noir
+description: Learn how to use Nargo to test your Noir program in a quick and easy way
+keywords: [Nargo, testing, Noir, compile, test]
+sidebar_position: 1
+---
+
+You can test your Noir programs using Noir circuits.
+
+Nargo will automatically compile and run any functions which have the decorator `#[test]` on them if
+you run `nargo test`.
+
+For example if you have a program like:
+
+```rust
+fn add(x: u64, y: u64) -> u64 {
+    x + y
+}
+#[test]
+fn test_add() {
+    assert(add(2,2) == 4);
+    assert(add(0,1) == 1);
+    assert(add(1,0) == 1);
+}
+```
+
+Running `nargo test` will test that the `test_add` function can be executed while satisfying all
+the constraints which allows you to test that add returns the expected values. Test functions can't
+have any arguments currently.
+
+### Test fail
+
+You can write tests that are expected to fail by using the decorator `#[test(should_fail)]`. For example:
+
+```rust
+fn add(x: u64, y: u64) -> u64 {
+    x + y
+}
+#[test(should_fail)]
+fn test_add() {
+    assert(add(2,2) == 5);
+}
+```
+
+You can be more specific and make it fail with a specific reason by using `should_fail_with = "<the reason for failure>"`:
+
+```rust
+fn main(african_swallow_avg_speed : Field) {
+    assert(african_swallow_avg_speed == 65, "What is the airspeed velocity of an unladen swallow");
+}
+
+#[test]
+fn test_king_arthur() {
+    main(65);
+}
+
+#[test(should_fail_with = "What is the airspeed velocity of an unladen swallow")]
+fn test_bridgekeeper() {
+    main(32);
+}
+```
+
+The string given to `should_fail_with` doesn't need to exactly match the failure reason, it just needs to be a substring of it:
+
+```rust
+fn main(african_swallow_avg_speed : Field) {
+    assert(african_swallow_avg_speed == 65, "What is the airspeed velocity of an unladen swallow");
+}
+
+#[test]
+fn test_king_arthur() {
+    main(65);
+}
+
+#[test(should_fail_with = "airspeed velocity")]
+fn test_bridgekeeper() {
+    main(32);
+}
+```
\ No newline at end of file
diff --git a/docs/versioned_docs/version-v1.0.0-beta.0/tutorials/noirjs_app.md b/docs/versioned_docs/version-v1.0.0-beta.0/tutorials/noirjs_app.md
new file mode 100644
index 00000000000..6e69ea0bbed
--- /dev/null
+++ b/docs/versioned_docs/version-v1.0.0-beta.0/tutorials/noirjs_app.md
@@ -0,0 +1,366 @@
+---
+title: Building a web app with NoirJS
+description: Learn how to setup a new app that uses Noir to generate and verify zero-knowledge SNARK proofs in a typescript or javascript environment.
+keywords: [how to, guide, javascript, typescript, noir, barretenberg, zero-knowledge, proofs, app]
+sidebar_position: 0
+pagination_next: noir/concepts/data_types/index
+---
+
+NoirJS is a set of packages meant to work both in a browser and a server environment. In this tutorial, we will build a simple web app using them. From here, you should get an idea on how to proceed with your own Noir projects!
+
+You can find the complete app code for this guide [here](https://github.com/noir-lang/tiny-noirjs-app).
+
+## Setup
+
+:::note
+
+Feel free to use whatever versions, just keep in mind that Nargo and the NoirJS packages are meant to be in sync. For example, Nargo 0.31.x matches `noir_js@0.31.x`, etc.
+
+In this guide, we will be pinned to 0.31.0.
+
+:::
+
+Before we start, we want to make sure we have Node, Nargo and the Barretenberg proving system (`bb`) installed.
+
+We start by opening a terminal and executing `node --version`. If we don't get an output like `v20.10.0`, that means node is not installed. Let's do that by following the handy [nvm guide](https://github.com/nvm-sh/nvm?tab=readme-ov-file#install--update-script).
+
+As for `Nargo`, we can follow the [Nargo guide](../getting_started/quick_start.md) to install it. If you're lazy, just paste this on a terminal and run `noirup`:
+
+```sh
+curl -L https://raw.githubusercontent.com/noir-lang/noirup/main/install | bash
+```
+
+Follow the instructions on [this page](https://github.com/AztecProtocol/aztec-packages/tree/master/barretenberg/cpp/src/barretenberg/bb#installation) to install `bb`.
+Version 0.41.0 is compatible with `nargo` version 0.31.0, which you can install with `bbup -v 0.41.0` once `bbup` is installed.
+
+Easy enough. Onwards!
+
+## Our project
+
+ZK is a powerful technology. An app that doesn't reveal one of the inputs to _anyone_ is almost unbelievable, yet Noir makes it as easy as a single line of code.
+
+In fact, it's so simple that it comes nicely packaged in `nargo`. Let's do that!
+
+### Nargo
+
+Run:
+
+```bash
+nargo new circuit
+```
+
+And... That's about it. Your program is ready to be compiled and run.
+
+To compile, let's `cd` into the `circuit` folder to enter our project, and call:
+
+```bash
+nargo compile
+```
+
+This compiles our circuit into `json` format and add it to a new `target` folder.
+
+:::info
+
+At this point in the tutorial, your folder structure should look like this:
+
+```tree
+.
+└── circuit <---- our working directory
+    ├── Nargo.toml
+    ├── src
+    │   └── main.nr
+    └── target
+        └── circuit.json
+```
+
+:::
+
+### Node and Vite
+
+If you want to explore Nargo, feel free to go on a side-quest now and follow the steps in the
+[getting started](../getting_started/quick_start.md) guide. However, we want our app to run on the browser, so we need Vite.
+
+Vite is a powerful tool to generate static websites. While it provides all kinds of features, let's just go barebones with some good old vanilla JS.
+
+To do this this, go back to the previous folder (`cd ..`) and create a new vite project by running `npm create vite` and choosing "Vanilla" and "Javascript".
+
+A wild `vite-project` directory should now appear in your root folder! Let's not waste any time and dive right in:
+
+```bash
+cd vite-project
+```
+
+### Setting Up Vite and Configuring the Project
+
+Before we proceed with any coding, let's get our environment tailored for Noir. We'll start by laying down the foundations with a `vite.config.js` file. This little piece of configuration is our secret sauce for making sure everything meshes well with the NoirJS libraries and other special setups we might need, like handling WebAssembly modules. Here’s how you get that going:
+
+#### Creating the vite.config.js
+
+In your freshly minted `vite-project` folder, create a new file named `vite.config.js` and open it in your code editor. Paste the following to set the stage:
+
+```javascript
+import { defineConfig } from 'vite';
+import copy from 'rollup-plugin-copy';
+import fs from 'fs';
+import path from 'path';
+
+const wasmContentTypePlugin = {
+  name: 'wasm-content-type-plugin',
+  configureServer(server) {
+    server.middlewares.use(async (req, res, next) => {
+      if (req.url.endsWith('.wasm')) {
+        res.setHeader('Content-Type', 'application/wasm');
+        const newPath = req.url.replace('deps', 'dist');
+        const targetPath = path.join(__dirname, newPath);
+        const wasmContent = fs.readFileSync(targetPath);
+        return res.end(wasmContent);
+      }
+      next();
+    });
+  },
+};
+
+export default defineConfig(({ command }) => {
+  if (command === 'serve') {
+    return {
+      build: {
+        target: 'esnext',
+        rollupOptions: {
+          external: ['@aztec/bb.js']
+        }
+      },
+      optimizeDeps: {
+        esbuildOptions: {
+          target: 'esnext'
+        }
+      },
+      plugins: [
+        copy({
+          targets: [{ src: 'node_modules/**/*.wasm', dest: 'node_modules/.vite/dist' }],
+          copySync: true,
+          hook: 'buildStart',
+        }),
+        command === 'serve' ? wasmContentTypePlugin : [],
+      ],
+    };
+  }
+
+  return {};
+});
+```
+
+#### Install Dependencies
+
+Now that our stage is set, install the necessary NoirJS packages along with our other dependencies:
+
+```bash
+npm install && npm install @noir-lang/backend_barretenberg@0.31.0 @noir-lang/noir_js@0.31.0
+npm install rollup-plugin-copy --save-dev
+```
+
+:::info
+
+At this point in the tutorial, your folder structure should look like this:
+
+```tree
+.
+└── circuit
+    └── ...etc...
+└── vite-project <---- our working directory
+    └── ...etc...
+```
+
+:::
+
+#### Some cleanup
+
+`npx create vite` is amazing but it creates a bunch of files we don't really need for our simple example. Actually, let's just delete everything except for `vite.config.js`, `index.html`, `main.js` and `package.json`. I feel lighter already.
+
+![my heart is ready for you, noir.js](@site/static/img/memes/titanic.jpeg)
+
+## HTML
+
+Our app won't run like this, of course. We need some working HTML, at least. Let's open our broken-hearted `index.html` and replace everything with this code snippet:
+
+```html
+<!DOCTYPE html>
+<head>
+  <style>
+    .outer {
+        display: flex;
+        justify-content: space-between;
+        width: 100%;
+    }
+    .inner {
+        width: 45%;
+        border: 1px solid black;
+        padding: 10px;
+        word-wrap: break-word;
+    }
+  </style>
+</head>
+<body>
+  <script type="module" src="/main.js"></script>
+  <h1>Noir app</h1>
+  <div class="input-area">
+    <input id="guessInput" type="number" placeholder="Enter your guess" />
+    <button id="submitGuess">Submit Guess</button>
+  </div>
+  <div class="outer">
+    <div id="logs" class="inner"><h2>Logs</h2></div>
+    <div id="results" class="inner"><h2>Proof</h2></div>
+  </div>
+</body>
+</html>
+```
+
+It _could_ be a beautiful UI... Depending on which universe you live in.
+
+## Some good old vanilla Javascript
+
+Our love for Noir needs undivided attention, so let's just open `main.js` and delete everything (this is where the romantic scenery becomes a bit creepy).
+
+Start by pasting in this boilerplate code:
+
+```js
+function display(container, msg) {
+  const c = document.getElementById(container);
+  const p = document.createElement('p');
+  p.textContent = msg;
+  c.appendChild(p);
+}
+
+document.getElementById('submitGuess').addEventListener('click', async () => {
+  try {
+    // here's where love happens
+  } catch (err) {
+    display('logs', 'Oh 💔 Wrong guess');
+  }
+});
+```
+
+The display function doesn't do much. We're simply manipulating our website to see stuff happening. For example, if the proof fails, it will simply log a broken heart 😢
+
+:::info
+
+At this point in the tutorial, your folder structure should look like this:
+
+```tree
+.
+└── circuit
+    └── ...same as above
+└── vite-project
+    ├── vite.config.js
+    ├── main.js
+    ├── package.json
+    └── index.html
+```
+
+You'll see other files and folders showing up (like `package-lock.json`, `node_modules`) but you shouldn't have to care about those.
+
+:::
+
+## Some NoirJS
+
+We're starting with the good stuff now. If you've compiled the circuit as described above, you should have a `json` file we want to import at the very top of our `main.js` file:
+
+```ts
+import circuit from '../circuit/target/circuit.json';
+```
+
+[Noir is backend-agnostic](../index.mdx#whats-new-about-noir). We write Noir, but we also need a proving backend. That's why we need to import and instantiate the two dependencies we installed above: `BarretenbergBackend` and `Noir`. Let's import them right below:
+
+```js
+import { BarretenbergBackend, BarretenbergVerifier as Verifier } from '@noir-lang/backend_barretenberg';
+import { Noir } from '@noir-lang/noir_js';
+```
+
+And instantiate them inside our try-catch block:
+
+```ts
+// try {
+const backend = new BarretenbergBackend(circuit);
+const noir = new Noir(circuit);
+// }
+```
+
+:::note
+
+For the remainder of the tutorial, everything will be happening inside the `try` block
+
+:::
+
+## Our app
+
+Now for the app itself. We're capturing whatever is in the input when people press the submit button. Just add this:
+
+```js
+const x = parseInt(document.getElementById('guessInput').value);
+const input = { x, y: 2 };
+```
+
+Now we're ready to prove stuff! Let's feed some inputs to our circuit and calculate the proof:
+
+```js
+await setup(); // let's squeeze our wasm inits here
+
+display('logs', 'Generating proof... ⌛');
+const { witness } = await noir.execute(input);
+const proof = await backend.generateProof(witness);
+display('logs', 'Generating proof... ✅');
+display('results', proof.proof);
+```
+
+You're probably eager to see stuff happening, so go and run your app now!
+
+From your terminal, run `npm run dev`. If it doesn't open a browser for you, just visit `localhost:5173`. You should now see the worst UI ever, with an ugly input.
+
+![Getting Started 0](@site/static/img/noir_getting_started_1.png)
+
+Now, our circuit says `fn main(x: Field, y: pub Field)`. This means only the `y` value is public, and it's hardcoded above: `input = { x, y: 2 }`. In other words, you won't need to send your secret`x` to the verifier!
+
+By inputting any number other than 2 in the input box and clicking "submit", you should get a valid proof. Otherwise the proof won't even generate correctly. By the way, if you're human, you shouldn't be able to understand anything on the "proof" box. That's OK. We like you, human ❤️.
+
+## Verifying
+
+Time to celebrate, yes! But we shouldn't trust machines so blindly. Let's add these lines to see our proof being verified:
+
+```js
+display('logs', 'Verifying proof... ⌛');
+const isValid = await backend.verifyProof(proof);
+
+// or to cache and use the verification key:
+// const verificationKey = await backend.getVerificationKey();
+// const verifier = new Verifier();
+// const isValid = await verifier.verifyProof(proof, verificationKey);
+
+if (isValid) display('logs', 'Verifying proof... ✅');
+```
+
+You have successfully generated a client-side Noir web app!
+
+![coded app without math knowledge](@site/static/img/memes/flextape.jpeg)
+
+## Further Reading
+
+You can see how noirjs is used in a full stack Next.js hardhat application in the [noir-starter repo here](https://github.com/noir-lang/noir-starter/tree/main/vite-hardhat). The example shows how to calculate a proof in the browser and verify it with a deployed Solidity verifier contract from noirjs.
+
+You should also check out the more advanced examples in the [noir-examples repo](https://github.com/noir-lang/noir-examples), where you'll find reference usage for some cool apps.
+
+## UltraHonk Backend
+
+Barretenberg has recently exposed a new UltraHonk backend. We can use UltraHonk in NoirJS after version 0.33.0. Everything will be the same as the tutorial above, except that the class we need to import will change:
+
+```js
+import { UltraHonkBackend, UltraHonkVerifier as Verifier } from '@noir-lang/backend_barretenberg';
+```
+
+The backend will then be instantiated as such:
+
+```js
+const backend = new UltraHonkBackend(circuit);
+```
+
+Then all the commands to prove and verify your circuit will be same.
+
+The only feature currently unsupported with UltraHonk are [recursive proofs](../explainers/explainer-recursion.md).
diff --git a/docs/versioned_sidebars/version-v0.35.0-sidebars.json b/docs/versioned_sidebars/version-v0.35.0-sidebars.json
new file mode 100644
index 00000000000..b9ad026f69f
--- /dev/null
+++ b/docs/versioned_sidebars/version-v0.35.0-sidebars.json
@@ -0,0 +1,93 @@
+{
+  "sidebar": [
+    {
+      "type": "doc",
+      "id": "index"
+    },
+    {
+      "type": "category",
+      "label": "Getting Started",
+      "items": [
+        {
+          "type": "autogenerated",
+          "dirName": "getting_started"
+        }
+      ]
+    },
+    {
+      "type": "category",
+      "label": "The Noir Language",
+      "items": [
+        {
+          "type": "autogenerated",
+          "dirName": "noir"
+        }
+      ]
+    },
+    {
+      "type": "html",
+      "value": "<div class=\"divider\"></div>",
+      "defaultStyle": true
+    },
+    {
+      "type": "category",
+      "label": "How To Guides",
+      "items": [
+        {
+          "type": "autogenerated",
+          "dirName": "how_to"
+        }
+      ]
+    },
+    {
+      "type": "category",
+      "label": "Explainers",
+      "items": [
+        {
+          "type": "autogenerated",
+          "dirName": "explainers"
+        }
+      ]
+    },
+    {
+      "type": "category",
+      "label": "Tutorials",
+      "items": [
+        {
+          "type": "autogenerated",
+          "dirName": "tutorials"
+        }
+      ]
+    },
+    {
+      "type": "category",
+      "label": "Reference",
+      "items": [
+        {
+          "type": "autogenerated",
+          "dirName": "reference"
+        }
+      ]
+    },
+    {
+      "type": "category",
+      "label": "Tooling",
+      "items": [
+        {
+          "type": "autogenerated",
+          "dirName": "tooling"
+        }
+      ]
+    },
+    {
+      "type": "html",
+      "value": "<div class=\"divider\"></div>",
+      "defaultStyle": true
+    },
+    {
+      "type": "doc",
+      "id": "migration_notes",
+      "label": "Migration notes"
+    }
+  ]
+}
diff --git a/docs/versioned_sidebars/version-v0.36.0-sidebars.json b/docs/versioned_sidebars/version-v0.36.0-sidebars.json
new file mode 100644
index 00000000000..b9ad026f69f
--- /dev/null
+++ b/docs/versioned_sidebars/version-v0.36.0-sidebars.json
@@ -0,0 +1,93 @@
+{
+  "sidebar": [
+    {
+      "type": "doc",
+      "id": "index"
+    },
+    {
+      "type": "category",
+      "label": "Getting Started",
+      "items": [
+        {
+          "type": "autogenerated",
+          "dirName": "getting_started"
+        }
+      ]
+    },
+    {
+      "type": "category",
+      "label": "The Noir Language",
+      "items": [
+        {
+          "type": "autogenerated",
+          "dirName": "noir"
+        }
+      ]
+    },
+    {
+      "type": "html",
+      "value": "<div class=\"divider\"></div>",
+      "defaultStyle": true
+    },
+    {
+      "type": "category",
+      "label": "How To Guides",
+      "items": [
+        {
+          "type": "autogenerated",
+          "dirName": "how_to"
+        }
+      ]
+    },
+    {
+      "type": "category",
+      "label": "Explainers",
+      "items": [
+        {
+          "type": "autogenerated",
+          "dirName": "explainers"
+        }
+      ]
+    },
+    {
+      "type": "category",
+      "label": "Tutorials",
+      "items": [
+        {
+          "type": "autogenerated",
+          "dirName": "tutorials"
+        }
+      ]
+    },
+    {
+      "type": "category",
+      "label": "Reference",
+      "items": [
+        {
+          "type": "autogenerated",
+          "dirName": "reference"
+        }
+      ]
+    },
+    {
+      "type": "category",
+      "label": "Tooling",
+      "items": [
+        {
+          "type": "autogenerated",
+          "dirName": "tooling"
+        }
+      ]
+    },
+    {
+      "type": "html",
+      "value": "<div class=\"divider\"></div>",
+      "defaultStyle": true
+    },
+    {
+      "type": "doc",
+      "id": "migration_notes",
+      "label": "Migration notes"
+    }
+  ]
+}
diff --git a/docs/versioned_sidebars/version-v0.37.0-sidebars.json b/docs/versioned_sidebars/version-v0.37.0-sidebars.json
new file mode 100644
index 00000000000..b9ad026f69f
--- /dev/null
+++ b/docs/versioned_sidebars/version-v0.37.0-sidebars.json
@@ -0,0 +1,93 @@
+{
+  "sidebar": [
+    {
+      "type": "doc",
+      "id": "index"
+    },
+    {
+      "type": "category",
+      "label": "Getting Started",
+      "items": [
+        {
+          "type": "autogenerated",
+          "dirName": "getting_started"
+        }
+      ]
+    },
+    {
+      "type": "category",
+      "label": "The Noir Language",
+      "items": [
+        {
+          "type": "autogenerated",
+          "dirName": "noir"
+        }
+      ]
+    },
+    {
+      "type": "html",
+      "value": "<div class=\"divider\"></div>",
+      "defaultStyle": true
+    },
+    {
+      "type": "category",
+      "label": "How To Guides",
+      "items": [
+        {
+          "type": "autogenerated",
+          "dirName": "how_to"
+        }
+      ]
+    },
+    {
+      "type": "category",
+      "label": "Explainers",
+      "items": [
+        {
+          "type": "autogenerated",
+          "dirName": "explainers"
+        }
+      ]
+    },
+    {
+      "type": "category",
+      "label": "Tutorials",
+      "items": [
+        {
+          "type": "autogenerated",
+          "dirName": "tutorials"
+        }
+      ]
+    },
+    {
+      "type": "category",
+      "label": "Reference",
+      "items": [
+        {
+          "type": "autogenerated",
+          "dirName": "reference"
+        }
+      ]
+    },
+    {
+      "type": "category",
+      "label": "Tooling",
+      "items": [
+        {
+          "type": "autogenerated",
+          "dirName": "tooling"
+        }
+      ]
+    },
+    {
+      "type": "html",
+      "value": "<div class=\"divider\"></div>",
+      "defaultStyle": true
+    },
+    {
+      "type": "doc",
+      "id": "migration_notes",
+      "label": "Migration notes"
+    }
+  ]
+}
diff --git a/docs/versioned_sidebars/version-v0.38.0-sidebars.json b/docs/versioned_sidebars/version-v0.38.0-sidebars.json
new file mode 100644
index 00000000000..b9ad026f69f
--- /dev/null
+++ b/docs/versioned_sidebars/version-v0.38.0-sidebars.json
@@ -0,0 +1,93 @@
+{
+  "sidebar": [
+    {
+      "type": "doc",
+      "id": "index"
+    },
+    {
+      "type": "category",
+      "label": "Getting Started",
+      "items": [
+        {
+          "type": "autogenerated",
+          "dirName": "getting_started"
+        }
+      ]
+    },
+    {
+      "type": "category",
+      "label": "The Noir Language",
+      "items": [
+        {
+          "type": "autogenerated",
+          "dirName": "noir"
+        }
+      ]
+    },
+    {
+      "type": "html",
+      "value": "<div class=\"divider\"></div>",
+      "defaultStyle": true
+    },
+    {
+      "type": "category",
+      "label": "How To Guides",
+      "items": [
+        {
+          "type": "autogenerated",
+          "dirName": "how_to"
+        }
+      ]
+    },
+    {
+      "type": "category",
+      "label": "Explainers",
+      "items": [
+        {
+          "type": "autogenerated",
+          "dirName": "explainers"
+        }
+      ]
+    },
+    {
+      "type": "category",
+      "label": "Tutorials",
+      "items": [
+        {
+          "type": "autogenerated",
+          "dirName": "tutorials"
+        }
+      ]
+    },
+    {
+      "type": "category",
+      "label": "Reference",
+      "items": [
+        {
+          "type": "autogenerated",
+          "dirName": "reference"
+        }
+      ]
+    },
+    {
+      "type": "category",
+      "label": "Tooling",
+      "items": [
+        {
+          "type": "autogenerated",
+          "dirName": "tooling"
+        }
+      ]
+    },
+    {
+      "type": "html",
+      "value": "<div class=\"divider\"></div>",
+      "defaultStyle": true
+    },
+    {
+      "type": "doc",
+      "id": "migration_notes",
+      "label": "Migration notes"
+    }
+  ]
+}
diff --git a/docs/versioned_sidebars/version-v0.39.0-sidebars.json b/docs/versioned_sidebars/version-v0.39.0-sidebars.json
new file mode 100644
index 00000000000..b9ad026f69f
--- /dev/null
+++ b/docs/versioned_sidebars/version-v0.39.0-sidebars.json
@@ -0,0 +1,93 @@
+{
+  "sidebar": [
+    {
+      "type": "doc",
+      "id": "index"
+    },
+    {
+      "type": "category",
+      "label": "Getting Started",
+      "items": [
+        {
+          "type": "autogenerated",
+          "dirName": "getting_started"
+        }
+      ]
+    },
+    {
+      "type": "category",
+      "label": "The Noir Language",
+      "items": [
+        {
+          "type": "autogenerated",
+          "dirName": "noir"
+        }
+      ]
+    },
+    {
+      "type": "html",
+      "value": "<div class=\"divider\"></div>",
+      "defaultStyle": true
+    },
+    {
+      "type": "category",
+      "label": "How To Guides",
+      "items": [
+        {
+          "type": "autogenerated",
+          "dirName": "how_to"
+        }
+      ]
+    },
+    {
+      "type": "category",
+      "label": "Explainers",
+      "items": [
+        {
+          "type": "autogenerated",
+          "dirName": "explainers"
+        }
+      ]
+    },
+    {
+      "type": "category",
+      "label": "Tutorials",
+      "items": [
+        {
+          "type": "autogenerated",
+          "dirName": "tutorials"
+        }
+      ]
+    },
+    {
+      "type": "category",
+      "label": "Reference",
+      "items": [
+        {
+          "type": "autogenerated",
+          "dirName": "reference"
+        }
+      ]
+    },
+    {
+      "type": "category",
+      "label": "Tooling",
+      "items": [
+        {
+          "type": "autogenerated",
+          "dirName": "tooling"
+        }
+      ]
+    },
+    {
+      "type": "html",
+      "value": "<div class=\"divider\"></div>",
+      "defaultStyle": true
+    },
+    {
+      "type": "doc",
+      "id": "migration_notes",
+      "label": "Migration notes"
+    }
+  ]
+}
diff --git a/docs/versioned_sidebars/version-v1.0.0-beta.0-sidebars.json b/docs/versioned_sidebars/version-v1.0.0-beta.0-sidebars.json
new file mode 100644
index 00000000000..b9ad026f69f
--- /dev/null
+++ b/docs/versioned_sidebars/version-v1.0.0-beta.0-sidebars.json
@@ -0,0 +1,93 @@
+{
+  "sidebar": [
+    {
+      "type": "doc",
+      "id": "index"
+    },
+    {
+      "type": "category",
+      "label": "Getting Started",
+      "items": [
+        {
+          "type": "autogenerated",
+          "dirName": "getting_started"
+        }
+      ]
+    },
+    {
+      "type": "category",
+      "label": "The Noir Language",
+      "items": [
+        {
+          "type": "autogenerated",
+          "dirName": "noir"
+        }
+      ]
+    },
+    {
+      "type": "html",
+      "value": "<div class=\"divider\"></div>",
+      "defaultStyle": true
+    },
+    {
+      "type": "category",
+      "label": "How To Guides",
+      "items": [
+        {
+          "type": "autogenerated",
+          "dirName": "how_to"
+        }
+      ]
+    },
+    {
+      "type": "category",
+      "label": "Explainers",
+      "items": [
+        {
+          "type": "autogenerated",
+          "dirName": "explainers"
+        }
+      ]
+    },
+    {
+      "type": "category",
+      "label": "Tutorials",
+      "items": [
+        {
+          "type": "autogenerated",
+          "dirName": "tutorials"
+        }
+      ]
+    },
+    {
+      "type": "category",
+      "label": "Reference",
+      "items": [
+        {
+          "type": "autogenerated",
+          "dirName": "reference"
+        }
+      ]
+    },
+    {
+      "type": "category",
+      "label": "Tooling",
+      "items": [
+        {
+          "type": "autogenerated",
+          "dirName": "tooling"
+        }
+      ]
+    },
+    {
+      "type": "html",
+      "value": "<div class=\"divider\"></div>",
+      "defaultStyle": true
+    },
+    {
+      "type": "doc",
+      "id": "migration_notes",
+      "label": "Migration notes"
+    }
+  ]
+}
diff --git a/examples/codegen_verifier/codegen_verifier.sh b/examples/codegen_verifier/codegen_verifier.sh
index fabd6235a67..f224f74168f 100755
--- a/examples/codegen_verifier/codegen_verifier.sh
+++ b/examples/codegen_verifier/codegen_verifier.sh
@@ -16,11 +16,17 @@ nargo execute witness
 PROOF_PATH=./target/proof
 $BACKEND prove -b ./target/hello_world.json -w ./target/witness.gz -o $PROOF_PATH
 
-NUM_PUBLIC_INPUTS=1
+# Sanity check that proof is valid.
+$BACKEND verify -k ./target/vk -p ./target/proof
+
+NUM_PUBLIC_INPUTS=2
 PUBLIC_INPUT_BYTES=$((32 * $NUM_PUBLIC_INPUTS))
 HEX_PUBLIC_INPUTS=$(head -c $PUBLIC_INPUT_BYTES $PROOF_PATH | od -An -v -t x1 | tr -d $' \n')
 HEX_PROOF=$(tail -c +$(($PUBLIC_INPUT_BYTES + 1)) $PROOF_PATH | od -An -v -t x1 | tr -d $' \n')
 
+# Split public inputs into strings where each string represents a `bytes32`.
+SPLIT_HEX_PUBLIC_INPUTS=$(sed -e 's/.\{64\}/0x&,/g' <<< $HEX_PUBLIC_INPUTS)
+
 # Spin up an anvil node to deploy the contract to
 anvil &
 
@@ -31,8 +37,7 @@ DEPLOY_INFO=$(forge create UltraVerifier \
 VERIFIER_ADDRESS=$(echo $DEPLOY_INFO | jq -r '.deployedTo')
 
 # Call the verifier contract with our proof.
-# Note that we haven't needed to split up `HEX_PUBLIC_INPUTS` as there's only a single public input
-cast call $VERIFIER_ADDRESS "verify(bytes, bytes32[])(bool)" "0x$HEX_PROOF" "[0x$HEX_PUBLIC_INPUTS]"
+cast call $VERIFIER_ADDRESS "verify(bytes, bytes32[])(bool)" "0x$HEX_PROOF" "[$SPLIT_HEX_PUBLIC_INPUTS]"
 
 # Stop anvil node again
-kill %-
\ No newline at end of file
+kill %-
diff --git a/examples/codegen_verifier/src/main.nr b/examples/codegen_verifier/src/main.nr
index baef0c3786a..93531797744 100644
--- a/examples/codegen_verifier/src/main.nr
+++ b/examples/codegen_verifier/src/main.nr
@@ -1,3 +1,3 @@
-fn main(x: Field, y: pub Field) {
+fn main(x: pub Field, y: pub Field) {
     assert(x != y);
-}
\ No newline at end of file
+}
diff --git a/examples/recursion/generate_recursive_proof.sh b/examples/recursion/generate_recursive_proof.sh
index 362512529d4..09b01d547b6 100755
--- a/examples/recursion/generate_recursive_proof.sh
+++ b/examples/recursion/generate_recursive_proof.sh
@@ -4,14 +4,14 @@ set -eu
 BACKEND=${BACKEND:-bb}
 
 nargo execute sum_witness --package sum
-$BACKEND prove -b ./target/sum.json -w ./target/sum_witness.gz -o ./target/sum_proof
+$BACKEND prove -b ./target/sum.json -w ./target/sum_witness.gz -o ./target/sum_proof --recursive
 
 # Once we have generated our inner proof, we must use this to generate inputs to `recurse_leaf``
 
-$BACKEND write_vk -b ./target/sum.json -o ./target/sum_key
+$BACKEND write_vk -b ./target/sum.json -o ./target/sum_key --recursive
 $BACKEND vk_as_fields -k ./target/sum_key -o ./target/sum_vk_as_fields
 VK_HASH=$(jq -r '.[0]' ./target/sum_vk_as_fields)
-VK_AS_FIELDS=$(jq -r '.[1:]' ./target/sum_vk_as_fields) 
+VK_AS_FIELDS=$(jq -r '.[1:]' ./target/sum_vk_as_fields)
 
 FULL_PROOF_AS_FIELDS="$($BACKEND proof_as_fields -p ./target/sum_proof -k ./target/sum_key -o -)"
 # sum has 3 public inputs
@@ -28,17 +28,17 @@ echo "public_inputs = $PUBLIC_INPUTS" >> $RECURSE_LEAF_PROVER_TOML
 # We can now execute and prove `recurse_leaf`
 
 nargo execute recurse_leaf_witness --package recurse_leaf
-$BACKEND prove -b ./target/recurse_leaf.json -w ./target/recurse_leaf_witness.gz -o ./target/recurse_leaf_proof
+$BACKEND prove -b ./target/recurse_leaf.json -w ./target/recurse_leaf_witness.gz -o ./target/recurse_leaf_proof --recursive
 
 # Let's do a sanity check that the proof we've generated so far is valid.
-$BACKEND write_vk -b ./target/recurse_leaf.json -o ./target/recurse_leaf_key
+$BACKEND write_vk -b ./target/recurse_leaf.json -o ./target/recurse_leaf_key --recursive
 $BACKEND verify -p ./target/recurse_leaf_proof -k ./target/recurse_leaf_key
 
 # Now we generate the final `recurse_node` proof similarly to how we did for `recurse_leaf`.
 
 $BACKEND vk_as_fields -k ./target/recurse_leaf_key -o ./target/recurse_leaf_vk_as_fields
 VK_HASH=$(jq -r '.[0]' ./target/recurse_leaf_vk_as_fields)
-VK_AS_FIELDS=$(jq -r '.[1:]' ./target/recurse_leaf_vk_as_fields) 
+VK_AS_FIELDS=$(jq -r '.[1:]' ./target/recurse_leaf_vk_as_fields)
 
 FULL_PROOF_AS_FIELDS="$($BACKEND proof_as_fields -p ./target/recurse_leaf_proof -k ./target/recurse_leaf_key -o -)"
 # recurse_leaf has 4 public inputs (excluding aggregation object)
diff --git a/examples/recursion/recurse_leaf/src/main.nr b/examples/recursion/recurse_leaf/src/main.nr
index 1f111a1b5b0..0031997160d 100644
--- a/examples/recursion/recurse_leaf/src/main.nr
+++ b/examples/recursion/recurse_leaf/src/main.nr
@@ -1,10 +1,9 @@
-#[recursive]
 fn main(
     verification_key: [Field; 114],
     public_inputs: pub [Field; 3],
     key_hash: Field,
     proof: [Field; 93],
-    num: u64
+    num: u64,
 ) -> pub u64 {
     // verify sum so far was computed correctly
     std::verify_proof(verification_key, proof, public_inputs, key_hash);
diff --git a/examples/recursion/sum/src/main.nr b/examples/recursion/sum/src/main.nr
index 722d941d57d..e8cd9f2aff9 100644
--- a/examples/recursion/sum/src/main.nr
+++ b/examples/recursion/sum/src/main.nr
@@ -1,4 +1,3 @@
-#[recursive]
 fn main(a: pub u64, b: pub u64) -> pub u64 {
     a + b
-}
\ No newline at end of file
+}
diff --git a/noir-logo.png b/noir-logo.png
index eabb163ad73..0abffba22ef 100644
Binary files a/noir-logo.png and b/noir-logo.png differ
diff --git a/noir_stdlib/src/array/check_shuffle.nr b/noir_stdlib/src/array/check_shuffle.nr
index 26f5ced3467..2e8c227feee 100644
--- a/noir_stdlib/src/array/check_shuffle.nr
+++ b/noir_stdlib/src/array/check_shuffle.nr
@@ -1,7 +1,10 @@
 use crate::cmp::Eq;
 
-unconstrained fn __get_shuffle_indices<T, let N: u32>(lhs: [T; N], rhs: [T; N]) -> [Field; N] where T: Eq {
-    let mut shuffle_indices: [Field;N ] = [0; N];
+unconstrained fn __get_shuffle_indices<T, let N: u32>(lhs: [T; N], rhs: [T; N]) -> [Field; N]
+where
+    T: Eq,
+{
+    let mut shuffle_indices: [Field; N] = [0; N];
 
     let mut shuffle_mask: [bool; N] = [false; N];
     for i in 0..N {
@@ -35,7 +38,10 @@ unconstrained fn __get_index<let N: u32>(indices: [Field; N], idx: Field) -> Fie
     result
 }
 
-pub(crate) fn check_shuffle<T, let N: u32>(lhs: [T; N], rhs: [T; N]) where T: Eq {
+pub(crate) fn check_shuffle<T, let N: u32>(lhs: [T; N], rhs: [T; N])
+where
+    T: Eq,
+{
     unsafe {
         let shuffle_indices = __get_shuffle_indices(lhs, rhs);
 
@@ -53,13 +59,13 @@ pub(crate) fn check_shuffle<T, let N: u32>(lhs: [T; N], rhs: [T; N]) where T: Eq
 }
 
 mod test {
-    use super::check_shuffle;
     use crate::cmp::Eq;
+    use super::check_shuffle;
 
     struct CompoundStruct {
         a: bool,
         b: Field,
-        c: u64
+        c: u64,
     }
     impl Eq for CompoundStruct {
         fn eq(self, other: Self) -> bool {
@@ -102,14 +108,14 @@ mod test {
             CompoundStruct { a: false, b: -100, c: 54321 },
             CompoundStruct { a: true, b: 5, c: 0xffffffffffffffff },
             CompoundStruct { a: true, b: 9814, c: 0xeeffee0011001133 },
-            CompoundStruct { a: false, b: 0x155, c: 0 }
+            CompoundStruct { a: false, b: 0x155, c: 0 },
         ];
         let rhs: [CompoundStruct; 5] = [
             CompoundStruct { a: false, b: 0x155, c: 0 },
             CompoundStruct { a: false, b: 0, c: 12345 },
             CompoundStruct { a: false, b: -100, c: 54321 },
             CompoundStruct { a: true, b: 9814, c: 0xeeffee0011001133 },
-            CompoundStruct { a: true, b: 5, c: 0xffffffffffffffff }
+            CompoundStruct { a: true, b: 5, c: 0xffffffffffffffff },
         ];
         check_shuffle(lhs, rhs);
     }
diff --git a/noir_stdlib/src/array/mod.nr b/noir_stdlib/src/array/mod.nr
index 46acf619dd2..8bb425854f2 100644
--- a/noir_stdlib/src/array/mod.nr
+++ b/noir_stdlib/src/array/mod.nr
@@ -7,13 +7,13 @@ mod quicksort;
 
 impl<T, let N: u32> [T; N] {
     /// Returns the length of this array.
-    /// 
+    ///
     /// ```noir
     /// fn len(self) -> Field
     /// ```
-    /// 
+    ///
     /// example
-    /// 
+    ///
     /// ```noir
     /// fn main() {
     ///     let array = [42, 42];
@@ -24,7 +24,7 @@ impl<T, let N: u32> [T; N] {
     pub fn len(self) -> u32 {}
 
     /// Returns this array as a slice.
-    /// 
+    ///
     /// ```noir
     /// let array = [1, 2];
     /// let slice = array.as_slice();
@@ -34,19 +34,19 @@ impl<T, let N: u32> [T; N] {
     pub fn as_slice(self) -> [T] {}
 
     /// Applies a function to each element of this array, returning a new array containing the mapped elements.
-    /// 
+    ///
     /// Example:
-    /// 
+    ///
     /// ```rust
     /// let a = [1, 2, 3];
     /// let b = a.map(|a| a * 2);
     /// assert_eq(b, [2, 4, 6]);
     /// ```
     pub fn map<U, Env>(self, f: fn[Env](T) -> U) -> [U; N] {
-        let first_elem = f(self[0]);
-        let mut ret = [first_elem; N];
+        let uninitialized = crate::mem::zeroed();
+        let mut ret = [uninitialized; N];
 
-        for i in 1..self.len() {
+        for i in 0..self.len() {
             ret[i] = f(self[i]);
         }
 
@@ -55,20 +55,20 @@ impl<T, let N: u32> [T; N] {
 
     /// Applies a function to each element of the array, returning the final accumulated value. The first
     /// parameter is the initial value.
-    /// 
+    ///
     /// This is a left fold, so the given function will be applied to the accumulator and first element of
     /// the array, then the second, and so on. For a given call the expected result would be equivalent to:
-    /// 
+    ///
     /// ```rust
     /// let a1 = [1];
     /// let a2 = [1, 2];
     /// let a3 = [1, 2, 3];
-    /// 
+    ///
     /// let f = |a, b| a - b;
     /// a1.fold(10, f); //=> f(10, 1)
     /// a2.fold(10, f); //=> f(f(10, 1), 2)
     /// a3.fold(10, f); //=> f(f(f(10, 1), 2), 3)
-    /// 
+    ///
     /// assert_eq(a3.fold(10, f), 10 - 1 - 2 - 3);
     /// ```
     pub fn fold<U, Env>(self, mut accumulator: U, f: fn[Env](U, T) -> U) -> U {
@@ -79,9 +79,11 @@ impl<T, let N: u32> [T; N] {
     }
 
     /// Same as fold, but uses the first element as the starting element.
-    /// 
+    ///
+    /// Requires the input array to be non-empty.
+    ///
     /// Example:
-    /// 
+    ///
     /// ```noir
     /// fn main() {
     ///     let arr = [1, 2, 3, 4];
@@ -98,9 +100,9 @@ impl<T, let N: u32> [T; N] {
     }
 
     /// Returns true if all the elements in this array satisfy the given predicate.
-    /// 
+    ///
     /// Example:
-    /// 
+    ///
     /// ```noir
     /// fn main() {
     ///     let arr = [2, 2, 2, 2, 2];
@@ -117,9 +119,9 @@ impl<T, let N: u32> [T; N] {
     }
 
     /// Returns true if any of the elements in this array satisfy the given predicate.
-    /// 
+    ///
     /// Example:
-    /// 
+    ///
     /// ```noir
     /// fn main() {
     ///     let arr = [2, 2, 2, 2, 5];
@@ -136,14 +138,17 @@ impl<T, let N: u32> [T; N] {
     }
 }
 
-impl<T, let N: u32> [T; N] where T: Ord + Eq {
+impl<T, let N: u32> [T; N]
+where
+    T: Ord + Eq,
+{
     /// Returns a new sorted array. The original array remains untouched. Notice that this function will
     /// only work for arrays of fields or integers, not for any arbitrary type. This is because the sorting
     /// logic it uses internally is optimized specifically for these values. If you need a sort function to
     /// sort any type, you should use the `sort_via` function.
-    /// 
+    ///
     /// Example:
-    /// 
+    ///
     /// ```rust
     /// fn main() {
     ///     let arr = [42, 32];
@@ -156,21 +161,24 @@ impl<T, let N: u32> [T; N] where T: Ord + Eq {
     }
 }
 
-impl<T, let N: u32> [T; N] where T: Eq {
-    /// Returns a new sorted array by sorting it with a custom comparison function. 
-    /// The original array remains untouched. 
+impl<T, let N: u32> [T; N]
+where
+    T: Eq,
+{
+    /// Returns a new sorted array by sorting it with a custom comparison function.
+    /// The original array remains untouched.
     /// The ordering function must return true if the first argument should be sorted to be before the second argument or is equal to the second argument.
-    /// 
+    ///
     /// Using this method with an operator like `<` that does not return `true` for equal values will result in an assertion failure for arrays with equal elements.
-    /// 
+    ///
     /// Example:
-    /// 
+    ///
     /// ```rust
     /// fn main() {
     ///     let arr = [42, 32]
     ///     let sorted_ascending = arr.sort_via(|a, b| a <= b);
     ///     assert(sorted_ascending == [32, 42]); // verifies
-    /// 
+    ///
     ///     let sorted_descending = arr.sort_via(|a, b| a >= b);
     ///     assert(sorted_descending == [32, 42]); // does not verify
     /// }
@@ -185,7 +193,8 @@ impl<T, let N: u32> [T; N] where T: Eq {
             if !is_unconstrained() {
                 for i in 0..N - 1 {
                     assert(
-                        ordering(sorted[i], sorted[i + 1]), "Array has not been sorted correctly according to `ordering`."
+                        ordering(sorted[i], sorted[i + 1]),
+                        "Array has not been sorted correctly according to `ordering`.",
                     );
                 }
                 check_shuffle::check_shuffle(self, sorted);
@@ -198,9 +207,9 @@ impl<T, let N: u32> [T; N] where T: Eq {
 impl<let N: u32> [u8; N] {
     /// Converts a byte array of type `[u8; N]` to a string. Note that this performs no UTF-8 validation -
     /// the given array is interpreted as-is as a string.
-    /// 
+    ///
     /// Example:
-    /// 
+    ///
     /// ```rust
     /// fn main() {
     ///     let hi = [104, 105].as_str_unchecked();
@@ -217,3 +226,10 @@ impl<let N: u32> From<str<N>> for [u8; N] {
         s.as_bytes()
     }
 }
+
+mod test {
+    #[test]
+    fn map_empty() {
+        assert_eq([].map(|x| x + 1), []);
+    }
+}
diff --git a/noir_stdlib/src/array/quicksort.nr b/noir_stdlib/src/array/quicksort.nr
index 6a54ed246f5..5e9c575c5ce 100644
--- a/noir_stdlib/src/array/quicksort.nr
+++ b/noir_stdlib/src/array/quicksort.nr
@@ -2,7 +2,7 @@ unconstrained fn partition<T, Env, let N: u32>(
     arr: &mut [T; N],
     low: u32,
     high: u32,
-    sortfn: fn[Env](T, T) -> bool
+    sortfn: fn[Env](T, T) -> bool,
 ) -> u32 {
     let pivot = high;
     let mut i = low;
@@ -20,7 +20,12 @@ unconstrained fn partition<T, Env, let N: u32>(
     i
 }
 
-unconstrained fn quicksort_recursive<T, Env, let N: u32>(arr: &mut [T; N], low: u32, high: u32, sortfn: fn[Env](T, T) -> bool) {
+unconstrained fn quicksort_recursive<T, Env, let N: u32>(
+    arr: &mut [T; N],
+    low: u32,
+    high: u32,
+    sortfn: fn[Env](T, T) -> bool,
+) {
     if low < high {
         let pivot_index = partition(arr, low, high, sortfn);
         if pivot_index > 0 {
@@ -30,7 +35,10 @@ unconstrained fn quicksort_recursive<T, Env, let N: u32>(arr: &mut [T; N], low:
     }
 }
 
-unconstrained pub(crate) fn quicksort<T, Env, let N: u32>(_arr: [T; N], sortfn: fn[Env](T, T) -> bool) -> [T; N] {
+pub(crate) unconstrained fn quicksort<T, Env, let N: u32>(
+    _arr: [T; N],
+    sortfn: fn[Env](T, T) -> bool,
+) -> [T; N] {
     let mut arr: [T; N] = _arr;
     if arr.len() <= 1 {} else {
         quicksort_recursive(&mut arr, 0, arr.len() - 1, sortfn);
diff --git a/noir_stdlib/src/bigint.nr b/noir_stdlib/src/bigint.nr
index 0015f480794..c94a7a75f25 100644
--- a/noir_stdlib/src/bigint.nr
+++ b/noir_stdlib/src/bigint.nr
@@ -1,16 +1,30 @@
-use crate::ops::{Add, Sub, Mul, Div};
 use crate::cmp::Eq;
-
-global bn254_fq = &[0x47, 0xFD, 0x7C, 0xD8, 0x16, 0x8C, 0x20, 0x3C, 0x8d, 0xca, 0x71, 0x68, 0x91, 0x6a, 0x81, 0x97,
-                    0x5d, 0x58, 0x81, 0x81, 0xb6, 0x45, 0x50, 0xb8, 0x29, 0xa0, 0x31, 0xe1, 0x72, 0x4e, 0x64, 0x30];
-global bn254_fr = &[1, 0, 0, 240, 147, 245, 225, 67, 145, 112, 185, 121, 72, 232, 51, 40, 93, 88, 129, 129, 182, 69, 80, 184, 41, 160, 49, 225, 114, 78, 100, 48];
-global secpk1_fr = &[0x41, 0x41, 0x36, 0xD0, 0x8C, 0x5E, 0xD2, 0xBF, 0x3B, 0xA0, 0x48, 0xAF, 0xE6, 0xDC, 0xAE, 0xBA,
-                     0xFE, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF];
-global secpk1_fq = &[0x2F, 0xFC, 0xFF, 0xFF, 0xFE, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
-                     0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF];
-global secpr1_fq = &[0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0x00, 0x00, 0x00, 0x00,
-                     0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0xFF, 0xFF, 0xFF, 0xFF];
-global secpr1_fr = &[81, 37, 99, 252, 194, 202, 185, 243, 132, 158, 23, 167, 173, 250, 230, 188, 255, 255, 255, 255, 255, 255, 255, 255, 0, 0, 0, 0, 255, 255, 255, 255];
+use crate::ops::{Add, Div, Mul, Sub};
+
+global bn254_fq: [u8] = &[
+    0x47, 0xFD, 0x7C, 0xD8, 0x16, 0x8C, 0x20, 0x3C, 0x8d, 0xca, 0x71, 0x68, 0x91, 0x6a, 0x81, 0x97,
+    0x5d, 0x58, 0x81, 0x81, 0xb6, 0x45, 0x50, 0xb8, 0x29, 0xa0, 0x31, 0xe1, 0x72, 0x4e, 0x64, 0x30,
+];
+global bn254_fr: [u8] = &[
+    1, 0, 0, 240, 147, 245, 225, 67, 145, 112, 185, 121, 72, 232, 51, 40, 93, 88, 129, 129, 182, 69,
+    80, 184, 41, 160, 49, 225, 114, 78, 100, 48,
+];
+global secpk1_fr: [u8] = &[
+    0x41, 0x41, 0x36, 0xD0, 0x8C, 0x5E, 0xD2, 0xBF, 0x3B, 0xA0, 0x48, 0xAF, 0xE6, 0xDC, 0xAE, 0xBA,
+    0xFE, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
+];
+global secpk1_fq: [u8] = &[
+    0x2F, 0xFC, 0xFF, 0xFF, 0xFE, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
+    0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
+];
+global secpr1_fq: [u8] = &[
+    0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0xFF, 0xFF, 0xFF, 0xFF,
+];
+global secpr1_fr: [u8] = &[
+    81, 37, 99, 252, 194, 202, 185, 243, 132, 158, 23, 167, 173, 250, 230, 188, 255, 255, 255, 255,
+    255, 255, 255, 255, 0, 0, 0, 0, 255, 255, 255, 255,
+];
 // docs:start:big_int_definition
 pub struct BigInt {
     pointer: u32,
@@ -50,7 +64,7 @@ pub trait BigField {
 }
 
 pub struct Secpk1Fq {
-   array: [u8;32],
+    array: [u8; 32],
 }
 
 impl BigField for Secpk1Fq {
@@ -107,7 +121,7 @@ impl Eq for Secpk1Fq {
 }
 
 pub struct Secpk1Fr {
-    array: [u8;32],
+    array: [u8; 32],
 }
 
 impl BigField for Secpk1Fr {
@@ -164,7 +178,7 @@ impl Eq for Secpk1Fr {
 }
 
 pub struct Bn254Fr {
-    array: [u8;32],
+    array: [u8; 32],
 }
 
 impl BigField for Bn254Fr {
@@ -221,7 +235,7 @@ impl Eq for Bn254Fr {
 }
 
 pub struct Bn254Fq {
-    array: [u8;32],
+    array: [u8; 32],
 }
 
 impl BigField for Bn254Fq {
@@ -278,7 +292,7 @@ impl Eq for Bn254Fq {
 }
 
 pub struct Secpr1Fq {
-    array: [u8;32],
+    array: [u8; 32],
 }
 
 impl BigField for Secpr1Fq {
@@ -335,7 +349,7 @@ impl Eq for Secpr1Fq {
 }
 
 pub struct Secpr1Fr {
-    array: [u8;32],
+    array: [u8; 32],
 }
 
 impl BigField for Secpr1Fr {
diff --git a/noir_stdlib/src/cmp.nr b/noir_stdlib/src/cmp.nr
index ac7e3df66ad..ae515150a4d 100644
--- a/noir_stdlib/src/cmp.nr
+++ b/noir_stdlib/src/cmp.nr
@@ -18,7 +18,14 @@ comptime fn derive_eq(s: StructDefinition) -> Quoted {
             fields
         }
     };
-    crate::meta::make_trait_impl(s, quote { Eq }, signature, for_each_field, quote { & }, body)
+    crate::meta::make_trait_impl(
+        s,
+        quote { Eq },
+        signature,
+        for_each_field,
+        quote { & },
+        body,
+    )
 }
 // docs:end:derive_eq
 
@@ -86,7 +93,10 @@ impl Eq for bool {
     }
 }
 
-impl<T, let N: u32> Eq for [T; N] where T: Eq {
+impl<T, let N: u32> Eq for [T; N]
+where
+    T: Eq,
+{
     fn eq(self, other: [T; N]) -> bool {
         let mut result = true;
         for i in 0..self.len() {
@@ -96,7 +106,10 @@ impl<T, let N: u32> Eq for [T; N] where T: Eq {
     }
 }
 
-impl<T> Eq for [T] where T: Eq {
+impl<T> Eq for [T]
+where
+    T: Eq,
+{
     fn eq(self, other: [T]) -> bool {
         let mut result = self.len() == other.len();
         for i in 0..self.len() {
@@ -114,25 +127,47 @@ impl<let N: u32> Eq for str<N> {
     }
 }
 
-impl<A, B> Eq for (A, B) where A: Eq, B: Eq {
+impl<A, B> Eq for (A, B)
+where
+    A: Eq,
+    B: Eq,
+{
     fn eq(self, other: (A, B)) -> bool {
         self.0.eq(other.0) & self.1.eq(other.1)
     }
 }
 
-impl<A, B, C> Eq for (A, B, C) where A: Eq, B: Eq, C: Eq {
+impl<A, B, C> Eq for (A, B, C)
+where
+    A: Eq,
+    B: Eq,
+    C: Eq,
+{
     fn eq(self, other: (A, B, C)) -> bool {
         self.0.eq(other.0) & self.1.eq(other.1) & self.2.eq(other.2)
     }
 }
 
-impl<A, B, C, D> Eq for (A, B, C, D) where A: Eq, B: Eq, C: Eq, D: Eq {
+impl<A, B, C, D> Eq for (A, B, C, D)
+where
+    A: Eq,
+    B: Eq,
+    C: Eq,
+    D: Eq,
+{
     fn eq(self, other: (A, B, C, D)) -> bool {
         self.0.eq(other.0) & self.1.eq(other.1) & self.2.eq(other.2) & self.3.eq(other.3)
     }
 }
 
-impl<A, B, C, D, E> Eq for (A, B, C, D, E) where A: Eq, B: Eq, C: Eq, D: Eq, E: Eq {
+impl<A, B, C, D, E> Eq for (A, B, C, D, E)
+where
+    A: Eq,
+    B: Eq,
+    C: Eq,
+    D: Eq,
+    E: Eq,
+{
     fn eq(self, other: (A, B, C, D, E)) -> bool {
         self.0.eq(other.0)
             & self.1.eq(other.1)
@@ -315,7 +350,10 @@ impl Ord for bool {
     }
 }
 
-impl<T, let N: u32> Ord for [T; N] where T: Ord {
+impl<T, let N: u32> Ord for [T; N]
+where
+    T: Ord,
+{
     // The first non-equal element of both arrays determines
     // the ordering for the whole array.
     fn cmp(self, other: [T; N]) -> Ordering {
@@ -335,7 +373,10 @@ impl<T, let N: u32> Ord for [T; N] where T: Ord {
     }
 }
 
-impl<T> Ord for [T] where T: Ord {
+impl<T> Ord for [T]
+where
+    T: Ord,
+{
     // The first non-equal element of both arrays determines
     // the ordering for the whole array.
     fn cmp(self, other: [T]) -> Ordering {
@@ -355,7 +396,11 @@ impl<T> Ord for [T] where T: Ord {
     }
 }
 
-impl<A, B> Ord for (A, B) where A: Ord, B: Ord {
+impl<A, B> Ord for (A, B)
+where
+    A: Ord,
+    B: Ord,
+{
     fn cmp(self, other: (A, B)) -> Ordering {
         let result = self.0.cmp(other.0);
 
@@ -367,7 +412,12 @@ impl<A, B> Ord for (A, B) where A: Ord, B: Ord {
     }
 }
 
-impl<A, B, C> Ord for (A, B, C) where A: Ord, B: Ord, C: Ord {
+impl<A, B, C> Ord for (A, B, C)
+where
+    A: Ord,
+    B: Ord,
+    C: Ord,
+{
     fn cmp(self, other: (A, B, C)) -> Ordering {
         let mut result = self.0.cmp(other.0);
 
@@ -383,7 +433,13 @@ impl<A, B, C> Ord for (A, B, C) where A: Ord, B: Ord, C: Ord {
     }
 }
 
-impl<A, B, C, D> Ord for (A, B, C, D) where A: Ord, B: Ord, C: Ord, D: Ord {
+impl<A, B, C, D> Ord for (A, B, C, D)
+where
+    A: Ord,
+    B: Ord,
+    C: Ord,
+    D: Ord,
+{
     fn cmp(self, other: (A, B, C, D)) -> Ordering {
         let mut result = self.0.cmp(other.0);
 
@@ -403,7 +459,14 @@ impl<A, B, C, D> Ord for (A, B, C, D) where A: Ord, B: Ord, C: Ord, D: Ord {
     }
 }
 
-impl<A, B, C, D, E> Ord for (A, B, C, D, E) where A: Ord, B: Ord, C: Ord, D: Ord, E: Ord {
+impl<A, B, C, D, E> Ord for (A, B, C, D, E)
+where
+    A: Ord,
+    B: Ord,
+    C: Ord,
+    D: Ord,
+    E: Ord,
+{
     fn cmp(self, other: (A, B, C, D, E)) -> Ordering {
         let mut result = self.0.cmp(other.0);
 
@@ -439,8 +502,15 @@ impl<A, B, C, D, E> Ord for (A, B, C, D, E) where A: Ord, B: Ord, C: Ord, D: Ord
 // assert_eq(cmp::max(1, 2), 2);
 // assert_eq(cmp::max(2, 2), 2);
 // ```
-pub fn max<T>(v1: T, v2: T) -> T where T: Ord {
-    if v1 > v2 { v1 } else { v2 }
+pub fn max<T>(v1: T, v2: T) -> T
+where
+    T: Ord,
+{
+    if v1 > v2 {
+        v1
+    } else {
+        v2
+    }
 }
 
 // Compares and returns the minimum of two values.
@@ -455,12 +525,19 @@ pub fn max<T>(v1: T, v2: T) -> T where T: Ord {
 // assert_eq(cmp::min(1, 2), 1);
 // assert_eq(cmp::min(2, 2), 2);
 // ```
-pub fn min<T>(v1: T, v2: T) -> T where T: Ord {
-    if v1 > v2 { v2 } else { v1 }
+pub fn min<T>(v1: T, v2: T) -> T
+where
+    T: Ord,
+{
+    if v1 > v2 {
+        v2
+    } else {
+        v1
+    }
 }
 
 mod cmp_tests {
-    use crate::cmp::{min, max};
+    use crate::cmp::{max, min};
 
     #[test]
     fn sanity_check_min() {
diff --git a/noir_stdlib/src/collections/bounded_vec.nr b/noir_stdlib/src/collections/bounded_vec.nr
index 7cd9942e02a..0ad39c518c4 100644
--- a/noir_stdlib/src/collections/bounded_vec.nr
+++ b/noir_stdlib/src/collections/bounded_vec.nr
@@ -4,16 +4,16 @@ use crate::{cmp::Eq, convert::From};
 /// is bounded with a maximum possible length. Unlike `Vec`, `BoundedVec` is not implemented
 /// via slices and thus is not subject to the same restrictions slices are (notably, nested
 /// slices - and thus nested vectors as well - are disallowed).
-/// 
+///
 /// Since a BoundedVec is backed by a normal array under the hood, growing the BoundedVec by
 /// pushing an additional element is also more efficient - the length only needs to be increased
 /// by one.
-/// 
+///
 /// For these reasons `BoundedVec<T, N>` should generally be preferred over `Vec<T>` when there
 /// is a reasonable maximum bound that can be placed on the vector.
-/// 
+///
 /// Example:
-/// 
+///
 /// ```noir
 /// let mut vector: BoundedVec<Field, 10> = BoundedVec::new();
 /// for i in 0..5 {
@@ -63,7 +63,7 @@ impl<T, let MaxLen: u32> BoundedVec<T, MaxLen> {
     /// ```
     ///
     /// This defaulting of `MaxLen` (and numeric generics in general) to zero may change in future noir versions
-    /// but for now make sure to use type annotations when using bounded vectors. Otherwise, you will receive a 
+    /// but for now make sure to use type annotations when using bounded vectors. Otherwise, you will receive a
     /// constraint failure at runtime when the vec is pushed to.
     pub fn new() -> Self {
         let zeroed = crate::mem::zeroed();
@@ -71,12 +71,12 @@ impl<T, let MaxLen: u32> BoundedVec<T, MaxLen> {
     }
 
     /// Retrieves an element from the vector at the given index, starting from zero.
-    /// 
+    ///
     /// If the given index is equal to or greater than the length of the vector, this
     /// will issue a constraint failure.
-    /// 
+    ///
     /// Example:
-    /// 
+    ///
     /// ```noir
     /// fn foo<let N: u32>(v: BoundedVec<u32, N>) {
     ///     let first = v.get(0);
@@ -91,12 +91,12 @@ impl<T, let MaxLen: u32> BoundedVec<T, MaxLen> {
 
     /// Retrieves an element from the vector at the given index, starting from zero, without
     /// performing a bounds check.
-    /// 
+    ///
     /// Since this function does not perform a bounds check on length before accessing the element,
     /// it is unsafe! Use at your own risk!
-    /// 
+    ///
     /// Example:
-    /// 
+    ///
     /// ```noir
     /// fn sum_of_first_three<let N: u32>(v: BoundedVec<u32, N>) -> u32 {
     ///     // Always ensure the length is larger than the largest
@@ -113,11 +113,11 @@ impl<T, let MaxLen: u32> BoundedVec<T, MaxLen> {
     }
 
     /// Writes an element to the vector at the given index, starting from zero.
-    /// 
+    ///
     /// If the given index is equal to or greater than the length of the vector, this will issue a constraint failure.
-    /// 
+    ///
     /// Example:
-    /// 
+    ///
     /// ```noir
     /// fn foo<let N: u32>(v: BoundedVec<u32, N>) {
     ///     let first = v.get(0);
@@ -133,30 +133,30 @@ impl<T, let MaxLen: u32> BoundedVec<T, MaxLen> {
     }
 
     /// Writes an element to the vector at the given index, starting from zero, without performing a bounds check.
-    /// 
+    ///
     /// Since this function does not perform a bounds check on length before accessing the element, it is unsafe! Use at your own risk!
-    /// 
+    ///
     /// Example:
-    /// 
+    ///
     /// ```noir
     /// fn set_unchecked_example() {
     ///     let mut vec: BoundedVec<u32, 5> = BoundedVec::new();
     ///     vec.extend_from_array([1, 2]);
-    /// 
+    ///
     ///     // Here we're safely writing within the valid range of `vec`
     ///     // `vec` now has the value [42, 2]
     ///     vec.set_unchecked(0, 42);
-    /// 
+    ///
     ///     // We can then safely read this value back out of `vec`.
     ///     // Notice that we use the checked version of `get` which would prevent reading unsafe values.
     ///     assert_eq(vec.get(0), 42);
-    /// 
+    ///
     ///     // We've now written past the end of `vec`.
     ///     // As this index is still within the maximum potential length of `v`,
-    ///     // it won't cause a constraint failure. 
+    ///     // it won't cause a constraint failure.
     ///     vec.set_unchecked(2, 42);
     ///     println(vec);
-    /// 
+    ///
     ///     // This will write past the end of the maximum potential length of `vec`,
     ///     // it will then trigger a constraint failure.
     ///     vec.set_unchecked(5, 42);
@@ -169,17 +169,17 @@ impl<T, let MaxLen: u32> BoundedVec<T, MaxLen> {
 
     /// Pushes an element to the end of the vector. This increases the length
     /// of the vector by one.
-    /// 
+    ///
     /// Panics if the new length of the vector will be greater than the max length.
-    /// 
+    ///
     /// Example:
-    /// 
+    ///
     /// ```noir
     /// let mut v: BoundedVec<Field, 2> = BoundedVec::new();
-    /// 
+    ///
     /// v.push(1);
     /// v.push(2);
-    /// 
+    ///
     /// // Panics with failed assertion "push out of bounds"
     /// v.push(3);
     /// ```
@@ -191,21 +191,21 @@ impl<T, let MaxLen: u32> BoundedVec<T, MaxLen> {
     }
 
     /// Returns the current length of this vector
-    /// 
+    ///
     /// Example:
-    /// 
+    ///
     /// ```noir
     /// let mut v: BoundedVec<Field, 4> = BoundedVec::new();
     /// assert(v.len() == 0);
-    /// 
+    ///
     /// v.push(100);
     /// assert(v.len() == 1);
-    /// 
+    ///
     /// v.push(200);
     /// v.push(300);
     /// v.push(400);
     /// assert(v.len() == 4);
-    /// 
+    ///
     /// let _ = v.pop();
     /// let _ = v.pop();
     /// assert(v.len() == 2);
@@ -216,12 +216,12 @@ impl<T, let MaxLen: u32> BoundedVec<T, MaxLen> {
 
     /// Returns the maximum length of this vector. This is always
     /// equal to the `MaxLen` parameter this vector was initialized with.
-    /// 
+    ///
     /// Example:
-    /// 
+    ///
     /// ```noir
     /// let mut v: BoundedVec<Field, 5> = BoundedVec::new();
-    /// 
+    ///
     /// assert(v.max_len() == 5);
     /// v.push(10);
     /// assert(v.max_len() == 5);
@@ -231,19 +231,19 @@ impl<T, let MaxLen: u32> BoundedVec<T, MaxLen> {
     }
 
     /// Returns the internal array within this vector.
-    /// 
+    ///
     /// Since arrays in Noir are immutable, mutating the returned storage array will not mutate
     /// the storage held internally by this vector.
-    /// 
+    ///
     /// Note that uninitialized elements may be zeroed out!
-    /// 
+    ///
     /// Example:
-    /// 
+    ///
     /// ```noir
     /// let mut v: BoundedVec<Field, 5> = BoundedVec::new();
-    /// 
+    ///
     /// assert(v.storage() == [0, 0, 0, 0, 0]);
-    /// 
+    ///
     /// v.push(57);
     /// assert(v.storage() == [57, 0, 0, 0, 0]);
     /// ```
@@ -252,16 +252,16 @@ impl<T, let MaxLen: u32> BoundedVec<T, MaxLen> {
     }
 
     /// Pushes each element from the given array to this vector.
-    /// 
+    ///
     /// Panics if pushing each element would cause the length of this vector
     /// to exceed the maximum length.
-    /// 
+    ///
     /// Example:
-    /// 
+    ///
     /// ```noir
     /// let mut vec: BoundedVec<Field, 3> = BoundedVec::new();
     /// vec.extend_from_array([2, 4]);
-    /// 
+    ///
     /// assert(vec.len == 2);
     /// assert(vec.get(0) == 2);
     /// assert(vec.get(1) == 4);
@@ -276,16 +276,16 @@ impl<T, let MaxLen: u32> BoundedVec<T, MaxLen> {
     }
 
     /// Pushes each element from the given slice to this vector.
-    /// 
+    ///
     /// Panics if pushing each element would cause the length of this vector
     /// to exceed the maximum length.
-    /// 
+    ///
     /// Example:
-    /// 
+    ///
     /// ```noir
     /// let mut vec: BoundedVec<Field, 3> = BoundedVec::new();
     /// vec.extend_from_slice(&[2, 4]);
-    /// 
+    ///
     /// assert(vec.len == 2);
     /// assert(vec.get(0) == 2);
     /// assert(vec.get(1) == 4);
@@ -301,17 +301,17 @@ impl<T, let MaxLen: u32> BoundedVec<T, MaxLen> {
 
     /// Pushes each element from the other vector to this vector. The length of
     /// the other vector is left unchanged.
-    /// 
+    ///
     /// Panics if pushing each element would cause the length of this vector
     /// to exceed the maximum length.
-    /// 
+    ///
     /// ```noir
     /// let mut v1: BoundedVec<Field, 5> = BoundedVec::new();
     /// let mut v2: BoundedVec<Field, 7> = BoundedVec::new();
-    /// 
+    ///
     /// v2.extend_from_array([1, 2, 3]);
     /// v1.extend_from_bounded_vec(v2);
-    /// 
+    ///
     /// assert(v1.storage() == [1, 2, 3, 0, 0]);
     /// assert(v2.storage() == [1, 2, 3, 0, 0, 0, 0]);
     /// ```
@@ -330,11 +330,11 @@ impl<T, let MaxLen: u32> BoundedVec<T, MaxLen> {
         self.len = new_len;
     }
 
-    /// Creates a new vector, populating it with values derived from an array input. 
+    /// Creates a new vector, populating it with values derived from an array input.
     /// The maximum length of the vector is determined based on the type signature.
-    /// 
+    ///
     /// Example:
-    /// 
+    ///
     /// ```noir
     /// let bounded_vec: BoundedVec<Field, 10> = BoundedVec::from_array([1, 2, 3])
     /// ```
@@ -347,19 +347,19 @@ impl<T, let MaxLen: u32> BoundedVec<T, MaxLen> {
 
     /// Pops the element at the end of the vector. This will decrease the length
     /// of the vector by one.
-    /// 
+    ///
     /// Panics if the vector is empty.
-    /// 
+    ///
     /// Example:
-    /// 
+    ///
     /// ```noir
     /// let mut v: BoundedVec<Field, 2> = BoundedVec::new();
     /// v.push(1);
     /// v.push(2);
-    /// 
+    ///
     /// let two = v.pop();
     /// let one = v.pop();
-    /// 
+    ///
     /// assert(two == 2);
     /// assert(one == 1);
     ///
@@ -377,13 +377,13 @@ impl<T, let MaxLen: u32> BoundedVec<T, MaxLen> {
 
     /// Returns true if the given predicate returns true for any element
     /// in this vector.
-    /// 
+    ///
     /// Example:
-    /// 
+    ///
     /// ```noir
     /// let mut v: BoundedVec<u32, 3> = BoundedVec::new();
     /// v.extend_from_array([2, 4, 6]);
-    /// 
+    ///
     /// let all_even = !v.any(|elem: u32| elem % 2 != 0);
     /// assert(all_even);
     /// ```
@@ -399,14 +399,14 @@ impl<T, let MaxLen: u32> BoundedVec<T, MaxLen> {
         ret
     }
 
-    /// Creates a new vector of equal size by calling a closure on each element in this vector.  
-    /// 
+    /// Creates a new vector of equal size by calling a closure on each element in this vector.
+    ///
     /// Example:
-    /// 
+    ///
     /// ```noir
     /// let vec: BoundedVec<u32, 4> = BoundedVec::from_array([1, 2, 3, 4]);
     /// let result = vec.map(|value| value * 2);
-    /// 
+    ///
     /// let expected = BoundedVec::from_array([2, 4, 6, 8]);
     /// assert_eq(result, expected);
     /// ```
@@ -420,16 +420,74 @@ impl<T, let MaxLen: u32> BoundedVec<T, MaxLen> {
         }
         ret
     }
+
+    /// Creates a new BoundedVec from the given array and length.
+    /// The given length must be less than or equal to the length of the array.
+    ///
+    /// This function will zero out any elements at or past index `len` of `array`.
+    /// This incurs an extra runtime cost of O(MaxLen). If you are sure your array is
+    /// zeroed after that index, you can use `from_parts_unchecked` to remove the extra loop.
+    ///
+    /// Example:
+    ///
+    /// ```noir
+    /// let vec: BoundedVec<u32, 4> = BoundedVec::from_parts([1, 2, 3, 0], 3);
+    /// assert_eq(vec.len(), 3);
+    /// ```
+    pub fn from_parts(mut array: [T; MaxLen], len: u32) -> Self {
+        assert(len <= MaxLen);
+        let zeroed = crate::mem::zeroed();
+        for i in 0..MaxLen {
+            if i >= len {
+                array[i] = zeroed;
+            }
+        }
+        BoundedVec { storage: array, len }
+    }
+
+    /// Creates a new BoundedVec from the given array and length.
+    /// The given length must be less than or equal to the length of the array.
+    ///
+    /// This function is unsafe because it expects all elements past the `len` index
+    /// of `array` to be zeroed, but does not check for this internally. Use `from_parts`
+    /// for a safe version of this function which does zero out any indices past the
+    /// given length. Invalidating this assumption can notably cause `BoundedVec::eq`
+    /// to give incorrect results since it will check even elements past `len`.
+    ///
+    /// Example:
+    ///
+    /// ```noir
+    /// let vec: BoundedVec<u32, 4> = BoundedVec::from_parts_unchecked([1, 2, 3, 0], 3);
+    /// assert_eq(vec.len(), 3);
+    ///
+    /// // invalid use!
+    /// let vec1: BoundedVec<u32, 4> = BoundedVec::from_parts_unchecked([1, 2, 3, 1], 3);
+    /// let vec2: BoundedVec<u32, 4> = BoundedVec::from_parts_unchecked([1, 2, 3, 2], 3);
+    ///
+    /// // both vecs have length 3 so we'd expect them to be equal, but this
+    /// // fails because elements past the length are still checked in eq
+    /// assert_eq(vec1, vec2); // fails
+    /// ```
+    pub fn from_parts_unchecked(array: [T; MaxLen], len: u32) -> Self {
+        assert(len <= MaxLen);
+        BoundedVec { storage: array, len }
+    }
 }
 
-impl<T, let MaxLen: u32> Eq for BoundedVec<T, MaxLen> where T: Eq {
+impl<T, let MaxLen: u32> Eq for BoundedVec<T, MaxLen>
+where
+    T: Eq,
+{
     fn eq(self, other: BoundedVec<T, MaxLen>) -> bool {
         // TODO: https://github.com/noir-lang/noir/issues/4837
         //
         // We make the assumption that the user has used the proper interface for working with `BoundedVec`s
         // rather than directly manipulating the internal fields as this can result in an inconsistent internal state.
-
-        (self.len == other.len) & (self.storage == other.storage)
+        if self.len == other.len {
+            self.storage == other.storage
+        } else {
+            false
+        }
     }
 }
 
@@ -502,7 +560,7 @@ mod bounded_vec_tests {
         #[test]
         fn applies_function_that_changes_return_type() {
             let vec: BoundedVec<u32, 4> = BoundedVec::from_array([1, 2, 3, 4]);
-            let result = vec.map(|value| (value * 2)  as Field);
+            let result = vec.map(|value| (value * 2) as Field);
             let expected: BoundedVec<Field, 4> = BoundedVec::from_array([2, 4, 6, 8]);
 
             assert_eq(result, expected);
@@ -515,7 +573,7 @@ mod bounded_vec_tests {
             let expected = BoundedVec::from_array([5, 1]);
 
             assert_eq(result, expected);
-            assert_eq(result.storage()[2], 0);
+            assert_eq(result.get_unchecked(2), 0);
         }
     }
 
@@ -549,12 +607,12 @@ mod bounded_vec_tests {
 
             assert_eq(bounded_vec.max_len(), 10);
             assert_eq(bounded_vec.len(), 3);
-            assert_eq(bounded_vec.storage()[0], 1);
-            assert_eq(bounded_vec.storage()[1], 2);
-            assert_eq(bounded_vec.storage()[2], 3);
+            assert_eq(bounded_vec.get(0), 1);
+            assert_eq(bounded_vec.get(1), 2);
+            assert_eq(bounded_vec.get(2), 3);
         }
 
-        #[test(should_fail_with="from array out of bounds")]
+        #[test(should_fail_with = "from array out of bounds")]
         fn max_len_lower_then_array_len() {
             let _: BoundedVec<Field, 2> = BoundedVec::from_array([0; 3]);
         }
@@ -570,8 +628,8 @@ mod bounded_vec_tests {
 
             assert_eq(bounded_vec.max_len(), 10);
             assert_eq(bounded_vec.len(), 2);
-            assert_eq(bounded_vec.storage()[0], 1);
-            assert_eq(bounded_vec.storage()[1], 2);
+            assert_eq(bounded_vec.get(0), 1);
+            assert_eq(bounded_vec.get(1), 2);
         }
     }
 
@@ -596,4 +654,38 @@ mod bounded_vec_tests {
             assert(bounded_vec1 != bounded_vec2);
         }
     }
+
+    mod from_parts {
+        use crate::collections::bounded_vec::BoundedVec;
+
+        #[test]
+        fn from_parts() {
+            // docs:start:from-parts
+            let vec: BoundedVec<u32, 4> = BoundedVec::from_parts([1, 2, 3, 0], 3);
+            assert_eq(vec.len(), 3);
+
+            // Any elements past the given length are zeroed out, so these
+            // two BoundedVecs will be completely equal
+            let vec1: BoundedVec<u32, 4> = BoundedVec::from_parts([1, 2, 3, 1], 3);
+            let vec2: BoundedVec<u32, 4> = BoundedVec::from_parts([1, 2, 3, 2], 3);
+            assert_eq(vec1, vec2);
+            // docs:end:from-parts
+        }
+
+        #[test]
+        fn from_parts_unchecked() {
+            // docs:start:from-parts-unchecked
+            let vec: BoundedVec<u32, 4> = BoundedVec::from_parts_unchecked([1, 2, 3, 0], 3);
+            assert_eq(vec.len(), 3);
+
+            // invalid use!
+            let vec1: BoundedVec<u32, 4> = BoundedVec::from_parts_unchecked([1, 2, 3, 1], 3);
+            let vec2: BoundedVec<u32, 4> = BoundedVec::from_parts_unchecked([1, 2, 3, 2], 3);
+
+            // both vecs have length 3 so we'd expect them to be equal, but this
+            // fails because elements past the length are still checked in eq
+            assert(vec1 != vec2);
+            // docs:end:from-parts-unchecked
+        }
+    }
 }
diff --git a/noir_stdlib/src/collections/map.nr b/noir_stdlib/src/collections/map.nr
index a336a01d101..2b0da1b90ec 100644
--- a/noir_stdlib/src/collections/map.nr
+++ b/noir_stdlib/src/collections/map.nr
@@ -1,33 +1,33 @@
 use crate::cmp::Eq;
-use crate::option::Option;
-use crate::default::Default;
-use crate::hash::{Hash, Hasher, BuildHasher};
 use crate::collections::bounded_vec::BoundedVec;
+use crate::default::Default;
+use crate::hash::{BuildHasher, Hash, Hasher};
+use crate::option::Option;
 
-// We use load factor alpha_max = 0.75. 
-// Upon exceeding it, assert will fail in order to inform the user 
+// We use load factor alpha_max = 0.75.
+// Upon exceeding it, assert will fail in order to inform the user
 // about performance degradation, so that he can adjust the capacity.
-global MAX_LOAD_FACTOR_NUMERATOR = 3;
-global MAX_LOAD_FACTOR_DEN0MINATOR = 4;
+global MAX_LOAD_FACTOR_NUMERATOR: u32 = 3;
+global MAX_LOAD_FACTOR_DEN0MINATOR: u32 = 4;
 
 /// `HashMap<Key, Value, MaxLen, Hasher>` is used to efficiently store and look up key-value pairs.
-/// 
+///
 /// `HashMap` is a bounded type which can store anywhere from zero to `MaxLen` total elements.
 /// Note that due to hash collisions, the actual maximum number of elements stored by any particular
 /// hashmap is likely lower than `MaxLen`. This is true even with cryptographic hash functions since
 /// every hash value will be performed modulo `MaxLen`.
-/// 
+///
 /// Example:
-/// 
+///
 /// ```noir
 /// // Create a mapping from Fields to u32s with a maximum length of 12
 /// // using a poseidon2 hasher
 /// use std::hash::poseidon2::Poseidon2Hasher;
 /// let mut map: HashMap<Field, u32, 12, BuildHasherDefault<Poseidon2Hasher>> = HashMap::default();
-/// 
+///
 /// map.insert(1, 2);
 /// map.insert(3, 4);
-/// 
+///
 /// let two = map.get(1).unwrap();
 /// ```
 pub struct HashMap<K, V, let N: u32, B> {
@@ -36,11 +36,11 @@ pub struct HashMap<K, V, let N: u32, B> {
     /// Amount of valid elements in the map.
     _len: u32,
 
-    _build_hasher: B
+    _build_hasher: B,
 }
 
 // Data unit in the HashMap table.
-// In case Noir adds support for enums in the future, this  
+// In case Noir adds support for enums in the future, this
 // should be refactored to have three states:
 // 1. (key, value)
 // 2. (empty)
@@ -79,7 +79,7 @@ impl<K, V> Slot<K, V> {
     }
 
     // Shall not override `_key_value` with Option::none(),
-    // because we must be able to differentiate empty 
+    // because we must be able to differentiate empty
     // and deleted slots for lookup.
     fn mark_deleted(&mut self) {
         self._is_deleted = true;
@@ -87,12 +87,12 @@ impl<K, V> Slot<K, V> {
 }
 
 // While conducting lookup, we iterate attempt from 0 to N - 1 due to heuristic,
-// that if we have went that far without finding desired, 
+// that if we have went that far without finding desired,
 // it is very unlikely to be after - performance will be heavily degraded.
 impl<K, V, let N: u32, B> HashMap<K, V, N, B> {
     /// Creates a hashmap with an existing `BuildHasher`. This can be used to ensure multiple
     /// hashmaps are created with the same hasher instance.
-    /// 
+    ///
     /// Example:
     ///
     /// ```noir
@@ -103,7 +103,8 @@ impl<K, V, let N: u32, B> HashMap<K, V, N, B> {
     // docs:start:with_hasher
     pub fn with_hasher<H>(_build_hasher: B) -> Self
     where
-        B: BuildHasher<H> {
+        B: BuildHasher<H>,
+    {
         // docs:end:with_hasher
         let _table = [Slot::default(); N];
         let _len = 0;
@@ -111,9 +112,9 @@ impl<K, V, let N: u32, B> HashMap<K, V, N, B> {
     }
 
     /// Clears the hashmap, removing all key-value pairs from it.
-    /// 
+    ///
     /// Example:
-    /// 
+    ///
     /// ```noir
     /// assert(!map.is_empty());
     /// map.clear();
@@ -128,9 +129,9 @@ impl<K, V, let N: u32, B> HashMap<K, V, N, B> {
 
     /// Returns `true` if the hashmap contains the given key. Unlike `get`, this will not also return
     /// the value associated with the key.
-    /// 
+    ///
     /// Example:
-    /// 
+    ///
     /// ```noir
     /// if map.contains_key(7) {
     ///     let value = map.get(7);
@@ -140,28 +141,26 @@ impl<K, V, let N: u32, B> HashMap<K, V, N, B> {
     /// }
     /// ```
     // docs:start:contains_key
-    pub fn contains_key<H>(
-        self,
-        key: K
-    ) -> bool
+    pub fn contains_key<H>(self, key: K) -> bool
     where
         K: Hash + Eq,
         B: BuildHasher<H>,
-        H: Hasher {
+        H: Hasher,
+    {
         // docs:end:contains_key
         self.get(key).is_some()
     }
 
     /// Returns `true` if the length of the hash map is empty.
-    /// 
+    ///
     /// Example:
-    /// 
+    ///
     /// ```noir
     /// assert(map.is_empty());
-    /// 
+    ///
     /// map.insert(1, 2);
     /// assert(!map.is_empty());
-    /// 
+    ///
     /// map.remove(1);
     /// assert(map.is_empty());
     /// ```
@@ -172,14 +171,14 @@ impl<K, V, let N: u32, B> HashMap<K, V, N, B> {
     }
 
     /// Returns a vector of each key-value pair present in the hashmap.
-    /// 
+    ///
     /// The length of the returned vector is always equal to the length of the hashmap.
-    /// 
+    ///
     /// Example:
-    /// 
+    ///
     /// ```noir
     /// let entries = map.entries();
-    /// 
+    ///
     /// // The length of a hashmap may not be compile-time known, so we
     /// // need to loop over its capacity instead
     /// for i in 0..map.capacity() {
@@ -202,21 +201,24 @@ impl<K, V, let N: u32, B> HashMap<K, V, N, B> {
             }
         }
 
-        let msg = f"Amount of valid elements should have been {self._len} times, but got {entries.len()}.";
+        let self_len = self._len;
+        let entries_len = entries.len();
+        let msg =
+            f"Amount of valid elements should have been {self_len} times, but got {entries_len}.";
         assert(entries.len() == self._len, msg);
 
         entries
     }
 
     /// Returns a vector of each key present in the hashmap.
-    /// 
+    ///
     /// The length of the returned vector is always equal to the length of the hashmap.
-    /// 
+    ///
     /// Example:
-    /// 
+    ///
     /// ```noir
     /// let keys = map.keys();
-    /// 
+    ///
     /// for i in 0..keys.max_len() {
     ///     if i < keys.len() {
     ///         let key = keys.get_unchecked(i);
@@ -237,21 +239,24 @@ impl<K, V, let N: u32, B> HashMap<K, V, N, B> {
             }
         }
 
-        let msg = f"Amount of valid elements should have been {self._len} times, but got {keys.len()}.";
+        let self_len = self._len;
+        let keys_len = keys.len();
+        let msg =
+            f"Amount of valid elements should have been {self_len} times, but got {keys_len}.";
         assert(keys.len() == self._len, msg);
 
         keys
     }
 
     /// Returns a vector of each value present in the hashmap.
-    /// 
+    ///
     /// The length of the returned vector is always equal to the length of the hashmap.
-    /// 
+    ///
     /// Example:
-    /// 
+    ///
     /// ```noir
     /// let values = map.values();
-    /// 
+    ///
     /// for i in 0..values.max_len() {
     ///     if i < values.len() {
     ///         let value = values.get_unchecked(i);
@@ -266,14 +271,15 @@ impl<K, V, let N: u32, B> HashMap<K, V, N, B> {
 
         for slot in self._table {
             if slot.is_valid() {
-                let (_, value) = unsafe {
-                    slot.key_value_unchecked()
-                };
+                let (_, value) = unsafe { slot.key_value_unchecked() };
                 values.push(value);
             }
         }
 
-        let msg = f"Amount of valid elements should have been {self._len} times, but got {values.len()}.";
+        let self_len = self._len;
+        let values_len = values.len();
+        let msg =
+            f"Amount of valid elements should have been {self_len} times, but got {values_len}.";
         assert(values.len() == self._len, msg);
 
         values
@@ -281,29 +287,27 @@ impl<K, V, let N: u32, B> HashMap<K, V, N, B> {
 
     /// Iterates through each key-value pair of the HashMap, setting each key-value pair to the
     /// result returned from the given function.
-    /// 
+    ///
     /// Note that since keys can be mutated, the HashMap needs to be rebuilt as it is iterated
     /// through. If this is not desired, use `iter_values_mut` if only values need to be mutated,
     /// or `entries` if neither keys nor values need to be mutated.
-    /// 
+    ///
     /// The iteration order is left unspecified. As a result, if two keys are mutated to become
     /// equal, which of the two values that will be present for the key in the resulting map is also unspecified.
-    /// 
+    ///
     /// Example:
-    /// 
+    ///
     /// ```noir
     /// // Add 1 to each key in the map, and double the value associated with that key.
     /// map.iter_mut(|k, v| (k + 1, v * 2));
     /// ```
     // docs:start:iter_mut
-    pub fn iter_mut<H>(
-        &mut self,
-        f: fn(K, V) -> (K, V)
-    )
+    pub fn iter_mut<H>(&mut self, f: fn(K, V) -> (K, V))
     where
         K: Eq + Hash,
         B: BuildHasher<H>,
-        H: Hasher {
+        H: Hasher,
+    {
         // docs:end:iter_mut
         let mut entries = self.entries();
         let mut new_map = HashMap::with_hasher(self._build_hasher);
@@ -321,29 +325,27 @@ impl<K, V, let N: u32, B> HashMap<K, V, N, B> {
 
     /// Iterates through the HashMap, mutating each key to the result returned from
     /// the given function.
-    /// 
+    ///
     /// Note that since keys can be mutated, the HashMap needs to be rebuilt as it is iterated
     /// through. If only iteration is desired and the keys are not intended to be mutated,
     /// prefer using `entries` instead.
-    /// 
+    ///
     /// The iteration order is left unspecified. As a result, if two keys are mutated to become
     /// equal, which of the two values that will be present for the key in the resulting map is also unspecified.
-    /// 
+    ///
     /// Example:
-    /// 
+    ///
     /// ```noir
     /// // Double each key, leaving the value associated with that key untouched
     /// map.iter_keys_mut(|k| k * 2);
     /// ```
     // docs:start:iter_keys_mut
-    pub fn iter_keys_mut<H>(
-        &mut self,
-        f: fn(K) -> K
-    ) 
+    pub fn iter_keys_mut<H>(&mut self, f: fn(K) -> K)
     where
         K: Eq + Hash,
         B: BuildHasher<H>,
-        H: Hasher {
+        H: Hasher,
+    {
         // docs:end:iter_keys_mut
         let mut entries = self.entries();
         let mut new_map = HashMap::with_hasher(self._build_hasher);
@@ -362,9 +364,9 @@ impl<K, V, let N: u32, B> HashMap<K, V, N, B> {
     /// Iterates through the HashMap, applying the given function to each value and mutating the
     /// value to equal the result. This function is more efficient than `iter_mut` and `iter_keys_mut`
     /// because the keys are untouched and the underlying hashmap thus does not need to be reordered.
-    /// 
+    ///
     /// Example:
-    /// 
+    ///
     /// ```noir
     /// // Halve each value
     /// map.iter_values_mut(|v| v / 2);
@@ -384,9 +386,9 @@ impl<K, V, let N: u32, B> HashMap<K, V, N, B> {
 
     /// Retains only the key-value pairs for which the given function returns true.
     /// Any key-value pairs for which the function returns false will be removed from the map.
-    /// 
+    ///
     /// Example:
-    /// 
+    ///
     /// ```noir
     /// map.retain(|k, v| (k != 0) & (v != 0));
     /// ```
@@ -407,22 +409,22 @@ impl<K, V, let N: u32, B> HashMap<K, V, N, B> {
     }
 
     /// Returns the current length of this hash map.
-    /// 
+    ///
     /// Example:
-    /// 
+    ///
     /// ```noir
     /// // This is equivalent to checking map.is_empty()
     /// assert(map.len() == 0);
-    /// 
+    ///
     /// map.insert(1, 2);
     /// map.insert(3, 4);
     /// map.insert(5, 6);
     /// assert(map.len() == 3);
-    /// 
+    ///
     /// // 3 was already present as a key in the hash map, so the length is unchanged
     /// map.insert(3, 7);
     /// assert(map.len() == 3);
-    /// 
+    ///
     /// map.remove(1);
     /// assert(map.len() == 2);
     /// ```
@@ -434,15 +436,15 @@ impl<K, V, let N: u32, B> HashMap<K, V, N, B> {
 
     /// Returns the maximum capacity of this hashmap. This is always equal to the capacity
     /// specified in the hashmap's type.
-    /// 
+    ///
     /// Unlike hashmaps in general purpose programming languages, hashmaps in Noir have a
     /// static capacity that does not increase as the map grows larger. Thus, this capacity
     /// is also the maximum possible element count that can be inserted into the hashmap.
     /// Due to hash collisions (modulo the hashmap length), it is likely the actual maximum
     /// element count will be lower than the full capacity.
-    /// 
+    ///
     /// Example:
-    /// 
+    ///
     /// ```noir
     /// let empty_map: HashMap<Field, Field, 42, BuildHasherDefault<Poseidon2Hasher>> = HashMap::default();
     /// assert(empty_map.len() == 0);
@@ -455,27 +457,25 @@ impl<K, V, let N: u32, B> HashMap<K, V, N, B> {
     }
 
     /// Retrieves a value from the hashmap, returning `Option::none()` if it was not found.
-    /// 
+    ///
     /// Example:
-    /// 
+    ///
     /// ```noir
     /// fn get_example(map: HashMap<Field, Field, 5, BuildHasherDefault<Poseidon2Hasher>>) {
     ///     let x = map.get(12);
-    /// 
+    ///
     ///     if x.is_some() {
     ///         assert(x.unwrap() == 42);
     ///     }
     /// }
     /// ```
     // docs:start:get
-    pub fn get<H>(
-        self,
-        key: K
-    ) -> Option<V>
+    pub fn get<H>(self, key: K) -> Option<V>
     where
         K: Eq + Hash,
         B: BuildHasher<H>,
-        H: Hasher {
+        H: Hasher,
+    {
         // docs:end:get
         let mut result = Option::none();
 
@@ -503,24 +503,21 @@ impl<K, V, let N: u32, B> HashMap<K, V, N, B> {
 
     /// Inserts a new key-value pair into the map. If the key was already in the map, its
     /// previous value will be overridden with the newly provided one.
-    /// 
+    ///
     /// Example:
-    /// 
+    ///
     /// ```noir
     /// let mut map: HashMap<Field, Field, 5, BuildHasherDefault<Poseidon2Hasher>> = HashMap::default();
     /// map.insert(12, 42);
     /// assert(map.len() == 1);
     /// ```
     // docs:start:insert
-    pub fn insert<H>(
-        &mut self,
-        key: K,
-        value: V
-    )
+    pub fn insert<H>(&mut self, key: K, value: V)
     where
         K: Eq + Hash,
         B: BuildHasher<H>,
-        H: Hasher {
+        H: Hasher,
+    {
         // docs:end:insert
         self.assert_load_factor();
 
@@ -555,30 +552,28 @@ impl<K, V, let N: u32, B> HashMap<K, V, N, B> {
 
     /// Removes the given key-value pair from the map. If the key was not already present
     /// in the map, this does nothing.
-    /// 
+    ///
     /// Example:
-    /// 
+    ///
     /// ```noir
     /// let mut map: HashMap<Field, Field, 5, BuildHasherDefault<Poseidon2Hasher>> = HashMap::default();
     /// map.insert(12, 42);
     /// assert(!map.is_empty());
-    /// 
+    ///
     /// map.remove(12);
     /// assert(map.is_empty());
-    /// 
+    ///
     /// // If a key was not present in the map, remove does nothing
     /// map.remove(12);
     /// assert(map.is_empty());
     /// ```
     // docs:start:remove
-    pub fn remove<H>(
-        &mut self,
-        key: K
-    )
+    pub fn remove<H>(&mut self, key: K)
     where
         K: Eq + Hash,
         B: BuildHasher<H>,
-        H: Hasher {
+        H: Hasher,
+    {
         // docs:end:remove
         let hash = self.hash(key);
         let mut should_break = false;
@@ -603,14 +598,12 @@ impl<K, V, let N: u32, B> HashMap<K, V, N, B> {
     }
 
     // Apply HashMap's hasher onto key to obtain pre-hash for probing.
-    fn hash<H>(
-        self,
-        key: K
-    ) -> u32
+    fn hash<H>(self, key: K) -> u32
     where
         K: Hash,
         B: BuildHasher<H>,
-        H: Hasher {
+        H: Hasher,
+    {
         let mut hasher = self._build_hasher.build_hasher();
         key.hash(&mut hasher);
         hasher.finish() as u32
@@ -619,15 +612,15 @@ impl<K, V, let N: u32, B> HashMap<K, V, N, B> {
     // Probing scheme: quadratic function.
     // We use 0.5 constant near variadic attempt and attempt^2 monomials.
     // This ensures good uniformity of distribution for table sizes
-    // equal to prime numbers or powers of two. 
+    // equal to prime numbers or powers of two.
     fn quadratic_probe(_self: Self, hash: u32, attempt: u32) -> u32 {
         (hash + (attempt + attempt * attempt) / 2) % N
     }
 
-    // Amount of elements in the table in relation to available slots exceeds alpha_max. 
-    // To avoid a comparatively more expensive division operation 
+    // Amount of elements in the table in relation to available slots exceeds alpha_max.
+    // To avoid a comparatively more expensive division operation
     // we conduct cross-multiplication instead.
-    // n / m >= MAX_LOAD_FACTOR_NUMERATOR / MAX_LOAD_FACTOR_DEN0MINATOR 
+    // n / m >= MAX_LOAD_FACTOR_NUMERATOR / MAX_LOAD_FACTOR_DEN0MINATOR
     // n * MAX_LOAD_FACTOR_DEN0MINATOR >= m * MAX_LOAD_FACTOR_NUMERATOR
     fn assert_load_factor(self) {
         let lhs = self._len * MAX_LOAD_FACTOR_DEN0MINATOR;
@@ -637,8 +630,8 @@ impl<K, V, let N: u32, B> HashMap<K, V, N, B> {
     }
 }
 
-// Equality class on HashMap has to test that they have 
-// equal sets of key-value entries, 
+// Equality class on HashMap has to test that they have
+// equal sets of key-value entries,
 // thus one is a subset of the other and vice versa.
 // docs:start:eq
 impl<K, V, let N: u32, B, H> Eq for HashMap<K, V, N, B>
@@ -646,21 +639,22 @@ where
     K: Eq + Hash,
     V: Eq,
     B: BuildHasher<H>,
-    H: Hasher {
+    H: Hasher,
+{
     /// Checks if two HashMaps are equal.
-    /// 
+    ///
     /// Example:
-    /// 
+    ///
     /// ```noir
     /// let mut map1: HashMap<Field, u64, 4, BuildHasherDefault<Poseidon2Hasher>> = HashMap::default();
     /// let mut map2: HashMap<Field, u64, 4, BuildHasherDefault<Poseidon2Hasher>> = HashMap::default();
-    /// 
+    ///
     /// map1.insert(1, 2);
     /// map1.insert(3, 4);
-    /// 
+    ///
     /// map2.insert(3, 4);
     /// map2.insert(1, 2);
-    /// 
+    ///
     /// assert(map1 == map2);
     /// ```
     fn eq(self, other: HashMap<K, V, N, B>) -> bool {
@@ -695,15 +689,16 @@ where
 impl<K, V, let N: u32, B, H> Default for HashMap<K, V, N, B>
 where
     B: BuildHasher<H> + Default,
-    H: Hasher + Default {
+    H: Hasher + Default,
+{
     /// Constructs an empty HashMap.
-    /// 
+    ///
     /// Example:
-    /// 
+    ///
     /// ```noir
     /// let hashmap: HashMap<u8, u32, 10, BuildHasherDefault<Poseidon2Hasher>> = HashMap::default();
     /// assert(hashmap.is_empty());
-    /// ``` 
+    /// ```
     fn default() -> Self {
         // docs:end:default
         let _build_hasher = B::default();
diff --git a/noir_stdlib/src/collections/umap.nr b/noir_stdlib/src/collections/umap.nr
index 9d23e216731..7aebeb437cf 100644
--- a/noir_stdlib/src/collections/umap.nr
+++ b/noir_stdlib/src/collections/umap.nr
@@ -1,7 +1,7 @@
 use crate::cmp::Eq;
-use crate::option::Option;
 use crate::default::Default;
-use crate::hash::{Hash, Hasher, BuildHasher};
+use crate::hash::{BuildHasher, Hash, Hasher};
+use crate::option::Option;
 
 // An unconstrained hash table with open addressing and quadratic probing.
 // Note that "unconstrained" here means that almost all operations on this
@@ -17,11 +17,11 @@ pub struct UHashMap<K, V, B> {
     // Amount of valid elements in the map.
     _len: u32,
 
-    _build_hasher: B
+    _build_hasher: B,
 }
 
 // Data unit in the UHashMap table.
-// In case Noir adds support for enums in the future, this  
+// In case Noir adds support for enums in the future, this
 // should be refactored to have three states:
 // 1. (key, value)
 // 2. (empty)
@@ -60,7 +60,7 @@ impl<K, V> Slot<K, V> {
     }
 
     // Shall not override `_key_value` with Option::none(),
-    // because we must be able to differentiate empty 
+    // because we must be able to differentiate empty
     // and deleted slots for lookup.
     fn mark_deleted(&mut self) {
         self._is_deleted = true;
@@ -68,14 +68,15 @@ impl<K, V> Slot<K, V> {
 }
 
 // While conducting lookup, we iterate attempt from 0 to N - 1 due to heuristic,
-// that if we have went that far without finding desired, 
+// that if we have went that far without finding desired,
 // it is very unlikely to be after - performance will be heavily degraded.
 impl<K, V, B> UHashMap<K, V, B> {
     // Creates a new instance of UHashMap with specified BuildHasher.
     // docs:start:with_hasher
     pub fn with_hasher<H>(_build_hasher: B) -> Self
     where
-        B: BuildHasher<H> {
+        B: BuildHasher<H>,
+    {
         // docs:end:with_hasher
         let _table = &[Slot::default()];
         let _len = 0;
@@ -84,7 +85,8 @@ impl<K, V, B> UHashMap<K, V, B> {
 
     pub fn with_hasher_and_capacity<H>(_build_hasher: B, capacity: u32) -> Self
     where
-        B: BuildHasher<H> {
+        B: BuildHasher<H>,
+    {
         // docs:end:with_hasher
         let mut _table = &[];
         for _ in 0..capacity {
@@ -104,18 +106,14 @@ impl<K, V, B> UHashMap<K, V, B> {
 
     // Returns true if the map contains a value for the specified key.
     // docs:start:contains_key
-    pub fn contains_key<H>(
-        self,
-        key: K
-    ) -> bool
+    pub fn contains_key<H>(self, key: K) -> bool
     where
         K: Hash + Eq,
         B: BuildHasher<H>,
-        H: Hasher {
+        H: Hasher,
+    {
         // docs:end:contains_key
-        unsafe {
-            self.get(key)
-        }.is_some()
+        unsafe { self.get(key) }.is_some()
     }
 
     // Returns true if the map contains no elements.
@@ -140,7 +138,10 @@ impl<K, V, B> UHashMap<K, V, B> {
             }
         }
 
-        let msg = f"Amount of valid elements should have been {self._len} times, but got {entries.len()}.";
+        let self_len = self._len;
+        let entries_len = entries.len();
+        let msg =
+            f"Amount of valid elements should have been {self_len} times, but got {entries_len}.";
         assert(entries.len() == self._len, msg);
 
         entries
@@ -160,7 +161,10 @@ impl<K, V, B> UHashMap<K, V, B> {
             }
         }
 
-        let msg = f"Amount of valid elements should have been {self._len} times, but got {keys.len()}.";
+        let self_len = self._len;
+        let keys_len = keys.len();
+        let msg =
+            f"Amount of valid elements should have been {self_len} times, but got {keys_len}.";
         assert(keys.len() == self._len, msg);
 
         keys
@@ -180,7 +184,10 @@ impl<K, V, B> UHashMap<K, V, B> {
             }
         }
 
-        let msg = f"Amount of valid elements should have been {self._len} times, but got {values.len()}.";
+        let self_len = self._len;
+        let values_len = values.len();
+        let msg =
+            f"Amount of valid elements should have been {self_len} times, but got {values_len}.";
         assert(values.len() == self._len, msg);
 
         values
@@ -188,14 +195,12 @@ impl<K, V, B> UHashMap<K, V, B> {
 
     // For each key-value entry applies mutator function.
     // docs:start:iter_mut
-    unconstrained pub fn iter_mut<H>(
-        &mut self,
-        f: fn(K, V) -> (K, V)
-    )
+    pub unconstrained fn iter_mut<H>(&mut self, f: fn(K, V) -> (K, V))
     where
         K: Eq + Hash,
         B: BuildHasher<H>,
-        H: Hasher {
+        H: Hasher,
+    {
         // docs:end:iter_mut
         let mut entries = self.entries();
         let mut new_map = UHashMap::with_hasher(self._build_hasher);
@@ -210,14 +215,12 @@ impl<K, V, B> UHashMap<K, V, B> {
 
     // For each key applies mutator function.
     // docs:start:iter_keys_mut
-    unconstrained pub fn iter_keys_mut<H>(
-        &mut self,
-        f: fn(K) -> K
-    ) 
+    pub unconstrained fn iter_keys_mut<H>(&mut self, f: fn(K) -> K)
     where
         K: Eq + Hash,
         B: BuildHasher<H>,
-        H: Hasher {
+        H: Hasher,
+    {
         // docs:end:iter_keys_mut
         let mut entries = self.entries();
         let mut new_map = UHashMap::with_hasher(self._build_hasher);
@@ -277,14 +280,12 @@ impl<K, V, B> UHashMap<K, V, B> {
 
     // Get the value by key. If it does not exist, returns none().
     // docs:start:get
-    unconstrained pub fn get<H>(
-        self,
-        key: K
-    ) -> Option<V>
+    pub unconstrained fn get<H>(self, key: K) -> Option<V>
     where
         K: Eq + Hash,
         B: BuildHasher<H>,
-        H: Hasher {
+        H: Hasher,
+    {
         // docs:end:get
         let mut result = Option::none();
 
@@ -307,17 +308,14 @@ impl<K, V, B> UHashMap<K, V, B> {
         result
     }
 
-    // Insert key-value entry. In case key was already present, value is overridden. 
+    // Insert key-value entry. In case key was already present, value is overridden.
     // docs:start:insert
-    unconstrained pub fn insert<H>(
-        &mut self,
-        key: K,
-        value: V
-    )
+    pub unconstrained fn insert<H>(&mut self, key: K, value: V)
     where
         K: Eq + Hash,
         B: BuildHasher<H>,
-        H: Hasher {
+        H: Hasher,
+    {
         // docs:end:insert
         self.try_resize();
 
@@ -348,7 +346,11 @@ impl<K, V, B> UHashMap<K, V, B> {
     }
 
     unconstrained fn try_resize<H>(&mut self)
-        where B: BuildHasher<H>, K: Eq + Hash, H: Hasher {
+    where
+        B: BuildHasher<H>,
+        K: Eq + Hash,
+        H: Hasher,
+    {
         if self.len() + 1 >= self.capacity() / 2 {
             let capacity = self.capacity() * 2;
             let mut new_map = UHashMap::with_hasher_and_capacity(self._build_hasher, capacity);
@@ -362,14 +364,12 @@ impl<K, V, B> UHashMap<K, V, B> {
 
     // Removes a key-value entry. If key is not present, UHashMap remains unchanged.
     // docs:start:remove
-    unconstrained pub fn remove<H>(
-        &mut self,
-        key: K
-    )
+    pub unconstrained fn remove<H>(&mut self, key: K)
     where
         K: Eq + Hash,
         B: BuildHasher<H>,
-        H: Hasher {
+        H: Hasher,
+    {
         // docs:end:remove
         let hash = self.hash(key);
 
@@ -391,14 +391,12 @@ impl<K, V, B> UHashMap<K, V, B> {
     }
 
     // Apply UHashMap's hasher onto key to obtain pre-hash for probing.
-    fn hash<H>(
-        self,
-        key: K
-    ) -> u32
+    fn hash<H>(self, key: K) -> u32
     where
         K: Hash,
         B: BuildHasher<H>,
-        H: Hasher {
+        H: Hasher,
+    {
         let mut hasher = self._build_hasher.build_hasher();
         key.hash(&mut hasher);
         hasher.finish() as u32
@@ -407,14 +405,14 @@ impl<K, V, B> UHashMap<K, V, B> {
     // Probing scheme: quadratic function.
     // We use 0.5 constant near variadic attempt and attempt^2 monomials.
     // This ensures good uniformity of distribution for table sizes
-    // equal to prime numbers or powers of two. 
+    // equal to prime numbers or powers of two.
     fn quadratic_probe(self: Self, hash: u32, attempt: u32) -> u32 {
         (hash + (attempt + attempt * attempt) / 2) % self._table.len()
     }
 }
 
-// Equality class on UHashMap has to test that they have 
-// equal sets of key-value entries, 
+// Equality class on UHashMap has to test that they have
+// equal sets of key-value entries,
 // thus one is a subset of the other and vice versa.
 // docs:start:eq
 impl<K, V, B, H> Eq for UHashMap<K, V, B>
@@ -422,7 +420,8 @@ where
     K: Eq + Hash,
     V: Eq,
     B: BuildHasher<H>,
-    H: Hasher {
+    H: Hasher,
+{
     fn eq(self, other: UHashMap<K, V, B>) -> bool {
         // docs:end:eq
         let mut equal = false;
@@ -433,9 +432,7 @@ where
                 // Not marked as deleted and has key-value.
                 if equal & slot.is_valid() {
                     let (key, value) = slot.key_value_unchecked();
-                    let other_value = unsafe {
-                        other.get(key)
-                    };
+                    let other_value = unsafe { other.get(key) };
 
                     if other_value.is_none() {
                         equal = false;
@@ -457,7 +454,8 @@ where
 impl<K, V, B, H> Default for UHashMap<K, V, B>
 where
     B: BuildHasher<H> + Default,
-    H: Hasher + Default {
+    H: Hasher + Default,
+{
     fn default() -> Self {
         // docs:end:default
         UHashMap::with_hasher(B::default())
diff --git a/noir_stdlib/src/collections/vec.nr b/noir_stdlib/src/collections/vec.nr
index f24ed4ac783..aa019095683 100644
--- a/noir_stdlib/src/collections/vec.nr
+++ b/noir_stdlib/src/collections/vec.nr
@@ -1,5 +1,5 @@
-pub struct Vec<T> { 
-    slice: [T]
+pub struct Vec<T> {
+    pub(crate) slice: [T],
 }
 // A mutable vector type implemented as a wrapper around immutable slices.
 // A separate type is technically not needed but helps differentiate which operations are mutable.
@@ -44,7 +44,7 @@ impl<T> Vec<T> {
         last_elem
     }
 
-    /// Insert an element at a specified index, shifting all elements 
+    /// Insert an element at a specified index, shifting all elements
     /// after it to the right
     pub fn insert(&mut self, index: u32, elem: T) {
         self.slice = self.slice.insert(index, elem);
diff --git a/noir_stdlib/src/compat.nr b/noir_stdlib/src/compat.nr
index 92e15bae30e..c65246816bf 100644
--- a/noir_stdlib/src/compat.nr
+++ b/noir_stdlib/src/compat.nr
@@ -1,10 +1,10 @@
 comptime global BN254_MODULUS_BE_BYTES: [u8] = &[
-    48, 100, 78, 114, 225, 49, 160, 41, 184, 80, 69, 182, 129, 129, 88, 93, 40, 51, 232, 72, 121, 185, 112, 145, 67, 225, 245, 147, 240, 0, 0, 1
+    48, 100, 78, 114, 225, 49, 160, 41, 184, 80, 69, 182, 129, 129, 88, 93, 40, 51, 232, 72, 121,
+    185, 112, 145, 67, 225, 245, 147, 240, 0, 0, 1,
 ];
 
 pub fn is_bn254() -> bool {
-    comptime
-    {
+    comptime {
         // We can't use the `Eq` trait here due to limitations on calling non-comptime functions
         // defined within the same crate.
         let mut eq = true;
diff --git a/noir_stdlib/src/convert.nr b/noir_stdlib/src/convert.nr
index a38a54ce365..d4bea8b6390 100644
--- a/noir_stdlib/src/convert.nr
+++ b/noir_stdlib/src/convert.nr
@@ -15,7 +15,10 @@ pub trait Into<T> {
     fn into(self) -> T;
 }
 
-impl<T, U> Into<T> for U where T: From<U> {
+impl<T, U> Into<T> for U
+where
+    T: From<U>,
+{
     fn into(self) -> T {
         T::from(self)
     }
diff --git a/noir_stdlib/src/default.nr b/noir_stdlib/src/default.nr
index 00bb278fd48..01f10a368b1 100644
--- a/noir_stdlib/src/default.nr
+++ b/noir_stdlib/src/default.nr
@@ -79,7 +79,10 @@ impl Default for bool {
     }
 }
 
-impl<T, let N: u32> Default for [T; N] where T: Default {
+impl<T, let N: u32> Default for [T; N]
+where
+    T: Default,
+{
     fn default() -> [T; N] {
         [T::default(); N]
     }
@@ -91,25 +94,47 @@ impl<T> Default for [T] {
     }
 }
 
-impl<A, B> Default for (A, B) where A: Default, B: Default {
+impl<A, B> Default for (A, B)
+where
+    A: Default,
+    B: Default,
+{
     fn default() -> (A, B) {
         (A::default(), B::default())
     }
 }
 
-impl<A, B, C> Default for (A, B, C) where A: Default, B: Default, C: Default {
+impl<A, B, C> Default for (A, B, C)
+where
+    A: Default,
+    B: Default,
+    C: Default,
+{
     fn default() -> (A, B, C) {
         (A::default(), B::default(), C::default())
     }
 }
 
-impl<A, B, C, D> Default for (A, B, C, D) where A: Default, B: Default, C: Default, D: Default {
+impl<A, B, C, D> Default for (A, B, C, D)
+where
+    A: Default,
+    B: Default,
+    C: Default,
+    D: Default,
+{
     fn default() -> (A, B, C, D) {
         (A::default(), B::default(), C::default(), D::default())
     }
 }
 
-impl<A, B, C, D, E> Default for (A, B, C, D, E) where A: Default, B: Default, C: Default, D: Default, E: Default {
+impl<A, B, C, D, E> Default for (A, B, C, D, E)
+where
+    A: Default,
+    B: Default,
+    C: Default,
+    D: Default,
+    E: Default,
+{
     fn default() -> (A, B, C, D, E) {
         (A::default(), B::default(), C::default(), D::default(), E::default())
     }
diff --git a/noir_stdlib/src/ec/consts/mod.nr b/noir_stdlib/src/ec/consts/mod.nr
deleted file mode 100644
index 73c594c6a26..00000000000
--- a/noir_stdlib/src/ec/consts/mod.nr
+++ /dev/null
@@ -1 +0,0 @@
-pub mod te;
diff --git a/noir_stdlib/src/ec/consts/te.nr b/noir_stdlib/src/ec/consts/te.nr
deleted file mode 100644
index e82302eadee..00000000000
--- a/noir_stdlib/src/ec/consts/te.nr
+++ /dev/null
@@ -1,32 +0,0 @@
-use crate::ec::tecurve::affine::Point as TEPoint;
-use crate::ec::tecurve::affine::Curve as TECurve;
-
-pub struct BabyJubjub {
-    curve: TECurve,
-    base8: TEPoint,
-    suborder: Field,
-}
-
-#[field(bn254)]
-#[deprecated = "It's recommmended to use the external noir-edwards library (https://github.com/noir-lang/noir-edwards)"]
-pub fn baby_jubjub() -> BabyJubjub {
-    BabyJubjub {
-        // Baby Jubjub (ERC-2494) parameters in affine representation
-        curve: TECurve::new(
-            168700,
-            168696,
-            // G
-            TEPoint::new(
-                995203441582195749578291179787384436505546430278305826713579947235728471134,
-                5472060717959818805561601436314318772137091100104008585924551046643952123905
-            )
-        ),
-        // [8]G precalculated
-        base8: TEPoint::new(
-            5299619240641551281634865583518297030282874472190772894086521144482721001553,
-            16950150798460657717958625567821834550301663161624707787222815936182638968203
-        ),
-        // The size of the group formed from multiplying the base field by 8.
-        suborder: 2736030358979909402780800718157159386076813972158567259200215660948447373041
-    }
-}
diff --git a/noir_stdlib/src/ec/mod.nr b/noir_stdlib/src/ec/mod.nr
deleted file mode 100644
index 112f39f74eb..00000000000
--- a/noir_stdlib/src/ec/mod.nr
+++ /dev/null
@@ -1,195 +0,0 @@
-// Elliptic curve implementation
-// Overview
-// ========
-// The following three elliptic curve representations are admissible:
-pub mod tecurve; // Twisted Edwards curves
-pub mod swcurve; // Elliptic curves in Short Weierstrass form
-pub mod montcurve; // Montgomery curves
-pub mod consts; // Commonly used curve presets
-//
-// Note that Twisted Edwards and Montgomery curves are (birationally) equivalent, so that
-// they may be freely converted between one another, whereas Short Weierstrass curves are
-// more general. Diagramatically:
-//
-// tecurve == montcurve `subset` swcurve
-//
-// Each module is further divided into two submodules, 'affine' and 'curvegroup', depending
-// on the preferred coordinate representation. Affine coordinates are none other than the usual
-// two-dimensional Cartesian coordinates used in the definitions of these curves, whereas
-// 'CurveGroup' coordinates (terminology borrowed from Arkworks, whose conventions we try
-// to follow) are special coordinate systems with respect to which the group operations may be
-// implemented more efficiently, usually by means of an appropriate choice of projective coordinates.
-//
-// In each of these submodules, there is a Point struct and a Curve struct, the former
-// representing a point in the coordinate system and the latter a curve configuration.
-//
-// Points
-// ======
-// Points may be instantiated using the associated function `new`, which takes coordinates
-// as its arguments. For instance,
-//
-// `let p = swcurve::Point::new(1,1);`
-//
-// The additive identity may be constructed by a call to the associated function `zero` of no
-// arguments:
-//
-// `let zero = swcurve::Point::zero();`
-//
-// Points may be tested for equality by calling the method `eq`:
-//
-// `let pred = p.eq(zero);`
-//
-// There is also the method `is_zero` to explicitly check whether a point is the additive identity:
-//
-// `constrain pred == p.is_zero();`
-//
-// Points may be negated by calling the `negate` method and converted to CurveGroup (or affine)
-// coordinates by calling the `into_group` (resp. `into_affine`) method on them. Finally,
-// Points may be freely mapped between their respective Twisted Edwards and Montgomery
-// representations by calling the `into_montcurve` or `into_tecurve` methods. For mappings
-// between Twisted Edwards/Montgomery curves and Short Weierstrass curves, see the Curve section
-// below, as the underlying mappings are those of curves rather than ambient spaces.
-// As a rule, Points in affine (or CurveGroup) coordinates are mapped to Points in affine
-// (resp. CurveGroup) coordinates.
-//
-// Curves
-// ======
-// A curve configuration (Curve) is completely determined by the Field coefficients of its defining
-// equation (a and b in the case of swcurve, a and d in the case of tecurve, and j and k in
-// the case of montcurve) together with a generator (`gen`) in the corresponding coordinate system.
-// For example, the Baby Jubjub curve configuration as defined in ERC-2494 may be instantiated as a Twisted
-// Edwards curve in affine coordinates as follows:
-//
-// `let bjj_affine = tecurve::Curve::new(168700, 168696, tecurve::Point::new(995203441582195749578291179787384436505546430278305826713579947235728471134,5472060717959818805561601436314318772137091100104008585924551046643952123905));`
-//
-// The `contains` method may be used to check whether a Point lies on a given curve:
-//
-// `constrain bjj_affine.contains(tecurve::Point::zero());`
-//
-// The elliptic curve group's addition operation is exposed as the `add` method, e.g.
-//
-// `let p = bjj_affine.add(bjj_affine.gen, bjj_affine.gen);`
-//
-// subtraction as the `subtract` method, e.g.
-//
-// `constrain tecurve::Point::zero().eq(bjj_affine.subtract(bjj_affine.gen, bjj_affine.gen));`
-//
-// scalar multiplication as the `mul` method, where the scalar is assumed to be a Field* element, e.g.
-//
-// `constrain tecurve::Point::zero().eq(bjj_affine.mul(2, tecurve::Point::zero());`
-//
-// There is a scalar multiplication method (`bit_mul`) provided where the scalar input is expected to be
-// an array of bits (little-endian convention), as well as a multi-scalar multiplication method** (`msm`)
-// which takes an array of Field elements and an array of elliptic curve points as arguments, both assumed
-// to be of the same length.
-//
-// Curve configurations may be converted between different coordinate representations by calling the `into_group`
-// and `into_affine` methods on them, e.g.
-//
-// `let bjj_curvegroup = bjj_affine.into_group();`
-//
-// Curve configurations may also be converted between different curve representations by calling the `into_swcurve`,
-// `into_montcurve` and `into_tecurve` methods subject to the relation between the curve representations mentioned
-// above. Note that it is possible to map Points from a Twisted Edwards/Montgomery curve to the corresponding
-// Short Weierstrass representation and back, and the methods to do so are exposed as `map_into_swcurve` and
-// `map_from_swcurve`, which each take one argument, the point to be mapped.
-//
-// Curve maps
-// ==========
-// There are a few different ways of mapping Field elements to elliptic curves. Here we provide the simplified
-// Shallue-van de Woestijne-Ulas and Elligator 2 methods, the former being applicable to all curve types
-// provided above subject to the constraint that the coefficients of the corresponding Short Weierstrass curve satisfies
-// a*b != 0 and the latter being applicable to Montgomery and Twisted Edwards curves subject to the constraint that
-// the coefficients of the corresponding Montgomery curve satisfy j*k != 0 and (j^2 - 4)/k^2 is non-square.
-//
-// The simplified Shallue-van de Woestijne-Ulas method is exposed as the method `swu_map` on the Curve configuration and
-// depends on two parameters, a Field element z != -1 for which g(x) - z is irreducible over Field and g(b/(z*a)) is
-// square, where g(x) = x^3 + a*x + b is the right-hand side of the defining equation of the corresponding Short
-// Weierstrass curve, and a Field element u to be mapped onto the curve. For example, in the case of bjj_affine above,
-// it may be determined using the scripts provided at <https://github.com/cfrg/draft-irtf-cfrg-hash-to-curve> that z = 5.
-//
-// The Elligator 2 method is exposed as the method `elligator2_map` on the Curve configurations of Montgomery and
-// Twisted Edwards curves. Like the simplified SWU method above, it depends on a certain non-square element of Field,
-// but this element need not satisfy any further conditions, so it is included as the (Field-dependent) constant
-//`ZETA` below. Thus, the `elligator2_map` method depends only on one parameter, the Field element to be mapped onto
-// the curve.
-//
-// For details on all of the above in the context of hashing to elliptic curves, see <https://datatracker.ietf.org/doc/id/draft-irtf-cfrg-hash-to-curve-06.html>.
-// 
-//
-// *TODO: Replace Field with Bigint.
-// **TODO: Support arrays of structs to make this work.
-// Field-dependent constant ZETA = a non-square element of Field
-// Required for Elligator 2 map
-// TODO: Replace with built-in constant.
-global ZETA = 5;
-// Field-dependent constants for Tonelli-Shanks algorithm (see sqrt function below)
-// TODO: Possibly make this built-in.
-global C1 = 28;
-global C3 = 40770029410420498293352137776570907027550720424234931066070132305055;
-global C5 = 19103219067921713944291392827692070036145651957329286315305642004821462161904;
-// Higher-order version of scalar multiplication
-// TODO: Make this work so that the submodules' bit_mul may be defined in terms of it.
-//fn bit_mul<T,N>(add: fn(T,T) -> T, e: T, bits: [u1; N], p: T) -> T {
-//    let mut out = e;
-//    let n = bits.len();
-// 
-//    for i in 0..n {
-//        out = add(
-//            add(out, out),
-//            if(bits[n - i - 1] == 0) {e} else {p});
-//    }
-// 
-//    out
-//}
-// TODO: Make this built-in.
-pub fn safe_inverse(x: Field) -> Field {
-    if x == 0 { 0 } else { 1 / x }
-}
-// Boolean indicating whether Field element is a square, i.e. whether there exists a y in Field s.t. x = y*y.
-pub fn is_square(x: Field) -> bool {
-    let v = pow(x, 0 - 1 / 2);
-
-    v * (v - 1) == 0
-}
-// Power function of two Field arguments of arbitrary size.
-// Adapted from std::field::pow_32.
-pub fn pow(x: Field, y: Field) -> Field {
-    let mut r = 1 as Field;
-    let b: [u1; 254] = y.to_le_bits();
-
-    for i in 0..254 {
-        r *= r;
-        r *= (b[254 - 1 - i] as Field)*x + (1-b[254 - 1 - i] as Field);
-    }
-
-    r
-}
-// Tonelli-Shanks algorithm for computing the square root of a Field element.
-// Requires C1 = max{c: 2^c divides (p-1)}, where p is the order of Field
-// as well as C3 = (C2 - 1)/2, where C2 = (p-1)/(2^c1),
-// and C5 = ZETA^C2, where ZETA is a non-square element of Field.
-// These are pre-computed above as globals.
-pub fn sqrt(x: Field) -> Field {
-    let mut z = pow(x, C3);
-    let mut t = z * z * x;
-    z *= x;
-    let mut b = t;
-    let mut c = C5;
-
-    for i in 0..(C1 - 1) {
-        for _j in 1..(C1 - i - 1) {
-            b *= b;
-        }
-
-        z *= if b == 1 { 1 } else { c };
-
-        c *= c;
-
-        t *= if b == 1 { 1 } else { c };
-
-        b = t;
-    }
-
-    z
-}
diff --git a/noir_stdlib/src/ec/montcurve.nr b/noir_stdlib/src/ec/montcurve.nr
deleted file mode 100644
index b8077b6b639..00000000000
--- a/noir_stdlib/src/ec/montcurve.nr
+++ /dev/null
@@ -1,380 +0,0 @@
-pub mod affine {
-    // Affine representation of Montgomery curves
-    // Points are represented by two-dimensional Cartesian coordinates.
-    // All group operations are induced by those of the corresponding Twisted Edwards curve.
-    // See e.g. <https://eprint.iacr.org/2017/212.pdf> for details on the correspondences.
-    use crate::ec::montcurve::curvegroup;
-    use crate::ec::swcurve::affine::Curve as SWCurve;
-    use crate::ec::swcurve::affine::Point as SWPoint;
-    use crate::ec::tecurve::affine::Curve as TECurve;
-    use crate::ec::tecurve::affine::Point as TEPoint;
-    use crate::ec::is_square;
-    use crate::ec::safe_inverse;
-    use crate::ec::sqrt;
-    use crate::ec::ZETA;
-    use crate::cmp::Eq;
-
-    // Curve specification
-    pub struct Curve { // Montgomery Curve configuration (ky^2 = x^3 + j*x^2 + x)
-        j: Field,
-        k: Field,
-        // Generator as point in Cartesian coordinates
-        gen: Point
-    }
-    // Point in Cartesian coordinates
-    pub struct Point {
-        x: Field,
-        y: Field,
-        infty: bool // Indicator for point at infinity
-    }
-
-    impl Point {
-        // Point constructor
-        pub fn new(x: Field, y: Field) -> Self {
-            Self { x, y, infty: false }
-        }
-
-        // Check if zero
-        pub fn is_zero(self) -> bool {
-            self.infty
-        }
-
-        // Conversion to CurveGroup coordinates
-        fn into_group(self) -> curvegroup::Point {
-            if self.is_zero() {
-                curvegroup::Point::zero()
-            } else {
-                let (x,y) = (self.x, self.y);
-                curvegroup::Point::new(x, y, 1)
-            }
-        }
-
-        // Additive identity
-        pub fn zero() -> Self {
-            Self { x: 0, y: 0, infty: true }
-        }
-
-        // Negation
-        fn negate(self) -> Self {
-            let Self {x, y, infty} = self;
-
-            Self { x, y: 0 - y, infty }
-        }
-
-        // Map into equivalent Twisted Edwards curve
-        fn into_tecurve(self) -> TEPoint {
-            let Self {x, y, infty} = self;
-
-            if infty | (y * (x + 1) == 0) {
-                TEPoint::zero()
-            } else {
-                TEPoint::new(x / y, (x - 1) / (x + 1))
-            }
-        }
-    }
-
-    impl Eq for Point {
-        fn eq(self, p: Self) -> bool {
-            (self.infty & p.infty) | (!self.infty & !p.infty & (self.x == p.x) & (self.y == p.y))
-        }
-    }
-
-    impl Curve {
-        // Curve constructor
-        pub fn new(j: Field, k: Field, gen: Point) -> Self {
-            // Check curve coefficients
-            assert(k != 0);
-            assert(j * j != 4);
-
-            let curve = Self { j, k, gen };
-
-            // gen should be on the curve
-            assert(curve.contains(curve.gen));
-
-            curve
-        }
-
-        // Conversion to CurveGroup coordinates
-        fn into_group(self) -> curvegroup::Curve {
-            curvegroup::Curve::new(self.j, self.k, self.gen.into_group())
-        }
-
-        // Membership check
-        pub fn contains(self, p: Point) -> bool {
-            let Self {j, k, gen: _gen} = self;
-            let Point {x, y, infty: infty} = p;
-
-            infty | (k * y * y == x * (x * x + j * x + 1))
-        }
-
-        // Point addition
-        pub fn add(self, p1: Point, p2: Point) -> Point {
-            self.into_tecurve().add(p1.into_tecurve(), p2.into_tecurve()).into_montcurve()
-        }
-
-        // Scalar multiplication with scalar represented by a bit array (little-endian convention).
-        // If k is the natural number represented by `bits`, then this computes p + ... + p k times.
-        fn bit_mul<let N: u32>(self, bits: [u1; N], p: Point) -> Point {
-            self.into_tecurve().bit_mul(bits, p.into_tecurve()).into_montcurve()
-        }
-
-        // Scalar multiplication (p + ... + p n times)
-        fn mul(self, n: Field, p: Point) -> Point {
-            self.into_tecurve().mul(n, p.into_tecurve()).into_montcurve()
-        }
-
-        // Multi-scalar multiplication (n[0]*p[0] + ... + n[N]*p[N], where * denotes scalar multiplication)
-        fn msm<let N: u32>(self, n: [Field; N], p: [Point; N]) -> Point {
-            let mut out = Point::zero();
-
-            for i in 0..N {
-                out = self.add(out, self.mul(n[i], p[i]));
-            }
-
-            out
-        }
-
-        // Point subtraction
-        fn subtract(self, p1: Point, p2: Point) -> Point {
-            self.add(p1, p2.negate())
-        }
-
-        // Conversion to equivalent Twisted Edwards curve
-        fn into_tecurve(self) -> TECurve {
-            let Self {j, k, gen} = self;
-            TECurve::new((j + 2) / k, (j - 2) / k, gen.into_tecurve())
-        }
-
-        // Conversion to equivalent Short Weierstrass curve
-        pub fn into_swcurve(self) -> SWCurve {
-            let j = self.j;
-            let k = self.k;
-            let a0 = (3 - j * j) / (3 * k * k);
-            let b0 = (2 * j * j * j - 9 * j) / (27 * k * k * k);
-
-            SWCurve::new(a0, b0, self.map_into_swcurve(self.gen))
-        }
-
-        // Point mapping into equivalent Short Weierstrass curve
-        pub fn map_into_swcurve(self, p: Point) -> SWPoint {
-            if p.is_zero() {
-                SWPoint::zero()
-            } else {
-                SWPoint::new((3 * p.x + self.j) / (3 * self.k), p.y / self.k)
-            }
-        }
-
-        // Point mapping from equivalent Short Weierstrass curve
-        fn map_from_swcurve(self, p: SWPoint) -> Point {
-            let SWPoint {x, y, infty} = p;
-            let j = self.j;
-            let k = self.k;
-
-            Point { x: (3 * k * x - j) / 3, y: y * k, infty }
-        }
-
-        // Elligator 2 map-to-curve method; see <https://datatracker.ietf.org/doc/id/draft-irtf-cfrg-hash-to-curve-06.html#name-elligator-2-method>.
-        fn elligator2_map(self, u: Field) -> Point {
-            let j = self.j;
-            let k = self.k;
-            let z = ZETA; // Non-square Field element required for map
-
-            // Check whether curve is admissible
-            assert(j != 0);
-            let l = (j * j - 4) / (k * k);
-            assert(l != 0);
-            assert(is_square(l) == false);
-
-            let x1 = safe_inverse(1 + z * u * u) * (0 - (j / k));
-
-            let gx1 = x1 * x1 * x1 + (j / k) * x1 * x1 + x1 / (k * k);
-            let x2 = 0 - x1 - (j / k);
-            let gx2 = x2 * x2 * x2 + (j / k) * x2 * x2 + x2 / (k * k);
-
-            let x = if is_square(gx1) { x1 } else { x2 };
-
-            let y = if is_square(gx1) {
-                let y0 = sqrt(gx1);
-                if y0.sgn0() == 1 { y0 } else { 0 - y0 }
-            } else {
-                let y0 = sqrt(gx2);
-                if y0.sgn0() == 0 { y0 } else { 0 - y0 }
-            };
-
-            Point::new(x * k, y * k)
-        }
-
-        // SWU map-to-curve method (via rational map)
-        fn swu_map(self, z: Field, u: Field) -> Point {
-            self.map_from_swcurve(self.into_swcurve().swu_map(z, u))
-        }
-    }
-}
-pub mod curvegroup {
-    // Affine representation of Montgomery curves
-    // Points are represented by three-dimensional projective (homogeneous) coordinates.
-    // All group operations are induced by those of the corresponding Twisted Edwards curve.
-    // See e.g. <https://eprint.iacr.org/2017/212.pdf> for details on the correspondences.
-    use crate::ec::montcurve::affine;
-    use crate::ec::swcurve::curvegroup::Curve as SWCurve;
-    use crate::ec::swcurve::curvegroup::Point as SWPoint;
-    use crate::ec::tecurve::curvegroup::Curve as TECurve;
-    use crate::ec::tecurve::curvegroup::Point as TEPoint;
-    use crate::cmp::Eq;
-
-    pub struct Curve { // Montgomery Curve configuration (ky^2 z = x*(x^2 + j*x*z + z*z))
-        j: Field,
-        k: Field,
-        // Generator as point in projective coordinates
-        gen: Point
-    }
-    // Point in projective coordinates
-    pub struct Point {
-        x: Field,
-        y: Field,
-        z: Field
-    }
-
-    impl Point {
-        // Point constructor
-        pub fn new(x: Field, y: Field, z: Field) -> Self {
-            Self { x, y, z }
-        }
-
-        // Check if zero
-        pub fn is_zero(self) -> bool {
-            self.z == 0
-        }
-
-        // Conversion to affine coordinates
-        fn into_affine(self) -> affine::Point {
-            if self.is_zero() {
-                affine::Point::zero()
-            } else {
-                let (x,y,z) = (self.x, self.y, self.z);
-                affine::Point::new(x / z, y / z)
-            }
-        }
-
-        // Additive identity
-        pub fn zero() -> Self {
-            Self { x: 0, y: 1, z: 0 }
-        }
-
-        // Negation
-        fn negate(self) -> Self {
-            let Self {x, y, z} = self;
-
-            Point::new(x, 0 - y, z)
-        }
-
-        // Map into equivalent Twisted Edwards curve
-        fn into_tecurve(self) -> TEPoint {
-            self.into_affine().into_tecurve().into_group()
-        }
-    }
-
-    impl Eq for Point {
-        fn eq(self, p: Self) -> bool {
-            (self.z == p.z)
-                | (((self.x * self.z) == (p.x * p.z)) & ((self.y * self.z) == (p.y * p.z)))
-        }
-    }
-
-    impl Curve {
-        // Curve constructor
-        pub fn new(j: Field, k: Field, gen: Point) -> Self {
-            // Check curve coefficients
-            assert(k != 0);
-            assert(j * j != 4);
-
-            let curve = Self { j, k, gen };
-
-            // gen should be on the curve
-            assert(curve.contains(curve.gen));
-
-            curve
-        }
-
-        // Conversion to affine coordinates
-        fn into_affine(self) -> affine::Curve {
-            affine::Curve::new(self.j, self.k, self.gen.into_affine())
-        }
-
-        // Membership check
-        pub fn contains(self, p: Point) -> bool {
-            let Self {j, k, gen: _gen} = self;
-            let Point {x, y, z} = p;
-
-            k * y * y * z == x * (x * x + j * x * z + z * z)
-        }
-
-        // Point addition
-        pub fn add(self, p1: Point, p2: Point) -> Point {
-            self.into_affine().add(p1.into_affine(), p2.into_affine()).into_group()
-        }
-
-        // Scalar multiplication with scalar represented by a bit array (little-endian convention).
-        // If k is the natural number represented by `bits`, then this computes p + ... + p k times.
-        fn bit_mul<let N: u32>(self, bits: [u1; N], p: Point) -> Point {
-            self.into_tecurve().bit_mul(bits, p.into_tecurve()).into_montcurve()
-        }
-
-        // Scalar multiplication (p + ... + p n times)
-        pub fn mul(self, n: Field, p: Point) -> Point {
-            self.into_tecurve().mul(n, p.into_tecurve()).into_montcurve()
-        }
-
-        // Multi-scalar multiplication (n[0]*p[0] + ... + n[N]*p[N], where * denotes scalar multiplication)
-        fn msm<let N: u32>(self, n: [Field; N], p: [Point; N]) -> Point {
-            let mut out = Point::zero();
-
-            for i in 0..N {
-                out = self.add(out, self.mul(n[i], p[i]));
-            }
-
-            out
-        }
-
-        // Point subtraction
-        pub fn subtract(self, p1: Point, p2: Point) -> Point {
-            self.add(p1, p2.negate())
-        }
-
-        // Conversion to equivalent Twisted Edwards curve
-        fn into_tecurve(self) -> TECurve {
-            let Self {j, k, gen} = self;
-            TECurve::new((j + 2) / k, (j - 2) / k, gen.into_tecurve())
-        }
-
-        // Conversion to equivalent Short Weierstrass curve
-        fn into_swcurve(self) -> SWCurve {
-            let j = self.j;
-            let k = self.k;
-            let a0 = (3 - j * j) / (3 * k * k);
-            let b0 = (2 * j * j * j - 9 * j) / (27 * k * k * k);
-
-            SWCurve::new(a0, b0, self.map_into_swcurve(self.gen))
-        }
-
-        // Point mapping into equivalent Short Weierstrass curve
-        pub fn map_into_swcurve(self, p: Point) -> SWPoint {
-            self.into_affine().map_into_swcurve(p.into_affine()).into_group()
-        }
-
-        // Point mapping from equivalent Short Weierstrass curve
-        fn map_from_swcurve(self, p: SWPoint) -> Point {
-            self.into_affine().map_from_swcurve(p.into_affine()).into_group()
-        }
-
-        // Elligator 2 map-to-curve method
-        fn elligator2_map(self, u: Field) -> Point {
-            self.into_affine().elligator2_map(u).into_group()
-        }
-
-        // SWU map-to-curve method (via rational map)
-        fn swu_map(self, z: Field, u: Field) -> Point {
-            self.into_affine().swu_map(z, u).into_group()
-        }
-    }
-}
diff --git a/noir_stdlib/src/ec/swcurve.nr b/noir_stdlib/src/ec/swcurve.nr
deleted file mode 100644
index 9c40ddd1adc..00000000000
--- a/noir_stdlib/src/ec/swcurve.nr
+++ /dev/null
@@ -1,386 +0,0 @@
-pub mod affine {
-    // Affine representation of Short Weierstrass curves
-    // Points are represented by two-dimensional Cartesian coordinates.
-    // Group operations are implemented in terms of those in CurveGroup (in this case, extended Twisted Edwards) coordinates
-    // for reasons of efficiency, cf. <https://en.wikibooks.org/wiki/Cryptography/Prime_Curve/Jacobian_Coordinates>.
-    use crate::ec::swcurve::curvegroup;
-    use crate::ec::safe_inverse;
-    use crate::ec::is_square;
-    use crate::ec::sqrt;
-    use crate::cmp::Eq;
-
-    // Curve specification
-    pub struct Curve { // Short Weierstrass curve
-        // Coefficients in defining equation y^2 = x^3 + ax + b
-        a: Field,
-        b: Field,
-        // Generator as point in Cartesian coordinates
-        gen: Point
-    }
-    // Point in Cartesian coordinates
-    pub struct Point {
-        x: Field,
-        y: Field,
-        infty: bool // Indicator for point at infinity
-    }
-
-    impl Point {
-        // Point constructor
-        pub fn new(x: Field, y: Field) -> Self {
-            Self { x, y, infty: false }
-        }
-
-        // Check if zero
-        pub fn is_zero(self) -> bool {
-            self.eq(Point::zero())
-        }
-
-        // Conversion to CurveGroup coordinates
-        fn into_group(self) -> curvegroup::Point {
-            let Self {x, y, infty} = self;
-
-            if infty {
-                curvegroup::Point::zero()
-            } else {
-                curvegroup::Point::new(x, y, 1)
-            }
-        }
-
-        // Additive identity
-        pub fn zero() -> Self {
-            Self { x: 0, y: 0, infty: true }
-        }
-
-        // Negation
-        fn negate(self) -> Self {
-            let Self {x, y, infty} = self;
-            Self { x, y: 0 - y, infty }
-        }
-    }
-
-    impl Eq for Point {
-        fn eq(self, p: Self) -> bool {
-            let Self {x: x1, y: y1, infty: inf1} = self;
-            let Self {x: x2, y: y2, infty: inf2} = p;
-
-            (inf1 & inf2) | (!inf1 & !inf2 & (x1 == x2) & (y1 == y2))
-        }
-    }
-
-    impl Curve {
-        // Curve constructor
-        pub fn new(a: Field, b: Field, gen: Point) -> Curve {
-            // Check curve coefficients
-            assert(4 * a * a * a + 27 * b * b != 0);
-
-            let curve = Curve { a, b, gen };
-
-            // gen should be on the curve
-            assert(curve.contains(curve.gen));
-
-            curve
-        }
-
-        // Conversion to CurveGroup coordinates
-        fn into_group(self) -> curvegroup::Curve {
-            let Curve{a, b, gen} = self;
-
-            curvegroup::Curve { a, b, gen: gen.into_group() }
-        }
-
-        // Membership check
-        pub fn contains(self, p: Point) -> bool {
-            let Point {x, y, infty} = p;
-            infty | (y * y == x * x * x + self.a * x + self.b)
-        }
-
-        // Point addition, implemented in terms of mixed addition for reasons of efficiency
-        pub fn add(self, p1: Point, p2: Point) -> Point {
-            self.mixed_add(p1, p2.into_group()).into_affine()
-        }
-
-        // Mixed point addition, i.e. first argument in affine, second in CurveGroup coordinates.
-        fn mixed_add(self, p1: Point, p2: curvegroup::Point) -> curvegroup::Point {
-            if p1.is_zero() {
-                p2
-            } else if p2.is_zero() {
-                p1.into_group()
-            } else {
-                let Point {x: x1, y: y1, infty: _inf} = p1;
-                let curvegroup::Point {x: x2, y: y2, z: z2} = p2;
-                let you1 = x1 * z2 * z2;
-                let you2 = x2;
-                let s1 = y1 * z2 * z2 * z2;
-                let s2 = y2;
-
-                if you1 == you2 {
-                    if s1 != s2 {
-                        curvegroup::Point::zero()
-                    } else {
-                        self.into_group().double(p2)
-                    }
-                } else {
-                    let h = you2 - you1;
-                    let r = s2 - s1;
-                    let x3 = r * r - h * h * h - 2 * you1 * h * h;
-                    let y3 = r * (you1 * h * h - x3) - s1 * h * h * h;
-                    let z3 = h * z2;
-
-                    curvegroup::Point::new(x3, y3, z3)
-                }
-            }
-        }
-
-        // Scalar multiplication with scalar represented by a bit array (little-endian convention).
-        // If k is the natural number represented by `bits`, then this computes p + ... + p k times.
-        fn bit_mul<let N: u32>(self, bits: [u1; N], p: Point) -> Point {
-            self.into_group().bit_mul(bits, p.into_group()).into_affine()
-        }
-
-        // Scalar multiplication (p + ... + p n times)
-        pub fn mul(self, n: Field, p: Point) -> Point {
-            self.into_group().mul(n, p.into_group()).into_affine()
-        }
-
-        // Multi-scalar multiplication (n[0]*p[0] + ... + n[N]*p[N], where * denotes scalar multiplication)
-        pub fn msm<let N: u32>(self, n: [Field; N], p: [Point; N]) -> Point {
-            let mut out = Point::zero();
-
-            for i in 0..N {
-                out = self.add(out, self.mul(n[i], p[i]));
-            }
-
-            out
-        }
-
-        // Point subtraction
-        pub fn subtract(self, p1: Point, p2: Point) -> Point {
-            self.add(p1, p2.negate())
-        }
-
-        // Simplified Shallue-van de Woestijne-Ulas map-to-curve method; see <https://www.ietf.org/archive/id/draft-irtf-cfrg-hash-to-curve-16.html#name-simplified-shallue-van-de-w>.
-        // First determine non-square z != -1 in Field s.t. g(x) - z irreducible over Field and g(b/(z*a)) is square,
-        // where g(x) = x^3 + a*x + b. swu_map(c,z,.) then maps a Field element to a point on curve c.
-        fn swu_map(self, z: Field, u: Field) -> Point {
-            // Check whether curve is admissible
-            assert(self.a * self.b != 0);
-
-            let Curve {a, b, gen: _gen} = self;
-
-            let tv1 = safe_inverse(z * z * u * u * u * u + u * u * z);
-            let x1 = if tv1 == 0 {
-                b / (z * a)
-            } else {
-                (0 - b / a) * (1 + tv1)
-            };
-            let gx1 = x1 * x1 * x1 + a * x1 + b;
-            let x2 = z * u * u * x1;
-            let gx2 = x2 * x2 * x2 + a * x2 + b;
-            let (x,y) = if is_square(gx1) {
-                (x1, sqrt(gx1))
-            } else {
-                (x2, sqrt(gx2))
-            };
-            Point::new(x, if u.sgn0() != y.sgn0() { 0 - y } else { y })
-        }
-    }
-}
-
-pub mod curvegroup {
-    // CurveGroup representation of Weierstrass curves
-    // Points are represented by three-dimensional Jacobian coordinates.
-    // See <https://en.wikibooks.org/wiki/Cryptography/Prime_Curve/Jacobian_Coordinates> for details.
-    use crate::ec::swcurve::affine;
-    use crate::cmp::Eq;
-
-    // Curve specification
-    pub struct Curve { // Short Weierstrass curve
-        // Coefficients in defining equation y^2 = x^3 + axz^4 + bz^6
-        a: Field,
-        b: Field,
-        // Generator as point in Cartesian coordinates
-        gen: Point
-    }
-    // Point in three-dimensional Jacobian coordinates
-    pub struct Point {
-        x: Field,
-        y: Field,
-        z: Field // z = 0 corresponds to point at infinity.
-    }
-
-    impl Point {
-        // Point constructor
-        pub fn new(x: Field, y: Field, z: Field) -> Self {
-            Self { x, y, z }
-        }
-
-        // Check if zero
-        pub fn is_zero(self) -> bool {
-            self.eq(Point::zero())
-        }
-
-        // Conversion to affine coordinates
-        pub fn into_affine(self) -> affine::Point {
-            let Self {x, y, z} = self;
-
-            if z == 0 {
-                affine::Point::zero()
-            } else {
-                affine::Point::new(x / (z * z), y / (z * z * z))
-            }
-        }
-
-        // Additive identity
-        pub fn zero() -> Self {
-            Self { x: 0, y: 0, z: 0 }
-        }
-
-        // Negation
-        fn negate(self) -> Self {
-            let Self {x, y, z} = self;
-            Self { x, y: 0 - y, z }
-        }
-    }
-
-    impl Eq for Point {
-        fn eq(self, p: Self) -> bool {
-            let Self {x: x1, y: y1, z: z1} = self;
-            let Self {x: x2, y: y2, z: z2} = p;
-
-            ((z1 == 0) & (z2 == 0)) | ((z1 != 0)
-                    & (z2 != 0)
-                    & (x1 * z2 * z2 == x2 * z1 * z1)
-                    & (y1 * z2 * z2 * z2 == y2 * z1 * z1 * z1))
-        }
-    }
-
-    impl Curve {
-        // Curve constructor
-        pub fn new(a: Field, b: Field, gen: Point) -> Curve {
-            // Check curve coefficients
-            assert(4 * a * a * a + 27 * b * b != 0);
-
-            let curve = Curve { a, b, gen };
-
-            // gen should be on the curve
-            assert(curve.contains(curve.gen));
-
-            curve
-        }
-
-        // Conversion to affine coordinates
-        pub fn into_affine(self) -> affine::Curve {
-            let Curve{a, b, gen} = self;
-
-            affine::Curve { a, b, gen: gen.into_affine() }
-        }
-
-        // Membership check
-        pub fn contains(self, p: Point) -> bool {
-            let Point {x, y, z} = p;
-            if z == 0 {
-                true
-            } else {
-                y * y == x * x * x + self.a * x * z * z * z * z + self.b * z * z * z * z * z * z
-            }
-        }
-
-        // Addition
-        pub fn add(self, p1: Point, p2: Point) -> Point {
-            if p1.is_zero() {
-                p2
-            } else if p2.is_zero() {
-                p1
-            } else {
-                let Point {x: x1, y: y1, z: z1} = p1;
-                let Point {x: x2, y: y2, z: z2} = p2;
-                let you1 = x1 * z2 * z2;
-                let you2 = x2 * z1 * z1;
-                let s1 = y1 * z2 * z2 * z2;
-                let s2 = y2 * z1 * z1 * z1;
-
-                if you1 == you2 {
-                    if s1 != s2 {
-                        Point::zero()
-                    } else {
-                        self.double(p1)
-                    }
-                } else {
-                    let h = you2 - you1;
-                    let r = s2 - s1;
-                    let x3 = r * r - h * h * h - 2 * you1 * h * h;
-                    let y3 = r * (you1 * h * h - x3) - s1 * h * h * h;
-                    let z3 = h * z1 * z2;
-
-                    Point::new(x3, y3, z3)
-                }
-            }
-        }
-
-        // Point doubling
-        pub fn double(self, p: Point) -> Point {
-            let Point {x, y, z} = p;
-
-            if p.is_zero() {
-                p
-            } else if y == 0 {
-                Point::zero()
-            } else {
-                let s = 4 * x * y * y;
-                let m = 3 * x * x + self.a * z * z * z * z;
-                let x0 = m * m - 2 * s;
-                let y0 = m * (s - x0) - 8 * y * y * y * y;
-                let z0 = 2 * y * z;
-
-                Point::new(x0, y0, z0)
-            }
-        }
-
-        // Scalar multiplication with scalar represented by a bit array (little-endian convention).
-        // If k is the natural number represented by `bits`, then this computes p + ... + p k times.
-        fn bit_mul<let N: u32>(self, bits: [u1; N], p: Point) -> Point {
-            let mut out = Point::zero();
-
-            for i in 0..N {
-                out = self.add(
-                    self.add(out, out),
-                    if(bits[N - i - 1] == 0) {Point::zero()} else {p});
-            }
-
-            out
-        }
-
-        // Scalar multiplication (p + ... + p n times)
-        pub fn mul(self, n: Field, p: Point) -> Point {
-            // TODO: temporary workaround until issue 1354 is solved
-            let mut n_as_bits: [u1; 254] = [0; 254];
-            let tmp: [u1; 254] = n.to_le_bits();
-            for i in 0..254 {
-                n_as_bits[i] = tmp[i];
-            }
-
-            self.bit_mul(n_as_bits, p)
-        }
-
-        // Multi-scalar multiplication (n[0]*p[0] + ... + n[N]*p[N], where * denotes scalar multiplication)
-        fn msm<let N: u32>(self, n: [Field; N], p: [Point; N]) -> Point {
-            let mut out = Point::zero();
-
-            for i in 0..N {
-                out = self.add(out, self.mul(n[i], p[i]));
-            }
-
-            out
-        }
-
-        // Point subtraction
-        pub fn subtract(self, p1: Point, p2: Point) -> Point {
-            self.add(p1, p2.negate())
-        }
-
-        // Simplified SWU map-to-curve method
-        fn swu_map(self, z: Field, u: Field) -> Point {
-            self.into_affine().swu_map(z, u).into_group()
-        }
-    }
-}
diff --git a/noir_stdlib/src/ec/tecurve.nr b/noir_stdlib/src/ec/tecurve.nr
deleted file mode 100644
index c37b7c94a54..00000000000
--- a/noir_stdlib/src/ec/tecurve.nr
+++ /dev/null
@@ -1,414 +0,0 @@
-pub mod affine {
-    // Affine coordinate representation of Twisted Edwards curves
-    // Points are represented by two-dimensional Cartesian coordinates.
-    // Group operations are implemented in terms of those in CurveGroup (in this case, extended Twisted Edwards) coordinates
-    // for reasons of efficiency.
-    // See <https://eprint.iacr.org/2008/522.pdf> for details.
-    use crate::ec::tecurve::curvegroup;
-    use crate::ec::montcurve::affine::Curve as MCurve;
-    use crate::ec::montcurve::affine::Point as MPoint;
-    use crate::ec::swcurve::affine::Curve as SWCurve;
-    use crate::ec::swcurve::affine::Point as SWPoint;
-    use crate::cmp::Eq;
-
-    // Curve specification
-    pub struct Curve { // Twisted Edwards curve
-        // Coefficients in defining equation ax^2 + y^2 = 1 + dx^2y^2
-        a: Field,
-        d: Field,
-        // Generator as point in Cartesian coordinates
-        gen: Point
-    }
-    // Point in Cartesian coordinates
-    pub struct Point {
-        x: Field,
-        y: Field
-    }
-
-    impl Point {
-        // Point constructor
-        #[deprecated = "It's recommmended to use the external noir-edwards library (https://github.com/noir-lang/noir-edwards)"]
-        pub fn new(x: Field, y: Field) -> Self {
-            Self { x, y }
-        }
-
-        // Check if zero
-        pub fn is_zero(self) -> bool {
-            self.eq(Point::zero())
-        }
-
-        // Conversion to CurveGroup coordinates
-        fn into_group(self) -> curvegroup::Point {
-            let Self {x, y} = self;
-
-            curvegroup::Point::new(x, y, x * y, 1)
-        }
-
-        // Additive identity
-        pub fn zero() -> Self {
-            Point::new(0, 1)
-        }
-
-        // Negation
-        fn negate(self) -> Self {
-            let Self {x, y} = self;
-            Point::new(0 - x, y)
-        }
-
-        // Map into prime-order subgroup of equivalent Montgomery curve
-        fn into_montcurve(self) -> MPoint {
-            if self.is_zero() {
-                MPoint::zero()
-            } else {
-                let Self {x, y} = self;
-                let x0 = (1 + y) / (1 - y);
-                let y0 = (1 + y) / (x * (1 - y));
-
-                MPoint::new(x0, y0)
-            }
-        }
-    }
-
-    impl Eq for Point {
-        fn eq(self, p: Self) -> bool {
-            let Self {x: x1, y: y1} = self;
-            let Self {x: x2, y: y2} = p;
-
-            (x1 == x2) & (y1 == y2)
-        }
-    }
-
-    impl Curve {
-        // Curve constructor
-        pub fn new(a: Field, d: Field, gen: Point) -> Curve {
-            // Check curve coefficients
-            assert(a * d * (a - d) != 0);
-
-            let curve = Curve { a, d, gen };
-
-            // gen should be on the curve
-            assert(curve.contains(curve.gen));
-
-            curve
-        }
-
-        // Conversion to CurveGroup coordinates
-        fn into_group(self) -> curvegroup::Curve {
-            let Curve{a, d, gen} = self;
-
-            curvegroup::Curve { a, d, gen: gen.into_group() }
-        }
-
-        // Membership check
-        pub fn contains(self, p: Point) -> bool {
-            let Point {x, y} = p;
-            self.a * x * x + y * y == 1 + self.d * x * x * y * y
-        }
-
-        // Point addition, implemented in terms of mixed addition for reasons of efficiency
-        pub fn add(self, p1: Point, p2: Point) -> Point {
-            self.mixed_add(p1, p2.into_group()).into_affine()
-        }
-
-        // Mixed point addition, i.e. first argument in affine, second in CurveGroup coordinates.
-        fn mixed_add(self, p1: Point, p2: curvegroup::Point) -> curvegroup::Point {
-            let Point{x: x1, y: y1} = p1;
-            let curvegroup::Point{x: x2, y: y2, t: t2, z: z2} = p2;
-
-            let a = x1 * x2;
-            let b = y1 * y2;
-            let c = self.d * x1 * y1 * t2;
-            let e = (x1 + y1) * (x2 + y2) - a - b;
-            let f = z2 - c;
-            let g = z2 + c;
-            let h = b - self.a * a;
-
-            let x = e * f;
-            let y = g * h;
-            let t = e * h;
-            let z = f * g;
-
-            curvegroup::Point::new(x, y, t, z)
-        }
-
-        // Scalar multiplication with scalar represented by a bit array (little-endian convention).
-        // If k is the natural number represented by `bits`, then this computes p + ... + p k times.
-        fn bit_mul<let N: u32>(self, bits: [u1; N], p: Point) -> Point {
-            self.into_group().bit_mul(bits, p.into_group()).into_affine()
-        }
-
-        // Scalar multiplication (p + ... + p n times)
-        fn mul(self, n: Field, p: Point) -> Point {
-            self.into_group().mul(n, p.into_group()).into_affine()
-        }
-
-        // Multi-scalar multiplication (n[0]*p[0] + ... + n[N]*p[N], where * denotes scalar multiplication)
-        fn msm<let N: u32>(self, n: [Field; N], p: [Point; N]) -> Point {
-            let mut out = Point::zero();
-
-            for i in 0..N {
-                out = self.add(out, self.mul(n[i], p[i]));
-            }
-
-            out
-        }
-
-        // Point subtraction
-        fn subtract(self, p1: Point, p2: Point) -> Point {
-            self.add(p1, p2.negate())
-        }
-
-        // Conversion to equivalent Montgomery curve
-        pub fn into_montcurve(self) -> MCurve {
-            let j = 2 * (self.a + self.d) / (self.a - self.d);
-            let k = 4 / (self.a - self.d);
-            let gen_montcurve = self.gen.into_montcurve();
-
-            MCurve::new(j, k, gen_montcurve)
-        }
-
-        // Conversion to equivalent Short Weierstrass curve
-        pub fn into_swcurve(self) -> SWCurve {
-            self.into_montcurve().into_swcurve()
-        }
-
-        // Point mapping into equivalent Short Weierstrass curve
-        pub fn map_into_swcurve(self, p: Point) -> SWPoint {
-            self.into_montcurve().map_into_swcurve(p.into_montcurve())
-        }
-
-        // Point mapping from equivalent Short Weierstrass curve
-        fn map_from_swcurve(self, p: SWPoint) -> Point {
-            self.into_montcurve().map_from_swcurve(p).into_tecurve()
-        }
-
-        // Elligator 2 map-to-curve method (via rational map)
-        fn elligator2_map(self, u: Field) -> Point {
-            self.into_montcurve().elligator2_map(u).into_tecurve()
-        }
-
-        // Simplified SWU map-to-curve method (via rational map)
-        fn swu_map(self, z: Field, u: Field) -> Point {
-            self.into_montcurve().swu_map(z, u).into_tecurve()
-        }
-    }
-}
-pub mod curvegroup {
-    // CurveGroup coordinate representation of Twisted Edwards curves
-    // Points are represented by four-dimensional projective coordinates, viz. extended Twisted Edwards coordinates.
-    // See section 3 of <https://eprint.iacr.org/2008/522.pdf> for details.
-    use crate::ec::tecurve::affine;
-    use crate::ec::montcurve::curvegroup::Curve as MCurve;
-    use crate::ec::montcurve::curvegroup::Point as MPoint;
-    use crate::ec::swcurve::curvegroup::Curve as SWCurve;
-    use crate::ec::swcurve::curvegroup::Point as SWPoint;
-    use crate::cmp::Eq;
-
-    // Curve specification
-    pub struct Curve { // Twisted Edwards curve
-        // Coefficients in defining equation a(x^2 + y^2)z^2 = z^4 + dx^2y^2
-        a: Field,
-        d: Field,
-        // Generator as point in projective coordinates
-        gen: Point
-    }
-    // Point in extended twisted Edwards coordinates
-    pub struct Point {
-        x: Field,
-        y: Field,
-        t: Field,
-        z: Field
-    }
-
-    impl Point {
-        // Point constructor
-        pub fn new(x: Field, y: Field, t: Field, z: Field) -> Self {
-            Self { x, y, t, z }
-        }
-
-        // Check if zero
-        pub fn is_zero(self) -> bool {
-            let Self {x, y, t, z} = self;
-            (x == 0) & (y == z) & (y != 0) & (t == 0)
-        }
-
-        // Conversion to affine coordinates
-        pub fn into_affine(self) -> affine::Point {
-            let Self {x, y, t: _t, z} = self;
-
-            affine::Point::new(x / z, y / z)
-        }
-
-        // Additive identity
-        pub fn zero() -> Self {
-            Point::new(0, 1, 0, 1)
-        }
-
-        // Negation
-        fn negate(self) -> Self {
-            let Self {x, y, t, z} = self;
-
-            Point::new(0 - x, y, 0 - t, z)
-        }
-
-        // Map into prime-order subgroup of equivalent Montgomery curve
-        fn into_montcurve(self) -> MPoint {
-            self.into_affine().into_montcurve().into_group()
-        }
-    }
-
-    impl Eq for Point {
-        fn eq(self, p: Self) -> bool {
-            let Self {x: x1, y: y1, t: _t1, z: z1} = self;
-            let Self {x: x2, y: y2, t: _t2, z:z2} = p;
-
-            (x1 * z2 == x2 * z1) & (y1 * z2 == y2 * z1)
-        }
-    }
-
-    impl Curve {
-        // Curve constructor
-        pub fn new(a: Field, d: Field, gen: Point) -> Curve {
-            // Check curve coefficients
-            assert(a * d * (a - d) != 0);
-
-            let curve = Curve { a, d, gen };
-
-            // gen should be on the curve
-            assert(curve.contains(curve.gen));
-
-            curve
-        }
-
-        // Conversion to affine coordinates
-        pub fn into_affine(self) -> affine::Curve {
-            let Curve{a, d, gen} = self;
-
-            affine::Curve { a, d, gen: gen.into_affine() }
-        }
-
-        // Membership check
-        pub fn contains(self, p: Point) -> bool {
-            let Point {x, y, t, z} = p;
-
-            (z != 0)
-                & (z * t == x * y)
-                & (z * z * (self.a * x * x + y * y) == z * z * z * z + self.d * x * x * y * y)
-        }
-
-        // Point addition
-        pub fn add(self, p1: Point, p2: Point) -> Point {
-            let Point{x: x1, y: y1, t: t1, z: z1} = p1;
-            let Point{x: x2, y: y2, t: t2, z: z2} = p2;
-
-            let a = x1 * x2;
-            let b = y1 * y2;
-            let c = self.d * t1 * t2;
-            let d = z1 * z2;
-            let e = (x1 + y1) * (x2 + y2) - a - b;
-            let f = d - c;
-            let g = d + c;
-            let h = b - self.a * a;
-
-            let x = e * f;
-            let y = g * h;
-            let t = e * h;
-            let z = f * g;
-
-            Point::new(x, y, t, z)
-        }
-
-        // Point doubling, cf. section 3.3
-        pub fn double(self, p: Point) -> Point {
-            let Point{x, y, t: _t, z} = p;
-
-            let a = x * x;
-            let b = y * y;
-            let c = 2 * z * z;
-            let d = self.a * a;
-            let e = (x + y) * (x + y) - a - b;
-            let g = d + b;
-            let f = g - c;
-            let h = d - b;
-
-            let x0 = e * f;
-            let y0 = g * h;
-            let t0 = e * h;
-            let z0 = f * g;
-
-            Point::new(x0, y0, t0, z0)
-        }
-
-        // Scalar multiplication with scalar represented by a bit array (little-endian convention).
-        // If k is the natural number represented by `bits`, then this computes p + ... + p k times.
-        fn bit_mul<let N: u32>(self, bits: [u1; N], p: Point) -> Point {
-            let mut out = Point::zero();
-
-            for i in 0..N {
-                out = self.add(
-                    self.add(out, out),
-                    if(bits[N - i - 1] == 0) {Point::zero()} else {p});
-            }
-
-            out
-        }
-
-        // Scalar multiplication (p + ... + p n times)
-        pub fn mul(self, n: Field, p: Point) -> Point {
-            // TODO: temporary workaround until issue 1354 is solved
-            let mut n_as_bits: [u1; 254] = [0; 254];
-            let tmp: [u1; 254] = n.to_le_bits();
-            for i in 0..254 {
-                n_as_bits[i] = tmp[i];
-            }
-
-            self.bit_mul(n_as_bits, p)
-        }
-
-        // Multi-scalar multiplication (n[0]*p[0] + ... + n[N]*p[N], where * denotes scalar multiplication)
-        fn msm<let N: u32>(self, n: [Field; N], p: [Point; N]) -> Point {
-            let mut out = Point::zero();
-
-            for i in 0..N {
-                out = self.add(out, self.mul(n[i], p[i]));
-            }
-
-            out
-        }
-
-        // Point subtraction
-        fn subtract(self, p1: Point, p2: Point) -> Point {
-            self.add(p1, p2.negate())
-        }
-
-        // Conversion to equivalent Montgomery curve
-        fn into_montcurve(self) -> MCurve {
-            self.into_affine().into_montcurve().into_group()
-        }
-
-        // Conversion to equivalent Short Weierstrass curve
-        fn into_swcurve(self) -> SWCurve {
-            self.into_montcurve().into_swcurve()
-        }
-
-        // Point mapping into equivalent short Weierstrass curve
-        pub fn map_into_swcurve(self, p: Point) -> SWPoint {
-            self.into_montcurve().map_into_swcurve(p.into_montcurve())
-        }
-
-        // Point mapping from equivalent short Weierstrass curve
-        fn map_from_swcurve(self, p: SWPoint) -> Point {
-            self.into_montcurve().map_from_swcurve(p).into_tecurve()
-        }
-
-        // Elligator 2 map-to-curve method (via rational maps)
-        fn elligator2_map(self, u: Field) -> Point {
-            self.into_montcurve().elligator2_map(u).into_tecurve()
-        }
-
-        // Simplified SWU map-to-curve method (via rational map)
-        fn swu_map(self, z: Field, u: Field) -> Point {
-            self.into_montcurve().swu_map(z, u).into_tecurve()
-        }
-    }
-}
diff --git a/noir_stdlib/src/ecdsa_secp256k1.nr b/noir_stdlib/src/ecdsa_secp256k1.nr
index 8a70184dca8..ec39e999715 100644
--- a/noir_stdlib/src/ecdsa_secp256k1.nr
+++ b/noir_stdlib/src/ecdsa_secp256k1.nr
@@ -4,7 +4,7 @@ pub fn verify_signature<let N: u32>(
     public_key_x: [u8; 32],
     public_key_y: [u8; 32],
     signature: [u8; 64],
-    message_hash: [u8; N]
+    message_hash: [u8; N],
 ) -> bool
 // docs:end:ecdsa_secp256k1
 {}
@@ -15,7 +15,7 @@ pub fn verify_signature_slice(
     public_key_x: [u8; 32],
     public_key_y: [u8; 32],
     signature: [u8; 64],
-    message_hash: [u8]
+    message_hash: [u8],
 ) -> bool
 // docs:end:ecdsa_secp256k1_slice
 {}
diff --git a/noir_stdlib/src/ecdsa_secp256r1.nr b/noir_stdlib/src/ecdsa_secp256r1.nr
index 8772fa7c2ca..c7905b24f6f 100644
--- a/noir_stdlib/src/ecdsa_secp256r1.nr
+++ b/noir_stdlib/src/ecdsa_secp256r1.nr
@@ -4,7 +4,7 @@ pub fn verify_signature<let N: u32>(
     public_key_x: [u8; 32],
     public_key_y: [u8; 32],
     signature: [u8; 64],
-    message_hash: [u8; N]
+    message_hash: [u8; N],
 ) -> bool
 // docs:end:ecdsa_secp256r1
 {}
@@ -15,7 +15,7 @@ pub fn verify_signature_slice(
     public_key_x: [u8; 32],
     public_key_y: [u8; 32],
     signature: [u8; 64],
-    message_hash: [u8]
+    message_hash: [u8],
 ) -> bool
 // docs:end:ecdsa_secp256r1_slice
 {}
diff --git a/noir_stdlib/src/eddsa.nr b/noir_stdlib/src/eddsa.nr
deleted file mode 100644
index cfdbbe9c3d0..00000000000
--- a/noir_stdlib/src/eddsa.nr
+++ /dev/null
@@ -1,74 +0,0 @@
-use crate::ec::consts::te::baby_jubjub;
-use crate::ec::tecurve::affine::Point as TEPoint;
-use crate::hash::Hasher;
-use crate::hash::poseidon::PoseidonHasher;
-use crate::default::Default;
-
-// Returns true if signature is valid
-pub fn eddsa_poseidon_verify(
-    pub_key_x: Field,
-    pub_key_y: Field,
-    signature_s: Field,
-    signature_r8_x: Field,
-    signature_r8_y: Field,
-    message: Field
-) -> bool {
-    eddsa_verify::<PoseidonHasher>(
-        pub_key_x,
-        pub_key_y,
-        signature_s,
-        signature_r8_x,
-        signature_r8_y,
-        message
-    )
-}
-
-pub fn eddsa_verify<H>(
-    pub_key_x: Field,
-    pub_key_y: Field,
-    signature_s: Field,
-    signature_r8_x: Field,
-    signature_r8_y: Field,
-    message: Field
-) -> bool 
-where H: Hasher + Default {
-    // Verifies by testing:
-    // S * B8 = R8 + H(R8, A, m) * A8
-    let bjj = baby_jubjub();
-
-    let pub_key = TEPoint::new(pub_key_x, pub_key_y);
-    assert(bjj.curve.contains(pub_key));
-
-    let signature_r8 = TEPoint::new(signature_r8_x, signature_r8_y);
-    assert(bjj.curve.contains(signature_r8));
-    // Ensure S < Subgroup Order
-    assert(signature_s.lt(bjj.suborder));
-    // Calculate the h = H(R, A, msg)
-    let mut hasher = H::default();
-    hasher.write(signature_r8_x);
-    hasher.write(signature_r8_y);
-    hasher.write(pub_key_x);
-    hasher.write(pub_key_y);
-    hasher.write(message);
-    let hash: Field = hasher.finish();
-    // Calculate second part of the right side:  right2 = h*8*A
-    // Multiply by 8 by doubling 3 times. This also ensures that the result is in the subgroup.
-    let pub_key_mul_2 = bjj.curve.add(pub_key, pub_key);
-    let pub_key_mul_4 = bjj.curve.add(pub_key_mul_2, pub_key_mul_2);
-    let pub_key_mul_8 = bjj.curve.add(pub_key_mul_4, pub_key_mul_4);
-    // We check that A8 is not zero.
-    assert(!pub_key_mul_8.is_zero());
-    // Compute the right side: R8 + h * A8
-    let right = bjj.curve.add(signature_r8, bjj.curve.mul(hash, pub_key_mul_8));
-    // Calculate left side of equation left = S * B8
-    let left = bjj.curve.mul(signature_s, bjj.base8);
-
-    left.eq(right)
-}
-
-// Returns the public key of the given secret key as (pub_key_x, pub_key_y)
-pub fn eddsa_to_pub(secret: Field) -> (Field, Field) {
-    let bjj = baby_jubjub();
-    let pub_key = bjj.curve.mul(secret, bjj.curve.gen);
-    (pub_key.x, pub_key.y)
-}
diff --git a/noir_stdlib/src/embedded_curve_ops.nr b/noir_stdlib/src/embedded_curve_ops.nr
index 445b6d96554..6b225ee18b2 100644
--- a/noir_stdlib/src/embedded_curve_ops.nr
+++ b/noir_stdlib/src/embedded_curve_ops.nr
@@ -1,24 +1,24 @@
-use crate::ops::arith::{Add, Sub, Neg};
 use crate::cmp::Eq;
+use crate::ops::arith::{Add, Neg, Sub};
 
 /// A point on the embedded elliptic curve
 /// By definition, the base field of the embedded curve is the scalar field of the proof system curve, i.e the Noir Field.
 /// x and y denotes the Weierstrass coordinates of the point, if is_infinite is false.
 pub struct EmbeddedCurvePoint {
-    x: Field,
-    y: Field,
-    is_infinite: bool
+    pub x: Field,
+    pub y: Field,
+    pub is_infinite: bool,
 }
 
 impl EmbeddedCurvePoint {
     /// Elliptic curve point doubling operation
     /// returns the doubled point of a point P, i.e P+P
-    fn double(self) -> EmbeddedCurvePoint {
+    pub fn double(self) -> EmbeddedCurvePoint {
         embedded_curve_add(self, self)
     }
 
     /// Returns the null element of the curve; 'the point at infinity'
-    fn point_at_infinity() -> EmbeddedCurvePoint {
+    pub fn point_at_infinity() -> EmbeddedCurvePoint {
         EmbeddedCurvePoint { x: 0, y: 0, is_infinite: true }
     }
 }
@@ -57,8 +57,8 @@ impl Eq for EmbeddedCurvePoint {
 /// By definition, the scalar field of the embedded curve is base field of the proving system curve.
 /// It may not fit into a Field element, so it is represented with two Field elements; its low and high limbs.
 pub struct EmbeddedCurveScalar {
-    lo: Field,
-    hi: Field,
+    pub lo: Field,
+    pub hi: Field,
 }
 
 impl EmbeddedCurveScalar {
@@ -67,20 +67,20 @@ impl EmbeddedCurveScalar {
     }
 
     #[field(bn254)]
-    fn from_field(scalar: Field) -> EmbeddedCurveScalar {
-        let (a,b) = crate::field::bn254::decompose(scalar);
+    pub fn from_field(scalar: Field) -> EmbeddedCurveScalar {
+        let (a, b) = crate::field::bn254::decompose(scalar);
         EmbeddedCurveScalar { lo: a, hi: b }
     }
 
     //Bytes to scalar: take the first (after the specified offset) 16 bytes of the input as the lo value, and the next 16 bytes as the hi value
     #[field(bn254)]
-    fn from_bytes(bytes: [u8; 64], offset: u32) -> EmbeddedCurveScalar {
+    pub(crate) fn from_bytes(bytes: [u8; 64], offset: u32) -> EmbeddedCurveScalar {
         let mut v = 1;
         let mut lo = 0 as Field;
         let mut hi = 0 as Field;
         for i in 0..16 {
-            lo = lo + (bytes[offset+31 - i] as Field) * v;
-            hi = hi + (bytes[offset+15 - i] as Field) * v;
+            lo = lo + (bytes[offset + 31 - i] as Field) * v;
+            hi = hi + (bytes[offset + 15 - i] as Field) * v;
             v = v * 256;
         }
         let sig_s = crate::embedded_curve_ops::EmbeddedCurveScalar { lo, hi };
@@ -98,12 +98,12 @@ impl Eq for EmbeddedCurveScalar {
 // For bn254, We have Grumpkin and Baby JubJub.
 // For bls12-381, we have JubJub and Bandersnatch.
 //
-// The embedded curve being used is decided by the 
+// The embedded curve being used is decided by the
 // underlying proof system.
 // docs:start:multi_scalar_mul
 pub fn multi_scalar_mul<let N: u32>(
     points: [EmbeddedCurvePoint; N],
-    scalars: [EmbeddedCurveScalar; N]
+    scalars: [EmbeddedCurveScalar; N],
 ) -> EmbeddedCurvePoint
 // docs:end:multi_scalar_mul
 {
@@ -112,16 +112,20 @@ pub fn multi_scalar_mul<let N: u32>(
 }
 
 #[foreign(multi_scalar_mul)]
-fn multi_scalar_mul_array_return<let N: u32>(points: [EmbeddedCurvePoint; N], scalars: [EmbeddedCurveScalar; N]) -> [Field; 3] {}
-
-#[foreign(multi_scalar_mul)]
-pub(crate) fn multi_scalar_mul_slice(points: [EmbeddedCurvePoint], scalars: [EmbeddedCurveScalar]) -> [Field; 3] {}
+pub(crate) fn multi_scalar_mul_array_return<let N: u32>(
+    points: [EmbeddedCurvePoint; N],
+    scalars: [EmbeddedCurveScalar; N],
+) -> [Field; 3] {}
 
 // docs:start:fixed_base_scalar_mul
 pub fn fixed_base_scalar_mul(scalar: EmbeddedCurveScalar) -> EmbeddedCurvePoint
 // docs:end:fixed_base_scalar_mul
 {
-    let g1 = EmbeddedCurvePoint { x: 1, y: 17631683881184975370165255887551781615748388533673675138860, is_infinite: false };
+    let g1 = EmbeddedCurvePoint {
+        x: 1,
+        y: 17631683881184975370165255887551781615748388533673675138860,
+        is_infinite: false,
+    };
     multi_scalar_mul([g1], [scalar])
 }
 
@@ -130,13 +134,20 @@ pub fn fixed_base_scalar_mul(scalar: EmbeddedCurveScalar) -> EmbeddedCurvePoint
 // This is a hack because returning an `EmbeddedCurvePoint` from a foreign function in brillig returns a [BrilligVariable::SingleAddr; 2] rather than BrilligVariable::BrilligArray
 // as is defined in the brillig bytecode format. This is a workaround which allows us to fix this without modifying the serialization format.
 // docs:start:embedded_curve_add
-pub fn embedded_curve_add(point1: EmbeddedCurvePoint, point2: EmbeddedCurvePoint) -> EmbeddedCurvePoint {
+pub fn embedded_curve_add(
+    point1: EmbeddedCurvePoint,
+    point2: EmbeddedCurvePoint,
+) -> EmbeddedCurvePoint {
     // docs:end:embedded_curve_add
     let x_coordinates_match = point1.x == point2.x;
     let y_coordinates_match = point1.y == point2.y;
     let double_predicate = (x_coordinates_match & y_coordinates_match);
     let infinity_predicate = (x_coordinates_match & !y_coordinates_match);
-    let point1_1 = EmbeddedCurvePoint { x: point1.x + (x_coordinates_match as Field), y: point1.y, is_infinite: x_coordinates_match };
+    let point1_1 = EmbeddedCurvePoint {
+        x: point1.x + (x_coordinates_match as Field),
+        y: point1.y,
+        is_infinite: x_coordinates_match,
+    };
     // point1_1 is guaranteed to have a different abscissa than point2
     let mut result = embedded_curve_add_unsafe(point1_1, point2);
     result.is_infinite = x_coordinates_match;
@@ -147,7 +158,7 @@ pub fn embedded_curve_add(point1: EmbeddedCurvePoint, point2: EmbeddedCurvePoint
 
     // infinity if x_match, !y_match
     if point1.is_infinite {
-        result= point2;
+        result = point2;
     }
     if point2.is_infinite {
         result = point1;
@@ -158,7 +169,10 @@ pub fn embedded_curve_add(point1: EmbeddedCurvePoint, point2: EmbeddedCurvePoint
 }
 
 #[foreign(embedded_curve_add)]
-fn embedded_curve_add_array_return(_point1: EmbeddedCurvePoint, _point2: EmbeddedCurvePoint) -> [Field; 3] {}
+fn embedded_curve_add_array_return(
+    _point1: EmbeddedCurvePoint,
+    _point2: EmbeddedCurvePoint,
+) -> [Field; 3] {}
 
 /// This function assumes that:
 /// The points are on the curve, and
@@ -166,7 +180,10 @@ fn embedded_curve_add_array_return(_point1: EmbeddedCurvePoint, _point2: Embedde
 /// Neither point is the infinity point.
 /// If it is used with correct input, the function ensures the correct non-zero result is returned.
 /// Except for points on the curve, the other assumptions are checked by the function. It will cause assertion failure if they are not respected.
-pub fn embedded_curve_add_not_nul(point1: EmbeddedCurvePoint, point2: EmbeddedCurvePoint) -> EmbeddedCurvePoint {
+pub fn embedded_curve_add_not_nul(
+    point1: EmbeddedCurvePoint,
+    point2: EmbeddedCurvePoint,
+) -> EmbeddedCurvePoint {
     assert(point1.x != point2.x);
     assert(!point1.is_infinite);
     assert(!point2.is_infinite);
@@ -178,7 +195,10 @@ pub fn embedded_curve_add_not_nul(point1: EmbeddedCurvePoint, point2: EmbeddedCu
 /// If they have the same value but are different variables, the result will be incorrect because in this case
 /// it assumes (but does not check) that the points' x-coordinates are not equal.
 /// It also assumes neither point is the infinity point.
-pub fn embedded_curve_add_unsafe(point1: EmbeddedCurvePoint, point2: EmbeddedCurvePoint) -> EmbeddedCurvePoint {
+pub fn embedded_curve_add_unsafe(
+    point1: EmbeddedCurvePoint,
+    point2: EmbeddedCurvePoint,
+) -> EmbeddedCurvePoint {
     let point_array = embedded_curve_add_array_return(point1, point2);
     let x = point_array[0];
     let y = point_array[1];
diff --git a/noir_stdlib/src/field/bn254.nr b/noir_stdlib/src/field/bn254.nr
index 8ff62062d5c..a7ca7d77373 100644
--- a/noir_stdlib/src/field/bn254.nr
+++ b/noir_stdlib/src/field/bn254.nr
@@ -1,3 +1,4 @@
+use crate::field::field_less_than;
 use crate::runtime::is_unconstrained;
 
 // The low and high decomposition of the field modulus
@@ -5,75 +6,46 @@ global PLO: Field = 53438638232309528389504892708671455233;
 global PHI: Field = 64323764613183177041862057485226039389;
 
 pub(crate) global TWO_POW_128: Field = 0x100000000000000000000000000000000;
+global TWO_POW_64: Field = 0x10000000000000000;
 
 // Decomposes a single field into two 16 byte fields.
-fn compute_decomposition(x: Field) -> (Field, Field) {
-    let x_bytes: [u8; 32] = x.to_le_bytes();
+fn compute_decomposition(mut x: Field) -> (Field, Field) {
+    // Here's we're taking advantage of truncating 64 bit limbs from the input field
+    // and then subtracting them from the input such the field division is equivalent to integer division.
+    let low_lower_64 = (x as u64) as Field;
+    x = (x - low_lower_64) / TWO_POW_64;
+    let low_upper_64 = (x as u64) as Field;
 
-    let mut low: Field = 0;
-    let mut high: Field = 0;
-
-    let mut offset = 1;
-    for i in 0..16 {
-        low += (x_bytes[i] as Field) * offset;
-        high += (x_bytes[i + 16] as Field) * offset;
-        offset *= 256;
-    }
+    let high = (x - low_upper_64) / TWO_POW_64;
+    let low = low_upper_64 * TWO_POW_64 + low_lower_64;
 
     (low, high)
 }
 
-unconstrained pub(crate) fn decompose_hint(x: Field) -> (Field, Field) {
+pub(crate) unconstrained fn decompose_hint(x: Field) -> (Field, Field) {
     compute_decomposition(x)
 }
 
-fn compute_lt(x: Field, y: Field, num_bytes: u32) -> bool {
-    let x_bytes: [u8; 32] = x.to_le_bytes();
-    let y_bytes: [u8; 32] = y.to_le_bytes();
-    let mut x_is_lt = false;
-    let mut done = false;
-    for i in 0..num_bytes {
-        if (!done) {
-            let x_byte = x_bytes[num_bytes - 1 - i];
-            let y_byte = y_bytes[num_bytes - 1 - i];
-            let bytes_match = x_byte == y_byte;
-            if !bytes_match {
-                x_is_lt = x_byte < y_byte;
-                done = true;
-            }
-        }
-    }
-    x_is_lt
-}
-
-fn compute_lte(x: Field, y: Field, num_bytes: u32) -> bool {
+unconstrained fn lte_hint(x: Field, y: Field) -> bool {
     if x == y {
         true
     } else {
-        compute_lt(x, y, num_bytes)
+        field_less_than(x, y)
     }
 }
 
-unconstrained fn lt_32_hint(x: Field, y: Field) -> bool {
-    compute_lt(x, y, 32)
-}
-
-unconstrained fn lte_16_hint(x: Field, y: Field) -> bool {
-    compute_lte(x, y, 16)
-}
-
 // Assert that (alo > blo && ahi >= bhi) || (alo <= blo && ahi > bhi)
 fn assert_gt_limbs(a: (Field, Field), b: (Field, Field)) {
     let (alo, ahi) = a;
     let (blo, bhi) = b;
     unsafe {
-        let borrow = lte_16_hint(alo, blo);
+        let borrow = lte_hint(alo, blo);
 
         let rlo = alo - blo - 1 + (borrow as Field) * TWO_POW_128;
         let rhi = ahi - bhi - (borrow as Field);
 
-        rlo.assert_max_bit_size(128);
-        rhi.assert_max_bit_size(128);
+        rlo.assert_max_bit_size::<128>();
+        rhi.assert_max_bit_size::<128>();
     }
 }
 
@@ -87,8 +59,8 @@ pub fn decompose(x: Field) -> (Field, Field) {
             let (xlo, xhi) = decompose_hint(x);
 
             // Range check the limbs
-            xlo.assert_max_bit_size(128);
-            xhi.assert_max_bit_size(128);
+            xlo.assert_max_bit_size::<128>();
+            xhi.assert_max_bit_size::<128>();
 
             // Check that the decomposition is correct
             assert_eq(x, xlo + TWO_POW_128 * xhi);
@@ -102,7 +74,7 @@ pub fn decompose(x: Field) -> (Field, Field) {
 
 pub fn assert_gt(a: Field, b: Field) {
     if is_unconstrained() {
-        assert(compute_lt(b, a, 32));
+        assert(unsafe { field_less_than(b, a) });
     } else {
         // Decompose a and b
         let a_limbs = decompose(a);
@@ -119,13 +91,15 @@ pub fn assert_lt(a: Field, b: Field) {
 
 pub fn gt(a: Field, b: Field) -> bool {
     if is_unconstrained() {
-        compute_lt(b, a, 32)
+        unsafe {
+            field_less_than(b, a)
+        }
     } else if a == b {
         false
     } else {
         // Take a hint of the comparison and verify it
         unsafe {
-            if lt_32_hint(a, b) {
+            if field_less_than(a, b) {
                 assert_gt(b, a);
                 false
             } else {
@@ -142,7 +116,7 @@ pub fn lt(a: Field, b: Field) -> bool {
 
 mod tests {
     // TODO: Allow imports from "super"
-    use crate::field::bn254::{decompose, compute_lt, assert_gt, gt, TWO_POW_128, compute_lte, PLO, PHI};
+    use crate::field::bn254::{assert_gt, decompose, gt, lte_hint, PHI, PLO, TWO_POW_128};
 
     #[test]
     fn check_decompose() {
@@ -159,24 +133,15 @@ mod tests {
     }
 
     #[test]
-    fn check_compute_lt() {
-        assert(compute_lt(0, 1, 16));
-        assert(compute_lt(0, 0x100, 16));
-        assert(compute_lt(0x100, TWO_POW_128 - 1, 16));
-        assert(!compute_lt(0, TWO_POW_128, 16));
-    }
-
-    #[test]
-    fn check_compute_lte() {
-        assert(compute_lte(0, 1, 16));
-        assert(compute_lte(0, 0x100, 16));
-        assert(compute_lte(0x100, TWO_POW_128 - 1, 16));
-        assert(!compute_lte(0, TWO_POW_128, 16));
-
-        assert(compute_lte(0, 0, 16));
-        assert(compute_lte(0x100, 0x100, 16));
-        assert(compute_lte(TWO_POW_128 - 1, TWO_POW_128 - 1, 16));
-        assert(compute_lte(TWO_POW_128, TWO_POW_128, 16));
+    unconstrained fn check_lte_hint() {
+        assert(lte_hint(0, 1));
+        assert(lte_hint(0, 0x100));
+        assert(lte_hint(0x100, TWO_POW_128 - 1));
+        assert(!lte_hint(0 - 1, 0));
+
+        assert(lte_hint(0, 0));
+        assert(lte_hint(0x100, 0x100));
+        assert(lte_hint(0 - 1, 0 - 1));
     }
 
     #[test]
diff --git a/noir_stdlib/src/field/mod.nr b/noir_stdlib/src/field/mod.nr
index 93245e18072..a5c1ff7bb62 100644
--- a/noir_stdlib/src/field/mod.nr
+++ b/noir_stdlib/src/field/mod.nr
@@ -1,4 +1,5 @@
 pub mod bn254;
+use crate::runtime::is_unconstrained;
 use bn254::lt as bn254_lt;
 
 impl Field {
@@ -7,11 +8,10 @@ impl Field {
     /// # Failures
     /// Causes a constraint failure for `Field` values exceeding `2^{bit_size}`.
     // docs:start:assert_max_bit_size
-    pub fn assert_max_bit_size(self, bit_size: u32) {
+    pub fn assert_max_bit_size<let BIT_SIZE: u32>(self) {
         // docs:end:assert_max_bit_size
-        crate::assert_constant(bit_size);
-        assert(bit_size < modulus_num_bits() as u32);
-        self.__assert_max_bit_size(bit_size);
+        assert(BIT_SIZE < modulus_num_bits() as u32);
+        self.__assert_max_bit_size(BIT_SIZE);
     }
 
     #[builtin(apply_range_constraint)]
@@ -19,7 +19,7 @@ impl Field {
 
     /// Decomposes `self` into its little endian bit decomposition as a `[u1; N]` array.
     /// This slice will be zero padded should not all bits be necessary to represent `self`.
-    /// 
+    ///
     /// # Failures
     /// Causes a constraint failure for `Field` values exceeding `2^N` as the resulting slice will not
     /// be able to represent the original `Field`.
@@ -35,7 +35,7 @@ impl Field {
 
     /// Decomposes `self` into its big endian bit decomposition as a `[u1; N]` array.
     /// This array will be zero padded should not all bits be necessary to represent `self`.
-    /// 
+    ///
     /// # Failures
     /// Causes a constraint failure for `Field` values exceeding `2^N` as the resulting slice will not
     /// be able to represent the original `Field`.
@@ -45,54 +45,92 @@ impl Field {
     /// (e.g. 254 for the BN254 field) allow for multiple bit decompositions. This is due to how the `Field` will
     /// wrap around due to overflow when verifying the decomposition.
     #[builtin(to_be_bits)]
-     // docs:start:to_be_bits
+    // docs:start:to_be_bits
     pub fn to_be_bits<let N: u32>(self: Self) -> [u1; N] {}
     // docs:end:to_be_bits
 
-    /// Decomposes `self` into its little endian byte decomposition as a `[u8]` slice of length `byte_size`.
-    /// This slice will be zero padded should not all bytes be necessary to represent `self`.
-    /// 
+    /// Decomposes `self` into its little endian byte decomposition as a `[u8;N]` array
+    /// This array will be zero padded should not all bytes be necessary to represent `self`.
+    ///
     /// # Failures
-    /// Causes a constraint failure for `Field` values exceeding `2^{8*byte_size}` as the resulting slice will not
-    /// be able to represent the original `Field`.
+    ///  The length N of the array must be big enough to contain all the bytes of the 'self',
+    ///  and no more than the number of bytes required to represent the field modulus
     ///
     /// # Safety
-    /// Values of `byte_size` equal to or greater than the number of bytes necessary to represent the `Field` modulus
-    /// (e.g. 32 for the BN254 field) allow for multiple byte decompositions. This is due to how the `Field` will
-    /// wrap around due to overflow when verifying the decomposition.
+    /// The result is ensured to be the canonical decomposition of the field element
     // docs:start:to_le_bytes
     pub fn to_le_bytes<let N: u32>(self: Self) -> [u8; N] {
-        self.to_le_radix(256)
+        // docs:end:to_le_bytes
+        // Compute the byte decomposition
+        let bytes = self.to_le_radix(256);
+
+        if !is_unconstrained() {
+            // Ensure that the byte decomposition does not overflow the modulus
+            let p = modulus_le_bytes();
+            assert(bytes.len() <= p.len());
+            let mut ok = bytes.len() != p.len();
+            for i in 0..N {
+                if !ok {
+                    if (bytes[N - 1 - i] != p[N - 1 - i]) {
+                        assert(bytes[N - 1 - i] < p[N - 1 - i]);
+                        ok = true;
+                    }
+                }
+            }
+            assert(ok);
+        }
+        bytes
     }
-    // docs:end:to_le_bytes
 
-    /// Decomposes `self` into its big endian byte decomposition as a `[u8]` slice of length `byte_size`.
-    /// This slice will be zero padded should not all bytes be necessary to represent `self`.
-    /// 
+    /// Decomposes `self` into its big endian byte decomposition as a `[u8;N]` array of length required to represent the field modulus
+    /// This array will be zero padded should not all bytes be necessary to represent `self`.
+    ///
     /// # Failures
-    /// Causes a constraint failure for `Field` values exceeding `2^{8*byte_size}` as the resulting slice will not
-    /// be able to represent the original `Field`.
+    ///  The length N of the array must be big enough to contain all the bytes of the 'self',
+    ///  and no more than the number of bytes required to represent the field modulus
     ///
     /// # Safety
-    /// Values of `byte_size` equal to or greater than the number of bytes necessary to represent the `Field` modulus
-    /// (e.g. 32 for the BN254 field) allow for multiple byte decompositions. This is due to how the `Field` will
-    /// wrap around due to overflow when verifying the decomposition.
+    /// The result is ensured to be the canonical decomposition of the field element
     // docs:start:to_be_bytes
     pub fn to_be_bytes<let N: u32>(self: Self) -> [u8; N] {
-        self.to_be_radix(256)
+        // docs:end:to_be_bytes
+        // Compute the byte decomposition
+        let bytes = self.to_be_radix(256);
+
+        if !is_unconstrained() {
+            // Ensure that the byte decomposition does not overflow the modulus
+            let p = modulus_be_bytes();
+            assert(bytes.len() <= p.len());
+            let mut ok = bytes.len() != p.len();
+            for i in 0..N {
+                if !ok {
+                    if (bytes[i] != p[i]) {
+                        assert(bytes[i] < p[i]);
+                        ok = true;
+                    }
+                }
+            }
+            assert(ok);
+        }
+        bytes
     }
-    // docs:end:to_be_bytes
 
     // docs:start:to_le_radix
     pub fn to_le_radix<let N: u32>(self: Self, radix: u32) -> [u8; N] {
-        crate::assert_constant(radix);
+        // Brillig does not need an immediate radix
+        if !crate::runtime::is_unconstrained() {
+            crate::assert_constant(radix);
+        }
         self.__to_le_radix(radix)
     }
     // docs:end:to_le_radix
 
     // docs:start:to_be_radix
     pub fn to_be_radix<let N: u32>(self: Self, radix: u32) -> [u8; N] {
-        crate::assert_constant(radix);
+        // Brillig does not need an immediate radix
+        if !crate::runtime::is_unconstrained() {
+            crate::assert_constant(radix);
+        }
         self.__to_be_radix(radix)
     }
     // docs:end:to_be_radix
@@ -113,7 +151,7 @@ impl Field {
 
         for i in 1..33 {
             r *= r;
-            r = (b[32-i] as Field) * (r * self) + (1 - b[32-i] as Field) * r;
+            r = (b[32 - i] as Field) * (r * self) + (1 - b[32 - i] as Field) * r;
         }
         r
     }
@@ -130,6 +168,32 @@ impl Field {
             lt_fallback(self, another)
         }
     }
+
+    /// Convert a little endian byte array to a field element.
+    /// If the provided byte array overflows the field modulus then the Field will silently wrap around.
+    pub fn from_le_bytes<let N: u32>(bytes: [u8; N]) -> Field {
+        let mut v = 1;
+        let mut result = 0;
+
+        for i in 0..N {
+            result += (bytes[i] as Field) * v;
+            v = v * 256;
+        }
+        result
+    }
+
+    /// Convert a big endian byte array to a field element.
+    /// If the provided byte array overflows the field modulus then the Field will silently wrap around.
+    pub fn from_be_bytes<let N: u32>(bytes: [u8; N]) -> Field {
+        let mut v = 1;
+        let mut result = 0;
+
+        for i in 0..N {
+            result += (bytes[N - 1 - i] as Field) * v;
+            v = v * 256;
+        }
+        result
+    }
 }
 
 #[builtin(modulus_num_bits)]
@@ -147,6 +211,14 @@ pub comptime fn modulus_be_bytes() -> [u8] {}
 #[builtin(modulus_le_bytes)]
 pub comptime fn modulus_le_bytes() -> [u8] {}
 
+/// An unconstrained only built in to efficiently compare fields.
+#[builtin(field_less_than)]
+unconstrained fn __field_less_than(x: Field, y: Field) -> bool {}
+
+pub(crate) unconstrained fn field_less_than(x: Field, y: Field) -> bool {
+    __field_less_than(x, y)
+}
+
 // Convert a 32 byte array to a field element by modding
 pub fn bytes32_to_field(bytes32: [u8; 32]) -> Field {
     // Convert it to a field element
@@ -164,25 +236,33 @@ pub fn bytes32_to_field(bytes32: [u8; 32]) -> Field {
 }
 
 fn lt_fallback(x: Field, y: Field) -> bool {
-    let x_bytes: [u8; 32] = x.to_le_bytes();
-    let y_bytes: [u8; 32] = y.to_le_bytes();
-    let mut x_is_lt = false;
-    let mut done = false;
-    for i in 0..32 {
-        if (!done) {
-            let x_byte = x_bytes[32 - 1 - i] as u8;
-            let y_byte = y_bytes[32 - 1 - i] as u8;
-            let bytes_match = x_byte == y_byte;
-            if !bytes_match {
-                x_is_lt = x_byte < y_byte;
-                done = true;
+    if is_unconstrained() {
+        unsafe {
+            field_less_than(x, y)
+        }
+    } else {
+        let x_bytes: [u8; 32] = x.to_le_bytes();
+        let y_bytes: [u8; 32] = y.to_le_bytes();
+        let mut x_is_lt = false;
+        let mut done = false;
+        for i in 0..32 {
+            if (!done) {
+                let x_byte = x_bytes[32 - 1 - i] as u8;
+                let y_byte = y_bytes[32 - 1 - i] as u8;
+                let bytes_match = x_byte == y_byte;
+                if !bytes_match {
+                    x_is_lt = x_byte < y_byte;
+                    done = true;
+                }
             }
         }
+        x_is_lt
     }
-    x_is_lt
 }
 
 mod tests {
+    use super::field_less_than;
+
     #[test]
     // docs:start:to_be_bits_example
     fn test_to_be_bits() {
@@ -205,8 +285,9 @@ mod tests {
     // docs:start:to_be_bytes_example
     fn test_to_be_bytes() {
         let field = 2;
-        let bits: [u8; 8] = field.to_be_bytes();
-        assert_eq(bits, [0, 0, 0, 0, 0, 0, 0, 2]);
+        let bytes: [u8; 8] = field.to_be_bytes();
+        assert_eq(bytes, [0, 0, 0, 0, 0, 0, 0, 2]);
+        assert_eq(Field::from_be_bytes::<8>(bytes), field);
     }
     // docs:end:to_be_bytes_example
 
@@ -214,8 +295,9 @@ mod tests {
     // docs:start:to_le_bytes_example
     fn test_to_le_bytes() {
         let field = 2;
-        let bits: [u8; 8] = field.to_le_bytes();
-        assert_eq(bits, [2, 0, 0, 0, 0, 0, 0, 0]);
+        let bytes: [u8; 8] = field.to_le_bytes();
+        assert_eq(bytes, [2, 0, 0, 0, 0, 0, 0, 0]);
+        assert_eq(Field::from_le_bytes::<8>(bytes), field);
     }
     // docs:end:to_le_bytes_example
 
@@ -223,8 +305,9 @@ mod tests {
     // docs:start:to_be_radix_example
     fn test_to_be_radix() {
         let field = 2;
-        let bits: [u8; 8] = field.to_be_radix(256);
-        assert_eq(bits, [0, 0, 0, 0, 0, 0, 0, 2]);
+        let bytes: [u8; 8] = field.to_be_radix(256);
+        assert_eq(bytes, [0, 0, 0, 0, 0, 0, 0, 2]);
+        assert_eq(Field::from_be_bytes::<8>(bytes), field);
     }
     // docs:end:to_be_radix_example
 
@@ -232,8 +315,17 @@ mod tests {
     // docs:start:to_le_radix_example
     fn test_to_le_radix() {
         let field = 2;
-        let bits: [u8; 8] = field.to_le_radix(256);
-        assert_eq(bits, [2, 0, 0, 0, 0, 0, 0, 0]);
+        let bytes: [u8; 8] = field.to_le_radix(256);
+        assert_eq(bytes, [2, 0, 0, 0, 0, 0, 0, 0]);
+        assert_eq(Field::from_le_bytes::<8>(bytes), field);
     }
     // docs:end:to_le_radix_example
+
+    #[test]
+    unconstrained fn test_field_less_than() {
+        assert(field_less_than(0, 1));
+        assert(field_less_than(0, 0x100));
+        assert(field_less_than(0x100, 0 - 1));
+        assert(!field_less_than(0 - 1, 0));
+    }
 }
diff --git a/noir_stdlib/src/hash/keccak.nr b/noir_stdlib/src/hash/keccak.nr
index 37eb4dfe8a6..93b366d1ec1 100644
--- a/noir_stdlib/src/hash/keccak.nr
+++ b/noir_stdlib/src/hash/keccak.nr
@@ -1,4 +1,3 @@
-use crate::collections::vec::Vec;
 use crate::runtime::is_unconstrained;
 
 global BLOCK_SIZE_IN_BYTES: u32 = 136; //(1600 - BITS * 2) / WORD_SIZE;
@@ -12,7 +11,10 @@ fn keccakf1600(input: [u64; 25]) -> [u64; 25] {}
 #[no_predicates]
 pub(crate) fn keccak256<let N: u32>(input: [u8; N], message_size: u32) -> [u8; 32] {
     assert(N >= message_size);
-    let mut block_bytes = [0; BLOCK_SIZE_IN_BYTES];
+
+    // Copy input to block bytes. For that we'll need at least input bytes (N)
+    // but we want it to be padded to a multiple of BLOCK_SIZE_IN_BYTES.
+    let mut block_bytes = [0; ((N / BLOCK_SIZE_IN_BYTES) + 1) * BLOCK_SIZE_IN_BYTES];
     if is_unconstrained() {
         for i in 0..message_size {
             block_bytes[i] = input[i];
@@ -28,7 +30,6 @@ pub(crate) fn keccak256<let N: u32>(input: [u8; N], message_size: u32) -> [u8; 3
     //1. format_input_lanes
     let max_blocks = (N + BLOCK_SIZE_IN_BYTES) / BLOCK_SIZE_IN_BYTES;
     //maximum number of bytes to hash
-    let max_blocks_length = (BLOCK_SIZE_IN_BYTES * max_blocks);
     let real_max_blocks = (message_size + BLOCK_SIZE_IN_BYTES) / BLOCK_SIZE_IN_BYTES;
     let real_blocks_bytes = real_max_blocks * BLOCK_SIZE_IN_BYTES;
 
@@ -36,34 +37,34 @@ pub(crate) fn keccak256<let N: u32>(input: [u8; N], message_size: u32) -> [u8; 3
     block_bytes[real_blocks_bytes - 1] = 0x80;
 
     // populate a vector of 64-bit limbs from our byte array
-    let num_limbs = max_blocks_length / WORD_SIZE;
-    let mut sliced_buffer = Vec::new();
-    for i in 0..num_limbs {
+    let mut sliced_buffer =
+        [0; (((N / BLOCK_SIZE_IN_BYTES) + 1) * BLOCK_SIZE_IN_BYTES) / WORD_SIZE];
+    for i in 0..sliced_buffer.len() {
         let limb_start = WORD_SIZE * i;
 
         let mut sliced = 0;
         let mut v = 1;
         for k in 0..WORD_SIZE {
-            sliced += v * (block_bytes[limb_start+k] as Field);
+            sliced += v * (block_bytes[limb_start + k] as Field);
             v *= 256;
         }
 
-        sliced_buffer.push(sliced as u64);
+        sliced_buffer[i] = sliced as u64;
     }
 
     //2. sponge_absorb
-    let mut state : [u64; NUM_KECCAK_LANES]= [0; NUM_KECCAK_LANES];
+    let mut state: [u64; NUM_KECCAK_LANES] = [0; NUM_KECCAK_LANES];
     // When in an unconstrained runtime we can take advantage of runtime loop bounds,
     // thus allowing us to simplify the loop body.
     if is_unconstrained() {
         for i in 0..real_max_blocks {
             if (i == 0) {
                 for j in 0..LIMBS_PER_BLOCK {
-                    state[j] = sliced_buffer.get(j);
+                    state[j] = sliced_buffer[j];
                 }
             } else {
                 for j in 0..LIMBS_PER_BLOCK {
-                    state[j] = state[j] ^ sliced_buffer.get(i * LIMBS_PER_BLOCK + j);
+                    state[j] = state[j] ^ sliced_buffer[i * LIMBS_PER_BLOCK + j];
                 }
             }
             state = keccakf1600(state);
@@ -73,13 +74,13 @@ pub(crate) fn keccak256<let N: u32>(input: [u8; N], message_size: u32) -> [u8; 3
         // We peel out the first block as to avoid a conditional inside of the loop.
         // Otherwise, a dynamic predicate can cause a blowup in a constrained runtime.
         for j in 0..LIMBS_PER_BLOCK {
-            state[j] = sliced_buffer.get(j);
+            state[j] = sliced_buffer[j];
         }
         state = keccakf1600(state);
         for i in 1..max_blocks {
             if i < real_max_blocks {
                 for j in 0..LIMBS_PER_BLOCK {
-                    state[j] = state[j] ^ sliced_buffer.get(i * LIMBS_PER_BLOCK + j);
+                    state[j] = state[j] ^ sliced_buffer[i * LIMBS_PER_BLOCK + j];
                 }
                 state = keccakf1600(state);
             }
@@ -92,7 +93,7 @@ pub(crate) fn keccak256<let N: u32>(input: [u8; N], message_size: u32) -> [u8; 3
         let lane = state[i] as Field;
         let lane_le: [u8; 8] = lane.to_le_bytes();
         for j in 0..8 {
-            result[8*i+j] = lane_le[j];
+            result[8 * i + j] = lane_le[j];
         }
     }
     result
@@ -105,17 +106,20 @@ mod tests {
     fn smoke_test() {
         let input = [0xbd];
         let result = [
-            0x5a, 0x50, 0x2f, 0x9f, 0xca, 0x46, 0x7b, 0x26, 0x6d, 0x5b, 0x78, 0x33, 0x65, 0x19, 0x37, 0xe8, 0x05, 0x27, 0x0c, 0xa3, 0xf3, 0xaf, 0x1c, 0x0d, 0xd2, 0x46, 0x2d, 0xca, 0x4b, 0x3b, 0x1a, 0xbf
+            0x5a, 0x50, 0x2f, 0x9f, 0xca, 0x46, 0x7b, 0x26, 0x6d, 0x5b, 0x78, 0x33, 0x65, 0x19,
+            0x37, 0xe8, 0x05, 0x27, 0x0c, 0xa3, 0xf3, 0xaf, 0x1c, 0x0d, 0xd2, 0x46, 0x2d, 0xca,
+            0x4b, 0x3b, 0x1a, 0xbf,
         ];
         assert_eq(keccak256(input, input.len()), result);
     }
 
     #[test]
     fn hash_hello_world() {
-        // "hello world"
-        let input = [72, 101, 108, 108, 111, 32, 119, 111, 114, 108, 100, 33];
+        let input = "Hello world!".as_bytes();
         let result = [
-            0xec, 0xd0, 0xe1, 0x8, 0xa9, 0x8e, 0x19, 0x2a, 0xf1, 0xd2, 0xc2, 0x50, 0x55, 0xf4, 0xe3, 0xbe, 0xd7, 0x84, 0xb5, 0xc8, 0x77, 0x20, 0x4e, 0x73, 0x21, 0x9a, 0x52, 0x3, 0x25, 0x1f, 0xea, 0xab
+            0xec, 0xd0, 0xe1, 0x8, 0xa9, 0x8e, 0x19, 0x2a, 0xf1, 0xd2, 0xc2, 0x50, 0x55, 0xf4, 0xe3,
+            0xbe, 0xd7, 0x84, 0xb5, 0xc8, 0x77, 0x20, 0x4e, 0x73, 0x21, 0x9a, 0x52, 0x3, 0x25, 0x1f,
+            0xea, 0xab,
         ];
         assert_eq(keccak256(input, input.len()), result);
     }
@@ -123,11 +127,28 @@ mod tests {
     #[test]
     fn var_size_hash() {
         let input = [
-            189, 190, 191, 192, 193, 194, 195, 196, 197, 198, 199, 200, 201, 202, 203, 204, 205, 206, 207, 208, 209, 210, 211, 212, 213, 214, 215, 216, 217, 218, 219, 220, 221, 222, 223
+            189, 190, 191, 192, 193, 194, 195, 196, 197, 198, 199, 200, 201, 202, 203, 204, 205,
+            206, 207, 208, 209, 210, 211, 212, 213, 214, 215, 216, 217, 218, 219, 220, 221, 222,
+            223,
         ];
         let result = [
-            226, 37, 115, 94, 94, 196, 72, 116, 194, 105, 79, 233, 65, 12, 30, 94, 181, 131, 170, 219, 171, 166, 236, 88, 143, 67, 255, 160, 248, 214, 39, 129
+            226, 37, 115, 94, 94, 196, 72, 116, 194, 105, 79, 233, 65, 12, 30, 94, 181, 131, 170,
+            219, 171, 166, 236, 88, 143, 67, 255, 160, 248, 214, 39, 129,
         ];
         assert_eq(keccak256(input, 13), result);
     }
+
+    #[test]
+    fn hash_longer_than_136_bytes() {
+        let input = "123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789"
+            .as_bytes();
+        assert(input.len() > 136);
+
+        let result = [
+            0x1d, 0xca, 0xeb, 0xdf, 0xd9, 0xd6, 0x24, 0x67, 0x1c, 0x18, 0x16, 0xda, 0xd, 0x8a, 0xeb,
+            0xa8, 0x75, 0x71, 0x2c, 0xc, 0x89, 0xe0, 0x25, 0x2, 0xe8, 0xb6, 0x5e, 0x16, 0x5, 0x55,
+            0xe4, 0x40,
+        ];
+        assert_eq(keccak256(input, input.len()), result);
+    }
 }
diff --git a/noir_stdlib/src/hash/mimc.nr b/noir_stdlib/src/hash/mimc.nr
deleted file mode 100644
index 1bcc9e3fcc7..00000000000
--- a/noir_stdlib/src/hash/mimc.nr
+++ /dev/null
@@ -1,156 +0,0 @@
-use crate::hash::Hasher;
-use crate::default::Default;
-
-// mimc-p/p implementation
-// constants are (publicly generated) random numbers, for instance using keccak as a ROM.
-// You must use constants generated for the native field
-// Rounds number should be ~ log(p)/log(exp)
-// For 254 bit primes, exponent 7 and 91 rounds seems to be recommended
-#[deprecated = "It's recommmended to use the external MiMC library (https://github.com/noir-lang/mimc)"]
-fn mimc<let N: u32>(x: Field, k: Field, constants: [Field; N], exp: Field) -> Field {
-    //round 0
-    let mut t = x + k;
-    let mut h = t.pow_32(exp);
-    //next rounds
-    for i in 1..constants.len() {
-        t = h + k + constants[i];
-        h = t.pow_32(exp);
-    }
-    h + k
-}
-
-global MIMC_BN254_ROUNDS: u32 = 91;
-//generated from seed "mimc" using keccak256 
-global MIMC_BN254_CONSTANTS: [Field; MIMC_BN254_ROUNDS] = [
-        0,
-        20888961410941983456478427210666206549300505294776164667214940546594746570981,
-        15265126113435022738560151911929040668591755459209400716467504685752745317193,
-        8334177627492981984476504167502758309043212251641796197711684499645635709656,
-        1374324219480165500871639364801692115397519265181803854177629327624133579404,
-        11442588683664344394633565859260176446561886575962616332903193988751292992472,
-        2558901189096558760448896669327086721003508630712968559048179091037845349145,
-        11189978595292752354820141775598510151189959177917284797737745690127318076389,
-        3262966573163560839685415914157855077211340576201936620532175028036746741754,
-        17029914891543225301403832095880481731551830725367286980611178737703889171730,
-        4614037031668406927330683909387957156531244689520944789503628527855167665518,
-        19647356996769918391113967168615123299113119185942498194367262335168397100658,
-        5040699236106090655289931820723926657076483236860546282406111821875672148900,
-        2632385916954580941368956176626336146806721642583847728103570779270161510514,
-        17691411851977575435597871505860208507285462834710151833948561098560743654671,
-        11482807709115676646560379017491661435505951727793345550942389701970904563183,
-        8360838254132998143349158726141014535383109403565779450210746881879715734773,
-        12663821244032248511491386323242575231591777785787269938928497649288048289525,
-        3067001377342968891237590775929219083706800062321980129409398033259904188058,
-        8536471869378957766675292398190944925664113548202769136103887479787957959589,
-        19825444354178182240559170937204690272111734703605805530888940813160705385792,
-        16703465144013840124940690347975638755097486902749048533167980887413919317592,
-        13061236261277650370863439564453267964462486225679643020432589226741411380501,
-        10864774797625152707517901967943775867717907803542223029967000416969007792571,
-        10035653564014594269791753415727486340557376923045841607746250017541686319774,
-        3446968588058668564420958894889124905706353937375068998436129414772610003289,
-        4653317306466493184743870159523234588955994456998076243468148492375236846006,
-        8486711143589723036499933521576871883500223198263343024003617825616410932026,
-        250710584458582618659378487568129931785810765264752039738223488321597070280,
-        2104159799604932521291371026105311735948154964200596636974609406977292675173,
-        16313562605837709339799839901240652934758303521543693857533755376563489378839,
-        6032365105133504724925793806318578936233045029919447519826248813478479197288,
-        14025118133847866722315446277964222215118620050302054655768867040006542798474,
-        7400123822125662712777833064081316757896757785777291653271747396958201309118,
-        1744432620323851751204287974553233986555641872755053103823939564833813704825,
-        8316378125659383262515151597439205374263247719876250938893842106722210729522,
-        6739722627047123650704294650168547689199576889424317598327664349670094847386,
-        21211457866117465531949733809706514799713333930924902519246949506964470524162,
-        13718112532745211817410303291774369209520657938741992779396229864894885156527,
-        5264534817993325015357427094323255342713527811596856940387954546330728068658,
-        18884137497114307927425084003812022333609937761793387700010402412840002189451,
-        5148596049900083984813839872929010525572543381981952060869301611018636120248,
-        19799686398774806587970184652860783461860993790013219899147141137827718662674,
-        19240878651604412704364448729659032944342952609050243268894572835672205984837,
-        10546185249390392695582524554167530669949955276893453512788278945742408153192,
-        5507959600969845538113649209272736011390582494851145043668969080335346810411,
-        18177751737739153338153217698774510185696788019377850245260475034576050820091,
-        19603444733183990109492724100282114612026332366576932662794133334264283907557,
-        10548274686824425401349248282213580046351514091431715597441736281987273193140,
-        1823201861560942974198127384034483127920205835821334101215923769688644479957,
-        11867589662193422187545516240823411225342068709600734253659804646934346124945,
-        18718569356736340558616379408444812528964066420519677106145092918482774343613,
-        10530777752259630125564678480897857853807637120039176813174150229243735996839,
-        20486583726592018813337145844457018474256372770211860618687961310422228379031,
-        12690713110714036569415168795200156516217175005650145422920562694422306200486,
-        17386427286863519095301372413760745749282643730629659997153085139065756667205,
-        2216432659854733047132347621569505613620980842043977268828076165669557467682,
-        6309765381643925252238633914530877025934201680691496500372265330505506717193,
-        20806323192073945401862788605803131761175139076694468214027227878952047793390,
-        4037040458505567977365391535756875199663510397600316887746139396052445718861,
-        19948974083684238245321361840704327952464170097132407924861169241740046562673,
-        845322671528508199439318170916419179535949348988022948153107378280175750024,
-        16222384601744433420585982239113457177459602187868460608565289920306145389382,
-        10232118865851112229330353999139005145127746617219324244541194256766741433339,
-        6699067738555349409504843460654299019000594109597429103342076743347235369120,
-        6220784880752427143725783746407285094967584864656399181815603544365010379208,
-        6129250029437675212264306655559561251995722990149771051304736001195288083309,
-        10773245783118750721454994239248013870822765715268323522295722350908043393604,
-        4490242021765793917495398271905043433053432245571325177153467194570741607167,
-        19596995117319480189066041930051006586888908165330319666010398892494684778526,
-        837850695495734270707668553360118467905109360511302468085569220634750561083,
-        11803922811376367215191737026157445294481406304781326649717082177394185903907,
-        10201298324909697255105265958780781450978049256931478989759448189112393506592,
-        13564695482314888817576351063608519127702411536552857463682060761575100923924,
-        9262808208636973454201420823766139682381973240743541030659775288508921362724,
-        173271062536305557219323722062711383294158572562695717740068656098441040230,
-        18120430890549410286417591505529104700901943324772175772035648111937818237369,
-        20484495168135072493552514219686101965206843697794133766912991150184337935627,
-        19155651295705203459475805213866664350848604323501251939850063308319753686505,
-        11971299749478202793661982361798418342615500543489781306376058267926437157297,
-        18285310723116790056148596536349375622245669010373674803854111592441823052978,
-        7069216248902547653615508023941692395371990416048967468982099270925308100727,
-        6465151453746412132599596984628739550147379072443683076388208843341824127379,
-        16143532858389170960690347742477978826830511669766530042104134302796355145785,
-        19362583304414853660976404410208489566967618125972377176980367224623492419647,
-        1702213613534733786921602839210290505213503664731919006932367875629005980493,
-        10781825404476535814285389902565833897646945212027592373510689209734812292327,
-        4212716923652881254737947578600828255798948993302968210248673545442808456151,
-        7594017890037021425366623750593200398174488805473151513558919864633711506220,
-        18979889247746272055963929241596362599320706910852082477600815822482192194401,
-        13602139229813231349386885113156901793661719180900395818909719758150455500533
-    ];
-
-//mimc implementation with hardcoded parameters for BN254 curve.
-#[field(bn254)]
-#[deprecated = "It's recommmended to use the external MiMC library (https://github.com/noir-lang/mimc)"]
-pub fn mimc_bn254<let N: u32>(array: [Field; N]) -> Field {
-    let exponent = 7;
-    let mut r = 0;
-    for elem in array {
-        let h = mimc(elem, r, MIMC_BN254_CONSTANTS, exponent);
-        r = r + elem + h;
-    }
-    r
-}
-
-pub struct MimcHasher {
-    _state: [Field],
-}
-
-impl Hasher for MimcHasher {
-    #[field(bn254)]
-    fn finish(self) -> Field {
-        let exponent = 7;
-        let mut r = 0;
-        for i in 0..self._state.len() {
-            let h = mimc(self._state[i], r, MIMC_BN254_CONSTANTS, exponent);
-            r = r + self._state[i] + h;
-        }
-        r
-    }
-
-    fn write(&mut self, input: Field) {
-        self._state = self._state.push_back(input);
-    }
-}
-
-impl Default for MimcHasher {
-    fn default() -> Self {
-        MimcHasher { _state: &[] }
-    }
-}
diff --git a/noir_stdlib/src/hash/mod.nr b/noir_stdlib/src/hash/mod.nr
index 1b37a07f6c9..5f7017b60b7 100644
--- a/noir_stdlib/src/hash/mod.nr
+++ b/noir_stdlib/src/hash/mod.nr
@@ -1,15 +1,15 @@
 pub mod poseidon;
-pub mod mimc;
 pub mod poseidon2;
 pub mod keccak;
 pub mod sha256;
 pub mod sha512;
 
 use crate::default::Default;
-use crate::uint128::U128;
-use crate::collections::vec::Vec;
-use crate::embedded_curve_ops::{EmbeddedCurvePoint, EmbeddedCurveScalar, multi_scalar_mul, multi_scalar_mul_slice};
+use crate::embedded_curve_ops::{
+    EmbeddedCurvePoint, EmbeddedCurveScalar, multi_scalar_mul, multi_scalar_mul_array_return,
+};
 use crate::meta::derive_via;
+use crate::uint128::U128;
 
 // Kept for backwards compatibility
 pub use sha256::{digest, sha256, sha256_compression, sha256_var};
@@ -32,21 +32,11 @@ pub fn pedersen_commitment<let N: u32>(input: [Field; N]) -> EmbeddedCurvePoint
     pedersen_commitment_with_separator(input, 0)
 }
 
-pub fn pedersen_hash_with_separator<let N: u32>(input: [Field; N], separator: u32) -> Field {
-    __pedersen_hash_with_separator(input, separator)
-}
-
-pub fn pedersen_commitment_with_separator<let N: u32>(input: [Field; N], separator: u32) -> EmbeddedCurvePoint {
-    let value = __pedersen_commitment_with_separator(input, separator);
-    if (value[0] == 0) & (value[1] == 0) {
-        EmbeddedCurvePoint { x: 0, y: 0, is_infinite: true }
-    } else {
-        EmbeddedCurvePoint { x: value[0], y: value[1], is_infinite: false }
-    }
-}
-
-#[no_predicates]
-fn pedersen_commitment_with_separator_noir<let N: u32>(input: [Field; N], separator: u32) -> EmbeddedCurvePoint {
+#[inline_always]
+pub fn pedersen_commitment_with_separator<let N: u32>(
+    input: [Field; N],
+    separator: u32,
+) -> EmbeddedCurvePoint {
     let mut points = [EmbeddedCurveScalar { lo: 0, hi: 0 }; N];
     for i in 0..N {
         // we use the unsafe version because the multi_scalar_mul will constrain the scalars.
@@ -56,39 +46,39 @@ fn pedersen_commitment_with_separator_noir<let N: u32>(input: [Field; N], separa
     multi_scalar_mul(generators, points)
 }
 
-#[no_predicates]
-fn pedersen_hash_with_separator_noir<let N: u32>(input: [Field; N], separator: u32) -> Field {
-    let mut scalars: Vec<EmbeddedCurveScalar> = Vec::from_slice([EmbeddedCurveScalar { lo: 0, hi: 0 }; N].as_slice()); //Vec::new();
-
-    for i in 0..N {
-        scalars.set(i, from_field_unsafe(input[i]));
-    }
-    scalars.push(EmbeddedCurveScalar { lo: N as Field, hi: 0 as Field });
-    let domain_generators :[EmbeddedCurvePoint; N]= derive_generators("DEFAULT_DOMAIN_SEPARATOR".as_bytes(), separator);
-    let mut vec_generators = Vec::new();
-    for i in 0..N {
-        vec_generators.push(domain_generators[i]);
-    }
-    let length_generator : [EmbeddedCurvePoint; 1] = derive_generators("pedersen_hash_length".as_bytes(), 0);
-    vec_generators.push(length_generator[0]);
-    multi_scalar_mul_slice(vec_generators.slice, scalars.slice)[0]
-}
-
 // docs:start:pedersen_hash
 pub fn pedersen_hash<let N: u32>(input: [Field; N]) -> Field
 // docs:end:pedersen_hash
 {
-    __pedersen_hash_with_separator(input, 0)
+    pedersen_hash_with_separator(input, 0)
 }
 
-#[foreign(pedersen_hash)]
-fn __pedersen_hash_with_separator<let N: u32>(input: [Field; N], separator: u32) -> Field {}
+#[no_predicates]
+pub fn pedersen_hash_with_separator<let N: u32>(input: [Field; N], separator: u32) -> Field {
+    let mut scalars: [EmbeddedCurveScalar; N + 1] = [EmbeddedCurveScalar { lo: 0, hi: 0 }; N + 1];
+    let mut generators: [EmbeddedCurvePoint; N + 1] =
+        [EmbeddedCurvePoint::point_at_infinity(); N + 1];
+    let domain_generators: [EmbeddedCurvePoint; N] =
+        derive_generators("DEFAULT_DOMAIN_SEPARATOR".as_bytes(), separator);
+
+    for i in 0..N {
+        scalars[i] = from_field_unsafe(input[i]);
+        generators[i] = domain_generators[i];
+    }
+    scalars[N] = EmbeddedCurveScalar { lo: N as Field, hi: 0 as Field };
 
-#[foreign(pedersen_commitment)]
-fn __pedersen_commitment_with_separator<let N: u32>(input: [Field; N], separator: u32) -> [Field; 2] {}
+    let length_generator: [EmbeddedCurvePoint; 1] =
+        derive_generators("pedersen_hash_length".as_bytes(), 0);
+    generators[N] = length_generator[0];
+    multi_scalar_mul_array_return(generators, scalars)[0]
+}
 
 #[field(bn254)]
-pub fn derive_generators<let N: u32, let M: u32>(domain_separator_bytes: [u8; M], starting_index: u32) -> [EmbeddedCurvePoint; N] {
+#[inline_always]
+pub fn derive_generators<let N: u32, let M: u32>(
+    domain_separator_bytes: [u8; M],
+    starting_index: u32,
+) -> [EmbeddedCurvePoint; N] {
     crate::assert_constant(domain_separator_bytes);
     // TODO(https://github.com/noir-lang/noir/issues/5672): Add back assert_constant on starting_index
     __derive_generators(domain_separator_bytes, starting_index)
@@ -96,16 +86,17 @@ pub fn derive_generators<let N: u32, let M: u32>(domain_separator_bytes: [u8; M]
 
 #[builtin(derive_pedersen_generators)]
 #[field(bn254)]
-fn __derive_generators<let N: u32, let M: u32>(domain_separator_bytes: [u8; M], starting_index: u32) -> [EmbeddedCurvePoint; N] {}
+fn __derive_generators<let N: u32, let M: u32>(
+    domain_separator_bytes: [u8; M],
+    starting_index: u32,
+) -> [EmbeddedCurvePoint; N] {}
 
 #[field(bn254)]
 // Same as from_field but:
 // does not assert the limbs are 128 bits
 // does not assert the decomposition does not overflow the EmbeddedCurveScalar
 fn from_field_unsafe(scalar: Field) -> EmbeddedCurveScalar {
-    let (xlo, xhi) = unsafe {
-        crate::field::bn254::decompose_hint(scalar)
-    };
+    let (xlo, xhi) = unsafe { crate::field::bn254::decompose_hint(scalar) };
     // Check that the decomposition is correct
     assert_eq(scalar, xlo + crate::field::bn254::TWO_POW_128 * xhi);
     EmbeddedCurveScalar { lo: xlo, hi: xhi }
@@ -138,7 +129,9 @@ pub fn poseidon2_permutation<let N: u32>(_input: [Field; N], _state_length: u32)
 // Hash trait shall be implemented per type.
 #[derive_via(derive_hash)]
 pub trait Hash {
-    fn hash<H>(self, state: &mut H) where H: Hasher;
+    fn hash<H>(self, state: &mut H)
+    where
+        H: Hasher;
 }
 
 // docs:start:derive_hash
@@ -146,7 +139,14 @@ comptime fn derive_hash(s: StructDefinition) -> Quoted {
     let name = quote { Hash };
     let signature = quote { fn hash<H>(_self: Self, _state: &mut H) where H: std::hash::Hasher };
     let for_each_field = |name| quote { _self.$name.hash(_state); };
-    crate::meta::make_trait_impl(s, name, signature, for_each_field, quote {}, |fields| fields)
+    crate::meta::make_trait_impl(
+        s,
+        name,
+        signature,
+        for_each_field,
+        quote {},
+        |fields| fields,
+    )
 }
 // docs:end:derive_hash
 
@@ -159,7 +159,10 @@ pub trait Hasher {
 }
 
 // BuildHasher is a factory trait, responsible for production of specific Hasher.
-pub trait BuildHasher<H> where H: Hasher {
+pub trait BuildHasher<H>
+where
+    H: Hasher,
+{
     fn build_hasher(self) -> H;
 }
 
@@ -167,7 +170,8 @@ pub struct BuildHasherDefault<H>;
 
 impl<H> BuildHasher<H> for BuildHasherDefault<H>
 where
-    H: Hasher + Default {
+    H: Hasher + Default,
+{
     fn build_hasher(_self: Self) -> H {
         H::default()
     }
@@ -175,99 +179,151 @@ where
 
 impl<H> Default for BuildHasherDefault<H>
 where
-    H: Hasher + Default {
+    H: Hasher + Default,
+{
     fn default() -> Self {
         BuildHasherDefault {}
     }
 }
 
 impl Hash for Field {
-    fn hash<H>(self, state: &mut H) where H: Hasher {
+    fn hash<H>(self, state: &mut H)
+    where
+        H: Hasher,
+    {
         H::write(state, self);
     }
 }
 
 impl Hash for u1 {
-    fn hash<H>(self, state: &mut H) where H: Hasher {
+    fn hash<H>(self, state: &mut H)
+    where
+        H: Hasher,
+    {
         H::write(state, self as Field);
     }
 }
 
 impl Hash for u8 {
-    fn hash<H>(self, state: &mut H) where H: Hasher {
+    fn hash<H>(self, state: &mut H)
+    where
+        H: Hasher,
+    {
         H::write(state, self as Field);
     }
 }
 
 impl Hash for u16 {
-    fn hash<H>(self, state: &mut H) where H: Hasher {
+    fn hash<H>(self, state: &mut H)
+    where
+        H: Hasher,
+    {
         H::write(state, self as Field);
     }
 }
 
 impl Hash for u32 {
-    fn hash<H>(self, state: &mut H) where H: Hasher {
+    fn hash<H>(self, state: &mut H)
+    where
+        H: Hasher,
+    {
         H::write(state, self as Field);
     }
 }
 
 impl Hash for u64 {
-    fn hash<H>(self, state: &mut H) where H: Hasher {
+    fn hash<H>(self, state: &mut H)
+    where
+        H: Hasher,
+    {
         H::write(state, self as Field);
     }
 }
 
 impl Hash for i8 {
-    fn hash<H>(self, state: &mut H) where H: Hasher {
+    fn hash<H>(self, state: &mut H)
+    where
+        H: Hasher,
+    {
         H::write(state, self as Field);
     }
 }
 
 impl Hash for i16 {
-    fn hash<H>(self, state: &mut H) where H: Hasher {
+    fn hash<H>(self, state: &mut H)
+    where
+        H: Hasher,
+    {
         H::write(state, self as Field);
     }
 }
 
 impl Hash for i32 {
-    fn hash<H>(self, state: &mut H) where H: Hasher {
+    fn hash<H>(self, state: &mut H)
+    where
+        H: Hasher,
+    {
         H::write(state, self as Field);
     }
 }
 
 impl Hash for i64 {
-    fn hash<H>(self, state: &mut H) where H: Hasher {
+    fn hash<H>(self, state: &mut H)
+    where
+        H: Hasher,
+    {
         H::write(state, self as Field);
     }
 }
 
 impl Hash for bool {
-    fn hash<H>(self, state: &mut H) where H: Hasher {
+    fn hash<H>(self, state: &mut H)
+    where
+        H: Hasher,
+    {
         H::write(state, self as Field);
     }
 }
 
 impl Hash for () {
-    fn hash<H>(_self: Self, _state: &mut H) where H: Hasher {}
+    fn hash<H>(_self: Self, _state: &mut H)
+    where
+        H: Hasher,
+    {}
 }
 
 impl Hash for U128 {
-    fn hash<H>(self, state: &mut H) where H: Hasher {
+    fn hash<H>(self, state: &mut H)
+    where
+        H: Hasher,
+    {
         H::write(state, self.lo as Field);
         H::write(state, self.hi as Field);
     }
 }
 
-impl<T, let N: u32> Hash for [T; N] where T: Hash {
-    fn hash<H>(self, state: &mut H) where H: Hasher {
+impl<T, let N: u32> Hash for [T; N]
+where
+    T: Hash,
+{
+    fn hash<H>(self, state: &mut H)
+    where
+        H: Hasher,
+    {
         for elem in self {
             elem.hash(state);
         }
     }
 }
 
-impl<T> Hash for [T] where T: Hash {
-    fn hash<H>(self, state: &mut H) where H: Hasher {
+impl<T> Hash for [T]
+where
+    T: Hash,
+{
+    fn hash<H>(self, state: &mut H)
+    where
+        H: Hasher,
+    {
         self.len().hash(state);
         for elem in self {
             elem.hash(state);
@@ -275,23 +331,47 @@ impl<T> Hash for [T] where T: Hash {
     }
 }
 
-impl<A, B> Hash for (A, B) where A: Hash, B: Hash {
-    fn hash<H>(self, state: &mut H) where H: Hasher {
+impl<A, B> Hash for (A, B)
+where
+    A: Hash,
+    B: Hash,
+{
+    fn hash<H>(self, state: &mut H)
+    where
+        H: Hasher,
+    {
         self.0.hash(state);
         self.1.hash(state);
     }
 }
 
-impl<A, B, C> Hash for (A, B, C) where A: Hash, B: Hash, C: Hash {
-    fn hash<H>(self, state: &mut H) where H: Hasher {
+impl<A, B, C> Hash for (A, B, C)
+where
+    A: Hash,
+    B: Hash,
+    C: Hash,
+{
+    fn hash<H>(self, state: &mut H)
+    where
+        H: Hasher,
+    {
         self.0.hash(state);
         self.1.hash(state);
         self.2.hash(state);
     }
 }
 
-impl<A, B, C, D> Hash for (A, B, C, D) where A: Hash, B: Hash, C: Hash, D: Hash {
-    fn hash<H>(self, state: &mut H) where H: Hasher {
+impl<A, B, C, D> Hash for (A, B, C, D)
+where
+    A: Hash,
+    B: Hash,
+    C: Hash,
+    D: Hash,
+{
+    fn hash<H>(self, state: &mut H)
+    where
+        H: Hasher,
+    {
         self.0.hash(state);
         self.1.hash(state);
         self.2.hash(state);
@@ -299,8 +379,18 @@ impl<A, B, C, D> Hash for (A, B, C, D) where A: Hash, B: Hash, C: Hash, D: Hash
     }
 }
 
-impl<A, B, C, D, E> Hash for (A, B, C, D, E) where A: Hash, B: Hash, C: Hash, D: Hash, E: Hash {
-    fn hash<H>(self, state: &mut H) where H: Hasher {
+impl<A, B, C, D, E> Hash for (A, B, C, D, E)
+where
+    A: Hash,
+    B: Hash,
+    C: Hash,
+    D: Hash,
+    E: Hash,
+{
+    fn hash<H>(self, state: &mut H)
+    where
+        H: Hasher,
+    {
         self.0.hash(state);
         self.1.hash(state);
         self.2.hash(state);
@@ -315,104 +405,124 @@ impl<A, B, C, D, E> Hash for (A, B, C, D, E) where A: Hash, B: Hash, C: Hash, D:
 #[test]
 fn assert_pedersen() {
     assert_eq(
-        pedersen_hash_with_separator([1], 1), 0x1b3f4b1a83092a13d8d1a59f7acb62aba15e7002f4440f2275edb99ebbc2305f
+        pedersen_hash_with_separator([1], 1),
+        0x1b3f4b1a83092a13d8d1a59f7acb62aba15e7002f4440f2275edb99ebbc2305f,
     );
     assert_eq(
-        pedersen_commitment_with_separator([1], 1), EmbeddedCurvePoint {
-        x: 0x054aa86a73cb8a34525e5bbed6e43ba1198e860f5f3950268f71df4591bde402,
-        y: 0x209dcfbf2cfb57f9f6046f44d71ac6faf87254afc7407c04eb621a6287cac126,
-        is_infinite: false
-    }
+        pedersen_commitment_with_separator([1], 1),
+        EmbeddedCurvePoint {
+            x: 0x054aa86a73cb8a34525e5bbed6e43ba1198e860f5f3950268f71df4591bde402,
+            y: 0x209dcfbf2cfb57f9f6046f44d71ac6faf87254afc7407c04eb621a6287cac126,
+            is_infinite: false,
+        },
     );
 
     assert_eq(
-        pedersen_hash_with_separator([1, 2], 2), 0x26691c129448e9ace0c66d11f0a16d9014a9e8498ee78f4d69f0083168188255
+        pedersen_hash_with_separator([1, 2], 2),
+        0x26691c129448e9ace0c66d11f0a16d9014a9e8498ee78f4d69f0083168188255,
     );
     assert_eq(
-        pedersen_commitment_with_separator([1, 2], 2), EmbeddedCurvePoint {
-        x: 0x2e2b3b191e49541fe468ec6877721d445dcaffe41728df0a0eafeb15e87b0753,
-        y: 0x2ff4482400ad3a6228be17a2af33e2bcdf41be04795f9782bd96efe7e24f8778,
-        is_infinite: false
-    }
+        pedersen_commitment_with_separator([1, 2], 2),
+        EmbeddedCurvePoint {
+            x: 0x2e2b3b191e49541fe468ec6877721d445dcaffe41728df0a0eafeb15e87b0753,
+            y: 0x2ff4482400ad3a6228be17a2af33e2bcdf41be04795f9782bd96efe7e24f8778,
+            is_infinite: false,
+        },
     );
     assert_eq(
-        pedersen_hash_with_separator([1, 2, 3], 3), 0x0bc694b7a1f8d10d2d8987d07433f26bd616a2d351bc79a3c540d85b6206dbe4
+        pedersen_hash_with_separator([1, 2, 3], 3),
+        0x0bc694b7a1f8d10d2d8987d07433f26bd616a2d351bc79a3c540d85b6206dbe4,
     );
     assert_eq(
-        pedersen_commitment_with_separator([1, 2, 3], 3), EmbeddedCurvePoint {
-        x: 0x1fee4e8cf8d2f527caa2684236b07c4b1bad7342c01b0f75e9a877a71827dc85,
-        y: 0x2f9fedb9a090697ab69bf04c8bc15f7385b3e4b68c849c1536e5ae15ff138fd1,
-        is_infinite: false
-    }
+        pedersen_commitment_with_separator([1, 2, 3], 3),
+        EmbeddedCurvePoint {
+            x: 0x1fee4e8cf8d2f527caa2684236b07c4b1bad7342c01b0f75e9a877a71827dc85,
+            y: 0x2f9fedb9a090697ab69bf04c8bc15f7385b3e4b68c849c1536e5ae15ff138fd1,
+            is_infinite: false,
+        },
     );
     assert_eq(
-        pedersen_hash_with_separator([1, 2, 3, 4], 4), 0xdae10fb32a8408521803905981a2b300d6a35e40e798743e9322b223a5eddc
+        pedersen_hash_with_separator([1, 2, 3, 4], 4),
+        0xdae10fb32a8408521803905981a2b300d6a35e40e798743e9322b223a5eddc,
     );
     assert_eq(
-        pedersen_commitment_with_separator([1, 2, 3, 4], 4), EmbeddedCurvePoint {
-        x: 0x07ae3e202811e1fca39c2d81eabe6f79183978e6f12be0d3b8eda095b79bdbc9,
-        y: 0x0afc6f892593db6fbba60f2da558517e279e0ae04f95758587760ba193145014,
-        is_infinite: false
-    }
+        pedersen_commitment_with_separator([1, 2, 3, 4], 4),
+        EmbeddedCurvePoint {
+            x: 0x07ae3e202811e1fca39c2d81eabe6f79183978e6f12be0d3b8eda095b79bdbc9,
+            y: 0x0afc6f892593db6fbba60f2da558517e279e0ae04f95758587760ba193145014,
+            is_infinite: false,
+        },
     );
     assert_eq(
-        pedersen_hash_with_separator([1, 2, 3, 4, 5], 5), 0xfc375b062c4f4f0150f7100dfb8d9b72a6d28582dd9512390b0497cdad9c22
+        pedersen_hash_with_separator([1, 2, 3, 4, 5], 5),
+        0xfc375b062c4f4f0150f7100dfb8d9b72a6d28582dd9512390b0497cdad9c22,
     );
     assert_eq(
-        pedersen_commitment_with_separator([1, 2, 3, 4, 5], 5), EmbeddedCurvePoint {
-        x: 0x1754b12bd475a6984a1094b5109eeca9838f4f81ac89c5f0a41dbce53189bb29,
-        y: 0x2da030e3cfcdc7ddad80eaf2599df6692cae0717d4e9f7bfbee8d073d5d278f7,
-        is_infinite: false
-    }
+        pedersen_commitment_with_separator([1, 2, 3, 4, 5], 5),
+        EmbeddedCurvePoint {
+            x: 0x1754b12bd475a6984a1094b5109eeca9838f4f81ac89c5f0a41dbce53189bb29,
+            y: 0x2da030e3cfcdc7ddad80eaf2599df6692cae0717d4e9f7bfbee8d073d5d278f7,
+            is_infinite: false,
+        },
     );
     assert_eq(
-        pedersen_hash_with_separator([1, 2, 3, 4, 5, 6], 6), 0x1696ed13dc2730062a98ac9d8f9de0661bb98829c7582f699d0273b18c86a572
+        pedersen_hash_with_separator([1, 2, 3, 4, 5, 6], 6),
+        0x1696ed13dc2730062a98ac9d8f9de0661bb98829c7582f699d0273b18c86a572,
     );
     assert_eq(
-        pedersen_commitment_with_separator([1, 2, 3, 4, 5, 6], 6), EmbeddedCurvePoint {
-        x: 0x190f6c0e97ad83e1e28da22a98aae156da083c5a4100e929b77e750d3106a697,
-        y: 0x1f4b60f34ef91221a0b49756fa0705da93311a61af73d37a0c458877706616fb,
-        is_infinite: false
-    }
+        pedersen_commitment_with_separator([1, 2, 3, 4, 5, 6], 6),
+        EmbeddedCurvePoint {
+            x: 0x190f6c0e97ad83e1e28da22a98aae156da083c5a4100e929b77e750d3106a697,
+            y: 0x1f4b60f34ef91221a0b49756fa0705da93311a61af73d37a0c458877706616fb,
+            is_infinite: false,
+        },
     );
     assert_eq(
-        pedersen_hash_with_separator([1, 2, 3, 4, 5, 6, 7], 7), 0x128c0ff144fc66b6cb60eeac8a38e23da52992fc427b92397a7dffd71c45ede3
+        pedersen_hash_with_separator([1, 2, 3, 4, 5, 6, 7], 7),
+        0x128c0ff144fc66b6cb60eeac8a38e23da52992fc427b92397a7dffd71c45ede3,
     );
     assert_eq(
-        pedersen_commitment_with_separator([1, 2, 3, 4, 5, 6, 7], 7), EmbeddedCurvePoint {
-        x: 0x015441e9d29491b06563fac16fc76abf7a9534c715421d0de85d20dbe2965939,
-        y: 0x1d2575b0276f4e9087e6e07c2cb75aa1baafad127af4be5918ef8a2ef2fea8fc,
-        is_infinite: false
-    }
+        pedersen_commitment_with_separator([1, 2, 3, 4, 5, 6, 7], 7),
+        EmbeddedCurvePoint {
+            x: 0x015441e9d29491b06563fac16fc76abf7a9534c715421d0de85d20dbe2965939,
+            y: 0x1d2575b0276f4e9087e6e07c2cb75aa1baafad127af4be5918ef8a2ef2fea8fc,
+            is_infinite: false,
+        },
     );
     assert_eq(
-        pedersen_hash_with_separator([1, 2, 3, 4, 5, 6, 7, 8], 8), 0x2f960e117482044dfc99d12fece2ef6862fba9242be4846c7c9a3e854325a55c
+        pedersen_hash_with_separator([1, 2, 3, 4, 5, 6, 7, 8], 8),
+        0x2f960e117482044dfc99d12fece2ef6862fba9242be4846c7c9a3e854325a55c,
     );
     assert_eq(
-        pedersen_commitment_with_separator([1, 2, 3, 4, 5, 6, 7, 8], 8), EmbeddedCurvePoint {
-        x: 0x1657737676968887fceb6dd516382ea13b3a2c557f509811cd86d5d1199bc443,
-        y: 0x1f39f0cb569040105fa1e2f156521e8b8e08261e635a2b210bdc94e8d6d65f77,
-        is_infinite: false
-    }
+        pedersen_commitment_with_separator([1, 2, 3, 4, 5, 6, 7, 8], 8),
+        EmbeddedCurvePoint {
+            x: 0x1657737676968887fceb6dd516382ea13b3a2c557f509811cd86d5d1199bc443,
+            y: 0x1f39f0cb569040105fa1e2f156521e8b8e08261e635a2b210bdc94e8d6d65f77,
+            is_infinite: false,
+        },
     );
     assert_eq(
-        pedersen_hash_with_separator([1, 2, 3, 4, 5, 6, 7, 8, 9], 9), 0x0c96db0790602dcb166cc4699e2d306c479a76926b81c2cb2aaa92d249ec7be7
+        pedersen_hash_with_separator([1, 2, 3, 4, 5, 6, 7, 8, 9], 9),
+        0x0c96db0790602dcb166cc4699e2d306c479a76926b81c2cb2aaa92d249ec7be7,
     );
     assert_eq(
-        pedersen_commitment_with_separator([1, 2, 3, 4, 5, 6, 7, 8, 9], 9), EmbeddedCurvePoint {
-        x: 0x0a3ceae42d14914a432aa60ec7fded4af7dad7dd4acdbf2908452675ec67e06d,
-        y: 0xfc19761eaaf621ad4aec9a8b2e84a4eceffdba78f60f8b9391b0bd9345a2f2,
-        is_infinite: false
-    }
+        pedersen_commitment_with_separator([1, 2, 3, 4, 5, 6, 7, 8, 9], 9),
+        EmbeddedCurvePoint {
+            x: 0x0a3ceae42d14914a432aa60ec7fded4af7dad7dd4acdbf2908452675ec67e06d,
+            y: 0xfc19761eaaf621ad4aec9a8b2e84a4eceffdba78f60f8b9391b0bd9345a2f2,
+            is_infinite: false,
+        },
     );
     assert_eq(
-        pedersen_hash_with_separator([1, 2, 3, 4, 5, 6, 7, 8, 9, 10], 10), 0x2cd37505871bc460a62ea1e63c7fe51149df5d0801302cf1cbc48beb8dff7e94
+        pedersen_hash_with_separator([1, 2, 3, 4, 5, 6, 7, 8, 9, 10], 10),
+        0x2cd37505871bc460a62ea1e63c7fe51149df5d0801302cf1cbc48beb8dff7e94,
     );
     assert_eq(
-        pedersen_commitment_with_separator([1, 2, 3, 4, 5, 6, 7, 8, 9, 10], 10), EmbeddedCurvePoint {
-        x: 0x2fb3f8b3d41ddde007c8c3c62550f9a9380ee546fcc639ffbb3fd30c8d8de30c,
-        y: 0x300783be23c446b11a4c0fabf6c91af148937cea15fcf5fb054abf7f752ee245,
-        is_infinite: false
-    }
+        pedersen_commitment_with_separator([1, 2, 3, 4, 5, 6, 7, 8, 9, 10], 10),
+        EmbeddedCurvePoint {
+            x: 0x2fb3f8b3d41ddde007c8c3c62550f9a9380ee546fcc639ffbb3fd30c8d8de30c,
+            y: 0x300783be23c446b11a4c0fabf6c91af148937cea15fcf5fb054abf7f752ee245,
+            is_infinite: false,
+        },
     );
 }
diff --git a/noir_stdlib/src/hash/poseidon/bn254.nr b/noir_stdlib/src/hash/poseidon/bn254.nr
index ce4b904ed5c..23591fb69c8 100644
--- a/noir_stdlib/src/hash/poseidon/bn254.nr
+++ b/noir_stdlib/src/hash/poseidon/bn254.nr
@@ -16,7 +16,7 @@ pub fn sponge<let N: u32>(msg: [Field; N]) -> Field {
 pub fn hash_1(input: [Field; 1]) -> Field {
     let mut state = [0; 2];
     for i in 0..input.len() {
-        state[i+1] = input[i];
+        state[i + 1] = input[i];
     }
 
     perm::x5_2(state)[0]
@@ -26,7 +26,7 @@ pub fn hash_1(input: [Field; 1]) -> Field {
 pub fn hash_2(input: [Field; 2]) -> Field {
     let mut state = [0; 3];
     for i in 0..input.len() {
-        state[i+1] = input[i];
+        state[i + 1] = input[i];
     }
 
     perm::x5_3(state)[0]
@@ -36,7 +36,7 @@ pub fn hash_2(input: [Field; 2]) -> Field {
 pub fn hash_3(input: [Field; 3]) -> Field {
     let mut state = [0; 4];
     for i in 0..input.len() {
-        state[i+1] = input[i];
+        state[i + 1] = input[i];
     }
 
     perm::x5_4(state)[0]
@@ -46,7 +46,7 @@ pub fn hash_3(input: [Field; 3]) -> Field {
 pub fn hash_4(input: [Field; 4]) -> Field {
     let mut state = [0; 5];
     for i in 0..input.len() {
-        state[i+1] = input[i];
+        state[i + 1] = input[i];
     }
 
     perm::x5_5(state)[0]
@@ -56,7 +56,7 @@ pub fn hash_4(input: [Field; 4]) -> Field {
 pub fn hash_5(input: [Field; 5]) -> Field {
     let mut state = [0; 6];
     for i in 0..input.len() {
-        state[i+1] = input[i];
+        state[i + 1] = input[i];
     }
 
     perm::x5_6(state)[0]
@@ -66,7 +66,7 @@ pub fn hash_5(input: [Field; 5]) -> Field {
 pub fn hash_6(input: [Field; 6]) -> Field {
     let mut state = [0; 7];
     for i in 0..input.len() {
-        state[i+1] = input[i];
+        state[i + 1] = input[i];
     }
 
     perm::x5_7(state)[0]
@@ -76,7 +76,7 @@ pub fn hash_6(input: [Field; 6]) -> Field {
 pub fn hash_7(input: [Field; 7]) -> Field {
     let mut state = [0; 8];
     for i in 0..input.len() {
-        state[i+1] = input[i];
+        state[i + 1] = input[i];
     }
 
     perm::x5_8(state)[0]
@@ -86,7 +86,7 @@ pub fn hash_7(input: [Field; 7]) -> Field {
 pub fn hash_8(input: [Field; 8]) -> Field {
     let mut state = [0; 9];
     for i in 0..input.len() {
-        state[i+1] = input[i];
+        state[i + 1] = input[i];
     }
 
     perm::x5_9(state)[0]
@@ -96,7 +96,7 @@ pub fn hash_8(input: [Field; 8]) -> Field {
 pub fn hash_9(input: [Field; 9]) -> Field {
     let mut state = [0; 10];
     for i in 0..input.len() {
-        state[i+1] = input[i];
+        state[i + 1] = input[i];
     }
 
     perm::x5_10(state)[0]
@@ -106,7 +106,7 @@ pub fn hash_9(input: [Field; 9]) -> Field {
 pub fn hash_10(input: [Field; 10]) -> Field {
     let mut state = [0; 11];
     for i in 0..input.len() {
-        state[i+1] = input[i];
+        state[i + 1] = input[i];
     }
 
     perm::x5_11(state)[0]
@@ -116,7 +116,7 @@ pub fn hash_10(input: [Field; 10]) -> Field {
 pub fn hash_11(input: [Field; 11]) -> Field {
     let mut state = [0; 12];
     for i in 0..input.len() {
-        state[i+1] = input[i];
+        state[i + 1] = input[i];
     }
 
     perm::x5_12(state)[0]
@@ -126,7 +126,7 @@ pub fn hash_11(input: [Field; 11]) -> Field {
 pub fn hash_12(input: [Field; 12]) -> Field {
     let mut state = [0; 13];
     for i in 0..input.len() {
-        state[i+1] = input[i];
+        state[i + 1] = input[i];
     }
 
     perm::x5_13(state)[0]
@@ -136,7 +136,7 @@ pub fn hash_12(input: [Field; 12]) -> Field {
 pub fn hash_13(input: [Field; 13]) -> Field {
     let mut state = [0; 14];
     for i in 0..input.len() {
-        state[i+1] = input[i];
+        state[i + 1] = input[i];
     }
 
     perm::x5_14(state)[0]
@@ -146,7 +146,7 @@ pub fn hash_13(input: [Field; 13]) -> Field {
 pub fn hash_14(input: [Field; 14]) -> Field {
     let mut state = [0; 15];
     for i in 0..input.len() {
-        state[i+1] = input[i];
+        state[i + 1] = input[i];
     }
 
     perm::x5_15(state)[0]
@@ -156,7 +156,7 @@ pub fn hash_14(input: [Field; 14]) -> Field {
 pub fn hash_15(input: [Field; 15]) -> Field {
     let mut state = [0; 16];
     for i in 0..input.len() {
-        state[i+1] = input[i];
+        state[i + 1] = input[i];
     }
 
     perm::x5_16(state)[0]
@@ -166,7 +166,7 @@ pub fn hash_15(input: [Field; 15]) -> Field {
 pub fn hash_16(input: [Field; 16]) -> Field {
     let mut state = [0; 17];
     for i in 0..input.len() {
-        state[i+1] = input[i];
+        state[i + 1] = input[i];
     }
 
     perm::x5_17(state)[0]
diff --git a/noir_stdlib/src/hash/poseidon/bn254/consts.nr b/noir_stdlib/src/hash/poseidon/bn254/consts.nr
index 3b28ced5835..42df0ef662f 100644
--- a/noir_stdlib/src/hash/poseidon/bn254/consts.nr
+++ b/noir_stdlib/src/hash/poseidon/bn254/consts.nr
@@ -1,10 +1,9 @@
 // Parameters are generated by a reference script https://extgit.iaik.tugraz.at/krypto/hadeshash/-/blob/master/code/generate_parameters_grain.sage
 // Used like so: sage generate_parameters_grain.sage 1 0 254 2 8 56 0x30644e72e131a029b85045b68181585d2833e84879b9709143e1f593f0000001
-
 // Constants for various Poseidon instances in the case of the prime field of the same order as BN254.
 // Consistent with https://github.com/iden3/circomlib/blob/master/circuits/poseidon.circom and https://github.com/iden3/circomlib/blob/master/circuits/poseidon_constants.circom
-use crate::hash::poseidon::PoseidonConfig;
 use crate::hash::poseidon::config;
+use crate::hash::poseidon::PoseidonConfig;
 // S-box power
 fn alpha() -> Field {
     5
diff --git a/noir_stdlib/src/hash/poseidon/bn254/perm.nr b/noir_stdlib/src/hash/poseidon/bn254/perm.nr
index b7dc05ef9de..3a12f59fe77 100644
--- a/noir_stdlib/src/hash/poseidon/bn254/perm.nr
+++ b/noir_stdlib/src/hash/poseidon/bn254/perm.nr
@@ -4,144 +4,112 @@ use crate::hash::poseidon::permute;
 
 #[field(bn254)]
 pub fn x5_2(mut state: [Field; 2]) -> [Field; 2] {
-    state = permute(
-        consts::x5_2_config(),
-        state);
+    state = permute(consts::x5_2_config(), state);
 
     state
 }
 
 #[field(bn254)]
 pub fn x5_3(mut state: [Field; 3]) -> [Field; 3] {
-    state = permute(
-        consts::x5_3_config(),
-        state);
+    state = permute(consts::x5_3_config(), state);
 
     state
 }
 
 #[field(bn254)]
 pub fn x5_4(mut state: [Field; 4]) -> [Field; 4] {
-    state = permute(
-        consts::x5_4_config(),
-        state);
+    state = permute(consts::x5_4_config(), state);
 
     state
 }
 
 #[field(bn254)]
 pub fn x5_5(mut state: [Field; 5]) -> [Field; 5] {
-    state = permute(
-        consts::x5_5_config(),
-        state);
+    state = permute(consts::x5_5_config(), state);
 
     state
 }
 
 #[field(bn254)]
 pub fn x5_6(mut state: [Field; 6]) -> [Field; 6] {
-    state = permute(
-        consts::x5_6_config(),
-        state);
+    state = permute(consts::x5_6_config(), state);
 
     state
 }
 
 #[field(bn254)]
 pub fn x5_7(mut state: [Field; 7]) -> [Field; 7] {
-    state = permute(
-        consts::x5_7_config(),
-        state);
+    state = permute(consts::x5_7_config(), state);
 
     state
 }
 
 #[field(bn254)]
 pub fn x5_8(mut state: [Field; 8]) -> [Field; 8] {
-    state = permute(
-        consts::x5_8_config(),
-        state);
+    state = permute(consts::x5_8_config(), state);
 
     state
 }
 
 #[field(bn254)]
 pub fn x5_9(mut state: [Field; 9]) -> [Field; 9] {
-    state = permute(
-        consts::x5_9_config(),
-        state);
+    state = permute(consts::x5_9_config(), state);
 
     state
 }
 
 #[field(bn254)]
 pub fn x5_10(mut state: [Field; 10]) -> [Field; 10] {
-    state = permute(
-        consts::x5_10_config(),
-        state);
+    state = permute(consts::x5_10_config(), state);
 
     state
 }
 
 #[field(bn254)]
 pub fn x5_11(mut state: [Field; 11]) -> [Field; 11] {
-    state = permute(
-        consts::x5_11_config(),
-        state);
+    state = permute(consts::x5_11_config(), state);
 
     state
 }
 
 #[field(bn254)]
 pub fn x5_12(mut state: [Field; 12]) -> [Field; 12] {
-    state = permute(
-        consts::x5_12_config(),
-        state);
+    state = permute(consts::x5_12_config(), state);
 
     state
 }
 
 #[field(bn254)]
 pub fn x5_13(mut state: [Field; 13]) -> [Field; 13] {
-    state = permute(
-        consts::x5_13_config(),
-        state);
+    state = permute(consts::x5_13_config(), state);
 
     state
 }
 
 #[field(bn254)]
 pub fn x5_14(mut state: [Field; 14]) -> [Field; 14] {
-    state = permute(
-        consts::x5_14_config(),
-        state);
+    state = permute(consts::x5_14_config(), state);
 
     state
 }
 
 #[field(bn254)]
 pub fn x5_15(mut state: [Field; 15]) -> [Field; 15] {
-    state = permute(
-        consts::x5_15_config(),
-        state);
+    state = permute(consts::x5_15_config(), state);
 
     state
 }
 
 #[field(bn254)]
 pub fn x5_16(mut state: [Field; 16]) -> [Field; 16] {
-    state = permute(
-        consts::x5_16_config(),
-        state);
+    state = permute(consts::x5_16_config(), state);
 
     state
 }
 
 #[field(bn254)]
 pub fn x5_17(mut state: [Field; 17]) -> [Field; 17] {
-    state = permute(
-        consts::x5_17_config(),
-        state);
+    state = permute(consts::x5_17_config(), state);
 
     state
 }
diff --git a/noir_stdlib/src/hash/poseidon/mod.nr b/noir_stdlib/src/hash/poseidon/mod.nr
index 9553d352d28..e2e47959024 100644
--- a/noir_stdlib/src/hash/poseidon/mod.nr
+++ b/noir_stdlib/src/hash/poseidon/mod.nr
@@ -1,18 +1,18 @@
 pub mod bn254; // Instantiations of Poseidon for prime field of the same order as BN254
-use crate::hash::Hasher;
 use crate::default::Default;
+use crate::hash::Hasher;
 
 // A config struct defining the parameters of the Poseidon instance to use.
 //
 // A thorough writeup of this method (along with an unoptimized method) can be found at: https://spec.filecoin.io/algorithms/crypto/poseidon/
-pub struct PoseidonConfig<let T: u32, let N: u32, let X: u32> { 
+pub struct PoseidonConfig<let T: u32, let N: u32, let X: u32> {
     // State width, should be equal to `T`
     t: Field,
     // Number of full rounds. should be even
     rf: u8,
     // Number of partial rounds
     rp: u8,
-     // S-box power; depends on the underlying field
+    // S-box power; depends on the underlying field
     alpha: Field,
     // The round constants for the
     round_constants: [Field; N],
@@ -35,7 +35,7 @@ pub fn config<let T: u32, let N: u32, let X: u32>(
     round_constants: [Field; N],
     mds: [[Field; T]; T],
     presparse_mds: [[Field; T]; T],
-    sparse_mds: [Field; X]
+    sparse_mds: [Field; X],
 ) -> PoseidonConfig<T, N, X> {
     // Input checks
     assert_eq(rf & 1, 0);
@@ -48,9 +48,10 @@ pub fn config<let T: u32, let N: u32, let X: u32>(
 
 pub fn permute<let T: u32, let N: u32, let X: u32>(
     pos_conf: PoseidonConfig<T, N, X>,
-    mut state: [Field; T]
+    mut state: [Field; T],
 ) -> [Field; T] {
-    let PoseidonConfig {t, rf, rp, alpha, round_constants, mds, presparse_mds, sparse_mds } = pos_conf;
+    let PoseidonConfig { t, rf, rp, alpha, round_constants, mds, presparse_mds, sparse_mds } =
+        pos_conf;
 
     for i in 0..state.len() {
         state[i] += round_constants[i];
@@ -76,7 +77,7 @@ pub fn permute<let T: u32, let N: u32, let X: u32>(
 
     for _r in 0..rp {
         state[0] = state[0].pow_32(alpha);
-        state[0] += round_constants[(rf/2 + 1) as u32 * T + _r as u32];
+        state[0] += round_constants[(rf / 2 + 1) as u32 * T + _r as u32];
         crate::as_witness(state[0]);
         {
             let mut newState0 = 0;
@@ -99,7 +100,7 @@ pub fn permute<let T: u32, let N: u32, let X: u32>(
     for _r in 0..rf / 2 - 1 {
         state = sigma(state);
         for i in 0..state.len() {
-            state[i] += round_constants[(rf/2+1) as u32 * T + rp as u32 + (_r as u32) * T + i];
+            state[i] += round_constants[(rf / 2 + 1) as u32 * T + rp as u32 + (_r as u32) * T + i];
         }
         state = apply_matrix(mds, state);
     }
@@ -130,7 +131,7 @@ fn absorb<let T: u32, let N: u32, let X: u32, let O: u32>(
     mut state: [Field; T],
     rate: Field,
     capacity: Field,
-    msg: [Field; O] // Arbitrary length message
+    msg: [Field; O], // Arbitrary length message
 ) -> [Field; T] {
     assert_eq(pos_conf.t, rate + capacity);
 
@@ -139,7 +140,7 @@ fn absorb<let T: u32, let N: u32, let X: u32, let O: u32>(
     for k in 0..msg.len() {
         // Add current block to state
         state[capacity + i] += msg[k];
-        i = i+1;
+        i = i + 1;
         // Enough to absorb
         if i == rate {
             state = permute(pos_conf, state);
@@ -165,7 +166,7 @@ fn sigma<let O: u32>(x: [Field; O]) -> [Field; O] {
     y
 }
 
-pub struct PoseidonHasher{
+pub struct PoseidonHasher {
     _state: [Field],
 }
 
@@ -179,51 +180,173 @@ impl Hasher for PoseidonHasher {
             result = bn254::hash_1([self._state[0]]);
         }
         if len == 2 {
-            result = bn254::hash_2([self._state[0],self._state[1]]);
+            result = bn254::hash_2([self._state[0], self._state[1]]);
         }
         if len == 3 {
-            result = bn254::hash_3([self._state[0],self._state[1],self._state[2]]);
+            result = bn254::hash_3([self._state[0], self._state[1], self._state[2]]);
         }
         if len == 4 {
-            result = bn254::hash_4([self._state[0],self._state[1],self._state[2],self._state[3]]);
+            result = bn254::hash_4([self._state[0], self._state[1], self._state[2], self._state[3]]);
         }
         if len == 5 {
-            result = bn254::hash_5([self._state[0],self._state[1],self._state[2],self._state[3],self._state[4]]);
+            result = bn254::hash_5([
+                self._state[0],
+                self._state[1],
+                self._state[2],
+                self._state[3],
+                self._state[4],
+            ]);
         }
         if len == 6 {
-            result = bn254::hash_6([self._state[0],self._state[1],self._state[2],self._state[3],self._state[4], self._state[5]]);
+            result = bn254::hash_6([
+                self._state[0],
+                self._state[1],
+                self._state[2],
+                self._state[3],
+                self._state[4],
+                self._state[5],
+            ]);
         }
         if len == 7 {
-            result = bn254::hash_7([self._state[0],self._state[1],self._state[2],self._state[3],self._state[4], self._state[5], self._state[6]]);
+            result = bn254::hash_7([
+                self._state[0],
+                self._state[1],
+                self._state[2],
+                self._state[3],
+                self._state[4],
+                self._state[5],
+                self._state[6],
+            ]);
         }
         if len == 8 {
-            result = bn254::hash_8([self._state[0],self._state[1],self._state[2],self._state[3],self._state[4], self._state[5], self._state[6], self._state[7]]);
+            result = bn254::hash_8([
+                self._state[0],
+                self._state[1],
+                self._state[2],
+                self._state[3],
+                self._state[4],
+                self._state[5],
+                self._state[6],
+                self._state[7],
+            ]);
         }
         if len == 9 {
-            result = bn254::hash_9([self._state[0],self._state[1],self._state[2],self._state[3],self._state[4], self._state[5], self._state[6], self._state[7], self._state[8]]);
+            result = bn254::hash_9([
+                self._state[0],
+                self._state[1],
+                self._state[2],
+                self._state[3],
+                self._state[4],
+                self._state[5],
+                self._state[6],
+                self._state[7],
+                self._state[8],
+            ]);
         }
         if len == 10 {
-            result = bn254::hash_10([self._state[0],self._state[1],self._state[2],self._state[3],self._state[4], self._state[5], self._state[6], self._state[7], self._state[8], self._state[9]]);
+            result = bn254::hash_10([
+                self._state[0],
+                self._state[1],
+                self._state[2],
+                self._state[3],
+                self._state[4],
+                self._state[5],
+                self._state[6],
+                self._state[7],
+                self._state[8],
+                self._state[9],
+            ]);
         }
         if len == 11 {
-            result = bn254::hash_11([self._state[0],self._state[1],self._state[2],self._state[3],self._state[4], self._state[5], self._state[6], self._state[7], self._state[8], self._state[9], self._state[10]]);
+            result = bn254::hash_11([
+                self._state[0],
+                self._state[1],
+                self._state[2],
+                self._state[3],
+                self._state[4],
+                self._state[5],
+                self._state[6],
+                self._state[7],
+                self._state[8],
+                self._state[9],
+                self._state[10],
+            ]);
         }
         if len == 12 {
-            result = bn254::hash_12([self._state[0],self._state[1],self._state[2],self._state[3],self._state[4], self._state[5], self._state[6], self._state[7], self._state[8], self._state[9], self._state[10], self._state[11]]);
+            result = bn254::hash_12([
+                self._state[0],
+                self._state[1],
+                self._state[2],
+                self._state[3],
+                self._state[4],
+                self._state[5],
+                self._state[6],
+                self._state[7],
+                self._state[8],
+                self._state[9],
+                self._state[10],
+                self._state[11],
+            ]);
         }
         if len == 13 {
-            result = bn254::hash_13([self._state[0],self._state[1],self._state[2],self._state[3],self._state[4], self._state[5], self._state[6], self._state[7], self._state[8], self._state[9], self._state[10], self._state[11], self._state[12]]);
+            result = bn254::hash_13([
+                self._state[0],
+                self._state[1],
+                self._state[2],
+                self._state[3],
+                self._state[4],
+                self._state[5],
+                self._state[6],
+                self._state[7],
+                self._state[8],
+                self._state[9],
+                self._state[10],
+                self._state[11],
+                self._state[12],
+            ]);
         }
         if len == 14 {
-            result = bn254::hash_14([self._state[0],self._state[1],self._state[2],self._state[3],self._state[4], self._state[5], self._state[6], self._state[7], self._state[8], self._state[9], self._state[10], self._state[11], self._state[12], self._state[13]]);
+            result = bn254::hash_14([
+                self._state[0],
+                self._state[1],
+                self._state[2],
+                self._state[3],
+                self._state[4],
+                self._state[5],
+                self._state[6],
+                self._state[7],
+                self._state[8],
+                self._state[9],
+                self._state[10],
+                self._state[11],
+                self._state[12],
+                self._state[13],
+            ]);
         }
         if len == 15 {
-            result = bn254::hash_15([self._state[0],self._state[1],self._state[2],self._state[3],self._state[4], self._state[5], self._state[6], self._state[7], self._state[8], self._state[9], self._state[10], self._state[11], self._state[12], self._state[13], self._state[14]]);
+            result = bn254::hash_15([
+                self._state[0],
+                self._state[1],
+                self._state[2],
+                self._state[3],
+                self._state[4],
+                self._state[5],
+                self._state[6],
+                self._state[7],
+                self._state[8],
+                self._state[9],
+                self._state[10],
+                self._state[11],
+                self._state[12],
+                self._state[13],
+                self._state[14],
+            ]);
         }
 
         result
     }
 
+    #[inline_always]
     fn write(&mut self, input: Field) {
         self._state = self._state.push_back(input);
     }
@@ -244,17 +367,29 @@ mod poseidon_tests {
         {
             let mut state = [0, 1, 2];
             let mut expected = [
-                0x115cc0f5e7d690413df64c6b9662e9cf2a3617f2743245519e19607a4417189a, 0x0fca49b798923ab0239de1c9e7a4a9a2210312b6a2f616d18b5a87f9b628ae29, 0x0e7ae82e40091e63cbd4f16a6d16310b3729d4b6e138fcf54110e2867045a30c
+                0x115cc0f5e7d690413df64c6b9662e9cf2a3617f2743245519e19607a4417189a,
+                0x0fca49b798923ab0239de1c9e7a4a9a2210312b6a2f616d18b5a87f9b628ae29,
+                0x0e7ae82e40091e63cbd4f16a6d16310b3729d4b6e138fcf54110e2867045a30c,
             ];
-            assert_eq(expected, poseidon::bn254::perm::x5_3(state), "Failed to reproduce output for [0, 1, 2]");
+            assert_eq(
+                expected,
+                poseidon::bn254::perm::x5_3(state),
+                "Failed to reproduce output for [0, 1, 2]",
+            );
         }
         {
             let mut state = [0, 1, 2, 3, 4];
             let mut expected = [
-                0x299c867db6c1fdd79dcefa40e4510b9837e60ebb1ce0663dbaa525df65250465, 0x1148aaef609aa338b27dafd89bb98862d8bb2b429aceac47d86206154ffe053d, 0x24febb87fed7462e23f6665ff9a0111f4044c38ee1672c1ac6b0637d34f24907, 0x0eb08f6d809668a981c186beaf6110060707059576406b248e5d9cf6e78b3d3e, 0x07748bc6877c9b82c8b98666ee9d0626ec7f5be4205f79ee8528ef1c4a376fc7
+                0x299c867db6c1fdd79dcefa40e4510b9837e60ebb1ce0663dbaa525df65250465,
+                0x1148aaef609aa338b27dafd89bb98862d8bb2b429aceac47d86206154ffe053d,
+                0x24febb87fed7462e23f6665ff9a0111f4044c38ee1672c1ac6b0637d34f24907,
+                0x0eb08f6d809668a981c186beaf6110060707059576406b248e5d9cf6e78b3d3e,
+                0x07748bc6877c9b82c8b98666ee9d0626ec7f5be4205f79ee8528ef1c4a376fc7,
             ];
             assert_eq(
-                expected, poseidon::bn254::perm::x5_5(state), "Failed to reproduce output for [0, 1, 2, 3, 4]"
+                expected,
+                poseidon::bn254::perm::x5_5(state),
+                "Failed to reproduce output for [0, 1, 2, 3, 4]",
             );
         }
     }
diff --git a/noir_stdlib/src/hash/poseidon2.nr b/noir_stdlib/src/hash/poseidon2.nr
index 6b61ca32302..419f07a2aca 100644
--- a/noir_stdlib/src/hash/poseidon2.nr
+++ b/noir_stdlib/src/hash/poseidon2.nr
@@ -1,11 +1,11 @@
-use crate::hash::Hasher;
 use crate::default::Default;
+use crate::hash::Hasher;
 
 comptime global RATE: u32 = 3;
 
 pub struct Poseidon2 {
-    cache: [Field;3],
-    state: [Field;4],
+    cache: [Field; 3],
+    state: [Field; 4],
     cache_size: u32,
     squeeze_mode: bool, // 0 => absorb, 1 => squeeze
 }
@@ -13,15 +13,12 @@ pub struct Poseidon2 {
 impl Poseidon2 {
     #[no_predicates]
     pub fn hash<let N: u32>(input: [Field; N], message_size: u32) -> Field {
-        if message_size == N {
-            Poseidon2::hash_internal(input, N, false)
-        } else {
-            Poseidon2::hash_internal(input, message_size, true)
-        }
+        Poseidon2::hash_internal(input, message_size, message_size != N)
     }
 
-    fn new(iv: Field) -> Poseidon2 {
-        let mut result = Poseidon2 { cache: [0; 3], state: [0; 4], cache_size: 0, squeeze_mode: false };
+    pub(crate) fn new(iv: Field) -> Poseidon2 {
+        let mut result =
+            Poseidon2 { cache: [0; 3], state: [0; 4], cache_size: 0, squeeze_mode: false };
         result.state[RATE] = iv;
         result
     }
@@ -62,9 +59,13 @@ impl Poseidon2 {
         self.state[0]
     }
 
-    fn hash_internal<let N: u32>(input: [Field; N], in_len: u32, is_variable_length: bool) -> Field {
+    fn hash_internal<let N: u32>(
+        input: [Field; N],
+        in_len: u32,
+        is_variable_length: bool,
+    ) -> Field {
         let two_pow_64 = 18446744073709551616;
-        let iv : Field = (in_len as Field) * two_pow_64;
+        let iv: Field = (in_len as Field) * two_pow_64;
         let mut sponge = Poseidon2::new(iv);
         for i in 0..input.len() {
             if i < in_len {
@@ -82,13 +83,13 @@ impl Poseidon2 {
     }
 }
 
-pub struct Poseidon2Hasher{
+pub struct Poseidon2Hasher {
     _state: [Field],
 }
 
 impl Hasher for Poseidon2Hasher {
     fn finish(self) -> Field {
-        let iv : Field = (self._state.len() as Field) * 18446744073709551616; // iv = (self._state.len() << 64)
+        let iv: Field = (self._state.len() as Field) * 18446744073709551616; // iv = (self._state.len() << 64)
         let mut sponge = Poseidon2::new(iv);
         for i in 0..self._state.len() {
             sponge.absorb(self._state[i]);
diff --git a/noir_stdlib/src/hash/sha256.nr b/noir_stdlib/src/hash/sha256.nr
index 413c26d6f6b..b9a2b02c9d9 100644
--- a/noir_stdlib/src/hash/sha256.nr
+++ b/noir_stdlib/src/hash/sha256.nr
@@ -3,97 +3,80 @@ use crate::runtime::is_unconstrained;
 // Implementation of SHA-256 mapping a byte array of variable length to
 // 32 bytes.
 
+// A message block is up to 64 bytes taken from the input.
+global BLOCK_SIZE: u32 = 64;
+
+// The first index in the block where the 8 byte message size will be written.
+global MSG_SIZE_PTR: u32 = 56;
+
+// Size of the message block when packed as 4-byte integer array.
+global INT_BLOCK_SIZE: u32 = 16;
+
+// A `u32` integer consists of 4 bytes.
+global INT_SIZE: u32 = 4;
+
+// Index of the integer in the `INT_BLOCK` where the length is written.
+global INT_SIZE_PTR: u32 = MSG_SIZE_PTR / INT_SIZE;
+
+// Magic numbers for bit shifting.
+// Works with actual bit shifting as well as the compiler turns them into * and /
+// but circuit execution appears to be 10% faster this way.
+global TWO_POW_8: u32 = 256;
+global TWO_POW_16: u32 = TWO_POW_8 * 256;
+global TWO_POW_24: u32 = TWO_POW_16 * 256;
+global TWO_POW_32: u64 = TWO_POW_24 as u64 * 256;
+
+// Index of a byte in a 64 byte block; ie. 0..=63
+type BLOCK_BYTE_PTR = u32;
+
+// The foreign function to compress blocks works on 16 pieces of 4-byte integers, instead of 64 bytes.
+type INT_BLOCK = [u32; INT_BLOCK_SIZE];
+
+// A message block is a slice of the original message of a fixed size,
+// potentially padded with zeros, with neighbouring 4 bytes packed into integers.
+type MSG_BLOCK = INT_BLOCK;
+
+// The hash is 32 bytes.
+type HASH = [u8; 32];
+
+// The state accumulates the blocks.
+// Its overall size is the same as the `HASH`.
+type STATE = [u32; 8];
+
 // Deprecated in favour of `sha256_var`
 // docs:start:sha256
-pub fn sha256<let N: u32>(input: [u8; N]) -> [u8; 32]
+pub fn sha256<let N: u32>(input: [u8; N]) -> HASH
 // docs:end:sha256
 {
     digest(input)
 }
 
 #[foreign(sha256_compression)]
-pub fn sha256_compression(_input: [u32; 16], _state: [u32; 8]) -> [u32; 8] {}
+pub fn sha256_compression(_input: INT_BLOCK, _state: STATE) -> STATE {}
 
 // SHA-256 hash function
 #[no_predicates]
-pub fn digest<let N: u32>(msg: [u8; N]) -> [u8; 32] {
+pub fn digest<let N: u32>(msg: [u8; N]) -> HASH {
     sha256_var(msg, N as u64)
 }
 
-// Convert 64-byte array to array of 16 u32s
-fn msg_u8_to_u32(msg: [u8; 64]) -> [u32; 16] {
-    let mut msg32: [u32; 16] = [0; 16];
-
-    for i in 0..16 {
-        let mut msg_field: Field = 0;
-        for j in 0..4 {
-            msg_field = msg_field * 256 + msg[64 - 4*(i + 1) + j] as Field;
-        }
-        msg32[15 - i] = msg_field as u32;
-    }
-
-    msg32
-}
-
-unconstrained fn build_msg_block_iter<let N: u32>(msg: [u8; N], message_size: u32, msg_start: u32) -> ([u8; 64], u32) {
-    let mut msg_block: [u8; BLOCK_SIZE] = [0; BLOCK_SIZE];
-    // We insert `BLOCK_SIZE` bytes (or up to the end of the message)
-    let block_input = if msg_start + BLOCK_SIZE > message_size {
-        if message_size < msg_start {
-            // This function is sometimes called with `msg_start` past the end of the message.
-            // In this case we return an empty block and zero pointer to signal that the result should be ignored.
-            0
-        } else {
-            message_size - msg_start
-        }
-    } else {
-        BLOCK_SIZE
-    };
-    for k in 0..block_input {
-        msg_block[k] = msg[msg_start + k];
-    }
-    (msg_block, block_input)
-}
-
-// Verify the block we are compressing was appropriately constructed
-fn verify_msg_block<let N: u32>(
-    msg: [u8; N],
-    message_size: u32,
-    msg_block: [u8; 64],
-    msg_start: u32
-) -> u32 {
-    let mut msg_byte_ptr: u32 = 0; // Message byte pointer
-    let mut msg_end = msg_start + BLOCK_SIZE;
-    if msg_end > N {
-        msg_end = N;
-    }
-
-    for k in msg_start..msg_end {
-        if k < message_size {
-            assert_eq(msg_block[msg_byte_ptr], msg[k]);
-            msg_byte_ptr = msg_byte_ptr + 1;
-        }
-    }
-
-    msg_byte_ptr
-}
-
-global BLOCK_SIZE = 64;
-global ZERO = 0;
-
 // Variable size SHA-256 hash
-pub fn sha256_var<let N: u32>(msg: [u8; N], message_size: u64) -> [u8; 32] {
+pub fn sha256_var<let N: u32>(msg: [u8; N], message_size: u64) -> HASH {
     let message_size = message_size as u32;
     let num_blocks = N / BLOCK_SIZE;
-    let mut msg_block: [u8; BLOCK_SIZE] = [0; BLOCK_SIZE];
-    let mut h: [u32; 8] = [1779033703, 3144134277, 1013904242, 2773480762, 1359893119, 2600822924, 528734635, 1541459225]; // Intermediate hash, starting with the canonical initial value
-    let mut msg_byte_ptr = 0; // Pointer into msg_block
-
+    let mut msg_block: MSG_BLOCK = [0; INT_BLOCK_SIZE];
+    // Intermediate hash, starting with the canonical initial value
+    let mut h: STATE = [
+        1779033703, 3144134277, 1013904242, 2773480762, 1359893119, 2600822924, 528734635,
+        1541459225,
+    ];
+    // Pointer into msg_block on a 64 byte scale
+    let mut msg_byte_ptr = 0;
     for i in 0..num_blocks {
         let msg_start = BLOCK_SIZE * i;
-        let (new_msg_block, new_msg_byte_ptr) = unsafe {
-            build_msg_block_iter(msg, message_size, msg_start)
-        };
+        let (new_msg_block, new_msg_byte_ptr) =
+            unsafe { build_msg_block(msg, message_size, msg_start) };
+
         if msg_start < message_size {
             msg_block = new_msg_block;
         }
@@ -110,8 +93,8 @@ pub fn sha256_var<let N: u32>(msg: [u8; N], message_size: u64) -> [u8; 32] {
 
         // If the block is filled, compress it.
         // An un-filled block is handled after this loop.
-        if msg_byte_ptr == BLOCK_SIZE {
-            h = sha256_compression(msg_u8_to_u32(msg_block), h);
+        if (msg_start < message_size) & (msg_byte_ptr == BLOCK_SIZE) {
+            h = sha256_compression(msg_block, h);
         }
     }
 
@@ -121,9 +104,8 @@ pub fn sha256_var<let N: u32>(msg: [u8; N], message_size: u64) -> [u8; 32] {
     // or our message cannot be evenly split into blocks.
     if modulo != 0 {
         let msg_start = BLOCK_SIZE * num_blocks;
-        let (new_msg_block, new_msg_byte_ptr) = unsafe {
-            build_msg_block_iter(msg, message_size, msg_start)
-        };
+        let (new_msg_block, new_msg_byte_ptr) =
+            unsafe { build_msg_block(msg, message_size, msg_start) };
 
         if msg_start < message_size {
             msg_block = new_msg_block;
@@ -133,124 +115,402 @@ pub fn sha256_var<let N: u32>(msg: [u8; N], message_size: u64) -> [u8; 32] {
             let new_msg_byte_ptr = verify_msg_block(msg, message_size, msg_block, msg_start);
             if msg_start < message_size {
                 msg_byte_ptr = new_msg_byte_ptr;
+                verify_msg_block_padding(msg_block, msg_byte_ptr);
             }
         } else if msg_start < message_size {
             msg_byte_ptr = new_msg_byte_ptr;
         }
     }
 
+    // If we had modulo == 0 then it means the last block was full,
+    // and we can reset the pointer to zero to overwrite it.
     if msg_byte_ptr == BLOCK_SIZE {
         msg_byte_ptr = 0;
     }
 
-    // This variable is used to get around the compiler under-constrained check giving a warning.
-    // We want to check against a constant zero, but if it does not come from the circuit inputs
-    // or return values the compiler check will issue a warning.
-    let zero = msg_block[0] - msg_block[0];
-
     // Pad the rest such that we have a [u32; 2] block at the end representing the length
     // of the message, and a block of 1 0 ... 0 following the message (i.e. [1 << 7, 0, ..., 0]).
-    msg_block[msg_byte_ptr] = 1 << 7;
-    let last_block = msg_block;
+    // Here we rely on the fact that everything beyond the available input is set to 0.
+    msg_block = update_block_item(
+        msg_block,
+        msg_byte_ptr,
+        |msg_item| set_item_byte_then_zeros(msg_item, msg_byte_ptr, 1 << 7),
+    );
     msg_byte_ptr = msg_byte_ptr + 1;
+    let last_block = msg_block;
 
-    unsafe {
-        let (new_msg_block, new_msg_byte_ptr) = pad_msg_block(msg_block, msg_byte_ptr);
-        msg_block = new_msg_block;
-        if crate::runtime::is_unconstrained() {
-            msg_byte_ptr = new_msg_byte_ptr;
-        }
+    // If we don't have room to write the size, compress the block and reset it.
+    if msg_byte_ptr > MSG_SIZE_PTR {
+        h = sha256_compression(msg_block, h);
+        // `attach_len_to_msg_block` will zero out everything after the `msg_byte_ptr`.
+        msg_byte_ptr = 0;
     }
 
-    if !crate::runtime::is_unconstrained() {
-        for i in 0..BLOCK_SIZE {
-            assert_eq(msg_block[i], last_block[i]);
+    msg_block = unsafe { attach_len_to_msg_block(msg_block, msg_byte_ptr, message_size) };
+
+    if !is_unconstrained() {
+        verify_msg_len(msg_block, last_block, msg_byte_ptr, message_size);
+    }
+
+    hash_final_block(msg_block, h)
+}
+
+// Take `BLOCK_SIZE` number of bytes from `msg` starting at `msg_start`.
+// Returns the block and the length that has been copied rather than padded with zeros.
+unconstrained fn build_msg_block<let N: u32>(
+    msg: [u8; N],
+    message_size: u32,
+    msg_start: u32,
+) -> (MSG_BLOCK, BLOCK_BYTE_PTR) {
+    let mut msg_block: MSG_BLOCK = [0; INT_BLOCK_SIZE];
+
+    // We insert `BLOCK_SIZE` bytes (or up to the end of the message)
+    let block_input = if msg_start + BLOCK_SIZE > message_size {
+        if message_size < msg_start {
+            // This function is sometimes called with `msg_start` past the end of the message.
+            // In this case we return an empty block and zero pointer to signal that the result should be ignored.
+            0
+        } else {
+            message_size - msg_start
+        }
+    } else {
+        BLOCK_SIZE
+    };
+
+    // Figure out the number of items in the int array that we have to pack.
+    // e.g. if the input is [0,1,2,3,4,5] then we need to pack it as 2 items: [0123, 4500]
+    let mut int_input = block_input / INT_SIZE;
+    if block_input % INT_SIZE != 0 {
+        int_input = int_input + 1;
+    };
+
+    for i in 0..int_input {
+        let mut msg_item: u32 = 0;
+        // Always construct the integer as 4 bytes, even if it means going beyond the input.
+        for j in 0..INT_SIZE {
+            let k = i * INT_SIZE + j;
+            let msg_byte = if k < block_input {
+                msg[msg_start + k]
+            } else {
+                0
+            };
+            msg_item = lshift8(msg_item, 1) + msg_byte as u32;
         }
+        msg_block[i] = msg_item;
+    }
+
+    // Returning the index as if it was a 64 byte array.
+    // We have to project it down to 16 items and bit shifting to get a byte back if we need it.
+    (msg_block, block_input)
+}
 
-        // If i >= 57, there aren't enough bits in the current message block to accomplish this, so
-        // the 1 and 0s fill up the current block, which we then compress accordingly.
-        // Not enough bits (64) to store length. Fill up with zeros.
-        for _i in 57..BLOCK_SIZE {
-            if msg_byte_ptr <= 63 & msg_byte_ptr >= 57 {
-                assert_eq(msg_block[msg_byte_ptr], zero);
-                msg_byte_ptr += 1;
+// Verify the block we are compressing was appropriately constructed by `build_msg_block`
+// and matches the input data. Returns the index of the first unset item.
+// If `message_size` is less than `msg_start` then this is called with the old non-empty block;
+// in that case we can skip verification, ie. no need to check that everything is zero.
+fn verify_msg_block<let N: u32>(
+    msg: [u8; N],
+    message_size: u32,
+    msg_block: MSG_BLOCK,
+    msg_start: u32,
+) -> BLOCK_BYTE_PTR {
+    let mut msg_byte_ptr = 0;
+    let mut msg_end = msg_start + BLOCK_SIZE;
+    if msg_end > N {
+        msg_end = N;
+    }
+    // We might have to go beyond the input to pad the fields.
+    if msg_end % INT_SIZE != 0 {
+        msg_end = msg_end + INT_SIZE - msg_end % INT_SIZE;
+    }
+
+    // Reconstructed packed item.
+    let mut msg_item: u32 = 0;
+
+    // Inclusive at the end so that we can compare the last item.
+    let mut i: u32 = 0;
+    for k in msg_start..=msg_end {
+        if k % INT_SIZE == 0 {
+            // If we consumed some input we can compare against the block.
+            if (msg_start < message_size) & (k > msg_start) {
+                assert_eq(msg_block[i], msg_item as u32);
+                i = i + 1;
+                msg_item = 0;
             }
         }
+        // Shift the accumulator
+        msg_item = lshift8(msg_item, 1);
+        // If we have input to consume, add it at the rightmost position.
+        if k < message_size & k < msg_end {
+            msg_item = msg_item + msg[k] as u32;
+            msg_byte_ptr = msg_byte_ptr + 1;
+        }
     }
 
-    if msg_byte_ptr >= 57 {
-        h = sha256_compression(msg_u8_to_u32(msg_block), h);
+    msg_byte_ptr
+}
+
+// Verify the block we are compressing was appropriately padded with zeros by `build_msg_block`.
+// This is only relevant for the last, potentially partially filled block.
+fn verify_msg_block_padding(msg_block: MSG_BLOCK, msg_byte_ptr: BLOCK_BYTE_PTR) {
+    // Check all the way to the end of the block.
+    verify_msg_block_zeros(msg_block, msg_byte_ptr, INT_BLOCK_SIZE);
+}
 
-        msg_byte_ptr = 0;
+// Verify that a region of ints in the message block are (partially) zeroed,
+// up to an (exclusive) maximum which can either be the end of the block
+// or just where the size is to be written.
+fn verify_msg_block_zeros(
+    msg_block: MSG_BLOCK,
+    mut msg_byte_ptr: BLOCK_BYTE_PTR,
+    max_int_byte_ptr: u32,
+) {
+    // This variable is used to get around the compiler under-constrained check giving a warning.
+    // We want to check against a constant zero, but if it does not come from the circuit inputs
+    // or return values the compiler check will issue a warning.
+    let zero = msg_block[0] - msg_block[0];
+
+    // First integer which is supposed to be (partially) zero.
+    let mut int_byte_ptr = msg_byte_ptr / INT_SIZE;
+
+    // Check partial zeros.
+    let modulo = msg_byte_ptr % INT_SIZE;
+    if modulo != 0 {
+        let zeros = INT_SIZE - modulo;
+        let mask = if zeros == 3 {
+            TWO_POW_24
+        } else if zeros == 2 {
+            TWO_POW_16
+        } else {
+            TWO_POW_8
+        };
+        assert_eq(msg_block[int_byte_ptr] % mask, zero);
+        int_byte_ptr = int_byte_ptr + 1;
     }
 
-    msg_block = unsafe {
-        attach_len_to_msg_block(msg_block, msg_byte_ptr, message_size)
-    };
+    // Check the rest of the items.
+    for i in 0..max_int_byte_ptr {
+        if i >= int_byte_ptr {
+            assert_eq(msg_block[i], zero);
+        }
+    }
+}
 
-    if !crate::runtime::is_unconstrained() {
-        for i in 0..56 {
-            let predicate = (i < msg_byte_ptr) as u8;
-            let expected_byte = predicate * last_block[i];
-            assert_eq(msg_block[i], expected_byte);
+// Verify that up to the byte pointer the two blocks are equal.
+// At the byte pointer the new block can be partially zeroed.
+fn verify_msg_block_equals_last(
+    msg_block: MSG_BLOCK,
+    last_block: MSG_BLOCK,
+    mut msg_byte_ptr: BLOCK_BYTE_PTR,
+) {
+    // msg_byte_ptr is the position at which they are no longer have to be the same.
+    // First integer which is supposed to be (partially) zero contains that pointer.
+    let mut int_byte_ptr = msg_byte_ptr / INT_SIZE;
+
+    // Check partial zeros.
+    let modulo = msg_byte_ptr % INT_SIZE;
+    if modulo != 0 {
+        // Reconstruct the partially zero item from the last block.
+        let last_field = last_block[int_byte_ptr];
+        let mut msg_item: u32 = 0;
+        // Reset to where they are still equal.
+        msg_byte_ptr = msg_byte_ptr - modulo;
+        for i in 0..INT_SIZE {
+            msg_item = lshift8(msg_item, 1);
+            if i < modulo {
+                msg_item = msg_item + get_item_byte(last_field, msg_byte_ptr) as u32;
+                msg_byte_ptr = msg_byte_ptr + 1;
+            }
         }
+        assert_eq(msg_block[int_byte_ptr], msg_item);
+    }
 
-        // We verify the message length was inserted correctly by reversing the byte decomposition.
-        let len = 8 * message_size;
-        let mut reconstructed_len: Field = 0;
-        for i in 56..64 {
-            reconstructed_len = 256 * reconstructed_len + msg_block[i] as Field;
+    for i in 0..INT_SIZE_PTR {
+        if i < int_byte_ptr {
+            assert_eq(msg_block[i], last_block[i]);
         }
-        assert_eq(reconstructed_len, len as Field);
     }
+}
 
-    hash_final_block(msg_block, h)
+// Apply a function on the block item which the pointer indicates.
+fn update_block_item<Env>(
+    mut msg_block: MSG_BLOCK,
+    msg_byte_ptr: BLOCK_BYTE_PTR,
+    f: fn[Env](u32) -> u32,
+) -> MSG_BLOCK {
+    let i = msg_byte_ptr / INT_SIZE;
+    msg_block[i] = f(msg_block[i]);
+    msg_block
+}
+
+// Set the rightmost `zeros` number of bytes to 0.
+fn set_item_zeros(item: u32, zeros: u8) -> u32 {
+    lshift8(rshift8(item, zeros), zeros)
+}
+
+// Replace one byte in the item with a value, and set everything after it to zero.
+fn set_item_byte_then_zeros(msg_item: u32, msg_byte_ptr: BLOCK_BYTE_PTR, msg_byte: u8) -> u32 {
+    let zeros = INT_SIZE - msg_byte_ptr % INT_SIZE;
+    let zeroed_item = set_item_zeros(msg_item, zeros as u8);
+    let new_item = byte_into_item(msg_byte, msg_byte_ptr);
+    zeroed_item + new_item
 }
 
-unconstrained fn pad_msg_block(
-    mut msg_block: [u8; 64],
-    mut msg_byte_ptr: u32
-) -> ([u8; BLOCK_SIZE], u32) {
-    // If i >= 57, there aren't enough bits in the current message block to accomplish this, so
-    // the 1 and 0s fill up the current block, which we then compress accordingly.
-    if msg_byte_ptr >= 57 {
-        // Not enough bits (64) to store length. Fill up with zeros.
-        for i in msg_byte_ptr..BLOCK_SIZE {
-            msg_block[i] = 0;
+// Get a byte of a message item according to its overall position in the `BLOCK_SIZE` space.
+fn get_item_byte(mut msg_item: u32, msg_byte_ptr: BLOCK_BYTE_PTR) -> u8 {
+    // How many times do we have to shift to the right to get to the position we want?
+    let max_shifts = INT_SIZE - 1;
+    let shifts = max_shifts - msg_byte_ptr % INT_SIZE;
+    msg_item = rshift8(msg_item, shifts as u8);
+    // At this point the byte we want is in the rightmost position.
+    msg_item as u8
+}
+
+// Project a byte into a position in a field based on the overall block pointer.
+// For example putting 1 into pointer 5 would be 100, because overall we would
+// have [____, 0100] with indexes [0123,4567].
+fn byte_into_item(msg_byte: u8, msg_byte_ptr: BLOCK_BYTE_PTR) -> u32 {
+    let mut msg_item = msg_byte as u32;
+    // How many times do we have to shift to the left to get to the position we want?
+    let max_shifts = INT_SIZE - 1;
+    let shifts = max_shifts - msg_byte_ptr % INT_SIZE;
+    lshift8(msg_item, shifts as u8)
+}
+
+// Construct a field out of 4 bytes.
+fn make_item(b0: u8, b1: u8, b2: u8, b3: u8) -> u32 {
+    let mut item = b0 as u32;
+    item = lshift8(item, 1) + b1 as u32;
+    item = lshift8(item, 1) + b2 as u32;
+    item = lshift8(item, 1) + b3 as u32;
+    item
+}
+
+// Shift by 8 bits to the left between 0 and 4 times.
+// Checks `is_unconstrained()` to just use a bitshift if we're running in an unconstrained context,
+// otherwise multiplies by 256.
+fn lshift8(item: u32, shifts: u8) -> u32 {
+    if is_unconstrained() {
+        if item == 0 {
+            0
+        } else {
+            // Brillig wouldn't shift 0<<4 without overflow.
+            item << (8 * shifts)
         }
-        (msg_block, BLOCK_SIZE)
     } else {
-        (msg_block, msg_byte_ptr)
+        // We can do a for loop up to INT_SIZE or an if-else.
+        if shifts == 0 {
+            item
+        } else if shifts == 1 {
+            item * TWO_POW_8
+        } else if shifts == 2 {
+            item * TWO_POW_16
+        } else if shifts == 3 {
+            item * TWO_POW_24
+        } else {
+            // Doesn't make sense, but it's most likely called on 0 anyway.
+            0
+        }
     }
 }
 
-unconstrained fn attach_len_to_msg_block(mut msg_block: [u8; BLOCK_SIZE], msg_byte_ptr: u32, message_size: u32) -> [u8; BLOCK_SIZE] {
+// Shift by 8 bits to the right between 0 and 4 times.
+// Checks `is_unconstrained()` to just use a bitshift if we're running in an unconstrained context,
+// otherwise divides by 256.
+fn rshift8(item: u32, shifts: u8) -> u32 {
+    if is_unconstrained() {
+        item >> (8 * shifts)
+    } else {
+        // Division wouldn't work on `Field`.
+        if shifts == 0 {
+            item
+        } else if shifts == 1 {
+            item / TWO_POW_8
+        } else if shifts == 2 {
+            item / TWO_POW_16
+        } else if shifts == 3 {
+            item / TWO_POW_24
+        } else {
+            0
+        }
+    }
+}
+
+// Zero out all bytes between the end of the message and where the length is appended,
+// then write the length into the last 8 bytes of the block.
+unconstrained fn attach_len_to_msg_block(
+    mut msg_block: MSG_BLOCK,
+    mut msg_byte_ptr: BLOCK_BYTE_PTR,
+    message_size: u32,
+) -> MSG_BLOCK {
     // We assume that `msg_byte_ptr` is less than 57 because if not then it is reset to zero before calling this function.
-    // In any case, fill blocks up with zeros until the last 64 (i.e. until msg_byte_ptr = 56).
+    // In any case, fill blocks up with zeros until the last 64 bits (i.e. until msg_byte_ptr = 56).
+    // There can be one item which has to be partially zeroed.
+    let modulo = msg_byte_ptr % INT_SIZE;
+    if modulo != 0 {
+        // Index of the block in which we find the item we need to partially zero.
+        let i = msg_byte_ptr / INT_SIZE;
+        let zeros = INT_SIZE - modulo;
+        msg_block[i] = set_item_zeros(msg_block[i], zeros as u8);
+        msg_byte_ptr = msg_byte_ptr + zeros;
+    }
 
-    for i in msg_byte_ptr..56 {
+    // The rest can be zeroed without bit shifting anything.
+    for i in (msg_byte_ptr / INT_SIZE)..INT_SIZE_PTR {
         msg_block[i] = 0;
     }
 
+    // Set the last two 4 byte ints as the first/second half of the 8 bytes of the length.
     let len = 8 * message_size;
     let len_bytes: [u8; 8] = (len as Field).to_be_bytes();
-    for i in 0..8 {
-        msg_block[56 + i] = len_bytes[i];
+    for i in 0..=1 {
+        let shift = i * 4;
+        msg_block[INT_SIZE_PTR + i] = make_item(
+            len_bytes[shift],
+            len_bytes[shift + 1],
+            len_bytes[shift + 2],
+            len_bytes[shift + 3],
+        );
     }
     msg_block
 }
 
-fn hash_final_block(msg_block: [u8; BLOCK_SIZE], mut state: [u32; 8]) -> [u8; 32] {
-    let mut out_h: [u8; 32] = [0; 32]; // Digest as sequence of bytes
+// Verify that the message length was correctly written by `attach_len_to_msg_block`,
+// and that everything between the byte pointer and the size pointer was zeroed,
+// and that everything before the byte pointer was untouched.
+fn verify_msg_len(
+    msg_block: MSG_BLOCK,
+    last_block: MSG_BLOCK,
+    msg_byte_ptr: BLOCK_BYTE_PTR,
+    message_size: u32,
+) {
+    // Check zeros up to the size pointer.
+    verify_msg_block_zeros(msg_block, msg_byte_ptr, INT_SIZE_PTR);
+
+    // Check that up to the pointer we match the last block.
+    verify_msg_block_equals_last(msg_block, last_block, msg_byte_ptr);
+
+    // We verify the message length was inserted correctly by reversing the byte decomposition.
+    let mut reconstructed_len: u64 = 0;
+    for i in INT_SIZE_PTR..INT_BLOCK_SIZE {
+        reconstructed_len = reconstructed_len * TWO_POW_32;
+        reconstructed_len = reconstructed_len + msg_block[i] as u64;
+    }
+    let len = 8 * message_size as u64;
+    assert_eq(reconstructed_len, len);
+}
 
+// Perform the final compression, then transform the `STATE` into `HASH`.
+fn hash_final_block(msg_block: MSG_BLOCK, mut state: STATE) -> HASH {
+    let mut out_h: HASH = [0; 32]; // Digest as sequence of bytes
     // Hash final padded block
-    state = sha256_compression(msg_u8_to_u32(msg_block), state);
+    state = sha256_compression(msg_block, state);
 
     // Return final hash as byte array
     for j in 0..8 {
-        let h_bytes: [u8; 4] = (state[7 - j] as Field).to_le_bytes();
+        let h_bytes: [u8; 4] = (state[j] as Field).to_be_bytes();
         for k in 0..4 {
-            out_h[31 - 4*j - k] = h_bytes[k];
+            out_h[4 * j + k] = h_bytes[k];
         }
     }
 
@@ -258,13 +518,20 @@ fn hash_final_block(msg_block: [u8; BLOCK_SIZE], mut state: [u32; 8]) -> [u8; 32
 }
 
 mod tests {
+    use super::{
+        attach_len_to_msg_block, build_msg_block, byte_into_item, get_item_byte, make_item,
+        set_item_byte_then_zeros, set_item_zeros,
+    };
+    use super::INT_BLOCK;
     use super::sha256_var;
 
     #[test]
     fn smoke_test() {
         let input = [0xbd];
         let result = [
-            0x68, 0x32, 0x57, 0x20, 0xaa, 0xbd, 0x7c, 0x82, 0xf3, 0x0f, 0x55, 0x4b, 0x31, 0x3d, 0x05, 0x70, 0xc9, 0x5a, 0xcc, 0xbb, 0x7d, 0xc4, 0xb5, 0xaa, 0xe1, 0x12, 0x04, 0xc0, 0x8f, 0xfe, 0x73, 0x2b
+            0x68, 0x32, 0x57, 0x20, 0xaa, 0xbd, 0x7c, 0x82, 0xf3, 0x0f, 0x55, 0x4b, 0x31, 0x3d,
+            0x05, 0x70, 0xc9, 0x5a, 0xcc, 0xbb, 0x7d, 0xc4, 0xb5, 0xaa, 0xe1, 0x12, 0x04, 0xc0,
+            0x8f, 0xfe, 0x73, 0x2b,
         ];
         assert_eq(sha256_var(input, input.len() as u64), result);
     }
@@ -272,10 +539,14 @@ mod tests {
     #[test]
     fn msg_just_over_block() {
         let input = [
-            102, 114, 111, 109, 58, 114, 117, 110, 110, 105, 101, 114, 46, 108, 101, 97, 103, 117, 101, 115, 46, 48, 106, 64, 105, 99, 108, 111, 117, 100, 46, 99, 111, 109, 13, 10, 99, 111, 110, 116, 101, 110, 116, 45, 116, 121, 112, 101, 58, 116, 101, 120, 116, 47, 112, 108, 97, 105, 110, 59, 32, 99, 104, 97, 114, 115, 101, 116
+            102, 114, 111, 109, 58, 114, 117, 110, 110, 105, 101, 114, 46, 108, 101, 97, 103, 117,
+            101, 115, 46, 48, 106, 64, 105, 99, 108, 111, 117, 100, 46, 99, 111, 109, 13, 10, 99,
+            111, 110, 116, 101, 110, 116, 45, 116, 121, 112, 101, 58, 116, 101, 120, 116, 47, 112,
+            108, 97, 105, 110, 59, 32, 99, 104, 97, 114, 115, 101, 116,
         ];
         let result = [
-            91, 122, 146, 93, 52, 109, 133, 148, 171, 61, 156, 70, 189, 238, 153, 7, 222, 184, 94, 24, 65, 114, 192, 244, 207, 199, 87, 232, 192, 224, 171, 207
+            91, 122, 146, 93, 52, 109, 133, 148, 171, 61, 156, 70, 189, 238, 153, 7, 222, 184, 94,
+            24, 65, 114, 192, 244, 207, 199, 87, 232, 192, 224, 171, 207,
         ];
         assert_eq(sha256_var(input, input.len() as u64), result);
     }
@@ -283,10 +554,33 @@ mod tests {
     #[test]
     fn msg_multiple_over_block() {
         let input = [
-            102, 114, 111, 109, 58, 114, 117, 110, 110, 105, 101, 114, 46, 108, 101, 97, 103, 117, 101, 115, 46, 48, 106, 64, 105, 99, 108, 111, 117, 100, 46, 99, 111, 109, 13, 10, 99, 111, 110, 116, 101, 110, 116, 45, 116, 121, 112, 101, 58, 116, 101, 120, 116, 47, 112, 108, 97, 105, 110, 59, 32, 99, 104, 97, 114, 115, 101, 116, 61, 117, 115, 45, 97, 115, 99, 105, 105, 13, 10, 109, 105, 109, 101, 45, 118, 101, 114, 115, 105, 111, 110, 58, 49, 46, 48, 32, 40, 77, 97, 99, 32, 79, 83, 32, 88, 32, 77, 97, 105, 108, 32, 49, 54, 46, 48, 32, 92, 40, 51, 55, 51, 49, 46, 53, 48, 48, 46, 50, 51, 49, 92, 41, 41, 13, 10, 115, 117, 98, 106, 101, 99, 116, 58, 72, 101, 108, 108, 111, 13, 10, 109, 101, 115, 115, 97, 103, 101, 45, 105, 100, 58, 60, 56, 70, 56, 49, 57, 68, 51, 50, 45, 66, 54, 65, 67, 45, 52, 56, 57, 68, 45, 57, 55, 55, 70, 45, 52, 51, 56, 66, 66, 67, 52, 67, 65, 66, 50, 55, 64, 109, 101, 46, 99, 111, 109, 62, 13, 10, 100, 97, 116, 101, 58, 83, 97, 116, 44, 32, 50, 54, 32, 65, 117, 103, 32, 50, 48, 50, 51, 32, 49, 50, 58, 50, 53, 58, 50, 50, 32, 43, 48, 52, 48, 48, 13, 10, 116, 111, 58, 122, 107, 101, 119, 116, 101, 115, 116, 64, 103, 109, 97, 105, 108, 46, 99, 111, 109, 13, 10, 100, 107, 105, 109, 45, 115, 105, 103, 110, 97, 116, 117, 114, 101, 58, 118, 61, 49, 59, 32, 97, 61, 114, 115, 97, 45, 115, 104, 97, 50, 53, 54, 59, 32, 99, 61, 114, 101, 108, 97, 120, 101, 100, 47, 114, 101, 108, 97, 120, 101, 100, 59, 32, 100, 61, 105, 99, 108, 111, 117, 100, 46, 99, 111, 109, 59, 32, 115, 61, 49, 97, 49, 104, 97, 105, 59, 32, 116, 61, 49, 54, 57, 51, 48, 51, 56, 51, 51, 55, 59, 32, 98, 104, 61, 55, 120, 81, 77, 68, 117, 111, 86, 86, 85, 52, 109, 48, 87, 48, 87, 82, 86, 83, 114, 86, 88, 77, 101, 71, 83, 73, 65, 83, 115, 110, 117, 99, 75, 57, 100, 74, 115, 114, 99, 43, 118, 85, 61, 59, 32, 104, 61, 102, 114, 111, 109, 58, 67, 111, 110, 116, 101, 110, 116, 45, 84, 121, 112, 101, 58, 77, 105, 109, 101, 45, 86, 101, 114, 115, 105, 111, 110, 58, 83, 117, 98, 106, 101, 99
+            102, 114, 111, 109, 58, 114, 117, 110, 110, 105, 101, 114, 46, 108, 101, 97, 103, 117,
+            101, 115, 46, 48, 106, 64, 105, 99, 108, 111, 117, 100, 46, 99, 111, 109, 13, 10, 99,
+            111, 110, 116, 101, 110, 116, 45, 116, 121, 112, 101, 58, 116, 101, 120, 116, 47, 112,
+            108, 97, 105, 110, 59, 32, 99, 104, 97, 114, 115, 101, 116, 61, 117, 115, 45, 97, 115,
+            99, 105, 105, 13, 10, 109, 105, 109, 101, 45, 118, 101, 114, 115, 105, 111, 110, 58, 49,
+            46, 48, 32, 40, 77, 97, 99, 32, 79, 83, 32, 88, 32, 77, 97, 105, 108, 32, 49, 54, 46,
+            48, 32, 92, 40, 51, 55, 51, 49, 46, 53, 48, 48, 46, 50, 51, 49, 92, 41, 41, 13, 10, 115,
+            117, 98, 106, 101, 99, 116, 58, 72, 101, 108, 108, 111, 13, 10, 109, 101, 115, 115, 97,
+            103, 101, 45, 105, 100, 58, 60, 56, 70, 56, 49, 57, 68, 51, 50, 45, 66, 54, 65, 67, 45,
+            52, 56, 57, 68, 45, 57, 55, 55, 70, 45, 52, 51, 56, 66, 66, 67, 52, 67, 65, 66, 50, 55,
+            64, 109, 101, 46, 99, 111, 109, 62, 13, 10, 100, 97, 116, 101, 58, 83, 97, 116, 44, 32,
+            50, 54, 32, 65, 117, 103, 32, 50, 48, 50, 51, 32, 49, 50, 58, 50, 53, 58, 50, 50, 32,
+            43, 48, 52, 48, 48, 13, 10, 116, 111, 58, 122, 107, 101, 119, 116, 101, 115, 116, 64,
+            103, 109, 97, 105, 108, 46, 99, 111, 109, 13, 10, 100, 107, 105, 109, 45, 115, 105, 103,
+            110, 97, 116, 117, 114, 101, 58, 118, 61, 49, 59, 32, 97, 61, 114, 115, 97, 45, 115,
+            104, 97, 50, 53, 54, 59, 32, 99, 61, 114, 101, 108, 97, 120, 101, 100, 47, 114, 101,
+            108, 97, 120, 101, 100, 59, 32, 100, 61, 105, 99, 108, 111, 117, 100, 46, 99, 111, 109,
+            59, 32, 115, 61, 49, 97, 49, 104, 97, 105, 59, 32, 116, 61, 49, 54, 57, 51, 48, 51, 56,
+            51, 51, 55, 59, 32, 98, 104, 61, 55, 120, 81, 77, 68, 117, 111, 86, 86, 85, 52, 109, 48,
+            87, 48, 87, 82, 86, 83, 114, 86, 88, 77, 101, 71, 83, 73, 65, 83, 115, 110, 117, 99, 75,
+            57, 100, 74, 115, 114, 99, 43, 118, 85, 61, 59, 32, 104, 61, 102, 114, 111, 109, 58, 67,
+            111, 110, 116, 101, 110, 116, 45, 84, 121, 112, 101, 58, 77, 105, 109, 101, 45, 86, 101,
+            114, 115, 105, 111, 110, 58, 83, 117, 98, 106, 101, 99,
         ];
         let result = [
-            116, 90, 151, 31, 78, 22, 138, 180, 211, 189, 69, 76, 227, 200, 155, 29, 59, 123, 154, 60, 47, 153, 203, 129, 157, 251, 48, 2, 79, 11, 65, 47
+            116, 90, 151, 31, 78, 22, 138, 180, 211, 189, 69, 76, 227, 200, 155, 29, 59, 123, 154,
+            60, 47, 153, 203, 129, 157, 251, 48, 2, 79, 11, 65, 47,
         ];
         assert_eq(sha256_var(input, input.len() as u64), result);
     }
@@ -294,10 +588,14 @@ mod tests {
     #[test]
     fn msg_just_under_block() {
         let input = [
-            102, 114, 111, 109, 58, 114, 117, 110, 110, 105, 101, 114, 46, 108, 101, 97, 103, 117, 101, 115, 46, 48, 106, 64, 105, 99, 108, 111, 117, 100, 46, 99, 111, 109, 13, 10, 99, 111, 110, 116, 101, 110, 116, 45, 116, 121, 112, 101, 58, 116, 101, 120, 116, 47, 112, 108, 97, 105, 110, 59
+            102, 114, 111, 109, 58, 114, 117, 110, 110, 105, 101, 114, 46, 108, 101, 97, 103, 117,
+            101, 115, 46, 48, 106, 64, 105, 99, 108, 111, 117, 100, 46, 99, 111, 109, 13, 10, 99,
+            111, 110, 116, 101, 110, 116, 45, 116, 121, 112, 101, 58, 116, 101, 120, 116, 47, 112,
+            108, 97, 105, 110, 59,
         ];
         let result = [
-            143, 140, 76, 173, 222, 123, 102, 68, 70, 149, 207, 43, 39, 61, 34, 79, 216, 252, 213, 165, 74, 16, 110, 74, 29, 64, 138, 167, 30, 1, 9, 119
+            143, 140, 76, 173, 222, 123, 102, 68, 70, 149, 207, 43, 39, 61, 34, 79, 216, 252, 213,
+            165, 74, 16, 110, 74, 29, 64, 138, 167, 30, 1, 9, 119,
         ];
         assert_eq(sha256_var(input, input.len() as u64), result);
     }
@@ -305,10 +603,34 @@ mod tests {
     #[test]
     fn msg_big_not_block_multiple() {
         let input = [
-            102, 114, 111, 109, 58, 114, 117, 110, 110, 105, 101, 114, 46, 108, 101, 97, 103, 117, 101, 115, 46, 48, 106, 64, 105, 99, 108, 111, 117, 100, 46, 99, 111, 109, 13, 10, 99, 111, 110, 116, 101, 110, 116, 45, 116, 121, 112, 101, 58, 116, 101, 120, 116, 47, 112, 108, 97, 105, 110, 59, 32, 99, 104, 97, 114, 115, 101, 116, 61, 117, 115, 45, 97, 115, 99, 105, 105, 13, 10, 109, 105, 109, 101, 45, 118, 101, 114, 115, 105, 111, 110, 58, 49, 46, 48, 32, 40, 77, 97, 99, 32, 79, 83, 32, 88, 32, 77, 97, 105, 108, 32, 49, 54, 46, 48, 32, 92, 40, 51, 55, 51, 49, 46, 53, 48, 48, 46, 50, 51, 49, 92, 41, 41, 13, 10, 115, 117, 98, 106, 101, 99, 116, 58, 72, 101, 108, 108, 111, 13, 10, 109, 101, 115, 115, 97, 103, 101, 45, 105, 100, 58, 60, 56, 70, 56, 49, 57, 68, 51, 50, 45, 66, 54, 65, 67, 45, 52, 56, 57, 68, 45, 57, 55, 55, 70, 45, 52, 51, 56, 66, 66, 67, 52, 67, 65, 66, 50, 55, 64, 109, 101, 46, 99, 111, 109, 62, 13, 10, 100, 97, 116, 101, 58, 83, 97, 116, 44, 32, 50, 54, 32, 65, 117, 103, 32, 50, 48, 50, 51, 32, 49, 50, 58, 50, 53, 58, 50, 50, 32, 43, 48, 52, 48, 48, 13, 10, 116, 111, 58, 122, 107, 101, 119, 116, 101, 115, 116, 64, 103, 109, 97, 105, 108, 46, 99, 111, 109, 13, 10, 100, 107, 105, 109, 45, 115, 105, 103, 110, 97, 116, 117, 114, 101, 58, 118, 61, 49, 59, 32, 97, 61, 114, 115, 97, 45, 115, 104, 97, 50, 53, 54, 59, 32, 99, 61, 114, 101, 108, 97, 120, 101, 100, 47, 114, 101, 108, 97, 120, 101, 100, 59, 32, 100, 61, 105, 99, 108, 111, 117, 100, 46, 99, 111, 109, 59, 32, 115, 61, 49, 97, 49, 104, 97, 105, 59, 32, 116, 61, 49, 54, 57, 51, 48, 51, 56, 51, 51, 55, 59, 32, 98, 104, 61, 55, 120, 81, 77, 68, 117, 111, 86, 86, 85, 52, 109, 48, 87, 48, 87, 82, 86, 83, 114, 86, 88, 77, 101, 71, 83, 73, 65, 83, 115, 110, 117, 99, 75, 57, 100, 74, 115, 114, 99, 43, 118, 85, 61, 59, 32, 104, 61, 102, 114, 111, 109, 58, 67, 111, 110, 116, 101, 110, 116, 45, 84, 121, 112, 101, 58, 77, 105, 109, 101, 45, 86, 101, 114, 115, 105, 111, 110, 58, 83, 117, 98, 106, 101, 99, 116, 58, 77, 101, 115, 115, 97, 103, 101, 45, 73, 100, 58, 68, 97, 116, 101, 58, 116, 111, 59, 32, 98, 61
+            102, 114, 111, 109, 58, 114, 117, 110, 110, 105, 101, 114, 46, 108, 101, 97, 103, 117,
+            101, 115, 46, 48, 106, 64, 105, 99, 108, 111, 117, 100, 46, 99, 111, 109, 13, 10, 99,
+            111, 110, 116, 101, 110, 116, 45, 116, 121, 112, 101, 58, 116, 101, 120, 116, 47, 112,
+            108, 97, 105, 110, 59, 32, 99, 104, 97, 114, 115, 101, 116, 61, 117, 115, 45, 97, 115,
+            99, 105, 105, 13, 10, 109, 105, 109, 101, 45, 118, 101, 114, 115, 105, 111, 110, 58, 49,
+            46, 48, 32, 40, 77, 97, 99, 32, 79, 83, 32, 88, 32, 77, 97, 105, 108, 32, 49, 54, 46,
+            48, 32, 92, 40, 51, 55, 51, 49, 46, 53, 48, 48, 46, 50, 51, 49, 92, 41, 41, 13, 10, 115,
+            117, 98, 106, 101, 99, 116, 58, 72, 101, 108, 108, 111, 13, 10, 109, 101, 115, 115, 97,
+            103, 101, 45, 105, 100, 58, 60, 56, 70, 56, 49, 57, 68, 51, 50, 45, 66, 54, 65, 67, 45,
+            52, 56, 57, 68, 45, 57, 55, 55, 70, 45, 52, 51, 56, 66, 66, 67, 52, 67, 65, 66, 50, 55,
+            64, 109, 101, 46, 99, 111, 109, 62, 13, 10, 100, 97, 116, 101, 58, 83, 97, 116, 44, 32,
+            50, 54, 32, 65, 117, 103, 32, 50, 48, 50, 51, 32, 49, 50, 58, 50, 53, 58, 50, 50, 32,
+            43, 48, 52, 48, 48, 13, 10, 116, 111, 58, 122, 107, 101, 119, 116, 101, 115, 116, 64,
+            103, 109, 97, 105, 108, 46, 99, 111, 109, 13, 10, 100, 107, 105, 109, 45, 115, 105, 103,
+            110, 97, 116, 117, 114, 101, 58, 118, 61, 49, 59, 32, 97, 61, 114, 115, 97, 45, 115,
+            104, 97, 50, 53, 54, 59, 32, 99, 61, 114, 101, 108, 97, 120, 101, 100, 47, 114, 101,
+            108, 97, 120, 101, 100, 59, 32, 100, 61, 105, 99, 108, 111, 117, 100, 46, 99, 111, 109,
+            59, 32, 115, 61, 49, 97, 49, 104, 97, 105, 59, 32, 116, 61, 49, 54, 57, 51, 48, 51, 56,
+            51, 51, 55, 59, 32, 98, 104, 61, 55, 120, 81, 77, 68, 117, 111, 86, 86, 85, 52, 109, 48,
+            87, 48, 87, 82, 86, 83, 114, 86, 88, 77, 101, 71, 83, 73, 65, 83, 115, 110, 117, 99, 75,
+            57, 100, 74, 115, 114, 99, 43, 118, 85, 61, 59, 32, 104, 61, 102, 114, 111, 109, 58, 67,
+            111, 110, 116, 101, 110, 116, 45, 84, 121, 112, 101, 58, 77, 105, 109, 101, 45, 86, 101,
+            114, 115, 105, 111, 110, 58, 83, 117, 98, 106, 101, 99, 116, 58, 77, 101, 115, 115, 97,
+            103, 101, 45, 73, 100, 58, 68, 97, 116, 101, 58, 116, 111, 59, 32, 98, 61,
         ];
         let result = [
-            112, 144, 73, 182, 208, 98, 9, 238, 54, 229, 61, 145, 222, 17, 72, 62, 148, 222, 186, 55, 192, 82, 220, 35, 66, 47, 193, 200, 22, 38, 26, 186
+            112, 144, 73, 182, 208, 98, 9, 238, 54, 229, 61, 145, 222, 17, 72, 62, 148, 222, 186,
+            55, 192, 82, 220, 35, 66, 47, 193, 200, 22, 38, 26, 186,
         ];
         assert_eq(sha256_var(input, input.len() as u64), result);
     }
@@ -316,10 +638,39 @@ mod tests {
     #[test]
     fn msg_big_with_padding() {
         let input = [
-            48, 130, 1, 37, 2, 1, 0, 48, 11, 6, 9, 96, 134, 72, 1, 101, 3, 4, 2, 1, 48, 130, 1, 17, 48, 37, 2, 1, 1, 4, 32, 176, 223, 31, 133, 108, 84, 158, 102, 70, 11, 165, 175, 196, 12, 201, 130, 25, 131, 46, 125, 156, 194, 28, 23, 55, 133, 157, 164, 135, 136, 220, 78, 48, 37, 2, 1, 2, 4, 32, 190, 82, 180, 235, 222, 33, 79, 50, 152, 136, 142, 35, 116, 224, 6, 242, 156, 141, 128, 248, 10, 61, 98, 86, 248, 45, 207, 210, 90, 232, 175, 38, 48, 37, 2, 1, 3, 4, 32, 0, 194, 104, 108, 237, 246, 97, 230, 116, 198, 69, 110, 26, 87, 17, 89, 110, 199, 108, 250, 36, 21, 39, 87, 110, 102, 250, 213, 174, 131, 171, 174, 48, 37, 2, 1, 11, 4, 32, 136, 155, 87, 144, 111, 15, 152, 127, 85, 25, 154, 81, 20, 58, 51, 75, 193, 116, 234, 0, 60, 30, 29, 30, 183, 141, 72, 247, 255, 203, 100, 124, 48, 37, 2, 1, 12, 4, 32, 41, 234, 106, 78, 31, 11, 114, 137, 237, 17, 92, 71, 134, 47, 62, 78, 189, 233, 201, 214, 53, 4, 47, 189, 201, 133, 6, 121, 34, 131, 64, 142, 48, 37, 2, 1, 13, 4, 32, 91, 222, 210, 193, 62, 222, 104, 82, 36, 41, 138, 253, 70, 15, 148, 208, 156, 45, 105, 171, 241, 195, 185, 43, 217, 162, 146, 201, 222, 89, 238, 38, 48, 37, 2, 1, 14, 4, 32, 76, 123, 216, 13, 51, 227, 72, 245, 59, 193, 238, 166, 103, 49, 23, 164, 171, 188, 194, 197, 156, 187, 249, 28, 198, 95, 69, 15, 182, 56, 54, 38, 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, 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, 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, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
+            48, 130, 1, 37, 2, 1, 0, 48, 11, 6, 9, 96, 134, 72, 1, 101, 3, 4, 2, 1, 48, 130, 1, 17,
+            48, 37, 2, 1, 1, 4, 32, 176, 223, 31, 133, 108, 84, 158, 102, 70, 11, 165, 175, 196, 12,
+            201, 130, 25, 131, 46, 125, 156, 194, 28, 23, 55, 133, 157, 164, 135, 136, 220, 78, 48,
+            37, 2, 1, 2, 4, 32, 190, 82, 180, 235, 222, 33, 79, 50, 152, 136, 142, 35, 116, 224, 6,
+            242, 156, 141, 128, 248, 10, 61, 98, 86, 248, 45, 207, 210, 90, 232, 175, 38, 48, 37, 2,
+            1, 3, 4, 32, 0, 194, 104, 108, 237, 246, 97, 230, 116, 198, 69, 110, 26, 87, 17, 89,
+            110, 199, 108, 250, 36, 21, 39, 87, 110, 102, 250, 213, 174, 131, 171, 174, 48, 37, 2,
+            1, 11, 4, 32, 136, 155, 87, 144, 111, 15, 152, 127, 85, 25, 154, 81, 20, 58, 51, 75,
+            193, 116, 234, 0, 60, 30, 29, 30, 183, 141, 72, 247, 255, 203, 100, 124, 48, 37, 2, 1,
+            12, 4, 32, 41, 234, 106, 78, 31, 11, 114, 137, 237, 17, 92, 71, 134, 47, 62, 78, 189,
+            233, 201, 214, 53, 4, 47, 189, 201, 133, 6, 121, 34, 131, 64, 142, 48, 37, 2, 1, 13, 4,
+            32, 91, 222, 210, 193, 62, 222, 104, 82, 36, 41, 138, 253, 70, 15, 148, 208, 156, 45,
+            105, 171, 241, 195, 185, 43, 217, 162, 146, 201, 222, 89, 238, 38, 48, 37, 2, 1, 14, 4,
+            32, 76, 123, 216, 13, 51, 227, 72, 245, 59, 193, 238, 166, 103, 49, 23, 164, 171, 188,
+            194, 197, 156, 187, 249, 28, 198, 95, 69, 15, 182, 56, 54, 38, 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, 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, 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, 0,
+            0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
         ];
         let result = [
-            32, 85, 108, 174, 127, 112, 178, 182, 8, 43, 134, 123, 192, 211, 131, 66, 184, 240, 212, 181, 240, 180, 106, 195, 24, 117, 54, 129, 19, 10, 250, 53
+            32, 85, 108, 174, 127, 112, 178, 182, 8, 43, 134, 123, 192, 211, 131, 66, 184, 240, 212,
+            181, 240, 180, 106, 195, 24, 117, 54, 129, 19, 10, 250, 53,
         ];
         let message_size = 297;
         assert_eq(sha256_var(input, message_size), result);
@@ -328,11 +679,158 @@ mod tests {
     #[test]
     fn msg_big_no_padding() {
         let input = [
-            48, 130, 1, 37, 2, 1, 0, 48, 11, 6, 9, 96, 134, 72, 1, 101, 3, 4, 2, 1, 48, 130, 1, 17, 48, 37, 2, 1, 1, 4, 32, 176, 223, 31, 133, 108, 84, 158, 102, 70, 11, 165, 175, 196, 12, 201, 130, 25, 131, 46, 125, 156, 194, 28, 23, 55, 133, 157, 164, 135, 136, 220, 78, 48, 37, 2, 1, 2, 4, 32, 190, 82, 180, 235, 222, 33, 79, 50, 152, 136, 142, 35, 116, 224, 6, 242, 156, 141, 128, 248, 10, 61, 98, 86, 248, 45, 207, 210, 90, 232, 175, 38, 48, 37, 2, 1, 3, 4, 32, 0, 194, 104, 108, 237, 246, 97, 230, 116, 198, 69, 110, 26, 87, 17, 89, 110, 199, 108, 250, 36, 21, 39, 87, 110, 102, 250, 213, 174, 131, 171, 174, 48, 37, 2, 1, 11, 4, 32, 136, 155, 87, 144, 111, 15, 152, 127, 85, 25, 154, 81, 20, 58, 51, 75, 193, 116, 234, 0, 60, 30, 29, 30, 183, 141, 72, 247, 255, 203, 100, 124, 48, 37, 2, 1, 12, 4, 32, 41, 234, 106, 78, 31, 11, 114, 137, 237, 17, 92, 71, 134, 47, 62, 78, 189, 233, 201, 214, 53, 4, 47, 189, 201, 133, 6, 121, 34, 131, 64, 142, 48, 37, 2, 1, 13, 4, 32, 91, 222, 210, 193, 62, 222, 104, 82, 36, 41, 138, 253, 70, 15, 148, 208, 156, 45, 105, 171, 241, 195, 185, 43, 217, 162, 146, 201, 222, 89, 238, 38, 48, 37, 2, 1, 14, 4, 32, 76, 123, 216, 13, 51, 227, 72, 245, 59, 193, 238, 166, 103, 49, 23, 164, 171, 188, 194, 197, 156, 187, 249, 28, 198, 95, 69, 15, 182, 56, 54, 38
+            48, 130, 1, 37, 2, 1, 0, 48, 11, 6, 9, 96, 134, 72, 1, 101, 3, 4, 2, 1, 48, 130, 1, 17,
+            48, 37, 2, 1, 1, 4, 32, 176, 223, 31, 133, 108, 84, 158, 102, 70, 11, 165, 175, 196, 12,
+            201, 130, 25, 131, 46, 125, 156, 194, 28, 23, 55, 133, 157, 164, 135, 136, 220, 78, 48,
+            37, 2, 1, 2, 4, 32, 190, 82, 180, 235, 222, 33, 79, 50, 152, 136, 142, 35, 116, 224, 6,
+            242, 156, 141, 128, 248, 10, 61, 98, 86, 248, 45, 207, 210, 90, 232, 175, 38, 48, 37, 2,
+            1, 3, 4, 32, 0, 194, 104, 108, 237, 246, 97, 230, 116, 198, 69, 110, 26, 87, 17, 89,
+            110, 199, 108, 250, 36, 21, 39, 87, 110, 102, 250, 213, 174, 131, 171, 174, 48, 37, 2,
+            1, 11, 4, 32, 136, 155, 87, 144, 111, 15, 152, 127, 85, 25, 154, 81, 20, 58, 51, 75,
+            193, 116, 234, 0, 60, 30, 29, 30, 183, 141, 72, 247, 255, 203, 100, 124, 48, 37, 2, 1,
+            12, 4, 32, 41, 234, 106, 78, 31, 11, 114, 137, 237, 17, 92, 71, 134, 47, 62, 78, 189,
+            233, 201, 214, 53, 4, 47, 189, 201, 133, 6, 121, 34, 131, 64, 142, 48, 37, 2, 1, 13, 4,
+            32, 91, 222, 210, 193, 62, 222, 104, 82, 36, 41, 138, 253, 70, 15, 148, 208, 156, 45,
+            105, 171, 241, 195, 185, 43, 217, 162, 146, 201, 222, 89, 238, 38, 48, 37, 2, 1, 14, 4,
+            32, 76, 123, 216, 13, 51, 227, 72, 245, 59, 193, 238, 166, 103, 49, 23, 164, 171, 188,
+            194, 197, 156, 187, 249, 28, 198, 95, 69, 15, 182, 56, 54, 38,
         ];
         let result = [
-            32, 85, 108, 174, 127, 112, 178, 182, 8, 43, 134, 123, 192, 211, 131, 66, 184, 240, 212, 181, 240, 180, 106, 195, 24, 117, 54, 129, 19, 10, 250, 53
+            32, 85, 108, 174, 127, 112, 178, 182, 8, 43, 134, 123, 192, 211, 131, 66, 184, 240, 212,
+            181, 240, 180, 106, 195, 24, 117, 54, 129, 19, 10, 250, 53,
         ];
         assert_eq(sha256_var(input, input.len() as u64), result);
     }
+
+    #[test]
+    fn same_msg_len_variable_padding() {
+        let input = [
+            29, 81, 165, 84, 243, 114, 101, 37, 242, 146, 127, 99, 69, 145, 39, 72, 213, 39, 253,
+            179, 218, 37, 217, 201, 172, 93, 198, 50, 249, 70, 15, 30, 162, 112, 187, 40, 140, 9,
+            236, 53, 32, 44, 38, 163, 113, 254, 192, 197, 44, 89, 71, 130, 169, 242, 17, 211, 214,
+            72, 19, 178, 186, 168, 147, 127, 99, 101, 252, 227, 8, 147, 150, 85, 97, 158, 17, 107,
+            218, 244, 82, 113, 247, 91, 208, 214, 60, 244, 87, 137, 173, 201, 130, 18, 66, 56, 198,
+            149, 207, 189, 175, 120, 123, 224, 177, 167, 251, 159, 143, 110, 68, 183, 189, 70, 126,
+            32, 35, 164, 44, 30, 44, 12, 65, 18, 62, 239, 242, 2, 248, 104, 2, 178, 64, 28, 126, 36,
+            137, 24, 14, 116, 91, 98, 90, 159, 218, 102, 45, 11, 110, 223, 245, 184, 52, 99, 59,
+            245, 136, 175, 3, 72, 164, 146, 145, 116, 22, 66, 24, 49, 193, 121, 3, 60, 37, 41, 97,
+            3, 190, 66, 195, 225, 63, 46, 3, 118, 4, 208, 15, 1, 40, 254, 235, 151, 123, 70, 180,
+            170, 44, 172, 90, 4, 254, 53, 239, 116, 246, 67, 56, 129, 61, 22, 169, 213, 65, 27, 216,
+            116, 162, 239, 214, 207, 126, 177, 20, 100, 25, 48, 143, 84, 215, 70, 197, 53, 65, 70,
+            86, 172, 61, 62, 9, 212, 167, 169, 133, 41, 126, 213, 196, 33, 192, 238, 0, 63, 246,
+            215, 58, 128, 110, 101, 92, 3, 170, 214, 130, 149, 52, 81, 125, 118, 233, 3, 118, 193,
+            104, 207, 120, 115, 77, 253, 191, 122, 0, 107, 164, 207, 113, 81, 169, 36, 201, 228, 74,
+            134, 131, 218, 178, 35, 30, 216, 101, 2, 103, 174, 87, 95, 50, 50, 215, 157, 5, 210,
+            188, 54, 211, 78, 45, 199, 96, 121, 241, 241, 176, 226, 194, 134, 130, 89, 217, 210,
+            186, 32, 140, 39, 91, 103, 212, 26, 87, 32, 72, 144, 228, 230, 117, 99, 188, 50, 15, 69,
+            79, 179, 50, 12, 106, 86, 218, 101, 73, 142, 243, 29, 250, 122, 228, 233, 29, 255, 22,
+            121, 114, 125, 103, 41, 250, 241, 179, 126, 158, 198, 116, 209, 65, 94, 98, 228, 175,
+            169, 96, 3, 9, 233, 133, 214, 55, 161, 164, 103, 80, 85, 24, 186, 64, 167, 92, 131, 53,
+            101, 202, 47, 25, 104, 118, 155, 14, 12, 12, 25, 116, 45, 221, 249, 28, 246, 212, 200,
+            157, 167, 169, 56, 197, 181, 4, 245, 146, 1, 140, 234, 191, 212, 228, 125, 87, 81, 86,
+            119, 30, 63, 129, 143, 32, 96,
+        ];
+
+        // Prepare inputs of different lengths
+        let mut input_511 = [0; 511];
+        let mut input_512 = [0; 512]; // Next block
+        let mut input_575 = [0; 575];
+        let mut input_576 = [0; 576]; // Next block
+        for i in 0..input.len() {
+            input_511[i] = input[i];
+            input_512[i] = input[i];
+            input_575[i] = input[i];
+            input_576[i] = input[i];
+        }
+
+        // Compute hashes of all inputs (with same message length)
+        let fixed_length_hash = super::sha256(input);
+        let var_full_length_hash = sha256_var(input, input.len() as u64);
+        let var_length_hash_511 = sha256_var(input_511, input.len() as u64);
+        let var_length_hash_512 = sha256_var(input_512, input.len() as u64);
+        let var_length_hash_575 = sha256_var(input_575, input.len() as u64);
+        let var_length_hash_576 = sha256_var(input_576, input.len() as u64);
+
+        // All of the above should have produced the same hash
+        assert_eq(var_full_length_hash, fixed_length_hash);
+        assert_eq(var_length_hash_511, fixed_length_hash);
+        assert_eq(var_length_hash_512, fixed_length_hash);
+        assert_eq(var_length_hash_575, fixed_length_hash);
+        assert_eq(var_length_hash_576, fixed_length_hash);
+    }
+
+    #[test]
+    fn test_get_item_byte() {
+        let fld = make_item(10, 20, 30, 40);
+        assert_eq(fld, 0x0a141e28);
+        assert_eq(get_item_byte(fld, 0), 10);
+        assert_eq(get_item_byte(fld, 4), 10);
+        assert_eq(get_item_byte(fld, 6), 30);
+    }
+
+    #[test]
+    fn test_byte_into_item() {
+        let fld = make_item(0, 20, 0, 0);
+        assert_eq(byte_into_item(20, 1), fld);
+        assert_eq(byte_into_item(20, 5), fld);
+    }
+
+    #[test]
+    fn test_set_item_zeros() {
+        let fld0 = make_item(10, 20, 30, 40);
+        let fld1 = make_item(10, 0, 0, 0);
+        assert_eq(set_item_zeros(fld0, 3), fld1);
+        assert_eq(set_item_zeros(fld0, 4), 0);
+        assert_eq(set_item_zeros(0, 4), 0);
+    }
+
+    #[test]
+    fn test_set_item_byte_then_zeros() {
+        let fld0 = make_item(10, 20, 30, 40);
+        let fld1 = make_item(10, 50, 0, 0);
+        assert_eq(set_item_byte_then_zeros(fld0, 1, 50), fld1);
+    }
+
+    #[test]
+    fn test_build_msg_block_start_0() {
+        let input = [
+            102, 114, 111, 109, 58, 114, 117, 110, 110, 105, 101, 114, 46, 108, 101, 97, 103, 117,
+            101, 115, 46, 48,
+        ];
+        assert_eq(input.len(), 22);
+        let (msg_block, msg_byte_ptr) = unsafe { build_msg_block(input, input.len(), 0) };
+        assert_eq(msg_byte_ptr, input.len());
+        assert_eq(msg_block[0], make_item(input[0], input[1], input[2], input[3]));
+        assert_eq(msg_block[1], make_item(input[4], input[5], input[6], input[7]));
+        assert_eq(msg_block[5], make_item(input[20], input[21], 0, 0));
+        assert_eq(msg_block[6], 0);
+    }
+
+    #[test]
+    fn test_build_msg_block_start_1() {
+        let input = [
+            102, 114, 111, 109, 58, 114, 117, 110, 110, 105, 101, 114, 46, 108, 101, 97, 103, 117,
+            101, 115, 46, 48, 106, 64, 105, 99, 108, 111, 117, 100, 46, 99, 111, 109, 13, 10, 99,
+            111, 110, 116, 101, 110, 116, 45, 116, 121, 112, 101, 58, 116, 101, 120, 116, 47, 112,
+            108, 97, 105, 110, 59, 32, 99, 104, 97, 114, 115, 101, 116,
+        ];
+        assert_eq(input.len(), 68);
+        let (msg_block, msg_byte_ptr) = unsafe { build_msg_block(input, input.len(), 64) };
+        assert_eq(msg_byte_ptr, 4);
+        assert_eq(msg_block[0], make_item(input[64], input[65], input[66], input[67]));
+        assert_eq(msg_block[1], 0);
+    }
+
+    #[test]
+    fn test_attach_len_to_msg_block() {
+        let input: INT_BLOCK = [
+            2152555847, 1397309779, 1936618851, 1262052426, 1936876331, 1985297723, 543702374,
+            1919905082, 1131376244, 1701737517, 1417244773, 978151789, 1697470053, 1920166255,
+            1849316213, 1651139939,
+        ];
+        let msg_block = unsafe { attach_len_to_msg_block(input, 1, 448) };
+        assert_eq(msg_block[0], ((1 << 7) as u32) * 256 * 256 * 256);
+        assert_eq(msg_block[1], 0);
+        assert_eq(msg_block[15], 3584);
+    }
 }
diff --git a/noir_stdlib/src/hash/sha512.nr b/noir_stdlib/src/hash/sha512.nr
index 09de174103f..5630139c1f1 100644
--- a/noir_stdlib/src/hash/sha512.nr
+++ b/noir_stdlib/src/hash/sha512.nr
@@ -35,7 +35,7 @@ fn sha_sigma1(x: u64) -> u64 {
 
 fn sha_w(msg: [u64; 16]) -> [u64; 80] // Expanded message blocks
 {
-    let mut w: [u64;80] = [0; 80];
+    let mut w: [u64; 80] = [0; 80];
 
     for j in 0..16 {
         w[j] = msg[j];
@@ -43,8 +43,8 @@ fn sha_w(msg: [u64; 16]) -> [u64; 80] // Expanded message blocks
 
     for j in 16..80 {
         w[j] = crate::wrapping_add(
-            crate::wrapping_add(sha_sigma1(w[j-2]), w[j-7]), 
-            crate::wrapping_add(sha_sigma0(w[j-15]), w[j-16]),
+            crate::wrapping_add(sha_sigma1(w[j - 2]), w[j - 7]),
+            crate::wrapping_add(sha_sigma0(w[j - 15]), w[j - 16]),
         );
     }
     w
@@ -65,7 +65,7 @@ fn sha_c(msg: [u64; 16], hash: [u64; 8]) -> [u64; 8] {
         out_h[7] = out_h[6];
         out_h[6] = out_h[5];
         out_h[5] = out_h[4];
-        out_h[4] = crate::wrapping_add(out_h[3] , t1);
+        out_h[4] = crate::wrapping_add(out_h[3], t1);
         out_h[3] = out_h[2];
         out_h[2] = out_h[1];
         out_h[1] = out_h[0];
@@ -81,7 +81,7 @@ fn msg_u8_to_u64(msg: [u8; 128]) -> [u64; 16] {
     for i in 0..16 {
         let mut msg_field: Field = 0;
         for j in 0..8 {
-            msg_field = msg_field * 256 + msg[128 - 8*(i + 1) + j] as Field;
+            msg_field = msg_field * 256 + msg[128 - 8 * (i + 1) + j] as Field;
         }
         msg64[15 - i] = msg_field as u64;
     }
@@ -157,7 +157,7 @@ pub fn digest<let N: u32>(msg: [u8; N]) -> [u8; 64] {
     for j in 0..8 {
         let h_bytes: [u8; 8] = (h[7 - j] as Field).to_le_bytes();
         for k in 0..8 {
-            out_h[63 - 8*j - k] = h_bytes[k];
+            out_h[63 - 8 * j - k] = h_bytes[k];
         }
     }
 
diff --git a/noir_stdlib/src/hint.nr b/noir_stdlib/src/hint.nr
new file mode 100644
index 00000000000..25dcc7ec56e
--- /dev/null
+++ b/noir_stdlib/src/hint.nr
@@ -0,0 +1,6 @@
+/// An identity function that *hints* to the compiler to be maximally pessimistic about what `black_box` could do.
+///
+/// This can be used to block the SSA optimization passes being applied to a value, which should help to prevent
+/// test programs from being optimized down to nothing and have them resemble runtime code more closely.
+#[builtin(black_box)]
+pub fn black_box<T>(value: T) -> T {}
diff --git a/noir_stdlib/src/lib.nr b/noir_stdlib/src/lib.nr
index 3d1dd3e90eb..c3a289a8fa2 100644
--- a/noir_stdlib/src/lib.nr
+++ b/noir_stdlib/src/lib.nr
@@ -3,15 +3,12 @@ pub mod aes128;
 pub mod array;
 pub mod slice;
 pub mod merkle;
-pub mod schnorr;
 pub mod ecdsa_secp256k1;
 pub mod ecdsa_secp256r1;
-pub mod eddsa;
 pub mod embedded_curve_ops;
 pub mod sha256;
 pub mod sha512;
 pub mod field;
-pub mod ec;
 pub mod collections;
 pub mod compat;
 pub mod convert;
@@ -29,6 +26,7 @@ pub mod meta;
 pub mod append;
 pub mod mem;
 pub mod panic;
+pub mod hint;
 
 // Oracle calls are required to be wrapped in an unconstrained function
 // Thus, the only argument to the `println` oracle is expected to always be an ident
@@ -55,7 +53,7 @@ pub fn verify_proof<let N: u32, let M: u32, let K: u32>(
     verification_key: [Field; N],
     proof: [Field; M],
     public_inputs: [Field; K],
-    key_hash: Field
+    key_hash: Field,
 ) {
     verify_proof_internal(verification_key, proof, public_inputs, key_hash, 0);
 }
@@ -65,9 +63,11 @@ pub fn verify_proof_with_type<let N: u32, let M: u32, let K: u32>(
     proof: [Field; M],
     public_inputs: [Field; K],
     key_hash: Field,
-    proof_type: u32
+    proof_type: u32,
 ) {
-    crate::assert_constant(proof_type);
+    if !crate::runtime::is_unconstrained() {
+        crate::assert_constant(proof_type);
+    }
     verify_proof_internal(verification_key, proof, public_inputs, key_hash, proof_type);
 }
 
@@ -77,7 +77,7 @@ fn verify_proof_internal<let N: u32, let M: u32, let K: u32>(
     proof: [Field; M],
     public_inputs: [Field; K],
     key_hash: Field,
-    proof_type: u32
+    proof_type: u32,
 ) {}
 
 // Asserts that the given value is known at compile-time.
@@ -104,7 +104,9 @@ pub fn wrapping_add<T>(x: T, y: T) -> T {
 
 pub fn wrapping_sub<T>(x: T, y: T) -> T {
     //340282366920938463463374607431768211456 is 2^128, it is used to avoid underflow
-    crate::from_field(crate::as_field(x) + 340282366920938463463374607431768211456 - crate::as_field(y))
+    crate::from_field(
+        crate::as_field(x) + 340282366920938463463374607431768211456 - crate::as_field(y),
+    )
 }
 
 pub fn wrapping_mul<T>(x: T, y: T) -> T {
@@ -113,4 +115,3 @@ pub fn wrapping_mul<T>(x: T, y: T) -> T {
 
 #[builtin(as_witness)]
 pub fn as_witness(x: Field) {}
-
diff --git a/noir_stdlib/src/mem.nr b/noir_stdlib/src/mem.nr
index 88d17e20ee3..23125867eab 100644
--- a/noir_stdlib/src/mem.nr
+++ b/noir_stdlib/src/mem.nr
@@ -4,3 +4,28 @@
 #[builtin(zeroed)]
 pub fn zeroed<T>() -> T {}
 
+/// Transmutes a value of type T to a value of type U.
+///
+/// Both types are asserted to be equal during compilation but after type checking.
+/// If not, a compilation error is issued.
+///
+/// This function is useful for types using arithmetic generics in cases
+/// which the compiler otherwise cannot prove equal during type checking.
+/// You can use this to obtain a value of the correct type while still asserting
+/// that it is equal to the previous.
+#[builtin(checked_transmute)]
+pub fn checked_transmute<T, U>(value: T) -> U {}
+
+/// Returns the internal reference count of an array value in unconstrained code.
+///
+/// Arrays only have reference count in unconstrained code - using this anywhere
+/// else will return zero.
+#[builtin(array_refcount)]
+pub fn array_refcount<T, let N: u32>(array: [T; N]) -> u32 {}
+
+/// Returns the internal reference count of a slice value in unconstrained code.
+///
+/// Slices only have reference count in unconstrained code - using this anywhere
+/// else will return zero.
+#[builtin(slice_refcount)]
+pub fn slice_refcount<T>(slice: [T]) -> u32 {}
diff --git a/noir_stdlib/src/meta/ctstring.nr b/noir_stdlib/src/meta/ctstring.nr
index ec205fa6f88..b414b3418d9 100644
--- a/noir_stdlib/src/meta/ctstring.nr
+++ b/noir_stdlib/src/meta/ctstring.nr
@@ -2,20 +2,20 @@ use crate::append::Append;
 
 impl CtString {
     // docs:start:new
-    comptime fn new() -> Self {
+    pub comptime fn new() -> Self {
         // docs:end:new
         "".as_ctstring()
     }
 
     // Bug: using &mut self as the object results in this method not being found
     // docs:start:append_str
-    comptime fn append_str<let N: u32>(self, s: str<N>) -> Self {
+    pub comptime fn append_str<let N: u32>(self, s: str<N>) -> Self {
         // docs:end:append_str
         f"{self}{s}".as_ctstring()
     }
 
     // docs:start:append_fmtstr
-    comptime fn append_fmtstr<let N: u32, T>(self, s: fmtstr<N, T>) -> Self {
+    pub comptime fn append_fmtstr<let N: u32, T>(self, s: fmtstr<N, T>) -> Self {
         // docs:end:append_fmtstr
         f"{self}{s}".as_ctstring()
     }
@@ -24,7 +24,7 @@ impl CtString {
     /// To get around this, we return a quoted str and the underlying str can
     /// be accessed using macro insertion `foo.as_quoted_str!()`.
     // docs:start:as_quoted_str
-    comptime fn as_quoted_str(self) -> Quoted {
+    pub comptime fn as_quoted_str(self) -> Quoted {
         // docs:end:as_quoted_str
         quote { $self }
     }
@@ -65,7 +65,10 @@ impl crate::cmp::Eq for CtString {
 }
 
 impl crate::hash::Hash for CtString {
-    comptime fn hash<H>(self, state: &mut H) where H: crate::hash::Hasher {
+    comptime fn hash<H>(self, state: &mut H)
+    where
+        H: crate::hash::Hasher,
+    {
         state.write(ctstring_hash(self));
     }
 }
@@ -85,8 +88,7 @@ comptime fn ctstring_hash(_string: CtString) -> Field {}
 mod test {
     #[test]
     fn as_quoted_str_example() {
-        comptime
-        {
+        comptime {
             // docs:start:as_quoted_str_example
             let my_ctstring = "foo bar".as_ctstring();
             let my_str = my_ctstring.as_quoted_str!();
diff --git a/noir_stdlib/src/meta/expr.nr b/noir_stdlib/src/meta/expr.nr
index c96f7d27442..bb795a520d3 100644
--- a/noir_stdlib/src/meta/expr.nr
+++ b/noir_stdlib/src/meta/expr.nr
@@ -1,96 +1,96 @@
 //! Contains methods on the built-in `Expr` type for quoted, syntactically valid expressions.
 
-use crate::option::Option;
-use crate::meta::op::UnaryOp;
 use crate::meta::op::BinaryOp;
+use crate::meta::op::UnaryOp;
+use crate::option::Option;
 
 impl Expr {
     /// If this expression is an array literal `[elem1, ..., elemN]`, this returns a slice of each element in the array.
     #[builtin(expr_as_array)]
     // docs:start:as_array
-    comptime fn as_array(self) -> Option<[Expr]> {}
+    pub comptime fn as_array(self) -> Option<[Expr]> {}
     // docs:end:as_array
 
     /// If this expression is an assert, this returns the assert expression and the optional message.
     #[builtin(expr_as_assert)]
     // docs:start:as_assert
-    comptime fn as_assert(self) -> Option<(Expr, Option<Expr>)> {}
+    pub comptime fn as_assert(self) -> Option<(Expr, Option<Expr>)> {}
     // docs:end:as_assert
 
     /// If this expression is an assert_eq, this returns the left-hand-side and right-hand-side
     /// expressions, together with the optional message.
     #[builtin(expr_as_assert_eq)]
     // docs:start:as_assert_eq
-    comptime fn as_assert_eq(self) -> Option<(Expr, Expr, Option<Expr>)> {}
+    pub comptime fn as_assert_eq(self) -> Option<(Expr, Expr, Option<Expr>)> {}
     // docs:end:as_assert_eq
 
     /// If this expression is an assignment, this returns a tuple with the left hand side
     /// and right hand side in order.
     #[builtin(expr_as_assign)]
     // docs:start:as_assign
-    comptime fn as_assign(self) -> Option<(Expr, Expr)> {}
+    pub comptime fn as_assign(self) -> Option<(Expr, Expr)> {}
     // docs:end:as_assign
 
     /// If this expression is a binary operator operation `<lhs> <op> <rhs>`,
     /// return the left-hand side, operator, and the right-hand side of the operation.
     #[builtin(expr_as_binary_op)]
     // docs:start:as_binary_op
-    comptime fn as_binary_op(self) -> Option<(Expr, BinaryOp, Expr)> {}
+    pub comptime fn as_binary_op(self) -> Option<(Expr, BinaryOp, Expr)> {}
     // docs:end:as_binary_op
 
     /// If this expression is a block `{ stmt1; stmt2; ...; stmtN }`, return
     /// a slice containing each statement.
     #[builtin(expr_as_block)]
     // docs:start:as_block
-    comptime fn as_block(self) -> Option<[Expr]> {}
+    pub comptime fn as_block(self) -> Option<[Expr]> {}
     // docs:end:as_block
 
     /// If this expression is a boolean literal, return that literal.
     #[builtin(expr_as_bool)]
     // docs:start:as_bool
-    comptime fn as_bool(self) -> Option<bool> {}
+    pub comptime fn as_bool(self) -> Option<bool> {}
     // docs:end:as_bool
 
     /// If this expression is a cast expression `expr as type`, returns the casted
     /// expression and the type to cast to.
     // docs:start:as_cast
     #[builtin(expr_as_cast)]
-    comptime fn as_cast(self) -> Option<(Expr, UnresolvedType)> {}
+    pub comptime fn as_cast(self) -> Option<(Expr, UnresolvedType)> {}
     // docs:end:as_cast
 
     /// If this expression is a `comptime { stmt1; stmt2; ...; stmtN }` block,
     /// return each statement in the block.
     #[builtin(expr_as_comptime)]
     // docs:start:as_comptime
-    comptime fn as_comptime(self) -> Option<[Expr]> {}
+    pub comptime fn as_comptime(self) -> Option<[Expr]> {}
     // docs:end:as_comptime
 
     /// If this expression is a constructor `Type { field1: expr1, ..., fieldN: exprN }`,
     /// return the type and the fields.
     #[builtin(expr_as_constructor)]
     // docs:start:as_constructor
-    comptime fn as_constructor(self) -> Option<(UnresolvedType, [(Quoted, Expr)])> {}
+    pub comptime fn as_constructor(self) -> Option<(UnresolvedType, [(Quoted, Expr)])> {}
     // docs:end:as_constructor
 
     /// If this expression is a for statement over a single expression, return the identifier,
     /// the expression and the for loop body.
     #[builtin(expr_as_for)]
     // docs:start:as_for
-    comptime fn as_for(self) -> Option<(Quoted, Expr, Expr)> {}
+    pub comptime fn as_for(self) -> Option<(Quoted, Expr, Expr)> {}
     // docs:end:as_for
 
     /// If this expression is a for statement over a range, return the identifier,
     /// the range start, the range end and the for loop body.
     #[builtin(expr_as_for_range)]
     // docs:start:as_for_range
-    comptime fn as_for_range(self) -> Option<(Quoted, Expr, Expr, Expr)> {}
+    pub comptime fn as_for_range(self) -> Option<(Quoted, Expr, Expr, Expr)> {}
     // docs:end:as_for_range
 
     /// If this expression is a function call `foo(arg1, ..., argN)`, return
     /// the function and a slice of each argument.
     #[builtin(expr_as_function_call)]
     // docs:start:as_function_call
-    comptime fn as_function_call(self) -> Option<(Expr, [Expr])> {}
+    pub comptime fn as_function_call(self) -> Option<(Expr, [Expr])> {}
     // docs:end:as_function_call
 
     /// If this expression is an `if condition { then_branch } else { else_branch }`,
@@ -98,96 +98,98 @@ impl Expr {
     /// `None` is returned for that branch instead.
     #[builtin(expr_as_if)]
     // docs:start:as_if
-    comptime fn as_if(self) -> Option<(Expr, Expr, Option<Expr>)> {}
+    pub comptime fn as_if(self) -> Option<(Expr, Expr, Option<Expr>)> {}
     // docs:end:as_if
 
     /// If this expression is an index into an array `array[index]`, return the
     /// array and the index.
     #[builtin(expr_as_index)]
     // docs:start:as_index
-    comptime fn as_index(self) -> Option<(Expr, Expr)> {}
+    pub comptime fn as_index(self) -> Option<(Expr, Expr)> {}
     // docs:end:as_index
 
     /// If this expression is an integer literal, return the integer as a field
     /// as well as whether the integer is negative (true) or not (false).
     #[builtin(expr_as_integer)]
     // docs:start:as_integer
-    comptime fn as_integer(self) -> Option<(Field, bool)> {}
+    pub comptime fn as_integer(self) -> Option<(Field, bool)> {}
     // docs:end:as_integer
 
     /// If this expression is a lambda, returns the parameters, return type and body.
     #[builtin(expr_as_lambda)]
     // docs:start:as_lambda
-    comptime fn as_lambda(self) -> Option<([(Expr, Option<UnresolvedType>)], Option<UnresolvedType>, Expr)> {}
+    pub comptime fn as_lambda(
+        self,
+    ) -> Option<([(Expr, Option<UnresolvedType>)], Option<UnresolvedType>, Expr)> {}
     // docs:end:as_lambda
 
     /// If this expression is a let statement, returns the let pattern as an `Expr`,
     /// the optional type annotation, and the assigned expression.
     #[builtin(expr_as_let)]
     // docs:start:as_let
-    comptime fn as_let(self) -> Option<(Expr, Option<UnresolvedType>, Expr)> {}
+    pub comptime fn as_let(self) -> Option<(Expr, Option<UnresolvedType>, Expr)> {}
     // docs:end:as_let
 
     /// If this expression is a member access `foo.bar`, return the struct/tuple
     /// expression and the field. The field will be represented as a quoted value.
     #[builtin(expr_as_member_access)]
     // docs:start:as_member_access
-    comptime fn as_member_access(self) -> Option<(Expr, Quoted)> {}
+    pub comptime fn as_member_access(self) -> Option<(Expr, Quoted)> {}
     // docs:end:as_member_access
 
     /// If this expression is a method call `foo.bar::<generic1, ..., genericM>(arg1, ..., argN)`, return
     /// the receiver, method name, a slice of each generic argument, and a slice of each argument.
     #[builtin(expr_as_method_call)]
     // docs:start:as_method_call
-    comptime fn as_method_call(self) -> Option<(Expr, Quoted, [UnresolvedType], [Expr])> {}
+    pub comptime fn as_method_call(self) -> Option<(Expr, Quoted, [UnresolvedType], [Expr])> {}
     // docs:end:as_method_call
 
     /// If this expression is a repeated element array `[elem; length]`, return
     /// the repeated element and the length expressions.
     #[builtin(expr_as_repeated_element_array)]
     // docs:start:as_repeated_element_array
-    comptime fn as_repeated_element_array(self) -> Option<(Expr, Expr)> {}
+    pub comptime fn as_repeated_element_array(self) -> Option<(Expr, Expr)> {}
     // docs:end:as_repeated_element_array
 
     /// If this expression is a repeated element slice `[elem; length]`, return
     /// the repeated element and the length expressions.
     #[builtin(expr_as_repeated_element_slice)]
     // docs:start:as_repeated_element_slice
-    comptime fn as_repeated_element_slice(self) -> Option<(Expr, Expr)> {}
+    pub comptime fn as_repeated_element_slice(self) -> Option<(Expr, Expr)> {}
     // docs:end:as_repeated_element_slice
 
     /// If this expression is a slice literal `&[elem1, ..., elemN]`,
     /// return each element of the slice.
     #[builtin(expr_as_slice)]
     // docs:start:as_slice
-    comptime fn as_slice(self) -> Option<[Expr]> {}
+    pub comptime fn as_slice(self) -> Option<[Expr]> {}
     // docs:end:as_slice
 
     /// If this expression is a tuple `(field1, ..., fieldN)`,
     /// return each element of the tuple.
     #[builtin(expr_as_tuple)]
     // docs:start:as_tuple
-    comptime fn as_tuple(self) -> Option<[Expr]> {}
+    pub comptime fn as_tuple(self) -> Option<[Expr]> {}
     // docs:end:as_tuple
 
     /// If this expression is a unary operation `<op> <rhs>`,
     /// return the unary operator as well as the right-hand side expression.
     #[builtin(expr_as_unary_op)]
     // docs:start:as_unary_op
-    comptime fn as_unary_op(self) -> Option<(UnaryOp, Expr)> {}
+    pub comptime fn as_unary_op(self) -> Option<(UnaryOp, Expr)> {}
     // docs:end:as_unary_op
 
     /// If this expression is an `unsafe { stmt1; ...; stmtN }` block,
     /// return each statement inside in a slice.
     #[builtin(expr_as_unsafe)]
     // docs:start:as_unsafe
-    comptime fn as_unsafe(self) -> Option<[Expr]> {}
+    pub comptime fn as_unsafe(self) -> Option<[Expr]> {}
     // docs:end:as_unsafe
 
     /// Returns `true` if this expression is trailed by a semicolon.
     ///
     /// Example:
-    /// 
+    ///
     /// ```noir
     /// comptime {
     ///     let expr1 = quote { 1 + 2 }.as_expr().unwrap();
@@ -195,37 +197,37 @@ impl Expr {
     ///
     ///     assert(expr1.as_binary_op().is_some());
     ///     assert(expr2.as_binary_op().is_some());
-    /// 
+    ///
     ///     assert(!expr1.has_semicolon());
     ///     assert(expr2.has_semicolon());
     /// }
     /// ```
     #[builtin(expr_has_semicolon)]
     // docs:start:has_semicolon
-    comptime fn has_semicolon(self) -> bool {}
+    pub comptime fn has_semicolon(self) -> bool {}
     // docs:end:has_semicolon
 
     /// Returns `true` if this expression is `break`.
     #[builtin(expr_is_break)]
     // docs:start:is_break
-    comptime fn is_break(self) -> bool {}
+    pub comptime fn is_break(self) -> bool {}
     // docs:end:is_break
 
     /// Returns `true` if this expression is `continue`.
     #[builtin(expr_is_continue)]
     // docs:start:is_continue
-    comptime fn is_continue(self) -> bool {}
+    pub comptime fn is_continue(self) -> bool {}
     // docs:end:is_continue
 
     /// Applies a mapping function to this expression and to all of its sub-expressions.
     /// `f` will be applied to each sub-expression first, then applied to the expression itself.
-    /// 
+    ///
     /// This happens recursively for every expression within `self`.
-    /// 
+    ///
     /// For example, calling `modify` on `(&[1], &[2, 3])` with an `f` that returns `Option::some`
     /// for expressions that are integers, doubling them, would return `(&[2], &[4, 6])`.
     // docs:start:modify
-    comptime fn modify<Env>(self, f: fn[Env](Expr) -> Option<Expr>) -> Expr {
+    pub comptime fn modify<Env>(self, f: fn[Env](Expr) -> Option<Expr>) -> Expr {
         // docs:end:modify
         let result = modify_array(self, f);
         let result = result.or_else(|| modify_assert(self, f));
@@ -262,278 +264,243 @@ impl Expr {
 
     /// Returns this expression as a `Quoted` value. It's the same as `quote { $self }`.
     // docs:start:quoted
-    comptime fn quoted(self) -> Quoted {
+    pub comptime fn quoted(self) -> Quoted {
         // docs:end:quoted
         quote { $self }
     }
 
-    /// Resolves and type-checks this expression and returns the result as a `TypedExpr`. 
-    /// 
+    /// Resolves and type-checks this expression and returns the result as a `TypedExpr`.
+    ///
     /// The `in_function` argument specifies where the expression is resolved:
     /// - If it's `none`, the expression is resolved in the function where `resolve` was called
     /// - If it's `some`, the expression is resolved in the given function
-    /// 
-    /// If any names used by this expression are not in scope or if there are any type errors, 
-    /// this will give compiler errors as if the expression was written directly into 
+    ///
+    /// If any names used by this expression are not in scope or if there are any type errors,
+    /// this will give compiler errors as if the expression was written directly into
     /// the current `comptime` function.
     #[builtin(expr_resolve)]
     // docs:start:resolve
-    comptime fn resolve(self, in_function: Option<FunctionDefinition>) -> TypedExpr {}
+    pub comptime fn resolve(self, in_function: Option<FunctionDefinition>) -> TypedExpr {}
     // docs:end:resolve
 }
 
 comptime fn modify_array<Env>(expr: Expr, f: fn[Env](Expr) -> Option<Expr>) -> Option<Expr> {
-    expr.as_array().map(
-        |exprs: [Expr]| {
+    expr.as_array().map(|exprs: [Expr]| {
         let exprs = modify_expressions(exprs, f);
         new_array(exprs)
-    }
-    )
+    })
 }
 
 comptime fn modify_assert<Env>(expr: Expr, f: fn[Env](Expr) -> Option<Expr>) -> Option<Expr> {
-    expr.as_assert().map(
-        |expr: (Expr, Option<Expr>)| {
+    expr.as_assert().map(|expr: (Expr, Option<Expr>)| {
         let (predicate, msg) = expr;
         let predicate = predicate.modify(f);
         let msg = msg.map(|msg: Expr| msg.modify(f));
         new_assert(predicate, msg)
-    }
-    )
+    })
 }
 
 comptime fn modify_assert_eq<Env>(expr: Expr, f: fn[Env](Expr) -> Option<Expr>) -> Option<Expr> {
-    expr.as_assert_eq().map(
-        |expr: (Expr, Expr, Option<Expr>)| {
+    expr.as_assert_eq().map(|expr: (Expr, Expr, Option<Expr>)| {
         let (lhs, rhs, msg) = expr;
         let lhs = lhs.modify(f);
         let rhs = rhs.modify(f);
         let msg = msg.map(|msg: Expr| msg.modify(f));
         new_assert_eq(lhs, rhs, msg)
-    }
-    )
+    })
 }
 
 comptime fn modify_assign<Env>(expr: Expr, f: fn[Env](Expr) -> Option<Expr>) -> Option<Expr> {
-    expr.as_assign().map(
-        |expr: (Expr, Expr)| {
+    expr.as_assign().map(|expr: (Expr, Expr)| {
         let (lhs, rhs) = expr;
         let lhs = lhs.modify(f);
         let rhs = rhs.modify(f);
         new_assign(lhs, rhs)
-    }
-    )
+    })
 }
 
 comptime fn modify_binary_op<Env>(expr: Expr, f: fn[Env](Expr) -> Option<Expr>) -> Option<Expr> {
-    expr.as_binary_op().map(
-        |expr: (Expr, BinaryOp, Expr)| {
+    expr.as_binary_op().map(|expr: (Expr, BinaryOp, Expr)| {
         let (lhs, op, rhs) = expr;
         let lhs = lhs.modify(f);
         let rhs = rhs.modify(f);
         new_binary_op(lhs, op, rhs)
-    }
-    )
+    })
 }
 
 comptime fn modify_block<Env>(expr: Expr, f: fn[Env](Expr) -> Option<Expr>) -> Option<Expr> {
-    expr.as_block().map(
-        |exprs: [Expr]| {
+    expr.as_block().map(|exprs: [Expr]| {
         let exprs = modify_expressions(exprs, f);
         new_block(exprs)
-    }
-    )
+    })
 }
 
 comptime fn modify_cast<Env>(expr: Expr, f: fn[Env](Expr) -> Option<Expr>) -> Option<Expr> {
-    expr.as_cast().map(
-        |expr: (Expr, UnresolvedType)| {
+    expr.as_cast().map(|expr: (Expr, UnresolvedType)| {
         let (expr, typ) = expr;
         let expr = expr.modify(f);
         new_cast(expr, typ)
-    }
-    )
+    })
 }
 
 comptime fn modify_comptime<Env>(expr: Expr, f: fn[Env](Expr) -> Option<Expr>) -> Option<Expr> {
-    expr.as_comptime().map(
-        |exprs: [Expr]| {
+    expr.as_comptime().map(|exprs: [Expr]| {
         let exprs = exprs.map(|expr: Expr| expr.modify(f));
         new_comptime(exprs)
-    }
-    )
+    })
 }
 
 comptime fn modify_constructor<Env>(expr: Expr, f: fn[Env](Expr) -> Option<Expr>) -> Option<Expr> {
-    expr.as_constructor().map(
-        |expr: (UnresolvedType, [(Quoted, Expr)])| {
+    expr.as_constructor().map(|expr: (UnresolvedType, [(Quoted, Expr)])| {
         let (typ, fields) = expr;
         let fields = fields.map(|field: (Quoted, Expr)| {
             let (name, value) = field;
             (name, value.modify(f))
         });
         new_constructor(typ, fields)
-    }
-    )
+    })
 }
 
-comptime fn modify_function_call<Env>(expr: Expr, f: fn[Env](Expr) -> Option<Expr>) -> Option<Expr> {
-    expr.as_function_call().map(
-        |expr: (Expr, [Expr])| {
+comptime fn modify_function_call<Env>(
+    expr: Expr,
+    f: fn[Env](Expr) -> Option<Expr>,
+) -> Option<Expr> {
+    expr.as_function_call().map(|expr: (Expr, [Expr])| {
         let (function, arguments) = expr;
         let function = function.modify(f);
         let arguments = arguments.map(|arg: Expr| arg.modify(f));
         new_function_call(function, arguments)
-    }
-    )
+    })
 }
 
 comptime fn modify_if<Env>(expr: Expr, f: fn[Env](Expr) -> Option<Expr>) -> Option<Expr> {
-    expr.as_if().map(
-        |expr: (Expr, Expr, Option<Expr>)| {
+    expr.as_if().map(|expr: (Expr, Expr, Option<Expr>)| {
         let (condition, consequence, alternative) = expr;
         let condition = condition.modify(f);
         let consequence = consequence.modify(f);
         let alternative = alternative.map(|alternative: Expr| alternative.modify(f));
         new_if(condition, consequence, alternative)
-    }
-    )
+    })
 }
 
 comptime fn modify_index<Env>(expr: Expr, f: fn[Env](Expr) -> Option<Expr>) -> Option<Expr> {
-    expr.as_index().map(
-        |expr: (Expr, Expr)| {
+    expr.as_index().map(|expr: (Expr, Expr)| {
         let (object, index) = expr;
         let object = object.modify(f);
         let index = index.modify(f);
         new_index(object, index)
-    }
-    )
+    })
 }
 
 comptime fn modify_for<Env>(expr: Expr, f: fn[Env](Expr) -> Option<Expr>) -> Option<Expr> {
-    expr.as_for().map(
-        |expr: (Quoted, Expr, Expr)| {
+    expr.as_for().map(|expr: (Quoted, Expr, Expr)| {
         let (identifier, array, body) = expr;
         let array = array.modify(f);
         let body = body.modify(f);
         new_for(identifier, array, body)
-    }
-    )
+    })
 }
 
 comptime fn modify_for_range<Env>(expr: Expr, f: fn[Env](Expr) -> Option<Expr>) -> Option<Expr> {
-    expr.as_for_range().map(
-        |expr: (Quoted, Expr, Expr, Expr)| {
+    expr.as_for_range().map(|expr: (Quoted, Expr, Expr, Expr)| {
         let (identifier, from, to, body) = expr;
         let from = from.modify(f);
         let to = to.modify(f);
         let body = body.modify(f);
         new_for_range(identifier, from, to, body)
-    }
-    )
+    })
 }
 
 comptime fn modify_lambda<Env>(expr: Expr, f: fn[Env](Expr) -> Option<Expr>) -> Option<Expr> {
-    expr.as_lambda().map(
-        |expr: ([(Expr, Option<UnresolvedType>)], Option<UnresolvedType>, Expr)| {
-            let (params, return_type, body) = expr;
-            let params = params.map(|param: (Expr, Option<UnresolvedType>)| (param.0.modify(f), param.1));
-            let body = body.modify(f);
-            new_lambda(params, return_type, body)
-    }
-    )
+    expr.as_lambda().map(|expr: ([(Expr, Option<UnresolvedType>)], Option<UnresolvedType>, Expr)| {
+        let (params, return_type, body) = expr;
+        let params =
+            params.map(|param: (Expr, Option<UnresolvedType>)| (param.0.modify(f), param.1));
+        let body = body.modify(f);
+        new_lambda(params, return_type, body)
+    })
 }
 
 comptime fn modify_let<Env>(expr: Expr, f: fn[Env](Expr) -> Option<Expr>) -> Option<Expr> {
-    expr.as_let().map(
-        |expr: (Expr, Option<UnresolvedType>, Expr)| {
+    expr.as_let().map(|expr: (Expr, Option<UnresolvedType>, Expr)| {
         let (pattern, typ, expr) = expr;
         let pattern = pattern.modify(f);
         let expr = expr.modify(f);
         new_let(pattern, typ, expr)
-    }
-    )
+    })
 }
 
-comptime fn modify_member_access<Env>(expr: Expr, f: fn[Env](Expr) -> Option<Expr>) -> Option<Expr> {
-    expr.as_member_access().map(
-        |expr: (Expr, Quoted)| {
+comptime fn modify_member_access<Env>(
+    expr: Expr,
+    f: fn[Env](Expr) -> Option<Expr>,
+) -> Option<Expr> {
+    expr.as_member_access().map(|expr: (Expr, Quoted)| {
         let (object, name) = expr;
         let object = object.modify(f);
         new_member_access(object, name)
-    }
-    )
+    })
 }
 
 comptime fn modify_method_call<Env>(expr: Expr, f: fn[Env](Expr) -> Option<Expr>) -> Option<Expr> {
-    expr.as_method_call().map(
-        |expr: (Expr, Quoted, [UnresolvedType], [Expr])| {
+    expr.as_method_call().map(|expr: (Expr, Quoted, [UnresolvedType], [Expr])| {
         let (object, name, generics, arguments) = expr;
         let object = object.modify(f);
         let arguments = arguments.map(|arg: Expr| arg.modify(f));
         new_method_call(object, name, generics, arguments)
-    }
-    )
+    })
 }
 
-comptime fn modify_repeated_element_array<Env>(expr: Expr, f: fn[Env](Expr) -> Option<Expr>) -> Option<Expr> {
-    expr.as_repeated_element_array().map(
-        |expr: (Expr, Expr)| {
+comptime fn modify_repeated_element_array<Env>(
+    expr: Expr,
+    f: fn[Env](Expr) -> Option<Expr>,
+) -> Option<Expr> {
+    expr.as_repeated_element_array().map(|expr: (Expr, Expr)| {
         let (expr, length) = expr;
         let expr = expr.modify(f);
         let length = length.modify(f);
         new_repeated_element_array(expr, length)
-    }
-    )
+    })
 }
 
-comptime fn modify_repeated_element_slice<Env>(expr: Expr, f: fn[Env](Expr) -> Option<Expr>) -> Option<Expr> {
-    expr.as_repeated_element_slice().map(
-        |expr: (Expr, Expr)| {
+comptime fn modify_repeated_element_slice<Env>(
+    expr: Expr,
+    f: fn[Env](Expr) -> Option<Expr>,
+) -> Option<Expr> {
+    expr.as_repeated_element_slice().map(|expr: (Expr, Expr)| {
         let (expr, length) = expr;
         let expr = expr.modify(f);
         let length = length.modify(f);
         new_repeated_element_slice(expr, length)
-    }
-    )
+    })
 }
 
 comptime fn modify_slice<Env>(expr: Expr, f: fn[Env](Expr) -> Option<Expr>) -> Option<Expr> {
-    expr.as_slice().map(
-        |exprs: [Expr]| {
+    expr.as_slice().map(|exprs: [Expr]| {
         let exprs = modify_expressions(exprs, f);
         new_slice(exprs)
-    }
-    )
+    })
 }
 
 comptime fn modify_tuple<Env>(expr: Expr, f: fn[Env](Expr) -> Option<Expr>) -> Option<Expr> {
-    expr.as_tuple().map(
-        |exprs: [Expr]| {
+    expr.as_tuple().map(|exprs: [Expr]| {
         let exprs = modify_expressions(exprs, f);
         new_tuple(exprs)
-    }
-    )
+    })
 }
 
 comptime fn modify_unary_op<Env>(expr: Expr, f: fn[Env](Expr) -> Option<Expr>) -> Option<Expr> {
-    expr.as_unary_op().map(
-        |expr: (UnaryOp, Expr)| {
+    expr.as_unary_op().map(|expr: (UnaryOp, Expr)| {
         let (op, rhs) = expr;
         let rhs = rhs.modify(f);
         new_unary_op(op, rhs)
-    }
-    )
+    })
 }
 
 comptime fn modify_unsafe<Env>(expr: Expr, f: fn[Env](Expr) -> Option<Expr>) -> Option<Expr> {
-    expr.as_unsafe().map(
-        |exprs: [Expr]| {
+    expr.as_unsafe().map(|exprs: [Expr]| {
         let exprs = exprs.map(|expr: Expr| expr.modify(f));
         new_unsafe(exprs)
-    }
-    )
+    })
 }
 
 comptime fn modify_expressions<Env>(exprs: [Expr], f: fn[Env](Expr) -> Option<Expr>) -> [Expr] {
@@ -587,12 +554,12 @@ comptime fn new_comptime(exprs: [Expr]) -> Expr {
 }
 
 comptime fn new_constructor(typ: UnresolvedType, fields: [(Quoted, Expr)]) -> Expr {
-    let fields = fields.map(
-        |field: (Quoted, Expr)| {
-        let (name, value) = field;
-        quote { $name: $value }
-    }
-    ).join(quote { , });
+    let fields = fields
+        .map(|field: (Quoted, Expr)| {
+            let (name, value) = field;
+            quote { $name: $value }
+        })
+        .join(quote { , });
     quote { $typ { $fields }}.as_expr().unwrap()
 }
 
@@ -620,19 +587,19 @@ comptime fn new_index(object: Expr, index: Expr) -> Expr {
 comptime fn new_lambda(
     params: [(Expr, Option<UnresolvedType>)],
     return_type: Option<UnresolvedType>,
-    body: Expr
+    body: Expr,
 ) -> Expr {
-    let params = params.map(
-        |param: (Expr, Option<UnresolvedType>)| {
-        let (name, typ) = param;
-        if typ.is_some() {
-            let typ = typ.unwrap();
-            quote { $name: $typ }
-        } else {
-            quote { $name }
-        }
-    }
-    ).join(quote { , });
+    let params = params
+        .map(|param: (Expr, Option<UnresolvedType>)| {
+            let (name, typ) = param;
+            if typ.is_some() {
+                let typ = typ.unwrap();
+                quote { $name: $typ }
+            } else {
+                quote { $name }
+            }
+        })
+        .join(quote { , });
 
     if return_type.is_some() {
         let return_type = return_type.unwrap();
@@ -661,7 +628,12 @@ comptime fn new_function_call(function: Expr, arguments: [Expr]) -> Expr {
     quote { $function($arguments) }.as_expr().unwrap()
 }
 
-comptime fn new_method_call(object: Expr, name: Quoted, generics: [UnresolvedType], arguments: [Expr]) -> Expr {
+comptime fn new_method_call(
+    object: Expr,
+    name: Quoted,
+    generics: [UnresolvedType],
+    arguments: [Expr],
+) -> Expr {
     let arguments = join_expressions(arguments, quote { , });
 
     if generics.len() == 0 {
diff --git a/noir_stdlib/src/meta/format_string.nr b/noir_stdlib/src/meta/format_string.nr
index 075a69fdafb..5e639dc278e 100644
--- a/noir_stdlib/src/meta/format_string.nr
+++ b/noir_stdlib/src/meta/format_string.nr
@@ -1,6 +1,6 @@
-impl <let N: u32, T> fmtstr<N, T> {
+impl<let N: u32, T> fmtstr<N, T> {
     #[builtin(fmtstr_quoted_contents)]
     // docs:start:quoted_contents
-    comptime fn quoted_contents(self) -> Quoted {}
+    pub comptime fn quoted_contents(self) -> Quoted {}
     // docs:end:quoted_contents
 }
diff --git a/noir_stdlib/src/meta/function_def.nr b/noir_stdlib/src/meta/function_def.nr
index cd5f9cc79fb..010110d678e 100644
--- a/noir_stdlib/src/meta/function_def.nr
+++ b/noir_stdlib/src/meta/function_def.nr
@@ -1,72 +1,78 @@
 impl FunctionDefinition {
     #[builtin(function_def_add_attribute)]
     // docs:start:add_attribute
-    comptime fn add_attribute<let N: u32>(self, attribute: str<N>) {}
+    pub comptime fn add_attribute<let N: u32>(self, attribute: str<N>) {}
     // docs:end:add_attribute
 
     #[builtin(function_def_body)]
     // docs:start:body
-    comptime fn body(self) -> Expr {}
+    pub comptime fn body(self) -> Expr {}
     // docs:end:body
 
     #[builtin(function_def_has_named_attribute)]
     // docs:start:has_named_attribute
-    comptime fn has_named_attribute<let N: u32>(self, name: str<N>) -> bool {}
+    pub comptime fn has_named_attribute<let N: u32>(self, name: str<N>) -> bool {}
     // docs:end:has_named_attribute
 
     #[builtin(function_def_is_unconstrained)]
     // docs:start:is_unconstrained
-    comptime fn is_unconstrained(self) -> bool {}
+    pub comptime fn is_unconstrained(self) -> bool {}
     // docs:end:is_unconstrained
 
     #[builtin(function_def_module)]
     // docs:start:module
-    comptime fn module(self) -> Module {}
+    pub comptime fn module(self) -> Module {}
     // docs:end:module
 
     #[builtin(function_def_name)]
     // docs:start:name
-    comptime fn name(self) -> Quoted {}
+    pub comptime fn name(self) -> Quoted {}
     // docs:end:name
 
     #[builtin(function_def_parameters)]
     // docs:start:parameters
-    comptime fn parameters(self) -> [(Quoted, Type)] {}
+    pub comptime fn parameters(self) -> [(Quoted, Type)] {}
     // docs:end:parameters
 
     #[builtin(function_def_return_type)]
     // docs:start:return_type
-    comptime fn return_type(self) -> Type {}
+    pub comptime fn return_type(self) -> Type {}
     // docs:end:return_type
 
     #[builtin(function_def_set_body)]
     // docs:start:set_body
-    comptime fn set_body(self, body: Expr) {}
+    pub comptime fn set_body(self, body: Expr) {}
     // docs:end:set_body
 
     #[builtin(function_def_set_parameters)]
     // docs:start:set_parameters
-    comptime fn set_parameters(self, parameters: [(Quoted, Type)]) {}
+    pub comptime fn set_parameters(self, parameters: [(Quoted, Type)]) {}
     // docs:end:set_parameters
 
     #[builtin(function_def_set_return_type)]
     // docs:start:set_return_type
-    comptime fn set_return_type(self, return_type: Type) {}
+    pub comptime fn set_return_type(self, return_type: Type) {}
     // docs:end:set_return_type
 
     #[builtin(function_def_set_return_public)]
     // docs:start:set_return_public
-    comptime fn set_return_public(self, public: bool) {}
+    pub comptime fn set_return_public(self, public: bool) {}
     // docs:end:set_return_public
 
+    #[builtin(function_def_set_return_data)]
+    comptime fn set_return_data(self) {}
+
     #[builtin(function_def_set_unconstrained)]
     // docs:start:set_unconstrained
-    comptime fn set_unconstrained(self, value: bool) {}
+    pub comptime fn set_unconstrained(self, value: bool) {}
     // docs:end:set_unconstrained
 }
 
 impl crate::hash::Hash for FunctionDefinition {
-    comptime fn hash<H>(self, state: &mut H) where H: crate::hash::Hasher {
+    comptime fn hash<H>(self, state: &mut H)
+    where
+        H: crate::hash::Hasher,
+    {
         state.write(function_def_hash(self))
     }
 }
diff --git a/noir_stdlib/src/meta/mod.nr b/noir_stdlib/src/meta/mod.nr
index 378f0df1ba8..5d2164a510d 100644
--- a/noir_stdlib/src/meta/mod.nr
+++ b/noir_stdlib/src/meta/mod.nr
@@ -39,7 +39,8 @@ use crate::hash::poseidon2::Poseidon2Hasher;
 pub type DeriveFunction = fn(StructDefinition) -> Quoted;
 
 // We'll keep a global HANDLERS map to keep track of the derive handler for each trait
-comptime mut global HANDLERS: UHashMap<TraitDefinition, DeriveFunction, BuildHasherDefault<Poseidon2Hasher>> = UHashMap::default();
+comptime mut global HANDLERS: UHashMap<TraitDefinition, DeriveFunction, BuildHasherDefault<Poseidon2Hasher>> =
+    UHashMap::default();
 
 // Given a struct and a slice of traits to derive, create trait impls for each.
 // This function is as simple as iterating over the slice, checking if we have a trait
@@ -51,9 +52,7 @@ pub comptime fn derive(s: StructDefinition, traits: [TraitDefinition]) -> Quoted
     let mut result = quote {};
 
     for trait_to_derive in traits {
-        let handler = unsafe {
-            HANDLERS.get(trait_to_derive)
-        };
+        let handler = unsafe { HANDLERS.get(trait_to_derive) };
         assert(handler.is_some(), f"No derive function registered for `{trait_to_derive}`");
 
         let trait_impl = handler.unwrap()(s);
@@ -92,7 +91,7 @@ pub comptime fn make_trait_impl<Env1, Env2>(
     function_signature: Quoted,
     for_each_field: fn[Env1](Quoted) -> Quoted,
     join_fields_with: Quoted,
-    body: fn[Env2](Quoted) -> Quoted
+    body: fn[Env2](Quoted) -> Quoted,
 ) -> Quoted {
     // docs:end:make_trait_impl
     let typ = s.as_type();
@@ -100,12 +99,10 @@ pub comptime fn make_trait_impl<Env1, Env2>(
     let where_clause = s.generics().map(|name| quote { $name: $trait_name }).join(quote {,});
 
     // `for_each_field(field1) $join_fields_with for_each_field(field2) $join_fields_with ...`
-    let fields = s.fields().map(
-        |f: (Quoted, Type)| {
+    let fields = s.fields().map(|f: (Quoted, Type)| {
         let name = f.0;
         for_each_field(name)
-    }
-    );
+    });
     let body = body(fields.join(join_fields_with));
 
     quote {
@@ -118,6 +115,8 @@ pub comptime fn make_trait_impl<Env1, Env2>(
 }
 
 mod tests {
+    use crate::meta::derive_via;
+
     // docs:start:quote-example
     comptime fn quote_one() -> Quoted {
         quote { 1 }
@@ -125,8 +124,7 @@ mod tests {
 
     #[test]
     fn returning_versus_macro_insertion() {
-        comptime
-        {
+        comptime {
             // let _a: Quoted = quote { 1 };
             let _a: Quoted = quote_one();
 
@@ -147,7 +145,10 @@ mod tests {
     }
 
     #[derive_field_count]
-    struct Bar { x: Field, y: [Field; 2] }
+    struct Bar {
+        x: Field,
+        y: [Field; 2],
+    }
 
     comptime fn derive_field_count(s: StructDefinition) -> Quoted {
         let typ = s.as_type();
@@ -164,7 +165,9 @@ mod tests {
 
     // docs:start:annotation-arguments-example
     #[assert_field_is_type(quote { i32 }.as_type())]
-    struct MyStruct { my_field: i32 }
+    struct MyStruct {
+        my_field: i32,
+    }
 
     comptime fn assert_field_is_type(s: StructDefinition, typ: Type) {
         // Assert the first field in `s` has type `typ`
@@ -175,7 +178,9 @@ mod tests {
 
     // docs:start:annotation-varargs-example
     #[assert_three_args(1, 2, 3)]
-    struct MyOtherStruct { my_other_field: u32 }
+    struct MyOtherStruct {
+        my_other_field: u32,
+    }
 
     #[varargs]
     comptime fn assert_three_args(_s: StructDefinition, args: [Field]) {
@@ -238,7 +243,7 @@ mod tests {
             method_signature,
             for_each_field,
             join_fields_with,
-            body
+            body,
         )
     }
     // docs:end:big-derive-usage-example
@@ -247,6 +252,41 @@ mod tests {
         fn do_nothing(_: Self) {}
     }
 
+    // docs:start:concatenate-example
+    comptime fn concatenate(q1: Quoted, q2: Quoted) -> Quoted {
+        assert(q1.tokens().len() <= 1);
+        assert(q2.tokens().len() <= 1);
+
+        f"{q1}{q2}".quoted_contents()
+    }
+
+    // The CtString type is also useful for a compile-time string of unbounded size
+    // so that you can append to it in a loop.
+    comptime fn double_spaced(q: Quoted) -> CtString {
+        let mut result = "".as_ctstring();
+
+        for token in q.tokens() {
+            if result != "".as_ctstring() {
+                result = result.append_str("  ");
+            }
+            result = result.append_fmtstr(f"{token}");
+        }
+
+        result
+    }
+
+    #[test]
+    fn concatenate_test() {
+        comptime {
+            let result = concatenate(quote {foo}, quote {bar});
+            assert_eq(result, quote {foobar});
+
+            let result = double_spaced(quote {foo bar 3}).as_quoted_str!();
+            assert_eq(result, "foo  bar  3");
+        }
+    }
+    // docs:end:concatenate-example
+
     // This function is just to remove unused warnings
     fn remove_unused_warnings() {
         let _: Bar = Bar { x: 1, y: [2, 3] };
@@ -254,6 +294,8 @@ mod tests {
         let _: MyOtherStruct = MyOtherStruct { my_other_field: 2 };
         let _ = derive_do_nothing(crate::panic::panic(f""));
         let _ = derive_do_nothing_alt(crate::panic::panic(f""));
-        remove_unused_warnings();
+        if false {
+            remove_unused_warnings();
+        }
     }
 }
diff --git a/noir_stdlib/src/meta/module.nr b/noir_stdlib/src/meta/module.nr
index 1b29301c4ef..0298282761a 100644
--- a/noir_stdlib/src/meta/module.nr
+++ b/noir_stdlib/src/meta/module.nr
@@ -1,37 +1,40 @@
 impl Module {
     #[builtin(module_add_item)]
     // docs:start:add_item
-    comptime fn add_item(self, item: Quoted) {}
+    pub comptime fn add_item(self, item: Quoted) {}
     // docs:end:add_item
 
     #[builtin(module_has_named_attribute)]
     // docs:start:has_named_attribute
-    comptime fn has_named_attribute<let N: u32>(self, name: str<N>) -> bool {}
+    pub comptime fn has_named_attribute<let N: u32>(self, name: str<N>) -> bool {}
     // docs:end:has_named_attribute
 
     #[builtin(module_is_contract)]
     // docs:start:is_contract
-    comptime fn is_contract(self) -> bool {}
+    pub comptime fn is_contract(self) -> bool {}
     // docs:end:is_contract
 
     #[builtin(module_functions)]
     // docs:start:functions
-    comptime fn functions(self) -> [FunctionDefinition] {}
+    pub comptime fn functions(self) -> [FunctionDefinition] {}
     // docs:end:functions
 
     #[builtin(module_structs)]
     // docs:start:structs
-    comptime fn structs(self) -> [StructDefinition] {}
+    pub comptime fn structs(self) -> [StructDefinition] {}
     // docs:end:structs
 
     #[builtin(module_name)]
     // docs:start:name
-    comptime fn name(self) -> Quoted {}
+    pub comptime fn name(self) -> Quoted {}
     // docs:end:name
 }
 
 impl crate::hash::Hash for Module {
-    comptime fn hash<H>(self, state: &mut H) where H: crate::hash::Hasher {
+    comptime fn hash<H>(self, state: &mut H)
+    where
+        H: crate::hash::Hasher,
+    {
         state.write(module_hash(self))
     }
 }
diff --git a/noir_stdlib/src/meta/op.nr b/noir_stdlib/src/meta/op.nr
index 197daaabaa6..afe230429f8 100644
--- a/noir_stdlib/src/meta/op.nr
+++ b/noir_stdlib/src/meta/op.nr
@@ -1,6 +1,23 @@
-#[derive(Eq, Hash)]
 pub struct UnaryOp {
-    op: Field
+    op: Field,
+}
+
+// Cannot derive Eq or Hash since they internally use paths
+// starting with std:: which is invalid within the same crate.
+// We'd need to use crate:: instead.
+impl crate::cmp::Eq for UnaryOp {
+    fn eq(self, other: Self) -> bool {
+        self.op == other.op
+    }
+}
+
+impl crate::hash::Hash for UnaryOp {
+    fn hash<H>(self, h: &mut H)
+    where
+        H: crate::hash::Hasher,
+    {
+        self.op.hash(h);
+    }
 }
 
 impl UnaryOp {
@@ -46,9 +63,23 @@ impl UnaryOp {
     }
 }
 
-#[derive(Eq, Hash)]
 pub struct BinaryOp {
-    op: Field
+    op: Field,
+}
+
+impl crate::cmp::Eq for BinaryOp {
+    fn eq(self, other: Self) -> bool {
+        self.op == other.op
+    }
+}
+
+impl crate::hash::Hash for BinaryOp {
+    fn hash<H>(self, h: &mut H)
+    where
+        H: crate::hash::Hasher,
+    {
+        self.op.hash(h);
+    }
 }
 
 impl BinaryOp {
diff --git a/noir_stdlib/src/meta/quoted.nr b/noir_stdlib/src/meta/quoted.nr
index 6e8d001c57c..d67174d7829 100644
--- a/noir_stdlib/src/meta/quoted.nr
+++ b/noir_stdlib/src/meta/quoted.nr
@@ -4,27 +4,27 @@ use crate::option::Option;
 impl Quoted {
     #[builtin(quoted_as_expr)]
     // docs:start:as_expr
-    comptime fn as_expr(self) -> Option<Expr> {}
+    pub comptime fn as_expr(self) -> Option<Expr> {}
     // docs:end:as_expr
 
     #[builtin(quoted_as_module)]
     // docs:start:as_module
-    comptime fn as_module(self) -> Option<Module> {}
+    pub comptime fn as_module(self) -> Option<Module> {}
     // docs:end:as_module
 
     #[builtin(quoted_as_trait_constraint)]
     // docs:start:as_trait_constraint
-    comptime fn as_trait_constraint(self) -> TraitConstraint {}
+    pub comptime fn as_trait_constraint(self) -> TraitConstraint {}
     // docs:end:as_trait_constraint
 
     #[builtin(quoted_as_type)]
     // docs:start:as_type
-    comptime fn as_type(self) -> Type {}
+    pub comptime fn as_type(self) -> Type {}
     // docs:end:as_type
 
     #[builtin(quoted_tokens)]
     // docs:start:tokens
-    comptime fn tokens(self) -> [Quoted] {}
+    pub comptime fn tokens(self) -> [Quoted] {}
     // docs:end:tokens
 }
 
@@ -35,7 +35,10 @@ impl Eq for Quoted {
 }
 
 impl crate::hash::Hash for Quoted {
-    comptime fn hash<H>(self, state: &mut H) where H: crate::hash::Hasher {
+    comptime fn hash<H>(self, state: &mut H)
+    where
+        H: crate::hash::Hasher,
+    {
         state.write(quoted_hash(self))
     }
 }
diff --git a/noir_stdlib/src/meta/struct_def.nr b/noir_stdlib/src/meta/struct_def.nr
index b17c0d37613..ba5d0289e73 100644
--- a/noir_stdlib/src/meta/struct_def.nr
+++ b/noir_stdlib/src/meta/struct_def.nr
@@ -1,47 +1,47 @@
 impl StructDefinition {
     #[builtin(struct_def_add_attribute)]
     // docs:start:add_attribute
-    comptime fn add_attribute<let N: u32>(self, attribute: str<N>) {}
+    pub comptime fn add_attribute<let N: u32>(self, attribute: str<N>) {}
     // docs:end:add_attribute
 
     #[builtin(struct_def_add_generic)]
     // docs:start:add_generic
-    comptime fn add_generic<let N: u32>(self, generic_name: str<N>) -> Type {}
+    pub comptime fn add_generic<let N: u32>(self, generic_name: str<N>) -> Type {}
     // docs:end:add_generic
 
     /// Return a syntactic version of this struct definition as a type.
     /// For example, `as_type(quote { type Foo<A, B> { ... } })` would return `Foo<A, B>`
     #[builtin(struct_def_as_type)]
     // docs:start:as_type
-    comptime fn as_type(self) -> Type {}
+    pub comptime fn as_type(self) -> Type {}
     // docs:end:as_type
 
     #[builtin(struct_def_has_named_attribute)]
     // docs:start:has_named_attribute
-    comptime fn has_named_attribute<let N: u32>(self, name: str<N>) -> bool {}
+    pub comptime fn has_named_attribute<let N: u32>(self, name: str<N>) -> bool {}
     // docs:end:has_named_attribute
 
     /// Return each generic on this struct.
     #[builtin(struct_def_generics)]
     // docs:start:generics
-    comptime fn generics(self) -> [Type] {}
+    pub comptime fn generics(self) -> [Type] {}
     // docs:end:generics
 
     /// Returns (name, type) pairs of each field in this struct. Each type is as-is
     /// with any generic arguments unchanged.
     #[builtin(struct_def_fields)]
     // docs:start:fields
-    comptime fn fields(self) -> [(Quoted, Type)] {}
+    pub comptime fn fields(self) -> [(Quoted, Type)] {}
     // docs:end:fields
 
     #[builtin(struct_def_module)]
     // docs:start:module
-    comptime fn module(self) -> Module {}
+    pub comptime fn module(self) -> Module {}
     // docs:end:module
 
     #[builtin(struct_def_name)]
     // docs:start:name
-    comptime fn name(self) -> Quoted {}
+    pub comptime fn name(self) -> Quoted {}
     // docs:end:name
 
     /// Sets the fields of this struct to the given fields list.
@@ -50,12 +50,15 @@ impl StructDefinition {
     /// Each name is expected to be a single identifier.
     #[builtin(struct_def_set_fields)]
     // docs:start:set_fields
-    comptime fn set_fields(self, new_fields: [(Quoted, Type)]) {}
+    pub comptime fn set_fields(self, new_fields: [(Quoted, Type)]) {}
     // docs:end:set_fields
 }
 
 impl crate::hash::Hash for StructDefinition {
-    comptime fn hash<H>(self, state: &mut H) where H: crate::hash::Hasher {
+    comptime fn hash<H>(self, state: &mut H)
+    where
+        H: crate::hash::Hasher,
+    {
         state.write(struct_def_hash(self))
     }
 }
diff --git a/noir_stdlib/src/meta/trait_constraint.nr b/noir_stdlib/src/meta/trait_constraint.nr
index b90f0b590d5..2d9c6639dbd 100644
--- a/noir_stdlib/src/meta/trait_constraint.nr
+++ b/noir_stdlib/src/meta/trait_constraint.nr
@@ -1,5 +1,5 @@
-use crate::hash::{Hash, Hasher};
 use crate::cmp::Eq;
+use crate::hash::{Hash, Hasher};
 
 impl Eq for TraitConstraint {
     comptime fn eq(self, other: Self) -> bool {
@@ -8,7 +8,10 @@ impl Eq for TraitConstraint {
 }
 
 impl Hash for TraitConstraint {
-    comptime fn hash<H>(self, state: &mut H) where H: Hasher {
+    comptime fn hash<H>(self, state: &mut H)
+    where
+        H: Hasher,
+    {
         state.write(constraint_hash(self));
     }
 }
diff --git a/noir_stdlib/src/meta/trait_def.nr b/noir_stdlib/src/meta/trait_def.nr
index 51676efbc34..75f746337d4 100644
--- a/noir_stdlib/src/meta/trait_def.nr
+++ b/noir_stdlib/src/meta/trait_def.nr
@@ -1,10 +1,10 @@
-use crate::hash::{Hash, Hasher};
 use crate::cmp::Eq;
+use crate::hash::{Hash, Hasher};
 
 impl TraitDefinition {
     #[builtin(trait_def_as_trait_constraint)]
-// docs:start:as_trait_constraint
-    comptime fn as_trait_constraint(_self: Self) -> TraitConstraint {}
+    // docs:start:as_trait_constraint
+    pub comptime fn as_trait_constraint(_self: Self) -> TraitConstraint {}
     // docs:end:as_trait_constraint
 }
 
@@ -15,7 +15,10 @@ impl Eq for TraitDefinition {
 }
 
 impl Hash for TraitDefinition {
-    comptime fn hash<H>(self, state: &mut H) where H: Hasher {
+    comptime fn hash<H>(self, state: &mut H)
+    where
+        H: Hasher,
+    {
         state.write(trait_def_hash(self));
     }
 }
diff --git a/noir_stdlib/src/meta/trait_impl.nr b/noir_stdlib/src/meta/trait_impl.nr
index 6755a5c2031..9db859bf8a0 100644
--- a/noir_stdlib/src/meta/trait_impl.nr
+++ b/noir_stdlib/src/meta/trait_impl.nr
@@ -1,11 +1,11 @@
 impl TraitImpl {
     #[builtin(trait_impl_trait_generic_args)]
-// docs:start:trait_generic_args
-    comptime fn trait_generic_args(self) -> [Type] {}
+    // docs:start:trait_generic_args
+    pub comptime fn trait_generic_args(self) -> [Type] {}
     // docs:end:trait_generic_args
 
     #[builtin(trait_impl_methods)]
-// docs:start:methods
-    comptime fn methods(self) -> [FunctionDefinition] {}
+    // docs:start:methods
+    pub comptime fn methods(self) -> [FunctionDefinition] {}
     // docs:end:methods
 }
diff --git a/noir_stdlib/src/meta/typ.nr b/noir_stdlib/src/meta/typ.nr
index 5a748c2c823..8076c692ca5 100644
--- a/noir_stdlib/src/meta/typ.nr
+++ b/noir_stdlib/src/meta/typ.nr
@@ -1,76 +1,205 @@
+//! Contains methods on the built-in `Type` type used for representing a type in the source program.
+
 use crate::cmp::Eq;
 use crate::option::Option;
 
+/// Creates and returns an unbound type variable. This is a special kind of type internal
+/// to type checking which will type check with any other type. When it is type checked
+/// against another type it will also be set to that type. For example, if `a` is a type
+/// variable and we have the type equality `(a, i32) = (u8, i32)`, the compiler will set
+/// `a` equal to `u8`.
+///
+/// Unbound type variables will often be rendered as `_` while printing them. Bound type
+/// variables will appear as the type they are bound to.
+///
+/// This can be used in conjunction with functions which internally perform type checks
+/// such as `Type::implements` or `Type::get_trait_impl` to potentially grab some of the types used.
+///
+/// Note that calling `Type::implements` or `Type::get_trait_impl` on a type variable will always
+/// fail.
+///
+/// Example:
+///
+/// ```noir
+/// trait Serialize<let N: u32> {}
+///
+/// impl Serialize<1> for Field {}
+///
+/// impl<T, let N: u32, let M: u32> Serialize<N * M> for [T; N]
+///     where T: Serialize<M> {}
+///
+/// impl<T, U, let N: u32, let M: u32> Serialize<N + M> for (T, U)
+///     where T: Serialize<N>, U: Serialize<M> {}
+///
+/// fn fresh_variable_example() {
+///     let typevar1 = std::meta::typ::fresh_type_variable();
+///     let constraint = quote { Serialize<$typevar1> }.as_trait_constraint();
+///     let field_type = quote { Field }.as_type();
+///
+///     // Search for a trait impl (binding typevar1 to 1 when the impl is found):
+///     assert(field_type.implements(constraint));
+///
+///     // typevar1 should be bound to the "1" generic now:
+///     assert_eq(typevar1.as_constant().unwrap(), 1);
+///
+///     // If we want to do the same with a different type, we need to
+///     // create a new type variable now that `typevar1` is bound
+///     let typevar2 = std::meta::typ::fresh_type_variable();
+///     let constraint = quote { Serialize<$typevar2> }.as_trait_constraint();
+///     let array_type = quote { [(Field, Field); 5] }.as_type();
+///     assert(array_type.implements(constraint));
+///
+///     // Now typevar2 should be bound to the serialized pair size 2 times the array length 5
+///     assert_eq(typevar2.as_constant().unwrap(), 10);
+/// }
+/// ```
 #[builtin(fresh_type_variable)]
 // docs:start:fresh_type_variable
 pub comptime fn fresh_type_variable() -> Type {}
 // docs:end:fresh_type_variable
 
 impl Type {
+    /// If this type is an array, return a pair of (element type, size type).
+    ///
+    /// Example:
+    ///
+    /// ```noir
+    /// comptime {
+    ///     let array_type = quote { [Field; 3] }.as_type();
+    ///     let (field_type, three_type) = array_type.as_array().unwrap();
+    ///
+    ///     assert(field_type.is_field());
+    ///     assert_eq(three_type.as_constant().unwrap(), 3);
+    /// }
+    /// ```
     #[builtin(type_as_array)]
-// docs:start:as_array
-    comptime fn as_array(self) -> Option<(Type, Type)> {}
+    // docs:start:as_array
+    pub comptime fn as_array(self) -> Option<(Type, Type)> {}
     // docs:end:as_array
 
+    /// If this type is a constant integer (such as the `3` in the array type `[Field; 3]`),
+    /// return the numeric constant.
     #[builtin(type_as_constant)]
-// docs:start:as_constant
-    comptime fn as_constant(self) -> Option<u32> {}
+    // docs:start:as_constant
+    pub comptime fn as_constant(self) -> Option<u32> {}
     // docs:end:as_constant
 
+    /// If this is an integer type, return a boolean which is `true`
+    /// if the type is signed, as well as the number of bits of this integer type.
     #[builtin(type_as_integer)]
-// docs:start:as_integer
-    comptime fn as_integer(self) -> Option<(bool, u8)> {}
+    // docs:start:as_integer
+    pub comptime fn as_integer(self) -> Option<(bool, u8)> {}
     // docs:end:as_integer
 
+    /// If this is a mutable reference type `&mut T`, returns the mutable type `T`.
+    #[builtin(type_as_mutable_reference)]
+    // docs:start:as_mutable_reference
+    comptime fn as_mutable_reference(self) -> Option<Type> {}
+    // docs:end:as_mutable_reference
+
+    /// If this is a slice type, return the element type of the slice.
     #[builtin(type_as_slice)]
-// docs:start:as_slice
-    comptime fn as_slice(self) -> Option<Type> {}
+    // docs:start:as_slice
+    pub comptime fn as_slice(self) -> Option<Type> {}
     // docs:end:as_slice
 
+    /// If this is a `str<N>` type, returns the length `N` as a type.
     #[builtin(type_as_str)]
-// docs:start:as_str
-    comptime fn as_str(self) -> Option<Type> {}
+    // docs:start:as_str
+    pub comptime fn as_str(self) -> Option<Type> {}
     // docs:end:as_str
 
+    /// If this is a struct type, returns the struct in addition to any generic arguments on this type.
     #[builtin(type_as_struct)]
-// docs:start:as_struct
-    comptime fn as_struct(self) -> Option<(StructDefinition, [Type])> {}
+    // docs:start:as_struct
+    pub comptime fn as_struct(self) -> Option<(StructDefinition, [Type])> {}
     // docs:end:as_struct
 
+    /// If this is a tuple type, returns each element type of the tuple.
     #[builtin(type_as_tuple)]
-// docs:start:as_tuple
-    comptime fn as_tuple(self) -> Option<[Type]> {}
+    // docs:start:as_tuple
+    pub comptime fn as_tuple(self) -> Option<[Type]> {}
     // docs:end:as_tuple
 
+    /// Retrieves the trait implementation that implements the given
+    /// trait constraint for this type. If the trait constraint is not
+    /// found, `None` is returned. Note that since the concrete trait implementation
+    /// for a trait constraint specified from a `where` clause is unknown,
+    /// this function will return `None` in these cases. If you only want to know
+    /// whether a type implements a trait, use `implements` instead.
+    ///
+    /// Example:
+    ///
+    /// ```rust
+    /// comptime {
+    ///     let field_type = quote { Field }.as_type();
+    ///     let default = quote { Default }.as_trait_constraint();
+    ///
+    ///     let the_impl: TraitImpl = field_type.get_trait_impl(default).unwrap();
+    ///     assert(the_impl.methods().len(), 1);
+    /// }
+    /// ```
     #[builtin(type_get_trait_impl)]
-// docs:start:get_trait_impl
-    comptime fn get_trait_impl(self, constraint: TraitConstraint) -> Option<TraitImpl> {}
+    // docs:start:get_trait_impl
+    pub comptime fn get_trait_impl(self, constraint: TraitConstraint) -> Option<TraitImpl> {}
     // docs:end:get_trait_impl
 
+    /// Returns `true` if this type implements the given trait. Note that unlike
+    /// `get_trait_impl` this will also return true for any `where` constraints
+    /// in scope.
+    ///
+    /// Example:
+    ///
+    /// ```rust
+    /// fn foo<T>() where T: Default {
+    ///     comptime {
+    ///         let field_type = quote { Field }.as_type();
+    ///         let default = quote { Default }.as_trait_constraint();
+    ///         assert(field_type.implements(default));
+    ///
+    ///         let t = quote { T }.as_type();
+    ///         assert(t.implements(default));
+    ///     }
+    /// }
+    /// ```
     #[builtin(type_implements)]
-// docs:start:implements
-    comptime fn implements(self, constraint: TraitConstraint) -> bool {}
+    // docs:start:implements
+    pub comptime fn implements(self, constraint: TraitConstraint) -> bool {}
     // docs:end:implements
 
+    /// Returns `true` if this type is `bool`.
     #[builtin(type_is_bool)]
-// docs:start:is_bool
-    comptime fn is_bool(self) -> bool {}
+    // docs:start:is_bool
+    pub comptime fn is_bool(self) -> bool {}
     // docs:end:is_bool
 
+    /// Returns `true` if this type is `Field`.
     #[builtin(type_is_field)]
-// docs:start:is_field
-    comptime fn is_field(self) -> bool {}
+    // docs:start:is_field
+    pub comptime fn is_field(self) -> bool {}
     // docs:end:is_field
+
+    /// Returns `true` if this type is the unit `()` type.
+    #[builtin(type_is_unit)]
+    // docs:start:is_unit
+    comptime fn is_unit(self) -> bool {}
+    // docs:end:is_unit
 }
 
 impl Eq for Type {
+    /// Note that this is syntactic equality, this is not the same as whether two types will type check
+    /// to be the same type. Unless type inference or generics are being used however, users should not
+    /// typically have to worry about this distinction.
     comptime fn eq(self, other: Self) -> bool {
         type_eq(self, other)
     }
 }
 
 impl crate::hash::Hash for Type {
-    comptime fn hash<H>(self, state: &mut H) where H: crate::hash::Hasher {
+    comptime fn hash<H>(self, state: &mut H)
+    where
+        H: crate::hash::Hasher,
+    {
         state.write(type_hash(self))
     }
 }
diff --git a/noir_stdlib/src/meta/typed_expr.nr b/noir_stdlib/src/meta/typed_expr.nr
index 1d3b073b6da..c69139ea233 100644
--- a/noir_stdlib/src/meta/typed_expr.nr
+++ b/noir_stdlib/src/meta/typed_expr.nr
@@ -5,12 +5,12 @@ impl TypedExpr {
     /// If this expression refers to a function definitions, returns it. Otherwise returns `Option::none()`.
     #[builtin(typed_expr_as_function_definition)]
     // docs:start:as_function_definition
-    comptime fn as_function_definition(self) -> Option<FunctionDefinition> {}
+    pub comptime fn as_function_definition(self) -> Option<FunctionDefinition> {}
     // docs:end:as_function_definition
 
     /// Returns the type of the expression, if the expression could be resolved without errors.
     #[builtin(typed_expr_get_type)]
     // docs:start:get_type
-    comptime fn get_type(self) -> Option<Type> {}
+    pub comptime fn get_type(self) -> Option<Type> {}
     // docs:end:get_type
 }
diff --git a/noir_stdlib/src/meta/unresolved_type.nr b/noir_stdlib/src/meta/unresolved_type.nr
index f53635414cc..5c2e8803674 100644
--- a/noir_stdlib/src/meta/unresolved_type.nr
+++ b/noir_stdlib/src/meta/unresolved_type.nr
@@ -1,6 +1,35 @@
+//! Contains methods on the built-in `UnresolvedType` type for the syntax of types.
+
+use crate::option::Option;
+
 impl UnresolvedType {
+    /// If this is a mutable reference type `&mut T`, returns the mutable type `T`.
+    #[builtin(unresolved_type_as_mutable_reference)]
+    // docs:start:as_mutable_reference
+    comptime fn as_mutable_reference(self) -> Option<UnresolvedType> {}
+    // docs:end:as_mutable_reference
+
+    /// If this is a slice `&[T]`, returns the element type `T`.
+    #[builtin(unresolved_type_as_slice)]
+    // docs:start:as_slice
+    comptime fn as_slice(self) -> Option<UnresolvedType> {}
+    // docs:end:as_slice
+
+    /// Returns `true` if this type is `bool`.
+    #[builtin(unresolved_type_is_bool)]
+    // docs:start:is_bool
+    comptime fn is_bool(self) -> bool {}
+    // docs:end:is_bool
+
+    /// Returns true if this type refers to the `Field` type.
     #[builtin(unresolved_type_is_field)]
     // docs:start:is_field
-    comptime fn is_field(self) -> bool {}
+    pub comptime fn is_field(self) -> bool {}
     // docs:end:is_field
+
+    /// Returns true if this type is the unit `()` type.
+    #[builtin(unresolved_type_is_unit)]
+    // docs:start:is_unit
+    comptime fn is_unit(self) -> bool {}
+    // docs:end:is_unit
 }
diff --git a/noir_stdlib/src/ops/mod.nr b/noir_stdlib/src/ops/mod.nr
index bf908ea4b27..0e3a2467c60 100644
--- a/noir_stdlib/src/ops/mod.nr
+++ b/noir_stdlib/src/ops/mod.nr
@@ -1,5 +1,5 @@
 pub(crate) mod arith;
 pub(crate) mod bit;
 
-pub use arith::{Add, Sub, Mul, Div, Rem, Neg};
-pub use bit::{Not, BitOr, BitAnd, BitXor, Shl, Shr};
+pub use arith::{Add, Div, Mul, Neg, Rem, Sub};
+pub use bit::{BitAnd, BitOr, BitXor, Not, Shl, Shr};
diff --git a/noir_stdlib/src/option.nr b/noir_stdlib/src/option.nr
index 6b3a2bf2f3c..0a62e412849 100644
--- a/noir_stdlib/src/option.nr
+++ b/noir_stdlib/src/option.nr
@@ -1,6 +1,6 @@
-use crate::hash::{Hash, Hasher};
-use crate::cmp::{Ordering, Ord, Eq};
+use crate::cmp::{Eq, Ord, Ordering};
 use crate::default::Default;
+use crate::hash::{Hash, Hasher};
 
 pub struct Option<T> {
     _is_some: bool,
@@ -43,7 +43,11 @@ impl<T> Option<T> {
 
     /// Returns the wrapped value if `self.is_some()`. Otherwise, returns the given default value.
     pub fn unwrap_or(self, default: T) -> T {
-        if self._is_some { self._value } else { default }
+        if self._is_some {
+            self._value
+        } else {
+            default
+        }
     }
 
     /// Returns the wrapped value if `self.is_some()`. Otherwise, calls the given function to return
@@ -57,7 +61,7 @@ impl<T> Option<T> {
     }
 
     /// Asserts `self.is_some()` with a provided custom message and returns the contained `Some` value
-    fn expect<let N: u32, MessageTypes>(self, message: fmtstr<N, MessageTypes>) -> T {
+    pub fn expect<let N: u32, MessageTypes>(self, message: fmtstr<N, MessageTypes>) -> T {
         assert(self.is_some(), message);
         self._value
     }
@@ -112,19 +116,31 @@ impl<T> Option<T> {
 
     /// If self is Some, return self. Otherwise, return `other`.
     pub fn or(self, other: Self) -> Self {
-        if self._is_some { self } else { other }
+        if self._is_some {
+            self
+        } else {
+            other
+        }
     }
 
     /// If self is Some, return self. Otherwise, return `default()`.
     pub fn or_else<Env>(self, default: fn[Env]() -> Self) -> Self {
-        if self._is_some { self } else { default() }
+        if self._is_some {
+            self
+        } else {
+            default()
+        }
     }
 
     // If only one of the two Options is Some, return that option.
     // Otherwise, if both options are Some or both are None, None is returned.
     pub fn xor(self, other: Self) -> Self {
         if self._is_some {
-            if other._is_some { Option::none() } else { self }
+            if other._is_some {
+                Option::none()
+            } else {
+                self
+            }
         } else if other._is_some {
             other
         } else {
@@ -163,7 +179,10 @@ impl<T> Default for Option<T> {
     }
 }
 
-impl<T> Eq for Option<T> where T: Eq {
+impl<T> Eq for Option<T>
+where
+    T: Eq,
+{
     fn eq(self, other: Self) -> bool {
         if self._is_some == other._is_some {
             if self._is_some {
@@ -177,8 +196,14 @@ impl<T> Eq for Option<T> where T: Eq {
     }
 }
 
-impl<T> Hash for Option<T> where T: Hash {
-    fn hash<H>(self, state: &mut H) where H: Hasher {
+impl<T> Hash for Option<T>
+where
+    T: Hash,
+{
+    fn hash<H>(self, state: &mut H)
+    where
+        H: Hasher,
+    {
         self._is_some.hash(state);
         if self._is_some {
             self._value.hash(state);
@@ -187,7 +212,10 @@ impl<T> Hash for Option<T> where T: Hash {
 }
 
 // For this impl we're declaring Option::none < Option::some
-impl<T> Ord for Option<T> where T: Ord {
+impl<T> Ord for Option<T>
+where
+    T: Ord,
+{
     fn cmp(self, other: Self) -> Ordering {
         if self._is_some {
             if other._is_some {
diff --git a/noir_stdlib/src/prelude.nr b/noir_stdlib/src/prelude.nr
index b6e54eaae60..a4a6c35b615 100644
--- a/noir_stdlib/src/prelude.nr
+++ b/noir_stdlib/src/prelude.nr
@@ -1,10 +1,10 @@
-pub use crate::collections::vec::Vec;
-pub use crate::collections::bounded_vec::BoundedVec;
-pub use crate::option::Option;
-pub use crate::{print, println, assert_constant};
-pub use crate::uint128::U128;
+pub use crate::{assert_constant, print, println};
 pub use crate::cmp::{Eq, Ord};
-pub use crate::default::Default;
+pub use crate::collections::bounded_vec::BoundedVec;
+pub use crate::collections::vec::Vec;
 pub use crate::convert::{From, Into};
+pub use crate::default::Default;
 pub use crate::meta::{derive, derive_via};
+pub use crate::option::Option;
 pub use crate::panic::panic;
+pub use crate::uint128::U128;
diff --git a/noir_stdlib/src/schnorr.nr b/noir_stdlib/src/schnorr.nr
deleted file mode 100644
index e24aabf3cda..00000000000
--- a/noir_stdlib/src/schnorr.nr
+++ /dev/null
@@ -1,94 +0,0 @@
-use crate::embedded_curve_ops::{EmbeddedCurvePoint, EmbeddedCurveScalar};
-
-#[foreign(schnorr_verify)]
-// docs:start:schnorr_verify
-pub fn verify_signature<let N: u32>(
-    public_key_x: Field,
-    public_key_y: Field,
-    signature: [u8; 64],
-    message: [u8; N]
-) -> bool
-// docs:end:schnorr_verify
-{}
-
-#[foreign(schnorr_verify)]
-// docs:start:schnorr_verify_slice
-pub fn verify_signature_slice(
-    public_key_x: Field,
-    public_key_y: Field,
-    signature: [u8; 64],
-    message: [u8]
-) -> bool
-// docs:end:schnorr_verify_slice
-{}
-
-pub fn verify_signature_noir<let N: u32>(
-    public_key: EmbeddedCurvePoint,
-    signature: [u8; 64],
-    message: [u8; N]
-) -> bool {
-    //scalar lo/hi from bytes
-    let sig_s = EmbeddedCurveScalar::from_bytes(signature, 0);
-    let sig_e = EmbeddedCurveScalar::from_bytes(signature, 32);
-    // pub_key is on Grumpkin curve
-    let mut is_ok = (public_key.y * public_key.y == public_key.x * public_key.x * public_key.x - 17)
-        & (!public_key.is_infinite);
-
-    if ((sig_s.lo != 0) | (sig_s.hi != 0)) & ((sig_e.lo != 0) | (sig_e.hi != 0)) {
-        let (r_is_infinite, result) = calculate_signature_challenge(public_key, sig_s, sig_e, message);
-
-        is_ok = !r_is_infinite;
-        for i in 0..32 {
-            is_ok &= result[i] == signature[32 + i];
-        }
-    }
-    is_ok
-}
-
-pub fn assert_valid_signature<let N: u32>(
-    public_key: EmbeddedCurvePoint,
-    signature: [u8; 64],
-    message: [u8; N]
-) {
-    //scalar lo/hi from bytes
-    let sig_s = EmbeddedCurveScalar::from_bytes(signature, 0);
-    let sig_e = EmbeddedCurveScalar::from_bytes(signature, 32);
-
-    // assert pub_key is on Grumpkin curve
-    assert(public_key.y * public_key.y == public_key.x * public_key.x * public_key.x - 17);
-    assert(public_key.is_infinite == false);
-    // assert signature is not null
-    assert((sig_s.lo != 0) | (sig_s.hi != 0));
-    assert((sig_e.lo != 0) | (sig_e.hi != 0));
-
-    let (r_is_infinite, result) = calculate_signature_challenge(public_key, sig_s, sig_e, message);
-
-    assert(!r_is_infinite);
-    for i in 0..32 {
-        assert(result[i] == signature[32 + i]);
-    }
-}
-
-fn calculate_signature_challenge<let N: u32>(
-    public_key: EmbeddedCurvePoint,
-    sig_s: EmbeddedCurveScalar,
-    sig_e: EmbeddedCurveScalar,
-    message: [u8; N]
-) -> (bool, [u8; 32]) {
-    let g1 = EmbeddedCurvePoint { x: 1, y: 17631683881184975370165255887551781615748388533673675138860, is_infinite: false };
-    let r = crate::embedded_curve_ops::multi_scalar_mul([g1, public_key], [sig_s, sig_e]);
-    // compare the _hashes_ rather than field elements modulo r
-    let pedersen_hash = crate::hash::pedersen_hash([r.x, public_key.x, public_key.y]);
-    let pde: [u8; 32] = pedersen_hash.to_be_bytes();
-
-    let mut hash_input = [0; N + 32];
-    for i in 0..32 {
-        hash_input[i] = pde[i];
-    }
-    for i in 0..N {
-        hash_input[32+i] = message[i];
-    }
-
-    let result = crate::hash::blake2s(hash_input);
-    (r.is_infinite, result)
-}
diff --git a/noir_stdlib/src/sha256.nr b/noir_stdlib/src/sha256.nr
index 7679e517317..9e07b690c4c 100644
--- a/noir_stdlib/src/sha256.nr
+++ b/noir_stdlib/src/sha256.nr
@@ -1,11 +1,10 @@
 // This file is kept for backwards compatibility.
-
-#[deprecated = "replace with std::hash::sha256::digest"]
+#[deprecated]
 pub fn digest<let N: u32>(msg: [u8; N]) -> [u8; 32] {
     crate::hash::sha256::digest(msg)
 }
 
-#[deprecated = "replace with std::hash::sha256::sha256_var"]
+#[deprecated]
 pub fn sha256_var<let N: u32>(msg: [u8; N], message_size: u64) -> [u8; 32] {
     crate::hash::sha256::sha256_var(msg, message_size)
 }
diff --git a/noir_stdlib/src/sha512.nr b/noir_stdlib/src/sha512.nr
index 0a8a5bf4760..27b53f4395f 100644
--- a/noir_stdlib/src/sha512.nr
+++ b/noir_stdlib/src/sha512.nr
@@ -1,6 +1,5 @@
 // This file is kept for backwards compatibility.
-
-#[deprecated = "replace with std::hash::sha512::digest"]
+#[deprecated]
 pub fn digest<let N: u32>(msg: [u8; N]) -> [u8; 64] {
     crate::hash::sha512::digest(msg)
 }
diff --git a/noir_stdlib/src/slice.nr b/noir_stdlib/src/slice.nr
index 66c69db65f0..a8815681d6d 100644
--- a/noir_stdlib/src/slice.nr
+++ b/noir_stdlib/src/slice.nr
@@ -12,8 +12,8 @@ impl<T> [T] {
     pub fn push_back(self, elem: T) -> Self {}
 
     /// Push a new element to the front of the slice, returning a
-    /// new slice with a length one greater than the 
-    /// original unmodified slice. 
+    /// new slice with a length one greater than the
+    /// original unmodified slice.
     #[builtin(slice_push_front)]
     pub fn push_front(self, elem: T) -> Self {}
 
@@ -27,13 +27,13 @@ impl<T> [T] {
     #[builtin(slice_pop_front)]
     pub fn pop_front(self) -> (T, Self) {}
 
-    /// Insert an element at a specified index, shifting all elements 
+    /// Insert an element at a specified index, shifting all elements
     /// after it to the right
     #[builtin(slice_insert)]
     pub fn insert(self, index: u32, elem: T) -> Self {}
 
     /// Remove an element at a specified index, shifting all elements
-    /// after it to the left, returning the altered slice and 
+    /// after it to the left, returning the altered slice and
     /// the removed element
     #[builtin(slice_remove)]
     pub fn remove(self, index: u32) -> (Self, T) {}
@@ -101,7 +101,10 @@ impl<T> [T] {
     }
 
     // Flatten each element in the slice into one value, separated by `separator`.
-    pub fn join(self, separator: T) -> T where T: Append {
+    pub fn join(self, separator: T) -> T
+    where
+        T: Append,
+    {
         let mut ret = T::empty();
 
         if self.len() != 0 {
diff --git a/noir_stdlib/src/test.nr b/noir_stdlib/src/test.nr
index e906ad54d55..4d6954913d1 100644
--- a/noir_stdlib/src/test.nr
+++ b/noir_stdlib/src/test.nr
@@ -21,30 +21,30 @@ pub struct OracleMock {
 }
 
 impl OracleMock {
-    unconstrained pub fn mock<let N: u32>(name: str<N>) -> Self {
+    pub unconstrained fn mock<let N: u32>(name: str<N>) -> Self {
         Self { id: create_mock_oracle(name) }
     }
 
-    unconstrained pub fn with_params<P>(self, params: P) -> Self {
+    pub unconstrained fn with_params<P>(self, params: P) -> Self {
         set_mock_params_oracle(self.id, params);
         self
     }
 
-    unconstrained pub fn get_last_params<P>(self) -> P {
+    pub unconstrained fn get_last_params<P>(self) -> P {
         get_mock_last_params_oracle(self.id)
     }
 
-    unconstrained pub fn returns<R>(self, returns: R) -> Self {
+    pub unconstrained fn returns<R>(self, returns: R) -> Self {
         set_mock_returns_oracle(self.id, returns);
         self
     }
 
-    unconstrained pub fn times(self, times: u64) -> Self {
+    pub unconstrained fn times(self, times: u64) -> Self {
         set_mock_times_oracle(self.id, times);
         self
     }
 
-    unconstrained pub fn clear(self) {
+    pub unconstrained fn clear(self) {
         clear_mock_oracle(self.id);
     }
 }
diff --git a/noir_stdlib/src/uint128.nr b/noir_stdlib/src/uint128.nr
index a3d7491eaff..06febb3ee00 100644
--- a/noir_stdlib/src/uint128.nr
+++ b/noir_stdlib/src/uint128.nr
@@ -1,11 +1,11 @@
-use crate::ops::{Add, Sub, Mul, Div, Rem, Not, BitOr, BitAnd, BitXor, Shl, Shr};
 use crate::cmp::{Eq, Ord, Ordering};
+use crate::ops::{Add, BitAnd, BitOr, BitXor, Div, Mul, Not, Rem, Shl, Shr, Sub};
 
-global pow64 : Field = 18446744073709551616; //2^64;
-global pow63 : Field = 9223372036854775808; // 2^63;
+global pow64: Field = 18446744073709551616; //2^64;
+global pow63: Field = 9223372036854775808; // 2^63;
 pub struct U128 {
-    lo: Field,
-    hi: Field,
+    pub(crate) lo: Field,
+    pub(crate) hi: Field,
 }
 
 impl U128 {
@@ -31,13 +31,13 @@ impl U128 {
         let mut lo = 0;
         let mut base = 1;
         for i in 0..8 {
-            lo += (bytes[i] as Field)*base;
+            lo += (bytes[i] as Field) * base;
             base *= 256;
         }
         let mut hi = 0;
         base = 1;
         for i in 8..16 {
-            hi += (bytes[i] as Field)*base;
+            hi += (bytes[i] as Field) * base;
             base *= 256;
         }
         U128 { lo, hi }
@@ -49,7 +49,7 @@ impl U128 {
         let mut bytes = [0; 16];
         for i in 0..8 {
             bytes[i] = hi[i];
-            bytes[i+8] = lo[i];
+            bytes[i + 8] = lo[i];
         }
         bytes
     }
@@ -60,7 +60,7 @@ impl U128 {
         let mut bytes = [0; 16];
         for i in 0..8 {
             bytes[i] = lo[i];
-            bytes[i+8] = hi[i];
+            bytes[i + 8] = hi[i];
         }
         bytes
     }
@@ -77,18 +77,18 @@ impl U128 {
         let mut base = 1;
         if N <= 18 {
             for i in 0..N - 2 {
-                lo += U128::decode_ascii(bytes[N-i-1])*base;
-                base = base*16;
+                lo += U128::decode_ascii(bytes[N - i - 1]) * base;
+                base = base * 16;
             }
         } else {
             for i in 0..16 {
-                lo += U128::decode_ascii(bytes[N-i-1])*base;
-                base = base*16;
+                lo += U128::decode_ascii(bytes[N - i - 1]) * base;
+                base = base * 16;
             }
             base = 1;
             for i in 17..N - 1 {
-                hi += U128::decode_ascii(bytes[N-i])*base;
-                base = base*16;
+                hi += U128::decode_ascii(bytes[N - i]) * base;
+                base = base * 16;
             }
         }
         U128 { lo: lo as Field, hi: hi as Field }
@@ -98,20 +98,21 @@ impl U128 {
         ((ascii >= 65) & (ascii <= 90)) // Between 'A' and 'Z'
     }
 
-    fn decode_ascii(ascii: u8) -> Field {
-        (if ascii < 58 {
-            ascii - 48
-        } else {
-            let ascii = ascii + 32 * (unsafe {
-                        U128::uconstrained_check_is_upper_ascii(ascii) as u8
-                    });
-            assert(ascii >= 97); // enforce >= 'a'
-            assert(ascii <= 102); // enforce <= 'f'
-            ascii - 87
-        }) as Field
+    pub(crate) fn decode_ascii(ascii: u8) -> Field {
+        (
+            if ascii < 58 {
+                ascii - 48
+            } else {
+                let ascii =
+                    ascii + 32 * (unsafe { U128::uconstrained_check_is_upper_ascii(ascii) as u8 });
+                assert(ascii >= 97); // enforce >= 'a'
+                assert(ascii <= 102); // enforce <= 'f'
+                ascii - 87
+            }
+        ) as Field
     }
 
-    // TODO: Replace with a faster version. 
+    // TODO: Replace with a faster version.
     // A circuit that uses this function can be slow to compute
     // (we're doing up to 127 calls to compute the quotient)
     unconstrained fn unconstrained_div(self: Self, b: U128) -> (U128, U128) {
@@ -123,7 +124,7 @@ impl U128 {
         } else if self == b {
             (U128::one(), U128::zero())
         } else {
-            let (q,r) = if b.hi as u64 >= pow63 as u64 {
+            let (q, r) = if b.hi as u64 >= pow63 as u64 {
                 // The result of multiplication by 2 would overflow
                 (U128::zero(), self)
             } else {
@@ -141,7 +142,7 @@ impl U128 {
     pub fn from_integer<T>(i: T) -> U128 {
         let f = crate::as_field(i);
         // Reject values which would overflow a u128
-        f.assert_max_bit_size(128);
+        f.assert_max_bit_size::<128>();
         let lo = f as u64 as Field;
         let hi = (f - lo) / pow64;
         U128 { lo, hi }
@@ -205,7 +206,7 @@ impl Mul for U128 {
 impl Div for U128 {
     fn div(self: Self, b: U128) -> U128 {
         unsafe {
-            let (q,r) = self.unconstrained_div(b);
+            let (q, r) = self.unconstrained_div(b);
             let a = b * q + r;
             assert_eq(self, a);
             assert(r < b);
@@ -217,7 +218,7 @@ impl Div for U128 {
 impl Rem for U128 {
     fn rem(self: Self, b: U128) -> U128 {
         unsafe {
-            let (q,r) = self.unconstrained_div(b);
+            let (q, r) = self.unconstrained_div(b);
             let a = b * q + r;
             assert_eq(self, a);
             assert(r < b);
@@ -256,7 +257,7 @@ impl BitOr for U128 {
     fn bitor(self, other: U128) -> U128 {
         U128 {
             lo: ((self.lo as u64) | (other.lo as u64)) as Field,
-            hi: ((self.hi as u64) | (other.hi as u64)) as Field
+            hi: ((self.hi as u64) | (other.hi as u64)) as Field,
         }
     }
 }
@@ -265,7 +266,7 @@ impl BitAnd for U128 {
     fn bitand(self, other: U128) -> U128 {
         U128 {
             lo: ((self.lo as u64) & (other.lo as u64)) as Field,
-            hi: ((self.hi as u64) & (other.hi as u64)) as Field
+            hi: ((self.hi as u64) & (other.hi as u64)) as Field,
         }
     }
 }
@@ -274,7 +275,7 @@ impl BitXor for U128 {
     fn bitxor(self, other: U128) -> U128 {
         U128 {
             lo: ((self.lo as u64) ^ (other.lo as u64)) as Field,
-            hi: ((self.hi as u64) ^ (other.hi as u64)) as Field
+            hi: ((self.hi as u64) ^ (other.hi as u64)) as Field,
         }
     }
 }
@@ -312,7 +313,7 @@ impl Shr for U128 {
 }
 
 mod tests {
-    use crate::uint128::{U128, pow64, pow63};
+    use crate::uint128::{pow63, pow64, U128};
 
     #[test]
     fn test_not(lo: u64, hi: u64) {
@@ -340,15 +341,15 @@ mod tests {
     fn test_byte_decomposition() {
         let a = U128::from_u64s_le(0x0706050403020100, 0x0f0e0d0c0b0a0908);
         // Get big-endian and little-endian byte decompostions
-        let le_bytes_a= a.to_le_bytes();
-        let be_bytes_a= a.to_be_bytes();
+        let le_bytes_a = a.to_le_bytes();
+        let be_bytes_a = a.to_be_bytes();
 
         // Check equivalence
         for i in 0..16 {
             assert_eq(le_bytes_a[i], be_bytes_a[15 - i]);
         }
         // Reconstruct U128 from byte decomposition
-        let b= U128::from_le_bytes(le_bytes_a);
+        let b = U128::from_le_bytes(le_bytes_a);
         // Check that it's the same element
         assert_eq(a, b);
     }
@@ -358,12 +359,12 @@ mod tests {
         let b = U128::from_hex("0x20000000000000001");
         assert_eq(a, b);
 
-        let c= U128::from_hex("0xffffffffffffffffffffffffffffffff");
-        let d= U128::from_u64s_le(0xffffffffffffffff, 0xffffffffffffffff);
+        let c = U128::from_hex("0xffffffffffffffffffffffffffffffff");
+        let d = U128::from_u64s_le(0xffffffffffffffff, 0xffffffffffffffff);
         assert_eq(c, d);
 
-        let e= U128::from_hex("0x00000000000000000000000000000000");
-        let f= U128::from_u64s_le(0, 0);
+        let e = U128::from_hex("0x00000000000000000000000000000000");
+        let f = U128::from_u64s_le(0, 0);
         assert_eq(e, f);
     }
 
@@ -373,7 +374,7 @@ mod tests {
     fn test_ascii_decode_correct_range() {
         // '0'..'9' range
         for i in 0..10 {
-            let decoded= U128::decode_ascii(48 + i);
+            let decoded = U128::decode_ascii(48 + i);
             assert_eq(decoded, i as Field);
         }
         // 'A'..'F' range
@@ -423,20 +424,20 @@ mod tests {
         // This code will actually fail because of ascii_decode,
         // but in the past it was possible to create a value > (1<<128)
         let a = U128::from_hex("0x~fffffffffffffffffffffffffffffff");
-        let b:Field= a.to_integer();
-        let c: [u8; 17]= b.to_le_bytes();
+        let b: Field = a.to_integer();
+        let c: [u8; 17] = b.to_le_bytes();
         assert(c[16] != 0);
     }
 
     #[test]
     fn test_unconstrained_div() {
         // Test the potential overflow case
-        let a= U128::from_u64s_le(0x0, 0xffffffffffffffff);
-        let b= U128::from_u64s_le(0x0, 0xfffffffffffffffe);
-        let c= U128::one();
-        let d= U128::from_u64s_le(0x0, 0x1);
+        let a = U128::from_u64s_le(0x0, 0xffffffffffffffff);
+        let b = U128::from_u64s_le(0x0, 0xfffffffffffffffe);
+        let c = U128::one();
+        let d = U128::from_u64s_le(0x0, 0x1);
         unsafe {
-            let (q,r) = a.unconstrained_div(b);
+            let (q, r) = a.unconstrained_div(b);
             assert_eq(q, c);
             assert_eq(r, d);
         }
@@ -451,7 +452,7 @@ mod tests {
 
         // Check where b is a multiple of a
         unsafe {
-            let (c,d) = b.unconstrained_div(a);
+            let (c, d) = b.unconstrained_div(a);
             assert_eq((c, d), (U128::zero(), b));
         }
 
@@ -459,7 +460,7 @@ mod tests {
         let a = U128::from_u64s_le(0x1, 0x0);
         let b = U128::zero();
         unsafe {
-            let (c, d)= a.unconstrained_div(b);
+            let (c, d) = a.unconstrained_div(b);
             assert_eq((c, d), (U128::zero(), U128::zero()));
         }
         // Dividing 1<<127 by 1<<127 (special case)
@@ -474,25 +475,25 @@ mod tests {
     #[test]
     fn integer_conversions() {
         // Maximum
-        let start:Field = 0xffffffffffffffffffffffffffffffff;
+        let start: Field = 0xffffffffffffffffffffffffffffffff;
         let a = U128::from_integer(start);
         let end = a.to_integer();
         assert_eq(start, end);
 
         // Minimum
-        let start:Field = 0x0;
+        let start: Field = 0x0;
         let a = U128::from_integer(start);
         let end = a.to_integer();
         assert_eq(start, end);
 
         // Low limb
-        let start:Field = 0xffffffffffffffff;
+        let start: Field = 0xffffffffffffffff;
         let a = U128::from_integer(start);
         let end = a.to_integer();
         assert_eq(start, end);
 
         // High limb
-        let start:Field = 0xffffffffffffffff0000000000000000;
+        let start: Field = 0xffffffffffffffff0000000000000000;
         let a = U128::from_integer(start);
         let end = a.to_integer();
         assert_eq(start, end);
@@ -533,7 +534,10 @@ mod tests {
         assert_eq(U128::zero(), U128::from_u64s_le(0, 1).wrapping_mul(U128::from_u64s_le(0, 1)));
         // -1 * -1 == 1
         assert_eq(
-            U128::one(), U128::from_u64s_le(0xffffffffffffffff, 0xffffffffffffffff).wrapping_mul(U128::from_u64s_le(0xffffffffffffffff, 0xffffffffffffffff))
+            U128::one(),
+            U128::from_u64s_le(0xffffffffffffffff, 0xffffffffffffffff).wrapping_mul(
+                U128::from_u64s_le(0xffffffffffffffff, 0xffffffffffffffff),
+            ),
         );
     }
 }
diff --git a/package.json b/package.json
index 8abaced7bdd..00036838f9b 100644
--- a/package.json
+++ b/package.json
@@ -8,7 +8,6 @@
     "tooling/noirc_abi_wasm",
     "tooling/noir_js",
     "tooling/noir_codegen",
-    "tooling/noir_js_backend_barretenberg",
     "acvm-repo/acvm_js",
     "docs"
   ],
diff --git a/release-please-config.json b/release-please-config.json
index 0ba192754a0..963f1af26d9 100644
--- a/release-please-config.json
+++ b/release-please-config.json
@@ -3,75 +3,69 @@
   "bump-minor-pre-major": true,
   "bump-patch-for-minor-pre-major": true,
   "prerelease": true,
+  "prerelease-type": "beta",
   "pull-request-title-pattern": "chore: Release Noir(${version})",
   "group-pull-request-title-pattern": "chore: Release Noir(${version})",
   "packages": {
     ".": {
       "release-type": "simple",
+      "versioning": "prerelease",
       "component": "noir",
       "package-name": "noir",
       "include-component-in-tag": false,
       "extra-files": [
         "Cargo.toml",
+        "acvm-repo/acir/Cargo.toml",
+        "acvm-repo/acir_field/Cargo.toml",
+        "acvm-repo/acvm/Cargo.toml",
+        "acvm-repo/acvm_js/Cargo.toml",
+        "acvm-repo/blackbox_solver/Cargo.toml",
+        "acvm-repo/bn254_blackbox_solver/Cargo.toml",
+        "acvm-repo/brillig/Cargo.toml",
+        "acvm-repo/brillig_vm/Cargo.toml",
         {
           "type": "json",
-          "path": "compiler/wasm/package.json",
+          "path": "acvm-repo/acvm_js/package.json",
           "jsonpath": "$.version"
         },
         {
           "type": "json",
-          "path": "tooling/noir_codegen/package.json",
+          "path": "acvm-repo/acvm_js/package.json",
           "jsonpath": "$.version"
         },
         {
           "type": "json",
-          "path": "tooling/noir_js/package.json",
+          "path": "compiler/wasm/package.json",
           "jsonpath": "$.version"
         },
         {
           "type": "json",
-          "path": "tooling/noir_js_backend_barretenberg/package.json",
+          "path": "tooling/noir_codegen/package.json",
           "jsonpath": "$.version"
         },
         {
           "type": "json",
-          "path": "tooling/noir_js_types/package.json",
+          "path": "tooling/noir_js/package.json",
           "jsonpath": "$.version"
         },
         {
           "type": "json",
-          "path": "tooling/noirc_abi_wasm/package.json",
+          "path": "tooling/noir_js_backend_barretenberg/package.json",
           "jsonpath": "$.version"
         },
         {
           "type": "json",
-          "path": "docs/docs/package.json",
+          "path": "tooling/noir_js_types/package.json",
           "jsonpath": "$.version"
-        }
-      ]
-    },
-    "acvm-repo": {
-      "release-type": "simple",
-      "package-name": "acvm",
-      "component": "acvm",
-      "include-component-in-tag": false,
-      "extra-files": [
-        "acir/Cargo.toml",
-        "acir_field/Cargo.toml",
-        "acvm/Cargo.toml",
-        "acvm_js/Cargo.toml",
-        "blackbox_solver/Cargo.toml",
-        "bn254_blackbox_solver/Cargo.toml",
-        "brillig/Cargo.toml",
-        "brillig_vm/Cargo.toml",
+        },
         {
           "type": "json",
-          "path": "acvm_js/package.json",
+          "path": "tooling/noirc_abi_wasm/package.json",
           "jsonpath": "$.version"
         },
         {
           "type": "json",
-          "path": "acvm_js/package.json",
+          "path": "docs/docs/package.json",
           "jsonpath": "$.version"
         }
       ]
diff --git a/scripts/bump-bb.sh b/scripts/bump-bb.sh
index 36c1f78ca05..661a8eb9d43 100755
--- a/scripts/bump-bb.sh
+++ b/scripts/bump-bb.sh
@@ -5,7 +5,7 @@ BB_VERSION=$1
 sed -i.bak "s/^VERSION=.*/VERSION=\"$BB_VERSION\"/" ./scripts/install_bb.sh  && rm ./scripts/install_bb.sh.bak
 
 tmp=$(mktemp)
-BACKEND_BARRETENBERG_PACKAGE_JSON=./tooling/noir_js_backend_barretenberg/package.json
-jq --arg v $BB_VERSION '.dependencies."@aztec/bb.js" = $v' $BACKEND_BARRETENBERG_PACKAGE_JSON > $tmp && mv $tmp $BACKEND_BARRETENBERG_PACKAGE_JSON
+INTEGRATION_TESTS_PACKAGE_JSON=./compiler/integration-tests/package.json
+jq --arg v $BB_VERSION '.dependencies."@aztec/bb.js" = $v' $INTEGRATION_TESTS_PACKAGE_JSON > $tmp && mv $tmp $INTEGRATION_TESTS_PACKAGE_JSON
 
 YARN_ENABLE_IMMUTABLE_INSTALLS=false yarn install
diff --git a/scripts/check-critical-libraries.sh b/scripts/check-critical-libraries.sh
new file mode 100755
index 00000000000..f8e474d23de
--- /dev/null
+++ b/scripts/check-critical-libraries.sh
@@ -0,0 +1,37 @@
+#!/usr/bin/env bash
+set -e
+
+# Run relative to repo root
+cd $(dirname "$0")/../
+
+if [[ -z $1 ]]; then
+    echo "Must specify Noir release to test against" >&2
+    echo "usage: ./check-critical-libraries.sh <release-version>" >&2
+    exit 1
+fi
+noirup -v $1
+
+CRITICAL_LIBRARIES=$(grep -v "^#\|^$" ./CRITICAL_NOIR_LIBRARIES)
+readarray -t REPOS_TO_CHECK < <(echo "$CRITICAL_LIBRARIES")
+
+getLatestReleaseTagForRepo() {
+    REPO_NAME=$1
+    TAG=$(gh release list -R $REPO_NAME --json 'tagName,isLatest' -q '.[] | select(.isLatest == true).tagName')
+    if [[ -z $TAG ]]; then
+        echo "$REPO_NAME has no valid release" >&2
+        exit 1
+    fi
+    echo $TAG
+}
+
+for REPO in ${REPOS_TO_CHECK[@]}; do
+    echo $REPO   
+    TMP_DIR=$(mktemp -d)
+    
+    TAG=$(getLatestReleaseTagForRepo $REPO)
+    git clone $REPO -c advice.detachedHead=false --depth 1 --branch $TAG $TMP_DIR
+    
+    nargo test -q --program-dir $TMP_DIR
+
+    rm -rf $TMP_DIR
+done
diff --git a/scripts/install_bb.sh b/scripts/install_bb.sh
index c94a1b7dff0..3d1dc038ab8 100755
--- a/scripts/install_bb.sh
+++ b/scripts/install_bb.sh
@@ -1,6 +1,6 @@
 #!/bin/bash
 
-VERSION="0.56.0"
+VERSION="0.66.0"
 
 BBUP_PATH=~/.bb/bbup
 
diff --git a/test_programs/benchmarks/bench_eddsa_poseidon/Nargo.toml b/test_programs/benchmarks/bench_eddsa_poseidon/Nargo.toml
index bc2a779f7b2..6c754f1d107 100644
--- a/test_programs/benchmarks/bench_eddsa_poseidon/Nargo.toml
+++ b/test_programs/benchmarks/bench_eddsa_poseidon/Nargo.toml
@@ -5,3 +5,4 @@ type = "bin"
 authors = [""]
 
 [dependencies]
+ec = { tag = "v0.1.2", git = "https://github.com/noir-lang/ec" }
diff --git a/test_programs/benchmarks/bench_eddsa_poseidon/src/main.nr b/test_programs/benchmarks/bench_eddsa_poseidon/src/main.nr
index cb853e48c30..c4a1d4b51f5 100644
--- a/test_programs/benchmarks/bench_eddsa_poseidon/src/main.nr
+++ b/test_programs/benchmarks/bench_eddsa_poseidon/src/main.nr
@@ -1,4 +1,10 @@
-use std::eddsa::eddsa_poseidon_verify;
+use std::default::Default;
+use std::hash::Hasher;
+use std::hash::poseidon::PoseidonHasher;
+
+use ec::consts::te::baby_jubjub;
+use ec::tecurve::affine::Point as TEPoint;
+
 
 fn main(
     msg: pub Field,
@@ -6,7 +12,52 @@ fn main(
     pub_key_y: Field,
     r8_x: Field,
     r8_y: Field,
-    s: Field
+    s: Field,
 ) -> pub bool {
-    eddsa_poseidon_verify(pub_key_x, pub_key_y, s, r8_x, r8_y, msg)
+    eddsa_verify::<PoseidonHasher>(pub_key_x, pub_key_y, s, r8_x, r8_y, msg)
+}
+
+pub fn eddsa_verify<H>(
+    pub_key_x: Field,
+    pub_key_y: Field,
+    signature_s: Field,
+    signature_r8_x: Field,
+    signature_r8_y: Field,
+    message: Field,
+) -> bool
+where
+    H: Hasher + Default,
+{
+    // Verifies by testing:
+    // S * B8 = R8 + H(R8, A, m) * A8
+    let bjj = baby_jubjub();
+
+    let pub_key = TEPoint::new(pub_key_x, pub_key_y);
+    assert(bjj.curve.contains(pub_key));
+
+    let signature_r8 = TEPoint::new(signature_r8_x, signature_r8_y);
+    assert(bjj.curve.contains(signature_r8));
+    // Ensure S < Subgroup Order
+    assert(signature_s.lt(bjj.suborder));
+    // Calculate the h = H(R, A, msg)
+    let mut hasher = H::default();
+    hasher.write(signature_r8_x);
+    hasher.write(signature_r8_y);
+    hasher.write(pub_key_x);
+    hasher.write(pub_key_y);
+    hasher.write(message);
+    let hash: Field = hasher.finish();
+    // Calculate second part of the right side:  right2 = h*8*A
+    // Multiply by 8 by doubling 3 times. This also ensures that the result is in the subgroup.
+    let pub_key_mul_2 = bjj.curve.add(pub_key, pub_key);
+    let pub_key_mul_4 = bjj.curve.add(pub_key_mul_2, pub_key_mul_2);
+    let pub_key_mul_8 = bjj.curve.add(pub_key_mul_4, pub_key_mul_4);
+    // We check that A8 is not zero.
+    assert(!pub_key_mul_8.is_zero());
+    // Compute the right side: R8 + h * A8
+    let right = bjj.curve.add(signature_r8, bjj.curve.mul(hash, pub_key_mul_8));
+    // Calculate left side of equation left = S * B8
+    let left = bjj.curve.mul(signature_s, bjj.base8);
+
+    left.eq(right)
 }
diff --git a/test_programs/benchmarks/bench_poseidon2_hash_100/src/main.nr b/test_programs/benchmarks/bench_poseidon2_hash_100/src/main.nr
index 39c714e524f..66a785f446a 100644
--- a/test_programs/benchmarks/bench_poseidon2_hash_100/src/main.nr
+++ b/test_programs/benchmarks/bench_poseidon2_hash_100/src/main.nr
@@ -1,6 +1,6 @@
 use std::hash::poseidon2;
 
-global SIZE = 100;
+global SIZE: u32 = 100;
 
 fn main(input: [[Field; 2]; SIZE]) -> pub [Field; SIZE] {
     let mut results: [Field; SIZE] = [0; SIZE];
diff --git a/test_programs/benchmarks/bench_poseidon2_hash_30/src/main.nr b/test_programs/benchmarks/bench_poseidon2_hash_30/src/main.nr
index d1251a4c853..2e72ebc3519 100644
--- a/test_programs/benchmarks/bench_poseidon2_hash_30/src/main.nr
+++ b/test_programs/benchmarks/bench_poseidon2_hash_30/src/main.nr
@@ -1,6 +1,6 @@
 use std::hash::poseidon2;
 
-global SIZE = 30;
+global SIZE: u32 = 30;
 
 fn main(input: [[Field; 2]; SIZE]) -> pub [Field; SIZE] {
     let mut results: [Field; SIZE] = [0; SIZE];
diff --git a/test_programs/benchmarks/bench_poseidon_hash/bench_poseidon_hash_100/src/main.nr b/test_programs/benchmarks/bench_poseidon_hash/bench_poseidon_hash_100/src/main.nr
index 1c9bbfe61bf..75d853941e5 100644
--- a/test_programs/benchmarks/bench_poseidon_hash/bench_poseidon_hash_100/src/main.nr
+++ b/test_programs/benchmarks/bench_poseidon_hash/bench_poseidon_hash_100/src/main.nr
@@ -1,6 +1,6 @@
 use std::hash;
 
-global SIZE = 100;
+global SIZE: u32 = 100;
 
 fn main(input: [[Field; 2]; SIZE]) -> pub [Field; SIZE] {
     let mut results: [Field; SIZE] = [0; SIZE];
diff --git a/test_programs/benchmarks/bench_poseidon_hash/bench_poseidon_hash_30/src/main.nr b/test_programs/benchmarks/bench_poseidon_hash/bench_poseidon_hash_30/src/main.nr
index 3edb47e9f72..d4f357e11f9 100644
--- a/test_programs/benchmarks/bench_poseidon_hash/bench_poseidon_hash_30/src/main.nr
+++ b/test_programs/benchmarks/bench_poseidon_hash/bench_poseidon_hash_30/src/main.nr
@@ -1,6 +1,6 @@
 use std::hash;
 
-global SIZE = 30;
+global SIZE: u32 = 30;
 
 fn main(input: [[Field; 2]; SIZE]) -> pub [Field; SIZE] {
     let mut results: [Field; SIZE] = [0; SIZE];
diff --git a/test_programs/benchmarks/bench_poseidon_hash_100/src/main.nr b/test_programs/benchmarks/bench_poseidon_hash_100/src/main.nr
index 1c9bbfe61bf..75d853941e5 100644
--- a/test_programs/benchmarks/bench_poseidon_hash_100/src/main.nr
+++ b/test_programs/benchmarks/bench_poseidon_hash_100/src/main.nr
@@ -1,6 +1,6 @@
 use std::hash;
 
-global SIZE = 100;
+global SIZE: u32 = 100;
 
 fn main(input: [[Field; 2]; SIZE]) -> pub [Field; SIZE] {
     let mut results: [Field; SIZE] = [0; SIZE];
diff --git a/test_programs/benchmarks/bench_poseidon_hash_30/src/main.nr b/test_programs/benchmarks/bench_poseidon_hash_30/src/main.nr
index 3edb47e9f72..d4f357e11f9 100644
--- a/test_programs/benchmarks/bench_poseidon_hash_30/src/main.nr
+++ b/test_programs/benchmarks/bench_poseidon_hash_30/src/main.nr
@@ -1,6 +1,6 @@
 use std::hash;
 
-global SIZE = 30;
+global SIZE: u32 = 30;
 
 fn main(input: [[Field; 2]; SIZE]) -> pub [Field; SIZE] {
     let mut results: [Field; SIZE] = [0; SIZE];
diff --git a/test_programs/benchmarks/bench_sha256_100/src/main.nr b/test_programs/benchmarks/bench_sha256_100/src/main.nr
index 6df856a83fc..6e4bfc27c8f 100644
--- a/test_programs/benchmarks/bench_sha256_100/src/main.nr
+++ b/test_programs/benchmarks/bench_sha256_100/src/main.nr
@@ -1,4 +1,4 @@
-global SIZE = 100;
+global SIZE: u32 = 100;
 
 fn main(input: [[u8; 2]; SIZE]) -> pub [[u8; 32]; SIZE] {
     let mut results: [[u8; 32]; SIZE] = [[0; 32]; SIZE];
diff --git a/test_programs/benchmarks/bench_sha256_30/src/main.nr b/test_programs/benchmarks/bench_sha256_30/src/main.nr
index 220c1cfbbed..0a4288114e3 100644
--- a/test_programs/benchmarks/bench_sha256_30/src/main.nr
+++ b/test_programs/benchmarks/bench_sha256_30/src/main.nr
@@ -1,4 +1,4 @@
-global SIZE = 30;
+global SIZE: u32 = 30;
 
 fn main(input: [[u8; 2]; SIZE]) -> pub [[u8; 32]; SIZE] {
     let mut results: [[u8; 32]; SIZE] = [[0; 32]; SIZE];
diff --git a/test_programs/benchmarks/bench_sha256_long/Nargo.toml b/test_programs/benchmarks/bench_sha256_long/Nargo.toml
new file mode 100644
index 00000000000..ae66d7ed5a6
--- /dev/null
+++ b/test_programs/benchmarks/bench_sha256_long/Nargo.toml
@@ -0,0 +1,7 @@
+[package]
+name = "bench_sha256_long"
+version = "0.1.0"
+type = "bin"
+authors = [""]
+
+[dependencies]
diff --git a/test_programs/benchmarks/bench_sha256_long/Prover.toml b/test_programs/benchmarks/bench_sha256_long/Prover.toml
new file mode 100644
index 00000000000..ba4bbc1540d
--- /dev/null
+++ b/test_programs/benchmarks/bench_sha256_long/Prover.toml
@@ -0,0 +1,191 @@
+# 2*64+60=188 bytes
+input = [
+    0,
+    1,
+    2,
+    3,
+    4,
+    5,
+    6,
+    7,
+    8,
+    9,
+    10,
+    11,
+    12,
+    13,
+    14,
+    15,
+    16,
+    17,
+    18,
+    19,
+    20,
+    21,
+    22,
+    23,
+    24,
+    25,
+    26,
+    27,
+    28,
+    29,
+    30,
+    31,
+    32,
+    33,
+    34,
+    35,
+    36,
+    37,
+    38,
+    39,
+    40,
+    41,
+    42,
+    43,
+    44,
+    45,
+    46,
+    47,
+    48,
+    49,
+    50,
+    51,
+    52,
+    53,
+    54,
+    55,
+    56,
+    57,
+    58,
+    59,
+    60,
+    61,
+    62,
+    63,
+    64,
+    65,
+    66,
+    67,
+    68,
+    69,
+    70,
+    71,
+    72,
+    73,
+    74,
+    75,
+    76,
+    77,
+    78,
+    79,
+    80,
+    81,
+    82,
+    83,
+    84,
+    85,
+    86,
+    87,
+    88,
+    89,
+    90,
+    91,
+    92,
+    93,
+    94,
+    95,
+    96,
+    97,
+    98,
+    99,
+    0,
+    1,
+    2,
+    3,
+    4,
+    5,
+    6,
+    7,
+    8,
+    9,
+    10,
+    11,
+    12,
+    13,
+    14,
+    15,
+    16,
+    17,
+    18,
+    19,
+    20,
+    21,
+    22,
+    23,
+    24,
+    25,
+    26,
+    27,
+    28,
+    29,
+    30,
+    31,
+    32,
+    33,
+    34,
+    35,
+    36,
+    37,
+    38,
+    39,
+    40,
+    41,
+    42,
+    43,
+    44,
+    45,
+    46,
+    47,
+    48,
+    49,
+    50,
+    51,
+    52,
+    53,
+    54,
+    55,
+    56,
+    57,
+    58,
+    59,
+    60,
+    61,
+    62,
+    63,
+    64,
+    65,
+    66,
+    67,
+    68,
+    69,
+    70,
+    71,
+    72,
+    73,
+    74,
+    75,
+    76,
+    77,
+    78,
+    79,
+    80,
+    81,
+    82,
+    83,
+    84,
+    85,
+    86,
+    87,
+]
diff --git a/test_programs/benchmarks/bench_sha256_long/src/main.nr b/test_programs/benchmarks/bench_sha256_long/src/main.nr
new file mode 100644
index 00000000000..c47bdc2a561
--- /dev/null
+++ b/test_programs/benchmarks/bench_sha256_long/src/main.nr
@@ -0,0 +1,7 @@
+// Input size long enough that we have to compress a few times
+// and then pad the last block out.
+global INPUT_SIZE: u32 = 2 * 64 + 60;
+
+fn main(input: [u8; INPUT_SIZE]) -> pub [u8; 32] {
+    std::hash::sha256(input)
+}
diff --git a/test_programs/compilation_report.sh b/test_programs/compilation_report.sh
new file mode 100755
index 00000000000..d050e7c9c34
--- /dev/null
+++ b/test_programs/compilation_report.sh
@@ -0,0 +1,51 @@
+#!/usr/bin/env bash
+set -e
+
+current_dir=$(pwd)
+base_path="$current_dir/execution_success"
+
+# Tests to be profiled for compilation report
+tests_to_profile=("sha256_regression" "regression_4709" "ram_blowup_regression")
+
+echo "{\"compilation_reports\": [ " > $current_dir/compilation_report.json
+
+# If there is an argument that means we want to generate a report for only the current directory
+if [ "$#" -ne 0 ]; then
+  base_path="$current_dir"
+  tests_to_profile=(".")
+fi
+
+ITER="1"
+NUM_ARTIFACTS=${#tests_to_profile[@]}
+
+for dir in ${tests_to_profile[@]}; do 
+    if [[ " ${excluded_dirs[@]} " =~ " ${dir} " ]]; then
+      continue
+    fi
+
+    if [[ ${CI-false} = "true" ]] && [[ " ${ci_excluded_dirs[@]} " =~ " ${dir} " ]]; then
+      continue
+    fi
+
+    cd $base_path/$dir
+
+    # The default package to run is the supplied list hardcoded at the top of the script
+    PACKAGE_NAME=$dir
+    # Otherwise default to the current directory as the package we want to run
+    if [ "$#" -ne 0 ]; then
+      PACKAGE_NAME=$(basename $current_dir)
+    fi
+
+    COMPILE_TIME=$((time nargo compile --force --silence-warnings) 2>&1 | grep real | grep -oE '[0-9]+m[0-9]+.[0-9]+s')
+    echo -e " {\n    \"artifact_name\":\"$PACKAGE_NAME\",\n    \"time\":\"$COMPILE_TIME\"" >> $current_dir/compilation_report.json
+    
+    if (($ITER == $NUM_ARTIFACTS)); then
+        echo "}" >> $current_dir/compilation_report.json
+    else 
+        echo "}, " >> $current_dir/compilation_report.json
+    fi
+
+    ITER=$(( $ITER + 1 ))
+done
+
+echo "]}" >> $current_dir/compilation_report.json
diff --git a/test_programs/compile_failure/cannot_deduce_numeric_generic/Nargo.toml b/test_programs/compile_failure/cannot_deduce_numeric_generic/Nargo.toml
new file mode 100644
index 00000000000..e87c464f6c7
--- /dev/null
+++ b/test_programs/compile_failure/cannot_deduce_numeric_generic/Nargo.toml
@@ -0,0 +1,7 @@
+[package]
+name = "cannot_deduce_numeric_generic"
+type = "bin"
+authors = [""]
+compiler_version = ">=0.33.0"
+
+[dependencies]
diff --git a/test_programs/compile_failure/cannot_deduce_numeric_generic/src/main.nr b/test_programs/compile_failure/cannot_deduce_numeric_generic/src/main.nr
new file mode 100644
index 00000000000..ee889e805f7
--- /dev/null
+++ b/test_programs/compile_failure/cannot_deduce_numeric_generic/src/main.nr
@@ -0,0 +1,8 @@
+fn foo<let N: u32>() -> u32 {
+    N
+}
+
+fn main() {
+    let _ = foo();
+}
+
diff --git a/test_programs/compile_failure/checked_transmute/Nargo.toml b/test_programs/compile_failure/checked_transmute/Nargo.toml
new file mode 100644
index 00000000000..9d01c873b03
--- /dev/null
+++ b/test_programs/compile_failure/checked_transmute/Nargo.toml
@@ -0,0 +1,7 @@
+[package]
+name = "checked_transmute"
+type = "bin"
+authors = [""]
+compiler_version = ">=0.35.0"
+
+[dependencies]
\ No newline at end of file
diff --git a/test_programs/compile_failure/checked_transmute/src/main.nr b/test_programs/compile_failure/checked_transmute/src/main.nr
new file mode 100644
index 00000000000..058fa0ec911
--- /dev/null
+++ b/test_programs/compile_failure/checked_transmute/src/main.nr
@@ -0,0 +1,9 @@
+use std::mem::checked_transmute;
+
+fn main() {
+    let _: [Field; 2] = transmute_fail([1]);
+}
+
+pub fn transmute_fail<let N: u32>(x: [Field; N]) -> [Field; N + 1] {
+    checked_transmute(x)
+}
diff --git a/test_programs/compile_failure/comptime_apply_failing_range_constraint/Nargo.toml b/test_programs/compile_failure/comptime_apply_failing_range_constraint/Nargo.toml
new file mode 100644
index 00000000000..e14cfeae5d6
--- /dev/null
+++ b/test_programs/compile_failure/comptime_apply_failing_range_constraint/Nargo.toml
@@ -0,0 +1,6 @@
+[package]
+name = "comptime_apply_failing_range_constraint"
+type = "bin"
+authors = [""]
+
+[dependencies]
diff --git a/test_programs/compile_failure/comptime_apply_failing_range_constraint/src/main.nr b/test_programs/compile_failure/comptime_apply_failing_range_constraint/src/main.nr
new file mode 100644
index 00000000000..752f13a2e51
--- /dev/null
+++ b/test_programs/compile_failure/comptime_apply_failing_range_constraint/src/main.nr
@@ -0,0 +1,5 @@
+fn main() {
+    comptime {
+        256.assert_max_bit_size::<8>()
+    }
+}
diff --git a/test_programs/compile_success_contract/abi_attribute/src/main.nr b/test_programs/compile_success_contract/abi_attribute/src/main.nr
index 164512b03db..c4d4a24e3c2 100644
--- a/test_programs/compile_success_contract/abi_attribute/src/main.nr
+++ b/test_programs/compile_success_contract/abi_attribute/src/main.nr
@@ -1,9 +1,9 @@
 contract Foo {
     #[abi(foo)]
-    global foo: Field = 42;
+    pub global foo: Field = 42;
 
     #[abi(bar)]
-    struct Bar {
+    pub struct Bar {
         inner: Field
     }
 }
diff --git a/test_programs/compile_success_contract/contract_with_impl/src/main.nr b/test_programs/compile_success_contract/contract_with_impl/src/main.nr
index 1c6b6c217c4..9d45b88fbc9 100644
--- a/test_programs/compile_success_contract/contract_with_impl/src/main.nr
+++ b/test_programs/compile_success_contract/contract_with_impl/src/main.nr
@@ -1,7 +1,9 @@
 contract Foo {
-    struct T { x: [Field] }
+    pub struct T { x: [Field] }
 
     impl T {
-        fn t(self) {}
+        fn t(self) {
+            let _ = self;
+        }
     }
 }
diff --git a/test_programs/compile_success_contract/non_entry_point_method/src/main.nr b/test_programs/compile_success_contract/non_entry_point_method/src/main.nr
index b768653262a..f49c2f14f9d 100644
--- a/test_programs/compile_success_contract/non_entry_point_method/src/main.nr
+++ b/test_programs/compile_success_contract/non_entry_point_method/src/main.nr
@@ -1,6 +1,6 @@
 contract Foo {
-    struct PlaceholderStruct{x : u32 }
+    pub struct PlaceholderStruct{x : u32 }
 
     #[contract_library_method]
-    fn has_mut(_context: &mut PlaceholderStruct) {}
+    pub fn has_mut(_context: &mut PlaceholderStruct) {}
 }
diff --git a/test_programs/compile_success_contract/recursive_method/Nargo.toml b/test_programs/compile_success_contract/recursive_method/Nargo.toml
deleted file mode 100644
index 8142e5b3278..00000000000
--- a/test_programs/compile_success_contract/recursive_method/Nargo.toml
+++ /dev/null
@@ -1,6 +0,0 @@
-[package]
-name = "recursive_method"
-type = "contract"
-authors = [""]
-
-[dependencies]
diff --git a/test_programs/compile_success_contract/recursive_method/src/main.nr b/test_programs/compile_success_contract/recursive_method/src/main.nr
deleted file mode 100644
index 6fd4bf3338d..00000000000
--- a/test_programs/compile_success_contract/recursive_method/src/main.nr
+++ /dev/null
@@ -1,6 +0,0 @@
-contract Foo {
-    #[recursive]
-    fn contract_entrypoint() -> pub Field {
-        1
-    }
-}
diff --git a/test_programs/compile_success_contract/simple_contract/src/main.nr b/test_programs/compile_success_contract/simple_contract/src/main.nr
index 7412e1386bf..7742ed6139b 100644
--- a/test_programs/compile_success_contract/simple_contract/src/main.nr
+++ b/test_programs/compile_success_contract/simple_contract/src/main.nr
@@ -10,7 +10,7 @@ contract Foo {
     }
     // Regression for issue #3344
     #[contract_library_method]
-    fn foo(x: u8) -> u8 {
+    pub fn foo(x: u8) -> u8 {
         x
     }
 }
diff --git a/test_programs/compile_success_empty/arithmetic_generics/src/main.nr b/test_programs/compile_success_empty/arithmetic_generics/src/main.nr
index 0a7d319485c..ae50748c8e7 100644
--- a/test_programs/compile_success_empty/arithmetic_generics/src/main.nr
+++ b/test_programs/compile_success_empty/arithmetic_generics/src/main.nr
@@ -52,9 +52,9 @@ fn push_multiple<let N: u32>(array: [Field; N]) -> [Field; N + 2] {
 // The rest of this file is setup for demo_proof
 // *********************************************
 
-struct W<let N: u32> { }
+pub struct W<let N: u32> {}
 
-struct Equiv<T, TU, U, UT> {
+pub struct Equiv<T, TU, U, UT> {
     // TODO(https://github.com/noir-lang/noir/issues/5644):
     // Bug with struct_obj.field_thats_a_fn(x)
 
@@ -75,29 +75,31 @@ impl<T, TU, U, UT> Equiv<T, TU, U, UT> {
 
 fn equiv_trans<T, TU, U, UT, UV, V, VU>(
     x: Equiv<T, TU, U, UT>,
-    y: Equiv<U, UV, V, VU>
-) -> Equiv<T, (Equiv<U, UV, V, VU>, Equiv<T, TU, U, UT>), V, (Equiv<T, TU, U, UT>, Equiv<U, UV, V, VU>)> {
-    Equiv { to_: |z| { y.to(x.to(z)) }, fro_: |z| { x.fro(y.fro(z)) } }
+    y: Equiv<U, UV, V, VU>,
+    ) -> Equiv<T, (Equiv<U, UV, V, VU>, Equiv<T, TU, U, UT>), V, (Equiv<T, TU, U, UT>, Equiv<U, UV, V, VU>)> {
+    Equiv { to_: |z| y.to(x.to(z)), fro_: |z| x.fro(y.fro(z)) }
 }
 
 fn mul_one_r<let N: u32>() -> Equiv<W<N>, (), W<N>, ()> {
-    Equiv { to_: |_x| { W {} }, fro_: |_x| { W {} } }
+    Equiv { to_: |_x| W {}, fro_: |_x| W {} }
 }
 
-fn add_equiv_r<let C: u32, let N: u32, let M: u32, EN, EM>(_: Equiv<W<N>, EN, W<M>, EM>) -> Equiv<W<C + N>, (), W<C + M>, ()> {
-    Equiv { to_: |_x| { W {} }, fro_: |_x| { W {} } }
+fn add_equiv_r<let C: u32, let N: u32, let M: u32, EN, EM>(
+    _: Equiv<W<N>, EN, W<M>, EM>,
+) -> Equiv<W<C + N>, (), W<C + M>, ()> {
+    Equiv { to_: |_x| W {}, fro_: |_x| W {} }
 }
 
 fn mul_comm<let N: u32, let M: u32>() -> Equiv<W<N * M>, (), W<M * N>, ()> {
-    Equiv { to_: |_x| { W {} }, fro_: |_x| { W {} } }
+    Equiv { to_: |_x| W {}, fro_: |_x| W {} }
 }
 
 fn mul_add<let N: u32, let M: u32, let P: u32>() -> Equiv<W<N * (M + P)>, (), W<N * M + N * P>, ()> {
-    Equiv { to_: |_x| { W {} }, fro_: |_x| { W {} } }
+    Equiv { to_: |_x| W {}, fro_: |_x| W {} }
 }
 
 // (N + 1) * N == N * N + N
-fn demo_proof<let N: u32>() -> Equiv<W<(N * (N + 1))>, (Equiv<W<N>, (), W<N>, ()>, Equiv<W<(N * (N + 1))>, (Equiv<W<(N * (N + 1))>, (), W<N>, ()>, Equiv<W<(N * (N + 1))>, (), W<(N * (N + 1))>, ()>), W<N>, (Equiv<W<(N * (N + 1))>, (), W<(N * (N + 1))>, ()>, Equiv<W<(N * (N + 1))>, (), W<N>, ()>)>), W<N>, (Equiv<W<(N * (N + 1))>, (Equiv<W<(N * (N + 1))>, (), W<N>, ()>, Equiv<W<(N * (N + 1))>, (), W<(N * (N + 1))>, ()>), W<N>, (Equiv<W<(N * (N + 1))>, (), W<(N * (N + 1))>, ()>, Equiv<W<(N * (N + 1))>, (), W<N>, ()>)>, Equiv<W<N>, (), W<N>, ()>)> {
+pub fn demo_proof<let N: u32>() -> Equiv<W<(N * (N + 1))>, (Equiv<W<N>, (), W<N>, ()>, Equiv<W<(N * (N + 1))>, (Equiv<W<(N * (N + 1))>, (), W<N>, ()>, Equiv<W<(N * (N + 1))>, (), W<(N * (N + 1))>, ()>), W<N>, (Equiv<W<(N * (N + 1))>, (), W<(N * (N + 1))>, ()>, Equiv<W<(N * (N + 1))>, (), W<N>, ()>)>), W<N>, (Equiv<W<(N * (N + 1))>, (Equiv<W<(N * (N + 1))>, (), W<N>, ()>, Equiv<W<(N * (N + 1))>, (), W<(N * (N + 1))>, ()>), W<N>, (Equiv<W<(N * (N + 1))>, (), W<(N * (N + 1))>, ()>, Equiv<W<(N * (N + 1))>, (), W<N>, ()>)>, Equiv<W<N>, (), W<N>, ()>)> {
     let p1: Equiv<W<(N + 1) * N>, (), W<N * (N + 1)>, ()> = mul_comm();
     let p2: Equiv<W<N * (N + 1)>, (), W<N * N + N>, ()> = mul_add::<N, N, 1>();
     let p3_sub: Equiv<W<N>, (), W<N>, ()> = mul_one_r();
@@ -117,9 +119,12 @@ fn test_constant_folding<let N: u32>() {
 
     // N * C1 / C2 = N * (C1 / C2)
     let _: W<N * 10 / 2> = W::<N * 5> {};
-
+    // This case is invalid due to integer division
+    // If N does not divide evenly with 10 then we cannot simplify it.
+    // e.g. 15 / 10 * 2 = 2 versus 15 / 5 = 3
+    //
     // N / C1 * C2 = N / (C1 / C2)
-    let _: W<N / 10 * 2> = W::<N / 5> {};
+    // let _: W<N / 10 * 2> = W::<N / 5> {};
 }
 
 fn test_non_constant_folding<let N: u32, let M: u32>() {
@@ -131,7 +136,9 @@ fn test_non_constant_folding<let N: u32, let M: u32>() {
 
     // N * M / M = N
     let _: W<N * M / M> = W::<N> {};
-
+    // This case is not true due to integer division rounding!
+    // Consider 5 / 2 * 2 which should equal 4, not 5
+    //
     // N / M * M = N
-    let _: W<N / M * M> = W::<N> {};
+    // let _: W<N / M * M> = W::<N> {};
 }
diff --git a/test_programs/compile_success_empty/arithmetic_generics_move_constant_terms/src/main.nr b/test_programs/compile_success_empty/arithmetic_generics_move_constant_terms/src/main.nr
index e27d4baf1f4..4a9b1489d35 100644
--- a/test_programs/compile_success_empty/arithmetic_generics_move_constant_terms/src/main.nr
+++ b/test_programs/compile_success_empty/arithmetic_generics_move_constant_terms/src/main.nr
@@ -2,9 +2,12 @@ trait FromCallData<let N: u32, let M: u32> {
     fn from_calldata(calldata: [Field; N]) -> (Self, [Field; M]);
 }
 
-struct Point { x: Field, y: Field }
+struct Point {
+    x: Field,
+    y: Field,
+}
 
-impl <let N: u32> FromCallData<N, N - 1> for Field {
+impl<let N: u32> FromCallData<N, N - 1> for Field {
     fn from_calldata(calldata: [Field; N]) -> (Self, [Field; N - 1]) {
         let slice = calldata.as_slice();
         let (value, slice) = slice.pop_front();
@@ -12,7 +15,7 @@ impl <let N: u32> FromCallData<N, N - 1> for Field {
     }
 }
 
-impl <let N: u32> FromCallData<N, N - 2> for Point {
+impl<let N: u32> FromCallData<N, N - 2> for Point {
     fn from_calldata(calldata: [Field; N]) -> (Self, [Field; N - 2]) {
         let (x, calldata) = FromCallData::from_calldata(calldata);
         let (y, calldata) = FromCallData::from_calldata(calldata);
diff --git a/test_programs/compile_success_empty/assert_constant/src/main.nr b/test_programs/compile_success_empty/assert_constant/src/main.nr
index 6910a2d17b2..42d66f88137 100644
--- a/test_programs/compile_success_empty/assert_constant/src/main.nr
+++ b/test_programs/compile_success_empty/assert_constant/src/main.nr
@@ -1,13 +1,13 @@
 use std::static_assert;
 
-global GLOBAL_ONE = 1;
-global GLOBAL_TWO = 2;
-global GLOBAL_THREE = GLOBAL_ONE + GLOBAL_TWO;
+global GLOBAL_ONE: Field = 1;
+global GLOBAL_TWO: Field = 2;
+global GLOBAL_THREE: Field = GLOBAL_ONE + GLOBAL_TWO;
 
 // contents known at compile time
 // length known at compile time
-global GLOBAL_ARRAY_PAIR = [GLOBAL_ONE, GLOBAL_TWO];
-global GLOBAL_SLICE_PAIR = &[GLOBAL_ONE, GLOBAL_TWO];
+global GLOBAL_ARRAY_PAIR: [Field; 2] = [GLOBAL_ONE, GLOBAL_TWO];
+global GLOBAL_SLICE_PAIR: [Field] = &[GLOBAL_ONE, GLOBAL_TWO];
 
 struct Foo {
     field: Field,
@@ -17,7 +17,7 @@ struct Foo {
 
 fn main(
     dynamic_one: Field, // == 1
-    dynamic_two: Field // == 2
+    dynamic_two: Field, // == 2
 ) {
     // contents unknown at compile time
     // length known at compile time
diff --git a/test_programs/compile_success_empty/attribute_args/src/main.nr b/test_programs/compile_success_empty/attribute_args/src/main.nr
index 6178df5e749..29690ba36c7 100644
--- a/test_programs/compile_success_empty/attribute_args/src/main.nr
+++ b/test_programs/compile_success_empty/attribute_args/src/main.nr
@@ -1,7 +1,7 @@
 #[attr_with_args(1, 2)]
-#[varargs(1, 2)]
-#[varargs(1, 2, 3, 4)]
-struct Foo {}
+#[attr_with_varargs(1, 2)]
+#[attr_with_varargs(1, 2, 3, 4)]
+pub struct Foo {}
 
 comptime fn attr_with_args(s: StructDefinition, a: Field, b: Field) {
     // Ensure all variables are in scope.
@@ -12,7 +12,7 @@ comptime fn attr_with_args(s: StructDefinition, a: Field, b: Field) {
 }
 
 #[varargs]
-comptime fn varargs(s: StructDefinition, t: [Field]) {
+comptime fn attr_with_varargs(s: StructDefinition, t: [Field]) {
     let _ = s;
     for _ in t {}
     assert(t.len() < 5);
diff --git a/test_programs/compile_success_empty/attribute_order/Nargo.toml b/test_programs/compile_success_empty/attribute_order/Nargo.toml
new file mode 100644
index 00000000000..4471bed86dc
--- /dev/null
+++ b/test_programs/compile_success_empty/attribute_order/Nargo.toml
@@ -0,0 +1,7 @@
+[package]
+name = "attribute_order"
+type = "bin"
+authors = [""]
+compiler_version = ">=0.36.0"
+
+[dependencies]
\ No newline at end of file
diff --git a/test_programs/compile_success_empty/attribute_order/src/a.nr b/test_programs/compile_success_empty/attribute_order/src/a.nr
new file mode 100644
index 00000000000..663643f1288
--- /dev/null
+++ b/test_programs/compile_success_empty/attribute_order/src/a.nr
@@ -0,0 +1,13 @@
+// This is run fifth, after each child module finishes even though
+// the function comes before the module declarations in the source.
+#[crate::assert_run_order_function(4)]
+pub fn foo() {}
+
+mod a_child1;
+mod a_child2;
+
+#[crate::assert_run_order_struct(5)]
+pub struct Bar {}
+
+#[crate::assert_run_order_trait(6)]
+pub trait Foo {}
diff --git a/test_programs/compile_success_empty/attribute_order/src/a/a_child1.nr b/test_programs/compile_success_empty/attribute_order/src/a/a_child1.nr
new file mode 100644
index 00000000000..834bbd43fb5
--- /dev/null
+++ b/test_programs/compile_success_empty/attribute_order/src/a/a_child1.nr
@@ -0,0 +1,5 @@
+#[crate::assert_run_order_function(0)]
+pub fn foo() {}
+
+#[crate::assert_run_order_struct(1)]
+pub struct Foo {}
diff --git a/test_programs/compile_success_empty/attribute_order/src/a/a_child2.nr b/test_programs/compile_success_empty/attribute_order/src/a/a_child2.nr
new file mode 100644
index 00000000000..3548f4450a5
--- /dev/null
+++ b/test_programs/compile_success_empty/attribute_order/src/a/a_child2.nr
@@ -0,0 +1,5 @@
+#[crate::assert_run_order_trait(2)]
+pub trait Foo {}
+
+#[crate::assert_run_order_function(3)]
+pub fn foo() {}
diff --git a/test_programs/compile_success_empty/attribute_order/src/b/b_child1.nr b/test_programs/compile_success_empty/attribute_order/src/b/b_child1.nr
new file mode 100644
index 00000000000..a8e7e898ec1
--- /dev/null
+++ b/test_programs/compile_success_empty/attribute_order/src/b/b_child1.nr
@@ -0,0 +1,4 @@
+#[crate::assert_run_order_function(8)]
+pub fn foo() {}
+
+#![crate::assert_run_order_module(9)]
diff --git a/test_programs/compile_success_empty/attribute_order/src/b/b_child2.nr b/test_programs/compile_success_empty/attribute_order/src/b/b_child2.nr
new file mode 100644
index 00000000000..8e6d967707a
--- /dev/null
+++ b/test_programs/compile_success_empty/attribute_order/src/b/b_child2.nr
@@ -0,0 +1,2 @@
+#[crate::assert_run_order_function(7)]
+pub fn foo() {}
diff --git a/test_programs/compile_success_empty/attribute_order/src/b/mod.nr b/test_programs/compile_success_empty/attribute_order/src/b/mod.nr
new file mode 100644
index 00000000000..77df04e15a9
--- /dev/null
+++ b/test_programs/compile_success_empty/attribute_order/src/b/mod.nr
@@ -0,0 +1,25 @@
+// Declare these in reverse order to ensure the declaration
+// order here is respected
+mod b_child2;
+
+#[crate::assert_run_order_module(12)]
+mod b_child1;
+
+#[crate::assert_run_order_function(13)]
+pub fn foo() {}
+
+#![crate::assert_run_order_module(14)]
+
+// Test inline submodules as well
+#[crate::assert_run_order_module(15)]
+mod b_child3 {
+    #![crate::assert_run_order_module(10)]
+
+    #[crate::assert_run_order_function(11)]
+    pub fn foo() {}
+}
+
+#[crate::assert_run_order_function(16)]
+pub fn bar() {}
+
+#![crate::assert_run_order_module(17)]
diff --git a/test_programs/compile_success_empty/attribute_order/src/main.nr b/test_programs/compile_success_empty/attribute_order/src/main.nr
new file mode 100644
index 00000000000..9d5ba32b58e
--- /dev/null
+++ b/test_programs/compile_success_empty/attribute_order/src/main.nr
@@ -0,0 +1,29 @@
+mod a;
+mod b;
+
+#[assert_run_order_function(18)]
+fn main() {
+    assert_eq(attributes_run, 19);
+}
+
+comptime mut global attributes_run: Field = 0;
+
+pub comptime fn assert_run_order_function(_f: FunctionDefinition, order: Field) {
+    assert_eq(order, attributes_run);
+    attributes_run += 1;
+}
+
+pub comptime fn assert_run_order_struct(_s: StructDefinition, order: Field) {
+    assert_eq(order, attributes_run);
+    attributes_run += 1;
+}
+
+pub comptime fn assert_run_order_trait(_t: TraitDefinition, order: Field) {
+    assert_eq(order, attributes_run);
+    attributes_run += 1;
+}
+
+pub comptime fn assert_run_order_module(_m: Module, order: Field) {
+    assert_eq(order, attributes_run);
+    attributes_run += 1;
+}
diff --git a/test_programs/compile_success_empty/attribute_sees_result_of_previous_attribute/Nargo.toml b/test_programs/compile_success_empty/attribute_sees_result_of_previous_attribute/Nargo.toml
new file mode 100644
index 00000000000..ad71067a58f
--- /dev/null
+++ b/test_programs/compile_success_empty/attribute_sees_result_of_previous_attribute/Nargo.toml
@@ -0,0 +1,7 @@
+[package]
+name = "attribute_sees_results_of_previous_attribute"
+type = "bin"
+authors = [""]
+compiler_version = ">=0.34.0"
+
+[dependencies]
diff --git a/test_programs/compile_success_empty/attribute_sees_result_of_previous_attribute/src/main.nr b/test_programs/compile_success_empty/attribute_sees_result_of_previous_attribute/src/main.nr
new file mode 100644
index 00000000000..561c3e12e0c
--- /dev/null
+++ b/test_programs/compile_success_empty/attribute_sees_result_of_previous_attribute/src/main.nr
@@ -0,0 +1,11 @@
+#[derive(Eq)]
+pub struct Foo {}
+
+#[check_eq_derived_for_foo]
+fn main() {}
+
+comptime fn check_eq_derived_for_foo(_f: FunctionDefinition) {
+    let foo = quote {Foo}.as_type();
+    let eq = quote {Eq}.as_trait_constraint();
+    assert(foo.implements(eq));
+}
diff --git a/test_programs/compile_success_empty/attributes_multiple/src/main.nr b/test_programs/compile_success_empty/attributes_multiple/src/main.nr
index 581fb989b4c..aadfe5caf3c 100644
--- a/test_programs/compile_success_empty/attributes_multiple/src/main.nr
+++ b/test_programs/compile_success_empty/attributes_multiple/src/main.nr
@@ -2,6 +2,6 @@ fn main() {
     another_func()
 }
 
-#[aztec(private)]
-#[internal]
+#['aztec(private)]
+#['internal]
 fn another_func() {}
diff --git a/test_programs/compile_success_empty/attributes_struct/src/main.nr b/test_programs/compile_success_empty/attributes_struct/src/main.nr
index 669cfc32927..713e6321f4b 100644
--- a/test_programs/compile_success_empty/attributes_struct/src/main.nr
+++ b/test_programs/compile_success_empty/attributes_struct/src/main.nr
@@ -1,8 +1,8 @@
-#[some_attribute]
-#[another_attribute]
-struct SomeStruct {
+#['some_attribute]
+#['another_attribute]
+pub struct SomeStruct {
     a: Field,
-    b: Field
+    b: Field,
 }
 
 fn main() {}
@@ -11,9 +11,7 @@ fn main() {}
 
 #[abi(something)]
 #[add_attribute]
-struct Foo {
-
-}
+pub struct Foo {}
 
 comptime fn add_attribute(s: StructDefinition) {
     assert(!s.has_named_attribute("foo"));
diff --git a/test_programs/compile_success_empty/brillig_cast/src/main.nr b/test_programs/compile_success_empty/brillig_cast/src/main.nr
index f2bede99d4c..f1a6814f4e7 100644
--- a/test_programs/compile_success_empty/brillig_cast/src/main.nr
+++ b/test_programs/compile_success_empty/brillig_cast/src/main.nr
@@ -1,5 +1,5 @@
 // Tests a very simple Brillig function.
-// 
+//
 // The features being tested are cast operations on brillig
 fn main() {
     unsafe {
diff --git a/test_programs/compile_success_empty/brillig_modulo/src/main.nr b/test_programs/compile_success_empty/brillig_modulo/src/main.nr
index dff5eadcb55..2ad43bdb7eb 100644
--- a/test_programs/compile_success_empty/brillig_modulo/src/main.nr
+++ b/test_programs/compile_success_empty/brillig_modulo/src/main.nr
@@ -1,5 +1,5 @@
 // Tests a very simple program.
-// 
+//
 // The features being tested is modulo operations on brillig
 fn main() {
     unsafe {
diff --git a/test_programs/compile_success_empty/brillig_slice_input/src/main.nr b/test_programs/compile_success_empty/brillig_slice_input/src/main.nr
index 596f364b49f..436a939767e 100644
--- a/test_programs/compile_success_empty/brillig_slice_input/src/main.nr
+++ b/test_programs/compile_success_empty/brillig_slice_input/src/main.nr
@@ -15,31 +15,13 @@ unconstrained fn sum_slice(slice: [[Point; 2]]) -> Field {
 
 fn main() {
     let mut slice = &[];
-    slice = slice.push_back([
-        Point {
-            x: 13,
-            y: 14,
-        },
-        Point {
-            x: 20,
-            y: 8,
-        }
-    ]);
+    slice = slice.push_back([Point { x: 13, y: 14 }, Point { x: 20, y: 8 }]);
     unsafe {
         let brillig_sum = sum_slice(slice);
         assert_eq(brillig_sum, 55);
     }
 
-    slice = slice.push_back([
-        Point {
-            x: 15,
-            y: 5,
-        },
-        Point {
-            x: 12,
-            y: 13,
-        }
-    ]);
+    slice = slice.push_back([Point { x: 15, y: 5 }, Point { x: 12, y: 13 }]);
     unsafe {
         let brillig_sum = sum_slice(slice);
         assert_eq(brillig_sum, 100);
diff --git a/test_programs/compile_success_empty/checked_transmute/Nargo.toml b/test_programs/compile_success_empty/checked_transmute/Nargo.toml
new file mode 100644
index 00000000000..f3392ec79bb
--- /dev/null
+++ b/test_programs/compile_success_empty/checked_transmute/Nargo.toml
@@ -0,0 +1,7 @@
+[package]
+name = "checked_transmute"
+type = "bin"
+authors = [""]
+compiler_version = ">=0.35.0"
+
+[dependencies]
diff --git a/test_programs/compile_success_empty/checked_transmute/src/main.nr b/test_programs/compile_success_empty/checked_transmute/src/main.nr
new file mode 100644
index 00000000000..1acf07e98a8
--- /dev/null
+++ b/test_programs/compile_success_empty/checked_transmute/src/main.nr
@@ -0,0 +1,17 @@
+use std::mem::checked_transmute;
+
+fn main() {
+    // 1*(2 + 3) = 1*2 + 1*3 = 5
+    let _: [Field; 5] = distribute::<1, 2, 3>([1, 2, 3, 4, 5]);
+}
+
+pub fn distribute<let N: u32, let A: u32, let B: u32>(
+    x: [Field; N * (A + B)],
+) -> [Field; N * A + N * B] {
+    // asserts: [Field; N * (A + B)] = [Field; N * A + N * B]
+    //       -> N * A + B = N * A + N * B
+    //
+    // This assert occurs during monomorphization when the actual values for N, A, and B
+    // become known. This also means if this function is not called, the assert will not trigger.
+    checked_transmute(x)
+}
diff --git a/test_programs/compile_success_empty/comptime_apply_range_constraint/Nargo.toml b/test_programs/compile_success_empty/comptime_apply_range_constraint/Nargo.toml
new file mode 100644
index 00000000000..84d16060440
--- /dev/null
+++ b/test_programs/compile_success_empty/comptime_apply_range_constraint/Nargo.toml
@@ -0,0 +1,6 @@
+[package]
+name = "comptime_apply_range_constraint"
+type = "bin"
+authors = [""]
+
+[dependencies]
diff --git a/test_programs/compile_success_empty/comptime_apply_range_constraint/src/main.nr b/test_programs/compile_success_empty/comptime_apply_range_constraint/src/main.nr
new file mode 100644
index 00000000000..ff5e0ba9511
--- /dev/null
+++ b/test_programs/compile_success_empty/comptime_apply_range_constraint/src/main.nr
@@ -0,0 +1,5 @@
+fn main() {
+    comptime {
+        2.assert_max_bit_size::<8>()
+    }
+}
diff --git a/test_programs/compile_success_empty/comptime_array_len/src/main.nr b/test_programs/compile_success_empty/comptime_array_len/src/main.nr
index c98a3de01dd..283f3ea8d3e 100644
--- a/test_programs/compile_success_empty/comptime_array_len/src/main.nr
+++ b/test_programs/compile_success_empty/comptime_array_len/src/main.nr
@@ -1,6 +1,5 @@
 fn main() {
-    comptime
-    {
+    comptime {
         assert_eq([1, 2, 3].len(), 3);
     }
 }
diff --git a/test_programs/compile_success_empty/comptime_as_slice/src/main.nr b/test_programs/compile_success_empty/comptime_as_slice/src/main.nr
index 07c5e344cc2..bc3f649e52a 100644
--- a/test_programs/compile_success_empty/comptime_as_slice/src/main.nr
+++ b/test_programs/compile_success_empty/comptime_as_slice/src/main.nr
@@ -1,6 +1,5 @@
 fn main() {
-    comptime
-    {
+    comptime {
         let ws: [Field; 3] = [1; 3];
         let ws_as_slice: [Field] = ws.as_slice();
 
diff --git a/test_programs/compile_success_empty/comptime_change_type_each_iteration/src/main.nr b/test_programs/compile_success_empty/comptime_change_type_each_iteration/src/main.nr
index 7b34c112d4f..976987fec9e 100644
--- a/test_programs/compile_success_empty/comptime_change_type_each_iteration/src/main.nr
+++ b/test_programs/compile_success_empty/comptime_change_type_each_iteration/src/main.nr
@@ -1,6 +1,5 @@
 fn main() {
-    comptime
-    {
+    comptime {
         for i in 9..11 {
             // Lengths are different on each iteration:
             // foo9, foo10
diff --git a/test_programs/compile_success_empty/comptime_closures/src/main.nr b/test_programs/compile_success_empty/comptime_closures/src/main.nr
index 95f602e04bf..e8a0366a304 100644
--- a/test_programs/compile_success_empty/comptime_closures/src/main.nr
+++ b/test_programs/compile_success_empty/comptime_closures/src/main.nr
@@ -1,22 +1,15 @@
 fn main() {
-    comptime
-    {
+    comptime {
         closure_test(0);
     }
 }
 
 fn closure_test(mut x: Field) {
     let one = 1;
-    let add1 = |z| {
-        (|| {
-            *z += one;
-        })()
-    };
+    let add1 = |z| (|| { *z += one; })();
 
     let two = 2;
-    let add2 = |z| {
-        *z = *z + two;
-    };
+    let add2 = |z| { *z = *z + two; };
 
     add1(&mut x);
     assert(x == 1);
diff --git a/test_programs/compile_success_empty/comptime_derive_generators/Nargo.toml b/test_programs/compile_success_empty/comptime_derive_generators/Nargo.toml
new file mode 100644
index 00000000000..0bf7ca9d0f2
--- /dev/null
+++ b/test_programs/compile_success_empty/comptime_derive_generators/Nargo.toml
@@ -0,0 +1,7 @@
+[package]
+name = "comptime_derive_generators"
+type = "bin"
+authors = [""]
+compiler_version = ">=0.35.0"
+
+[dependencies]
\ No newline at end of file
diff --git a/test_programs/compile_success_empty/comptime_derive_generators/src/main.nr b/test_programs/compile_success_empty/comptime_derive_generators/src/main.nr
new file mode 100644
index 00000000000..b79ce9956c1
--- /dev/null
+++ b/test_programs/compile_success_empty/comptime_derive_generators/src/main.nr
@@ -0,0 +1,67 @@
+use std::embedded_curve_ops::EmbeddedCurvePoint;
+
+fn main() {
+    comptime {
+        // Result computed from executing `derive_generators` with non-comptime Noir
+        let result = [
+            EmbeddedCurvePoint {
+                x: 0x0224a8abc6c8b8d50373d64cd2a1ab1567bf372b3b1f7b861d7f01257052d383,
+                y: 0x2358629b90eafb299d6650a311e79914b0215eb0a790810b26da5a826726d711,
+                is_infinite: false,
+            },
+            EmbeddedCurvePoint {
+                x: 0x0f106f6d46bc904a5290542490b2f238775ff3c445b2f8f704c466655f460a2a,
+                y: 0x29ab84d472f1d33f42fe09c47b8f7710f01920d6155250126731e486877bcf27,
+                is_infinite: false,
+            },
+            EmbeddedCurvePoint {
+                x: 0x0298f2e42249f0519c8a8abd91567ebe016e480f219b8c19461d6a595cc33696,
+                y: 0x035bec4b8520a4ece27bd5aafabee3dfe1390d7439c419a8c55aceb207aac83b,
+                is_infinite: false,
+            },
+            EmbeddedCurvePoint {
+                x: 0x2c9628479de4181ea77e7b0913ccf41d2a74155b1d9c82eaa220c218781f6f3b,
+                y: 0x278f86b8fd95520b5da23bee1a5e354dc5dcb0cb43d6b76e628ddbffb101d776,
+                is_infinite: false,
+            },
+            EmbeddedCurvePoint {
+                x: 0x0be1916f382e3532aa53a766fe74b1a983784caab90290aea7bf616bc371fb41,
+                y: 0x0f65545005e896f14249956344faf9addd762b7573a487b58f805a361d920a20,
+                is_infinite: false,
+            },
+            EmbeddedCurvePoint {
+                x: 0x29ff8437ae5bec89981441b23036a22b7fd5bee9eff0e83c0dd5b87bfb5bd60e,
+                y: 0x1fd247352b77e2676b22db23cf7cd482474f543e3480b5a39c42f839a306be10,
+                is_infinite: false,
+            },
+            EmbeddedCurvePoint {
+                x: 0x2f3bd4e98f8c8458cd58888749f0f5e582a43565767398e08e50e94b9b19a4d9,
+                y: 0x1f534906d1aa8b4ba74ad9e3f85ae3f8295e51eaafd15b5d116801b96360205b,
+                is_infinite: false,
+            },
+            EmbeddedCurvePoint {
+                x: 0x27759098f425b76447c2c52728576803a1ac5de37bba875ac47cdcff539ab931,
+                y: 0x0aa47ee64d12d856cfb81b595c1d60ceecb693f0fdae644746ff333e39f61db7,
+                is_infinite: false,
+            },
+            EmbeddedCurvePoint {
+                x: 0x015ca8d68616fde86c9108e3db04f588e0f308e60d367e963b7d460fe9a65e6c,
+                y: 0x2cf918009dda942ac9d59903cd2d0294d8738f938b1394170d892a027d0f347b,
+                is_infinite: false,
+            },
+            EmbeddedCurvePoint {
+                x: 0x0d1783d5b256765515f3c9988df9f1ba7e6f5fb0248c8971fbc503ffd5187714,
+                y: 0x2ebb434ff4857fc3621f3bc3c6b8002b17d02d9c204e75f19b8f0b99ea68402c,
+                is_infinite: false,
+            },
+        ];
+
+        let generators: [EmbeddedCurvePoint; 10] =
+            std::hash::derive_generators("DEFAULT_DOMAIN_SEPARATOR".as_bytes(), 5);
+
+        for i in 0..10 {
+            assert(generators[i].x == result[i].x);
+            assert(generators[i].y == result[i].y);
+        }
+    }
+}
diff --git a/test_programs/compile_success_empty/comptime_fmt_strings/src/main.nr b/test_programs/compile_success_empty/comptime_fmt_strings/src/main.nr
index ca337c822d8..8cdd15aaa0e 100644
--- a/test_programs/compile_success_empty/comptime_fmt_strings/src/main.nr
+++ b/test_programs/compile_success_empty/comptime_fmt_strings/src/main.nr
@@ -6,7 +6,7 @@ fn main() {
 
         // Can't print these at compile-time here since printing to stdout while
         // compiling breaks the test runner.
-        let s1 = f"x is {x}, fake interpolation: \{y}, y is {y}";
+        let s1 = f"x is {x}, fake interpolation: {{y}}, y is {y}";
         let s2 = std::mem::zeroed::<fmtstr<4, ()>>();
         (s1, s2)
     };
diff --git a/test_programs/compile_success_empty/comptime_function_definition/src/main.nr b/test_programs/compile_success_empty/comptime_function_definition/src/main.nr
index 4266d3734f9..105c1e8d577 100644
--- a/test_programs/compile_success_empty/comptime_function_definition/src/main.nr
+++ b/test_programs/compile_success_empty/comptime_function_definition/src/main.nr
@@ -1,9 +1,18 @@
 use std::meta::type_of;
 
-struct Foo { x: Field, field: Field }
+pub struct Foo {
+    x: Field,
+    field: Field,
+}
 
 #[function_attr]
-pub fn foo(w: i32, y: Field, Foo { x, field: some_field }: Foo, mut a: bool, (b, c): (i32, i32)) -> i32 {
+pub fn foo(
+    w: i32,
+    y: Field,
+    Foo { x, field: some_field }: Foo,
+    mut a: bool,
+    (b, c): (i32, i32),
+) -> i32 {
     let _ = (w, y, x, some_field, a, b, c);
     1
 }
diff --git a/test_programs/compile_success_empty/comptime_global_using_trait/src/main.nr b/test_programs/compile_success_empty/comptime_global_using_trait/src/main.nr
index a1a2c4b125a..86bde1c5eba 100644
--- a/test_programs/compile_success_empty/comptime_global_using_trait/src/main.nr
+++ b/test_programs/compile_success_empty/comptime_global_using_trait/src/main.nr
@@ -1,3 +1,3 @@
-comptime global FOO: i32 = Default::default();
+pub comptime global FOO: i32 = Default::default();
 
 fn main() {}
diff --git a/test_programs/compile_success_empty/comptime_globals_regression/src/main.nr b/test_programs/compile_success_empty/comptime_globals_regression/src/main.nr
index 54dbc0413f0..45afef6d831 100644
--- a/test_programs/compile_success_empty/comptime_globals_regression/src/main.nr
+++ b/test_programs/compile_success_empty/comptime_globals_regression/src/main.nr
@@ -1,14 +1,8 @@
-comptime mut global COUNTER = 0;
+comptime mut global COUNTER: Field = 0;
 
 fn main() {
-    comptime
-    {
-        increment()
-    };
-    comptime
-    {
-        increment()
-    };
+    comptime { increment() };
+    comptime { increment() };
 
     assert_eq(get_counter(), 2);
 }
diff --git a/test_programs/compile_success_empty/comptime_keccak/src/main.nr b/test_programs/compile_success_empty/comptime_keccak/src/main.nr
index 3cde32b6ba9..dc4e88b7ab2 100644
--- a/test_programs/compile_success_empty/comptime_keccak/src/main.nr
+++ b/test_programs/compile_success_empty/comptime_keccak/src/main.nr
@@ -1,12 +1,13 @@
 // Tests a very simple program.
-// 
+//
 // The features being tested is keccak256 in brillig
 fn main() {
-    comptime
-    {
+    comptime {
         let x = 0xbd;
         let result = [
-            0x5a, 0x50, 0x2f, 0x9f, 0xca, 0x46, 0x7b, 0x26, 0x6d, 0x5b, 0x78, 0x33, 0x65, 0x19, 0x37, 0xe8, 0x05, 0x27, 0x0c, 0xa3, 0xf3, 0xaf, 0x1c, 0x0d, 0xd2, 0x46, 0x2d, 0xca, 0x4b, 0x3b, 0x1a, 0xbf
+            0x5a, 0x50, 0x2f, 0x9f, 0xca, 0x46, 0x7b, 0x26, 0x6d, 0x5b, 0x78, 0x33, 0x65, 0x19,
+            0x37, 0xe8, 0x05, 0x27, 0x0c, 0xa3, 0xf3, 0xaf, 0x1c, 0x0d, 0xd2, 0x46, 0x2d, 0xca,
+            0x4b, 0x3b, 0x1a, 0xbf,
         ];
         // We use the `as` keyword here to denote the fact that we want to take just the first byte from the x Field
         // The padding is taken care of by the program
diff --git a/test_programs/compile_success_empty/comptime_module/src/main.nr b/test_programs/compile_success_empty/comptime_module/src/main.nr
index 5099f3b7acb..20fd8053fbe 100644
--- a/test_programs/compile_success_empty/comptime_module/src/main.nr
+++ b/test_programs/compile_success_empty/comptime_module/src/main.nr
@@ -1,6 +1,6 @@
-#[outer_attribute]
+#['outer_attribute]
 mod foo {
-    #![some_attribute]
+    #!['some_attribute]
     pub fn x() {}
     pub fn y() {}
     pub fn z() {}
@@ -12,7 +12,7 @@ mod foo {
 
 contract bar {}
 
-#[some_attribute]
+#['some_attribute]
 mod another_module {}
 
 #[outer_attribute_func]
@@ -24,7 +24,7 @@ mod yet_another_module {
 #[outer_attribute_separate_module]
 mod separate_module;
 
-comptime mut global counter = 0;
+comptime mut global counter: u32 = 0;
 
 comptime fn increment_counter() {
     counter += 1;
@@ -47,7 +47,7 @@ comptime fn outer_attribute_separate_module(m: Module) {
     increment_counter();
 }
 
-struct Foo {}
+pub struct Foo {}
 
 #[add_function]
 mod add_to_me {
@@ -59,15 +59,14 @@ comptime fn add_function(m: Module) {
         quote { pub fn added_function() -> super::Foo {
             add_to_me_function();
             super::Foo {}
-    } }
+    } },
     );
 }
 
 fn main() {
     let _ = foo::Struct1 {};
 
-    comptime
-    {
+    comptime {
         // Check Module::is_contract
         let foo = quote { foo }.as_module().unwrap();
         assert(!foo.is_contract());
@@ -120,8 +119,7 @@ mod baz {
 
 #[test]
 fn as_module_test() {
-    comptime
-    {
+    comptime {
         let my_mod = quote { baz::qux }.as_module().unwrap();
         assert_eq(my_mod.name(), quote { qux });
     }
diff --git a/test_programs/compile_success_empty/comptime_mut_global/src/main.nr b/test_programs/compile_success_empty/comptime_mut_global/src/main.nr
index fa739289d37..111968a8a41 100644
--- a/test_programs/compile_success_empty/comptime_mut_global/src/main.nr
+++ b/test_programs/compile_success_empty/comptime_mut_global/src/main.nr
@@ -7,15 +7,13 @@ comptime fn get_unique_id() -> Field {
 }
 
 fn id1() -> Field {
-    comptime
-    {
+    comptime {
         get_unique_id()
     }
 }
 
 fn id2() -> Field {
-    comptime
-    {
+    comptime {
         get_unique_id()
     }
 }
diff --git a/test_programs/compile_success_empty/comptime_parse_statement_as_expression/src/main.nr b/test_programs/compile_success_empty/comptime_parse_statement_as_expression/src/main.nr
index 4fa47dbc2f7..50e88382737 100644
--- a/test_programs/compile_success_empty/comptime_parse_statement_as_expression/src/main.nr
+++ b/test_programs/compile_success_empty/comptime_parse_statement_as_expression/src/main.nr
@@ -1,27 +1,26 @@
 fn main() {
-    comptime
-    {
-        let block = quote[{
+    comptime {
+        let block = quote {{
             1;
             2;
             3
-        }];
+        }};
         let statements = block.as_expr().unwrap().as_block().unwrap();
         let last = statements.pop_back().1;
 
         // `3` should  fit in an expression position even though it is
         // originally a StatementKind::Expression
-        let regression1 = quote[{
+        let regression1 = quote {{
             let _ = $last;
-        }];
+        }};
         assert(regression1.as_expr().is_some());
 
         // `1;` should  fit in an expression position even though it is
         // originally a StatementKind::Semi
         let first = statements.pop_front().0;
-        let regression2 = quote[{
+        let regression2 = quote {{
             let _ = $first;
-        }];
+        }};
         assert(regression2.as_expr().is_some());
     }
 }
diff --git a/test_programs/compile_success_empty/comptime_slice_methods/src/main.nr b/test_programs/compile_success_empty/comptime_slice_methods/src/main.nr
index b76e8d70b83..8341669a0a4 100644
--- a/test_programs/compile_success_empty/comptime_slice_methods/src/main.nr
+++ b/test_programs/compile_success_empty/comptime_slice_methods/src/main.nr
@@ -1,6 +1,5 @@
 fn main() {
-    comptime
-    {
+    comptime {
         // Comptime scopes are counted as unconstrained
         assert(std::runtime::is_unconstrained());
 
diff --git a/test_programs/compile_success_empty/comptime_str_as_bytes/src/main.nr b/test_programs/compile_success_empty/comptime_str_as_bytes/src/main.nr
index eefea67100f..fe69f2205c7 100644
--- a/test_programs/compile_success_empty/comptime_str_as_bytes/src/main.nr
+++ b/test_programs/compile_success_empty/comptime_str_as_bytes/src/main.nr
@@ -1,8 +1,8 @@
 fn main() {
-    comptime
-    {
+    comptime {
         let hello_world_string = "hello world";
-        let hello_world_bytes: [u8; 11] = [0x68, 0x65, 0x6c, 0x6c, 0x6f, 0x20, 0x77, 0x6f, 0x72, 0x6c, 0x64];
+        let hello_world_bytes: [u8; 11] =
+            [0x68, 0x65, 0x6c, 0x6c, 0x6f, 0x20, 0x77, 0x6f, 0x72, 0x6c, 0x64];
 
         assert_eq(hello_world_string.as_bytes(), hello_world_bytes);
     }
diff --git a/test_programs/compile_success_empty/comptime_struct_definition/src/main.nr b/test_programs/compile_success_empty/comptime_struct_definition/src/main.nr
index da2871a253d..686ac26025d 100644
--- a/test_programs/compile_success_empty/comptime_struct_definition/src/main.nr
+++ b/test_programs/compile_success_empty/comptime_struct_definition/src/main.nr
@@ -1,11 +1,11 @@
 #[my_comptime_fn]
-struct MyType<A, B, C> {
+pub struct MyType<A, B, C> {
     field1: [A; 10],
     field2: (B, C),
 }
 
 #[mutate_struct_fields]
-struct I32AndField {
+pub struct I32AndField {
     z: i8,
 }
 
@@ -17,23 +17,20 @@ comptime fn my_comptime_fn(typ: StructDefinition) {
 }
 
 comptime fn mutate_struct_fields(s: StructDefinition) {
-    let fields = &[
-        (quote[x], quote[i32].as_type()),
-        (quote[y], quote[Field].as_type())
-    ];
+    let fields = &[(quote {x}, quote {i32}.as_type()), (quote {y}, quote {Field}.as_type())];
     s.set_fields(fields);
 }
 
 mod foo {
     #[attr]
-    struct Foo {}
+    pub struct Foo {}
 
     comptime fn attr(s: StructDefinition) {
         assert_eq(s.module().name(), quote { foo });
     }
 
     #[add_generic]
-    struct Bar {}
+    pub struct Bar {}
 
     // docs:start:add-generic-example
     comptime fn add_generic(s: StructDefinition) {
diff --git a/test_programs/compile_success_empty/comptime_to_radix/src/main.nr b/test_programs/compile_success_empty/comptime_to_radix/src/main.nr
index 959a7c12007..2233436a46c 100644
--- a/test_programs/compile_success_empty/comptime_to_radix/src/main.nr
+++ b/test_programs/compile_success_empty/comptime_to_radix/src/main.nr
@@ -1,6 +1,5 @@
 fn main() {
-    comptime
-    {
+    comptime {
         let le_bytes: [u8; 3] = 257.to_le_bytes();
         assert_eq(le_bytes, [1, 1, 0]);
 
diff --git a/test_programs/compile_success_empty/comptime_trait_constraint/src/main.nr b/test_programs/compile_success_empty/comptime_trait_constraint/src/main.nr
index 448da96a460..2f24675e8c7 100644
--- a/test_programs/compile_success_empty/comptime_trait_constraint/src/main.nr
+++ b/test_programs/compile_success_empty/comptime_trait_constraint/src/main.nr
@@ -1,12 +1,11 @@
-use std::hash::{Hash, Hasher};
+use std::hash::Hasher;
 
 trait TraitWithGenerics<A, B> {
     fn foo(self) -> (A, B);
 }
 
 fn main() {
-    comptime
-    {
+    comptime {
         let constraint1 = quote { Default }.as_trait_constraint();
         let constraint2 = quote { TraitWithGenerics<Field, u32> }.as_trait_constraint();
 
diff --git a/test_programs/compile_success_empty/comptime_trait_impl/src/main.nr b/test_programs/compile_success_empty/comptime_trait_impl/src/main.nr
index 87b48e7a357..598f04c5d3d 100644
--- a/test_programs/compile_success_empty/comptime_trait_impl/src/main.nr
+++ b/test_programs/compile_success_empty/comptime_trait_impl/src/main.nr
@@ -1,19 +1,14 @@
-use std::meta::type_of;
-
 trait SomeTrait<X, Y> {
     fn foo();
 }
-struct SomeStruct {
-
-}
+pub struct SomeStruct {}
 
 impl SomeTrait<i32, i64> for SomeStruct {
     fn foo() {}
 }
 
 fn main() {
-    comptime
-    {
+    comptime {
         let some_struct = quote { SomeStruct }.as_type();
         let some_trait = quote { SomeTrait<i32, i64> }.as_trait_constraint();
         let trait_impl = some_struct.get_trait_impl(some_trait).unwrap();
diff --git a/test_programs/compile_success_empty/comptime_traits/src/main.nr b/test_programs/compile_success_empty/comptime_traits/src/main.nr
index 7d1e116dd0c..11025d45024 100644
--- a/test_programs/compile_success_empty/comptime_traits/src/main.nr
+++ b/test_programs/compile_success_empty/comptime_traits/src/main.nr
@@ -1,8 +1,7 @@
 use std::ops::Neg;
 
 fn main() {
-    comptime
-    {
+    comptime {
         // impl Eq for Field
         assert(3 == 3);
 
@@ -26,9 +25,8 @@ impl Neg for MyType {
     }
 }
 
-fn neg_at_comptime() {
-    comptime
-    {
+pub fn neg_at_comptime() {
+    comptime {
         let value = MyType { value: 1 };
         let _result = -value;
     }
diff --git a/test_programs/compile_success_empty/comptime_type/src/main.nr b/test_programs/compile_success_empty/comptime_type/src/main.nr
index c7b3d0b9400..887690cb6cb 100644
--- a/test_programs/compile_success_empty/comptime_type/src/main.nr
+++ b/test_programs/compile_success_empty/comptime_type/src/main.nr
@@ -1,21 +1,15 @@
 use std::meta::type_of;
 
 struct Foo<T> {
-    x: T
+    x: T,
 }
 
-trait SomeTrait<T> {
-
-}
-struct StructImplementsSomeTrait {
-
-}
+trait SomeTrait<T> {}
+pub struct StructImplementsSomeTrait {}
 
 impl SomeTrait<i32> for StructImplementsSomeTrait {}
 
-struct StructDoesNotImplementSomeTrait {
-
-}
+pub struct StructDoesNotImplementSomeTrait {}
 
 // docs:start:serialize-setup
 trait Serialize<let N: u32> {}
@@ -23,15 +17,19 @@ trait Serialize<let N: u32> {}
 impl Serialize<1> for Field {}
 
 impl<T, let N: u32, let M: u32> Serialize<N * M> for [T; N]
-    where T: Serialize<M> {}
+where
+    T: Serialize<M>,
+{}
 
 impl<T, U, let N: u32, let M: u32> Serialize<N + M> for (T, U)
-    where T: Serialize<N>, U: Serialize<M> {}
+where
+    T: Serialize<N>,
+    U: Serialize<M>,
+{}
 // docs:end:serialize-setup
 
 fn main() {
-    comptime
-    {
+    comptime {
         // Check type_of works correctly (relies on Eq for Type)
         let a_field = 0;
         let another_field = 1;
@@ -82,7 +80,7 @@ fn main() {
 
         let array = [1, 2, 3];
         let array_type = type_of(array);
-        let (array_type_element_type , array_length) = array_type.as_array().unwrap();
+        let (array_type_element_type, array_length) = array_type.as_array().unwrap();
         assert_eq(array_type_element_type, field_type_1);
 
         // Check Type::as_constant
@@ -111,7 +109,8 @@ fn main() {
         // Check Type::implements
         let some_trait_i32 = quote { SomeTrait<i32> }.as_trait_constraint();
         let struct_implements_some_trait = quote { StructImplementsSomeTrait }.as_type();
-        let struct_does_not_implement_some_trait = quote { StructDoesNotImplementSomeTrait }.as_type();
+        let struct_does_not_implement_some_trait =
+            quote { StructDoesNotImplementSomeTrait }.as_type();
         assert(struct_implements_some_trait.implements(some_trait_i32));
         assert(!struct_does_not_implement_some_trait.implements(some_trait_i32));
 
@@ -148,13 +147,22 @@ fn main() {
         // Now typevar2 should be bound to the serialized pair size 2 times the array length 5
         assert_eq(typevar2.as_constant().unwrap(), 10);
         // docs:end:fresh-type-variable-example
+        // Check Type::is_unit
+        let unit = quote { () }.as_type();
+        assert(unit.is_unit());
+
+        // Check Type::as_mutable_reference
+        let typ = quote { &mut Field }.as_type();
+        assert_eq(typ.as_mutable_reference().unwrap(), quote { Field }.as_type());
     }
 }
 
 // docs:start:implements_example
-fn function_with_where<T>(_x: T) where T: SomeTrait<i32> {
-    comptime
-    {
+pub fn function_with_where<T>(_x: T)
+where
+    T: SomeTrait<i32>,
+{
+    comptime {
         let t = quote { T }.as_type();
         let some_trait_i32 = quote { SomeTrait<i32> }.as_trait_constraint();
         assert(t.implements(some_trait_i32));
diff --git a/test_programs/compile_success_empty/comptime_typed_expr/src/main.nr b/test_programs/compile_success_empty/comptime_typed_expr/src/main.nr
index ba2594f1da9..361f6e8a1c8 100644
--- a/test_programs/compile_success_empty/comptime_typed_expr/src/main.nr
+++ b/test_programs/compile_success_empty/comptime_typed_expr/src/main.nr
@@ -1,6 +1,5 @@
 fn main() {
-    comptime
-    {
+    comptime {
         let expr = quote { [1, 3] }.as_expr().unwrap().resolve(Option::none());
         assert_eq(expr.get_type().unwrap(), quote { [Field; 2] }.as_type());
     }
diff --git a/test_programs/compile_success_empty/comptime_unresolved_type/Nargo.toml b/test_programs/compile_success_empty/comptime_unresolved_type/Nargo.toml
new file mode 100644
index 00000000000..cc266b9b9c5
--- /dev/null
+++ b/test_programs/compile_success_empty/comptime_unresolved_type/Nargo.toml
@@ -0,0 +1,7 @@
+[package]
+name = "comptime_unresolved_type"
+type = "bin"
+authors = [""]
+compiler_version = ">=0.31.0"
+
+[dependencies]
\ No newline at end of file
diff --git a/test_programs/compile_success_empty/comptime_unresolved_type/src/main.nr b/test_programs/compile_success_empty/comptime_unresolved_type/src/main.nr
new file mode 100644
index 00000000000..e3a5f7ad4ca
--- /dev/null
+++ b/test_programs/compile_success_empty/comptime_unresolved_type/src/main.nr
@@ -0,0 +1,23 @@
+fn main() {
+    comptime {
+        // Check UnresolvedType::is_bool
+        let typ = quote { x as bool }.as_expr().unwrap().as_cast().unwrap().1;
+        assert(typ.is_bool());
+
+        // Check UnresolvedType::is_field
+        let typ = quote { x as Field }.as_expr().unwrap().as_cast().unwrap().1;
+        assert(typ.is_field());
+
+        // Check UnresolvedType::is_unit
+        let typ = quote { x as () }.as_expr().unwrap().as_cast().unwrap().1;
+        assert(typ.is_unit());
+
+        // Check UnresolvedType::as_mutable_reference
+        let typ = quote { x as &mut Field }.as_expr().unwrap().as_cast().unwrap().1;
+        assert(typ.as_mutable_reference().unwrap().is_field());
+
+        // Check UnresolvedType::as_slice
+        let typ = quote { x as [Field] }.as_expr().unwrap().as_cast().unwrap().1;
+        assert(typ.as_slice().unwrap().is_field());
+    }
+}
diff --git a/test_programs/compile_success_empty/conditional_regression_579/src/main.nr b/test_programs/compile_success_empty/conditional_regression_579/src/main.nr
index a517f4fdb70..758c6fefc28 100644
--- a/test_programs/compile_success_empty/conditional_regression_579/src/main.nr
+++ b/test_programs/compile_success_empty/conditional_regression_579/src/main.nr
@@ -7,7 +7,7 @@ fn main() {
 }
 
 struct MyStruct579 {
-    array_param: [u32; 2]
+    array_param: [u32; 2],
 }
 
 impl MyStruct579 {
@@ -20,7 +20,7 @@ fn test(flag: bool) -> MyStruct579 {
     let mut my_struct = MyStruct579::new([0; 2]);
 
     if flag == true {
-        my_struct=  MyStruct579::new([1; 2]);
+        my_struct = MyStruct579::new([1; 2]);
     }
     my_struct
 }
diff --git a/test_programs/compile_success_empty/conditional_regression_to_bits/src/main.nr b/test_programs/compile_success_empty/conditional_regression_to_bits/src/main.nr
index 5205e2bff73..dd80d2c576f 100644
--- a/test_programs/compile_success_empty/conditional_regression_to_bits/src/main.nr
+++ b/test_programs/compile_success_empty/conditional_regression_to_bits/src/main.nr
@@ -1,5 +1,5 @@
 fn main() {
-    //Regression for to_le_bits() constant evaluation 
+    //Regression for to_le_bits() constant evaluation
     // binary array representation of u8 1
     let arr: [u8; 2] = [1, 2];
     let as_bits_hardcode_1 = [1, 0];
diff --git a/test_programs/compile_success_empty/ctstring/src/main.nr b/test_programs/compile_success_empty/ctstring/src/main.nr
index b2329cb1997..61cd848a436 100644
--- a/test_programs/compile_success_empty/ctstring/src/main.nr
+++ b/test_programs/compile_success_empty/ctstring/src/main.nr
@@ -1,6 +1,5 @@
 fn main() {
-    comptime
-    {
+    comptime {
         let msg1 = "msg1";
         let msg2 = f" (msg2 contains {msg1}) ";
 
diff --git a/test_programs/compile_success_empty/derive_impl/src/main.nr b/test_programs/compile_success_empty/derive_impl/src/main.nr
index 69cb641e7c7..4396169235d 100644
--- a/test_programs/compile_success_empty/derive_impl/src/main.nr
+++ b/test_programs/compile_success_empty/derive_impl/src/main.nr
@@ -1,7 +1,9 @@
 comptime fn derive_default(typ: StructDefinition) -> Quoted {
     let generics = typ.generics();
     assert_eq(
-        generics.len(), 0, "derive_default: Deriving Default on generic types is currently unimplemented"
+        generics.len(),
+        0,
+        "derive_default: Deriving Default on generic types is currently unimplemented",
     );
 
     let type_name = typ.as_type();
@@ -18,15 +20,17 @@ comptime fn derive_default(typ: StructDefinition) -> Quoted {
     }
 }
 
+// Bar needs to be defined before Foo so that its impls are defined before
+// Foo's are.
+#[derive_default]
+struct Bar {}
+
 #[derive_default]
 struct Foo {
     x: Field,
     y: Bar,
 }
 
-#[derive_default]
-struct Bar {}
-
 comptime fn make_field_exprs(fields: [(Quoted, Type)]) -> [Quoted] {
     let mut result = &[];
     for my_field in fields {
diff --git a/test_programs/compile_success_empty/ec_baby_jubjub/Nargo.toml b/test_programs/compile_success_empty/ec_baby_jubjub/Nargo.toml
deleted file mode 100644
index fdb0df17112..00000000000
--- a/test_programs/compile_success_empty/ec_baby_jubjub/Nargo.toml
+++ /dev/null
@@ -1,7 +0,0 @@
-[package]
-name = "ec_baby_jubjub"
-description = "Baby Jubjub sanity checks"
-type = "bin"
-authors = [""]
-
-[dependencies]
diff --git a/test_programs/compile_success_empty/ec_baby_jubjub/src/main.nr b/test_programs/compile_success_empty/ec_baby_jubjub/src/main.nr
deleted file mode 100644
index 616ac7ef6ee..00000000000
--- a/test_programs/compile_success_empty/ec_baby_jubjub/src/main.nr
+++ /dev/null
@@ -1,219 +0,0 @@
-// Tests may be checked against https://github.com/cfrg/draft-irtf-cfrg-hash-to-curve/tree/main/poc
-use std::ec::tecurve::affine::Curve as AffineCurve;
-use std::ec::tecurve::affine::Point as Gaffine;
-use std::ec::tecurve::curvegroup::Curve;
-use std::ec::tecurve::curvegroup::Point as G;
-
-use std::ec::swcurve::affine::Point as SWGaffine;
-use std::ec::swcurve::curvegroup::Point as SWG;
-
-use std::ec::montcurve::affine::Point as MGaffine;
-use std::ec::montcurve::curvegroup::Point as MG;
-use std::compat;
-
-fn main() {
-    // This test only makes sense if Field is the right prime field.
-    if compat::is_bn254() {
-        // Define Baby Jubjub (ERC-2494) parameters in affine representation
-        let bjj_affine = AffineCurve::new(
-            168700,
-            168696,
-            Gaffine::new(
-                995203441582195749578291179787384436505546430278305826713579947235728471134,
-                5472060717959818805561601436314318772137091100104008585924551046643952123905
-            )
-        );
-        // Test addition
-        let p1_affine = Gaffine::new(
-            17777552123799933955779906779655732241715742912184938656739573121738514868268,
-            2626589144620713026669568689430873010625803728049924121243784502389097019475
-        );
-        let p2_affine = Gaffine::new(
-            16540640123574156134436876038791482806971768689494387082833631921987005038935,
-            20819045374670962167435360035096875258406992893633759881276124905556507972311
-        );
-
-        let p3_affine = bjj_affine.add(p1_affine, p2_affine);
-        assert(
-            p3_affine.eq(
-                Gaffine::new(
-                    7916061937171219682591368294088513039687205273691143098332585753343424131937,
-                    14035240266687799601661095864649209771790948434046947201833777492504781204499
-                )
-            )
-        );
-        // Test scalar multiplication
-        let p4_affine = bjj_affine.mul(2, p1_affine);
-        assert(
-            p4_affine.eq(
-                Gaffine::new(
-                    6890855772600357754907169075114257697580319025794532037257385534741338397365,
-                    4338620300185947561074059802482547481416142213883829469920100239455078257889
-                )
-            )
-        );
-        assert(p4_affine.eq(bjj_affine.bit_mul([0, 1], p1_affine)));
-        // Test subtraction
-        let p5_affine = bjj_affine.subtract(p3_affine, p3_affine);
-        assert(p5_affine.eq(Gaffine::zero()));
-        // Check that these points are on the curve
-        assert(
-            bjj_affine.contains(bjj_affine.gen)
-            & bjj_affine.contains(p1_affine)
-            & bjj_affine.contains(p2_affine)
-            & bjj_affine.contains(p3_affine)
-            & bjj_affine.contains(p4_affine)
-            & bjj_affine.contains(p5_affine)
-        );
-        // Test CurveGroup equivalents
-        let bjj = bjj_affine.into_group(); // Baby Jubjub
-        let p1 = p1_affine.into_group();
-        let p2 = p2_affine.into_group();
-        let p3 = p3_affine.into_group();
-        let p4 = p4_affine.into_group();
-        let p5 = p5_affine.into_group();
-        // Test addition
-        assert(p3.eq(bjj.add(p1, p2)));
-        // Test scalar multiplication
-        assert(p4.eq(bjj.mul(2, p1)));
-        assert(p4.eq(bjj.bit_mul([0, 1], p1)));
-        // Test subtraction
-        assert(G::zero().eq(bjj.subtract(p3, p3)));
-        assert(p5.eq(G::zero()));
-        // Check that these points are on the curve
-        assert(
-            bjj.contains(bjj.gen)
-            & bjj.contains(p1)
-            & bjj.contains(p2)
-            & bjj.contains(p3)
-            & bjj.contains(p4)
-            & bjj.contains(p5)
-        );
-        // Test SWCurve equivalents of the above
-        // First the affine representation
-        let bjj_swcurve_affine = bjj_affine.into_swcurve();
-
-        let p1_swcurve_affine = bjj_affine.map_into_swcurve(p1_affine);
-        let p2_swcurve_affine = bjj_affine.map_into_swcurve(p2_affine);
-        let p3_swcurve_affine = bjj_affine.map_into_swcurve(p3_affine);
-        let p4_swcurve_affine = bjj_affine.map_into_swcurve(p4_affine);
-        let p5_swcurve_affine = bjj_affine.map_into_swcurve(p5_affine);
-        // Addition
-        assert(p3_swcurve_affine.eq(bjj_swcurve_affine.add(p1_swcurve_affine, p2_swcurve_affine)));
-        // Doubling
-        assert(p4_swcurve_affine.eq(bjj_swcurve_affine.mul(2, p1_swcurve_affine)));
-        assert(p4_swcurve_affine.eq(bjj_swcurve_affine.bit_mul([0, 1], p1_swcurve_affine)));
-        // Subtraction
-        assert(SWGaffine::zero().eq(bjj_swcurve_affine.subtract(p3_swcurve_affine, p3_swcurve_affine)));
-        assert(p5_swcurve_affine.eq(SWGaffine::zero()));
-        // Check that these points are on the curve
-        assert(
-            bjj_swcurve_affine.contains(bjj_swcurve_affine.gen)
-            & bjj_swcurve_affine.contains(p1_swcurve_affine)
-            & bjj_swcurve_affine.contains(p2_swcurve_affine)
-            & bjj_swcurve_affine.contains(p3_swcurve_affine)
-            & bjj_swcurve_affine.contains(p4_swcurve_affine)
-            & bjj_swcurve_affine.contains(p5_swcurve_affine)
-        );
-        // Then the CurveGroup representation
-        let bjj_swcurve = bjj.into_swcurve();
-
-        let p1_swcurve = bjj.map_into_swcurve(p1);
-        let p2_swcurve = bjj.map_into_swcurve(p2);
-        let p3_swcurve = bjj.map_into_swcurve(p3);
-        let p4_swcurve = bjj.map_into_swcurve(p4);
-        let p5_swcurve = bjj.map_into_swcurve(p5);
-        // Addition
-        assert(p3_swcurve.eq(bjj_swcurve.add(p1_swcurve, p2_swcurve)));
-        // Doubling
-        assert(p4_swcurve.eq(bjj_swcurve.mul(2, p1_swcurve)));
-        assert(p4_swcurve.eq(bjj_swcurve.bit_mul([0, 1], p1_swcurve)));
-        // Subtraction
-        assert(SWG::zero().eq(bjj_swcurve.subtract(p3_swcurve, p3_swcurve)));
-        assert(p5_swcurve.eq(SWG::zero()));
-        // Check that these points are on the curve
-        assert(
-            bjj_swcurve.contains(bjj_swcurve.gen)
-            & bjj_swcurve.contains(p1_swcurve)
-            & bjj_swcurve.contains(p2_swcurve)
-            & bjj_swcurve.contains(p3_swcurve)
-            & bjj_swcurve.contains(p4_swcurve)
-            & bjj_swcurve.contains(p5_swcurve)
-        );
-        // Test MontCurve conversions
-        // First the affine representation
-        let bjj_montcurve_affine = bjj_affine.into_montcurve();
-
-        let p1_montcurve_affine = p1_affine.into_montcurve();
-        let p2_montcurve_affine = p2_affine.into_montcurve();
-        let p3_montcurve_affine = p3_affine.into_montcurve();
-        let p4_montcurve_affine = p4_affine.into_montcurve();
-        let p5_montcurve_affine = p5_affine.into_montcurve();
-        // Addition
-        assert(p3_montcurve_affine.eq(bjj_montcurve_affine.add(p1_montcurve_affine, p2_montcurve_affine)));
-        // Doubling
-        assert(p4_montcurve_affine.eq(bjj_montcurve_affine.mul(2, p1_montcurve_affine)));
-        assert(p4_montcurve_affine.eq(bjj_montcurve_affine.bit_mul([0, 1], p1_montcurve_affine)));
-        // Subtraction
-        assert(MGaffine::zero().eq(bjj_montcurve_affine.subtract(p3_montcurve_affine, p3_montcurve_affine)));
-        assert(p5_montcurve_affine.eq(MGaffine::zero()));
-        // Check that these points are on the curve
-        assert(
-            bjj_montcurve_affine.contains(bjj_montcurve_affine.gen)
-            & bjj_montcurve_affine.contains(p1_montcurve_affine)
-            & bjj_montcurve_affine.contains(p2_montcurve_affine)
-            & bjj_montcurve_affine.contains(p3_montcurve_affine)
-            & bjj_montcurve_affine.contains(p4_montcurve_affine)
-            & bjj_montcurve_affine.contains(p5_montcurve_affine)
-        );
-        // Then the CurveGroup representation
-        let bjj_montcurve = bjj.into_montcurve();
-
-        let p1_montcurve = p1_montcurve_affine.into_group();
-        let p2_montcurve = p2_montcurve_affine.into_group();
-        let p3_montcurve = p3_montcurve_affine.into_group();
-        let p4_montcurve = p4_montcurve_affine.into_group();
-        let p5_montcurve = p5_montcurve_affine.into_group();
-        // Addition
-        assert(p3_montcurve.eq(bjj_montcurve.add(p1_montcurve, p2_montcurve)));
-        // Doubling
-        assert(p4_montcurve.eq(bjj_montcurve.mul(2, p1_montcurve)));
-        assert(p4_montcurve.eq(bjj_montcurve.bit_mul([0, 1], p1_montcurve)));
-        // Subtraction
-        assert(MG::zero().eq(bjj_montcurve.subtract(p3_montcurve, p3_montcurve)));
-        assert(p5_montcurve.eq(MG::zero()));
-        // Check that these points are on the curve
-        assert(
-            bjj_montcurve.contains(bjj_montcurve.gen)
-            & bjj_montcurve.contains(p1_montcurve)
-            & bjj_montcurve.contains(p2_montcurve)
-            & bjj_montcurve.contains(p3_montcurve)
-            & bjj_montcurve.contains(p4_montcurve)
-            & bjj_montcurve.contains(p5_montcurve)
-        );
-        // Elligator 2 map-to-curve
-        let ell2_pt_map = bjj_affine.elligator2_map(27);
-
-        assert(
-            ell2_pt_map.eq(
-                MGaffine::new(
-                    7972459279704486422145701269802978968072470631857513331988813812334797879121,
-                    8142420778878030219043334189293412482212146646099536952861607542822144507872
-                ).into_tecurve()
-            )
-        );
-        // SWU map-to-curve
-        let swu_pt_map = bjj_affine.swu_map(5, 27);
-
-        assert(
-            swu_pt_map.eq(
-                bjj_affine.map_from_swcurve(
-                    SWGaffine::new(
-                        2162719247815120009132293839392097468339661471129795280520343931405114293888,
-                        5341392251743377373758788728206293080122949448990104760111875914082289313973
-                    )
-                )
-            )
-        );
-    }
-}
diff --git a/test_programs/compile_success_empty/embedded_curve_add_simplification/src/main.nr b/test_programs/compile_success_empty/embedded_curve_add_simplification/src/main.nr
index 39992a6454b..8984bd54979 100644
--- a/test_programs/compile_success_empty/embedded_curve_add_simplification/src/main.nr
+++ b/test_programs/compile_success_empty/embedded_curve_add_simplification/src/main.nr
@@ -1,8 +1,12 @@
-use std::embedded_curve_ops::{EmbeddedCurvePoint, EmbeddedCurveScalar, multi_scalar_mul};
+use std::embedded_curve_ops::EmbeddedCurvePoint;
 
 fn main() {
     let zero = EmbeddedCurvePoint::point_at_infinity();
-    let g1 = EmbeddedCurvePoint { x: 1, y: 17631683881184975370165255887551781615748388533673675138860, is_infinite: false };
+    let g1 = EmbeddedCurvePoint {
+        x: 1,
+        y: 17631683881184975370165255887551781615748388533673675138860,
+        is_infinite: false,
+    };
 
     assert(g1 + zero == g1);
     assert(g1 - g1 == zero);
diff --git a/test_programs/compile_success_empty/embedded_curve_msm_simplification/Nargo.toml b/test_programs/compile_success_empty/embedded_curve_msm_simplification/Nargo.toml
new file mode 100644
index 00000000000..9c9bd8de04a
--- /dev/null
+++ b/test_programs/compile_success_empty/embedded_curve_msm_simplification/Nargo.toml
@@ -0,0 +1,6 @@
+[package]
+name = "embedded_curve_msm_simplification"
+type = "bin"
+authors = [""]
+
+[dependencies]
diff --git a/test_programs/compile_success_empty/embedded_curve_msm_simplification/src/main.nr b/test_programs/compile_success_empty/embedded_curve_msm_simplification/src/main.nr
new file mode 100644
index 00000000000..e5aaa0f4d15
--- /dev/null
+++ b/test_programs/compile_success_empty/embedded_curve_msm_simplification/src/main.nr
@@ -0,0 +1,12 @@
+fn main() {
+    let pub_x = 0x0000000000000000000000000000000000000000000000000000000000000001;
+    let pub_y = 0x0000000000000002cf135e7506a45d632d270d45f1181294833fc48d823f272c;
+
+    let g1_y = 17631683881184975370165255887551781615748388533673675138860;
+    let g1 = std::embedded_curve_ops::EmbeddedCurvePoint { x: 1, y: g1_y, is_infinite: false };
+    let scalar = std::embedded_curve_ops::EmbeddedCurveScalar { lo: 1, hi: 0 };
+    // Test that multi_scalar_mul correctly derives the public key
+    let res = std::embedded_curve_ops::multi_scalar_mul([g1], [scalar]);
+    assert(res.x == pub_x);
+    assert(res.y == pub_y);
+}
diff --git a/test_programs/compile_success_empty/function_attribute/src/main.nr b/test_programs/compile_success_empty/function_attribute/src/main.nr
index ec22b730d3f..1bc524d4cb5 100644
--- a/test_programs/compile_success_empty/function_attribute/src/main.nr
+++ b/test_programs/compile_success_empty/function_attribute/src/main.nr
@@ -1,5 +1,5 @@
 #[function_attr]
-fn foo() {}
+pub fn foo() {}
 
 struct Foo {}
 
diff --git a/test_programs/compile_success_empty/generators/src/main.nr b/test_programs/compile_success_empty/generators/src/main.nr
index 20bdedee50f..58aebc92b72 100644
--- a/test_programs/compile_success_empty/generators/src/main.nr
+++ b/test_programs/compile_success_empty/generators/src/main.nr
@@ -21,7 +21,7 @@ fn fibonacci_generator() -> fn[(&mut Field, &mut Field)]() -> Field {
 
         *y = *x + *y;
         *x = old_y;
-        
+
         old_x
     }
 }
diff --git a/test_programs/compile_success_empty/impl_from_where_impl/src/main.nr b/test_programs/compile_success_empty/impl_from_where_impl/src/main.nr
index 3cec46bdfcd..8ce6ce3314d 100644
--- a/test_programs/compile_success_empty/impl_from_where_impl/src/main.nr
+++ b/test_programs/compile_success_empty/impl_from_where_impl/src/main.nr
@@ -6,7 +6,10 @@ trait Bar {
     }
 }
 
-impl<T> Bar for (T, T) where T: Bar {
+impl<T> Bar for (T, T)
+where
+    T: Bar,
+{
     fn ok(self) -> Self {
         self
     }
diff --git a/test_programs/compile_success_empty/impl_where_clause/src/main.nr b/test_programs/compile_success_empty/impl_where_clause/src/main.nr
index 2f3223efaae..9cf0d26132c 100644
--- a/test_programs/compile_success_empty/impl_where_clause/src/main.nr
+++ b/test_programs/compile_success_empty/impl_where_clause/src/main.nr
@@ -18,7 +18,10 @@ impl MyEq for InnerStruct {
     }
 }
 
-impl<T> MyStruct<T> where T: MyEq {
+impl<T> MyStruct<T>
+where
+    T: MyEq,
+{
     fn my_eq(self, other: Self) -> bool {
         (self.a == other.a) & self.b.my_eq(other.b)
     }
diff --git a/test_programs/compile_success_empty/inject_context_attribute/src/main.nr b/test_programs/compile_success_empty/inject_context_attribute/src/main.nr
index 156579ce0b2..963d4cea969 100644
--- a/test_programs/compile_success_empty/inject_context_attribute/src/main.nr
+++ b/test_programs/compile_success_empty/inject_context_attribute/src/main.nr
@@ -40,21 +40,20 @@ comptime fn inject_context(f: FunctionDefinition) {
 }
 
 comptime fn mapping_function(expr: Expr, f: FunctionDefinition) -> Option<Expr> {
-    expr.as_function_call().and_then(
-        |func_call: (Expr, [Expr])| {
+    expr.as_function_call().and_then(|func_call: (Expr, [Expr])| {
         let (name, arguments) = func_call;
         name.resolve(Option::some(f)).as_function_definition().and_then(
             |function_definition: FunctionDefinition| {
-            if function_definition.has_named_attribute("inject_context") {
-                let arguments = arguments.push_front(quote { _context }.as_expr().unwrap());
-                let arguments = arguments.map(|arg: Expr| arg.quoted()).join(quote { , });
-                Option::some(quote { $name($arguments) }.as_expr().unwrap())
-            } else {
-                Option::none()
-            }
-        }
-        )}
-    )
+                if function_definition.has_named_attribute("inject_context") {
+                    let arguments = arguments.push_front(quote { _context }.as_expr().unwrap());
+                    let arguments = arguments.map(|arg: Expr| arg.quoted()).join(quote { , });
+                    Option::some(quote { $name($arguments) }.as_expr().unwrap())
+                } else {
+                    Option::none()
+                }
+            },
+        )
+    })
 }
 
 fn main() {
diff --git a/test_programs/compile_success_empty/inner_outer_cl/src/main.nr b/test_programs/compile_success_empty/inner_outer_cl/src/main.nr
index ce847b56b93..17cbabec48e 100644
--- a/test_programs/compile_success_empty/inner_outer_cl/src/main.nr
+++ b/test_programs/compile_success_empty/inner_outer_cl/src/main.nr
@@ -2,9 +2,7 @@ fn main() {
     let z1 = 0;
     let z2 = 1;
     let cl_outer = |x| {
-        let cl_inner = |y| {
-            x + y + z2
-        };
+        let cl_inner = |y| x + y + z2;
         cl_inner(1) + z1
     };
     let result = cl_outer(1);
diff --git a/test_programs/compile_success_empty/macros_in_comptime/src/main.nr b/test_programs/compile_success_empty/macros_in_comptime/src/main.nr
index 197f4e87f0b..799091fca09 100644
--- a/test_programs/compile_success_empty/macros_in_comptime/src/main.nr
+++ b/test_programs/compile_success_empty/macros_in_comptime/src/main.nr
@@ -5,11 +5,8 @@ use std::meta::unquote;
 global three_field: Field = 3;
 
 fn main() {
-    comptime
-    {
-        unsafe {
-            foo::<three_field>(5)
-        };
+    comptime {
+        unsafe { foo::<three_field>(5) };
         submodule::bar();
     }
 }
diff --git a/test_programs/compile_success_empty/method_call_regression/src/main.nr b/test_programs/compile_success_empty/method_call_regression/src/main.nr
index de58271cae6..f5b28978ef7 100644
--- a/test_programs/compile_success_empty/method_call_regression/src/main.nr
+++ b/test_programs/compile_success_empty/method_call_regression/src/main.nr
@@ -5,11 +5,16 @@ fn main() {
     s.foo();
 }
 
-struct Struct<A, B> { a: A, b: B }
+struct Struct<A, B> {
+    a: A,
+    b: B,
+}
 
 // Before the fix, this candidate is searched first, binding ? to `u8` permanently.
 impl Struct<u8, u8> {
-    fn foo(self) {}
+    fn foo(self) {
+        let _ = self;
+    }
 }
 
 // Then this candidate would be searched next but would not be a valid
@@ -19,5 +24,7 @@ impl Struct<u8, u8> {
 // method is actually selected. So this candidate is now valid since
 // `Struct<u32, ()>` unifies with `Struct<?, ()>` with `? = u32`.
 impl Struct<u32, ()> {
-    fn foo(self) {}
+    fn foo(self) {
+        let _ = self;
+    }
 }
diff --git a/test_programs/compile_success_empty/mod_nr_entrypoint/src/foo/mod.nr b/test_programs/compile_success_empty/mod_nr_entrypoint/src/foo/mod.nr
index 4eac6cb8514..216294fbf08 100644
--- a/test_programs/compile_success_empty/mod_nr_entrypoint/src/foo/mod.nr
+++ b/test_programs/compile_success_empty/mod_nr_entrypoint/src/foo/mod.nr
@@ -1,4 +1,4 @@
-mod bar;
+pub mod bar;
 
 pub fn in_foo_mod() -> Field {
     1
diff --git a/test_programs/compile_success_empty/mod_nr_entrypoint/src/main.nr b/test_programs/compile_success_empty/mod_nr_entrypoint/src/main.nr
index 620fd99f6ec..972a64bfeb9 100644
--- a/test_programs/compile_success_empty/mod_nr_entrypoint/src/main.nr
+++ b/test_programs/compile_success_empty/mod_nr_entrypoint/src/main.nr
@@ -1,6 +1,6 @@
-use crate::foo::in_foo_mod;
-use crate::foo::bar::in_bar_mod;
 use crate::baz::in_baz_mod;
+use crate::foo::bar::in_bar_mod;
+use crate::foo::in_foo_mod;
 
 mod foo;
 mod baz;
diff --git a/test_programs/compile_success_empty/no_duplicate_methods/src/main.nr b/test_programs/compile_success_empty/no_duplicate_methods/src/main.nr
index 3ca9c841a8c..7e25a61d2ff 100644
--- a/test_programs/compile_success_empty/no_duplicate_methods/src/main.nr
+++ b/test_programs/compile_success_empty/no_duplicate_methods/src/main.nr
@@ -7,7 +7,9 @@ trait ToField2 {
     fn to_field(self) -> Field;
 }
 
-struct Foo { x: Field }
+pub struct Foo {
+    x: Field,
+}
 
 impl ToField for Foo {
     fn to_field(self) -> Field {
diff --git a/test_programs/compile_success_empty/numeric_generics/src/main.nr b/test_programs/compile_success_empty/numeric_generics/src/main.nr
index 04f170aef58..1bdde60bcd5 100644
--- a/test_programs/compile_success_empty/numeric_generics/src/main.nr
+++ b/test_programs/compile_success_empty/numeric_generics/src/main.nr
@@ -32,7 +32,7 @@ impl<let S: u32> MyStruct<S> {
     }
 }
 
-fn foo(mut s: MyStruct<2+1>) -> MyStruct<10/2-2> {
+fn foo(mut s: MyStruct<2 + 1>) -> MyStruct<10 / 2 - 2> {
     s.data[0] = s.data[0] + 1;
     s
 }
diff --git a/test_programs/compile_success_empty/numeric_generics_explicit/src/main.nr b/test_programs/compile_success_empty/numeric_generics_explicit/src/main.nr
index 5c618e9db36..978a7fdf66b 100644
--- a/test_programs/compile_success_empty/numeric_generics_explicit/src/main.nr
+++ b/test_programs/compile_success_empty/numeric_generics_explicit/src/main.nr
@@ -1,5 +1,5 @@
 // Regression that a global of the same name does not trigger a duplicate definition error
-global N = 1000;
+global N: u32 = 1000;
 
 fn main() {
     let a = id([1, 2]);
@@ -48,7 +48,7 @@ impl<let S: u32> MyStruct<S> {
     }
 }
 
-fn foo(mut s: MyStruct<2+1>) -> MyStruct<10/2-2> {
+fn foo(mut s: MyStruct<2 + 1>) -> MyStruct<10 / 2 - 2> {
     s.data[0] = s.data[0] + 1;
     s
 }
@@ -85,10 +85,13 @@ trait Deserialize<let N: u32> {
     fn deserialize(fields: [Field; N]) -> Self;
 }
 
-struct PublicStorage {}
+pub struct PublicStorage {}
 
 impl PublicStorage {
-    fn read<T, let N: u32>() -> T where T: Deserialize<N> {
+    fn read<T, let N: u32>() -> T
+    where
+        T: Deserialize<N>,
+    {
         // Used as a type within a function body
         let mut fields: [Field; N] = [0; N];
         // Used a loop bound
@@ -102,10 +105,10 @@ impl PublicStorage {
 // Check that we can thread numeric generics into nested structs
 // and also that we can handle nested structs with numeric generics
 // which are declared after the parent struct
-struct NestedNumeric<let N: u32> {
+pub struct NestedNumeric<let N: u32> {
     a: Field,
-    b: InnerNumeric<N>
+    b: InnerNumeric<N>,
 }
-struct InnerNumeric<let N: u32> {
+pub struct InnerNumeric<let N: u32> {
     inner: [u32; N],
 }
diff --git a/test_programs/compile_success_empty/parenthesized_expression_in_array_length/src/main.nr b/test_programs/compile_success_empty/parenthesized_expression_in_array_length/src/main.nr
index b596d331e7f..d4479ec933b 100644
--- a/test_programs/compile_success_empty/parenthesized_expression_in_array_length/src/main.nr
+++ b/test_programs/compile_success_empty/parenthesized_expression_in_array_length/src/main.nr
@@ -1,5 +1,5 @@
-global N = 100;
-global BLOCK_SIZE = 10;
+global N: u32 = 100;
+global BLOCK_SIZE: u32 = 10;
 
 fn main() {
     let _: [Field; 110] = [0; ((N + BLOCK_SIZE) * BLOCK_SIZE) / BLOCK_SIZE];
diff --git a/test_programs/compile_success_empty/raw_string/src/main.nr b/test_programs/compile_success_empty/raw_string/src/main.nr
index ad8dfe82ae5..6bed1cfecc9 100644
--- a/test_programs/compile_success_empty/raw_string/src/main.nr
+++ b/test_programs/compile_success_empty/raw_string/src/main.nr
@@ -1,4 +1,4 @@
-global D = r#####"Hello "world""#####;
+global D: str<13> = r#####"Hello "world""#####;
 
 fn main() {
     let a = "Hello \"world\"";
diff --git a/test_programs/compile_success_empty/reexports/src/main.nr b/test_programs/compile_success_empty/reexports/src/main.nr
index 0fd65a33564..6b568bea682 100644
--- a/test_programs/compile_success_empty/reexports/src/main.nr
+++ b/test_programs/compile_success_empty/reexports/src/main.nr
@@ -1,4 +1,4 @@
-use reexporting_lib::{FooStruct, MyStruct, lib};
+use reexporting_lib::{FooStruct, lib, MyStruct};
 
 fn main() {
     let x: FooStruct = MyStruct { inner: 0 };
diff --git a/test_programs/compile_success_empty/regression_2099/Nargo.toml b/test_programs/compile_success_empty/regression_2099/Nargo.toml
index 6b9f9a24038..69fd4caabed 100644
--- a/test_programs/compile_success_empty/regression_2099/Nargo.toml
+++ b/test_programs/compile_success_empty/regression_2099/Nargo.toml
@@ -2,4 +2,6 @@
 name = "regression_2099"
 type = "bin"
 authors = [""]
+
 [dependencies]
+ec = { tag = "v0.1.2", git = "https://github.com/noir-lang/ec" }
diff --git a/test_programs/compile_success_empty/regression_2099/src/main.nr b/test_programs/compile_success_empty/regression_2099/src/main.nr
index 660f72f56e5..3a8b9092792 100644
--- a/test_programs/compile_success_empty/regression_2099/src/main.nr
+++ b/test_programs/compile_success_empty/regression_2099/src/main.nr
@@ -1,13 +1,5 @@
-use std::ec::tecurve::affine::Curve as AffineCurve;
-use std::ec::tecurve::affine::Point as Gaffine;
-use std::ec::tecurve::curvegroup::Curve;
-use std::ec::tecurve::curvegroup::Point as G;
-
-use std::ec::swcurve::affine::Point as SWGaffine;
-use std::ec::swcurve::curvegroup::Point as SWG;
-
-use std::ec::montcurve::affine::Point as MGaffine;
-use std::ec::montcurve::curvegroup::Point as MG;
+use ec::tecurve::affine::Curve as AffineCurve;
+use ec::tecurve::affine::Point as Gaffine;
 
 fn main() {
     // Define Baby Jubjub (ERC-2494) parameters in affine representation
@@ -16,17 +8,17 @@ fn main() {
         168696,
         Gaffine::new(
             995203441582195749578291179787384436505546430278305826713579947235728471134,
-            5472060717959818805561601436314318772137091100104008585924551046643952123905
-        )
+            5472060717959818805561601436314318772137091100104008585924551046643952123905,
+        ),
     );
     // Test addition
     let p1_affine = Gaffine::new(
         17777552123799933955779906779655732241715742912184938656739573121738514868268,
-        2626589144620713026669568689430873010625803728049924121243784502389097019475
+        2626589144620713026669568689430873010625803728049924121243784502389097019475,
     );
     let p2_affine = Gaffine::new(
         16540640123574156134436876038791482806971768689494387082833631921987005038935,
-        20819045374670962167435360035096875258406992893633759881276124905556507972311
+        20819045374670962167435360035096875258406992893633759881276124905556507972311,
     );
     let _p3_affine = bjj_affine.add(p1_affine, p2_affine);
     // Test SWCurve equivalents of the above
diff --git a/test_programs/compile_success_empty/regression_4436/src/main.nr b/test_programs/compile_success_empty/regression_4436/src/main.nr
index 336d0f1f4ed..30e4a942bdf 100644
--- a/test_programs/compile_success_empty/regression_4436/src/main.nr
+++ b/test_programs/compile_success_empty/regression_4436/src/main.nr
@@ -3,15 +3,15 @@ trait LibTrait<N> {
     fn get_constant() -> Field;
 }
 
-global STRUCT_A_LEN: u32 = 3;
-global STRUCT_B_LEN: u32 = 5;
+pub global STRUCT_A_LEN: u32 = 3;
+pub global STRUCT_B_LEN: u32 = 5;
 
-struct StructA;
-struct StructB;
+pub struct StructA;
+pub struct StructB;
 
 impl LibTrait<u32> for StructA {
     fn broadcast() {
-        Self::get_constant();
+        let _ = Self::get_constant();
     }
 
     fn get_constant() -> Field {
@@ -20,7 +20,7 @@ impl LibTrait<u32> for StructA {
 }
 impl LibTrait<u64> for StructB {
     fn broadcast() {
-        Self::get_constant();
+        let _ = Self::get_constant();
     }
 
     fn get_constant() -> Field {
diff --git a/test_programs/compile_success_empty/regression_4635/src/main.nr b/test_programs/compile_success_empty/regression_4635/src/main.nr
index 6bccdf9e30f..f33effb6bdb 100644
--- a/test_programs/compile_success_empty/regression_4635/src/main.nr
+++ b/test_programs/compile_success_empty/regression_4635/src/main.nr
@@ -15,7 +15,7 @@ trait Deserialize<let N: u32> {
 global AZTEC_ADDRESS_LENGTH: u32 = 1;
 
 struct AztecAddress {
-    inner : Field
+    inner: Field,
 }
 
 impl FromField for AztecAddress {
@@ -39,10 +39,13 @@ impl Eq for AztecAddress {
 // Custom code
 
 struct MyStruct<T> {
-    a: T
+    a: T,
 }
 
-impl<T> Deserialize<1> for MyStruct<T> where T: FromField {
+impl<T> Deserialize<1> for MyStruct<T>
+where
+    T: FromField,
+{
     fn deserialize(fields: [Field; 1]) -> Self {
         Self { a: FromField::from_field(fields[0]) }
     }
@@ -51,7 +54,6 @@ impl<T> Deserialize<1> for MyStruct<T> where T: FromField {
 fn main() {
     let fields = [5; 1];
     let foo = MyStruct::deserialize(fields); // Note I don't specify T here (the type of `foo.a`)
-
     let bar = AztecAddress { inner: 5 };
 
     // Here `T` is apparently inferred to be `AztecAddress`, presumably because of the comparison.
diff --git a/test_programs/compile_success_empty/regression_5065/src/main.nr b/test_programs/compile_success_empty/regression_5065/src/main.nr
index 36b0570165f..6ffb6e4e237 100644
--- a/test_programs/compile_success_empty/regression_5065/src/main.nr
+++ b/test_programs/compile_success_empty/regression_5065/src/main.nr
@@ -24,7 +24,10 @@ impl MyTrait for MyType {
     }
 }
 
-fn foo<T>() -> T where T: MyTrait {
+fn foo<T>() -> T
+where
+    T: MyTrait,
+{
     MyTrait::new()
 }
 
diff --git a/test_programs/compile_success_empty/regression_6077/src/main.nr b/test_programs/compile_success_empty/regression_6077/src/main.nr
index fe067177e77..971d487316f 100644
--- a/test_programs/compile_success_empty/regression_6077/src/main.nr
+++ b/test_programs/compile_success_empty/regression_6077/src/main.nr
@@ -1,4 +1,4 @@
-struct WeirdStruct<T, U> {
+pub struct WeirdStruct<T, U> {
     a: T,
     b: U,
 }
@@ -19,7 +19,9 @@ comptime fn mangle_fn(f: FunctionDefinition) {
         {
             WeirdStruct { a: 1, b: [0;3] }
         }
-    }.as_expr().unwrap();
+    }
+        .as_expr()
+        .unwrap();
 
     f.set_return_type(new_return_type);
     f.set_body(new_body);
diff --git a/test_programs/compile_success_empty/ret_fn_ret_cl/src/main.nr b/test_programs/compile_success_empty/ret_fn_ret_cl/src/main.nr
index 89083b076b6..0e99a92585b 100644
--- a/test_programs/compile_success_empty/ret_fn_ret_cl/src/main.nr
+++ b/test_programs/compile_success_empty/ret_fn_ret_cl/src/main.nr
@@ -17,9 +17,7 @@ fn ret_fn() -> fn(Field) -> Field {
 //     inner_closure
 // }
 fn ret_lambda() -> fn(Field) -> Field {
-    let cl = |z: Field| -> Field {
-        z + 1
-    };
+    let cl = |z: Field| -> Field { z + 1 };
     cl
 }
 
diff --git a/test_programs/compile_success_empty/schnorr_simplification/src/main.nr b/test_programs/compile_success_empty/schnorr_simplification/src/main.nr
deleted file mode 100644
index e1095cd7fe2..00000000000
--- a/test_programs/compile_success_empty/schnorr_simplification/src/main.nr
+++ /dev/null
@@ -1,78 +0,0 @@
-use std::embedded_curve_ops;
-
-// Note: If main has any unsized types, then the verifier will never be able
-// to figure out the circuit instance
-fn main() {
-    let message = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9];
-    let pub_key_x = 0x04b260954662e97f00cab9adb773a259097f7a274b83b113532bce27fa3fb96a;
-    let pub_key_y = 0x2fd51571db6c08666b0edfbfbc57d432068bccd0110a39b166ab243da0037197;
-    let signature = [
-        1,
-        13,
-        119,
-        112,
-        212,
-        39,
-        233,
-        41,
-        84,
-        235,
-        255,
-        93,
-        245,
-        172,
-        186,
-        83,
-        157,
-        253,
-        76,
-        77,
-        33,
-        128,
-        178,
-        15,
-        214,
-        67,
-        105,
-        107,
-        177,
-        234,
-        77,
-        48,
-        27,
-        237,
-        155,
-        84,
-        39,
-        84,
-        247,
-        27,
-        22,
-        8,
-        176,
-        230,
-        24,
-        115,
-        145,
-        220,
-        254,
-        122,
-        135,
-        179,
-        171,
-        4,
-        214,
-        202,
-        64,
-        199,
-        19,
-        84,
-        239,
-        138,
-        124,
-        12
-    ];
-
-    let valid_signature = std::schnorr::verify_signature(pub_key_x, pub_key_y, signature, message);
-    assert(valid_signature);
-}
diff --git a/test_programs/compile_success_empty/serialize/src/main.nr b/test_programs/compile_success_empty/serialize/src/main.nr
index 19f3f0319b8..66c79f9fc9d 100644
--- a/test_programs/compile_success_empty/serialize/src/main.nr
+++ b/test_programs/compile_success_empty/serialize/src/main.nr
@@ -5,7 +5,11 @@ trait Serialize {
     fn serialize(self) -> [Field; Self::Size];
 }
 
-impl<A, B, let AS: u32, let BS: u32> Serialize for (A, B) where A: Serialize<Size = AS>, B: Serialize<Size = BS> {
+impl<A, B, let AS: u32, let BS: u32> Serialize for (A, B)
+where
+    A: Serialize<Size = AS>,
+    B: Serialize<Size = BS>,
+{
     // let Size = <A as Serialize>::Size + <B as Serialize>::Size;
     let Size: u32 = AS + BS;
 
@@ -24,7 +28,10 @@ impl<A, B, let AS: u32, let BS: u32> Serialize for (A, B) where A: Serialize<Siz
     }
 }
 
-impl<T, let N: u32, let TS: u32> Serialize for [T; N] where T: Serialize<Size = TS> {
+impl<T, let N: u32, let TS: u32> Serialize for [T; N]
+where
+    T: Serialize<Size = TS>,
+{
     // let Size = <T as Serialize>::Size * N;
     let Size: u32 = TS * N;
 
diff --git a/test_programs/compile_success_empty/simple_program_no_body/src/main.nr b/test_programs/compile_success_empty/simple_program_no_body/src/main.nr
index 21719018f3f..8605ff1a9cc 100644
--- a/test_programs/compile_success_empty/simple_program_no_body/src/main.nr
+++ b/test_programs/compile_success_empty/simple_program_no_body/src/main.nr
@@ -1,5 +1,5 @@
 // Tests a very simple program.
-// 
+//
 // The features being tested are:
 // - Abi generation of private and public
 // main parameters.
diff --git a/test_programs/compile_success_empty/simple_range/src/main.nr b/test_programs/compile_success_empty/simple_range/src/main.nr
index 3f595cfd817..b7c319cfed4 100644
--- a/test_programs/compile_success_empty/simple_range/src/main.nr
+++ b/test_programs/compile_success_empty/simple_range/src/main.nr
@@ -1,5 +1,5 @@
 // Tests a very simple program.
-// 
+//
 // The features being tested is casting to an integer
 fn main(x: Field) {
     let _z = x as u32;
diff --git a/test_programs/compile_success_empty/slice_init_with_complex_type/src/main.nr b/test_programs/compile_success_empty/slice_init_with_complex_type/src/main.nr
index 01ccf2fdeff..27339f812e7 100644
--- a/test_programs/compile_success_empty/slice_init_with_complex_type/src/main.nr
+++ b/test_programs/compile_success_empty/slice_init_with_complex_type/src/main.nr
@@ -4,14 +4,14 @@ struct strct1 {
 
 fn main() {
     let var1: [[i32; 1]] = [[0]];
-    let var2: [[i32; 1]] = var1;
+    let _var2: [[i32; 1]] = var1;
 
     let var1: [(i32, u8)] = [(1, 2)];
-    let var2: [(i32, u8)] = var1;
+    let _var2: [(i32, u8)] = var1;
 
     let var3: [strct1] = [strct1 { elem1: 1321351 }];
-    let var4: [strct1] = var3;
+    let _var4: [strct1] = var3;
 
     let var1: [i32; 1] = [0];
-    let var2: [[i32; 1]] = [var1];
+    let _var2: [[i32; 1]] = [var1];
 }
diff --git a/test_programs/compile_success_empty/slice_join/src/main.nr b/test_programs/compile_success_empty/slice_join/src/main.nr
index 217000694b0..d65f8a4f040 100644
--- a/test_programs/compile_success_empty/slice_join/src/main.nr
+++ b/test_programs/compile_success_empty/slice_join/src/main.nr
@@ -10,7 +10,10 @@ fn main() {
     assert_eq(odds_and_evens, &[1, 3, 5, 100, 2, 4]);
 }
 
-fn append_three<T>(one: T, two: T, three: T) -> T where T: Append {
+fn append_three<T>(one: T, two: T, three: T) -> T
+where
+    T: Append,
+{
     // The `T::empty()`s here should do nothing
     T::empty().append(one).append(two).append(three).append(T::empty())
 }
diff --git a/test_programs/compile_success_empty/static_assert/src/main.nr b/test_programs/compile_success_empty/static_assert/src/main.nr
index e61d9388ceb..fda310ba7eb 100644
--- a/test_programs/compile_success_empty/static_assert/src/main.nr
+++ b/test_programs/compile_success_empty/static_assert/src/main.nr
@@ -1,15 +1,15 @@
 use std::static_assert;
 
-global GLOBAL_ONE = 1;
-global GLOBAL_TWO = 2;
-global GLOBAL_THREE = GLOBAL_ONE + GLOBAL_TWO;
+global GLOBAL_ONE: Field = 1;
+global GLOBAL_TWO: Field = 2;
+global GLOBAL_THREE: Field = GLOBAL_ONE + GLOBAL_TWO;
 
 // contents known at compile time
 // length known at compile time
-global GLOBAL_ARRAY_PAIR = [GLOBAL_ONE, GLOBAL_TWO];
-global GLOBAL_SLICE_PAIR = &[GLOBAL_ONE, GLOBAL_TWO];
+global GLOBAL_ARRAY_PAIR: [Field; 2] = [GLOBAL_ONE, GLOBAL_TWO];
+global GLOBAL_SLICE_PAIR: [Field] = &[GLOBAL_ONE, GLOBAL_TWO];
 
-struct Foo {
+pub struct Foo {
     field: Field,
     array: [Field; 3],
     slice: [Field],
@@ -17,7 +17,7 @@ struct Foo {
 
 fn main(
     dynamic_one: Field, // == 1
-    dynamic_two: Field // == 2
+    dynamic_two: Field, // == 2
 ) {
     // contents unknown at compile time
     // length known at compile time
diff --git a/test_programs/compile_success_empty/struct_public_field/Nargo.toml b/test_programs/compile_success_empty/struct_public_field/Nargo.toml
new file mode 100644
index 00000000000..37307b94af5
--- /dev/null
+++ b/test_programs/compile_success_empty/struct_public_field/Nargo.toml
@@ -0,0 +1,7 @@
+[package]
+name = "struct_public_field"
+type = "bin"
+authors = [""]
+
+[dependencies]
+dependency = {path = "dependency"}
\ No newline at end of file
diff --git a/test_programs/compile_success_empty/struct_public_field/dependency/Nargo.toml b/test_programs/compile_success_empty/struct_public_field/dependency/Nargo.toml
new file mode 100644
index 00000000000..2e471678a44
--- /dev/null
+++ b/test_programs/compile_success_empty/struct_public_field/dependency/Nargo.toml
@@ -0,0 +1,6 @@
+[package]
+name = "dependency"
+type = "lib"
+authors = [""]
+
+[dependencies]
\ No newline at end of file
diff --git a/test_programs/compile_success_empty/struct_public_field/dependency/src/lib.nr b/test_programs/compile_success_empty/struct_public_field/dependency/src/lib.nr
new file mode 100644
index 00000000000..0e9bd4bd9f8
--- /dev/null
+++ b/test_programs/compile_success_empty/struct_public_field/dependency/src/lib.nr
@@ -0,0 +1,4 @@
+pub struct Point {
+    pub x: Field,
+    pub y: Field,
+}
diff --git a/test_programs/compile_success_empty/struct_public_field/src/main.nr b/test_programs/compile_success_empty/struct_public_field/src/main.nr
new file mode 100644
index 00000000000..c269c474de7
--- /dev/null
+++ b/test_programs/compile_success_empty/struct_public_field/src/main.nr
@@ -0,0 +1,8 @@
+use dependency::Point;
+
+fn main() {
+    let point = Point { x: 1, y: 2 };
+    let _ = point.x;
+    let Point { x, y } = point;
+    let _ = (x, y);
+}
diff --git a/test_programs/compile_success_empty/to_bits/src/main.nr b/test_programs/compile_success_empty/to_bits/src/main.nr
index 918a2fad036..dc2ff4be394 100644
--- a/test_programs/compile_success_empty/to_bits/src/main.nr
+++ b/test_programs/compile_success_empty/to_bits/src/main.nr
@@ -1,7 +1,7 @@
 fn main() {
     let field = 1000;
-    let be_bits:[u1; 16] = field.to_be_bits();
-    let le_bits:[u1; 16] = field.to_le_bits();
+    let be_bits: [u1; 16] = field.to_be_bits();
+    let le_bits: [u1; 16] = field.to_le_bits();
 
     for i in 0..16 {
         let x = be_bits[i];
diff --git a/test_programs/compile_success_empty/trait_allowed_item_name_matches/src/main.nr b/test_programs/compile_success_empty/trait_allowed_item_name_matches/src/main.nr
index 44cad58c2a6..f32445202b7 100644
--- a/test_programs/compile_success_empty/trait_allowed_item_name_matches/src/main.nr
+++ b/test_programs/compile_success_empty/trait_allowed_item_name_matches/src/main.nr
@@ -1,25 +1,25 @@
-trait Trait1 {
-  // types and consts with the same name are allowed
-  type Tralala;
-  let Tralala: u32;
+pub trait Trait1 {
+    // types and consts with the same name are allowed
+    type Tralala;
+    let Tralala: u32;
 }
 
-trait Trait2 {
-  // consts and types with the same name are allowed
-  let Tralala: u32;
-  type Tralala;
+pub trait Trait2 {
+    // consts and types with the same name are allowed
+    let Tralala: u32;
+    type Tralala;
 }
 
-trait Trait3 {
-  // types and functions with the same name are allowed
-  type Tralala;
-  fn Tralala();
+pub trait Trait3 {
+    // types and functions with the same name are allowed
+    type Tralala;
+    fn Tralala();
 }
 
-trait Trait4 {
-  // functions and types with the same name are allowed
-  fn Tralala();
-  type Tralala;
+pub trait Trait4 {
+    // functions and types with the same name are allowed
+    fn Tralala();
+    type Tralala;
 }
 
 fn main() {}
diff --git a/test_programs/compile_success_empty/trait_as_constraint/src/main.nr b/test_programs/compile_success_empty/trait_as_constraint/src/main.nr
index 1911f045c27..b516376aae5 100644
--- a/test_programs/compile_success_empty/trait_as_constraint/src/main.nr
+++ b/test_programs/compile_success_empty/trait_as_constraint/src/main.nr
@@ -1,5 +1,5 @@
 #[test_as_constraint]
-trait Foo<T> {}
+pub trait Foo<T> {}
 
 comptime fn test_as_constraint(t: TraitDefinition) {
     let constraint = t.as_trait_constraint();
diff --git a/test_programs/compile_success_empty/trait_associated_member_names_clashes/src/main.nr b/test_programs/compile_success_empty/trait_associated_member_names_clashes/src/main.nr
index 412a75010f6..953ee321b47 100644
--- a/test_programs/compile_success_empty/trait_associated_member_names_clashes/src/main.nr
+++ b/test_programs/compile_success_empty/trait_associated_member_names_clashes/src/main.nr
@@ -6,8 +6,7 @@ trait Trait2 {
     fn tralala() -> Field;
 }
 
-struct Struct1 {
-}
+pub struct Struct1 {}
 
 impl Struct1 {
     fn tralala() -> Field {
diff --git a/test_programs/compile_success_empty/trait_call_full_path/src/main.nr b/test_programs/compile_success_empty/trait_call_full_path/src/main.nr
index 2d4b003f2ad..aea0f436dce 100644
--- a/test_programs/compile_success_empty/trait_call_full_path/src/main.nr
+++ b/test_programs/compile_success_empty/trait_call_full_path/src/main.nr
@@ -1,5 +1,5 @@
 mod foo {
-    trait Trait {
+    pub trait Trait {
         fn me(self) -> Self;
     }
 
diff --git a/test_programs/compile_success_empty/trait_default_implementation/src/main.nr b/test_programs/compile_success_empty/trait_default_implementation/src/main.nr
index 361d82ff3df..ecfa6da0818 100644
--- a/test_programs/compile_success_empty/trait_default_implementation/src/main.nr
+++ b/test_programs/compile_success_empty/trait_default_implementation/src/main.nr
@@ -2,7 +2,7 @@ trait MyDefault {
     fn my_default(x: Field, y: Field) -> Self;
 
     fn method2(x: Field) -> Field {
-	    x
+        x
     }
 }
 
diff --git a/test_programs/compile_success_empty/trait_function_calls/src/main.nr b/test_programs/compile_success_empty/trait_function_calls/src/main.nr
index 62af0e756cd..f9a338bfa47 100644
--- a/test_programs/compile_success_empty/trait_function_calls/src/main.nr
+++ b/test_programs/compile_success_empty/trait_function_calls/src/main.nr
@@ -26,10 +26,13 @@ trait Trait1a {
         self.trait_method2() * 7892 - self.vl
     }
     fn trait_method2(self) -> Field {
+        let _ = self;
         43278
     }
 }
-struct Struct1a { vl: Field }
+struct Struct1a {
+    vl: Field,
+}
 impl Trait1a for Struct1a {}
 // 1b) trait default method -> trait overriden method
 trait Trait1b {
@@ -40,9 +43,12 @@ trait Trait1b {
         9323
     }
 }
-struct Struct1b { vl: Field }
+struct Struct1b {
+    vl: Field,
+}
 impl Trait1b for Struct1b {
     fn trait_method2(self) -> Field {
+        let _ = self;
         2394
     }
 }
@@ -53,9 +59,12 @@ trait Trait1c {
     }
     fn trait_method2(self) -> Field;
 }
-struct Struct1c { vl: Field }
+struct Struct1c {
+    vl: Field,
+}
 impl Trait1c for Struct1c {
     fn trait_method2(self) -> Field {
+        let _ = self;
         5485
     }
 }
@@ -65,10 +74,13 @@ trait Trait1d {
         self.trait_method2() * 2825 - self.vl
     }
     fn trait_method2(self) -> Field {
+        let _ = self;
         29341
     }
 }
-struct Struct1d { vl: Field }
+struct Struct1d {
+    vl: Field,
+}
 impl Trait1d for Struct1d {
     fn trait_method1(self) -> Field {
         self.trait_method2() * 9342 - self.vl
@@ -83,12 +95,15 @@ trait Trait1e {
         2381
     }
 }
-struct Struct1e { vl: Field }
+struct Struct1e {
+    vl: Field,
+}
 impl Trait1e for Struct1e {
     fn trait_method1(self) -> Field {
         self.trait_method2() * 47324 - self.vl
     }
     fn trait_method2(self) -> Field {
+        let _ = self;
         58945
     }
 }
@@ -99,12 +114,15 @@ trait Trait1f {
     }
     fn trait_method2(self) -> Field;
 }
-struct Struct1f { vl: Field }
+struct Struct1f {
+    vl: Field,
+}
 impl Trait1f for Struct1f {
     fn trait_method1(self) -> Field {
         self.trait_method2() * 34875 - self.vl
     }
     fn trait_method2(self) -> Field {
+        let _ = self;
         5748
     }
 }
@@ -112,10 +130,13 @@ impl Trait1f for Struct1f {
 trait Trait1g {
     fn trait_method1(self) -> Field;
     fn trait_method2(self) -> Field {
+        let _ = self;
         37845
     }
 }
-struct Struct1g { vl: Field }
+struct Struct1g {
+    vl: Field,
+}
 impl Trait1g for Struct1g {
     fn trait_method1(self) -> Field {
         self.trait_method2() * 7854 - self.vl
@@ -128,12 +149,15 @@ trait Trait1h {
         7823
     }
 }
-struct Struct1h { vl: Field }
+struct Struct1h {
+    vl: Field,
+}
 impl Trait1h for Struct1h {
     fn trait_method1(self) -> Field {
         self.trait_method2() * 3482 - self.vl
     }
     fn trait_method2(self) -> Field {
+        let _ = self;
         8542
     }
 }
@@ -142,12 +166,15 @@ trait Trait1i {
     fn trait_method1(self) -> Field;
     fn trait_method2(self) -> Field;
 }
-struct Struct1i { vl: Field }
+struct Struct1i {
+    vl: Field,
+}
 impl Trait1i for Struct1i {
     fn trait_method1(self) -> Field {
         self.trait_method2() * 23478 - self.vl
     }
     fn trait_method2(self) -> Field {
+        let _ = self;
         98543
     }
 }
@@ -161,7 +188,9 @@ trait Trait2a {
         7843
     }
 }
-struct Struct2a { vl: Field }
+struct Struct2a {
+    vl: Field,
+}
 impl Trait2a for Struct2a {}
 // 2b) trait default method -> trait overriden function
 trait Trait2b {
@@ -172,7 +201,9 @@ trait Trait2b {
         3752
     }
 }
-struct Struct2b { vl: Field }
+struct Struct2b {
+    vl: Field,
+}
 impl Trait2b for Struct2b {
     fn trait_function2() -> Field {
         8477
@@ -185,7 +216,9 @@ trait Trait2c {
     }
     fn trait_function2() -> Field;
 }
-struct Struct2c { vl: Field }
+struct Struct2c {
+    vl: Field,
+}
 impl Trait2c for Struct2c {
     fn trait_function2() -> Field {
         8342
@@ -200,7 +233,9 @@ trait Trait2d {
         384
     }
 }
-struct Struct2d { vl: Field }
+struct Struct2d {
+    vl: Field,
+}
 impl Trait2d for Struct2d {
     fn trait_method1(self) -> Field {
         Self::trait_function2() * 3984 - self.vl
@@ -215,7 +250,9 @@ trait Trait2e {
         97342
     }
 }
-struct Struct2e { vl: Field }
+struct Struct2e {
+    vl: Field,
+}
 impl Trait2e for Struct2e {
     fn trait_method1(self) -> Field {
         Self::trait_function2() * 7363 - self.vl
@@ -231,7 +268,9 @@ trait Trait2f {
     }
     fn trait_function2() -> Field;
 }
-struct Struct2f { vl: Field }
+struct Struct2f {
+    vl: Field,
+}
 impl Trait2f for Struct2f {
     fn trait_method1(self) -> Field {
         Self::trait_function2() * 6362 - self.vl
@@ -247,7 +286,9 @@ trait Trait2g {
         19273
     }
 }
-struct Struct2g { vl: Field }
+struct Struct2g {
+    vl: Field,
+}
 impl Trait2g for Struct2g {
     fn trait_method1(self) -> Field {
         Self::trait_function2() * 9123 - self.vl
@@ -260,7 +301,9 @@ trait Trait2h {
         1281
     }
 }
-struct Struct2h { vl: Field }
+struct Struct2h {
+    vl: Field,
+}
 impl Trait2h for Struct2h {
     fn trait_method1(self) -> Field {
         Self::trait_function2() * 4833 - self.vl
@@ -274,7 +317,9 @@ trait Trait2i {
     fn trait_method1(self) -> Field;
     fn trait_function2() -> Field;
 }
-struct Struct2i { vl: Field }
+struct Struct2i {
+    vl: Field,
+}
 impl Trait2i for Struct2i {
     fn trait_method1(self) -> Field {
         Self::trait_function2() * 2291 - self.vl
@@ -290,10 +335,13 @@ trait Trait3a {
         b.trait_method2() * 8344 - b.vl + a
     }
     fn trait_method2(self) -> Field {
+        let _ = self;
         19212
     }
 }
-struct Struct3a { vl: Field }
+struct Struct3a {
+    vl: Field,
+}
 impl Trait3a for Struct3a {}
 // 3b) trait default function -> trait overriden method
 trait Trait3b {
@@ -304,9 +352,12 @@ trait Trait3b {
         9111
     }
 }
-struct Struct3b { vl: Field }
+struct Struct3b {
+    vl: Field,
+}
 impl Trait3b for Struct3b {
     fn trait_method2(self) -> Field {
+        let _ = self;
         2392
     }
 }
@@ -317,9 +368,12 @@ trait Trait3c {
     }
     fn trait_method2(self) -> Field;
 }
-struct Struct3c { vl: Field }
+struct Struct3c {
+    vl: Field,
+}
 impl Trait3c for Struct3c {
     fn trait_method2(self) -> Field {
+        let _ = self;
         7743
     }
 }
@@ -329,10 +383,13 @@ trait Trait3d {
         b.trait_method2() * 291 - b.vl + a
     }
     fn trait_method2(self) -> Field {
+        let _ = self;
         3328
     }
 }
-struct Struct3d { vl: Field }
+struct Struct3d {
+    vl: Field,
+}
 impl Trait3d for Struct3d {
     fn trait_function1(a: Field, b: Self) -> Field {
         b.trait_method2() * 4933 - b.vl + a
@@ -347,12 +404,15 @@ trait Trait3e {
         373
     }
 }
-struct Struct3e { vl: Field }
+struct Struct3e {
+    vl: Field,
+}
 impl Trait3e for Struct3e {
     fn trait_function1(a: Field, b: Self) -> Field {
         b.trait_method2() * 81232 - b.vl + a
     }
     fn trait_method2(self) -> Field {
+        let _ = self;
         80002
     }
 }
@@ -363,12 +423,15 @@ trait Trait3f {
     }
     fn trait_method2(self) -> Field;
 }
-struct Struct3f { vl: Field }
+struct Struct3f {
+    vl: Field,
+}
 impl Trait3f for Struct3f {
     fn trait_function1(a: Field, b: Self) -> Field {
         b.trait_method2() * 29223 - b.vl + a
     }
     fn trait_method2(self) -> Field {
+        let _ = self;
         63532
     }
 }
@@ -376,10 +439,13 @@ impl Trait3f for Struct3f {
 trait Trait3g {
     fn trait_function1(a: Field, b: Self) -> Field;
     fn trait_method2(self) -> Field {
+        let _ = self;
         8887
     }
 }
-struct Struct3g { vl: Field }
+struct Struct3g {
+    vl: Field,
+}
 impl Trait3g for Struct3g {
     fn trait_function1(a: Field, b: Self) -> Field {
         b.trait_method2() * 31337 - b.vl + a
@@ -392,12 +458,15 @@ trait Trait3h {
         293
     }
 }
-struct Struct3h { vl: Field }
+struct Struct3h {
+    vl: Field,
+}
 impl Trait3h for Struct3h {
     fn trait_function1(a: Field, b: Self) -> Field {
         b.trait_method2() * 74747 - b.vl + a
     }
     fn trait_method2(self) -> Field {
+        let _ = self;
         6283
     }
 }
@@ -406,12 +475,15 @@ trait Trait3i {
     fn trait_function1(a: Field, b: Self) -> Field;
     fn trait_method2(self) -> Field;
 }
-struct Struct3i { vl: Field }
+struct Struct3i {
+    vl: Field,
+}
 impl Trait3i for Struct3i {
     fn trait_function1(a: Field, b: Self) -> Field {
         b.trait_method2() * 1237 - b.vl + a
     }
     fn trait_method2(self) -> Field {
+        let _ = self;
         84352
     }
 }
@@ -425,7 +497,9 @@ trait Trait4a {
         2932
     }
 }
-struct Struct4a { vl: Field }
+pub struct Struct4a {
+    vl: Field,
+}
 impl Trait4a for Struct4a {}
 // 4b) trait default function -> trait overriden function
 trait Trait4b {
@@ -436,7 +510,9 @@ trait Trait4b {
         2932
     }
 }
-struct Struct4b { vl: Field }
+pub struct Struct4b {
+    vl: Field,
+}
 impl Trait4b for Struct4b {
     fn trait_function2() -> Field {
         9353
@@ -449,7 +525,9 @@ trait Trait4c {
     }
     fn trait_function2() -> Field;
 }
-struct Struct4c { vl: Field }
+pub struct Struct4c {
+    vl: Field,
+}
 impl Trait4c for Struct4c {
     fn trait_function2() -> Field {
         2928
@@ -464,7 +542,9 @@ trait Trait4d {
         9332
     }
 }
-struct Struct4d { vl: Field }
+pub struct Struct4d {
+    vl: Field,
+}
 impl Trait4d for Struct4d {
     fn trait_function1() -> Field {
         Self::trait_function2() * 8374
@@ -479,7 +559,9 @@ trait Trait4e {
         28328
     }
 }
-struct Struct4e { vl: Field }
+pub struct Struct4e {
+    vl: Field,
+}
 impl Trait4e for Struct4e {
     fn trait_function1() -> Field {
         Self::trait_function2() * 12323
@@ -495,7 +577,9 @@ trait Trait4f {
     }
     fn trait_function2() -> Field;
 }
-struct Struct4f { vl: Field }
+pub struct Struct4f {
+    vl: Field,
+}
 impl Trait4f for Struct4f {
     fn trait_function1() -> Field {
         Self::trait_function2() * 21392
@@ -511,7 +595,9 @@ trait Trait4g {
         2932
     }
 }
-struct Struct4g { vl: Field }
+pub struct Struct4g {
+    vl: Field,
+}
 impl Trait4g for Struct4g {
     fn trait_function1() -> Field {
         Self::trait_function2() * 3345
@@ -524,7 +610,9 @@ trait Trait4h {
         5756
     }
 }
-struct Struct4h { vl: Field }
+pub struct Struct4h {
+    vl: Field,
+}
 impl Trait4h for Struct4h {
     fn trait_function1() -> Field {
         Self::trait_function2() * 6478
@@ -538,7 +626,9 @@ trait Trait4i {
     fn trait_function1() -> Field;
     fn trait_function2() -> Field;
 }
-struct Struct4i { vl: Field }
+pub struct Struct4i {
+    vl: Field,
+}
 impl Trait4i for Struct4i {
     fn trait_function1() -> Field {
         Self::trait_function2() * 8239
diff --git a/test_programs/compile_success_empty/trait_generics/src/main.nr b/test_programs/compile_success_empty/trait_generics/src/main.nr
index 77309ca4bee..08302ded68c 100644
--- a/test_programs/compile_success_empty/trait_generics/src/main.nr
+++ b/test_programs/compile_success_empty/trait_generics/src/main.nr
@@ -7,7 +7,11 @@ fn main() {
     assert_eq(15, sum_static(Data { a: 5, b: 10 }));
 }
 
-fn foo<T, U>(x: T, u: U) where T: MyInto<U>, U: Eq {
+fn foo<T, U>(x: T, u: U)
+where
+    T: MyInto<U>,
+    U: Eq,
+{
     assert(x.into() == u);
 }
 
@@ -15,7 +19,10 @@ trait MyInto<T> {
     fn into(self) -> T;
 }
 
-impl<T, U, let N: u32> MyInto<[U; N]> for [T; N] where T: MyInto<U> {
+impl<T, U, let N: u32> MyInto<[U; N]> for [T; N]
+where
+    T: MyInto<U>,
+{
     fn into(self) -> [U; N] {
         self.map(|x: T| x.into())
     }
@@ -44,13 +51,19 @@ impl Serializable<2> for Data {
     }
 }
 
-fn sum<T, let M: u32>(data: T) -> Field where T: Serializable<M> {
+fn sum<T, let M: u32>(data: T) -> Field
+where
+    T: Serializable<M>,
+{
     let serialized = data.serialize();
     serialized.fold(0, |acc, elem| acc + elem)
 }
 
 // Test static trait method syntax
-fn sum_static<T, let M: u32>(data: T) -> Field where T: Serializable<M> {
+fn sum_static<T, let M: u32>(data: T) -> Field
+where
+    T: Serializable<M>,
+{
     let serialized = Serializable::serialize(data);
     serialized.fold(0, |acc, elem| acc + elem)
 }
diff --git a/test_programs/compile_success_empty/trait_impl_generics/src/main.nr b/test_programs/compile_success_empty/trait_impl_generics/src/main.nr
index bae4d62f9e4..33a086912d6 100644
--- a/test_programs/compile_success_empty/trait_impl_generics/src/main.nr
+++ b/test_programs/compile_success_empty/trait_impl_generics/src/main.nr
@@ -23,7 +23,7 @@ fn main() {
 
     assert(x.foo() == 32);
     assert(y.foo() == 64);
-    // Types matching multiple impls will currently choose 
+    // Types matching multiple impls will currently choose
     // the first matching one instead of erroring
     assert(z.foo() == 32);
 
@@ -44,7 +44,9 @@ trait T2 {
     fn t2(self) -> Self;
 }
 
-struct S2<T> { x: T }
+struct S2<T> {
+    x: T,
+}
 
 impl<T> T2 for S2<T> {
     fn t2(self) -> Self {
diff --git a/test_programs/compile_success_empty/trait_impl_with_where_clause/src/main.nr b/test_programs/compile_success_empty/trait_impl_with_where_clause/src/main.nr
index 6da2c86fa2f..6fa194f2520 100644
--- a/test_programs/compile_success_empty/trait_impl_with_where_clause/src/main.nr
+++ b/test_programs/compile_success_empty/trait_impl_with_where_clause/src/main.nr
@@ -10,7 +10,10 @@ trait MyEq {
     fn my_eq(self, other: Self) -> bool;
 }
 
-impl<T> MyEq for [T; 3] where T: MyEq {
+impl<T> MyEq for [T; 3]
+where
+    T: MyEq,
+{
     fn my_eq(self, other: Self) -> bool {
         let mut ret = true;
         for i in 0..self.len() {
diff --git a/test_programs/compile_success_empty/trait_method_mut_self/src/main.nr b/test_programs/compile_success_empty/trait_method_mut_self/src/main.nr
index 9cc8375b140..aa0baab7f89 100644
--- a/test_programs/compile_success_empty/trait_method_mut_self/src/main.nr
+++ b/test_programs/compile_success_empty/trait_method_mut_self/src/main.nr
@@ -17,7 +17,7 @@ fn main(x: Field, y: pub Field) {
     hasher.write(x);
     hasher.write(y);
     let expected_hash = hasher.finish();
-    // Check that we get the same result when using the hasher in a 
+    // Check that we get the same result when using the hasher in a
     // method that purely uses trait methods without a supplied implementation.
     assert(hash_simple_array::<Poseidon2Hasher>([x, y]) == expected_hash);
 }
@@ -29,7 +29,7 @@ trait SomeTrait {
 }
 
 struct AType {
-    x: Field
+    x: Field,
 }
 
 impl SomeTrait for AType {
@@ -48,18 +48,27 @@ fn pass_trait_by_value_impl_param(mut a_mut_ref: impl SomeTrait, value: Field) {
     assert(a_mut_ref.get_value() == value);
 }
 
-fn pass_trait_by_value<T>(mut a_mut_ref: T, value: Field) where T: SomeTrait {
+fn pass_trait_by_value<T>(mut a_mut_ref: T, value: Field)
+where
+    T: SomeTrait,
+{
     // We auto add a mutable reference to the object type if the method call expects a mutable self
     a_mut_ref.set_value(value);
     assert(a_mut_ref.get_value() == value);
 }
 
-fn pass_trait_by_mut_ref<T>(a_mut_ref: &mut T, value: Field) where T: SomeTrait {
+fn pass_trait_by_mut_ref<T>(a_mut_ref: &mut T, value: Field)
+where
+    T: SomeTrait,
+{
     // We auto add a mutable reference to the object type if the method call expects a mutable self
     a_mut_ref.set_value(value);
 }
 
-fn hash_simple_array<H>(input: [Field; 2]) -> Field where H: Hasher + Default {
+fn hash_simple_array<H>(input: [Field; 2]) -> Field
+where
+    H: Hasher + Default,
+{
     // Check that we can call a trait method instead of a trait implementation
     // TODO: Need to remove the need for this type annotation
     // TODO: Curently, without the annotation we will get `Expression type is ambiguous` when trying to use the `hasher`
diff --git a/test_programs/compile_success_empty/trait_multi_module_test/src/module1.nr b/test_programs/compile_success_empty/trait_multi_module_test/src/module1.nr
index 4d41ff2909a..8eaeafa5207 100644
--- a/test_programs/compile_success_empty/trait_multi_module_test/src/module1.nr
+++ b/test_programs/compile_success_empty/trait_multi_module_test/src/module1.nr
@@ -1,2 +1 @@
-trait MyTrait {
-}
+pub trait MyTrait {}
diff --git a/test_programs/compile_success_empty/trait_multi_module_test/src/module2.nr b/test_programs/compile_success_empty/trait_multi_module_test/src/module2.nr
index 3cadb6d78cb..3db88f40ef7 100644
--- a/test_programs/compile_success_empty/trait_multi_module_test/src/module2.nr
+++ b/test_programs/compile_success_empty/trait_multi_module_test/src/module2.nr
@@ -1,2 +1 @@
-struct MyStruct {
-}
+pub struct MyStruct {}
diff --git a/test_programs/compile_success_empty/trait_multi_module_test/src/module4.nr b/test_programs/compile_success_empty/trait_multi_module_test/src/module4.nr
index f9458e83c4a..487cc404726 100644
--- a/test_programs/compile_success_empty/trait_multi_module_test/src/module4.nr
+++ b/test_programs/compile_success_empty/trait_multi_module_test/src/module4.nr
@@ -1,2 +1 @@
-trait MyTrait4 {
-}
+pub trait MyTrait4 {}
diff --git a/test_programs/compile_success_empty/trait_multi_module_test/src/module5.nr b/test_programs/compile_success_empty/trait_multi_module_test/src/module5.nr
index cd9b7f0bf39..9c58cf799db 100644
--- a/test_programs/compile_success_empty/trait_multi_module_test/src/module5.nr
+++ b/test_programs/compile_success_empty/trait_multi_module_test/src/module5.nr
@@ -1,2 +1 @@
-struct MyStruct5 {
-}
+pub struct MyStruct5 {}
diff --git a/test_programs/compile_success_empty/trait_override_implementation/src/main.nr b/test_programs/compile_success_empty/trait_override_implementation/src/main.nr
index 68a928c0c52..12a625b0843 100644
--- a/test_programs/compile_success_empty/trait_override_implementation/src/main.nr
+++ b/test_programs/compile_success_empty/trait_override_implementation/src/main.nr
@@ -23,10 +23,18 @@ impl MyDefault for Foo {
 
 trait F {
     fn f1(self) -> Field;
-    fn f2(_self: Self) -> Field { 2 }
-    fn f3(_self: Self) -> Field { 3 }
-    fn f4(_self: Self) -> Field { 4 }
-    fn f5(_self: Self) -> Field { 5 }
+    fn f2(_self: Self) -> Field {
+        2
+    }
+    fn f3(_self: Self) -> Field {
+        3
+    }
+    fn f4(_self: Self) -> Field {
+        4
+    }
+    fn f5(_self: Self) -> Field {
+        5
+    }
 }
 
 struct Bar {}
diff --git a/test_programs/compile_success_empty/trait_static_methods/src/main.nr b/test_programs/compile_success_empty/trait_static_methods/src/main.nr
index 976d0ab762c..571f917ab89 100644
--- a/test_programs/compile_success_empty/trait_static_methods/src/main.nr
+++ b/test_programs/compile_success_empty/trait_static_methods/src/main.nr
@@ -11,7 +11,7 @@ trait ATrait {
 }
 
 struct Foo {
-    x: Field
+    x: Field,
 }
 impl ATrait for Foo {
     fn asd() -> Self {
@@ -21,7 +21,7 @@ impl ATrait for Foo {
 }
 
 struct Bar {
-    x: Field
+    x: Field,
 }
 impl ATrait for Bar {
     // The trait method is declared as returning `Self`
diff --git a/test_programs/compile_success_empty/trait_where_clause/src/main.nr b/test_programs/compile_success_empty/trait_where_clause/src/main.nr
index 655450d05ac..8dc00be622d 100644
--- a/test_programs/compile_success_empty/trait_where_clause/src/main.nr
+++ b/test_programs/compile_success_empty/trait_where_clause/src/main.nr
@@ -7,10 +7,19 @@ mod the_trait;
 use crate::the_trait::Asd;
 use crate::the_trait::StaticTrait;
 
-struct Add10  { x: Field, }
-struct Add20  { x: Field, }
-struct Add30  { x: Field, }
-struct AddXY  { x: Field, y: Field, }
+struct Add10 {
+    x: Field,
+}
+struct Add20 {
+    x: Field,
+}
+struct Add30 {
+    x: Field,
+}
+struct AddXY {
+    x: Field,
+    y: Field,
+}
 
 impl Asd for Add10 {
     fn asd(self) -> Field {
@@ -42,22 +51,29 @@ impl StaticTrait for Static100 {
 struct Static200 {}
 impl StaticTrait for Static200 {
     fn static_function(slf: Self) -> Field {
+        let _ = slf;
         200
     }
 }
 
-fn assert_asd_eq_100<T>(t: T) where T: crate::the_trait::Asd {
+fn assert_asd_eq_100<T>(t: T)
+where
+    T: crate::the_trait::Asd,
+{
     assert(t.asd() == 100);
 }
 
-fn add_one_to_static_function<T>(t: T) -> Field where T: StaticTrait {
+fn add_one_to_static_function<T>(t: T) -> Field
+where
+    T: StaticTrait,
+{
     T::static_function(t) + 1
 }
 
 fn main() {
-    let x  = Add10 { x: 90 };
-    let z  = Add20 { x: 80 };
-    let a  = Add30 { x: 70 };
+    let x = Add10 { x: 90 };
+    let z = Add20 { x: 80 };
+    let a = Add30 { x: 70 };
     let xy = AddXY { x: 30, y: 70 };
 
     assert_asd_eq_100(x);
diff --git a/test_programs/compile_success_empty/trait_where_clause/src/the_trait.nr b/test_programs/compile_success_empty/trait_where_clause/src/the_trait.nr
index c5cac4a1186..6390856731e 100644
--- a/test_programs/compile_success_empty/trait_where_clause/src/the_trait.nr
+++ b/test_programs/compile_success_empty/trait_where_clause/src/the_trait.nr
@@ -1,9 +1,10 @@
-trait Asd {
+pub trait Asd {
     fn asd(self) -> Field;
 }
 
-trait StaticTrait {
+pub trait StaticTrait {
     fn static_function(slf: Self) -> Field {
+        let _ = slf;
         100
     }
 }
diff --git a/test_programs/compile_success_empty/turbofish_call_func_diff_types/src/main.nr b/test_programs/compile_success_empty/turbofish_call_func_diff_types/src/main.nr
index 36c7d2926c1..e44df34a193 100644
--- a/test_programs/compile_success_empty/turbofish_call_func_diff_types/src/main.nr
+++ b/test_programs/compile_success_empty/turbofish_call_func_diff_types/src/main.nr
@@ -1,13 +1,13 @@
 use std::hash::Hasher;
-use std::hash::poseidon2::Poseidon2Hasher;
 use std::hash::poseidon::PoseidonHasher;
+use std::hash::poseidon2::Poseidon2Hasher;
 
 fn main(x: Field, y: pub Field) {
     let mut hasher = PoseidonHasher::default();
     hasher.write(x);
     hasher.write(y);
     let poseidon_expected_hash = hasher.finish();
-    // Check that we get the same result when using the hasher in a 
+    // Check that we get the same result when using the hasher in a
     // method that purely uses trait methods without a supplied implementation.
     assert(hash_simple_array::<PoseidonHasher>([x, y]) == poseidon_expected_hash);
 
@@ -21,7 +21,10 @@ fn main(x: Field, y: pub Field) {
     assert(hash_simple_array::<Poseidon2Hasher>([x, y]) == poseidon2_expected_hash);
 }
 
-fn hash_simple_array<H>(input: [Field; 2]) -> Field where H: Hasher + Default {
+fn hash_simple_array<H>(input: [Field; 2]) -> Field
+where
+    H: Hasher + Default,
+{
     // Check that we can call a trait method instead of a trait implementation
     let mut hasher = H::default();
     // Regression that the object is converted to a mutable reference type `&mut _`.
diff --git a/test_programs/compile_success_empty/type_path/src/main.nr b/test_programs/compile_success_empty/type_path/src/main.nr
index 96f3a29d96b..ca9a9008f6c 100644
--- a/test_programs/compile_success_empty/type_path/src/main.nr
+++ b/test_programs/compile_success_empty/type_path/src/main.nr
@@ -1,14 +1,18 @@
 fn main() {
-    comptime
-    {
+    comptime {
         let foo = quote { Foo }.as_type();
         quote {
             $foo::static()
         }
     }
+
+    // Make sure this call works fine: in the past we used to not distinguish
+    // whether a TypePath had generics or not, always resolved them, filling them
+    // up with Type::Error, and eventually leading to an ICE.
+    let _ = Field::from_be_bytes([1]);
 }
 
-struct Foo {}
+pub struct Foo {}
 
 impl Foo {
     fn static() {}
diff --git a/test_programs/compile_success_empty/unary_operators/src/main.nr b/test_programs/compile_success_empty/unary_operators/src/main.nr
index ef622fd3eb9..8793086c1c1 100644
--- a/test_programs/compile_success_empty/unary_operators/src/main.nr
+++ b/test_programs/compile_success_empty/unary_operators/src/main.nr
@@ -3,5 +3,5 @@ fn main() {
     assert(x == 1 - 2);
 
     let y: i32 = -1;
-    assert(x == 1 - 2);
+    assert(y == 1 - 2);
 }
diff --git a/test_programs/compile_success_empty/unquote_function/src/main.nr b/test_programs/compile_success_empty/unquote_function/src/main.nr
index 273a091b26d..7b6442abe8a 100644
--- a/test_programs/compile_success_empty/unquote_function/src/main.nr
+++ b/test_programs/compile_success_empty/unquote_function/src/main.nr
@@ -3,7 +3,7 @@ fn main() {
 }
 
 #[output_function]
-fn foo() {}
+pub fn foo() {}
 
 comptime fn output_function(_f: FunctionDefinition) -> Quoted {
     quote {
diff --git a/test_programs/compile_success_empty/unquote_multiple_items_from_annotation/src/main.nr b/test_programs/compile_success_empty/unquote_multiple_items_from_annotation/src/main.nr
index 04f07f038e5..591c03de905 100644
--- a/test_programs/compile_success_empty/unquote_multiple_items_from_annotation/src/main.nr
+++ b/test_programs/compile_success_empty/unquote_multiple_items_from_annotation/src/main.nr
@@ -1,5 +1,5 @@
 #[foo]
-struct Foo {}
+pub struct Foo {}
 
 fn main() {
     assert_eq(ONE, 1);
@@ -8,7 +8,7 @@ fn main() {
 
 comptime fn foo(_: StructDefinition) -> Quoted {
     quote {
-        global ONE = 1;
-        global TWO = 2;
+        global ONE: Field = 1;
+        global TWO: u32 = 2;
     }
 }
diff --git a/test_programs/compile_success_empty/unquote_struct/src/main.nr b/test_programs/compile_success_empty/unquote_struct/src/main.nr
index 603440b5c76..d4ab275858c 100644
--- a/test_programs/compile_success_empty/unquote_struct/src/main.nr
+++ b/test_programs/compile_success_empty/unquote_struct/src/main.nr
@@ -10,18 +10,18 @@ fn foo(x: Field, y: u32) -> u32 {
 
 // Given a function, wrap its parameters in a struct definition
 comptime fn output_struct(f: FunctionDefinition) -> Quoted {
-    let fields = f.parameters().map(
-        |param: (Quoted, Type)| {
-        let name = param.0;
-        let typ = param.1;
-        quote { $name: $typ, }
-    }
-    ).join(quote {});
+    let fields = f
+        .parameters()
+        .map(|param: (Quoted, Type)| {
+            let name = param.0;
+            let typ = param.1;
+            quote { $name: $typ, }
+        })
+        .join(quote {});
 
     quote {
         struct Foo { $fields }
-
-        impl Foo {
+    impl Foo {
             fn assert_equal(self) {
                 assert_eq(self.x as u32, self.y);
             }
diff --git a/test_programs/compile_success_empty/unused_variables/src/main.nr b/test_programs/compile_success_empty/unused_variables/src/main.nr
index f82cace0509..2fb57e3b275 100644
--- a/test_programs/compile_success_empty/unused_variables/src/main.nr
+++ b/test_programs/compile_success_empty/unused_variables/src/main.nr
@@ -1 +1,4 @@
-fn main(x: Field, y: pub Field) {}
+fn main(x: Field, y: pub Field) {
+    let _ = x;
+    let _ = y;
+}
diff --git a/test_programs/compile_success_empty/use_callers_scope/src/main.nr b/test_programs/compile_success_empty/use_callers_scope/src/main.nr
index b4e8a7f7c4d..26429997f0e 100644
--- a/test_programs/compile_success_empty/use_callers_scope/src/main.nr
+++ b/test_programs/compile_success_empty/use_callers_scope/src/main.nr
@@ -1,7 +1,7 @@
 #[bar::struct_attr]
-struct Foo {}
+pub struct Foo {}
 
-struct Bar {}
+pub struct Bar {}
 
 #[bar::fn_attr]
 fn main() {}
@@ -19,11 +19,7 @@ mod bar {
 
         // Ensure closures can still access Bar even
         // though `map` separates them from `fn_attr`.
-        let _ = &[1, 2, 3].map(
-            |_| {
-            quote { Bar }.as_type()
-        }
-        );
+        let _ = &[1, 2, 3].map(|_| quote { Bar }.as_type());
     }
 
     // use_callers_scope should also work nested
diff --git a/test_programs/compile_success_empty/workspace_reexport_bug/library/src/lib.nr b/test_programs/compile_success_empty/workspace_reexport_bug/library/src/lib.nr
index e3a1539ea65..e56c127f562 100644
--- a/test_programs/compile_success_empty/workspace_reexport_bug/library/src/lib.nr
+++ b/test_programs/compile_success_empty/workspace_reexport_bug/library/src/lib.nr
@@ -1,2 +1,2 @@
 // Re-export 
-use library2::ReExportMeFromAnotherLib;
+pub use library2::ReExportMeFromAnotherLib;
diff --git a/test_programs/compile_success_empty/workspace_reexport_bug/library2/src/lib.nr b/test_programs/compile_success_empty/workspace_reexport_bug/library2/src/lib.nr
index 7e5a29a1424..c38c7bd1675 100644
--- a/test_programs/compile_success_empty/workspace_reexport_bug/library2/src/lib.nr
+++ b/test_programs/compile_success_empty/workspace_reexport_bug/library2/src/lib.nr
@@ -1,5 +1,5 @@
 // When we re-export this type from another library and then use it in
 // main, we get a panic
-struct ReExportMeFromAnotherLib {
+pub struct ReExportMeFromAnotherLib {
     x : Field,
 }
diff --git a/test_programs/compile_success_no_bug/databus_mapping_regression/src/main.nr b/test_programs/compile_success_no_bug/databus_mapping_regression/src/main.nr
index a3aae2911bb..9b6ad264a9e 100644
--- a/test_programs/compile_success_no_bug/databus_mapping_regression/src/main.nr
+++ b/test_programs/compile_success_no_bug/databus_mapping_regression/src/main.nr
@@ -23,8 +23,8 @@ pub fn array_to_bounded_vec<T, let N: u32>(array: [T; N]) -> BoundedVec<T, N> wh
     BoundedVec { storage: array, len }
 }
 
-global TX_SIZE = 5;
-global APP_CALL_SIZE = 2;
+global TX_SIZE: u32 = 5;
+global APP_CALL_SIZE: u32 = 2;
 
 fn main(
     a: call_data(0) [Field; TX_SIZE],
@@ -38,5 +38,5 @@ fn main(
             a_as_bounded_vec.push(value);
         }
     }
-    a_as_bounded_vec.storage
+    a_as_bounded_vec.storage()
 }
diff --git a/test_programs/compile_success_with_bug/underconstrained_value_detector_5425/Nargo.toml b/test_programs/compile_success_with_bug/underconstrained_value_detector_5425/Nargo.toml
new file mode 100644
index 00000000000..48ab5a0390b
--- /dev/null
+++ b/test_programs/compile_success_with_bug/underconstrained_value_detector_5425/Nargo.toml
@@ -0,0 +1,7 @@
+[package]
+name = "underconstrained_value_detector_5425"
+type = "bin"
+authors = [""]
+compiler_version = ">=0.36.0"
+
+[dependencies]
\ No newline at end of file
diff --git a/test_programs/compile_success_with_bug/underconstrained_value_detector_5425/src/main.nr b/test_programs/compile_success_with_bug/underconstrained_value_detector_5425/src/main.nr
new file mode 100644
index 00000000000..1d9269eebd5
--- /dev/null
+++ b/test_programs/compile_success_with_bug/underconstrained_value_detector_5425/src/main.nr
@@ -0,0 +1,48 @@
+unconstrained fn maximum_price(options: [u32; 3]) -> u32 {
+    let mut maximum_option = 0;
+    for option in options {
+        if (option > maximum_option) {
+            maximum_option = option;
+        }
+    }
+    maximum_option
+}
+
+fn main(sandwiches: pub [u32; 3], drinks: pub [u32; 3], snacks: pub [u32; 3], best_value: u32) {
+    unsafe {
+        let meal_deal_cost: u32 = 390;
+        let most_expensive_sandwich = maximum_price(sandwiches);
+        let mut sandwich_exists = false;
+        for sandwich_price in sandwiches {
+            assert(sandwich_price <= most_expensive_sandwich);
+            sandwich_exists |= sandwich_price == most_expensive_sandwich;
+        }
+
+        // maximum_price(sandwiches) is properly constrained with this assert,
+        // linking the result to the arguments
+        assert(sandwich_exists);
+
+        let most_expensive_drink = maximum_price(drinks);
+        let mut drink_exists = false;
+        for drink_price in drinks {
+            assert(drink_price <= most_expensive_drink);
+            drink_exists |= drink_price == most_expensive_drink;
+        }
+
+        // maximum_price(drinks) is properly constrained with this assert,
+        // linking the result to the arguments
+        assert(drink_exists);
+
+        let most_expensive_snack = maximum_price(snacks);
+        // maximum_price(snacks)'s result isn't constrained against `snacks`
+        // in any way, triggering the missing Brillig constraint check
+
+        assert(
+            best_value
+                == (
+                    most_expensive_sandwich + most_expensive_drink + most_expensive_snack
+                        - meal_deal_cost
+                ),
+        );
+    }
+}
diff --git a/test_programs/execution_failure/invalid_comptime_bits_decomposition/Nargo.toml b/test_programs/execution_failure/invalid_comptime_bits_decomposition/Nargo.toml
new file mode 100644
index 00000000000..c4efe5b4bb4
--- /dev/null
+++ b/test_programs/execution_failure/invalid_comptime_bits_decomposition/Nargo.toml
@@ -0,0 +1,7 @@
+[package]
+name = "invalid_comptime_bits_decomposition"
+type = "bin"
+authors = [""]
+compiler_version = ">=0.30.0"
+
+[dependencies]
\ No newline at end of file
diff --git a/test_programs/execution_failure/invalid_comptime_bits_decomposition/src/main.nr b/test_programs/execution_failure/invalid_comptime_bits_decomposition/src/main.nr
new file mode 100644
index 00000000000..a9ac06c42c6
--- /dev/null
+++ b/test_programs/execution_failure/invalid_comptime_bits_decomposition/src/main.nr
@@ -0,0 +1,5 @@
+fn main() -> pub [u1; 1] {
+    let large_number: Field = 2;
+
+    large_number.to_be_bits()
+}
diff --git a/test_programs/execution_failure/invalid_comptime_bytes_decomposition/Nargo.toml b/test_programs/execution_failure/invalid_comptime_bytes_decomposition/Nargo.toml
new file mode 100644
index 00000000000..7ec63576af3
--- /dev/null
+++ b/test_programs/execution_failure/invalid_comptime_bytes_decomposition/Nargo.toml
@@ -0,0 +1,7 @@
+[package]
+name = "invalid_comptime_bytes_decomposition"
+type = "bin"
+authors = [""]
+compiler_version = ">=0.30.0"
+
+[dependencies]
\ No newline at end of file
diff --git a/test_programs/execution_failure/invalid_comptime_bytes_decomposition/src/main.nr b/test_programs/execution_failure/invalid_comptime_bytes_decomposition/src/main.nr
new file mode 100644
index 00000000000..29be8508575
--- /dev/null
+++ b/test_programs/execution_failure/invalid_comptime_bytes_decomposition/src/main.nr
@@ -0,0 +1,4 @@
+fn main() -> pub [u8; 1] {
+    let large_number: Field = 256;
+    large_number.to_be_bytes()
+}
diff --git a/test_programs/execution_success/1327_concrete_in_generic/src/main.nr b/test_programs/execution_success/1327_concrete_in_generic/src/main.nr
index 3e476107c29..1d37eca57a2 100644
--- a/test_programs/execution_success/1327_concrete_in_generic/src/main.nr
+++ b/test_programs/execution_success/1327_concrete_in_generic/src/main.nr
@@ -6,8 +6,8 @@ fn new_concrete_c_over_d() -> C<D> {
 // ---
 // Map<V>
 struct B<T_C> {
-        new_concrete_t_c_constructor: fn()->T_C,
-    }
+    new_concrete_t_c_constructor: fn() -> T_C,
+}
 
 impl<T_C> B<T_C> {
     fn new(new_concrete_t_c_constructor: fn() -> T_C) -> B<T_C> {
@@ -22,8 +22,8 @@ impl<T_C> B<T_C> {
 // ---
 // PrivateSet<Note>
 struct C<T_D> {
-        t_d_interface: MethodInterface<T_D>,
-    }
+    t_d_interface: MethodInterface<T_D>,
+}
 
 impl<T_D> C<T_D> {
     fn new(t_d_interface: MethodInterface<T_D>) -> Self {
@@ -37,13 +37,13 @@ impl<T_D> C<T_D> {
 }
 // ---
 struct MethodInterface<T_D> {
-        some_method_on_t_d: fn(T_D)->Field,
-    }
+    some_method_on_t_d: fn(T_D) -> Field,
+}
 // ---
 // Note
 struct D {
-        d: Field,
-    }
+    d: Field,
+}
 
 fn d_method(input: D) -> Field {
     input.d * input.d
diff --git a/test_programs/execution_success/4_sub/src/main.nr b/test_programs/execution_success/4_sub/src/main.nr
index 2b4fc395705..4170c2cbaf2 100644
--- a/test_programs/execution_success/4_sub/src/main.nr
+++ b/test_programs/execution_success/4_sub/src/main.nr
@@ -1,5 +1,5 @@
 // Test unsafe integer subtraction with underflow: 12 - 2418266113 = 1876701195 modulo 2^32
 fn main(mut x: u32, y: u32, z: u32) {
-    x = std::wrapping_sub(x,y);
+    x = std::wrapping_sub(x, y);
     assert(x == z);
 }
diff --git a/test_programs/execution_success/5_over/src/main.nr b/test_programs/execution_success/5_over/src/main.nr
index 6c4153e4b49..ad0a60d0a7f 100644
--- a/test_programs/execution_success/5_over/src/main.nr
+++ b/test_programs/execution_success/5_over/src/main.nr
@@ -1,7 +1,7 @@
 // Test unsafe integer arithmetic
 // Test odd bits integer
 fn main(mut x: u32, y: u32) {
-    x = std::wrapping_mul(x,x);
+    x = std::wrapping_mul(x, x);
     assert(y == x);
 
     let c: u1 = 0;
diff --git a/test_programs/execution_success/6/src/main.nr b/test_programs/execution_success/6/src/main.nr
index 8657199bd7f..5b71174614f 100644
--- a/test_programs/execution_success/6/src/main.nr
+++ b/test_programs/execution_success/6/src/main.nr
@@ -3,16 +3,9 @@
 // bytes.
 //
 // If you do not cast, it will take all the bytes from the field element!
-// Mimc input is an array of field elements
-// The function is called mimc_bn254 to emphasize its parameters are chosen for bn254 curve, it should be used only with a proving system using the same curve (e.g Plonk from Aztec)
-
 fn main(x: [u8; 5], result: pub [u8; 32]) {
     let mut digest = std::hash::sha256(x);
     digest[0] = 5 as u8;
     digest = std::hash::sha256(x);
     assert(digest == result);
-
-    let y = [12, 45, 78, 41];
-    let h = std::hash::mimc::mimc_bn254(y);
-    assert(h == 18226366069841799622585958305961373004333097209608110160936134895615261821931);
 }
diff --git a/test_programs/execution_success/6_array/src/main.nr b/test_programs/execution_success/6_array/src/main.nr
index d7180c260ff..37f6e447487 100644
--- a/test_programs/execution_success/6_array/src/main.nr
+++ b/test_programs/execution_success/6_array/src/main.nr
@@ -2,28 +2,28 @@
 fn main(x: [u32; 5], y: [u32; 5], mut z: u32, t: u32) {
     let mut c = 2301;
     z = y[4];
-    //Test 1: 
+    //Test 1:
     for i in 0..5 {
-        c = z*z*y[i];
+        c = z * z * y[i];
         z -= c;
     }
     assert(z == 0); //y[4]=0, so c and z are always 0
     //Test 2:
     c = 2301 as u32;
     for i in 0..5 {
-        c = t+2 as u32;
-        c = std::wrapping_mul(std::wrapping_mul(z,z),x[i]);
-        z =std::wrapping_add(z, std::wrapping_sub(x[i]*y[i] , c));
+        c = t + 2 as u32;
+        c = std::wrapping_mul(std::wrapping_mul(z, z), x[i]);
+        z = std::wrapping_add(z, std::wrapping_sub(x[i] * y[i], c));
     }
     assert(z == 3814912846);
     //Test 3:
     c = 2300001 as u32;
     z = y[4];
     for i in 0..5 {
-        z  = z + x[i]*y[i];
+        z = z + x[i] * y[i];
         for _i in 0..3 {
-            c = std::wrapping_sub(i as u32,2 as u32);
-            z = std::wrapping_mul(z,c);
+            c = std::wrapping_sub(i as u32, 2 as u32);
+            z = std::wrapping_mul(z, c);
         }
     }
     assert(z == 41472);
@@ -32,7 +32,7 @@ fn main(x: [u32; 5], y: [u32; 5], mut z: u32, t: u32) {
     for i in 0..3 {
         z += x[i] * y[i];
         for j in 0..2 {
-            z += x[i+j] - y[i+j];
+            z += x[i + j] - y[i + j];
         }
     }
     assert(z == 11539);
diff --git a/test_programs/execution_success/7/src/main.nr b/test_programs/execution_success/7/src/main.nr
index ad3fe1aadc8..32880aa8e41 100644
--- a/test_programs/execution_success/7/src/main.nr
+++ b/test_programs/execution_success/7/src/main.nr
@@ -2,7 +2,6 @@
 //
 // Pre-alpha dependencies must now be prefixed with the word "dep".
 // The line below indicates that we would like to pull in the standard library dependency.
-
 fn main(x: [u8; 5], result: [u8; 32]) {
     let digest = std::hash::blake2s(x);
     assert(digest == result);
diff --git a/test_programs/execution_success/7_function/src/main.nr b/test_programs/execution_success/7_function/src/main.nr
index 32227b841bd..ad065a5cae5 100644
--- a/test_programs/execution_success/7_function/src/main.nr
+++ b/test_programs/execution_success/7_function/src/main.nr
@@ -31,8 +31,8 @@ fn pow(base: Field, exponent: Field) -> Field {
     let mut r = 1 as Field;
     let b: [u1; 32] = exponent.to_le_bits();
     for i in 1..33 {
-        r = r*r;
-        r = (b[32-i] as Field) * (r * base) + (1 - b[32-i] as Field) * r;
+        r = r * r;
+        r = (b[32 - i] as Field) * (r * base) + (1 - b[32 - i] as Field) * r;
     }
     r
 }
diff --git a/test_programs/execution_success/aes128_encrypt/src/main.nr b/test_programs/execution_success/aes128_encrypt/src/main.nr
index b937c801860..3d3992971f7 100644
--- a/test_programs/execution_success/aes128_encrypt/src/main.nr
+++ b/test_programs/execution_success/aes128_encrypt/src/main.nr
@@ -15,35 +15,23 @@ unconstrained fn decode_hex<let N: u32, let M: u32>(s: str<N>) -> [u8; M] {
         if i % 2 != 0 {
             continue;
         }
-        result[i/2] = decode_ascii(as_bytes[i]) * 16 + decode_ascii(as_bytes[i + 1]);
+        result[i / 2] = decode_ascii(as_bytes[i]) * 16 + decode_ascii(as_bytes[i + 1]);
     }
     result
 }
 
 unconstrained fn cipher(plaintext: [u8; 12], iv: [u8; 16], key: [u8; 16]) -> [u8; 16] {
-    let slice_res = std::aes128::aes128_encrypt(plaintext, iv, key);
-    let mut result = [0; 16];
-    for i in 0..16 {
-        result[i] = slice_res[i];
-    }
-    result
+    let result = std::aes128::aes128_encrypt(plaintext, iv, key);
+    result.as_array()
 }
 
 fn main(inputs: str<12>, iv: str<16>, key: str<16>, output: str<32>) {
-    let result = std::aes128::aes128_encrypt(inputs.as_bytes(), iv.as_bytes(), key.as_bytes());
+    let result: [u8; 16] =
+        std::aes128::aes128_encrypt(inputs.as_bytes(), iv.as_bytes(), key.as_bytes()).as_array();
 
-    let output_bytes: [u8; 16] = unsafe {
-        let output_bytes: [u8; 16] = decode_hex(output);
-        for i in 0..16 {
-            assert(result[i] == output_bytes[i]);
-        }
-        output_bytes
-    };
+    let output_bytes: [u8; 16] = unsafe { decode_hex(output) };
+    assert(result == output_bytes);
 
-    unsafe {
-        let unconstrained_result = cipher(inputs.as_bytes(), iv.as_bytes(), key.as_bytes());
-        for i in 0..16 {
-            assert(unconstrained_result[i] == output_bytes[i]);
-        }
-    }
+    let unconstrained_result = unsafe { cipher(inputs.as_bytes(), iv.as_bytes(), key.as_bytes()) };
+    assert(unconstrained_result == output_bytes);
 }
diff --git a/test_programs/execution_success/arithmetic_binary_operations/src/main.nr b/test_programs/execution_success/arithmetic_binary_operations/src/main.nr
index 69554f413a4..3a6b0149ec1 100644
--- a/test_programs/execution_success/arithmetic_binary_operations/src/main.nr
+++ b/test_programs/execution_success/arithmetic_binary_operations/src/main.nr
@@ -1,5 +1,5 @@
 // Tests a very simple program.
-// 
+//
 // The features being tested are:
 // Binary addition, multiplication, division, constant modulo
 // x = 3, y = 4, z = 5
diff --git a/test_programs/compile_success_empty/schnorr_simplification/Nargo.toml b/test_programs/execution_success/array_dedup_regression/Nargo.toml
similarity index 62%
rename from test_programs/compile_success_empty/schnorr_simplification/Nargo.toml
rename to test_programs/execution_success/array_dedup_regression/Nargo.toml
index 599f06ac3d2..16a708743ed 100644
--- a/test_programs/compile_success_empty/schnorr_simplification/Nargo.toml
+++ b/test_programs/execution_success/array_dedup_regression/Nargo.toml
@@ -1,5 +1,5 @@
 [package]
-name = "schnorr_simplification"
+name = "array_dedup_regression"
 type = "bin"
 authors = [""]
 
diff --git a/test_programs/execution_success/array_dedup_regression/Prover.toml b/test_programs/execution_success/array_dedup_regression/Prover.toml
new file mode 100644
index 00000000000..3aea0c58ce5
--- /dev/null
+++ b/test_programs/execution_success/array_dedup_regression/Prover.toml
@@ -0,0 +1 @@
+x = 0
diff --git a/test_programs/execution_success/array_dedup_regression/src/main.nr b/test_programs/execution_success/array_dedup_regression/src/main.nr
new file mode 100644
index 00000000000..5506d55b9e7
--- /dev/null
+++ b/test_programs/execution_success/array_dedup_regression/src/main.nr
@@ -0,0 +1,21 @@
+unconstrained fn main(x: u32) {
+    let a1 = [1, 2, 3, 4, 5];
+
+    for i in 0..5 {
+        let mut a2 = [1, 2, 3, 4, 5];
+        a2[x + i] = 128;
+        println(a2);
+
+        if i != 0 {
+            assert(a2[x + i - 1] != 128);
+        }
+    }
+
+    // Can't use `== [1, 2, 3, 4, 5]` here, that make_array may get
+    // deduplicated to equal a1 in the bugged version
+    assert_eq(a1[0], 1);
+    assert_eq(a1[1], 2);
+    assert_eq(a1[2], 3);
+    assert_eq(a1[3], 4);
+    assert_eq(a1[4], 5);
+}
diff --git a/test_programs/execution_success/array_dynamic/src/main.nr b/test_programs/execution_success/array_dynamic/src/main.nr
index 6b51095bd8c..fc29c4364c9 100644
--- a/test_programs/execution_success/array_dynamic/src/main.nr
+++ b/test_programs/execution_success/array_dynamic/src/main.nr
@@ -5,7 +5,7 @@ fn main(
     index: [Field; 5],
     index2: [Field; 5],
     offset: Field,
-    sublen: Field
+    sublen: Field,
 ) {
     let idx = (z - 5 * t - 5) as Field;
     //dynamic array test
diff --git a/test_programs/execution_success/array_to_slice_constant_length/src/main.nr b/test_programs/execution_success/array_to_slice_constant_length/src/main.nr
index 5668a9ff388..09f99622939 100644
--- a/test_programs/execution_success/array_to_slice_constant_length/src/main.nr
+++ b/test_programs/execution_success/array_to_slice_constant_length/src/main.nr
@@ -1,5 +1,4 @@
 // Regression test for https://github.com/noir-lang/noir/issues/4722
-
 unconstrained fn return_array(val: Field) -> [Field; 1] {
     [val; 1]
 }
diff --git a/test_programs/execution_success/assert/src/main.nr b/test_programs/execution_success/assert/src/main.nr
index 00e94414c0b..b95665d502b 100644
--- a/test_programs/execution_success/assert/src/main.nr
+++ b/test_programs/execution_success/assert/src/main.nr
@@ -1,3 +1,10 @@
 fn main(x: Field) {
     assert(x == 1);
+    assert(1 == conditional(x as bool));
+}
+
+fn conditional(x: bool) -> Field {
+    assert(x, f"Expected x to be true but got {x}");
+    assert_eq(x, true, f"Expected x to be true but got {x}");
+    1
 }
diff --git a/test_programs/execution_success/assert_statement/src/main.nr b/test_programs/execution_success/assert_statement/src/main.nr
index 2646a0b85c2..c076f047dd8 100644
--- a/test_programs/execution_success/assert_statement/src/main.nr
+++ b/test_programs/execution_success/assert_statement/src/main.nr
@@ -1,5 +1,5 @@
 // Tests a very simple program.
-// 
+//
 // The features being tested is assertion
 fn main(x: Field, y: pub Field) {
     assert(x == y, "x and y are not equal");
diff --git a/test_programs/execution_success/assert_statement_recursive/src/main.nr b/test_programs/execution_success/assert_statement_recursive/src/main.nr
deleted file mode 100644
index d89ea3d35bb..00000000000
--- a/test_programs/execution_success/assert_statement_recursive/src/main.nr
+++ /dev/null
@@ -1,11 +0,0 @@
-// Tests a very simple program.
-// 
-// The features being tested is assertion
-// This is the same as the `assert_statement` test except we specify
-// that the backend should use a prover which will construct proofs
-// friendly to recursive verification in another SNARK.
-#[recursive]
-fn main(x: Field, y: pub Field) {
-    assert(x == y, "x and y are not equal");
-    assert_eq(x, y, "x and y are not equal");
-}
diff --git a/test_programs/execution_success/bench_2_to_17/src/main.nr b/test_programs/execution_success/bench_2_to_17/src/main.nr
index ae80dfcf0b4..204fbc38a16 100644
--- a/test_programs/execution_success/bench_2_to_17/src/main.nr
+++ b/test_programs/execution_success/bench_2_to_17/src/main.nr
@@ -1,6 +1,6 @@
 use std::hash::poseidon2;
 
-global len = 2450 * 2;
+global len: u32 = 2450 * 2;
 fn main(x: Field) {
     let ped_input = [x; len];
     let mut val = poseidon2::Poseidon2::hash(ped_input, len);
diff --git a/test_programs/execution_success/bench_ecdsa_secp256k1/src/main.nr b/test_programs/execution_success/bench_ecdsa_secp256k1/src/main.nr
index 60f182c7836..18d57d7886c 100644
--- a/test_programs/execution_success/bench_ecdsa_secp256k1/src/main.nr
+++ b/test_programs/execution_success/bench_ecdsa_secp256k1/src/main.nr
@@ -1,6 +1,7 @@
 use dep::std;
 
 fn main(hashed_message: [u8; 32], pub_key_x: [u8; 32], pub_key_y: [u8; 32], signature: [u8; 64]) {
-    let valid_signature = std::ecdsa_secp256k1::verify_signature(pub_key_x, pub_key_y, signature, hashed_message);
+    let valid_signature =
+        std::ecdsa_secp256k1::verify_signature(pub_key_x, pub_key_y, signature, hashed_message);
     assert(valid_signature);
 }
diff --git a/test_programs/execution_success/bigint/src/main.nr b/test_programs/execution_success/bigint/src/main.nr
index 8592e6fb230..5a8b9fb67ef 100644
--- a/test_programs/execution_success/bigint/src/main.nr
+++ b/test_programs/execution_success/bigint/src/main.nr
@@ -7,8 +7,8 @@ fn main(mut x: [u8; 5], y: [u8; 5]) {
     let mut a_be_bytes = [0; 32];
     let mut b_be_bytes = [0; 32];
     for i in 0..5 {
-        a_be_bytes[31-i] = x[i];
-        b_be_bytes[31-i] = y[i];
+        a_be_bytes[31 - i] = x[i];
+        b_be_bytes[31 - i] = y[i];
     }
     let a_field = std::field::bytes32_to_field(a_be_bytes);
     let b_field = std::field::bytes32_to_field(b_be_bytes);
@@ -44,15 +44,17 @@ fn main(mut x: [u8; 5], y: [u8; 5]) {
     big_int_example(x[0], x[1]);
 
     // Regression for issue #4882
-    let num_b:[u8;32] = [
-        0, 0, 0, 240, 147, 245, 225, 67, 145, 112, 185, 121, 72, 232, 51, 40, 93, 88, 129, 129, 182, 69, 80, 184, 41, 160, 49, 225, 114, 78, 100, 48
+    let num_b: [u8; 32] = [
+        0, 0, 0, 240, 147, 245, 225, 67, 145, 112, 185, 121, 72, 232, 51, 40, 93, 88, 129, 129, 182,
+        69, 80, 184, 41, 160, 49, 225, 114, 78, 100, 48,
     ];
-    let num2_b:[u8;7] = [126, 193, 45, 39, 188, 84, 11];
+    let num2_b: [u8; 7] = [126, 193, 45, 39, 188, 84, 11];
     let num = bigint::Bn254Fr::from_le_bytes(num_b.as_slice());
     let num2 = bigint::Bn254Fr::from_le_bytes(num2_b.as_slice());
 
-    let ret_b:[u8;32] = [
-        131, 62, 210, 200, 215, 160, 214, 67, 145, 112, 185, 121, 72, 232, 51, 40, 93, 88, 129, 129, 182, 69, 80, 184, 41, 160, 49, 225, 114, 78, 100, 48
+    let ret_b: [u8; 32] = [
+        131, 62, 210, 200, 215, 160, 214, 67, 145, 112, 185, 121, 72, 232, 51, 40, 93, 88, 129, 129,
+        182, 69, 80, 184, 41, 160, 49, 225, 114, 78, 100, 48,
     ];
     let ret = bigint::Bn254Fr::from_le_bytes(ret_b.as_slice());
     assert(ret == num.mul(num2));
diff --git a/test_programs/execution_success/binary_operator_overloading/src/main.nr b/test_programs/execution_success/binary_operator_overloading/src/main.nr
index c2c831d0c1e..03a4e1ed22f 100644
--- a/test_programs/execution_success/binary_operator_overloading/src/main.nr
+++ b/test_programs/execution_success/binary_operator_overloading/src/main.nr
@@ -1,5 +1,5 @@
-use std::ops::{Add, Sub, Mul, Div, Rem, BitAnd, BitOr, BitXor, Shl, Shr};
 use std::cmp::Ordering;
+use std::ops::{Add, BitAnd, BitOr, BitXor, Div, Mul, Rem, Shl, Shr, Sub};
 
 // x = 3, y = 9
 fn main(x: u32, y: u32) {
@@ -30,7 +30,7 @@ fn main(x: u32, y: u32) {
     assert((wx >= wy) == (ex >= ey));
     assert(wx.cmp(wy) == ex.cmp(ey));
 
-    // Ensure operator overloading still works with more complex types 
+    // Ensure operator overloading still works with more complex types
     let pair_ascending = Pair { x: wx, y: wy };
     let pair_descending = Pair { x: wy, y: wx };
 
@@ -45,7 +45,7 @@ fn main(x: u32, y: u32) {
 }
 
 struct Wrapper {
-    inner: u32
+    inner: u32,
 }
 
 impl Wrapper {
diff --git a/test_programs/execution_success/bit_shifts_comptime/src/main.nr b/test_programs/execution_success/bit_shifts_comptime/src/main.nr
index 6d9736b6abb..a11dae1c716 100644
--- a/test_programs/execution_success/bit_shifts_comptime/src/main.nr
+++ b/test_programs/execution_success/bit_shifts_comptime/src/main.nr
@@ -15,6 +15,10 @@ fn main(x: u64) {
     assert(x << 63 == 0);
 
     assert_eq((1 as u64) << 32, 0x0100000000);
+
+    //regression for 6201
+    let a: i16 = -769;
+    assert_eq(a >> 3, -97);
 }
 
 fn regression_2250() {
diff --git a/test_programs/execution_success/bit_shifts_runtime/Prover.toml b/test_programs/execution_success/bit_shifts_runtime/Prover.toml
index 98d8630792e..7b56d36c9d5 100644
--- a/test_programs/execution_success/bit_shifts_runtime/Prover.toml
+++ b/test_programs/execution_success/bit_shifts_runtime/Prover.toml
@@ -1,2 +1,3 @@
 x = 64
-y = 1
\ No newline at end of file
+y = 1
+z = "-769"
diff --git a/test_programs/execution_success/bit_shifts_runtime/src/main.nr b/test_programs/execution_success/bit_shifts_runtime/src/main.nr
index 059bbe84dac..370bb699048 100644
--- a/test_programs/execution_success/bit_shifts_runtime/src/main.nr
+++ b/test_programs/execution_success/bit_shifts_runtime/src/main.nr
@@ -1,4 +1,4 @@
-fn main(x: u64, y: u8) {
+fn main(x: u64, y: u8, z: i16) {
     // runtime shifts on compile-time known values
     assert(64 << y == 128);
     assert(64 >> y == 32);
@@ -17,4 +17,6 @@ fn main(x: u64, y: u8) {
     assert(a << y == -2);
 
     assert(x >> (x as u8) == 0);
+
+    assert_eq(z >> 3, -97);
 }
diff --git a/test_programs/execution_success/brillig_array_to_slice/Nargo.toml b/test_programs/execution_success/brillig_array_to_slice/Nargo.toml
deleted file mode 100644
index 58157c38c26..00000000000
--- a/test_programs/execution_success/brillig_array_to_slice/Nargo.toml
+++ /dev/null
@@ -1,7 +0,0 @@
-[package]
-name = "brillig_array_to_slice"
-type = "bin"
-authors = [""]
-compiler_version = ">=0.25.0"
-
-[dependencies]
\ No newline at end of file
diff --git a/test_programs/execution_success/brillig_array_to_slice/Prover.toml b/test_programs/execution_success/brillig_array_to_slice/Prover.toml
deleted file mode 100644
index 11497a473bc..00000000000
--- a/test_programs/execution_success/brillig_array_to_slice/Prover.toml
+++ /dev/null
@@ -1 +0,0 @@
-x = "0"
diff --git a/test_programs/execution_success/brillig_array_to_slice/src/main.nr b/test_programs/execution_success/brillig_array_to_slice/src/main.nr
deleted file mode 100644
index f54adb39963..00000000000
--- a/test_programs/execution_success/brillig_array_to_slice/src/main.nr
+++ /dev/null
@@ -1,20 +0,0 @@
-unconstrained fn brillig_as_slice(x: Field) -> (u32, Field, Field) {
-    let mut dynamic: [Field; 1] = [1];
-    dynamic[x] = 2;
-    assert(dynamic[0] == 2);
-
-    let brillig_slice = dynamic.as_slice();
-    assert(brillig_slice.len() == 1);
-
-    (brillig_slice.len(), dynamic[0], brillig_slice[0])
-}
-
-fn main(x: Field) {
-    unsafe {
-        let (slice_len, dynamic_0, slice_0) = brillig_as_slice(x);
-        assert(slice_len == 1);
-        assert(dynamic_0 == 2);
-        assert(slice_0 == 2);
-    }
-}
-
diff --git a/test_programs/execution_success/brillig_arrays/src/main.nr b/test_programs/execution_success/brillig_arrays/src/main.nr
index c7f0757f31e..00d43e2b10d 100644
--- a/test_programs/execution_success/brillig_arrays/src/main.nr
+++ b/test_programs/execution_success/brillig_arrays/src/main.nr
@@ -1,5 +1,5 @@
 // Tests a very simple program.
-// 
+//
 // The features being tested are array reads and writes
 fn main(x: [Field; 3]) {
     unsafe {
diff --git a/test_programs/execution_success/brillig_assert/Prover.toml b/test_programs/execution_success/brillig_assert/Prover.toml
deleted file mode 100644
index 4dd6b405159..00000000000
--- a/test_programs/execution_success/brillig_assert/Prover.toml
+++ /dev/null
@@ -1 +0,0 @@
-x = "1"
diff --git a/test_programs/execution_success/brillig_assert/src/main.nr b/test_programs/execution_success/brillig_assert/src/main.nr
deleted file mode 100644
index c6c39b61bc9..00000000000
--- a/test_programs/execution_success/brillig_assert/src/main.nr
+++ /dev/null
@@ -1,14 +0,0 @@
-// Tests a very simple program.
-// 
-// The features being tested is using assert on brillig
-fn main(x: Field) {
-    unsafe {
-        assert(1 == conditional(x as bool));
-    }
-}
-
-unconstrained fn conditional(x: bool) -> Field {
-    assert(x, f"Expected x to be false but got {x}");
-    assert_eq(x, true, f"Expected x to be false but got {x}");
-    1
-}
diff --git a/test_programs/execution_success/brillig_blake2s/src/main.nr b/test_programs/execution_success/brillig_blake2s/src/main.nr
index 122142a9c80..c4412bd2bba 100644
--- a/test_programs/execution_success/brillig_blake2s/src/main.nr
+++ b/test_programs/execution_success/brillig_blake2s/src/main.nr
@@ -1,5 +1,5 @@
 // Tests a very simple program.
-// 
+//
 // The features being tested is blake2s in brillig
 fn main(x: [u8; 5], result: [u8; 32]) {
     unsafe {
diff --git a/test_programs/execution_success/brillig_blake3/Nargo.toml b/test_programs/execution_success/brillig_blake3/Nargo.toml
deleted file mode 100644
index 879476dbdcf..00000000000
--- a/test_programs/execution_success/brillig_blake3/Nargo.toml
+++ /dev/null
@@ -1,7 +0,0 @@
-[package]
-name = "brillig_blake3"
-type = "bin"
-authors = [""]
-compiler_version = ">=0.22.0"
-
-[dependencies]
diff --git a/test_programs/execution_success/brillig_blake3/Prover.toml b/test_programs/execution_success/brillig_blake3/Prover.toml
deleted file mode 100644
index c807701479b..00000000000
--- a/test_programs/execution_success/brillig_blake3/Prover.toml
+++ /dev/null
@@ -1,37 +0,0 @@
-# hello as bytes
-# https://connor4312.github.io/blake3/index.html
-x = [104, 101, 108, 108, 111]
-result = [
-       0xea,
-       0x8f,
-       0x16,
-       0x3d,
-       0xb3,
-       0x86,
-       0x82,
-       0x92,
-       0x5e,
-       0x44,
-       0x91,
-       0xc5,
-       0xe5,
-       0x8d,
-       0x4b,
-       0xb3,
-       0x50,
-       0x6e,
-       0xf8,
-       0xc1,
-       0x4e,
-       0xb7,
-       0x8a,
-       0x86,
-       0xe9,
-       0x08,
-       0xc5,
-       0x62,
-       0x4a,
-       0x67,
-       0x20,
-       0x0f,
-]
diff --git a/test_programs/execution_success/brillig_blake3/src/main.nr b/test_programs/execution_success/brillig_blake3/src/main.nr
deleted file mode 100644
index 64852d775f4..00000000000
--- a/test_programs/execution_success/brillig_blake3/src/main.nr
+++ /dev/null
@@ -1,4 +0,0 @@
-unconstrained fn main(x: [u8; 5], result: [u8; 32]) {
-    let digest = std::hash::blake3(x);
-    assert(digest == result);
-}
diff --git a/test_programs/execution_success/brillig_block_parameter_liveness/src/main.nr b/test_programs/execution_success/brillig_block_parameter_liveness/src/main.nr
index 6ddfc03622a..7f04dcd4d04 100644
--- a/test_programs/execution_success/brillig_block_parameter_liveness/src/main.nr
+++ b/test_programs/execution_success/brillig_block_parameter_liveness/src/main.nr
@@ -1,5 +1,4 @@
 // Tests that we run liveness in block parameters by trying to create too many block parameters to fit in the stack
-
 // Uses up 10 stack items
 struct Inner {
     a: u64,
diff --git a/test_programs/execution_success/brillig_calls/src/main.nr b/test_programs/execution_success/brillig_calls/src/main.nr
index 3e23da53b18..c76d7651b0a 100644
--- a/test_programs/execution_success/brillig_calls/src/main.nr
+++ b/test_programs/execution_success/brillig_calls/src/main.nr
@@ -1,5 +1,5 @@
 // Tests a very simple program.
-// 
+//
 // The features being tested is brillig calls
 fn main(x: u32) {
     unsafe {
diff --git a/test_programs/execution_success/brillig_calls_array/src/main.nr b/test_programs/execution_success/brillig_calls_array/src/main.nr
index 8b27a9bb202..90f588ab988 100644
--- a/test_programs/execution_success/brillig_calls_array/src/main.nr
+++ b/test_programs/execution_success/brillig_calls_array/src/main.nr
@@ -1,5 +1,5 @@
 // Tests a very simple program.
-// 
+//
 // The features being tested is brillig calls passing arrays around
 fn main(x: [u32; 3]) {
     unsafe {
diff --git a/test_programs/execution_success/brillig_calls_conditionals/src/main.nr b/test_programs/execution_success/brillig_calls_conditionals/src/main.nr
index 318da4caf72..0fbfd84968f 100644
--- a/test_programs/execution_success/brillig_calls_conditionals/src/main.nr
+++ b/test_programs/execution_success/brillig_calls_conditionals/src/main.nr
@@ -1,5 +1,5 @@
 // Tests a very simple program.
-// 
+//
 // The features being tested is brillig calls with conditionals
 fn main(x: [u32; 3]) {
     unsafe {
diff --git a/test_programs/execution_success/brillig_conditional/src/main.nr b/test_programs/execution_success/brillig_conditional/src/main.nr
index 8ababf82319..17484f6e8c5 100644
--- a/test_programs/execution_success/brillig_conditional/src/main.nr
+++ b/test_programs/execution_success/brillig_conditional/src/main.nr
@@ -1,5 +1,5 @@
 // Tests a very simple program.
-// 
+//
 // The features being tested is basic conditonal on brillig
 fn main(x: Field) {
     unsafe {
@@ -8,5 +8,9 @@ fn main(x: Field) {
 }
 
 unconstrained fn conditional(x: bool) -> Field {
-    if x { 4 } else { 5 }
+    if x {
+        4
+    } else {
+        5
+    }
 }
diff --git a/test_programs/execution_success/brillig_constant_reference_regression/src/main.nr b/test_programs/execution_success/brillig_constant_reference_regression/src/main.nr
index c975d20a3b6..67bde87c712 100644
--- a/test_programs/execution_success/brillig_constant_reference_regression/src/main.nr
+++ b/test_programs/execution_success/brillig_constant_reference_regression/src/main.nr
@@ -1,11 +1,7 @@
 unconstrained fn main(sorted_index: [u32; 2]) {
-    let original = [
-        55,
-        11
-    ];
+    let original = [55, 11];
 
     let mut sorted = original; // Stores the constant "original" into the sorted reference
-
     for i in 0..2 {
         let index = sorted_index[i];
         let value = original[index];
diff --git a/test_programs/execution_success/brillig_cow/src/main.nr b/test_programs/execution_success/brillig_cow/src/main.nr
index 52ce8b8be3c..2dd0d4b3411 100644
--- a/test_programs/execution_success/brillig_cow/src/main.nr
+++ b/test_programs/execution_success/brillig_cow/src/main.nr
@@ -1,6 +1,5 @@
 // Tests the copy on write optimization for arrays. We look for cases where we are modifying an array in place when we shouldn't.
-
-global ARRAY_SIZE = 5;
+global ARRAY_SIZE: u32 = 5;
 
 struct ExecutionResult {
     original: [Field; ARRAY_SIZE],
@@ -23,14 +22,14 @@ fn modify_in_inlined_constrained(original: [Field; ARRAY_SIZE], index: u64) -> E
 
     let modified_once = modified;
 
-    modified[index+1] = 27;
+    modified[index + 1] = 27;
 
     ExecutionResult { original, modified_once, modified_twice: modified }
 }
 
 unconstrained fn modify_in_unconstrained(
     original: [Field; ARRAY_SIZE],
-    index: u64
+    index: u64,
 ) -> ExecutionResult {
     let mut modified = original;
 
@@ -38,7 +37,7 @@ unconstrained fn modify_in_unconstrained(
 
     let modified_once = modified;
 
-    modified[index+1] = 27;
+    modified[index + 1] = 27;
 
     ExecutionResult { original, modified_once, modified_twice: modified }
 }
diff --git a/test_programs/execution_success/brillig_cow_assign/src/main.nr b/test_programs/execution_success/brillig_cow_assign/src/main.nr
index e5c3e2bd2f5..cfa228b3a96 100644
--- a/test_programs/execution_success/brillig_cow_assign/src/main.nr
+++ b/test_programs/execution_success/brillig_cow_assign/src/main.nr
@@ -1,4 +1,4 @@
-global N = 10;
+global N: u32 = 10;
 
 unconstrained fn main() {
     let mut arr = [0; N];
@@ -14,7 +14,6 @@ unconstrained fn main() {
     // Expect:
     // arr        = [27, 27, 27, 27, 27, 27, 27, 27, 27, 27]
     // mid_change = [27, 27, 27, 27, 27, 0, 0, 0, 0, 0]
-
     let modified_i = N / 2 + 1;
     assert_eq(arr[modified_i], 27);
 
diff --git a/test_programs/execution_success/brillig_cow_regression/src/main.nr b/test_programs/execution_success/brillig_cow_regression/src/main.nr
index 3fce7fb2c7d..69273bc3dca 100644
--- a/test_programs/execution_success/brillig_cow_regression/src/main.nr
+++ b/test_programs/execution_success/brillig_cow_regression/src/main.nr
@@ -1,5 +1,4 @@
 // Tests a performance regression found in aztec-packages with brillig cow optimization
-
 global MAX_NOTE_HASHES_PER_TX: u32 = 64;
 global MAX_NULLIFIERS_PER_TX: u32 = 64;
 global MAX_L2_TO_L1_MSGS_PER_TX: u32 = 2;
@@ -8,14 +7,14 @@ global MAX_NEW_CONTRACTS_PER_TX: u32 = 1;
 global NUM_ENCRYPTED_LOGS_HASHES_PER_TX: u32 = 1;
 global NUM_UNENCRYPTED_LOGS_HASHES_PER_TX: u32 = 1;
 global NUM_FIELDS_PER_SHA256: u32 = 2;
-global TX_EFFECT_HASH_INPUT_SIZE = 169;
+global TX_EFFECT_HASH_INPUT_SIZE: u32 = 169;
 global TX_EFFECT_HASH_LOG_FIELDS: u32 = 4;
 global TX_EFFECT_HASH_FULL_FIELDS: u32 = 165;
 
 struct PublicDataUpdateRequest {
-    leaf_slot : Field,
-    old_value : Field,
-    new_value : Field
+    leaf_slot: Field,
+    old_value: Field,
+    new_value: Field,
 }
 
 struct NewContractData {
@@ -43,7 +42,7 @@ struct U256 {
     // This is in big-endian order, typically because
     // sha256 is usually in big endian order.
     // Note: this means that inner[0] has the most significant 64 bits.
-    inner : [u64; 4]
+    inner: [u64; 4],
 }
 
 impl U256 {
@@ -92,7 +91,7 @@ impl U256 {
         let two_pow_64 = 2.pow_32(64);
 
         let high = (self.inner[0] as Field) * two_pow_64 + self.inner[1] as Field;
-        let low  = (self.inner[2] as Field) * two_pow_64 + self.inner[3] as Field;
+        let low = (self.inner[2] as Field) * two_pow_64 + self.inner[3] as Field;
 
         [high, low]
     }
@@ -113,18 +112,16 @@ unconstrained fn main(kernel_data: DataToHash) -> pub [Field; NUM_FIELDS_PER_SHA
     for j in 0..MAX_NOTE_HASHES_PER_TX {
         tx_effects_hash_inputs[offset + j] = new_note_hashes[j];
     }
-    offset += MAX_NOTE_HASHES_PER_TX ;
+    offset += MAX_NOTE_HASHES_PER_TX;
 
     for j in 0..MAX_NULLIFIERS_PER_TX {
         tx_effects_hash_inputs[offset + j] = new_nullifiers[j];
     }
-    offset += MAX_NULLIFIERS_PER_TX ;
+    offset += MAX_NULLIFIERS_PER_TX;
 
     for j in 0..MAX_PUBLIC_DATA_UPDATE_REQUESTS_PER_TX {
-        tx_effects_hash_inputs[offset + j * 2] =
-                public_data_update_requests[j].leaf_slot;
-        tx_effects_hash_inputs[offset + j * 2 + 1] =
-                public_data_update_requests[j].new_value;
+        tx_effects_hash_inputs[offset + j * 2] = public_data_update_requests[j].leaf_slot;
+        tx_effects_hash_inputs[offset + j * 2 + 1] = public_data_update_requests[j].new_value;
     }
     offset += MAX_PUBLIC_DATA_UPDATE_REQUESTS_PER_TX * 2;
 
@@ -157,8 +154,8 @@ unconstrained fn main(kernel_data: DataToHash) -> pub [Field; NUM_FIELDS_PER_SHA
 
     offset += NUM_UNENCRYPTED_LOGS_HASHES_PER_TX * NUM_FIELDS_PER_SHA256;
     assert_eq(offset, TX_EFFECT_HASH_INPUT_SIZE); // Sanity check
-
-    let mut hash_input_flattened = [0; TX_EFFECT_HASH_FULL_FIELDS * 32 + TX_EFFECT_HASH_LOG_FIELDS * 16];
+    let mut hash_input_flattened =
+        [0; TX_EFFECT_HASH_FULL_FIELDS * 32 + TX_EFFECT_HASH_LOG_FIELDS * 16];
     for offset in 0..TX_EFFECT_HASH_FULL_FIELDS {
         let input_as_bytes: [u8; 32] = tx_effects_hash_inputs[offset].to_be_bytes();
         for byte_index in 0..32 {
@@ -167,9 +164,11 @@ unconstrained fn main(kernel_data: DataToHash) -> pub [Field; NUM_FIELDS_PER_SHA
     }
 
     for log_field_index in 0..TX_EFFECT_HASH_LOG_FIELDS {
-        let input_as_bytes: [u8; 16] = tx_effects_hash_inputs[TX_EFFECT_HASH_FULL_FIELDS + log_field_index].to_be_bytes();
+        let input_as_bytes: [u8; 16] =
+            tx_effects_hash_inputs[TX_EFFECT_HASH_FULL_FIELDS + log_field_index].to_be_bytes();
         for byte_index in 0..16 {
-            hash_input_flattened[TX_EFFECT_HASH_FULL_FIELDS * 32 + log_field_index * 16 + byte_index] = input_as_bytes[byte_index];
+            hash_input_flattened[TX_EFFECT_HASH_FULL_FIELDS * 32 + log_field_index * 16 + byte_index] =
+                input_as_bytes[byte_index];
         }
     }
 
diff --git a/test_programs/execution_success/brillig_ecdsa_secp256k1/Prover.toml b/test_programs/execution_success/brillig_ecdsa_secp256k1/Prover.toml
deleted file mode 100644
index e78fc19cb71..00000000000
--- a/test_programs/execution_success/brillig_ecdsa_secp256k1/Prover.toml
+++ /dev/null
@@ -1,169 +0,0 @@
-
-hashed_message = [
-    0x3a,
-    0x73,
-    0xf4,
-    0x12,
-    0x3a,
-    0x5c,
-    0xd2,
-    0x12,
-    0x1f,
-    0x21,
-    0xcd,
-    0x7e,
-    0x8d,
-    0x35,
-    0x88,
-    0x35,
-    0x47,
-    0x69,
-    0x49,
-    0xd0,
-    0x35,
-    0xd9,
-    0xc2,
-    0xda,
-    0x68,
-    0x06,
-    0xb4,
-    0x63,
-    0x3a,
-    0xc8,
-    0xc1,
-    0xe2,
-]
-pub_key_x = [
-    0xa0,
-    0x43,
-    0x4d,
-    0x9e,
-    0x47,
-    0xf3,
-    0xc8,
-    0x62,
-    0x35,
-    0x47,
-    0x7c,
-    0x7b,
-    0x1a,
-    0xe6,
-    0xae,
-    0x5d,
-    0x34,
-    0x42,
-    0xd4,
-    0x9b,
-    0x19,
-    0x43,
-    0xc2,
-    0xb7,
-    0x52,
-    0xa6,
-    0x8e,
-    0x2a,
-    0x47,
-    0xe2,
-    0x47,
-    0xc7,
-]
-pub_key_y = [
-    0x89,
-    0x3a,
-    0xba,
-    0x42,
-    0x54,
-    0x19,
-    0xbc,
-    0x27,
-    0xa3,
-    0xb6,
-    0xc7,
-    0xe6,
-    0x93,
-    0xa2,
-    0x4c,
-    0x69,
-    0x6f,
-    0x79,
-    0x4c,
-    0x2e,
-    0xd8,
-    0x77,
-    0xa1,
-    0x59,
-    0x3c,
-    0xbe,
-    0xe5,
-    0x3b,
-    0x03,
-    0x73,
-    0x68,
-    0xd7,
-]
-signature = [
-    0xe5,
-    0x08,
-    0x1c,
-    0x80,
-    0xab,
-    0x42,
-    0x7d,
-    0xc3,
-    0x70,
-    0x34,
-    0x6f,
-    0x4a,
-    0x0e,
-    0x31,
-    0xaa,
-    0x2b,
-    0xad,
-    0x8d,
-    0x97,
-    0x98,
-    0xc3,
-    0x80,
-    0x61,
-    0xdb,
-    0x9a,
-    0xe5,
-    0x5a,
-    0x4e,
-    0x8d,
-    0xf4,
-    0x54,
-    0xfd,
-    0x28,
-    0x11,
-    0x98,
-    0x94,
-    0x34,
-    0x4e,
-    0x71,
-    0xb7,
-    0x87,
-    0x70,
-    0xcc,
-    0x93,
-    0x1d,
-    0x61,
-    0xf4,
-    0x80,
-    0xec,
-    0xbb,
-    0x0b,
-    0x89,
-    0xd6,
-    0xeb,
-    0x69,
-    0x69,
-    0x01,
-    0x61,
-    0xe4,
-    0x9a,
-    0x71,
-    0x5f,
-    0xcd,
-    0x55,
-]
diff --git a/test_programs/execution_success/brillig_ecdsa_secp256k1/src/main.nr b/test_programs/execution_success/brillig_ecdsa_secp256k1/src/main.nr
deleted file mode 100644
index 45f13c79637..00000000000
--- a/test_programs/execution_success/brillig_ecdsa_secp256k1/src/main.nr
+++ /dev/null
@@ -1,17 +0,0 @@
-// Tests a very simple program.
-// 
-// The features being tested is ecdsa in brillig
-fn main(hashed_message: [u8; 32], pub_key_x: [u8; 32], pub_key_y: [u8; 32], signature: [u8; 64]) {
-    unsafe {
-        assert(ecdsa(hashed_message, pub_key_x, pub_key_y, signature));
-    }
-}
-
-unconstrained fn ecdsa(
-    hashed_message: [u8; 32],
-    pub_key_x: [u8; 32],
-    pub_key_y: [u8; 32],
-    signature: [u8; 64]
-) -> bool {
-    std::ecdsa_secp256k1::verify_signature(pub_key_x, pub_key_y, signature, hashed_message)
-}
diff --git a/test_programs/execution_success/brillig_ecdsa_secp256r1/Prover.toml b/test_programs/execution_success/brillig_ecdsa_secp256r1/Prover.toml
deleted file mode 100644
index a45f799877b..00000000000
--- a/test_programs/execution_success/brillig_ecdsa_secp256r1/Prover.toml
+++ /dev/null
@@ -1,20 +0,0 @@
-hashed_message = [
-    84, 112, 91, 163, 186, 175, 219, 223, 186, 140, 95, 154, 112, 247, 168, 155, 238, 152,
-    217, 6, 181, 62, 49, 7, 77, 167, 186, 236, 220, 13, 169, 173,
-]
-pub_key_x = [
-    85, 15, 71, 16, 3, 243, 223, 151, 195, 223, 80, 106, 199, 151, 246, 114, 31, 177, 161,
-    251, 123, 143, 111, 131, 210, 36, 73, 138, 101, 200, 142, 36,
-]
-pub_key_y = [
-    19, 96, 147, 215, 1, 46, 80, 154, 115, 113, 92, 189, 11, 0, 163, 204, 15, 244, 181,
-    192, 27, 63, 250, 25, 106, 177, 251, 50, 112, 54, 184, 230,
-]
-signature = [
-    44,  112, 168, 208, 132, 182, 43,  252, 92,  224, 54, 65, 202, 249, 247, 42,
-    212, 218, 140, 129, 191, 230, 236, 148, 135, 187, 94, 27, 239, 98,  161, 50,
-    24,  173, 158, 226, 158, 175, 53,  31,  220, 80,  241, 82,  12,  66, 94, 155,
-    144, 138, 7,   39,  139, 67,  176, 236, 123, 135, 39,  120, 193, 78, 7,  132 
-]
-
-
diff --git a/test_programs/execution_success/brillig_ecdsa_secp256r1/src/main.nr b/test_programs/execution_success/brillig_ecdsa_secp256r1/src/main.nr
deleted file mode 100644
index 32b562ec50c..00000000000
--- a/test_programs/execution_success/brillig_ecdsa_secp256r1/src/main.nr
+++ /dev/null
@@ -1,17 +0,0 @@
-// Tests a very simple program.
-// 
-// The features being tested is ecdsa in brillig
-fn main(hashed_message: [u8; 32], pub_key_x: [u8; 32], pub_key_y: [u8; 32], signature: [u8; 64]) {
-    unsafe {
-        assert(ecdsa(hashed_message, pub_key_x, pub_key_y, signature));
-    }
-}
-
-unconstrained fn ecdsa(
-    hashed_message: [u8; 32],
-    pub_key_x: [u8; 32],
-    pub_key_y: [u8; 32],
-    signature: [u8; 64]
-) -> bool {
-    std::ecdsa_secp256r1::verify_signature(pub_key_x, pub_key_y, signature, hashed_message)
-}
diff --git a/test_programs/execution_success/brillig_fns_as_values/src/main.nr b/test_programs/execution_success/brillig_fns_as_values/src/main.nr
index 55b9d307905..03a92b4b10d 100644
--- a/test_programs/execution_success/brillig_fns_as_values/src/main.nr
+++ b/test_programs/execution_success/brillig_fns_as_values/src/main.nr
@@ -1,5 +1,5 @@
 struct MyStruct {
-    operation: unconstrained fn (u32) -> u32,
+    operation: unconstrained fn(u32) -> u32,
 }
 
 fn main(x: u32) {
diff --git a/test_programs/execution_success/brillig_hash_to_field/Nargo.toml b/test_programs/execution_success/brillig_hash_to_field/Nargo.toml
deleted file mode 100644
index 7cfcc745f0d..00000000000
--- a/test_programs/execution_success/brillig_hash_to_field/Nargo.toml
+++ /dev/null
@@ -1,6 +0,0 @@
-[package]
-name = "brillig_hash_to_field"
-type = "bin"
-authors = [""]
-
-[dependencies]
diff --git a/test_programs/execution_success/brillig_hash_to_field/Prover.toml b/test_programs/execution_success/brillig_hash_to_field/Prover.toml
deleted file mode 100644
index ecdcfd1fb00..00000000000
--- a/test_programs/execution_success/brillig_hash_to_field/Prover.toml
+++ /dev/null
@@ -1 +0,0 @@
-input = "27"
\ No newline at end of file
diff --git a/test_programs/execution_success/brillig_hash_to_field/src/main.nr b/test_programs/execution_success/brillig_hash_to_field/src/main.nr
deleted file mode 100644
index d1ea635d49a..00000000000
--- a/test_programs/execution_success/brillig_hash_to_field/src/main.nr
+++ /dev/null
@@ -1,12 +0,0 @@
-// Tests a very simple program.
-// 
-// The features being tested is hash_to_field in brillig
-fn main(input: Field) -> pub Field {
-    unsafe {
-        hash_to_field(input)
-    }
-}
-
-unconstrained fn hash_to_field(input: Field) -> Field {
-    std::hash::hash_to_field(&[input])
-}
diff --git a/test_programs/execution_success/brillig_identity_function/src/main.nr b/test_programs/execution_success/brillig_identity_function/src/main.nr
index c2759fe054f..f3b45d0de4e 100644
--- a/test_programs/execution_success/brillig_identity_function/src/main.nr
+++ b/test_programs/execution_success/brillig_identity_function/src/main.nr
@@ -3,7 +3,7 @@ struct myStruct {
     foo_arr: [Field; 2],
 }
 // Tests a very simple program.
-// 
+//
 // The features being tested is the identity function in Brillig
 fn main(x: Field) {
     unsafe {
diff --git a/test_programs/execution_success/brillig_keccak/Prover.toml b/test_programs/execution_success/brillig_keccak/Prover.toml
deleted file mode 100644
index d65c4011d3f..00000000000
--- a/test_programs/execution_success/brillig_keccak/Prover.toml
+++ /dev/null
@@ -1,35 +0,0 @@
-x = 0xbd
-result = [
-        0x5a,
-        0x50,
-        0x2f,
-        0x9f,
-        0xca,
-        0x46,
-        0x7b,
-        0x26,
-        0x6d,
-        0x5b,
-        0x78,
-        0x33,
-        0x65,
-        0x19,
-        0x37,
-        0xe8,
-        0x05,
-        0x27,
-        0x0c,
-        0xa3,
-        0xf3,
-        0xaf,
-        0x1c,
-        0x0d,
-        0xd2,
-        0x46,
-        0x2d,
-        0xca,
-        0x4b,
-        0x3b,
-        0x1a,
-        0xbf,
-]
diff --git a/test_programs/execution_success/brillig_keccak/src/main.nr b/test_programs/execution_success/brillig_keccak/src/main.nr
deleted file mode 100644
index 9674ed92942..00000000000
--- a/test_programs/execution_success/brillig_keccak/src/main.nr
+++ /dev/null
@@ -1,26 +0,0 @@
-// Tests a very simple program.
-// 
-// The features being tested is keccak256 in brillig
-fn main(x: Field, result: [u8; 32]) {
-    unsafe {
-        // We use the `as` keyword here to denote the fact that we want to take just the first byte from the x Field
-        // The padding is taken care of by the program
-        let digest = keccak256([x as u8], 1);
-        assert(digest == result);
-        //#1399: variable message size
-        let message_size = 4;
-        let hash_a = keccak256([1, 2, 3, 4], message_size);
-        let hash_b = keccak256([1, 2, 3, 4, 0, 0, 0, 0], message_size);
-
-        assert(hash_a == hash_b);
-
-        let message_size_big = 8;
-        let hash_c = keccak256([1, 2, 3, 4, 0, 0, 0, 0], message_size_big);
-
-        assert(hash_a != hash_c);
-    }
-}
-
-unconstrained fn keccak256<let N: u32>(data: [u8; N], msg_len: u32) -> [u8; 32] {
-    std::hash::keccak256(data, msg_len)
-}
diff --git a/test_programs/execution_success/brillig_loop/Prover.toml b/test_programs/execution_success/brillig_loop/Prover.toml
deleted file mode 100644
index 22cd5b7c12f..00000000000
--- a/test_programs/execution_success/brillig_loop/Prover.toml
+++ /dev/null
@@ -1 +0,0 @@
-sum = "6"
diff --git a/test_programs/execution_success/brillig_loop/src/main.nr b/test_programs/execution_success/brillig_loop/src/main.nr
deleted file mode 100644
index 770660bb2a1..00000000000
--- a/test_programs/execution_success/brillig_loop/src/main.nr
+++ /dev/null
@@ -1,25 +0,0 @@
-// Tests a very simple program.
-// 
-// The features being tested is basic looping on brillig
-fn main(sum: u32) {
-    unsafe {
-        assert(loop(4) == sum);
-        assert(plain_loop() == sum);
-    }
-}
-
-unconstrained fn loop(x: u32) -> u32 {
-    let mut sum = 0;
-    for i in 0..x {
-        sum = sum + i;
-    }
-    sum
-}
-
-unconstrained fn plain_loop() -> u32 {
-    let mut sum = 0;
-    for i in 0..4 {
-        sum = sum + i;
-    }
-    sum
-}
diff --git a/test_programs/execution_success/brillig_loop_size_regression/src/main.nr b/test_programs/execution_success/brillig_loop_size_regression/src/main.nr
index 488304114b9..88c6544dcaa 100644
--- a/test_programs/execution_success/brillig_loop_size_regression/src/main.nr
+++ b/test_programs/execution_success/brillig_loop_size_regression/src/main.nr
@@ -5,7 +5,8 @@ struct EnumEmulation {
 }
 
 unconstrained fn main() -> pub Field {
-    let mut emulated_enum = EnumEmulation { a: Option::some(1), b: Option::none(), c: Option::none() };
+    let mut emulated_enum =
+        EnumEmulation { a: Option::some(1), b: Option::none(), c: Option::none() };
 
     for _ in 0..1 {
         assert_eq(emulated_enum.a.unwrap(), 1);
diff --git a/test_programs/execution_success/brillig_not/src/main.nr b/test_programs/execution_success/brillig_not/src/main.nr
index 557d1e2e31f..4e61b6a54ea 100644
--- a/test_programs/execution_success/brillig_not/src/main.nr
+++ b/test_programs/execution_success/brillig_not/src/main.nr
@@ -1,5 +1,5 @@
 // Tests a very simple Brillig function.
-// 
+//
 // The features being tested is not instruction on brillig
 fn main(x: Field, y: Field) {
     unsafe {
diff --git a/test_programs/execution_success/brillig_oracle/src/main.nr b/test_programs/execution_success/brillig_oracle/src/main.nr
index 93465b87389..8f5b2fa7566 100644
--- a/test_programs/execution_success/brillig_oracle/src/main.nr
+++ b/test_programs/execution_success/brillig_oracle/src/main.nr
@@ -15,8 +15,12 @@ fn main(_x: Field) {
         }
 
         // TODO: this method of returning a slice feels hacky.
-        let _ = OracleMock::mock("get_number_sequence").with_params(size).returns((20, mock_oracle_response));
-        let _ = OracleMock::mock("get_reverse_number_sequence").with_params(size).returns((20, reversed_mock_oracle_response));
+        let _ = OracleMock::mock("get_number_sequence").with_params(size).returns((
+            20, mock_oracle_response,
+        ));
+        let _ = OracleMock::mock("get_reverse_number_sequence").with_params(size).returns((
+            20, reversed_mock_oracle_response,
+        ));
 
         get_number_sequence_wrapper(size as Field);
     }
diff --git a/test_programs/execution_success/brillig_pedersen/src/main.nr b/test_programs/execution_success/brillig_pedersen/src/main.nr
index 17c79f9d0ae..55f81882bd4 100644
--- a/test_programs/execution_success/brillig_pedersen/src/main.nr
+++ b/test_programs/execution_success/brillig_pedersen/src/main.nr
@@ -1,4 +1,11 @@
-unconstrained fn main(x: Field, y: Field, salt: Field, out_x: Field, out_y: Field, out_hash: Field) {
+unconstrained fn main(
+    x: Field,
+    y: Field,
+    salt: Field,
+    out_x: Field,
+    out_y: Field,
+    out_hash: Field,
+) {
     let res = std::hash::pedersen_commitment_with_separator([x, y], 0);
     assert(res.x == out_x);
     assert(res.y == out_y);
diff --git a/test_programs/execution_success/brillig_recursion/src/main.nr b/test_programs/execution_success/brillig_recursion/src/main.nr
index c69468013b1..5354777a1de 100644
--- a/test_programs/execution_success/brillig_recursion/src/main.nr
+++ b/test_programs/execution_success/brillig_recursion/src/main.nr
@@ -1,5 +1,5 @@
 // Tests a very simple program.
-// 
+//
 // The feature being tested is brillig recursion
 fn main(x: u32) {
     unsafe {
diff --git a/test_programs/execution_success/brillig_references/Nargo.toml b/test_programs/execution_success/brillig_references/Nargo.toml
deleted file mode 100644
index 0f64b862ba0..00000000000
--- a/test_programs/execution_success/brillig_references/Nargo.toml
+++ /dev/null
@@ -1,6 +0,0 @@
-[package]
-name = "brillig_references"
-type = "bin"
-authors = [""]
-
-[dependencies]
diff --git a/test_programs/execution_success/brillig_references/src/main.nr b/test_programs/execution_success/brillig_references/src/main.nr
deleted file mode 100644
index e1f906beb0a..00000000000
--- a/test_programs/execution_success/brillig_references/src/main.nr
+++ /dev/null
@@ -1,49 +0,0 @@
-unconstrained fn main(mut x: Field) {
-    add1(&mut x);
-    assert(x == 3);
-    // https://github.com/noir-lang/noir/issues/1899
-    // let mut s = S { y: x };
-    // s.add2();
-    // assert(s.y == 5);
-    // Test that normal mutable variables are still copied
-    let mut a = 0;
-    mutate_copy(a);
-    assert(a == 0);
-    // Test something 3 allocations deep
-    let mut nested_allocations = Nested { y: &mut &mut 0 };
-    add1(*nested_allocations.y);
-    assert(**nested_allocations.y == 1);
-    // Test nested struct allocations with a mutable reference to an array.
-    let mut c = C { foo: 0, bar: &mut C2 { array: &mut [1, 2] } };
-    *c.bar.array = [3, 4];
-    let arr: [Field; 2] = *c.bar.array;
-    assert(arr[0] == 3);
-    assert(arr[1] == 4);
-}
-
-unconstrained fn add1(x: &mut Field) {
-    *x += 1;
-}
-
-struct S { y: Field }
-
-struct Nested { y: &mut &mut Field }
-
-struct C {
-    foo: Field,
-    bar: &mut C2,
-}
-
-struct C2 {
-    array: &mut [Field; 2]
-}
-
-impl S {
-    unconstrained fn add2(&mut self) {
-        self.y += 2;
-    }
-}
-
-unconstrained fn mutate_copy(mut a: Field) {
-    a = 7;
-}
diff --git a/test_programs/execution_success/brillig_sha256/Prover.toml b/test_programs/execution_success/brillig_sha256/Prover.toml
deleted file mode 100644
index 374ae90ad78..00000000000
--- a/test_programs/execution_success/brillig_sha256/Prover.toml
+++ /dev/null
@@ -1,35 +0,0 @@
-x = 0xbd
-result = [
-        0x68,
-        0x32,
-        0x57,
-        0x20,
-        0xaa,
-        0xbd,
-        0x7c,
-        0x82,
-        0xf3,
-        0x0f,
-        0x55,
-        0x4b,
-        0x31,
-        0x3d,
-        0x05,
-        0x70,
-        0xc9,
-        0x5a,
-        0xcc,
-        0xbb,
-        0x7d,
-        0xc4,
-        0xb5,
-        0xaa,
-        0xe1,
-        0x12,
-        0x04,
-        0xc0,
-        0x8f,
-        0xfe,
-        0x73,
-        0x2b,
-]
diff --git a/test_programs/execution_success/brillig_sha256/src/main.nr b/test_programs/execution_success/brillig_sha256/src/main.nr
deleted file mode 100644
index 5519fb2da64..00000000000
--- a/test_programs/execution_success/brillig_sha256/src/main.nr
+++ /dev/null
@@ -1,15 +0,0 @@
-// Tests a very simple program.
-// 
-// The features being tested is sha256 in brillig
-fn main(x: Field, result: [u8; 32]) {
-    unsafe {
-        assert(result == sha256(x));
-    }
-}
-
-unconstrained fn sha256(x: Field) -> [u8; 32] {
-    // We use the `as` keyword here to denote the fact that we want to take just the first byte from the x Field
-    // The padding is taken care of by the program
-    std::hash::sha256([x as u8])
-}
-
diff --git a/test_programs/execution_success/brillig_slices/Nargo.toml b/test_programs/execution_success/brillig_slices/Nargo.toml
deleted file mode 100644
index 5f6caad088a..00000000000
--- a/test_programs/execution_success/brillig_slices/Nargo.toml
+++ /dev/null
@@ -1,5 +0,0 @@
-[package]
-name = "brillig_slices"
-type = "bin"
-authors = [""]
-[dependencies]
diff --git a/test_programs/execution_success/brillig_slices/Prover.toml b/test_programs/execution_success/brillig_slices/Prover.toml
deleted file mode 100644
index f28f2f8cc48..00000000000
--- a/test_programs/execution_success/brillig_slices/Prover.toml
+++ /dev/null
@@ -1,2 +0,0 @@
-x = "5"
-y = "10"
diff --git a/test_programs/execution_success/brillig_slices/src/main.nr b/test_programs/execution_success/brillig_slices/src/main.nr
deleted file mode 100644
index 89f838a3a57..00000000000
--- a/test_programs/execution_success/brillig_slices/src/main.nr
+++ /dev/null
@@ -1,140 +0,0 @@
-use std::slice;
-unconstrained fn main(x: Field, y: Field) {
-    let mut slice: [Field] = &[y, x];
-    assert(slice.len() == 2);
-
-    slice = slice.push_back(7);
-    assert(slice.len() == 3);
-    assert(slice[0] == y);
-    assert(slice[1] == x);
-    assert(slice[2] == 7);
-    // Array set on slice target
-    slice[0] = x;
-    slice[1] = y;
-    slice[2] = 1;
-
-    assert(slice[0] == x);
-    assert(slice[1] == y);
-    assert(slice[2] == 1);
-
-    slice = push_front_to_slice(slice, 2);
-    assert(slice.len() == 4);
-    assert(slice[0] == 2);
-    assert(slice[1] == x);
-    assert(slice[2] == y);
-    assert(slice[3] == 1);
-
-    let (item, popped_front_slice) = slice.pop_front();
-    slice = popped_front_slice;
-    assert(item == 2);
-
-    assert(slice.len() == 3);
-    assert(slice[0] == x);
-    assert(slice[1] == y);
-    assert(slice[2] == 1);
-
-    let (popped_back_slice, another_item) = slice.pop_back();
-    slice = popped_back_slice;
-    assert(another_item == 1);
-
-    assert(slice.len() == 2);
-    assert(slice[0] == x);
-    assert(slice[1] == y);
-
-    slice = slice.insert(1, 2);
-    assert(slice.len() == 3);
-    assert(slice[0] == x);
-    assert(slice[1] == 2);
-    assert(slice[2] == y);
-
-    let (removed_slice, should_be_2) = slice.remove(1);
-    slice = removed_slice;
-    assert(should_be_2 == 2);
-
-    assert(slice.len() == 2);
-    assert(slice[0] == x);
-    assert(slice[1] == y);
-
-    let (slice_with_only_x, should_be_y) = slice.remove(1);
-    slice = slice_with_only_x;
-    assert(should_be_y == y);
-
-    assert(slice.len() == 1);
-    assert(slice[0] == x);
-
-    let (empty_slice, should_be_x) = slice.remove(0);
-    assert(should_be_x == x);
-    assert(empty_slice.len() == 0);
-
-    regression_merge_slices(x, y);
-}
-// Tests slice passing to/from functions
-unconstrained fn push_front_to_slice<T>(slice: [T], item: T) -> [T] {
-    slice.push_front(item)
-}
-// The parameters to this function must come from witness values (inputs to main)
-unconstrained fn regression_merge_slices(x: Field, y: Field) {
-    merge_slices_if(x, y);
-    merge_slices_else(x);
-}
-
-unconstrained fn merge_slices_if(x: Field, y: Field) {
-    let slice = merge_slices_return(x, y);
-    assert(slice[2] == 10);
-    assert(slice.len() == 3);
-
-    let slice = merge_slices_mutate(x, y);
-    assert(slice[3] == 5);
-    assert(slice.len() == 4);
-
-    let slice = merge_slices_mutate_in_loop(x, y);
-    assert(slice[6] == 4);
-    assert(slice.len() == 7);
-}
-
-unconstrained fn merge_slices_else(x: Field) {
-    let slice = merge_slices_return(x, 5);
-    assert(slice[0] == 0);
-    assert(slice[1] == 0);
-    assert(slice.len() == 2);
-
-    let slice = merge_slices_mutate(x, 5);
-    assert(slice[2] == 5);
-    assert(slice.len() == 3);
-
-    let slice = merge_slices_mutate_in_loop(x, 5);
-    assert(slice[2] == 5);
-    assert(slice.len() == 3);
-}
-// Test returning a merged slice without a mutation
-unconstrained fn merge_slices_return(x: Field, y: Field) -> [Field] {
-    let slice = &[0; 2];
-    if x != y {
-        if x != 20 { slice.push_back(y) } else { slice }
-    } else {
-        slice
-    }
-}
-// Test mutating a slice inside of an if statement
-unconstrained fn merge_slices_mutate(x: Field, y: Field) -> [Field] {
-    let mut slice = &[0; 2];
-    if x != y {
-        slice = slice.push_back(y);
-        slice = slice.push_back(x);
-    } else {
-        slice = slice.push_back(x);
-    }
-    slice
-}
-// Test mutating a slice inside of a loop in an if statement
-unconstrained fn merge_slices_mutate_in_loop(x: Field, y: Field) -> [Field] {
-    let mut slice = &[0; 2];
-    if x != y {
-        for i in 0..5 {
-            slice = slice.push_back(i as Field);
-        }
-    } else {
-        slice = slice.push_back(x);
-    }
-    slice
-}
diff --git a/test_programs/execution_success/brillig_uninitialized_arrays/Nargo.toml b/test_programs/execution_success/brillig_uninitialized_arrays/Nargo.toml
new file mode 100644
index 00000000000..68bcf9929cc
--- /dev/null
+++ b/test_programs/execution_success/brillig_uninitialized_arrays/Nargo.toml
@@ -0,0 +1,6 @@
+[package]
+name = "brillig_uninitialized_arrays"
+type = "bin"
+authors = [""]
+
+[dependencies]
diff --git a/test_programs/execution_success/brillig_unitialised_arrays/Prover.toml b/test_programs/execution_success/brillig_uninitialized_arrays/Prover.toml
similarity index 100%
rename from test_programs/execution_success/brillig_unitialised_arrays/Prover.toml
rename to test_programs/execution_success/brillig_uninitialized_arrays/Prover.toml
diff --git a/test_programs/execution_success/brillig_unitialised_arrays/src/main.nr b/test_programs/execution_success/brillig_uninitialized_arrays/src/main.nr
similarity index 100%
rename from test_programs/execution_success/brillig_unitialised_arrays/src/main.nr
rename to test_programs/execution_success/brillig_uninitialized_arrays/src/main.nr
diff --git a/test_programs/execution_success/brillig_unitialised_arrays/Nargo.toml b/test_programs/execution_success/brillig_unitialised_arrays/Nargo.toml
deleted file mode 100644
index f23ecc787d0..00000000000
--- a/test_programs/execution_success/brillig_unitialised_arrays/Nargo.toml
+++ /dev/null
@@ -1,6 +0,0 @@
-[package]
-name = "brillig_unitialised_arrays"
-type = "bin"
-authors = [""]
-
-[dependencies]
diff --git a/test_programs/execution_success/check_large_field_bits/Nargo.toml b/test_programs/execution_success/check_large_field_bits/Nargo.toml
new file mode 100644
index 00000000000..33d5dd66484
--- /dev/null
+++ b/test_programs/execution_success/check_large_field_bits/Nargo.toml
@@ -0,0 +1,7 @@
+[package]
+name = "check_large_field_bits"
+type = "bin"
+authors = [""]
+compiler_version = ">=0.35.0"
+
+[dependencies]
diff --git a/test_programs/execution_success/check_large_field_bits/src/main.nr b/test_programs/execution_success/check_large_field_bits/src/main.nr
new file mode 100644
index 00000000000..8022ea138ed
--- /dev/null
+++ b/test_programs/execution_success/check_large_field_bits/src/main.nr
@@ -0,0 +1,51 @@
+// 2^32 + 1
+global A: Field = 4294967297;
+global B: Field = 4294967297;
+
+// 2^33 + 2
+global C: Field = A + B;
+
+fn main() {
+    // 2 * (2^32 + 1) == 2^33 + 2
+    assert(C == 8589934594);
+
+    let mut leading_zeroes = 0;
+    let mut stop = false;
+    let bits: [u1; 64] = C.to_be_bits();
+    for i in 0..64 {
+        if (bits[i] == 0) & !stop {
+            leading_zeroes += 1;
+        } else {
+            stop = true;
+        }
+    }
+    let size = 64 - leading_zeroes;
+
+    // 8589934594 has 34 bits
+    assert(size == 34);
+    C.assert_max_bit_size::<34>();
+
+    assert(
+        C.to_be_bits()
+            == [
+                1, 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, 0,
+            ],
+    );
+
+    // leading big-endian bits past 34 are 0's
+    assert(
+        C.to_be_bits()
+            == [
+                0, 1, 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, 0,
+            ],
+    );
+    assert(
+        C.to_be_bits()
+            == [
+                0, 0, 1, 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, 0,
+            ],
+    );
+}
diff --git a/test_programs/execution_success/closures_mut_ref/src/main.nr b/test_programs/execution_success/closures_mut_ref/src/main.nr
index 5a743d1b633..bff2649aead 100644
--- a/test_programs/execution_success/closures_mut_ref/src/main.nr
+++ b/test_programs/execution_success/closures_mut_ref/src/main.nr
@@ -1,13 +1,9 @@
 fn main(mut x: Field) {
     let one = 1;
-    let add1 = |z| {
-        *z = *z + one;
-    };
+    let add1 = |z| { *z = *z + one; };
 
     let two = 2;
-    let add2 = |z| {
-        *z = *z + two;
-    };
+    let add2 = |z| { *z = *z + two; };
 
     add1(&mut x);
     assert(x == 1);
diff --git a/test_programs/execution_success/comptime_slice_equality/src/main.nr b/test_programs/execution_success/comptime_slice_equality/src/main.nr
index 83f82fca06f..e39e1fe0fb8 100644
--- a/test_programs/execution_success/comptime_slice_equality/src/main.nr
+++ b/test_programs/execution_success/comptime_slice_equality/src/main.nr
@@ -1,6 +1,5 @@
 fn main() {
-    comptime
-    {
+    comptime {
         assert_eq(&[1], &[1]);
     }
 }
diff --git a/test_programs/execution_success/conditional_1/src/main.nr b/test_programs/execution_success/conditional_1/src/main.nr
index e7d780263b8..eedb8a697d1 100644
--- a/test_programs/execution_success/conditional_1/src/main.nr
+++ b/test_programs/execution_success/conditional_1/src/main.nr
@@ -25,10 +25,10 @@ fn main(a: u32, mut c: [u32; 4], x: [u8; 5], result: pub [u8; 32]) {
             for j in 0..4 {
                 data[i + j] = c[4 - 1 - j];
                 for k in 0..4 {
-                    ba = ba +data[k];
+                    ba = ba + data[k];
                 }
                 if ba == 4864 {
-                    c[3]=ba;
+                    c[3] = ba;
                 }
             }
         }
@@ -84,7 +84,7 @@ fn main(a: u32, mut c: [u32; 4], x: [u8; 5], result: pub [u8; 32]) {
     x = a - a;
     for i in 0..4 {
         if c[i] == 0 {
-            x = i as u32 +2;
+            x = i as u32 + 2;
         }
     }
     assert(x == 0);
diff --git a/test_programs/execution_success/conditional_regression_547/src/main.nr b/test_programs/execution_success/conditional_regression_547/src/main.nr
index e47d23516a5..7c09e6a2e20 100644
--- a/test_programs/execution_success/conditional_regression_547/src/main.nr
+++ b/test_programs/execution_success/conditional_regression_547/src/main.nr
@@ -12,5 +12,9 @@ fn main(x: Field) -> pub Field {
 }
 
 fn safe_inverse(n: Field) -> Field {
-    if n == 0 { 0 } else { 1 / n }
+    if n == 0 {
+        0
+    } else {
+        1 / n
+    }
 }
diff --git a/test_programs/execution_success/conditional_regression_661/src/main.nr b/test_programs/execution_success/conditional_regression_661/src/main.nr
index 26521a88358..1036acc6da4 100644
--- a/test_programs/execution_success/conditional_regression_661/src/main.nr
+++ b/test_programs/execution_success/conditional_regression_661/src/main.nr
@@ -22,7 +22,7 @@ fn issue_661_foo(array: [u32; 4], b: u32) -> [u32; 1] {
 
 fn issue_661_bar(a: [u32; 4]) -> [u32; 4] {
     let mut b: [u32; 4] = [0; 4];
-    b[0]=a[0]+1;
+    b[0] = a[0] + 1;
     b
 }
 
diff --git a/test_programs/execution_success/databus_composite_calldata/Nargo.toml b/test_programs/execution_success/databus_composite_calldata/Nargo.toml
new file mode 100644
index 00000000000..38c916e5d97
--- /dev/null
+++ b/test_programs/execution_success/databus_composite_calldata/Nargo.toml
@@ -0,0 +1,6 @@
+[package]
+name = "databus_composite_calldata"
+type = "bin"
+authors = [""]
+
+[dependencies]
diff --git a/test_programs/execution_success/databus_composite_calldata/Prover.toml b/test_programs/execution_success/databus_composite_calldata/Prover.toml
new file mode 100644
index 00000000000..ab154c13372
--- /dev/null
+++ b/test_programs/execution_success/databus_composite_calldata/Prover.toml
@@ -0,0 +1,11 @@
+zero = "0"
+one = "1"
+values = [[["12", "33"], ["37", "11"]],[["14", "37"], ["30", "10"]],[["10", "30"], ["30", "10"]]]
+
+[[foos]]
+x = 1
+y = [1,2,3,4,5,6,7,8,9,0]
+
+[[foos]]
+x = 2
+y = [1,2,3,5,6,8,7,8,9,0]
\ No newline at end of file
diff --git a/test_programs/execution_success/databus_composite_calldata/src/main.nr b/test_programs/execution_success/databus_composite_calldata/src/main.nr
new file mode 100644
index 00000000000..fe6e2ed613a
--- /dev/null
+++ b/test_programs/execution_success/databus_composite_calldata/src/main.nr
@@ -0,0 +1,16 @@
+struct Foo {
+    x: u32,
+    y: [u32; 10],
+}
+
+fn main(
+    foos: call_data(0) [Foo; 2],
+    values: call_data(0) [[[u32; 2]; 2]; 3],
+    zero: u32,
+    one: u32,
+) -> pub u32 {
+    assert_eq(foos[zero].x + 1, foos[one].x);
+    assert_eq(foos[zero].y[3] + 2, foos[one].y[4]);
+    assert_eq(values[zero][one][zero], values[one][zero][one]);
+    foos[zero].x + foos[one].y[0]
+}
diff --git a/test_programs/execution_success/databus_in_fn_with_empty_arr/Nargo.toml b/test_programs/execution_success/databus_in_fn_with_empty_arr/Nargo.toml
new file mode 100644
index 00000000000..7c5caf7c771
--- /dev/null
+++ b/test_programs/execution_success/databus_in_fn_with_empty_arr/Nargo.toml
@@ -0,0 +1,6 @@
+[package]
+name = "databus_in_fn_with_empty_arr"
+type = "bin"
+authors = [""]
+
+[dependencies]
diff --git a/test_programs/execution_success/databus_in_fn_with_empty_arr/Prover.toml b/test_programs/execution_success/databus_in_fn_with_empty_arr/Prover.toml
new file mode 100644
index 00000000000..e84e0dd7eec
--- /dev/null
+++ b/test_programs/execution_success/databus_in_fn_with_empty_arr/Prover.toml
@@ -0,0 +1,3 @@
+_empty = []
+value_1 = "1"
+value_2 = "2"
diff --git a/test_programs/execution_success/databus_in_fn_with_empty_arr/src/main.nr b/test_programs/execution_success/databus_in_fn_with_empty_arr/src/main.nr
new file mode 100644
index 00000000000..85671978a33
--- /dev/null
+++ b/test_programs/execution_success/databus_in_fn_with_empty_arr/src/main.nr
@@ -0,0 +1,3 @@
+fn main(_empty: [u32; 0], value_1: u32, value_2: call_data(0) u32) {
+    assert_eq(value_1 + 1, value_2);
+}
diff --git a/test_programs/execution_success/databus_two_calldata/src/main.nr b/test_programs/execution_success/databus_two_calldata/src/main.nr
index 75df2a0953c..f19852ae8a0 100644
--- a/test_programs/execution_success/databus_two_calldata/src/main.nr
+++ b/test_programs/execution_success/databus_two_calldata/src/main.nr
@@ -1,6 +1,10 @@
-// An simple program demonstrating two calldata array inputs and a single return data array. As an arbitrary example, 
+// An simple program demonstrating two calldata array inputs and a single return data array. As an arbitrary example,
 // the return data is computed as a linear combination of the calldata.
-fn main(mut x: [u32; 4], y: call_data(0) [u32; 3], z: call_data(1) [u32; 4]) -> return_data [u32; 4] {
+fn main(
+    mut x: [u32; 4],
+    y: call_data(0) [u32; 3],
+    z: call_data(1) [u32; 4],
+) -> return_data [u32; 4] {
     let mut result = [0; 4];
     for i in 0..3 {
         let idx = x[i];
diff --git a/test_programs/execution_success/debug_logs/src/main.nr b/test_programs/execution_success/debug_logs/src/main.nr
index d1314406068..14344b1700b 100644
--- a/test_programs/execution_success/debug_logs/src/main.nr
+++ b/test_programs/execution_success/debug_logs/src/main.nr
@@ -6,7 +6,6 @@ fn main(x: Field, y: pub Field) {
     // let fmt_str: fmtstr<14, (Field, Field)> = f"i: {x}, j: {y}";
     // let fmt_fmt_str = f"fmtstr: {fmt_str}, i: {x}";
     // println(fmt_fmt_str);
-
     // A `fmtstr` lets you easily perform string interpolation.
     let fmt_str: fmtstr<14, (Field, Field)> = f"i: {x}, j: {y}";
 
@@ -83,7 +82,9 @@ fn string_with_generics<let N: u32, T>(string: fmtstr<N, T>) -> fmtstr<N, T> {
     string
 }
 
-fn string_with_partial_generics<let N: u32, T>(string: fmtstr<N, (Field, T)>) -> fmtstr<N, (Field, T)> {
+fn string_with_partial_generics<let N: u32, T>(
+    string: fmtstr<N, (Field, T)>,
+) -> fmtstr<N, (Field, T)> {
     string
 }
 
@@ -98,12 +99,10 @@ struct fooStruct {
 }
 
 fn regression_2903() {
-    let v : [str<1>; 1] = ["1"; 1];
+    let v: [str<1>; 1] = ["1"; 1];
     println(v); // will print [1]
-
     let a = v[0];
     println(a); // will print `1`
-
     let bytes = ["aaa", "bbb", "ccc"];
     println(bytes);
 }
@@ -121,7 +120,9 @@ fn regression_2906() {
     let label_five_vals = "12345";
     println(f"label_five_vals: {label_five_vals}");
 
-    println(f"array_five_vals: {array_five_vals}, label_five_vals: {label_five_vals}");
+    println(
+        f"array_five_vals: {array_five_vals}, label_five_vals: {label_five_vals}",
+    );
 }
 
 fn regression_4967() {
@@ -132,6 +133,8 @@ fn regression_4967() {
     println(slice_of_tuples);
 
     let slice_of_tuples_coerced: [(i32, u8)] = [(11, 22), (33, 44)];
-    println(f"slice_of_tuples: {slice_of_tuples_coerced}, sentinel: {sentinel}");
+    println(
+        f"slice_of_tuples: {slice_of_tuples_coerced}, sentinel: {sentinel}",
+    );
     println(slice_of_tuples_coerced);
 }
diff --git a/test_programs/execution_success/derive/src/main.nr b/test_programs/execution_success/derive/src/main.nr
index f2f467eb761..f7d4f6b607a 100644
--- a/test_programs/execution_success/derive/src/main.nr
+++ b/test_programs/execution_success/derive/src/main.nr
@@ -6,7 +6,9 @@ trait DoNothing {
 }
 
 #[derive(DoNothing)]
-struct MyStruct { my_field: u32 }
+struct MyStruct {
+    my_field: u32,
+}
 
 comptime fn derive_do_nothing(s: StructDefinition) -> Quoted {
     let typ = s.as_type();
@@ -23,6 +25,14 @@ comptime fn derive_do_nothing(s: StructDefinition) -> Quoted {
 
 // Test stdlib derive fns & multiple traits
 // - We can derive Ord and Hash even though std::cmp::Ordering and std::hash::Hasher aren't imported
+// - We need to define MyOtherOtherStruct first since MyOtherStruct references it as a field and
+//   attributes are run in reading order. If it were defined afterward, the derived Eq impl for MyOtherStruct
+//   would error that MyOtherOtherStruct doesn't (yet) implement Eq.
+#[derive(Eq, Default, Hash, Ord)]
+struct MyOtherOtherStruct<T> {
+    x: T,
+}
+
 #[derive(Eq, Default, Hash, Ord)]
 struct MyOtherStruct<A, B> {
     field1: A,
@@ -31,12 +41,7 @@ struct MyOtherStruct<A, B> {
 }
 
 #[derive(Eq, Default, Hash, Ord)]
-struct MyOtherOtherStruct<T> {
-    x: T,
-}
-
-#[derive(Eq, Default, Hash, Ord)]
-struct EmptyStruct { }
+struct EmptyStruct {}
 
 fn main() {
     let s = MyStruct { my_field: 1 };
@@ -49,8 +54,16 @@ fn main() {
     assert_eq(o, o);
 
     // Field & str<2> above don't implement Ord
-    let o1 = MyOtherStruct { field1: 12 as u32, field2: 24 as i8, field3: MyOtherOtherStruct { x: 54 as i8 } };
-    let o2 = MyOtherStruct { field1: 12 as u32, field2: 24 as i8, field3: MyOtherOtherStruct { x: 55 as i8 } };
+    let o1 = MyOtherStruct {
+        field1: 12 as u32,
+        field2: 24 as i8,
+        field3: MyOtherOtherStruct { x: 54 as i8 },
+    };
+    let o2 = MyOtherStruct {
+        field1: 12 as u32,
+        field2: 24 as i8,
+        field3: MyOtherOtherStruct { x: 55 as i8 },
+    };
     assert(o1 < o2);
 
     let mut hasher = TestHasher { result: 0 };
diff --git a/test_programs/execution_success/diamond_deps_0/Prover.toml b/test_programs/execution_success/diamond_deps_0/Prover.toml
index a713241e7dd..2bad103177c 100644
--- a/test_programs/execution_success/diamond_deps_0/Prover.toml
+++ b/test_programs/execution_success/diamond_deps_0/Prover.toml
@@ -1,3 +1,3 @@
 x = 1
 y = 1
-return = 5
\ No newline at end of file
+return = 7
diff --git a/test_programs/execution_success/brillig_ecdsa_secp256k1/Nargo.toml b/test_programs/execution_success/double_verify_honk_proof/Nargo.toml
similarity index 61%
rename from test_programs/execution_success/brillig_ecdsa_secp256k1/Nargo.toml
rename to test_programs/execution_success/double_verify_honk_proof/Nargo.toml
index 495a49f2247..5f819990c72 100644
--- a/test_programs/execution_success/brillig_ecdsa_secp256k1/Nargo.toml
+++ b/test_programs/execution_success/double_verify_honk_proof/Nargo.toml
@@ -1,5 +1,5 @@
 [package]
-name = "brillig_ecdsa_secp256k1"
+name = "double_verify_honk_proof"
 type = "bin"
 authors = [""]
 
diff --git a/test_programs/execution_success/double_verify_honk_proof/Prover.toml b/test_programs/execution_success/double_verify_honk_proof/Prover.toml
new file mode 100644
index 00000000000..f8e7ba41a18
--- /dev/null
+++ b/test_programs/execution_success/double_verify_honk_proof/Prover.toml
@@ -0,0 +1,5 @@
+key_hash = "0x0000000000000000000000000000000000000000000000000000000000000000"
+proof = ["0x0000000000000000000000000000000000000000000000000000000000000040", "0x0000000000000000000000000000000000000000000000000000000000000011", "0x0000000000000000000000000000000000000000000000000000000000000001", "0x0000000000000000000000000000000000000000000000042ab5d6d1986846cf", "0x00000000000000000000000000000000000000000000000b75c020998797da78", "0x0000000000000000000000000000000000000000000000005a107acb64952eca", "0x000000000000000000000000000000000000000000000000000031e97a575e9d", "0x00000000000000000000000000000000000000000000000b5666547acf8bd5a4", "0x00000000000000000000000000000000000000000000000c410db10a01750aeb", "0x00000000000000000000000000000000000000000000000d722669117f9758a4", "0x000000000000000000000000000000000000000000000000000178cbf4206471", "0x000000000000000000000000000000000000000000000000e91b8a11e7842c38", "0x000000000000000000000000000000000000000000000007fd51009034b3357f", "0x000000000000000000000000000000000000000000000009889939f81e9c7402", "0x0000000000000000000000000000000000000000000000000000f94656a2ca48", "0x000000000000000000000000000000000000000000000006fb128b46c1ddb67f", "0x0000000000000000000000000000000000000000000000093fe27776f50224bd", "0x000000000000000000000000000000000000000000000004a0c80c0da527a081", "0x0000000000000000000000000000000000000000000000000001b52c2020d746", "0x0000000000000000000000000000005a9bae947e1e91af9e4033d8d6aa6ed632", "0x000000000000000000000000000000000025e485e013446d4ac7981c88ba6ecc", "0x000000000000000000000000000000ff1e0496e30ab24a63b32b2d1120b76e62", "0x00000000000000000000000000000000001afe0a8a685d7cd85d1010e55d9d7c", "0x000000000000000000000000000000b0804efd6573805f991458295f510a2004", "0x00000000000000000000000000000000000c81a178016e2fe18605022d5a8b0e", "0x000000000000000000000000000000eba51e76eb1cfff60a53a0092a3c3dea47", "0x000000000000000000000000000000000022e7466247b533282f5936ac4e6c15", "0x00000000000000000000000000000071b1d76edf770edff98f00ff4deec264cd", "0x00000000000000000000000000000000001e48128e68794d8861fcbb2986a383", "0x000000000000000000000000000000d3a2af4915ae6d86b097adc377fafda2d4", "0x000000000000000000000000000000000006359de9ca452dab3a4f1f8d9c9d98", "0x0000000000000000000000000000006cf7dd96d7636fda5953191b1ad776d491", "0x00000000000000000000000000000000001633d881a08d136e834cb13a28fcc6", "0x00000000000000000000000000000001254956cff6908b069fca0e6cf1c47eb1", "0x000000000000000000000000000000000006f4d4dd3890e997e75e75886bf8f7", "0x0000000000000000000000000000006cf7dd96d7636fda5953191b1ad776d491", "0x00000000000000000000000000000000001633d881a08d136e834cb13a28fcc6", "0x00000000000000000000000000000001254956cff6908b069fca0e6cf1c47eb1", "0x000000000000000000000000000000000006f4d4dd3890e997e75e75886bf8f7", "0x000000000000000000000000000000f968b227a358a305607f3efc933823d288", "0x00000000000000000000000000000000000eaf8adb390375a76d95e918b65e08", "0x000000000000000000000000000000bb34b4b447aae56f5e24f81c3acd6d547f", "0x00000000000000000000000000000000002175d012746260ebcfe339a91a81e1", "0x00000000000000000000000000000052eebbd1f6f7554e837f60c44000ed14b6", "0x00000000000000000000000000000000001c1c045a3ec94b8801f2272cc0b3f4", "0x0000000000000000000000000000004d2ef74134578f6b431a9df071ffca4292", "0x0000000000000000000000000000000000291326ade7aa6f0dfc8900eab5580b", "0x0000000000000000000000000000002433eec6418a6dba820c9527e2581fc8bc", "0x00000000000000000000000000000000000e88b7daad19af2ac2f9bdf9e50ee2", "0x000000000000000000000000000000dcfce2c427155cc3e4d035735d3dd5ece8", "0x00000000000000000000000000000000002d7d473cac1a15d0fee8b22c1a7b3e", "0x1a4249b90be4602c8ff40c7c276160ee41b2a0f8a238ce7706e9face2db03d48", "0x162204b9d54d3ffd285c393a5a1ff76ee681474fd780a21a3cf7fac5c24fc2b9", "0x30279eb953d8ee79b2155c69c04e6443c5de6bf7e02886256dd7b3cd3c9502a4", "0x0d32c1bd21baf43e72d5d82d461ef54833807ff81a877adc822f27a6db88d754", "0x0fe15e055c0803d5ebe6dd77689b70cfd82138f008810ce24535c992daaff27d", "0x1fba82c012671212ce2fc13fd09bf8fba4f7d5875ab8d37495d1ccfcff287331", "0x090738a5842fa4d2699b3726aa0dd97cb59569b4be2c6825335ec4969f859dc2", "0x0c6cb72dabbc28abcf4a50c203534e066c29f48c24ca64d672092f263df3f9d7", "0x0f27fbea0d9145f815c288b50fe7e8c10b8185d325b5264624fd57102855d05d", "0x2a815cd3fd1c43c72ee0130465250ff771d1e7be2347e4ada331b83265a03450", "0x148b4ecf2ad7ed17409417086867ee27bc1b0906dbc9cbb3714c285071e2db70", "0x08e700a42b1d6d36ee65f8ebedf47d3a44463ff9fa579dce13b7492e20142c3a", "0x2e23c69521d572ff2152c50f8c9a9191535f4cf37f95f1e0428692e78842b642", "0x14519e0354365923fb41400c19866135b45e975d56a0980260bc99f0390b1d5f", "0x04caded1f05738f736cb5bcf08d785e395e58eb7738523a20638aa16bc51593e", "0x28787eaccd38383215ea21ec02895c32d979f68ca155f534a2e2d377bff6698b", "0x20a1b81fa96c58cf11c5762c5ceb731efdcb081fca2d34d5c463d2cf40e6da18", "0x11789a06fe3bf53833741d180f068d29534d5bb58a5c64b8119542e62b189fb4", "0x23d00fcd032ace719ffcbc513bfa177a55b04377d76455c2788d999d05d011e2", "0x01f0e81b57b4a73cc118e51ede18f8724debf25c2d109db6ef45280f99f1a3fa", "0x156d1c9b61749810de728f259c2c1c1fd4dbff97101426e26087ca461c93307c", "0x1c5d619ac3a478cfd06d5eebfd879960bb321236be173813f5e78d1366d32c69", "0x250cfae4e1dfc551406f1f3d10b649a637dcb7bcb0f6f697994cf96afd35d0c1", "0x242b999f58cf5f53c874d1092bd38725aa9ea076f5bc8f176efa9ea23393874b", "0x2e15748255c4a5e0e9fe38047341b692a967257de27a85a3a38681bc9f1602ea", "0x01ef83886ea7017253699cb6371988eb8e21b4f7023d7479ece4907fe6d4a6fd", "0x08db2dbc271e375b9312f695c59c48f313235b3432cad50921c8d9ad6dd7ad7a", "0x199309f2c2cd45c15a4abb0e6554a1615ff5a6e9488a8d900bbf835fc8f664ef", "0x074be7a3d88e31ab1b59c9208c012bcfb1f85f351c709e68134996891db52b57", "0x301b1011354d2ebf46134fc4d6d734bb6ed8542d719f38f5e09a376a580cad7f", "0x12968f3eccaa27e44f14d5aaac6ecb70c00d040e07536292e685d7cab03fc563", "0x2110a023c8c22fd2ed70270a2d0a265b92a32ce2217ffe1be9a5d7d5c25f512f", "0x1e8cf4c60c53900f0430d5b44de5804fe8b38299bc803beeb4216e1a289cf624", "0x12301cb908ccb28a2616e29b831ec7105b5d3ebf45ff5fe91d50a9dd53a50b52", "0x0f1029ed107d84ff2d6d4a416cbd01da3f3d7bf5b2209ce93ba424f4b85616fc", "0x1b431d016611b8abd684afd9e92331c3325967b1116bfa91d4f44e2f8e2c9fc2", "0x281e335a0fd117064c8ace3f01e02b134a19e9b9220571ebfaaaa0e3a12d34db", "0x22559c106f77e2ae95677d5e38e288343e3b7168371aec7d3aaab9ef8150af70", "0x13f113b1d9b590149cf08c3f6e90589cda5c7b98528866b891256cb9d5d814e7", "0x10252ef388e4c80246962e98b9e976fab2cd25e1e6f1e3fd2a7d4786c5218a97", "0x16b890723dfdebd9912a9207255f95cb800222165b6fae97ec46e461f23e83f3", "0x25caf77c7d2e8e069341ec90f3c8f6d64319cfd2d77cab0625cf0377285ba11c", "0x016c84288b0bc3c50eebbe250cdd5a4ee50b2c65a24ac64d0c930cbdecb95141", "0x20a537c045b069d47dc6315f45b391f60681222381e5059ec7c8b17bf677d911", "0x2594c0edfcd4064d215a3d797bc8e3b2f401c61f3961ae96ccbec8f8fd29e81f", "0x1c831d7047483ca00ed59bdb84c47ffb8bbebbae92aa164c7b35fcffbb8a35d3", "0x2ea7f60de52b8cd6b0bd06f861fc1f2c5ed1d1fbfa53caccdb836400a03df434", "0x275c6c8bd115f7d2ce196439e2330fad305c6745bab0bf1ce3f2fa32dadc3c43", "0x0000000000000000000000000000000000000000000000000000000000000000", "0x0000000000000000000000000000000000000000000000000000000000000000", "0x0000000000000000000000000000000000000000000000000000000000000000", "0x0000000000000000000000000000000000000000000000000000000000000000", "0x0000000000000000000000000000000000000000000000000000000000000000", "0x0000000000000000000000000000000000000000000000000000000000000000", "0x0000000000000000000000000000000000000000000000000000000000000000", "0x0000000000000000000000000000000000000000000000000000000000000000", "0x0000000000000000000000000000000000000000000000000000000000000000", "0x0000000000000000000000000000000000000000000000000000000000000000", "0x0000000000000000000000000000000000000000000000000000000000000000", "0x0000000000000000000000000000000000000000000000000000000000000000", "0x0000000000000000000000000000000000000000000000000000000000000000", "0x0000000000000000000000000000000000000000000000000000000000000000", "0x0000000000000000000000000000000000000000000000000000000000000000", "0x0000000000000000000000000000000000000000000000000000000000000000", "0x0000000000000000000000000000000000000000000000000000000000000000", "0x0000000000000000000000000000000000000000000000000000000000000000", "0x0000000000000000000000000000000000000000000000000000000000000000", "0x0000000000000000000000000000000000000000000000000000000000000000", "0x0000000000000000000000000000000000000000000000000000000000000000", "0x0000000000000000000000000000000000000000000000000000000000000000", "0x0000000000000000000000000000000000000000000000000000000000000000", "0x0000000000000000000000000000000000000000000000000000000000000000", "0x0000000000000000000000000000000000000000000000000000000000000000", "0x0000000000000000000000000000000000000000000000000000000000000000", "0x0000000000000000000000000000000000000000000000000000000000000000", "0x0000000000000000000000000000000000000000000000000000000000000000", "0x0000000000000000000000000000000000000000000000000000000000000000", "0x0000000000000000000000000000000000000000000000000000000000000000", "0x0000000000000000000000000000000000000000000000000000000000000000", "0x0000000000000000000000000000000000000000000000000000000000000000", "0x0000000000000000000000000000000000000000000000000000000000000000", "0x0000000000000000000000000000000000000000000000000000000000000000", "0x0000000000000000000000000000000000000000000000000000000000000000", "0x0000000000000000000000000000000000000000000000000000000000000000", "0x0000000000000000000000000000000000000000000000000000000000000000", "0x0000000000000000000000000000000000000000000000000000000000000000", "0x0000000000000000000000000000000000000000000000000000000000000000", "0x0000000000000000000000000000000000000000000000000000000000000000", "0x0000000000000000000000000000000000000000000000000000000000000000", "0x0000000000000000000000000000000000000000000000000000000000000000", "0x0000000000000000000000000000000000000000000000000000000000000000", "0x0000000000000000000000000000000000000000000000000000000000000000", "0x0000000000000000000000000000000000000000000000000000000000000000", "0x0000000000000000000000000000000000000000000000000000000000000000", "0x0000000000000000000000000000000000000000000000000000000000000000", "0x0000000000000000000000000000000000000000000000000000000000000000", "0x0000000000000000000000000000000000000000000000000000000000000000", "0x0000000000000000000000000000000000000000000000000000000000000000", "0x0000000000000000000000000000000000000000000000000000000000000000", "0x0000000000000000000000000000000000000000000000000000000000000000", "0x0000000000000000000000000000000000000000000000000000000000000000", "0x0000000000000000000000000000000000000000000000000000000000000000", "0x0000000000000000000000000000000000000000000000000000000000000000", "0x0000000000000000000000000000000000000000000000000000000000000000", "0x0000000000000000000000000000000000000000000000000000000000000000", "0x0000000000000000000000000000000000000000000000000000000000000000", "0x0000000000000000000000000000000000000000000000000000000000000000", "0x0000000000000000000000000000000000000000000000000000000000000000", "0x0000000000000000000000000000000000000000000000000000000000000000", "0x0000000000000000000000000000000000000000000000000000000000000000", "0x0000000000000000000000000000000000000000000000000000000000000000", "0x0000000000000000000000000000000000000000000000000000000000000000", "0x0000000000000000000000000000000000000000000000000000000000000000", "0x0000000000000000000000000000000000000000000000000000000000000000", "0x0000000000000000000000000000000000000000000000000000000000000000", "0x0000000000000000000000000000000000000000000000000000000000000000", "0x0000000000000000000000000000000000000000000000000000000000000000", "0x0000000000000000000000000000000000000000000000000000000000000000", "0x0000000000000000000000000000000000000000000000000000000000000000", "0x0000000000000000000000000000000000000000000000000000000000000000", "0x0000000000000000000000000000000000000000000000000000000000000000", "0x0000000000000000000000000000000000000000000000000000000000000000", "0x0000000000000000000000000000000000000000000000000000000000000000", "0x0000000000000000000000000000000000000000000000000000000000000000", "0x0000000000000000000000000000000000000000000000000000000000000000", "0x0000000000000000000000000000000000000000000000000000000000000000", "0x0000000000000000000000000000000000000000000000000000000000000000", "0x0000000000000000000000000000000000000000000000000000000000000000", "0x0000000000000000000000000000000000000000000000000000000000000000", "0x0000000000000000000000000000000000000000000000000000000000000000", "0x0000000000000000000000000000000000000000000000000000000000000000", "0x0000000000000000000000000000000000000000000000000000000000000000", "0x0000000000000000000000000000000000000000000000000000000000000000", "0x0000000000000000000000000000000000000000000000000000000000000000", "0x0000000000000000000000000000000000000000000000000000000000000000", "0x0000000000000000000000000000000000000000000000000000000000000000", "0x0000000000000000000000000000000000000000000000000000000000000000", "0x0000000000000000000000000000000000000000000000000000000000000000", "0x0000000000000000000000000000000000000000000000000000000000000000", "0x0000000000000000000000000000000000000000000000000000000000000000", "0x0000000000000000000000000000000000000000000000000000000000000000", "0x0000000000000000000000000000000000000000000000000000000000000000", "0x0000000000000000000000000000000000000000000000000000000000000000", "0x0000000000000000000000000000000000000000000000000000000000000000", "0x0000000000000000000000000000000000000000000000000000000000000000", "0x0000000000000000000000000000000000000000000000000000000000000000", "0x0000000000000000000000000000000000000000000000000000000000000000", "0x0000000000000000000000000000000000000000000000000000000000000000", "0x0000000000000000000000000000000000000000000000000000000000000000", "0x0000000000000000000000000000000000000000000000000000000000000000", "0x0000000000000000000000000000000000000000000000000000000000000000", "0x0000000000000000000000000000000000000000000000000000000000000000", "0x0000000000000000000000000000000000000000000000000000000000000000", "0x0000000000000000000000000000000000000000000000000000000000000000", "0x0000000000000000000000000000000000000000000000000000000000000000", "0x0000000000000000000000000000000000000000000000000000000000000000", "0x0000000000000000000000000000000000000000000000000000000000000000", "0x0000000000000000000000000000000000000000000000000000000000000000", "0x0000000000000000000000000000000000000000000000000000000000000000", "0x0000000000000000000000000000000000000000000000000000000000000000", "0x0000000000000000000000000000000000000000000000000000000000000000", "0x0000000000000000000000000000000000000000000000000000000000000000", "0x0000000000000000000000000000000000000000000000000000000000000000", "0x0000000000000000000000000000000000000000000000000000000000000000", "0x0000000000000000000000000000000000000000000000000000000000000000", "0x0000000000000000000000000000000000000000000000000000000000000000", "0x0000000000000000000000000000000000000000000000000000000000000000", "0x0000000000000000000000000000000000000000000000000000000000000000", "0x0000000000000000000000000000000000000000000000000000000000000000", "0x0000000000000000000000000000000000000000000000000000000000000000", "0x0000000000000000000000000000000000000000000000000000000000000000", "0x0000000000000000000000000000000000000000000000000000000000000000", "0x0000000000000000000000000000000000000000000000000000000000000000", "0x0000000000000000000000000000000000000000000000000000000000000000", "0x0000000000000000000000000000000000000000000000000000000000000000", "0x0000000000000000000000000000000000000000000000000000000000000000", "0x0000000000000000000000000000000000000000000000000000000000000000", "0x0000000000000000000000000000000000000000000000000000000000000000", "0x0000000000000000000000000000000000000000000000000000000000000000", "0x0000000000000000000000000000000000000000000000000000000000000000", "0x0000000000000000000000000000000000000000000000000000000000000000", "0x0000000000000000000000000000000000000000000000000000000000000000", "0x0000000000000000000000000000000000000000000000000000000000000000", "0x0000000000000000000000000000000000000000000000000000000000000000", "0x0000000000000000000000000000000000000000000000000000000000000000", "0x0000000000000000000000000000000000000000000000000000000000000000", "0x0000000000000000000000000000000000000000000000000000000000000000", "0x0000000000000000000000000000000000000000000000000000000000000000", "0x0000000000000000000000000000000000000000000000000000000000000000", "0x0000000000000000000000000000000000000000000000000000000000000000", "0x0000000000000000000000000000000000000000000000000000000000000000", "0x0000000000000000000000000000000000000000000000000000000000000000", "0x0000000000000000000000000000000000000000000000000000000000000000", "0x0000000000000000000000000000000000000000000000000000000000000000", "0x0000000000000000000000000000000000000000000000000000000000000000", "0x0000000000000000000000000000000000000000000000000000000000000000", "0x0000000000000000000000000000000000000000000000000000000000000000", "0x0000000000000000000000000000000000000000000000000000000000000000", "0x0000000000000000000000000000000000000000000000000000000000000000", "0x0000000000000000000000000000000000000000000000000000000000000000", "0x0000000000000000000000000000000000000000000000000000000000000000", "0x0000000000000000000000000000000000000000000000000000000000000000", "0x0000000000000000000000000000000000000000000000000000000000000000", "0x0000000000000000000000000000000000000000000000000000000000000000", "0x0000000000000000000000000000000000000000000000000000000000000000", "0x0000000000000000000000000000000000000000000000000000000000000000", "0x0000000000000000000000000000000000000000000000000000000000000000", "0x0000000000000000000000000000000000000000000000000000000000000000", "0x0000000000000000000000000000000000000000000000000000000000000000", "0x0000000000000000000000000000000000000000000000000000000000000000", "0x0000000000000000000000000000000000000000000000000000000000000000", "0x0000000000000000000000000000000000000000000000000000000000000000", "0x0000000000000000000000000000000000000000000000000000000000000000", "0x0000000000000000000000000000000000000000000000000000000000000000", "0x0000000000000000000000000000000000000000000000000000000000000000", "0x0000000000000000000000000000000000000000000000000000000000000000", "0x0000000000000000000000000000000000000000000000000000000000000000", "0x0000000000000000000000000000000000000000000000000000000000000000", "0x0000000000000000000000000000000000000000000000000000000000000000", "0x0000000000000000000000000000000000000000000000000000000000000000", "0x0000000000000000000000000000000000000000000000000000000000000000", "0x0000000000000000000000000000000000000000000000000000000000000000", "0x0000000000000000000000000000000000000000000000000000000000000000", "0x0000000000000000000000000000000000000000000000000000000000000000", "0x2b3f4e210619347288731e7f0eea1ae60dd8696fe87319044864d099a03a9536", "0x0fecd3d2aebedeb8be2b0b7e3a74de9ec8bd2cb72851541463729e0715aef48b", "0x10bee385ad0c2cd3ff88ef4d630840749e4367f9add4a300fc4f545a7778e92c", "0x1fe792730eeafbd22c4eb80e86e2b40108b1e55b2a08db786289eea5745b9e3b", "0x04d411679da432816b213cd5580dda1fd6c2f258684c036be19b5b26baca583c", "0x159f17b655d2b8a803e0cfb564918628be52d3baa950ca1b127854491624f8f4", "0x225340463867d9252a1269013536e2e1dd219aa18eadef13c324b63d44679334", "0x1885e231554e02abb40ed54b72ebf09b883d0298a6bc06fc645a30365f370ef2", "0x233344517f25170972b8ba35d01f2df2e073d322993abce7df26796126e93498", "0x08990e8faa13b18b4433ec417c5cc596885e11ffd372d5f612c08cc79a5d5c80", "0x1e960a0c892b755c28e21dcbed816c1b182d7da43bae07f8ee622bd4485f79e7", "0x27b58e2ee290a179d349ace82752528b2ff946d60c092b99ef42f53c25d0c99f", "0x2a5cf8a3193107d982edd253002c7a52ab876b445dde8307ab78fbdca022d93c", "0x2b1ab4d5277f8c82750c1c7bd043889b71465ec64a9afc1bfa37d06b1ebd0725", "0x2a0dbf5c4373a58a83d5f2a031ea0615bf12800e33b70c3191a7cbb15966ced8", "0x1f272bb4a19d14a0abdfebc9fc83125e10623b9aef730f8d25f2bf5bead38ea9", "0x2c2339cf0ae7aff56091a568c1e2c3f01f52d8ed13400737fd31eaabcaffb9bd", "0x21f5fefe6b5fa0b5da71089befb74a1a39e52b4f830cb330c3c284e154614dfd", "0x1e6f6ba4b2444586b380dc4e2b3fad111ff1f4754420a846f53ea0789ebfb0ad", "0x1193d170b0b2dd0c4a04331a4b4aa3f12920f182ec3ab547837e30f1116ca584", "0x00000000000000000000000000000025704a15c9e2ce8a69558e7bbcdcbc7784", "0x2e5d36112770fb6c985681cafe40a8c99ad13f702309e7969801dd0ed080e727", "0x0eefc2585f591bb457183134e19ad643966272234d645514bf7868d6dd8ae2cb", "0x300803e4e2339ad39b9c31f228949bbeaf9c74b7101e7be1930b088126247eaa", "0x2bb562a50ed944b438b83b01f200101a34faef7f296a75c84c731755ebddbc1a", "0x1288e0b9c742af39cbcac21357c1b29511b0bbdd3d0e3cf5e14b2eef68a28ab3", "0x20f089131cc96d86ff1cfb67fa3f51670f4bad30158751b2587354bbec76cdf9", "0x1a26c6d3e633f9bf8434cf755b5f1217dad0d455071a97a7bcf85b824f5cf07a", "0x0d7e9b8a51fccf910ec25bdbd13e70b34bd6ea6f4d629fa744f9cdf5f2beb1cf", "0x0b40f28ce428e64df9cf5a024133fc420f39decf5f6af020cc3211ab298d4631", "0x0ca4f189dde7a55fe829f46681232904f6670249a22e0deb47222bd309523a8a", "0x2c544f2e31143783977645edb2a6bdb39b875053963bfa1a5b3ae9de204a7ebe", "0x00aae4454eb48fb18ff60db6b9d015abea2e770a2f7d86d121522b834c791ba5", "0x07d74e351fd4cccf4e18475d25211efa8a359066fc693a5c8505ddb507e4b74b", "0x07d74e351fd4cccf4e18475d25211efa8a359066fc693a5c8505ddb507e4b74b", "0x2d9e5bff47207d82533e2445959941181cc890c5779bc7f24d6e8a7b9e425b5c", "0x0aea3c0c317c441a5775a9849108d7a6889b39128235f717b09b184aa08e4eb7", "0x1ca5bc6fb37c55a562f4991901c39902f42d14db71284116df74cb4e7d55e493", "0x220fed26d64cd69f40e6d145a423e4a3c8cd0dce747e7d51647441270ad4d774", "0x15be574c9358889257aa2a30ff7b5fcc31a57da7032296e2c1201c49a44bbdb6", "0x2de539925525bedd3b7f43a9c6bf0f713151a17f79ac7ff4a9cd27b15ffe892a", "0x083086693dbf465211741e2cbff70ff38eb08383faf22d397eb2742c8ad7396a", "0x1fdfa258a890598816e807c50058d7a1462edd5ff196a2eae0f862e454b49aa1", "0x10c434c6daaa8226fa8e3e302123dfdc4455cf68063df518949df5a65a945213", "0x0000000000000000000000000000006472a7874de2c454a4591ed7784df1c104", "0x000000000000000000000000000000000008c46ac53d2c4ad0c26a5d6c790082", "0x0000000000000000000000000000005e422f9cfb8725800de60dfe0a8d4104c0", "0x000000000000000000000000000000000000f10fd4e4de81a0c00073ec91c274", "0x000000000000000000000000000000b20813090eca76bc6aa4a699b1ec8d5d6d", "0x0000000000000000000000000000000000292cc9f8a744eb00e0903c29ce87a7", "0x000000000000000000000000000000350a368b415fbb99fa90a26a42b1a3affd", "0x0000000000000000000000000000000000280eb9275cb05a3435f464d1dc369d", "0x000000000000000000000000000000280df6505e20c7725fe6d29439f96ee05d", "0x000000000000000000000000000000000017ef5033a08535451e2747827aa94b", "0x0000000000000000000000000000002f9ba89ae91b4e4a4ff8ccbd0526faad2f", "0x00000000000000000000000000000000001c2013561dafcc02cb03220bdf23c4", "0x000000000000000000000000000000aac102c400f9e5da0321ded4510994434b", "0x00000000000000000000000000000000001ec8ab9cc834b492fde124962f04a1", "0x0000000000000000000000000000000673dbd698da8b8cce450d2a083aba9987", "0x00000000000000000000000000000000000a49e55bb040249cb41c63cea901cd", "0x000000000000000000000000000000133d92af8d76ee0c74a12081ee7b2ef8c4", "0x0000000000000000000000000000000000240f552d1c6cbb007650e4b142e0a5", "0x000000000000000000000000000000e29c6e7d982ec08d51c79d6261c28d742d", "0x000000000000000000000000000000000021baeec04d9be419c923626034e7b3", "0x0000000000000000000000000000000000000000000000000000000000000001", "0x0000000000000000000000000000000000000000000000000000000000000000", "0x0000000000000000000000000000000000000000000000000000000000000002", "0x0000000000000000000000000000000000000000000000000000000000000000", "0x0000000000000000000000000000000000000000000000000000000000000001", "0x0000000000000000000000000000000000000000000000000000000000000000", "0x0000000000000000000000000000000000000000000000000000000000000002", "0x0000000000000000000000000000000000000000000000000000000000000000", "0x0000000000000000000000000000000000000000000000000000000000000001", "0x0000000000000000000000000000000000000000000000000000000000000000", "0x0000000000000000000000000000000000000000000000000000000000000002", "0x0000000000000000000000000000000000000000000000000000000000000000", "0x0000000000000000000000000000000000000000000000000000000000000001", "0x0000000000000000000000000000000000000000000000000000000000000000", "0x0000000000000000000000000000000000000000000000000000000000000002", "0x0000000000000000000000000000000000000000000000000000000000000000", "0x0000000000000000000000000000000000000000000000000000000000000001", "0x0000000000000000000000000000000000000000000000000000000000000000", "0x0000000000000000000000000000000000000000000000000000000000000002", "0x0000000000000000000000000000000000000000000000000000000000000000", "0x0000000000000000000000000000000000000000000000000000000000000001", "0x0000000000000000000000000000000000000000000000000000000000000000", "0x0000000000000000000000000000000000000000000000000000000000000002", "0x0000000000000000000000000000000000000000000000000000000000000000", "0x0000000000000000000000000000000000000000000000000000000000000001", "0x0000000000000000000000000000000000000000000000000000000000000000", "0x0000000000000000000000000000000000000000000000000000000000000002", "0x0000000000000000000000000000000000000000000000000000000000000000", "0x0000000000000000000000000000000000000000000000000000000000000001", "0x0000000000000000000000000000000000000000000000000000000000000000", "0x0000000000000000000000000000000000000000000000000000000000000002", "0x0000000000000000000000000000000000000000000000000000000000000000", "0x0000000000000000000000000000000000000000000000000000000000000001", "0x0000000000000000000000000000000000000000000000000000000000000000", "0x0000000000000000000000000000000000000000000000000000000000000002", "0x0000000000000000000000000000000000000000000000000000000000000000", "0x0000000000000000000000000000000000000000000000000000000000000001", "0x0000000000000000000000000000000000000000000000000000000000000000", "0x0000000000000000000000000000000000000000000000000000000000000002", "0x0000000000000000000000000000000000000000000000000000000000000000", "0x0000000000000000000000000000000000000000000000000000000000000001", "0x0000000000000000000000000000000000000000000000000000000000000000", "0x0000000000000000000000000000000000000000000000000000000000000002", "0x0000000000000000000000000000000000000000000000000000000000000000", "0x0000000000000000000000000000000000000000000000000000000000000001", "0x0000000000000000000000000000000000000000000000000000000000000000", "0x0000000000000000000000000000000000000000000000000000000000000002", "0x0000000000000000000000000000000000000000000000000000000000000000", "0x0000000000000000000000000000000000000000000000000000000000000001", "0x0000000000000000000000000000000000000000000000000000000000000000", "0x0000000000000000000000000000000000000000000000000000000000000002", "0x0000000000000000000000000000000000000000000000000000000000000000", "0x0000000000000000000000000000000000000000000000000000000000000001", "0x0000000000000000000000000000000000000000000000000000000000000000", "0x0000000000000000000000000000000000000000000000000000000000000002", "0x0000000000000000000000000000000000000000000000000000000000000000", "0x0000000000000000000000000000000000000000000000000000000000000001", "0x0000000000000000000000000000000000000000000000000000000000000000", "0x0000000000000000000000000000000000000000000000000000000000000002", "0x0000000000000000000000000000000000000000000000000000000000000000", "0x0000000000000000000000000000000000000000000000000000000000000001", "0x0000000000000000000000000000000000000000000000000000000000000000", "0x0000000000000000000000000000000000000000000000000000000000000002", "0x0000000000000000000000000000000000000000000000000000000000000000", "0x0000000000000000000000000000000000000000000000000000000000000001", "0x0000000000000000000000000000000000000000000000000000000000000000", "0x0000000000000000000000000000000000000000000000000000000000000002", "0x0000000000000000000000000000000000000000000000000000000000000000", "0x0000000000000000000000000000000000000000000000000000000000000001", "0x0000000000000000000000000000000000000000000000000000000000000000", "0x0000000000000000000000000000000000000000000000000000000000000002", "0x0000000000000000000000000000000000000000000000000000000000000000", "0x0000000000000000000000000000000000000000000000000000000000000001", "0x0000000000000000000000000000000000000000000000000000000000000000", "0x0000000000000000000000000000000000000000000000000000000000000002", "0x0000000000000000000000000000000000000000000000000000000000000000", "0x0000000000000000000000000000000000000000000000000000000000000001", "0x0000000000000000000000000000000000000000000000000000000000000000", "0x0000000000000000000000000000000000000000000000000000000000000002", "0x0000000000000000000000000000000000000000000000000000000000000000", "0x0000000000000000000000000000000000000000000000000000000000000001", "0x0000000000000000000000000000000000000000000000000000000000000000", "0x0000000000000000000000000000000000000000000000000000000000000002", "0x0000000000000000000000000000000000000000000000000000000000000000", "0x0000000000000000000000000000000000000000000000000000000000000001", "0x0000000000000000000000000000000000000000000000000000000000000000", "0x0000000000000000000000000000000000000000000000000000000000000002", "0x0000000000000000000000000000000000000000000000000000000000000000", "0x1e940a528b42d8230e7d4dff76262a80986c0d00b2c02a9bc0559e36212d1547", "0x1ceccf21ac39f70d76ad6f7fe0dcb33b6af04555a0b1959e4714d65925e4e253", "0x096139d757046cdbdb7ee89a95f112f70882a43a46c2f739d9be115dda013420", "0x2f9c8ac67c7825b08eff0e7f7656a671f4c64e5601f2efab35b1b795801eec04", "0x2077e648e1704851cdffd7e6e56311634a7b741bab77ca34d9dff12a6a2bfe99", "0x115d48c4a97aeb3c447a060f9e0d675b0dc7f4a05a3f5776e2f279f3a165d7dc", "0x0000000000000000000000000000000000000000000000000000000000000000", "0x0000000000000000000000000000000000000000000000000000000000000000", "0x0000000000000000000000000000000000000000000000000000000000000000", "0x0000000000000000000000000000000000000000000000000000000000000000", "0x0000000000000000000000000000000000000000000000000000000000000000", "0x0000000000000000000000000000000000000000000000000000000000000000", "0x0000000000000000000000000000000000000000000000000000000000000000", "0x0000000000000000000000000000000000000000000000000000000000000000", "0x0000000000000000000000000000000000000000000000000000000000000000", "0x0000000000000000000000000000000000000000000000000000000000000000", "0x0000000000000000000000000000000000000000000000000000000000000000", "0x0000000000000000000000000000000000000000000000000000000000000000", "0x0000000000000000000000000000000000000000000000000000000000000000", "0x0000000000000000000000000000000000000000000000000000000000000000", "0x0000000000000000000000000000000000000000000000000000000000000000", "0x0000000000000000000000000000000000000000000000000000000000000000", "0x0000000000000000000000000000000000000000000000000000000000000000", "0x0000000000000000000000000000000000000000000000000000000000000000", "0x0000000000000000000000000000000000000000000000000000000000000000", "0x0000000000000000000000000000000000000000000000000000000000000000", "0x0000000000000000000000000000000000000000000000000000000000000000", "0x0000000000000000000000000000000000000000000000000000000000000000", "0x000000000000000000000000000000fd38c45c3ec5b841482a80e3a56ce82555", "0x00000000000000000000000000000000000ad70b03f092f60af3e0ce1bb29d2c", "0x0000000000000000000000000000007a184d5342c90c634c0b1a050f0b97c9fb", "0x0000000000000000000000000000000000271f42abcb3bc1f0332e4b3ca85e1d", "0x0000000000000000000000000000008256322bbe2c1b8cd9d84e5ff6123477f2", "0x000000000000000000000000000000000025cab962761681dd9547f4c78814df", "0x0000000000000000000000000000008c4234510e5825c02b9ac427bcbf8e279a", "0x000000000000000000000000000000000013a14e0d7fc073c44643af38cc5396"]
+public_inputs = ["0x0000000000000000000000000000000000000000000000000000000000000003"]
+verification_key = ["0x0000000000000000000000000000000000000000000000000000000000000040", "0x0000000000000000000000000000000000000000000000000000000000000011", "0x0000000000000000000000000000000000000000000000000000000000000001", "0x0000000000000000000000000000000000000000000000000000000000000001", "0x0000000000000000000000000000000000000000000000000000000000000001", "0x0000000000000000000000000000000000000000000000000000000000000002", "0x0000000000000000000000000000000000000000000000000000000000000003", "0x0000000000000000000000000000000000000000000000000000000000000004", "0x0000000000000000000000000000000000000000000000000000000000000005", "0x0000000000000000000000000000000000000000000000000000000000000006", "0x0000000000000000000000000000000000000000000000000000000000000007", "0x0000000000000000000000000000000000000000000000000000000000000008", "0x0000000000000000000000000000000000000000000000000000000000000009", "0x000000000000000000000000000000000000000000000000000000000000000a", "0x000000000000000000000000000000000000000000000000000000000000000b", "0x000000000000000000000000000000000000000000000000000000000000000c", "0x000000000000000000000000000000000000000000000000000000000000000d", "0x000000000000000000000000000000000000000000000000000000000000000e", "0x000000000000000000000000000000000000000000000000000000000000000f", "0x0000000000000000000000000000000000000000000000000000000000000010", "0x00000000000000000000000000000060e430ad1c23bfcf3514323aae3f206e84", "0x00000000000000000000000000000000001b5c3ff4c2458d8f481b1c068f27ae", "0x000000000000000000000000000000bb510ab2112def34980e4fc6998ad9dd16", "0x00000000000000000000000000000000000576e7c105b43e061e13cb877fefe1", "0x000000000000000000000000000000ced074785d11857b065d8199e6669a601c", "0x00000000000000000000000000000000000053b48a4098c1c0ae268f273952f7", "0x000000000000000000000000000000d1d4b26e941db8168cee8f6de548ae0fd8", "0x00000000000000000000000000000000001a9adf5a6dadc3d948bb61dfd63f4c", "0x0000000000000000000000000000009ce1faac6f8de6ebb18f1db17372c82ad5", "0x00000000000000000000000000000000002002681bb417184b2df070a16a3858", "0x000000000000000000000000000000161baa651a8092e0e84725594de5aba511", "0x00000000000000000000000000000000000be0064399c2a1efff9eb0cdcb2223", "0x0000000000000000000000000000008673be6fd1bdbe980a29d8c1ded54381e7", "0x000000000000000000000000000000000008a5158a7d9648cf1d234524c9fa0c", "0x0000000000000000000000000000002b4fce6e4b1c72062b296d49bca2aa4130", "0x00000000000000000000000000000000002e45a9eff4b6769e55fb710cded44f", "0x00000000000000000000000000000072b85bf733758b76bcf97333efb85a23e3", "0x000000000000000000000000000000000017da0ea508994fc82862715e4b5592", "0x00000000000000000000000000000094fa74695cf058dba8ff35aec95456c6c3", "0x0000000000000000000000000000000000211acddb851061c24b8f159e832bd1", "0x000000000000000000000000000000303b5e5c531384b9a792e11702ad3bcab0", "0x00000000000000000000000000000000000d336dff51a60b8833d5d7f6d4314c", "0x0000000000000000000000000000009f825dde88092070747180d581c342444a", "0x0000000000000000000000000000000000237fbd6511a03cca8cac01b555fe01", "0x0000000000000000000000000000007c313205159495df6d8de292079a4844ff", "0x000000000000000000000000000000000018facdfc468530dd45e8f7a1d38ce9", "0x0000000000000000000000000000000d1ce33446fc3dc4ab40ca38d92dac74e1", "0x00000000000000000000000000000000000852d8e3e0e8f4435af3e94222688b", "0x0000000000000000000000000000006c04ee19ec1dfec87ed47d6d04aa158de2", "0x000000000000000000000000000000000013240f97a584b45184c8ec31319b5f", "0x000000000000000000000000000000cefb5d240b07ceb4be26ea429b6dc9d9e0", "0x00000000000000000000000000000000002dad22022121d689f57fb38ca21349", "0x000000000000000000000000000000c9f189f2a91aeb664ce376d8b157ba98f8", "0x00000000000000000000000000000000002531a51ad54f124d58094b219818d2", "0x000000000000000000000000000000ef1e6db71809307f677677e62b4163f556", "0x0000000000000000000000000000000000272da4396fb2a7ee0638b9140e523d", "0x0000000000000000000000000000002e54c0244a7732c87bc4712a76dd8c83fb", "0x000000000000000000000000000000000007db77b3e04b7eba9643da57cbbe4d", "0x000000000000000000000000000000e0dfe1ddd7f74ae0d636c910c3e85830d8", "0x00000000000000000000000000000000000466fa9b57ec4664abd1505b490862", "0x0000000000000000000000000000009ee55ae8a32fe5384c79907067cc27192e", "0x00000000000000000000000000000000000799d0e465cec07ecb5238c854e830", "0x0000000000000000000000000000001d5910ad361e76e1c241247a823733c39f", "0x00000000000000000000000000000000002b03f2ccf7507564da2e6678bef8fe", "0x000000000000000000000000000000ee40d90bea71fba7a412dd61fcf34e8ceb", "0x0000000000000000000000000000000000140b0936c323fd2471155617b6af56", "0x0000000000000000000000000000002b90071823185c5ff8e440fd3d73b6fefc", "0x00000000000000000000000000000000002b6c10790a5f6631c87d652e059df4", "0x00000000000000000000000000000029a17181c7934fc3fdbd352eac5cb521b9", "0x00000000000000000000000000000000001f497cbf5284ff29a2d336e5991999", "0x000000000000000000000000000000072bd9c0c6beda1fdee6d4ff0432ba9e1b", "0x000000000000000000000000000000000013ea38a0bd2aa751a490a724fac818", "0x000000000000000000000000000000c599f63dcd3edd49f08ae5c3141c1e3493", "0x00000000000000000000000000000000002bdb36be0bea09950dd32a8ccf6fbc", "0x00000000000000000000000000000047f27f29724e7f19eba0340256a0bd4b7d", "0x00000000000000000000000000000000001c1c5ccf87a962129ca785f8f35120", "0x000000000000000000000000000000c5c71efdae00679bbe4a95096e012b1817", "0x000000000000000000000000000000000017a365de041e317817d0135f2b48e0", "0x0000000000000000000000000000008ae711ac402f7848d719c93a89ba8d39f1", "0x00000000000000000000000000000000002b6fb40ed8a1935226f4f9786a0499", "0x0000000000000000000000000000002f03a71501d83de1da5715a4e9462d6198", "0x00000000000000000000000000000000001644064443b8546f48eae693af47b8", "0x00000000000000000000000000000083763ab1b6e8fe269b2fe4c7b9c448c08d", "0x000000000000000000000000000000000021d7cc18c59676a8eeb47c0111c251", "0x000000000000000000000000000000b5f937153073e03ea7d51a996e0ebc2e6b", "0x000000000000000000000000000000000011ddd0e26457373eb06e0493177672", "0x000000000000000000000000000000c5f6eb9f6fc8fa99811a4a88c74a6d018b", "0x000000000000000000000000000000000025bcd07a0732c123567834f5109558", "0x000000000000000000000000000000aeb08a0b1a4442189448b4e97490568146", "0x000000000000000000000000000000000002a1744e4771705536a88f07e0f90f", "0x000000000000000000000000000000b938568293bd0724b0ea76c2ec34c4a829", "0x0000000000000000000000000000000000053296e8f3b9ad3af877dfa9c7c2a7", "0x000000000000000000000000000000f0ca1db6323996eba26bdc86dafef9d10b", "0x00000000000000000000000000000000001441a46c58af03d5645d52721d956a", "0x0000000000000000000000000000008bbf8f884013c66c28ba09c2fbd573b656", "0x0000000000000000000000000000000000206c391ca06fac27d1908e94570243", "0x0000000000000000000000000000002d4f5aaed88ba4f79612d53b804ca8f194", "0x00000000000000000000000000000000001674011c96392df08970fa6b7b4cb8", "0x0000000000000000000000000000009f88297c1729d76c4d9306853598c91325", "0x0000000000000000000000000000000000256f51adfcacc3c1e340be4d32d3e9", "0x0000000000000000000000000000000ab9955eec0d74eb799afed2a802b24d75", "0x00000000000000000000000000000000001fcbe43ea105b30d36ed0b21b03411", "0x000000000000000000000000000000d66b1d5433f1aa5305cd1edce7c22de466", "0x00000000000000000000000000000000002331546a256b8a3b751956806680d4", "0x000000000000000000000000000000e97954ad6cd6f45fb15c91434121db4304", "0x00000000000000000000000000000000002e20a97e09d50f227ced47e7a98250", "0x0000000000000000000000000000001ebbc27eb9ebededefba79522eb58ae89b", "0x0000000000000000000000000000000000090efa4974e566e81d1177b85a30be", "0x0000000000000000000000000000005eafa070b9c9632404052642e3bc14f9fd", "0x00000000000000000000000000000000001489068864102daca6a6b8bc4d448b", "0x0000000000000000000000000000009ebc91aaaac036a6477cadbe54e8556dfd", "0x00000000000000000000000000000000000ef6d835e2ed3343b95c82c8c54037", "0x00000000000000000000000000000033b28b529dff46e93af4e7422530478e4a", "0x000000000000000000000000000000000020a86c2f8591bf190bcddcc03c42fb", "0x000000000000000000000000000000a9679d0acc088f7dc27bf6d866bcd2dda2", "0x00000000000000000000000000000000002fb9d0d2d4099402bed74f738f64cc", "0x00000000000000000000000000000023b09f876a29a061582848a8b9a5870c12", "0x00000000000000000000000000000000001d5bb906f03f0d49e9c4791bc43af9", "0x00000000000000000000000000000017aac9854ea240d8ec97bf760c4d4ba870", "0x00000000000000000000000000000000000b227a556c414ada0dc75bb303e30e", "0x0000000000000000000000000000000000000000000000000000000000000001", "0x0000000000000000000000000000000000000000000000000000000000000000", "0x0000000000000000000000000000000000000000000000000000000000000002", "0x0000000000000000000000000000000000000000000000000000000000000000", "0x0000000000000000000000000000009b624fa65d1a24b7f14a8f25f3789622af", "0x000000000000000000000000000000000013d47bff8c630e847b70e2732fd3f0", "0x00000000000000000000000000000061d21663e93132f32921075f4c936a84df", "0x00000000000000000000000000000000001a74ca4e118fb480b9b999902989a3"]
+proof_b = ["0x0000000000000000000000000000000000000000000000000000000000000040", "0x0000000000000000000000000000000000000000000000000000000000000011", "0x0000000000000000000000000000000000000000000000000000000000000001", "0x0000000000000000000000000000000000000000000000042ab5d6d1986846cf", "0x00000000000000000000000000000000000000000000000b75c020998797da78", "0x0000000000000000000000000000000000000000000000005a107acb64952eca", "0x000000000000000000000000000000000000000000000000000031e97a575e9d", "0x00000000000000000000000000000000000000000000000b5666547acf8bd5a4", "0x00000000000000000000000000000000000000000000000c410db10a01750aeb", "0x00000000000000000000000000000000000000000000000d722669117f9758a4", "0x000000000000000000000000000000000000000000000000000178cbf4206471", "0x000000000000000000000000000000000000000000000000e91b8a11e7842c38", "0x000000000000000000000000000000000000000000000007fd51009034b3357f", "0x000000000000000000000000000000000000000000000009889939f81e9c7402", "0x0000000000000000000000000000000000000000000000000000f94656a2ca48", "0x000000000000000000000000000000000000000000000006fb128b46c1ddb67f", "0x0000000000000000000000000000000000000000000000093fe27776f50224bd", "0x000000000000000000000000000000000000000000000004a0c80c0da527a081", "0x0000000000000000000000000000000000000000000000000001b52c2020d746", "0x0000000000000000000000000000005a9bae947e1e91af9e4033d8d6aa6ed632", "0x000000000000000000000000000000000025e485e013446d4ac7981c88ba6ecc", "0x000000000000000000000000000000ff1e0496e30ab24a63b32b2d1120b76e62", "0x00000000000000000000000000000000001afe0a8a685d7cd85d1010e55d9d7c", "0x000000000000000000000000000000b0804efd6573805f991458295f510a2004", "0x00000000000000000000000000000000000c81a178016e2fe18605022d5a8b0e", "0x000000000000000000000000000000eba51e76eb1cfff60a53a0092a3c3dea47", "0x000000000000000000000000000000000022e7466247b533282f5936ac4e6c15", "0x00000000000000000000000000000071b1d76edf770edff98f00ff4deec264cd", "0x00000000000000000000000000000000001e48128e68794d8861fcbb2986a383", "0x000000000000000000000000000000d3a2af4915ae6d86b097adc377fafda2d4", "0x000000000000000000000000000000000006359de9ca452dab3a4f1f8d9c9d98", "0x0000000000000000000000000000006cf7dd96d7636fda5953191b1ad776d491", "0x00000000000000000000000000000000001633d881a08d136e834cb13a28fcc6", "0x00000000000000000000000000000001254956cff6908b069fca0e6cf1c47eb1", "0x000000000000000000000000000000000006f4d4dd3890e997e75e75886bf8f7", "0x0000000000000000000000000000006cf7dd96d7636fda5953191b1ad776d491", "0x00000000000000000000000000000000001633d881a08d136e834cb13a28fcc6", "0x00000000000000000000000000000001254956cff6908b069fca0e6cf1c47eb1", "0x000000000000000000000000000000000006f4d4dd3890e997e75e75886bf8f7", "0x000000000000000000000000000000f968b227a358a305607f3efc933823d288", "0x00000000000000000000000000000000000eaf8adb390375a76d95e918b65e08", "0x000000000000000000000000000000bb34b4b447aae56f5e24f81c3acd6d547f", "0x00000000000000000000000000000000002175d012746260ebcfe339a91a81e1", "0x00000000000000000000000000000052eebbd1f6f7554e837f60c44000ed14b6", "0x00000000000000000000000000000000001c1c045a3ec94b8801f2272cc0b3f4", "0x0000000000000000000000000000004d2ef74134578f6b431a9df071ffca4292", "0x0000000000000000000000000000000000291326ade7aa6f0dfc8900eab5580b", "0x0000000000000000000000000000002433eec6418a6dba820c9527e2581fc8bc", "0x00000000000000000000000000000000000e88b7daad19af2ac2f9bdf9e50ee2", "0x000000000000000000000000000000dcfce2c427155cc3e4d035735d3dd5ece8", "0x00000000000000000000000000000000002d7d473cac1a15d0fee8b22c1a7b3e", "0x1a4249b90be4602c8ff40c7c276160ee41b2a0f8a238ce7706e9face2db03d48", "0x162204b9d54d3ffd285c393a5a1ff76ee681474fd780a21a3cf7fac5c24fc2b9", "0x30279eb953d8ee79b2155c69c04e6443c5de6bf7e02886256dd7b3cd3c9502a4", "0x0d32c1bd21baf43e72d5d82d461ef54833807ff81a877adc822f27a6db88d754", "0x0fe15e055c0803d5ebe6dd77689b70cfd82138f008810ce24535c992daaff27d", "0x1fba82c012671212ce2fc13fd09bf8fba4f7d5875ab8d37495d1ccfcff287331", "0x090738a5842fa4d2699b3726aa0dd97cb59569b4be2c6825335ec4969f859dc2", "0x0c6cb72dabbc28abcf4a50c203534e066c29f48c24ca64d672092f263df3f9d7", "0x0f27fbea0d9145f815c288b50fe7e8c10b8185d325b5264624fd57102855d05d", "0x2a815cd3fd1c43c72ee0130465250ff771d1e7be2347e4ada331b83265a03450", "0x148b4ecf2ad7ed17409417086867ee27bc1b0906dbc9cbb3714c285071e2db70", "0x08e700a42b1d6d36ee65f8ebedf47d3a44463ff9fa579dce13b7492e20142c3a", "0x2e23c69521d572ff2152c50f8c9a9191535f4cf37f95f1e0428692e78842b642", "0x14519e0354365923fb41400c19866135b45e975d56a0980260bc99f0390b1d5f", "0x04caded1f05738f736cb5bcf08d785e395e58eb7738523a20638aa16bc51593e", "0x28787eaccd38383215ea21ec02895c32d979f68ca155f534a2e2d377bff6698b", "0x20a1b81fa96c58cf11c5762c5ceb731efdcb081fca2d34d5c463d2cf40e6da18", "0x11789a06fe3bf53833741d180f068d29534d5bb58a5c64b8119542e62b189fb4", "0x23d00fcd032ace719ffcbc513bfa177a55b04377d76455c2788d999d05d011e2", "0x01f0e81b57b4a73cc118e51ede18f8724debf25c2d109db6ef45280f99f1a3fa", "0x156d1c9b61749810de728f259c2c1c1fd4dbff97101426e26087ca461c93307c", "0x1c5d619ac3a478cfd06d5eebfd879960bb321236be173813f5e78d1366d32c69", "0x250cfae4e1dfc551406f1f3d10b649a637dcb7bcb0f6f697994cf96afd35d0c1", "0x242b999f58cf5f53c874d1092bd38725aa9ea076f5bc8f176efa9ea23393874b", "0x2e15748255c4a5e0e9fe38047341b692a967257de27a85a3a38681bc9f1602ea", "0x01ef83886ea7017253699cb6371988eb8e21b4f7023d7479ece4907fe6d4a6fd", "0x08db2dbc271e375b9312f695c59c48f313235b3432cad50921c8d9ad6dd7ad7a", "0x199309f2c2cd45c15a4abb0e6554a1615ff5a6e9488a8d900bbf835fc8f664ef", "0x074be7a3d88e31ab1b59c9208c012bcfb1f85f351c709e68134996891db52b57", "0x301b1011354d2ebf46134fc4d6d734bb6ed8542d719f38f5e09a376a580cad7f", "0x12968f3eccaa27e44f14d5aaac6ecb70c00d040e07536292e685d7cab03fc563", "0x2110a023c8c22fd2ed70270a2d0a265b92a32ce2217ffe1be9a5d7d5c25f512f", "0x1e8cf4c60c53900f0430d5b44de5804fe8b38299bc803beeb4216e1a289cf624", "0x12301cb908ccb28a2616e29b831ec7105b5d3ebf45ff5fe91d50a9dd53a50b52", "0x0f1029ed107d84ff2d6d4a416cbd01da3f3d7bf5b2209ce93ba424f4b85616fc", "0x1b431d016611b8abd684afd9e92331c3325967b1116bfa91d4f44e2f8e2c9fc2", "0x281e335a0fd117064c8ace3f01e02b134a19e9b9220571ebfaaaa0e3a12d34db", "0x22559c106f77e2ae95677d5e38e288343e3b7168371aec7d3aaab9ef8150af70", "0x13f113b1d9b590149cf08c3f6e90589cda5c7b98528866b891256cb9d5d814e7", "0x10252ef388e4c80246962e98b9e976fab2cd25e1e6f1e3fd2a7d4786c5218a97", "0x16b890723dfdebd9912a9207255f95cb800222165b6fae97ec46e461f23e83f3", "0x25caf77c7d2e8e069341ec90f3c8f6d64319cfd2d77cab0625cf0377285ba11c", "0x016c84288b0bc3c50eebbe250cdd5a4ee50b2c65a24ac64d0c930cbdecb95141", "0x20a537c045b069d47dc6315f45b391f60681222381e5059ec7c8b17bf677d911", "0x2594c0edfcd4064d215a3d797bc8e3b2f401c61f3961ae96ccbec8f8fd29e81f", "0x1c831d7047483ca00ed59bdb84c47ffb8bbebbae92aa164c7b35fcffbb8a35d3", "0x2ea7f60de52b8cd6b0bd06f861fc1f2c5ed1d1fbfa53caccdb836400a03df434", "0x275c6c8bd115f7d2ce196439e2330fad305c6745bab0bf1ce3f2fa32dadc3c43", "0x0000000000000000000000000000000000000000000000000000000000000000", "0x0000000000000000000000000000000000000000000000000000000000000000", "0x0000000000000000000000000000000000000000000000000000000000000000", "0x0000000000000000000000000000000000000000000000000000000000000000", "0x0000000000000000000000000000000000000000000000000000000000000000", "0x0000000000000000000000000000000000000000000000000000000000000000", "0x0000000000000000000000000000000000000000000000000000000000000000", "0x0000000000000000000000000000000000000000000000000000000000000000", "0x0000000000000000000000000000000000000000000000000000000000000000", "0x0000000000000000000000000000000000000000000000000000000000000000", "0x0000000000000000000000000000000000000000000000000000000000000000", "0x0000000000000000000000000000000000000000000000000000000000000000", "0x0000000000000000000000000000000000000000000000000000000000000000", "0x0000000000000000000000000000000000000000000000000000000000000000", "0x0000000000000000000000000000000000000000000000000000000000000000", "0x0000000000000000000000000000000000000000000000000000000000000000", "0x0000000000000000000000000000000000000000000000000000000000000000", "0x0000000000000000000000000000000000000000000000000000000000000000", "0x0000000000000000000000000000000000000000000000000000000000000000", "0x0000000000000000000000000000000000000000000000000000000000000000", "0x0000000000000000000000000000000000000000000000000000000000000000", "0x0000000000000000000000000000000000000000000000000000000000000000", "0x0000000000000000000000000000000000000000000000000000000000000000", "0x0000000000000000000000000000000000000000000000000000000000000000", "0x0000000000000000000000000000000000000000000000000000000000000000", "0x0000000000000000000000000000000000000000000000000000000000000000", "0x0000000000000000000000000000000000000000000000000000000000000000", "0x0000000000000000000000000000000000000000000000000000000000000000", "0x0000000000000000000000000000000000000000000000000000000000000000", "0x0000000000000000000000000000000000000000000000000000000000000000", "0x0000000000000000000000000000000000000000000000000000000000000000", "0x0000000000000000000000000000000000000000000000000000000000000000", "0x0000000000000000000000000000000000000000000000000000000000000000", "0x0000000000000000000000000000000000000000000000000000000000000000", "0x0000000000000000000000000000000000000000000000000000000000000000", "0x0000000000000000000000000000000000000000000000000000000000000000", "0x0000000000000000000000000000000000000000000000000000000000000000", "0x0000000000000000000000000000000000000000000000000000000000000000", "0x0000000000000000000000000000000000000000000000000000000000000000", "0x0000000000000000000000000000000000000000000000000000000000000000", "0x0000000000000000000000000000000000000000000000000000000000000000", "0x0000000000000000000000000000000000000000000000000000000000000000", "0x0000000000000000000000000000000000000000000000000000000000000000", "0x0000000000000000000000000000000000000000000000000000000000000000", "0x0000000000000000000000000000000000000000000000000000000000000000", "0x0000000000000000000000000000000000000000000000000000000000000000", "0x0000000000000000000000000000000000000000000000000000000000000000", "0x0000000000000000000000000000000000000000000000000000000000000000", "0x0000000000000000000000000000000000000000000000000000000000000000", "0x0000000000000000000000000000000000000000000000000000000000000000", "0x0000000000000000000000000000000000000000000000000000000000000000", "0x0000000000000000000000000000000000000000000000000000000000000000", "0x0000000000000000000000000000000000000000000000000000000000000000", "0x0000000000000000000000000000000000000000000000000000000000000000", "0x0000000000000000000000000000000000000000000000000000000000000000", "0x0000000000000000000000000000000000000000000000000000000000000000", "0x0000000000000000000000000000000000000000000000000000000000000000", "0x0000000000000000000000000000000000000000000000000000000000000000", "0x0000000000000000000000000000000000000000000000000000000000000000", "0x0000000000000000000000000000000000000000000000000000000000000000", "0x0000000000000000000000000000000000000000000000000000000000000000", "0x0000000000000000000000000000000000000000000000000000000000000000", "0x0000000000000000000000000000000000000000000000000000000000000000", "0x0000000000000000000000000000000000000000000000000000000000000000", "0x0000000000000000000000000000000000000000000000000000000000000000", "0x0000000000000000000000000000000000000000000000000000000000000000", "0x0000000000000000000000000000000000000000000000000000000000000000", "0x0000000000000000000000000000000000000000000000000000000000000000", "0x0000000000000000000000000000000000000000000000000000000000000000", "0x0000000000000000000000000000000000000000000000000000000000000000", "0x0000000000000000000000000000000000000000000000000000000000000000", "0x0000000000000000000000000000000000000000000000000000000000000000", "0x0000000000000000000000000000000000000000000000000000000000000000", "0x0000000000000000000000000000000000000000000000000000000000000000", "0x0000000000000000000000000000000000000000000000000000000000000000", "0x0000000000000000000000000000000000000000000000000000000000000000", "0x0000000000000000000000000000000000000000000000000000000000000000", "0x0000000000000000000000000000000000000000000000000000000000000000", "0x0000000000000000000000000000000000000000000000000000000000000000", "0x0000000000000000000000000000000000000000000000000000000000000000", "0x0000000000000000000000000000000000000000000000000000000000000000", "0x0000000000000000000000000000000000000000000000000000000000000000", "0x0000000000000000000000000000000000000000000000000000000000000000", "0x0000000000000000000000000000000000000000000000000000000000000000", "0x0000000000000000000000000000000000000000000000000000000000000000", "0x0000000000000000000000000000000000000000000000000000000000000000", "0x0000000000000000000000000000000000000000000000000000000000000000", "0x0000000000000000000000000000000000000000000000000000000000000000", "0x0000000000000000000000000000000000000000000000000000000000000000", "0x0000000000000000000000000000000000000000000000000000000000000000", "0x0000000000000000000000000000000000000000000000000000000000000000", "0x0000000000000000000000000000000000000000000000000000000000000000", "0x0000000000000000000000000000000000000000000000000000000000000000", "0x0000000000000000000000000000000000000000000000000000000000000000", "0x0000000000000000000000000000000000000000000000000000000000000000", "0x0000000000000000000000000000000000000000000000000000000000000000", "0x0000000000000000000000000000000000000000000000000000000000000000", "0x0000000000000000000000000000000000000000000000000000000000000000", "0x0000000000000000000000000000000000000000000000000000000000000000", "0x0000000000000000000000000000000000000000000000000000000000000000", "0x0000000000000000000000000000000000000000000000000000000000000000", "0x0000000000000000000000000000000000000000000000000000000000000000", "0x0000000000000000000000000000000000000000000000000000000000000000", "0x0000000000000000000000000000000000000000000000000000000000000000", "0x0000000000000000000000000000000000000000000000000000000000000000", "0x0000000000000000000000000000000000000000000000000000000000000000", "0x0000000000000000000000000000000000000000000000000000000000000000", "0x0000000000000000000000000000000000000000000000000000000000000000", "0x0000000000000000000000000000000000000000000000000000000000000000", "0x0000000000000000000000000000000000000000000000000000000000000000", "0x0000000000000000000000000000000000000000000000000000000000000000", "0x0000000000000000000000000000000000000000000000000000000000000000", "0x0000000000000000000000000000000000000000000000000000000000000000", "0x0000000000000000000000000000000000000000000000000000000000000000", "0x0000000000000000000000000000000000000000000000000000000000000000", "0x0000000000000000000000000000000000000000000000000000000000000000", "0x0000000000000000000000000000000000000000000000000000000000000000", "0x0000000000000000000000000000000000000000000000000000000000000000", "0x0000000000000000000000000000000000000000000000000000000000000000", "0x0000000000000000000000000000000000000000000000000000000000000000", "0x0000000000000000000000000000000000000000000000000000000000000000", "0x0000000000000000000000000000000000000000000000000000000000000000", "0x0000000000000000000000000000000000000000000000000000000000000000", "0x0000000000000000000000000000000000000000000000000000000000000000", "0x0000000000000000000000000000000000000000000000000000000000000000", "0x0000000000000000000000000000000000000000000000000000000000000000", "0x0000000000000000000000000000000000000000000000000000000000000000", "0x0000000000000000000000000000000000000000000000000000000000000000", "0x0000000000000000000000000000000000000000000000000000000000000000", "0x0000000000000000000000000000000000000000000000000000000000000000", "0x0000000000000000000000000000000000000000000000000000000000000000", "0x0000000000000000000000000000000000000000000000000000000000000000", "0x0000000000000000000000000000000000000000000000000000000000000000", "0x0000000000000000000000000000000000000000000000000000000000000000", "0x0000000000000000000000000000000000000000000000000000000000000000", "0x0000000000000000000000000000000000000000000000000000000000000000", "0x0000000000000000000000000000000000000000000000000000000000000000", "0x0000000000000000000000000000000000000000000000000000000000000000", "0x0000000000000000000000000000000000000000000000000000000000000000", "0x0000000000000000000000000000000000000000000000000000000000000000", "0x0000000000000000000000000000000000000000000000000000000000000000", "0x0000000000000000000000000000000000000000000000000000000000000000", "0x0000000000000000000000000000000000000000000000000000000000000000", "0x0000000000000000000000000000000000000000000000000000000000000000", "0x0000000000000000000000000000000000000000000000000000000000000000", "0x0000000000000000000000000000000000000000000000000000000000000000", "0x0000000000000000000000000000000000000000000000000000000000000000", "0x0000000000000000000000000000000000000000000000000000000000000000", "0x0000000000000000000000000000000000000000000000000000000000000000", "0x0000000000000000000000000000000000000000000000000000000000000000", "0x0000000000000000000000000000000000000000000000000000000000000000", "0x0000000000000000000000000000000000000000000000000000000000000000", "0x0000000000000000000000000000000000000000000000000000000000000000", "0x0000000000000000000000000000000000000000000000000000000000000000", "0x0000000000000000000000000000000000000000000000000000000000000000", "0x0000000000000000000000000000000000000000000000000000000000000000", "0x0000000000000000000000000000000000000000000000000000000000000000", "0x0000000000000000000000000000000000000000000000000000000000000000", "0x0000000000000000000000000000000000000000000000000000000000000000", "0x0000000000000000000000000000000000000000000000000000000000000000", "0x0000000000000000000000000000000000000000000000000000000000000000", "0x0000000000000000000000000000000000000000000000000000000000000000", "0x0000000000000000000000000000000000000000000000000000000000000000", "0x0000000000000000000000000000000000000000000000000000000000000000", "0x0000000000000000000000000000000000000000000000000000000000000000", "0x0000000000000000000000000000000000000000000000000000000000000000", "0x0000000000000000000000000000000000000000000000000000000000000000", "0x0000000000000000000000000000000000000000000000000000000000000000", "0x0000000000000000000000000000000000000000000000000000000000000000", "0x0000000000000000000000000000000000000000000000000000000000000000", "0x0000000000000000000000000000000000000000000000000000000000000000", "0x0000000000000000000000000000000000000000000000000000000000000000", "0x0000000000000000000000000000000000000000000000000000000000000000", "0x0000000000000000000000000000000000000000000000000000000000000000", "0x0000000000000000000000000000000000000000000000000000000000000000", "0x0000000000000000000000000000000000000000000000000000000000000000", "0x2b3f4e210619347288731e7f0eea1ae60dd8696fe87319044864d099a03a9536", "0x0fecd3d2aebedeb8be2b0b7e3a74de9ec8bd2cb72851541463729e0715aef48b", "0x10bee385ad0c2cd3ff88ef4d630840749e4367f9add4a300fc4f545a7778e92c", "0x1fe792730eeafbd22c4eb80e86e2b40108b1e55b2a08db786289eea5745b9e3b", "0x04d411679da432816b213cd5580dda1fd6c2f258684c036be19b5b26baca583c", "0x159f17b655d2b8a803e0cfb564918628be52d3baa950ca1b127854491624f8f4", "0x225340463867d9252a1269013536e2e1dd219aa18eadef13c324b63d44679334", "0x1885e231554e02abb40ed54b72ebf09b883d0298a6bc06fc645a30365f370ef2", "0x233344517f25170972b8ba35d01f2df2e073d322993abce7df26796126e93498", "0x08990e8faa13b18b4433ec417c5cc596885e11ffd372d5f612c08cc79a5d5c80", "0x1e960a0c892b755c28e21dcbed816c1b182d7da43bae07f8ee622bd4485f79e7", "0x27b58e2ee290a179d349ace82752528b2ff946d60c092b99ef42f53c25d0c99f", "0x2a5cf8a3193107d982edd253002c7a52ab876b445dde8307ab78fbdca022d93c", "0x2b1ab4d5277f8c82750c1c7bd043889b71465ec64a9afc1bfa37d06b1ebd0725", "0x2a0dbf5c4373a58a83d5f2a031ea0615bf12800e33b70c3191a7cbb15966ced8", "0x1f272bb4a19d14a0abdfebc9fc83125e10623b9aef730f8d25f2bf5bead38ea9", "0x2c2339cf0ae7aff56091a568c1e2c3f01f52d8ed13400737fd31eaabcaffb9bd", "0x21f5fefe6b5fa0b5da71089befb74a1a39e52b4f830cb330c3c284e154614dfd", "0x1e6f6ba4b2444586b380dc4e2b3fad111ff1f4754420a846f53ea0789ebfb0ad", "0x1193d170b0b2dd0c4a04331a4b4aa3f12920f182ec3ab547837e30f1116ca584", "0x00000000000000000000000000000025704a15c9e2ce8a69558e7bbcdcbc7784", "0x2e5d36112770fb6c985681cafe40a8c99ad13f702309e7969801dd0ed080e727", "0x0eefc2585f591bb457183134e19ad643966272234d645514bf7868d6dd8ae2cb", "0x300803e4e2339ad39b9c31f228949bbeaf9c74b7101e7be1930b088126247eaa", "0x2bb562a50ed944b438b83b01f200101a34faef7f296a75c84c731755ebddbc1a", "0x1288e0b9c742af39cbcac21357c1b29511b0bbdd3d0e3cf5e14b2eef68a28ab3", "0x20f089131cc96d86ff1cfb67fa3f51670f4bad30158751b2587354bbec76cdf9", "0x1a26c6d3e633f9bf8434cf755b5f1217dad0d455071a97a7bcf85b824f5cf07a", "0x0d7e9b8a51fccf910ec25bdbd13e70b34bd6ea6f4d629fa744f9cdf5f2beb1cf", "0x0b40f28ce428e64df9cf5a024133fc420f39decf5f6af020cc3211ab298d4631", "0x0ca4f189dde7a55fe829f46681232904f6670249a22e0deb47222bd309523a8a", "0x2c544f2e31143783977645edb2a6bdb39b875053963bfa1a5b3ae9de204a7ebe", "0x00aae4454eb48fb18ff60db6b9d015abea2e770a2f7d86d121522b834c791ba5", "0x07d74e351fd4cccf4e18475d25211efa8a359066fc693a5c8505ddb507e4b74b", "0x07d74e351fd4cccf4e18475d25211efa8a359066fc693a5c8505ddb507e4b74b", "0x2d9e5bff47207d82533e2445959941181cc890c5779bc7f24d6e8a7b9e425b5c", "0x0aea3c0c317c441a5775a9849108d7a6889b39128235f717b09b184aa08e4eb7", "0x1ca5bc6fb37c55a562f4991901c39902f42d14db71284116df74cb4e7d55e493", "0x220fed26d64cd69f40e6d145a423e4a3c8cd0dce747e7d51647441270ad4d774", "0x15be574c9358889257aa2a30ff7b5fcc31a57da7032296e2c1201c49a44bbdb6", "0x2de539925525bedd3b7f43a9c6bf0f713151a17f79ac7ff4a9cd27b15ffe892a", "0x083086693dbf465211741e2cbff70ff38eb08383faf22d397eb2742c8ad7396a", "0x1fdfa258a890598816e807c50058d7a1462edd5ff196a2eae0f862e454b49aa1", "0x10c434c6daaa8226fa8e3e302123dfdc4455cf68063df518949df5a65a945213", "0x0000000000000000000000000000006472a7874de2c454a4591ed7784df1c104", "0x000000000000000000000000000000000008c46ac53d2c4ad0c26a5d6c790082", "0x0000000000000000000000000000005e422f9cfb8725800de60dfe0a8d4104c0", "0x000000000000000000000000000000000000f10fd4e4de81a0c00073ec91c274", "0x000000000000000000000000000000b20813090eca76bc6aa4a699b1ec8d5d6d", "0x0000000000000000000000000000000000292cc9f8a744eb00e0903c29ce87a7", "0x000000000000000000000000000000350a368b415fbb99fa90a26a42b1a3affd", "0x0000000000000000000000000000000000280eb9275cb05a3435f464d1dc369d", "0x000000000000000000000000000000280df6505e20c7725fe6d29439f96ee05d", "0x000000000000000000000000000000000017ef5033a08535451e2747827aa94b", "0x0000000000000000000000000000002f9ba89ae91b4e4a4ff8ccbd0526faad2f", "0x00000000000000000000000000000000001c2013561dafcc02cb03220bdf23c4", "0x000000000000000000000000000000aac102c400f9e5da0321ded4510994434b", "0x00000000000000000000000000000000001ec8ab9cc834b492fde124962f04a1", "0x0000000000000000000000000000000673dbd698da8b8cce450d2a083aba9987", "0x00000000000000000000000000000000000a49e55bb040249cb41c63cea901cd", "0x000000000000000000000000000000133d92af8d76ee0c74a12081ee7b2ef8c4", "0x0000000000000000000000000000000000240f552d1c6cbb007650e4b142e0a5", "0x000000000000000000000000000000e29c6e7d982ec08d51c79d6261c28d742d", "0x000000000000000000000000000000000021baeec04d9be419c923626034e7b3", "0x0000000000000000000000000000000000000000000000000000000000000001", "0x0000000000000000000000000000000000000000000000000000000000000000", "0x0000000000000000000000000000000000000000000000000000000000000002", "0x0000000000000000000000000000000000000000000000000000000000000000", "0x0000000000000000000000000000000000000000000000000000000000000001", "0x0000000000000000000000000000000000000000000000000000000000000000", "0x0000000000000000000000000000000000000000000000000000000000000002", "0x0000000000000000000000000000000000000000000000000000000000000000", "0x0000000000000000000000000000000000000000000000000000000000000001", "0x0000000000000000000000000000000000000000000000000000000000000000", "0x0000000000000000000000000000000000000000000000000000000000000002", "0x0000000000000000000000000000000000000000000000000000000000000000", "0x0000000000000000000000000000000000000000000000000000000000000001", "0x0000000000000000000000000000000000000000000000000000000000000000", "0x0000000000000000000000000000000000000000000000000000000000000002", "0x0000000000000000000000000000000000000000000000000000000000000000", "0x0000000000000000000000000000000000000000000000000000000000000001", "0x0000000000000000000000000000000000000000000000000000000000000000", "0x0000000000000000000000000000000000000000000000000000000000000002", "0x0000000000000000000000000000000000000000000000000000000000000000", "0x0000000000000000000000000000000000000000000000000000000000000001", "0x0000000000000000000000000000000000000000000000000000000000000000", "0x0000000000000000000000000000000000000000000000000000000000000002", "0x0000000000000000000000000000000000000000000000000000000000000000", "0x0000000000000000000000000000000000000000000000000000000000000001", "0x0000000000000000000000000000000000000000000000000000000000000000", "0x0000000000000000000000000000000000000000000000000000000000000002", "0x0000000000000000000000000000000000000000000000000000000000000000", "0x0000000000000000000000000000000000000000000000000000000000000001", "0x0000000000000000000000000000000000000000000000000000000000000000", "0x0000000000000000000000000000000000000000000000000000000000000002", "0x0000000000000000000000000000000000000000000000000000000000000000", "0x0000000000000000000000000000000000000000000000000000000000000001", "0x0000000000000000000000000000000000000000000000000000000000000000", "0x0000000000000000000000000000000000000000000000000000000000000002", "0x0000000000000000000000000000000000000000000000000000000000000000", "0x0000000000000000000000000000000000000000000000000000000000000001", "0x0000000000000000000000000000000000000000000000000000000000000000", "0x0000000000000000000000000000000000000000000000000000000000000002", "0x0000000000000000000000000000000000000000000000000000000000000000", "0x0000000000000000000000000000000000000000000000000000000000000001", "0x0000000000000000000000000000000000000000000000000000000000000000", "0x0000000000000000000000000000000000000000000000000000000000000002", "0x0000000000000000000000000000000000000000000000000000000000000000", "0x0000000000000000000000000000000000000000000000000000000000000001", "0x0000000000000000000000000000000000000000000000000000000000000000", "0x0000000000000000000000000000000000000000000000000000000000000002", "0x0000000000000000000000000000000000000000000000000000000000000000", "0x0000000000000000000000000000000000000000000000000000000000000001", "0x0000000000000000000000000000000000000000000000000000000000000000", "0x0000000000000000000000000000000000000000000000000000000000000002", "0x0000000000000000000000000000000000000000000000000000000000000000", "0x0000000000000000000000000000000000000000000000000000000000000001", "0x0000000000000000000000000000000000000000000000000000000000000000", "0x0000000000000000000000000000000000000000000000000000000000000002", "0x0000000000000000000000000000000000000000000000000000000000000000", "0x0000000000000000000000000000000000000000000000000000000000000001", "0x0000000000000000000000000000000000000000000000000000000000000000", "0x0000000000000000000000000000000000000000000000000000000000000002", "0x0000000000000000000000000000000000000000000000000000000000000000", "0x0000000000000000000000000000000000000000000000000000000000000001", "0x0000000000000000000000000000000000000000000000000000000000000000", "0x0000000000000000000000000000000000000000000000000000000000000002", "0x0000000000000000000000000000000000000000000000000000000000000000", "0x0000000000000000000000000000000000000000000000000000000000000001", "0x0000000000000000000000000000000000000000000000000000000000000000", "0x0000000000000000000000000000000000000000000000000000000000000002", "0x0000000000000000000000000000000000000000000000000000000000000000", "0x0000000000000000000000000000000000000000000000000000000000000001", "0x0000000000000000000000000000000000000000000000000000000000000000", "0x0000000000000000000000000000000000000000000000000000000000000002", "0x0000000000000000000000000000000000000000000000000000000000000000", "0x0000000000000000000000000000000000000000000000000000000000000001", "0x0000000000000000000000000000000000000000000000000000000000000000", "0x0000000000000000000000000000000000000000000000000000000000000002", "0x0000000000000000000000000000000000000000000000000000000000000000", "0x0000000000000000000000000000000000000000000000000000000000000001", "0x0000000000000000000000000000000000000000000000000000000000000000", "0x0000000000000000000000000000000000000000000000000000000000000002", "0x0000000000000000000000000000000000000000000000000000000000000000", "0x0000000000000000000000000000000000000000000000000000000000000001", "0x0000000000000000000000000000000000000000000000000000000000000000", "0x0000000000000000000000000000000000000000000000000000000000000002", "0x0000000000000000000000000000000000000000000000000000000000000000", "0x0000000000000000000000000000000000000000000000000000000000000001", "0x0000000000000000000000000000000000000000000000000000000000000000", "0x0000000000000000000000000000000000000000000000000000000000000002", "0x0000000000000000000000000000000000000000000000000000000000000000", "0x1e940a528b42d8230e7d4dff76262a80986c0d00b2c02a9bc0559e36212d1547", "0x1ceccf21ac39f70d76ad6f7fe0dcb33b6af04555a0b1959e4714d65925e4e253", "0x096139d757046cdbdb7ee89a95f112f70882a43a46c2f739d9be115dda013420", "0x2f9c8ac67c7825b08eff0e7f7656a671f4c64e5601f2efab35b1b795801eec04", "0x2077e648e1704851cdffd7e6e56311634a7b741bab77ca34d9dff12a6a2bfe99", "0x115d48c4a97aeb3c447a060f9e0d675b0dc7f4a05a3f5776e2f279f3a165d7dc", "0x0000000000000000000000000000000000000000000000000000000000000000", "0x0000000000000000000000000000000000000000000000000000000000000000", "0x0000000000000000000000000000000000000000000000000000000000000000", "0x0000000000000000000000000000000000000000000000000000000000000000", "0x0000000000000000000000000000000000000000000000000000000000000000", "0x0000000000000000000000000000000000000000000000000000000000000000", "0x0000000000000000000000000000000000000000000000000000000000000000", "0x0000000000000000000000000000000000000000000000000000000000000000", "0x0000000000000000000000000000000000000000000000000000000000000000", "0x0000000000000000000000000000000000000000000000000000000000000000", "0x0000000000000000000000000000000000000000000000000000000000000000", "0x0000000000000000000000000000000000000000000000000000000000000000", "0x0000000000000000000000000000000000000000000000000000000000000000", "0x0000000000000000000000000000000000000000000000000000000000000000", "0x0000000000000000000000000000000000000000000000000000000000000000", "0x0000000000000000000000000000000000000000000000000000000000000000", "0x0000000000000000000000000000000000000000000000000000000000000000", "0x0000000000000000000000000000000000000000000000000000000000000000", "0x0000000000000000000000000000000000000000000000000000000000000000", "0x0000000000000000000000000000000000000000000000000000000000000000", "0x0000000000000000000000000000000000000000000000000000000000000000", "0x0000000000000000000000000000000000000000000000000000000000000000", "0x000000000000000000000000000000fd38c45c3ec5b841482a80e3a56ce82555", "0x00000000000000000000000000000000000ad70b03f092f60af3e0ce1bb29d2c", "0x0000000000000000000000000000007a184d5342c90c634c0b1a050f0b97c9fb", "0x0000000000000000000000000000000000271f42abcb3bc1f0332e4b3ca85e1d", "0x0000000000000000000000000000008256322bbe2c1b8cd9d84e5ff6123477f2", "0x000000000000000000000000000000000025cab962761681dd9547f4c78814df", "0x0000000000000000000000000000008c4234510e5825c02b9ac427bcbf8e279a", "0x000000000000000000000000000000000013a14e0d7fc073c44643af38cc5396"]
\ No newline at end of file
diff --git a/test_programs/execution_success/double_verify_honk_proof/src/main.nr b/test_programs/execution_success/double_verify_honk_proof/src/main.nr
new file mode 100644
index 00000000000..82090bb8602
--- /dev/null
+++ b/test_programs/execution_success/double_verify_honk_proof/src/main.nr
@@ -0,0 +1,28 @@
+// This circuit aggregates two Honk proof from `assert_statement`.
+global SIZE_OF_PROOF_IF_LOGN_IS_28: u32 = 463;
+global HONK_IDENTIFIER: u32 = 1;
+fn main(
+    verification_key: [Field; 128],
+    // This is the proof without public inputs attached.
+    // This means: the size of this does not change with the number of public inputs.
+    proof: [Field; SIZE_OF_PROOF_IF_LOGN_IS_28],
+    public_inputs: pub [Field; 1],
+    key_hash: Field,
+    // The second proof, currently set to be identical
+    proof_b: [Field; SIZE_OF_PROOF_IF_LOGN_IS_28],
+) {
+    std::verify_proof_with_type(
+        verification_key,
+        proof,
+        public_inputs,
+        key_hash,
+        HONK_IDENTIFIER,
+    );
+    std::verify_proof_with_type(
+        verification_key,
+        proof_b,
+        public_inputs,
+        key_hash,
+        HONK_IDENTIFIER,
+    );
+}
diff --git a/test_programs/execution_success/double_verify_nested_proof/src/main.nr b/test_programs/execution_success/double_verify_nested_proof/src/main.nr
index 75a5fa9ebda..8dde07cae19 100644
--- a/test_programs/execution_success/double_verify_nested_proof/src/main.nr
+++ b/test_programs/execution_success/double_verify_nested_proof/src/main.nr
@@ -1,9 +1,8 @@
-
 // This circuit aggregates two recursive proofs from `double_verify_proof_recursive`.
-// Recursive aggregation is a backend-specific process and it is expected for backends 
-// to attach any extra data they may need (e.g. aggregation objects) to their proofs. 
-// Whether the proof we are verifying itself contains a recursive proof is expected to be 
-// a circuit constant by the barretenberg. Barretenberg hides this circuit constant in the 
+// Recursive aggregation is a backend-specific process and it is expected for backends
+// to attach any extra data they may need (e.g. aggregation objects) to their proofs.
+// Whether the proof we are verifying itself contains a recursive proof is expected to be
+// a circuit constant by the barretenberg. Barretenberg hides this circuit constant in the
 // proof serialization. Thus, we must have separate circuits for verifying a normal proof and a recursive proof
 // with two different proof sizes.
 fn main(
@@ -17,7 +16,7 @@ fn main(
     // This is currently not public. It is fine given that the vk is a part of the circuit definition.
     // I believe we want to eventually make it public too though.
     key_hash: Field,
-    proof_b: [Field; 109]
+    proof_b: [Field; 109],
 ) {
     std::verify_proof(verification_key, proof, public_inputs, key_hash);
 
diff --git a/test_programs/execution_success/double_verify_proof/src/main.nr b/test_programs/execution_success/double_verify_proof/src/main.nr
index 8d73bb09aa5..8f9fbf7bec5 100644
--- a/test_programs/execution_success/double_verify_proof/src/main.nr
+++ b/test_programs/execution_success/double_verify_proof/src/main.nr
@@ -1,16 +1,15 @@
-
-// This circuit aggregates two proofs from `assert_statement_recursive`.
+// This circuit aggregates two proofs from `assert_statement`.
 fn main(
     verification_key: [Field; 114],
     // This is the proof without public inputs attached.
-    // 
+    //
     // This means: the size of this does not change with the number of public inputs.
     proof: [Field; 93],
     public_inputs: pub [Field; 1],
     // This is currently not public. It is fine given that the vk is a part of the circuit definition.
     // I believe we want to eventually make it public too though.
     key_hash: Field,
-    proof_b: [Field; 93]
+    proof_b: [Field; 93],
 ) {
     std::verify_proof(verification_key, proof, public_inputs, key_hash);
 
diff --git a/test_programs/execution_success/double_verify_proof_recursive/Nargo.toml b/test_programs/execution_success/double_verify_proof_recursive/Nargo.toml
deleted file mode 100644
index b7688b33bfd..00000000000
--- a/test_programs/execution_success/double_verify_proof_recursive/Nargo.toml
+++ /dev/null
@@ -1,5 +0,0 @@
-[package]
-name = "double_verify_proof_recursive"
-type = "bin"
-authors = [""]
-[dependencies]
diff --git a/test_programs/execution_success/double_verify_proof_recursive/Prover.toml b/test_programs/execution_success/double_verify_proof_recursive/Prover.toml
deleted file mode 100644
index dff48212e50..00000000000
--- a/test_programs/execution_success/double_verify_proof_recursive/Prover.toml
+++ /dev/null
@@ -1,5 +0,0 @@
-key_hash = "0x096129b1c6e108252fc5c829c4cc9b7e8f0d1fd9f29c2532b563d6396645e08f"
-proof = ["0x000000000000000000000000000000d62b795bec274279129a71195796825fcc","0x00000000000000000000000000000000000793ab763140f20a68a6bd2721fd74","0x00000000000000000000000000000053141d06d3307b36153f321511199e579c","0x00000000000000000000000000000000000a4b55d6c21f98a9c434911dcb5c67","0x0000000000000000000000000000005f9d324c0abd22cec92d99dbec438e9491","0x0000000000000000000000000000000000240dfafe1b53dc27147cbab14ea893","0x000000000000000000000000000000044a61d3aac32c6931247cf334a19d9611","0x000000000000000000000000000000000003f0f8cf4207bfa85c23ec9f8d0c88","0x00000000000000000000000000000002168a470e39ba2ac266f6b474de12045f","0x000000000000000000000000000000000025791e7d3feab542345c00ec5a30df","0x000000000000000000000000000000dcafd76d4c3640969c80e017b951ef6397","0x00000000000000000000000000000000001d27f75a1256771e88e0c86fc42dbc","0x0000000000000000000000000000007347ae7d2d9d7fc2b8f0baa014ee1fed9f","0x000000000000000000000000000000000018bd927f42bf7caf9555f56f09000d","0x000000000000000000000000000000041f765f83cbe5904c8f453f70a4531d10","0x00000000000000000000000000000000001858aabeeb5331a221419f4fed1c19","0x000000000000000000000000000000d254a54caaedf8287b9af951b2f2611121","0x000000000000000000000000000000000005ab493623c9563cf2e55ba5f18200","0x00000000000000000000000000000014f24cddc1a02440dc63637df8032c8074","0x000000000000000000000000000000000011950c16cef98471b1d78b935195a4","0x000000000000000000000000000000b0340b459e6bd5cc8f031c8654a502897f","0x00000000000000000000000000000000000e1cf3968dac4545a76a2ae58e512c","0x0000000000000000000000000000002adf7218aa06ca0d2c2e600dcc39193a2d","0x00000000000000000000000000000000001302e7e4b0f14749bd885ca25588b6","0x00000000000000000000000000000092009ce4056e79ab815d8cdfd4491138ae","0x000000000000000000000000000000000018af11e853c6cf2f0f6274b0da8133","0x000000000000000000000000000000dd3dc6f49232141718527b3a0e4b26e21d","0x00000000000000000000000000000000001a877853348a8b695c4f9a9aa4ce68","0x000000000000000000000000000000aecfc56ba07155450b368140d6324023b5","0x000000000000000000000000000000000029c11052798c57ece614617d33fcc2","0x000000000000000000000000000000eb106ffc816d16fb84e84b0b61157b2603","0x000000000000000000000000000000000026c3cac16206899a21cb5126841446","0x000000000000000000000000000000a782ed54805fe845068b362b58e2fa34ec","0x00000000000000000000000000000000000cf046a1bfcc666b7f28b572676073","0x000000000000000000000000000000b931c8dda60bb4aca4cc817f5540f1209f","0x000000000000000000000000000000000024ad50c3936fafc3d190e6a4874223","0x000000000000000000000000000000cce90cfbaf5671c8c8652db28a3a9566f7","0x000000000000000000000000000000000003574db9d0f84380c9635660f86354","0x0000000000000000000000000000003eb3e1dc31846a90f721e7a08c6d6dc4f7","0x000000000000000000000000000000000028999a700cd1abae1a288eebb9a91c","0x000000000000000000000000000000c1be4d385b11387e14eb9817050d772f78","0x000000000000000000000000000000000003c56b5bad8b4484c66ac921f1f102","0x000000000000000000000000000000ace245cabf0f00dc7fd253dd8af0377a14","0x0000000000000000000000000000000000107f1731fcf34b364c813599fa1df7","0x035b937d404932b542b706eb810ef4a7dca4566d4dde1ad6a8717f46167ead7e","0x17608cef3dc7960f41cb1295706df663727d45ee598a61e05e989d111449fb65","0x054712a950ad67da3aa860e49e6891f99b586b7f37caff94eb013fdb374b61ee","0x04b755083086c769b7f593e0e48d68dc54be808203351380ca5566a48149d8bb","0x17d7670b0915235f626fdc1d7e1134d2be906ef138d7843384b3ebc23b1d630f","0x064cf544ab5f4e3dab47960502cccc83321fb275068dfbdd3a2fcbc6dddcaa65","0x083338262712e2b66769ea40d9f412b18caa1bc81a51ff5a50b6c41f8c4b3d23","0x0cdd38958cab97defde00f4a5961b6fd676e29d9f2c352f6bb2c68b91f83f8af","0x02c8bdd005c2f43a0a8cbb2744916ce5c322dfa5b23367a829c12699f4036d32","0x25bac73c7e7b659fbea3135b7a0decf9db8dc3045bd2837dae337c64cc722546","0x19eb361aa419d37bce3d2e8b2b7692a02a9559e83d7f3d8fe9169970fbbc2cba","0x2494bd5106d00e05c7ea60e632e9fe03773b7f2c5b662aa37ec512a01f4a0775","0x18c52c2f2c6e7be1d7847c15e452a3a9c64316103d12e4b5b9a82fac4e940ee9","0x0e0342810456ef78f498c1bfa085a5f3cbc06db1f32fabd0ea9ad27dccac1680","0x024c13d6ef56af33ed7164ea8e47ddecc8a487b000d8b1b45edcd3895a503ba2","0x26e0d127f626bd39b55bc5d0c131dbf03fe006dc5c3edc57dda1e629799a4317","0x1b1140061bc52b15c4f5e100729a81968ee79dc03deb966a18850335a8e44a8b","0x1bb76f945199e71d531a89288912087a02dd0e83020e65d671485bf2e5e86e1a","0x29269900859c6d86e404185b415bf3b279cd100f38cfdb0077e8d6a299c4fd35","0x22b5e94bae2f6f0cdb424a3b12c4bf82cec3fb228e012c1974ed457827bbe012","0x18d3543a93249778e7a57936170dae85ffc47c2567f2d0076a32c0bb86fcf10a","0x03721dc2670206cde42a175fd56bcce32cf6cb8801450a8e8e4b3d4e07785973","0x2806db136dd214d3ac1478460855cae6a4324ab45cab35320d104fee26c260e8","0x1c3749f1937082afbbae9375b9be708cf339e1983e57ef4447f36cfa560c685c","0x1067b8cfb90ef08bcb48aea56b2716334241787c2004a95682d68a0685566fd0","0x0f41aee4416398f1d48ffc302403273cddef34a41f98507c53682041d82e51ff","0x10d854c9f0bfbdff7ca91a68f4978e9a79e7b14243d92f465f17bdf88d9f64f8","0x00000000000000000000000000000000018938b11099e0cdc05ddab84a153a97","0x0000000000000000000000000000000001d7dda1471f0dc3b3a3d3438c197982","0x00000000000000000000000000000000022682917da43ab9a6e9cbcece1db86d","0x2453913e6b0f36eab883ac4b0e0604d56aaeb9c55e641135173e63c342f1a660","0x05216c1b58dc43a49d01aaba3113b0e86be450fc17d28016e648e7162a1b67fb","0x152b34845a0222a2b41354c0d395a250d8363dc18748647d85acd89d6934ec56","0x1dfc6e971ce82b7dcda1f7f282713c6e22a8c79258a61209bda69719806da544","0x2968dd8b3af8e3953f1fbbd72f4c49b8270597bb27d4037adc157ac6083bee60","0x1b9425b88a4c7d39b3d75afe66917a9aa1d2055724392bc01fb918d84ff1410e","0x04ab571f236d8e750904dc307dd274003d9130f1a7110e4c1521cfb408877c73","0x2ad84f26fdc5831545272d02b806bb0e6dae44e71f73552c4eb9ff06030748c7","0x020e632b99d325db774b8630fb50b9a4e74d35b7f27d9fc02c65087ee747e42c","0x09a8c5a3171268cb61c02515c01c109889200ed13f415ae54df2078bbb887f92","0x1143281a9451abbb4c34c3fa84e7678c2af2e7ea8c05160a6f7f06988fc91af8","0x000000000000000000000000000000cbda736ca5cf6bc75413c2cc9e28ab0a68","0x00000000000000000000000000000000001ee78c9cc56aa5991062ae2e338587","0x000000000000000000000000000000bc9bfcdebb486f4cb314e681d2cc5f8df6","0x00000000000000000000000000000000000ad538431d04771bca7f633cb659ff","0x000000000000000000000000000000d45b317afcefa466a59bba9e171f1af70c","0x0000000000000000000000000000000000133c50180ea17932e4881124e7a7c6","0x000000000000000000000000000000fc9ed37f543775849f3e84eaa06f77f992","0x00000000000000000000000000000000001372873c9c051d1baff99248b8f70e"]
-public_inputs = ["0x0000000000000000000000000000000000000000000000000000000000000003"]
-verification_key = ["0x2b337de1c8c14f22ec9b9e2f96afef3652627366f8170a0a948dad4ac1bd5e80","0x0000000000000000000000000000000000000000000000000000000000000008","0x0000000000000000000000000000000000000000000000000000000000000005","0x0000000000000000000000000000000000000000000000000000000000000008","0x0000000000000000000000000000000000000000000000000000000000000001","0x0000000000000000000000000000000000000000000000000000000000000000","0x0000000000000000000000000000000000000000000000000000000000000000","0x0000000000000000000000000000000000000000000000000000000000000000","0x0000000000000000000000000000000000000000000000000000000000000000","0x0000000000000000000000000000000000000000000000000000000000000000","0x0000000000000000000000000000000000000000000000000000000000000000","0x0000000000000000000000000000000000000000000000000000000000000000","0x0000000000000000000000000000000000000000000000000000000000000000","0x0000000000000000000000000000000000000000000000000000000000000000","0x0000000000000000000000000000000000000000000000000000000000000000","0x0000000000000000000000000000000000000000000000000000000000000000","0x0000000000000000000000000000000000000000000000000000000000000000","0x0000000000000000000000000000000000000000000000000000000000000000","0x0000000000000000000000000000000000000000000000000000000000000000","0x0000000000000000000000000000000000000000000000000000000000000000","0x0000000000000000000000000000000000000000000000000000000000000000","0x0000000000000000000000000000000000000000000000000000000000000000","0x00000000000000000000000000000092139c61bae1a44f0fc7689507414be688","0x00000000000000000000000000000000000160ce4e279582f91bde4f03f5e9a2","0x0000000000000000000000000000005dc2d37f658c3b2d60f24740eb13b65d79","0x000000000000000000000000000000000007e3e8a5d98a1177ec85bf88f163a5","0x000000000000000000000000000000dc3035fbd7ff16412a8fd7da587a935298","0x000000000000000000000000000000000023d08e2817ac16990004ed11d8fc66","0x000000000000000000000000000000356a5ad59c646c746a8d09f5d154e47c4f","0x00000000000000000000000000000000000708529196af3c8e16ffa580c26182","0x0000000000000000000000000000002ddfe70eb7a1280596e8e4a804f118a6dd","0x000000000000000000000000000000000013757e15a0905f298303784a161b21","0x000000000000000000000000000000a23a729df796935c7824e3a26be794829b","0x000000000000000000000000000000000005775b6c146c4a59856e869fe5a70e","0x000000000000000000000000000000eef0c9e088fd2d45aa40311082d1f2809b","0x00000000000000000000000000000000001d539ccbfc556d0ad59307a218de65","0x000000000000000000000000000000a2c848beceb6ab7806fd3b88037b8410fc","0x0000000000000000000000000000000000177004deeb1f9d401fd7b1af1a5ac8","0x0000000000000000000000000000002508eb63672a733f20de1a97644be4f540","0x00000000000000000000000000000000000d82d51f2f75d806285fd248c819b8","0x000000000000000000000000000000d002f9100cbba8a29f13b11513c53c59d0","0x000000000000000000000000000000000006cd3b0e3460533b9e5ea2cdc0fcbb","0x000000000000000000000000000000f45ea38a93b2f810c5633ddb54927c1c96","0x000000000000000000000000000000000021791de65f9a28ec7024b1a87ab4f3","0x000000000000000000000000000000926511a0439502c86885a8c6f0327aa7ad","0x000000000000000000000000000000000029fa14a969c5d81ed3abbbfb11220a","0x000000000000000000000000000000b84c3258e8206f560e5b5b18cbeafef87e","0x00000000000000000000000000000000002a910445cd8fc895e5d235cd8ea185","0x000000000000000000000000000000887e67f15e84bcb8507a5064a363f6043b","0x000000000000000000000000000000000014dc6643d801c3ef27c2066b6e2bb4","0x000000000000000000000000000000e38e900b42c314ba803088e8fbf125203f","0x000000000000000000000000000000000020690fd4869db418306046b38161dc","0x0000000000000000000000000000001e2fa856bf7951b8292b1e88185993629c","0x0000000000000000000000000000000000048a85e0bbac7c60ad3d78f601f63c","0x0000000000000000000000000000006f457719495073d3666d77a625aeab0c51","0x00000000000000000000000000000000002623ad892dc62b1fa7d0a650f0d470","0x000000000000000000000000000000dbfcc8a467e021c03b13f74a9f79c3a10c","0x0000000000000000000000000000000000295f6f10976c37bd9c6f96bb7187d5","0x000000000000000000000000000000c13ef9a937cc12420fb38d9ab8e848e85e","0x000000000000000000000000000000000003560a3b334e887532f605c9cb7628","0x0000000000000000000000000000009bcebf08a4599cdda0fb96312d4dc0c7a9","0x000000000000000000000000000000000015adc8bb1e01c835f48959d1237bd6","0x00000000000000000000000000000047762ab839e4ff63c77605a9f383da37c2","0x000000000000000000000000000000000016a8c3c53d89660cf271522cd301fb","0x000000000000000000000000000000f0c8539a0b5f94420a513f9c305b932bfe","0x00000000000000000000000000000000002957ba01d9de5638f808f88a692533","0x000000000000000000000000000000ab17c6189d67d3bf5dd2f3885de0151b6f","0x0000000000000000000000000000000000060d8aa43fdc434d1942263f364d95","0x0000000000000000000000000000005d292333b3adb497f00b4bc32d45229060","0x00000000000000000000000000000000001a1018a66221883639f2898a66f345","0x00000000000000000000000000000006555a806b1993291deba0dc44e2abf431","0x00000000000000000000000000000000000cacff7099a9d5e35a21f4a00b2dc3","0x000000000000000000000000000000f50c11ba95d349c36d143eefd12e494950","0x00000000000000000000000000000000001022e8c5f02d639bc9dd8bc4407f99","0x000000000000000000000000000000c76828795098eda73d50b4b585c60afc60","0x00000000000000000000000000000000002bf09c0ec7011e93888962f2406630","0x00000000000000000000000000000049e5c83a8978d832fb8e144548e3ca1adb","0x00000000000000000000000000000000000e0ec242c2e160a984f61ca5adf5f5","0x0000000000000000000000000000009c5d6e08a6605ab4513748ac0fa017dd1c","0x00000000000000000000000000000000001f54baa07558e5fb055bd9ba49c067","0x0000000000000000000000000000001e1ee7ee29bbb5e4b080c6091c1433ce62","0x000000000000000000000000000000000024aec62a9d9763499267dc98c33428","0x0000000000000000000000000000001a96755946ff16f0d6632365f0eb0ab4d4","0x000000000000000000000000000000000028cf3e22bcd53782ebc3e0490e27e5","0x00000000000000000000000000000043148d7d8c9ba43f2133fab4201435a364","0x0000000000000000000000000000000000234ce541f1f5117dd404cfaf01a229","0x000000000000000000000000000000a7fb95ffb461d9514a1070e2d2403982ef","0x00000000000000000000000000000000003016955028b6390f446c3fd0c5b424","0x00000000000000000000000000000008863c3b7cd7cddc20ba79ce915051c56e","0x000000000000000000000000000000000013ef666111b0be56a235983d397d2a","0x000000000000000000000000000000e3993f465fc9f56e93ac769e597b752c1c","0x0000000000000000000000000000000000217f7c4235161e9a3c16c45b6ca499","0x0000000000000000000000000000008ffa4cd96bc67b0b7df5678271e1114075","0x0000000000000000000000000000000000256467bfcb63d9fdcb5dde397757ad","0x00000000000000000000000000000054e5eb270bb64bde6e6ececadfd8c3236c","0x00000000000000000000000000000000000e52d1bd75812c33c6f3d79ee4b94c","0x000000000000000000000000000000484a2c641dce55bc2dd64ef0cd790a7fea","0x00000000000000000000000000000000000ff417d256be43e73c8b1aa85bdda3","0x0000000000000000000000000000000b72e7b7713ab5da44e0f864182e748a23","0x00000000000000000000000000000000001a221055f1625ad833a44705f5f74e","0x00000000000000000000000000000067a99a34e9b81a17ad001db02e29bcb82a","0x000000000000000000000000000000000018a6c02e398389827568fa960e86e2","0x000000000000000000000000000000bb29f26f9890d6cc6401f4921d5884edca","0x00000000000000000000000000000000000868357b28039385c5a5058b6d358e","0x00000000000000000000000000000036fb6e229dde8edf7ec858b12d7e8be485","0x00000000000000000000000000000000001060afe929554ca473103f5e68193c","0x00000000000000000000000000000015226e07e207744c0857074dcab883af4a","0x00000000000000000000000000000000000b1c02619282755533457230b19b4a","0x0000000000000000000000000000001f2a0277e4807e6e1cbabca21dde5eb5e1","0x00000000000000000000000000000000000d928deafed363659688ed4ccdef52","0x000000000000000000000000000000363f0c994e91cecad25835338edee2294f","0x00000000000000000000000000000000002eea648c8732596b1314fe2a4d2f05","0x000000000000000000000000000000b2671d2ae51d31c1210433c3972bb64578","0x00000000000000000000000000000000000ab49886c2b94bd0bd3f6ed1dbbe2c"]
-proof_b = ["0x000000000000000000000000000000f05c69448ca29bdf52076f9b073bb30fed","0x000000000000000000000000000000000028c86bb3e27b4aaaaef126f7df5349","0x00000000000000000000000000000026ae031fc93594375dfc7f3bbe027f97d5","0x000000000000000000000000000000000000dd12c7290fe7f775796a233b8590","0x000000000000000000000000000000c1ee6631704de424d010c5c4ac8293ac49","0x00000000000000000000000000000000002f41818c9aa83f5c8d9bdd128015b9","0x000000000000000000000000000000b50a5801482f7e3a5de8ab3cce0f10b0d3","0x000000000000000000000000000000000022a0bc69c293dbf293b25bc9eef7f8","0x0000000000000000000000000000003b02abf1967ef394154dc15d763135e903","0x00000000000000000000000000000000000d8a2ee46acc6d1ed8d517b56d47c8","0x00000000000000000000000000000039bf0d1b3d8cf9de898f101c626e978d78","0x0000000000000000000000000000000000008faa7df2451a24d291a9b584f1a5","0x000000000000000000000000000000c1dae329ed7adf63a2d89a5f16fb98b6d8","0x00000000000000000000000000000000001ff0bc16fc0bd4aa2d6255690453c2","0x000000000000000000000000000000d12d7589f853a9b472613efa56689beaf1","0x00000000000000000000000000000000002d6fbc798f4403751df6aeee8bedd3","0x0000000000000000000000000000007c1fa069cb17194fecf88db9dd54a4ee36","0x0000000000000000000000000000000000268e026f9814822a42b2d59eec5d24","0x000000000000000000000000000000c3fb56beab774218cd63498fc050a5fd9b","0x00000000000000000000000000000000000071c014d7b5063f005a0bc2ee1af4","0x000000000000000000000000000000ae12b25371c6af42bbe0a85cddd2eaebc7","0x000000000000000000000000000000000026d270e1ffc9c7c344c694dfadda83","0x00000000000000000000000000000080280858c6be461716921caa3c26f3f6f3","0x000000000000000000000000000000000001dcdd3f39e27d0ce6aa5d14dff4c1","0x000000000000000000000000000000080e1d2c913c834ebcf7e0600c076c08fd","0x00000000000000000000000000000000002df3d142217694e65fb7c355d62764","0x000000000000000000000000000000e5e336f3f59d77e500f49771bfbeb12e83","0x000000000000000000000000000000000028fffe08bdc4c0690643d2e1a1275f","0x000000000000000000000000000000db5618b32afc13e18f21b39f3fbede9d11","0x00000000000000000000000000000000001d244818370d43fb7e8bc67e03787b","0x0000000000000000000000000000006bcc1fd3f9f78449ad1df1bc11bc379edd","0x000000000000000000000000000000000009ac9cbb285edbf5b3a973f3f5f1cb","0x000000000000000000000000000000fd885905b6c0fc95bb4dd0b11f6797d4b3","0x000000000000000000000000000000000021f07995cdd835145e19c38127c562","0x000000000000000000000000000000bbbf2b975c2c97ae4b45c4a52059e53ee3","0x000000000000000000000000000000000024158163788841cf4590bbc1e89a90","0x0000000000000000000000000000009aca93d2b1386ea412d4b36ea5bb9894a8","0x00000000000000000000000000000000002532d1d210e8ed4c2f5c00cbaaa475","0x000000000000000000000000000000634a88caa1d77cb6b5fe77cac31458fc31","0x00000000000000000000000000000000000bdf18bae92fce7cfddab5520cac6e","0x000000000000000000000000000000622e9626255170ccec77602c755aa193e1","0x000000000000000000000000000000000001d4edba370e04436a988bad05dada","0x000000000000000000000000000000b52934323a0aec8f803cdaafee2ab7bfb2","0x0000000000000000000000000000000000155312af5e0e25ca9fd61aef9e58ed","0x06270b517855f6f6a608e432883d1d1030a12a1e33022dc142b7728691421da2","0x2af7c794d7b720b25eb1df0afd8c8e3c15b6e518194c3caea7966a5f8210ff04","0x073fe573aeb27d81a5713be93e1365390dcbc3c8e7439ff1d36a84cc014f5642","0x11351b961147431e54535248b58b35cf5cddb9b13827899167617d7a96794d64","0x297c9421c9c3db286770787c35b86bc41583386491b4ae55e5fa81aefa21efc4","0x0f4eeca3ff4a3495f859898937688652d33f9b4dd3e003e12adf15278e0997c3","0x133e3d8b82721d40d919f2326810ba6f07eff3f7d20d86b2bde692a811522019","0x2c502f53c9698b73bb8c8f9b9cf2d705d16a64a7040348b4b39c637a2064316c","0x0cbc1971e1c566cde9d9125c91cdc88e817db182692f836c1a5170a6246eaf73","0x12c47793e7db706c637cd4b4d96d227f569850176b852b1fe8ad522ddb38ef0e","0x0cd7b300e9309a135285be1aeb02b152f97931a7357ab6d609a2cb1970aab877","0x2a7789dfe286c9d0a7592f1c9316e730cb14c9d843aefc4764d76e7f8571c96a","0x248ac54ce3dbf37796621882a4ac76046df5ab680da487fd85cce76b1ae392d3","0x149d1d07cebe320f77b03533e34912545cedeae62bd9778d37724728762b5710","0x00fe29daebdaed61309790e70e2dcefa3f3af4c6c965ce424b8dbcf09b8e4b49","0x2b75b3bace61b731d7f0c003a144b62b0a4fbe9f0d14ca89b0652b70210014b3","0x2588ef27cfb6e0d8c6f9a969b2da44fead30a02ed70a563fd15aa45bb671de1c","0x2b74d7674b55642697b4a1e226eddb0e4918b2d57aa5b99093dc46cadcdea000","0x244c626845d3a5040f08f01e9611f968ad675ca857789149b13a0cfa83a2e064","0x2cb8d02f90cae33fd7bcfb80af4aff067c4f5fc4b3f9228d5b8f768bc8f6c971","0x1372f3d1f04e0c39a50e823d5da03d70bebe19a1b8e28f8c2ff601cc0bfc0095","0x19af6601d2613426a50b7c35d60562a5f2f2634e6af56dac13459632e15570ee","0x13c2a16ed3b65dcd9414659be79af17995d344de34eaf962343b0f1e76c73a57","0x0dd5dcdbd50b8774831d4f01f930804d38b4266dfee085185530880a0c3903c0","0x07e91848d660b11b722638680ac60f20db9507fdc8d610ce762600f5a1aacd29","0x1f9c2a94d10c0a7fb60292cfc46fd3d2501181bea0ffe1f5f2501d474be3a785","0x14edb9c5bd389eae08a5ea2a7a1662894e1e878c142084d966a625bef68cf7c3","0x00000000000000000000000000000000cecd01810814d175f0a533f0067618c4","0x00000000000000000000000000000000f82935013ce5c82720c63e533af41db8","0x000000000000000000000000000000012185688171b6bed850e748b66f7222ac","0x2dd7f5ff2150155c2ac86ebe28d9ecbca2eea812b0021ab2bceae111cfea8325","0x04ea6c2daf2b9e827d2213c3d03953410dcf1ed67ba34a3c00e772be92606a8b","0x163f2bd18dcde52f99b9867c944780fd718d1612927053b139b280fc55013d1b","0x05e388fd160ccac30a8f7b18a4bd042f705e92b5937e8c0e9478e2ff623907c6","0x00ba3f6f527d6ed3ff17a63b1d5be3c42bdfae88fdf63311fc7b871157939309","0x16187d9daa8c2e5a1a9ab15be7ca6a8feebfb31bea76f9a3ca69381881c70561","0x0f64522e4904edb7377b14a7b9dad848829167324ef5c016346b3ad8251191ee","0x273bbe6000a4001dce369e5a36cc0b0ca3fd351665b688238aa8c556a6ca6b8e","0x022d2232efb2faa8307846c9a4c697aabad1b7f1336b35ad72fa8922975b49d9","0x0d82d478bff3955c4b0a34ef94427ca5f9da23147ad953c89f2e428277ec2825","0x18d886be90343010659c231583be61a138e28e37c24771e3cb61fbe2587d0671","0x000000000000000000000000000000196ba6a58dbeb7c34cb1d6287e23d434de","0x00000000000000000000000000000000001df8ae8a1589590f8863c1fefd8dfd","0x000000000000000000000000000000f30e11b2c5fbefa166cbb9f58c5f8e1a4c","0x000000000000000000000000000000000026420ade7666bc0ab1cf1fd9d0c534","0x0000000000000000000000000000000feb5b7d8260d25a1ee1ce76ff461673fc","0x00000000000000000000000000000000002bd2ac6223a80671b777bf5dca70a4","0x000000000000000000000000000000690f757006d2fa1ddb0114c9f268783537","0x000000000000000000000000000000000023ad36feadd91e50118f32e97a0204"]
\ No newline at end of file
diff --git a/test_programs/execution_success/double_verify_proof_recursive/src/main.nr b/test_programs/execution_success/double_verify_proof_recursive/src/main.nr
deleted file mode 100644
index 5137a538e42..00000000000
--- a/test_programs/execution_success/double_verify_proof_recursive/src/main.nr
+++ /dev/null
@@ -1,19 +0,0 @@
-
-// This circuit aggregates two proofs from `assert_statement_recursive`.
-#[recursive]
-fn main(
-    verification_key: [Field; 114],
-    // This is the proof without public inputs attached.
-    // 
-    // This means: the size of this does not change with the number of public inputs.
-    proof: [Field; 93],
-    public_inputs: pub [Field; 1],
-    // This is currently not public. It is fine given that the vk is a part of the circuit definition.
-    // I believe we want to eventually make it public too though.
-    key_hash: Field,
-    proof_b: [Field; 93]
-) {
-    std::verify_proof(verification_key, proof, public_inputs, key_hash);
-
-    std::verify_proof(verification_key, proof_b, public_inputs, key_hash);
-}
diff --git a/test_programs/execution_success/ecdsa_secp256k1/src/main.nr b/test_programs/execution_success/ecdsa_secp256k1/src/main.nr
index 7f0999fc360..00d420089fc 100644
--- a/test_programs/execution_success/ecdsa_secp256k1/src/main.nr
+++ b/test_programs/execution_success/ecdsa_secp256k1/src/main.nr
@@ -3,12 +3,13 @@ fn main(
     hashed_message: [u8; 32],
     pub_key_x: [u8; 32],
     pub_key_y: [u8; 32],
-    signature: [u8; 64]
+    signature: [u8; 64],
 ) {
     // Hash the message, since secp256k1 expects a hashed_message
     let expected = std::hash::sha256(message);
     assert(hashed_message == expected);
 
-    let valid_signature = std::ecdsa_secp256k1::verify_signature(pub_key_x, pub_key_y, signature, hashed_message);
+    let valid_signature =
+        std::ecdsa_secp256k1::verify_signature(pub_key_x, pub_key_y, signature, hashed_message);
     assert(valid_signature);
 }
diff --git a/test_programs/execution_success/ecdsa_secp256r1/src/main.nr b/test_programs/execution_success/ecdsa_secp256r1/src/main.nr
index 09f427c37d9..d65e4a371b9 100644
--- a/test_programs/execution_success/ecdsa_secp256r1/src/main.nr
+++ b/test_programs/execution_success/ecdsa_secp256r1/src/main.nr
@@ -1,4 +1,5 @@
 fn main(hashed_message: [u8; 32], pub_key_x: [u8; 32], pub_key_y: [u8; 32], signature: [u8; 64]) {
-    let valid_signature = std::ecdsa_secp256r1::verify_signature(pub_key_x, pub_key_y, signature, hashed_message);
+    let valid_signature =
+        std::ecdsa_secp256r1::verify_signature(pub_key_x, pub_key_y, signature, hashed_message);
     assert(valid_signature);
 }
diff --git a/test_programs/execution_success/ecdsa_secp256r1_3x/src/main.nr b/test_programs/execution_success/ecdsa_secp256r1_3x/src/main.nr
index b5bd633915f..ab9b70e52df 100644
--- a/test_programs/execution_success/ecdsa_secp256r1_3x/src/main.nr
+++ b/test_programs/execution_success/ecdsa_secp256r1_3x/src/main.nr
@@ -10,12 +10,23 @@ fn main(
     hashed_message_3: [u8; 32],
     pub_key_x_3: [u8; 32],
     pub_key_y_3: [u8; 32],
-    signature_3: [u8; 64]
+    signature_3: [u8; 64],
 ) {
-    let valid_signature = std::ecdsa_secp256r1::verify_signature(pub_key_x, pub_key_y, signature, hashed_message);
+    let valid_signature =
+        std::ecdsa_secp256r1::verify_signature(pub_key_x, pub_key_y, signature, hashed_message);
     assert(valid_signature);
-    let valid_signature_2 = std::ecdsa_secp256r1::verify_signature(pub_key_x_2, pub_key_y_2, signature_2, hashed_message_2);
+    let valid_signature_2 = std::ecdsa_secp256r1::verify_signature(
+        pub_key_x_2,
+        pub_key_y_2,
+        signature_2,
+        hashed_message_2,
+    );
     assert(valid_signature_2);
-    let valid_signature_3 = std::ecdsa_secp256r1::verify_signature(pub_key_x_3, pub_key_y_3, signature_3, hashed_message_3);
+    let valid_signature_3 = std::ecdsa_secp256r1::verify_signature(
+        pub_key_x_3,
+        pub_key_y_3,
+        signature_3,
+        hashed_message_3,
+    );
     assert(valid_signature_3);
 }
diff --git a/test_programs/execution_success/eddsa/Nargo.toml b/test_programs/execution_success/eddsa/Nargo.toml
deleted file mode 100644
index 0f545c2febc..00000000000
--- a/test_programs/execution_success/eddsa/Nargo.toml
+++ /dev/null
@@ -1,7 +0,0 @@
-[package]
-name = "eddsa"
-description = "Eddsa verification"
-type = "bin"
-authors = [""]
-
-[dependencies]
diff --git a/test_programs/execution_success/eddsa/Prover.toml b/test_programs/execution_success/eddsa/Prover.toml
deleted file mode 100644
index 53555202ca6..00000000000
--- a/test_programs/execution_success/eddsa/Prover.toml
+++ /dev/null
@@ -1,3 +0,0 @@
-_priv_key_a = 123
-_priv_key_b = 456
-msg = 789
diff --git a/test_programs/execution_success/eddsa/src/main.nr b/test_programs/execution_success/eddsa/src/main.nr
deleted file mode 100644
index 407ca049806..00000000000
--- a/test_programs/execution_success/eddsa/src/main.nr
+++ /dev/null
@@ -1,55 +0,0 @@
-use std::compat;
-use std::ec::consts::te::baby_jubjub;
-use std::ec::tecurve::affine::Point as TEPoint;
-use std::hash;
-use std::eddsa::{eddsa_to_pub, eddsa_poseidon_verify, eddsa_verify};
-use std::hash::poseidon2::Poseidon2Hasher;
-
-fn main(msg: pub Field, _priv_key_a: Field, _priv_key_b: Field) {
-    // Skip this test for non-bn254 backends
-    if compat::is_bn254() {
-        let bjj = baby_jubjub();
-
-        let pub_key_a = bjj.curve.mul(_priv_key_a, bjj.curve.gen);
-        let pub_key_b = bjj.curve.mul(_priv_key_b, bjj.curve.gen);
-        let (pub_key_a_x, pub_key_a_y) = eddsa_to_pub(_priv_key_a);
-        let (pub_key_b_x, pub_key_b_y) = eddsa_to_pub(_priv_key_b);
-        assert(TEPoint::new(pub_key_a_x, pub_key_a_y) == pub_key_a);
-        assert(TEPoint::new(pub_key_b_x, pub_key_b_y) == pub_key_b);
-        // Manually computed as fields can't use modulo. Importantantly the commitment is within
-        // the subgroup order. Note that choice of hash is flexible for this step.
-        // let r_a = hash::pedersen_commitment([_priv_key_a, msg])[0] % bjj.suborder; // modulus computed manually
-        let r_a = 1414770703199880747815475415092878800081323795074043628810774576767372531818;
-        // let r_b = hash::pedersen_commitment([_priv_key_b, msg])[0] % bjj.suborder; // modulus computed manually
-        let r_b = 571799555715456644614141527517766533395606396271089506978608487688924659618;
-
-        let r8_a = bjj.curve.mul(r_a, bjj.base8);
-        let r8_b = bjj.curve.mul(r_b, bjj.base8);
-        // let h_a: [Field; 6] = hash::poseidon::bn254::hash_5([
-        //     r8_a.x,
-        //     r8_a.y,
-        //     pub_key_a.x,
-        //     pub_key_a.y,
-        //     msg,
-        // ]);
-        // let h_b: [Field; 6] = hash::poseidon::bn254::hash_5([
-        //     r8_b.x,
-        //     r8_b.y,
-        //     pub_key_b.x,
-        //     pub_key_b.y,
-        //     msg,
-        // ]);
-        // let s_a = (r_a + _priv_key_a * h_a) % bjj.suborder; // modulus computed manually
-        let s_a = 30333430637424319196043722294837632681219980330991241982145549329256671548;
-        // let s_b = (r_b + _priv_key_b * h_b) % bjj.suborder; // modulus computed manually
-        let s_b = 1646085314320208098241070054368798527940102577261034947654839408482102287019;
-        // User A verifies their signature over the message
-        assert(eddsa_poseidon_verify(pub_key_a.x, pub_key_a.y, s_a, r8_a.x, r8_a.y, msg));
-        // User B's signature over the message can't be used with user A's pub key
-        assert(!eddsa_poseidon_verify(pub_key_a.x, pub_key_a.y, s_b, r8_b.x, r8_b.y, msg));
-        // User A's signature over the message can't be used with another message
-        assert(!eddsa_poseidon_verify(pub_key_a.x, pub_key_a.y, s_a, r8_a.x, r8_a.y, msg + 1));
-        // Using a different hash should fail
-        assert(!eddsa_verify::<Poseidon2Hasher>(pub_key_a.x, pub_key_a.y, s_a, r8_a.x, r8_a.y, msg));
-    }
-}
diff --git a/test_programs/execution_success/embedded_curve_ops/src/main.nr b/test_programs/execution_success/embedded_curve_ops/src/main.nr
index 5372f73df23..85cf60dc796 100644
--- a/test_programs/execution_success/embedded_curve_ops/src/main.nr
+++ b/test_programs/execution_success/embedded_curve_ops/src/main.nr
@@ -8,7 +8,8 @@ fn main(priv_key: Field, pub_x: pub Field, pub_y: pub Field) {
     assert(res.y == pub_y);
 
     // Test that double function calling embedded_curve_add works as expected
-    let pub_point = std::embedded_curve_ops::EmbeddedCurvePoint { x: pub_x, y: pub_y, is_infinite: false };
+    let pub_point =
+        std::embedded_curve_ops::EmbeddedCurvePoint { x: pub_x, y: pub_y, is_infinite: false };
     let res = pub_point.double();
     let double = g1.add(g1);
 
@@ -19,4 +20,22 @@ fn main(priv_key: Field, pub_x: pub Field, pub_y: pub Field) {
 
     // The results should be double the g1 point because the scalars are 1 and we pass in g1 twice
     assert(double.x == res.x);
+
+    // Tests for #6549
+    let const_scalar1 = std::embedded_curve_ops::EmbeddedCurveScalar { lo: 23, hi: 0 };
+    let const_scalar2 = std::embedded_curve_ops::EmbeddedCurveScalar { lo: 0, hi: 23 };
+    let const_scalar3 = std::embedded_curve_ops::EmbeddedCurveScalar { lo: 13, hi: 4 };
+    let partial_mul = std::embedded_curve_ops::multi_scalar_mul(
+        [g1, double, pub_point, g1, g1],
+        [scalar, const_scalar1, scalar, const_scalar2, const_scalar3],
+    );
+    assert(partial_mul.x == 0x2024c4eebfbc8a20018f8c95c7aab77c6f34f10cf785a6f04e97452d8708fda7);
+    // Check simplification by zero
+    let zero_point = std::embedded_curve_ops::EmbeddedCurvePoint { x: 0, y: 0, is_infinite: true };
+    let const_zero = std::embedded_curve_ops::EmbeddedCurveScalar { lo: 0, hi: 0 };
+    let partial_mul = std::embedded_curve_ops::multi_scalar_mul(
+        [zero_point, double, g1],
+        [scalar, const_zero, scalar],
+    );
+    assert(partial_mul == g1);
 }
diff --git a/test_programs/execution_success/fmtstr_with_global/Nargo.toml b/test_programs/execution_success/fmtstr_with_global/Nargo.toml
new file mode 100644
index 00000000000..889683f7410
--- /dev/null
+++ b/test_programs/execution_success/fmtstr_with_global/Nargo.toml
@@ -0,0 +1,7 @@
+[package]
+name = "fmtstr_with_global"
+type = "bin"
+authors = [""]
+compiler_version = ">=0.32.0"
+
+[dependencies]
diff --git a/test_programs/execution_success/fmtstr_with_global/src/main.nr b/test_programs/execution_success/fmtstr_with_global/src/main.nr
new file mode 100644
index 00000000000..4ca118f856f
--- /dev/null
+++ b/test_programs/execution_success/fmtstr_with_global/src/main.nr
@@ -0,0 +1,5 @@
+global FOO: Field = 1;
+
+fn main() {
+    println(f"foo = {FOO}");
+}
diff --git a/test_programs/execution_success/fold_2_to_17/src/main.nr b/test_programs/execution_success/fold_2_to_17/src/main.nr
index a3a747e4aee..d54dff4617a 100644
--- a/test_programs/execution_success/fold_2_to_17/src/main.nr
+++ b/test_programs/execution_success/fold_2_to_17/src/main.nr
@@ -1,6 +1,6 @@
 use std::hash::poseidon2;
 
-global len = 2450 * 2 - 240; // for just under 2^17 gates
+global len: u32 = 2450 * 2 - 240; // for just under 2^17 gates
 fn main(x: Field) {
     let ped_input = [x; len];
     let mut val = poseidon2::Poseidon2::hash(ped_input, len);
diff --git a/test_programs/execution_success/fold_call_witness_condition/src/main.nr b/test_programs/execution_success/fold_call_witness_condition/src/main.nr
index 5dc75e4a99f..5b9a5db62c5 100644
--- a/test_programs/execution_success/fold_call_witness_condition/src/main.nr
+++ b/test_programs/execution_success/fold_call_witness_condition/src/main.nr
@@ -1,4 +1,4 @@
-global NUM_RESULTS = 2;
+global NUM_RESULTS: u32 = 2;
 fn main(x: Field, y: pub Field, enable: bool) -> pub [Field; NUM_RESULTS] {
     let mut result = [0; NUM_RESULTS];
     for i in 0..NUM_RESULTS {
diff --git a/test_programs/execution_success/fold_complex_outputs/src/main.nr b/test_programs/execution_success/fold_complex_outputs/src/main.nr
index 309d9747598..b433c8b416c 100644
--- a/test_programs/execution_success/fold_complex_outputs/src/main.nr
+++ b/test_programs/execution_success/fold_complex_outputs/src/main.nr
@@ -2,7 +2,7 @@ struct MyStruct {
     x: u32,
     y: u32,
     z: u32,
-    nested_struct: InnerStruct
+    nested_struct: InnerStruct,
 }
 
 struct InnerStruct {
diff --git a/test_programs/execution_success/fold_numeric_generic_poseidon/src/main.nr b/test_programs/execution_success/fold_numeric_generic_poseidon/src/main.nr
index 8eaea086ec0..15b9dd26195 100644
--- a/test_programs/execution_success/fold_numeric_generic_poseidon/src/main.nr
+++ b/test_programs/execution_success/fold_numeric_generic_poseidon/src/main.nr
@@ -1,7 +1,7 @@
-use std::hash::{pedersen_hash_with_separator, poseidon2::Poseidon2};
+use std::hash::poseidon2::Poseidon2;
 
 global NUM_HASHES: u32 = 2;
-global HASH_LENGTH = 10;
+global HASH_LENGTH: u32 = 10;
 
 #[fold]
 pub fn poseidon_hash<let N: u32>(inputs: [Field; N]) -> Field {
@@ -10,7 +10,7 @@ pub fn poseidon_hash<let N: u32>(inputs: [Field; N]) -> Field {
 
 fn main(
     to_hash: [[Field; HASH_LENGTH]; NUM_HASHES],
-    enable: [bool; NUM_HASHES]
+    enable: [bool; NUM_HASHES],
 ) -> pub [Field; NUM_HASHES + 1] {
     let mut result = [0; NUM_HASHES + 1];
     for i in 0..NUM_HASHES {
diff --git a/test_programs/execution_success/global_consts/src/foo.nr b/test_programs/execution_success/global_consts/src/foo.nr
index 50e331493dc..2c39b534259 100644
--- a/test_programs/execution_success/global_consts/src/foo.nr
+++ b/test_programs/execution_success/global_consts/src/foo.nr
@@ -2,7 +2,7 @@ mod bar;
 
 global N: u32 = 5;
 global MAGIC_NUMBER: u32 = 3;
-global TYPE_INFERRED = 42;
+global TYPE_INFERRED: u32 = 42;
 
 pub fn from_foo(x: [Field; bar::N]) {
     for i in 0..bar::N {
diff --git a/test_programs/execution_success/global_consts/src/main.nr b/test_programs/execution_success/global_consts/src/main.nr
index 0b382ff6b8b..2eaab810d6a 100644
--- a/test_programs/execution_success/global_consts/src/main.nr
+++ b/test_programs/execution_success/global_consts/src/main.nr
@@ -10,15 +10,15 @@ global T_LEN: u32 = 2;
 global DERIVED: Field = M as Field + L;
 
 struct Dummy {
-     x: [Field; N],
-     y: [Field; foo::MAGIC_NUMBER]
+    x: [Field; N],
+    y: [Field; foo::MAGIC_NUMBER],
 }
 
 struct Test {
     v: Field,
 }
 global VALS: [Test; 1] = [Test { v: 100 }];
-global NESTED = [VALS, VALS];
+global NESTED: [[Test; 1]; 2] = [VALS, VALS];
 
 unconstrained fn calculate_global_value() -> Field {
     42
@@ -31,7 +31,7 @@ fn main(
     a: [Field; M + N - N],
     b: [Field; 30 + N / 2],
     c: pub [Field; foo::MAGIC_NUMBER],
-    d: [Field; foo::bar::N]
+    d: [Field; foo::bar::N],
 ) {
     let test_struct = Dummy { x: d, y: c };
 
@@ -109,7 +109,7 @@ mod my_submodule {
 }
 
 struct Foo {
-  a: Field,
+    a: Field,
 }
 
 struct Bar {}
@@ -121,6 +121,4 @@ impl Bar {
 }
 
 // Regression for #1440
-global foo = Foo {
-    a: Bar::get_a(),
-};
+global foo: Foo = Foo { a: Bar::get_a() };
diff --git a/test_programs/execution_success/hashmap/src/main.nr b/test_programs/execution_success/hashmap/src/main.nr
index e8bc486e1e2..aab531ea559 100644
--- a/test_programs/execution_success/hashmap/src/main.nr
+++ b/test_programs/execution_success/hashmap/src/main.nr
@@ -10,22 +10,22 @@ type K = Field;
 type V = Field;
 
 // It is more convenient and readable to use structs as input.
-struct Entry{
+struct Entry {
     key: Field,
-    value: Field
+    value: Field,
 }
 
 global HASHMAP_CAP: u32 = 8;
-global HASHMAP_LEN = 6;
+global HASHMAP_LEN: u32 = 6;
 
-global FIELD_CMP = |a: Field, b: Field| a.lt(b);
+global FIELD_CMP: fn(Field, Field) -> bool = |a: Field, b: Field| a.lt(b);
 
-global K_CMP = FIELD_CMP;
-global V_CMP = FIELD_CMP;
-global KV_CMP = |a: (K, V), b: (K, V)| a.0.lt(b.0);
+global K_CMP: fn(Field, Field) -> bool = FIELD_CMP;
+global V_CMP: fn(Field, Field) -> bool = FIELD_CMP;
+global KV_CMP: fn((K, V), (K, V)) -> bool = |a: (K, V), b: (K, V)| a.0.lt(b.0);
 
-global ALLOCATE_HASHMAP = || -> HashMap<K, V, HASHMAP_CAP, BuildHasherDefault<Poseidon2Hasher>> 
-    HashMap::default();
+global ALLOCATE_HASHMAP: fn() -> HashMap<K, V, HASHMAP_CAP, BuildHasherDefault<Poseidon2Hasher>> =
+    || -> HashMap<K, V, HASHMAP_CAP, BuildHasherDefault<Poseidon2Hasher>> HashMap::default();
 
 fn main(input: [Entry; HASHMAP_LEN]) {
     test_sequential(input[0].key, input[0].value);
@@ -54,7 +54,10 @@ fn test_sequential(key: K, value: V) {
     assert(value == got, f"Inserted {value} but got {got} for the same key.");
 
     hashmap.remove(key);
-    assert(hashmap.is_empty(), "HashMap after one insert and corresponding removal should be empty.");
+    assert(
+        hashmap.is_empty(),
+        "HashMap after one insert and corresponding removal should be empty.",
+    );
     let got = hashmap.get(key);
     assert(got.is_none(), "Value has been removed, but is still available (not none).");
 }
@@ -101,10 +104,11 @@ fn test_insert_and_methods(input: [Entry; HASHMAP_LEN]) {
         hashmap.insert(entry.key, entry.value);
     }
 
-    assert(hashmap.len() == HASHMAP_LEN, "hashmap.len() does not match input lenght.");
+    assert(hashmap.len() == HASHMAP_LEN, "hashmap.len() does not match input length.");
 
     for entry in input {
-        assert(hashmap.contains_key(entry.key), f"Not found inserted key {entry.key}.");
+        let entry_key = entry.key;
+        assert(hashmap.contains_key(entry.key), f"Not found inserted key {entry_key}.");
     }
 
     hashmap.clear();
@@ -123,11 +127,14 @@ fn test_retain() {
     let (key, value) = (11, 5);
     hashmap.insert(key, value);
 
-    let predicate = |key: K, value: V| -> bool {key * value == 55};
+    let predicate = |key: K, value: V| -> bool { key * value == 55 };
     hashmap.retain(predicate);
 
     assert(hashmap.len() == 2, "HashMap should have retained 2 elements.");
-    assert(hashmap.get(2).is_none(), "Pair should have been removed, since it does not match predicate.");
+    assert(
+        hashmap.get(2).is_none(),
+        "Pair should have been removed, since it does not match predicate.",
+    );
 }
 
 // Equality trait check.
@@ -172,10 +179,10 @@ fn test_mut_iterators() {
     hashmap.insert(5, 7);
     hashmap.insert(11, 13);
 
-    let f = |k: K| -> K{ k * 3};
+    let f = |k: K| -> K { k * 3 };
     hashmap.iter_keys_mut(f);
 
-    let f = |v: V| -> V{ v * 5};
+    let f = |v: V| -> V { v * 5 };
     hashmap.iter_values_mut(f);
 
     let keys: [K; 3] = cut(hashmap.keys()).sort_via(K_CMP);
@@ -184,7 +191,7 @@ fn test_mut_iterators() {
     assert(keys == [6, 15, 33], f"Got incorrect iteration of keys: {keys}");
     assert(values == [15, 35, 65], "Got incorrect iteration of values.");
 
-    let f = |k: K, v: V| -> (K, V){(k * 2, v * 2)};
+    let f = |k: K, v: V| -> (K, V) { (k * 2, v * 2) };
     hashmap.iter_mut(f);
 
     let entries: [(K, V); 3] = cut(hashmap.entries()).sort_via(KV_CMP);
@@ -202,19 +209,17 @@ fn doc_tests() {
     let hashmap: HashMap<u8, u32, 10, BuildHasherDefault<Poseidon2Hasher>> = HashMap::default();
     assert(hashmap.is_empty());
     // docs:end:default_example
-
     // docs:start:with_hasher_example
     let my_hasher: BuildHasherDefault<Poseidon2Hasher> = Default::default();
-    let hashmap: HashMap<u8, u32, 10, BuildHasherDefault<Poseidon2Hasher>> = HashMap::with_hasher(my_hasher);
+    let hashmap: HashMap<u8, u32, 10, BuildHasherDefault<Poseidon2Hasher>> =
+        HashMap::with_hasher(my_hasher);
     assert(hashmap.is_empty());
     // docs:end:with_hasher_example
-
     // docs:start:insert_example
     let mut map: HashMap<Field, Field, 5, BuildHasherDefault<Poseidon2Hasher>> = HashMap::default();
     map.insert(12, 42);
     assert(map.len() == 1);
     // docs:end:insert_example
-
     get_example(map);
 
     // docs:start:remove_example
@@ -225,7 +230,6 @@ fn doc_tests() {
     map.remove(12);
     assert(map.is_empty());
     // docs:end:remove_example
-
     // docs:start:is_empty_example
     assert(map.is_empty());
 
@@ -235,7 +239,6 @@ fn doc_tests() {
     map.remove(1);
     assert(map.is_empty());
     // docs:end:is_empty_example
-
     // docs:start:len_example
     // This is equivalent to checking map.is_empty()
     assert(map.len() == 0);
@@ -252,19 +255,17 @@ fn doc_tests() {
     map.remove(1);
     assert(map.len() == 2);
     // docs:end:len_example
-
     // docs:start:capacity_example
-    let empty_map: HashMap<Field, Field, 42, BuildHasherDefault<Poseidon2Hasher>> = HashMap::default();
+    let empty_map: HashMap<Field, Field, 42, BuildHasherDefault<Poseidon2Hasher>> =
+        HashMap::default();
     assert(empty_map.len() == 0);
     assert(empty_map.capacity() == 42);
     // docs:end:capacity_example
-
     // docs:start:clear_example
     assert(!map.is_empty());
     map.clear();
     assert(map.is_empty());
     // docs:end:clear_example
-
     // docs:start:contains_key_example
     if map.contains_key(7) {
         let value = map.get(7);
@@ -273,14 +274,12 @@ fn doc_tests() {
         println("No value for key 7!");
     }
     // docs:end:contains_key_example
-
     entries_examples(map);
     iter_examples(map);
 
     // docs:start:retain_example
     map.retain(|k, v| (k != 0) & (v != 0));
     // docs:end:retain_example
-
     // docs:start:eq_example
     let mut map1: HashMap<Field, u64, 4, BuildHasherDefault<Poseidon2Hasher>> = HashMap::default();
     let mut map2: HashMap<Field, u64, 4, BuildHasherDefault<Poseidon2Hasher>> = HashMap::default();
@@ -318,7 +317,6 @@ fn entries_examples(map: HashMap<Field, Field, 5, BuildHasherDefault<Poseidon2Ha
         }
     }
     // docs:end:entries_example
-
     // docs:start:keys_example
     let keys = map.keys();
 
@@ -330,7 +328,6 @@ fn entries_examples(map: HashMap<Field, Field, 5, BuildHasherDefault<Poseidon2Ha
         }
     }
     // docs:end:keys_example
-
     // docs:start:values_example
     let values = map.values();
 
@@ -348,12 +345,10 @@ fn iter_examples(mut map: HashMap<Field, Field, 5, BuildHasherDefault<Poseidon2H
     // Add 1 to each key in the map, and double the value associated with that key.
     map.iter_mut(|k, v| (k + 1, v * 2));
     // docs:end:iter_mut_example
-
     // docs:start:iter_keys_mut_example
     // Double each key, leaving the value associated with that key untouched
     map.iter_keys_mut(|k| k * 2);
     // docs:end:iter_keys_mut_example
-
     // docs:start:iter_values_mut_example
     // Halve each value
     map.iter_values_mut(|v| v / 2);
diff --git a/test_programs/execution_success/higher_order_functions/src/main.nr b/test_programs/execution_success/higher_order_functions/src/main.nr
index 0a498e74ad1..1f9598f8591 100644
--- a/test_programs/execution_success/higher_order_functions/src/main.nr
+++ b/test_programs/execution_success/higher_order_functions/src/main.nr
@@ -5,12 +5,7 @@ fn main(w: Field) -> pub Field {
     assert(twice(|x| x * 2, 5) == 20);
     assert((|x, y| x + y + 1)(2, 3) == 6);
     // nested lambdas
-    assert(
-        (|a, b| {
-        a + (|c| c + 2)(b)
-    })(0, 1)
-        == 3
-    );
+    assert((|a, b| a + (|c| c + 2)(b))(0, 1) == 3);
     // Closures:
     let a = 42;
     let g = || a;
@@ -25,7 +20,7 @@ fn main(w: Field) -> pub Field {
     x = x + 1;
     assert((|y| y + z)(1) == 4);
     // When you capture mutable variables,
-    // again, the captured variable doesn't change: 
+    // again, the captured variable doesn't change:
     let closure_capturing_mutable = (|y| y + x);
     assert(closure_capturing_mutable(1) == 5);
     x += 1;
diff --git a/test_programs/execution_success/brillig_loop/Nargo.toml b/test_programs/execution_success/hint_black_box/Nargo.toml
similarity index 69%
rename from test_programs/execution_success/brillig_loop/Nargo.toml
rename to test_programs/execution_success/hint_black_box/Nargo.toml
index 1212397c4db..8a49ec25494 100644
--- a/test_programs/execution_success/brillig_loop/Nargo.toml
+++ b/test_programs/execution_success/hint_black_box/Nargo.toml
@@ -1,5 +1,5 @@
 [package]
-name = "brillig_loop"
+name = "hint_black_box"
 type = "bin"
 authors = [""]
 
diff --git a/test_programs/execution_success/hint_black_box/Prover.toml b/test_programs/execution_success/hint_black_box/Prover.toml
new file mode 100644
index 00000000000..67dda9c2b68
--- /dev/null
+++ b/test_programs/execution_success/hint_black_box/Prover.toml
@@ -0,0 +1,3 @@
+# 5 * a = b
+a = 10
+b = 50
diff --git a/test_programs/execution_success/hint_black_box/src/main.nr b/test_programs/execution_success/hint_black_box/src/main.nr
new file mode 100644
index 00000000000..1109c54301f
--- /dev/null
+++ b/test_programs/execution_success/hint_black_box/src/main.nr
@@ -0,0 +1,90 @@
+use std::hint::black_box;
+
+fn main(a: u32, b: u32) {
+    // This version unrolls into a number of additions
+    assert_eq(loop(5, a), b);
+    // This version simplifies into a single `constraint 50 == b`
+    assert_eq(loop(5, 10), b);
+    // This version should not simplify down to a single constraint,
+    // it should treat 10 as opaque:
+    assert_eq(loop(5, black_box(10)), b);
+
+    // Check array handling.
+    let arr = [a, a, a, a, a];
+
+    assert_eq(array_sum(arr), b);
+    assert_eq(array_sum(black_box(arr)), b);
+
+    assert_eq(slice_sum(arr.as_slice()), b);
+    assert_eq(slice_sum(black_box(arr).as_slice()), b);
+
+    // This doesn't work because by calling `black_box` on a slice the compiler
+    // loses track of the length, and then cannot unroll the loop for ACIR.
+    //assert_eq(slice_sum(black_box(arr.as_slice())), b);
+
+    // But we can pass a blackboxed slice to Brillig.
+    let s = unsafe { brillig_slice_sum(black_box(arr.as_slice())) };
+    assert_eq(s, b);
+
+    let mut d = b;
+    // This gets completely eliminated:
+    let mut c = 0;
+    set_ref(&mut c, &mut d);
+    assert_eq(c, b);
+
+    // This way the constraint is preserved:
+    let mut c = 0;
+    set_ref(&mut c, &mut black_box(d));
+    assert_eq(c, b);
+
+    // A reference over the output of black box is not the original variable:
+    let mut c = 0;
+    set_ref(&mut black_box(c), &mut d);
+    assert_eq(c, 0);
+
+    // This would cause a causes a crash during SSA passes unless it's a Brillig runtime:
+    //  > Could not resolve some references to the array. All references must be resolved at compile time
+    // The SSA cannot have Allocate by the time we start generating ACIR, but `black_box` prevents them
+    // from being optimised away during SSA passes.
+    // If we use `--force-brillig` then the it doesn't crash but the assertion fails because `mem2reg`
+    // eliminates the storing to the reference.
+    //let mut c = 0;
+    //set_ref(black_box(&mut c), black_box(&mut d));
+    //assert_eq(c, b);
+}
+
+fn loop(n: u32, k: u32) -> u32 {
+    let mut sum = 0;
+    for _ in 0..n {
+        sum = sum + k;
+    }
+    sum
+}
+
+fn array_sum<let N: u32>(xs: [u32; N]) -> u32 {
+    let mut sum = 0;
+    for i in 0..N {
+        sum = sum + xs[i];
+    }
+    sum
+}
+
+fn slice_sum(xs: [u32]) -> u32 {
+    let mut sum = 0;
+    for x in xs {
+        sum = sum + x;
+    }
+    sum
+}
+
+unconstrained fn brillig_slice_sum(xs: [u32]) -> u32 {
+    let mut sum = 0;
+    for x in xs {
+        sum = sum + x;
+    }
+    sum
+}
+
+fn set_ref(c: &mut u32, b: &mut u32) {
+    *c = *b;
+}
diff --git a/test_programs/execution_success/inline_decompose_hint_brillig_call/Nargo.toml b/test_programs/execution_success/inline_decompose_hint_brillig_call/Nargo.toml
new file mode 100644
index 00000000000..ecac2dfb197
--- /dev/null
+++ b/test_programs/execution_success/inline_decompose_hint_brillig_call/Nargo.toml
@@ -0,0 +1,7 @@
+[package]
+name = "inline_decompose_hint_brillig_call"
+version = "0.1.0"
+type = "bin"
+authors = [""]
+
+[dependencies]
diff --git a/test_programs/execution_success/inline_decompose_hint_brillig_call/src/main.nr b/test_programs/execution_success/inline_decompose_hint_brillig_call/src/main.nr
new file mode 100644
index 00000000000..e500f0f976d
--- /dev/null
+++ b/test_programs/execution_success/inline_decompose_hint_brillig_call/src/main.nr
@@ -0,0 +1,15 @@
+use std::embedded_curve_ops::{EmbeddedCurvePoint, EmbeddedCurveScalar, fixed_base_scalar_mul};
+
+fn main() -> pub Field {
+    let pre_address = 0x23d95e303879a5d0bbef78ecbc335e559da37431f6dcd11da54ed375c2846813;
+    let (a, b) = std::field::bn254::decompose(pre_address);
+    let curve = EmbeddedCurveScalar { lo: a, hi: b };
+    let key = fixed_base_scalar_mul(curve);
+    let point = EmbeddedCurvePoint {
+        x: 0x111223493147f6785514b1c195bb37a2589f22a6596d30bb2bb145fdc9ca8f1e,
+        y: 0x273bbffd678edce8fe30e0deafc4f66d58357c06fd4a820285294b9746c3be95,
+        is_infinite: false,
+    };
+    let address_point = key.add(point);
+    address_point.x
+}
diff --git a/test_programs/execution_success/inline_never_basic/Prover.toml b/test_programs/execution_success/inline_never_basic/Prover.toml
index f28f2f8cc48..fbe96700abe 100644
--- a/test_programs/execution_success/inline_never_basic/Prover.toml
+++ b/test_programs/execution_success/inline_never_basic/Prover.toml
@@ -1,2 +1,2 @@
 x = "5"
-y = "10"
+y = "10"
\ No newline at end of file
diff --git a/test_programs/execution_success/inline_never_basic/src/main.nr b/test_programs/execution_success/inline_never_basic/src/main.nr
index 1922aaedb6c..505a1641c76 100644
--- a/test_programs/execution_success/inline_never_basic/src/main.nr
+++ b/test_programs/execution_success/inline_never_basic/src/main.nr
@@ -2,7 +2,7 @@ fn main(x: Field, y: pub Field) {
     basic_check(x, y);
 }
 
-#[inline(never)]
+#['inline(never)]
 fn basic_check(x: Field, y: Field) {
     assert(x != y);
 }
diff --git a/test_programs/execution_success/keccak256/src/main.nr b/test_programs/execution_success/keccak256/src/main.nr
index ff18cae0c9c..1e13fa028b7 100644
--- a/test_programs/execution_success/keccak256/src/main.nr
+++ b/test_programs/execution_success/keccak256/src/main.nr
@@ -1,5 +1,4 @@
 // docs:start:keccak256
-
 fn main(x: Field, result: [u8; 32]) {
     // We use the `as` keyword here to denote the fact that we want to take just the first byte from the x Field
     // The padding is taken care of by the program
diff --git a/test_programs/execution_success/schnorr/Nargo.toml b/test_programs/execution_success/loop/Nargo.toml
similarity index 76%
rename from test_programs/execution_success/schnorr/Nargo.toml
rename to test_programs/execution_success/loop/Nargo.toml
index aa24a2f3caf..66c72338363 100644
--- a/test_programs/execution_success/schnorr/Nargo.toml
+++ b/test_programs/execution_success/loop/Nargo.toml
@@ -1,5 +1,5 @@
 [package]
-name = "schnorr"
+name = "loop"
 type = "bin"
 authors = [""]
 
diff --git a/test_programs/execution_success/loop/Prover.toml b/test_programs/execution_success/loop/Prover.toml
new file mode 100644
index 00000000000..0f44bf96f44
--- /dev/null
+++ b/test_programs/execution_success/loop/Prover.toml
@@ -0,0 +1 @@
+six_as_u32 = "6"
diff --git a/test_programs/execution_success/loop/src/main.nr b/test_programs/execution_success/loop/src/main.nr
new file mode 100644
index 00000000000..b3be4c4c3ff
--- /dev/null
+++ b/test_programs/execution_success/loop/src/main.nr
@@ -0,0 +1,32 @@
+// Tests a very simple program.
+//
+// The features being tested is basic looping.
+fn main(six_as_u32: u32) {
+    assert_eq(loop(4), six_as_u32);
+    assert_eq(loop_incl(3), six_as_u32);
+    assert(plain_loop() == six_as_u32);
+}
+
+fn loop(x: u32) -> u32 {
+    let mut sum = 0;
+    for i in 0..x {
+        sum = sum + i;
+    }
+    sum
+}
+
+fn loop_incl(x: u32) -> u32 {
+    let mut sum = 0;
+    for i in 0..=x {
+        sum = sum + i;
+    }
+    sum
+}
+
+fn plain_loop() -> u32 {
+    let mut sum = 0;
+    for i in 0..4 {
+        sum = sum + i;
+    }
+    sum
+}
diff --git a/test_programs/execution_success/loop_invariant_regression/Nargo.toml b/test_programs/execution_success/loop_invariant_regression/Nargo.toml
new file mode 100644
index 00000000000..9590789f52e
--- /dev/null
+++ b/test_programs/execution_success/loop_invariant_regression/Nargo.toml
@@ -0,0 +1,7 @@
+[package]
+name = "loop_invariant_regression"
+type = "bin"
+authors = [""]
+compiler_version = ">=0.38.0"
+
+[dependencies]
\ No newline at end of file
diff --git a/test_programs/execution_success/assert_statement_recursive/Prover.toml b/test_programs/execution_success/loop_invariant_regression/Prover.toml
similarity index 50%
rename from test_programs/execution_success/assert_statement_recursive/Prover.toml
rename to test_programs/execution_success/loop_invariant_regression/Prover.toml
index 5d1dc99124f..18680c805a7 100644
--- a/test_programs/execution_success/assert_statement_recursive/Prover.toml
+++ b/test_programs/execution_success/loop_invariant_regression/Prover.toml
@@ -1,2 +1,2 @@
-x = "3"
+x = "2"
 y = "3"
diff --git a/test_programs/execution_success/loop_invariant_regression/src/main.nr b/test_programs/execution_success/loop_invariant_regression/src/main.nr
new file mode 100644
index 00000000000..c28ce063116
--- /dev/null
+++ b/test_programs/execution_success/loop_invariant_regression/src/main.nr
@@ -0,0 +1,26 @@
+// Tests a simple loop where we expect loop invariant instructions
+// to be hoisted to the loop's pre-header block.
+fn main(x: u32, y: u32) {
+    loop(4, x, y);
+    array_read_loop(4, x);
+}
+
+fn loop(upper_bound: u32, x: u32, y: u32) {
+    for _ in 0..upper_bound {
+        let mut z = x * y;
+        z = z * x;
+        assert_eq(z, 12);
+    }
+}
+
+fn array_read_loop(upper_bound: u32, x: u32) {
+    let arr = [2; 5];
+    for i in 0..upper_bound {
+        for j in 0..upper_bound {
+            for _ in 0..upper_bound {
+                assert_eq(arr[i], x);
+                assert_eq(arr[j], x);
+            }
+        }
+    }
+}
diff --git a/test_programs/execution_success/merkle_insert/Prover.toml b/test_programs/execution_success/merkle_insert/Prover.toml
index 0656908c063..3248d75a9b9 100644
--- a/test_programs/execution_success/merkle_insert/Prover.toml
+++ b/test_programs/execution_success/merkle_insert/Prover.toml
@@ -8,4 +8,3 @@ old_hash_path = [
 new_root = "0x25e2a8ee5b85e5b546ae27832b9b53f5fae5b371e3e7f8cddda839f41669fc68"
 leaf = "0x23fe6c8f2426b793f0f156f57efbecbea52e951af761634a85e80cc1a9fb5003"
 index = "0"
-mimc_input = [12, 45, 78, 41]
diff --git a/test_programs/execution_success/merkle_insert/src/main.nr b/test_programs/execution_success/merkle_insert/src/main.nr
index a08088e847b..25a455c90b8 100644
--- a/test_programs/execution_success/merkle_insert/src/main.nr
+++ b/test_programs/execution_success/merkle_insert/src/main.nr
@@ -1,5 +1,3 @@
-use std::hash::mimc;
-
 fn main(
     old_root: Field,
     old_leaf: Field,
@@ -7,15 +5,9 @@ fn main(
     new_root: pub Field,
     leaf: Field,
     index: Field,
-    mimc_input: [Field; 4]
 ) {
     assert(old_root == std::merkle::compute_merkle_root(old_leaf, index, old_hash_path));
 
     let calculated_root = std::merkle::compute_merkle_root(leaf, index, old_hash_path);
     assert(new_root == calculated_root);
-
-    let h = mimc::mimc_bn254(mimc_input);
-    // Regression test for PR #891
-    std::println(h);
-    assert(h == 18226366069841799622585958305961373004333097209608110160936134895615261821931);
 }
diff --git a/test_programs/execution_success/modulus/src/main.nr b/test_programs/execution_success/modulus/src/main.nr
index 1627cc0dba2..36ec722a049 100644
--- a/test_programs/execution_success/modulus/src/main.nr
+++ b/test_programs/execution_success/modulus/src/main.nr
@@ -5,7 +5,7 @@ fn main(bn254_modulus_be_bytes: [u8; 32], bn254_modulus_be_bits: [u1; 254]) {
 
     assert_reverse(
         std::field::modulus_be_bytes(),
-        std::field::modulus_le_bytes()
+        std::field::modulus_le_bytes(),
     );
 
     let modulus_be_byte_array = std::field::modulus_be_bytes();
diff --git a/test_programs/execution_success/brillig_ecdsa_secp256r1/Nargo.toml b/test_programs/execution_success/negated_jmpif_condition/Nargo.toml
similarity index 62%
rename from test_programs/execution_success/brillig_ecdsa_secp256r1/Nargo.toml
rename to test_programs/execution_success/negated_jmpif_condition/Nargo.toml
index 0a71e782104..c83e2c1c1fd 100644
--- a/test_programs/execution_success/brillig_ecdsa_secp256r1/Nargo.toml
+++ b/test_programs/execution_success/negated_jmpif_condition/Nargo.toml
@@ -1,5 +1,5 @@
 [package]
-name = "brillig_ecdsa_secp256r1"
+name = "negated_jmpif_condition"
 type = "bin"
 authors = [""]
 
diff --git a/test_programs/execution_success/brillig_references/Prover.toml b/test_programs/execution_success/negated_jmpif_condition/Prover.toml
similarity index 100%
rename from test_programs/execution_success/brillig_references/Prover.toml
rename to test_programs/execution_success/negated_jmpif_condition/Prover.toml
diff --git a/test_programs/execution_success/negated_jmpif_condition/src/main.nr b/test_programs/execution_success/negated_jmpif_condition/src/main.nr
new file mode 100644
index 00000000000..06de2b41820
--- /dev/null
+++ b/test_programs/execution_success/negated_jmpif_condition/src/main.nr
@@ -0,0 +1,9 @@
+fn main(mut x: Field) {
+    let mut q = 0;
+
+    if x != 10 {
+        q = 2;
+    }
+
+    assert(q == 2);
+}
diff --git a/test_programs/execution_success/nested_arrays_from_brillig/src/main.nr b/test_programs/execution_success/nested_arrays_from_brillig/src/main.nr
index 9664b4d1ce6..f8070aa3ef4 100644
--- a/test_programs/execution_success/nested_arrays_from_brillig/src/main.nr
+++ b/test_programs/execution_success/nested_arrays_from_brillig/src/main.nr
@@ -20,9 +20,7 @@ unconstrained fn create_inside_brillig(values: [Field; 6]) -> [MyNote; 2] {
 }
 
 fn main(values: [Field; 6]) {
-    let notes = unsafe {
-        create_inside_brillig(values)
-    };
+    let notes = unsafe { create_inside_brillig(values) };
     assert(access_nested(notes) == (2 + 4 + 3 + 1));
 }
 
diff --git a/test_programs/execution_success/no_predicates_numeric_generic_poseidon/src/main.nr b/test_programs/execution_success/no_predicates_numeric_generic_poseidon/src/main.nr
index d6b463dbe30..82a868f3ffb 100644
--- a/test_programs/execution_success/no_predicates_numeric_generic_poseidon/src/main.nr
+++ b/test_programs/execution_success/no_predicates_numeric_generic_poseidon/src/main.nr
@@ -1,7 +1,7 @@
 use std::hash::poseidon2::Poseidon2;
 
 global NUM_HASHES: u32 = 2;
-global HASH_LENGTH = 10;
+global HASH_LENGTH: u32 = 10;
 
 #[no_predicates]
 pub fn poseidon_hash<let N: u32>(inputs: [Field; N]) -> Field {
@@ -10,7 +10,7 @@ pub fn poseidon_hash<let N: u32>(inputs: [Field; N]) -> Field {
 
 fn main(
     to_hash: [[Field; HASH_LENGTH]; NUM_HASHES],
-    enable: [bool; NUM_HASHES]
+    enable: [bool; NUM_HASHES],
 ) -> pub [Field; NUM_HASHES + 1] {
     let mut result = [0; NUM_HASHES + 1];
     for i in 0..NUM_HASHES {
diff --git a/test_programs/execution_success/pedersen_commitment/src/main.nr b/test_programs/execution_success/pedersen_commitment/src/main.nr
index 81c605a64dd..c2225edcdf1 100644
--- a/test_programs/execution_success/pedersen_commitment/src/main.nr
+++ b/test_programs/execution_success/pedersen_commitment/src/main.nr
@@ -1,5 +1,4 @@
 // docs:start:pedersen-commitment
-
 fn main(x: Field, y: Field, expected_commitment: std::embedded_curve_ops::EmbeddedCurvePoint) {
     let commitment = std::hash::pedersen_commitment([x, y]);
     assert_eq(commitment.x, expected_commitment.x);
diff --git a/test_programs/execution_success/pedersen_hash/src/main.nr b/test_programs/execution_success/pedersen_hash/src/main.nr
index f8ec56a9d98..de981d44bca 100644
--- a/test_programs/execution_success/pedersen_hash/src/main.nr
+++ b/test_programs/execution_success/pedersen_hash/src/main.nr
@@ -1,5 +1,4 @@
 // docs:start:pedersen-hash
-
 fn main(x: Field, y: Field, expected_hash: Field) {
     let hash = std::hash::pedersen_hash([x, y]);
     assert_eq(hash, expected_hash);
diff --git a/test_programs/execution_success/ram_blowup_regression/Nargo.toml b/test_programs/execution_success/ram_blowup_regression/Nargo.toml
new file mode 100644
index 00000000000..0ccbf63aa8d
--- /dev/null
+++ b/test_programs/execution_success/ram_blowup_regression/Nargo.toml
@@ -0,0 +1,7 @@
+[package]
+name = "ram_blowup_regression"
+type = "bin"
+authors = [""]
+compiler_version = ">=0.35.0"
+
+[dependencies]
\ No newline at end of file
diff --git a/test_programs/execution_success/ram_blowup_regression/Prover.toml b/test_programs/execution_success/ram_blowup_regression/Prover.toml
new file mode 100644
index 00000000000..35842ce2431
--- /dev/null
+++ b/test_programs/execution_success/ram_blowup_regression/Prover.toml
@@ -0,0 +1 @@
+tx_effects_hash_input = [1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1]
\ No newline at end of file
diff --git a/test_programs/execution_success/ram_blowup_regression/src/main.nr b/test_programs/execution_success/ram_blowup_regression/src/main.nr
new file mode 100644
index 00000000000..6deb54dd21d
--- /dev/null
+++ b/test_programs/execution_success/ram_blowup_regression/src/main.nr
@@ -0,0 +1,41 @@
+global TX_EFFECTS_HASH_INPUT_FIELDS: u32 = 256;
+
+// Convert a 32 byte array to a field element by truncating the final byte
+pub fn field_from_bytes_32_trunc(bytes32: [u8; 32]) -> Field {
+    // Convert it to a field element
+    let mut v = 1;
+    let mut high = 0 as Field;
+    let mut low = 0 as Field;
+
+    for i in 0..15 {
+        // covers bytes 16..30 (31 is truncated and ignored)
+        low = low + (bytes32[15 + 15 - i] as Field) * v;
+        v = v * 256;
+        // covers bytes 0..14
+        high = high + (bytes32[14 - i] as Field) * v;
+    }
+    // covers byte 15
+    low = low + (bytes32[15] as Field) * v;
+
+    low + high * v
+}
+
+pub fn sha256_to_field<let N: u32>(bytes_to_hash: [u8; N]) -> Field {
+    let sha256_hashed = std::hash::sha256(bytes_to_hash);
+    let hash_in_a_field = field_from_bytes_32_trunc(sha256_hashed);
+
+    hash_in_a_field
+}
+
+fn main(tx_effects_hash_input: [Field; TX_EFFECTS_HASH_INPUT_FIELDS]) -> pub Field {
+    let mut hash_input_flattened = [0; TX_EFFECTS_HASH_INPUT_FIELDS * 32];
+    for offset in 0..TX_EFFECTS_HASH_INPUT_FIELDS {
+        let input_as_bytes: [u8; 32] = tx_effects_hash_input[offset].to_be_bytes();
+        for byte_index in 0..32 {
+            hash_input_flattened[offset * 32 + byte_index] = input_as_bytes[byte_index];
+        }
+    }
+
+    let sha_digest = sha256_to_field(hash_input_flattened);
+    sha_digest
+}
diff --git a/test_programs/execution_success/reference_counts/Nargo.toml b/test_programs/execution_success/reference_counts/Nargo.toml
new file mode 100644
index 00000000000..ae787e0ccb9
--- /dev/null
+++ b/test_programs/execution_success/reference_counts/Nargo.toml
@@ -0,0 +1,7 @@
+[package]
+name = "reference_counts"
+type = "bin"
+authors = [""]
+compiler_version = ">=0.35.0"
+
+[dependencies]
diff --git a/test_programs/execution_success/reference_counts/Prover.toml b/test_programs/execution_success/reference_counts/Prover.toml
new file mode 100644
index 00000000000..c01dd9462d8
--- /dev/null
+++ b/test_programs/execution_success/reference_counts/Prover.toml
@@ -0,0 +1,2 @@
+x = 5
+b = true
diff --git a/test_programs/execution_success/reference_counts/src/main.nr b/test_programs/execution_success/reference_counts/src/main.nr
new file mode 100644
index 00000000000..68b9f2407b9
--- /dev/null
+++ b/test_programs/execution_success/reference_counts/src/main.nr
@@ -0,0 +1,78 @@
+use std::mem::array_refcount;
+
+fn main() {
+    let mut array = [0, 1, 2];
+    assert_refcount(array, 2);
+
+    borrow(array, array_refcount(array));
+    borrow_mut(&mut array, array_refcount(array));
+    copy_mut(array, array_refcount(array));
+
+    borrow_mut_two(&mut array, &mut array, array_refcount(array));
+
+    let mut u32_array = [0, 1, 2];
+    let rc1 = array_refcount(array);
+    let rc2 = array_refcount(u32_array);
+    borrow_mut_two_separate(&mut array, &mut u32_array, rc1, rc2);
+}
+
+fn borrow(array: [Field; 3], rc_before_call: u32) {
+    assert_refcount(array, rc_before_call);
+    println(array[0]);
+}
+
+fn borrow_mut(array: &mut [Field; 3], rc_before_call: u32) {
+    // Optimization: inc_rc isn't needed since there is only one array (`array`)
+    // of the same type that `array` can be modified through
+    assert_refcount(*array, rc_before_call + 0);
+    array[0] = 3;
+    println(array[0]);
+}
+
+fn copy_mut(mut array: [Field; 3], rc_before_call: u32) {
+    assert_refcount(array, rc_before_call + 1);
+    array[0] = 4;
+    println(array[0]);
+}
+
+/// Borrow the same array mutably through both parameters, inc_rc is necessary here, although
+/// only one is needed to bring the rc from 1 to 2.
+fn borrow_mut_two(array1: &mut [Field; 3], array2: &mut [Field; 3], rc_before_call: u32) {
+    assert_refcount(*array1, rc_before_call + 1);
+    assert_refcount(*array2, rc_before_call + 1);
+    array1[0] = 5;
+    array2[0] = 6;
+    println(array1[0]); // array1 & 2 alias, so this should also print 6
+    println(array2[0]);
+}
+
+/// Borrow a different array: we should be able to reason that these types cannot be mutably
+/// aliased since they're different types so we don't need any inc_rc instructions.
+fn borrow_mut_two_separate(
+    array1: &mut [Field; 3],
+    array2: &mut [u32; 3],
+    rc_before_call1: u32,
+    rc_before_call2: u32,
+) {
+    assert_refcount(*array1, rc_before_call1 + 0);
+    assert_refcount(*array2, rc_before_call2 + 0);
+    array1[0] = 7;
+    array2[0] = 8;
+    println(array1[0]);
+    println(array2[0]);
+}
+
+fn assert_refcount<T>(array: [T; 3], expected: u32) {
+    let count = array_refcount(array);
+
+    // All refcounts are zero when running this as a constrained program
+    if std::runtime::is_unconstrained() {
+        if count != expected {
+            // Brillig doesn't print the actual & expected arguments on assertion failure
+            println(f"actual = {count}, expected = {expected}");
+        }
+        assert_eq(count, expected);
+    } else {
+        assert_eq(count, 0);
+    }
+}
diff --git a/test_programs/execution_success/reference_only_used_as_alias/src/main.nr b/test_programs/execution_success/reference_only_used_as_alias/src/main.nr
index c04d68d1748..8b5b804cf94 100644
--- a/test_programs/execution_success/reference_only_used_as_alias/src/main.nr
+++ b/test_programs/execution_success/reference_only_used_as_alias/src/main.nr
@@ -13,11 +13,6 @@ impl EventInterface for ExampleEvent0 {
     }
 }
 
-struct ExampleEvent1 {
-    value2: u8,
-    value3: u8,
-}
-
 struct Context {
     a: u32,
     b: [u32; 3],
@@ -38,7 +33,10 @@ impl Context {
     }
 }
 
-fn compute<Event>(_event: Event) -> ([u8; 5], Field) where Event: EventInterface {
+fn compute<Event>(_event: Event) -> ([u8; 5], Field)
+where
+    Event: EventInterface,
+{
     ([0 as u8; 5], 0)
 }
 
@@ -46,17 +44,23 @@ fn emit_with_keys<Event, let OB: u32>(
     context: &mut Context,
     randomness: Field,
     event: Event,
-    inner_compute: fn(Event) -> ([u8; OB], Field)
-) where Event: EventInterface {
+    inner_compute: fn(Event) -> ([u8; OB], Field),
+)
+where
+    Event: EventInterface,
+{
     let (log, log_hash) = inner_compute(event);
     context.emit_raw_log(randomness, log, log_hash);
 }
 
-pub fn encode_event_with_randomness<Event>(
+fn encode_event_with_randomness<Event>(
     context: &mut Context,
-    randomness: Field
-) -> fn[(&mut Context, Field)](Event) -> () where Event: EventInterface {
-    | e: Event | {
+    randomness: Field,
+) -> fn[(&mut Context, Field)](Event) -> ()
+where
+    Event: EventInterface,
+{
+    |e: Event| {
         unsafe {
             func(context.a);
         }
diff --git a/test_programs/execution_success/references/src/main.nr b/test_programs/execution_success/references/src/main.nr
index 1a9be5f82b9..65d70dc4a5f 100644
--- a/test_programs/execution_success/references/src/main.nr
+++ b/test_programs/execution_success/references/src/main.nr
@@ -1,7 +1,6 @@
 fn main(mut x: Field) {
     add1(&mut x);
     assert(x == 3);
-
     let mut s = S { y: x };
     s.add2();
     assert(s.y == 5);
@@ -21,18 +20,16 @@ fn main(mut x: Field) {
     let mut c = C { foo: 0, bar: &mut C2 { array: &mut [1, 2] } };
     *c.bar.array = [3, 4];
     assert(*c.bar.array == [3, 4]);
-
     regression_1887();
     regression_2054();
     regression_2030();
     regression_2255();
-
+    regression_6443();
     assert(x == 3);
     regression_2218_if_inner_if(x, 10);
     regression_2218_if_inner_else(20, x);
     regression_2218_else(x, 3);
     regression_2218_loop(x, 10);
-
     regression_2560(s_ref);
 }
 
@@ -40,9 +37,13 @@ fn add1(x: &mut Field) {
     *x += 1;
 }
 
-struct S { y: Field }
+struct S {
+    y: Field,
+}
 
-struct Nested { y: &mut &mut Field }
+struct Nested {
+    y: &mut &mut Field,
+}
 
 struct C {
     foo: Field,
@@ -50,7 +51,7 @@ struct C {
 }
 
 struct C2 {
-    array: &mut [Field; 2]
+    array: &mut [Field; 2],
 }
 
 impl S {
@@ -74,8 +75,12 @@ fn regression_1887() {
     assert(foo.bar.x == 32);
 }
 
-struct Foo { bar: Bar }
-struct Bar { x: Field }
+struct Foo {
+    bar: Bar,
+}
+struct Bar {
+    x: Field,
+}
 
 impl Bar {
     fn mutate(&mut self) {
@@ -98,6 +103,7 @@ fn regression_2030() {
     let _ = *array[0];
     *array[0] = 1;
 }
+
 // The `mut x: &mut ...` caught a bug handling lvalues where a double-dereference would occur internally
 // in one step rather than being tracked by two separate steps. This lead to assigning the 1 value to the
 // incorrect outer `mut` reference rather than the correct `&mut` reference.
@@ -111,6 +117,18 @@ fn regression_2255_helper(mut x: &mut Field) {
     *x = 1;
 }
 
+// Similar to `regression_2255` but without the double-dereferencing.
+// The test checks that `mem2reg` does not eliminate storing to a reference passed as a parameter.
+fn regression_6443() {
+    let x = &mut 0;
+    regression_6443_helper(x);
+    assert(*x == 1);
+}
+
+fn regression_6443_helper(x: &mut Field) {
+    *x = 1;
+}
+
 fn regression_2218(x: Field, y: Field) -> Field {
     let q = &mut &mut 0;
     let q1 = *q;
diff --git a/test_programs/execution_success/regression/Prover.toml b/test_programs/execution_success/regression/Prover.toml
index 2875190982f..c81cbf10fbb 100644
--- a/test_programs/execution_success/regression/Prover.toml
+++ b/test_programs/execution_success/regression/Prover.toml
@@ -1,2 +1,4 @@
 x = [0x3f, 0x1c, 0xb8, 0x99, 0xab]
 z = 3
+u = "169"
+v = "-13"
\ No newline at end of file
diff --git a/test_programs/execution_success/regression/src/main.nr b/test_programs/execution_success/regression/src/main.nr
index e6226de29ef..809fdbe4b28 100644
--- a/test_programs/execution_success/regression/src/main.nr
+++ b/test_programs/execution_success/regression/src/main.nr
@@ -34,16 +34,16 @@ fn compact_decode<let N: u32>(input: [u8; N], length: Field) -> ([U4; NIBBLE_LEN
         for i in 1..input.len() {
             if i as u32 < length as u32 {
                 let x = input[i];
-                nibble[2*i - 1] = U4::from_u8(x >> 4);
-                nibble[2*i] = U4::from_u8(x & 0x0f);
+                nibble[2 * i - 1] = U4::from_u8(x >> 4);
+                nibble[2 * i] = U4::from_u8(x & 0x0f);
             }
         }
     } else {
         for i in 0..2 {
             if (i as u32) < length as u32 - 1 {
                 let x = input[i + 1];
-                nibble[2*i] = U4::from_u8(x >> 4);
-                nibble[2*i + 1] = U4::from_u8(x & 0x0f);
+                nibble[2 * i] = U4::from_u8(x >> 4);
+                nibble[2 * i + 1] = U4::from_u8(x & 0x0f);
             }
         }
     }
@@ -63,7 +63,7 @@ fn enc<let N: u32>(value: [u8; N], value_length: Field) -> ([u8; 32], Field) {
         out_value[0] = 0x80 + value_length as u8;
 
         for i in 1..value.len() {
-            out_value[i] = value[i-1];
+            out_value[i] = value[i - 1];
         }
 
         let out = (out_value, value_length + 1);
@@ -94,30 +94,31 @@ fn bitshift_variable(idx: u8) -> u64 {
     bits
 }
 
-fn main(x: [u8; 5], z: Field) {
+fn main(x: [u8; 5], z: Field, u: i16, v: i16) {
     //Issue 1144
     let (nib, len) = compact_decode(x, z);
     assert(len == 5);
     assert(
         [nib[0], nib[1], nib[2], nib[3], nib[4]]
-        == [U4::from_u8(15), U4::from_u8(1), U4::from_u8(12), U4::from_u8(11), U4::from_u8(8)]
+            == [U4::from_u8(15), U4::from_u8(1), U4::from_u8(12), U4::from_u8(11), U4::from_u8(8)],
     );
     // Issue 1169
     let val1 = [
         0xb8, 0x8f, 0x61, 0xe6, 0xfb, 0xda, 0x83, 0xfb, 0xff, 0xfa, 0xbe, 0x36, 0x41, 0x12, 0x13,
         0x74, 0x80, 0x39, 0x80, 0x18, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-        0x00, 0x00
+        0x00, 0x00,
     ];
     let val1_length = 20;
 
     let enc_val1 = enc(val1, val1_length);
 
     assert(
-        enc_val1.0 == [
-            0x94, 0xb8, 0x8f, 0x61, 0xe6, 0xfb, 0xda, 0x83, 0xfb, 0xff, 0xfa, 0xbe, 0x36, 0x41,
-            0x12, 0x13, 0x74, 0x80, 0x39, 0x80, 0x18, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-            0x00, 0x00, 0x00, 0x00
-        ]
+        enc_val1.0
+            == [
+                0x94, 0xb8, 0x8f, 0x61, 0xe6, 0xfb, 0xda, 0x83, 0xfb, 0xff, 0xfa, 0xbe, 0x36, 0x41,
+                0x12, 0x13, 0x74, 0x80, 0x39, 0x80, 0x18, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+                0x00, 0x00, 0x00, 0x00,
+            ],
     );
     assert(enc_val1.1 == 21);
     // Issue 2399
@@ -129,4 +130,12 @@ fn main(x: [u8; 5], z: Field) {
     assert(result_0 == 1);
     let result_4 = bitshift_variable(4);
     assert(result_4 == 16);
+
+    // Issue 6609
+    assert(u % -13 == 0);
+    assert(u % v == 0);
+    assert(u % -11 == 4);
+    assert(-u % -11 == -4);
+    assert(u % -11 == u % (v + 2));
+    assert(-u % -11 == -u % (v + 2));
 }
diff --git a/test_programs/execution_success/regression_2660/src/main.nr b/test_programs/execution_success/regression_2660/src/main.nr
index f32bc924e3a..92aa15abb43 100644
--- a/test_programs/execution_success/regression_2660/src/main.nr
+++ b/test_programs/execution_success/regression_2660/src/main.nr
@@ -1,4 +1,4 @@
-global foo = -1;
+global foo: i32 = -1;
 
 fn main(x: i32) {
     let y = x + foo;
diff --git a/test_programs/execution_success/regression_3394/src/main.nr b/test_programs/execution_success/regression_3394/src/main.nr
index 59494253757..393e5c91bc2 100644
--- a/test_programs/execution_success/regression_3394/src/main.nr
+++ b/test_programs/execution_success/regression_3394/src/main.nr
@@ -1,4 +1,4 @@
 fn main() {
-    let x : i8 = -128;
+    let x: i8 = -128;
     std::println(x);
 }
diff --git a/test_programs/execution_success/regression_3607/src/main.nr b/test_programs/execution_success/regression_3607/src/main.nr
index 9c7ef243f60..a2a5ed19d91 100644
--- a/test_programs/execution_success/regression_3607/src/main.nr
+++ b/test_programs/execution_success/regression_3607/src/main.nr
@@ -1,8 +1,8 @@
 fn main(mut x: u32) {
     if x == 0 {
-        x = (x+1) / x;
+        x = (x + 1) / x;
     } else {
-        x = (x+1) / x;
+        x = (x + 1) / x;
     }
     assert(x != 0);
 }
diff --git a/test_programs/execution_success/regression_3889/src/main.nr b/test_programs/execution_success/regression_3889/src/main.nr
index 402a69a10da..dfd9e8c2c85 100644
--- a/test_programs/execution_success/regression_3889/src/main.nr
+++ b/test_programs/execution_success/regression_3889/src/main.nr
@@ -1,12 +1,12 @@
 mod Foo {
-    struct NewType{
+    struct NewType {
         a: Field,
     }
 }
 
 mod Bar {
-    use crate::Foo::NewType as BarStruct;
     use crate::Foo::NewType;
+    use crate::Foo::NewType as BarStruct;
 }
 
 mod Baz {
diff --git a/test_programs/execution_success/regression_4088/src/main.nr b/test_programs/execution_success/regression_4088/src/main.nr
index b2a050b5db3..25097b14ae8 100644
--- a/test_programs/execution_success/regression_4088/src/main.nr
+++ b/test_programs/execution_success/regression_4088/src/main.nr
@@ -16,7 +16,10 @@ fn check<let N: u32>(serialized_note: [Field; N]) {
     assert(serialized_note[0] == 0);
 }
 
-fn oopsie<Note, let N: u32>(note: Note) where Note: Serialize<N> {
+fn oopsie<Note, let N: u32>(note: Note)
+where
+    Note: Serialize<N>,
+{
     let serialized_note = Note::serialize(note);
 
     check(serialized_note)
diff --git a/test_programs/execution_success/regression_4124/src/main.nr b/test_programs/execution_success/regression_4124/src/main.nr
index b0e1a394c32..c2407ea91b9 100644
--- a/test_programs/execution_success/regression_4124/src/main.nr
+++ b/test_programs/execution_success/regression_4124/src/main.nr
@@ -24,7 +24,10 @@ impl<T> PublicMutable<T> {
         PublicMutable { storage_slot }
     }
 
-    pub fn read<let T_SERIALIZED_LEN: u32>(_self: Self) -> T where T: MyDeserialize<T_SERIALIZED_LEN> {
+    pub fn read<let T_SERIALIZED_LEN: u32>(_self: Self) -> T
+    where
+        T: MyDeserialize<T_SERIALIZED_LEN>,
+    {
         // storage_read returns slice here
         let fields: [Field; T_SERIALIZED_LEN] = storage_read();
         T::deserialize(fields)
diff --git a/test_programs/execution_success/regression_4449/src/main.nr b/test_programs/execution_success/regression_4449/src/main.nr
index 66bab2e09f4..3fda39bd874 100644
--- a/test_programs/execution_success/regression_4449/src/main.nr
+++ b/test_programs/execution_success/regression_4449/src/main.nr
@@ -1,5 +1,4 @@
 // Regression test for issue #4449
-
 fn main(x: u8, result: [u8; 32]) {
     let x = x % 31;
     let mut digest = [0; 32];
diff --git a/test_programs/execution_success/regression_4709/src/main.nr b/test_programs/execution_success/regression_4709/src/main.nr
index 1df09c53b55..9d730542641 100644
--- a/test_programs/execution_success/regression_4709/src/main.nr
+++ b/test_programs/execution_success/regression_4709/src/main.nr
@@ -1,262 +1,3845 @@
 // Regression test for issue #4709
 global EXPONENTIATE: [[Field; 257]; 257] = [
-[1, 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, 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, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1],
-[1, 2, 4, 8, 16, 32, 64, 128, 256, 255, 253, 249, 241, 225, 193, 129, 1, 2, 4, 8, 16, 32, 64, 128, 256, 255, 253, 249, 241, 225, 193, 129, 1, 2, 4, 8, 16, 32, 64, 128, 256, 255, 253, 249, 241, 225, 193, 129, 1, 2, 4, 8, 16, 32, 64, 128, 256, 255, 253, 249, 241, 225, 193, 129, 1, 2, 4, 8, 16, 32, 64, 128, 256, 255, 253, 249, 241, 225, 193, 129, 1, 2, 4, 8, 16, 32, 64, 128, 256, 255, 253, 249, 241, 225, 193, 129, 1, 2, 4, 8, 16, 32, 64, 128, 256, 255, 253, 249, 241, 225, 193, 129, 1, 2, 4, 8, 16, 32, 64, 128, 256, 255, 253, 249, 241, 225, 193, 129, 1, 2, 4, 8, 16, 32, 64, 128, 256, 255, 253, 249, 241, 225, 193, 129, 1, 2, 4, 8, 16, 32, 64, 128, 256, 255, 253, 249, 241, 225, 193, 129, 1, 2, 4, 8, 16, 32, 64, 128, 256, 255, 253, 249, 241, 225, 193, 129, 1, 2, 4, 8, 16, 32, 64, 128, 256, 255, 253, 249, 241, 225, 193, 129, 1, 2, 4, 8, 16, 32, 64, 128, 256, 255, 253, 249, 241, 225, 193, 129, 1, 2, 4, 8, 16, 32, 64, 128, 256, 255, 253, 249, 241, 225, 193, 129, 1, 2, 4, 8, 16, 32, 64, 128, 256, 255, 253, 249, 241, 225, 193, 129, 1, 2, 4, 8, 16, 32, 64, 128, 256, 255, 253, 249, 241, 225, 193, 129, 1],
-[1, 3, 9, 27, 81, 243, 215, 131, 136, 151, 196, 74, 222, 152, 199, 83, 249, 233, 185, 41, 123, 112, 79, 237, 197, 77, 231, 179, 23, 69, 207, 107, 64, 192, 62, 186, 44, 132, 139, 160, 223, 155, 208, 110, 73, 219, 143, 172, 2, 6, 18, 54, 162, 229, 173, 5, 15, 45, 135, 148, 187, 47, 141, 166, 241, 209, 113, 82, 246, 224, 158, 217, 137, 154, 205, 101, 46, 138, 157, 214, 128, 127, 124, 115, 88, 7, 21, 63, 189, 53, 159, 220, 146, 181, 29, 87, 4, 12, 36, 108, 67, 201, 89, 10, 30, 90, 13, 39, 117, 94, 25, 75, 225, 161, 226, 164, 235, 191, 59, 177, 17, 51, 153, 202, 92, 19, 57, 171, 256, 254, 248, 230, 176, 14, 42, 126, 121, 106, 61, 183, 35, 105, 58, 174, 8, 24, 72, 216, 134, 145, 178, 20, 60, 180, 26, 78, 234, 188, 50, 150, 193, 65, 195, 71, 213, 125, 118, 97, 34, 102, 49, 147, 184, 38, 114, 85, 255, 251, 239, 203, 95, 28, 84, 252, 242, 212, 122, 109, 70, 210, 116, 91, 16, 48, 144, 175, 11, 33, 99, 40, 120, 103, 52, 156, 211, 119, 100, 43, 129, 130, 133, 142, 169, 250, 236, 194, 68, 204, 98, 37, 111, 76, 228, 170, 253, 245, 221, 149, 190, 56, 168, 247, 227, 167, 244, 218, 140, 163, 232, 182, 32, 96, 31, 93, 22, 66, 198, 80, 240, 206, 104, 55, 165, 238, 200, 86, 1],
-[1, 4, 16, 64, 256, 253, 241, 193, 1, 4, 16, 64, 256, 253, 241, 193, 1, 4, 16, 64, 256, 253, 241, 193, 1, 4, 16, 64, 256, 253, 241, 193, 1, 4, 16, 64, 256, 253, 241, 193, 1, 4, 16, 64, 256, 253, 241, 193, 1, 4, 16, 64, 256, 253, 241, 193, 1, 4, 16, 64, 256, 253, 241, 193, 1, 4, 16, 64, 256, 253, 241, 193, 1, 4, 16, 64, 256, 253, 241, 193, 1, 4, 16, 64, 256, 253, 241, 193, 1, 4, 16, 64, 256, 253, 241, 193, 1, 4, 16, 64, 256, 253, 241, 193, 1, 4, 16, 64, 256, 253, 241, 193, 1, 4, 16, 64, 256, 253, 241, 193, 1, 4, 16, 64, 256, 253, 241, 193, 1, 4, 16, 64, 256, 253, 241, 193, 1, 4, 16, 64, 256, 253, 241, 193, 1, 4, 16, 64, 256, 253, 241, 193, 1, 4, 16, 64, 256, 253, 241, 193, 1, 4, 16, 64, 256, 253, 241, 193, 1, 4, 16, 64, 256, 253, 241, 193, 1, 4, 16, 64, 256, 253, 241, 193, 1, 4, 16, 64, 256, 253, 241, 193, 1, 4, 16, 64, 256, 253, 241, 193, 1, 4, 16, 64, 256, 253, 241, 193, 1, 4, 16, 64, 256, 253, 241, 193, 1, 4, 16, 64, 256, 253, 241, 193, 1, 4, 16, 64, 256, 253, 241, 193, 1, 4, 16, 64, 256, 253, 241, 193, 1, 4, 16, 64, 256, 253, 241, 193, 1, 4, 16, 64, 256, 253, 241, 193, 1],
-[1, 5, 25, 125, 111, 41, 205, 254, 242, 182, 139, 181, 134, 156, 9, 45, 225, 97, 228, 112, 46, 230, 122, 96, 223, 87, 178, 119, 81, 148, 226, 102, 253, 237, 157, 14, 70, 93, 208, 12, 60, 43, 215, 47, 235, 147, 221, 77, 128, 126, 116, 66, 73, 108, 26, 130, 136, 166, 59, 38, 190, 179, 124, 106, 16, 80, 143, 201, 234, 142, 196, 209, 17, 85, 168, 69, 88, 183, 144, 206, 2, 10, 50, 250, 222, 82, 153, 251, 227, 107, 21, 105, 11, 55, 18, 90, 193, 194, 199, 224, 92, 203, 244, 192, 189, 174, 99, 238, 162, 39, 195, 204, 249, 217, 57, 28, 140, 186, 159, 24, 120, 86, 173, 94, 213, 37, 185, 154, 256, 252, 232, 132, 146, 216, 52, 3, 15, 75, 118, 76, 123, 101, 248, 212, 32, 160, 29, 145, 211, 27, 135, 161, 34, 170, 79, 138, 176, 109, 31, 155, 4, 20, 100, 243, 187, 164, 49, 245, 197, 214, 42, 210, 22, 110, 36, 180, 129, 131, 141, 191, 184, 149, 231, 127, 121, 91, 198, 219, 67, 78, 133, 151, 241, 177, 114, 56, 23, 115, 61, 48, 240, 172, 89, 188, 169, 74, 113, 51, 255, 247, 207, 7, 35, 175, 104, 6, 30, 150, 236, 152, 246, 202, 239, 167, 64, 63, 58, 33, 165, 54, 13, 65, 68, 83, 158, 19, 95, 218, 62, 53, 8, 40, 200, 229, 117, 71, 98, 233, 137, 171, 84, 163, 44, 220, 72, 103, 1],
-[1, 6, 36, 216, 11, 66, 139, 63, 121, 212, 244, 179, 46, 19, 114, 170, 249, 209, 226, 71, 169, 243, 173, 10, 60, 103, 104, 110, 146, 105, 116, 182, 64, 127, 248, 203, 190, 112, 158, 177, 34, 204, 196, 148, 117, 188, 100, 86, 2, 12, 72, 175, 22, 132, 21, 126, 242, 167, 231, 101, 92, 38, 228, 83, 241, 161, 195, 142, 81, 229, 89, 20, 120, 206, 208, 220, 35, 210, 232, 107, 128, 254, 239, 149, 123, 224, 59, 97, 68, 151, 135, 39, 234, 119, 200, 172, 4, 24, 144, 93, 44, 7, 42, 252, 227, 77, 205, 202, 184, 76, 199, 166, 225, 65, 133, 27, 162, 201, 178, 40, 240, 155, 159, 183, 70, 163, 207, 214, 256, 251, 221, 41, 246, 191, 118, 194, 136, 45, 13, 78, 211, 238, 143, 87, 8, 48, 31, 186, 88, 14, 84, 247, 197, 154, 153, 147, 111, 152, 141, 75, 193, 130, 9, 54, 67, 145, 99, 80, 223, 53, 61, 109, 140, 69, 157, 171, 255, 245, 185, 82, 235, 125, 236, 131, 15, 90, 26, 156, 165, 219, 29, 174, 16, 96, 62, 115, 176, 28, 168, 237, 137, 51, 49, 37, 222, 47, 25, 150, 129, 3, 18, 108, 134, 33, 198, 160, 189, 106, 122, 218, 23, 138, 57, 85, 253, 233, 113, 164, 213, 250, 215, 5, 30, 180, 52, 55, 73, 181, 58, 91, 32, 192, 124, 230, 95, 56, 79, 217, 17, 102, 98, 74, 187, 94, 50, 43, 1],
-[1, 7, 49, 86, 88, 102, 200, 115, 34, 238, 124, 97, 165, 127, 118, 55, 128, 125, 104, 214, 213, 206, 157, 71, 240, 138, 195, 80, 46, 65, 198, 101, 193, 66, 205, 150, 22, 154, 50, 93, 137, 188, 31, 217, 234, 96, 158, 78, 32, 224, 26, 182, 246, 180, 232, 82, 60, 163, 113, 20, 140, 209, 178, 218, 241, 145, 244, 166, 134, 167, 141, 216, 227, 47, 72, 247, 187, 24, 168, 148, 8, 56, 135, 174, 190, 45, 58, 149, 15, 105, 221, 5, 35, 245, 173, 183, 253, 229, 61, 170, 162, 106, 228, 54, 121, 76, 18, 126, 111, 6, 42, 37, 2, 14, 98, 172, 176, 204, 143, 230, 68, 219, 248, 194, 73, 254, 236, 110, 256, 250, 208, 171, 169, 155, 57, 142, 223, 19, 133, 160, 92, 130, 139, 202, 129, 132, 153, 43, 44, 51, 100, 186, 17, 119, 62, 177, 211, 192, 59, 156, 64, 191, 52, 107, 235, 103, 207, 164, 120, 69, 226, 40, 23, 161, 99, 179, 225, 33, 231, 75, 11, 77, 25, 175, 197, 94, 144, 237, 117, 48, 79, 39, 16, 112, 13, 91, 123, 90, 116, 41, 30, 210, 185, 10, 70, 233, 89, 109, 249, 201, 122, 83, 67, 212, 199, 108, 242, 152, 36, 252, 222, 12, 84, 74, 4, 28, 196, 87, 95, 151, 29, 203, 136, 181, 239, 131, 146, 251, 215, 220, 255, 243, 159, 85, 81, 53, 114, 27, 189, 38, 9, 63, 184, 3, 21, 147, 1],
-[1, 8, 64, 255, 241, 129, 4, 32, 256, 249, 193, 2, 16, 128, 253, 225, 1, 8, 64, 255, 241, 129, 4, 32, 256, 249, 193, 2, 16, 128, 253, 225, 1, 8, 64, 255, 241, 129, 4, 32, 256, 249, 193, 2, 16, 128, 253, 225, 1, 8, 64, 255, 241, 129, 4, 32, 256, 249, 193, 2, 16, 128, 253, 225, 1, 8, 64, 255, 241, 129, 4, 32, 256, 249, 193, 2, 16, 128, 253, 225, 1, 8, 64, 255, 241, 129, 4, 32, 256, 249, 193, 2, 16, 128, 253, 225, 1, 8, 64, 255, 241, 129, 4, 32, 256, 249, 193, 2, 16, 128, 253, 225, 1, 8, 64, 255, 241, 129, 4, 32, 256, 249, 193, 2, 16, 128, 253, 225, 1, 8, 64, 255, 241, 129, 4, 32, 256, 249, 193, 2, 16, 128, 253, 225, 1, 8, 64, 255, 241, 129, 4, 32, 256, 249, 193, 2, 16, 128, 253, 225, 1, 8, 64, 255, 241, 129, 4, 32, 256, 249, 193, 2, 16, 128, 253, 225, 1, 8, 64, 255, 241, 129, 4, 32, 256, 249, 193, 2, 16, 128, 253, 225, 1, 8, 64, 255, 241, 129, 4, 32, 256, 249, 193, 2, 16, 128, 253, 225, 1, 8, 64, 255, 241, 129, 4, 32, 256, 249, 193, 2, 16, 128, 253, 225, 1, 8, 64, 255, 241, 129, 4, 32, 256, 249, 193, 2, 16, 128, 253, 225, 1, 8, 64, 255, 241, 129, 4, 32, 256, 249, 193, 2, 16, 128, 253, 225, 1],
-[1, 9, 81, 215, 136, 196, 222, 199, 249, 185, 123, 79, 197, 231, 23, 207, 64, 62, 44, 139, 223, 208, 73, 143, 2, 18, 162, 173, 15, 135, 187, 141, 241, 113, 246, 158, 137, 205, 46, 157, 128, 124, 88, 21, 189, 159, 146, 29, 4, 36, 67, 89, 30, 13, 117, 25, 225, 226, 235, 59, 17, 153, 92, 57, 256, 248, 176, 42, 121, 61, 35, 58, 8, 72, 134, 178, 60, 26, 234, 50, 193, 195, 213, 118, 34, 49, 184, 114, 255, 239, 95, 84, 242, 122, 70, 116, 16, 144, 11, 99, 120, 52, 211, 100, 129, 133, 169, 236, 68, 98, 111, 228, 253, 221, 190, 168, 227, 244, 140, 232, 32, 31, 22, 198, 240, 104, 165, 200, 1, 9, 81, 215, 136, 196, 222, 199, 249, 185, 123, 79, 197, 231, 23, 207, 64, 62, 44, 139, 223, 208, 73, 143, 2, 18, 162, 173, 15, 135, 187, 141, 241, 113, 246, 158, 137, 205, 46, 157, 128, 124, 88, 21, 189, 159, 146, 29, 4, 36, 67, 89, 30, 13, 117, 25, 225, 226, 235, 59, 17, 153, 92, 57, 256, 248, 176, 42, 121, 61, 35, 58, 8, 72, 134, 178, 60, 26, 234, 50, 193, 195, 213, 118, 34, 49, 184, 114, 255, 239, 95, 84, 242, 122, 70, 116, 16, 144, 11, 99, 120, 52, 211, 100, 129, 133, 169, 236, 68, 98, 111, 228, 253, 221, 190, 168, 227, 244, 140, 232, 32, 31, 22, 198, 240, 104, 165, 200, 1],
-[1, 10, 100, 229, 234, 27, 13, 130, 15, 150, 215, 94, 169, 148, 195, 151, 225, 194, 141, 125, 222, 164, 98, 209, 34, 83, 59, 76, 246, 147, 185, 51, 253, 217, 114, 112, 92, 149, 205, 251, 197, 171, 168, 138, 95, 179, 248, 167, 128, 252, 207, 14, 140, 115, 122, 192, 121, 182, 21, 210, 44, 183, 31, 53, 16, 160, 58, 66, 146, 175, 208, 24, 240, 87, 99, 219, 134, 55, 36, 103, 2, 20, 200, 201, 211, 54, 26, 3, 30, 43, 173, 188, 81, 39, 133, 45, 193, 131, 25, 250, 187, 71, 196, 161, 68, 166, 118, 152, 235, 37, 113, 102, 249, 177, 228, 224, 184, 41, 153, 245, 137, 85, 79, 19, 190, 101, 239, 77, 256, 247, 157, 28, 23, 230, 244, 127, 242, 107, 42, 163, 88, 109, 62, 106, 32, 63, 116, 132, 35, 93, 159, 48, 223, 174, 198, 181, 11, 110, 72, 206, 4, 40, 143, 145, 165, 108, 52, 6, 60, 86, 89, 119, 162, 78, 9, 90, 129, 5, 50, 243, 117, 142, 135, 65, 136, 75, 236, 47, 213, 74, 226, 204, 241, 97, 199, 191, 111, 82, 49, 233, 17, 170, 158, 38, 123, 202, 221, 154, 255, 237, 57, 56, 46, 203, 231, 254, 227, 214, 84, 69, 176, 218, 124, 212, 64, 126, 232, 7, 70, 186, 61, 96, 189, 91, 139, 105, 22, 220, 144, 155, 8, 80, 29, 33, 73, 216, 104, 12, 120, 172, 178, 238, 67, 156, 18, 180, 1],
-[1, 11, 121, 46, 249, 169, 60, 146, 64, 190, 34, 117, 2, 22, 242, 92, 241, 81, 120, 35, 128, 123, 68, 234, 4, 44, 227, 184, 225, 162, 240, 70, 256, 246, 136, 211, 8, 88, 197, 111, 193, 67, 223, 140, 255, 235, 15, 165, 16, 176, 137, 222, 129, 134, 189, 23, 253, 213, 30, 73, 32, 95, 17, 187, 1, 11, 121, 46, 249, 169, 60, 146, 64, 190, 34, 117, 2, 22, 242, 92, 241, 81, 120, 35, 128, 123, 68, 234, 4, 44, 227, 184, 225, 162, 240, 70, 256, 246, 136, 211, 8, 88, 197, 111, 193, 67, 223, 140, 255, 235, 15, 165, 16, 176, 137, 222, 129, 134, 189, 23, 253, 213, 30, 73, 32, 95, 17, 187, 1, 11, 121, 46, 249, 169, 60, 146, 64, 190, 34, 117, 2, 22, 242, 92, 241, 81, 120, 35, 128, 123, 68, 234, 4, 44, 227, 184, 225, 162, 240, 70, 256, 246, 136, 211, 8, 88, 197, 111, 193, 67, 223, 140, 255, 235, 15, 165, 16, 176, 137, 222, 129, 134, 189, 23, 253, 213, 30, 73, 32, 95, 17, 187, 1, 11, 121, 46, 249, 169, 60, 146, 64, 190, 34, 117, 2, 22, 242, 92, 241, 81, 120, 35, 128, 123, 68, 234, 4, 44, 227, 184, 225, 162, 240, 70, 256, 246, 136, 211, 8, 88, 197, 111, 193, 67, 223, 140, 255, 235, 15, 165, 16, 176, 137, 222, 129, 134, 189, 23, 253, 213, 30, 73, 32, 95, 17, 187, 1],
-[1, 12, 144, 186, 176, 56, 158, 97, 136, 90, 52, 110, 35, 163, 157, 85, 249, 161, 133, 54, 134, 66, 21, 252, 197, 51, 98, 148, 234, 238, 29, 91, 64, 254, 221, 82, 213, 243, 89, 40, 223, 106, 244, 101, 184, 152, 25, 43, 2, 24, 31, 115, 95, 112, 59, 194, 15, 180, 104, 220, 70, 69, 57, 170, 241, 65, 9, 108, 11, 132, 42, 247, 137, 102, 196, 39, 211, 219, 58, 182, 128, 251, 185, 164, 169, 229, 178, 80, 189, 212, 231, 202, 111, 47, 50, 86, 4, 48, 62, 230, 190, 224, 118, 131, 30, 103, 208, 183, 140, 138, 114, 83, 225, 130, 18, 216, 22, 7, 84, 237, 17, 204, 135, 78, 165, 181, 116, 107, 256, 245, 113, 71, 81, 201, 99, 160, 121, 167, 205, 147, 222, 94, 100, 172, 8, 96, 124, 203, 123, 191, 236, 5, 60, 206, 159, 109, 23, 19, 228, 166, 193, 3, 36, 175, 44, 14, 168, 217, 34, 151, 13, 156, 73, 105, 232, 214, 255, 233, 226, 142, 162, 145, 198, 63, 242, 77, 153, 37, 187, 188, 200, 87, 16, 192, 248, 149, 246, 125, 215, 10, 120, 155, 61, 218, 46, 38, 199, 75, 129, 6, 72, 93, 88, 28, 79, 177, 68, 45, 26, 55, 146, 210, 207, 171, 253, 209, 195, 27, 67, 33, 139, 126, 227, 154, 49, 74, 117, 119, 143, 174, 32, 127, 239, 41, 235, 250, 173, 20, 240, 53, 122, 179, 92, 76, 141, 150, 1],
-[1, 13, 169, 141, 34, 185, 92, 168, 128, 122, 44, 58, 240, 36, 211, 173, 193, 196, 235, 228, 137, 239, 23, 42, 32, 159, 11, 143, 60, 9, 117, 236, 241, 49, 123, 57, 227, 124, 70, 139, 8, 104, 67, 100, 15, 195, 222, 59, 253, 205, 95, 207, 121, 31, 146, 99, 2, 26, 81, 25, 68, 113, 184, 79, 256, 244, 88, 116, 223, 72, 165, 89, 129, 135, 213, 199, 17, 221, 46, 84, 64, 61, 22, 29, 120, 18, 234, 215, 225, 98, 246, 114, 197, 248, 140, 21, 16, 208, 134, 200, 30, 133, 187, 118, 249, 153, 190, 157, 242, 62, 35, 198, 4, 52, 162, 50, 136, 226, 111, 158, 255, 231, 176, 232, 189, 144, 73, 178, 1, 13, 169, 141, 34, 185, 92, 168, 128, 122, 44, 58, 240, 36, 211, 173, 193, 196, 235, 228, 137, 239, 23, 42, 32, 159, 11, 143, 60, 9, 117, 236, 241, 49, 123, 57, 227, 124, 70, 139, 8, 104, 67, 100, 15, 195, 222, 59, 253, 205, 95, 207, 121, 31, 146, 99, 2, 26, 81, 25, 68, 113, 184, 79, 256, 244, 88, 116, 223, 72, 165, 89, 129, 135, 213, 199, 17, 221, 46, 84, 64, 61, 22, 29, 120, 18, 234, 215, 225, 98, 246, 114, 197, 248, 140, 21, 16, 208, 134, 200, 30, 133, 187, 118, 249, 153, 190, 157, 242, 62, 35, 198, 4, 52, 162, 50, 136, 226, 111, 158, 255, 231, 176, 232, 189, 144, 73, 178, 1],
-[1, 14, 196, 174, 123, 180, 207, 71, 223, 38, 18, 252, 187, 48, 158, 156, 128, 250, 159, 170, 67, 167, 25, 93, 17, 238, 248, 131, 35, 233, 178, 179, 193, 132, 49, 172, 95, 45, 116, 82, 120, 138, 133, 63, 111, 12, 168, 39, 32, 191, 104, 171, 81, 106, 199, 216, 197, 188, 62, 97, 73, 251, 173, 109, 241, 33, 205, 43, 88, 204, 29, 149, 30, 163, 226, 80, 92, 3, 42, 74, 8, 112, 26, 107, 213, 155, 114, 54, 242, 47, 144, 217, 211, 127, 236, 220, 253, 201, 244, 75, 22, 51, 200, 230, 136, 105, 185, 20, 23, 65, 139, 147, 2, 28, 135, 91, 246, 103, 157, 142, 189, 76, 36, 247, 117, 96, 59, 55, 256, 243, 61, 83, 134, 77, 50, 186, 34, 219, 239, 5, 70, 209, 99, 101, 129, 7, 98, 87, 190, 90, 232, 164, 240, 19, 9, 126, 222, 24, 79, 78, 64, 125, 208, 85, 162, 212, 141, 175, 137, 119, 124, 194, 146, 245, 89, 218, 225, 66, 153, 86, 176, 151, 58, 41, 60, 69, 195, 160, 184, 6, 84, 148, 16, 224, 52, 214, 169, 53, 228, 108, 227, 94, 31, 177, 165, 254, 215, 183, 249, 145, 231, 150, 44, 102, 143, 203, 15, 210, 113, 40, 46, 130, 21, 37, 4, 56, 13, 182, 235, 206, 57, 27, 121, 152, 72, 237, 234, 192, 118, 110, 255, 229, 122, 166, 11, 154, 100, 115, 68, 181, 221, 10, 140, 161, 198, 202, 1],
-[1, 15, 225, 34, 253, 197, 128, 121, 16, 240, 2, 30, 193, 68, 249, 137, 256, 242, 32, 223, 4, 60, 129, 136, 241, 17, 255, 227, 64, 189, 8, 120, 1, 15, 225, 34, 253, 197, 128, 121, 16, 240, 2, 30, 193, 68, 249, 137, 256, 242, 32, 223, 4, 60, 129, 136, 241, 17, 255, 227, 64, 189, 8, 120, 1, 15, 225, 34, 253, 197, 128, 121, 16, 240, 2, 30, 193, 68, 249, 137, 256, 242, 32, 223, 4, 60, 129, 136, 241, 17, 255, 227, 64, 189, 8, 120, 1, 15, 225, 34, 253, 197, 128, 121, 16, 240, 2, 30, 193, 68, 249, 137, 256, 242, 32, 223, 4, 60, 129, 136, 241, 17, 255, 227, 64, 189, 8, 120, 1, 15, 225, 34, 253, 197, 128, 121, 16, 240, 2, 30, 193, 68, 249, 137, 256, 242, 32, 223, 4, 60, 129, 136, 241, 17, 255, 227, 64, 189, 8, 120, 1, 15, 225, 34, 253, 197, 128, 121, 16, 240, 2, 30, 193, 68, 249, 137, 256, 242, 32, 223, 4, 60, 129, 136, 241, 17, 255, 227, 64, 189, 8, 120, 1, 15, 225, 34, 253, 197, 128, 121, 16, 240, 2, 30, 193, 68, 249, 137, 256, 242, 32, 223, 4, 60, 129, 136, 241, 17, 255, 227, 64, 189, 8, 120, 1, 15, 225, 34, 253, 197, 128, 121, 16, 240, 2, 30, 193, 68, 249, 137, 256, 242, 32, 223, 4, 60, 129, 136, 241, 17, 255, 227, 64, 189, 8, 120, 1],
-[1, 16, 256, 241, 1, 16, 256, 241, 1, 16, 256, 241, 1, 16, 256, 241, 1, 16, 256, 241, 1, 16, 256, 241, 1, 16, 256, 241, 1, 16, 256, 241, 1, 16, 256, 241, 1, 16, 256, 241, 1, 16, 256, 241, 1, 16, 256, 241, 1, 16, 256, 241, 1, 16, 256, 241, 1, 16, 256, 241, 1, 16, 256, 241, 1, 16, 256, 241, 1, 16, 256, 241, 1, 16, 256, 241, 1, 16, 256, 241, 1, 16, 256, 241, 1, 16, 256, 241, 1, 16, 256, 241, 1, 16, 256, 241, 1, 16, 256, 241, 1, 16, 256, 241, 1, 16, 256, 241, 1, 16, 256, 241, 1, 16, 256, 241, 1, 16, 256, 241, 1, 16, 256, 241, 1, 16, 256, 241, 1, 16, 256, 241, 1, 16, 256, 241, 1, 16, 256, 241, 1, 16, 256, 241, 1, 16, 256, 241, 1, 16, 256, 241, 1, 16, 256, 241, 1, 16, 256, 241, 1, 16, 256, 241, 1, 16, 256, 241, 1, 16, 256, 241, 1, 16, 256, 241, 1, 16, 256, 241, 1, 16, 256, 241, 1, 16, 256, 241, 1, 16, 256, 241, 1, 16, 256, 241, 1, 16, 256, 241, 1, 16, 256, 241, 1, 16, 256, 241, 1, 16, 256, 241, 1, 16, 256, 241, 1, 16, 256, 241, 1, 16, 256, 241, 1, 16, 256, 241, 1, 16, 256, 241, 1, 16, 256, 241, 1, 16, 256, 241, 1, 16, 256, 241, 1, 16, 256, 241, 1, 16, 256, 241, 1, 16, 256, 241, 1],
-[1, 17, 32, 30, 253, 189, 129, 137, 16, 15, 255, 223, 193, 197, 8, 136, 256, 240, 225, 227, 4, 68, 128, 120, 241, 242, 2, 34, 64, 60, 249, 121, 1, 17, 32, 30, 253, 189, 129, 137, 16, 15, 255, 223, 193, 197, 8, 136, 256, 240, 225, 227, 4, 68, 128, 120, 241, 242, 2, 34, 64, 60, 249, 121, 1, 17, 32, 30, 253, 189, 129, 137, 16, 15, 255, 223, 193, 197, 8, 136, 256, 240, 225, 227, 4, 68, 128, 120, 241, 242, 2, 34, 64, 60, 249, 121, 1, 17, 32, 30, 253, 189, 129, 137, 16, 15, 255, 223, 193, 197, 8, 136, 256, 240, 225, 227, 4, 68, 128, 120, 241, 242, 2, 34, 64, 60, 249, 121, 1, 17, 32, 30, 253, 189, 129, 137, 16, 15, 255, 223, 193, 197, 8, 136, 256, 240, 225, 227, 4, 68, 128, 120, 241, 242, 2, 34, 64, 60, 249, 121, 1, 17, 32, 30, 253, 189, 129, 137, 16, 15, 255, 223, 193, 197, 8, 136, 256, 240, 225, 227, 4, 68, 128, 120, 241, 242, 2, 34, 64, 60, 249, 121, 1, 17, 32, 30, 253, 189, 129, 137, 16, 15, 255, 223, 193, 197, 8, 136, 256, 240, 225, 227, 4, 68, 128, 120, 241, 242, 2, 34, 64, 60, 249, 121, 1, 17, 32, 30, 253, 189, 129, 137, 16, 15, 255, 223, 193, 197, 8, 136, 256, 240, 225, 227, 4, 68, 128, 120, 241, 242, 2, 34, 64, 60, 249, 121, 1],
-[1, 18, 67, 178, 120, 104, 73, 29, 8, 144, 22, 139, 189, 61, 70, 232, 64, 124, 176, 84, 227, 231, 46, 57, 255, 221, 123, 158, 17, 49, 111, 199, 241, 226, 213, 236, 136, 135, 117, 50, 129, 9, 162, 89, 60, 52, 165, 143, 4, 72, 11, 198, 223, 159, 35, 116, 32, 62, 88, 42, 242, 244, 23, 157, 256, 239, 190, 79, 137, 153, 184, 228, 249, 113, 235, 118, 68, 196, 187, 25, 193, 133, 81, 173, 30, 26, 211, 200, 2, 36, 134, 99, 240, 208, 146, 58, 16, 31, 44, 21, 121, 122, 140, 207, 128, 248, 95, 168, 197, 205, 92, 114, 253, 185, 246, 59, 34, 98, 222, 141, 225, 195, 169, 215, 15, 13, 234, 100, 1, 18, 67, 178, 120, 104, 73, 29, 8, 144, 22, 139, 189, 61, 70, 232, 64, 124, 176, 84, 227, 231, 46, 57, 255, 221, 123, 158, 17, 49, 111, 199, 241, 226, 213, 236, 136, 135, 117, 50, 129, 9, 162, 89, 60, 52, 165, 143, 4, 72, 11, 198, 223, 159, 35, 116, 32, 62, 88, 42, 242, 244, 23, 157, 256, 239, 190, 79, 137, 153, 184, 228, 249, 113, 235, 118, 68, 196, 187, 25, 193, 133, 81, 173, 30, 26, 211, 200, 2, 36, 134, 99, 240, 208, 146, 58, 16, 31, 44, 21, 121, 122, 140, 207, 128, 248, 95, 168, 197, 205, 92, 114, 253, 185, 246, 59, 34, 98, 222, 141, 225, 195, 169, 215, 15, 13, 234, 100, 1],
-[1, 19, 104, 177, 22, 161, 232, 39, 227, 201, 221, 87, 111, 53, 236, 115, 129, 138, 52, 217, 11, 209, 116, 148, 242, 229, 239, 172, 184, 155, 118, 186, 193, 69, 26, 237, 134, 233, 58, 74, 121, 243, 248, 86, 92, 206, 59, 93, 225, 163, 13, 247, 67, 245, 29, 37, 189, 250, 124, 43, 46, 103, 158, 175, 241, 210, 135, 252, 162, 251, 143, 147, 223, 125, 62, 150, 23, 180, 79, 216, 249, 105, 196, 126, 81, 254, 200, 202, 240, 191, 31, 75, 140, 90, 168, 108, 253, 181, 98, 63, 169, 127, 100, 101, 120, 224, 144, 166, 70, 45, 84, 54, 255, 219, 49, 160, 213, 192, 50, 179, 60, 112, 72, 83, 35, 151, 42, 27, 256, 238, 153, 80, 235, 96, 25, 218, 30, 56, 36, 170, 146, 204, 21, 142, 128, 119, 205, 40, 246, 48, 141, 109, 15, 28, 18, 85, 73, 102, 139, 71, 64, 188, 231, 20, 123, 24, 199, 183, 136, 14, 9, 171, 165, 51, 198, 164, 32, 94, 244, 10, 190, 12, 228, 220, 68, 7, 133, 214, 211, 154, 99, 82, 16, 47, 122, 5, 95, 6, 114, 110, 34, 132, 195, 107, 234, 77, 178, 41, 8, 152, 61, 131, 176, 3, 57, 55, 17, 66, 226, 182, 117, 167, 89, 149, 4, 76, 159, 194, 88, 130, 157, 156, 137, 33, 113, 91, 187, 212, 173, 203, 2, 38, 208, 97, 44, 65, 207, 78, 197, 145, 185, 174, 222, 106, 215, 230, 1],
-[1, 20, 143, 33, 146, 93, 61, 192, 242, 214, 168, 19, 123, 147, 113, 204, 225, 131, 50, 229, 211, 108, 104, 24, 223, 91, 21, 163, 176, 179, 239, 154, 253, 177, 199, 125, 187, 142, 13, 3, 60, 172, 99, 181, 22, 183, 62, 212, 128, 247, 57, 112, 184, 82, 98, 161, 136, 150, 173, 119, 67, 55, 72, 155, 16, 63, 232, 14, 23, 203, 205, 245, 17, 83, 118, 47, 169, 39, 9, 180, 2, 40, 29, 66, 35, 186, 122, 127, 227, 171, 79, 38, 246, 37, 226, 151, 193, 5, 100, 201, 165, 216, 208, 48, 189, 182, 42, 69, 95, 101, 221, 51, 249, 97, 141, 250, 117, 27, 26, 6, 120, 87, 198, 105, 44, 109, 124, 167, 256, 237, 114, 224, 111, 164, 196, 65, 15, 43, 89, 238, 134, 110, 144, 53, 32, 126, 207, 28, 46, 149, 153, 233, 34, 166, 236, 94, 81, 78, 18, 103, 4, 80, 58, 132, 70, 115, 244, 254, 197, 85, 158, 76, 235, 74, 195, 45, 129, 10, 200, 145, 73, 175, 159, 96, 121, 107, 84, 138, 190, 202, 185, 102, 241, 194, 25, 243, 234, 54, 52, 12, 240, 174, 139, 210, 88, 218, 248, 77, 255, 217, 228, 191, 222, 71, 135, 130, 30, 86, 178, 219, 11, 220, 31, 106, 64, 252, 157, 56, 92, 41, 49, 209, 68, 75, 215, 188, 162, 156, 36, 206, 8, 160, 116, 7, 140, 230, 231, 251, 137, 170, 59, 152, 213, 148, 133, 90, 1],
-[1, 21, 184, 9, 189, 114, 81, 159, 255, 215, 146, 239, 136, 29, 95, 196, 4, 84, 222, 36, 242, 199, 67, 122, 249, 89, 70, 185, 30, 116, 123, 13, 16, 79, 117, 144, 197, 25, 11, 231, 225, 99, 23, 226, 120, 207, 235, 52, 64, 59, 211, 62, 17, 100, 44, 153, 129, 139, 92, 133, 223, 57, 169, 208, 256, 236, 73, 248, 68, 143, 176, 98, 2, 42, 111, 18, 121, 228, 162, 61, 253, 173, 35, 221, 15, 58, 190, 135, 8, 168, 187, 72, 227, 141, 134, 244, 241, 178, 140, 113, 60, 232, 246, 26, 32, 158, 234, 31, 137, 50, 22, 205, 193, 198, 46, 195, 240, 157, 213, 104, 128, 118, 165, 124, 34, 200, 88, 49, 1, 21, 184, 9, 189, 114, 81, 159, 255, 215, 146, 239, 136, 29, 95, 196, 4, 84, 222, 36, 242, 199, 67, 122, 249, 89, 70, 185, 30, 116, 123, 13, 16, 79, 117, 144, 197, 25, 11, 231, 225, 99, 23, 226, 120, 207, 235, 52, 64, 59, 211, 62, 17, 100, 44, 153, 129, 139, 92, 133, 223, 57, 169, 208, 256, 236, 73, 248, 68, 143, 176, 98, 2, 42, 111, 18, 121, 228, 162, 61, 253, 173, 35, 221, 15, 58, 190, 135, 8, 168, 187, 72, 227, 141, 134, 244, 241, 178, 140, 113, 60, 232, 246, 26, 32, 158, 234, 31, 137, 50, 22, 205, 193, 198, 46, 195, 240, 157, 213, 104, 128, 118, 165, 124, 34, 200, 88, 49, 1],
-[1, 22, 227, 111, 129, 11, 242, 184, 193, 134, 121, 92, 225, 67, 189, 46, 241, 162, 223, 23, 249, 81, 240, 140, 253, 169, 120, 70, 255, 213, 60, 35, 256, 235, 30, 146, 128, 246, 15, 73, 64, 123, 136, 165, 32, 190, 68, 211, 16, 95, 34, 234, 8, 176, 17, 117, 4, 88, 137, 187, 2, 44, 197, 222, 1, 22, 227, 111, 129, 11, 242, 184, 193, 134, 121, 92, 225, 67, 189, 46, 241, 162, 223, 23, 249, 81, 240, 140, 253, 169, 120, 70, 255, 213, 60, 35, 256, 235, 30, 146, 128, 246, 15, 73, 64, 123, 136, 165, 32, 190, 68, 211, 16, 95, 34, 234, 8, 176, 17, 117, 4, 88, 137, 187, 2, 44, 197, 222, 1, 22, 227, 111, 129, 11, 242, 184, 193, 134, 121, 92, 225, 67, 189, 46, 241, 162, 223, 23, 249, 81, 240, 140, 253, 169, 120, 70, 255, 213, 60, 35, 256, 235, 30, 146, 128, 246, 15, 73, 64, 123, 136, 165, 32, 190, 68, 211, 16, 95, 34, 234, 8, 176, 17, 117, 4, 88, 137, 187, 2, 44, 197, 222, 1, 22, 227, 111, 129, 11, 242, 184, 193, 134, 121, 92, 225, 67, 189, 46, 241, 162, 223, 23, 249, 81, 240, 140, 253, 169, 120, 70, 255, 213, 60, 35, 256, 235, 30, 146, 128, 246, 15, 73, 64, 123, 136, 165, 32, 190, 68, 211, 16, 95, 34, 234, 8, 176, 17, 117, 4, 88, 137, 187, 2, 44, 197, 222, 1],
-[1, 23, 15, 88, 225, 35, 34, 11, 253, 165, 197, 162, 128, 117, 121, 213, 16, 111, 240, 123, 2, 46, 30, 176, 193, 70, 68, 22, 249, 73, 137, 67, 256, 234, 242, 169, 32, 222, 223, 246, 4, 92, 60, 95, 129, 140, 136, 44, 241, 146, 17, 134, 255, 211, 227, 81, 64, 187, 189, 235, 8, 184, 120, 190, 1, 23, 15, 88, 225, 35, 34, 11, 253, 165, 197, 162, 128, 117, 121, 213, 16, 111, 240, 123, 2, 46, 30, 176, 193, 70, 68, 22, 249, 73, 137, 67, 256, 234, 242, 169, 32, 222, 223, 246, 4, 92, 60, 95, 129, 140, 136, 44, 241, 146, 17, 134, 255, 211, 227, 81, 64, 187, 189, 235, 8, 184, 120, 190, 1, 23, 15, 88, 225, 35, 34, 11, 253, 165, 197, 162, 128, 117, 121, 213, 16, 111, 240, 123, 2, 46, 30, 176, 193, 70, 68, 22, 249, 73, 137, 67, 256, 234, 242, 169, 32, 222, 223, 246, 4, 92, 60, 95, 129, 140, 136, 44, 241, 146, 17, 134, 255, 211, 227, 81, 64, 187, 189, 235, 8, 184, 120, 190, 1, 23, 15, 88, 225, 35, 34, 11, 253, 165, 197, 162, 128, 117, 121, 213, 16, 111, 240, 123, 2, 46, 30, 176, 193, 70, 68, 22, 249, 73, 137, 67, 256, 234, 242, 169, 32, 222, 223, 246, 4, 92, 60, 95, 129, 140, 136, 44, 241, 146, 17, 134, 255, 211, 227, 81, 64, 187, 189, 235, 8, 184, 120, 190, 1],
-[1, 24, 62, 203, 246, 250, 89, 80, 121, 77, 49, 148, 211, 181, 232, 171, 249, 65, 18, 175, 88, 56, 59, 131, 60, 155, 122, 101, 111, 94, 200, 174, 64, 251, 113, 142, 67, 66, 42, 237, 34, 45, 52, 220, 140, 19, 199, 150, 2, 48, 124, 149, 235, 243, 178, 160, 242, 154, 98, 39, 165, 105, 207, 85, 241, 130, 36, 93, 176, 112, 118, 5, 120, 53, 244, 202, 222, 188, 143, 91, 128, 245, 226, 27, 134, 132, 84, 217, 68, 90, 104, 183, 23, 38, 141, 43, 4, 96, 248, 41, 213, 229, 99, 63, 227, 51, 196, 78, 73, 210, 157, 170, 225, 3, 72, 186, 95, 224, 236, 10, 240, 106, 231, 147, 187, 119, 29, 182, 256, 233, 195, 54, 11, 7, 168, 177, 136, 180, 208, 109, 46, 76, 25, 86, 8, 192, 239, 82, 169, 201, 198, 126, 197, 102, 135, 156, 146, 163, 57, 83, 193, 6, 144, 115, 190, 191, 215, 20, 223, 212, 205, 37, 117, 238, 58, 107, 255, 209, 133, 108, 22, 14, 79, 97, 15, 103, 159, 218, 92, 152, 50, 172, 16, 127, 221, 164, 81, 145, 139, 252, 137, 204, 13, 55, 35, 69, 114, 166, 129, 12, 31, 230, 123, 125, 173, 40, 189, 167, 153, 74, 234, 219, 116, 214, 253, 161, 9, 216, 44, 28, 158, 194, 30, 206, 61, 179, 184, 47, 100, 87, 32, 254, 185, 71, 162, 33, 21, 247, 17, 151, 26, 110, 70, 138, 228, 75, 1],
-[1, 25, 111, 205, 242, 139, 134, 9, 225, 228, 46, 122, 223, 178, 81, 226, 253, 157, 70, 208, 60, 215, 235, 221, 128, 116, 73, 26, 136, 59, 190, 124, 16, 143, 234, 196, 17, 168, 88, 144, 2, 50, 222, 153, 227, 21, 11, 18, 193, 199, 92, 244, 189, 99, 162, 195, 249, 57, 140, 159, 120, 173, 213, 185, 256, 232, 146, 52, 15, 118, 123, 248, 32, 29, 211, 135, 34, 79, 176, 31, 4, 100, 187, 49, 197, 42, 22, 36, 129, 141, 184, 231, 121, 198, 67, 133, 241, 114, 23, 61, 240, 89, 169, 113, 255, 207, 35, 104, 30, 236, 246, 239, 64, 58, 165, 13, 68, 158, 95, 62, 8, 200, 117, 98, 137, 84, 44, 72, 1, 25, 111, 205, 242, 139, 134, 9, 225, 228, 46, 122, 223, 178, 81, 226, 253, 157, 70, 208, 60, 215, 235, 221, 128, 116, 73, 26, 136, 59, 190, 124, 16, 143, 234, 196, 17, 168, 88, 144, 2, 50, 222, 153, 227, 21, 11, 18, 193, 199, 92, 244, 189, 99, 162, 195, 249, 57, 140, 159, 120, 173, 213, 185, 256, 232, 146, 52, 15, 118, 123, 248, 32, 29, 211, 135, 34, 79, 176, 31, 4, 100, 187, 49, 197, 42, 22, 36, 129, 141, 184, 231, 121, 198, 67, 133, 241, 114, 23, 61, 240, 89, 169, 113, 255, 207, 35, 104, 30, 236, 246, 239, 64, 58, 165, 13, 68, 158, 95, 62, 8, 200, 117, 98, 137, 84, 44, 72, 1],
-[1, 26, 162, 100, 30, 9, 234, 173, 129, 13, 81, 50, 15, 133, 117, 215, 193, 135, 169, 25, 136, 195, 187, 236, 225, 196, 213, 141, 68, 226, 222, 118, 241, 98, 235, 199, 34, 113, 111, 59, 249, 49, 246, 228, 17, 185, 184, 158, 253, 153, 123, 114, 137, 221, 92, 79, 255, 205, 190, 57, 197, 239, 46, 168, 256, 231, 95, 157, 227, 248, 23, 84, 128, 244, 176, 207, 242, 124, 140, 42, 64, 122, 88, 232, 121, 62, 70, 21, 32, 61, 44, 116, 189, 31, 35, 139, 16, 159, 22, 58, 223, 144, 146, 198, 8, 208, 11, 29, 240, 72, 73, 99, 4, 104, 134, 143, 120, 36, 165, 178, 2, 52, 67, 200, 60, 18, 211, 89, 1, 26, 162, 100, 30, 9, 234, 173, 129, 13, 81, 50, 15, 133, 117, 215, 193, 135, 169, 25, 136, 195, 187, 236, 225, 196, 213, 141, 68, 226, 222, 118, 241, 98, 235, 199, 34, 113, 111, 59, 249, 49, 246, 228, 17, 185, 184, 158, 253, 153, 123, 114, 137, 221, 92, 79, 255, 205, 190, 57, 197, 239, 46, 168, 256, 231, 95, 157, 227, 248, 23, 84, 128, 244, 176, 207, 242, 124, 140, 42, 64, 122, 88, 232, 121, 62, 70, 21, 32, 61, 44, 116, 189, 31, 35, 139, 16, 159, 22, 58, 223, 144, 146, 198, 8, 208, 11, 29, 240, 72, 73, 99, 4, 104, 134, 143, 120, 36, 165, 178, 2, 52, 67, 200, 60, 18, 211, 89, 1],
-[1, 27, 215, 151, 222, 83, 185, 112, 197, 179, 207, 192, 44, 160, 208, 219, 2, 54, 173, 45, 187, 166, 113, 224, 137, 101, 157, 127, 88, 63, 159, 181, 4, 108, 89, 90, 117, 75, 226, 191, 17, 202, 57, 254, 176, 126, 61, 105, 8, 216, 178, 180, 234, 150, 195, 125, 34, 147, 114, 251, 95, 252, 122, 210, 16, 175, 99, 103, 211, 43, 133, 250, 68, 37, 228, 245, 190, 247, 244, 163, 32, 93, 198, 206, 165, 86, 9, 243, 136, 74, 199, 233, 123, 237, 231, 69, 64, 186, 139, 155, 73, 172, 18, 229, 15, 148, 141, 209, 246, 217, 205, 138, 128, 115, 21, 53, 146, 87, 36, 201, 30, 39, 25, 161, 235, 177, 153, 19, 256, 230, 42, 106, 35, 174, 72, 145, 60, 78, 50, 65, 213, 97, 49, 38, 255, 203, 84, 212, 70, 91, 144, 33, 120, 156, 100, 130, 169, 194, 98, 76, 253, 149, 168, 167, 140, 182, 31, 66, 240, 55, 200, 3, 81, 131, 196, 152, 249, 41, 79, 77, 23, 107, 62, 132, 223, 110, 143, 6, 162, 5, 135, 47, 241, 82, 158, 154, 46, 214, 124, 7, 189, 220, 29, 12, 67, 10, 13, 94, 225, 164, 59, 51, 92, 171, 248, 14, 121, 183, 58, 24, 134, 20, 26, 188, 193, 71, 118, 102, 184, 85, 239, 28, 242, 109, 116, 48, 11, 40, 52, 119, 129, 142, 236, 204, 111, 170, 221, 56, 227, 218, 232, 96, 22, 80, 104, 238, 1],
-[1, 28, 13, 107, 169, 106, 141, 93, 34, 181, 185, 40, 92, 6, 168, 78, 128, 243, 122, 75, 44, 204, 58, 82, 240, 38, 36, 237, 211, 254, 173, 218, 193, 7, 196, 91, 235, 155, 228, 216, 137, 238, 239, 10, 23, 130, 42, 148, 32, 125, 159, 83, 11, 51, 143, 149, 60, 138, 9, 252, 117, 192, 236, 183, 241, 66, 49, 87, 123, 103, 57, 54, 227, 188, 124, 131, 70, 161, 139, 37, 8, 224, 104, 85, 67, 77, 100, 230, 15, 163, 195, 63, 222, 48, 59, 110, 253, 145, 205, 86, 95, 90, 207, 142, 121, 47, 31, 97, 146, 233, 99, 202, 2, 56, 26, 214, 81, 212, 25, 186, 68, 105, 113, 80, 184, 12, 79, 156, 256, 229, 244, 150, 88, 151, 116, 164, 223, 76, 72, 217, 165, 251, 89, 179, 129, 14, 135, 182, 213, 53, 199, 175, 17, 219, 221, 20, 46, 3, 84, 39, 64, 250, 61, 166, 22, 102, 29, 41, 120, 19, 18, 247, 234, 127, 215, 109, 225, 132, 98, 174, 246, 206, 114, 108, 197, 119, 248, 5, 140, 65, 21, 74, 16, 191, 208, 170, 134, 154, 200, 203, 30, 69, 133, 126, 187, 96, 118, 220, 249, 33, 153, 172, 190, 180, 157, 27, 242, 94, 62, 194, 35, 209, 198, 147, 4, 112, 52, 171, 162, 167, 50, 115, 136, 210, 226, 160, 111, 24, 158, 55, 255, 201, 231, 43, 176, 45, 232, 71, 189, 152, 144, 177, 73, 245, 178, 101, 1],
-[1, 29, 70, 231, 17, 236, 162, 72, 32, 157, 184, 196, 30, 99, 44, 248, 253, 141, 234, 104, 189, 84, 123, 226, 129, 143, 35, 244, 137, 118, 81, 36, 16, 207, 92, 98, 15, 178, 22, 124, 255, 199, 117, 52, 223, 42, 190, 113, 193, 200, 146, 122, 197, 59, 169, 18, 8, 232, 46, 49, 136, 89, 11, 62, 256, 228, 187, 26, 240, 21, 95, 185, 225, 100, 73, 61, 227, 158, 213, 9, 4, 116, 23, 153, 68, 173, 134, 31, 128, 114, 222, 13, 120, 139, 176, 221, 241, 50, 165, 159, 242, 79, 235, 133, 2, 58, 140, 205, 34, 215, 67, 144, 64, 57, 111, 135, 60, 198, 88, 239, 249, 25, 211, 208, 121, 168, 246, 195, 1, 29, 70, 231, 17, 236, 162, 72, 32, 157, 184, 196, 30, 99, 44, 248, 253, 141, 234, 104, 189, 84, 123, 226, 129, 143, 35, 244, 137, 118, 81, 36, 16, 207, 92, 98, 15, 178, 22, 124, 255, 199, 117, 52, 223, 42, 190, 113, 193, 200, 146, 122, 197, 59, 169, 18, 8, 232, 46, 49, 136, 89, 11, 62, 256, 228, 187, 26, 240, 21, 95, 185, 225, 100, 73, 61, 227, 158, 213, 9, 4, 116, 23, 153, 68, 173, 134, 31, 128, 114, 222, 13, 120, 139, 176, 221, 241, 50, 165, 159, 242, 79, 235, 133, 2, 58, 140, 205, 34, 215, 67, 144, 64, 57, 111, 135, 60, 198, 88, 239, 249, 25, 211, 208, 121, 168, 246, 195, 1],
-[1, 30, 129, 15, 193, 136, 225, 68, 241, 34, 249, 17, 253, 137, 255, 197, 256, 227, 128, 242, 64, 121, 32, 189, 16, 223, 8, 240, 4, 120, 2, 60, 1, 30, 129, 15, 193, 136, 225, 68, 241, 34, 249, 17, 253, 137, 255, 197, 256, 227, 128, 242, 64, 121, 32, 189, 16, 223, 8, 240, 4, 120, 2, 60, 1, 30, 129, 15, 193, 136, 225, 68, 241, 34, 249, 17, 253, 137, 255, 197, 256, 227, 128, 242, 64, 121, 32, 189, 16, 223, 8, 240, 4, 120, 2, 60, 1, 30, 129, 15, 193, 136, 225, 68, 241, 34, 249, 17, 253, 137, 255, 197, 256, 227, 128, 242, 64, 121, 32, 189, 16, 223, 8, 240, 4, 120, 2, 60, 1, 30, 129, 15, 193, 136, 225, 68, 241, 34, 249, 17, 253, 137, 255, 197, 256, 227, 128, 242, 64, 121, 32, 189, 16, 223, 8, 240, 4, 120, 2, 60, 1, 30, 129, 15, 193, 136, 225, 68, 241, 34, 249, 17, 253, 137, 255, 197, 256, 227, 128, 242, 64, 121, 32, 189, 16, 223, 8, 240, 4, 120, 2, 60, 1, 30, 129, 15, 193, 136, 225, 68, 241, 34, 249, 17, 253, 137, 255, 197, 256, 227, 128, 242, 64, 121, 32, 189, 16, 223, 8, 240, 4, 120, 2, 60, 1, 30, 129, 15, 193, 136, 225, 68, 241, 34, 249, 17, 253, 137, 255, 197, 256, 227, 128, 242, 64, 121, 32, 189, 16, 223, 8, 240, 4, 120, 2, 60, 1],
-[1, 31, 190, 236, 120, 122, 184, 50, 8, 248, 235, 89, 189, 205, 187, 143, 64, 185, 81, 198, 227, 98, 211, 116, 255, 195, 134, 42, 17, 13, 146, 157, 241, 18, 44, 79, 136, 104, 140, 228, 129, 144, 95, 118, 60, 61, 92, 25, 4, 124, 246, 173, 223, 231, 222, 200, 32, 221, 169, 99, 242, 49, 234, 58, 256, 226, 67, 21, 137, 135, 73, 207, 249, 9, 22, 168, 68, 52, 70, 114, 193, 72, 176, 59, 30, 159, 46, 141, 2, 62, 123, 215, 240, 244, 111, 100, 16, 239, 213, 178, 121, 153, 117, 29, 128, 113, 162, 139, 197, 196, 165, 232, 253, 133, 11, 84, 34, 26, 35, 57, 225, 36, 88, 158, 15, 208, 23, 199, 1, 31, 190, 236, 120, 122, 184, 50, 8, 248, 235, 89, 189, 205, 187, 143, 64, 185, 81, 198, 227, 98, 211, 116, 255, 195, 134, 42, 17, 13, 146, 157, 241, 18, 44, 79, 136, 104, 140, 228, 129, 144, 95, 118, 60, 61, 92, 25, 4, 124, 246, 173, 223, 231, 222, 200, 32, 221, 169, 99, 242, 49, 234, 58, 256, 226, 67, 21, 137, 135, 73, 207, 249, 9, 22, 168, 68, 52, 70, 114, 193, 72, 176, 59, 30, 159, 46, 141, 2, 62, 123, 215, 240, 244, 111, 100, 16, 239, 213, 178, 121, 153, 117, 29, 128, 113, 162, 139, 197, 196, 165, 232, 253, 133, 11, 84, 34, 26, 35, 57, 225, 36, 88, 158, 15, 208, 23, 199, 1],
-[1, 32, 253, 129, 16, 255, 193, 8, 256, 225, 4, 128, 241, 2, 64, 249, 1, 32, 253, 129, 16, 255, 193, 8, 256, 225, 4, 128, 241, 2, 64, 249, 1, 32, 253, 129, 16, 255, 193, 8, 256, 225, 4, 128, 241, 2, 64, 249, 1, 32, 253, 129, 16, 255, 193, 8, 256, 225, 4, 128, 241, 2, 64, 249, 1, 32, 253, 129, 16, 255, 193, 8, 256, 225, 4, 128, 241, 2, 64, 249, 1, 32, 253, 129, 16, 255, 193, 8, 256, 225, 4, 128, 241, 2, 64, 249, 1, 32, 253, 129, 16, 255, 193, 8, 256, 225, 4, 128, 241, 2, 64, 249, 1, 32, 253, 129, 16, 255, 193, 8, 256, 225, 4, 128, 241, 2, 64, 249, 1, 32, 253, 129, 16, 255, 193, 8, 256, 225, 4, 128, 241, 2, 64, 249, 1, 32, 253, 129, 16, 255, 193, 8, 256, 225, 4, 128, 241, 2, 64, 249, 1, 32, 253, 129, 16, 255, 193, 8, 256, 225, 4, 128, 241, 2, 64, 249, 1, 32, 253, 129, 16, 255, 193, 8, 256, 225, 4, 128, 241, 2, 64, 249, 1, 32, 253, 129, 16, 255, 193, 8, 256, 225, 4, 128, 241, 2, 64, 249, 1, 32, 253, 129, 16, 255, 193, 8, 256, 225, 4, 128, 241, 2, 64, 249, 1, 32, 253, 129, 16, 255, 193, 8, 256, 225, 4, 128, 241, 2, 64, 249, 1, 32, 253, 129, 16, 255, 193, 8, 256, 225, 4, 128, 241, 2, 64, 249, 1],
-[1, 33, 61, 214, 123, 204, 50, 108, 223, 163, 239, 177, 187, 3, 99, 183, 128, 112, 98, 150, 67, 155, 232, 203, 17, 47, 9, 40, 35, 127, 79, 37, 193, 201, 208, 182, 95, 51, 141, 27, 120, 105, 124, 237, 111, 65, 89, 110, 32, 28, 153, 166, 81, 103, 58, 115, 197, 76, 195, 10, 73, 96, 84, 202, 241, 243, 52, 174, 88, 77, 228, 71, 30, 219, 31, 252, 92, 209, 215, 156, 8, 7, 231, 170, 213, 90, 143, 93, 242, 19, 113, 131, 211, 24, 21, 179, 253, 125, 13, 172, 22, 212, 57, 82, 136, 119, 72, 63, 23, 245, 118, 39, 2, 66, 122, 171, 246, 151, 100, 216, 189, 69, 221, 97, 117, 6, 198, 109, 256, 224, 196, 43, 134, 53, 207, 149, 34, 94, 18, 80, 70, 254, 158, 74, 129, 145, 159, 107, 190, 102, 25, 54, 240, 210, 248, 217, 222, 130, 178, 220, 64, 56, 49, 75, 162, 206, 116, 230, 137, 152, 133, 20, 146, 192, 168, 147, 225, 229, 104, 91, 176, 154, 199, 142, 60, 181, 62, 247, 184, 161, 173, 55, 16, 14, 205, 83, 169, 180, 29, 186, 227, 38, 226, 5, 165, 48, 42, 101, 249, 250, 26, 87, 44, 167, 114, 164, 15, 238, 144, 126, 46, 233, 236, 78, 4, 132, 244, 85, 235, 45, 200, 175, 121, 138, 185, 194, 234, 12, 139, 218, 255, 191, 135, 86, 11, 106, 157, 41, 68, 188, 36, 160, 140, 251, 59, 148, 1],
-[1, 34, 128, 240, 193, 137, 32, 60, 241, 227, 8, 15, 253, 121, 2, 68, 256, 223, 129, 17, 64, 120, 225, 197, 16, 30, 249, 242, 4, 136, 255, 189, 1, 34, 128, 240, 193, 137, 32, 60, 241, 227, 8, 15, 253, 121, 2, 68, 256, 223, 129, 17, 64, 120, 225, 197, 16, 30, 249, 242, 4, 136, 255, 189, 1, 34, 128, 240, 193, 137, 32, 60, 241, 227, 8, 15, 253, 121, 2, 68, 256, 223, 129, 17, 64, 120, 225, 197, 16, 30, 249, 242, 4, 136, 255, 189, 1, 34, 128, 240, 193, 137, 32, 60, 241, 227, 8, 15, 253, 121, 2, 68, 256, 223, 129, 17, 64, 120, 225, 197, 16, 30, 249, 242, 4, 136, 255, 189, 1, 34, 128, 240, 193, 137, 32, 60, 241, 227, 8, 15, 253, 121, 2, 68, 256, 223, 129, 17, 64, 120, 225, 197, 16, 30, 249, 242, 4, 136, 255, 189, 1, 34, 128, 240, 193, 137, 32, 60, 241, 227, 8, 15, 253, 121, 2, 68, 256, 223, 129, 17, 64, 120, 225, 197, 16, 30, 249, 242, 4, 136, 255, 189, 1, 34, 128, 240, 193, 137, 32, 60, 241, 227, 8, 15, 253, 121, 2, 68, 256, 223, 129, 17, 64, 120, 225, 197, 16, 30, 249, 242, 4, 136, 255, 189, 1, 34, 128, 240, 193, 137, 32, 60, 241, 227, 8, 15, 253, 121, 2, 68, 256, 223, 129, 17, 64, 120, 225, 197, 16, 30, 249, 242, 4, 136, 255, 189, 1],
-[1, 35, 197, 213, 2, 70, 137, 169, 4, 140, 17, 81, 8, 23, 34, 162, 16, 46, 68, 67, 32, 92, 136, 134, 64, 184, 15, 11, 128, 111, 30, 22, 256, 222, 60, 44, 255, 187, 120, 88, 253, 117, 240, 176, 249, 234, 223, 95, 241, 211, 189, 190, 225, 165, 121, 123, 193, 73, 242, 246, 129, 146, 227, 235, 1, 35, 197, 213, 2, 70, 137, 169, 4, 140, 17, 81, 8, 23, 34, 162, 16, 46, 68, 67, 32, 92, 136, 134, 64, 184, 15, 11, 128, 111, 30, 22, 256, 222, 60, 44, 255, 187, 120, 88, 253, 117, 240, 176, 249, 234, 223, 95, 241, 211, 189, 190, 225, 165, 121, 123, 193, 73, 242, 246, 129, 146, 227, 235, 1, 35, 197, 213, 2, 70, 137, 169, 4, 140, 17, 81, 8, 23, 34, 162, 16, 46, 68, 67, 32, 92, 136, 134, 64, 184, 15, 11, 128, 111, 30, 22, 256, 222, 60, 44, 255, 187, 120, 88, 253, 117, 240, 176, 249, 234, 223, 95, 241, 211, 189, 190, 225, 165, 121, 123, 193, 73, 242, 246, 129, 146, 227, 235, 1, 35, 197, 213, 2, 70, 137, 169, 4, 140, 17, 81, 8, 23, 34, 162, 16, 46, 68, 67, 32, 92, 136, 134, 64, 184, 15, 11, 128, 111, 30, 22, 256, 222, 60, 44, 255, 187, 120, 88, 253, 117, 240, 176, 249, 234, 223, 95, 241, 211, 189, 190, 225, 165, 121, 123, 193, 73, 242, 246, 129, 146, 227, 235, 1],
-[1, 36, 11, 139, 121, 244, 46, 114, 249, 226, 169, 173, 60, 104, 146, 116, 64, 248, 190, 158, 34, 196, 117, 100, 2, 72, 22, 21, 242, 231, 92, 228, 241, 195, 81, 89, 120, 208, 35, 232, 128, 239, 123, 59, 68, 135, 234, 200, 4, 144, 44, 42, 227, 205, 184, 199, 225, 133, 162, 178, 240, 159, 70, 207, 256, 221, 246, 118, 136, 13, 211, 143, 8, 31, 88, 84, 197, 153, 111, 141, 193, 9, 67, 99, 223, 61, 140, 157, 255, 185, 235, 236, 15, 26, 165, 29, 16, 62, 176, 168, 137, 49, 222, 25, 129, 18, 134, 198, 189, 122, 23, 57, 253, 113, 213, 215, 30, 52, 73, 58, 32, 124, 95, 79, 17, 98, 187, 50, 1, 36, 11, 139, 121, 244, 46, 114, 249, 226, 169, 173, 60, 104, 146, 116, 64, 248, 190, 158, 34, 196, 117, 100, 2, 72, 22, 21, 242, 231, 92, 228, 241, 195, 81, 89, 120, 208, 35, 232, 128, 239, 123, 59, 68, 135, 234, 200, 4, 144, 44, 42, 227, 205, 184, 199, 225, 133, 162, 178, 240, 159, 70, 207, 256, 221, 246, 118, 136, 13, 211, 143, 8, 31, 88, 84, 197, 153, 111, 141, 193, 9, 67, 99, 223, 61, 140, 157, 255, 185, 235, 236, 15, 26, 165, 29, 16, 62, 176, 168, 137, 49, 222, 25, 129, 18, 134, 198, 189, 122, 23, 57, 253, 113, 213, 215, 30, 52, 73, 58, 32, 124, 95, 79, 17, 98, 187, 50, 1],
-[1, 37, 84, 24, 117, 217, 62, 238, 68, 203, 58, 90, 246, 107, 104, 250, 255, 183, 89, 209, 23, 80, 133, 38, 121, 108, 141, 77, 22, 43, 49, 14, 4, 148, 79, 96, 211, 97, 248, 181, 15, 41, 232, 103, 213, 171, 159, 229, 249, 218, 99, 65, 92, 63, 18, 152, 227, 175, 50, 51, 88, 172, 196, 56, 16, 78, 59, 127, 73, 131, 221, 210, 60, 164, 157, 155, 81, 170, 122, 145, 225, 101, 139, 3, 111, 252, 72, 94, 137, 186, 200, 204, 95, 174, 13, 224, 64, 55, 236, 251, 35, 10, 113, 69, 240, 142, 114, 106, 67, 166, 231, 66, 129, 147, 42, 12, 187, 237, 31, 119, 34, 230, 29, 45, 123, 182, 52, 125, 256, 220, 173, 233, 140, 40, 195, 19, 189, 54, 199, 167, 11, 150, 153, 7, 2, 74, 168, 48, 234, 177, 124, 219, 136, 149, 116, 180, 235, 214, 208, 243, 253, 109, 178, 161, 46, 160, 9, 76, 242, 216, 25, 154, 44, 86, 98, 28, 8, 39, 158, 192, 165, 194, 239, 105, 30, 82, 207, 206, 169, 85, 61, 201, 241, 179, 198, 130, 184, 126, 36, 47, 197, 93, 100, 102, 176, 87, 135, 112, 32, 156, 118, 254, 146, 5, 185, 163, 120, 71, 57, 53, 162, 83, 244, 33, 193, 202, 21, 6, 222, 247, 144, 188, 17, 115, 143, 151, 190, 91, 26, 191, 128, 110, 215, 245, 70, 20, 226, 138, 223, 27, 228, 212, 134, 75, 205, 132, 1],
-[1, 38, 159, 131, 95, 12, 199, 109, 30, 112, 144, 75, 23, 103, 59, 186, 129, 19, 208, 194, 176, 6, 228, 183, 15, 56, 72, 166, 140, 180, 158, 93, 193, 138, 104, 97, 88, 3, 114, 220, 136, 28, 36, 83, 70, 90, 79, 175, 225, 69, 52, 177, 44, 130, 57, 110, 68, 14, 18, 170, 35, 45, 168, 216, 241, 163, 26, 217, 22, 65, 157, 55, 34, 7, 9, 85, 146, 151, 84, 108, 249, 210, 13, 237, 11, 161, 207, 156, 17, 132, 133, 171, 73, 204, 42, 54, 253, 105, 135, 247, 134, 209, 232, 78, 137, 66, 195, 214, 165, 102, 21, 27, 255, 181, 196, 252, 67, 233, 116, 39, 197, 33, 226, 107, 211, 51, 139, 142, 256, 219, 98, 126, 162, 245, 58, 148, 227, 145, 113, 182, 234, 154, 198, 71, 128, 238, 49, 63, 81, 251, 29, 74, 242, 201, 185, 91, 117, 77, 99, 164, 64, 119, 153, 160, 169, 254, 143, 37, 121, 229, 221, 174, 187, 167, 178, 82, 32, 188, 205, 80, 213, 127, 200, 147, 189, 243, 239, 87, 222, 212, 89, 41, 16, 94, 231, 40, 235, 192, 100, 202, 223, 250, 248, 172, 111, 106, 173, 149, 8, 47, 244, 20, 246, 96, 50, 101, 240, 125, 124, 86, 184, 53, 215, 203, 4, 152, 122, 10, 123, 48, 25, 179, 120, 191, 62, 43, 92, 155, 236, 230, 2, 76, 61, 5, 190, 24, 141, 218, 60, 224, 31, 150, 46, 206, 118, 115, 1],
-[1, 39, 236, 209, 184, 237, 248, 163, 189, 175, 143, 180, 81, 75, 98, 224, 255, 179, 42, 96, 146, 40, 18, 188, 136, 164, 228, 154, 95, 107, 61, 66, 4, 156, 173, 65, 222, 177, 221, 138, 242, 186, 58, 206, 67, 43, 135, 125, 249, 202, 168, 127, 70, 160, 72, 238, 30, 142, 141, 102, 123, 171, 244, 7, 16, 110, 178, 3, 117, 194, 113, 38, 197, 230, 232, 53, 11, 172, 26, 243, 225, 37, 158, 251, 23, 126, 31, 181, 120, 54, 50, 151, 235, 170, 205, 28, 64, 183, 198, 12, 211, 5, 195, 152, 17, 149, 157, 212, 44, 174, 104, 201, 129, 148, 118, 233, 92, 247, 124, 210, 223, 216, 200, 90, 169, 166, 49, 112, 256, 218, 21, 48, 73, 20, 9, 94, 68, 82, 114, 77, 176, 182, 159, 33, 2, 78, 215, 161, 111, 217, 239, 69, 121, 93, 29, 103, 162, 150, 196, 191, 253, 101, 84, 192, 35, 80, 36, 119, 15, 71, 199, 51, 190, 214, 122, 132, 8, 55, 89, 130, 187, 97, 185, 19, 227, 115, 116, 155, 134, 86, 13, 250, 241, 147, 79, 254, 140, 63, 144, 219, 60, 27, 25, 204, 246, 85, 231, 14, 32, 220, 99, 6, 234, 131, 226, 76, 137, 203, 207, 106, 22, 87, 52, 229, 193, 74, 59, 245, 46, 252, 62, 105, 240, 108, 100, 45, 213, 83, 153, 56, 128, 109, 139, 24, 165, 10, 133, 47, 34, 41, 57, 167, 88, 91, 208, 145, 1],
-[1, 40, 58, 7, 23, 149, 49, 161, 15, 86, 99, 105, 88, 179, 221, 102, 225, 5, 200, 33, 35, 115, 231, 245, 34, 75, 173, 238, 11, 183, 124, 77, 253, 97, 25, 229, 165, 175, 61, 127, 197, 170, 118, 94, 162, 55, 144, 106, 128, 237, 228, 125, 117, 54, 104, 48, 121, 214, 79, 76, 213, 39, 18, 206, 16, 126, 157, 112, 111, 71, 13, 6, 240, 91, 42, 138, 123, 37, 195, 90, 2, 80, 116, 14, 46, 41, 98, 65, 30, 172, 198, 210, 176, 101, 185, 204, 193, 10, 143, 66, 70, 230, 205, 233, 68, 150, 89, 219, 22, 109, 248, 154, 249, 194, 50, 201, 73, 93, 122, 254, 137, 83, 236, 188, 67, 110, 31, 212, 256, 217, 199, 250, 234, 108, 208, 96, 242, 171, 158, 152, 169, 78, 36, 155, 32, 252, 57, 224, 222, 142, 26, 12, 223, 182, 84, 19, 246, 74, 133, 180, 4, 160, 232, 28, 92, 82, 196, 130, 60, 87, 139, 163, 95, 202, 113, 151, 129, 20, 29, 132, 140, 203, 153, 209, 136, 43, 178, 181, 44, 218, 239, 51, 241, 131, 100, 145, 146, 186, 244, 251, 17, 166, 215, 119, 134, 220, 62, 167, 255, 177, 141, 243, 211, 216, 159, 192, 227, 85, 59, 47, 81, 156, 72, 53, 64, 247, 114, 191, 187, 27, 52, 24, 189, 107, 168, 38, 235, 148, 9, 103, 8, 63, 207, 56, 184, 164, 135, 3, 120, 174, 21, 69, 190, 147, 226, 45, 1],
-[1, 41, 139, 45, 46, 87, 226, 14, 60, 147, 116, 130, 190, 80, 196, 69, 2, 82, 21, 90, 92, 174, 195, 28, 120, 37, 232, 3, 123, 160, 135, 138, 4, 164, 42, 180, 184, 91, 133, 56, 240, 74, 207, 6, 246, 63, 13, 19, 8, 71, 84, 103, 111, 182, 9, 112, 223, 148, 157, 12, 235, 126, 26, 38, 16, 142, 168, 206, 222, 107, 18, 224, 189, 39, 57, 24, 213, 252, 52, 76, 32, 27, 79, 155, 187, 214, 36, 191, 121, 78, 114, 48, 169, 247, 104, 152, 64, 54, 158, 53, 117, 171, 72, 125, 242, 156, 228, 96, 81, 237, 208, 47, 128, 108, 59, 106, 234, 85, 144, 250, 227, 55, 199, 192, 162, 217, 159, 94, 256, 216, 118, 212, 211, 170, 31, 243, 197, 110, 141, 127, 67, 177, 61, 188, 255, 175, 236, 167, 165, 83, 62, 229, 137, 220, 25, 254, 134, 97, 122, 119, 253, 93, 215, 77, 73, 166, 124, 201, 17, 183, 50, 251, 11, 194, 244, 238, 249, 186, 173, 154, 146, 75, 248, 145, 34, 109, 100, 245, 22, 131, 231, 219, 241, 115, 89, 51, 35, 150, 239, 33, 68, 218, 200, 233, 44, 5, 205, 181, 225, 230, 178, 102, 70, 43, 221, 66, 136, 179, 143, 209, 88, 10, 153, 105, 193, 203, 99, 204, 140, 86, 185, 132, 15, 101, 29, 161, 176, 20, 49, 210, 129, 149, 198, 151, 23, 172, 113, 7, 30, 202, 58, 65, 95, 40, 98, 163, 1],
-[1, 42, 222, 72, 197, 50, 44, 49, 2, 84, 187, 144, 137, 100, 88, 98, 4, 168, 117, 31, 17, 200, 176, 196, 8, 79, 234, 62, 34, 143, 95, 135, 16, 158, 211, 124, 68, 29, 190, 13, 32, 59, 165, 248, 136, 58, 123, 26, 64, 118, 73, 239, 15, 116, 246, 52, 128, 236, 146, 221, 30, 232, 235, 104, 256, 215, 35, 185, 60, 207, 213, 208, 255, 173, 70, 113, 120, 157, 169, 159, 253, 89, 140, 226, 240, 57, 81, 61, 249, 178, 23, 195, 223, 114, 162, 122, 241, 99, 46, 133, 189, 228, 67, 244, 225, 198, 92, 9, 121, 199, 134, 231, 193, 139, 184, 18, 242, 141, 11, 205, 129, 21, 111, 36, 227, 25, 22, 153, 1, 42, 222, 72, 197, 50, 44, 49, 2, 84, 187, 144, 137, 100, 88, 98, 4, 168, 117, 31, 17, 200, 176, 196, 8, 79, 234, 62, 34, 143, 95, 135, 16, 158, 211, 124, 68, 29, 190, 13, 32, 59, 165, 248, 136, 58, 123, 26, 64, 118, 73, 239, 15, 116, 246, 52, 128, 236, 146, 221, 30, 232, 235, 104, 256, 215, 35, 185, 60, 207, 213, 208, 255, 173, 70, 113, 120, 157, 169, 159, 253, 89, 140, 226, 240, 57, 81, 61, 249, 178, 23, 195, 223, 114, 162, 122, 241, 99, 46, 133, 189, 228, 67, 244, 225, 198, 92, 9, 121, 199, 134, 231, 193, 139, 184, 18, 242, 141, 11, 205, 129, 21, 111, 36, 227, 25, 22, 153, 1],
-[1, 43, 50, 94, 187, 74, 98, 102, 17, 217, 79, 56, 95, 230, 124, 192, 32, 91, 58, 181, 73, 55, 52, 180, 30, 5, 215, 250, 213, 164, 113, 233, 253, 85, 57, 138, 23, 218, 122, 106, 189, 160, 198, 33, 134, 108, 18, 3, 129, 150, 25, 47, 222, 37, 49, 51, 137, 237, 168, 28, 176, 115, 62, 96, 16, 174, 29, 219, 165, 156, 26, 90, 15, 131, 236, 125, 235, 82, 185, 245, 255, 171, 157, 69, 140, 109, 61, 53, 223, 80, 99, 145, 67, 54, 9, 130, 193, 75, 141, 152, 111, 147, 153, 154, 197, 247, 84, 14, 88, 186, 31, 48, 8, 87, 143, 238, 211, 78, 13, 45, 136, 194, 118, 191, 246, 41, 221, 251, 256, 214, 207, 163, 70, 183, 159, 155, 240, 40, 178, 201, 162, 27, 133, 65, 225, 166, 199, 76, 184, 202, 205, 77, 227, 252, 42, 7, 44, 93, 144, 24, 4, 172, 200, 119, 234, 39, 135, 151, 68, 97, 59, 224, 123, 149, 239, 254, 128, 107, 232, 210, 35, 220, 208, 206, 120, 20, 89, 229, 81, 142, 195, 161, 241, 83, 228, 38, 92, 101, 231, 167, 242, 126, 21, 132, 22, 175, 72, 12, 2, 86, 100, 188, 117, 148, 196, 204, 34, 177, 158, 112, 190, 203, 248, 127, 64, 182, 116, 105, 146, 110, 104, 103, 60, 10, 173, 243, 169, 71, 226, 209, 249, 170, 114, 19, 46, 179, 244, 212, 121, 63, 139, 66, 11, 216, 36, 6, 1],
-[1, 44, 137, 117, 8, 95, 68, 165, 64, 246, 30, 35, 255, 169, 240, 23, 241, 67, 121, 184, 129, 22, 197, 187, 4, 176, 34, 211, 32, 123, 15, 146, 256, 213, 120, 140, 249, 162, 189, 92, 193, 11, 227, 222, 2, 88, 17, 234, 16, 190, 136, 73, 128, 235, 60, 70, 253, 81, 223, 46, 225, 134, 242, 111, 1, 44, 137, 117, 8, 95, 68, 165, 64, 246, 30, 35, 255, 169, 240, 23, 241, 67, 121, 184, 129, 22, 197, 187, 4, 176, 34, 211, 32, 123, 15, 146, 256, 213, 120, 140, 249, 162, 189, 92, 193, 11, 227, 222, 2, 88, 17, 234, 16, 190, 136, 73, 128, 235, 60, 70, 253, 81, 223, 46, 225, 134, 242, 111, 1, 44, 137, 117, 8, 95, 68, 165, 64, 246, 30, 35, 255, 169, 240, 23, 241, 67, 121, 184, 129, 22, 197, 187, 4, 176, 34, 211, 32, 123, 15, 146, 256, 213, 120, 140, 249, 162, 189, 92, 193, 11, 227, 222, 2, 88, 17, 234, 16, 190, 136, 73, 128, 235, 60, 70, 253, 81, 223, 46, 225, 134, 242, 111, 1, 44, 137, 117, 8, 95, 68, 165, 64, 246, 30, 35, 255, 169, 240, 23, 241, 67, 121, 184, 129, 22, 197, 187, 4, 176, 34, 211, 32, 123, 15, 146, 256, 213, 120, 140, 249, 162, 189, 92, 193, 11, 227, 222, 2, 88, 17, 234, 16, 190, 136, 73, 128, 235, 60, 70, 253, 81, 223, 46, 225, 134, 242, 111, 1],
-[1, 45, 226, 147, 190, 69, 21, 174, 120, 3, 135, 164, 184, 56, 207, 63, 8, 103, 9, 148, 235, 38, 168, 107, 189, 24, 52, 27, 187, 191, 114, 247, 64, 53, 72, 156, 81, 47, 59, 85, 227, 192, 159, 216, 211, 243, 141, 177, 255, 167, 62, 220, 134, 119, 215, 166, 17, 251, 244, 186, 146, 145, 100, 131, 241, 51, 239, 218, 44, 181, 178, 43, 136, 209, 153, 203, 140, 132, 29, 20, 129, 151, 113, 202, 95, 163, 139, 87, 60, 130, 196, 82, 92, 28, 232, 160, 4, 180, 133, 74, 246, 19, 84, 182, 223, 12, 26, 142, 222, 224, 57, 252, 32, 155, 36, 78, 169, 152, 158, 171, 242, 96, 208, 108, 234, 250, 199, 217, 256, 212, 31, 110, 67, 188, 236, 83, 137, 254, 122, 93, 73, 201, 50, 194, 249, 154, 248, 109, 22, 219, 89, 150, 68, 233, 205, 230, 70, 66, 143, 10, 193, 204, 185, 101, 176, 210, 198, 172, 30, 65, 98, 41, 46, 14, 116, 80, 2, 90, 195, 37, 123, 138, 42, 91, 240, 6, 13, 71, 111, 112, 157, 126, 16, 206, 18, 39, 213, 76, 79, 214, 121, 48, 104, 54, 117, 125, 228, 237, 128, 106, 144, 55, 162, 94, 118, 170, 197, 127, 61, 175, 165, 229, 25, 97, 253, 77, 124, 183, 11, 238, 173, 75, 34, 245, 231, 115, 35, 33, 200, 5, 225, 102, 221, 179, 88, 105, 99, 86, 15, 161, 49, 149, 23, 7, 58, 40, 1],
-[1, 46, 60, 190, 2, 92, 120, 123, 4, 184, 240, 246, 8, 111, 223, 235, 16, 222, 189, 213, 32, 187, 121, 169, 64, 117, 242, 81, 128, 234, 227, 162, 256, 211, 197, 67, 255, 165, 137, 134, 253, 73, 17, 11, 249, 146, 34, 22, 241, 35, 68, 44, 225, 70, 136, 88, 193, 140, 15, 176, 129, 23, 30, 95, 1, 46, 60, 190, 2, 92, 120, 123, 4, 184, 240, 246, 8, 111, 223, 235, 16, 222, 189, 213, 32, 187, 121, 169, 64, 117, 242, 81, 128, 234, 227, 162, 256, 211, 197, 67, 255, 165, 137, 134, 253, 73, 17, 11, 249, 146, 34, 22, 241, 35, 68, 44, 225, 70, 136, 88, 193, 140, 15, 176, 129, 23, 30, 95, 1, 46, 60, 190, 2, 92, 120, 123, 4, 184, 240, 246, 8, 111, 223, 235, 16, 222, 189, 213, 32, 187, 121, 169, 64, 117, 242, 81, 128, 234, 227, 162, 256, 211, 197, 67, 255, 165, 137, 134, 253, 73, 17, 11, 249, 146, 34, 22, 241, 35, 68, 44, 225, 70, 136, 88, 193, 140, 15, 176, 129, 23, 30, 95, 1, 46, 60, 190, 2, 92, 120, 123, 4, 184, 240, 246, 8, 111, 223, 235, 16, 222, 189, 213, 32, 187, 121, 169, 64, 117, 242, 81, 128, 234, 227, 162, 256, 211, 197, 67, 255, 165, 137, 134, 253, 73, 17, 11, 249, 146, 34, 22, 241, 35, 68, 44, 225, 70, 136, 88, 193, 140, 15, 176, 129, 23, 30, 95, 1],
-[1, 47, 153, 252, 22, 6, 25, 147, 227, 132, 36, 150, 111, 77, 21, 216, 129, 152, 205, 126, 11, 3, 141, 202, 242, 66, 18, 75, 184, 167, 139, 108, 193, 76, 231, 63, 134, 130, 199, 101, 121, 33, 9, 166, 92, 212, 198, 54, 225, 38, 244, 160, 67, 65, 228, 179, 189, 145, 133, 83, 46, 106, 99, 27, 241, 19, 122, 80, 162, 161, 114, 218, 223, 201, 195, 170, 23, 53, 178, 142, 249, 138, 61, 40, 81, 209, 57, 109, 240, 229, 226, 85, 140, 155, 89, 71, 253, 69, 159, 20, 169, 233, 157, 183, 120, 243, 113, 171, 70, 206, 173, 164, 255, 163, 208, 10, 213, 245, 207, 220, 60, 250, 185, 214, 35, 103, 215, 82, 256, 210, 104, 5, 235, 251, 232, 110, 30, 125, 221, 107, 146, 180, 236, 41, 128, 105, 52, 131, 246, 254, 116, 55, 15, 191, 239, 182, 73, 90, 118, 149, 64, 181, 26, 194, 123, 127, 58, 156, 136, 224, 248, 91, 165, 45, 59, 203, 32, 219, 13, 97, 190, 192, 29, 78, 68, 112, 124, 174, 211, 151, 158, 230, 16, 238, 135, 177, 95, 96, 143, 39, 34, 56, 62, 87, 234, 204, 79, 115, 8, 119, 196, 217, 176, 48, 200, 148, 17, 28, 31, 172, 117, 102, 168, 186, 4, 188, 98, 237, 88, 24, 100, 74, 137, 14, 144, 86, 187, 51, 84, 93, 2, 94, 49, 247, 44, 12, 50, 37, 197, 7, 72, 43, 222, 154, 42, 175, 1],
-[1, 48, 248, 82, 81, 33, 42, 217, 136, 103, 61, 101, 222, 119, 58, 214, 249, 130, 72, 115, 123, 250, 178, 63, 197, 204, 26, 220, 23, 76, 50, 87, 64, 245, 195, 108, 44, 56, 118, 10, 223, 167, 49, 39, 73, 163, 114, 75, 2, 96, 239, 164, 162, 66, 84, 177, 15, 206, 122, 202, 187, 238, 116, 171, 241, 3, 144, 230, 246, 243, 99, 126, 137, 151, 52, 183, 46, 152, 100, 174, 128, 233, 133, 216, 88, 112, 236, 20, 189, 77, 98, 78, 146, 69, 228, 150, 4, 192, 221, 71, 67, 132, 168, 97, 30, 155, 244, 147, 117, 219, 232, 85, 225, 6, 31, 203, 235, 229, 198, 252, 17, 45, 104, 109, 92, 47, 200, 91, 256, 209, 9, 175, 176, 224, 215, 40, 121, 154, 196, 156, 35, 138, 199, 43, 8, 127, 185, 142, 134, 7, 79, 194, 60, 53, 231, 37, 234, 181, 207, 170, 193, 12, 62, 149, 213, 201, 139, 247, 34, 90, 208, 218, 184, 94, 143, 182, 255, 161, 18, 93, 95, 191, 173, 80, 242, 51, 135, 55, 70, 19, 141, 86, 16, 254, 113, 27, 11, 14, 158, 131, 120, 106, 205, 74, 211, 105, 157, 83, 129, 24, 124, 41, 169, 145, 21, 237, 68, 180, 159, 179, 111, 188, 29, 107, 253, 65, 36, 186, 190, 125, 89, 160, 227, 102, 13, 110, 140, 38, 25, 172, 32, 251, 226, 54, 22, 28, 59, 5, 240, 212, 153, 148, 165, 210, 57, 166, 1],
-[1, 49, 88, 200, 34, 124, 165, 118, 128, 104, 213, 157, 240, 195, 46, 198, 193, 205, 22, 50, 137, 31, 234, 158, 32, 26, 246, 232, 60, 113, 140, 178, 241, 244, 134, 141, 227, 72, 187, 168, 8, 135, 190, 58, 15, 221, 35, 173, 253, 61, 162, 228, 121, 18, 111, 42, 2, 98, 176, 143, 68, 248, 73, 236, 256, 208, 169, 57, 223, 133, 92, 139, 129, 153, 44, 100, 17, 62, 211, 59, 64, 52, 235, 207, 120, 226, 23, 99, 225, 231, 11, 25, 197, 144, 117, 79, 16, 13, 123, 116, 30, 185, 70, 89, 249, 122, 67, 199, 242, 36, 222, 84, 4, 196, 95, 29, 136, 239, 146, 215, 255, 159, 81, 114, 189, 9, 184, 21, 1, 49, 88, 200, 34, 124, 165, 118, 128, 104, 213, 157, 240, 195, 46, 198, 193, 205, 22, 50, 137, 31, 234, 158, 32, 26, 246, 232, 60, 113, 140, 178, 241, 244, 134, 141, 227, 72, 187, 168, 8, 135, 190, 58, 15, 221, 35, 173, 253, 61, 162, 228, 121, 18, 111, 42, 2, 98, 176, 143, 68, 248, 73, 236, 256, 208, 169, 57, 223, 133, 92, 139, 129, 153, 44, 100, 17, 62, 211, 59, 64, 52, 235, 207, 120, 226, 23, 99, 225, 231, 11, 25, 197, 144, 117, 79, 16, 13, 123, 116, 30, 185, 70, 89, 249, 122, 67, 199, 242, 36, 222, 84, 4, 196, 95, 29, 136, 239, 146, 215, 255, 159, 81, 114, 189, 9, 184, 21, 1],
-[1, 50, 187, 98, 17, 79, 95, 124, 32, 58, 73, 52, 30, 215, 213, 113, 253, 57, 23, 122, 189, 198, 134, 18, 129, 25, 222, 49, 137, 168, 176, 62, 16, 29, 165, 26, 15, 236, 235, 185, 255, 157, 140, 61, 223, 99, 67, 9, 193, 141, 111, 153, 197, 84, 88, 31, 8, 143, 211, 13, 136, 118, 246, 221, 256, 207, 70, 159, 240, 178, 162, 133, 225, 199, 184, 205, 227, 42, 44, 144, 4, 200, 234, 135, 68, 59, 123, 239, 128, 232, 35, 208, 120, 89, 81, 195, 241, 228, 92, 231, 242, 21, 22, 72, 2, 100, 117, 196, 34, 158, 190, 248, 64, 116, 146, 104, 60, 173, 169, 226, 249, 114, 46, 244, 121, 139, 11, 36, 1, 50, 187, 98, 17, 79, 95, 124, 32, 58, 73, 52, 30, 215, 213, 113, 253, 57, 23, 122, 189, 198, 134, 18, 129, 25, 222, 49, 137, 168, 176, 62, 16, 29, 165, 26, 15, 236, 235, 185, 255, 157, 140, 61, 223, 99, 67, 9, 193, 141, 111, 153, 197, 84, 88, 31, 8, 143, 211, 13, 136, 118, 246, 221, 256, 207, 70, 159, 240, 178, 162, 133, 225, 199, 184, 205, 227, 42, 44, 144, 4, 200, 234, 135, 68, 59, 123, 239, 128, 232, 35, 208, 120, 89, 81, 195, 241, 228, 92, 231, 242, 21, 22, 72, 2, 100, 117, 196, 34, 158, 190, 248, 64, 116, 146, 104, 60, 173, 169, 226, 249, 114, 46, 244, 121, 139, 11, 36, 1],
-[1, 51, 31, 39, 190, 181, 236, 214, 120, 209, 122, 54, 184, 132, 50, 237, 8, 151, 248, 55, 235, 163, 89, 170, 189, 130, 205, 175, 187, 28, 143, 97, 64, 180, 185, 183, 81, 19, 198, 75, 227, 12, 98, 115, 211, 224, 116, 5, 255, 155, 195, 179, 134, 152, 42, 86, 17, 96, 13, 149, 146, 250, 157, 40, 241, 212, 18, 147, 44, 188, 79, 174, 136, 254, 104, 164, 140, 201, 228, 63, 129, 154, 144, 148, 95, 219, 118, 107, 60, 233, 61, 27, 92, 66, 25, 247, 4, 204, 124, 156, 246, 210, 173, 85, 223, 65, 231, 216, 222, 14, 200, 177, 32, 90, 221, 220, 169, 138, 99, 166, 242, 6, 49, 186, 234, 112, 58, 131, 256, 206, 226, 218, 67, 76, 21, 43, 137, 48, 135, 203, 73, 125, 207, 20, 249, 106, 9, 202, 22, 94, 168, 87, 68, 127, 52, 82, 70, 229, 114, 160, 193, 77, 72, 74, 176, 238, 59, 182, 30, 245, 159, 142, 46, 33, 141, 252, 2, 102, 62, 78, 123, 105, 215, 171, 240, 161, 244, 108, 111, 7, 100, 217, 16, 45, 239, 110, 213, 69, 178, 83, 121, 3, 153, 93, 117, 56, 29, 194, 128, 103, 113, 109, 162, 38, 139, 150, 197, 24, 196, 230, 165, 191, 232, 10, 253, 53, 133, 101, 11, 47, 84, 172, 34, 192, 26, 41, 35, 243, 57, 80, 225, 167, 36, 37, 88, 119, 158, 91, 15, 251, 208, 71, 23, 145, 199, 126, 1],
-[1, 52, 134, 29, 223, 31, 70, 42, 128, 231, 190, 114, 17, 113, 222, 236, 193, 13, 162, 200, 120, 72, 146, 139, 32, 122, 176, 157, 197, 221, 184, 59, 241, 196, 169, 50, 30, 18, 165, 99, 8, 159, 44, 232, 242, 248, 46, 79, 253, 49, 235, 141, 136, 133, 234, 89, 2, 104, 11, 58, 189, 62, 140, 84, 256, 205, 123, 228, 34, 226, 187, 215, 129, 26, 67, 143, 240, 144, 35, 21, 64, 244, 95, 57, 137, 185, 111, 118, 225, 135, 81, 100, 60, 36, 73, 198, 16, 61, 88, 207, 227, 239, 92, 158, 249, 98, 213, 25, 15, 9, 211, 178, 4, 208, 22, 116, 121, 124, 23, 168, 255, 153, 246, 199, 68, 195, 117, 173, 1, 52, 134, 29, 223, 31, 70, 42, 128, 231, 190, 114, 17, 113, 222, 236, 193, 13, 162, 200, 120, 72, 146, 139, 32, 122, 176, 157, 197, 221, 184, 59, 241, 196, 169, 50, 30, 18, 165, 99, 8, 159, 44, 232, 242, 248, 46, 79, 253, 49, 235, 141, 136, 133, 234, 89, 2, 104, 11, 58, 189, 62, 140, 84, 256, 205, 123, 228, 34, 226, 187, 215, 129, 26, 67, 143, 240, 144, 35, 21, 64, 244, 95, 57, 137, 185, 111, 118, 225, 135, 81, 100, 60, 36, 73, 198, 16, 61, 88, 207, 227, 239, 92, 158, 249, 98, 213, 25, 15, 9, 211, 178, 4, 208, 22, 116, 121, 124, 23, 168, 255, 153, 246, 199, 68, 195, 117, 173, 1],
-[1, 53, 239, 74, 67, 210, 79, 75, 120, 192, 153, 142, 73, 14, 228, 5, 8, 167, 113, 78, 22, 138, 118, 86, 189, 251, 196, 108, 70, 112, 25, 40, 64, 51, 133, 110, 176, 76, 173, 174, 227, 209, 26, 93, 46, 125, 200, 63, 255, 151, 36, 109, 123, 94, 99, 107, 17, 130, 208, 230, 111, 229, 58, 247, 241, 180, 31, 101, 213, 238, 21, 85, 136, 12, 122, 41, 117, 33, 207, 177, 129, 155, 248, 37, 162, 105, 168, 166, 60, 96, 205, 71, 165, 7, 114, 131, 4, 212, 185, 39, 11, 69, 59, 43, 223, 254, 98, 54, 35, 56, 141, 20, 32, 154, 195, 55, 88, 38, 215, 87, 242, 233, 13, 175, 23, 191, 100, 160, 256, 204, 18, 183, 190, 47, 178, 182, 137, 65, 104, 115, 184, 243, 29, 252, 249, 90, 144, 179, 235, 119, 139, 171, 68, 6, 61, 149, 187, 145, 232, 217, 193, 206, 124, 147, 81, 181, 84, 83, 30, 48, 231, 164, 211, 132, 57, 194, 2, 106, 221, 148, 134, 163, 158, 150, 240, 127, 49, 27, 146, 28, 199, 10, 16, 77, 226, 156, 44, 19, 236, 172, 121, 245, 135, 216, 140, 224, 50, 80, 128, 102, 9, 220, 95, 152, 89, 91, 197, 161, 52, 186, 92, 250, 143, 126, 253, 45, 72, 218, 246, 188, 198, 214, 34, 3, 159, 203, 222, 201, 116, 237, 225, 103, 62, 202, 169, 219, 42, 170, 15, 24, 244, 82, 234, 66, 157, 97, 1],
-[1, 54, 89, 180, 211, 86, 18, 201, 60, 156, 200, 6, 67, 20, 52, 238, 2, 108, 178, 103, 165, 172, 36, 145, 120, 55, 143, 12, 134, 40, 104, 219, 4, 216, 99, 206, 73, 87, 72, 33, 240, 110, 29, 24, 11, 80, 208, 181, 8, 175, 198, 155, 146, 174, 144, 66, 223, 220, 58, 48, 22, 160, 159, 105, 16, 93, 139, 53, 35, 91, 31, 132, 189, 183, 116, 96, 44, 63, 61, 210, 32, 186, 21, 106, 70, 182, 62, 7, 121, 109, 232, 192, 88, 126, 122, 163, 64, 115, 42, 212, 140, 107, 124, 14, 242, 218, 207, 127, 176, 252, 244, 69, 128, 230, 84, 167, 23, 214, 248, 28, 227, 179, 157, 254, 95, 247, 231, 138, 256, 203, 168, 77, 46, 171, 239, 56, 197, 101, 57, 251, 190, 237, 205, 19, 255, 149, 79, 154, 92, 85, 221, 112, 137, 202, 114, 245, 123, 217, 153, 38, 253, 41, 158, 51, 184, 170, 185, 224, 17, 147, 228, 233, 246, 177, 49, 76, 249, 82, 59, 102, 111, 83, 113, 191, 34, 37, 199, 209, 235, 97, 98, 152, 241, 164, 118, 204, 222, 166, 226, 125, 68, 74, 141, 161, 213, 194, 196, 47, 225, 71, 236, 151, 187, 75, 195, 250, 136, 148, 25, 65, 169, 131, 135, 94, 193, 142, 215, 45, 117, 150, 133, 243, 15, 39, 50, 130, 81, 5, 13, 188, 129, 27, 173, 90, 234, 43, 9, 229, 30, 78, 100, 3, 162, 10, 26, 119, 1],
-[1, 55, 198, 96, 140, 247, 221, 76, 68, 142, 100, 103, 11, 91, 122, 28, 255, 147, 118, 65, 234, 20, 72, 105, 121, 230, 57, 51, 235, 75, 13, 201, 4, 220, 21, 127, 46, 217, 113, 47, 15, 54, 143, 155, 44, 107, 231, 112, 249, 74, 215, 3, 165, 80, 31, 163, 227, 149, 228, 204, 169, 43, 52, 33, 16, 109, 84, 251, 184, 97, 195, 188, 60, 216, 58, 106, 176, 171, 153, 191, 225, 39, 89, 12, 146, 63, 124, 138, 137, 82, 141, 45, 162, 172, 208, 132, 64, 179, 79, 233, 222, 131, 9, 238, 240, 93, 232, 167, 190, 170, 98, 250, 129, 156, 99, 48, 70, 252, 239, 38, 34, 71, 50, 180, 134, 174, 61, 14, 256, 202, 59, 161, 117, 10, 36, 181, 189, 115, 157, 154, 246, 166, 135, 229, 2, 110, 139, 192, 23, 237, 185, 152, 136, 27, 200, 206, 22, 182, 244, 56, 253, 37, 236, 130, 211, 40, 144, 210, 242, 203, 114, 102, 213, 150, 26, 145, 8, 183, 42, 254, 92, 177, 226, 94, 30, 108, 29, 53, 88, 214, 205, 224, 241, 148, 173, 6, 73, 160, 62, 69, 197, 41, 199, 151, 81, 86, 104, 66, 32, 218, 168, 245, 111, 194, 133, 119, 120, 175, 116, 212, 95, 85, 49, 125, 193, 78, 178, 24, 35, 126, 248, 19, 17, 164, 25, 90, 67, 87, 159, 7, 128, 101, 158, 209, 187, 5, 18, 219, 223, 186, 207, 77, 123, 83, 196, 243, 1],
-[1, 56, 52, 85, 134, 51, 29, 82, 223, 152, 31, 194, 70, 65, 42, 39, 128, 229, 231, 86, 190, 103, 114, 216, 17, 181, 113, 160, 222, 96, 236, 109, 193, 14, 13, 214, 162, 77, 200, 149, 120, 38, 72, 177, 146, 209, 139, 74, 32, 250, 122, 150, 176, 90, 157, 54, 197, 238, 221, 40, 184, 24, 59, 220, 241, 132, 196, 182, 169, 212, 50, 230, 30, 138, 18, 237, 165, 245, 99, 147, 8, 191, 159, 166, 44, 151, 232, 142, 242, 188, 248, 10, 46, 6, 79, 55, 253, 33, 49, 174, 235, 53, 141, 186, 136, 163, 133, 252, 234, 254, 89, 101, 2, 112, 104, 170, 11, 102, 58, 164, 189, 47, 62, 131, 140, 130, 84, 78, 256, 201, 205, 172, 123, 206, 228, 175, 34, 105, 226, 63, 187, 192, 215, 218, 129, 28, 26, 171, 67, 154, 143, 41, 240, 76, 144, 97, 35, 161, 21, 148, 64, 243, 244, 43, 95, 180, 57, 108, 137, 219, 185, 80, 111, 48, 118, 183, 225, 7, 135, 107, 81, 167, 100, 203, 60, 19, 36, 217, 73, 233, 198, 37, 16, 125, 61, 75, 88, 45, 207, 27, 227, 119, 239, 20, 92, 12, 158, 110, 249, 66, 98, 91, 213, 106, 25, 115, 15, 69, 9, 247, 211, 251, 178, 202, 4, 224, 208, 83, 22, 204, 116, 71, 121, 94, 124, 5, 23, 3, 168, 156, 255, 145, 153, 87, 246, 155, 199, 93, 68, 210, 195, 126, 117, 127, 173, 179, 1],
-[1, 57, 165, 153, 240, 59, 22, 226, 32, 25, 140, 13, 227, 89, 190, 36, 253, 29, 111, 159, 68, 21, 169, 124, 129, 157, 211, 205, 120, 158, 11, 113, 16, 141, 70, 135, 242, 173, 95, 18, 255, 143, 184, 208, 34, 139, 213, 62, 193, 207, 234, 231, 60, 79, 134, 185, 8, 199, 35, 196, 121, 215, 176, 9, 256, 200, 92, 104, 17, 198, 235, 31, 225, 232, 117, 244, 30, 168, 67, 221, 4, 228, 146, 98, 189, 236, 88, 133, 128, 100, 46, 52, 137, 99, 246, 144, 241, 116, 187, 122, 15, 84, 162, 239, 2, 114, 73, 49, 223, 118, 44, 195, 64, 50, 23, 26, 197, 178, 123, 72, 249, 58, 222, 61, 136, 42, 81, 248, 1, 57, 165, 153, 240, 59, 22, 226, 32, 25, 140, 13, 227, 89, 190, 36, 253, 29, 111, 159, 68, 21, 169, 124, 129, 157, 211, 205, 120, 158, 11, 113, 16, 141, 70, 135, 242, 173, 95, 18, 255, 143, 184, 208, 34, 139, 213, 62, 193, 207, 234, 231, 60, 79, 134, 185, 8, 199, 35, 196, 121, 215, 176, 9, 256, 200, 92, 104, 17, 198, 235, 31, 225, 232, 117, 244, 30, 168, 67, 221, 4, 228, 146, 98, 189, 236, 88, 133, 128, 100, 46, 52, 137, 99, 246, 144, 241, 116, 187, 122, 15, 84, 162, 239, 2, 114, 73, 49, 223, 118, 44, 195, 64, 50, 23, 26, 197, 178, 123, 72, 249, 58, 222, 61, 136, 42, 81, 248, 1],
-[1, 58, 23, 49, 15, 99, 88, 221, 225, 200, 35, 231, 34, 173, 11, 124, 253, 25, 165, 61, 197, 118, 162, 144, 128, 228, 117, 104, 121, 79, 213, 18, 16, 157, 111, 13, 240, 42, 123, 195, 2, 116, 46, 98, 30, 198, 176, 185, 193, 143, 70, 205, 68, 89, 22, 248, 249, 50, 73, 122, 137, 236, 67, 31, 256, 199, 234, 208, 242, 158, 169, 36, 32, 57, 222, 26, 223, 84, 246, 133, 4, 232, 92, 196, 60, 139, 95, 113, 129, 29, 140, 153, 136, 178, 44, 239, 241, 100, 146, 244, 17, 215, 134, 62, 255, 141, 211, 159, 227, 59, 81, 72, 64, 114, 187, 52, 189, 168, 235, 9, 8, 207, 184, 135, 120, 21, 190, 226, 1, 58, 23, 49, 15, 99, 88, 221, 225, 200, 35, 231, 34, 173, 11, 124, 253, 25, 165, 61, 197, 118, 162, 144, 128, 228, 117, 104, 121, 79, 213, 18, 16, 157, 111, 13, 240, 42, 123, 195, 2, 116, 46, 98, 30, 198, 176, 185, 193, 143, 70, 205, 68, 89, 22, 248, 249, 50, 73, 122, 137, 236, 67, 31, 256, 199, 234, 208, 242, 158, 169, 36, 32, 57, 222, 26, 223, 84, 246, 133, 4, 232, 92, 196, 60, 139, 95, 113, 129, 29, 140, 153, 136, 178, 44, 239, 241, 100, 146, 244, 17, 215, 134, 62, 255, 141, 211, 159, 227, 59, 81, 72, 64, 114, 187, 52, 189, 168, 235, 9, 8, 207, 184, 135, 120, 21, 190, 226, 1],
-[1, 59, 140, 36, 68, 157, 11, 135, 255, 139, 234, 185, 121, 200, 235, 244, 4, 236, 46, 144, 15, 114, 44, 26, 249, 42, 165, 226, 227, 29, 169, 205, 16, 173, 184, 62, 60, 199, 176, 104, 225, 168, 146, 133, 137, 116, 162, 49, 64, 178, 222, 248, 240, 25, 190, 159, 129, 158, 70, 18, 34, 207, 134, 196, 256, 198, 117, 221, 189, 100, 246, 122, 2, 118, 23, 72, 136, 57, 22, 13, 253, 21, 211, 113, 242, 143, 213, 231, 8, 215, 92, 31, 30, 228, 88, 52, 241, 84, 73, 195, 197, 58, 81, 153, 32, 89, 111, 124, 120, 141, 95, 208, 193, 79, 35, 9, 17, 232, 67, 98, 128, 99, 187, 239, 223, 50, 123, 61, 1, 59, 140, 36, 68, 157, 11, 135, 255, 139, 234, 185, 121, 200, 235, 244, 4, 236, 46, 144, 15, 114, 44, 26, 249, 42, 165, 226, 227, 29, 169, 205, 16, 173, 184, 62, 60, 199, 176, 104, 225, 168, 146, 133, 137, 116, 162, 49, 64, 178, 222, 248, 240, 25, 190, 159, 129, 158, 70, 18, 34, 207, 134, 196, 256, 198, 117, 221, 189, 100, 246, 122, 2, 118, 23, 72, 136, 57, 22, 13, 253, 21, 211, 113, 242, 143, 213, 231, 8, 215, 92, 31, 30, 228, 88, 52, 241, 84, 73, 195, 197, 58, 81, 153, 32, 89, 111, 124, 120, 141, 95, 208, 193, 79, 35, 9, 17, 232, 67, 98, 128, 99, 187, 239, 223, 50, 123, 61, 1],
-[1, 60, 2, 120, 4, 240, 8, 223, 16, 189, 32, 121, 64, 242, 128, 227, 256, 197, 255, 137, 253, 17, 249, 34, 241, 68, 225, 136, 193, 15, 129, 30, 1, 60, 2, 120, 4, 240, 8, 223, 16, 189, 32, 121, 64, 242, 128, 227, 256, 197, 255, 137, 253, 17, 249, 34, 241, 68, 225, 136, 193, 15, 129, 30, 1, 60, 2, 120, 4, 240, 8, 223, 16, 189, 32, 121, 64, 242, 128, 227, 256, 197, 255, 137, 253, 17, 249, 34, 241, 68, 225, 136, 193, 15, 129, 30, 1, 60, 2, 120, 4, 240, 8, 223, 16, 189, 32, 121, 64, 242, 128, 227, 256, 197, 255, 137, 253, 17, 249, 34, 241, 68, 225, 136, 193, 15, 129, 30, 1, 60, 2, 120, 4, 240, 8, 223, 16, 189, 32, 121, 64, 242, 128, 227, 256, 197, 255, 137, 253, 17, 249, 34, 241, 68, 225, 136, 193, 15, 129, 30, 1, 60, 2, 120, 4, 240, 8, 223, 16, 189, 32, 121, 64, 242, 128, 227, 256, 197, 255, 137, 253, 17, 249, 34, 241, 68, 225, 136, 193, 15, 129, 30, 1, 60, 2, 120, 4, 240, 8, 223, 16, 189, 32, 121, 64, 242, 128, 227, 256, 197, 255, 137, 253, 17, 249, 34, 241, 68, 225, 136, 193, 15, 129, 30, 1, 60, 2, 120, 4, 240, 8, 223, 16, 189, 32, 121, 64, 242, 128, 227, 256, 197, 255, 137, 253, 17, 249, 34, 241, 68, 225, 136, 193, 15, 129, 30, 1],
-[1, 61, 123, 50, 223, 239, 187, 99, 128, 98, 67, 232, 17, 9, 35, 79, 193, 208, 95, 141, 120, 124, 111, 89, 32, 153, 81, 58, 197, 195, 73, 84, 241, 52, 88, 228, 30, 31, 92, 215, 8, 231, 213, 143, 242, 113, 211, 21, 253, 13, 22, 57, 136, 72, 23, 118, 2, 122, 246, 100, 189, 221, 117, 198, 256, 196, 134, 207, 34, 18, 70, 158, 129, 159, 190, 25, 240, 248, 222, 178, 64, 49, 162, 116, 137, 133, 146, 168, 225, 104, 176, 199, 60, 62, 184, 173, 16, 205, 169, 29, 227, 226, 165, 42, 249, 26, 44, 114, 15, 144, 46, 236, 4, 244, 235, 200, 121, 185, 234, 139, 255, 135, 11, 157, 68, 36, 140, 59, 1, 61, 123, 50, 223, 239, 187, 99, 128, 98, 67, 232, 17, 9, 35, 79, 193, 208, 95, 141, 120, 124, 111, 89, 32, 153, 81, 58, 197, 195, 73, 84, 241, 52, 88, 228, 30, 31, 92, 215, 8, 231, 213, 143, 242, 113, 211, 21, 253, 13, 22, 57, 136, 72, 23, 118, 2, 122, 246, 100, 189, 221, 117, 198, 256, 196, 134, 207, 34, 18, 70, 158, 129, 159, 190, 25, 240, 248, 222, 178, 64, 49, 162, 116, 137, 133, 146, 168, 225, 104, 176, 199, 60, 62, 184, 173, 16, 205, 169, 29, 227, 226, 165, 42, 249, 26, 44, 114, 15, 144, 46, 236, 4, 244, 235, 200, 121, 185, 234, 139, 255, 135, 11, 157, 68, 36, 140, 59, 1],
-[1, 62, 246, 89, 121, 49, 211, 232, 249, 18, 88, 59, 60, 122, 111, 200, 64, 113, 67, 42, 34, 52, 140, 199, 2, 124, 235, 178, 242, 98, 165, 207, 241, 36, 176, 118, 120, 244, 222, 143, 128, 226, 134, 84, 68, 104, 23, 141, 4, 248, 213, 99, 227, 196, 73, 157, 225, 72, 95, 236, 240, 231, 187, 29, 256, 195, 11, 168, 136, 208, 46, 25, 8, 239, 169, 198, 197, 135, 146, 57, 193, 144, 190, 215, 223, 205, 117, 58, 255, 133, 22, 79, 15, 159, 92, 50, 16, 221, 81, 139, 137, 13, 35, 114, 129, 31, 123, 173, 189, 153, 234, 116, 253, 9, 44, 158, 30, 61, 184, 100, 32, 185, 162, 21, 17, 26, 70, 228, 1, 62, 246, 89, 121, 49, 211, 232, 249, 18, 88, 59, 60, 122, 111, 200, 64, 113, 67, 42, 34, 52, 140, 199, 2, 124, 235, 178, 242, 98, 165, 207, 241, 36, 176, 118, 120, 244, 222, 143, 128, 226, 134, 84, 68, 104, 23, 141, 4, 248, 213, 99, 227, 196, 73, 157, 225, 72, 95, 236, 240, 231, 187, 29, 256, 195, 11, 168, 136, 208, 46, 25, 8, 239, 169, 198, 197, 135, 146, 57, 193, 144, 190, 215, 223, 205, 117, 58, 255, 133, 22, 79, 15, 159, 92, 50, 16, 221, 81, 139, 137, 13, 35, 114, 129, 31, 123, 173, 189, 153, 234, 116, 253, 9, 44, 158, 30, 61, 184, 100, 32, 185, 162, 21, 17, 26, 70, 228, 1],
-[1, 63, 114, 243, 146, 203, 196, 12, 242, 83, 89, 210, 123, 39, 144, 77, 225, 40, 207, 191, 211, 186, 153, 130, 223, 171, 236, 219, 176, 37, 18, 106, 253, 5, 58, 56, 187, 216, 244, 209, 60, 182, 158, 188, 22, 101, 195, 206, 128, 97, 200, 7, 184, 27, 159, 251, 136, 87, 84, 152, 67, 109, 185, 90, 16, 237, 25, 33, 23, 164, 52, 192, 17, 43, 139, 19, 169, 110, 248, 204, 2, 126, 228, 229, 35, 149, 135, 24, 227, 166, 178, 163, 246, 78, 31, 154, 193, 80, 157, 125, 165, 115, 49, 3, 189, 85, 215, 181, 95, 74, 36, 212, 249, 10, 116, 112, 117, 175, 231, 161, 120, 107, 59, 119, 44, 202, 133, 155, 256, 194, 143, 14, 111, 54, 61, 245, 15, 174, 168, 47, 134, 218, 113, 180, 32, 217, 50, 66, 46, 71, 104, 127, 34, 86, 21, 38, 81, 220, 239, 151, 4, 252, 199, 201, 70, 41, 13, 48, 197, 75, 99, 69, 235, 156, 62, 51, 129, 160, 57, 250, 73, 230, 98, 6, 121, 170, 173, 105, 190, 148, 72, 167, 241, 20, 232, 224, 234, 93, 205, 65, 240, 214, 118, 238, 88, 147, 9, 53, 255, 131, 29, 28, 222, 108, 122, 233, 30, 91, 79, 94, 11, 179, 226, 103, 64, 177, 100, 132, 92, 142, 208, 254, 68, 172, 42, 76, 162, 183, 221, 45, 8, 247, 141, 145, 140, 82, 26, 96, 137, 150, 198, 138, 213, 55, 124, 102, 1],
-[1, 64, 241, 4, 256, 193, 16, 253, 1, 64, 241, 4, 256, 193, 16, 253, 1, 64, 241, 4, 256, 193, 16, 253, 1, 64, 241, 4, 256, 193, 16, 253, 1, 64, 241, 4, 256, 193, 16, 253, 1, 64, 241, 4, 256, 193, 16, 253, 1, 64, 241, 4, 256, 193, 16, 253, 1, 64, 241, 4, 256, 193, 16, 253, 1, 64, 241, 4, 256, 193, 16, 253, 1, 64, 241, 4, 256, 193, 16, 253, 1, 64, 241, 4, 256, 193, 16, 253, 1, 64, 241, 4, 256, 193, 16, 253, 1, 64, 241, 4, 256, 193, 16, 253, 1, 64, 241, 4, 256, 193, 16, 253, 1, 64, 241, 4, 256, 193, 16, 253, 1, 64, 241, 4, 256, 193, 16, 253, 1, 64, 241, 4, 256, 193, 16, 253, 1, 64, 241, 4, 256, 193, 16, 253, 1, 64, 241, 4, 256, 193, 16, 253, 1, 64, 241, 4, 256, 193, 16, 253, 1, 64, 241, 4, 256, 193, 16, 253, 1, 64, 241, 4, 256, 193, 16, 253, 1, 64, 241, 4, 256, 193, 16, 253, 1, 64, 241, 4, 256, 193, 16, 253, 1, 64, 241, 4, 256, 193, 16, 253, 1, 64, 241, 4, 256, 193, 16, 253, 1, 64, 241, 4, 256, 193, 16, 253, 1, 64, 241, 4, 256, 193, 16, 253, 1, 64, 241, 4, 256, 193, 16, 253, 1, 64, 241, 4, 256, 193, 16, 253, 1, 64, 241, 4, 256, 193, 16, 253, 1, 64, 241, 4, 256, 193, 16, 253, 1],
-[1, 65, 113, 149, 176, 132, 99, 10, 136, 102, 205, 218, 35, 219, 100, 75, 249, 251, 124, 93, 134, 229, 236, 177, 197, 212, 159, 55, 234, 47, 228, 171, 64, 48, 36, 27, 213, 224, 168, 126, 223, 103, 13, 74, 184, 138, 232, 174, 2, 130, 226, 41, 95, 7, 198, 20, 15, 204, 153, 179, 70, 181, 200, 150, 241, 245, 248, 186, 11, 201, 215, 97, 137, 167, 61, 110, 211, 94, 199, 85, 128, 96, 72, 54, 169, 191, 79, 252, 189, 206, 26, 148, 111, 19, 207, 91, 4, 3, 195, 82, 190, 14, 139, 40, 30, 151, 49, 101, 140, 105, 143, 43, 225, 233, 239, 115, 22, 145, 173, 194, 17, 77, 122, 220, 165, 188, 141, 170, 256, 192, 144, 108, 81, 125, 158, 247, 121, 155, 52, 39, 222, 38, 157, 182, 8, 6, 133, 164, 123, 28, 21, 80, 60, 45, 98, 202, 23, 210, 29, 86, 193, 209, 221, 230, 44, 33, 89, 131, 34, 154, 244, 183, 73, 119, 25, 83, 255, 127, 31, 216, 162, 250, 59, 237, 242, 53, 104, 78, 187, 76, 57, 107, 16, 12, 9, 71, 246, 56, 42, 160, 120, 90, 196, 147, 46, 163, 58, 172, 129, 161, 185, 203, 88, 66, 178, 5, 68, 51, 231, 109, 146, 238, 50, 166, 253, 254, 62, 175, 67, 243, 118, 217, 227, 106, 208, 156, 117, 152, 114, 214, 32, 24, 18, 142, 235, 112, 84, 63, 240, 180, 135, 37, 92, 69, 116, 87, 1],
-[1, 66, 244, 170, 169, 103, 116, 203, 34, 188, 72, 126, 92, 161, 89, 220, 128, 224, 135, 172, 44, 77, 199, 27, 240, 163, 221, 194, 211, 48, 84, 147, 193, 145, 61, 171, 235, 90, 29, 115, 137, 47, 18, 160, 23, 233, 215, 55, 32, 56, 98, 43, 11, 212, 114, 71, 60, 105, 248, 177, 117, 12, 21, 101, 241, 229, 208, 107, 123, 151, 200, 93, 227, 76, 133, 40, 70, 251, 118, 78, 8, 14, 153, 75, 67, 53, 157, 82, 15, 219, 62, 237, 222, 3, 198, 218, 253, 250, 52, 91, 95, 102, 50, 216, 121, 19, 226, 10, 146, 127, 158, 148, 2, 132, 231, 83, 81, 206, 232, 149, 68, 119, 144, 252, 184, 65, 178, 183, 256, 191, 13, 87, 88, 154, 141, 54, 223, 69, 185, 131, 165, 96, 168, 37, 129, 33, 122, 85, 213, 180, 58, 230, 17, 94, 36, 63, 46, 209, 173, 110, 64, 112, 196, 86, 22, 167, 228, 142, 120, 210, 239, 97, 234, 24, 42, 202, 225, 201, 159, 214, 246, 45, 143, 186, 197, 152, 9, 80, 140, 245, 236, 156, 16, 28, 49, 150, 134, 106, 57, 164, 30, 181, 124, 217, 187, 6, 139, 179, 249, 243, 104, 182, 190, 204, 100, 175, 242, 38, 195, 20, 35, 254, 59, 39, 4, 7, 205, 166, 162, 155, 207, 41, 136, 238, 31, 247, 111, 130, 99, 109, 255, 125, 26, 174, 176, 51, 25, 108, 189, 138, 113, 5, 73, 192, 79, 74, 1],
-[1, 67, 120, 73, 8, 22, 189, 70, 64, 176, 227, 46, 255, 123, 17, 111, 241, 213, 136, 117, 129, 162, 60, 165, 4, 11, 223, 35, 32, 88, 242, 23, 256, 190, 137, 184, 249, 235, 68, 187, 193, 81, 30, 211, 2, 134, 240, 146, 16, 44, 121, 140, 128, 95, 197, 92, 253, 246, 34, 222, 225, 169, 15, 234, 1, 67, 120, 73, 8, 22, 189, 70, 64, 176, 227, 46, 255, 123, 17, 111, 241, 213, 136, 117, 129, 162, 60, 165, 4, 11, 223, 35, 32, 88, 242, 23, 256, 190, 137, 184, 249, 235, 68, 187, 193, 81, 30, 211, 2, 134, 240, 146, 16, 44, 121, 140, 128, 95, 197, 92, 253, 246, 34, 222, 225, 169, 15, 234, 1, 67, 120, 73, 8, 22, 189, 70, 64, 176, 227, 46, 255, 123, 17, 111, 241, 213, 136, 117, 129, 162, 60, 165, 4, 11, 223, 35, 32, 88, 242, 23, 256, 190, 137, 184, 249, 235, 68, 187, 193, 81, 30, 211, 2, 134, 240, 146, 16, 44, 121, 140, 128, 95, 197, 92, 253, 246, 34, 222, 225, 169, 15, 234, 1, 67, 120, 73, 8, 22, 189, 70, 64, 176, 227, 46, 255, 123, 17, 111, 241, 213, 136, 117, 129, 162, 60, 165, 4, 11, 223, 35, 32, 88, 242, 23, 256, 190, 137, 184, 249, 235, 68, 187, 193, 81, 30, 211, 2, 134, 240, 146, 16, 44, 121, 140, 128, 95, 197, 92, 253, 246, 34, 222, 225, 169, 15, 234, 1],
-[1, 68, 255, 121, 4, 15, 249, 227, 16, 60, 225, 137, 64, 240, 129, 34, 256, 189, 2, 136, 253, 242, 8, 30, 241, 197, 32, 120, 193, 17, 128, 223, 1, 68, 255, 121, 4, 15, 249, 227, 16, 60, 225, 137, 64, 240, 129, 34, 256, 189, 2, 136, 253, 242, 8, 30, 241, 197, 32, 120, 193, 17, 128, 223, 1, 68, 255, 121, 4, 15, 249, 227, 16, 60, 225, 137, 64, 240, 129, 34, 256, 189, 2, 136, 253, 242, 8, 30, 241, 197, 32, 120, 193, 17, 128, 223, 1, 68, 255, 121, 4, 15, 249, 227, 16, 60, 225, 137, 64, 240, 129, 34, 256, 189, 2, 136, 253, 242, 8, 30, 241, 197, 32, 120, 193, 17, 128, 223, 1, 68, 255, 121, 4, 15, 249, 227, 16, 60, 225, 137, 64, 240, 129, 34, 256, 189, 2, 136, 253, 242, 8, 30, 241, 197, 32, 120, 193, 17, 128, 223, 1, 68, 255, 121, 4, 15, 249, 227, 16, 60, 225, 137, 64, 240, 129, 34, 256, 189, 2, 136, 253, 242, 8, 30, 241, 197, 32, 120, 193, 17, 128, 223, 1, 68, 255, 121, 4, 15, 249, 227, 16, 60, 225, 137, 64, 240, 129, 34, 256, 189, 2, 136, 253, 242, 8, 30, 241, 197, 32, 120, 193, 17, 128, 223, 1, 68, 255, 121, 4, 15, 249, 227, 16, 60, 225, 137, 64, 240, 129, 34, 256, 189, 2, 136, 253, 242, 8, 30, 241, 197, 32, 120, 193, 17, 128, 223, 1],
-[1, 69, 135, 63, 235, 24, 114, 156, 227, 243, 62, 166, 146, 51, 178, 203, 129, 163, 196, 160, 246, 12, 57, 78, 242, 250, 31, 83, 73, 154, 89, 230, 193, 210, 98, 80, 123, 6, 157, 39, 121, 125, 144, 170, 165, 77, 173, 115, 225, 105, 49, 40, 190, 3, 207, 148, 189, 191, 72, 85, 211, 167, 215, 186, 241, 181, 153, 20, 95, 130, 232, 74, 223, 224, 36, 171, 234, 212, 236, 93, 249, 219, 205, 10, 176, 65, 116, 37, 240, 112, 18, 214, 117, 106, 118, 175, 253, 238, 231, 5, 88, 161, 58, 147, 120, 56, 9, 107, 187, 53, 59, 216, 255, 119, 244, 131, 44, 209, 29, 202, 60, 28, 133, 182, 222, 155, 158, 108, 256, 188, 122, 194, 22, 233, 143, 101, 30, 14, 195, 91, 111, 206, 79, 54, 128, 94, 61, 97, 11, 245, 200, 179, 15, 7, 226, 174, 184, 103, 168, 27, 64, 47, 159, 177, 134, 251, 100, 218, 136, 132, 113, 87, 92, 180, 84, 142, 32, 152, 208, 217, 67, 254, 50, 109, 68, 66, 185, 172, 46, 90, 42, 71, 16, 76, 104, 237, 162, 127, 25, 183, 34, 33, 221, 86, 23, 45, 21, 164, 8, 38, 52, 247, 81, 192, 141, 220, 17, 145, 239, 43, 140, 151, 139, 82, 4, 19, 26, 252, 169, 96, 199, 110, 137, 201, 248, 150, 70, 204, 198, 41, 2, 138, 13, 126, 213, 48, 228, 55, 197, 229, 124, 75, 35, 102, 99, 149, 1],
-[1, 70, 17, 162, 32, 184, 30, 44, 253, 234, 189, 123, 129, 35, 137, 81, 16, 92, 15, 22, 255, 117, 223, 190, 193, 146, 197, 169, 8, 46, 136, 11, 256, 187, 240, 95, 225, 73, 227, 213, 4, 23, 68, 134, 128, 222, 120, 176, 241, 165, 242, 235, 2, 140, 34, 67, 64, 111, 60, 88, 249, 211, 121, 246, 1, 70, 17, 162, 32, 184, 30, 44, 253, 234, 189, 123, 129, 35, 137, 81, 16, 92, 15, 22, 255, 117, 223, 190, 193, 146, 197, 169, 8, 46, 136, 11, 256, 187, 240, 95, 225, 73, 227, 213, 4, 23, 68, 134, 128, 222, 120, 176, 241, 165, 242, 235, 2, 140, 34, 67, 64, 111, 60, 88, 249, 211, 121, 246, 1, 70, 17, 162, 32, 184, 30, 44, 253, 234, 189, 123, 129, 35, 137, 81, 16, 92, 15, 22, 255, 117, 223, 190, 193, 146, 197, 169, 8, 46, 136, 11, 256, 187, 240, 95, 225, 73, 227, 213, 4, 23, 68, 134, 128, 222, 120, 176, 241, 165, 242, 235, 2, 140, 34, 67, 64, 111, 60, 88, 249, 211, 121, 246, 1, 70, 17, 162, 32, 184, 30, 44, 253, 234, 189, 123, 129, 35, 137, 81, 16, 92, 15, 22, 255, 117, 223, 190, 193, 146, 197, 169, 8, 46, 136, 11, 256, 187, 240, 95, 225, 73, 227, 213, 4, 23, 68, 134, 128, 222, 120, 176, 241, 165, 242, 235, 2, 140, 34, 67, 64, 111, 60, 88, 249, 211, 121, 246, 1],
-[1, 71, 158, 167, 35, 172, 133, 191, 197, 109, 29, 3, 213, 217, 244, 105, 2, 142, 59, 77, 70, 87, 9, 125, 137, 218, 58, 6, 169, 177, 231, 210, 4, 27, 118, 154, 140, 174, 18, 250, 17, 179, 116, 12, 81, 97, 205, 163, 8, 54, 236, 51, 23, 91, 36, 243, 34, 101, 232, 24, 162, 194, 153, 69, 16, 108, 215, 102, 46, 182, 72, 229, 68, 202, 207, 48, 67, 131, 49, 138, 32, 216, 173, 204, 92, 107, 144, 201, 136, 147, 157, 96, 134, 5, 98, 19, 64, 175, 89, 151, 184, 214, 31, 145, 15, 37, 57, 192, 11, 10, 196, 38, 128, 93, 178, 45, 111, 171, 62, 33, 30, 74, 114, 127, 22, 20, 135, 76, 256, 186, 99, 90, 222, 85, 124, 66, 60, 148, 228, 254, 44, 40, 13, 152, 255, 115, 198, 180, 187, 170, 248, 132, 120, 39, 199, 251, 88, 80, 26, 47, 253, 230, 139, 103, 117, 83, 239, 7, 240, 78, 141, 245, 176, 160, 52, 94, 249, 203, 21, 206, 234, 166, 221, 14, 223, 156, 25, 233, 95, 63, 104, 188, 241, 149, 42, 155, 211, 75, 185, 28, 189, 55, 50, 209, 190, 126, 208, 119, 225, 41, 84, 53, 165, 150, 113, 56, 121, 110, 100, 161, 123, 252, 159, 238, 193, 82, 168, 106, 73, 43, 226, 112, 242, 220, 200, 65, 246, 247, 61, 219, 129, 164, 79, 212, 146, 86, 195, 224, 227, 183, 143, 130, 235, 237, 122, 181, 1],
-[1, 72, 44, 84, 137, 98, 117, 200, 8, 62, 95, 158, 68, 13, 165, 58, 64, 239, 246, 236, 30, 104, 35, 207, 255, 113, 169, 89, 240, 61, 23, 114, 241, 133, 67, 198, 121, 231, 184, 141, 129, 36, 22, 42, 197, 49, 187, 100, 4, 31, 176, 79, 34, 135, 211, 29, 32, 248, 123, 118, 15, 52, 146, 232, 256, 185, 213, 173, 120, 159, 140, 57, 249, 195, 162, 99, 189, 244, 92, 199, 193, 18, 11, 21, 227, 153, 222, 50, 2, 144, 88, 168, 17, 196, 234, 143, 16, 124, 190, 59, 136, 26, 73, 116, 128, 221, 235, 215, 60, 208, 70, 157, 253, 226, 81, 178, 223, 122, 46, 228, 225, 9, 134, 139, 242, 205, 111, 25, 1, 72, 44, 84, 137, 98, 117, 200, 8, 62, 95, 158, 68, 13, 165, 58, 64, 239, 246, 236, 30, 104, 35, 207, 255, 113, 169, 89, 240, 61, 23, 114, 241, 133, 67, 198, 121, 231, 184, 141, 129, 36, 22, 42, 197, 49, 187, 100, 4, 31, 176, 79, 34, 135, 211, 29, 32, 248, 123, 118, 15, 52, 146, 232, 256, 185, 213, 173, 120, 159, 140, 57, 249, 195, 162, 99, 189, 244, 92, 199, 193, 18, 11, 21, 227, 153, 222, 50, 2, 144, 88, 168, 17, 196, 234, 143, 16, 124, 190, 59, 136, 26, 73, 116, 128, 221, 235, 215, 60, 208, 70, 157, 253, 226, 81, 178, 223, 122, 46, 228, 225, 9, 134, 139, 242, 205, 111, 25, 1],
-[1, 73, 189, 176, 255, 111, 136, 162, 4, 35, 242, 190, 249, 187, 30, 134, 16, 140, 197, 246, 225, 234, 120, 22, 64, 46, 17, 213, 129, 165, 223, 88, 256, 184, 68, 81, 2, 146, 121, 95, 253, 222, 15, 67, 8, 70, 227, 123, 241, 117, 60, 11, 32, 23, 137, 235, 193, 211, 240, 44, 128, 92, 34, 169, 1, 73, 189, 176, 255, 111, 136, 162, 4, 35, 242, 190, 249, 187, 30, 134, 16, 140, 197, 246, 225, 234, 120, 22, 64, 46, 17, 213, 129, 165, 223, 88, 256, 184, 68, 81, 2, 146, 121, 95, 253, 222, 15, 67, 8, 70, 227, 123, 241, 117, 60, 11, 32, 23, 137, 235, 193, 211, 240, 44, 128, 92, 34, 169, 1, 73, 189, 176, 255, 111, 136, 162, 4, 35, 242, 190, 249, 187, 30, 134, 16, 140, 197, 246, 225, 234, 120, 22, 64, 46, 17, 213, 129, 165, 223, 88, 256, 184, 68, 81, 2, 146, 121, 95, 253, 222, 15, 67, 8, 70, 227, 123, 241, 117, 60, 11, 32, 23, 137, 235, 193, 211, 240, 44, 128, 92, 34, 169, 1, 73, 189, 176, 255, 111, 136, 162, 4, 35, 242, 190, 249, 187, 30, 134, 16, 140, 197, 246, 225, 234, 120, 22, 64, 46, 17, 213, 129, 165, 223, 88, 256, 184, 68, 81, 2, 146, 121, 95, 253, 222, 15, 67, 8, 70, 227, 123, 241, 117, 60, 11, 32, 23, 137, 235, 193, 211, 240, 44, 128, 92, 34, 169, 1],
-[1, 74, 79, 192, 73, 5, 113, 138, 189, 108, 25, 51, 176, 174, 26, 125, 255, 109, 99, 130, 111, 247, 31, 238, 136, 41, 207, 155, 162, 166, 205, 7, 4, 39, 59, 254, 35, 20, 195, 38, 242, 175, 100, 204, 190, 182, 104, 243, 249, 179, 139, 6, 187, 217, 124, 181, 30, 164, 57, 106, 134, 150, 49, 28, 16, 156, 236, 245, 140, 80, 9, 152, 197, 186, 143, 45, 246, 214, 159, 201, 225, 202, 42, 24, 234, 97, 239, 210, 120, 142, 228, 167, 22, 86, 196, 112, 64, 110, 173, 209, 46, 63, 36, 94, 17, 230, 58, 180, 213, 85, 122, 33, 129, 37, 168, 96, 165, 131, 185, 69, 223, 54, 141, 154, 88, 87, 13, 191, 256, 183, 178, 65, 184, 252, 144, 119, 68, 149, 232, 206, 81, 83, 231, 132, 2, 148, 158, 127, 146, 10, 226, 19, 121, 216, 50, 102, 95, 91, 52, 250, 253, 218, 198, 3, 222, 237, 62, 219, 15, 82, 157, 53, 67, 75, 153, 14, 8, 78, 118, 251, 70, 40, 133, 76, 227, 93, 200, 151, 123, 107, 208, 229, 241, 101, 21, 12, 117, 177, 248, 105, 60, 71, 114, 212, 11, 43, 98, 56, 32, 55, 215, 233, 23, 160, 18, 47, 137, 115, 29, 90, 235, 171, 61, 145, 193, 147, 84, 48, 211, 194, 221, 163, 240, 27, 199, 77, 44, 172, 135, 224, 128, 220, 89, 161, 92, 126, 72, 188, 34, 203, 116, 103, 169, 170, 244, 66, 1],
-[1, 75, 228, 138, 70, 110, 26, 151, 17, 247, 21, 33, 162, 71, 185, 254, 32, 87, 100, 47, 184, 179, 61, 206, 30, 194, 158, 28, 44, 216, 9, 161, 253, 214, 116, 219, 234, 74, 153, 167, 189, 40, 173, 125, 123, 230, 31, 12, 129, 166, 114, 69, 35, 55, 13, 204, 137, 252, 139, 145, 81, 164, 221, 127, 16, 172, 50, 152, 92, 218, 159, 103, 15, 97, 79, 14, 22, 108, 133, 209, 255, 107, 58, 238, 117, 37, 205, 212, 223, 20, 215, 191, 190, 115, 144, 6, 193, 83, 57, 163, 146, 156, 135, 102, 197, 126, 198, 201, 169, 82, 239, 192, 8, 86, 25, 76, 46, 109, 208, 180, 136, 177, 168, 7, 11, 54, 195, 233, 256, 182, 29, 119, 187, 147, 231, 106, 240, 10, 236, 224, 95, 186, 72, 3, 225, 170, 157, 210, 73, 78, 196, 51, 227, 63, 99, 229, 213, 41, 248, 96, 4, 43, 141, 38, 23, 183, 104, 90, 68, 217, 84, 132, 134, 27, 226, 245, 128, 91, 143, 188, 222, 202, 244, 53, 120, 5, 118, 112, 176, 93, 36, 130, 241, 85, 207, 105, 165, 39, 98, 154, 242, 160, 178, 243, 235, 149, 124, 48, 2, 150, 199, 19, 140, 220, 52, 45, 34, 237, 42, 66, 67, 142, 113, 251, 64, 174, 200, 94, 111, 101, 122, 155, 60, 131, 59, 56, 88, 175, 18, 65, 249, 171, 232, 181, 211, 148, 49, 77, 121, 80, 89, 250, 246, 203, 62, 24, 1],
-[1, 76, 122, 20, 235, 127, 143, 74, 227, 33, 195, 171, 146, 45, 79, 93, 129, 38, 61, 10, 246, 192, 200, 37, 242, 145, 226, 214, 73, 151, 168, 175, 193, 19, 159, 5, 123, 96, 100, 147, 121, 201, 113, 107, 165, 204, 84, 216, 225, 138, 208, 131, 190, 48, 50, 202, 189, 229, 185, 182, 211, 102, 42, 108, 241, 69, 104, 194, 95, 24, 25, 101, 223, 243, 221, 91, 234, 51, 21, 54, 249, 163, 52, 97, 176, 12, 141, 179, 240, 250, 239, 174, 117, 154, 139, 27, 253, 210, 26, 177, 88, 6, 199, 218, 120, 125, 248, 87, 187, 77, 198, 142, 255, 105, 13, 217, 44, 3, 228, 109, 60, 191, 124, 172, 222, 167, 99, 71, 256, 181, 135, 237, 22, 130, 114, 183, 30, 224, 62, 86, 111, 212, 178, 164, 128, 219, 196, 247, 11, 65, 57, 220, 15, 112, 31, 43, 184, 106, 89, 82, 64, 238, 98, 252, 134, 161, 157, 110, 136, 56, 144, 150, 92, 53, 173, 41, 32, 119, 49, 126, 67, 209, 207, 55, 68, 28, 72, 75, 46, 155, 215, 149, 16, 188, 153, 63, 162, 233, 232, 156, 34, 14, 36, 166, 23, 206, 236, 203, 8, 94, 205, 160, 81, 245, 116, 78, 17, 7, 18, 83, 140, 103, 118, 230, 4, 47, 231, 80, 169, 251, 58, 39, 137, 132, 9, 170, 70, 180, 59, 115, 2, 152, 244, 40, 213, 254, 29, 148, 197, 66, 133, 85, 35, 90, 158, 186, 1],
-[1, 77, 18, 101, 67, 19, 178, 85, 120, 245, 104, 41, 73, 224, 29, 177, 8, 102, 144, 37, 22, 152, 139, 166, 189, 161, 61, 71, 70, 250, 232, 131, 64, 45, 124, 39, 176, 188, 84, 43, 227, 3, 231, 54, 46, 201, 57, 20, 255, 103, 221, 55, 123, 219, 158, 87, 17, 24, 49, 175, 111, 66, 199, 160, 241, 53, 226, 183, 213, 210, 236, 182, 136, 192, 135, 115, 117, 14, 50, 252, 129, 167, 9, 179, 162, 138, 89, 171, 60, 251, 52, 149, 165, 112, 143, 217, 4, 51, 72, 147, 11, 76, 198, 83, 223, 209, 159, 164, 35, 125, 116, 194, 32, 151, 62, 148, 88, 94, 42, 150, 242, 130, 244, 27, 23, 229, 157, 10, 256, 180, 239, 156, 190, 238, 79, 172, 137, 12, 153, 216, 184, 33, 228, 80, 249, 155, 113, 220, 235, 105, 118, 91, 68, 96, 196, 186, 187, 7, 25, 126, 193, 212, 133, 218, 81, 69, 173, 214, 30, 254, 26, 203, 211, 56, 200, 237, 2, 154, 36, 202, 134, 38, 99, 170, 240, 233, 208, 82, 146, 191, 58, 97, 16, 204, 31, 74, 44, 47, 21, 75, 121, 65, 122, 142, 140, 243, 207, 5, 128, 90, 248, 78, 95, 119, 168, 86, 197, 6, 205, 108, 92, 145, 114, 40, 253, 206, 185, 110, 246, 181, 59, 174, 34, 48, 98, 93, 222, 132, 141, 63, 225, 106, 195, 109, 169, 163, 215, 107, 15, 127, 13, 230, 234, 28, 100, 247, 1],
-[1, 78, 173, 130, 117, 131, 195, 47, 68, 164, 199, 102, 246, 170, 153, 112, 255, 101, 168, 254, 23, 252, 124, 163, 121, 186, 116, 53, 22, 174, 208, 33, 4, 55, 178, 6, 211, 10, 9, 188, 15, 142, 25, 151, 213, 166, 98, 191, 249, 147, 158, 245, 92, 237, 239, 138, 227, 230, 207, 212, 88, 182, 61, 132, 16, 220, 198, 24, 73, 40, 36, 238, 60, 54, 100, 90, 81, 150, 135, 250, 225, 74, 118, 209, 111, 177, 185, 38, 137, 149, 57, 77, 95, 214, 244, 14, 64, 109, 21, 96, 35, 160, 144, 181, 240, 216, 143, 103, 67, 86, 26, 229, 129, 39, 215, 65, 187, 194, 226, 152, 34, 82, 228, 51, 123, 85, 205, 56, 256, 179, 84, 127, 140, 126, 62, 210, 189, 93, 58, 155, 11, 87, 104, 145, 2, 156, 89, 3, 234, 5, 133, 94, 136, 71, 141, 204, 235, 83, 49, 224, 253, 202, 79, 251, 46, 247, 248, 69, 242, 115, 232, 106, 44, 91, 159, 66, 8, 110, 99, 12, 165, 20, 18, 119, 30, 27, 50, 45, 169, 75, 196, 125, 241, 37, 59, 233, 184, 217, 221, 19, 197, 203, 157, 167, 176, 107, 122, 7, 32, 183, 139, 48, 146, 80, 72, 219, 120, 108, 200, 180, 162, 43, 13, 243, 193, 148, 236, 161, 222, 97, 113, 76, 17, 41, 114, 154, 190, 171, 231, 28, 128, 218, 42, 192, 70, 63, 31, 105, 223, 175, 29, 206, 134, 172, 52, 201, 1],
-[1, 79, 73, 113, 189, 25, 176, 26, 255, 99, 111, 31, 136, 207, 162, 205, 4, 59, 35, 195, 242, 100, 190, 104, 249, 139, 187, 124, 30, 57, 134, 49, 16, 236, 140, 9, 197, 143, 246, 159, 225, 42, 234, 239, 120, 228, 22, 196, 64, 173, 46, 36, 17, 58, 213, 122, 129, 168, 165, 185, 223, 141, 88, 13, 256, 178, 184, 144, 68, 232, 81, 231, 2, 158, 146, 226, 121, 50, 95, 52, 253, 198, 222, 62, 15, 157, 67, 153, 8, 118, 70, 133, 227, 200, 123, 208, 241, 21, 117, 248, 60, 114, 11, 98, 32, 215, 23, 18, 137, 29, 235, 61, 193, 84, 211, 221, 240, 199, 44, 135, 128, 89, 92, 72, 34, 116, 169, 244, 1, 79, 73, 113, 189, 25, 176, 26, 255, 99, 111, 31, 136, 207, 162, 205, 4, 59, 35, 195, 242, 100, 190, 104, 249, 139, 187, 124, 30, 57, 134, 49, 16, 236, 140, 9, 197, 143, 246, 159, 225, 42, 234, 239, 120, 228, 22, 196, 64, 173, 46, 36, 17, 58, 213, 122, 129, 168, 165, 185, 223, 141, 88, 13, 256, 178, 184, 144, 68, 232, 81, 231, 2, 158, 146, 226, 121, 50, 95, 52, 253, 198, 222, 62, 15, 157, 67, 153, 8, 118, 70, 133, 227, 200, 123, 208, 241, 21, 117, 248, 60, 114, 11, 98, 32, 215, 23, 18, 137, 29, 235, 61, 193, 84, 211, 221, 240, 199, 44, 135, 128, 89, 92, 72, 34, 116, 169, 244, 1],
-[1, 80, 232, 56, 111, 142, 52, 48, 242, 85, 118, 188, 134, 183, 248, 51, 225, 10, 29, 7, 46, 82, 135, 6, 223, 107, 79, 152, 81, 55, 31, 167, 253, 194, 100, 33, 70, 203, 49, 65, 60, 174, 42, 19, 235, 39, 36, 53, 128, 217, 141, 229, 73, 186, 231, 233, 136, 86, 198, 163, 190, 37, 133, 103, 16, 252, 114, 125, 234, 216, 61, 254, 17, 75, 89, 181, 88, 101, 113, 45, 2, 160, 207, 112, 222, 27, 104, 96, 227, 170, 236, 119, 11, 109, 239, 102, 193, 20, 58, 14, 92, 164, 13, 12, 189, 214, 158, 47, 162, 110, 62, 77, 249, 131, 200, 66, 140, 149, 98, 130, 120, 91, 84, 38, 213, 78, 72, 106, 256, 177, 25, 201, 146, 115, 205, 209, 15, 172, 139, 69, 123, 74, 9, 206, 32, 247, 228, 250, 211, 175, 122, 251, 34, 150, 178, 105, 176, 202, 226, 90, 4, 63, 157, 224, 187, 54, 208, 192, 197, 83, 215, 238, 22, 218, 221, 204, 129, 40, 116, 28, 184, 71, 26, 24, 121, 171, 59, 94, 67, 220, 124, 154, 241, 5, 143, 132, 23, 41, 196, 3, 240, 182, 168, 76, 169, 156, 144, 212, 255, 97, 50, 145, 35, 230, 153, 161, 30, 87, 21, 138, 246, 148, 18, 155, 64, 237, 199, 243, 165, 93, 244, 245, 68, 43, 99, 210, 95, 147, 195, 180, 8, 126, 57, 191, 117, 108, 159, 127, 137, 166, 173, 219, 44, 179, 185, 151, 1],
-[1, 81, 136, 222, 249, 123, 197, 23, 64, 44, 223, 73, 2, 162, 15, 187, 241, 246, 137, 46, 128, 88, 189, 146, 4, 67, 30, 117, 225, 235, 17, 92, 256, 176, 121, 35, 8, 134, 60, 234, 193, 213, 34, 184, 255, 95, 242, 70, 16, 11, 120, 211, 129, 169, 68, 111, 253, 190, 227, 140, 32, 22, 240, 165, 1, 81, 136, 222, 249, 123, 197, 23, 64, 44, 223, 73, 2, 162, 15, 187, 241, 246, 137, 46, 128, 88, 189, 146, 4, 67, 30, 117, 225, 235, 17, 92, 256, 176, 121, 35, 8, 134, 60, 234, 193, 213, 34, 184, 255, 95, 242, 70, 16, 11, 120, 211, 129, 169, 68, 111, 253, 190, 227, 140, 32, 22, 240, 165, 1, 81, 136, 222, 249, 123, 197, 23, 64, 44, 223, 73, 2, 162, 15, 187, 241, 246, 137, 46, 128, 88, 189, 146, 4, 67, 30, 117, 225, 235, 17, 92, 256, 176, 121, 35, 8, 134, 60, 234, 193, 213, 34, 184, 255, 95, 242, 70, 16, 11, 120, 211, 129, 169, 68, 111, 253, 190, 227, 140, 32, 22, 240, 165, 1, 81, 136, 222, 249, 123, 197, 23, 64, 44, 223, 73, 2, 162, 15, 187, 241, 246, 137, 46, 128, 88, 189, 146, 4, 67, 30, 117, 225, 235, 17, 92, 256, 176, 121, 35, 8, 134, 60, 234, 193, 213, 34, 184, 255, 95, 242, 70, 16, 11, 120, 211, 129, 169, 68, 111, 253, 190, 227, 140, 32, 22, 240, 165, 1],
-[1, 82, 42, 103, 222, 214, 72, 250, 197, 220, 50, 245, 44, 10, 49, 163, 2, 164, 84, 206, 187, 171, 144, 243, 137, 183, 100, 233, 88, 20, 98, 69, 4, 71, 168, 155, 117, 85, 31, 229, 17, 109, 200, 209, 176, 40, 196, 138, 8, 142, 79, 53, 234, 170, 62, 201, 34, 218, 143, 161, 95, 80, 135, 19, 16, 27, 158, 106, 211, 83, 124, 145, 68, 179, 29, 65, 190, 160, 13, 38, 32, 54, 59, 212, 165, 166, 248, 33, 136, 101, 58, 130, 123, 63, 26, 76, 64, 108, 118, 167, 73, 75, 239, 66, 15, 202, 116, 3, 246, 126, 52, 152, 128, 216, 236, 77, 146, 150, 221, 132, 30, 147, 232, 6, 235, 252, 104, 47, 256, 175, 215, 154, 35, 43, 185, 7, 60, 37, 207, 12, 213, 247, 208, 94, 255, 93, 173, 51, 70, 86, 113, 14, 120, 74, 157, 24, 169, 237, 159, 188, 253, 186, 89, 102, 140, 172, 226, 28, 240, 148, 57, 48, 81, 217, 61, 119, 249, 115, 178, 204, 23, 87, 195, 56, 223, 39, 114, 96, 162, 177, 122, 238, 241, 230, 99, 151, 46, 174, 133, 112, 189, 78, 228, 192, 67, 97, 244, 219, 225, 203, 198, 45, 92, 91, 9, 224, 121, 156, 199, 127, 134, 194, 231, 181, 193, 149, 139, 90, 184, 182, 18, 191, 242, 55, 141, 254, 11, 131, 205, 105, 129, 41, 21, 180, 111, 107, 36, 125, 227, 110, 25, 251, 22, 5, 153, 210, 1],
-[1, 83, 207, 219, 187, 101, 159, 90, 17, 126, 178, 125, 95, 175, 133, 245, 32, 86, 199, 69, 73, 148, 205, 53, 30, 177, 42, 145, 213, 203, 144, 130, 253, 182, 200, 152, 23, 110, 135, 154, 189, 10, 59, 14, 134, 71, 239, 48, 129, 170, 232, 238, 222, 179, 208, 45, 137, 63, 89, 191, 176, 216, 195, 251, 16, 43, 228, 163, 165, 74, 231, 155, 15, 217, 21, 201, 235, 230, 72, 65, 255, 91, 100, 76, 140, 55, 196, 77, 223, 5, 158, 7, 67, 164, 248, 24, 193, 85, 116, 119, 111, 218, 104, 151, 197, 160, 173, 224, 88, 108, 226, 254, 8, 150, 114, 210, 211, 37, 244, 206, 136, 237, 139, 229, 246, 115, 36, 161, 256, 174, 50, 38, 70, 156, 98, 167, 240, 131, 79, 132, 162, 82, 124, 12, 225, 171, 58, 188, 184, 109, 52, 204, 227, 80, 215, 112, 44, 54, 113, 127, 4, 75, 57, 105, 234, 147, 122, 103, 68, 247, 198, 243, 123, 186, 18, 209, 128, 87, 25, 19, 35, 78, 49, 212, 120, 194, 168, 66, 81, 41, 62, 6, 241, 214, 29, 94, 92, 183, 26, 102, 242, 40, 236, 56, 22, 27, 185, 192, 2, 166, 157, 181, 117, 202, 61, 180, 34, 252, 99, 250, 190, 93, 9, 233, 64, 172, 141, 138, 146, 39, 153, 106, 60, 97, 84, 33, 169, 149, 31, 3, 249, 107, 143, 47, 46, 220, 13, 51, 121, 20, 118, 28, 11, 142, 221, 96, 1],
-[1, 84, 117, 62, 68, 58, 246, 104, 255, 89, 23, 133, 121, 141, 22, 49, 4, 79, 211, 248, 15, 232, 213, 159, 249, 99, 92, 18, 227, 50, 88, 196, 16, 59, 73, 221, 60, 157, 81, 122, 225, 139, 111, 72, 137, 200, 95, 13, 64, 236, 35, 113, 240, 114, 67, 231, 129, 42, 187, 31, 34, 29, 123, 52, 256, 173, 140, 195, 189, 199, 11, 153, 2, 168, 234, 124, 136, 116, 235, 208, 253, 178, 46, 9, 242, 25, 44, 98, 8, 158, 165, 239, 30, 207, 169, 61, 241, 198, 184, 36, 197, 100, 176, 135, 32, 118, 146, 185, 120, 57, 162, 244, 193, 21, 222, 144, 17, 143, 190, 26, 128, 215, 70, 226, 223, 228, 134, 205, 1, 84, 117, 62, 68, 58, 246, 104, 255, 89, 23, 133, 121, 141, 22, 49, 4, 79, 211, 248, 15, 232, 213, 159, 249, 99, 92, 18, 227, 50, 88, 196, 16, 59, 73, 221, 60, 157, 81, 122, 225, 139, 111, 72, 137, 200, 95, 13, 64, 236, 35, 113, 240, 114, 67, 231, 129, 42, 187, 31, 34, 29, 123, 52, 256, 173, 140, 195, 189, 199, 11, 153, 2, 168, 234, 124, 136, 116, 235, 208, 253, 178, 46, 9, 242, 25, 44, 98, 8, 158, 165, 239, 30, 207, 169, 61, 241, 198, 184, 36, 197, 100, 176, 135, 32, 118, 146, 185, 120, 57, 162, 244, 193, 21, 222, 144, 17, 143, 190, 26, 128, 215, 70, 226, 223, 228, 134, 205, 1],
-[1, 85, 29, 152, 70, 39, 231, 103, 17, 160, 236, 14, 162, 149, 72, 209, 32, 150, 157, 238, 184, 220, 196, 212, 30, 237, 99, 191, 44, 142, 248, 6, 253, 174, 141, 163, 234, 101, 104, 102, 189, 131, 84, 201, 123, 175, 226, 192, 129, 171, 143, 76, 35, 148, 244, 180, 137, 80, 118, 7, 81, 203, 36, 233, 16, 75, 207, 119, 92, 110, 98, 106, 15, 247, 178, 224, 22, 71, 124, 3, 255, 87, 199, 210, 117, 179, 52, 51, 223, 194, 42, 229, 190, 216, 113, 96, 193, 214, 200, 38, 146, 74, 122, 90, 197, 40, 59, 132, 169, 230, 18, 245, 8, 166, 232, 188, 46, 55, 49, 53, 136, 252, 89, 112, 11, 164, 62, 130, 256, 172, 228, 105, 187, 218, 26, 154, 240, 97, 21, 243, 95, 108, 185, 48, 225, 107, 100, 19, 73, 37, 61, 45, 227, 20, 158, 66, 213, 115, 9, 251, 4, 83, 116, 94, 23, 156, 153, 155, 68, 126, 173, 56, 134, 82, 31, 65, 128, 86, 114, 181, 222, 109, 13, 77, 120, 177, 139, 250, 176, 54, 221, 24, 241, 182, 50, 138, 165, 147, 159, 151, 242, 10, 79, 33, 235, 186, 133, 254, 2, 170, 58, 47, 140, 78, 205, 206, 34, 63, 215, 28, 67, 41, 144, 161, 64, 43, 57, 219, 111, 183, 135, 167, 60, 217, 198, 125, 88, 27, 239, 12, 249, 91, 25, 69, 211, 202, 208, 204, 121, 5, 168, 145, 246, 93, 195, 127, 1],
-[1, 86, 200, 238, 165, 55, 104, 206, 240, 80, 198, 66, 22, 93, 31, 96, 32, 182, 232, 163, 140, 218, 244, 167, 227, 247, 168, 56, 190, 149, 221, 245, 253, 170, 228, 76, 111, 37, 98, 204, 68, 194, 236, 250, 169, 142, 133, 130, 129, 43, 100, 119, 211, 156, 52, 103, 120, 40, 99, 33, 11, 175, 144, 48, 16, 91, 116, 210, 70, 109, 122, 212, 242, 252, 84, 28, 95, 203, 239, 251, 255, 85, 114, 38, 184, 147, 49, 102, 34, 97, 118, 125, 213, 71, 195, 65, 193, 150, 50, 188, 234, 78, 26, 180, 60, 20, 178, 145, 134, 216, 72, 24, 8, 174, 58, 105, 35, 183, 61, 106, 121, 126, 42, 14, 176, 230, 248, 254, 256, 171, 57, 19, 92, 202, 153, 51, 17, 177, 59, 191, 235, 164, 226, 161, 225, 75, 25, 94, 117, 39, 13, 90, 30, 10, 89, 201, 67, 108, 36, 12, 4, 87, 29, 181, 146, 220, 159, 53, 189, 63, 21, 7, 88, 115, 124, 127, 128, 214, 157, 138, 46, 101, 205, 154, 137, 217, 158, 224, 246, 82, 113, 209, 241, 166, 141, 47, 187, 148, 135, 45, 15, 5, 173, 229, 162, 54, 18, 6, 2, 172, 143, 219, 73, 110, 208, 155, 223, 160, 139, 132, 44, 186, 62, 192, 64, 107, 207, 69, 23, 179, 231, 77, 197, 237, 79, 112, 123, 41, 185, 233, 249, 83, 199, 152, 222, 74, 196, 151, 136, 131, 215, 243, 81, 27, 9, 3, 1],
-[1, 87, 116, 69, 92, 37, 135, 180, 240, 63, 84, 112, 235, 142, 18, 24, 32, 214, 114, 152, 117, 156, 208, 106, 227, 217, 118, 243, 67, 175, 62, 254, 253, 166, 50, 238, 146, 109, 231, 51, 68, 5, 178, 66, 88, 203, 185, 161, 129, 172, 58, 163, 46, 147, 196, 90, 120, 160, 42, 56, 246, 71, 9, 12, 16, 107, 57, 76, 187, 78, 104, 53, 242, 237, 59, 250, 162, 216, 31, 127, 255, 83, 25, 119, 73, 183, 244, 154, 34, 131, 89, 33, 44, 230, 221, 209, 193, 86, 29, 210, 23, 202, 98, 45, 60, 80, 21, 28, 123, 164, 133, 6, 8, 182, 157, 38, 222, 39, 52, 155, 121, 247, 158, 125, 81, 108, 144, 192, 256, 170, 141, 188, 165, 220, 122, 77, 17, 194, 173, 145, 22, 115, 239, 233, 225, 43, 143, 105, 140, 101, 49, 151, 30, 40, 139, 14, 190, 82, 195, 3, 4, 91, 207, 19, 111, 148, 26, 206, 189, 252, 79, 191, 169, 54, 72, 96, 128, 85, 199, 94, 211, 110, 61, 167, 137, 97, 215, 201, 11, 186, 248, 245, 241, 150, 200, 181, 70, 179, 153, 204, 15, 20, 198, 7, 95, 41, 226, 130, 2, 174, 232, 138, 184, 74, 13, 103, 223, 126, 168, 224, 213, 27, 36, 48, 64, 171, 228, 47, 234, 55, 159, 212, 197, 177, 236, 229, 134, 93, 124, 251, 249, 75, 100, 219, 35, 218, 205, 102, 136, 10, 99, 132, 176, 149, 113, 65, 1],
-[1, 88, 34, 165, 128, 213, 240, 46, 193, 22, 137, 234, 32, 246, 60, 140, 241, 134, 227, 187, 8, 190, 15, 35, 253, 162, 121, 111, 2, 176, 68, 73, 256, 169, 223, 92, 129, 44, 17, 211, 64, 235, 120, 23, 225, 11, 197, 117, 16, 123, 30, 70, 249, 67, 242, 222, 4, 95, 136, 146, 255, 81, 189, 184, 1, 88, 34, 165, 128, 213, 240, 46, 193, 22, 137, 234, 32, 246, 60, 140, 241, 134, 227, 187, 8, 190, 15, 35, 253, 162, 121, 111, 2, 176, 68, 73, 256, 169, 223, 92, 129, 44, 17, 211, 64, 235, 120, 23, 225, 11, 197, 117, 16, 123, 30, 70, 249, 67, 242, 222, 4, 95, 136, 146, 255, 81, 189, 184, 1, 88, 34, 165, 128, 213, 240, 46, 193, 22, 137, 234, 32, 246, 60, 140, 241, 134, 227, 187, 8, 190, 15, 35, 253, 162, 121, 111, 2, 176, 68, 73, 256, 169, 223, 92, 129, 44, 17, 211, 64, 235, 120, 23, 225, 11, 197, 117, 16, 123, 30, 70, 249, 67, 242, 222, 4, 95, 136, 146, 255, 81, 189, 184, 1, 88, 34, 165, 128, 213, 240, 46, 193, 22, 137, 234, 32, 246, 60, 140, 241, 134, 227, 187, 8, 190, 15, 35, 253, 162, 121, 111, 2, 176, 68, 73, 256, 169, 223, 92, 129, 44, 17, 211, 64, 235, 120, 23, 225, 11, 197, 117, 16, 123, 30, 70, 249, 67, 242, 222, 4, 95, 136, 146, 255, 81, 189, 184, 1],
-[1, 89, 211, 18, 60, 200, 67, 52, 2, 178, 165, 36, 120, 143, 134, 104, 4, 99, 73, 72, 240, 29, 11, 208, 8, 198, 146, 144, 223, 58, 22, 159, 16, 139, 35, 31, 189, 116, 44, 61, 32, 21, 70, 62, 121, 232, 88, 122, 64, 42, 140, 124, 242, 207, 176, 244, 128, 84, 23, 248, 227, 157, 95, 231, 256, 168, 46, 239, 197, 57, 190, 205, 255, 79, 92, 221, 137, 114, 123, 153, 253, 158, 184, 185, 17, 228, 246, 49, 249, 59, 111, 113, 34, 199, 235, 98, 241, 118, 222, 226, 68, 141, 213, 196, 225, 236, 187, 195, 136, 25, 169, 135, 193, 215, 117, 133, 15, 50, 81, 13, 129, 173, 234, 9, 30, 100, 162, 26, 1, 89, 211, 18, 60, 200, 67, 52, 2, 178, 165, 36, 120, 143, 134, 104, 4, 99, 73, 72, 240, 29, 11, 208, 8, 198, 146, 144, 223, 58, 22, 159, 16, 139, 35, 31, 189, 116, 44, 61, 32, 21, 70, 62, 121, 232, 88, 122, 64, 42, 140, 124, 242, 207, 176, 244, 128, 84, 23, 248, 227, 157, 95, 231, 256, 168, 46, 239, 197, 57, 190, 205, 255, 79, 92, 221, 137, 114, 123, 153, 253, 158, 184, 185, 17, 228, 246, 49, 249, 59, 111, 113, 34, 199, 235, 98, 241, 118, 222, 226, 68, 141, 213, 196, 225, 236, 187, 195, 136, 25, 169, 135, 193, 215, 117, 133, 15, 50, 81, 13, 129, 173, 234, 9, 30, 100, 162, 26, 1],
-[1, 90, 133, 148, 213, 152, 59, 170, 137, 251, 231, 230, 140, 7, 116, 160, 8, 206, 36, 156, 162, 188, 215, 75, 68, 209, 49, 41, 92, 56, 157, 252, 64, 106, 31, 220, 11, 219, 178, 86, 30, 130, 135, 71, 222, 191, 228, 217, 255, 77, 248, 218, 88, 210, 139, 174, 240, 12, 52, 54, 234, 243, 25, 194, 241, 102, 185, 202, 190, 138, 84, 107, 121, 96, 159, 175, 73, 145, 200, 10, 129, 45, 195, 74, 235, 76, 158, 85, 197, 254, 244, 115, 70, 132, 58, 80, 4, 103, 18, 78, 81, 94, 236, 166, 34, 233, 153, 149, 46, 28, 207, 126, 32, 53, 144, 110, 134, 238, 89, 43, 15, 65, 196, 164, 111, 224, 114, 237, 256, 167, 124, 109, 44, 105, 198, 87, 120, 6, 26, 27, 117, 250, 141, 97, 249, 51, 221, 101, 95, 69, 42, 182, 189, 48, 208, 216, 165, 201, 100, 5, 193, 151, 226, 37, 246, 38, 79, 171, 227, 127, 122, 186, 35, 66, 29, 40, 2, 180, 9, 39, 169, 47, 118, 83, 17, 245, 205, 203, 23, 14, 232, 63, 16, 155, 72, 55, 67, 119, 173, 150, 136, 161, 98, 82, 184, 112, 57, 247, 128, 212, 62, 183, 22, 181, 99, 172, 60, 3, 13, 142, 187, 125, 199, 177, 253, 154, 239, 179, 176, 163, 21, 91, 223, 24, 104, 108, 211, 229, 50, 131, 225, 204, 113, 147, 123, 19, 168, 214, 242, 192, 61, 93, 146, 33, 143, 20, 1],
-[1, 91, 57, 47, 165, 109, 153, 45, 240, 252, 59, 229, 22, 203, 226, 6, 32, 85, 25, 219, 140, 147, 13, 155, 227, 97, 89, 132, 190, 71, 36, 192, 253, 150, 29, 69, 111, 78, 159, 77, 68, 20, 21, 112, 169, 216, 124, 233, 129, 174, 157, 152, 211, 183, 205, 151, 120, 126, 158, 243, 11, 230, 113, 3, 16, 171, 141, 238, 70, 202, 135, 206, 242, 177, 173, 66, 95, 164, 18, 96, 255, 75, 143, 163, 184, 39, 208, 167, 34, 10, 139, 56, 213, 108, 62, 245, 193, 87, 207, 76, 234, 220, 231, 204, 60, 63, 79, 250, 134, 115, 185, 130, 8, 214, 199, 119, 35, 101, 196, 103, 121, 217, 215, 33, 176, 82, 9, 48, 256, 166, 200, 210, 92, 148, 104, 212, 17, 5, 198, 28, 235, 54, 31, 251, 225, 172, 232, 38, 117, 110, 244, 102, 30, 160, 168, 125, 67, 186, 221, 65, 4, 107, 228, 188, 146, 179, 98, 180, 189, 237, 236, 145, 88, 41, 133, 24, 128, 83, 100, 105, 46, 74, 52, 106, 137, 131, 99, 14, 246, 27, 144, 254, 241, 86, 116, 19, 187, 55, 122, 51, 15, 80, 84, 191, 162, 93, 239, 161, 2, 182, 114, 94, 73, 218, 49, 90, 223, 247, 118, 201, 44, 149, 195, 12, 64, 170, 50, 181, 23, 37, 26, 53, 197, 194, 178, 7, 123, 142, 72, 127, 249, 43, 58, 138, 222, 156, 61, 154, 136, 40, 42, 224, 81, 175, 248, 209, 1],
-[1, 92, 240, 235, 32, 117, 227, 67, 253, 146, 68, 88, 129, 46, 120, 246, 16, 187, 242, 162, 255, 73, 34, 44, 193, 23, 60, 123, 8, 222, 121, 81, 256, 165, 17, 22, 225, 140, 30, 190, 4, 111, 189, 169, 128, 211, 137, 11, 241, 70, 15, 95, 2, 184, 223, 213, 64, 234, 197, 134, 249, 35, 136, 176, 1, 92, 240, 235, 32, 117, 227, 67, 253, 146, 68, 88, 129, 46, 120, 246, 16, 187, 242, 162, 255, 73, 34, 44, 193, 23, 60, 123, 8, 222, 121, 81, 256, 165, 17, 22, 225, 140, 30, 190, 4, 111, 189, 169, 128, 211, 137, 11, 241, 70, 15, 95, 2, 184, 223, 213, 64, 234, 197, 134, 249, 35, 136, 176, 1, 92, 240, 235, 32, 117, 227, 67, 253, 146, 68, 88, 129, 46, 120, 246, 16, 187, 242, 162, 255, 73, 34, 44, 193, 23, 60, 123, 8, 222, 121, 81, 256, 165, 17, 22, 225, 140, 30, 190, 4, 111, 189, 169, 128, 211, 137, 11, 241, 70, 15, 95, 2, 184, 223, 213, 64, 234, 197, 134, 249, 35, 136, 176, 1, 92, 240, 235, 32, 117, 227, 67, 253, 146, 68, 88, 129, 46, 120, 246, 16, 187, 242, 162, 255, 73, 34, 44, 193, 23, 60, 123, 8, 222, 121, 81, 256, 165, 17, 22, 225, 140, 30, 190, 4, 111, 189, 169, 128, 211, 137, 11, 241, 70, 15, 95, 2, 184, 223, 213, 64, 234, 197, 134, 249, 35, 136, 176, 1],
-[1, 93, 168, 204, 211, 91, 239, 125, 60, 183, 57, 161, 67, 63, 205, 47, 2, 186, 79, 151, 165, 182, 221, 250, 120, 109, 114, 65, 134, 126, 153, 94, 4, 115, 158, 45, 73, 107, 185, 243, 240, 218, 228, 130, 11, 252, 49, 188, 8, 230, 59, 90, 146, 214, 113, 229, 223, 179, 199, 3, 22, 247, 98, 119, 16, 203, 118, 180, 35, 171, 226, 201, 189, 101, 141, 6, 44, 237, 196, 238, 32, 149, 236, 103, 70, 85, 195, 145, 121, 202, 25, 12, 88, 217, 135, 219, 64, 41, 215, 206, 140, 170, 133, 33, 242, 147, 50, 24, 176, 177, 13, 181, 128, 82, 173, 155, 23, 83, 9, 66, 227, 37, 100, 48, 95, 97, 26, 105, 256, 164, 89, 53, 46, 166, 18, 132, 197, 74, 200, 96, 190, 194, 52, 210, 255, 71, 178, 106, 92, 75, 36, 7, 137, 148, 143, 192, 123, 131, 104, 163, 253, 142, 99, 212, 184, 150, 72, 14, 17, 39, 29, 127, 246, 5, 208, 69, 249, 27, 198, 167, 111, 43, 144, 28, 34, 78, 58, 254, 235, 10, 159, 138, 241, 54, 139, 77, 222, 86, 31, 56, 68, 156, 116, 251, 213, 20, 61, 19, 225, 108, 21, 154, 187, 172, 62, 112, 136, 55, 232, 245, 169, 40, 122, 38, 193, 216, 42, 51, 117, 87, 124, 224, 15, 110, 207, 233, 81, 80, 244, 76, 129, 175, 84, 102, 234, 174, 248, 191, 30, 220, 157, 209, 162, 160, 231, 152, 1],
-[1, 94, 98, 217, 95, 192, 58, 55, 30, 250, 113, 85, 23, 106, 198, 108, 129, 47, 49, 237, 176, 96, 29, 156, 15, 125, 185, 171, 140, 53, 99, 54, 193, 152, 153, 247, 88, 48, 143, 78, 136, 191, 221, 214, 70, 155, 178, 27, 225, 76, 205, 252, 44, 24, 200, 39, 68, 224, 239, 107, 35, 206, 89, 142, 241, 38, 231, 126, 22, 12, 100, 148, 34, 112, 248, 182, 146, 103, 173, 71, 249, 19, 244, 63, 11, 6, 50, 74, 17, 56, 124, 91, 73, 180, 215, 164, 253, 138, 122, 160, 134, 3, 25, 37, 137, 28, 62, 174, 165, 90, 236, 82, 255, 69, 61, 80, 67, 130, 141, 147, 197, 14, 31, 87, 211, 45, 118, 41, 256, 163, 159, 40, 162, 65, 199, 202, 227, 7, 144, 172, 234, 151, 59, 149, 128, 210, 208, 20, 81, 161, 228, 101, 242, 132, 72, 86, 117, 204, 158, 203, 64, 105, 104, 10, 169, 209, 114, 179, 121, 66, 36, 43, 187, 102, 79, 230, 32, 181, 52, 5, 213, 233, 57, 218, 189, 33, 18, 150, 222, 51, 168, 115, 16, 219, 26, 131, 235, 245, 157, 109, 223, 145, 9, 75, 111, 154, 84, 186, 8, 238, 13, 194, 246, 251, 207, 183, 240, 201, 133, 166, 184, 77, 42, 93, 4, 119, 135, 97, 123, 254, 232, 220, 120, 229, 195, 83, 92, 167, 21, 175, 2, 188, 196, 177, 190, 127, 116, 110, 60, 243, 226, 170, 46, 212, 139, 216, 1],
-[1, 95, 30, 23, 129, 176, 15, 140, 193, 88, 136, 70, 225, 44, 68, 35, 241, 22, 34, 146, 249, 11, 17, 73, 253, 134, 137, 165, 255, 67, 197, 211, 256, 162, 227, 234, 128, 81, 242, 117, 64, 169, 121, 187, 32, 213, 189, 222, 16, 235, 223, 111, 8, 246, 240, 184, 4, 123, 120, 92, 2, 190, 60, 46, 1, 95, 30, 23, 129, 176, 15, 140, 193, 88, 136, 70, 225, 44, 68, 35, 241, 22, 34, 146, 249, 11, 17, 73, 253, 134, 137, 165, 255, 67, 197, 211, 256, 162, 227, 234, 128, 81, 242, 117, 64, 169, 121, 187, 32, 213, 189, 222, 16, 235, 223, 111, 8, 246, 240, 184, 4, 123, 120, 92, 2, 190, 60, 46, 1, 95, 30, 23, 129, 176, 15, 140, 193, 88, 136, 70, 225, 44, 68, 35, 241, 22, 34, 146, 249, 11, 17, 73, 253, 134, 137, 165, 255, 67, 197, 211, 256, 162, 227, 234, 128, 81, 242, 117, 64, 169, 121, 187, 32, 213, 189, 222, 16, 235, 223, 111, 8, 246, 240, 184, 4, 123, 120, 92, 2, 190, 60, 46, 1, 95, 30, 23, 129, 176, 15, 140, 193, 88, 136, 70, 225, 44, 68, 35, 241, 22, 34, 146, 249, 11, 17, 73, 253, 134, 137, 165, 255, 67, 197, 211, 256, 162, 227, 234, 128, 81, 242, 117, 64, 169, 121, 187, 32, 213, 189, 222, 16, 235, 223, 111, 8, 246, 240, 184, 4, 123, 120, 92, 2, 190, 60, 46, 1],
-[1, 96, 221, 142, 11, 28, 118, 20, 121, 51, 13, 220, 46, 47, 143, 107, 249, 3, 31, 149, 169, 33, 84, 97, 60, 106, 153, 39, 146, 138, 141, 172, 64, 233, 9, 93, 190, 250, 99, 252, 34, 180, 61, 202, 117, 181, 157, 166, 2, 192, 185, 27, 22, 56, 236, 40, 242, 102, 26, 183, 92, 94, 29, 214, 241, 6, 62, 41, 81, 66, 168, 194, 120, 212, 49, 78, 35, 19, 25, 87, 128, 209, 18, 186, 123, 243, 198, 247, 68, 103, 122, 147, 234, 105, 57, 75, 4, 127, 113, 54, 44, 112, 215, 80, 227, 204, 52, 109, 184, 188, 58, 171, 225, 12, 124, 82, 162, 132, 79, 131, 240, 167, 98, 156, 70, 38, 50, 174, 256, 161, 36, 115, 246, 229, 139, 237, 136, 206, 244, 37, 211, 210, 114, 150, 8, 254, 226, 108, 88, 224, 173, 160, 197, 151, 104, 218, 111, 119, 116, 85, 193, 24, 248, 164, 67, 7, 158, 5, 223, 77, 196, 55, 140, 76, 100, 91, 255, 65, 72, 230, 235, 201, 21, 217, 15, 155, 231, 74, 165, 163, 228, 43, 16, 251, 195, 216, 176, 191, 89, 63, 137, 45, 208, 179, 222, 238, 232, 170, 129, 48, 239, 71, 134, 14, 59, 10, 189, 154, 135, 110, 23, 152, 200, 182, 253, 130, 144, 203, 213, 145, 42, 177, 30, 53, 205, 148, 73, 69, 199, 86, 32, 245, 133, 175, 95, 125, 178, 126, 17, 90, 159, 101, 187, 219, 207, 83, 1],
-[1, 97, 157, 66, 234, 82, 244, 24, 15, 170, 42, 219, 169, 202, 62, 103, 225, 237, 116, 201, 222, 203, 159, 3, 34, 214, 198, 188, 246, 218, 72, 45, 253, 126, 143, 250, 92, 186, 52, 161, 197, 91, 89, 152, 95, 220, 9, 102, 128, 80, 50, 224, 140, 216, 135, 245, 121, 172, 236, 19, 44, 156, 226, 77, 16, 10, 199, 28, 146, 27, 49, 127, 240, 150, 158, 163, 134, 148, 221, 106, 2, 194, 57, 132, 211, 164, 231, 48, 30, 83, 84, 181, 81, 147, 124, 206, 193, 217, 232, 145, 187, 149, 61, 6, 68, 171, 139, 119, 235, 179, 144, 90, 249, 252, 29, 243, 184, 115, 104, 65, 137, 182, 178, 47, 190, 183, 18, 204, 256, 160, 100, 191, 23, 175, 13, 233, 242, 87, 215, 38, 88, 55, 195, 154, 32, 20, 141, 56, 35, 54, 98, 254, 223, 43, 59, 69, 11, 39, 185, 212, 4, 131, 114, 7, 165, 71, 205, 96, 60, 166, 168, 105, 162, 37, 248, 155, 129, 177, 207, 33, 117, 41, 122, 12, 136, 85, 21, 238, 213, 101, 31, 180, 241, 247, 58, 229, 111, 230, 208, 130, 17, 107, 99, 94, 123, 109, 36, 151, 255, 63, 200, 125, 46, 93, 26, 209, 227, 174, 173, 76, 176, 110, 133, 51, 64, 40, 25, 112, 70, 108, 196, 251, 189, 86, 118, 138, 22, 78, 113, 167, 8, 5, 228, 14, 73, 142, 153, 192, 120, 75, 79, 210, 67, 74, 239, 53, 1],
-[1, 98, 95, 58, 30, 113, 23, 198, 129, 49, 176, 29, 15, 185, 140, 99, 193, 153, 88, 143, 136, 221, 70, 178, 225, 205, 44, 200, 68, 239, 35, 89, 241, 231, 22, 100, 34, 248, 146, 173, 249, 244, 11, 50, 17, 124, 73, 215, 253, 122, 134, 25, 137, 62, 165, 236, 255, 61, 67, 141, 197, 31, 211, 118, 256, 159, 162, 199, 227, 144, 234, 59, 128, 208, 81, 228, 242, 72, 117, 158, 64, 104, 169, 114, 121, 36, 187, 79, 32, 52, 213, 57, 189, 18, 222, 168, 16, 26, 235, 157, 223, 9, 111, 84, 8, 13, 246, 207, 240, 133, 184, 42, 4, 135, 123, 232, 120, 195, 92, 21, 2, 196, 190, 116, 60, 226, 46, 139, 1, 98, 95, 58, 30, 113, 23, 198, 129, 49, 176, 29, 15, 185, 140, 99, 193, 153, 88, 143, 136, 221, 70, 178, 225, 205, 44, 200, 68, 239, 35, 89, 241, 231, 22, 100, 34, 248, 146, 173, 249, 244, 11, 50, 17, 124, 73, 215, 253, 122, 134, 25, 137, 62, 165, 236, 255, 61, 67, 141, 197, 31, 211, 118, 256, 159, 162, 199, 227, 144, 234, 59, 128, 208, 81, 228, 242, 72, 117, 158, 64, 104, 169, 114, 121, 36, 187, 79, 32, 52, 213, 57, 189, 18, 222, 168, 16, 26, 235, 157, 223, 9, 111, 84, 8, 13, 246, 207, 240, 133, 184, 42, 4, 135, 123, 232, 120, 195, 92, 21, 2, 196, 190, 116, 60, 226, 46, 139, 1],
-[1, 99, 35, 124, 197, 228, 213, 13, 2, 198, 70, 248, 137, 199, 169, 26, 4, 139, 140, 239, 17, 141, 81, 52, 8, 21, 23, 221, 34, 25, 162, 104, 16, 42, 46, 185, 68, 50, 67, 208, 32, 84, 92, 113, 136, 100, 134, 159, 64, 168, 184, 226, 15, 200, 11, 61, 128, 79, 111, 195, 30, 143, 22, 122, 256, 158, 222, 133, 60, 29, 44, 244, 255, 59, 187, 9, 120, 58, 88, 231, 253, 118, 117, 18, 240, 116, 176, 205, 249, 236, 234, 36, 223, 232, 95, 153, 241, 215, 211, 72, 189, 207, 190, 49, 225, 173, 165, 144, 121, 157, 123, 98, 193, 89, 73, 31, 242, 57, 246, 196, 129, 178, 146, 62, 227, 114, 235, 135, 1, 99, 35, 124, 197, 228, 213, 13, 2, 198, 70, 248, 137, 199, 169, 26, 4, 139, 140, 239, 17, 141, 81, 52, 8, 21, 23, 221, 34, 25, 162, 104, 16, 42, 46, 185, 68, 50, 67, 208, 32, 84, 92, 113, 136, 100, 134, 159, 64, 168, 184, 226, 15, 200, 11, 61, 128, 79, 111, 195, 30, 143, 22, 122, 256, 158, 222, 133, 60, 29, 44, 244, 255, 59, 187, 9, 120, 58, 88, 231, 253, 118, 117, 18, 240, 116, 176, 205, 249, 236, 234, 36, 223, 232, 95, 153, 241, 215, 211, 72, 189, 207, 190, 49, 225, 173, 165, 144, 121, 157, 123, 98, 193, 89, 73, 31, 242, 57, 246, 196, 129, 178, 146, 62, 227, 114, 235, 135, 1],
-[1, 100, 234, 13, 15, 215, 169, 195, 225, 141, 222, 98, 34, 59, 246, 185, 253, 114, 92, 205, 197, 168, 95, 248, 128, 207, 140, 122, 121, 21, 44, 31, 16, 58, 146, 208, 240, 99, 134, 36, 2, 200, 211, 26, 30, 173, 81, 133, 193, 25, 187, 196, 68, 118, 235, 113, 249, 228, 184, 153, 137, 79, 190, 239, 256, 157, 23, 244, 242, 42, 88, 62, 32, 116, 35, 159, 223, 198, 11, 72, 4, 143, 165, 52, 60, 89, 162, 9, 129, 50, 117, 135, 136, 236, 213, 226, 241, 199, 111, 49, 17, 158, 123, 221, 255, 57, 46, 231, 227, 84, 176, 124, 64, 232, 70, 61, 189, 139, 22, 144, 8, 29, 73, 104, 120, 178, 67, 18, 1, 100, 234, 13, 15, 215, 169, 195, 225, 141, 222, 98, 34, 59, 246, 185, 253, 114, 92, 205, 197, 168, 95, 248, 128, 207, 140, 122, 121, 21, 44, 31, 16, 58, 146, 208, 240, 99, 134, 36, 2, 200, 211, 26, 30, 173, 81, 133, 193, 25, 187, 196, 68, 118, 235, 113, 249, 228, 184, 153, 137, 79, 190, 239, 256, 157, 23, 244, 242, 42, 88, 62, 32, 116, 35, 159, 223, 198, 11, 72, 4, 143, 165, 52, 60, 89, 162, 9, 129, 50, 117, 135, 136, 236, 213, 226, 241, 199, 111, 49, 17, 158, 123, 221, 255, 57, 46, 231, 227, 84, 176, 124, 64, 232, 70, 61, 189, 139, 22, 144, 8, 29, 73, 104, 120, 178, 67, 18, 1],
-[1, 101, 178, 245, 73, 177, 144, 152, 189, 71, 232, 45, 176, 43, 231, 201, 255, 55, 158, 24, 111, 160, 226, 210, 136, 115, 50, 167, 162, 171, 52, 112, 4, 147, 198, 209, 35, 194, 62, 94, 242, 27, 157, 180, 190, 172, 153, 33, 249, 220, 118, 96, 187, 126, 133, 69, 30, 203, 200, 154, 134, 170, 208, 191, 16, 74, 21, 65, 140, 5, 248, 119, 197, 108, 114, 206, 246, 174, 98, 132, 225, 109, 215, 127, 234, 247, 18, 19, 120, 41, 29, 102, 22, 166, 61, 250, 64, 39, 84, 3, 46, 20, 221, 219, 17, 175, 199, 53, 213, 182, 135, 14, 129, 179, 89, 251, 165, 217, 72, 76, 223, 164, 116, 151, 88, 150, 244, 229, 256, 156, 79, 12, 184, 80, 113, 105, 68, 186, 25, 212, 81, 214, 26, 56, 2, 202, 99, 233, 146, 97, 31, 47, 121, 142, 207, 90, 95, 86, 205, 145, 253, 110, 59, 48, 222, 63, 195, 163, 15, 230, 100, 77, 67, 85, 104, 224, 8, 37, 139, 161, 70, 131, 124, 188, 227, 54, 57, 103, 123, 87, 49, 66, 241, 183, 236, 192, 117, 252, 9, 138, 60, 149, 143, 51, 11, 83, 159, 125, 32, 148, 42, 130, 23, 10, 239, 238, 137, 216, 228, 155, 235, 91, 196, 7, 193, 218, 173, 254, 211, 237, 36, 38, 240, 82, 58, 204, 44, 75, 122, 243, 128, 78, 168, 6, 92, 40, 185, 181, 34, 93, 141, 106, 169, 107, 13, 28, 1],
-[1, 102, 124, 55, 213, 138, 198, 150, 137, 96, 26, 82, 140, 145, 141, 247, 8, 45, 221, 183, 162, 76, 42, 172, 68, 254, 208, 142, 92, 132, 100, 177, 64, 103, 226, 179, 11, 94, 79, 91, 30, 233, 122, 108, 222, 28, 29, 131, 255, 53, 9, 147, 88, 238, 118, 214, 240, 65, 205, 93, 234, 224, 232, 20, 241, 167, 72, 148, 190, 105, 173, 170, 121, 6, 98, 230, 73, 250, 57, 160, 129, 51, 62, 156, 235, 69, 99, 75, 197, 48, 13, 41, 70, 201, 199, 252, 4, 151, 239, 220, 81, 38, 21, 86, 34, 127, 104, 71, 46, 66, 50, 217, 32, 180, 113, 218, 134, 47, 168, 174, 15, 245, 61, 54, 111, 14, 143, 194, 256, 155, 133, 202, 44, 119, 59, 107, 120, 161, 231, 175, 117, 112, 116, 10, 249, 212, 36, 74, 95, 181, 215, 85, 189, 3, 49, 115, 165, 125, 157, 80, 193, 154, 31, 78, 246, 163, 178, 166, 227, 24, 135, 149, 35, 229, 228, 126, 2, 204, 248, 110, 169, 19, 139, 43, 17, 192, 52, 164, 23, 33, 25, 237, 16, 90, 185, 109, 67, 152, 84, 87, 136, 251, 159, 27, 184, 7, 200, 97, 128, 206, 195, 101, 22, 188, 158, 182, 60, 209, 244, 216, 187, 56, 58, 5, 253, 106, 18, 37, 176, 219, 236, 171, 223, 130, 153, 186, 211, 191, 207, 40, 225, 77, 144, 39, 123, 210, 89, 83, 242, 12, 196, 203, 146, 243, 114, 63, 1],
-[1, 103, 72, 220, 44, 163, 84, 171, 137, 233, 98, 71, 117, 229, 200, 40, 8, 53, 62, 218, 95, 19, 158, 83, 68, 65, 13, 54, 165, 33, 58, 63, 64, 167, 239, 202, 246, 152, 236, 150, 30, 6, 104, 175, 35, 7, 207, 247, 255, 51, 113, 74, 169, 188, 89, 172, 240, 48, 61, 115, 23, 56, 114, 177, 241, 151, 133, 78, 67, 219, 198, 91, 121, 127, 231, 149, 184, 191, 141, 131, 129, 180, 36, 110, 22, 210, 42, 214, 197, 245, 49, 164, 187, 243, 100, 20, 4, 155, 31, 109, 176, 138, 79, 170, 34, 161, 135, 27, 211, 145, 29, 160, 32, 212, 248, 101, 123, 76, 118, 75, 15, 3, 52, 216, 146, 132, 232, 252, 256, 154, 185, 37, 213, 94, 173, 86, 120, 24, 159, 186, 140, 28, 57, 217, 249, 204, 195, 39, 162, 238, 99, 174, 189, 192, 244, 203, 92, 224, 199, 194, 193, 90, 18, 55, 11, 105, 21, 107, 227, 251, 153, 82, 222, 250, 50, 10, 2, 206, 144, 183, 88, 69, 168, 85, 17, 209, 196, 142, 234, 201, 143, 80, 16, 106, 124, 179, 190, 38, 59, 166, 136, 130, 26, 108, 73, 66, 116, 126, 128, 77, 221, 147, 235, 47, 215, 43, 60, 12, 208, 93, 70, 14, 157, 237, 253, 102, 226, 148, 81, 119, 178, 87, 223, 96, 122, 230, 46, 112, 228, 97, 225, 45, 9, 156, 134, 181, 139, 182, 242, 254, 205, 41, 111, 125, 25, 5, 1],
-[1, 104, 22, 232, 227, 221, 111, 236, 129, 52, 11, 116, 242, 239, 184, 118, 193, 26, 134, 58, 121, 248, 92, 59, 225, 13, 67, 29, 189, 124, 46, 158, 241, 135, 162, 143, 223, 62, 23, 79, 249, 196, 81, 200, 240, 31, 140, 168, 253, 98, 169, 100, 120, 144, 70, 84, 255, 49, 213, 50, 60, 72, 35, 42, 256, 153, 235, 25, 30, 36, 146, 21, 128, 205, 246, 141, 15, 18, 73, 139, 64, 231, 123, 199, 136, 9, 165, 198, 32, 244, 190, 228, 68, 133, 211, 99, 16, 122, 95, 114, 34, 195, 234, 178, 8, 61, 176, 57, 17, 226, 117, 89, 4, 159, 88, 157, 137, 113, 187, 173, 2, 208, 44, 207, 197, 185, 222, 215, 1, 104, 22, 232, 227, 221, 111, 236, 129, 52, 11, 116, 242, 239, 184, 118, 193, 26, 134, 58, 121, 248, 92, 59, 225, 13, 67, 29, 189, 124, 46, 158, 241, 135, 162, 143, 223, 62, 23, 79, 249, 196, 81, 200, 240, 31, 140, 168, 253, 98, 169, 100, 120, 144, 70, 84, 255, 49, 213, 50, 60, 72, 35, 42, 256, 153, 235, 25, 30, 36, 146, 21, 128, 205, 246, 141, 15, 18, 73, 139, 64, 231, 123, 199, 136, 9, 165, 198, 32, 244, 190, 228, 68, 133, 211, 99, 16, 122, 95, 114, 34, 195, 234, 178, 8, 61, 176, 57, 17, 226, 117, 89, 4, 159, 88, 157, 137, 113, 187, 173, 2, 208, 44, 207, 197, 185, 222, 215, 1],
-[1, 105, 231, 97, 162, 48, 157, 37, 30, 66, 248, 83, 234, 155, 84, 82, 129, 181, 244, 177, 81, 24, 207, 147, 15, 33, 124, 170, 117, 206, 42, 41, 193, 219, 122, 217, 169, 12, 232, 202, 136, 145, 62, 85, 187, 103, 21, 149, 225, 238, 61, 237, 213, 6, 116, 101, 68, 201, 31, 171, 222, 180, 139, 203, 241, 119, 159, 247, 235, 3, 58, 179, 34, 229, 144, 214, 111, 90, 198, 230, 249, 188, 208, 252, 246, 130, 29, 218, 17, 243, 72, 107, 184, 45, 99, 115, 253, 94, 104, 126, 123, 65, 143, 109, 137, 250, 36, 182, 92, 151, 178, 186, 255, 47, 52, 63, 190, 161, 200, 183, 197, 125, 18, 91, 46, 204, 89, 93, 256, 152, 26, 160, 95, 209, 100, 220, 227, 191, 9, 174, 23, 102, 173, 175, 128, 76, 13, 80, 176, 233, 50, 110, 242, 224, 133, 87, 140, 51, 215, 216, 64, 38, 135, 40, 88, 245, 25, 55, 121, 112, 195, 172, 70, 154, 236, 108, 32, 19, 196, 20, 44, 251, 141, 156, 189, 56, 226, 86, 35, 77, 118, 54, 16, 138, 98, 10, 22, 254, 199, 78, 223, 28, 113, 43, 146, 167, 59, 27, 8, 69, 49, 5, 11, 127, 228, 39, 240, 14, 185, 150, 73, 212, 158, 142, 4, 163, 153, 131, 134, 192, 114, 148, 120, 7, 221, 75, 165, 106, 79, 71, 2, 210, 205, 194, 67, 96, 57, 74, 60, 132, 239, 166, 211, 53, 168, 164, 1],
-[1, 106, 185, 78, 44, 38, 173, 91, 137, 130, 159, 149, 117, 66, 57, 131, 8, 77, 195, 110, 95, 47, 99, 214, 68, 12, 244, 164, 165, 14, 199, 20, 64, 102, 18, 109, 246, 119, 21, 170, 30, 96, 153, 27, 35, 112, 50, 160, 255, 45, 144, 101, 169, 181, 168, 75, 240, 254, 196, 216, 23, 125, 143, 252, 241, 103, 124, 37, 67, 163, 59, 86, 121, 233, 26, 186, 184, 229, 116, 217, 129, 53, 221, 39, 22, 19, 215, 174, 197, 65, 208, 203, 187, 33, 157, 194, 4, 167, 226, 55, 176, 152, 178, 107, 34, 6, 122, 82, 211, 7, 228, 10, 32, 51, 9, 183, 123, 188, 139, 85, 15, 48, 205, 142, 146, 56, 25, 80, 256, 151, 72, 179, 213, 219, 84, 166, 120, 127, 98, 108, 140, 191, 200, 126, 249, 180, 62, 147, 162, 210, 158, 43, 189, 245, 13, 93, 92, 243, 58, 237, 193, 155, 239, 148, 11, 138, 236, 87, 227, 161, 104, 230, 222, 145, 207, 97, 2, 212, 113, 156, 88, 76, 89, 182, 17, 3, 61, 41, 234, 132, 114, 5, 16, 154, 133, 220, 190, 94, 198, 171, 136, 24, 231, 71, 73, 28, 141, 40, 128, 204, 36, 218, 235, 238, 42, 83, 60, 192, 49, 54, 70, 224, 100, 63, 253, 90, 31, 202, 81, 105, 79, 150, 223, 251, 135, 175, 46, 250, 29, 247, 225, 206, 248, 74, 134, 69, 118, 172, 242, 209, 52, 115, 111, 201, 232, 177, 1],
-[1, 107, 141, 181, 92, 78, 122, 204, 240, 237, 173, 7, 235, 216, 239, 130, 32, 83, 143, 138, 117, 183, 49, 103, 227, 131, 139, 224, 67, 230, 195, 48, 253, 86, 207, 47, 146, 202, 26, 212, 68, 80, 79, 229, 88, 164, 72, 251, 129, 182, 199, 219, 46, 39, 61, 102, 120, 247, 215, 132, 246, 108, 248, 65, 16, 170, 200, 69, 187, 220, 153, 180, 242, 194, 198, 112, 162, 115, 226, 24, 255, 43, 232, 152, 73, 101, 13, 106, 34, 40, 168, 243, 44, 82, 36, 254, 193, 91, 228, 238, 23, 148, 159, 51, 60, 252, 236, 66, 123, 54, 124, 161, 8, 85, 100, 163, 222, 110, 205, 90, 121, 97, 99, 56, 81, 186, 113, 12, 256, 150, 116, 76, 165, 179, 135, 53, 17, 20, 84, 250, 22, 41, 18, 127, 225, 174, 114, 119, 140, 74, 208, 154, 30, 126, 118, 33, 190, 27, 62, 209, 4, 171, 50, 210, 111, 55, 231, 45, 189, 177, 178, 28, 169, 93, 185, 6, 128, 75, 58, 38, 211, 218, 196, 155, 137, 10, 42, 125, 11, 149, 9, 192, 241, 87, 57, 188, 70, 37, 104, 77, 15, 63, 59, 145, 95, 142, 31, 233, 2, 214, 25, 105, 184, 156, 244, 151, 223, 217, 89, 14, 213, 175, 221, 3, 64, 166, 29, 19, 234, 109, 98, 206, 197, 5, 21, 191, 134, 203, 133, 96, 249, 172, 157, 94, 35, 147, 52, 167, 136, 160, 158, 201, 176, 71, 144, 245, 1],
-[1, 108, 99, 155, 35, 182, 124, 28, 197, 202, 228, 209, 213, 131, 13, 119, 2, 216, 198, 53, 70, 107, 248, 56, 137, 147, 199, 161, 169, 5, 26, 238, 4, 175, 139, 106, 140, 214, 239, 112, 17, 37, 141, 65, 81, 10, 52, 219, 8, 93, 21, 212, 23, 171, 221, 224, 34, 74, 25, 130, 162, 20, 104, 181, 16, 186, 42, 167, 46, 85, 185, 191, 68, 148, 50, 3, 67, 40, 208, 105, 32, 115, 84, 77, 92, 170, 113, 125, 136, 39, 100, 6, 134, 80, 159, 210, 64, 230, 168, 154, 184, 83, 226, 250, 15, 78, 200, 12, 11, 160, 61, 163, 128, 203, 79, 51, 111, 166, 195, 243, 30, 156, 143, 24, 22, 63, 122, 69, 256, 149, 158, 102, 222, 75, 133, 229, 60, 55, 29, 48, 44, 126, 244, 138, 255, 41, 59, 204, 187, 150, 9, 201, 120, 110, 58, 96, 88, 252, 231, 19, 253, 82, 118, 151, 117, 43, 18, 145, 240, 220, 116, 192, 176, 247, 205, 38, 249, 164, 236, 45, 234, 86, 36, 33, 223, 183, 232, 127, 95, 237, 153, 76, 241, 71, 215, 90, 211, 172, 72, 66, 189, 109, 207, 254, 190, 217, 49, 152, 225, 142, 173, 180, 165, 87, 144, 132, 121, 218, 157, 251, 123, 177, 98, 47, 193, 27, 89, 103, 73, 174, 31, 7, 242, 179, 57, 245, 246, 97, 196, 94, 129, 54, 178, 206, 146, 91, 62, 14, 227, 101, 114, 233, 235, 194, 135, 188, 1],
-[1, 109, 59, 6, 140, 97, 36, 69, 68, 216, 157, 151, 11, 171, 135, 66, 255, 39, 139, 245, 234, 63, 185, 119, 121, 82, 200, 212, 235, 172, 244, 125, 4, 179, 236, 24, 46, 131, 144, 19, 15, 93, 114, 90, 44, 170, 26, 7, 249, 156, 42, 209, 165, 252, 226, 219, 227, 71, 29, 77, 169, 174, 205, 243, 16, 202, 173, 96, 184, 10, 62, 76, 60, 115, 199, 103, 176, 166, 104, 28, 225, 110, 168, 65, 146, 237, 133, 105, 137, 27, 116, 51, 162, 182, 49, 201, 64, 37, 178, 127, 222, 40, 248, 47, 240, 203, 25, 155, 190, 150, 159, 112, 129, 183, 158, 3, 70, 177, 18, 163, 34, 108, 207, 204, 134, 214, 196, 33, 256, 148, 198, 251, 117, 160, 221, 188, 189, 41, 100, 106, 246, 86, 122, 191, 2, 218, 118, 12, 23, 194, 72, 138, 136, 175, 57, 45, 22, 85, 13, 132, 253, 78, 21, 233, 211, 126, 113, 238, 242, 164, 143, 167, 213, 87, 231, 250, 8, 101, 215, 48, 92, 5, 31, 38, 30, 186, 228, 180, 88, 83, 52, 14, 241, 55, 84, 161, 73, 247, 195, 181, 197, 142, 58, 154, 81, 91, 153, 229, 32, 147, 89, 192, 111, 20, 124, 152, 120, 230, 141, 206, 95, 75, 208, 56, 193, 220, 79, 130, 35, 217, 9, 210, 17, 54, 232, 102, 67, 107, 98, 145, 128, 74, 99, 254, 187, 80, 239, 94, 223, 149, 50, 53, 123, 43, 61, 224, 1],
-[1, 110, 21, 254, 184, 194, 9, 219, 189, 230, 114, 204, 81, 172, 159, 14, 255, 37, 215, 6, 146, 126, 239, 76, 136, 54, 29, 106, 95, 170, 196, 229, 4, 183, 84, 245, 222, 5, 36, 105, 242, 149, 199, 45, 67, 174, 122, 56, 249, 148, 89, 24, 70, 247, 185, 47, 30, 216, 116, 167, 123, 166, 13, 145, 16, 218, 79, 209, 117, 20, 144, 163, 197, 82, 25, 180, 11, 182, 231, 224, 225, 78, 99, 96, 23, 217, 226, 188, 120, 93, 207, 154, 235, 150, 52, 66, 64, 101, 59, 65, 211, 80, 62, 138, 17, 71, 100, 206, 44, 214, 153, 125, 129, 55, 139, 127, 92, 97, 133, 238, 223, 115, 57, 102, 169, 86, 208, 7, 256, 147, 236, 3, 73, 63, 248, 38, 68, 27, 143, 53, 176, 85, 98, 243, 2, 220, 42, 251, 111, 131, 18, 181, 121, 203, 228, 151, 162, 87, 61, 28, 253, 74, 173, 12, 35, 252, 221, 152, 15, 108, 58, 212, 190, 83, 135, 201, 8, 109, 168, 233, 187, 10, 72, 210, 227, 41, 141, 90, 134, 91, 244, 112, 241, 39, 178, 48, 140, 237, 113, 94, 60, 175, 232, 77, 246, 75, 26, 33, 32, 179, 158, 161, 234, 40, 31, 69, 137, 164, 50, 103, 22, 107, 205, 191, 193, 156, 198, 192, 46, 177, 195, 119, 240, 186, 157, 51, 213, 43, 104, 132, 128, 202, 118, 130, 165, 160, 124, 19, 34, 142, 200, 155, 88, 171, 49, 250, 1],
-[1, 111, 242, 134, 225, 46, 223, 81, 253, 70, 60, 235, 128, 73, 136, 190, 16, 234, 17, 88, 2, 222, 227, 11, 193, 92, 189, 162, 249, 140, 120, 213, 256, 146, 15, 123, 32, 211, 34, 176, 4, 187, 197, 22, 129, 184, 121, 67, 241, 23, 240, 169, 255, 35, 30, 246, 64, 165, 68, 95, 8, 117, 137, 44, 1, 111, 242, 134, 225, 46, 223, 81, 253, 70, 60, 235, 128, 73, 136, 190, 16, 234, 17, 88, 2, 222, 227, 11, 193, 92, 189, 162, 249, 140, 120, 213, 256, 146, 15, 123, 32, 211, 34, 176, 4, 187, 197, 22, 129, 184, 121, 67, 241, 23, 240, 169, 255, 35, 30, 246, 64, 165, 68, 95, 8, 117, 137, 44, 1, 111, 242, 134, 225, 46, 223, 81, 253, 70, 60, 235, 128, 73, 136, 190, 16, 234, 17, 88, 2, 222, 227, 11, 193, 92, 189, 162, 249, 140, 120, 213, 256, 146, 15, 123, 32, 211, 34, 176, 4, 187, 197, 22, 129, 184, 121, 67, 241, 23, 240, 169, 255, 35, 30, 246, 64, 165, 68, 95, 8, 117, 137, 44, 1, 111, 242, 134, 225, 46, 223, 81, 253, 70, 60, 235, 128, 73, 136, 190, 16, 234, 17, 88, 2, 222, 227, 11, 193, 92, 189, 162, 249, 140, 120, 213, 256, 146, 15, 123, 32, 211, 34, 176, 4, 187, 197, 22, 129, 184, 121, 67, 241, 23, 240, 169, 255, 35, 30, 246, 64, 165, 68, 95, 8, 117, 137, 44, 1],
-[1, 112, 208, 166, 88, 90, 57, 216, 34, 210, 133, 247, 165, 233, 139, 148, 128, 201, 153, 174, 213, 212, 100, 149, 240, 152, 62, 5, 46, 12, 59, 183, 193, 28, 52, 170, 22, 151, 207, 54, 137, 181, 226, 126, 234, 251, 99, 37, 32, 243, 231, 172, 246, 53, 25, 230, 60, 38, 144, 194, 140, 3, 79, 110, 241, 7, 13, 171, 134, 102, 116, 142, 227, 238, 185, 160, 187, 127, 89, 202, 8, 125, 122, 43, 190, 206, 199, 186, 15, 138, 36, 177, 35, 65, 84, 156, 253, 66, 196, 107, 162, 154, 29, 164, 121, 188, 239, 40, 111, 96, 215, 179, 2, 224, 159, 75, 176, 180, 114, 175, 68, 163, 9, 237, 73, 209, 21, 39, 256, 145, 49, 91, 169, 167, 200, 41, 223, 47, 124, 10, 92, 24, 118, 109, 129, 56, 104, 83, 44, 45, 157, 108, 17, 105, 195, 252, 211, 245, 198, 74, 64, 229, 205, 87, 235, 106, 50, 203, 120, 76, 31, 131, 23, 6, 158, 220, 225, 14, 26, 85, 11, 204, 232, 27, 197, 219, 113, 63, 117, 254, 178, 147, 16, 250, 244, 86, 123, 155, 141, 115, 30, 19, 72, 97, 70, 130, 168, 55, 249, 132, 135, 214, 67, 51, 58, 71, 242, 119, 221, 80, 222, 192, 173, 101, 4, 191, 61, 150, 95, 103, 228, 93, 136, 69, 18, 217, 146, 161, 42, 78, 255, 33, 98, 182, 81, 77, 143, 82, 189, 94, 248, 20, 184, 48, 236, 218, 1],
-[1, 113, 176, 99, 136, 205, 35, 100, 249, 124, 134, 236, 197, 159, 234, 228, 64, 36, 213, 168, 223, 13, 184, 232, 2, 226, 95, 198, 15, 153, 70, 200, 241, 248, 11, 215, 137, 61, 211, 199, 128, 72, 169, 79, 189, 26, 111, 207, 4, 195, 190, 139, 30, 49, 140, 143, 225, 239, 22, 173, 17, 122, 165, 141, 256, 144, 81, 158, 121, 52, 222, 157, 8, 133, 123, 21, 60, 98, 23, 29, 193, 221, 44, 89, 34, 244, 73, 25, 255, 31, 162, 59, 242, 104, 187, 57, 16, 9, 246, 42, 120, 196, 46, 58, 129, 185, 88, 178, 68, 231, 146, 50, 253, 62, 67, 118, 227, 208, 117, 114, 32, 18, 235, 84, 240, 135, 92, 116, 1, 113, 176, 99, 136, 205, 35, 100, 249, 124, 134, 236, 197, 159, 234, 228, 64, 36, 213, 168, 223, 13, 184, 232, 2, 226, 95, 198, 15, 153, 70, 200, 241, 248, 11, 215, 137, 61, 211, 199, 128, 72, 169, 79, 189, 26, 111, 207, 4, 195, 190, 139, 30, 49, 140, 143, 225, 239, 22, 173, 17, 122, 165, 141, 256, 144, 81, 158, 121, 52, 222, 157, 8, 133, 123, 21, 60, 98, 23, 29, 193, 221, 44, 89, 34, 244, 73, 25, 255, 31, 162, 59, 242, 104, 187, 57, 16, 9, 246, 42, 120, 196, 46, 58, 129, 185, 88, 178, 68, 231, 146, 50, 253, 62, 67, 118, 227, 208, 117, 114, 32, 18, 235, 84, 240, 135, 92, 116, 1],
-[1, 114, 146, 196, 242, 89, 123, 144, 225, 207, 211, 153, 223, 236, 176, 18, 253, 58, 187, 244, 60, 158, 22, 195, 128, 200, 184, 159, 136, 84, 67, 185, 16, 25, 23, 52, 17, 139, 169, 248, 2, 228, 35, 135, 227, 178, 246, 31, 193, 157, 165, 49, 189, 215, 95, 36, 249, 116, 117, 231, 120, 59, 44, 133, 256, 143, 111, 61, 15, 168, 134, 113, 32, 50, 46, 104, 34, 21, 81, 239, 4, 199, 70, 13, 197, 99, 235, 62, 129, 57, 73, 98, 121, 173, 190, 72, 241, 232, 234, 205, 240, 118, 88, 9, 255, 29, 222, 122, 30, 79, 11, 226, 64, 100, 92, 208, 68, 42, 162, 221, 8, 141, 140, 26, 137, 198, 213, 124, 1, 114, 146, 196, 242, 89, 123, 144, 225, 207, 211, 153, 223, 236, 176, 18, 253, 58, 187, 244, 60, 158, 22, 195, 128, 200, 184, 159, 136, 84, 67, 185, 16, 25, 23, 52, 17, 139, 169, 248, 2, 228, 35, 135, 227, 178, 246, 31, 193, 157, 165, 49, 189, 215, 95, 36, 249, 116, 117, 231, 120, 59, 44, 133, 256, 143, 111, 61, 15, 168, 134, 113, 32, 50, 46, 104, 34, 21, 81, 239, 4, 199, 70, 13, 197, 99, 235, 62, 129, 57, 73, 98, 121, 173, 190, 72, 241, 232, 234, 205, 240, 118, 88, 9, 255, 29, 222, 122, 30, 79, 11, 226, 64, 100, 92, 208, 68, 42, 162, 221, 8, 141, 140, 26, 137, 198, 213, 124, 1],
-[1, 115, 118, 206, 46, 150, 31, 224, 60, 218, 141, 24, 190, 5, 61, 76, 2, 230, 236, 155, 92, 43, 62, 191, 120, 179, 25, 48, 123, 10, 122, 152, 4, 203, 215, 53, 184, 86, 124, 125, 240, 101, 50, 96, 246, 20, 244, 47, 8, 149, 173, 106, 111, 172, 248, 250, 223, 202, 100, 192, 235, 40, 231, 94, 16, 41, 89, 212, 222, 87, 239, 243, 189, 147, 200, 127, 213, 80, 205, 188, 32, 82, 178, 167, 187, 174, 221, 229, 121, 37, 143, 254, 169, 160, 153, 119, 64, 164, 99, 77, 117, 91, 185, 201, 242, 74, 29, 251, 81, 63, 49, 238, 128, 71, 198, 154, 234, 182, 113, 145, 227, 148, 58, 245, 162, 126, 98, 219, 256, 142, 139, 51, 211, 107, 226, 33, 197, 39, 116, 233, 67, 252, 196, 181, 255, 27, 21, 102, 165, 214, 195, 66, 137, 78, 232, 209, 134, 247, 135, 105, 253, 54, 42, 204, 73, 171, 133, 132, 17, 156, 207, 161, 11, 237, 13, 210, 249, 108, 84, 151, 146, 85, 9, 7, 34, 55, 157, 65, 22, 217, 26, 163, 241, 216, 168, 45, 35, 170, 18, 14, 68, 110, 57, 130, 44, 177, 52, 69, 225, 175, 79, 90, 70, 83, 36, 28, 136, 220, 114, 3, 88, 97, 104, 138, 193, 93, 158, 180, 140, 166, 72, 56, 15, 183, 228, 6, 176, 194, 208, 19, 129, 186, 59, 103, 23, 75, 144, 112, 30, 109, 199, 12, 95, 131, 159, 38, 1],
-[1, 116, 92, 135, 240, 84, 235, 18, 32, 114, 117, 208, 227, 118, 67, 62, 253, 50, 146, 231, 68, 178, 88, 185, 129, 58, 46, 196, 120, 42, 246, 9, 16, 57, 187, 104, 242, 59, 162, 31, 255, 25, 73, 244, 34, 89, 44, 221, 193, 29, 23, 98, 60, 21, 123, 133, 8, 157, 222, 52, 121, 158, 81, 144, 256, 141, 165, 122, 17, 173, 22, 239, 225, 143, 140, 49, 30, 139, 190, 195, 4, 207, 111, 26, 189, 79, 169, 72, 128, 199, 211, 61, 137, 215, 11, 248, 241, 200, 70, 153, 15, 198, 95, 226, 2, 232, 184, 13, 223, 168, 213, 36, 64, 228, 234, 159, 197, 236, 134, 124, 249, 100, 35, 205, 136, 99, 176, 113, 1, 116, 92, 135, 240, 84, 235, 18, 32, 114, 117, 208, 227, 118, 67, 62, 253, 50, 146, 231, 68, 178, 88, 185, 129, 58, 46, 196, 120, 42, 246, 9, 16, 57, 187, 104, 242, 59, 162, 31, 255, 25, 73, 244, 34, 89, 44, 221, 193, 29, 23, 98, 60, 21, 123, 133, 8, 157, 222, 52, 121, 158, 81, 144, 256, 141, 165, 122, 17, 173, 22, 239, 225, 143, 140, 49, 30, 139, 190, 195, 4, 207, 111, 26, 189, 79, 169, 72, 128, 199, 211, 61, 137, 215, 11, 248, 241, 200, 70, 153, 15, 198, 95, 226, 2, 232, 184, 13, 223, 168, 213, 36, 64, 228, 234, 159, 197, 236, 134, 124, 249, 100, 35, 205, 136, 99, 176, 113, 1],
-[1, 117, 68, 246, 255, 23, 121, 22, 4, 211, 15, 213, 249, 92, 227, 88, 16, 73, 60, 81, 225, 111, 137, 95, 64, 35, 240, 67, 129, 187, 34, 123, 256, 140, 189, 11, 2, 234, 136, 235, 253, 46, 242, 44, 8, 165, 30, 169, 241, 184, 197, 176, 32, 146, 120, 162, 193, 222, 17, 190, 128, 70, 223, 134, 1, 117, 68, 246, 255, 23, 121, 22, 4, 211, 15, 213, 249, 92, 227, 88, 16, 73, 60, 81, 225, 111, 137, 95, 64, 35, 240, 67, 129, 187, 34, 123, 256, 140, 189, 11, 2, 234, 136, 235, 253, 46, 242, 44, 8, 165, 30, 169, 241, 184, 197, 176, 32, 146, 120, 162, 193, 222, 17, 190, 128, 70, 223, 134, 1, 117, 68, 246, 255, 23, 121, 22, 4, 211, 15, 213, 249, 92, 227, 88, 16, 73, 60, 81, 225, 111, 137, 95, 64, 35, 240, 67, 129, 187, 34, 123, 256, 140, 189, 11, 2, 234, 136, 235, 253, 46, 242, 44, 8, 165, 30, 169, 241, 184, 197, 176, 32, 146, 120, 162, 193, 222, 17, 190, 128, 70, 223, 134, 1, 117, 68, 246, 255, 23, 121, 22, 4, 211, 15, 213, 249, 92, 227, 88, 16, 73, 60, 81, 225, 111, 137, 95, 64, 35, 240, 67, 129, 187, 34, 123, 256, 140, 189, 11, 2, 234, 136, 235, 253, 46, 242, 44, 8, 165, 30, 169, 241, 184, 197, 176, 32, 146, 120, 162, 193, 222, 17, 190, 128, 70, 223, 134, 1],
-[1, 118, 46, 31, 60, 141, 190, 61, 2, 236, 92, 62, 120, 25, 123, 122, 4, 215, 184, 124, 240, 50, 246, 244, 8, 173, 111, 248, 223, 100, 235, 231, 16, 89, 222, 239, 189, 200, 213, 205, 32, 178, 187, 221, 121, 143, 169, 153, 64, 99, 117, 185, 242, 29, 81, 49, 128, 198, 234, 113, 227, 58, 162, 98, 256, 139, 211, 226, 197, 116, 67, 196, 255, 21, 165, 195, 137, 232, 134, 135, 253, 42, 73, 133, 17, 207, 11, 13, 249, 84, 146, 9, 34, 157, 22, 26, 241, 168, 35, 18, 68, 57, 44, 52, 225, 79, 70, 36, 136, 114, 88, 104, 193, 158, 140, 72, 15, 228, 176, 208, 129, 59, 23, 144, 30, 199, 95, 159, 1, 118, 46, 31, 60, 141, 190, 61, 2, 236, 92, 62, 120, 25, 123, 122, 4, 215, 184, 124, 240, 50, 246, 244, 8, 173, 111, 248, 223, 100, 235, 231, 16, 89, 222, 239, 189, 200, 213, 205, 32, 178, 187, 221, 121, 143, 169, 153, 64, 99, 117, 185, 242, 29, 81, 49, 128, 198, 234, 113, 227, 58, 162, 98, 256, 139, 211, 226, 197, 116, 67, 196, 255, 21, 165, 195, 137, 232, 134, 135, 253, 42, 73, 133, 17, 207, 11, 13, 249, 84, 146, 9, 34, 157, 22, 26, 241, 168, 35, 18, 68, 57, 44, 52, 225, 79, 70, 36, 136, 114, 88, 104, 193, 158, 140, 72, 15, 228, 176, 208, 129, 59, 23, 144, 30, 199, 95, 159, 1],
-[1, 119, 26, 10, 162, 3, 100, 78, 30, 229, 9, 43, 234, 90, 173, 27, 129, 188, 13, 5, 81, 130, 50, 39, 15, 243, 133, 150, 117, 45, 215, 142, 193, 94, 135, 131, 169, 65, 25, 148, 136, 250, 195, 75, 187, 151, 236, 71, 225, 47, 196, 194, 213, 161, 141, 74, 68, 125, 226, 166, 222, 204, 118, 164, 241, 152, 98, 97, 235, 209, 199, 37, 34, 191, 113, 83, 111, 102, 59, 82, 249, 76, 49, 177, 246, 233, 228, 147, 17, 224, 185, 170, 184, 51, 158, 41, 253, 38, 153, 217, 123, 245, 114, 202, 137, 112, 221, 85, 92, 154, 79, 149, 255, 19, 205, 237, 190, 251, 57, 101, 197, 56, 239, 171, 46, 77, 168, 203, 256, 138, 231, 247, 95, 254, 157, 179, 227, 28, 248, 214, 23, 167, 84, 230, 128, 69, 244, 252, 176, 127, 207, 218, 242, 14, 124, 107, 140, 212, 42, 115, 64, 163, 122, 126, 88, 192, 232, 109, 121, 7, 62, 182, 70, 106, 21, 186, 32, 210, 61, 63, 44, 96, 116, 183, 189, 132, 31, 91, 35, 53, 139, 93, 16, 105, 159, 160, 22, 48, 58, 220, 223, 66, 144, 174, 146, 155, 198, 175, 8, 181, 208, 80, 11, 24, 29, 110, 240, 33, 72, 87, 73, 206, 99, 216, 4, 219, 104, 40, 134, 12, 143, 55, 120, 145, 36, 172, 165, 103, 178, 108, 2, 238, 52, 20, 67, 6, 200, 156, 60, 201, 18, 86, 211, 180, 89, 54, 1],
-[1, 120, 8, 189, 64, 227, 255, 17, 241, 136, 129, 60, 4, 223, 32, 242, 256, 137, 249, 68, 193, 30, 2, 240, 16, 121, 128, 197, 253, 34, 225, 15, 1, 120, 8, 189, 64, 227, 255, 17, 241, 136, 129, 60, 4, 223, 32, 242, 256, 137, 249, 68, 193, 30, 2, 240, 16, 121, 128, 197, 253, 34, 225, 15, 1, 120, 8, 189, 64, 227, 255, 17, 241, 136, 129, 60, 4, 223, 32, 242, 256, 137, 249, 68, 193, 30, 2, 240, 16, 121, 128, 197, 253, 34, 225, 15, 1, 120, 8, 189, 64, 227, 255, 17, 241, 136, 129, 60, 4, 223, 32, 242, 256, 137, 249, 68, 193, 30, 2, 240, 16, 121, 128, 197, 253, 34, 225, 15, 1, 120, 8, 189, 64, 227, 255, 17, 241, 136, 129, 60, 4, 223, 32, 242, 256, 137, 249, 68, 193, 30, 2, 240, 16, 121, 128, 197, 253, 34, 225, 15, 1, 120, 8, 189, 64, 227, 255, 17, 241, 136, 129, 60, 4, 223, 32, 242, 256, 137, 249, 68, 193, 30, 2, 240, 16, 121, 128, 197, 253, 34, 225, 15, 1, 120, 8, 189, 64, 227, 255, 17, 241, 136, 129, 60, 4, 223, 32, 242, 256, 137, 249, 68, 193, 30, 2, 240, 16, 121, 128, 197, 253, 34, 225, 15, 1, 120, 8, 189, 64, 227, 255, 17, 241, 136, 129, 60, 4, 223, 32, 242, 256, 137, 249, 68, 193, 30, 2, 240, 16, 121, 128, 197, 253, 34, 225, 15, 1],
-[1, 121, 249, 60, 64, 34, 2, 242, 241, 120, 128, 68, 4, 227, 225, 240, 256, 136, 8, 197, 193, 223, 255, 15, 16, 137, 129, 189, 253, 30, 32, 17, 1, 121, 249, 60, 64, 34, 2, 242, 241, 120, 128, 68, 4, 227, 225, 240, 256, 136, 8, 197, 193, 223, 255, 15, 16, 137, 129, 189, 253, 30, 32, 17, 1, 121, 249, 60, 64, 34, 2, 242, 241, 120, 128, 68, 4, 227, 225, 240, 256, 136, 8, 197, 193, 223, 255, 15, 16, 137, 129, 189, 253, 30, 32, 17, 1, 121, 249, 60, 64, 34, 2, 242, 241, 120, 128, 68, 4, 227, 225, 240, 256, 136, 8, 197, 193, 223, 255, 15, 16, 137, 129, 189, 253, 30, 32, 17, 1, 121, 249, 60, 64, 34, 2, 242, 241, 120, 128, 68, 4, 227, 225, 240, 256, 136, 8, 197, 193, 223, 255, 15, 16, 137, 129, 189, 253, 30, 32, 17, 1, 121, 249, 60, 64, 34, 2, 242, 241, 120, 128, 68, 4, 227, 225, 240, 256, 136, 8, 197, 193, 223, 255, 15, 16, 137, 129, 189, 253, 30, 32, 17, 1, 121, 249, 60, 64, 34, 2, 242, 241, 120, 128, 68, 4, 227, 225, 240, 256, 136, 8, 197, 193, 223, 255, 15, 16, 137, 129, 189, 253, 30, 32, 17, 1, 121, 249, 60, 64, 34, 2, 242, 241, 120, 128, 68, 4, 227, 225, 240, 256, 136, 8, 197, 193, 223, 255, 15, 16, 137, 129, 189, 253, 30, 32, 17, 1],
-[1, 122, 235, 143, 227, 195, 146, 79, 129, 61, 246, 200, 242, 226, 73, 168, 193, 159, 123, 100, 121, 113, 165, 84, 225, 208, 190, 50, 189, 185, 211, 42, 241, 104, 95, 25, 223, 221, 234, 21, 249, 52, 176, 141, 240, 239, 117, 139, 253, 26, 88, 199, 120, 248, 187, 198, 255, 13, 44, 228, 60, 124, 222, 99, 256, 135, 22, 114, 30, 62, 111, 178, 128, 196, 11, 57, 15, 31, 184, 89, 64, 98, 134, 157, 136, 144, 92, 173, 32, 49, 67, 207, 68, 72, 46, 215, 16, 153, 162, 232, 34, 36, 23, 236, 8, 205, 81, 116, 17, 18, 140, 118, 4, 231, 169, 58, 137, 9, 70, 59, 2, 244, 213, 29, 197, 133, 35, 158, 1, 122, 235, 143, 227, 195, 146, 79, 129, 61, 246, 200, 242, 226, 73, 168, 193, 159, 123, 100, 121, 113, 165, 84, 225, 208, 190, 50, 189, 185, 211, 42, 241, 104, 95, 25, 223, 221, 234, 21, 249, 52, 176, 141, 240, 239, 117, 139, 253, 26, 88, 199, 120, 248, 187, 198, 255, 13, 44, 228, 60, 124, 222, 99, 256, 135, 22, 114, 30, 62, 111, 178, 128, 196, 11, 57, 15, 31, 184, 89, 64, 98, 134, 157, 136, 144, 92, 173, 32, 49, 67, 207, 68, 72, 46, 215, 16, 153, 162, 232, 34, 36, 23, 236, 8, 205, 81, 116, 17, 18, 140, 118, 4, 231, 169, 58, 137, 9, 70, 59, 2, 244, 213, 29, 197, 133, 35, 158, 1],
-[1, 123, 223, 187, 128, 67, 17, 35, 193, 95, 120, 111, 32, 81, 197, 73, 241, 88, 30, 92, 8, 213, 242, 211, 253, 22, 136, 23, 2, 246, 189, 117, 256, 134, 34, 70, 129, 190, 240, 222, 64, 162, 137, 146, 225, 176, 60, 184, 16, 169, 227, 165, 249, 44, 15, 46, 4, 235, 121, 234, 255, 11, 68, 140, 1, 123, 223, 187, 128, 67, 17, 35, 193, 95, 120, 111, 32, 81, 197, 73, 241, 88, 30, 92, 8, 213, 242, 211, 253, 22, 136, 23, 2, 246, 189, 117, 256, 134, 34, 70, 129, 190, 240, 222, 64, 162, 137, 146, 225, 176, 60, 184, 16, 169, 227, 165, 249, 44, 15, 46, 4, 235, 121, 234, 255, 11, 68, 140, 1, 123, 223, 187, 128, 67, 17, 35, 193, 95, 120, 111, 32, 81, 197, 73, 241, 88, 30, 92, 8, 213, 242, 211, 253, 22, 136, 23, 2, 246, 189, 117, 256, 134, 34, 70, 129, 190, 240, 222, 64, 162, 137, 146, 225, 176, 60, 184, 16, 169, 227, 165, 249, 44, 15, 46, 4, 235, 121, 234, 255, 11, 68, 140, 1, 123, 223, 187, 128, 67, 17, 35, 193, 95, 120, 111, 32, 81, 197, 73, 241, 88, 30, 92, 8, 213, 242, 211, 253, 22, 136, 23, 2, 246, 189, 117, 256, 134, 34, 70, 129, 190, 240, 222, 64, 162, 137, 146, 225, 176, 60, 184, 16, 169, 227, 165, 249, 44, 15, 46, 4, 235, 121, 234, 255, 11, 68, 140, 1],
-[1, 124, 213, 198, 137, 26, 140, 141, 8, 221, 162, 42, 68, 208, 92, 100, 64, 226, 11, 79, 30, 122, 222, 29, 255, 9, 88, 118, 240, 205, 234, 232, 241, 72, 190, 173, 121, 98, 73, 57, 129, 62, 235, 99, 197, 13, 70, 199, 4, 239, 81, 21, 34, 104, 46, 50, 32, 113, 134, 168, 15, 61, 111, 143, 256, 133, 44, 59, 120, 231, 117, 116, 249, 36, 95, 215, 189, 49, 165, 157, 193, 31, 246, 178, 227, 135, 35, 228, 2, 248, 169, 139, 17, 52, 23, 25, 16, 185, 67, 84, 136, 159, 184, 200, 128, 195, 22, 158, 60, 244, 187, 58, 253, 18, 176, 236, 223, 153, 211, 207, 225, 144, 123, 89, 242, 196, 146, 114, 1, 124, 213, 198, 137, 26, 140, 141, 8, 221, 162, 42, 68, 208, 92, 100, 64, 226, 11, 79, 30, 122, 222, 29, 255, 9, 88, 118, 240, 205, 234, 232, 241, 72, 190, 173, 121, 98, 73, 57, 129, 62, 235, 99, 197, 13, 70, 199, 4, 239, 81, 21, 34, 104, 46, 50, 32, 113, 134, 168, 15, 61, 111, 143, 256, 133, 44, 59, 120, 231, 117, 116, 249, 36, 95, 215, 189, 49, 165, 157, 193, 31, 246, 178, 227, 135, 35, 228, 2, 248, 169, 139, 17, 52, 23, 25, 16, 185, 67, 84, 136, 159, 184, 200, 128, 195, 22, 158, 60, 244, 187, 58, 253, 18, 176, 236, 223, 153, 211, 207, 225, 144, 123, 89, 242, 196, 146, 114, 1],
-[1, 125, 205, 182, 134, 45, 228, 230, 223, 119, 226, 237, 70, 12, 215, 147, 128, 66, 26, 166, 190, 106, 143, 142, 17, 69, 144, 10, 222, 251, 21, 55, 193, 224, 244, 174, 162, 204, 57, 186, 120, 94, 185, 252, 146, 3, 118, 101, 32, 145, 135, 170, 176, 155, 100, 164, 197, 210, 36, 131, 184, 127, 198, 78, 241, 56, 61, 172, 169, 51, 207, 175, 30, 152, 239, 63, 165, 65, 158, 218, 8, 229, 98, 171, 44, 103, 25, 41, 242, 181, 9, 97, 46, 96, 178, 148, 253, 14, 208, 43, 235, 77, 116, 108, 136, 38, 124, 80, 234, 209, 168, 183, 2, 250, 153, 107, 11, 90, 199, 203, 189, 238, 195, 217, 140, 24, 173, 37, 256, 132, 52, 75, 123, 212, 29, 27, 34, 138, 31, 20, 187, 245, 42, 110, 129, 191, 231, 91, 67, 151, 114, 115, 240, 188, 113, 247, 35, 6, 236, 202, 64, 33, 13, 83, 95, 53, 200, 71, 137, 163, 72, 5, 111, 254, 139, 156, 225, 112, 122, 87, 81, 102, 157, 93, 60, 47, 221, 126, 73, 130, 59, 179, 16, 201, 196, 85, 88, 206, 50, 82, 227, 105, 18, 194, 92, 192, 99, 39, 249, 28, 159, 86, 213, 154, 232, 216, 15, 76, 248, 160, 211, 161, 79, 109, 4, 243, 49, 214, 22, 180, 141, 149, 121, 219, 133, 177, 23, 48, 89, 74, 255, 7, 104, 150, 246, 167, 58, 54, 68, 19, 62, 40, 117, 233, 84, 220, 1],
-[1, 126, 199, 145, 23, 71, 208, 251, 15, 91, 158, 119, 88, 37, 36, 167, 225, 80, 57, 243, 35, 41, 26, 192, 34, 172, 84, 47, 11, 101, 133, 53, 253, 10, 232, 191, 165, 230, 196, 24, 197, 150, 139, 38, 162, 109, 113, 103, 128, 194, 29, 56, 117, 93, 153, 3, 121, 83, 178, 69, 213, 110, 239, 45, 16, 217, 100, 7, 111, 108, 244, 161, 240, 171, 215, 105, 123, 78, 62, 102, 2, 252, 141, 33, 46, 142, 159, 245, 30, 182, 59, 238, 176, 74, 72, 77, 193, 160, 114, 229, 70, 82, 52, 127, 68, 87, 168, 94, 22, 202, 9, 106, 249, 20, 207, 125, 73, 203, 135, 48, 137, 43, 21, 76, 67, 218, 226, 206, 256, 131, 58, 112, 234, 186, 49, 6, 242, 166, 99, 138, 169, 220, 221, 90, 32, 177, 200, 14, 222, 216, 231, 65, 223, 85, 173, 210, 246, 156, 124, 204, 4, 247, 25, 66, 92, 27, 61, 233, 60, 107, 118, 219, 95, 148, 144, 154, 129, 63, 228, 201, 140, 164, 104, 254, 136, 174, 79, 188, 44, 147, 18, 212, 241, 40, 157, 250, 146, 149, 13, 96, 17, 86, 42, 152, 134, 179, 195, 155, 255, 5, 116, 224, 211, 115, 98, 12, 227, 75, 198, 19, 81, 183, 185, 180, 64, 97, 143, 28, 187, 175, 205, 130, 189, 170, 89, 163, 235, 55, 248, 151, 8, 237, 50, 132, 184, 54, 122, 209, 120, 214, 236, 181, 190, 39, 31, 51, 1],
-[1, 127, 195, 93, 246, 145, 168, 5, 121, 204, 208, 202, 211, 69, 25, 91, 249, 12, 239, 27, 88, 125, 198, 217, 60, 167, 135, 183, 111, 219, 57, 43, 64, 161, 144, 41, 67, 28, 215, 63, 34, 206, 205, 78, 140, 47, 58, 170, 2, 254, 133, 186, 235, 33, 79, 10, 242, 151, 159, 147, 165, 138, 50, 182, 241, 24, 221, 54, 176, 250, 139, 177, 120, 77, 13, 109, 222, 181, 114, 86, 128, 65, 31, 82, 134, 56, 173, 126, 68, 155, 153, 156, 23, 94, 116, 83, 4, 251, 9, 115, 213, 66, 158, 20, 227, 45, 61, 37, 73, 19, 100, 107, 225, 48, 185, 108, 95, 243, 21, 97, 240, 154, 26, 218, 187, 105, 228, 172, 256, 130, 62, 164, 11, 112, 89, 252, 136, 53, 49, 55, 46, 188, 232, 166, 8, 245, 18, 230, 169, 132, 59, 40, 197, 90, 122, 74, 146, 38, 200, 214, 193, 96, 113, 216, 190, 229, 42, 194, 223, 51, 52, 179, 117, 210, 199, 87, 255, 3, 124, 71, 22, 224, 178, 247, 15, 106, 98, 110, 92, 119, 207, 75, 16, 233, 36, 203, 81, 7, 118, 80, 137, 180, 244, 148, 35, 76, 143, 171, 129, 192, 226, 175, 123, 201, 84, 131, 189, 102, 104, 101, 234, 163, 141, 174, 253, 6, 248, 142, 44, 191, 99, 237, 30, 212, 196, 220, 184, 238, 157, 150, 32, 209, 72, 149, 162, 14, 236, 160, 17, 103, 231, 39, 70, 152, 29, 85, 1],
-[1, 128, 193, 32, 241, 8, 253, 2, 256, 129, 64, 225, 16, 249, 4, 255, 1, 128, 193, 32, 241, 8, 253, 2, 256, 129, 64, 225, 16, 249, 4, 255, 1, 128, 193, 32, 241, 8, 253, 2, 256, 129, 64, 225, 16, 249, 4, 255, 1, 128, 193, 32, 241, 8, 253, 2, 256, 129, 64, 225, 16, 249, 4, 255, 1, 128, 193, 32, 241, 8, 253, 2, 256, 129, 64, 225, 16, 249, 4, 255, 1, 128, 193, 32, 241, 8, 253, 2, 256, 129, 64, 225, 16, 249, 4, 255, 1, 128, 193, 32, 241, 8, 253, 2, 256, 129, 64, 225, 16, 249, 4, 255, 1, 128, 193, 32, 241, 8, 253, 2, 256, 129, 64, 225, 16, 249, 4, 255, 1, 128, 193, 32, 241, 8, 253, 2, 256, 129, 64, 225, 16, 249, 4, 255, 1, 128, 193, 32, 241, 8, 253, 2, 256, 129, 64, 225, 16, 249, 4, 255, 1, 128, 193, 32, 241, 8, 253, 2, 256, 129, 64, 225, 16, 249, 4, 255, 1, 128, 193, 32, 241, 8, 253, 2, 256, 129, 64, 225, 16, 249, 4, 255, 1, 128, 193, 32, 241, 8, 253, 2, 256, 129, 64, 225, 16, 249, 4, 255, 1, 128, 193, 32, 241, 8, 253, 2, 256, 129, 64, 225, 16, 249, 4, 255, 1, 128, 193, 32, 241, 8, 253, 2, 256, 129, 64, 225, 16, 249, 4, 255, 1, 128, 193, 32, 241, 8, 253, 2, 256, 129, 64, 225, 16, 249, 4, 255, 1],
-[1, 129, 193, 225, 241, 249, 253, 255, 256, 128, 64, 32, 16, 8, 4, 2, 1, 129, 193, 225, 241, 249, 253, 255, 256, 128, 64, 32, 16, 8, 4, 2, 1, 129, 193, 225, 241, 249, 253, 255, 256, 128, 64, 32, 16, 8, 4, 2, 1, 129, 193, 225, 241, 249, 253, 255, 256, 128, 64, 32, 16, 8, 4, 2, 1, 129, 193, 225, 241, 249, 253, 255, 256, 128, 64, 32, 16, 8, 4, 2, 1, 129, 193, 225, 241, 249, 253, 255, 256, 128, 64, 32, 16, 8, 4, 2, 1, 129, 193, 225, 241, 249, 253, 255, 256, 128, 64, 32, 16, 8, 4, 2, 1, 129, 193, 225, 241, 249, 253, 255, 256, 128, 64, 32, 16, 8, 4, 2, 1, 129, 193, 225, 241, 249, 253, 255, 256, 128, 64, 32, 16, 8, 4, 2, 1, 129, 193, 225, 241, 249, 253, 255, 256, 128, 64, 32, 16, 8, 4, 2, 1, 129, 193, 225, 241, 249, 253, 255, 256, 128, 64, 32, 16, 8, 4, 2, 1, 129, 193, 225, 241, 249, 253, 255, 256, 128, 64, 32, 16, 8, 4, 2, 1, 129, 193, 225, 241, 249, 253, 255, 256, 128, 64, 32, 16, 8, 4, 2, 1, 129, 193, 225, 241, 249, 253, 255, 256, 128, 64, 32, 16, 8, 4, 2, 1, 129, 193, 225, 241, 249, 253, 255, 256, 128, 64, 32, 16, 8, 4, 2, 1, 129, 193, 225, 241, 249, 253, 255, 256, 128, 64, 32, 16, 8, 4, 2, 1],
-[1, 130, 195, 164, 246, 112, 168, 252, 121, 53, 208, 55, 211, 188, 25, 166, 249, 245, 239, 230, 88, 132, 198, 40, 60, 90, 135, 74, 111, 38, 57, 214, 64, 96, 144, 216, 67, 229, 215, 194, 34, 51, 205, 179, 140, 210, 58, 87, 2, 3, 133, 71, 235, 224, 79, 247, 242, 106, 159, 110, 165, 119, 50, 75, 241, 233, 221, 203, 176, 7, 139, 80, 120, 180, 13, 148, 222, 76, 114, 171, 128, 192, 31, 175, 134, 201, 173, 131, 68, 102, 153, 101, 23, 163, 116, 174, 4, 6, 9, 142, 213, 191, 158, 237, 227, 212, 61, 220, 73, 238, 100, 150, 225, 209, 185, 149, 95, 14, 21, 160, 240, 103, 26, 39, 187, 152, 228, 85, 256, 127, 62, 93, 11, 145, 89, 5, 136, 204, 49, 202, 46, 69, 232, 91, 8, 12, 18, 27, 169, 125, 59, 217, 197, 167, 122, 183, 146, 219, 200, 43, 193, 161, 113, 41, 190, 28, 42, 63, 223, 206, 52, 78, 117, 47, 199, 170, 255, 254, 124, 186, 22, 33, 178, 10, 15, 151, 98, 147, 92, 138, 207, 182, 16, 24, 36, 54, 81, 250, 118, 177, 137, 77, 244, 109, 35, 181, 143, 86, 129, 65, 226, 82, 123, 56, 84, 126, 189, 155, 104, 156, 234, 94, 141, 83, 253, 251, 248, 115, 44, 66, 99, 20, 30, 45, 196, 37, 184, 19, 157, 107, 32, 48, 72, 108, 162, 243, 236, 97, 17, 154, 231, 218, 70, 105, 29, 172, 1],
-[1, 131, 199, 112, 23, 186, 208, 6, 15, 166, 158, 138, 88, 220, 36, 90, 225, 177, 57, 14, 35, 216, 26, 65, 34, 85, 84, 210, 11, 156, 133, 204, 253, 247, 232, 66, 165, 27, 196, 233, 197, 107, 139, 219, 162, 148, 113, 154, 128, 63, 29, 201, 117, 164, 153, 254, 121, 174, 178, 188, 213, 147, 239, 212, 16, 40, 100, 250, 111, 149, 244, 96, 240, 86, 215, 152, 123, 179, 62, 155, 2, 5, 141, 224, 46, 115, 159, 12, 30, 75, 59, 19, 176, 183, 72, 180, 193, 97, 114, 28, 70, 175, 52, 130, 68, 170, 168, 163, 22, 55, 9, 151, 249, 237, 207, 132, 73, 54, 135, 209, 137, 214, 21, 181, 67, 39, 226, 51, 256, 126, 58, 145, 234, 71, 49, 251, 242, 91, 99, 119, 169, 37, 221, 167, 32, 80, 200, 243, 222, 41, 231, 192, 223, 172, 173, 47, 246, 101, 124, 53, 4, 10, 25, 191, 92, 230, 61, 24, 60, 150, 118, 38, 95, 109, 144, 103, 129, 194, 228, 56, 140, 93, 104, 3, 136, 83, 79, 69, 44, 110, 18, 45, 241, 217, 157, 7, 146, 108, 13, 161, 17, 171, 42, 105, 134, 78, 195, 102, 255, 252, 116, 33, 211, 142, 98, 245, 227, 182, 198, 238, 81, 74, 185, 77, 64, 160, 143, 229, 187, 82, 205, 127, 189, 87, 89, 94, 235, 202, 248, 106, 8, 20, 50, 125, 184, 203, 122, 48, 120, 43, 236, 76, 190, 218, 31, 206, 1],
-[1, 132, 205, 75, 134, 212, 228, 27, 223, 138, 226, 20, 70, 245, 215, 110, 128, 191, 26, 91, 190, 151, 143, 115, 17, 188, 144, 247, 222, 6, 21, 202, 193, 33, 244, 83, 162, 53, 57, 71, 120, 163, 185, 5, 146, 254, 118, 156, 32, 112, 135, 87, 176, 102, 100, 93, 197, 47, 36, 126, 184, 130, 198, 179, 241, 201, 61, 85, 169, 206, 207, 82, 30, 105, 239, 194, 165, 192, 158, 39, 8, 28, 98, 86, 44, 154, 25, 216, 242, 76, 9, 160, 46, 161, 178, 109, 253, 243, 208, 214, 235, 180, 116, 149, 136, 219, 124, 177, 234, 48, 168, 74, 2, 7, 153, 150, 11, 167, 199, 54, 189, 19, 195, 40, 140, 233, 173, 220, 256, 125, 52, 182, 123, 45, 29, 230, 34, 119, 31, 237, 187, 12, 42, 147, 129, 66, 231, 166, 67, 106, 114, 142, 240, 69, 113, 10, 35, 251, 236, 55, 64, 224, 13, 174, 95, 204, 200, 186, 137, 94, 72, 252, 111, 3, 139, 101, 225, 145, 122, 170, 81, 155, 157, 164, 60, 210, 221, 131, 73, 127, 59, 78, 16, 56, 196, 172, 88, 51, 50, 175, 227, 152, 18, 63, 92, 65, 99, 218, 249, 229, 159, 171, 213, 103, 232, 41, 15, 181, 248, 97, 211, 96, 79, 148, 4, 14, 49, 43, 22, 77, 141, 108, 121, 38, 133, 80, 23, 209, 89, 183, 255, 250, 104, 107, 246, 90, 58, 203, 68, 238, 62, 217, 117, 24, 84, 37, 1],
-[1, 133, 213, 59, 137, 231, 140, 116, 8, 36, 162, 215, 68, 49, 92, 157, 64, 31, 11, 178, 30, 135, 222, 228, 255, 248, 88, 139, 240, 52, 234, 25, 241, 185, 190, 84, 121, 159, 73, 200, 129, 195, 235, 158, 197, 244, 70, 58, 4, 18, 81, 236, 34, 153, 46, 207, 32, 144, 134, 89, 15, 196, 111, 114, 256, 124, 44, 198, 120, 26, 117, 141, 249, 221, 95, 42, 189, 208, 165, 100, 193, 226, 246, 79, 227, 122, 35, 29, 2, 9, 169, 118, 17, 205, 23, 232, 16, 72, 67, 173, 136, 98, 184, 57, 128, 62, 22, 99, 60, 13, 187, 199, 253, 239, 176, 21, 223, 104, 211, 50, 225, 113, 123, 168, 242, 61, 146, 143, 1, 133, 213, 59, 137, 231, 140, 116, 8, 36, 162, 215, 68, 49, 92, 157, 64, 31, 11, 178, 30, 135, 222, 228, 255, 248, 88, 139, 240, 52, 234, 25, 241, 185, 190, 84, 121, 159, 73, 200, 129, 195, 235, 158, 197, 244, 70, 58, 4, 18, 81, 236, 34, 153, 46, 207, 32, 144, 134, 89, 15, 196, 111, 114, 256, 124, 44, 198, 120, 26, 117, 141, 249, 221, 95, 42, 189, 208, 165, 100, 193, 226, 246, 79, 227, 122, 35, 29, 2, 9, 169, 118, 17, 205, 23, 232, 16, 72, 67, 173, 136, 98, 184, 57, 128, 62, 22, 99, 60, 13, 187, 199, 253, 239, 176, 21, 223, 104, 211, 50, 225, 113, 123, 168, 242, 61, 146, 143, 1],
-[1, 134, 223, 70, 128, 190, 17, 222, 193, 162, 120, 146, 32, 176, 197, 184, 241, 169, 30, 165, 8, 44, 242, 46, 253, 235, 136, 234, 2, 11, 189, 140, 256, 123, 34, 187, 129, 67, 240, 35, 64, 95, 137, 111, 225, 81, 60, 73, 16, 88, 227, 92, 249, 213, 15, 211, 4, 22, 121, 23, 255, 246, 68, 117, 1, 134, 223, 70, 128, 190, 17, 222, 193, 162, 120, 146, 32, 176, 197, 184, 241, 169, 30, 165, 8, 44, 242, 46, 253, 235, 136, 234, 2, 11, 189, 140, 256, 123, 34, 187, 129, 67, 240, 35, 64, 95, 137, 111, 225, 81, 60, 73, 16, 88, 227, 92, 249, 213, 15, 211, 4, 22, 121, 23, 255, 246, 68, 117, 1, 134, 223, 70, 128, 190, 17, 222, 193, 162, 120, 146, 32, 176, 197, 184, 241, 169, 30, 165, 8, 44, 242, 46, 253, 235, 136, 234, 2, 11, 189, 140, 256, 123, 34, 187, 129, 67, 240, 35, 64, 95, 137, 111, 225, 81, 60, 73, 16, 88, 227, 92, 249, 213, 15, 211, 4, 22, 121, 23, 255, 246, 68, 117, 1, 134, 223, 70, 128, 190, 17, 222, 193, 162, 120, 146, 32, 176, 197, 184, 241, 169, 30, 165, 8, 44, 242, 46, 253, 235, 136, 234, 2, 11, 189, 140, 256, 123, 34, 187, 129, 67, 240, 35, 64, 95, 137, 111, 225, 81, 60, 73, 16, 88, 227, 92, 249, 213, 15, 211, 4, 22, 121, 23, 255, 246, 68, 117, 1],
-[1, 135, 235, 114, 227, 62, 146, 178, 129, 196, 246, 57, 242, 31, 73, 89, 193, 98, 123, 157, 121, 144, 165, 173, 225, 49, 190, 207, 189, 72, 211, 215, 241, 153, 95, 232, 223, 36, 234, 236, 249, 205, 176, 116, 240, 18, 117, 118, 253, 231, 88, 58, 120, 9, 187, 59, 255, 244, 44, 29, 60, 133, 222, 158, 256, 122, 22, 143, 30, 195, 111, 79, 128, 61, 11, 200, 15, 226, 184, 168, 64, 159, 134, 100, 136, 113, 92, 84, 32, 208, 67, 50, 68, 185, 46, 42, 16, 104, 162, 25, 34, 221, 23, 21, 8, 52, 81, 141, 17, 239, 140, 139, 4, 26, 169, 199, 137, 248, 70, 198, 2, 13, 213, 228, 197, 124, 35, 99, 1, 135, 235, 114, 227, 62, 146, 178, 129, 196, 246, 57, 242, 31, 73, 89, 193, 98, 123, 157, 121, 144, 165, 173, 225, 49, 190, 207, 189, 72, 211, 215, 241, 153, 95, 232, 223, 36, 234, 236, 249, 205, 176, 116, 240, 18, 117, 118, 253, 231, 88, 58, 120, 9, 187, 59, 255, 244, 44, 29, 60, 133, 222, 158, 256, 122, 22, 143, 30, 195, 111, 79, 128, 61, 11, 200, 15, 226, 184, 168, 64, 159, 134, 100, 136, 113, 92, 84, 32, 208, 67, 50, 68, 185, 46, 42, 16, 104, 162, 25, 34, 221, 23, 21, 8, 52, 81, 141, 17, 239, 140, 139, 4, 26, 169, 199, 137, 248, 70, 198, 2, 13, 213, 228, 197, 124, 35, 99, 1],
-[1, 136, 249, 197, 64, 223, 2, 15, 241, 137, 128, 189, 4, 30, 225, 17, 256, 121, 8, 60, 193, 34, 255, 242, 16, 120, 129, 68, 253, 227, 32, 240, 1, 136, 249, 197, 64, 223, 2, 15, 241, 137, 128, 189, 4, 30, 225, 17, 256, 121, 8, 60, 193, 34, 255, 242, 16, 120, 129, 68, 253, 227, 32, 240, 1, 136, 249, 197, 64, 223, 2, 15, 241, 137, 128, 189, 4, 30, 225, 17, 256, 121, 8, 60, 193, 34, 255, 242, 16, 120, 129, 68, 253, 227, 32, 240, 1, 136, 249, 197, 64, 223, 2, 15, 241, 137, 128, 189, 4, 30, 225, 17, 256, 121, 8, 60, 193, 34, 255, 242, 16, 120, 129, 68, 253, 227, 32, 240, 1, 136, 249, 197, 64, 223, 2, 15, 241, 137, 128, 189, 4, 30, 225, 17, 256, 121, 8, 60, 193, 34, 255, 242, 16, 120, 129, 68, 253, 227, 32, 240, 1, 136, 249, 197, 64, 223, 2, 15, 241, 137, 128, 189, 4, 30, 225, 17, 256, 121, 8, 60, 193, 34, 255, 242, 16, 120, 129, 68, 253, 227, 32, 240, 1, 136, 249, 197, 64, 223, 2, 15, 241, 137, 128, 189, 4, 30, 225, 17, 256, 121, 8, 60, 193, 34, 255, 242, 16, 120, 129, 68, 253, 227, 32, 240, 1, 136, 249, 197, 64, 223, 2, 15, 241, 137, 128, 189, 4, 30, 225, 17, 256, 121, 8, 60, 193, 34, 255, 242, 16, 120, 129, 68, 253, 227, 32, 240, 1],
-[1, 137, 8, 68, 64, 30, 255, 240, 241, 121, 129, 197, 4, 34, 32, 15, 256, 120, 249, 189, 193, 227, 2, 17, 16, 136, 128, 60, 253, 223, 225, 242, 1, 137, 8, 68, 64, 30, 255, 240, 241, 121, 129, 197, 4, 34, 32, 15, 256, 120, 249, 189, 193, 227, 2, 17, 16, 136, 128, 60, 253, 223, 225, 242, 1, 137, 8, 68, 64, 30, 255, 240, 241, 121, 129, 197, 4, 34, 32, 15, 256, 120, 249, 189, 193, 227, 2, 17, 16, 136, 128, 60, 253, 223, 225, 242, 1, 137, 8, 68, 64, 30, 255, 240, 241, 121, 129, 197, 4, 34, 32, 15, 256, 120, 249, 189, 193, 227, 2, 17, 16, 136, 128, 60, 253, 223, 225, 242, 1, 137, 8, 68, 64, 30, 255, 240, 241, 121, 129, 197, 4, 34, 32, 15, 256, 120, 249, 189, 193, 227, 2, 17, 16, 136, 128, 60, 253, 223, 225, 242, 1, 137, 8, 68, 64, 30, 255, 240, 241, 121, 129, 197, 4, 34, 32, 15, 256, 120, 249, 189, 193, 227, 2, 17, 16, 136, 128, 60, 253, 223, 225, 242, 1, 137, 8, 68, 64, 30, 255, 240, 241, 121, 129, 197, 4, 34, 32, 15, 256, 120, 249, 189, 193, 227, 2, 17, 16, 136, 128, 60, 253, 223, 225, 242, 1, 137, 8, 68, 64, 30, 255, 240, 241, 121, 129, 197, 4, 34, 32, 15, 256, 120, 249, 189, 193, 227, 2, 17, 16, 136, 128, 60, 253, 223, 225, 242, 1],
-[1, 138, 26, 247, 162, 254, 100, 179, 30, 28, 9, 214, 234, 167, 173, 230, 129, 69, 13, 252, 81, 127, 50, 218, 15, 14, 133, 107, 117, 212, 215, 115, 193, 163, 135, 126, 169, 192, 25, 109, 136, 7, 195, 182, 187, 106, 236, 186, 225, 210, 196, 63, 213, 96, 141, 183, 68, 132, 226, 91, 222, 53, 118, 93, 241, 105, 98, 160, 235, 48, 199, 220, 34, 66, 113, 174, 111, 155, 59, 175, 249, 181, 49, 80, 246, 24, 228, 110, 17, 33, 185, 87, 184, 206, 158, 216, 253, 219, 153, 40, 123, 12, 114, 55, 137, 145, 221, 172, 92, 103, 79, 108, 255, 238, 205, 20, 190, 6, 57, 156, 197, 201, 239, 86, 46, 180, 168, 54, 256, 119, 231, 10, 95, 3, 157, 78, 227, 229, 248, 43, 23, 90, 84, 27, 128, 188, 244, 5, 176, 130, 207, 39, 242, 243, 124, 150, 140, 45, 42, 142, 64, 94, 122, 131, 88, 65, 232, 148, 121, 250, 62, 75, 70, 151, 21, 71, 32, 47, 61, 194, 44, 161, 116, 74, 189, 125, 31, 166, 35, 204, 139, 164, 16, 152, 159, 97, 22, 209, 58, 37, 223, 191, 144, 83, 146, 102, 198, 82, 8, 76, 208, 177, 11, 233, 29, 147, 240, 224, 72, 170, 73, 51, 99, 41, 4, 38, 104, 217, 134, 245, 143, 202, 120, 112, 36, 85, 165, 154, 178, 149, 2, 19, 52, 237, 67, 251, 200, 101, 60, 56, 18, 171, 211, 77, 89, 203, 1],
-[1, 139, 46, 226, 60, 116, 190, 196, 2, 21, 92, 195, 120, 232, 123, 135, 4, 42, 184, 133, 240, 207, 246, 13, 8, 84, 111, 9, 223, 157, 235, 26, 16, 168, 222, 18, 189, 57, 213, 52, 32, 79, 187, 36, 121, 114, 169, 104, 64, 158, 117, 72, 242, 228, 81, 208, 128, 59, 234, 144, 227, 199, 162, 159, 256, 118, 211, 31, 197, 141, 67, 61, 255, 236, 165, 62, 137, 25, 134, 122, 253, 215, 73, 124, 17, 50, 11, 244, 249, 173, 146, 248, 34, 100, 22, 231, 241, 89, 35, 239, 68, 200, 44, 205, 225, 178, 70, 221, 136, 143, 88, 153, 193, 99, 140, 185, 15, 29, 176, 49, 129, 198, 23, 113, 30, 58, 95, 98, 1, 139, 46, 226, 60, 116, 190, 196, 2, 21, 92, 195, 120, 232, 123, 135, 4, 42, 184, 133, 240, 207, 246, 13, 8, 84, 111, 9, 223, 157, 235, 26, 16, 168, 222, 18, 189, 57, 213, 52, 32, 79, 187, 36, 121, 114, 169, 104, 64, 158, 117, 72, 242, 228, 81, 208, 128, 59, 234, 144, 227, 199, 162, 159, 256, 118, 211, 31, 197, 141, 67, 61, 255, 236, 165, 62, 137, 25, 134, 122, 253, 215, 73, 124, 17, 50, 11, 244, 249, 173, 146, 248, 34, 100, 22, 231, 241, 89, 35, 239, 68, 200, 44, 205, 225, 178, 70, 221, 136, 143, 88, 153, 193, 99, 140, 185, 15, 29, 176, 49, 129, 198, 23, 113, 30, 58, 95, 98, 1],
-[1, 140, 68, 11, 255, 234, 121, 235, 4, 46, 15, 44, 249, 165, 227, 169, 16, 184, 60, 176, 225, 146, 137, 162, 64, 222, 240, 190, 129, 70, 34, 134, 256, 117, 189, 246, 2, 23, 136, 22, 253, 211, 242, 213, 8, 92, 30, 88, 241, 73, 197, 81, 32, 111, 120, 95, 193, 35, 17, 67, 128, 187, 223, 123, 1, 140, 68, 11, 255, 234, 121, 235, 4, 46, 15, 44, 249, 165, 227, 169, 16, 184, 60, 176, 225, 146, 137, 162, 64, 222, 240, 190, 129, 70, 34, 134, 256, 117, 189, 246, 2, 23, 136, 22, 253, 211, 242, 213, 8, 92, 30, 88, 241, 73, 197, 81, 32, 111, 120, 95, 193, 35, 17, 67, 128, 187, 223, 123, 1, 140, 68, 11, 255, 234, 121, 235, 4, 46, 15, 44, 249, 165, 227, 169, 16, 184, 60, 176, 225, 146, 137, 162, 64, 222, 240, 190, 129, 70, 34, 134, 256, 117, 189, 246, 2, 23, 136, 22, 253, 211, 242, 213, 8, 92, 30, 88, 241, 73, 197, 81, 32, 111, 120, 95, 193, 35, 17, 67, 128, 187, 223, 123, 1, 140, 68, 11, 255, 234, 121, 235, 4, 46, 15, 44, 249, 165, 227, 169, 16, 184, 60, 176, 225, 146, 137, 162, 64, 222, 240, 190, 129, 70, 34, 134, 256, 117, 189, 246, 2, 23, 136, 22, 253, 211, 242, 213, 8, 92, 30, 88, 241, 73, 197, 81, 32, 111, 120, 95, 193, 35, 17, 67, 128, 187, 223, 123, 1],
-[1, 141, 92, 122, 240, 173, 235, 239, 32, 143, 117, 49, 227, 139, 67, 195, 253, 207, 146, 26, 68, 79, 88, 72, 129, 199, 46, 61, 120, 215, 246, 248, 16, 200, 187, 153, 242, 198, 162, 226, 255, 232, 73, 13, 34, 168, 44, 36, 193, 228, 23, 159, 60, 236, 123, 124, 8, 100, 222, 205, 121, 99, 81, 113, 256, 116, 165, 135, 17, 84, 22, 18, 225, 114, 140, 208, 30, 118, 190, 62, 4, 50, 111, 231, 189, 178, 169, 185, 128, 58, 211, 196, 137, 42, 11, 9, 241, 57, 70, 104, 15, 59, 95, 31, 2, 25, 184, 244, 223, 89, 213, 221, 64, 29, 234, 98, 197, 21, 134, 133, 249, 157, 35, 52, 136, 158, 176, 144, 1, 141, 92, 122, 240, 173, 235, 239, 32, 143, 117, 49, 227, 139, 67, 195, 253, 207, 146, 26, 68, 79, 88, 72, 129, 199, 46, 61, 120, 215, 246, 248, 16, 200, 187, 153, 242, 198, 162, 226, 255, 232, 73, 13, 34, 168, 44, 36, 193, 228, 23, 159, 60, 236, 123, 124, 8, 100, 222, 205, 121, 99, 81, 113, 256, 116, 165, 135, 17, 84, 22, 18, 225, 114, 140, 208, 30, 118, 190, 62, 4, 50, 111, 231, 189, 178, 169, 185, 128, 58, 211, 196, 137, 42, 11, 9, 241, 57, 70, 104, 15, 59, 95, 31, 2, 25, 184, 244, 223, 89, 213, 221, 64, 29, 234, 98, 197, 21, 134, 133, 249, 157, 35, 52, 136, 158, 176, 144, 1],
-[1, 142, 118, 51, 46, 107, 31, 33, 60, 39, 141, 233, 190, 252, 61, 181, 2, 27, 236, 102, 92, 214, 62, 66, 120, 78, 25, 209, 123, 247, 122, 105, 4, 54, 215, 204, 184, 171, 124, 132, 240, 156, 50, 161, 246, 237, 244, 210, 8, 108, 173, 151, 111, 85, 248, 7, 223, 55, 100, 65, 235, 217, 231, 163, 16, 216, 89, 45, 222, 170, 239, 14, 189, 110, 200, 130, 213, 177, 205, 69, 32, 175, 178, 90, 187, 83, 221, 28, 121, 220, 143, 3, 169, 97, 153, 138, 64, 93, 99, 180, 117, 166, 185, 56, 242, 183, 29, 6, 81, 194, 49, 19, 128, 186, 198, 103, 234, 75, 113, 112, 227, 109, 58, 12, 162, 131, 98, 38, 256, 115, 139, 206, 211, 150, 226, 224, 197, 218, 116, 24, 67, 5, 196, 76, 255, 230, 21, 155, 165, 43, 195, 191, 137, 179, 232, 48, 134, 10, 135, 152, 253, 203, 42, 53, 73, 86, 133, 125, 17, 101, 207, 96, 11, 20, 13, 47, 249, 149, 84, 106, 146, 172, 9, 250, 34, 202, 157, 192, 22, 40, 26, 94, 241, 41, 168, 212, 35, 87, 18, 243, 68, 147, 57, 127, 44, 80, 52, 188, 225, 82, 79, 167, 70, 174, 36, 229, 136, 37, 114, 254, 88, 160, 104, 119, 193, 164, 158, 77, 140, 91, 72, 201, 15, 74, 228, 251, 176, 63, 208, 238, 129, 71, 59, 154, 23, 182, 144, 145, 30, 148, 199, 245, 95, 126, 159, 219, 1],
-[1, 143, 146, 61, 242, 168, 123, 113, 225, 50, 211, 104, 223, 21, 176, 239, 253, 199, 187, 13, 60, 99, 22, 62, 128, 57, 184, 98, 136, 173, 67, 72, 16, 232, 23, 205, 17, 118, 169, 9, 2, 29, 35, 122, 227, 79, 246, 226, 193, 100, 165, 208, 189, 42, 95, 221, 249, 141, 117, 26, 120, 198, 44, 124, 256, 114, 111, 196, 15, 89, 134, 144, 32, 207, 46, 153, 34, 236, 81, 18, 4, 58, 70, 244, 197, 158, 235, 195, 129, 200, 73, 159, 121, 84, 190, 185, 241, 25, 234, 52, 240, 139, 88, 248, 255, 228, 222, 135, 30, 178, 11, 31, 64, 157, 92, 49, 68, 215, 162, 36, 8, 116, 140, 231, 137, 59, 213, 133, 1, 143, 146, 61, 242, 168, 123, 113, 225, 50, 211, 104, 223, 21, 176, 239, 253, 199, 187, 13, 60, 99, 22, 62, 128, 57, 184, 98, 136, 173, 67, 72, 16, 232, 23, 205, 17, 118, 169, 9, 2, 29, 35, 122, 227, 79, 246, 226, 193, 100, 165, 208, 189, 42, 95, 221, 249, 141, 117, 26, 120, 198, 44, 124, 256, 114, 111, 196, 15, 89, 134, 144, 32, 207, 46, 153, 34, 236, 81, 18, 4, 58, 70, 244, 197, 158, 235, 195, 129, 200, 73, 159, 121, 84, 190, 185, 241, 25, 234, 52, 240, 139, 88, 248, 255, 228, 222, 135, 30, 178, 11, 31, 64, 157, 92, 49, 68, 215, 162, 36, 8, 116, 140, 231, 137, 59, 213, 133, 1],
-[1, 144, 176, 158, 136, 52, 35, 157, 249, 133, 134, 21, 197, 98, 234, 29, 64, 221, 213, 89, 223, 244, 184, 25, 2, 31, 95, 59, 15, 104, 70, 57, 241, 9, 11, 42, 137, 196, 211, 58, 128, 185, 169, 178, 189, 231, 111, 50, 4, 62, 190, 118, 30, 208, 140, 114, 225, 18, 22, 84, 17, 135, 165, 116, 256, 113, 81, 99, 121, 205, 222, 100, 8, 124, 123, 236, 60, 159, 23, 228, 193, 36, 44, 168, 34, 13, 73, 232, 255, 226, 162, 198, 242, 153, 187, 200, 16, 248, 246, 215, 120, 61, 46, 199, 129, 72, 88, 79, 68, 26, 146, 207, 253, 195, 67, 139, 227, 49, 117, 143, 32, 239, 235, 173, 240, 122, 92, 141, 1, 144, 176, 158, 136, 52, 35, 157, 249, 133, 134, 21, 197, 98, 234, 29, 64, 221, 213, 89, 223, 244, 184, 25, 2, 31, 95, 59, 15, 104, 70, 57, 241, 9, 11, 42, 137, 196, 211, 58, 128, 185, 169, 178, 189, 231, 111, 50, 4, 62, 190, 118, 30, 208, 140, 114, 225, 18, 22, 84, 17, 135, 165, 116, 256, 113, 81, 99, 121, 205, 222, 100, 8, 124, 123, 236, 60, 159, 23, 228, 193, 36, 44, 168, 34, 13, 73, 232, 255, 226, 162, 198, 242, 153, 187, 200, 16, 248, 246, 215, 120, 61, 46, 199, 129, 72, 88, 79, 68, 26, 146, 207, 253, 195, 67, 139, 227, 49, 117, 143, 32, 239, 235, 173, 240, 122, 92, 141, 1],
-[1, 145, 208, 91, 88, 167, 57, 41, 34, 47, 133, 10, 165, 24, 139, 109, 128, 56, 153, 83, 213, 45, 100, 108, 240, 105, 62, 252, 46, 245, 59, 74, 193, 229, 52, 87, 22, 106, 207, 203, 137, 76, 226, 131, 234, 6, 99, 220, 32, 14, 231, 85, 246, 204, 25, 27, 60, 219, 144, 63, 140, 254, 79, 147, 241, 250, 13, 86, 134, 155, 116, 115, 227, 19, 185, 97, 187, 130, 89, 55, 8, 132, 122, 214, 190, 51, 199, 71, 15, 119, 36, 80, 35, 192, 84, 101, 253, 191, 196, 150, 162, 103, 29, 93, 121, 69, 239, 217, 111, 161, 215, 78, 2, 33, 159, 182, 176, 77, 114, 82, 68, 94, 9, 20, 73, 48, 21, 218, 256, 112, 49, 166, 169, 90, 200, 216, 223, 210, 124, 247, 92, 233, 118, 148, 129, 201, 104, 174, 44, 212, 157, 149, 17, 152, 195, 5, 211, 12, 198, 183, 64, 28, 205, 170, 235, 151, 50, 54, 120, 181, 31, 126, 23, 251, 158, 37, 225, 243, 26, 172, 11, 53, 232, 230, 197, 38, 113, 194, 117, 3, 178, 110, 16, 7, 244, 171, 123, 102, 141, 142, 30, 238, 72, 160, 70, 127, 168, 202, 249, 125, 135, 43, 67, 206, 58, 186, 242, 138, 221, 177, 222, 65, 173, 156, 4, 66, 61, 107, 95, 154, 228, 164, 136, 188, 18, 40, 146, 96, 42, 179, 255, 224, 98, 75, 81, 180, 143, 175, 189, 163, 248, 237, 184, 209, 236, 39, 1],
-[1, 146, 242, 123, 225, 211, 223, 176, 253, 187, 60, 22, 128, 184, 136, 67, 16, 23, 17, 169, 2, 35, 227, 246, 193, 165, 189, 95, 249, 117, 120, 44, 256, 111, 15, 134, 32, 46, 34, 81, 4, 70, 197, 235, 129, 73, 121, 190, 241, 234, 240, 88, 255, 222, 30, 11, 64, 92, 68, 162, 8, 140, 137, 213, 1, 146, 242, 123, 225, 211, 223, 176, 253, 187, 60, 22, 128, 184, 136, 67, 16, 23, 17, 169, 2, 35, 227, 246, 193, 165, 189, 95, 249, 117, 120, 44, 256, 111, 15, 134, 32, 46, 34, 81, 4, 70, 197, 235, 129, 73, 121, 190, 241, 234, 240, 88, 255, 222, 30, 11, 64, 92, 68, 162, 8, 140, 137, 213, 1, 146, 242, 123, 225, 211, 223, 176, 253, 187, 60, 22, 128, 184, 136, 67, 16, 23, 17, 169, 2, 35, 227, 246, 193, 165, 189, 95, 249, 117, 120, 44, 256, 111, 15, 134, 32, 46, 34, 81, 4, 70, 197, 235, 129, 73, 121, 190, 241, 234, 240, 88, 255, 222, 30, 11, 64, 92, 68, 162, 8, 140, 137, 213, 1, 146, 242, 123, 225, 211, 223, 176, 253, 187, 60, 22, 128, 184, 136, 67, 16, 23, 17, 169, 2, 35, 227, 246, 193, 165, 189, 95, 249, 117, 120, 44, 256, 111, 15, 134, 32, 46, 34, 81, 4, 70, 197, 235, 129, 73, 121, 190, 241, 234, 240, 88, 255, 222, 30, 11, 64, 92, 68, 162, 8, 140, 137, 213, 1],
-[1, 147, 21, 3, 184, 63, 9, 38, 189, 27, 114, 53, 81, 85, 159, 243, 255, 220, 215, 251, 146, 131, 239, 181, 136, 203, 29, 151, 95, 87, 196, 28, 4, 74, 84, 12, 222, 252, 36, 152, 242, 108, 199, 212, 67, 83, 122, 201, 249, 109, 89, 233, 70, 10, 185, 210, 30, 41, 116, 90, 123, 91, 13, 112, 16, 39, 79, 48, 117, 237, 144, 94, 197, 175, 25, 77, 11, 75, 231, 33, 225, 179, 99, 161, 23, 40, 226, 69, 120, 164, 207, 103, 235, 107, 52, 191, 64, 156, 59, 192, 211, 177, 62, 119, 17, 186, 100, 51, 44, 43, 153, 132, 129, 202, 139, 130, 92, 160, 133, 19, 223, 142, 57, 155, 169, 171, 208, 250, 256, 110, 236, 254, 73, 194, 248, 219, 68, 230, 143, 204, 176, 172, 98, 14, 2, 37, 42, 6, 111, 126, 18, 76, 121, 54, 228, 106, 162, 170, 61, 229, 253, 183, 173, 245, 35, 5, 221, 105, 15, 149, 58, 45, 190, 174, 135, 56, 8, 148, 168, 24, 187, 247, 72, 47, 227, 216, 141, 167, 134, 166, 244, 145, 241, 218, 178, 209, 140, 20, 113, 163, 60, 82, 232, 180, 246, 182, 26, 224, 32, 78, 158, 96, 234, 217, 31, 188, 137, 93, 50, 154, 22, 150, 205, 66, 193, 101, 198, 65, 46, 80, 195, 138, 240, 71, 157, 206, 213, 214, 104, 125, 128, 55, 118, 127, 165, 97, 124, 238, 34, 115, 200, 102, 88, 86, 49, 7, 1],
-[1, 148, 59, 251, 140, 160, 36, 188, 68, 41, 157, 106, 11, 86, 135, 191, 255, 218, 139, 12, 234, 194, 185, 138, 121, 175, 200, 45, 235, 85, 244, 132, 4, 78, 236, 233, 46, 126, 144, 238, 15, 164, 114, 167, 44, 87, 26, 250, 249, 101, 42, 48, 165, 5, 226, 38, 227, 186, 29, 180, 169, 83, 205, 14, 16, 55, 173, 161, 184, 247, 62, 181, 60, 142, 199, 154, 176, 91, 104, 229, 225, 147, 168, 192, 146, 20, 133, 152, 137, 230, 116, 206, 162, 75, 49, 56, 64, 220, 178, 130, 222, 217, 248, 210, 240, 54, 25, 102, 190, 107, 159, 145, 129, 74, 158, 254, 70, 80, 18, 94, 34, 149, 207, 53, 134, 43, 196, 224, 256, 109, 198, 6, 117, 97, 221, 69, 189, 216, 100, 151, 246, 171, 122, 66, 2, 39, 118, 245, 23, 63, 72, 119, 136, 82, 57, 212, 22, 172, 13, 125, 253, 179, 21, 24, 211, 131, 113, 19, 242, 93, 143, 90, 213, 170, 231, 7, 8, 156, 215, 209, 92, 252, 31, 219, 30, 71, 228, 77, 88, 174, 52, 243, 241, 202, 84, 96, 73, 10, 195, 76, 197, 115, 58, 103, 81, 166, 153, 28, 32, 110, 89, 65, 111, 237, 124, 105, 120, 27, 141, 51, 95, 182, 208, 201, 193, 37, 79, 127, 35, 40, 9, 47, 17, 203, 232, 155, 67, 150, 98, 112, 128, 183, 99, 3, 187, 177, 239, 163, 223, 108, 50, 204, 123, 214, 61, 33, 1],
-[1, 149, 99, 102, 35, 75, 124, 229, 197, 55, 228, 48, 213, 126, 13, 138, 2, 41, 198, 204, 70, 150, 248, 201, 137, 110, 199, 96, 169, 252, 26, 19, 4, 82, 139, 151, 140, 43, 239, 145, 17, 220, 141, 192, 81, 247, 52, 38, 8, 164, 21, 45, 23, 86, 221, 33, 34, 183, 25, 127, 162, 237, 104, 76, 16, 71, 42, 90, 46, 172, 185, 66, 68, 109, 50, 254, 67, 217, 208, 152, 32, 142, 84, 180, 92, 87, 113, 132, 136, 218, 100, 251, 134, 177, 159, 47, 64, 27, 168, 103, 184, 174, 226, 7, 15, 179, 200, 245, 11, 97, 61, 94, 128, 54, 79, 206, 111, 91, 195, 14, 30, 101, 143, 233, 22, 194, 122, 188, 256, 108, 158, 155, 222, 182, 133, 28, 60, 202, 29, 209, 44, 131, 244, 119, 255, 216, 59, 53, 187, 107, 9, 56, 120, 147, 58, 161, 88, 5, 231, 238, 253, 175, 118, 106, 117, 214, 18, 112, 240, 37, 116, 65, 176, 10, 205, 219, 249, 93, 236, 212, 234, 171, 36, 224, 223, 74, 232, 130, 95, 20, 153, 181, 241, 186, 215, 167, 211, 85, 72, 191, 189, 148, 207, 3, 190, 40, 49, 105, 225, 115, 173, 77, 165, 170, 144, 125, 121, 39, 157, 6, 123, 80, 98, 210, 193, 230, 89, 154, 73, 83, 31, 250, 242, 78, 57, 12, 246, 160, 196, 163, 129, 203, 178, 51, 146, 166, 62, 243, 227, 156, 114, 24, 235, 63, 135, 69, 1],
-[1, 150, 141, 76, 92, 179, 122, 53, 240, 20, 173, 250, 235, 41, 239, 127, 32, 174, 143, 119, 117, 74, 49, 154, 227, 126, 139, 33, 67, 27, 195, 209, 253, 171, 207, 210, 146, 55, 26, 45, 68, 177, 79, 28, 88, 93, 72, 6, 129, 75, 199, 38, 46, 218, 61, 155, 120, 10, 215, 125, 246, 149, 248, 192, 16, 87, 200, 188, 187, 37, 153, 77, 242, 63, 198, 145, 162, 142, 226, 233, 255, 214, 232, 105, 73, 156, 13, 151, 34, 217, 168, 14, 44, 175, 36, 3, 193, 166, 228, 19, 23, 109, 159, 206, 60, 5, 236, 191, 123, 203, 124, 96, 8, 172, 100, 94, 222, 147, 205, 167, 121, 160, 99, 201, 81, 71, 113, 245, 256, 107, 116, 181, 165, 78, 135, 204, 17, 237, 84, 7, 22, 216, 18, 130, 225, 83, 114, 138, 140, 183, 208, 103, 30, 131, 118, 224, 190, 230, 62, 48, 4, 86, 50, 47, 111, 202, 231, 212, 189, 80, 178, 229, 169, 164, 185, 251, 128, 182, 58, 219, 211, 39, 196, 102, 137, 247, 42, 132, 11, 108, 9, 65, 241, 170, 57, 69, 70, 220, 104, 180, 15, 194, 59, 112, 95, 115, 31, 24, 2, 43, 25, 152, 184, 101, 244, 106, 223, 40, 89, 243, 213, 82, 221, 254, 64, 91, 29, 238, 234, 148, 98, 51, 197, 252, 21, 66, 134, 54, 133, 161, 249, 85, 157, 163, 35, 110, 52, 90, 136, 97, 158, 56, 176, 186, 144, 12, 1],
-[1, 151, 185, 179, 44, 219, 173, 166, 137, 127, 159, 108, 117, 191, 57, 126, 8, 180, 195, 147, 95, 210, 99, 43, 68, 245, 244, 93, 165, 243, 199, 237, 64, 155, 18, 148, 246, 138, 21, 87, 30, 161, 153, 230, 35, 145, 50, 97, 255, 212, 144, 156, 169, 76, 168, 182, 240, 3, 196, 41, 23, 132, 143, 5, 241, 154, 124, 220, 67, 94, 59, 171, 121, 24, 26, 71, 184, 28, 116, 40, 129, 204, 221, 218, 22, 238, 215, 83, 197, 192, 208, 54, 187, 224, 157, 63, 4, 90, 226, 202, 176, 105, 178, 150, 34, 251, 122, 175, 211, 250, 228, 247, 32, 206, 9, 74, 123, 69, 139, 172, 15, 209, 205, 115, 146, 201, 25, 177, 256, 106, 72, 78, 213, 38, 84, 91, 120, 130, 98, 149, 140, 66, 200, 131, 249, 77, 62, 110, 162, 47, 158, 214, 189, 12, 13, 164, 92, 14, 58, 20, 193, 102, 239, 109, 11, 119, 236, 170, 227, 96, 104, 27, 222, 112, 207, 160, 2, 45, 113, 101, 88, 181, 89, 75, 17, 254, 61, 216, 234, 125, 114, 252, 16, 103, 133, 37, 190, 163, 198, 86, 136, 233, 231, 186, 73, 229, 141, 217, 128, 53, 36, 39, 235, 19, 42, 174, 60, 65, 49, 203, 70, 33, 100, 194, 253, 167, 31, 55, 81, 152, 79, 107, 223, 6, 135, 82, 46, 7, 29, 10, 225, 51, 248, 183, 134, 188, 118, 85, 242, 48, 52, 142, 111, 56, 232, 80, 1],
-[1, 152, 231, 160, 162, 209, 157, 220, 30, 191, 248, 174, 234, 102, 84, 175, 129, 76, 244, 80, 81, 233, 207, 110, 15, 224, 124, 87, 117, 51, 42, 216, 193, 38, 122, 40, 169, 245, 232, 55, 136, 112, 62, 172, 187, 154, 21, 108, 225, 19, 61, 20, 213, 251, 116, 156, 68, 56, 31, 86, 222, 77, 139, 54, 241, 138, 159, 10, 235, 254, 58, 78, 34, 28, 144, 43, 111, 167, 198, 27, 249, 69, 208, 5, 246, 127, 29, 39, 17, 14, 72, 150, 184, 212, 99, 142, 253, 163, 104, 131, 123, 192, 143, 148, 137, 7, 36, 75, 92, 106, 178, 71, 255, 210, 52, 194, 190, 96, 200, 74, 197, 132, 18, 166, 46, 53, 89, 164, 256, 105, 26, 97, 95, 48, 100, 37, 227, 66, 9, 83, 23, 155, 173, 82, 128, 181, 13, 177, 176, 24, 50, 147, 242, 33, 133, 170, 140, 206, 215, 41, 64, 219, 135, 217, 88, 12, 25, 202, 121, 145, 195, 85, 70, 103, 236, 149, 32, 238, 196, 237, 44, 6, 141, 101, 189, 201, 226, 171, 35, 180, 118, 203, 16, 119, 98, 247, 22, 3, 199, 179, 223, 229, 113, 214, 146, 90, 59, 230, 8, 188, 49, 252, 11, 130, 228, 218, 240, 243, 185, 107, 73, 45, 158, 115, 4, 94, 153, 126, 134, 65, 114, 109, 120, 250, 221, 182, 165, 151, 79, 186, 2, 47, 205, 63, 67, 161, 57, 183, 60, 125, 239, 91, 211, 204, 168, 93, 1],
-[1, 153, 22, 25, 227, 36, 111, 21, 129, 205, 11, 141, 242, 18, 184, 139, 193, 231, 134, 199, 121, 9, 92, 198, 225, 244, 67, 228, 189, 133, 46, 99, 241, 122, 162, 114, 223, 195, 23, 178, 249, 61, 81, 57, 240, 226, 140, 89, 253, 159, 169, 157, 120, 113, 70, 173, 255, 208, 213, 207, 60, 185, 35, 215, 256, 104, 235, 232, 30, 221, 146, 236, 128, 52, 246, 116, 15, 239, 73, 118, 64, 26, 123, 58, 136, 248, 165, 59, 32, 13, 190, 29, 68, 124, 211, 158, 16, 135, 95, 143, 34, 62, 234, 79, 8, 196, 176, 200, 17, 31, 117, 168, 4, 98, 88, 100, 137, 144, 187, 84, 2, 49, 44, 50, 197, 72, 222, 42, 1, 153, 22, 25, 227, 36, 111, 21, 129, 205, 11, 141, 242, 18, 184, 139, 193, 231, 134, 199, 121, 9, 92, 198, 225, 244, 67, 228, 189, 133, 46, 99, 241, 122, 162, 114, 223, 195, 23, 178, 249, 61, 81, 57, 240, 226, 140, 89, 253, 159, 169, 157, 120, 113, 70, 173, 255, 208, 213, 207, 60, 185, 35, 215, 256, 104, 235, 232, 30, 221, 146, 236, 128, 52, 246, 116, 15, 239, 73, 118, 64, 26, 123, 58, 136, 248, 165, 59, 32, 13, 190, 29, 68, 124, 211, 158, 16, 135, 95, 143, 34, 62, 234, 79, 8, 196, 176, 200, 17, 31, 117, 168, 4, 98, 88, 100, 137, 144, 187, 84, 2, 49, 44, 50, 197, 72, 222, 42, 1],
-[1, 154, 72, 37, 44, 94, 84, 86, 137, 24, 98, 186, 117, 28, 200, 217, 8, 204, 62, 39, 95, 238, 158, 174, 68, 192, 13, 203, 165, 224, 58, 194, 64, 90, 239, 55, 246, 105, 236, 107, 30, 251, 104, 82, 35, 250, 207, 10, 255, 206, 113, 183, 169, 69, 89, 85, 240, 209, 61, 142, 23, 201, 114, 80, 241, 106, 133, 179, 67, 38, 198, 166, 121, 130, 231, 108, 184, 66, 141, 126, 129, 77, 36, 147, 22, 47, 42, 43, 197, 12, 49, 93, 187, 14, 100, 237, 4, 102, 31, 148, 176, 119, 79, 87, 34, 96, 135, 230, 211, 112, 29, 97, 32, 45, 248, 156, 123, 181, 118, 182, 15, 254, 52, 41, 146, 125, 232, 5, 256, 103, 185, 220, 213, 163, 173, 171, 120, 233, 159, 71, 140, 229, 57, 40, 249, 53, 195, 218, 162, 19, 99, 83, 189, 65, 244, 54, 92, 33, 199, 63, 193, 167, 18, 202, 11, 152, 21, 150, 227, 6, 153, 175, 222, 7, 50, 247, 2, 51, 144, 74, 88, 188, 168, 172, 17, 48, 196, 115, 234, 56, 143, 177, 16, 151, 124, 78, 190, 219, 59, 91, 136, 127, 26, 149, 73, 191, 116, 131, 128, 180, 221, 110, 235, 210, 215, 214, 60, 245, 208, 164, 70, 243, 157, 20, 253, 155, 226, 109, 81, 138, 178, 170, 223, 161, 122, 27, 46, 145, 228, 160, 225, 212, 9, 101, 134, 76, 139, 75, 242, 3, 205, 216, 111, 132, 25, 252, 1],
-[1, 155, 124, 202, 213, 119, 198, 107, 137, 161, 26, 175, 140, 112, 141, 10, 8, 212, 221, 74, 162, 181, 42, 85, 68, 3, 208, 115, 92, 125, 100, 80, 64, 154, 226, 78, 11, 163, 79, 166, 30, 24, 122, 149, 222, 229, 29, 126, 255, 204, 9, 110, 88, 19, 118, 43, 240, 192, 205, 164, 234, 33, 232, 237, 241, 90, 72, 109, 190, 152, 173, 87, 121, 251, 98, 27, 73, 7, 57, 97, 129, 206, 62, 101, 235, 188, 99, 182, 197, 209, 13, 216, 70, 56, 199, 5, 4, 106, 239, 37, 81, 219, 21, 171, 34, 130, 104, 186, 46, 191, 50, 40, 32, 77, 113, 39, 134, 210, 168, 83, 15, 12, 61, 203, 111, 243, 143, 63, 256, 102, 133, 55, 44, 138, 59, 150, 120, 96, 231, 82, 117, 145, 116, 247, 249, 45, 36, 183, 95, 76, 215, 172, 189, 254, 49, 142, 165, 132, 157, 177, 193, 103, 31, 179, 246, 94, 178, 91, 227, 233, 135, 108, 35, 28, 228, 131, 2, 53, 248, 147, 169, 238, 139, 214, 17, 65, 52, 93, 23, 224, 25, 20, 16, 167, 185, 148, 67, 105, 84, 170, 136, 6, 159, 230, 184, 250, 200, 160, 128, 51, 195, 156, 22, 69, 158, 75, 60, 48, 244, 41, 187, 201, 58, 252, 253, 151, 18, 220, 176, 38, 236, 86, 223, 127, 153, 71, 211, 66, 207, 217, 225, 180, 144, 218, 123, 47, 89, 174, 242, 245, 196, 54, 146, 14, 114, 194, 1],
-[1, 156, 178, 12, 73, 80, 144, 105, 189, 186, 232, 212, 176, 214, 231, 56, 255, 202, 158, 233, 111, 97, 226, 47, 136, 142, 50, 90, 162, 86, 52, 145, 4, 110, 198, 48, 35, 63, 62, 163, 242, 230, 157, 77, 190, 85, 153, 224, 249, 37, 118, 161, 187, 131, 133, 188, 30, 54, 200, 103, 134, 87, 208, 66, 16, 183, 21, 192, 140, 252, 248, 138, 197, 149, 114, 51, 246, 83, 98, 125, 225, 148, 215, 130, 234, 10, 18, 238, 120, 216, 29, 155, 22, 91, 61, 7, 64, 218, 84, 254, 46, 237, 221, 38, 17, 82, 199, 204, 213, 75, 135, 243, 129, 78, 89, 6, 165, 40, 72, 181, 223, 93, 116, 106, 88, 107, 244, 28, 256, 101, 79, 245, 184, 177, 113, 152, 68, 71, 25, 45, 81, 43, 26, 201, 2, 55, 99, 24, 146, 160, 31, 210, 121, 115, 207, 167, 95, 171, 205, 112, 253, 147, 59, 209, 222, 194, 195, 94, 15, 27, 100, 180, 67, 172, 104, 33, 8, 220, 139, 96, 70, 126, 124, 69, 227, 203, 57, 154, 123, 170, 49, 191, 241, 74, 236, 65, 117, 5, 9, 119, 60, 108, 143, 206, 11, 174, 159, 132, 32, 109, 42, 127, 23, 247, 239, 19, 137, 41, 228, 102, 235, 166, 196, 250, 193, 39, 173, 3, 211, 20, 36, 219, 240, 175, 58, 53, 44, 182, 122, 14, 128, 179, 168, 251, 92, 217, 185, 76, 34, 164, 141, 151, 169, 150, 13, 229, 1],
-[1, 157, 234, 244, 15, 42, 169, 62, 225, 116, 222, 159, 34, 198, 246, 72, 253, 143, 92, 52, 197, 89, 95, 9, 128, 50, 140, 135, 121, 236, 44, 226, 16, 199, 146, 49, 240, 158, 134, 221, 2, 57, 211, 231, 30, 84, 81, 124, 193, 232, 187, 61, 68, 139, 235, 144, 249, 29, 184, 104, 137, 178, 190, 18, 256, 100, 23, 13, 242, 215, 88, 195, 32, 141, 35, 98, 223, 59, 11, 185, 4, 114, 165, 205, 60, 168, 162, 248, 129, 207, 117, 122, 136, 21, 213, 31, 241, 58, 111, 208, 17, 99, 123, 36, 255, 200, 46, 26, 227, 173, 176, 133, 64, 25, 70, 196, 189, 118, 22, 113, 8, 228, 73, 153, 120, 79, 67, 239, 1, 157, 234, 244, 15, 42, 169, 62, 225, 116, 222, 159, 34, 198, 246, 72, 253, 143, 92, 52, 197, 89, 95, 9, 128, 50, 140, 135, 121, 236, 44, 226, 16, 199, 146, 49, 240, 158, 134, 221, 2, 57, 211, 231, 30, 84, 81, 124, 193, 232, 187, 61, 68, 139, 235, 144, 249, 29, 184, 104, 137, 178, 190, 18, 256, 100, 23, 13, 242, 215, 88, 195, 32, 141, 35, 98, 223, 59, 11, 185, 4, 114, 165, 205, 60, 168, 162, 248, 129, 207, 117, 122, 136, 21, 213, 31, 241, 58, 111, 208, 17, 99, 123, 36, 255, 200, 46, 26, 227, 173, 176, 133, 64, 25, 70, 196, 189, 118, 22, 113, 8, 228, 73, 153, 120, 79, 67, 239, 1],
-[1, 158, 35, 133, 197, 29, 213, 244, 2, 59, 70, 9, 137, 58, 169, 231, 4, 118, 140, 18, 17, 116, 81, 205, 8, 236, 23, 36, 34, 232, 162, 153, 16, 215, 46, 72, 68, 207, 67, 49, 32, 173, 92, 144, 136, 157, 134, 98, 64, 89, 184, 31, 15, 57, 11, 196, 128, 178, 111, 62, 30, 114, 22, 135, 256, 99, 222, 124, 60, 228, 44, 13, 255, 198, 187, 248, 120, 199, 88, 26, 253, 139, 117, 239, 240, 141, 176, 52, 249, 21, 234, 221, 223, 25, 95, 104, 241, 42, 211, 185, 189, 50, 190, 208, 225, 84, 165, 113, 121, 100, 123, 159, 193, 168, 73, 226, 242, 200, 246, 61, 129, 79, 146, 195, 227, 143, 235, 122, 1, 158, 35, 133, 197, 29, 213, 244, 2, 59, 70, 9, 137, 58, 169, 231, 4, 118, 140, 18, 17, 116, 81, 205, 8, 236, 23, 36, 34, 232, 162, 153, 16, 215, 46, 72, 68, 207, 67, 49, 32, 173, 92, 144, 136, 157, 134, 98, 64, 89, 184, 31, 15, 57, 11, 196, 128, 178, 111, 62, 30, 114, 22, 135, 256, 99, 222, 124, 60, 228, 44, 13, 255, 198, 187, 248, 120, 199, 88, 26, 253, 139, 117, 239, 240, 141, 176, 52, 249, 21, 234, 221, 223, 25, 95, 104, 241, 42, 211, 185, 189, 50, 190, 208, 225, 84, 165, 113, 121, 100, 123, 159, 193, 168, 73, 226, 242, 200, 246, 61, 129, 79, 146, 195, 227, 143, 235, 122, 1],
-[1, 159, 95, 199, 30, 144, 23, 59, 129, 208, 176, 228, 15, 72, 140, 158, 193, 104, 88, 114, 136, 36, 70, 79, 225, 52, 44, 57, 68, 18, 35, 168, 241, 26, 22, 157, 34, 9, 146, 84, 249, 13, 11, 207, 17, 133, 73, 42, 253, 135, 134, 232, 137, 195, 165, 21, 255, 196, 67, 116, 197, 226, 211, 139, 256, 98, 162, 58, 227, 113, 234, 198, 128, 49, 81, 29, 242, 185, 117, 99, 64, 153, 169, 143, 121, 221, 187, 178, 32, 205, 213, 200, 189, 239, 222, 89, 16, 231, 235, 100, 223, 248, 111, 173, 8, 244, 246, 50, 240, 124, 184, 215, 4, 122, 123, 25, 120, 62, 92, 236, 2, 61, 190, 141, 60, 31, 46, 118, 1, 159, 95, 199, 30, 144, 23, 59, 129, 208, 176, 228, 15, 72, 140, 158, 193, 104, 88, 114, 136, 36, 70, 79, 225, 52, 44, 57, 68, 18, 35, 168, 241, 26, 22, 157, 34, 9, 146, 84, 249, 13, 11, 207, 17, 133, 73, 42, 253, 135, 134, 232, 137, 195, 165, 21, 255, 196, 67, 116, 197, 226, 211, 139, 256, 98, 162, 58, 227, 113, 234, 198, 128, 49, 81, 29, 242, 185, 117, 99, 64, 153, 169, 143, 121, 221, 187, 178, 32, 205, 213, 200, 189, 239, 222, 89, 16, 231, 235, 100, 223, 248, 111, 173, 8, 244, 246, 50, 240, 124, 184, 215, 4, 122, 123, 25, 120, 62, 92, 236, 2, 61, 190, 141, 60, 31, 46, 118, 1],
-[1, 160, 157, 191, 234, 175, 244, 233, 15, 87, 42, 38, 169, 55, 62, 154, 225, 20, 116, 56, 222, 54, 159, 254, 34, 43, 198, 69, 246, 39, 72, 212, 253, 131, 143, 7, 92, 71, 52, 96, 197, 166, 89, 105, 95, 37, 9, 155, 128, 177, 50, 33, 140, 41, 135, 12, 121, 85, 236, 238, 44, 101, 226, 180, 16, 247, 199, 229, 146, 230, 49, 130, 240, 107, 158, 94, 134, 109, 221, 151, 2, 63, 57, 125, 211, 93, 231, 209, 30, 174, 84, 76, 81, 110, 124, 51, 193, 40, 232, 112, 187, 108, 61, 251, 68, 86, 139, 138, 235, 78, 144, 167, 249, 5, 29, 14, 184, 142, 104, 192, 137, 75, 178, 210, 190, 74, 18, 53, 256, 97, 100, 66, 23, 82, 13, 24, 242, 170, 215, 219, 88, 202, 195, 103, 32, 237, 141, 201, 35, 203, 98, 3, 223, 214, 59, 188, 11, 218, 185, 45, 4, 126, 114, 250, 165, 186, 205, 161, 60, 91, 168, 152, 162, 220, 248, 102, 129, 80, 207, 224, 117, 216, 122, 245, 136, 172, 21, 19, 213, 156, 31, 77, 241, 10, 58, 28, 111, 27, 208, 127, 17, 150, 99, 163, 123, 148, 36, 106, 255, 194, 200, 132, 46, 164, 26, 48, 227, 83, 173, 181, 176, 147, 133, 206, 64, 217, 25, 145, 70, 149, 196, 6, 189, 171, 118, 119, 22, 179, 113, 90, 8, 252, 228, 243, 73, 115, 153, 65, 120, 182, 79, 47, 67, 183, 239, 204, 1],
-[1, 161, 221, 115, 11, 229, 118, 237, 121, 206, 13, 37, 46, 210, 143, 150, 249, 254, 31, 108, 169, 224, 84, 160, 60, 151, 153, 218, 146, 119, 141, 85, 64, 24, 9, 164, 190, 7, 99, 5, 34, 77, 61, 55, 117, 76, 157, 91, 2, 65, 185, 230, 22, 201, 236, 217, 242, 155, 26, 74, 92, 163, 29, 43, 241, 251, 62, 216, 81, 191, 168, 63, 120, 45, 49, 179, 35, 238, 25, 170, 128, 48, 18, 71, 123, 14, 198, 10, 68, 154, 122, 110, 234, 152, 57, 182, 4, 130, 113, 203, 44, 145, 215, 177, 227, 53, 52, 148, 184, 69, 58, 86, 225, 245, 124, 175, 162, 125, 79, 126, 240, 90, 98, 101, 70, 219, 50, 83, 256, 96, 36, 142, 246, 28, 139, 20, 136, 51, 244, 220, 211, 47, 114, 107, 8, 3, 226, 149, 88, 33, 173, 97, 197, 106, 104, 39, 111, 138, 116, 172, 193, 233, 248, 93, 67, 250, 158, 252, 223, 180, 196, 202, 140, 181, 100, 166, 255, 192, 72, 27, 235, 56, 21, 40, 15, 102, 231, 183, 165, 94, 228, 214, 16, 6, 195, 41, 176, 66, 89, 194, 137, 212, 208, 78, 222, 19, 232, 87, 129, 209, 239, 186, 134, 243, 59, 247, 189, 103, 135, 147, 23, 105, 200, 75, 253, 127, 144, 54, 213, 112, 42, 80, 30, 204, 205, 109, 73, 188, 199, 171, 32, 12, 133, 82, 95, 132, 178, 131, 17, 167, 159, 156, 187, 38, 207, 174, 1],
-[1, 162, 30, 234, 129, 81, 15, 117, 193, 169, 136, 187, 225, 213, 68, 222, 241, 235, 34, 111, 249, 246, 17, 184, 253, 123, 137, 92, 255, 190, 197, 46, 256, 95, 227, 23, 128, 176, 242, 140, 64, 88, 121, 70, 32, 44, 189, 35, 16, 22, 223, 146, 8, 11, 240, 73, 4, 134, 120, 165, 2, 67, 60, 211, 1, 162, 30, 234, 129, 81, 15, 117, 193, 169, 136, 187, 225, 213, 68, 222, 241, 235, 34, 111, 249, 246, 17, 184, 253, 123, 137, 92, 255, 190, 197, 46, 256, 95, 227, 23, 128, 176, 242, 140, 64, 88, 121, 70, 32, 44, 189, 35, 16, 22, 223, 146, 8, 11, 240, 73, 4, 134, 120, 165, 2, 67, 60, 211, 1, 162, 30, 234, 129, 81, 15, 117, 193, 169, 136, 187, 225, 213, 68, 222, 241, 235, 34, 111, 249, 246, 17, 184, 253, 123, 137, 92, 255, 190, 197, 46, 256, 95, 227, 23, 128, 176, 242, 140, 64, 88, 121, 70, 32, 44, 189, 35, 16, 22, 223, 146, 8, 11, 240, 73, 4, 134, 120, 165, 2, 67, 60, 211, 1, 162, 30, 234, 129, 81, 15, 117, 193, 169, 136, 187, 225, 213, 68, 222, 241, 235, 34, 111, 249, 246, 17, 184, 253, 123, 137, 92, 255, 190, 197, 46, 256, 95, 227, 23, 128, 176, 242, 140, 64, 88, 121, 70, 32, 44, 189, 35, 16, 22, 223, 146, 8, 11, 240, 73, 4, 134, 120, 165, 2, 67, 60, 211, 1],
-[1, 163, 98, 40, 95, 65, 58, 202, 30, 7, 113, 172, 23, 151, 198, 149, 129, 210, 49, 20, 176, 161, 29, 101, 15, 132, 185, 86, 140, 204, 99, 203, 193, 105, 153, 10, 88, 209, 143, 179, 136, 66, 221, 43, 70, 102, 178, 230, 225, 181, 205, 5, 44, 233, 200, 218, 68, 33, 239, 150, 35, 51, 89, 115, 241, 219, 231, 131, 22, 245, 100, 109, 34, 145, 248, 75, 146, 154, 173, 186, 249, 238, 244, 194, 11, 251, 50, 183, 17, 201, 124, 166, 73, 77, 215, 93, 253, 119, 122, 97, 134, 254, 25, 220, 137, 229, 62, 83, 165, 167, 236, 175, 255, 188, 61, 177, 67, 127, 141, 110, 197, 243, 31, 170, 211, 212, 118, 216, 256, 94, 159, 217, 162, 192, 199, 55, 227, 250, 144, 85, 234, 106, 59, 108, 128, 47, 208, 237, 81, 96, 228, 156, 242, 125, 72, 171, 117, 53, 158, 54, 64, 152, 104, 247, 169, 48, 114, 78, 121, 191, 36, 214, 187, 155, 79, 27, 32, 76, 52, 252, 213, 24, 57, 39, 189, 224, 18, 107, 222, 206, 168, 142, 16, 38, 26, 126, 235, 12, 157, 148, 223, 112, 9, 182, 111, 103, 84, 71, 8, 19, 13, 63, 246, 6, 207, 74, 240, 56, 133, 91, 184, 180, 42, 164, 4, 138, 135, 160, 123, 3, 232, 37, 120, 28, 195, 174, 92, 90, 21, 82, 2, 69, 196, 80, 190, 130, 116, 147, 60, 14, 226, 87, 46, 45, 139, 41, 1],
-[1, 164, 168, 53, 211, 166, 239, 132, 60, 74, 57, 96, 67, 194, 205, 210, 2, 71, 79, 106, 165, 75, 221, 7, 120, 148, 114, 192, 134, 131, 153, 163, 4, 142, 158, 212, 73, 150, 185, 14, 240, 39, 228, 127, 11, 5, 49, 69, 8, 27, 59, 167, 146, 43, 113, 28, 223, 78, 199, 254, 22, 10, 98, 138, 16, 54, 118, 77, 35, 86, 226, 56, 189, 156, 141, 251, 44, 20, 196, 19, 32, 108, 236, 154, 70, 172, 195, 112, 121, 55, 25, 245, 88, 40, 135, 38, 64, 216, 215, 51, 140, 87, 133, 224, 242, 110, 50, 233, 176, 80, 13, 76, 128, 175, 173, 102, 23, 174, 9, 191, 227, 220, 100, 209, 95, 160, 26, 152, 256, 93, 89, 204, 46, 91, 18, 125, 197, 183, 200, 161, 190, 63, 52, 47, 255, 186, 178, 151, 92, 182, 36, 250, 137, 109, 143, 65, 123, 126, 104, 94, 253, 115, 99, 45, 184, 107, 72, 243, 17, 218, 29, 130, 246, 252, 208, 188, 249, 230, 198, 90, 111, 214, 144, 229, 34, 179, 58, 3, 235, 247, 159, 119, 241, 203, 139, 180, 222, 171, 31, 201, 68, 101, 116, 6, 213, 237, 61, 238, 225, 149, 21, 103, 187, 85, 62, 145, 136, 202, 232, 12, 169, 217, 122, 219, 193, 41, 42, 206, 117, 170, 124, 33, 15, 147, 207, 24, 81, 177, 244, 181, 129, 82, 84, 155, 234, 83, 248, 66, 30, 37, 157, 48, 162, 97, 231, 105, 1],
-[1, 165, 240, 22, 32, 140, 227, 190, 253, 111, 68, 169, 129, 211, 120, 11, 16, 70, 242, 95, 255, 184, 34, 213, 193, 234, 60, 134, 8, 35, 121, 176, 256, 92, 17, 235, 225, 117, 30, 67, 4, 146, 189, 88, 128, 46, 137, 246, 241, 187, 15, 162, 2, 73, 223, 44, 64, 23, 197, 123, 249, 222, 136, 81, 1, 165, 240, 22, 32, 140, 227, 190, 253, 111, 68, 169, 129, 211, 120, 11, 16, 70, 242, 95, 255, 184, 34, 213, 193, 234, 60, 134, 8, 35, 121, 176, 256, 92, 17, 235, 225, 117, 30, 67, 4, 146, 189, 88, 128, 46, 137, 246, 241, 187, 15, 162, 2, 73, 223, 44, 64, 23, 197, 123, 249, 222, 136, 81, 1, 165, 240, 22, 32, 140, 227, 190, 253, 111, 68, 169, 129, 211, 120, 11, 16, 70, 242, 95, 255, 184, 34, 213, 193, 234, 60, 134, 8, 35, 121, 176, 256, 92, 17, 235, 225, 117, 30, 67, 4, 146, 189, 88, 128, 46, 137, 246, 241, 187, 15, 162, 2, 73, 223, 44, 64, 23, 197, 123, 249, 222, 136, 81, 1, 165, 240, 22, 32, 140, 227, 190, 253, 111, 68, 169, 129, 211, 120, 11, 16, 70, 242, 95, 255, 184, 34, 213, 193, 234, 60, 134, 8, 35, 121, 176, 256, 92, 17, 235, 225, 117, 30, 67, 4, 146, 189, 88, 128, 46, 137, 246, 241, 187, 15, 162, 2, 73, 223, 44, 64, 23, 197, 123, 249, 222, 136, 81, 1],
-[1, 166, 57, 210, 165, 148, 153, 212, 240, 5, 59, 28, 22, 54, 226, 251, 32, 172, 25, 38, 140, 110, 13, 102, 227, 160, 89, 125, 190, 186, 36, 65, 253, 107, 29, 188, 111, 179, 159, 180, 68, 237, 21, 145, 169, 41, 124, 24, 129, 83, 157, 105, 211, 74, 205, 106, 120, 131, 158, 14, 11, 27, 113, 254, 16, 86, 141, 19, 70, 55, 135, 51, 242, 80, 173, 191, 95, 93, 18, 161, 255, 182, 143, 94, 184, 218, 208, 90, 34, 247, 139, 201, 213, 149, 62, 12, 193, 170, 207, 181, 234, 37, 231, 53, 60, 194, 79, 7, 134, 142, 185, 127, 8, 43, 199, 138, 35, 156, 196, 154, 121, 40, 215, 224, 176, 175, 9, 209, 256, 91, 200, 47, 92, 109, 104, 45, 17, 252, 198, 229, 235, 203, 31, 6, 225, 85, 232, 219, 117, 147, 244, 155, 30, 97, 168, 132, 67, 71, 221, 192, 4, 150, 228, 69, 146, 78, 98, 77, 189, 20, 236, 112, 88, 216, 133, 233, 128, 174, 100, 152, 46, 183, 52, 151, 137, 126, 99, 243, 246, 230, 144, 3, 241, 171, 116, 238, 187, 202, 122, 206, 15, 177, 84, 66, 162, 164, 239, 96, 2, 75, 114, 163, 73, 39, 49, 167, 223, 10, 118, 56, 44, 108, 195, 245, 64, 87, 50, 76, 23, 220, 26, 204, 197, 63, 178, 250, 123, 115, 72, 130, 249, 214, 58, 119, 222, 101, 61, 103, 136, 217, 42, 33, 81, 82, 248, 48, 1],
-[1, 167, 133, 109, 213, 105, 59, 87, 137, 6, 231, 27, 140, 250, 116, 97, 8, 51, 36, 101, 162, 69, 215, 182, 68, 48, 49, 216, 92, 201, 157, 5, 64, 151, 31, 37, 11, 38, 178, 171, 30, 127, 135, 186, 222, 66, 228, 40, 255, 180, 248, 39, 88, 47, 139, 83, 240, 245, 52, 203, 234, 14, 25, 63, 241, 155, 185, 55, 190, 119, 84, 150, 121, 161, 159, 82, 73, 112, 200, 247, 129, 212, 195, 183, 235, 181, 158, 172, 197, 3, 244, 142, 70, 125, 58, 177, 4, 154, 18, 179, 81, 163, 236, 91, 34, 24, 153, 108, 46, 229, 207, 131, 32, 204, 144, 147, 134, 19, 89, 214, 15, 192, 196, 93, 111, 33, 114, 20, 256, 90, 124, 148, 44, 152, 198, 170, 120, 251, 26, 230, 117, 7, 141, 160, 249, 206, 221, 156, 95, 188, 42, 75, 189, 209, 208, 41, 165, 56, 100, 252, 193, 106, 226, 220, 246, 219, 79, 86, 227, 130, 122, 71, 35, 191, 29, 217, 2, 77, 9, 218, 169, 210, 118, 174, 17, 12, 205, 54, 23, 243, 232, 194, 16, 102, 72, 202, 67, 138, 173, 107, 136, 96, 98, 175, 184, 145, 57, 10, 128, 45, 62, 74, 22, 76, 99, 85, 60, 254, 13, 115, 187, 132, 199, 80, 253, 103, 239, 78, 176, 94, 21, 166, 223, 233, 104, 149, 211, 28, 50, 126, 225, 53, 113, 110, 123, 238, 168, 43, 242, 65, 61, 164, 146, 224, 143, 237, 1],
-[1, 168, 211, 239, 60, 57, 67, 205, 2, 79, 165, 221, 120, 114, 134, 153, 4, 158, 73, 185, 240, 228, 11, 49, 8, 59, 146, 113, 223, 199, 22, 98, 16, 118, 35, 226, 189, 141, 44, 196, 32, 236, 70, 195, 121, 25, 88, 135, 64, 215, 140, 133, 242, 50, 176, 13, 128, 173, 23, 9, 227, 100, 95, 26, 256, 89, 46, 18, 197, 200, 190, 52, 255, 178, 92, 36, 137, 143, 123, 104, 253, 99, 184, 72, 17, 29, 246, 208, 249, 198, 111, 144, 34, 58, 235, 159, 241, 139, 222, 31, 68, 116, 213, 61, 225, 21, 187, 62, 136, 232, 169, 122, 193, 42, 117, 124, 15, 207, 81, 244, 129, 84, 234, 248, 30, 157, 162, 231, 1, 168, 211, 239, 60, 57, 67, 205, 2, 79, 165, 221, 120, 114, 134, 153, 4, 158, 73, 185, 240, 228, 11, 49, 8, 59, 146, 113, 223, 199, 22, 98, 16, 118, 35, 226, 189, 141, 44, 196, 32, 236, 70, 195, 121, 25, 88, 135, 64, 215, 140, 133, 242, 50, 176, 13, 128, 173, 23, 9, 227, 100, 95, 26, 256, 89, 46, 18, 197, 200, 190, 52, 255, 178, 92, 36, 137, 143, 123, 104, 253, 99, 184, 72, 17, 29, 246, 208, 249, 198, 111, 144, 34, 58, 235, 159, 241, 139, 222, 31, 68, 116, 213, 61, 225, 21, 187, 62, 136, 232, 169, 122, 193, 42, 117, 124, 15, 207, 81, 244, 129, 84, 234, 248, 30, 157, 162, 231, 1],
-[1, 169, 34, 92, 128, 44, 240, 211, 193, 235, 137, 23, 32, 11, 60, 117, 241, 123, 227, 70, 8, 67, 15, 222, 253, 95, 121, 146, 2, 81, 68, 184, 256, 88, 223, 165, 129, 213, 17, 46, 64, 22, 120, 234, 225, 246, 197, 140, 16, 134, 30, 187, 249, 190, 242, 35, 4, 162, 136, 111, 255, 176, 189, 73, 1, 169, 34, 92, 128, 44, 240, 211, 193, 235, 137, 23, 32, 11, 60, 117, 241, 123, 227, 70, 8, 67, 15, 222, 253, 95, 121, 146, 2, 81, 68, 184, 256, 88, 223, 165, 129, 213, 17, 46, 64, 22, 120, 234, 225, 246, 197, 140, 16, 134, 30, 187, 249, 190, 242, 35, 4, 162, 136, 111, 255, 176, 189, 73, 1, 169, 34, 92, 128, 44, 240, 211, 193, 235, 137, 23, 32, 11, 60, 117, 241, 123, 227, 70, 8, 67, 15, 222, 253, 95, 121, 146, 2, 81, 68, 184, 256, 88, 223, 165, 129, 213, 17, 46, 64, 22, 120, 234, 225, 246, 197, 140, 16, 134, 30, 187, 249, 190, 242, 35, 4, 162, 136, 111, 255, 176, 189, 73, 1, 169, 34, 92, 128, 44, 240, 211, 193, 235, 137, 23, 32, 11, 60, 117, 241, 123, 227, 70, 8, 67, 15, 222, 253, 95, 121, 146, 2, 81, 68, 184, 256, 88, 223, 165, 129, 213, 17, 46, 64, 22, 120, 234, 225, 246, 197, 140, 16, 134, 30, 187, 249, 190, 242, 35, 4, 162, 136, 111, 255, 176, 189, 73, 1],
-[1, 170, 116, 188, 92, 220, 135, 77, 240, 194, 84, 145, 235, 115, 18, 233, 32, 43, 114, 105, 117, 101, 208, 151, 227, 40, 118, 14, 67, 82, 62, 3, 253, 91, 50, 19, 146, 148, 231, 206, 68, 252, 178, 191, 88, 54, 185, 96, 129, 85, 58, 94, 46, 110, 196, 167, 120, 97, 42, 201, 246, 186, 9, 245, 16, 150, 57, 181, 187, 179, 104, 204, 242, 20, 59, 7, 162, 41, 31, 130, 255, 174, 25, 138, 73, 74, 244, 103, 34, 126, 89, 224, 44, 27, 221, 48, 193, 171, 29, 47, 23, 55, 98, 212, 60, 177, 21, 229, 123, 93, 133, 251, 8, 75, 157, 219, 222, 218, 52, 102, 121, 10, 158, 132, 81, 149, 144, 65, 256, 87, 141, 69, 165, 37, 122, 180, 17, 63, 173, 112, 22, 142, 239, 24, 225, 214, 143, 152, 140, 156, 49, 106, 30, 217, 139, 243, 190, 175, 195, 254, 4, 166, 207, 238, 111, 109, 26, 51, 189, 5, 79, 66, 169, 203, 72, 161, 128, 172, 199, 163, 211, 147, 61, 90, 137, 160, 215, 56, 11, 71, 248, 12, 241, 107, 200, 76, 70, 78, 153, 53, 15, 237, 198, 250, 95, 216, 226, 127, 2, 83, 232, 119, 184, 183, 13, 154, 223, 131, 168, 33, 213, 230, 36, 209, 64, 86, 228, 210, 234, 202, 159, 45, 197, 80, 236, 28, 134, 164, 124, 6, 249, 182, 100, 38, 35, 39, 205, 155, 136, 247, 99, 125, 176, 108, 113, 192, 1],
-[1, 171, 200, 19, 165, 202, 104, 51, 240, 177, 198, 191, 22, 164, 31, 161, 32, 75, 232, 94, 140, 39, 244, 90, 227, 10, 168, 201, 190, 108, 221, 12, 253, 87, 228, 181, 111, 220, 98, 53, 68, 63, 236, 7, 169, 115, 133, 127, 129, 214, 100, 138, 211, 101, 52, 154, 120, 217, 99, 224, 11, 82, 144, 209, 16, 166, 116, 47, 70, 148, 122, 45, 242, 5, 84, 229, 95, 54, 239, 6, 255, 172, 114, 219, 184, 110, 49, 155, 34, 160, 118, 132, 213, 186, 195, 192, 193, 107, 50, 69, 234, 179, 26, 77, 60, 237, 178, 112, 134, 41, 72, 233, 8, 83, 58, 152, 35, 74, 61, 151, 121, 131, 42, 243, 176, 27, 248, 3, 256, 86, 57, 238, 92, 55, 153, 206, 17, 80, 59, 66, 235, 93, 226, 96, 225, 182, 25, 163, 117, 218, 13, 167, 30, 247, 89, 56, 67, 149, 36, 245, 4, 170, 29, 76, 146, 37, 159, 204, 189, 194, 21, 250, 88, 142, 124, 130, 128, 43, 157, 119, 46, 156, 205, 103, 137, 40, 158, 33, 246, 175, 113, 48, 241, 91, 141, 210, 187, 109, 135, 212, 15, 252, 173, 28, 162, 203, 18, 251, 2, 85, 143, 38, 73, 147, 208, 102, 223, 97, 139, 125, 44, 71, 62, 65, 64, 150, 207, 188, 23, 78, 231, 180, 197, 20, 79, 145, 123, 216, 185, 24, 249, 174, 199, 105, 222, 183, 196, 106, 136, 126, 215, 14, 81, 230, 9, 254, 1],
-[1, 172, 29, 105, 70, 218, 231, 154, 17, 97, 236, 243, 162, 108, 72, 48, 32, 107, 157, 19, 184, 37, 196, 45, 30, 20, 99, 66, 44, 115, 248, 251, 253, 83, 141, 94, 234, 156, 104, 155, 189, 126, 84, 56, 123, 82, 226, 65, 129, 86, 143, 181, 35, 109, 244, 77, 137, 177, 118, 250, 81, 54, 36, 24, 16, 182, 207, 138, 92, 147, 98, 151, 15, 10, 178, 33, 22, 186, 124, 254, 255, 170, 199, 47, 117, 78, 52, 206, 223, 63, 42, 28, 190, 41, 113, 161, 193, 43, 200, 219, 146, 183, 122, 167, 197, 217, 59, 125, 169, 27, 18, 12, 8, 91, 232, 69, 46, 202, 49, 204, 136, 5, 89, 145, 11, 93, 62, 127, 256, 85, 228, 152, 187, 39, 26, 103, 240, 160, 21, 14, 95, 149, 185, 209, 225, 150, 100, 238, 73, 220, 61, 212, 227, 237, 158, 191, 213, 142, 9, 6, 4, 174, 116, 163, 23, 101, 153, 102, 68, 131, 173, 201, 134, 175, 31, 192, 128, 171, 114, 76, 222, 148, 13, 180, 120, 80, 139, 7, 176, 203, 221, 233, 241, 75, 50, 119, 165, 110, 159, 106, 242, 247, 79, 224, 235, 71, 133, 3, 2, 87, 58, 210, 140, 179, 205, 51, 34, 194, 215, 229, 67, 216, 144, 96, 64, 214, 57, 38, 111, 74, 135, 90, 60, 40, 198, 132, 88, 230, 239, 245, 249, 166, 25, 188, 211, 55, 208, 53, 121, 252, 168, 112, 246, 164, 195, 130, 1],
-[1, 173, 117, 195, 68, 199, 246, 153, 255, 168, 23, 124, 121, 116, 22, 208, 4, 178, 211, 9, 15, 25, 213, 98, 249, 158, 92, 239, 227, 207, 88, 61, 16, 198, 73, 36, 60, 100, 81, 135, 225, 118, 111, 185, 137, 57, 95, 244, 64, 21, 35, 144, 240, 143, 67, 26, 129, 215, 187, 226, 34, 228, 123, 205, 256, 84, 140, 62, 189, 58, 11, 104, 2, 89, 234, 133, 136, 141, 235, 49, 253, 79, 46, 248, 242, 232, 44, 159, 8, 99, 165, 18, 30, 50, 169, 196, 241, 59, 184, 221, 197, 157, 176, 122, 32, 139, 146, 72, 120, 200, 162, 13, 193, 236, 222, 113, 17, 114, 190, 231, 128, 42, 70, 31, 223, 29, 134, 52, 1, 173, 117, 195, 68, 199, 246, 153, 255, 168, 23, 124, 121, 116, 22, 208, 4, 178, 211, 9, 15, 25, 213, 98, 249, 158, 92, 239, 227, 207, 88, 61, 16, 198, 73, 36, 60, 100, 81, 135, 225, 118, 111, 185, 137, 57, 95, 244, 64, 21, 35, 144, 240, 143, 67, 26, 129, 215, 187, 226, 34, 228, 123, 205, 256, 84, 140, 62, 189, 58, 11, 104, 2, 89, 234, 133, 136, 141, 235, 49, 253, 79, 46, 248, 242, 232, 44, 159, 8, 99, 165, 18, 30, 50, 169, 196, 241, 59, 184, 221, 197, 157, 176, 122, 32, 139, 146, 72, 120, 200, 162, 13, 193, 236, 222, 113, 17, 114, 190, 231, 128, 42, 70, 31, 223, 29, 134, 52, 1],
-[1, 174, 207, 38, 187, 156, 159, 167, 17, 131, 178, 132, 95, 82, 133, 12, 32, 171, 199, 188, 73, 109, 205, 204, 30, 80, 42, 112, 213, 54, 144, 127, 253, 75, 200, 105, 23, 147, 135, 103, 189, 247, 59, 243, 134, 186, 239, 209, 129, 87, 232, 19, 222, 78, 208, 212, 137, 194, 89, 66, 176, 41, 195, 6, 16, 214, 228, 94, 165, 183, 231, 102, 15, 40, 21, 56, 235, 27, 72, 192, 255, 166, 100, 181, 140, 202, 196, 180, 223, 252, 158, 250, 67, 93, 248, 233, 193, 172, 116, 138, 111, 39, 104, 106, 197, 97, 173, 33, 88, 149, 226, 3, 8, 107, 114, 47, 211, 220, 244, 51, 136, 20, 139, 28, 246, 142, 36, 96, 256, 83, 50, 219, 70, 101, 98, 90, 240, 126, 79, 125, 162, 175, 124, 245, 225, 86, 58, 69, 184, 148, 52, 53, 227, 177, 215, 145, 44, 203, 113, 130, 4, 182, 57, 152, 234, 110, 122, 154, 68, 10, 198, 14, 123, 71, 18, 48, 128, 170, 25, 238, 35, 179, 49, 45, 120, 63, 168, 191, 81, 216, 62, 251, 241, 43, 29, 163, 92, 74, 26, 155, 242, 217, 236, 201, 22, 230, 185, 65, 2, 91, 157, 76, 117, 55, 61, 77, 34, 5, 99, 7, 190, 164, 9, 24, 64, 85, 141, 119, 146, 218, 153, 151, 60, 160, 84, 224, 169, 108, 31, 254, 249, 150, 143, 210, 46, 37, 13, 206, 121, 237, 118, 229, 11, 115, 221, 161, 1],
-[1, 175, 42, 154, 222, 43, 72, 7, 197, 37, 50, 12, 44, 247, 49, 94, 2, 93, 84, 51, 187, 86, 144, 14, 137, 74, 100, 24, 88, 237, 98, 188, 4, 186, 168, 102, 117, 172, 31, 28, 17, 148, 200, 48, 176, 217, 196, 119, 8, 115, 79, 204, 234, 87, 62, 56, 34, 39, 143, 96, 95, 177, 135, 238, 16, 230, 158, 151, 211, 174, 124, 112, 68, 78, 29, 192, 190, 97, 13, 219, 32, 203, 59, 45, 165, 91, 248, 224, 136, 156, 58, 127, 123, 194, 26, 181, 64, 149, 118, 90, 73, 182, 239, 191, 15, 55, 116, 254, 246, 131, 52, 105, 128, 41, 236, 180, 146, 107, 221, 125, 30, 110, 232, 251, 235, 5, 104, 210, 256, 82, 215, 103, 35, 214, 185, 250, 60, 220, 207, 245, 213, 10, 208, 163, 255, 164, 173, 206, 70, 171, 113, 243, 120, 183, 157, 233, 169, 20, 159, 69, 253, 71, 89, 155, 140, 85, 226, 229, 240, 109, 57, 209, 81, 40, 61, 138, 249, 142, 178, 53, 23, 170, 195, 201, 223, 218, 114, 161, 162, 80, 122, 19, 241, 27, 99, 106, 46, 83, 133, 145, 189, 179, 228, 65, 67, 160, 244, 38, 225, 54, 198, 212, 92, 166, 9, 33, 121, 101, 199, 130, 134, 63, 231, 76, 193, 108, 139, 167, 184, 75, 18, 66, 242, 202, 141, 3, 11, 126, 205, 152, 129, 216, 21, 77, 111, 150, 36, 132, 227, 147, 25, 6, 22, 252, 153, 47, 1],
-[1, 176, 136, 35, 249, 134, 197, 234, 64, 213, 223, 184, 2, 95, 15, 70, 241, 11, 137, 211, 128, 169, 189, 111, 4, 190, 30, 140, 225, 22, 17, 165, 256, 81, 121, 222, 8, 123, 60, 23, 193, 44, 34, 73, 255, 162, 242, 187, 16, 246, 120, 46, 129, 88, 68, 146, 253, 67, 227, 117, 32, 235, 240, 92, 1, 176, 136, 35, 249, 134, 197, 234, 64, 213, 223, 184, 2, 95, 15, 70, 241, 11, 137, 211, 128, 169, 189, 111, 4, 190, 30, 140, 225, 22, 17, 165, 256, 81, 121, 222, 8, 123, 60, 23, 193, 44, 34, 73, 255, 162, 242, 187, 16, 246, 120, 46, 129, 88, 68, 146, 253, 67, 227, 117, 32, 235, 240, 92, 1, 176, 136, 35, 249, 134, 197, 234, 64, 213, 223, 184, 2, 95, 15, 70, 241, 11, 137, 211, 128, 169, 189, 111, 4, 190, 30, 140, 225, 22, 17, 165, 256, 81, 121, 222, 8, 123, 60, 23, 193, 44, 34, 73, 255, 162, 242, 187, 16, 246, 120, 46, 129, 88, 68, 146, 253, 67, 227, 117, 32, 235, 240, 92, 1, 176, 136, 35, 249, 134, 197, 234, 64, 213, 223, 184, 2, 95, 15, 70, 241, 11, 137, 211, 128, 169, 189, 111, 4, 190, 30, 140, 225, 22, 17, 165, 256, 81, 121, 222, 8, 123, 60, 23, 193, 44, 34, 73, 255, 162, 242, 187, 16, 246, 120, 46, 129, 88, 68, 146, 253, 67, 227, 117, 32, 235, 240, 92, 1],
-[1, 177, 232, 201, 111, 115, 52, 209, 242, 172, 118, 69, 134, 74, 248, 206, 225, 247, 29, 250, 46, 175, 135, 251, 223, 150, 79, 105, 81, 202, 31, 90, 253, 63, 100, 224, 70, 54, 49, 192, 60, 83, 42, 238, 235, 218, 36, 204, 128, 40, 141, 28, 73, 71, 231, 24, 136, 171, 198, 94, 190, 220, 133, 154, 16, 5, 114, 132, 234, 41, 61, 3, 17, 182, 89, 76, 88, 156, 113, 212, 2, 97, 207, 145, 222, 230, 104, 161, 227, 87, 236, 138, 11, 148, 239, 155, 193, 237, 58, 243, 92, 93, 13, 245, 189, 43, 158, 210, 162, 147, 62, 180, 249, 126, 200, 191, 140, 108, 98, 127, 120, 166, 84, 219, 213, 179, 72, 151, 256, 80, 25, 56, 146, 142, 205, 48, 15, 85, 139, 188, 123, 183, 9, 51, 32, 10, 228, 7, 211, 82, 122, 6, 34, 107, 178, 152, 176, 55, 226, 167, 4, 194, 157, 33, 187, 203, 208, 65, 197, 174, 215, 19, 22, 39, 221, 53, 129, 217, 116, 229, 184, 186, 26, 233, 121, 86, 59, 163, 67, 37, 124, 103, 241, 252, 143, 125, 23, 216, 196, 254, 240, 75, 168, 181, 169, 101, 144, 45, 255, 160, 50, 112, 35, 27, 153, 96, 30, 170, 21, 119, 246, 109, 18, 102, 64, 20, 199, 14, 165, 164, 244, 12, 68, 214, 99, 47, 95, 110, 195, 77, 8, 131, 57, 66, 117, 149, 159, 130, 137, 91, 173, 38, 44, 78, 185, 106, 1],
-[1, 178, 73, 144, 189, 232, 176, 231, 255, 158, 111, 226, 136, 50, 162, 52, 4, 198, 35, 62, 242, 157, 190, 153, 249, 118, 187, 133, 30, 200, 134, 208, 16, 21, 140, 248, 197, 114, 246, 98, 225, 215, 234, 18, 120, 29, 22, 61, 64, 84, 46, 221, 17, 199, 213, 135, 129, 89, 165, 72, 223, 116, 88, 244, 256, 79, 184, 113, 68, 25, 81, 26, 2, 99, 146, 31, 121, 207, 95, 205, 253, 59, 222, 195, 15, 100, 67, 104, 8, 139, 70, 124, 227, 57, 123, 49, 241, 236, 117, 9, 60, 143, 11, 159, 32, 42, 23, 239, 137, 228, 235, 196, 193, 173, 211, 36, 240, 58, 44, 122, 128, 168, 92, 185, 34, 141, 169, 13, 1, 178, 73, 144, 189, 232, 176, 231, 255, 158, 111, 226, 136, 50, 162, 52, 4, 198, 35, 62, 242, 157, 190, 153, 249, 118, 187, 133, 30, 200, 134, 208, 16, 21, 140, 248, 197, 114, 246, 98, 225, 215, 234, 18, 120, 29, 22, 61, 64, 84, 46, 221, 17, 199, 213, 135, 129, 89, 165, 72, 223, 116, 88, 244, 256, 79, 184, 113, 68, 25, 81, 26, 2, 99, 146, 31, 121, 207, 95, 205, 253, 59, 222, 195, 15, 100, 67, 104, 8, 139, 70, 124, 227, 57, 123, 49, 241, 236, 117, 9, 60, 143, 11, 159, 32, 42, 23, 239, 137, 228, 235, 196, 193, 173, 211, 36, 240, 58, 44, 122, 128, 168, 92, 185, 34, 141, 169, 13, 1],
-[1, 179, 173, 127, 117, 126, 195, 210, 68, 93, 199, 155, 246, 87, 153, 145, 255, 156, 168, 3, 23, 5, 124, 94, 121, 71, 116, 204, 22, 83, 208, 224, 4, 202, 178, 251, 211, 247, 9, 69, 15, 115, 25, 106, 213, 91, 98, 66, 249, 110, 158, 12, 92, 20, 239, 119, 227, 27, 207, 45, 88, 75, 61, 125, 16, 37, 198, 233, 73, 217, 36, 19, 60, 203, 100, 167, 81, 107, 135, 7, 225, 183, 118, 48, 111, 80, 185, 219, 137, 108, 57, 180, 95, 43, 244, 243, 64, 148, 21, 161, 35, 97, 144, 76, 240, 41, 143, 154, 67, 171, 26, 28, 129, 218, 215, 192, 187, 63, 226, 105, 34, 175, 228, 206, 123, 172, 205, 201, 256, 78, 84, 130, 140, 131, 62, 47, 189, 164, 58, 102, 11, 170, 104, 112, 2, 101, 89, 254, 234, 252, 133, 163, 136, 186, 141, 53, 235, 174, 49, 33, 253, 55, 79, 6, 46, 10, 248, 188, 242, 142, 232, 151, 44, 166, 159, 191, 8, 147, 99, 245, 165, 237, 18, 138, 30, 230, 50, 212, 169, 182, 196, 132, 241, 220, 59, 24, 184, 40, 221, 238, 197, 54, 157, 90, 176, 150, 122, 250, 32, 74, 139, 209, 146, 177, 72, 38, 120, 149, 200, 77, 162, 214, 13, 14, 193, 109, 236, 96, 222, 160, 113, 181, 17, 216, 114, 103, 190, 86, 231, 229, 128, 39, 42, 65, 70, 194, 31, 152, 223, 82, 29, 51, 134, 85, 52, 56, 1],
-[1, 180, 18, 156, 67, 238, 178, 172, 120, 12, 104, 216, 73, 33, 29, 80, 8, 155, 144, 220, 22, 105, 139, 91, 189, 96, 61, 186, 70, 7, 232, 126, 64, 212, 124, 218, 176, 69, 84, 214, 227, 254, 231, 203, 46, 56, 57, 237, 255, 154, 221, 202, 123, 38, 158, 170, 17, 233, 49, 82, 111, 191, 199, 97, 241, 204, 226, 74, 213, 47, 236, 75, 136, 65, 135, 142, 117, 243, 50, 5, 129, 90, 9, 78, 162, 119, 89, 86, 60, 6, 52, 108, 165, 145, 143, 40, 4, 206, 72, 110, 11, 181, 198, 174, 223, 48, 159, 93, 35, 132, 116, 63, 32, 106, 62, 109, 88, 163, 42, 107, 242, 127, 244, 230, 23, 28, 157, 247, 256, 77, 239, 101, 190, 19, 79, 85, 137, 245, 153, 41, 184, 224, 228, 177, 249, 102, 113, 37, 235, 152, 118, 166, 68, 161, 196, 71, 187, 250, 25, 131, 193, 45, 133, 39, 81, 188, 173, 43, 30, 3, 26, 54, 211, 201, 200, 20, 2, 103, 36, 55, 134, 219, 99, 87, 240, 24, 208, 175, 146, 66, 58, 160, 16, 53, 31, 183, 44, 210, 21, 182, 121, 192, 122, 115, 140, 14, 207, 252, 128, 167, 248, 179, 95, 138, 168, 171, 197, 251, 205, 149, 92, 112, 114, 217, 253, 51, 185, 147, 246, 76, 59, 83, 34, 209, 98, 164, 222, 125, 141, 194, 225, 151, 195, 148, 169, 94, 215, 150, 15, 130, 13, 27, 234, 229, 100, 10, 1],
-[1, 181, 122, 237, 235, 130, 143, 183, 227, 224, 195, 86, 146, 212, 79, 164, 129, 219, 61, 247, 246, 65, 200, 220, 242, 112, 226, 43, 73, 106, 168, 82, 193, 238, 159, 252, 123, 161, 100, 110, 121, 56, 113, 150, 165, 53, 84, 41, 225, 119, 208, 126, 190, 209, 50, 55, 189, 28, 185, 75, 211, 155, 42, 149, 241, 188, 104, 63, 95, 233, 25, 156, 223, 14, 221, 166, 234, 206, 21, 203, 249, 94, 52, 160, 176, 245, 141, 78, 240, 7, 239, 83, 117, 103, 139, 230, 253, 47, 26, 80, 88, 251, 199, 39, 120, 132, 248, 170, 187, 180, 198, 115, 255, 152, 13, 40, 44, 254, 228, 148, 60, 66, 124, 85, 222, 90, 99, 186, 256, 76, 135, 20, 22, 127, 114, 74, 30, 33, 62, 171, 111, 45, 178, 93, 128, 38, 196, 10, 11, 192, 57, 37, 15, 145, 31, 214, 184, 151, 89, 175, 64, 19, 98, 5, 134, 96, 157, 147, 136, 201, 144, 107, 92, 204, 173, 216, 32, 138, 49, 131, 67, 48, 207, 202, 68, 229, 72, 182, 46, 102, 215, 108, 16, 69, 153, 194, 162, 24, 232, 101, 34, 243, 36, 91, 23, 51, 236, 54, 8, 163, 205, 97, 81, 12, 116, 179, 17, 250, 18, 174, 140, 154, 118, 27, 4, 210, 231, 177, 169, 6, 58, 218, 137, 125, 9, 87, 70, 77, 59, 142, 2, 105, 244, 217, 213, 3, 29, 109, 197, 191, 133, 172, 35, 167, 158, 71, 1],
-[1, 182, 228, 119, 70, 147, 26, 106, 17, 10, 21, 224, 162, 186, 185, 3, 32, 170, 100, 210, 184, 78, 61, 51, 30, 63, 158, 229, 44, 41, 9, 96, 253, 43, 116, 38, 234, 183, 153, 90, 189, 217, 173, 132, 123, 27, 31, 245, 129, 91, 114, 188, 35, 202, 13, 53, 137, 5, 139, 112, 81, 93, 221, 130, 16, 85, 50, 105, 92, 39, 159, 154, 15, 160, 79, 243, 22, 149, 133, 48, 255, 150, 58, 19, 117, 220, 205, 45, 223, 237, 215, 66, 190, 142, 144, 251, 193, 174, 57, 94, 146, 101, 135, 155, 197, 131, 198, 56, 169, 175, 239, 65, 8, 171, 25, 181, 46, 148, 208, 77, 136, 80, 168, 250, 11, 203, 195, 24, 256, 75, 29, 138, 187, 110, 231, 151, 240, 247, 236, 33, 95, 71, 72, 254, 225, 87, 157, 47, 73, 179, 196, 206, 227, 194, 99, 28, 213, 216, 248, 161, 4, 214, 141, 219, 23, 74, 104, 167, 68, 40, 84, 125, 134, 230, 226, 12, 128, 166, 143, 69, 222, 55, 244, 204, 120, 252, 118, 145, 176, 164, 36, 127, 241, 172, 207, 152, 165, 218, 98, 103, 242, 97, 178, 14, 235, 108, 124, 209, 2, 107, 199, 238, 140, 37, 52, 212, 34, 20, 42, 191, 67, 115, 113, 6, 64, 83, 200, 163, 111, 156, 122, 102, 60, 126, 59, 201, 88, 82, 18, 192, 249, 86, 232, 76, 211, 109, 49, 180, 121, 177, 89, 7, 246, 54, 62, 233, 1],
-[1, 183, 79, 65, 73, 252, 113, 119, 189, 149, 25, 206, 176, 83, 26, 132, 255, 148, 99, 127, 111, 10, 31, 19, 136, 216, 207, 102, 162, 91, 205, 250, 4, 218, 59, 3, 35, 237, 195, 219, 242, 82, 100, 53, 190, 75, 104, 14, 249, 78, 139, 251, 187, 40, 124, 76, 30, 93, 57, 151, 134, 107, 49, 229, 16, 101, 236, 12, 140, 177, 9, 105, 197, 71, 143, 212, 246, 43, 159, 56, 225, 55, 42, 233, 234, 160, 239, 47, 120, 115, 228, 90, 22, 171, 196, 145, 64, 147, 173, 48, 46, 194, 36, 163, 17, 27, 58, 77, 213, 172, 122, 224, 129, 220, 168, 161, 165, 126, 185, 188, 223, 203, 141, 103, 88, 170, 13, 66, 256, 74, 178, 192, 184, 5, 144, 138, 68, 108, 232, 51, 81, 174, 231, 125, 2, 109, 158, 130, 146, 247, 226, 238, 121, 41, 50, 155, 95, 166, 52, 7, 253, 39, 198, 254, 222, 20, 62, 38, 15, 175, 157, 204, 67, 182, 153, 243, 8, 179, 118, 6, 70, 217, 133, 181, 227, 164, 200, 106, 123, 150, 208, 28, 241, 156, 21, 245, 117, 80, 248, 152, 60, 186, 114, 45, 11, 214, 98, 201, 32, 202, 215, 24, 23, 97, 18, 210, 137, 142, 29, 167, 235, 86, 61, 112, 193, 110, 84, 209, 211, 63, 221, 94, 240, 230, 199, 180, 44, 85, 135, 33, 128, 37, 89, 96, 92, 131, 72, 69, 34, 54, 116, 154, 169, 87, 244, 191, 1],
-[1, 184, 189, 81, 255, 146, 136, 95, 4, 222, 242, 67, 249, 70, 30, 123, 16, 117, 197, 11, 225, 23, 120, 235, 64, 211, 17, 44, 129, 92, 223, 169, 256, 73, 68, 176, 2, 111, 121, 162, 253, 35, 15, 190, 8, 187, 227, 134, 241, 140, 60, 246, 32, 234, 137, 22, 193, 46, 240, 213, 128, 165, 34, 88, 1, 184, 189, 81, 255, 146, 136, 95, 4, 222, 242, 67, 249, 70, 30, 123, 16, 117, 197, 11, 225, 23, 120, 235, 64, 211, 17, 44, 129, 92, 223, 169, 256, 73, 68, 176, 2, 111, 121, 162, 253, 35, 15, 190, 8, 187, 227, 134, 241, 140, 60, 246, 32, 234, 137, 22, 193, 46, 240, 213, 128, 165, 34, 88, 1, 184, 189, 81, 255, 146, 136, 95, 4, 222, 242, 67, 249, 70, 30, 123, 16, 117, 197, 11, 225, 23, 120, 235, 64, 211, 17, 44, 129, 92, 223, 169, 256, 73, 68, 176, 2, 111, 121, 162, 253, 35, 15, 190, 8, 187, 227, 134, 241, 140, 60, 246, 32, 234, 137, 22, 193, 46, 240, 213, 128, 165, 34, 88, 1, 184, 189, 81, 255, 146, 136, 95, 4, 222, 242, 67, 249, 70, 30, 123, 16, 117, 197, 11, 225, 23, 120, 235, 64, 211, 17, 44, 129, 92, 223, 169, 256, 73, 68, 176, 2, 111, 121, 162, 253, 35, 15, 190, 8, 187, 227, 134, 241, 140, 60, 246, 32, 234, 137, 22, 193, 46, 240, 213, 128, 165, 34, 88, 1],
-[1, 185, 44, 173, 137, 159, 117, 57, 8, 195, 95, 99, 68, 244, 165, 199, 64, 18, 246, 21, 30, 153, 35, 50, 255, 144, 169, 168, 240, 196, 23, 143, 241, 124, 67, 59, 121, 26, 184, 116, 129, 221, 22, 215, 197, 208, 187, 157, 4, 226, 176, 178, 34, 122, 211, 228, 32, 9, 123, 139, 15, 205, 146, 25, 256, 72, 213, 84, 120, 98, 140, 200, 249, 62, 162, 158, 189, 13, 92, 58, 193, 239, 11, 236, 227, 104, 222, 207, 2, 113, 88, 89, 17, 61, 234, 114, 16, 133, 190, 198, 136, 231, 73, 141, 128, 36, 235, 42, 60, 49, 70, 100, 253, 31, 81, 79, 223, 135, 46, 29, 225, 248, 134, 118, 242, 52, 111, 232, 1, 185, 44, 173, 137, 159, 117, 57, 8, 195, 95, 99, 68, 244, 165, 199, 64, 18, 246, 21, 30, 153, 35, 50, 255, 144, 169, 168, 240, 196, 23, 143, 241, 124, 67, 59, 121, 26, 184, 116, 129, 221, 22, 215, 197, 208, 187, 157, 4, 226, 176, 178, 34, 122, 211, 228, 32, 9, 123, 139, 15, 205, 146, 25, 256, 72, 213, 84, 120, 98, 140, 200, 249, 62, 162, 158, 189, 13, 92, 58, 193, 239, 11, 236, 227, 104, 222, 207, 2, 113, 88, 89, 17, 61, 234, 114, 16, 133, 190, 198, 136, 231, 73, 141, 128, 36, 235, 42, 60, 49, 70, 100, 253, 31, 81, 79, 223, 135, 46, 29, 225, 248, 134, 118, 242, 52, 111, 232, 1],
-[1, 186, 158, 90, 35, 85, 133, 66, 197, 148, 29, 254, 213, 40, 244, 152, 2, 115, 59, 180, 70, 170, 9, 132, 137, 39, 58, 251, 169, 80, 231, 47, 4, 230, 118, 103, 140, 83, 18, 7, 17, 78, 116, 245, 81, 160, 205, 94, 8, 203, 236, 206, 23, 166, 36, 14, 34, 156, 232, 233, 162, 63, 153, 188, 16, 149, 215, 155, 46, 75, 72, 28, 68, 55, 207, 209, 67, 126, 49, 119, 32, 41, 173, 53, 92, 150, 144, 56, 136, 110, 157, 161, 134, 252, 98, 238, 64, 82, 89, 106, 184, 43, 31, 112, 15, 220, 57, 65, 11, 247, 196, 219, 128, 164, 178, 212, 111, 86, 62, 224, 30, 183, 114, 130, 22, 237, 135, 181, 256, 71, 99, 167, 222, 172, 124, 191, 60, 109, 228, 3, 44, 217, 13, 105, 255, 142, 198, 77, 187, 87, 248, 125, 120, 218, 199, 6, 88, 177, 26, 210, 253, 27, 139, 154, 117, 174, 239, 250, 240, 179, 141, 12, 176, 97, 52, 163, 249, 54, 21, 51, 234, 91, 221, 243, 223, 101, 25, 24, 95, 194, 104, 69, 241, 108, 42, 102, 211, 182, 185, 229, 189, 202, 50, 48, 190, 131, 208, 138, 225, 216, 84, 204, 165, 107, 113, 201, 121, 147, 100, 96, 123, 5, 159, 19, 193, 175, 168, 151, 73, 214, 226, 145, 242, 37, 200, 192, 246, 10, 61, 38, 129, 93, 79, 45, 146, 171, 195, 33, 227, 74, 143, 127, 235, 20, 122, 76, 1],
-[1, 187, 17, 95, 32, 73, 30, 213, 253, 23, 189, 134, 129, 222, 137, 176, 16, 165, 15, 235, 255, 140, 223, 67, 193, 111, 197, 88, 8, 211, 136, 246, 256, 70, 240, 162, 225, 184, 227, 44, 4, 234, 68, 123, 128, 35, 120, 81, 241, 92, 242, 22, 2, 117, 34, 190, 64, 146, 60, 169, 249, 46, 121, 11, 1, 187, 17, 95, 32, 73, 30, 213, 253, 23, 189, 134, 129, 222, 137, 176, 16, 165, 15, 235, 255, 140, 223, 67, 193, 111, 197, 88, 8, 211, 136, 246, 256, 70, 240, 162, 225, 184, 227, 44, 4, 234, 68, 123, 128, 35, 120, 81, 241, 92, 242, 22, 2, 117, 34, 190, 64, 146, 60, 169, 249, 46, 121, 11, 1, 187, 17, 95, 32, 73, 30, 213, 253, 23, 189, 134, 129, 222, 137, 176, 16, 165, 15, 235, 255, 140, 223, 67, 193, 111, 197, 88, 8, 211, 136, 246, 256, 70, 240, 162, 225, 184, 227, 44, 4, 234, 68, 123, 128, 35, 120, 81, 241, 92, 242, 22, 2, 117, 34, 190, 64, 146, 60, 169, 249, 46, 121, 11, 1, 187, 17, 95, 32, 73, 30, 213, 253, 23, 189, 134, 129, 222, 137, 176, 16, 165, 15, 235, 255, 140, 223, 67, 193, 111, 197, 88, 8, 211, 136, 246, 256, 70, 240, 162, 225, 184, 227, 44, 4, 234, 68, 123, 128, 35, 120, 81, 241, 92, 242, 22, 2, 117, 34, 190, 64, 146, 60, 169, 249, 46, 121, 11, 1],
-[1, 188, 135, 194, 235, 233, 114, 101, 227, 14, 62, 91, 146, 206, 178, 54, 129, 94, 196, 97, 246, 245, 57, 179, 242, 7, 31, 174, 73, 103, 89, 27, 193, 47, 98, 177, 123, 251, 157, 218, 121, 132, 144, 87, 165, 180, 173, 142, 225, 152, 49, 217, 190, 254, 207, 109, 189, 66, 72, 172, 211, 90, 215, 71, 241, 76, 153, 237, 95, 127, 232, 183, 223, 33, 36, 86, 234, 45, 236, 164, 249, 38, 205, 247, 176, 192, 116, 220, 240, 145, 18, 43, 117, 151, 118, 82, 253, 19, 231, 252, 88, 96, 58, 110, 120, 201, 9, 150, 187, 204, 59, 41, 255, 138, 244, 126, 44, 48, 29, 55, 60, 229, 133, 75, 222, 102, 158, 149, 256, 69, 122, 63, 22, 24, 143, 156, 30, 243, 195, 166, 111, 51, 79, 203, 128, 163, 61, 160, 11, 12, 200, 78, 15, 250, 226, 83, 184, 154, 168, 230, 64, 210, 159, 80, 134, 6, 100, 39, 136, 125, 113, 170, 92, 77, 84, 115, 32, 105, 208, 40, 67, 3, 50, 148, 68, 191, 185, 85, 46, 167, 42, 186, 16, 181, 104, 20, 162, 130, 25, 74, 34, 224, 221, 171, 23, 212, 21, 93, 8, 219, 52, 10, 81, 65, 141, 37, 17, 112, 239, 214, 140, 106, 139, 175, 4, 238, 26, 5, 169, 161, 199, 147, 137, 56, 248, 107, 70, 53, 198, 216, 2, 119, 13, 131, 213, 209, 228, 202, 197, 28, 124, 182, 35, 155, 99, 108, 1],
-[1, 189, 255, 136, 4, 242, 249, 30, 16, 197, 225, 120, 64, 17, 129, 223, 256, 68, 2, 121, 253, 15, 8, 227, 241, 60, 32, 137, 193, 240, 128, 34, 1, 189, 255, 136, 4, 242, 249, 30, 16, 197, 225, 120, 64, 17, 129, 223, 256, 68, 2, 121, 253, 15, 8, 227, 241, 60, 32, 137, 193, 240, 128, 34, 1, 189, 255, 136, 4, 242, 249, 30, 16, 197, 225, 120, 64, 17, 129, 223, 256, 68, 2, 121, 253, 15, 8, 227, 241, 60, 32, 137, 193, 240, 128, 34, 1, 189, 255, 136, 4, 242, 249, 30, 16, 197, 225, 120, 64, 17, 129, 223, 256, 68, 2, 121, 253, 15, 8, 227, 241, 60, 32, 137, 193, 240, 128, 34, 1, 189, 255, 136, 4, 242, 249, 30, 16, 197, 225, 120, 64, 17, 129, 223, 256, 68, 2, 121, 253, 15, 8, 227, 241, 60, 32, 137, 193, 240, 128, 34, 1, 189, 255, 136, 4, 242, 249, 30, 16, 197, 225, 120, 64, 17, 129, 223, 256, 68, 2, 121, 253, 15, 8, 227, 241, 60, 32, 137, 193, 240, 128, 34, 1, 189, 255, 136, 4, 242, 249, 30, 16, 197, 225, 120, 64, 17, 129, 223, 256, 68, 2, 121, 253, 15, 8, 227, 241, 60, 32, 137, 193, 240, 128, 34, 1, 189, 255, 136, 4, 242, 249, 30, 16, 197, 225, 120, 64, 17, 129, 223, 256, 68, 2, 121, 253, 15, 8, 227, 241, 60, 32, 137, 193, 240, 128, 34, 1],
-[1, 190, 120, 184, 8, 235, 189, 187, 64, 81, 227, 211, 255, 134, 17, 146, 241, 44, 136, 140, 129, 95, 60, 92, 4, 246, 223, 222, 32, 169, 242, 234, 256, 67, 137, 73, 249, 22, 68, 70, 193, 176, 30, 46, 2, 123, 240, 111, 16, 213, 121, 117, 128, 162, 197, 165, 253, 11, 34, 35, 225, 88, 15, 23, 1, 190, 120, 184, 8, 235, 189, 187, 64, 81, 227, 211, 255, 134, 17, 146, 241, 44, 136, 140, 129, 95, 60, 92, 4, 246, 223, 222, 32, 169, 242, 234, 256, 67, 137, 73, 249, 22, 68, 70, 193, 176, 30, 46, 2, 123, 240, 111, 16, 213, 121, 117, 128, 162, 197, 165, 253, 11, 34, 35, 225, 88, 15, 23, 1, 190, 120, 184, 8, 235, 189, 187, 64, 81, 227, 211, 255, 134, 17, 146, 241, 44, 136, 140, 129, 95, 60, 92, 4, 246, 223, 222, 32, 169, 242, 234, 256, 67, 137, 73, 249, 22, 68, 70, 193, 176, 30, 46, 2, 123, 240, 111, 16, 213, 121, 117, 128, 162, 197, 165, 253, 11, 34, 35, 225, 88, 15, 23, 1, 190, 120, 184, 8, 235, 189, 187, 64, 81, 227, 211, 255, 134, 17, 146, 241, 44, 136, 140, 129, 95, 60, 92, 4, 246, 223, 222, 32, 169, 242, 234, 256, 67, 137, 73, 249, 22, 68, 70, 193, 176, 30, 46, 2, 123, 240, 111, 16, 213, 121, 117, 128, 162, 197, 165, 253, 11, 34, 35, 225, 88, 15, 23, 1],
-[1, 191, 244, 87, 169, 154, 116, 54, 34, 69, 72, 131, 92, 96, 89, 37, 128, 33, 135, 85, 44, 180, 199, 230, 240, 94, 221, 63, 211, 209, 84, 110, 193, 112, 61, 86, 235, 167, 29, 142, 137, 210, 18, 97, 23, 24, 215, 202, 32, 201, 98, 214, 11, 45, 114, 186, 60, 152, 248, 80, 117, 245, 21, 156, 241, 28, 208, 150, 123, 106, 200, 164, 227, 181, 133, 217, 70, 6, 118, 179, 8, 243, 153, 182, 67, 204, 157, 175, 15, 38, 62, 20, 222, 254, 198, 39, 253, 7, 52, 166, 95, 155, 50, 41, 121, 238, 226, 247, 146, 130, 158, 109, 2, 125, 231, 174, 81, 51, 232, 108, 68, 138, 144, 5, 184, 192, 178, 74, 256, 66, 13, 170, 88, 103, 141, 203, 223, 188, 185, 126, 165, 161, 168, 220, 129, 224, 122, 172, 213, 77, 58, 27, 17, 163, 36, 194, 46, 48, 173, 147, 64, 145, 196, 171, 22, 90, 228, 115, 120, 47, 239, 160, 234, 233, 42, 55, 225, 56, 159, 43, 246, 212, 143, 71, 197, 105, 9, 177, 140, 12, 236, 101, 16, 229, 49, 107, 134, 151, 57, 93, 30, 76, 124, 40, 187, 251, 139, 78, 249, 14, 104, 75, 190, 53, 100, 82, 242, 219, 195, 237, 35, 3, 59, 218, 4, 250, 205, 91, 162, 102, 207, 216, 136, 19, 31, 10, 111, 127, 99, 148, 255, 132, 26, 83, 176, 206, 25, 149, 189, 119, 113, 252, 73, 65, 79, 183, 1],
-[1, 192, 113, 108, 176, 125, 99, 247, 136, 155, 205, 39, 35, 38, 100, 182, 249, 6, 124, 164, 134, 28, 236, 80, 197, 45, 159, 202, 234, 210, 228, 86, 64, 209, 36, 230, 213, 33, 168, 131, 223, 154, 13, 183, 184, 119, 232, 83, 2, 127, 226, 216, 95, 250, 198, 237, 15, 53, 153, 78, 70, 76, 200, 107, 241, 12, 248, 71, 11, 56, 215, 160, 137, 90, 61, 147, 211, 163, 199, 172, 128, 161, 72, 203, 169, 66, 79, 5, 189, 51, 26, 109, 111, 238, 207, 166, 4, 254, 195, 175, 190, 243, 139, 217, 30, 106, 49, 156, 140, 152, 143, 214, 225, 24, 239, 142, 22, 112, 173, 63, 17, 180, 122, 37, 165, 69, 141, 87, 256, 65, 144, 149, 81, 132, 158, 10, 121, 102, 52, 218, 222, 219, 157, 75, 8, 251, 133, 93, 123, 229, 21, 177, 60, 212, 98, 55, 23, 47, 29, 171, 193, 48, 221, 27, 44, 224, 89, 126, 34, 103, 244, 74, 73, 138, 25, 174, 255, 130, 31, 41, 162, 7, 59, 20, 242, 204, 104, 179, 187, 181, 57, 150, 16, 245, 9, 186, 246, 201, 42, 97, 120, 167, 196, 110, 46, 94, 58, 85, 129, 96, 185, 54, 88, 191, 178, 252, 68, 206, 231, 148, 146, 19, 50, 91, 253, 3, 62, 82, 67, 14, 118, 40, 227, 151, 208, 101, 117, 105, 114, 43, 32, 233, 18, 115, 235, 145, 84, 194, 240, 77, 135, 220, 92, 188, 116, 170, 1],
-[1, 193, 241, 253, 256, 64, 16, 4, 1, 193, 241, 253, 256, 64, 16, 4, 1, 193, 241, 253, 256, 64, 16, 4, 1, 193, 241, 253, 256, 64, 16, 4, 1, 193, 241, 253, 256, 64, 16, 4, 1, 193, 241, 253, 256, 64, 16, 4, 1, 193, 241, 253, 256, 64, 16, 4, 1, 193, 241, 253, 256, 64, 16, 4, 1, 193, 241, 253, 256, 64, 16, 4, 1, 193, 241, 253, 256, 64, 16, 4, 1, 193, 241, 253, 256, 64, 16, 4, 1, 193, 241, 253, 256, 64, 16, 4, 1, 193, 241, 253, 256, 64, 16, 4, 1, 193, 241, 253, 256, 64, 16, 4, 1, 193, 241, 253, 256, 64, 16, 4, 1, 193, 241, 253, 256, 64, 16, 4, 1, 193, 241, 253, 256, 64, 16, 4, 1, 193, 241, 253, 256, 64, 16, 4, 1, 193, 241, 253, 256, 64, 16, 4, 1, 193, 241, 253, 256, 64, 16, 4, 1, 193, 241, 253, 256, 64, 16, 4, 1, 193, 241, 253, 256, 64, 16, 4, 1, 193, 241, 253, 256, 64, 16, 4, 1, 193, 241, 253, 256, 64, 16, 4, 1, 193, 241, 253, 256, 64, 16, 4, 1, 193, 241, 253, 256, 64, 16, 4, 1, 193, 241, 253, 256, 64, 16, 4, 1, 193, 241, 253, 256, 64, 16, 4, 1, 193, 241, 253, 256, 64, 16, 4, 1, 193, 241, 253, 256, 64, 16, 4, 1, 193, 241, 253, 256, 64, 16, 4, 1, 193, 241, 253, 256, 64, 16, 4, 1],
-[1, 194, 114, 14, 146, 54, 196, 245, 242, 174, 89, 47, 123, 218, 144, 180, 225, 217, 207, 66, 211, 71, 153, 127, 223, 86, 236, 38, 176, 220, 18, 151, 253, 252, 58, 201, 187, 41, 244, 48, 60, 75, 158, 69, 22, 156, 195, 51, 128, 160, 200, 250, 184, 230, 159, 6, 136, 170, 84, 105, 67, 148, 185, 167, 16, 20, 25, 224, 23, 93, 52, 65, 17, 214, 139, 238, 169, 147, 248, 53, 2, 131, 228, 28, 35, 108, 135, 233, 227, 91, 178, 94, 246, 179, 31, 103, 193, 177, 157, 132, 165, 142, 49, 254, 189, 172, 215, 76, 95, 183, 36, 45, 249, 247, 116, 145, 117, 82, 231, 96, 120, 150, 59, 138, 44, 55, 133, 102, 256, 63, 143, 243, 111, 203, 61, 12, 15, 83, 168, 210, 134, 39, 113, 77, 32, 40, 50, 191, 46, 186, 104, 130, 34, 171, 21, 219, 81, 37, 239, 106, 4, 5, 199, 56, 70, 216, 13, 209, 197, 182, 99, 188, 235, 101, 62, 206, 129, 97, 57, 7, 73, 27, 98, 251, 121, 87, 173, 152, 190, 109, 72, 90, 241, 237, 232, 33, 234, 164, 205, 192, 240, 43, 118, 19, 88, 110, 9, 204, 255, 126, 29, 229, 222, 149, 122, 24, 30, 166, 79, 163, 11, 78, 226, 154, 64, 80, 100, 125, 92, 115, 208, 3, 68, 85, 42, 181, 162, 74, 221, 212, 8, 10, 141, 112, 140, 175, 26, 161, 137, 107, 198, 119, 213, 202, 124, 155, 1],
-[1, 195, 246, 168, 121, 208, 211, 25, 249, 239, 88, 198, 60, 135, 111, 57, 64, 144, 67, 215, 34, 205, 140, 58, 2, 133, 235, 79, 242, 159, 165, 50, 241, 221, 176, 139, 120, 13, 222, 114, 128, 31, 134, 173, 68, 153, 23, 116, 4, 9, 213, 158, 227, 61, 73, 100, 225, 185, 95, 21, 240, 26, 187, 228, 256, 62, 11, 89, 136, 49, 46, 232, 8, 18, 169, 59, 197, 122, 146, 200, 193, 113, 190, 42, 223, 52, 117, 199, 255, 124, 22, 178, 15, 98, 92, 207, 16, 36, 81, 118, 137, 244, 35, 143, 129, 226, 123, 84, 189, 104, 234, 141, 253, 248, 44, 99, 30, 196, 184, 157, 32, 72, 162, 236, 17, 231, 70, 29, 1, 195, 246, 168, 121, 208, 211, 25, 249, 239, 88, 198, 60, 135, 111, 57, 64, 144, 67, 215, 34, 205, 140, 58, 2, 133, 235, 79, 242, 159, 165, 50, 241, 221, 176, 139, 120, 13, 222, 114, 128, 31, 134, 173, 68, 153, 23, 116, 4, 9, 213, 158, 227, 61, 73, 100, 225, 185, 95, 21, 240, 26, 187, 228, 256, 62, 11, 89, 136, 49, 46, 232, 8, 18, 169, 59, 197, 122, 146, 200, 193, 113, 190, 42, 223, 52, 117, 199, 255, 124, 22, 178, 15, 98, 92, 207, 16, 36, 81, 118, 137, 244, 35, 143, 129, 226, 123, 84, 189, 104, 234, 141, 253, 248, 44, 99, 30, 196, 184, 157, 32, 72, 162, 236, 17, 231, 70, 29, 1],
-[1, 196, 123, 207, 223, 18, 187, 158, 128, 159, 67, 25, 17, 248, 35, 178, 193, 49, 95, 116, 120, 133, 111, 168, 32, 104, 81, 199, 197, 62, 73, 173, 241, 205, 88, 29, 30, 226, 92, 42, 8, 26, 213, 114, 242, 144, 211, 236, 253, 244, 22, 200, 136, 185, 23, 139, 2, 135, 246, 157, 189, 36, 117, 59, 256, 61, 134, 50, 34, 239, 70, 99, 129, 98, 190, 232, 240, 9, 222, 79, 64, 208, 162, 141, 137, 124, 146, 89, 225, 153, 176, 58, 60, 195, 184, 84, 16, 52, 169, 228, 227, 31, 165, 215, 249, 231, 44, 143, 15, 113, 46, 21, 4, 13, 235, 57, 121, 72, 234, 118, 255, 122, 11, 100, 68, 221, 140, 198, 1, 196, 123, 207, 223, 18, 187, 158, 128, 159, 67, 25, 17, 248, 35, 178, 193, 49, 95, 116, 120, 133, 111, 168, 32, 104, 81, 199, 197, 62, 73, 173, 241, 205, 88, 29, 30, 226, 92, 42, 8, 26, 213, 114, 242, 144, 211, 236, 253, 244, 22, 200, 136, 185, 23, 139, 2, 135, 246, 157, 189, 36, 117, 59, 256, 61, 134, 50, 34, 239, 70, 99, 129, 98, 190, 232, 240, 9, 222, 79, 64, 208, 162, 141, 137, 124, 146, 89, 225, 153, 176, 58, 60, 195, 184, 84, 16, 52, 169, 228, 227, 31, 165, 215, 249, 231, 44, 143, 15, 113, 46, 21, 4, 13, 235, 57, 121, 72, 234, 118, 255, 122, 11, 100, 68, 221, 140, 198, 1],
-[1, 197, 2, 137, 4, 17, 8, 34, 16, 68, 32, 136, 64, 15, 128, 30, 256, 60, 255, 120, 253, 240, 249, 223, 241, 189, 225, 121, 193, 242, 129, 227, 1, 197, 2, 137, 4, 17, 8, 34, 16, 68, 32, 136, 64, 15, 128, 30, 256, 60, 255, 120, 253, 240, 249, 223, 241, 189, 225, 121, 193, 242, 129, 227, 1, 197, 2, 137, 4, 17, 8, 34, 16, 68, 32, 136, 64, 15, 128, 30, 256, 60, 255, 120, 253, 240, 249, 223, 241, 189, 225, 121, 193, 242, 129, 227, 1, 197, 2, 137, 4, 17, 8, 34, 16, 68, 32, 136, 64, 15, 128, 30, 256, 60, 255, 120, 253, 240, 249, 223, 241, 189, 225, 121, 193, 242, 129, 227, 1, 197, 2, 137, 4, 17, 8, 34, 16, 68, 32, 136, 64, 15, 128, 30, 256, 60, 255, 120, 253, 240, 249, 223, 241, 189, 225, 121, 193, 242, 129, 227, 1, 197, 2, 137, 4, 17, 8, 34, 16, 68, 32, 136, 64, 15, 128, 30, 256, 60, 255, 120, 253, 240, 249, 223, 241, 189, 225, 121, 193, 242, 129, 227, 1, 197, 2, 137, 4, 17, 8, 34, 16, 68, 32, 136, 64, 15, 128, 30, 256, 60, 255, 120, 253, 240, 249, 223, 241, 189, 225, 121, 193, 242, 129, 227, 1, 197, 2, 137, 4, 17, 8, 34, 16, 68, 32, 136, 64, 15, 128, 30, 256, 60, 255, 120, 253, 240, 249, 223, 241, 189, 225, 121, 193, 242, 129, 227, 1],
-[1, 198, 140, 221, 68, 100, 11, 122, 255, 118, 234, 72, 121, 57, 235, 13, 4, 21, 46, 113, 15, 143, 44, 231, 249, 215, 165, 31, 227, 228, 169, 52, 16, 84, 184, 195, 60, 58, 176, 153, 225, 89, 146, 124, 137, 141, 162, 208, 64, 79, 222, 9, 240, 232, 190, 98, 129, 99, 70, 239, 34, 50, 134, 61, 256, 59, 117, 36, 189, 157, 246, 135, 2, 139, 23, 185, 136, 200, 22, 244, 253, 236, 211, 144, 242, 114, 213, 26, 8, 42, 92, 226, 30, 29, 88, 205, 241, 173, 73, 62, 197, 199, 81, 104, 32, 168, 111, 133, 120, 116, 95, 49, 193, 178, 35, 248, 17, 25, 67, 159, 128, 158, 187, 18, 223, 207, 123, 196, 1, 198, 140, 221, 68, 100, 11, 122, 255, 118, 234, 72, 121, 57, 235, 13, 4, 21, 46, 113, 15, 143, 44, 231, 249, 215, 165, 31, 227, 228, 169, 52, 16, 84, 184, 195, 60, 58, 176, 153, 225, 89, 146, 124, 137, 141, 162, 208, 64, 79, 222, 9, 240, 232, 190, 98, 129, 99, 70, 239, 34, 50, 134, 61, 256, 59, 117, 36, 189, 157, 246, 135, 2, 139, 23, 185, 136, 200, 22, 244, 253, 236, 211, 144, 242, 114, 213, 26, 8, 42, 92, 226, 30, 29, 88, 205, 241, 173, 73, 62, 197, 199, 81, 104, 32, 168, 111, 133, 120, 116, 95, 49, 193, 178, 35, 248, 17, 25, 67, 159, 128, 158, 187, 18, 223, 207, 123, 196, 1],
-[1, 199, 23, 208, 15, 158, 88, 36, 225, 57, 35, 26, 34, 84, 11, 133, 253, 232, 165, 196, 197, 139, 162, 113, 128, 29, 117, 153, 121, 178, 213, 239, 16, 100, 111, 244, 240, 215, 123, 62, 2, 141, 46, 159, 30, 59, 176, 72, 193, 114, 70, 52, 68, 168, 22, 9, 249, 207, 73, 135, 137, 21, 67, 226, 256, 58, 234, 49, 242, 99, 169, 221, 32, 200, 222, 231, 223, 173, 246, 124, 4, 25, 92, 61, 60, 118, 95, 144, 129, 228, 140, 104, 136, 79, 44, 18, 241, 157, 146, 13, 17, 42, 134, 195, 255, 116, 211, 98, 227, 198, 81, 185, 64, 143, 187, 205, 189, 89, 235, 248, 8, 50, 184, 122, 120, 236, 190, 31, 1, 199, 23, 208, 15, 158, 88, 36, 225, 57, 35, 26, 34, 84, 11, 133, 253, 232, 165, 196, 197, 139, 162, 113, 128, 29, 117, 153, 121, 178, 213, 239, 16, 100, 111, 244, 240, 215, 123, 62, 2, 141, 46, 159, 30, 59, 176, 72, 193, 114, 70, 52, 68, 168, 22, 9, 249, 207, 73, 135, 137, 21, 67, 226, 256, 58, 234, 49, 242, 99, 169, 221, 32, 200, 222, 231, 223, 173, 246, 124, 4, 25, 92, 61, 60, 118, 95, 144, 129, 228, 140, 104, 136, 79, 44, 18, 241, 157, 146, 13, 17, 42, 134, 195, 255, 116, 211, 98, 227, 198, 81, 185, 64, 143, 187, 205, 189, 89, 235, 248, 8, 50, 184, 122, 120, 236, 190, 31, 1],
-[1, 200, 165, 104, 240, 198, 22, 31, 32, 232, 140, 244, 227, 168, 190, 221, 253, 228, 111, 98, 68, 236, 169, 133, 129, 100, 211, 52, 120, 99, 11, 144, 16, 116, 70, 122, 242, 84, 95, 239, 255, 114, 184, 49, 34, 118, 213, 195, 193, 50, 234, 26, 60, 178, 134, 72, 8, 58, 35, 61, 121, 42, 176, 248, 256, 57, 92, 153, 17, 59, 235, 226, 225, 25, 117, 13, 30, 89, 67, 36, 4, 29, 146, 159, 189, 21, 88, 124, 128, 157, 46, 205, 137, 158, 246, 113, 241, 141, 187, 135, 15, 173, 162, 18, 2, 143, 73, 208, 223, 139, 44, 62, 64, 207, 23, 231, 197, 79, 123, 185, 249, 199, 222, 196, 136, 215, 81, 9, 1, 200, 165, 104, 240, 198, 22, 31, 32, 232, 140, 244, 227, 168, 190, 221, 253, 228, 111, 98, 68, 236, 169, 133, 129, 100, 211, 52, 120, 99, 11, 144, 16, 116, 70, 122, 242, 84, 95, 239, 255, 114, 184, 49, 34, 118, 213, 195, 193, 50, 234, 26, 60, 178, 134, 72, 8, 58, 35, 61, 121, 42, 176, 248, 256, 57, 92, 153, 17, 59, 235, 226, 225, 25, 117, 13, 30, 89, 67, 36, 4, 29, 146, 159, 189, 21, 88, 124, 128, 157, 46, 205, 137, 158, 246, 113, 241, 141, 187, 135, 15, 173, 162, 18, 2, 143, 73, 208, 223, 139, 44, 62, 64, 207, 23, 231, 197, 79, 123, 185, 249, 199, 222, 196, 136, 215, 81, 9, 1],
-[1, 201, 52, 172, 134, 206, 29, 175, 223, 105, 31, 63, 70, 192, 42, 218, 128, 28, 231, 171, 190, 154, 114, 41, 17, 76, 113, 97, 222, 161, 236, 148, 193, 243, 13, 43, 162, 180, 200, 108, 120, 219, 72, 80, 146, 48, 139, 183, 32, 7, 122, 107, 176, 167, 157, 203, 197, 19, 221, 217, 184, 233, 59, 37, 241, 125, 196, 75, 169, 45, 50, 27, 30, 119, 18, 20, 165, 12, 99, 110, 8, 66, 159, 91, 44, 106, 232, 115, 242, 69, 248, 247, 46, 251, 79, 202, 253, 224, 49, 83, 235, 204, 141, 71, 136, 94, 133, 5, 234, 3, 89, 156, 2, 145, 104, 87, 11, 155, 58, 93, 189, 210, 62, 126, 140, 127, 84, 179, 256, 56, 205, 85, 123, 51, 228, 82, 34, 152, 226, 194, 187, 65, 215, 39, 129, 229, 26, 86, 67, 103, 143, 216, 240, 181, 144, 160, 35, 96, 21, 109, 64, 14, 244, 214, 95, 77, 57, 149, 137, 38, 185, 177, 111, 209, 118, 74, 225, 250, 135, 150, 81, 90, 100, 54, 60, 238, 36, 40, 73, 24, 198, 220, 16, 132, 61, 182, 88, 212, 207, 230, 227, 138, 239, 237, 92, 245, 158, 147, 249, 191, 98, 166, 213, 151, 25, 142, 15, 188, 9, 10, 211, 6, 178, 55, 4, 33, 208, 174, 22, 53, 116, 186, 121, 163, 124, 252, 23, 254, 168, 101, 255, 112, 153, 170, 246, 102, 199, 164, 68, 47, 195, 131, 117, 130, 173, 78, 1],
-[1, 202, 198, 161, 140, 10, 221, 181, 68, 115, 100, 154, 11, 166, 122, 229, 255, 110, 118, 192, 234, 237, 72, 152, 121, 27, 57, 206, 235, 182, 13, 56, 4, 37, 21, 130, 46, 40, 113, 210, 15, 203, 143, 102, 44, 150, 231, 145, 249, 183, 215, 254, 165, 177, 31, 94, 227, 108, 228, 53, 169, 214, 52, 224, 16, 148, 84, 6, 184, 160, 195, 69, 60, 41, 58, 151, 176, 86, 153, 66, 225, 218, 89, 245, 146, 194, 124, 119, 137, 175, 141, 212, 162, 85, 208, 125, 64, 78, 79, 24, 222, 126, 9, 19, 240, 164, 232, 90, 190, 87, 98, 7, 129, 101, 99, 209, 70, 5, 239, 219, 34, 186, 50, 77, 134, 83, 61, 243, 256, 55, 59, 96, 117, 247, 36, 76, 189, 142, 157, 103, 246, 91, 135, 28, 2, 147, 139, 65, 23, 20, 185, 105, 136, 230, 200, 51, 22, 75, 244, 201, 253, 220, 236, 127, 211, 217, 144, 47, 242, 54, 114, 155, 213, 107, 26, 112, 8, 74, 42, 3, 92, 80, 226, 163, 30, 149, 29, 204, 88, 43, 205, 33, 241, 109, 173, 251, 73, 97, 62, 188, 197, 216, 199, 106, 81, 171, 104, 191, 32, 39, 168, 12, 111, 63, 133, 138, 120, 82, 116, 45, 95, 172, 49, 132, 193, 179, 178, 233, 35, 131, 248, 238, 17, 93, 25, 167, 67, 170, 159, 250, 128, 156, 158, 48, 187, 252, 18, 38, 223, 71, 207, 180, 123, 174, 196, 14, 1],
-[1, 203, 89, 77, 211, 171, 18, 56, 60, 101, 200, 251, 67, 237, 52, 19, 2, 149, 178, 154, 165, 85, 36, 112, 120, 202, 143, 245, 134, 217, 104, 38, 4, 41, 99, 51, 73, 170, 72, 224, 240, 147, 29, 233, 11, 177, 208, 76, 8, 82, 198, 102, 146, 83, 144, 191, 223, 37, 58, 209, 22, 97, 159, 152, 16, 164, 139, 204, 35, 166, 31, 125, 189, 74, 116, 161, 44, 194, 61, 47, 32, 71, 21, 151, 70, 75, 62, 250, 121, 148, 232, 65, 88, 131, 122, 94, 64, 142, 42, 45, 140, 150, 124, 243, 242, 39, 207, 130, 176, 5, 244, 188, 128, 27, 84, 90, 23, 43, 248, 229, 227, 78, 157, 3, 95, 10, 231, 119, 256, 54, 168, 180, 46, 86, 239, 201, 197, 156, 57, 6, 190, 20, 205, 238, 255, 108, 79, 103, 92, 172, 221, 145, 137, 55, 114, 12, 123, 40, 153, 219, 253, 216, 158, 206, 184, 87, 185, 33, 17, 110, 228, 24, 246, 80, 49, 181, 249, 175, 59, 155, 111, 174, 113, 66, 34, 220, 199, 48, 235, 160, 98, 105, 241, 93, 118, 53, 222, 91, 226, 132, 68, 183, 141, 96, 213, 63, 196, 210, 225, 186, 236, 106, 187, 182, 195, 7, 136, 109, 25, 192, 169, 126, 135, 163, 193, 115, 215, 212, 117, 107, 133, 14, 15, 218, 50, 127, 81, 252, 13, 69, 129, 230, 173, 167, 234, 214, 9, 28, 30, 179, 100, 254, 162, 247, 26, 138, 1],
-[1, 204, 239, 183, 67, 47, 79, 182, 120, 65, 153, 115, 73, 243, 228, 252, 8, 90, 113, 179, 22, 119, 118, 171, 189, 6, 196, 149, 70, 145, 25, 217, 64, 206, 133, 147, 176, 181, 173, 83, 227, 48, 26, 164, 46, 132, 200, 194, 255, 106, 36, 148, 123, 163, 99, 150, 17, 127, 208, 27, 111, 28, 58, 10, 241, 77, 31, 156, 213, 19, 21, 172, 136, 245, 122, 216, 117, 224, 207, 80, 129, 102, 248, 220, 162, 152, 168, 91, 60, 161, 205, 186, 165, 250, 114, 126, 4, 45, 185, 218, 11, 188, 59, 214, 223, 3, 98, 203, 35, 201, 141, 237, 32, 103, 195, 202, 88, 219, 215, 170, 242, 24, 13, 82, 23, 66, 100, 97, 256, 53, 18, 74, 190, 210, 178, 75, 137, 192, 104, 142, 184, 14, 29, 5, 249, 167, 144, 78, 235, 138, 139, 86, 68, 251, 61, 108, 187, 112, 232, 40, 193, 51, 124, 110, 81, 76, 84, 174, 30, 209, 231, 93, 211, 125, 57, 63, 2, 151, 221, 109, 134, 94, 158, 107, 240, 130, 49, 230, 146, 229, 199, 247, 16, 180, 226, 101, 44, 238, 236, 85, 121, 12, 135, 41, 140, 33, 50, 177, 128, 155, 9, 37, 95, 105, 89, 166, 197, 96, 52, 71, 92, 7, 143, 131, 253, 212, 72, 39, 246, 69, 198, 43, 34, 254, 159, 54, 222, 56, 116, 20, 225, 154, 62, 55, 169, 38, 42, 87, 15, 233, 244, 175, 234, 191, 157, 160, 1],
-[1, 205, 134, 228, 223, 226, 70, 215, 128, 26, 190, 143, 17, 144, 222, 21, 193, 244, 162, 57, 120, 185, 146, 118, 32, 135, 176, 100, 197, 36, 184, 198, 241, 61, 169, 207, 30, 239, 165, 158, 8, 98, 44, 25, 242, 9, 46, 178, 253, 208, 235, 116, 136, 124, 234, 168, 2, 153, 11, 199, 189, 195, 140, 173, 256, 52, 123, 29, 34, 31, 187, 42, 129, 231, 67, 114, 240, 113, 35, 236, 64, 13, 95, 200, 137, 72, 111, 139, 225, 122, 81, 157, 60, 221, 73, 59, 16, 196, 88, 50, 227, 18, 92, 99, 249, 159, 213, 232, 15, 248, 211, 79, 4, 49, 22, 141, 121, 133, 23, 89, 255, 104, 246, 58, 68, 62, 117, 84, 1, 205, 134, 228, 223, 226, 70, 215, 128, 26, 190, 143, 17, 144, 222, 21, 193, 244, 162, 57, 120, 185, 146, 118, 32, 135, 176, 100, 197, 36, 184, 198, 241, 61, 169, 207, 30, 239, 165, 158, 8, 98, 44, 25, 242, 9, 46, 178, 253, 208, 235, 116, 136, 124, 234, 168, 2, 153, 11, 199, 189, 195, 140, 173, 256, 52, 123, 29, 34, 31, 187, 42, 129, 231, 67, 114, 240, 113, 35, 236, 64, 13, 95, 200, 137, 72, 111, 139, 225, 122, 81, 157, 60, 221, 73, 59, 16, 196, 88, 50, 227, 18, 92, 99, 249, 159, 213, 232, 15, 248, 211, 79, 4, 49, 22, 141, 121, 133, 23, 89, 255, 104, 246, 58, 68, 62, 117, 84, 1],
-[1, 206, 31, 218, 190, 76, 236, 43, 120, 48, 122, 203, 184, 125, 50, 20, 8, 106, 248, 202, 235, 94, 89, 87, 189, 127, 205, 82, 187, 229, 143, 160, 64, 77, 185, 74, 81, 238, 198, 182, 227, 245, 98, 142, 211, 33, 116, 252, 255, 102, 195, 78, 134, 105, 42, 171, 17, 161, 13, 108, 146, 7, 157, 217, 241, 45, 18, 110, 44, 69, 79, 83, 136, 3, 104, 93, 140, 56, 228, 194, 129, 103, 144, 109, 95, 38, 118, 150, 60, 24, 61, 230, 92, 191, 25, 10, 4, 53, 124, 101, 246, 47, 173, 172, 223, 192, 231, 41, 222, 243, 200, 80, 32, 167, 221, 37, 169, 119, 99, 91, 242, 251, 49, 71, 234, 145, 58, 126, 256, 51, 226, 39, 67, 181, 21, 214, 137, 209, 135, 54, 73, 132, 207, 237, 249, 151, 9, 55, 22, 163, 168, 170, 68, 130, 52, 175, 70, 28, 114, 97, 193, 180, 72, 183, 176, 19, 59, 75, 30, 12, 159, 115, 46, 224, 141, 5, 2, 155, 62, 179, 123, 152, 215, 86, 240, 96, 244, 149, 111, 250, 100, 40, 16, 212, 239, 147, 213, 188, 178, 174, 121, 254, 153, 164, 117, 201, 29, 63, 128, 154, 113, 148, 162, 219, 139, 107, 197, 233, 196, 27, 165, 66, 232, 247, 253, 204, 133, 156, 11, 210, 84, 85, 34, 65, 26, 216, 35, 14, 57, 177, 225, 90, 36, 220, 88, 138, 158, 166, 15, 6, 208, 186, 23, 112, 199, 131, 1],
-[1, 207, 187, 159, 17, 178, 95, 133, 32, 199, 73, 205, 30, 42, 213, 144, 253, 200, 23, 135, 189, 59, 134, 239, 129, 232, 222, 208, 137, 89, 176, 195, 16, 228, 165, 231, 15, 21, 235, 72, 255, 100, 140, 196, 223, 158, 67, 248, 193, 116, 111, 104, 197, 173, 88, 226, 8, 114, 211, 244, 136, 139, 246, 36, 256, 50, 70, 98, 240, 79, 162, 124, 225, 58, 184, 52, 227, 215, 44, 113, 4, 57, 234, 122, 68, 198, 123, 18, 128, 25, 35, 49, 120, 168, 81, 62, 241, 29, 92, 26, 242, 236, 22, 185, 2, 157, 117, 61, 34, 99, 190, 9, 64, 141, 146, 153, 60, 84, 169, 31, 249, 143, 46, 13, 121, 118, 11, 221, 1, 207, 187, 159, 17, 178, 95, 133, 32, 199, 73, 205, 30, 42, 213, 144, 253, 200, 23, 135, 189, 59, 134, 239, 129, 232, 222, 208, 137, 89, 176, 195, 16, 228, 165, 231, 15, 21, 235, 72, 255, 100, 140, 196, 223, 158, 67, 248, 193, 116, 111, 104, 197, 173, 88, 226, 8, 114, 211, 244, 136, 139, 246, 36, 256, 50, 70, 98, 240, 79, 162, 124, 225, 58, 184, 52, 227, 215, 44, 113, 4, 57, 234, 122, 68, 198, 123, 18, 128, 25, 35, 49, 120, 168, 81, 62, 241, 29, 92, 26, 242, 236, 22, 185, 2, 157, 117, 61, 34, 99, 190, 9, 64, 141, 146, 153, 60, 84, 169, 31, 249, 143, 46, 13, 121, 118, 11, 221, 1],
-[1, 208, 88, 57, 34, 133, 165, 139, 128, 153, 213, 100, 240, 62, 46, 59, 193, 52, 22, 207, 137, 226, 234, 99, 32, 231, 246, 25, 60, 144, 140, 79, 241, 13, 134, 116, 227, 185, 187, 89, 8, 122, 190, 199, 15, 36, 35, 84, 253, 196, 162, 29, 121, 239, 111, 215, 2, 159, 176, 114, 68, 9, 73, 21, 256, 49, 169, 200, 223, 124, 92, 118, 129, 104, 44, 157, 17, 195, 211, 198, 64, 205, 235, 50, 120, 31, 23, 158, 225, 26, 11, 232, 197, 113, 117, 178, 16, 244, 123, 141, 30, 72, 70, 168, 249, 135, 67, 58, 242, 221, 222, 173, 4, 61, 95, 228, 136, 18, 146, 42, 255, 98, 81, 143, 189, 248, 184, 236, 1, 208, 88, 57, 34, 133, 165, 139, 128, 153, 213, 100, 240, 62, 46, 59, 193, 52, 22, 207, 137, 226, 234, 99, 32, 231, 246, 25, 60, 144, 140, 79, 241, 13, 134, 116, 227, 185, 187, 89, 8, 122, 190, 199, 15, 36, 35, 84, 253, 196, 162, 29, 121, 239, 111, 215, 2, 159, 176, 114, 68, 9, 73, 21, 256, 49, 169, 200, 223, 124, 92, 118, 129, 104, 44, 157, 17, 195, 211, 198, 64, 205, 235, 50, 120, 31, 23, 158, 225, 26, 11, 232, 197, 113, 117, 178, 16, 244, 123, 141, 30, 72, 70, 168, 249, 135, 67, 58, 242, 221, 222, 173, 4, 61, 95, 228, 136, 18, 146, 42, 255, 98, 81, 143, 189, 248, 184, 236, 1],
-[1, 209, 248, 175, 81, 224, 42, 40, 136, 154, 61, 156, 222, 138, 58, 43, 249, 127, 72, 142, 123, 7, 178, 194, 197, 53, 26, 37, 23, 181, 50, 170, 64, 12, 195, 149, 44, 201, 118, 247, 223, 90, 49, 218, 73, 94, 114, 182, 2, 161, 239, 93, 162, 191, 84, 80, 15, 51, 122, 55, 187, 19, 116, 86, 241, 254, 144, 27, 246, 14, 99, 131, 137, 106, 52, 74, 46, 105, 100, 83, 128, 24, 133, 41, 88, 145, 236, 237, 189, 180, 98, 179, 146, 188, 228, 107, 4, 65, 221, 186, 67, 125, 168, 160, 30, 102, 244, 110, 117, 38, 232, 172, 225, 251, 31, 54, 235, 28, 198, 5, 17, 212, 104, 148, 92, 210, 200, 166, 256, 48, 9, 82, 176, 33, 215, 217, 121, 103, 196, 101, 35, 119, 199, 214, 8, 130, 185, 115, 134, 250, 79, 63, 60, 204, 231, 220, 234, 76, 207, 87, 193, 245, 62, 108, 213, 56, 139, 10, 34, 167, 208, 39, 184, 163, 143, 75, 255, 96, 18, 164, 95, 66, 173, 177, 242, 206, 135, 202, 70, 238, 141, 171, 16, 3, 113, 230, 11, 243, 158, 126, 120, 151, 205, 183, 211, 152, 157, 174, 129, 233, 124, 216, 169, 112, 21, 20, 68, 77, 159, 78, 111, 69, 29, 150, 253, 192, 36, 71, 190, 132, 89, 97, 227, 155, 13, 147, 140, 219, 25, 85, 32, 6, 226, 203, 22, 229, 59, 252, 240, 45, 153, 109, 165, 47, 57, 91, 1],
-[1, 210, 153, 5, 22, 251, 25, 110, 227, 125, 36, 107, 111, 180, 21, 41, 129, 105, 205, 131, 11, 254, 141, 55, 242, 191, 18, 182, 184, 90, 139, 149, 193, 181, 231, 194, 134, 127, 199, 156, 121, 224, 9, 91, 92, 45, 198, 203, 225, 219, 244, 97, 67, 192, 228, 78, 189, 112, 133, 174, 46, 151, 99, 230, 241, 238, 122, 177, 162, 96, 114, 39, 223, 56, 195, 87, 23, 204, 178, 115, 249, 119, 61, 217, 81, 48, 57, 148, 240, 28, 226, 172, 140, 102, 89, 186, 253, 188, 159, 237, 169, 24, 157, 74, 120, 14, 113, 86, 70, 51, 173, 93, 255, 94, 208, 247, 213, 12, 207, 37, 60, 7, 185, 43, 35, 154, 215, 175, 256, 47, 104, 252, 235, 6, 232, 147, 30, 132, 221, 150, 146, 77, 236, 216, 128, 152, 52, 126, 246, 3, 116, 202, 15, 66, 239, 75, 73, 167, 118, 108, 64, 76, 26, 63, 123, 130, 58, 101, 136, 33, 248, 166, 165, 212, 59, 54, 32, 38, 13, 160, 190, 65, 29, 179, 68, 145, 124, 83, 211, 106, 158, 27, 16, 19, 135, 80, 95, 161, 143, 218, 34, 201, 62, 170, 234, 53, 79, 142, 8, 138, 196, 40, 176, 209, 200, 109, 17, 229, 31, 85, 117, 155, 168, 71, 4, 69, 98, 20, 88, 233, 100, 183, 137, 243, 144, 171, 187, 206, 84, 164, 2, 163, 49, 10, 44, 245, 50, 220, 197, 250, 72, 214, 222, 103, 42, 82, 1],
-[1, 211, 60, 67, 2, 165, 120, 134, 4, 73, 240, 11, 8, 146, 223, 22, 16, 35, 189, 44, 32, 70, 121, 88, 64, 140, 242, 176, 128, 23, 227, 95, 256, 46, 197, 190, 255, 92, 137, 123, 253, 184, 17, 246, 249, 111, 34, 235, 241, 222, 68, 213, 225, 187, 136, 169, 193, 117, 15, 81, 129, 234, 30, 162, 1, 211, 60, 67, 2, 165, 120, 134, 4, 73, 240, 11, 8, 146, 223, 22, 16, 35, 189, 44, 32, 70, 121, 88, 64, 140, 242, 176, 128, 23, 227, 95, 256, 46, 197, 190, 255, 92, 137, 123, 253, 184, 17, 246, 249, 111, 34, 235, 241, 222, 68, 213, 225, 187, 136, 169, 193, 117, 15, 81, 129, 234, 30, 162, 1, 211, 60, 67, 2, 165, 120, 134, 4, 73, 240, 11, 8, 146, 223, 22, 16, 35, 189, 44, 32, 70, 121, 88, 64, 140, 242, 176, 128, 23, 227, 95, 256, 46, 197, 190, 255, 92, 137, 123, 253, 184, 17, 246, 249, 111, 34, 235, 241, 222, 68, 213, 225, 187, 136, 169, 193, 117, 15, 81, 129, 234, 30, 162, 1, 211, 60, 67, 2, 165, 120, 134, 4, 73, 240, 11, 8, 146, 223, 22, 16, 35, 189, 44, 32, 70, 121, 88, 64, 140, 242, 176, 128, 23, 227, 95, 256, 46, 197, 190, 255, 92, 137, 123, 253, 184, 17, 246, 249, 111, 34, 235, 241, 222, 68, 213, 225, 187, 136, 169, 193, 117, 15, 81, 129, 234, 30, 162, 1],
-[1, 212, 226, 110, 190, 188, 21, 83, 120, 254, 135, 93, 184, 201, 207, 194, 8, 154, 9, 109, 235, 219, 168, 150, 189, 233, 52, 230, 187, 66, 114, 10, 64, 204, 72, 101, 81, 210, 59, 172, 227, 65, 159, 41, 211, 14, 141, 80, 255, 90, 62, 37, 134, 138, 215, 91, 17, 6, 244, 71, 146, 112, 100, 126, 241, 206, 239, 39, 44, 76, 178, 214, 136, 48, 153, 54, 140, 125, 29, 237, 129, 106, 113, 55, 95, 94, 139, 170, 60, 127, 196, 175, 92, 229, 232, 97, 4, 77, 133, 183, 246, 238, 84, 75, 223, 245, 26, 115, 222, 33, 57, 5, 32, 102, 36, 179, 169, 105, 158, 86, 242, 161, 208, 149, 234, 7, 199, 40, 256, 45, 31, 147, 67, 69, 236, 174, 137, 3, 122, 164, 73, 56, 50, 63, 249, 103, 248, 148, 22, 38, 89, 107, 68, 24, 205, 27, 70, 191, 143, 247, 193, 53, 185, 156, 176, 47, 198, 85, 30, 192, 98, 216, 46, 243, 116, 177, 2, 167, 195, 220, 123, 119, 42, 166, 240, 251, 13, 186, 111, 145, 157, 131, 16, 51, 18, 218, 213, 181, 79, 43, 121, 209, 104, 203, 117, 132, 228, 20, 128, 151, 144, 202, 162, 163, 118, 87, 197, 130, 61, 82, 165, 28, 25, 160, 253, 180, 124, 74, 11, 19, 173, 182, 34, 12, 231, 142, 35, 224, 200, 252, 225, 155, 221, 78, 88, 152, 99, 171, 15, 96, 49, 108, 23, 250, 58, 217, 1],
-[1, 213, 137, 140, 8, 162, 68, 92, 64, 11, 30, 222, 255, 88, 240, 234, 241, 190, 121, 73, 129, 235, 197, 70, 4, 81, 34, 46, 32, 134, 15, 111, 256, 44, 120, 117, 249, 95, 189, 165, 193, 246, 227, 35, 2, 169, 17, 23, 16, 67, 136, 184, 128, 22, 60, 187, 253, 176, 223, 211, 225, 123, 242, 146, 1, 213, 137, 140, 8, 162, 68, 92, 64, 11, 30, 222, 255, 88, 240, 234, 241, 190, 121, 73, 129, 235, 197, 70, 4, 81, 34, 46, 32, 134, 15, 111, 256, 44, 120, 117, 249, 95, 189, 165, 193, 246, 227, 35, 2, 169, 17, 23, 16, 67, 136, 184, 128, 22, 60, 187, 253, 176, 223, 211, 225, 123, 242, 146, 1, 213, 137, 140, 8, 162, 68, 92, 64, 11, 30, 222, 255, 88, 240, 234, 241, 190, 121, 73, 129, 235, 197, 70, 4, 81, 34, 46, 32, 134, 15, 111, 256, 44, 120, 117, 249, 95, 189, 165, 193, 246, 227, 35, 2, 169, 17, 23, 16, 67, 136, 184, 128, 22, 60, 187, 253, 176, 223, 211, 225, 123, 242, 146, 1, 213, 137, 140, 8, 162, 68, 92, 64, 11, 30, 222, 255, 88, 240, 234, 241, 190, 121, 73, 129, 235, 197, 70, 4, 81, 34, 46, 32, 134, 15, 111, 256, 44, 120, 117, 249, 95, 189, 165, 193, 246, 227, 35, 2, 169, 17, 23, 16, 67, 136, 184, 128, 22, 60, 187, 253, 176, 223, 211, 225, 123, 242, 146, 1],
-[1, 214, 50, 163, 187, 183, 98, 155, 17, 40, 79, 201, 95, 27, 124, 65, 32, 166, 58, 76, 73, 202, 52, 77, 30, 252, 215, 7, 213, 93, 113, 24, 253, 172, 57, 119, 23, 39, 122, 151, 189, 97, 198, 224, 134, 149, 18, 254, 129, 107, 25, 210, 222, 220, 49, 206, 137, 20, 168, 229, 176, 142, 62, 161, 16, 83, 29, 38, 165, 101, 26, 167, 15, 126, 236, 132, 235, 175, 185, 12, 255, 86, 157, 188, 140, 148, 61, 204, 223, 177, 99, 112, 67, 203, 9, 127, 193, 182, 141, 105, 111, 110, 153, 103, 197, 10, 84, 243, 88, 71, 31, 209, 8, 170, 143, 19, 211, 179, 13, 212, 136, 63, 118, 66, 246, 216, 221, 6, 256, 43, 207, 94, 70, 74, 159, 102, 240, 217, 178, 56, 162, 230, 133, 192, 225, 91, 199, 181, 184, 55, 205, 180, 227, 5, 42, 250, 44, 164, 144, 233, 4, 85, 200, 138, 234, 218, 135, 106, 68, 160, 59, 33, 123, 108, 239, 3, 128, 150, 232, 47, 35, 37, 208, 51, 120, 237, 89, 28, 81, 115, 195, 96, 241, 174, 228, 219, 92, 156, 231, 90, 242, 131, 21, 125, 22, 82, 72, 245, 2, 171, 100, 69, 117, 109, 196, 53, 34, 80, 158, 145, 190, 54, 248, 130, 64, 75, 116, 152, 146, 147, 104, 154, 60, 247, 173, 14, 169, 186, 226, 48, 249, 87, 114, 238, 46, 78, 244, 45, 121, 194, 139, 191, 11, 41, 36, 251, 1],
-[1, 215, 222, 185, 197, 207, 44, 208, 2, 173, 187, 113, 137, 157, 88, 159, 4, 89, 117, 226, 17, 57, 176, 61, 8, 178, 234, 195, 34, 114, 95, 122, 16, 99, 211, 133, 68, 228, 190, 244, 32, 198, 165, 9, 136, 199, 123, 231, 64, 139, 73, 18, 15, 141, 246, 205, 128, 21, 146, 36, 30, 25, 235, 153, 256, 42, 35, 72, 60, 50, 213, 49, 255, 84, 70, 144, 120, 100, 169, 98, 253, 168, 140, 31, 240, 200, 81, 196, 249, 79, 23, 62, 223, 143, 162, 135, 241, 158, 46, 124, 189, 29, 67, 13, 225, 59, 92, 248, 121, 58, 134, 26, 193, 118, 184, 239, 242, 116, 11, 52, 129, 236, 111, 221, 227, 232, 22, 104, 1, 215, 222, 185, 197, 207, 44, 208, 2, 173, 187, 113, 137, 157, 88, 159, 4, 89, 117, 226, 17, 57, 176, 61, 8, 178, 234, 195, 34, 114, 95, 122, 16, 99, 211, 133, 68, 228, 190, 244, 32, 198, 165, 9, 136, 199, 123, 231, 64, 139, 73, 18, 15, 141, 246, 205, 128, 21, 146, 36, 30, 25, 235, 153, 256, 42, 35, 72, 60, 50, 213, 49, 255, 84, 70, 144, 120, 100, 169, 98, 253, 168, 140, 31, 240, 200, 81, 196, 249, 79, 23, 62, 223, 143, 162, 135, 241, 158, 46, 124, 189, 29, 67, 13, 225, 59, 92, 248, 121, 58, 134, 26, 193, 118, 184, 239, 242, 116, 11, 52, 129, 236, 111, 221, 227, 232, 22, 104, 1],
-[1, 216, 139, 212, 46, 170, 226, 243, 60, 110, 116, 127, 190, 177, 196, 188, 2, 175, 21, 167, 92, 83, 195, 229, 120, 220, 232, 254, 123, 97, 135, 119, 4, 93, 42, 77, 184, 166, 133, 201, 240, 183, 207, 251, 246, 194, 13, 238, 8, 186, 84, 154, 111, 75, 9, 145, 223, 109, 157, 245, 235, 131, 26, 219, 16, 115, 168, 51, 222, 150, 18, 33, 189, 218, 57, 233, 213, 5, 52, 181, 32, 230, 79, 102, 187, 43, 36, 66, 121, 179, 114, 209, 169, 10, 104, 105, 64, 203, 158, 204, 117, 86, 72, 132, 242, 101, 228, 161, 81, 20, 208, 210, 128, 149, 59, 151, 234, 172, 144, 7, 227, 202, 199, 65, 162, 40, 159, 163, 256, 41, 118, 45, 211, 87, 31, 14, 197, 147, 141, 130, 67, 80, 61, 69, 255, 82, 236, 90, 165, 174, 62, 28, 137, 37, 25, 3, 134, 160, 122, 138, 253, 164, 215, 180, 73, 91, 124, 56, 17, 74, 50, 6, 11, 63, 244, 19, 249, 71, 173, 103, 146, 182, 248, 112, 34, 148, 100, 12, 22, 126, 231, 38, 241, 142, 89, 206, 35, 107, 239, 224, 68, 39, 200, 24, 44, 252, 205, 76, 225, 27, 178, 155, 70, 214, 221, 191, 136, 78, 143, 48, 88, 247, 153, 152, 193, 54, 99, 53, 140, 171, 185, 125, 15, 156, 29, 96, 176, 237, 49, 47, 129, 108, 198, 106, 23, 85, 113, 250, 30, 55, 58, 192, 95, 217, 98, 94, 1],
-[1, 217, 58, 250, 23, 108, 49, 96, 15, 171, 99, 152, 88, 78, 221, 155, 225, 252, 200, 224, 35, 142, 231, 12, 34, 182, 173, 19, 11, 74, 124, 180, 253, 160, 25, 28, 165, 82, 61, 130, 197, 87, 118, 163, 162, 202, 144, 151, 128, 20, 228, 132, 117, 203, 104, 209, 121, 43, 79, 181, 213, 218, 18, 51, 16, 131, 157, 145, 111, 186, 13, 251, 240, 166, 42, 119, 123, 220, 195, 167, 2, 177, 116, 243, 46, 216, 98, 192, 30, 85, 198, 47, 176, 156, 185, 53, 193, 247, 143, 191, 70, 27, 205, 24, 68, 107, 89, 38, 22, 148, 248, 103, 249, 63, 50, 56, 73, 164, 122, 3, 137, 174, 236, 69, 67, 147, 31, 45, 256, 40, 199, 7, 234, 149, 208, 161, 242, 86, 158, 105, 169, 179, 36, 102, 32, 5, 57, 33, 222, 115, 26, 245, 223, 75, 84, 238, 246, 183, 133, 77, 4, 97, 232, 229, 92, 175, 196, 127, 60, 170, 139, 94, 95, 55, 113, 106, 129, 237, 29, 125, 140, 54, 153, 48, 136, 214, 178, 76, 44, 39, 239, 206, 241, 126, 100, 112, 146, 71, 244, 6, 17, 91, 215, 138, 134, 37, 62, 90, 255, 80, 141, 14, 211, 41, 159, 65, 227, 172, 59, 210, 81, 101, 72, 204, 64, 10, 114, 66, 187, 230, 52, 233, 189, 150, 168, 219, 235, 109, 9, 154, 8, 194, 207, 201, 184, 93, 135, 254, 120, 83, 21, 188, 190, 110, 226, 212, 1],
-[1, 218, 236, 48, 184, 20, 248, 94, 189, 82, 143, 77, 81, 182, 98, 33, 255, 78, 42, 161, 146, 217, 18, 69, 136, 93, 228, 103, 95, 150, 61, 191, 4, 101, 173, 192, 222, 80, 221, 119, 242, 71, 58, 51, 67, 214, 135, 132, 249, 55, 168, 130, 70, 97, 72, 19, 30, 115, 141, 155, 123, 86, 244, 250, 16, 147, 178, 254, 117, 63, 113, 219, 197, 27, 232, 204, 11, 85, 26, 14, 225, 220, 158, 6, 23, 131, 31, 76, 120, 203, 50, 106, 235, 87, 205, 229, 64, 74, 198, 245, 211, 252, 195, 105, 17, 108, 157, 45, 44, 83, 104, 56, 129, 109, 118, 24, 92, 10, 124, 47, 223, 41, 200, 167, 169, 91, 49, 145, 256, 39, 21, 209, 73, 237, 9, 163, 68, 175, 114, 180, 176, 75, 159, 224, 2, 179, 215, 96, 111, 40, 239, 188, 121, 164, 29, 154, 162, 107, 196, 66, 253, 156, 84, 65, 35, 177, 36, 138, 15, 186, 199, 206, 190, 43, 122, 125, 8, 202, 89, 127, 187, 160, 185, 238, 227, 142, 116, 102, 134, 171, 13, 7, 241, 110, 79, 3, 140, 194, 144, 38, 60, 230, 25, 53, 246, 172, 231, 243, 32, 37, 99, 251, 234, 126, 226, 181, 137, 54, 207, 151, 22, 170, 52, 28, 193, 183, 59, 12, 46, 5, 62, 152, 240, 149, 100, 212, 213, 174, 153, 201, 128, 148, 139, 233, 165, 247, 133, 210, 34, 216, 57, 90, 88, 166, 208, 112, 1],
-[1, 219, 159, 126, 95, 245, 199, 148, 30, 145, 144, 182, 23, 154, 59, 71, 129, 238, 208, 63, 176, 251, 228, 74, 15, 201, 72, 91, 140, 77, 158, 164, 193, 119, 104, 160, 88, 254, 114, 37, 136, 229, 36, 174, 70, 167, 79, 82, 225, 188, 52, 80, 44, 127, 57, 147, 68, 243, 18, 87, 35, 212, 168, 41, 241, 94, 26, 40, 22, 192, 157, 202, 34, 250, 9, 172, 146, 106, 84, 149, 249, 47, 13, 20, 11, 96, 207, 101, 17, 125, 133, 86, 73, 53, 42, 203, 253, 152, 135, 10, 134, 48, 232, 179, 137, 191, 195, 43, 165, 155, 21, 230, 255, 76, 196, 5, 67, 24, 116, 218, 197, 224, 226, 150, 211, 206, 139, 115, 256, 38, 98, 131, 162, 12, 58, 109, 227, 112, 113, 75, 234, 103, 198, 186, 128, 19, 49, 194, 81, 6, 29, 183, 242, 56, 185, 166, 117, 180, 99, 93, 64, 138, 153, 97, 169, 3, 143, 220, 121, 28, 221, 83, 187, 90, 178, 175, 32, 69, 205, 177, 213, 130, 200, 110, 189, 14, 239, 170, 222, 45, 89, 216, 16, 163, 231, 217, 235, 65, 100, 55, 223, 7, 248, 85, 111, 151, 173, 108, 8, 210, 244, 237, 246, 161, 50, 156, 240, 132, 124, 171, 184, 204, 215, 54, 4, 105, 122, 247, 123, 209, 25, 78, 120, 66, 62, 214, 92, 102, 236, 27, 2, 181, 61, 252, 190, 233, 141, 39, 60, 33, 31, 107, 46, 51, 118, 142, 1],
-[1, 220, 84, 233, 117, 40, 62, 19, 68, 54, 58, 167, 246, 150, 104, 7, 255, 74, 89, 48, 23, 177, 133, 219, 121, 149, 141, 180, 22, 214, 49, 243, 4, 109, 79, 161, 211, 160, 248, 76, 15, 216, 232, 154, 213, 86, 159, 28, 249, 39, 99, 192, 92, 194, 18, 105, 227, 82, 50, 206, 88, 85, 196, 201, 16, 179, 59, 130, 73, 126, 221, 47, 60, 93, 157, 102, 81, 87, 122, 112, 225, 156, 139, 254, 111, 5, 72, 163, 137, 71, 200, 53, 95, 83, 13, 33, 64, 202, 236, 6, 35, 247, 113, 188, 240, 115, 114, 151, 67, 91, 231, 191, 129, 110, 42, 245, 187, 20, 31, 138, 34, 27, 29, 212, 123, 75, 52, 132, 256, 37, 173, 24, 140, 217, 195, 238, 189, 203, 199, 90, 11, 107, 153, 250, 2, 183, 168, 209, 234, 80, 124, 38, 136, 108, 116, 77, 235, 43, 208, 14, 253, 148, 178, 96, 46, 97, 9, 181, 242, 41, 25, 103, 44, 171, 98, 229, 8, 218, 158, 65, 165, 63, 239, 152, 30, 175, 207, 51, 169, 172, 61, 56, 241, 78, 198, 127, 184, 131, 36, 210, 197, 164, 100, 155, 176, 170, 135, 145, 32, 101, 118, 3, 146, 252, 185, 94, 120, 186, 57, 204, 162, 174, 244, 224, 193, 55, 21, 251, 222, 10, 144, 69, 17, 142, 143, 106, 190, 166, 26, 66, 128, 147, 215, 12, 70, 237, 226, 119, 223, 230, 228, 45, 134, 182, 205, 125, 1],
-[1, 221, 11, 118, 121, 13, 46, 143, 249, 31, 169, 84, 60, 153, 146, 141, 64, 9, 190, 99, 34, 61, 117, 157, 2, 185, 22, 236, 242, 26, 92, 29, 241, 62, 81, 168, 120, 49, 35, 25, 128, 18, 123, 198, 68, 122, 234, 57, 4, 113, 44, 215, 227, 52, 184, 58, 225, 124, 162, 79, 240, 98, 70, 50, 256, 36, 246, 139, 136, 244, 211, 114, 8, 226, 88, 173, 197, 104, 111, 116, 193, 248, 67, 158, 223, 196, 140, 100, 255, 72, 235, 21, 15, 231, 165, 228, 16, 195, 176, 89, 137, 208, 222, 232, 129, 239, 134, 59, 189, 135, 23, 200, 253, 144, 213, 42, 30, 205, 73, 199, 32, 133, 95, 178, 17, 159, 187, 207, 1, 221, 11, 118, 121, 13, 46, 143, 249, 31, 169, 84, 60, 153, 146, 141, 64, 9, 190, 99, 34, 61, 117, 157, 2, 185, 22, 236, 242, 26, 92, 29, 241, 62, 81, 168, 120, 49, 35, 25, 128, 18, 123, 198, 68, 122, 234, 57, 4, 113, 44, 215, 227, 52, 184, 58, 225, 124, 162, 79, 240, 98, 70, 50, 256, 36, 246, 139, 136, 244, 211, 114, 8, 226, 88, 173, 197, 104, 111, 116, 193, 248, 67, 158, 223, 196, 140, 100, 255, 72, 235, 21, 15, 231, 165, 228, 16, 195, 176, 89, 137, 208, 222, 232, 129, 239, 134, 59, 189, 135, 23, 200, 253, 144, 213, 42, 30, 205, 73, 199, 32, 133, 95, 178, 17, 159, 187, 207, 1],
-[1, 222, 197, 44, 2, 187, 137, 88, 4, 117, 17, 176, 8, 234, 34, 95, 16, 211, 68, 190, 32, 165, 136, 123, 64, 73, 15, 246, 128, 146, 30, 235, 256, 35, 60, 213, 255, 70, 120, 169, 253, 140, 240, 81, 249, 23, 223, 162, 241, 46, 189, 67, 225, 92, 121, 134, 193, 184, 242, 11, 129, 111, 227, 22, 1, 222, 197, 44, 2, 187, 137, 88, 4, 117, 17, 176, 8, 234, 34, 95, 16, 211, 68, 190, 32, 165, 136, 123, 64, 73, 15, 246, 128, 146, 30, 235, 256, 35, 60, 213, 255, 70, 120, 169, 253, 140, 240, 81, 249, 23, 223, 162, 241, 46, 189, 67, 225, 92, 121, 134, 193, 184, 242, 11, 129, 111, 227, 22, 1, 222, 197, 44, 2, 187, 137, 88, 4, 117, 17, 176, 8, 234, 34, 95, 16, 211, 68, 190, 32, 165, 136, 123, 64, 73, 15, 246, 128, 146, 30, 235, 256, 35, 60, 213, 255, 70, 120, 169, 253, 140, 240, 81, 249, 23, 223, 162, 241, 46, 189, 67, 225, 92, 121, 134, 193, 184, 242, 11, 129, 111, 227, 22, 1, 222, 197, 44, 2, 187, 137, 88, 4, 117, 17, 176, 8, 234, 34, 95, 16, 211, 68, 190, 32, 165, 136, 123, 64, 73, 15, 246, 128, 146, 30, 235, 256, 35, 60, 213, 255, 70, 120, 169, 253, 140, 240, 81, 249, 23, 223, 162, 241, 46, 189, 67, 225, 92, 121, 134, 193, 184, 242, 11, 129, 111, 227, 22, 1],
-[1, 223, 128, 17, 193, 120, 32, 197, 241, 30, 8, 242, 253, 136, 2, 189, 256, 34, 129, 240, 64, 137, 225, 60, 16, 227, 249, 15, 4, 121, 255, 68, 1, 223, 128, 17, 193, 120, 32, 197, 241, 30, 8, 242, 253, 136, 2, 189, 256, 34, 129, 240, 64, 137, 225, 60, 16, 227, 249, 15, 4, 121, 255, 68, 1, 223, 128, 17, 193, 120, 32, 197, 241, 30, 8, 242, 253, 136, 2, 189, 256, 34, 129, 240, 64, 137, 225, 60, 16, 227, 249, 15, 4, 121, 255, 68, 1, 223, 128, 17, 193, 120, 32, 197, 241, 30, 8, 242, 253, 136, 2, 189, 256, 34, 129, 240, 64, 137, 225, 60, 16, 227, 249, 15, 4, 121, 255, 68, 1, 223, 128, 17, 193, 120, 32, 197, 241, 30, 8, 242, 253, 136, 2, 189, 256, 34, 129, 240, 64, 137, 225, 60, 16, 227, 249, 15, 4, 121, 255, 68, 1, 223, 128, 17, 193, 120, 32, 197, 241, 30, 8, 242, 253, 136, 2, 189, 256, 34, 129, 240, 64, 137, 225, 60, 16, 227, 249, 15, 4, 121, 255, 68, 1, 223, 128, 17, 193, 120, 32, 197, 241, 30, 8, 242, 253, 136, 2, 189, 256, 34, 129, 240, 64, 137, 225, 60, 16, 227, 249, 15, 4, 121, 255, 68, 1, 223, 128, 17, 193, 120, 32, 197, 241, 30, 8, 242, 253, 136, 2, 189, 256, 34, 129, 240, 64, 137, 225, 60, 16, 227, 249, 15, 4, 121, 255, 68, 1],
-[1, 224, 61, 43, 123, 53, 50, 149, 223, 94, 239, 80, 187, 254, 99, 74, 128, 145, 98, 107, 67, 102, 232, 54, 17, 210, 9, 217, 35, 130, 79, 220, 193, 56, 208, 75, 95, 206, 141, 230, 120, 152, 124, 20, 111, 192, 89, 147, 32, 229, 153, 91, 81, 154, 58, 142, 197, 181, 195, 247, 73, 161, 84, 55, 241, 14, 52, 83, 88, 180, 228, 186, 30, 38, 31, 5, 92, 48, 215, 101, 8, 250, 231, 87, 213, 167, 143, 164, 242, 238, 113, 126, 211, 233, 21, 78, 253, 132, 13, 85, 22, 45, 57, 175, 136, 138, 72, 194, 23, 12, 118, 218, 2, 191, 122, 86, 246, 106, 100, 41, 189, 188, 221, 160, 117, 251, 198, 148, 256, 33, 196, 214, 134, 204, 207, 108, 34, 163, 18, 177, 70, 3, 158, 183, 129, 112, 159, 150, 190, 155, 25, 203, 240, 47, 248, 40, 222, 127, 178, 37, 64, 201, 49, 182, 162, 51, 116, 27, 137, 105, 133, 237, 146, 65, 168, 110, 225, 28, 104, 166, 176, 103, 199, 115, 60, 76, 62, 10, 184, 96, 173, 202, 16, 243, 205, 174, 169, 77, 29, 71, 227, 219, 226, 252, 165, 209, 42, 156, 249, 7, 26, 170, 44, 90, 114, 93, 15, 19, 144, 131, 46, 24, 236, 179, 4, 125, 244, 172, 235, 212, 200, 82, 121, 119, 185, 63, 234, 245, 139, 39, 255, 66, 135, 171, 11, 151, 157, 216, 68, 69, 36, 97, 140, 6, 59, 109, 1],
-[1, 225, 253, 128, 16, 2, 193, 249, 256, 32, 4, 129, 241, 255, 64, 8, 1, 225, 253, 128, 16, 2, 193, 249, 256, 32, 4, 129, 241, 255, 64, 8, 1, 225, 253, 128, 16, 2, 193, 249, 256, 32, 4, 129, 241, 255, 64, 8, 1, 225, 253, 128, 16, 2, 193, 249, 256, 32, 4, 129, 241, 255, 64, 8, 1, 225, 253, 128, 16, 2, 193, 249, 256, 32, 4, 129, 241, 255, 64, 8, 1, 225, 253, 128, 16, 2, 193, 249, 256, 32, 4, 129, 241, 255, 64, 8, 1, 225, 253, 128, 16, 2, 193, 249, 256, 32, 4, 129, 241, 255, 64, 8, 1, 225, 253, 128, 16, 2, 193, 249, 256, 32, 4, 129, 241, 255, 64, 8, 1, 225, 253, 128, 16, 2, 193, 249, 256, 32, 4, 129, 241, 255, 64, 8, 1, 225, 253, 128, 16, 2, 193, 249, 256, 32, 4, 129, 241, 255, 64, 8, 1, 225, 253, 128, 16, 2, 193, 249, 256, 32, 4, 129, 241, 255, 64, 8, 1, 225, 253, 128, 16, 2, 193, 249, 256, 32, 4, 129, 241, 255, 64, 8, 1, 225, 253, 128, 16, 2, 193, 249, 256, 32, 4, 129, 241, 255, 64, 8, 1, 225, 253, 128, 16, 2, 193, 249, 256, 32, 4, 129, 241, 255, 64, 8, 1, 225, 253, 128, 16, 2, 193, 249, 256, 32, 4, 129, 241, 255, 64, 8, 1, 225, 253, 128, 16, 2, 193, 249, 256, 32, 4, 129, 241, 255, 64, 8, 1],
-[1, 226, 190, 21, 120, 135, 184, 207, 8, 9, 235, 168, 189, 52, 187, 114, 64, 72, 81, 59, 227, 159, 211, 141, 255, 62, 134, 215, 17, 244, 146, 100, 241, 239, 44, 178, 136, 153, 140, 29, 129, 113, 95, 139, 60, 196, 92, 232, 4, 133, 246, 84, 223, 26, 222, 57, 32, 36, 169, 158, 242, 208, 234, 199, 256, 31, 67, 236, 137, 122, 73, 50, 249, 248, 22, 89, 68, 205, 70, 143, 193, 185, 176, 198, 30, 98, 46, 116, 2, 195, 123, 42, 240, 13, 111, 157, 16, 18, 213, 79, 121, 104, 117, 228, 128, 144, 162, 118, 197, 61, 165, 25, 253, 124, 11, 173, 34, 231, 35, 200, 225, 221, 88, 99, 15, 49, 23, 58, 1, 226, 190, 21, 120, 135, 184, 207, 8, 9, 235, 168, 189, 52, 187, 114, 64, 72, 81, 59, 227, 159, 211, 141, 255, 62, 134, 215, 17, 244, 146, 100, 241, 239, 44, 178, 136, 153, 140, 29, 129, 113, 95, 139, 60, 196, 92, 232, 4, 133, 246, 84, 223, 26, 222, 57, 32, 36, 169, 158, 242, 208, 234, 199, 256, 31, 67, 236, 137, 122, 73, 50, 249, 248, 22, 89, 68, 205, 70, 143, 193, 185, 176, 198, 30, 98, 46, 116, 2, 195, 123, 42, 240, 13, 111, 157, 16, 18, 213, 79, 121, 104, 117, 228, 128, 144, 162, 118, 197, 61, 165, 25, 253, 124, 11, 173, 34, 231, 35, 200, 225, 221, 88, 99, 15, 49, 23, 58, 1],
-[1, 227, 129, 242, 193, 121, 225, 189, 241, 223, 249, 240, 253, 120, 255, 60, 256, 30, 128, 15, 64, 136, 32, 68, 16, 34, 8, 17, 4, 137, 2, 197, 1, 227, 129, 242, 193, 121, 225, 189, 241, 223, 249, 240, 253, 120, 255, 60, 256, 30, 128, 15, 64, 136, 32, 68, 16, 34, 8, 17, 4, 137, 2, 197, 1, 227, 129, 242, 193, 121, 225, 189, 241, 223, 249, 240, 253, 120, 255, 60, 256, 30, 128, 15, 64, 136, 32, 68, 16, 34, 8, 17, 4, 137, 2, 197, 1, 227, 129, 242, 193, 121, 225, 189, 241, 223, 249, 240, 253, 120, 255, 60, 256, 30, 128, 15, 64, 136, 32, 68, 16, 34, 8, 17, 4, 137, 2, 197, 1, 227, 129, 242, 193, 121, 225, 189, 241, 223, 249, 240, 253, 120, 255, 60, 256, 30, 128, 15, 64, 136, 32, 68, 16, 34, 8, 17, 4, 137, 2, 197, 1, 227, 129, 242, 193, 121, 225, 189, 241, 223, 249, 240, 253, 120, 255, 60, 256, 30, 128, 15, 64, 136, 32, 68, 16, 34, 8, 17, 4, 137, 2, 197, 1, 227, 129, 242, 193, 121, 225, 189, 241, 223, 249, 240, 253, 120, 255, 60, 256, 30, 128, 15, 64, 136, 32, 68, 16, 34, 8, 17, 4, 137, 2, 197, 1, 227, 129, 242, 193, 121, 225, 189, 241, 223, 249, 240, 253, 120, 255, 60, 256, 30, 128, 15, 64, 136, 32, 68, 16, 34, 8, 17, 4, 137, 2, 197, 1],
-[1, 228, 70, 26, 17, 21, 162, 185, 32, 100, 184, 61, 30, 158, 44, 9, 253, 116, 234, 153, 189, 173, 123, 31, 129, 114, 35, 13, 137, 139, 81, 221, 16, 50, 92, 159, 15, 79, 22, 133, 255, 58, 117, 205, 223, 215, 190, 144, 193, 57, 146, 135, 197, 198, 169, 239, 8, 25, 46, 208, 136, 168, 11, 195, 256, 29, 187, 231, 240, 236, 95, 72, 225, 157, 73, 196, 227, 99, 213, 248, 4, 141, 23, 104, 68, 84, 134, 226, 128, 143, 222, 244, 120, 118, 176, 36, 241, 207, 165, 98, 242, 178, 235, 124, 2, 199, 140, 52, 34, 42, 67, 113, 64, 200, 111, 122, 60, 59, 88, 18, 249, 232, 211, 49, 121, 89, 246, 62, 1, 228, 70, 26, 17, 21, 162, 185, 32, 100, 184, 61, 30, 158, 44, 9, 253, 116, 234, 153, 189, 173, 123, 31, 129, 114, 35, 13, 137, 139, 81, 221, 16, 50, 92, 159, 15, 79, 22, 133, 255, 58, 117, 205, 223, 215, 190, 144, 193, 57, 146, 135, 197, 198, 169, 239, 8, 25, 46, 208, 136, 168, 11, 195, 256, 29, 187, 231, 240, 236, 95, 72, 225, 157, 73, 196, 227, 99, 213, 248, 4, 141, 23, 104, 68, 84, 134, 226, 128, 143, 222, 244, 120, 118, 176, 36, 241, 207, 165, 98, 242, 178, 235, 124, 2, 199, 140, 52, 34, 42, 67, 113, 64, 200, 111, 122, 60, 59, 88, 18, 249, 232, 211, 49, 121, 89, 246, 62, 1],
-[1, 229, 13, 150, 169, 151, 141, 164, 34, 76, 185, 217, 92, 251, 168, 179, 128, 14, 122, 182, 44, 53, 58, 175, 240, 219, 36, 20, 211, 3, 173, 39, 193, 250, 196, 166, 235, 102, 228, 41, 137, 19, 239, 247, 23, 127, 42, 109, 32, 132, 159, 174, 11, 206, 143, 108, 60, 119, 9, 5, 117, 65, 236, 74, 241, 191, 49, 170, 123, 154, 57, 203, 227, 69, 124, 126, 70, 96, 139, 220, 8, 33, 104, 172, 67, 180, 100, 27, 15, 94, 195, 194, 222, 209, 59, 147, 253, 112, 205, 171, 95, 167, 207, 115, 121, 210, 31, 160, 146, 24, 99, 55, 2, 201, 26, 43, 81, 45, 25, 71, 68, 152, 113, 177, 184, 245, 79, 101, 256, 28, 244, 107, 88, 106, 116, 93, 223, 181, 72, 40, 165, 6, 89, 78, 129, 243, 135, 75, 213, 204, 199, 82, 17, 38, 221, 237, 46, 254, 84, 218, 64, 7, 61, 91, 22, 155, 29, 216, 120, 238, 18, 10, 234, 130, 215, 148, 225, 125, 98, 83, 246, 51, 114, 149, 197, 138, 248, 252, 140, 192, 21, 183, 16, 66, 208, 87, 134, 103, 200, 54, 30, 188, 133, 131, 187, 161, 118, 37, 249, 224, 153, 85, 190, 77, 157, 230, 242, 163, 62, 63, 35, 48, 198, 110, 4, 145, 52, 86, 162, 90, 50, 142, 136, 47, 226, 97, 111, 233, 158, 202, 255, 56, 231, 214, 176, 212, 232, 186, 189, 105, 144, 80, 73, 12, 178, 156, 1],
-[1, 230, 215, 106, 222, 174, 185, 145, 197, 78, 207, 65, 44, 97, 208, 38, 2, 203, 173, 212, 187, 91, 113, 33, 137, 156, 157, 130, 88, 194, 159, 76, 4, 149, 89, 167, 117, 182, 226, 66, 17, 55, 57, 3, 176, 131, 61, 152, 8, 41, 178, 77, 234, 107, 195, 132, 34, 110, 114, 6, 95, 5, 122, 47, 16, 82, 99, 154, 211, 214, 133, 7, 68, 220, 228, 12, 190, 10, 244, 94, 32, 164, 198, 51, 165, 171, 9, 14, 136, 183, 199, 24, 123, 20, 231, 188, 64, 71, 139, 102, 73, 85, 18, 28, 15, 109, 141, 48, 246, 40, 205, 119, 128, 142, 21, 204, 146, 170, 36, 56, 30, 218, 25, 96, 235, 80, 153, 238, 256, 27, 42, 151, 35, 83, 72, 112, 60, 179, 50, 192, 213, 160, 49, 219, 255, 54, 84, 45, 70, 166, 144, 224, 120, 101, 100, 127, 169, 63, 98, 181, 253, 108, 168, 90, 140, 75, 31, 191, 240, 202, 200, 254, 81, 126, 196, 105, 249, 216, 79, 180, 23, 150, 62, 125, 223, 147, 143, 251, 162, 252, 135, 210, 241, 175, 158, 103, 46, 43, 124, 250, 189, 37, 29, 245, 67, 247, 13, 163, 225, 93, 59, 206, 92, 86, 248, 243, 121, 74, 58, 233, 134, 237, 26, 69, 193, 186, 118, 155, 184, 172, 239, 229, 242, 148, 116, 209, 11, 217, 52, 138, 129, 115, 236, 53, 111, 87, 221, 201, 227, 39, 232, 161, 22, 177, 104, 19, 1],
-[1, 231, 162, 157, 30, 248, 234, 84, 129, 244, 81, 207, 15, 124, 117, 42, 193, 122, 169, 232, 136, 62, 187, 21, 225, 61, 213, 116, 68, 31, 222, 139, 241, 159, 235, 58, 34, 144, 111, 198, 249, 208, 246, 29, 17, 72, 184, 99, 253, 104, 123, 143, 137, 36, 92, 178, 255, 52, 190, 200, 197, 18, 46, 89, 256, 26, 95, 100, 227, 9, 23, 173, 128, 13, 176, 50, 242, 133, 140, 215, 64, 135, 88, 25, 121, 195, 70, 236, 32, 196, 44, 141, 189, 226, 35, 118, 16, 98, 22, 199, 223, 113, 146, 59, 8, 49, 11, 228, 240, 185, 73, 158, 4, 153, 134, 114, 120, 221, 165, 79, 2, 205, 67, 57, 60, 239, 211, 168, 1, 231, 162, 157, 30, 248, 234, 84, 129, 244, 81, 207, 15, 124, 117, 42, 193, 122, 169, 232, 136, 62, 187, 21, 225, 61, 213, 116, 68, 31, 222, 139, 241, 159, 235, 58, 34, 144, 111, 198, 249, 208, 246, 29, 17, 72, 184, 99, 253, 104, 123, 143, 137, 36, 92, 178, 255, 52, 190, 200, 197, 18, 46, 89, 256, 26, 95, 100, 227, 9, 23, 173, 128, 13, 176, 50, 242, 133, 140, 215, 64, 135, 88, 25, 121, 195, 70, 236, 32, 196, 44, 141, 189, 226, 35, 118, 16, 98, 22, 199, 223, 113, 146, 59, 8, 49, 11, 228, 240, 185, 73, 158, 4, 153, 134, 114, 120, 221, 165, 79, 2, 205, 67, 57, 60, 239, 211, 168, 1],
-[1, 232, 111, 52, 242, 118, 134, 248, 225, 29, 46, 135, 223, 79, 81, 31, 253, 100, 70, 49, 60, 42, 235, 36, 128, 141, 73, 231, 136, 198, 190, 133, 16, 114, 234, 61, 17, 89, 88, 113, 2, 207, 222, 104, 227, 236, 11, 239, 193, 58, 92, 13, 189, 158, 162, 62, 249, 200, 140, 98, 120, 84, 213, 72, 256, 25, 146, 205, 15, 139, 123, 9, 32, 228, 211, 122, 34, 178, 176, 226, 4, 157, 187, 208, 197, 215, 22, 221, 129, 116, 184, 26, 121, 59, 67, 124, 241, 143, 23, 196, 240, 168, 169, 144, 255, 50, 35, 153, 30, 21, 246, 18, 64, 199, 165, 244, 68, 99, 95, 195, 8, 57, 117, 159, 137, 173, 44, 185, 1, 232, 111, 52, 242, 118, 134, 248, 225, 29, 46, 135, 223, 79, 81, 31, 253, 100, 70, 49, 60, 42, 235, 36, 128, 141, 73, 231, 136, 198, 190, 133, 16, 114, 234, 61, 17, 89, 88, 113, 2, 207, 222, 104, 227, 236, 11, 239, 193, 58, 92, 13, 189, 158, 162, 62, 249, 200, 140, 98, 120, 84, 213, 72, 256, 25, 146, 205, 15, 139, 123, 9, 32, 228, 211, 122, 34, 178, 176, 226, 4, 157, 187, 208, 197, 215, 22, 221, 129, 116, 184, 26, 121, 59, 67, 124, 241, 143, 23, 196, 240, 168, 169, 144, 255, 50, 35, 153, 30, 21, 246, 18, 64, 199, 165, 244, 68, 99, 95, 195, 8, 57, 117, 159, 137, 173, 44, 185, 1],
-[1, 233, 62, 54, 246, 7, 89, 177, 121, 180, 49, 109, 211, 76, 232, 86, 249, 192, 18, 82, 88, 201, 59, 126, 60, 102, 122, 156, 111, 163, 200, 83, 64, 6, 113, 115, 67, 191, 42, 20, 34, 212, 52, 37, 140, 238, 199, 107, 2, 209, 124, 108, 235, 14, 178, 97, 242, 103, 98, 218, 165, 152, 207, 172, 241, 127, 36, 164, 176, 145, 118, 252, 120, 204, 244, 55, 222, 69, 143, 166, 128, 12, 226, 230, 134, 125, 84, 40, 68, 167, 104, 74, 23, 219, 141, 214, 4, 161, 248, 216, 213, 28, 99, 194, 227, 206, 196, 179, 73, 47, 157, 87, 225, 254, 72, 71, 95, 33, 236, 247, 240, 151, 231, 110, 187, 138, 29, 75, 256, 24, 195, 203, 11, 250, 168, 80, 136, 77, 208, 148, 46, 181, 25, 171, 8, 65, 239, 175, 169, 56, 198, 131, 197, 155, 135, 101, 146, 94, 57, 174, 193, 251, 144, 142, 190, 66, 215, 237, 223, 45, 205, 220, 117, 19, 58, 150, 255, 48, 133, 149, 22, 243, 79, 160, 15, 154, 159, 39, 92, 105, 50, 85, 16, 130, 221, 93, 81, 112, 139, 5, 137, 53, 13, 202, 35, 188, 114, 91, 129, 245, 31, 27, 123, 132, 173, 217, 189, 90, 153, 183, 234, 38, 116, 43, 253, 96, 9, 41, 44, 229, 158, 63, 30, 51, 61, 78, 184, 210, 100, 170, 32, 3, 185, 186, 162, 224, 21, 10, 17, 106, 26, 147, 70, 119, 228, 182, 1],
-[1, 234, 15, 169, 225, 222, 34, 246, 253, 92, 197, 95, 128, 140, 121, 44, 16, 146, 240, 134, 2, 211, 30, 81, 193, 187, 68, 235, 249, 184, 137, 190, 256, 23, 242, 88, 32, 35, 223, 11, 4, 165, 60, 162, 129, 117, 136, 213, 241, 111, 17, 123, 255, 46, 227, 176, 64, 70, 189, 22, 8, 73, 120, 67, 1, 234, 15, 169, 225, 222, 34, 246, 253, 92, 197, 95, 128, 140, 121, 44, 16, 146, 240, 134, 2, 211, 30, 81, 193, 187, 68, 235, 249, 184, 137, 190, 256, 23, 242, 88, 32, 35, 223, 11, 4, 165, 60, 162, 129, 117, 136, 213, 241, 111, 17, 123, 255, 46, 227, 176, 64, 70, 189, 22, 8, 73, 120, 67, 1, 234, 15, 169, 225, 222, 34, 246, 253, 92, 197, 95, 128, 140, 121, 44, 16, 146, 240, 134, 2, 211, 30, 81, 193, 187, 68, 235, 249, 184, 137, 190, 256, 23, 242, 88, 32, 35, 223, 11, 4, 165, 60, 162, 129, 117, 136, 213, 241, 111, 17, 123, 255, 46, 227, 176, 64, 70, 189, 22, 8, 73, 120, 67, 1, 234, 15, 169, 225, 222, 34, 246, 253, 92, 197, 95, 128, 140, 121, 44, 16, 146, 240, 134, 2, 211, 30, 81, 193, 187, 68, 235, 249, 184, 137, 190, 256, 23, 242, 88, 32, 35, 223, 11, 4, 165, 60, 162, 129, 117, 136, 213, 241, 111, 17, 123, 255, 46, 227, 176, 64, 70, 189, 22, 8, 73, 120, 67, 1],
-[1, 235, 227, 146, 129, 246, 242, 73, 193, 123, 121, 165, 225, 190, 189, 211, 241, 95, 223, 234, 249, 176, 240, 117, 253, 88, 120, 187, 255, 44, 60, 222, 256, 22, 30, 111, 128, 11, 15, 184, 64, 134, 136, 92, 32, 67, 68, 46, 16, 162, 34, 23, 8, 81, 17, 140, 4, 169, 137, 70, 2, 213, 197, 35, 1, 235, 227, 146, 129, 246, 242, 73, 193, 123, 121, 165, 225, 190, 189, 211, 241, 95, 223, 234, 249, 176, 240, 117, 253, 88, 120, 187, 255, 44, 60, 222, 256, 22, 30, 111, 128, 11, 15, 184, 64, 134, 136, 92, 32, 67, 68, 46, 16, 162, 34, 23, 8, 81, 17, 140, 4, 169, 137, 70, 2, 213, 197, 35, 1, 235, 227, 146, 129, 246, 242, 73, 193, 123, 121, 165, 225, 190, 189, 211, 241, 95, 223, 234, 249, 176, 240, 117, 253, 88, 120, 187, 255, 44, 60, 222, 256, 22, 30, 111, 128, 11, 15, 184, 64, 134, 136, 92, 32, 67, 68, 46, 16, 162, 34, 23, 8, 81, 17, 140, 4, 169, 137, 70, 2, 213, 197, 35, 1, 235, 227, 146, 129, 246, 242, 73, 193, 123, 121, 165, 225, 190, 189, 211, 241, 95, 223, 234, 249, 176, 240, 117, 253, 88, 120, 187, 255, 44, 60, 222, 256, 22, 30, 111, 128, 11, 15, 184, 64, 134, 136, 92, 32, 67, 68, 46, 16, 162, 34, 23, 8, 81, 17, 140, 4, 169, 137, 70, 2, 213, 197, 35, 1],
-[1, 236, 184, 248, 189, 143, 81, 98, 255, 42, 146, 18, 136, 228, 95, 61, 4, 173, 222, 221, 242, 58, 67, 135, 249, 168, 70, 72, 30, 141, 123, 244, 16, 178, 117, 113, 197, 232, 11, 26, 225, 158, 23, 31, 120, 50, 235, 205, 64, 198, 211, 195, 17, 157, 44, 104, 129, 118, 92, 124, 223, 200, 169, 49, 256, 21, 73, 9, 68, 114, 176, 159, 2, 215, 111, 239, 121, 29, 162, 196, 253, 84, 35, 36, 15, 199, 190, 122, 8, 89, 187, 185, 227, 116, 134, 13, 241, 79, 140, 144, 60, 25, 246, 231, 32, 99, 234, 226, 137, 207, 22, 52, 193, 59, 46, 62, 240, 100, 213, 153, 128, 139, 165, 133, 34, 57, 88, 208, 1, 236, 184, 248, 189, 143, 81, 98, 255, 42, 146, 18, 136, 228, 95, 61, 4, 173, 222, 221, 242, 58, 67, 135, 249, 168, 70, 72, 30, 141, 123, 244, 16, 178, 117, 113, 197, 232, 11, 26, 225, 158, 23, 31, 120, 50, 235, 205, 64, 198, 211, 195, 17, 157, 44, 104, 129, 118, 92, 124, 223, 200, 169, 49, 256, 21, 73, 9, 68, 114, 176, 159, 2, 215, 111, 239, 121, 29, 162, 196, 253, 84, 35, 36, 15, 199, 190, 122, 8, 89, 187, 185, 227, 116, 134, 13, 241, 79, 140, 144, 60, 25, 246, 231, 32, 99, 234, 226, 137, 207, 22, 52, 193, 59, 46, 62, 240, 100, 213, 153, 128, 139, 165, 133, 34, 57, 88, 208, 1],
-[1, 237, 143, 224, 146, 164, 61, 65, 242, 43, 168, 238, 123, 110, 113, 53, 225, 126, 50, 28, 211, 149, 104, 233, 223, 166, 21, 94, 176, 78, 239, 103, 253, 80, 199, 132, 187, 115, 13, 254, 60, 85, 99, 76, 22, 74, 62, 45, 128, 10, 57, 145, 184, 175, 98, 96, 136, 107, 173, 138, 67, 202, 72, 102, 16, 194, 232, 243, 23, 54, 205, 12, 17, 174, 118, 210, 169, 218, 9, 77, 2, 217, 29, 191, 35, 71, 122, 130, 227, 86, 79, 219, 246, 220, 226, 106, 193, 252, 100, 56, 165, 41, 208, 209, 189, 75, 42, 188, 95, 156, 221, 206, 249, 160, 141, 7, 117, 230, 26, 251, 120, 170, 198, 152, 44, 148, 124, 90, 256, 20, 114, 33, 111, 93, 196, 192, 15, 214, 89, 19, 134, 147, 144, 204, 32, 131, 207, 229, 46, 108, 153, 24, 34, 91, 236, 163, 81, 179, 18, 154, 4, 177, 58, 125, 70, 142, 244, 3, 197, 172, 158, 181, 235, 183, 195, 212, 129, 247, 200, 112, 73, 82, 159, 161, 121, 150, 84, 119, 190, 55, 185, 155, 241, 63, 25, 14, 234, 203, 52, 245, 240, 83, 139, 47, 88, 39, 248, 180, 255, 40, 228, 66, 222, 186, 135, 127, 30, 171, 178, 38, 11, 37, 31, 151, 64, 5, 157, 201, 92, 216, 49, 48, 68, 182, 215, 69, 162, 101, 36, 51, 8, 97, 116, 250, 140, 27, 231, 6, 137, 87, 59, 105, 213, 109, 133, 167, 1],
-[1, 238, 104, 80, 22, 96, 232, 218, 227, 56, 221, 170, 111, 204, 236, 142, 129, 119, 52, 40, 11, 48, 116, 109, 242, 28, 239, 85, 184, 102, 118, 71, 193, 188, 26, 20, 134, 24, 58, 183, 121, 14, 248, 171, 92, 51, 59, 164, 225, 94, 13, 10, 67, 12, 29, 220, 189, 7, 124, 214, 46, 154, 158, 82, 241, 47, 135, 5, 162, 6, 143, 110, 223, 132, 62, 107, 23, 77, 79, 41, 249, 152, 196, 131, 81, 3, 200, 55, 240, 66, 31, 182, 140, 167, 168, 149, 253, 76, 98, 194, 169, 130, 100, 156, 120, 33, 144, 91, 70, 212, 84, 203, 255, 38, 49, 97, 213, 65, 50, 78, 60, 145, 72, 174, 35, 106, 42, 230, 256, 19, 153, 177, 235, 161, 25, 39, 30, 201, 36, 87, 146, 53, 21, 115, 128, 138, 205, 217, 246, 209, 141, 148, 15, 229, 18, 172, 73, 155, 139, 186, 64, 69, 231, 237, 123, 233, 199, 74, 136, 243, 9, 86, 165, 206, 198, 93, 32, 163, 244, 247, 190, 245, 228, 37, 68, 250, 133, 43, 211, 103, 99, 175, 16, 210, 122, 252, 95, 251, 114, 147, 34, 125, 195, 150, 234, 180, 178, 216, 8, 105, 61, 126, 176, 254, 57, 202, 17, 191, 226, 75, 117, 90, 89, 108, 4, 181, 159, 63, 88, 127, 157, 101, 137, 224, 113, 166, 187, 45, 173, 54, 2, 219, 208, 160, 44, 192, 207, 179, 197, 112, 185, 83, 222, 151, 215, 27, 1],
-[1, 239, 67, 79, 120, 153, 73, 228, 8, 113, 22, 118, 189, 196, 70, 25, 64, 133, 176, 173, 227, 26, 46, 200, 255, 36, 123, 99, 17, 208, 111, 58, 241, 31, 213, 21, 136, 122, 117, 207, 129, 248, 162, 168, 60, 205, 165, 114, 4, 185, 11, 59, 223, 98, 35, 141, 32, 195, 88, 215, 242, 13, 23, 100, 256, 18, 190, 178, 137, 104, 184, 29, 249, 144, 235, 139, 68, 61, 187, 232, 193, 124, 81, 84, 30, 231, 211, 57, 2, 221, 134, 158, 240, 49, 146, 199, 16, 226, 44, 236, 121, 135, 140, 50, 128, 9, 95, 89, 197, 52, 92, 143, 253, 72, 246, 198, 34, 159, 222, 116, 225, 62, 169, 42, 15, 244, 234, 157, 1, 239, 67, 79, 120, 153, 73, 228, 8, 113, 22, 118, 189, 196, 70, 25, 64, 133, 176, 173, 227, 26, 46, 200, 255, 36, 123, 99, 17, 208, 111, 58, 241, 31, 213, 21, 136, 122, 117, 207, 129, 248, 162, 168, 60, 205, 165, 114, 4, 185, 11, 59, 223, 98, 35, 141, 32, 195, 88, 215, 242, 13, 23, 100, 256, 18, 190, 178, 137, 104, 184, 29, 249, 144, 235, 139, 68, 61, 187, 232, 193, 124, 81, 84, 30, 231, 211, 57, 2, 221, 134, 158, 240, 49, 146, 199, 16, 226, 44, 236, 121, 135, 140, 50, 128, 9, 95, 89, 197, 52, 92, 143, 253, 72, 246, 198, 34, 159, 222, 116, 225, 62, 169, 42, 15, 244, 234, 157, 1],
-[1, 240, 32, 227, 253, 68, 129, 120, 16, 242, 255, 34, 193, 60, 8, 121, 256, 17, 225, 30, 4, 189, 128, 137, 241, 15, 2, 223, 64, 197, 249, 136, 1, 240, 32, 227, 253, 68, 129, 120, 16, 242, 255, 34, 193, 60, 8, 121, 256, 17, 225, 30, 4, 189, 128, 137, 241, 15, 2, 223, 64, 197, 249, 136, 1, 240, 32, 227, 253, 68, 129, 120, 16, 242, 255, 34, 193, 60, 8, 121, 256, 17, 225, 30, 4, 189, 128, 137, 241, 15, 2, 223, 64, 197, 249, 136, 1, 240, 32, 227, 253, 68, 129, 120, 16, 242, 255, 34, 193, 60, 8, 121, 256, 17, 225, 30, 4, 189, 128, 137, 241, 15, 2, 223, 64, 197, 249, 136, 1, 240, 32, 227, 253, 68, 129, 120, 16, 242, 255, 34, 193, 60, 8, 121, 256, 17, 225, 30, 4, 189, 128, 137, 241, 15, 2, 223, 64, 197, 249, 136, 1, 240, 32, 227, 253, 68, 129, 120, 16, 242, 255, 34, 193, 60, 8, 121, 256, 17, 225, 30, 4, 189, 128, 137, 241, 15, 2, 223, 64, 197, 249, 136, 1, 240, 32, 227, 253, 68, 129, 120, 16, 242, 255, 34, 193, 60, 8, 121, 256, 17, 225, 30, 4, 189, 128, 137, 241, 15, 2, 223, 64, 197, 249, 136, 1, 240, 32, 227, 253, 68, 129, 120, 16, 242, 255, 34, 193, 60, 8, 121, 256, 17, 225, 30, 4, 189, 128, 137, 241, 15, 2, 223, 64, 197, 249, 136, 1],
-[1, 241, 256, 16, 1, 241, 256, 16, 1, 241, 256, 16, 1, 241, 256, 16, 1, 241, 256, 16, 1, 241, 256, 16, 1, 241, 256, 16, 1, 241, 256, 16, 1, 241, 256, 16, 1, 241, 256, 16, 1, 241, 256, 16, 1, 241, 256, 16, 1, 241, 256, 16, 1, 241, 256, 16, 1, 241, 256, 16, 1, 241, 256, 16, 1, 241, 256, 16, 1, 241, 256, 16, 1, 241, 256, 16, 1, 241, 256, 16, 1, 241, 256, 16, 1, 241, 256, 16, 1, 241, 256, 16, 1, 241, 256, 16, 1, 241, 256, 16, 1, 241, 256, 16, 1, 241, 256, 16, 1, 241, 256, 16, 1, 241, 256, 16, 1, 241, 256, 16, 1, 241, 256, 16, 1, 241, 256, 16, 1, 241, 256, 16, 1, 241, 256, 16, 1, 241, 256, 16, 1, 241, 256, 16, 1, 241, 256, 16, 1, 241, 256, 16, 1, 241, 256, 16, 1, 241, 256, 16, 1, 241, 256, 16, 1, 241, 256, 16, 1, 241, 256, 16, 1, 241, 256, 16, 1, 241, 256, 16, 1, 241, 256, 16, 1, 241, 256, 16, 1, 241, 256, 16, 1, 241, 256, 16, 1, 241, 256, 16, 1, 241, 256, 16, 1, 241, 256, 16, 1, 241, 256, 16, 1, 241, 256, 16, 1, 241, 256, 16, 1, 241, 256, 16, 1, 241, 256, 16, 1, 241, 256, 16, 1, 241, 256, 16, 1, 241, 256, 16, 1, 241, 256, 16, 1, 241, 256, 16, 1, 241, 256, 16, 1, 241, 256, 16, 1],
-[1, 242, 225, 223, 253, 60, 128, 136, 16, 17, 2, 227, 193, 189, 249, 120, 256, 15, 32, 34, 4, 197, 129, 121, 241, 240, 255, 30, 64, 68, 8, 137, 1, 242, 225, 223, 253, 60, 128, 136, 16, 17, 2, 227, 193, 189, 249, 120, 256, 15, 32, 34, 4, 197, 129, 121, 241, 240, 255, 30, 64, 68, 8, 137, 1, 242, 225, 223, 253, 60, 128, 136, 16, 17, 2, 227, 193, 189, 249, 120, 256, 15, 32, 34, 4, 197, 129, 121, 241, 240, 255, 30, 64, 68, 8, 137, 1, 242, 225, 223, 253, 60, 128, 136, 16, 17, 2, 227, 193, 189, 249, 120, 256, 15, 32, 34, 4, 197, 129, 121, 241, 240, 255, 30, 64, 68, 8, 137, 1, 242, 225, 223, 253, 60, 128, 136, 16, 17, 2, 227, 193, 189, 249, 120, 256, 15, 32, 34, 4, 197, 129, 121, 241, 240, 255, 30, 64, 68, 8, 137, 1, 242, 225, 223, 253, 60, 128, 136, 16, 17, 2, 227, 193, 189, 249, 120, 256, 15, 32, 34, 4, 197, 129, 121, 241, 240, 255, 30, 64, 68, 8, 137, 1, 242, 225, 223, 253, 60, 128, 136, 16, 17, 2, 227, 193, 189, 249, 120, 256, 15, 32, 34, 4, 197, 129, 121, 241, 240, 255, 30, 64, 68, 8, 137, 1, 242, 225, 223, 253, 60, 128, 136, 16, 17, 2, 227, 193, 189, 249, 120, 256, 15, 32, 34, 4, 197, 129, 121, 241, 240, 255, 30, 64, 68, 8, 137, 1],
-[1, 243, 196, 83, 123, 77, 207, 186, 223, 219, 18, 5, 187, 209, 158, 101, 128, 7, 159, 87, 67, 90, 25, 164, 17, 19, 248, 126, 35, 24, 178, 78, 193, 125, 49, 85, 95, 212, 116, 175, 120, 119, 133, 194, 111, 245, 168, 218, 32, 66, 104, 86, 81, 151, 199, 41, 197, 69, 62, 160, 73, 6, 173, 148, 241, 224, 205, 214, 88, 53, 29, 108, 30, 94, 226, 177, 92, 254, 42, 183, 8, 145, 26, 150, 213, 102, 114, 203, 242, 210, 144, 40, 211, 130, 236, 37, 253, 56, 244, 182, 22, 206, 200, 27, 136, 152, 185, 237, 23, 192, 139, 110, 2, 229, 135, 166, 246, 154, 157, 115, 189, 181, 36, 10, 117, 161, 59, 202, 256, 14, 61, 174, 134, 180, 50, 71, 34, 38, 239, 252, 70, 48, 99, 156, 129, 250, 98, 170, 190, 167, 232, 93, 240, 238, 9, 131, 222, 233, 79, 179, 64, 132, 208, 172, 162, 45, 141, 82, 137, 138, 124, 63, 146, 12, 89, 39, 225, 191, 153, 171, 176, 106, 58, 216, 60, 188, 195, 97, 184, 251, 84, 109, 16, 33, 52, 43, 169, 204, 228, 149, 227, 163, 31, 80, 165, 3, 215, 74, 249, 112, 231, 107, 44, 155, 143, 54, 15, 47, 113, 217, 46, 127, 21, 220, 4, 201, 13, 75, 235, 51, 57, 230, 121, 105, 72, 20, 234, 65, 118, 147, 255, 28, 122, 91, 11, 103, 100, 142, 68, 76, 221, 247, 140, 96, 198, 55, 1],
-[1, 244, 169, 116, 34, 72, 92, 89, 128, 135, 44, 199, 240, 221, 211, 84, 193, 61, 235, 29, 137, 18, 23, 215, 32, 98, 11, 114, 60, 248, 117, 21, 241, 208, 123, 200, 227, 133, 70, 118, 8, 153, 67, 157, 15, 62, 222, 198, 253, 52, 95, 50, 121, 226, 146, 158, 2, 231, 81, 232, 68, 144, 184, 178, 256, 13, 88, 141, 223, 185, 165, 168, 129, 122, 213, 58, 17, 36, 46, 173, 64, 196, 22, 228, 120, 239, 234, 42, 225, 159, 246, 143, 197, 9, 140, 236, 16, 49, 134, 57, 30, 124, 187, 139, 249, 104, 190, 100, 242, 195, 35, 59, 4, 205, 162, 207, 136, 31, 111, 99, 255, 26, 176, 25, 189, 113, 73, 79, 1, 244, 169, 116, 34, 72, 92, 89, 128, 135, 44, 199, 240, 221, 211, 84, 193, 61, 235, 29, 137, 18, 23, 215, 32, 98, 11, 114, 60, 248, 117, 21, 241, 208, 123, 200, 227, 133, 70, 118, 8, 153, 67, 157, 15, 62, 222, 198, 253, 52, 95, 50, 121, 226, 146, 158, 2, 231, 81, 232, 68, 144, 184, 178, 256, 13, 88, 141, 223, 185, 165, 168, 129, 122, 213, 58, 17, 36, 46, 173, 64, 196, 22, 228, 120, 239, 234, 42, 225, 159, 246, 143, 197, 9, 140, 236, 16, 49, 134, 57, 30, 124, 187, 139, 249, 104, 190, 100, 242, 195, 35, 59, 4, 205, 162, 207, 136, 31, 111, 99, 255, 26, 176, 25, 189, 113, 73, 79, 1],
-[1, 245, 144, 71, 176, 201, 158, 160, 136, 167, 52, 147, 35, 94, 157, 172, 249, 96, 133, 203, 134, 191, 21, 5, 197, 206, 98, 109, 234, 19, 29, 166, 64, 3, 221, 175, 213, 14, 89, 217, 223, 151, 244, 156, 184, 105, 25, 214, 2, 233, 31, 142, 95, 145, 59, 63, 15, 77, 104, 37, 70, 188, 57, 87, 241, 192, 9, 149, 11, 125, 42, 10, 137, 155, 196, 218, 211, 38, 58, 75, 128, 6, 185, 93, 169, 28, 178, 177, 189, 45, 231, 55, 111, 210, 50, 171, 4, 209, 62, 27, 190, 33, 118, 126, 30, 154, 208, 74, 140, 119, 114, 174, 225, 127, 18, 41, 22, 250, 84, 20, 17, 53, 135, 179, 165, 76, 116, 150, 256, 12, 113, 186, 81, 56, 99, 97, 121, 90, 205, 110, 222, 163, 100, 85, 8, 161, 124, 54, 123, 66, 236, 252, 60, 51, 159, 148, 23, 238, 228, 91, 193, 254, 36, 82, 44, 243, 168, 40, 34, 106, 13, 101, 73, 152, 232, 43, 255, 24, 226, 115, 162, 112, 198, 194, 242, 180, 153, 220, 187, 69, 200, 170, 16, 65, 248, 108, 246, 132, 215, 247, 120, 102, 61, 39, 46, 219, 199, 182, 129, 251, 72, 164, 88, 229, 79, 80, 68, 212, 26, 202, 146, 47, 207, 86, 253, 48, 195, 230, 67, 224, 139, 131, 227, 103, 49, 183, 117, 138, 143, 83, 32, 130, 239, 216, 235, 7, 173, 237, 240, 204, 122, 78, 92, 181, 141, 107, 1],
-[1, 246, 121, 211, 249, 88, 60, 111, 64, 67, 34, 140, 2, 235, 242, 165, 241, 176, 120, 222, 128, 134, 68, 23, 4, 213, 227, 73, 225, 95, 240, 187, 256, 11, 136, 46, 8, 169, 197, 146, 193, 190, 223, 117, 255, 22, 15, 92, 16, 81, 137, 35, 129, 123, 189, 234, 253, 44, 30, 184, 32, 162, 17, 70, 1, 246, 121, 211, 249, 88, 60, 111, 64, 67, 34, 140, 2, 235, 242, 165, 241, 176, 120, 222, 128, 134, 68, 23, 4, 213, 227, 73, 225, 95, 240, 187, 256, 11, 136, 46, 8, 169, 197, 146, 193, 190, 223, 117, 255, 22, 15, 92, 16, 81, 137, 35, 129, 123, 189, 234, 253, 44, 30, 184, 32, 162, 17, 70, 1, 246, 121, 211, 249, 88, 60, 111, 64, 67, 34, 140, 2, 235, 242, 165, 241, 176, 120, 222, 128, 134, 68, 23, 4, 213, 227, 73, 225, 95, 240, 187, 256, 11, 136, 46, 8, 169, 197, 146, 193, 190, 223, 117, 255, 22, 15, 92, 16, 81, 137, 35, 129, 123, 189, 234, 253, 44, 30, 184, 32, 162, 17, 70, 1, 246, 121, 211, 249, 88, 60, 111, 64, 67, 34, 140, 2, 235, 242, 165, 241, 176, 120, 222, 128, 134, 68, 23, 4, 213, 227, 73, 225, 95, 240, 187, 256, 11, 136, 46, 8, 169, 197, 146, 193, 190, 223, 117, 255, 22, 15, 92, 16, 81, 137, 35, 129, 123, 189, 234, 253, 44, 30, 184, 32, 162, 17, 70, 1],
-[1, 247, 100, 28, 234, 230, 13, 127, 15, 107, 215, 163, 169, 109, 195, 106, 225, 63, 141, 132, 222, 93, 98, 48, 34, 174, 59, 181, 246, 110, 185, 206, 253, 40, 114, 145, 92, 108, 205, 6, 197, 86, 168, 119, 95, 78, 248, 90, 128, 5, 207, 243, 140, 142, 122, 65, 121, 75, 21, 47, 44, 74, 31, 204, 16, 97, 58, 191, 146, 82, 208, 233, 240, 170, 99, 38, 134, 202, 36, 154, 2, 237, 200, 56, 211, 203, 26, 254, 30, 214, 173, 69, 81, 218, 133, 212, 193, 126, 25, 7, 187, 186, 196, 96, 68, 91, 118, 105, 235, 220, 113, 155, 249, 80, 228, 33, 184, 216, 153, 12, 137, 172, 79, 238, 190, 156, 239, 180, 256, 10, 157, 229, 23, 27, 244, 130, 242, 150, 42, 94, 88, 148, 62, 151, 32, 194, 116, 125, 35, 164, 159, 209, 223, 83, 198, 76, 11, 147, 72, 51, 4, 217, 143, 112, 165, 149, 52, 251, 60, 171, 89, 138, 162, 179, 9, 167, 129, 252, 50, 14, 117, 115, 135, 192, 136, 182, 236, 210, 213, 183, 226, 53, 241, 160, 199, 66, 111, 175, 49, 24, 17, 87, 158, 219, 123, 55, 221, 103, 255, 20, 57, 201, 46, 54, 231, 3, 227, 43, 84, 188, 176, 39, 124, 45, 64, 131, 232, 250, 70, 71, 61, 161, 189, 166, 139, 152, 22, 37, 144, 102, 8, 177, 29, 224, 73, 41, 104, 245, 120, 85, 178, 19, 67, 101, 18, 77, 1],
-[1, 248, 81, 42, 136, 61, 222, 58, 249, 72, 123, 178, 197, 26, 23, 50, 64, 195, 44, 118, 223, 49, 73, 114, 2, 239, 162, 84, 15, 122, 187, 116, 241, 144, 246, 99, 137, 52, 46, 100, 128, 133, 88, 236, 189, 98, 146, 228, 4, 221, 67, 168, 30, 244, 117, 232, 225, 31, 235, 198, 17, 104, 92, 200, 256, 9, 176, 215, 121, 196, 35, 199, 8, 185, 134, 79, 60, 231, 234, 207, 193, 62, 213, 139, 34, 208, 184, 143, 255, 18, 95, 173, 242, 135, 70, 141, 16, 113, 11, 158, 120, 205, 211, 157, 129, 124, 169, 21, 68, 159, 111, 29, 253, 36, 190, 89, 227, 13, 140, 25, 32, 226, 22, 59, 240, 153, 165, 57, 1, 248, 81, 42, 136, 61, 222, 58, 249, 72, 123, 178, 197, 26, 23, 50, 64, 195, 44, 118, 223, 49, 73, 114, 2, 239, 162, 84, 15, 122, 187, 116, 241, 144, 246, 99, 137, 52, 46, 100, 128, 133, 88, 236, 189, 98, 146, 228, 4, 221, 67, 168, 30, 244, 117, 232, 225, 31, 235, 198, 17, 104, 92, 200, 256, 9, 176, 215, 121, 196, 35, 199, 8, 185, 134, 79, 60, 231, 234, 207, 193, 62, 213, 139, 34, 208, 184, 143, 255, 18, 95, 173, 242, 135, 70, 141, 16, 113, 11, 158, 120, 205, 211, 157, 129, 124, 169, 21, 68, 159, 111, 29, 253, 36, 190, 89, 227, 13, 140, 25, 32, 226, 22, 59, 240, 153, 165, 57, 1],
-[1, 249, 64, 2, 241, 128, 4, 225, 256, 8, 193, 255, 16, 129, 253, 32, 1, 249, 64, 2, 241, 128, 4, 225, 256, 8, 193, 255, 16, 129, 253, 32, 1, 249, 64, 2, 241, 128, 4, 225, 256, 8, 193, 255, 16, 129, 253, 32, 1, 249, 64, 2, 241, 128, 4, 225, 256, 8, 193, 255, 16, 129, 253, 32, 1, 249, 64, 2, 241, 128, 4, 225, 256, 8, 193, 255, 16, 129, 253, 32, 1, 249, 64, 2, 241, 128, 4, 225, 256, 8, 193, 255, 16, 129, 253, 32, 1, 249, 64, 2, 241, 128, 4, 225, 256, 8, 193, 255, 16, 129, 253, 32, 1, 249, 64, 2, 241, 128, 4, 225, 256, 8, 193, 255, 16, 129, 253, 32, 1, 249, 64, 2, 241, 128, 4, 225, 256, 8, 193, 255, 16, 129, 253, 32, 1, 249, 64, 2, 241, 128, 4, 225, 256, 8, 193, 255, 16, 129, 253, 32, 1, 249, 64, 2, 241, 128, 4, 225, 256, 8, 193, 255, 16, 129, 253, 32, 1, 249, 64, 2, 241, 128, 4, 225, 256, 8, 193, 255, 16, 129, 253, 32, 1, 249, 64, 2, 241, 128, 4, 225, 256, 8, 193, 255, 16, 129, 253, 32, 1, 249, 64, 2, 241, 128, 4, 225, 256, 8, 193, 255, 16, 129, 253, 32, 1, 249, 64, 2, 241, 128, 4, 225, 256, 8, 193, 255, 16, 129, 253, 32, 1, 249, 64, 2, 241, 128, 4, 225, 256, 8, 193, 255, 16, 129, 253, 32, 1],
-[1, 250, 49, 171, 88, 155, 200, 142, 34, 19, 124, 160, 165, 130, 118, 202, 128, 132, 104, 43, 213, 51, 157, 186, 240, 119, 195, 177, 46, 192, 198, 156, 193, 191, 205, 107, 22, 103, 50, 164, 137, 69, 31, 40, 234, 161, 158, 179, 32, 33, 26, 75, 246, 77, 232, 175, 60, 94, 113, 237, 140, 48, 178, 39, 241, 112, 244, 91, 134, 90, 141, 41, 227, 210, 72, 10, 187, 233, 168, 109, 8, 201, 135, 83, 190, 212, 58, 108, 15, 152, 221, 252, 35, 12, 173, 74, 253, 28, 61, 87, 162, 151, 228, 203, 121, 181, 18, 131, 111, 251, 42, 220, 2, 243, 98, 85, 176, 53, 143, 27, 68, 38, 248, 63, 73, 3, 236, 147, 256, 7, 208, 86, 169, 102, 57, 115, 223, 238, 133, 97, 92, 127, 139, 55, 129, 125, 153, 214, 44, 206, 100, 71, 17, 138, 62, 80, 211, 65, 59, 101, 64, 66, 52, 150, 235, 154, 207, 93, 120, 188, 226, 217, 23, 96, 99, 78, 225, 224, 231, 182, 11, 180, 25, 82, 197, 163, 144, 20, 117, 209, 79, 218, 16, 145, 13, 166, 123, 167, 116, 216, 30, 47, 185, 247, 70, 24, 89, 148, 249, 56, 122, 174, 67, 45, 199, 149, 242, 105, 36, 5, 222, 245, 84, 183, 4, 229, 196, 170, 95, 106, 29, 54, 136, 76, 239, 126, 146, 6, 215, 37, 255, 14, 159, 172, 81, 204, 114, 230, 189, 219, 9, 194, 184, 254, 21, 110, 1],
-[1, 251, 36, 41, 11, 191, 139, 194, 121, 45, 244, 78, 46, 238, 114, 87, 249, 48, 226, 186, 169, 14, 173, 247, 60, 154, 104, 147, 146, 152, 116, 75, 64, 130, 248, 54, 190, 145, 158, 80, 34, 53, 196, 109, 117, 69, 100, 171, 2, 245, 72, 82, 22, 125, 21, 131, 242, 90, 231, 156, 92, 219, 228, 174, 241, 96, 195, 115, 81, 28, 89, 237, 120, 51, 208, 37, 35, 47, 232, 150, 128, 3, 239, 108, 123, 33, 59, 160, 68, 106, 135, 218, 234, 138, 200, 85, 4, 233, 144, 164, 44, 250, 42, 5, 227, 180, 205, 55, 184, 181, 199, 91, 225, 192, 133, 230, 162, 56, 178, 217, 240, 102, 159, 74, 70, 94, 207, 43, 256, 6, 221, 216, 246, 66, 118, 63, 136, 212, 13, 179, 211, 19, 143, 170, 8, 209, 31, 71, 88, 243, 84, 10, 197, 103, 153, 110, 111, 105, 141, 182, 193, 127, 9, 203, 67, 112, 99, 177, 223, 204, 61, 148, 140, 188, 157, 86, 255, 12, 185, 175, 235, 132, 236, 126, 15, 167, 26, 101, 165, 38, 29, 83, 16, 161, 62, 142, 176, 229, 168, 20, 137, 206, 49, 220, 222, 210, 25, 107, 129, 254, 18, 149, 134, 224, 198, 97, 189, 151, 122, 39, 23, 119, 57, 172, 253, 24, 113, 93, 213, 7, 215, 252, 30, 77, 52, 202, 73, 76, 58, 166, 32, 65, 124, 27, 95, 201, 79, 40, 17, 155, 98, 183, 187, 163, 50, 214, 1],
-[1, 252, 25, 132, 111, 216, 205, 3, 242, 75, 139, 76, 134, 101, 9, 212, 225, 160, 228, 145, 46, 27, 122, 161, 223, 170, 178, 138, 81, 109, 226, 155, 253, 20, 157, 243, 70, 164, 208, 245, 60, 214, 215, 210, 235, 110, 221, 180, 128, 131, 116, 191, 73, 149, 26, 127, 136, 91, 59, 219, 190, 78, 124, 151, 16, 177, 143, 56, 234, 115, 196, 48, 17, 172, 168, 188, 88, 74, 144, 51, 2, 247, 50, 7, 222, 175, 153, 6, 227, 150, 21, 152, 11, 202, 18, 167, 193, 63, 199, 33, 92, 54, 244, 65, 189, 83, 99, 19, 162, 218, 195, 53, 249, 40, 57, 229, 140, 71, 159, 233, 120, 171, 173, 163, 213, 220, 185, 103, 256, 5, 232, 125, 146, 41, 52, 254, 15, 182, 118, 181, 123, 156, 248, 45, 32, 97, 29, 112, 211, 230, 135, 96, 34, 87, 79, 119, 176, 148, 31, 102, 4, 237, 100, 14, 187, 93, 49, 12, 197, 43, 42, 47, 22, 147, 36, 77, 129, 126, 141, 66, 184, 108, 231, 130, 121, 166, 198, 38, 67, 179, 133, 106, 241, 80, 114, 201, 23, 142, 61, 209, 240, 85, 89, 69, 169, 183, 113, 206, 255, 10, 207, 250, 35, 82, 104, 251, 30, 107, 236, 105, 246, 55, 239, 90, 64, 194, 58, 224, 165, 203, 13, 192, 68, 174, 158, 238, 95, 39, 62, 204, 8, 217, 200, 28, 117, 186, 98, 24, 137, 86, 84, 94, 44, 37, 72, 154, 1],
-[1, 253, 16, 193, 256, 4, 241, 64, 1, 253, 16, 193, 256, 4, 241, 64, 1, 253, 16, 193, 256, 4, 241, 64, 1, 253, 16, 193, 256, 4, 241, 64, 1, 253, 16, 193, 256, 4, 241, 64, 1, 253, 16, 193, 256, 4, 241, 64, 1, 253, 16, 193, 256, 4, 241, 64, 1, 253, 16, 193, 256, 4, 241, 64, 1, 253, 16, 193, 256, 4, 241, 64, 1, 253, 16, 193, 256, 4, 241, 64, 1, 253, 16, 193, 256, 4, 241, 64, 1, 253, 16, 193, 256, 4, 241, 64, 1, 253, 16, 193, 256, 4, 241, 64, 1, 253, 16, 193, 256, 4, 241, 64, 1, 253, 16, 193, 256, 4, 241, 64, 1, 253, 16, 193, 256, 4, 241, 64, 1, 253, 16, 193, 256, 4, 241, 64, 1, 253, 16, 193, 256, 4, 241, 64, 1, 253, 16, 193, 256, 4, 241, 64, 1, 253, 16, 193, 256, 4, 241, 64, 1, 253, 16, 193, 256, 4, 241, 64, 1, 253, 16, 193, 256, 4, 241, 64, 1, 253, 16, 193, 256, 4, 241, 64, 1, 253, 16, 193, 256, 4, 241, 64, 1, 253, 16, 193, 256, 4, 241, 64, 1, 253, 16, 193, 256, 4, 241, 64, 1, 253, 16, 193, 256, 4, 241, 64, 1, 253, 16, 193, 256, 4, 241, 64, 1, 253, 16, 193, 256, 4, 241, 64, 1, 253, 16, 193, 256, 4, 241, 64, 1, 253, 16, 193, 256, 4, 241, 64, 1, 253, 16, 193, 256, 4, 241, 64, 1],
-[1, 254, 9, 230, 81, 14, 215, 126, 136, 106, 196, 183, 222, 105, 199, 174, 249, 24, 185, 216, 123, 145, 79, 20, 197, 180, 231, 78, 23, 188, 207, 150, 64, 65, 62, 71, 44, 125, 139, 97, 223, 102, 208, 147, 73, 38, 143, 85, 2, 251, 18, 203, 162, 28, 173, 252, 15, 212, 135, 109, 187, 210, 141, 91, 241, 48, 113, 175, 246, 33, 158, 40, 137, 103, 205, 156, 46, 119, 157, 43, 128, 130, 124, 142, 88, 250, 21, 194, 189, 204, 159, 37, 146, 76, 29, 170, 4, 245, 36, 149, 67, 56, 89, 247, 30, 167, 13, 218, 117, 163, 25, 182, 225, 96, 226, 93, 235, 66, 59, 80, 17, 206, 153, 55, 92, 238, 57, 86, 256, 3, 248, 27, 176, 243, 42, 131, 121, 151, 61, 74, 35, 152, 58, 83, 8, 233, 72, 41, 134, 112, 178, 237, 60, 77, 26, 179, 234, 69, 50, 107, 193, 192, 195, 186, 213, 132, 118, 160, 34, 155, 49, 110, 184, 219, 114, 172, 255, 6, 239, 54, 95, 229, 84, 5, 242, 45, 122, 148, 70, 47, 116, 166, 16, 209, 144, 82, 11, 224, 99, 217, 120, 154, 52, 101, 211, 138, 100, 214, 129, 127, 133, 115, 169, 7, 236, 63, 68, 53, 98, 220, 111, 181, 228, 87, 253, 12, 221, 108, 190, 201, 168, 10, 227, 90, 244, 39, 140, 94, 232, 75, 32, 161, 31, 164, 22, 191, 198, 177, 240, 51, 104, 202, 165, 19, 200, 171, 1],
-[1, 255, 4, 249, 16, 225, 64, 129, 256, 2, 253, 8, 241, 32, 193, 128, 1, 255, 4, 249, 16, 225, 64, 129, 256, 2, 253, 8, 241, 32, 193, 128, 1, 255, 4, 249, 16, 225, 64, 129, 256, 2, 253, 8, 241, 32, 193, 128, 1, 255, 4, 249, 16, 225, 64, 129, 256, 2, 253, 8, 241, 32, 193, 128, 1, 255, 4, 249, 16, 225, 64, 129, 256, 2, 253, 8, 241, 32, 193, 128, 1, 255, 4, 249, 16, 225, 64, 129, 256, 2, 253, 8, 241, 32, 193, 128, 1, 255, 4, 249, 16, 225, 64, 129, 256, 2, 253, 8, 241, 32, 193, 128, 1, 255, 4, 249, 16, 225, 64, 129, 256, 2, 253, 8, 241, 32, 193, 128, 1, 255, 4, 249, 16, 225, 64, 129, 256, 2, 253, 8, 241, 32, 193, 128, 1, 255, 4, 249, 16, 225, 64, 129, 256, 2, 253, 8, 241, 32, 193, 128, 1, 255, 4, 249, 16, 225, 64, 129, 256, 2, 253, 8, 241, 32, 193, 128, 1, 255, 4, 249, 16, 225, 64, 129, 256, 2, 253, 8, 241, 32, 193, 128, 1, 255, 4, 249, 16, 225, 64, 129, 256, 2, 253, 8, 241, 32, 193, 128, 1, 255, 4, 249, 16, 225, 64, 129, 256, 2, 253, 8, 241, 32, 193, 128, 1, 255, 4, 249, 16, 225, 64, 129, 256, 2, 253, 8, 241, 32, 193, 128, 1, 255, 4, 249, 16, 225, 64, 129, 256, 2, 253, 8, 241, 32, 193, 128, 1],
-[1, 256, 1, 256, 1, 256, 1, 256, 1, 256, 1, 256, 1, 256, 1, 256, 1, 256, 1, 256, 1, 256, 1, 256, 1, 256, 1, 256, 1, 256, 1, 256, 1, 256, 1, 256, 1, 256, 1, 256, 1, 256, 1, 256, 1, 256, 1, 256, 1, 256, 1, 256, 1, 256, 1, 256, 1, 256, 1, 256, 1, 256, 1, 256, 1, 256, 1, 256, 1, 256, 1, 256, 1, 256, 1, 256, 1, 256, 1, 256, 1, 256, 1, 256, 1, 256, 1, 256, 1, 256, 1, 256, 1, 256, 1, 256, 1, 256, 1, 256, 1, 256, 1, 256, 1, 256, 1, 256, 1, 256, 1, 256, 1, 256, 1, 256, 1, 256, 1, 256, 1, 256, 1, 256, 1, 256, 1, 256, 1, 256, 1, 256, 1, 256, 1, 256, 1, 256, 1, 256, 1, 256, 1, 256, 1, 256, 1, 256, 1, 256, 1, 256, 1, 256, 1, 256, 1, 256, 1, 256, 1, 256, 1, 256, 1, 256, 1, 256, 1, 256, 1, 256, 1, 256, 1, 256, 1, 256, 1, 256, 1, 256, 1, 256, 1, 256, 1, 256, 1, 256, 1, 256, 1, 256, 1, 256, 1, 256, 1, 256, 1, 256, 1, 256, 1, 256, 1, 256, 1, 256, 1, 256, 1, 256, 1, 256, 1, 256, 1, 256, 1, 256, 1, 256, 1, 256, 1, 256, 1, 256, 1, 256, 1, 256, 1, 256, 1, 256, 1, 256, 1, 256, 1, 256, 1, 256, 1, 256, 1, 256, 1, 256, 1, 256, 1, 256, 1],
+    [
+        1, 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, 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, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
+        1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
+        1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
+        1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
+        1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
+        1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
+        1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
+        1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
+        1, 1, 1, 1, 1, 1, 1, 1, 1,
+    ],
+    [
+        1, 2, 4, 8, 16, 32, 64, 128, 256, 255, 253, 249, 241, 225, 193, 129, 1, 2, 4, 8, 16, 32, 64,
+        128, 256, 255, 253, 249, 241, 225, 193, 129, 1, 2, 4, 8, 16, 32, 64, 128, 256, 255, 253,
+        249, 241, 225, 193, 129, 1, 2, 4, 8, 16, 32, 64, 128, 256, 255, 253, 249, 241, 225, 193,
+        129, 1, 2, 4, 8, 16, 32, 64, 128, 256, 255, 253, 249, 241, 225, 193, 129, 1, 2, 4, 8, 16,
+        32, 64, 128, 256, 255, 253, 249, 241, 225, 193, 129, 1, 2, 4, 8, 16, 32, 64, 128, 256, 255,
+        253, 249, 241, 225, 193, 129, 1, 2, 4, 8, 16, 32, 64, 128, 256, 255, 253, 249, 241, 225,
+        193, 129, 1, 2, 4, 8, 16, 32, 64, 128, 256, 255, 253, 249, 241, 225, 193, 129, 1, 2, 4, 8,
+        16, 32, 64, 128, 256, 255, 253, 249, 241, 225, 193, 129, 1, 2, 4, 8, 16, 32, 64, 128, 256,
+        255, 253, 249, 241, 225, 193, 129, 1, 2, 4, 8, 16, 32, 64, 128, 256, 255, 253, 249, 241,
+        225, 193, 129, 1, 2, 4, 8, 16, 32, 64, 128, 256, 255, 253, 249, 241, 225, 193, 129, 1, 2, 4,
+        8, 16, 32, 64, 128, 256, 255, 253, 249, 241, 225, 193, 129, 1, 2, 4, 8, 16, 32, 64, 128,
+        256, 255, 253, 249, 241, 225, 193, 129, 1, 2, 4, 8, 16, 32, 64, 128, 256, 255, 253, 249,
+        241, 225, 193, 129, 1,
+    ],
+    [
+        1, 3, 9, 27, 81, 243, 215, 131, 136, 151, 196, 74, 222, 152, 199, 83, 249, 233, 185, 41,
+        123, 112, 79, 237, 197, 77, 231, 179, 23, 69, 207, 107, 64, 192, 62, 186, 44, 132, 139, 160,
+        223, 155, 208, 110, 73, 219, 143, 172, 2, 6, 18, 54, 162, 229, 173, 5, 15, 45, 135, 148,
+        187, 47, 141, 166, 241, 209, 113, 82, 246, 224, 158, 217, 137, 154, 205, 101, 46, 138, 157,
+        214, 128, 127, 124, 115, 88, 7, 21, 63, 189, 53, 159, 220, 146, 181, 29, 87, 4, 12, 36, 108,
+        67, 201, 89, 10, 30, 90, 13, 39, 117, 94, 25, 75, 225, 161, 226, 164, 235, 191, 59, 177, 17,
+        51, 153, 202, 92, 19, 57, 171, 256, 254, 248, 230, 176, 14, 42, 126, 121, 106, 61, 183, 35,
+        105, 58, 174, 8, 24, 72, 216, 134, 145, 178, 20, 60, 180, 26, 78, 234, 188, 50, 150, 193,
+        65, 195, 71, 213, 125, 118, 97, 34, 102, 49, 147, 184, 38, 114, 85, 255, 251, 239, 203, 95,
+        28, 84, 252, 242, 212, 122, 109, 70, 210, 116, 91, 16, 48, 144, 175, 11, 33, 99, 40, 120,
+        103, 52, 156, 211, 119, 100, 43, 129, 130, 133, 142, 169, 250, 236, 194, 68, 204, 98, 37,
+        111, 76, 228, 170, 253, 245, 221, 149, 190, 56, 168, 247, 227, 167, 244, 218, 140, 163, 232,
+        182, 32, 96, 31, 93, 22, 66, 198, 80, 240, 206, 104, 55, 165, 238, 200, 86, 1,
+    ],
+    [
+        1, 4, 16, 64, 256, 253, 241, 193, 1, 4, 16, 64, 256, 253, 241, 193, 1, 4, 16, 64, 256, 253,
+        241, 193, 1, 4, 16, 64, 256, 253, 241, 193, 1, 4, 16, 64, 256, 253, 241, 193, 1, 4, 16, 64,
+        256, 253, 241, 193, 1, 4, 16, 64, 256, 253, 241, 193, 1, 4, 16, 64, 256, 253, 241, 193, 1,
+        4, 16, 64, 256, 253, 241, 193, 1, 4, 16, 64, 256, 253, 241, 193, 1, 4, 16, 64, 256, 253,
+        241, 193, 1, 4, 16, 64, 256, 253, 241, 193, 1, 4, 16, 64, 256, 253, 241, 193, 1, 4, 16, 64,
+        256, 253, 241, 193, 1, 4, 16, 64, 256, 253, 241, 193, 1, 4, 16, 64, 256, 253, 241, 193, 1,
+        4, 16, 64, 256, 253, 241, 193, 1, 4, 16, 64, 256, 253, 241, 193, 1, 4, 16, 64, 256, 253,
+        241, 193, 1, 4, 16, 64, 256, 253, 241, 193, 1, 4, 16, 64, 256, 253, 241, 193, 1, 4, 16, 64,
+        256, 253, 241, 193, 1, 4, 16, 64, 256, 253, 241, 193, 1, 4, 16, 64, 256, 253, 241, 193, 1,
+        4, 16, 64, 256, 253, 241, 193, 1, 4, 16, 64, 256, 253, 241, 193, 1, 4, 16, 64, 256, 253,
+        241, 193, 1, 4, 16, 64, 256, 253, 241, 193, 1, 4, 16, 64, 256, 253, 241, 193, 1, 4, 16, 64,
+        256, 253, 241, 193, 1, 4, 16, 64, 256, 253, 241, 193, 1, 4, 16, 64, 256, 253, 241, 193, 1,
+    ],
+    [
+        1, 5, 25, 125, 111, 41, 205, 254, 242, 182, 139, 181, 134, 156, 9, 45, 225, 97, 228, 112,
+        46, 230, 122, 96, 223, 87, 178, 119, 81, 148, 226, 102, 253, 237, 157, 14, 70, 93, 208, 12,
+        60, 43, 215, 47, 235, 147, 221, 77, 128, 126, 116, 66, 73, 108, 26, 130, 136, 166, 59, 38,
+        190, 179, 124, 106, 16, 80, 143, 201, 234, 142, 196, 209, 17, 85, 168, 69, 88, 183, 144,
+        206, 2, 10, 50, 250, 222, 82, 153, 251, 227, 107, 21, 105, 11, 55, 18, 90, 193, 194, 199,
+        224, 92, 203, 244, 192, 189, 174, 99, 238, 162, 39, 195, 204, 249, 217, 57, 28, 140, 186,
+        159, 24, 120, 86, 173, 94, 213, 37, 185, 154, 256, 252, 232, 132, 146, 216, 52, 3, 15, 75,
+        118, 76, 123, 101, 248, 212, 32, 160, 29, 145, 211, 27, 135, 161, 34, 170, 79, 138, 176,
+        109, 31, 155, 4, 20, 100, 243, 187, 164, 49, 245, 197, 214, 42, 210, 22, 110, 36, 180, 129,
+        131, 141, 191, 184, 149, 231, 127, 121, 91, 198, 219, 67, 78, 133, 151, 241, 177, 114, 56,
+        23, 115, 61, 48, 240, 172, 89, 188, 169, 74, 113, 51, 255, 247, 207, 7, 35, 175, 104, 6, 30,
+        150, 236, 152, 246, 202, 239, 167, 64, 63, 58, 33, 165, 54, 13, 65, 68, 83, 158, 19, 95,
+        218, 62, 53, 8, 40, 200, 229, 117, 71, 98, 233, 137, 171, 84, 163, 44, 220, 72, 103, 1,
+    ],
+    [
+        1, 6, 36, 216, 11, 66, 139, 63, 121, 212, 244, 179, 46, 19, 114, 170, 249, 209, 226, 71,
+        169, 243, 173, 10, 60, 103, 104, 110, 146, 105, 116, 182, 64, 127, 248, 203, 190, 112, 158,
+        177, 34, 204, 196, 148, 117, 188, 100, 86, 2, 12, 72, 175, 22, 132, 21, 126, 242, 167, 231,
+        101, 92, 38, 228, 83, 241, 161, 195, 142, 81, 229, 89, 20, 120, 206, 208, 220, 35, 210, 232,
+        107, 128, 254, 239, 149, 123, 224, 59, 97, 68, 151, 135, 39, 234, 119, 200, 172, 4, 24, 144,
+        93, 44, 7, 42, 252, 227, 77, 205, 202, 184, 76, 199, 166, 225, 65, 133, 27, 162, 201, 178,
+        40, 240, 155, 159, 183, 70, 163, 207, 214, 256, 251, 221, 41, 246, 191, 118, 194, 136, 45,
+        13, 78, 211, 238, 143, 87, 8, 48, 31, 186, 88, 14, 84, 247, 197, 154, 153, 147, 111, 152,
+        141, 75, 193, 130, 9, 54, 67, 145, 99, 80, 223, 53, 61, 109, 140, 69, 157, 171, 255, 245,
+        185, 82, 235, 125, 236, 131, 15, 90, 26, 156, 165, 219, 29, 174, 16, 96, 62, 115, 176, 28,
+        168, 237, 137, 51, 49, 37, 222, 47, 25, 150, 129, 3, 18, 108, 134, 33, 198, 160, 189, 106,
+        122, 218, 23, 138, 57, 85, 253, 233, 113, 164, 213, 250, 215, 5, 30, 180, 52, 55, 73, 181,
+        58, 91, 32, 192, 124, 230, 95, 56, 79, 217, 17, 102, 98, 74, 187, 94, 50, 43, 1,
+    ],
+    [
+        1, 7, 49, 86, 88, 102, 200, 115, 34, 238, 124, 97, 165, 127, 118, 55, 128, 125, 104, 214,
+        213, 206, 157, 71, 240, 138, 195, 80, 46, 65, 198, 101, 193, 66, 205, 150, 22, 154, 50, 93,
+        137, 188, 31, 217, 234, 96, 158, 78, 32, 224, 26, 182, 246, 180, 232, 82, 60, 163, 113, 20,
+        140, 209, 178, 218, 241, 145, 244, 166, 134, 167, 141, 216, 227, 47, 72, 247, 187, 24, 168,
+        148, 8, 56, 135, 174, 190, 45, 58, 149, 15, 105, 221, 5, 35, 245, 173, 183, 253, 229, 61,
+        170, 162, 106, 228, 54, 121, 76, 18, 126, 111, 6, 42, 37, 2, 14, 98, 172, 176, 204, 143,
+        230, 68, 219, 248, 194, 73, 254, 236, 110, 256, 250, 208, 171, 169, 155, 57, 142, 223, 19,
+        133, 160, 92, 130, 139, 202, 129, 132, 153, 43, 44, 51, 100, 186, 17, 119, 62, 177, 211,
+        192, 59, 156, 64, 191, 52, 107, 235, 103, 207, 164, 120, 69, 226, 40, 23, 161, 99, 179, 225,
+        33, 231, 75, 11, 77, 25, 175, 197, 94, 144, 237, 117, 48, 79, 39, 16, 112, 13, 91, 123, 90,
+        116, 41, 30, 210, 185, 10, 70, 233, 89, 109, 249, 201, 122, 83, 67, 212, 199, 108, 242, 152,
+        36, 252, 222, 12, 84, 74, 4, 28, 196, 87, 95, 151, 29, 203, 136, 181, 239, 131, 146, 251,
+        215, 220, 255, 243, 159, 85, 81, 53, 114, 27, 189, 38, 9, 63, 184, 3, 21, 147, 1,
+    ],
+    [
+        1, 8, 64, 255, 241, 129, 4, 32, 256, 249, 193, 2, 16, 128, 253, 225, 1, 8, 64, 255, 241,
+        129, 4, 32, 256, 249, 193, 2, 16, 128, 253, 225, 1, 8, 64, 255, 241, 129, 4, 32, 256, 249,
+        193, 2, 16, 128, 253, 225, 1, 8, 64, 255, 241, 129, 4, 32, 256, 249, 193, 2, 16, 128, 253,
+        225, 1, 8, 64, 255, 241, 129, 4, 32, 256, 249, 193, 2, 16, 128, 253, 225, 1, 8, 64, 255,
+        241, 129, 4, 32, 256, 249, 193, 2, 16, 128, 253, 225, 1, 8, 64, 255, 241, 129, 4, 32, 256,
+        249, 193, 2, 16, 128, 253, 225, 1, 8, 64, 255, 241, 129, 4, 32, 256, 249, 193, 2, 16, 128,
+        253, 225, 1, 8, 64, 255, 241, 129, 4, 32, 256, 249, 193, 2, 16, 128, 253, 225, 1, 8, 64,
+        255, 241, 129, 4, 32, 256, 249, 193, 2, 16, 128, 253, 225, 1, 8, 64, 255, 241, 129, 4, 32,
+        256, 249, 193, 2, 16, 128, 253, 225, 1, 8, 64, 255, 241, 129, 4, 32, 256, 249, 193, 2, 16,
+        128, 253, 225, 1, 8, 64, 255, 241, 129, 4, 32, 256, 249, 193, 2, 16, 128, 253, 225, 1, 8,
+        64, 255, 241, 129, 4, 32, 256, 249, 193, 2, 16, 128, 253, 225, 1, 8, 64, 255, 241, 129, 4,
+        32, 256, 249, 193, 2, 16, 128, 253, 225, 1, 8, 64, 255, 241, 129, 4, 32, 256, 249, 193, 2,
+        16, 128, 253, 225, 1,
+    ],
+    [
+        1, 9, 81, 215, 136, 196, 222, 199, 249, 185, 123, 79, 197, 231, 23, 207, 64, 62, 44, 139,
+        223, 208, 73, 143, 2, 18, 162, 173, 15, 135, 187, 141, 241, 113, 246, 158, 137, 205, 46,
+        157, 128, 124, 88, 21, 189, 159, 146, 29, 4, 36, 67, 89, 30, 13, 117, 25, 225, 226, 235, 59,
+        17, 153, 92, 57, 256, 248, 176, 42, 121, 61, 35, 58, 8, 72, 134, 178, 60, 26, 234, 50, 193,
+        195, 213, 118, 34, 49, 184, 114, 255, 239, 95, 84, 242, 122, 70, 116, 16, 144, 11, 99, 120,
+        52, 211, 100, 129, 133, 169, 236, 68, 98, 111, 228, 253, 221, 190, 168, 227, 244, 140, 232,
+        32, 31, 22, 198, 240, 104, 165, 200, 1, 9, 81, 215, 136, 196, 222, 199, 249, 185, 123, 79,
+        197, 231, 23, 207, 64, 62, 44, 139, 223, 208, 73, 143, 2, 18, 162, 173, 15, 135, 187, 141,
+        241, 113, 246, 158, 137, 205, 46, 157, 128, 124, 88, 21, 189, 159, 146, 29, 4, 36, 67, 89,
+        30, 13, 117, 25, 225, 226, 235, 59, 17, 153, 92, 57, 256, 248, 176, 42, 121, 61, 35, 58, 8,
+        72, 134, 178, 60, 26, 234, 50, 193, 195, 213, 118, 34, 49, 184, 114, 255, 239, 95, 84, 242,
+        122, 70, 116, 16, 144, 11, 99, 120, 52, 211, 100, 129, 133, 169, 236, 68, 98, 111, 228, 253,
+        221, 190, 168, 227, 244, 140, 232, 32, 31, 22, 198, 240, 104, 165, 200, 1,
+    ],
+    [
+        1, 10, 100, 229, 234, 27, 13, 130, 15, 150, 215, 94, 169, 148, 195, 151, 225, 194, 141, 125,
+        222, 164, 98, 209, 34, 83, 59, 76, 246, 147, 185, 51, 253, 217, 114, 112, 92, 149, 205, 251,
+        197, 171, 168, 138, 95, 179, 248, 167, 128, 252, 207, 14, 140, 115, 122, 192, 121, 182, 21,
+        210, 44, 183, 31, 53, 16, 160, 58, 66, 146, 175, 208, 24, 240, 87, 99, 219, 134, 55, 36,
+        103, 2, 20, 200, 201, 211, 54, 26, 3, 30, 43, 173, 188, 81, 39, 133, 45, 193, 131, 25, 250,
+        187, 71, 196, 161, 68, 166, 118, 152, 235, 37, 113, 102, 249, 177, 228, 224, 184, 41, 153,
+        245, 137, 85, 79, 19, 190, 101, 239, 77, 256, 247, 157, 28, 23, 230, 244, 127, 242, 107, 42,
+        163, 88, 109, 62, 106, 32, 63, 116, 132, 35, 93, 159, 48, 223, 174, 198, 181, 11, 110, 72,
+        206, 4, 40, 143, 145, 165, 108, 52, 6, 60, 86, 89, 119, 162, 78, 9, 90, 129, 5, 50, 243,
+        117, 142, 135, 65, 136, 75, 236, 47, 213, 74, 226, 204, 241, 97, 199, 191, 111, 82, 49, 233,
+        17, 170, 158, 38, 123, 202, 221, 154, 255, 237, 57, 56, 46, 203, 231, 254, 227, 214, 84, 69,
+        176, 218, 124, 212, 64, 126, 232, 7, 70, 186, 61, 96, 189, 91, 139, 105, 22, 220, 144, 155,
+        8, 80, 29, 33, 73, 216, 104, 12, 120, 172, 178, 238, 67, 156, 18, 180, 1,
+    ],
+    [
+        1, 11, 121, 46, 249, 169, 60, 146, 64, 190, 34, 117, 2, 22, 242, 92, 241, 81, 120, 35, 128,
+        123, 68, 234, 4, 44, 227, 184, 225, 162, 240, 70, 256, 246, 136, 211, 8, 88, 197, 111, 193,
+        67, 223, 140, 255, 235, 15, 165, 16, 176, 137, 222, 129, 134, 189, 23, 253, 213, 30, 73, 32,
+        95, 17, 187, 1, 11, 121, 46, 249, 169, 60, 146, 64, 190, 34, 117, 2, 22, 242, 92, 241, 81,
+        120, 35, 128, 123, 68, 234, 4, 44, 227, 184, 225, 162, 240, 70, 256, 246, 136, 211, 8, 88,
+        197, 111, 193, 67, 223, 140, 255, 235, 15, 165, 16, 176, 137, 222, 129, 134, 189, 23, 253,
+        213, 30, 73, 32, 95, 17, 187, 1, 11, 121, 46, 249, 169, 60, 146, 64, 190, 34, 117, 2, 22,
+        242, 92, 241, 81, 120, 35, 128, 123, 68, 234, 4, 44, 227, 184, 225, 162, 240, 70, 256, 246,
+        136, 211, 8, 88, 197, 111, 193, 67, 223, 140, 255, 235, 15, 165, 16, 176, 137, 222, 129,
+        134, 189, 23, 253, 213, 30, 73, 32, 95, 17, 187, 1, 11, 121, 46, 249, 169, 60, 146, 64, 190,
+        34, 117, 2, 22, 242, 92, 241, 81, 120, 35, 128, 123, 68, 234, 4, 44, 227, 184, 225, 162,
+        240, 70, 256, 246, 136, 211, 8, 88, 197, 111, 193, 67, 223, 140, 255, 235, 15, 165, 16, 176,
+        137, 222, 129, 134, 189, 23, 253, 213, 30, 73, 32, 95, 17, 187, 1,
+    ],
+    [
+        1, 12, 144, 186, 176, 56, 158, 97, 136, 90, 52, 110, 35, 163, 157, 85, 249, 161, 133, 54,
+        134, 66, 21, 252, 197, 51, 98, 148, 234, 238, 29, 91, 64, 254, 221, 82, 213, 243, 89, 40,
+        223, 106, 244, 101, 184, 152, 25, 43, 2, 24, 31, 115, 95, 112, 59, 194, 15, 180, 104, 220,
+        70, 69, 57, 170, 241, 65, 9, 108, 11, 132, 42, 247, 137, 102, 196, 39, 211, 219, 58, 182,
+        128, 251, 185, 164, 169, 229, 178, 80, 189, 212, 231, 202, 111, 47, 50, 86, 4, 48, 62, 230,
+        190, 224, 118, 131, 30, 103, 208, 183, 140, 138, 114, 83, 225, 130, 18, 216, 22, 7, 84, 237,
+        17, 204, 135, 78, 165, 181, 116, 107, 256, 245, 113, 71, 81, 201, 99, 160, 121, 167, 205,
+        147, 222, 94, 100, 172, 8, 96, 124, 203, 123, 191, 236, 5, 60, 206, 159, 109, 23, 19, 228,
+        166, 193, 3, 36, 175, 44, 14, 168, 217, 34, 151, 13, 156, 73, 105, 232, 214, 255, 233, 226,
+        142, 162, 145, 198, 63, 242, 77, 153, 37, 187, 188, 200, 87, 16, 192, 248, 149, 246, 125,
+        215, 10, 120, 155, 61, 218, 46, 38, 199, 75, 129, 6, 72, 93, 88, 28, 79, 177, 68, 45, 26,
+        55, 146, 210, 207, 171, 253, 209, 195, 27, 67, 33, 139, 126, 227, 154, 49, 74, 117, 119,
+        143, 174, 32, 127, 239, 41, 235, 250, 173, 20, 240, 53, 122, 179, 92, 76, 141, 150, 1,
+    ],
+    [
+        1, 13, 169, 141, 34, 185, 92, 168, 128, 122, 44, 58, 240, 36, 211, 173, 193, 196, 235, 228,
+        137, 239, 23, 42, 32, 159, 11, 143, 60, 9, 117, 236, 241, 49, 123, 57, 227, 124, 70, 139, 8,
+        104, 67, 100, 15, 195, 222, 59, 253, 205, 95, 207, 121, 31, 146, 99, 2, 26, 81, 25, 68, 113,
+        184, 79, 256, 244, 88, 116, 223, 72, 165, 89, 129, 135, 213, 199, 17, 221, 46, 84, 64, 61,
+        22, 29, 120, 18, 234, 215, 225, 98, 246, 114, 197, 248, 140, 21, 16, 208, 134, 200, 30, 133,
+        187, 118, 249, 153, 190, 157, 242, 62, 35, 198, 4, 52, 162, 50, 136, 226, 111, 158, 255,
+        231, 176, 232, 189, 144, 73, 178, 1, 13, 169, 141, 34, 185, 92, 168, 128, 122, 44, 58, 240,
+        36, 211, 173, 193, 196, 235, 228, 137, 239, 23, 42, 32, 159, 11, 143, 60, 9, 117, 236, 241,
+        49, 123, 57, 227, 124, 70, 139, 8, 104, 67, 100, 15, 195, 222, 59, 253, 205, 95, 207, 121,
+        31, 146, 99, 2, 26, 81, 25, 68, 113, 184, 79, 256, 244, 88, 116, 223, 72, 165, 89, 129, 135,
+        213, 199, 17, 221, 46, 84, 64, 61, 22, 29, 120, 18, 234, 215, 225, 98, 246, 114, 197, 248,
+        140, 21, 16, 208, 134, 200, 30, 133, 187, 118, 249, 153, 190, 157, 242, 62, 35, 198, 4, 52,
+        162, 50, 136, 226, 111, 158, 255, 231, 176, 232, 189, 144, 73, 178, 1,
+    ],
+    [
+        1, 14, 196, 174, 123, 180, 207, 71, 223, 38, 18, 252, 187, 48, 158, 156, 128, 250, 159, 170,
+        67, 167, 25, 93, 17, 238, 248, 131, 35, 233, 178, 179, 193, 132, 49, 172, 95, 45, 116, 82,
+        120, 138, 133, 63, 111, 12, 168, 39, 32, 191, 104, 171, 81, 106, 199, 216, 197, 188, 62, 97,
+        73, 251, 173, 109, 241, 33, 205, 43, 88, 204, 29, 149, 30, 163, 226, 80, 92, 3, 42, 74, 8,
+        112, 26, 107, 213, 155, 114, 54, 242, 47, 144, 217, 211, 127, 236, 220, 253, 201, 244, 75,
+        22, 51, 200, 230, 136, 105, 185, 20, 23, 65, 139, 147, 2, 28, 135, 91, 246, 103, 157, 142,
+        189, 76, 36, 247, 117, 96, 59, 55, 256, 243, 61, 83, 134, 77, 50, 186, 34, 219, 239, 5, 70,
+        209, 99, 101, 129, 7, 98, 87, 190, 90, 232, 164, 240, 19, 9, 126, 222, 24, 79, 78, 64, 125,
+        208, 85, 162, 212, 141, 175, 137, 119, 124, 194, 146, 245, 89, 218, 225, 66, 153, 86, 176,
+        151, 58, 41, 60, 69, 195, 160, 184, 6, 84, 148, 16, 224, 52, 214, 169, 53, 228, 108, 227,
+        94, 31, 177, 165, 254, 215, 183, 249, 145, 231, 150, 44, 102, 143, 203, 15, 210, 113, 40,
+        46, 130, 21, 37, 4, 56, 13, 182, 235, 206, 57, 27, 121, 152, 72, 237, 234, 192, 118, 110,
+        255, 229, 122, 166, 11, 154, 100, 115, 68, 181, 221, 10, 140, 161, 198, 202, 1,
+    ],
+    [
+        1, 15, 225, 34, 253, 197, 128, 121, 16, 240, 2, 30, 193, 68, 249, 137, 256, 242, 32, 223, 4,
+        60, 129, 136, 241, 17, 255, 227, 64, 189, 8, 120, 1, 15, 225, 34, 253, 197, 128, 121, 16,
+        240, 2, 30, 193, 68, 249, 137, 256, 242, 32, 223, 4, 60, 129, 136, 241, 17, 255, 227, 64,
+        189, 8, 120, 1, 15, 225, 34, 253, 197, 128, 121, 16, 240, 2, 30, 193, 68, 249, 137, 256,
+        242, 32, 223, 4, 60, 129, 136, 241, 17, 255, 227, 64, 189, 8, 120, 1, 15, 225, 34, 253, 197,
+        128, 121, 16, 240, 2, 30, 193, 68, 249, 137, 256, 242, 32, 223, 4, 60, 129, 136, 241, 17,
+        255, 227, 64, 189, 8, 120, 1, 15, 225, 34, 253, 197, 128, 121, 16, 240, 2, 30, 193, 68, 249,
+        137, 256, 242, 32, 223, 4, 60, 129, 136, 241, 17, 255, 227, 64, 189, 8, 120, 1, 15, 225, 34,
+        253, 197, 128, 121, 16, 240, 2, 30, 193, 68, 249, 137, 256, 242, 32, 223, 4, 60, 129, 136,
+        241, 17, 255, 227, 64, 189, 8, 120, 1, 15, 225, 34, 253, 197, 128, 121, 16, 240, 2, 30, 193,
+        68, 249, 137, 256, 242, 32, 223, 4, 60, 129, 136, 241, 17, 255, 227, 64, 189, 8, 120, 1, 15,
+        225, 34, 253, 197, 128, 121, 16, 240, 2, 30, 193, 68, 249, 137, 256, 242, 32, 223, 4, 60,
+        129, 136, 241, 17, 255, 227, 64, 189, 8, 120, 1,
+    ],
+    [
+        1, 16, 256, 241, 1, 16, 256, 241, 1, 16, 256, 241, 1, 16, 256, 241, 1, 16, 256, 241, 1, 16,
+        256, 241, 1, 16, 256, 241, 1, 16, 256, 241, 1, 16, 256, 241, 1, 16, 256, 241, 1, 16, 256,
+        241, 1, 16, 256, 241, 1, 16, 256, 241, 1, 16, 256, 241, 1, 16, 256, 241, 1, 16, 256, 241, 1,
+        16, 256, 241, 1, 16, 256, 241, 1, 16, 256, 241, 1, 16, 256, 241, 1, 16, 256, 241, 1, 16,
+        256, 241, 1, 16, 256, 241, 1, 16, 256, 241, 1, 16, 256, 241, 1, 16, 256, 241, 1, 16, 256,
+        241, 1, 16, 256, 241, 1, 16, 256, 241, 1, 16, 256, 241, 1, 16, 256, 241, 1, 16, 256, 241, 1,
+        16, 256, 241, 1, 16, 256, 241, 1, 16, 256, 241, 1, 16, 256, 241, 1, 16, 256, 241, 1, 16,
+        256, 241, 1, 16, 256, 241, 1, 16, 256, 241, 1, 16, 256, 241, 1, 16, 256, 241, 1, 16, 256,
+        241, 1, 16, 256, 241, 1, 16, 256, 241, 1, 16, 256, 241, 1, 16, 256, 241, 1, 16, 256, 241, 1,
+        16, 256, 241, 1, 16, 256, 241, 1, 16, 256, 241, 1, 16, 256, 241, 1, 16, 256, 241, 1, 16,
+        256, 241, 1, 16, 256, 241, 1, 16, 256, 241, 1, 16, 256, 241, 1, 16, 256, 241, 1, 16, 256,
+        241, 1, 16, 256, 241, 1, 16, 256, 241, 1, 16, 256, 241, 1, 16, 256, 241, 1, 16, 256, 241, 1,
+    ],
+    [
+        1, 17, 32, 30, 253, 189, 129, 137, 16, 15, 255, 223, 193, 197, 8, 136, 256, 240, 225, 227,
+        4, 68, 128, 120, 241, 242, 2, 34, 64, 60, 249, 121, 1, 17, 32, 30, 253, 189, 129, 137, 16,
+        15, 255, 223, 193, 197, 8, 136, 256, 240, 225, 227, 4, 68, 128, 120, 241, 242, 2, 34, 64,
+        60, 249, 121, 1, 17, 32, 30, 253, 189, 129, 137, 16, 15, 255, 223, 193, 197, 8, 136, 256,
+        240, 225, 227, 4, 68, 128, 120, 241, 242, 2, 34, 64, 60, 249, 121, 1, 17, 32, 30, 253, 189,
+        129, 137, 16, 15, 255, 223, 193, 197, 8, 136, 256, 240, 225, 227, 4, 68, 128, 120, 241, 242,
+        2, 34, 64, 60, 249, 121, 1, 17, 32, 30, 253, 189, 129, 137, 16, 15, 255, 223, 193, 197, 8,
+        136, 256, 240, 225, 227, 4, 68, 128, 120, 241, 242, 2, 34, 64, 60, 249, 121, 1, 17, 32, 30,
+        253, 189, 129, 137, 16, 15, 255, 223, 193, 197, 8, 136, 256, 240, 225, 227, 4, 68, 128, 120,
+        241, 242, 2, 34, 64, 60, 249, 121, 1, 17, 32, 30, 253, 189, 129, 137, 16, 15, 255, 223, 193,
+        197, 8, 136, 256, 240, 225, 227, 4, 68, 128, 120, 241, 242, 2, 34, 64, 60, 249, 121, 1, 17,
+        32, 30, 253, 189, 129, 137, 16, 15, 255, 223, 193, 197, 8, 136, 256, 240, 225, 227, 4, 68,
+        128, 120, 241, 242, 2, 34, 64, 60, 249, 121, 1,
+    ],
+    [
+        1, 18, 67, 178, 120, 104, 73, 29, 8, 144, 22, 139, 189, 61, 70, 232, 64, 124, 176, 84, 227,
+        231, 46, 57, 255, 221, 123, 158, 17, 49, 111, 199, 241, 226, 213, 236, 136, 135, 117, 50,
+        129, 9, 162, 89, 60, 52, 165, 143, 4, 72, 11, 198, 223, 159, 35, 116, 32, 62, 88, 42, 242,
+        244, 23, 157, 256, 239, 190, 79, 137, 153, 184, 228, 249, 113, 235, 118, 68, 196, 187, 25,
+        193, 133, 81, 173, 30, 26, 211, 200, 2, 36, 134, 99, 240, 208, 146, 58, 16, 31, 44, 21, 121,
+        122, 140, 207, 128, 248, 95, 168, 197, 205, 92, 114, 253, 185, 246, 59, 34, 98, 222, 141,
+        225, 195, 169, 215, 15, 13, 234, 100, 1, 18, 67, 178, 120, 104, 73, 29, 8, 144, 22, 139,
+        189, 61, 70, 232, 64, 124, 176, 84, 227, 231, 46, 57, 255, 221, 123, 158, 17, 49, 111, 199,
+        241, 226, 213, 236, 136, 135, 117, 50, 129, 9, 162, 89, 60, 52, 165, 143, 4, 72, 11, 198,
+        223, 159, 35, 116, 32, 62, 88, 42, 242, 244, 23, 157, 256, 239, 190, 79, 137, 153, 184, 228,
+        249, 113, 235, 118, 68, 196, 187, 25, 193, 133, 81, 173, 30, 26, 211, 200, 2, 36, 134, 99,
+        240, 208, 146, 58, 16, 31, 44, 21, 121, 122, 140, 207, 128, 248, 95, 168, 197, 205, 92, 114,
+        253, 185, 246, 59, 34, 98, 222, 141, 225, 195, 169, 215, 15, 13, 234, 100, 1,
+    ],
+    [
+        1, 19, 104, 177, 22, 161, 232, 39, 227, 201, 221, 87, 111, 53, 236, 115, 129, 138, 52, 217,
+        11, 209, 116, 148, 242, 229, 239, 172, 184, 155, 118, 186, 193, 69, 26, 237, 134, 233, 58,
+        74, 121, 243, 248, 86, 92, 206, 59, 93, 225, 163, 13, 247, 67, 245, 29, 37, 189, 250, 124,
+        43, 46, 103, 158, 175, 241, 210, 135, 252, 162, 251, 143, 147, 223, 125, 62, 150, 23, 180,
+        79, 216, 249, 105, 196, 126, 81, 254, 200, 202, 240, 191, 31, 75, 140, 90, 168, 108, 253,
+        181, 98, 63, 169, 127, 100, 101, 120, 224, 144, 166, 70, 45, 84, 54, 255, 219, 49, 160, 213,
+        192, 50, 179, 60, 112, 72, 83, 35, 151, 42, 27, 256, 238, 153, 80, 235, 96, 25, 218, 30, 56,
+        36, 170, 146, 204, 21, 142, 128, 119, 205, 40, 246, 48, 141, 109, 15, 28, 18, 85, 73, 102,
+        139, 71, 64, 188, 231, 20, 123, 24, 199, 183, 136, 14, 9, 171, 165, 51, 198, 164, 32, 94,
+        244, 10, 190, 12, 228, 220, 68, 7, 133, 214, 211, 154, 99, 82, 16, 47, 122, 5, 95, 6, 114,
+        110, 34, 132, 195, 107, 234, 77, 178, 41, 8, 152, 61, 131, 176, 3, 57, 55, 17, 66, 226, 182,
+        117, 167, 89, 149, 4, 76, 159, 194, 88, 130, 157, 156, 137, 33, 113, 91, 187, 212, 173, 203,
+        2, 38, 208, 97, 44, 65, 207, 78, 197, 145, 185, 174, 222, 106, 215, 230, 1,
+    ],
+    [
+        1, 20, 143, 33, 146, 93, 61, 192, 242, 214, 168, 19, 123, 147, 113, 204, 225, 131, 50, 229,
+        211, 108, 104, 24, 223, 91, 21, 163, 176, 179, 239, 154, 253, 177, 199, 125, 187, 142, 13,
+        3, 60, 172, 99, 181, 22, 183, 62, 212, 128, 247, 57, 112, 184, 82, 98, 161, 136, 150, 173,
+        119, 67, 55, 72, 155, 16, 63, 232, 14, 23, 203, 205, 245, 17, 83, 118, 47, 169, 39, 9, 180,
+        2, 40, 29, 66, 35, 186, 122, 127, 227, 171, 79, 38, 246, 37, 226, 151, 193, 5, 100, 201,
+        165, 216, 208, 48, 189, 182, 42, 69, 95, 101, 221, 51, 249, 97, 141, 250, 117, 27, 26, 6,
+        120, 87, 198, 105, 44, 109, 124, 167, 256, 237, 114, 224, 111, 164, 196, 65, 15, 43, 89,
+        238, 134, 110, 144, 53, 32, 126, 207, 28, 46, 149, 153, 233, 34, 166, 236, 94, 81, 78, 18,
+        103, 4, 80, 58, 132, 70, 115, 244, 254, 197, 85, 158, 76, 235, 74, 195, 45, 129, 10, 200,
+        145, 73, 175, 159, 96, 121, 107, 84, 138, 190, 202, 185, 102, 241, 194, 25, 243, 234, 54,
+        52, 12, 240, 174, 139, 210, 88, 218, 248, 77, 255, 217, 228, 191, 222, 71, 135, 130, 30, 86,
+        178, 219, 11, 220, 31, 106, 64, 252, 157, 56, 92, 41, 49, 209, 68, 75, 215, 188, 162, 156,
+        36, 206, 8, 160, 116, 7, 140, 230, 231, 251, 137, 170, 59, 152, 213, 148, 133, 90, 1,
+    ],
+    [
+        1, 21, 184, 9, 189, 114, 81, 159, 255, 215, 146, 239, 136, 29, 95, 196, 4, 84, 222, 36, 242,
+        199, 67, 122, 249, 89, 70, 185, 30, 116, 123, 13, 16, 79, 117, 144, 197, 25, 11, 231, 225,
+        99, 23, 226, 120, 207, 235, 52, 64, 59, 211, 62, 17, 100, 44, 153, 129, 139, 92, 133, 223,
+        57, 169, 208, 256, 236, 73, 248, 68, 143, 176, 98, 2, 42, 111, 18, 121, 228, 162, 61, 253,
+        173, 35, 221, 15, 58, 190, 135, 8, 168, 187, 72, 227, 141, 134, 244, 241, 178, 140, 113, 60,
+        232, 246, 26, 32, 158, 234, 31, 137, 50, 22, 205, 193, 198, 46, 195, 240, 157, 213, 104,
+        128, 118, 165, 124, 34, 200, 88, 49, 1, 21, 184, 9, 189, 114, 81, 159, 255, 215, 146, 239,
+        136, 29, 95, 196, 4, 84, 222, 36, 242, 199, 67, 122, 249, 89, 70, 185, 30, 116, 123, 13, 16,
+        79, 117, 144, 197, 25, 11, 231, 225, 99, 23, 226, 120, 207, 235, 52, 64, 59, 211, 62, 17,
+        100, 44, 153, 129, 139, 92, 133, 223, 57, 169, 208, 256, 236, 73, 248, 68, 143, 176, 98, 2,
+        42, 111, 18, 121, 228, 162, 61, 253, 173, 35, 221, 15, 58, 190, 135, 8, 168, 187, 72, 227,
+        141, 134, 244, 241, 178, 140, 113, 60, 232, 246, 26, 32, 158, 234, 31, 137, 50, 22, 205,
+        193, 198, 46, 195, 240, 157, 213, 104, 128, 118, 165, 124, 34, 200, 88, 49, 1,
+    ],
+    [
+        1, 22, 227, 111, 129, 11, 242, 184, 193, 134, 121, 92, 225, 67, 189, 46, 241, 162, 223, 23,
+        249, 81, 240, 140, 253, 169, 120, 70, 255, 213, 60, 35, 256, 235, 30, 146, 128, 246, 15, 73,
+        64, 123, 136, 165, 32, 190, 68, 211, 16, 95, 34, 234, 8, 176, 17, 117, 4, 88, 137, 187, 2,
+        44, 197, 222, 1, 22, 227, 111, 129, 11, 242, 184, 193, 134, 121, 92, 225, 67, 189, 46, 241,
+        162, 223, 23, 249, 81, 240, 140, 253, 169, 120, 70, 255, 213, 60, 35, 256, 235, 30, 146,
+        128, 246, 15, 73, 64, 123, 136, 165, 32, 190, 68, 211, 16, 95, 34, 234, 8, 176, 17, 117, 4,
+        88, 137, 187, 2, 44, 197, 222, 1, 22, 227, 111, 129, 11, 242, 184, 193, 134, 121, 92, 225,
+        67, 189, 46, 241, 162, 223, 23, 249, 81, 240, 140, 253, 169, 120, 70, 255, 213, 60, 35, 256,
+        235, 30, 146, 128, 246, 15, 73, 64, 123, 136, 165, 32, 190, 68, 211, 16, 95, 34, 234, 8,
+        176, 17, 117, 4, 88, 137, 187, 2, 44, 197, 222, 1, 22, 227, 111, 129, 11, 242, 184, 193,
+        134, 121, 92, 225, 67, 189, 46, 241, 162, 223, 23, 249, 81, 240, 140, 253, 169, 120, 70,
+        255, 213, 60, 35, 256, 235, 30, 146, 128, 246, 15, 73, 64, 123, 136, 165, 32, 190, 68, 211,
+        16, 95, 34, 234, 8, 176, 17, 117, 4, 88, 137, 187, 2, 44, 197, 222, 1,
+    ],
+    [
+        1, 23, 15, 88, 225, 35, 34, 11, 253, 165, 197, 162, 128, 117, 121, 213, 16, 111, 240, 123,
+        2, 46, 30, 176, 193, 70, 68, 22, 249, 73, 137, 67, 256, 234, 242, 169, 32, 222, 223, 246, 4,
+        92, 60, 95, 129, 140, 136, 44, 241, 146, 17, 134, 255, 211, 227, 81, 64, 187, 189, 235, 8,
+        184, 120, 190, 1, 23, 15, 88, 225, 35, 34, 11, 253, 165, 197, 162, 128, 117, 121, 213, 16,
+        111, 240, 123, 2, 46, 30, 176, 193, 70, 68, 22, 249, 73, 137, 67, 256, 234, 242, 169, 32,
+        222, 223, 246, 4, 92, 60, 95, 129, 140, 136, 44, 241, 146, 17, 134, 255, 211, 227, 81, 64,
+        187, 189, 235, 8, 184, 120, 190, 1, 23, 15, 88, 225, 35, 34, 11, 253, 165, 197, 162, 128,
+        117, 121, 213, 16, 111, 240, 123, 2, 46, 30, 176, 193, 70, 68, 22, 249, 73, 137, 67, 256,
+        234, 242, 169, 32, 222, 223, 246, 4, 92, 60, 95, 129, 140, 136, 44, 241, 146, 17, 134, 255,
+        211, 227, 81, 64, 187, 189, 235, 8, 184, 120, 190, 1, 23, 15, 88, 225, 35, 34, 11, 253, 165,
+        197, 162, 128, 117, 121, 213, 16, 111, 240, 123, 2, 46, 30, 176, 193, 70, 68, 22, 249, 73,
+        137, 67, 256, 234, 242, 169, 32, 222, 223, 246, 4, 92, 60, 95, 129, 140, 136, 44, 241, 146,
+        17, 134, 255, 211, 227, 81, 64, 187, 189, 235, 8, 184, 120, 190, 1,
+    ],
+    [
+        1, 24, 62, 203, 246, 250, 89, 80, 121, 77, 49, 148, 211, 181, 232, 171, 249, 65, 18, 175,
+        88, 56, 59, 131, 60, 155, 122, 101, 111, 94, 200, 174, 64, 251, 113, 142, 67, 66, 42, 237,
+        34, 45, 52, 220, 140, 19, 199, 150, 2, 48, 124, 149, 235, 243, 178, 160, 242, 154, 98, 39,
+        165, 105, 207, 85, 241, 130, 36, 93, 176, 112, 118, 5, 120, 53, 244, 202, 222, 188, 143, 91,
+        128, 245, 226, 27, 134, 132, 84, 217, 68, 90, 104, 183, 23, 38, 141, 43, 4, 96, 248, 41,
+        213, 229, 99, 63, 227, 51, 196, 78, 73, 210, 157, 170, 225, 3, 72, 186, 95, 224, 236, 10,
+        240, 106, 231, 147, 187, 119, 29, 182, 256, 233, 195, 54, 11, 7, 168, 177, 136, 180, 208,
+        109, 46, 76, 25, 86, 8, 192, 239, 82, 169, 201, 198, 126, 197, 102, 135, 156, 146, 163, 57,
+        83, 193, 6, 144, 115, 190, 191, 215, 20, 223, 212, 205, 37, 117, 238, 58, 107, 255, 209,
+        133, 108, 22, 14, 79, 97, 15, 103, 159, 218, 92, 152, 50, 172, 16, 127, 221, 164, 81, 145,
+        139, 252, 137, 204, 13, 55, 35, 69, 114, 166, 129, 12, 31, 230, 123, 125, 173, 40, 189, 167,
+        153, 74, 234, 219, 116, 214, 253, 161, 9, 216, 44, 28, 158, 194, 30, 206, 61, 179, 184, 47,
+        100, 87, 32, 254, 185, 71, 162, 33, 21, 247, 17, 151, 26, 110, 70, 138, 228, 75, 1,
+    ],
+    [
+        1, 25, 111, 205, 242, 139, 134, 9, 225, 228, 46, 122, 223, 178, 81, 226, 253, 157, 70, 208,
+        60, 215, 235, 221, 128, 116, 73, 26, 136, 59, 190, 124, 16, 143, 234, 196, 17, 168, 88, 144,
+        2, 50, 222, 153, 227, 21, 11, 18, 193, 199, 92, 244, 189, 99, 162, 195, 249, 57, 140, 159,
+        120, 173, 213, 185, 256, 232, 146, 52, 15, 118, 123, 248, 32, 29, 211, 135, 34, 79, 176, 31,
+        4, 100, 187, 49, 197, 42, 22, 36, 129, 141, 184, 231, 121, 198, 67, 133, 241, 114, 23, 61,
+        240, 89, 169, 113, 255, 207, 35, 104, 30, 236, 246, 239, 64, 58, 165, 13, 68, 158, 95, 62,
+        8, 200, 117, 98, 137, 84, 44, 72, 1, 25, 111, 205, 242, 139, 134, 9, 225, 228, 46, 122, 223,
+        178, 81, 226, 253, 157, 70, 208, 60, 215, 235, 221, 128, 116, 73, 26, 136, 59, 190, 124, 16,
+        143, 234, 196, 17, 168, 88, 144, 2, 50, 222, 153, 227, 21, 11, 18, 193, 199, 92, 244, 189,
+        99, 162, 195, 249, 57, 140, 159, 120, 173, 213, 185, 256, 232, 146, 52, 15, 118, 123, 248,
+        32, 29, 211, 135, 34, 79, 176, 31, 4, 100, 187, 49, 197, 42, 22, 36, 129, 141, 184, 231,
+        121, 198, 67, 133, 241, 114, 23, 61, 240, 89, 169, 113, 255, 207, 35, 104, 30, 236, 246,
+        239, 64, 58, 165, 13, 68, 158, 95, 62, 8, 200, 117, 98, 137, 84, 44, 72, 1,
+    ],
+    [
+        1, 26, 162, 100, 30, 9, 234, 173, 129, 13, 81, 50, 15, 133, 117, 215, 193, 135, 169, 25,
+        136, 195, 187, 236, 225, 196, 213, 141, 68, 226, 222, 118, 241, 98, 235, 199, 34, 113, 111,
+        59, 249, 49, 246, 228, 17, 185, 184, 158, 253, 153, 123, 114, 137, 221, 92, 79, 255, 205,
+        190, 57, 197, 239, 46, 168, 256, 231, 95, 157, 227, 248, 23, 84, 128, 244, 176, 207, 242,
+        124, 140, 42, 64, 122, 88, 232, 121, 62, 70, 21, 32, 61, 44, 116, 189, 31, 35, 139, 16, 159,
+        22, 58, 223, 144, 146, 198, 8, 208, 11, 29, 240, 72, 73, 99, 4, 104, 134, 143, 120, 36, 165,
+        178, 2, 52, 67, 200, 60, 18, 211, 89, 1, 26, 162, 100, 30, 9, 234, 173, 129, 13, 81, 50, 15,
+        133, 117, 215, 193, 135, 169, 25, 136, 195, 187, 236, 225, 196, 213, 141, 68, 226, 222, 118,
+        241, 98, 235, 199, 34, 113, 111, 59, 249, 49, 246, 228, 17, 185, 184, 158, 253, 153, 123,
+        114, 137, 221, 92, 79, 255, 205, 190, 57, 197, 239, 46, 168, 256, 231, 95, 157, 227, 248,
+        23, 84, 128, 244, 176, 207, 242, 124, 140, 42, 64, 122, 88, 232, 121, 62, 70, 21, 32, 61,
+        44, 116, 189, 31, 35, 139, 16, 159, 22, 58, 223, 144, 146, 198, 8, 208, 11, 29, 240, 72, 73,
+        99, 4, 104, 134, 143, 120, 36, 165, 178, 2, 52, 67, 200, 60, 18, 211, 89, 1,
+    ],
+    [
+        1, 27, 215, 151, 222, 83, 185, 112, 197, 179, 207, 192, 44, 160, 208, 219, 2, 54, 173, 45,
+        187, 166, 113, 224, 137, 101, 157, 127, 88, 63, 159, 181, 4, 108, 89, 90, 117, 75, 226, 191,
+        17, 202, 57, 254, 176, 126, 61, 105, 8, 216, 178, 180, 234, 150, 195, 125, 34, 147, 114,
+        251, 95, 252, 122, 210, 16, 175, 99, 103, 211, 43, 133, 250, 68, 37, 228, 245, 190, 247,
+        244, 163, 32, 93, 198, 206, 165, 86, 9, 243, 136, 74, 199, 233, 123, 237, 231, 69, 64, 186,
+        139, 155, 73, 172, 18, 229, 15, 148, 141, 209, 246, 217, 205, 138, 128, 115, 21, 53, 146,
+        87, 36, 201, 30, 39, 25, 161, 235, 177, 153, 19, 256, 230, 42, 106, 35, 174, 72, 145, 60,
+        78, 50, 65, 213, 97, 49, 38, 255, 203, 84, 212, 70, 91, 144, 33, 120, 156, 100, 130, 169,
+        194, 98, 76, 253, 149, 168, 167, 140, 182, 31, 66, 240, 55, 200, 3, 81, 131, 196, 152, 249,
+        41, 79, 77, 23, 107, 62, 132, 223, 110, 143, 6, 162, 5, 135, 47, 241, 82, 158, 154, 46, 214,
+        124, 7, 189, 220, 29, 12, 67, 10, 13, 94, 225, 164, 59, 51, 92, 171, 248, 14, 121, 183, 58,
+        24, 134, 20, 26, 188, 193, 71, 118, 102, 184, 85, 239, 28, 242, 109, 116, 48, 11, 40, 52,
+        119, 129, 142, 236, 204, 111, 170, 221, 56, 227, 218, 232, 96, 22, 80, 104, 238, 1,
+    ],
+    [
+        1, 28, 13, 107, 169, 106, 141, 93, 34, 181, 185, 40, 92, 6, 168, 78, 128, 243, 122, 75, 44,
+        204, 58, 82, 240, 38, 36, 237, 211, 254, 173, 218, 193, 7, 196, 91, 235, 155, 228, 216, 137,
+        238, 239, 10, 23, 130, 42, 148, 32, 125, 159, 83, 11, 51, 143, 149, 60, 138, 9, 252, 117,
+        192, 236, 183, 241, 66, 49, 87, 123, 103, 57, 54, 227, 188, 124, 131, 70, 161, 139, 37, 8,
+        224, 104, 85, 67, 77, 100, 230, 15, 163, 195, 63, 222, 48, 59, 110, 253, 145, 205, 86, 95,
+        90, 207, 142, 121, 47, 31, 97, 146, 233, 99, 202, 2, 56, 26, 214, 81, 212, 25, 186, 68, 105,
+        113, 80, 184, 12, 79, 156, 256, 229, 244, 150, 88, 151, 116, 164, 223, 76, 72, 217, 165,
+        251, 89, 179, 129, 14, 135, 182, 213, 53, 199, 175, 17, 219, 221, 20, 46, 3, 84, 39, 64,
+        250, 61, 166, 22, 102, 29, 41, 120, 19, 18, 247, 234, 127, 215, 109, 225, 132, 98, 174, 246,
+        206, 114, 108, 197, 119, 248, 5, 140, 65, 21, 74, 16, 191, 208, 170, 134, 154, 200, 203, 30,
+        69, 133, 126, 187, 96, 118, 220, 249, 33, 153, 172, 190, 180, 157, 27, 242, 94, 62, 194, 35,
+        209, 198, 147, 4, 112, 52, 171, 162, 167, 50, 115, 136, 210, 226, 160, 111, 24, 158, 55,
+        255, 201, 231, 43, 176, 45, 232, 71, 189, 152, 144, 177, 73, 245, 178, 101, 1,
+    ],
+    [
+        1, 29, 70, 231, 17, 236, 162, 72, 32, 157, 184, 196, 30, 99, 44, 248, 253, 141, 234, 104,
+        189, 84, 123, 226, 129, 143, 35, 244, 137, 118, 81, 36, 16, 207, 92, 98, 15, 178, 22, 124,
+        255, 199, 117, 52, 223, 42, 190, 113, 193, 200, 146, 122, 197, 59, 169, 18, 8, 232, 46, 49,
+        136, 89, 11, 62, 256, 228, 187, 26, 240, 21, 95, 185, 225, 100, 73, 61, 227, 158, 213, 9, 4,
+        116, 23, 153, 68, 173, 134, 31, 128, 114, 222, 13, 120, 139, 176, 221, 241, 50, 165, 159,
+        242, 79, 235, 133, 2, 58, 140, 205, 34, 215, 67, 144, 64, 57, 111, 135, 60, 198, 88, 239,
+        249, 25, 211, 208, 121, 168, 246, 195, 1, 29, 70, 231, 17, 236, 162, 72, 32, 157, 184, 196,
+        30, 99, 44, 248, 253, 141, 234, 104, 189, 84, 123, 226, 129, 143, 35, 244, 137, 118, 81, 36,
+        16, 207, 92, 98, 15, 178, 22, 124, 255, 199, 117, 52, 223, 42, 190, 113, 193, 200, 146, 122,
+        197, 59, 169, 18, 8, 232, 46, 49, 136, 89, 11, 62, 256, 228, 187, 26, 240, 21, 95, 185, 225,
+        100, 73, 61, 227, 158, 213, 9, 4, 116, 23, 153, 68, 173, 134, 31, 128, 114, 222, 13, 120,
+        139, 176, 221, 241, 50, 165, 159, 242, 79, 235, 133, 2, 58, 140, 205, 34, 215, 67, 144, 64,
+        57, 111, 135, 60, 198, 88, 239, 249, 25, 211, 208, 121, 168, 246, 195, 1,
+    ],
+    [
+        1, 30, 129, 15, 193, 136, 225, 68, 241, 34, 249, 17, 253, 137, 255, 197, 256, 227, 128, 242,
+        64, 121, 32, 189, 16, 223, 8, 240, 4, 120, 2, 60, 1, 30, 129, 15, 193, 136, 225, 68, 241,
+        34, 249, 17, 253, 137, 255, 197, 256, 227, 128, 242, 64, 121, 32, 189, 16, 223, 8, 240, 4,
+        120, 2, 60, 1, 30, 129, 15, 193, 136, 225, 68, 241, 34, 249, 17, 253, 137, 255, 197, 256,
+        227, 128, 242, 64, 121, 32, 189, 16, 223, 8, 240, 4, 120, 2, 60, 1, 30, 129, 15, 193, 136,
+        225, 68, 241, 34, 249, 17, 253, 137, 255, 197, 256, 227, 128, 242, 64, 121, 32, 189, 16,
+        223, 8, 240, 4, 120, 2, 60, 1, 30, 129, 15, 193, 136, 225, 68, 241, 34, 249, 17, 253, 137,
+        255, 197, 256, 227, 128, 242, 64, 121, 32, 189, 16, 223, 8, 240, 4, 120, 2, 60, 1, 30, 129,
+        15, 193, 136, 225, 68, 241, 34, 249, 17, 253, 137, 255, 197, 256, 227, 128, 242, 64, 121,
+        32, 189, 16, 223, 8, 240, 4, 120, 2, 60, 1, 30, 129, 15, 193, 136, 225, 68, 241, 34, 249,
+        17, 253, 137, 255, 197, 256, 227, 128, 242, 64, 121, 32, 189, 16, 223, 8, 240, 4, 120, 2,
+        60, 1, 30, 129, 15, 193, 136, 225, 68, 241, 34, 249, 17, 253, 137, 255, 197, 256, 227, 128,
+        242, 64, 121, 32, 189, 16, 223, 8, 240, 4, 120, 2, 60, 1,
+    ],
+    [
+        1, 31, 190, 236, 120, 122, 184, 50, 8, 248, 235, 89, 189, 205, 187, 143, 64, 185, 81, 198,
+        227, 98, 211, 116, 255, 195, 134, 42, 17, 13, 146, 157, 241, 18, 44, 79, 136, 104, 140, 228,
+        129, 144, 95, 118, 60, 61, 92, 25, 4, 124, 246, 173, 223, 231, 222, 200, 32, 221, 169, 99,
+        242, 49, 234, 58, 256, 226, 67, 21, 137, 135, 73, 207, 249, 9, 22, 168, 68, 52, 70, 114,
+        193, 72, 176, 59, 30, 159, 46, 141, 2, 62, 123, 215, 240, 244, 111, 100, 16, 239, 213, 178,
+        121, 153, 117, 29, 128, 113, 162, 139, 197, 196, 165, 232, 253, 133, 11, 84, 34, 26, 35, 57,
+        225, 36, 88, 158, 15, 208, 23, 199, 1, 31, 190, 236, 120, 122, 184, 50, 8, 248, 235, 89,
+        189, 205, 187, 143, 64, 185, 81, 198, 227, 98, 211, 116, 255, 195, 134, 42, 17, 13, 146,
+        157, 241, 18, 44, 79, 136, 104, 140, 228, 129, 144, 95, 118, 60, 61, 92, 25, 4, 124, 246,
+        173, 223, 231, 222, 200, 32, 221, 169, 99, 242, 49, 234, 58, 256, 226, 67, 21, 137, 135, 73,
+        207, 249, 9, 22, 168, 68, 52, 70, 114, 193, 72, 176, 59, 30, 159, 46, 141, 2, 62, 123, 215,
+        240, 244, 111, 100, 16, 239, 213, 178, 121, 153, 117, 29, 128, 113, 162, 139, 197, 196, 165,
+        232, 253, 133, 11, 84, 34, 26, 35, 57, 225, 36, 88, 158, 15, 208, 23, 199, 1,
+    ],
+    [
+        1, 32, 253, 129, 16, 255, 193, 8, 256, 225, 4, 128, 241, 2, 64, 249, 1, 32, 253, 129, 16,
+        255, 193, 8, 256, 225, 4, 128, 241, 2, 64, 249, 1, 32, 253, 129, 16, 255, 193, 8, 256, 225,
+        4, 128, 241, 2, 64, 249, 1, 32, 253, 129, 16, 255, 193, 8, 256, 225, 4, 128, 241, 2, 64,
+        249, 1, 32, 253, 129, 16, 255, 193, 8, 256, 225, 4, 128, 241, 2, 64, 249, 1, 32, 253, 129,
+        16, 255, 193, 8, 256, 225, 4, 128, 241, 2, 64, 249, 1, 32, 253, 129, 16, 255, 193, 8, 256,
+        225, 4, 128, 241, 2, 64, 249, 1, 32, 253, 129, 16, 255, 193, 8, 256, 225, 4, 128, 241, 2,
+        64, 249, 1, 32, 253, 129, 16, 255, 193, 8, 256, 225, 4, 128, 241, 2, 64, 249, 1, 32, 253,
+        129, 16, 255, 193, 8, 256, 225, 4, 128, 241, 2, 64, 249, 1, 32, 253, 129, 16, 255, 193, 8,
+        256, 225, 4, 128, 241, 2, 64, 249, 1, 32, 253, 129, 16, 255, 193, 8, 256, 225, 4, 128, 241,
+        2, 64, 249, 1, 32, 253, 129, 16, 255, 193, 8, 256, 225, 4, 128, 241, 2, 64, 249, 1, 32, 253,
+        129, 16, 255, 193, 8, 256, 225, 4, 128, 241, 2, 64, 249, 1, 32, 253, 129, 16, 255, 193, 8,
+        256, 225, 4, 128, 241, 2, 64, 249, 1, 32, 253, 129, 16, 255, 193, 8, 256, 225, 4, 128, 241,
+        2, 64, 249, 1,
+    ],
+    [
+        1, 33, 61, 214, 123, 204, 50, 108, 223, 163, 239, 177, 187, 3, 99, 183, 128, 112, 98, 150,
+        67, 155, 232, 203, 17, 47, 9, 40, 35, 127, 79, 37, 193, 201, 208, 182, 95, 51, 141, 27, 120,
+        105, 124, 237, 111, 65, 89, 110, 32, 28, 153, 166, 81, 103, 58, 115, 197, 76, 195, 10, 73,
+        96, 84, 202, 241, 243, 52, 174, 88, 77, 228, 71, 30, 219, 31, 252, 92, 209, 215, 156, 8, 7,
+        231, 170, 213, 90, 143, 93, 242, 19, 113, 131, 211, 24, 21, 179, 253, 125, 13, 172, 22, 212,
+        57, 82, 136, 119, 72, 63, 23, 245, 118, 39, 2, 66, 122, 171, 246, 151, 100, 216, 189, 69,
+        221, 97, 117, 6, 198, 109, 256, 224, 196, 43, 134, 53, 207, 149, 34, 94, 18, 80, 70, 254,
+        158, 74, 129, 145, 159, 107, 190, 102, 25, 54, 240, 210, 248, 217, 222, 130, 178, 220, 64,
+        56, 49, 75, 162, 206, 116, 230, 137, 152, 133, 20, 146, 192, 168, 147, 225, 229, 104, 91,
+        176, 154, 199, 142, 60, 181, 62, 247, 184, 161, 173, 55, 16, 14, 205, 83, 169, 180, 29, 186,
+        227, 38, 226, 5, 165, 48, 42, 101, 249, 250, 26, 87, 44, 167, 114, 164, 15, 238, 144, 126,
+        46, 233, 236, 78, 4, 132, 244, 85, 235, 45, 200, 175, 121, 138, 185, 194, 234, 12, 139, 218,
+        255, 191, 135, 86, 11, 106, 157, 41, 68, 188, 36, 160, 140, 251, 59, 148, 1,
+    ],
+    [
+        1, 34, 128, 240, 193, 137, 32, 60, 241, 227, 8, 15, 253, 121, 2, 68, 256, 223, 129, 17, 64,
+        120, 225, 197, 16, 30, 249, 242, 4, 136, 255, 189, 1, 34, 128, 240, 193, 137, 32, 60, 241,
+        227, 8, 15, 253, 121, 2, 68, 256, 223, 129, 17, 64, 120, 225, 197, 16, 30, 249, 242, 4, 136,
+        255, 189, 1, 34, 128, 240, 193, 137, 32, 60, 241, 227, 8, 15, 253, 121, 2, 68, 256, 223,
+        129, 17, 64, 120, 225, 197, 16, 30, 249, 242, 4, 136, 255, 189, 1, 34, 128, 240, 193, 137,
+        32, 60, 241, 227, 8, 15, 253, 121, 2, 68, 256, 223, 129, 17, 64, 120, 225, 197, 16, 30, 249,
+        242, 4, 136, 255, 189, 1, 34, 128, 240, 193, 137, 32, 60, 241, 227, 8, 15, 253, 121, 2, 68,
+        256, 223, 129, 17, 64, 120, 225, 197, 16, 30, 249, 242, 4, 136, 255, 189, 1, 34, 128, 240,
+        193, 137, 32, 60, 241, 227, 8, 15, 253, 121, 2, 68, 256, 223, 129, 17, 64, 120, 225, 197,
+        16, 30, 249, 242, 4, 136, 255, 189, 1, 34, 128, 240, 193, 137, 32, 60, 241, 227, 8, 15, 253,
+        121, 2, 68, 256, 223, 129, 17, 64, 120, 225, 197, 16, 30, 249, 242, 4, 136, 255, 189, 1, 34,
+        128, 240, 193, 137, 32, 60, 241, 227, 8, 15, 253, 121, 2, 68, 256, 223, 129, 17, 64, 120,
+        225, 197, 16, 30, 249, 242, 4, 136, 255, 189, 1,
+    ],
+    [
+        1, 35, 197, 213, 2, 70, 137, 169, 4, 140, 17, 81, 8, 23, 34, 162, 16, 46, 68, 67, 32, 92,
+        136, 134, 64, 184, 15, 11, 128, 111, 30, 22, 256, 222, 60, 44, 255, 187, 120, 88, 253, 117,
+        240, 176, 249, 234, 223, 95, 241, 211, 189, 190, 225, 165, 121, 123, 193, 73, 242, 246, 129,
+        146, 227, 235, 1, 35, 197, 213, 2, 70, 137, 169, 4, 140, 17, 81, 8, 23, 34, 162, 16, 46, 68,
+        67, 32, 92, 136, 134, 64, 184, 15, 11, 128, 111, 30, 22, 256, 222, 60, 44, 255, 187, 120,
+        88, 253, 117, 240, 176, 249, 234, 223, 95, 241, 211, 189, 190, 225, 165, 121, 123, 193, 73,
+        242, 246, 129, 146, 227, 235, 1, 35, 197, 213, 2, 70, 137, 169, 4, 140, 17, 81, 8, 23, 34,
+        162, 16, 46, 68, 67, 32, 92, 136, 134, 64, 184, 15, 11, 128, 111, 30, 22, 256, 222, 60, 44,
+        255, 187, 120, 88, 253, 117, 240, 176, 249, 234, 223, 95, 241, 211, 189, 190, 225, 165, 121,
+        123, 193, 73, 242, 246, 129, 146, 227, 235, 1, 35, 197, 213, 2, 70, 137, 169, 4, 140, 17,
+        81, 8, 23, 34, 162, 16, 46, 68, 67, 32, 92, 136, 134, 64, 184, 15, 11, 128, 111, 30, 22,
+        256, 222, 60, 44, 255, 187, 120, 88, 253, 117, 240, 176, 249, 234, 223, 95, 241, 211, 189,
+        190, 225, 165, 121, 123, 193, 73, 242, 246, 129, 146, 227, 235, 1,
+    ],
+    [
+        1, 36, 11, 139, 121, 244, 46, 114, 249, 226, 169, 173, 60, 104, 146, 116, 64, 248, 190, 158,
+        34, 196, 117, 100, 2, 72, 22, 21, 242, 231, 92, 228, 241, 195, 81, 89, 120, 208, 35, 232,
+        128, 239, 123, 59, 68, 135, 234, 200, 4, 144, 44, 42, 227, 205, 184, 199, 225, 133, 162,
+        178, 240, 159, 70, 207, 256, 221, 246, 118, 136, 13, 211, 143, 8, 31, 88, 84, 197, 153, 111,
+        141, 193, 9, 67, 99, 223, 61, 140, 157, 255, 185, 235, 236, 15, 26, 165, 29, 16, 62, 176,
+        168, 137, 49, 222, 25, 129, 18, 134, 198, 189, 122, 23, 57, 253, 113, 213, 215, 30, 52, 73,
+        58, 32, 124, 95, 79, 17, 98, 187, 50, 1, 36, 11, 139, 121, 244, 46, 114, 249, 226, 169, 173,
+        60, 104, 146, 116, 64, 248, 190, 158, 34, 196, 117, 100, 2, 72, 22, 21, 242, 231, 92, 228,
+        241, 195, 81, 89, 120, 208, 35, 232, 128, 239, 123, 59, 68, 135, 234, 200, 4, 144, 44, 42,
+        227, 205, 184, 199, 225, 133, 162, 178, 240, 159, 70, 207, 256, 221, 246, 118, 136, 13, 211,
+        143, 8, 31, 88, 84, 197, 153, 111, 141, 193, 9, 67, 99, 223, 61, 140, 157, 255, 185, 235,
+        236, 15, 26, 165, 29, 16, 62, 176, 168, 137, 49, 222, 25, 129, 18, 134, 198, 189, 122, 23,
+        57, 253, 113, 213, 215, 30, 52, 73, 58, 32, 124, 95, 79, 17, 98, 187, 50, 1,
+    ],
+    [
+        1, 37, 84, 24, 117, 217, 62, 238, 68, 203, 58, 90, 246, 107, 104, 250, 255, 183, 89, 209,
+        23, 80, 133, 38, 121, 108, 141, 77, 22, 43, 49, 14, 4, 148, 79, 96, 211, 97, 248, 181, 15,
+        41, 232, 103, 213, 171, 159, 229, 249, 218, 99, 65, 92, 63, 18, 152, 227, 175, 50, 51, 88,
+        172, 196, 56, 16, 78, 59, 127, 73, 131, 221, 210, 60, 164, 157, 155, 81, 170, 122, 145, 225,
+        101, 139, 3, 111, 252, 72, 94, 137, 186, 200, 204, 95, 174, 13, 224, 64, 55, 236, 251, 35,
+        10, 113, 69, 240, 142, 114, 106, 67, 166, 231, 66, 129, 147, 42, 12, 187, 237, 31, 119, 34,
+        230, 29, 45, 123, 182, 52, 125, 256, 220, 173, 233, 140, 40, 195, 19, 189, 54, 199, 167, 11,
+        150, 153, 7, 2, 74, 168, 48, 234, 177, 124, 219, 136, 149, 116, 180, 235, 214, 208, 243,
+        253, 109, 178, 161, 46, 160, 9, 76, 242, 216, 25, 154, 44, 86, 98, 28, 8, 39, 158, 192, 165,
+        194, 239, 105, 30, 82, 207, 206, 169, 85, 61, 201, 241, 179, 198, 130, 184, 126, 36, 47,
+        197, 93, 100, 102, 176, 87, 135, 112, 32, 156, 118, 254, 146, 5, 185, 163, 120, 71, 57, 53,
+        162, 83, 244, 33, 193, 202, 21, 6, 222, 247, 144, 188, 17, 115, 143, 151, 190, 91, 26, 191,
+        128, 110, 215, 245, 70, 20, 226, 138, 223, 27, 228, 212, 134, 75, 205, 132, 1,
+    ],
+    [
+        1, 38, 159, 131, 95, 12, 199, 109, 30, 112, 144, 75, 23, 103, 59, 186, 129, 19, 208, 194,
+        176, 6, 228, 183, 15, 56, 72, 166, 140, 180, 158, 93, 193, 138, 104, 97, 88, 3, 114, 220,
+        136, 28, 36, 83, 70, 90, 79, 175, 225, 69, 52, 177, 44, 130, 57, 110, 68, 14, 18, 170, 35,
+        45, 168, 216, 241, 163, 26, 217, 22, 65, 157, 55, 34, 7, 9, 85, 146, 151, 84, 108, 249, 210,
+        13, 237, 11, 161, 207, 156, 17, 132, 133, 171, 73, 204, 42, 54, 253, 105, 135, 247, 134,
+        209, 232, 78, 137, 66, 195, 214, 165, 102, 21, 27, 255, 181, 196, 252, 67, 233, 116, 39,
+        197, 33, 226, 107, 211, 51, 139, 142, 256, 219, 98, 126, 162, 245, 58, 148, 227, 145, 113,
+        182, 234, 154, 198, 71, 128, 238, 49, 63, 81, 251, 29, 74, 242, 201, 185, 91, 117, 77, 99,
+        164, 64, 119, 153, 160, 169, 254, 143, 37, 121, 229, 221, 174, 187, 167, 178, 82, 32, 188,
+        205, 80, 213, 127, 200, 147, 189, 243, 239, 87, 222, 212, 89, 41, 16, 94, 231, 40, 235, 192,
+        100, 202, 223, 250, 248, 172, 111, 106, 173, 149, 8, 47, 244, 20, 246, 96, 50, 101, 240,
+        125, 124, 86, 184, 53, 215, 203, 4, 152, 122, 10, 123, 48, 25, 179, 120, 191, 62, 43, 92,
+        155, 236, 230, 2, 76, 61, 5, 190, 24, 141, 218, 60, 224, 31, 150, 46, 206, 118, 115, 1,
+    ],
+    [
+        1, 39, 236, 209, 184, 237, 248, 163, 189, 175, 143, 180, 81, 75, 98, 224, 255, 179, 42, 96,
+        146, 40, 18, 188, 136, 164, 228, 154, 95, 107, 61, 66, 4, 156, 173, 65, 222, 177, 221, 138,
+        242, 186, 58, 206, 67, 43, 135, 125, 249, 202, 168, 127, 70, 160, 72, 238, 30, 142, 141,
+        102, 123, 171, 244, 7, 16, 110, 178, 3, 117, 194, 113, 38, 197, 230, 232, 53, 11, 172, 26,
+        243, 225, 37, 158, 251, 23, 126, 31, 181, 120, 54, 50, 151, 235, 170, 205, 28, 64, 183, 198,
+        12, 211, 5, 195, 152, 17, 149, 157, 212, 44, 174, 104, 201, 129, 148, 118, 233, 92, 247,
+        124, 210, 223, 216, 200, 90, 169, 166, 49, 112, 256, 218, 21, 48, 73, 20, 9, 94, 68, 82,
+        114, 77, 176, 182, 159, 33, 2, 78, 215, 161, 111, 217, 239, 69, 121, 93, 29, 103, 162, 150,
+        196, 191, 253, 101, 84, 192, 35, 80, 36, 119, 15, 71, 199, 51, 190, 214, 122, 132, 8, 55,
+        89, 130, 187, 97, 185, 19, 227, 115, 116, 155, 134, 86, 13, 250, 241, 147, 79, 254, 140, 63,
+        144, 219, 60, 27, 25, 204, 246, 85, 231, 14, 32, 220, 99, 6, 234, 131, 226, 76, 137, 203,
+        207, 106, 22, 87, 52, 229, 193, 74, 59, 245, 46, 252, 62, 105, 240, 108, 100, 45, 213, 83,
+        153, 56, 128, 109, 139, 24, 165, 10, 133, 47, 34, 41, 57, 167, 88, 91, 208, 145, 1,
+    ],
+    [
+        1, 40, 58, 7, 23, 149, 49, 161, 15, 86, 99, 105, 88, 179, 221, 102, 225, 5, 200, 33, 35,
+        115, 231, 245, 34, 75, 173, 238, 11, 183, 124, 77, 253, 97, 25, 229, 165, 175, 61, 127, 197,
+        170, 118, 94, 162, 55, 144, 106, 128, 237, 228, 125, 117, 54, 104, 48, 121, 214, 79, 76,
+        213, 39, 18, 206, 16, 126, 157, 112, 111, 71, 13, 6, 240, 91, 42, 138, 123, 37, 195, 90, 2,
+        80, 116, 14, 46, 41, 98, 65, 30, 172, 198, 210, 176, 101, 185, 204, 193, 10, 143, 66, 70,
+        230, 205, 233, 68, 150, 89, 219, 22, 109, 248, 154, 249, 194, 50, 201, 73, 93, 122, 254,
+        137, 83, 236, 188, 67, 110, 31, 212, 256, 217, 199, 250, 234, 108, 208, 96, 242, 171, 158,
+        152, 169, 78, 36, 155, 32, 252, 57, 224, 222, 142, 26, 12, 223, 182, 84, 19, 246, 74, 133,
+        180, 4, 160, 232, 28, 92, 82, 196, 130, 60, 87, 139, 163, 95, 202, 113, 151, 129, 20, 29,
+        132, 140, 203, 153, 209, 136, 43, 178, 181, 44, 218, 239, 51, 241, 131, 100, 145, 146, 186,
+        244, 251, 17, 166, 215, 119, 134, 220, 62, 167, 255, 177, 141, 243, 211, 216, 159, 192, 227,
+        85, 59, 47, 81, 156, 72, 53, 64, 247, 114, 191, 187, 27, 52, 24, 189, 107, 168, 38, 235,
+        148, 9, 103, 8, 63, 207, 56, 184, 164, 135, 3, 120, 174, 21, 69, 190, 147, 226, 45, 1,
+    ],
+    [
+        1, 41, 139, 45, 46, 87, 226, 14, 60, 147, 116, 130, 190, 80, 196, 69, 2, 82, 21, 90, 92,
+        174, 195, 28, 120, 37, 232, 3, 123, 160, 135, 138, 4, 164, 42, 180, 184, 91, 133, 56, 240,
+        74, 207, 6, 246, 63, 13, 19, 8, 71, 84, 103, 111, 182, 9, 112, 223, 148, 157, 12, 235, 126,
+        26, 38, 16, 142, 168, 206, 222, 107, 18, 224, 189, 39, 57, 24, 213, 252, 52, 76, 32, 27, 79,
+        155, 187, 214, 36, 191, 121, 78, 114, 48, 169, 247, 104, 152, 64, 54, 158, 53, 117, 171, 72,
+        125, 242, 156, 228, 96, 81, 237, 208, 47, 128, 108, 59, 106, 234, 85, 144, 250, 227, 55,
+        199, 192, 162, 217, 159, 94, 256, 216, 118, 212, 211, 170, 31, 243, 197, 110, 141, 127, 67,
+        177, 61, 188, 255, 175, 236, 167, 165, 83, 62, 229, 137, 220, 25, 254, 134, 97, 122, 119,
+        253, 93, 215, 77, 73, 166, 124, 201, 17, 183, 50, 251, 11, 194, 244, 238, 249, 186, 173,
+        154, 146, 75, 248, 145, 34, 109, 100, 245, 22, 131, 231, 219, 241, 115, 89, 51, 35, 150,
+        239, 33, 68, 218, 200, 233, 44, 5, 205, 181, 225, 230, 178, 102, 70, 43, 221, 66, 136, 179,
+        143, 209, 88, 10, 153, 105, 193, 203, 99, 204, 140, 86, 185, 132, 15, 101, 29, 161, 176, 20,
+        49, 210, 129, 149, 198, 151, 23, 172, 113, 7, 30, 202, 58, 65, 95, 40, 98, 163, 1,
+    ],
+    [
+        1, 42, 222, 72, 197, 50, 44, 49, 2, 84, 187, 144, 137, 100, 88, 98, 4, 168, 117, 31, 17,
+        200, 176, 196, 8, 79, 234, 62, 34, 143, 95, 135, 16, 158, 211, 124, 68, 29, 190, 13, 32, 59,
+        165, 248, 136, 58, 123, 26, 64, 118, 73, 239, 15, 116, 246, 52, 128, 236, 146, 221, 30, 232,
+        235, 104, 256, 215, 35, 185, 60, 207, 213, 208, 255, 173, 70, 113, 120, 157, 169, 159, 253,
+        89, 140, 226, 240, 57, 81, 61, 249, 178, 23, 195, 223, 114, 162, 122, 241, 99, 46, 133, 189,
+        228, 67, 244, 225, 198, 92, 9, 121, 199, 134, 231, 193, 139, 184, 18, 242, 141, 11, 205,
+        129, 21, 111, 36, 227, 25, 22, 153, 1, 42, 222, 72, 197, 50, 44, 49, 2, 84, 187, 144, 137,
+        100, 88, 98, 4, 168, 117, 31, 17, 200, 176, 196, 8, 79, 234, 62, 34, 143, 95, 135, 16, 158,
+        211, 124, 68, 29, 190, 13, 32, 59, 165, 248, 136, 58, 123, 26, 64, 118, 73, 239, 15, 116,
+        246, 52, 128, 236, 146, 221, 30, 232, 235, 104, 256, 215, 35, 185, 60, 207, 213, 208, 255,
+        173, 70, 113, 120, 157, 169, 159, 253, 89, 140, 226, 240, 57, 81, 61, 249, 178, 23, 195,
+        223, 114, 162, 122, 241, 99, 46, 133, 189, 228, 67, 244, 225, 198, 92, 9, 121, 199, 134,
+        231, 193, 139, 184, 18, 242, 141, 11, 205, 129, 21, 111, 36, 227, 25, 22, 153, 1,
+    ],
+    [
+        1, 43, 50, 94, 187, 74, 98, 102, 17, 217, 79, 56, 95, 230, 124, 192, 32, 91, 58, 181, 73,
+        55, 52, 180, 30, 5, 215, 250, 213, 164, 113, 233, 253, 85, 57, 138, 23, 218, 122, 106, 189,
+        160, 198, 33, 134, 108, 18, 3, 129, 150, 25, 47, 222, 37, 49, 51, 137, 237, 168, 28, 176,
+        115, 62, 96, 16, 174, 29, 219, 165, 156, 26, 90, 15, 131, 236, 125, 235, 82, 185, 245, 255,
+        171, 157, 69, 140, 109, 61, 53, 223, 80, 99, 145, 67, 54, 9, 130, 193, 75, 141, 152, 111,
+        147, 153, 154, 197, 247, 84, 14, 88, 186, 31, 48, 8, 87, 143, 238, 211, 78, 13, 45, 136,
+        194, 118, 191, 246, 41, 221, 251, 256, 214, 207, 163, 70, 183, 159, 155, 240, 40, 178, 201,
+        162, 27, 133, 65, 225, 166, 199, 76, 184, 202, 205, 77, 227, 252, 42, 7, 44, 93, 144, 24, 4,
+        172, 200, 119, 234, 39, 135, 151, 68, 97, 59, 224, 123, 149, 239, 254, 128, 107, 232, 210,
+        35, 220, 208, 206, 120, 20, 89, 229, 81, 142, 195, 161, 241, 83, 228, 38, 92, 101, 231, 167,
+        242, 126, 21, 132, 22, 175, 72, 12, 2, 86, 100, 188, 117, 148, 196, 204, 34, 177, 158, 112,
+        190, 203, 248, 127, 64, 182, 116, 105, 146, 110, 104, 103, 60, 10, 173, 243, 169, 71, 226,
+        209, 249, 170, 114, 19, 46, 179, 244, 212, 121, 63, 139, 66, 11, 216, 36, 6, 1,
+    ],
+    [
+        1, 44, 137, 117, 8, 95, 68, 165, 64, 246, 30, 35, 255, 169, 240, 23, 241, 67, 121, 184, 129,
+        22, 197, 187, 4, 176, 34, 211, 32, 123, 15, 146, 256, 213, 120, 140, 249, 162, 189, 92, 193,
+        11, 227, 222, 2, 88, 17, 234, 16, 190, 136, 73, 128, 235, 60, 70, 253, 81, 223, 46, 225,
+        134, 242, 111, 1, 44, 137, 117, 8, 95, 68, 165, 64, 246, 30, 35, 255, 169, 240, 23, 241, 67,
+        121, 184, 129, 22, 197, 187, 4, 176, 34, 211, 32, 123, 15, 146, 256, 213, 120, 140, 249,
+        162, 189, 92, 193, 11, 227, 222, 2, 88, 17, 234, 16, 190, 136, 73, 128, 235, 60, 70, 253,
+        81, 223, 46, 225, 134, 242, 111, 1, 44, 137, 117, 8, 95, 68, 165, 64, 246, 30, 35, 255, 169,
+        240, 23, 241, 67, 121, 184, 129, 22, 197, 187, 4, 176, 34, 211, 32, 123, 15, 146, 256, 213,
+        120, 140, 249, 162, 189, 92, 193, 11, 227, 222, 2, 88, 17, 234, 16, 190, 136, 73, 128, 235,
+        60, 70, 253, 81, 223, 46, 225, 134, 242, 111, 1, 44, 137, 117, 8, 95, 68, 165, 64, 246, 30,
+        35, 255, 169, 240, 23, 241, 67, 121, 184, 129, 22, 197, 187, 4, 176, 34, 211, 32, 123, 15,
+        146, 256, 213, 120, 140, 249, 162, 189, 92, 193, 11, 227, 222, 2, 88, 17, 234, 16, 190, 136,
+        73, 128, 235, 60, 70, 253, 81, 223, 46, 225, 134, 242, 111, 1,
+    ],
+    [
+        1, 45, 226, 147, 190, 69, 21, 174, 120, 3, 135, 164, 184, 56, 207, 63, 8, 103, 9, 148, 235,
+        38, 168, 107, 189, 24, 52, 27, 187, 191, 114, 247, 64, 53, 72, 156, 81, 47, 59, 85, 227,
+        192, 159, 216, 211, 243, 141, 177, 255, 167, 62, 220, 134, 119, 215, 166, 17, 251, 244, 186,
+        146, 145, 100, 131, 241, 51, 239, 218, 44, 181, 178, 43, 136, 209, 153, 203, 140, 132, 29,
+        20, 129, 151, 113, 202, 95, 163, 139, 87, 60, 130, 196, 82, 92, 28, 232, 160, 4, 180, 133,
+        74, 246, 19, 84, 182, 223, 12, 26, 142, 222, 224, 57, 252, 32, 155, 36, 78, 169, 152, 158,
+        171, 242, 96, 208, 108, 234, 250, 199, 217, 256, 212, 31, 110, 67, 188, 236, 83, 137, 254,
+        122, 93, 73, 201, 50, 194, 249, 154, 248, 109, 22, 219, 89, 150, 68, 233, 205, 230, 70, 66,
+        143, 10, 193, 204, 185, 101, 176, 210, 198, 172, 30, 65, 98, 41, 46, 14, 116, 80, 2, 90,
+        195, 37, 123, 138, 42, 91, 240, 6, 13, 71, 111, 112, 157, 126, 16, 206, 18, 39, 213, 76, 79,
+        214, 121, 48, 104, 54, 117, 125, 228, 237, 128, 106, 144, 55, 162, 94, 118, 170, 197, 127,
+        61, 175, 165, 229, 25, 97, 253, 77, 124, 183, 11, 238, 173, 75, 34, 245, 231, 115, 35, 33,
+        200, 5, 225, 102, 221, 179, 88, 105, 99, 86, 15, 161, 49, 149, 23, 7, 58, 40, 1,
+    ],
+    [
+        1, 46, 60, 190, 2, 92, 120, 123, 4, 184, 240, 246, 8, 111, 223, 235, 16, 222, 189, 213, 32,
+        187, 121, 169, 64, 117, 242, 81, 128, 234, 227, 162, 256, 211, 197, 67, 255, 165, 137, 134,
+        253, 73, 17, 11, 249, 146, 34, 22, 241, 35, 68, 44, 225, 70, 136, 88, 193, 140, 15, 176,
+        129, 23, 30, 95, 1, 46, 60, 190, 2, 92, 120, 123, 4, 184, 240, 246, 8, 111, 223, 235, 16,
+        222, 189, 213, 32, 187, 121, 169, 64, 117, 242, 81, 128, 234, 227, 162, 256, 211, 197, 67,
+        255, 165, 137, 134, 253, 73, 17, 11, 249, 146, 34, 22, 241, 35, 68, 44, 225, 70, 136, 88,
+        193, 140, 15, 176, 129, 23, 30, 95, 1, 46, 60, 190, 2, 92, 120, 123, 4, 184, 240, 246, 8,
+        111, 223, 235, 16, 222, 189, 213, 32, 187, 121, 169, 64, 117, 242, 81, 128, 234, 227, 162,
+        256, 211, 197, 67, 255, 165, 137, 134, 253, 73, 17, 11, 249, 146, 34, 22, 241, 35, 68, 44,
+        225, 70, 136, 88, 193, 140, 15, 176, 129, 23, 30, 95, 1, 46, 60, 190, 2, 92, 120, 123, 4,
+        184, 240, 246, 8, 111, 223, 235, 16, 222, 189, 213, 32, 187, 121, 169, 64, 117, 242, 81,
+        128, 234, 227, 162, 256, 211, 197, 67, 255, 165, 137, 134, 253, 73, 17, 11, 249, 146, 34,
+        22, 241, 35, 68, 44, 225, 70, 136, 88, 193, 140, 15, 176, 129, 23, 30, 95, 1,
+    ],
+    [
+        1, 47, 153, 252, 22, 6, 25, 147, 227, 132, 36, 150, 111, 77, 21, 216, 129, 152, 205, 126,
+        11, 3, 141, 202, 242, 66, 18, 75, 184, 167, 139, 108, 193, 76, 231, 63, 134, 130, 199, 101,
+        121, 33, 9, 166, 92, 212, 198, 54, 225, 38, 244, 160, 67, 65, 228, 179, 189, 145, 133, 83,
+        46, 106, 99, 27, 241, 19, 122, 80, 162, 161, 114, 218, 223, 201, 195, 170, 23, 53, 178, 142,
+        249, 138, 61, 40, 81, 209, 57, 109, 240, 229, 226, 85, 140, 155, 89, 71, 253, 69, 159, 20,
+        169, 233, 157, 183, 120, 243, 113, 171, 70, 206, 173, 164, 255, 163, 208, 10, 213, 245, 207,
+        220, 60, 250, 185, 214, 35, 103, 215, 82, 256, 210, 104, 5, 235, 251, 232, 110, 30, 125,
+        221, 107, 146, 180, 236, 41, 128, 105, 52, 131, 246, 254, 116, 55, 15, 191, 239, 182, 73,
+        90, 118, 149, 64, 181, 26, 194, 123, 127, 58, 156, 136, 224, 248, 91, 165, 45, 59, 203, 32,
+        219, 13, 97, 190, 192, 29, 78, 68, 112, 124, 174, 211, 151, 158, 230, 16, 238, 135, 177, 95,
+        96, 143, 39, 34, 56, 62, 87, 234, 204, 79, 115, 8, 119, 196, 217, 176, 48, 200, 148, 17, 28,
+        31, 172, 117, 102, 168, 186, 4, 188, 98, 237, 88, 24, 100, 74, 137, 14, 144, 86, 187, 51,
+        84, 93, 2, 94, 49, 247, 44, 12, 50, 37, 197, 7, 72, 43, 222, 154, 42, 175, 1,
+    ],
+    [
+        1, 48, 248, 82, 81, 33, 42, 217, 136, 103, 61, 101, 222, 119, 58, 214, 249, 130, 72, 115,
+        123, 250, 178, 63, 197, 204, 26, 220, 23, 76, 50, 87, 64, 245, 195, 108, 44, 56, 118, 10,
+        223, 167, 49, 39, 73, 163, 114, 75, 2, 96, 239, 164, 162, 66, 84, 177, 15, 206, 122, 202,
+        187, 238, 116, 171, 241, 3, 144, 230, 246, 243, 99, 126, 137, 151, 52, 183, 46, 152, 100,
+        174, 128, 233, 133, 216, 88, 112, 236, 20, 189, 77, 98, 78, 146, 69, 228, 150, 4, 192, 221,
+        71, 67, 132, 168, 97, 30, 155, 244, 147, 117, 219, 232, 85, 225, 6, 31, 203, 235, 229, 198,
+        252, 17, 45, 104, 109, 92, 47, 200, 91, 256, 209, 9, 175, 176, 224, 215, 40, 121, 154, 196,
+        156, 35, 138, 199, 43, 8, 127, 185, 142, 134, 7, 79, 194, 60, 53, 231, 37, 234, 181, 207,
+        170, 193, 12, 62, 149, 213, 201, 139, 247, 34, 90, 208, 218, 184, 94, 143, 182, 255, 161,
+        18, 93, 95, 191, 173, 80, 242, 51, 135, 55, 70, 19, 141, 86, 16, 254, 113, 27, 11, 14, 158,
+        131, 120, 106, 205, 74, 211, 105, 157, 83, 129, 24, 124, 41, 169, 145, 21, 237, 68, 180,
+        159, 179, 111, 188, 29, 107, 253, 65, 36, 186, 190, 125, 89, 160, 227, 102, 13, 110, 140,
+        38, 25, 172, 32, 251, 226, 54, 22, 28, 59, 5, 240, 212, 153, 148, 165, 210, 57, 166, 1,
+    ],
+    [
+        1, 49, 88, 200, 34, 124, 165, 118, 128, 104, 213, 157, 240, 195, 46, 198, 193, 205, 22, 50,
+        137, 31, 234, 158, 32, 26, 246, 232, 60, 113, 140, 178, 241, 244, 134, 141, 227, 72, 187,
+        168, 8, 135, 190, 58, 15, 221, 35, 173, 253, 61, 162, 228, 121, 18, 111, 42, 2, 98, 176,
+        143, 68, 248, 73, 236, 256, 208, 169, 57, 223, 133, 92, 139, 129, 153, 44, 100, 17, 62, 211,
+        59, 64, 52, 235, 207, 120, 226, 23, 99, 225, 231, 11, 25, 197, 144, 117, 79, 16, 13, 123,
+        116, 30, 185, 70, 89, 249, 122, 67, 199, 242, 36, 222, 84, 4, 196, 95, 29, 136, 239, 146,
+        215, 255, 159, 81, 114, 189, 9, 184, 21, 1, 49, 88, 200, 34, 124, 165, 118, 128, 104, 213,
+        157, 240, 195, 46, 198, 193, 205, 22, 50, 137, 31, 234, 158, 32, 26, 246, 232, 60, 113, 140,
+        178, 241, 244, 134, 141, 227, 72, 187, 168, 8, 135, 190, 58, 15, 221, 35, 173, 253, 61, 162,
+        228, 121, 18, 111, 42, 2, 98, 176, 143, 68, 248, 73, 236, 256, 208, 169, 57, 223, 133, 92,
+        139, 129, 153, 44, 100, 17, 62, 211, 59, 64, 52, 235, 207, 120, 226, 23, 99, 225, 231, 11,
+        25, 197, 144, 117, 79, 16, 13, 123, 116, 30, 185, 70, 89, 249, 122, 67, 199, 242, 36, 222,
+        84, 4, 196, 95, 29, 136, 239, 146, 215, 255, 159, 81, 114, 189, 9, 184, 21, 1,
+    ],
+    [
+        1, 50, 187, 98, 17, 79, 95, 124, 32, 58, 73, 52, 30, 215, 213, 113, 253, 57, 23, 122, 189,
+        198, 134, 18, 129, 25, 222, 49, 137, 168, 176, 62, 16, 29, 165, 26, 15, 236, 235, 185, 255,
+        157, 140, 61, 223, 99, 67, 9, 193, 141, 111, 153, 197, 84, 88, 31, 8, 143, 211, 13, 136,
+        118, 246, 221, 256, 207, 70, 159, 240, 178, 162, 133, 225, 199, 184, 205, 227, 42, 44, 144,
+        4, 200, 234, 135, 68, 59, 123, 239, 128, 232, 35, 208, 120, 89, 81, 195, 241, 228, 92, 231,
+        242, 21, 22, 72, 2, 100, 117, 196, 34, 158, 190, 248, 64, 116, 146, 104, 60, 173, 169, 226,
+        249, 114, 46, 244, 121, 139, 11, 36, 1, 50, 187, 98, 17, 79, 95, 124, 32, 58, 73, 52, 30,
+        215, 213, 113, 253, 57, 23, 122, 189, 198, 134, 18, 129, 25, 222, 49, 137, 168, 176, 62, 16,
+        29, 165, 26, 15, 236, 235, 185, 255, 157, 140, 61, 223, 99, 67, 9, 193, 141, 111, 153, 197,
+        84, 88, 31, 8, 143, 211, 13, 136, 118, 246, 221, 256, 207, 70, 159, 240, 178, 162, 133, 225,
+        199, 184, 205, 227, 42, 44, 144, 4, 200, 234, 135, 68, 59, 123, 239, 128, 232, 35, 208, 120,
+        89, 81, 195, 241, 228, 92, 231, 242, 21, 22, 72, 2, 100, 117, 196, 34, 158, 190, 248, 64,
+        116, 146, 104, 60, 173, 169, 226, 249, 114, 46, 244, 121, 139, 11, 36, 1,
+    ],
+    [
+        1, 51, 31, 39, 190, 181, 236, 214, 120, 209, 122, 54, 184, 132, 50, 237, 8, 151, 248, 55,
+        235, 163, 89, 170, 189, 130, 205, 175, 187, 28, 143, 97, 64, 180, 185, 183, 81, 19, 198, 75,
+        227, 12, 98, 115, 211, 224, 116, 5, 255, 155, 195, 179, 134, 152, 42, 86, 17, 96, 13, 149,
+        146, 250, 157, 40, 241, 212, 18, 147, 44, 188, 79, 174, 136, 254, 104, 164, 140, 201, 228,
+        63, 129, 154, 144, 148, 95, 219, 118, 107, 60, 233, 61, 27, 92, 66, 25, 247, 4, 204, 124,
+        156, 246, 210, 173, 85, 223, 65, 231, 216, 222, 14, 200, 177, 32, 90, 221, 220, 169, 138,
+        99, 166, 242, 6, 49, 186, 234, 112, 58, 131, 256, 206, 226, 218, 67, 76, 21, 43, 137, 48,
+        135, 203, 73, 125, 207, 20, 249, 106, 9, 202, 22, 94, 168, 87, 68, 127, 52, 82, 70, 229,
+        114, 160, 193, 77, 72, 74, 176, 238, 59, 182, 30, 245, 159, 142, 46, 33, 141, 252, 2, 102,
+        62, 78, 123, 105, 215, 171, 240, 161, 244, 108, 111, 7, 100, 217, 16, 45, 239, 110, 213, 69,
+        178, 83, 121, 3, 153, 93, 117, 56, 29, 194, 128, 103, 113, 109, 162, 38, 139, 150, 197, 24,
+        196, 230, 165, 191, 232, 10, 253, 53, 133, 101, 11, 47, 84, 172, 34, 192, 26, 41, 35, 243,
+        57, 80, 225, 167, 36, 37, 88, 119, 158, 91, 15, 251, 208, 71, 23, 145, 199, 126, 1,
+    ],
+    [
+        1, 52, 134, 29, 223, 31, 70, 42, 128, 231, 190, 114, 17, 113, 222, 236, 193, 13, 162, 200,
+        120, 72, 146, 139, 32, 122, 176, 157, 197, 221, 184, 59, 241, 196, 169, 50, 30, 18, 165, 99,
+        8, 159, 44, 232, 242, 248, 46, 79, 253, 49, 235, 141, 136, 133, 234, 89, 2, 104, 11, 58,
+        189, 62, 140, 84, 256, 205, 123, 228, 34, 226, 187, 215, 129, 26, 67, 143, 240, 144, 35, 21,
+        64, 244, 95, 57, 137, 185, 111, 118, 225, 135, 81, 100, 60, 36, 73, 198, 16, 61, 88, 207,
+        227, 239, 92, 158, 249, 98, 213, 25, 15, 9, 211, 178, 4, 208, 22, 116, 121, 124, 23, 168,
+        255, 153, 246, 199, 68, 195, 117, 173, 1, 52, 134, 29, 223, 31, 70, 42, 128, 231, 190, 114,
+        17, 113, 222, 236, 193, 13, 162, 200, 120, 72, 146, 139, 32, 122, 176, 157, 197, 221, 184,
+        59, 241, 196, 169, 50, 30, 18, 165, 99, 8, 159, 44, 232, 242, 248, 46, 79, 253, 49, 235,
+        141, 136, 133, 234, 89, 2, 104, 11, 58, 189, 62, 140, 84, 256, 205, 123, 228, 34, 226, 187,
+        215, 129, 26, 67, 143, 240, 144, 35, 21, 64, 244, 95, 57, 137, 185, 111, 118, 225, 135, 81,
+        100, 60, 36, 73, 198, 16, 61, 88, 207, 227, 239, 92, 158, 249, 98, 213, 25, 15, 9, 211, 178,
+        4, 208, 22, 116, 121, 124, 23, 168, 255, 153, 246, 199, 68, 195, 117, 173, 1,
+    ],
+    [
+        1, 53, 239, 74, 67, 210, 79, 75, 120, 192, 153, 142, 73, 14, 228, 5, 8, 167, 113, 78, 22,
+        138, 118, 86, 189, 251, 196, 108, 70, 112, 25, 40, 64, 51, 133, 110, 176, 76, 173, 174, 227,
+        209, 26, 93, 46, 125, 200, 63, 255, 151, 36, 109, 123, 94, 99, 107, 17, 130, 208, 230, 111,
+        229, 58, 247, 241, 180, 31, 101, 213, 238, 21, 85, 136, 12, 122, 41, 117, 33, 207, 177, 129,
+        155, 248, 37, 162, 105, 168, 166, 60, 96, 205, 71, 165, 7, 114, 131, 4, 212, 185, 39, 11,
+        69, 59, 43, 223, 254, 98, 54, 35, 56, 141, 20, 32, 154, 195, 55, 88, 38, 215, 87, 242, 233,
+        13, 175, 23, 191, 100, 160, 256, 204, 18, 183, 190, 47, 178, 182, 137, 65, 104, 115, 184,
+        243, 29, 252, 249, 90, 144, 179, 235, 119, 139, 171, 68, 6, 61, 149, 187, 145, 232, 217,
+        193, 206, 124, 147, 81, 181, 84, 83, 30, 48, 231, 164, 211, 132, 57, 194, 2, 106, 221, 148,
+        134, 163, 158, 150, 240, 127, 49, 27, 146, 28, 199, 10, 16, 77, 226, 156, 44, 19, 236, 172,
+        121, 245, 135, 216, 140, 224, 50, 80, 128, 102, 9, 220, 95, 152, 89, 91, 197, 161, 52, 186,
+        92, 250, 143, 126, 253, 45, 72, 218, 246, 188, 198, 214, 34, 3, 159, 203, 222, 201, 116,
+        237, 225, 103, 62, 202, 169, 219, 42, 170, 15, 24, 244, 82, 234, 66, 157, 97, 1,
+    ],
+    [
+        1, 54, 89, 180, 211, 86, 18, 201, 60, 156, 200, 6, 67, 20, 52, 238, 2, 108, 178, 103, 165,
+        172, 36, 145, 120, 55, 143, 12, 134, 40, 104, 219, 4, 216, 99, 206, 73, 87, 72, 33, 240,
+        110, 29, 24, 11, 80, 208, 181, 8, 175, 198, 155, 146, 174, 144, 66, 223, 220, 58, 48, 22,
+        160, 159, 105, 16, 93, 139, 53, 35, 91, 31, 132, 189, 183, 116, 96, 44, 63, 61, 210, 32,
+        186, 21, 106, 70, 182, 62, 7, 121, 109, 232, 192, 88, 126, 122, 163, 64, 115, 42, 212, 140,
+        107, 124, 14, 242, 218, 207, 127, 176, 252, 244, 69, 128, 230, 84, 167, 23, 214, 248, 28,
+        227, 179, 157, 254, 95, 247, 231, 138, 256, 203, 168, 77, 46, 171, 239, 56, 197, 101, 57,
+        251, 190, 237, 205, 19, 255, 149, 79, 154, 92, 85, 221, 112, 137, 202, 114, 245, 123, 217,
+        153, 38, 253, 41, 158, 51, 184, 170, 185, 224, 17, 147, 228, 233, 246, 177, 49, 76, 249, 82,
+        59, 102, 111, 83, 113, 191, 34, 37, 199, 209, 235, 97, 98, 152, 241, 164, 118, 204, 222,
+        166, 226, 125, 68, 74, 141, 161, 213, 194, 196, 47, 225, 71, 236, 151, 187, 75, 195, 250,
+        136, 148, 25, 65, 169, 131, 135, 94, 193, 142, 215, 45, 117, 150, 133, 243, 15, 39, 50, 130,
+        81, 5, 13, 188, 129, 27, 173, 90, 234, 43, 9, 229, 30, 78, 100, 3, 162, 10, 26, 119, 1,
+    ],
+    [
+        1, 55, 198, 96, 140, 247, 221, 76, 68, 142, 100, 103, 11, 91, 122, 28, 255, 147, 118, 65,
+        234, 20, 72, 105, 121, 230, 57, 51, 235, 75, 13, 201, 4, 220, 21, 127, 46, 217, 113, 47, 15,
+        54, 143, 155, 44, 107, 231, 112, 249, 74, 215, 3, 165, 80, 31, 163, 227, 149, 228, 204, 169,
+        43, 52, 33, 16, 109, 84, 251, 184, 97, 195, 188, 60, 216, 58, 106, 176, 171, 153, 191, 225,
+        39, 89, 12, 146, 63, 124, 138, 137, 82, 141, 45, 162, 172, 208, 132, 64, 179, 79, 233, 222,
+        131, 9, 238, 240, 93, 232, 167, 190, 170, 98, 250, 129, 156, 99, 48, 70, 252, 239, 38, 34,
+        71, 50, 180, 134, 174, 61, 14, 256, 202, 59, 161, 117, 10, 36, 181, 189, 115, 157, 154, 246,
+        166, 135, 229, 2, 110, 139, 192, 23, 237, 185, 152, 136, 27, 200, 206, 22, 182, 244, 56,
+        253, 37, 236, 130, 211, 40, 144, 210, 242, 203, 114, 102, 213, 150, 26, 145, 8, 183, 42,
+        254, 92, 177, 226, 94, 30, 108, 29, 53, 88, 214, 205, 224, 241, 148, 173, 6, 73, 160, 62,
+        69, 197, 41, 199, 151, 81, 86, 104, 66, 32, 218, 168, 245, 111, 194, 133, 119, 120, 175,
+        116, 212, 95, 85, 49, 125, 193, 78, 178, 24, 35, 126, 248, 19, 17, 164, 25, 90, 67, 87, 159,
+        7, 128, 101, 158, 209, 187, 5, 18, 219, 223, 186, 207, 77, 123, 83, 196, 243, 1,
+    ],
+    [
+        1, 56, 52, 85, 134, 51, 29, 82, 223, 152, 31, 194, 70, 65, 42, 39, 128, 229, 231, 86, 190,
+        103, 114, 216, 17, 181, 113, 160, 222, 96, 236, 109, 193, 14, 13, 214, 162, 77, 200, 149,
+        120, 38, 72, 177, 146, 209, 139, 74, 32, 250, 122, 150, 176, 90, 157, 54, 197, 238, 221, 40,
+        184, 24, 59, 220, 241, 132, 196, 182, 169, 212, 50, 230, 30, 138, 18, 237, 165, 245, 99,
+        147, 8, 191, 159, 166, 44, 151, 232, 142, 242, 188, 248, 10, 46, 6, 79, 55, 253, 33, 49,
+        174, 235, 53, 141, 186, 136, 163, 133, 252, 234, 254, 89, 101, 2, 112, 104, 170, 11, 102,
+        58, 164, 189, 47, 62, 131, 140, 130, 84, 78, 256, 201, 205, 172, 123, 206, 228, 175, 34,
+        105, 226, 63, 187, 192, 215, 218, 129, 28, 26, 171, 67, 154, 143, 41, 240, 76, 144, 97, 35,
+        161, 21, 148, 64, 243, 244, 43, 95, 180, 57, 108, 137, 219, 185, 80, 111, 48, 118, 183, 225,
+        7, 135, 107, 81, 167, 100, 203, 60, 19, 36, 217, 73, 233, 198, 37, 16, 125, 61, 75, 88, 45,
+        207, 27, 227, 119, 239, 20, 92, 12, 158, 110, 249, 66, 98, 91, 213, 106, 25, 115, 15, 69, 9,
+        247, 211, 251, 178, 202, 4, 224, 208, 83, 22, 204, 116, 71, 121, 94, 124, 5, 23, 3, 168,
+        156, 255, 145, 153, 87, 246, 155, 199, 93, 68, 210, 195, 126, 117, 127, 173, 179, 1,
+    ],
+    [
+        1, 57, 165, 153, 240, 59, 22, 226, 32, 25, 140, 13, 227, 89, 190, 36, 253, 29, 111, 159, 68,
+        21, 169, 124, 129, 157, 211, 205, 120, 158, 11, 113, 16, 141, 70, 135, 242, 173, 95, 18,
+        255, 143, 184, 208, 34, 139, 213, 62, 193, 207, 234, 231, 60, 79, 134, 185, 8, 199, 35, 196,
+        121, 215, 176, 9, 256, 200, 92, 104, 17, 198, 235, 31, 225, 232, 117, 244, 30, 168, 67, 221,
+        4, 228, 146, 98, 189, 236, 88, 133, 128, 100, 46, 52, 137, 99, 246, 144, 241, 116, 187, 122,
+        15, 84, 162, 239, 2, 114, 73, 49, 223, 118, 44, 195, 64, 50, 23, 26, 197, 178, 123, 72, 249,
+        58, 222, 61, 136, 42, 81, 248, 1, 57, 165, 153, 240, 59, 22, 226, 32, 25, 140, 13, 227, 89,
+        190, 36, 253, 29, 111, 159, 68, 21, 169, 124, 129, 157, 211, 205, 120, 158, 11, 113, 16,
+        141, 70, 135, 242, 173, 95, 18, 255, 143, 184, 208, 34, 139, 213, 62, 193, 207, 234, 231,
+        60, 79, 134, 185, 8, 199, 35, 196, 121, 215, 176, 9, 256, 200, 92, 104, 17, 198, 235, 31,
+        225, 232, 117, 244, 30, 168, 67, 221, 4, 228, 146, 98, 189, 236, 88, 133, 128, 100, 46, 52,
+        137, 99, 246, 144, 241, 116, 187, 122, 15, 84, 162, 239, 2, 114, 73, 49, 223, 118, 44, 195,
+        64, 50, 23, 26, 197, 178, 123, 72, 249, 58, 222, 61, 136, 42, 81, 248, 1,
+    ],
+    [
+        1, 58, 23, 49, 15, 99, 88, 221, 225, 200, 35, 231, 34, 173, 11, 124, 253, 25, 165, 61, 197,
+        118, 162, 144, 128, 228, 117, 104, 121, 79, 213, 18, 16, 157, 111, 13, 240, 42, 123, 195, 2,
+        116, 46, 98, 30, 198, 176, 185, 193, 143, 70, 205, 68, 89, 22, 248, 249, 50, 73, 122, 137,
+        236, 67, 31, 256, 199, 234, 208, 242, 158, 169, 36, 32, 57, 222, 26, 223, 84, 246, 133, 4,
+        232, 92, 196, 60, 139, 95, 113, 129, 29, 140, 153, 136, 178, 44, 239, 241, 100, 146, 244,
+        17, 215, 134, 62, 255, 141, 211, 159, 227, 59, 81, 72, 64, 114, 187, 52, 189, 168, 235, 9,
+        8, 207, 184, 135, 120, 21, 190, 226, 1, 58, 23, 49, 15, 99, 88, 221, 225, 200, 35, 231, 34,
+        173, 11, 124, 253, 25, 165, 61, 197, 118, 162, 144, 128, 228, 117, 104, 121, 79, 213, 18,
+        16, 157, 111, 13, 240, 42, 123, 195, 2, 116, 46, 98, 30, 198, 176, 185, 193, 143, 70, 205,
+        68, 89, 22, 248, 249, 50, 73, 122, 137, 236, 67, 31, 256, 199, 234, 208, 242, 158, 169, 36,
+        32, 57, 222, 26, 223, 84, 246, 133, 4, 232, 92, 196, 60, 139, 95, 113, 129, 29, 140, 153,
+        136, 178, 44, 239, 241, 100, 146, 244, 17, 215, 134, 62, 255, 141, 211, 159, 227, 59, 81,
+        72, 64, 114, 187, 52, 189, 168, 235, 9, 8, 207, 184, 135, 120, 21, 190, 226, 1,
+    ],
+    [
+        1, 59, 140, 36, 68, 157, 11, 135, 255, 139, 234, 185, 121, 200, 235, 244, 4, 236, 46, 144,
+        15, 114, 44, 26, 249, 42, 165, 226, 227, 29, 169, 205, 16, 173, 184, 62, 60, 199, 176, 104,
+        225, 168, 146, 133, 137, 116, 162, 49, 64, 178, 222, 248, 240, 25, 190, 159, 129, 158, 70,
+        18, 34, 207, 134, 196, 256, 198, 117, 221, 189, 100, 246, 122, 2, 118, 23, 72, 136, 57, 22,
+        13, 253, 21, 211, 113, 242, 143, 213, 231, 8, 215, 92, 31, 30, 228, 88, 52, 241, 84, 73,
+        195, 197, 58, 81, 153, 32, 89, 111, 124, 120, 141, 95, 208, 193, 79, 35, 9, 17, 232, 67, 98,
+        128, 99, 187, 239, 223, 50, 123, 61, 1, 59, 140, 36, 68, 157, 11, 135, 255, 139, 234, 185,
+        121, 200, 235, 244, 4, 236, 46, 144, 15, 114, 44, 26, 249, 42, 165, 226, 227, 29, 169, 205,
+        16, 173, 184, 62, 60, 199, 176, 104, 225, 168, 146, 133, 137, 116, 162, 49, 64, 178, 222,
+        248, 240, 25, 190, 159, 129, 158, 70, 18, 34, 207, 134, 196, 256, 198, 117, 221, 189, 100,
+        246, 122, 2, 118, 23, 72, 136, 57, 22, 13, 253, 21, 211, 113, 242, 143, 213, 231, 8, 215,
+        92, 31, 30, 228, 88, 52, 241, 84, 73, 195, 197, 58, 81, 153, 32, 89, 111, 124, 120, 141, 95,
+        208, 193, 79, 35, 9, 17, 232, 67, 98, 128, 99, 187, 239, 223, 50, 123, 61, 1,
+    ],
+    [
+        1, 60, 2, 120, 4, 240, 8, 223, 16, 189, 32, 121, 64, 242, 128, 227, 256, 197, 255, 137, 253,
+        17, 249, 34, 241, 68, 225, 136, 193, 15, 129, 30, 1, 60, 2, 120, 4, 240, 8, 223, 16, 189,
+        32, 121, 64, 242, 128, 227, 256, 197, 255, 137, 253, 17, 249, 34, 241, 68, 225, 136, 193,
+        15, 129, 30, 1, 60, 2, 120, 4, 240, 8, 223, 16, 189, 32, 121, 64, 242, 128, 227, 256, 197,
+        255, 137, 253, 17, 249, 34, 241, 68, 225, 136, 193, 15, 129, 30, 1, 60, 2, 120, 4, 240, 8,
+        223, 16, 189, 32, 121, 64, 242, 128, 227, 256, 197, 255, 137, 253, 17, 249, 34, 241, 68,
+        225, 136, 193, 15, 129, 30, 1, 60, 2, 120, 4, 240, 8, 223, 16, 189, 32, 121, 64, 242, 128,
+        227, 256, 197, 255, 137, 253, 17, 249, 34, 241, 68, 225, 136, 193, 15, 129, 30, 1, 60, 2,
+        120, 4, 240, 8, 223, 16, 189, 32, 121, 64, 242, 128, 227, 256, 197, 255, 137, 253, 17, 249,
+        34, 241, 68, 225, 136, 193, 15, 129, 30, 1, 60, 2, 120, 4, 240, 8, 223, 16, 189, 32, 121,
+        64, 242, 128, 227, 256, 197, 255, 137, 253, 17, 249, 34, 241, 68, 225, 136, 193, 15, 129,
+        30, 1, 60, 2, 120, 4, 240, 8, 223, 16, 189, 32, 121, 64, 242, 128, 227, 256, 197, 255, 137,
+        253, 17, 249, 34, 241, 68, 225, 136, 193, 15, 129, 30, 1,
+    ],
+    [
+        1, 61, 123, 50, 223, 239, 187, 99, 128, 98, 67, 232, 17, 9, 35, 79, 193, 208, 95, 141, 120,
+        124, 111, 89, 32, 153, 81, 58, 197, 195, 73, 84, 241, 52, 88, 228, 30, 31, 92, 215, 8, 231,
+        213, 143, 242, 113, 211, 21, 253, 13, 22, 57, 136, 72, 23, 118, 2, 122, 246, 100, 189, 221,
+        117, 198, 256, 196, 134, 207, 34, 18, 70, 158, 129, 159, 190, 25, 240, 248, 222, 178, 64,
+        49, 162, 116, 137, 133, 146, 168, 225, 104, 176, 199, 60, 62, 184, 173, 16, 205, 169, 29,
+        227, 226, 165, 42, 249, 26, 44, 114, 15, 144, 46, 236, 4, 244, 235, 200, 121, 185, 234, 139,
+        255, 135, 11, 157, 68, 36, 140, 59, 1, 61, 123, 50, 223, 239, 187, 99, 128, 98, 67, 232, 17,
+        9, 35, 79, 193, 208, 95, 141, 120, 124, 111, 89, 32, 153, 81, 58, 197, 195, 73, 84, 241, 52,
+        88, 228, 30, 31, 92, 215, 8, 231, 213, 143, 242, 113, 211, 21, 253, 13, 22, 57, 136, 72, 23,
+        118, 2, 122, 246, 100, 189, 221, 117, 198, 256, 196, 134, 207, 34, 18, 70, 158, 129, 159,
+        190, 25, 240, 248, 222, 178, 64, 49, 162, 116, 137, 133, 146, 168, 225, 104, 176, 199, 60,
+        62, 184, 173, 16, 205, 169, 29, 227, 226, 165, 42, 249, 26, 44, 114, 15, 144, 46, 236, 4,
+        244, 235, 200, 121, 185, 234, 139, 255, 135, 11, 157, 68, 36, 140, 59, 1,
+    ],
+    [
+        1, 62, 246, 89, 121, 49, 211, 232, 249, 18, 88, 59, 60, 122, 111, 200, 64, 113, 67, 42, 34,
+        52, 140, 199, 2, 124, 235, 178, 242, 98, 165, 207, 241, 36, 176, 118, 120, 244, 222, 143,
+        128, 226, 134, 84, 68, 104, 23, 141, 4, 248, 213, 99, 227, 196, 73, 157, 225, 72, 95, 236,
+        240, 231, 187, 29, 256, 195, 11, 168, 136, 208, 46, 25, 8, 239, 169, 198, 197, 135, 146, 57,
+        193, 144, 190, 215, 223, 205, 117, 58, 255, 133, 22, 79, 15, 159, 92, 50, 16, 221, 81, 139,
+        137, 13, 35, 114, 129, 31, 123, 173, 189, 153, 234, 116, 253, 9, 44, 158, 30, 61, 184, 100,
+        32, 185, 162, 21, 17, 26, 70, 228, 1, 62, 246, 89, 121, 49, 211, 232, 249, 18, 88, 59, 60,
+        122, 111, 200, 64, 113, 67, 42, 34, 52, 140, 199, 2, 124, 235, 178, 242, 98, 165, 207, 241,
+        36, 176, 118, 120, 244, 222, 143, 128, 226, 134, 84, 68, 104, 23, 141, 4, 248, 213, 99, 227,
+        196, 73, 157, 225, 72, 95, 236, 240, 231, 187, 29, 256, 195, 11, 168, 136, 208, 46, 25, 8,
+        239, 169, 198, 197, 135, 146, 57, 193, 144, 190, 215, 223, 205, 117, 58, 255, 133, 22, 79,
+        15, 159, 92, 50, 16, 221, 81, 139, 137, 13, 35, 114, 129, 31, 123, 173, 189, 153, 234, 116,
+        253, 9, 44, 158, 30, 61, 184, 100, 32, 185, 162, 21, 17, 26, 70, 228, 1,
+    ],
+    [
+        1, 63, 114, 243, 146, 203, 196, 12, 242, 83, 89, 210, 123, 39, 144, 77, 225, 40, 207, 191,
+        211, 186, 153, 130, 223, 171, 236, 219, 176, 37, 18, 106, 253, 5, 58, 56, 187, 216, 244,
+        209, 60, 182, 158, 188, 22, 101, 195, 206, 128, 97, 200, 7, 184, 27, 159, 251, 136, 87, 84,
+        152, 67, 109, 185, 90, 16, 237, 25, 33, 23, 164, 52, 192, 17, 43, 139, 19, 169, 110, 248,
+        204, 2, 126, 228, 229, 35, 149, 135, 24, 227, 166, 178, 163, 246, 78, 31, 154, 193, 80, 157,
+        125, 165, 115, 49, 3, 189, 85, 215, 181, 95, 74, 36, 212, 249, 10, 116, 112, 117, 175, 231,
+        161, 120, 107, 59, 119, 44, 202, 133, 155, 256, 194, 143, 14, 111, 54, 61, 245, 15, 174,
+        168, 47, 134, 218, 113, 180, 32, 217, 50, 66, 46, 71, 104, 127, 34, 86, 21, 38, 81, 220,
+        239, 151, 4, 252, 199, 201, 70, 41, 13, 48, 197, 75, 99, 69, 235, 156, 62, 51, 129, 160, 57,
+        250, 73, 230, 98, 6, 121, 170, 173, 105, 190, 148, 72, 167, 241, 20, 232, 224, 234, 93, 205,
+        65, 240, 214, 118, 238, 88, 147, 9, 53, 255, 131, 29, 28, 222, 108, 122, 233, 30, 91, 79,
+        94, 11, 179, 226, 103, 64, 177, 100, 132, 92, 142, 208, 254, 68, 172, 42, 76, 162, 183, 221,
+        45, 8, 247, 141, 145, 140, 82, 26, 96, 137, 150, 198, 138, 213, 55, 124, 102, 1,
+    ],
+    [
+        1, 64, 241, 4, 256, 193, 16, 253, 1, 64, 241, 4, 256, 193, 16, 253, 1, 64, 241, 4, 256, 193,
+        16, 253, 1, 64, 241, 4, 256, 193, 16, 253, 1, 64, 241, 4, 256, 193, 16, 253, 1, 64, 241, 4,
+        256, 193, 16, 253, 1, 64, 241, 4, 256, 193, 16, 253, 1, 64, 241, 4, 256, 193, 16, 253, 1,
+        64, 241, 4, 256, 193, 16, 253, 1, 64, 241, 4, 256, 193, 16, 253, 1, 64, 241, 4, 256, 193,
+        16, 253, 1, 64, 241, 4, 256, 193, 16, 253, 1, 64, 241, 4, 256, 193, 16, 253, 1, 64, 241, 4,
+        256, 193, 16, 253, 1, 64, 241, 4, 256, 193, 16, 253, 1, 64, 241, 4, 256, 193, 16, 253, 1,
+        64, 241, 4, 256, 193, 16, 253, 1, 64, 241, 4, 256, 193, 16, 253, 1, 64, 241, 4, 256, 193,
+        16, 253, 1, 64, 241, 4, 256, 193, 16, 253, 1, 64, 241, 4, 256, 193, 16, 253, 1, 64, 241, 4,
+        256, 193, 16, 253, 1, 64, 241, 4, 256, 193, 16, 253, 1, 64, 241, 4, 256, 193, 16, 253, 1,
+        64, 241, 4, 256, 193, 16, 253, 1, 64, 241, 4, 256, 193, 16, 253, 1, 64, 241, 4, 256, 193,
+        16, 253, 1, 64, 241, 4, 256, 193, 16, 253, 1, 64, 241, 4, 256, 193, 16, 253, 1, 64, 241, 4,
+        256, 193, 16, 253, 1, 64, 241, 4, 256, 193, 16, 253, 1, 64, 241, 4, 256, 193, 16, 253, 1,
+    ],
+    [
+        1, 65, 113, 149, 176, 132, 99, 10, 136, 102, 205, 218, 35, 219, 100, 75, 249, 251, 124, 93,
+        134, 229, 236, 177, 197, 212, 159, 55, 234, 47, 228, 171, 64, 48, 36, 27, 213, 224, 168,
+        126, 223, 103, 13, 74, 184, 138, 232, 174, 2, 130, 226, 41, 95, 7, 198, 20, 15, 204, 153,
+        179, 70, 181, 200, 150, 241, 245, 248, 186, 11, 201, 215, 97, 137, 167, 61, 110, 211, 94,
+        199, 85, 128, 96, 72, 54, 169, 191, 79, 252, 189, 206, 26, 148, 111, 19, 207, 91, 4, 3, 195,
+        82, 190, 14, 139, 40, 30, 151, 49, 101, 140, 105, 143, 43, 225, 233, 239, 115, 22, 145, 173,
+        194, 17, 77, 122, 220, 165, 188, 141, 170, 256, 192, 144, 108, 81, 125, 158, 247, 121, 155,
+        52, 39, 222, 38, 157, 182, 8, 6, 133, 164, 123, 28, 21, 80, 60, 45, 98, 202, 23, 210, 29,
+        86, 193, 209, 221, 230, 44, 33, 89, 131, 34, 154, 244, 183, 73, 119, 25, 83, 255, 127, 31,
+        216, 162, 250, 59, 237, 242, 53, 104, 78, 187, 76, 57, 107, 16, 12, 9, 71, 246, 56, 42, 160,
+        120, 90, 196, 147, 46, 163, 58, 172, 129, 161, 185, 203, 88, 66, 178, 5, 68, 51, 231, 109,
+        146, 238, 50, 166, 253, 254, 62, 175, 67, 243, 118, 217, 227, 106, 208, 156, 117, 152, 114,
+        214, 32, 24, 18, 142, 235, 112, 84, 63, 240, 180, 135, 37, 92, 69, 116, 87, 1,
+    ],
+    [
+        1, 66, 244, 170, 169, 103, 116, 203, 34, 188, 72, 126, 92, 161, 89, 220, 128, 224, 135, 172,
+        44, 77, 199, 27, 240, 163, 221, 194, 211, 48, 84, 147, 193, 145, 61, 171, 235, 90, 29, 115,
+        137, 47, 18, 160, 23, 233, 215, 55, 32, 56, 98, 43, 11, 212, 114, 71, 60, 105, 248, 177,
+        117, 12, 21, 101, 241, 229, 208, 107, 123, 151, 200, 93, 227, 76, 133, 40, 70, 251, 118, 78,
+        8, 14, 153, 75, 67, 53, 157, 82, 15, 219, 62, 237, 222, 3, 198, 218, 253, 250, 52, 91, 95,
+        102, 50, 216, 121, 19, 226, 10, 146, 127, 158, 148, 2, 132, 231, 83, 81, 206, 232, 149, 68,
+        119, 144, 252, 184, 65, 178, 183, 256, 191, 13, 87, 88, 154, 141, 54, 223, 69, 185, 131,
+        165, 96, 168, 37, 129, 33, 122, 85, 213, 180, 58, 230, 17, 94, 36, 63, 46, 209, 173, 110,
+        64, 112, 196, 86, 22, 167, 228, 142, 120, 210, 239, 97, 234, 24, 42, 202, 225, 201, 159,
+        214, 246, 45, 143, 186, 197, 152, 9, 80, 140, 245, 236, 156, 16, 28, 49, 150, 134, 106, 57,
+        164, 30, 181, 124, 217, 187, 6, 139, 179, 249, 243, 104, 182, 190, 204, 100, 175, 242, 38,
+        195, 20, 35, 254, 59, 39, 4, 7, 205, 166, 162, 155, 207, 41, 136, 238, 31, 247, 111, 130,
+        99, 109, 255, 125, 26, 174, 176, 51, 25, 108, 189, 138, 113, 5, 73, 192, 79, 74, 1,
+    ],
+    [
+        1, 67, 120, 73, 8, 22, 189, 70, 64, 176, 227, 46, 255, 123, 17, 111, 241, 213, 136, 117,
+        129, 162, 60, 165, 4, 11, 223, 35, 32, 88, 242, 23, 256, 190, 137, 184, 249, 235, 68, 187,
+        193, 81, 30, 211, 2, 134, 240, 146, 16, 44, 121, 140, 128, 95, 197, 92, 253, 246, 34, 222,
+        225, 169, 15, 234, 1, 67, 120, 73, 8, 22, 189, 70, 64, 176, 227, 46, 255, 123, 17, 111, 241,
+        213, 136, 117, 129, 162, 60, 165, 4, 11, 223, 35, 32, 88, 242, 23, 256, 190, 137, 184, 249,
+        235, 68, 187, 193, 81, 30, 211, 2, 134, 240, 146, 16, 44, 121, 140, 128, 95, 197, 92, 253,
+        246, 34, 222, 225, 169, 15, 234, 1, 67, 120, 73, 8, 22, 189, 70, 64, 176, 227, 46, 255, 123,
+        17, 111, 241, 213, 136, 117, 129, 162, 60, 165, 4, 11, 223, 35, 32, 88, 242, 23, 256, 190,
+        137, 184, 249, 235, 68, 187, 193, 81, 30, 211, 2, 134, 240, 146, 16, 44, 121, 140, 128, 95,
+        197, 92, 253, 246, 34, 222, 225, 169, 15, 234, 1, 67, 120, 73, 8, 22, 189, 70, 64, 176, 227,
+        46, 255, 123, 17, 111, 241, 213, 136, 117, 129, 162, 60, 165, 4, 11, 223, 35, 32, 88, 242,
+        23, 256, 190, 137, 184, 249, 235, 68, 187, 193, 81, 30, 211, 2, 134, 240, 146, 16, 44, 121,
+        140, 128, 95, 197, 92, 253, 246, 34, 222, 225, 169, 15, 234, 1,
+    ],
+    [
+        1, 68, 255, 121, 4, 15, 249, 227, 16, 60, 225, 137, 64, 240, 129, 34, 256, 189, 2, 136, 253,
+        242, 8, 30, 241, 197, 32, 120, 193, 17, 128, 223, 1, 68, 255, 121, 4, 15, 249, 227, 16, 60,
+        225, 137, 64, 240, 129, 34, 256, 189, 2, 136, 253, 242, 8, 30, 241, 197, 32, 120, 193, 17,
+        128, 223, 1, 68, 255, 121, 4, 15, 249, 227, 16, 60, 225, 137, 64, 240, 129, 34, 256, 189, 2,
+        136, 253, 242, 8, 30, 241, 197, 32, 120, 193, 17, 128, 223, 1, 68, 255, 121, 4, 15, 249,
+        227, 16, 60, 225, 137, 64, 240, 129, 34, 256, 189, 2, 136, 253, 242, 8, 30, 241, 197, 32,
+        120, 193, 17, 128, 223, 1, 68, 255, 121, 4, 15, 249, 227, 16, 60, 225, 137, 64, 240, 129,
+        34, 256, 189, 2, 136, 253, 242, 8, 30, 241, 197, 32, 120, 193, 17, 128, 223, 1, 68, 255,
+        121, 4, 15, 249, 227, 16, 60, 225, 137, 64, 240, 129, 34, 256, 189, 2, 136, 253, 242, 8, 30,
+        241, 197, 32, 120, 193, 17, 128, 223, 1, 68, 255, 121, 4, 15, 249, 227, 16, 60, 225, 137,
+        64, 240, 129, 34, 256, 189, 2, 136, 253, 242, 8, 30, 241, 197, 32, 120, 193, 17, 128, 223,
+        1, 68, 255, 121, 4, 15, 249, 227, 16, 60, 225, 137, 64, 240, 129, 34, 256, 189, 2, 136, 253,
+        242, 8, 30, 241, 197, 32, 120, 193, 17, 128, 223, 1,
+    ],
+    [
+        1, 69, 135, 63, 235, 24, 114, 156, 227, 243, 62, 166, 146, 51, 178, 203, 129, 163, 196, 160,
+        246, 12, 57, 78, 242, 250, 31, 83, 73, 154, 89, 230, 193, 210, 98, 80, 123, 6, 157, 39, 121,
+        125, 144, 170, 165, 77, 173, 115, 225, 105, 49, 40, 190, 3, 207, 148, 189, 191, 72, 85, 211,
+        167, 215, 186, 241, 181, 153, 20, 95, 130, 232, 74, 223, 224, 36, 171, 234, 212, 236, 93,
+        249, 219, 205, 10, 176, 65, 116, 37, 240, 112, 18, 214, 117, 106, 118, 175, 253, 238, 231,
+        5, 88, 161, 58, 147, 120, 56, 9, 107, 187, 53, 59, 216, 255, 119, 244, 131, 44, 209, 29,
+        202, 60, 28, 133, 182, 222, 155, 158, 108, 256, 188, 122, 194, 22, 233, 143, 101, 30, 14,
+        195, 91, 111, 206, 79, 54, 128, 94, 61, 97, 11, 245, 200, 179, 15, 7, 226, 174, 184, 103,
+        168, 27, 64, 47, 159, 177, 134, 251, 100, 218, 136, 132, 113, 87, 92, 180, 84, 142, 32, 152,
+        208, 217, 67, 254, 50, 109, 68, 66, 185, 172, 46, 90, 42, 71, 16, 76, 104, 237, 162, 127,
+        25, 183, 34, 33, 221, 86, 23, 45, 21, 164, 8, 38, 52, 247, 81, 192, 141, 220, 17, 145, 239,
+        43, 140, 151, 139, 82, 4, 19, 26, 252, 169, 96, 199, 110, 137, 201, 248, 150, 70, 204, 198,
+        41, 2, 138, 13, 126, 213, 48, 228, 55, 197, 229, 124, 75, 35, 102, 99, 149, 1,
+    ],
+    [
+        1, 70, 17, 162, 32, 184, 30, 44, 253, 234, 189, 123, 129, 35, 137, 81, 16, 92, 15, 22, 255,
+        117, 223, 190, 193, 146, 197, 169, 8, 46, 136, 11, 256, 187, 240, 95, 225, 73, 227, 213, 4,
+        23, 68, 134, 128, 222, 120, 176, 241, 165, 242, 235, 2, 140, 34, 67, 64, 111, 60, 88, 249,
+        211, 121, 246, 1, 70, 17, 162, 32, 184, 30, 44, 253, 234, 189, 123, 129, 35, 137, 81, 16,
+        92, 15, 22, 255, 117, 223, 190, 193, 146, 197, 169, 8, 46, 136, 11, 256, 187, 240, 95, 225,
+        73, 227, 213, 4, 23, 68, 134, 128, 222, 120, 176, 241, 165, 242, 235, 2, 140, 34, 67, 64,
+        111, 60, 88, 249, 211, 121, 246, 1, 70, 17, 162, 32, 184, 30, 44, 253, 234, 189, 123, 129,
+        35, 137, 81, 16, 92, 15, 22, 255, 117, 223, 190, 193, 146, 197, 169, 8, 46, 136, 11, 256,
+        187, 240, 95, 225, 73, 227, 213, 4, 23, 68, 134, 128, 222, 120, 176, 241, 165, 242, 235, 2,
+        140, 34, 67, 64, 111, 60, 88, 249, 211, 121, 246, 1, 70, 17, 162, 32, 184, 30, 44, 253, 234,
+        189, 123, 129, 35, 137, 81, 16, 92, 15, 22, 255, 117, 223, 190, 193, 146, 197, 169, 8, 46,
+        136, 11, 256, 187, 240, 95, 225, 73, 227, 213, 4, 23, 68, 134, 128, 222, 120, 176, 241, 165,
+        242, 235, 2, 140, 34, 67, 64, 111, 60, 88, 249, 211, 121, 246, 1,
+    ],
+    [
+        1, 71, 158, 167, 35, 172, 133, 191, 197, 109, 29, 3, 213, 217, 244, 105, 2, 142, 59, 77, 70,
+        87, 9, 125, 137, 218, 58, 6, 169, 177, 231, 210, 4, 27, 118, 154, 140, 174, 18, 250, 17,
+        179, 116, 12, 81, 97, 205, 163, 8, 54, 236, 51, 23, 91, 36, 243, 34, 101, 232, 24, 162, 194,
+        153, 69, 16, 108, 215, 102, 46, 182, 72, 229, 68, 202, 207, 48, 67, 131, 49, 138, 32, 216,
+        173, 204, 92, 107, 144, 201, 136, 147, 157, 96, 134, 5, 98, 19, 64, 175, 89, 151, 184, 214,
+        31, 145, 15, 37, 57, 192, 11, 10, 196, 38, 128, 93, 178, 45, 111, 171, 62, 33, 30, 74, 114,
+        127, 22, 20, 135, 76, 256, 186, 99, 90, 222, 85, 124, 66, 60, 148, 228, 254, 44, 40, 13,
+        152, 255, 115, 198, 180, 187, 170, 248, 132, 120, 39, 199, 251, 88, 80, 26, 47, 253, 230,
+        139, 103, 117, 83, 239, 7, 240, 78, 141, 245, 176, 160, 52, 94, 249, 203, 21, 206, 234, 166,
+        221, 14, 223, 156, 25, 233, 95, 63, 104, 188, 241, 149, 42, 155, 211, 75, 185, 28, 189, 55,
+        50, 209, 190, 126, 208, 119, 225, 41, 84, 53, 165, 150, 113, 56, 121, 110, 100, 161, 123,
+        252, 159, 238, 193, 82, 168, 106, 73, 43, 226, 112, 242, 220, 200, 65, 246, 247, 61, 219,
+        129, 164, 79, 212, 146, 86, 195, 224, 227, 183, 143, 130, 235, 237, 122, 181, 1,
+    ],
+    [
+        1, 72, 44, 84, 137, 98, 117, 200, 8, 62, 95, 158, 68, 13, 165, 58, 64, 239, 246, 236, 30,
+        104, 35, 207, 255, 113, 169, 89, 240, 61, 23, 114, 241, 133, 67, 198, 121, 231, 184, 141,
+        129, 36, 22, 42, 197, 49, 187, 100, 4, 31, 176, 79, 34, 135, 211, 29, 32, 248, 123, 118, 15,
+        52, 146, 232, 256, 185, 213, 173, 120, 159, 140, 57, 249, 195, 162, 99, 189, 244, 92, 199,
+        193, 18, 11, 21, 227, 153, 222, 50, 2, 144, 88, 168, 17, 196, 234, 143, 16, 124, 190, 59,
+        136, 26, 73, 116, 128, 221, 235, 215, 60, 208, 70, 157, 253, 226, 81, 178, 223, 122, 46,
+        228, 225, 9, 134, 139, 242, 205, 111, 25, 1, 72, 44, 84, 137, 98, 117, 200, 8, 62, 95, 158,
+        68, 13, 165, 58, 64, 239, 246, 236, 30, 104, 35, 207, 255, 113, 169, 89, 240, 61, 23, 114,
+        241, 133, 67, 198, 121, 231, 184, 141, 129, 36, 22, 42, 197, 49, 187, 100, 4, 31, 176, 79,
+        34, 135, 211, 29, 32, 248, 123, 118, 15, 52, 146, 232, 256, 185, 213, 173, 120, 159, 140,
+        57, 249, 195, 162, 99, 189, 244, 92, 199, 193, 18, 11, 21, 227, 153, 222, 50, 2, 144, 88,
+        168, 17, 196, 234, 143, 16, 124, 190, 59, 136, 26, 73, 116, 128, 221, 235, 215, 60, 208, 70,
+        157, 253, 226, 81, 178, 223, 122, 46, 228, 225, 9, 134, 139, 242, 205, 111, 25, 1,
+    ],
+    [
+        1, 73, 189, 176, 255, 111, 136, 162, 4, 35, 242, 190, 249, 187, 30, 134, 16, 140, 197, 246,
+        225, 234, 120, 22, 64, 46, 17, 213, 129, 165, 223, 88, 256, 184, 68, 81, 2, 146, 121, 95,
+        253, 222, 15, 67, 8, 70, 227, 123, 241, 117, 60, 11, 32, 23, 137, 235, 193, 211, 240, 44,
+        128, 92, 34, 169, 1, 73, 189, 176, 255, 111, 136, 162, 4, 35, 242, 190, 249, 187, 30, 134,
+        16, 140, 197, 246, 225, 234, 120, 22, 64, 46, 17, 213, 129, 165, 223, 88, 256, 184, 68, 81,
+        2, 146, 121, 95, 253, 222, 15, 67, 8, 70, 227, 123, 241, 117, 60, 11, 32, 23, 137, 235, 193,
+        211, 240, 44, 128, 92, 34, 169, 1, 73, 189, 176, 255, 111, 136, 162, 4, 35, 242, 190, 249,
+        187, 30, 134, 16, 140, 197, 246, 225, 234, 120, 22, 64, 46, 17, 213, 129, 165, 223, 88, 256,
+        184, 68, 81, 2, 146, 121, 95, 253, 222, 15, 67, 8, 70, 227, 123, 241, 117, 60, 11, 32, 23,
+        137, 235, 193, 211, 240, 44, 128, 92, 34, 169, 1, 73, 189, 176, 255, 111, 136, 162, 4, 35,
+        242, 190, 249, 187, 30, 134, 16, 140, 197, 246, 225, 234, 120, 22, 64, 46, 17, 213, 129,
+        165, 223, 88, 256, 184, 68, 81, 2, 146, 121, 95, 253, 222, 15, 67, 8, 70, 227, 123, 241,
+        117, 60, 11, 32, 23, 137, 235, 193, 211, 240, 44, 128, 92, 34, 169, 1,
+    ],
+    [
+        1, 74, 79, 192, 73, 5, 113, 138, 189, 108, 25, 51, 176, 174, 26, 125, 255, 109, 99, 130,
+        111, 247, 31, 238, 136, 41, 207, 155, 162, 166, 205, 7, 4, 39, 59, 254, 35, 20, 195, 38,
+        242, 175, 100, 204, 190, 182, 104, 243, 249, 179, 139, 6, 187, 217, 124, 181, 30, 164, 57,
+        106, 134, 150, 49, 28, 16, 156, 236, 245, 140, 80, 9, 152, 197, 186, 143, 45, 246, 214, 159,
+        201, 225, 202, 42, 24, 234, 97, 239, 210, 120, 142, 228, 167, 22, 86, 196, 112, 64, 110,
+        173, 209, 46, 63, 36, 94, 17, 230, 58, 180, 213, 85, 122, 33, 129, 37, 168, 96, 165, 131,
+        185, 69, 223, 54, 141, 154, 88, 87, 13, 191, 256, 183, 178, 65, 184, 252, 144, 119, 68, 149,
+        232, 206, 81, 83, 231, 132, 2, 148, 158, 127, 146, 10, 226, 19, 121, 216, 50, 102, 95, 91,
+        52, 250, 253, 218, 198, 3, 222, 237, 62, 219, 15, 82, 157, 53, 67, 75, 153, 14, 8, 78, 118,
+        251, 70, 40, 133, 76, 227, 93, 200, 151, 123, 107, 208, 229, 241, 101, 21, 12, 117, 177,
+        248, 105, 60, 71, 114, 212, 11, 43, 98, 56, 32, 55, 215, 233, 23, 160, 18, 47, 137, 115, 29,
+        90, 235, 171, 61, 145, 193, 147, 84, 48, 211, 194, 221, 163, 240, 27, 199, 77, 44, 172, 135,
+        224, 128, 220, 89, 161, 92, 126, 72, 188, 34, 203, 116, 103, 169, 170, 244, 66, 1,
+    ],
+    [
+        1, 75, 228, 138, 70, 110, 26, 151, 17, 247, 21, 33, 162, 71, 185, 254, 32, 87, 100, 47, 184,
+        179, 61, 206, 30, 194, 158, 28, 44, 216, 9, 161, 253, 214, 116, 219, 234, 74, 153, 167, 189,
+        40, 173, 125, 123, 230, 31, 12, 129, 166, 114, 69, 35, 55, 13, 204, 137, 252, 139, 145, 81,
+        164, 221, 127, 16, 172, 50, 152, 92, 218, 159, 103, 15, 97, 79, 14, 22, 108, 133, 209, 255,
+        107, 58, 238, 117, 37, 205, 212, 223, 20, 215, 191, 190, 115, 144, 6, 193, 83, 57, 163, 146,
+        156, 135, 102, 197, 126, 198, 201, 169, 82, 239, 192, 8, 86, 25, 76, 46, 109, 208, 180, 136,
+        177, 168, 7, 11, 54, 195, 233, 256, 182, 29, 119, 187, 147, 231, 106, 240, 10, 236, 224, 95,
+        186, 72, 3, 225, 170, 157, 210, 73, 78, 196, 51, 227, 63, 99, 229, 213, 41, 248, 96, 4, 43,
+        141, 38, 23, 183, 104, 90, 68, 217, 84, 132, 134, 27, 226, 245, 128, 91, 143, 188, 222, 202,
+        244, 53, 120, 5, 118, 112, 176, 93, 36, 130, 241, 85, 207, 105, 165, 39, 98, 154, 242, 160,
+        178, 243, 235, 149, 124, 48, 2, 150, 199, 19, 140, 220, 52, 45, 34, 237, 42, 66, 67, 142,
+        113, 251, 64, 174, 200, 94, 111, 101, 122, 155, 60, 131, 59, 56, 88, 175, 18, 65, 249, 171,
+        232, 181, 211, 148, 49, 77, 121, 80, 89, 250, 246, 203, 62, 24, 1,
+    ],
+    [
+        1, 76, 122, 20, 235, 127, 143, 74, 227, 33, 195, 171, 146, 45, 79, 93, 129, 38, 61, 10, 246,
+        192, 200, 37, 242, 145, 226, 214, 73, 151, 168, 175, 193, 19, 159, 5, 123, 96, 100, 147,
+        121, 201, 113, 107, 165, 204, 84, 216, 225, 138, 208, 131, 190, 48, 50, 202, 189, 229, 185,
+        182, 211, 102, 42, 108, 241, 69, 104, 194, 95, 24, 25, 101, 223, 243, 221, 91, 234, 51, 21,
+        54, 249, 163, 52, 97, 176, 12, 141, 179, 240, 250, 239, 174, 117, 154, 139, 27, 253, 210,
+        26, 177, 88, 6, 199, 218, 120, 125, 248, 87, 187, 77, 198, 142, 255, 105, 13, 217, 44, 3,
+        228, 109, 60, 191, 124, 172, 222, 167, 99, 71, 256, 181, 135, 237, 22, 130, 114, 183, 30,
+        224, 62, 86, 111, 212, 178, 164, 128, 219, 196, 247, 11, 65, 57, 220, 15, 112, 31, 43, 184,
+        106, 89, 82, 64, 238, 98, 252, 134, 161, 157, 110, 136, 56, 144, 150, 92, 53, 173, 41, 32,
+        119, 49, 126, 67, 209, 207, 55, 68, 28, 72, 75, 46, 155, 215, 149, 16, 188, 153, 63, 162,
+        233, 232, 156, 34, 14, 36, 166, 23, 206, 236, 203, 8, 94, 205, 160, 81, 245, 116, 78, 17, 7,
+        18, 83, 140, 103, 118, 230, 4, 47, 231, 80, 169, 251, 58, 39, 137, 132, 9, 170, 70, 180, 59,
+        115, 2, 152, 244, 40, 213, 254, 29, 148, 197, 66, 133, 85, 35, 90, 158, 186, 1,
+    ],
+    [
+        1, 77, 18, 101, 67, 19, 178, 85, 120, 245, 104, 41, 73, 224, 29, 177, 8, 102, 144, 37, 22,
+        152, 139, 166, 189, 161, 61, 71, 70, 250, 232, 131, 64, 45, 124, 39, 176, 188, 84, 43, 227,
+        3, 231, 54, 46, 201, 57, 20, 255, 103, 221, 55, 123, 219, 158, 87, 17, 24, 49, 175, 111, 66,
+        199, 160, 241, 53, 226, 183, 213, 210, 236, 182, 136, 192, 135, 115, 117, 14, 50, 252, 129,
+        167, 9, 179, 162, 138, 89, 171, 60, 251, 52, 149, 165, 112, 143, 217, 4, 51, 72, 147, 11,
+        76, 198, 83, 223, 209, 159, 164, 35, 125, 116, 194, 32, 151, 62, 148, 88, 94, 42, 150, 242,
+        130, 244, 27, 23, 229, 157, 10, 256, 180, 239, 156, 190, 238, 79, 172, 137, 12, 153, 216,
+        184, 33, 228, 80, 249, 155, 113, 220, 235, 105, 118, 91, 68, 96, 196, 186, 187, 7, 25, 126,
+        193, 212, 133, 218, 81, 69, 173, 214, 30, 254, 26, 203, 211, 56, 200, 237, 2, 154, 36, 202,
+        134, 38, 99, 170, 240, 233, 208, 82, 146, 191, 58, 97, 16, 204, 31, 74, 44, 47, 21, 75, 121,
+        65, 122, 142, 140, 243, 207, 5, 128, 90, 248, 78, 95, 119, 168, 86, 197, 6, 205, 108, 92,
+        145, 114, 40, 253, 206, 185, 110, 246, 181, 59, 174, 34, 48, 98, 93, 222, 132, 141, 63, 225,
+        106, 195, 109, 169, 163, 215, 107, 15, 127, 13, 230, 234, 28, 100, 247, 1,
+    ],
+    [
+        1, 78, 173, 130, 117, 131, 195, 47, 68, 164, 199, 102, 246, 170, 153, 112, 255, 101, 168,
+        254, 23, 252, 124, 163, 121, 186, 116, 53, 22, 174, 208, 33, 4, 55, 178, 6, 211, 10, 9, 188,
+        15, 142, 25, 151, 213, 166, 98, 191, 249, 147, 158, 245, 92, 237, 239, 138, 227, 230, 207,
+        212, 88, 182, 61, 132, 16, 220, 198, 24, 73, 40, 36, 238, 60, 54, 100, 90, 81, 150, 135,
+        250, 225, 74, 118, 209, 111, 177, 185, 38, 137, 149, 57, 77, 95, 214, 244, 14, 64, 109, 21,
+        96, 35, 160, 144, 181, 240, 216, 143, 103, 67, 86, 26, 229, 129, 39, 215, 65, 187, 194, 226,
+        152, 34, 82, 228, 51, 123, 85, 205, 56, 256, 179, 84, 127, 140, 126, 62, 210, 189, 93, 58,
+        155, 11, 87, 104, 145, 2, 156, 89, 3, 234, 5, 133, 94, 136, 71, 141, 204, 235, 83, 49, 224,
+        253, 202, 79, 251, 46, 247, 248, 69, 242, 115, 232, 106, 44, 91, 159, 66, 8, 110, 99, 12,
+        165, 20, 18, 119, 30, 27, 50, 45, 169, 75, 196, 125, 241, 37, 59, 233, 184, 217, 221, 19,
+        197, 203, 157, 167, 176, 107, 122, 7, 32, 183, 139, 48, 146, 80, 72, 219, 120, 108, 200,
+        180, 162, 43, 13, 243, 193, 148, 236, 161, 222, 97, 113, 76, 17, 41, 114, 154, 190, 171,
+        231, 28, 128, 218, 42, 192, 70, 63, 31, 105, 223, 175, 29, 206, 134, 172, 52, 201, 1,
+    ],
+    [
+        1, 79, 73, 113, 189, 25, 176, 26, 255, 99, 111, 31, 136, 207, 162, 205, 4, 59, 35, 195, 242,
+        100, 190, 104, 249, 139, 187, 124, 30, 57, 134, 49, 16, 236, 140, 9, 197, 143, 246, 159,
+        225, 42, 234, 239, 120, 228, 22, 196, 64, 173, 46, 36, 17, 58, 213, 122, 129, 168, 165, 185,
+        223, 141, 88, 13, 256, 178, 184, 144, 68, 232, 81, 231, 2, 158, 146, 226, 121, 50, 95, 52,
+        253, 198, 222, 62, 15, 157, 67, 153, 8, 118, 70, 133, 227, 200, 123, 208, 241, 21, 117, 248,
+        60, 114, 11, 98, 32, 215, 23, 18, 137, 29, 235, 61, 193, 84, 211, 221, 240, 199, 44, 135,
+        128, 89, 92, 72, 34, 116, 169, 244, 1, 79, 73, 113, 189, 25, 176, 26, 255, 99, 111, 31, 136,
+        207, 162, 205, 4, 59, 35, 195, 242, 100, 190, 104, 249, 139, 187, 124, 30, 57, 134, 49, 16,
+        236, 140, 9, 197, 143, 246, 159, 225, 42, 234, 239, 120, 228, 22, 196, 64, 173, 46, 36, 17,
+        58, 213, 122, 129, 168, 165, 185, 223, 141, 88, 13, 256, 178, 184, 144, 68, 232, 81, 231, 2,
+        158, 146, 226, 121, 50, 95, 52, 253, 198, 222, 62, 15, 157, 67, 153, 8, 118, 70, 133, 227,
+        200, 123, 208, 241, 21, 117, 248, 60, 114, 11, 98, 32, 215, 23, 18, 137, 29, 235, 61, 193,
+        84, 211, 221, 240, 199, 44, 135, 128, 89, 92, 72, 34, 116, 169, 244, 1,
+    ],
+    [
+        1, 80, 232, 56, 111, 142, 52, 48, 242, 85, 118, 188, 134, 183, 248, 51, 225, 10, 29, 7, 46,
+        82, 135, 6, 223, 107, 79, 152, 81, 55, 31, 167, 253, 194, 100, 33, 70, 203, 49, 65, 60, 174,
+        42, 19, 235, 39, 36, 53, 128, 217, 141, 229, 73, 186, 231, 233, 136, 86, 198, 163, 190, 37,
+        133, 103, 16, 252, 114, 125, 234, 216, 61, 254, 17, 75, 89, 181, 88, 101, 113, 45, 2, 160,
+        207, 112, 222, 27, 104, 96, 227, 170, 236, 119, 11, 109, 239, 102, 193, 20, 58, 14, 92, 164,
+        13, 12, 189, 214, 158, 47, 162, 110, 62, 77, 249, 131, 200, 66, 140, 149, 98, 130, 120, 91,
+        84, 38, 213, 78, 72, 106, 256, 177, 25, 201, 146, 115, 205, 209, 15, 172, 139, 69, 123, 74,
+        9, 206, 32, 247, 228, 250, 211, 175, 122, 251, 34, 150, 178, 105, 176, 202, 226, 90, 4, 63,
+        157, 224, 187, 54, 208, 192, 197, 83, 215, 238, 22, 218, 221, 204, 129, 40, 116, 28, 184,
+        71, 26, 24, 121, 171, 59, 94, 67, 220, 124, 154, 241, 5, 143, 132, 23, 41, 196, 3, 240, 182,
+        168, 76, 169, 156, 144, 212, 255, 97, 50, 145, 35, 230, 153, 161, 30, 87, 21, 138, 246, 148,
+        18, 155, 64, 237, 199, 243, 165, 93, 244, 245, 68, 43, 99, 210, 95, 147, 195, 180, 8, 126,
+        57, 191, 117, 108, 159, 127, 137, 166, 173, 219, 44, 179, 185, 151, 1,
+    ],
+    [
+        1, 81, 136, 222, 249, 123, 197, 23, 64, 44, 223, 73, 2, 162, 15, 187, 241, 246, 137, 46,
+        128, 88, 189, 146, 4, 67, 30, 117, 225, 235, 17, 92, 256, 176, 121, 35, 8, 134, 60, 234,
+        193, 213, 34, 184, 255, 95, 242, 70, 16, 11, 120, 211, 129, 169, 68, 111, 253, 190, 227,
+        140, 32, 22, 240, 165, 1, 81, 136, 222, 249, 123, 197, 23, 64, 44, 223, 73, 2, 162, 15, 187,
+        241, 246, 137, 46, 128, 88, 189, 146, 4, 67, 30, 117, 225, 235, 17, 92, 256, 176, 121, 35,
+        8, 134, 60, 234, 193, 213, 34, 184, 255, 95, 242, 70, 16, 11, 120, 211, 129, 169, 68, 111,
+        253, 190, 227, 140, 32, 22, 240, 165, 1, 81, 136, 222, 249, 123, 197, 23, 64, 44, 223, 73,
+        2, 162, 15, 187, 241, 246, 137, 46, 128, 88, 189, 146, 4, 67, 30, 117, 225, 235, 17, 92,
+        256, 176, 121, 35, 8, 134, 60, 234, 193, 213, 34, 184, 255, 95, 242, 70, 16, 11, 120, 211,
+        129, 169, 68, 111, 253, 190, 227, 140, 32, 22, 240, 165, 1, 81, 136, 222, 249, 123, 197, 23,
+        64, 44, 223, 73, 2, 162, 15, 187, 241, 246, 137, 46, 128, 88, 189, 146, 4, 67, 30, 117, 225,
+        235, 17, 92, 256, 176, 121, 35, 8, 134, 60, 234, 193, 213, 34, 184, 255, 95, 242, 70, 16,
+        11, 120, 211, 129, 169, 68, 111, 253, 190, 227, 140, 32, 22, 240, 165, 1,
+    ],
+    [
+        1, 82, 42, 103, 222, 214, 72, 250, 197, 220, 50, 245, 44, 10, 49, 163, 2, 164, 84, 206, 187,
+        171, 144, 243, 137, 183, 100, 233, 88, 20, 98, 69, 4, 71, 168, 155, 117, 85, 31, 229, 17,
+        109, 200, 209, 176, 40, 196, 138, 8, 142, 79, 53, 234, 170, 62, 201, 34, 218, 143, 161, 95,
+        80, 135, 19, 16, 27, 158, 106, 211, 83, 124, 145, 68, 179, 29, 65, 190, 160, 13, 38, 32, 54,
+        59, 212, 165, 166, 248, 33, 136, 101, 58, 130, 123, 63, 26, 76, 64, 108, 118, 167, 73, 75,
+        239, 66, 15, 202, 116, 3, 246, 126, 52, 152, 128, 216, 236, 77, 146, 150, 221, 132, 30, 147,
+        232, 6, 235, 252, 104, 47, 256, 175, 215, 154, 35, 43, 185, 7, 60, 37, 207, 12, 213, 247,
+        208, 94, 255, 93, 173, 51, 70, 86, 113, 14, 120, 74, 157, 24, 169, 237, 159, 188, 253, 186,
+        89, 102, 140, 172, 226, 28, 240, 148, 57, 48, 81, 217, 61, 119, 249, 115, 178, 204, 23, 87,
+        195, 56, 223, 39, 114, 96, 162, 177, 122, 238, 241, 230, 99, 151, 46, 174, 133, 112, 189,
+        78, 228, 192, 67, 97, 244, 219, 225, 203, 198, 45, 92, 91, 9, 224, 121, 156, 199, 127, 134,
+        194, 231, 181, 193, 149, 139, 90, 184, 182, 18, 191, 242, 55, 141, 254, 11, 131, 205, 105,
+        129, 41, 21, 180, 111, 107, 36, 125, 227, 110, 25, 251, 22, 5, 153, 210, 1,
+    ],
+    [
+        1, 83, 207, 219, 187, 101, 159, 90, 17, 126, 178, 125, 95, 175, 133, 245, 32, 86, 199, 69,
+        73, 148, 205, 53, 30, 177, 42, 145, 213, 203, 144, 130, 253, 182, 200, 152, 23, 110, 135,
+        154, 189, 10, 59, 14, 134, 71, 239, 48, 129, 170, 232, 238, 222, 179, 208, 45, 137, 63, 89,
+        191, 176, 216, 195, 251, 16, 43, 228, 163, 165, 74, 231, 155, 15, 217, 21, 201, 235, 230,
+        72, 65, 255, 91, 100, 76, 140, 55, 196, 77, 223, 5, 158, 7, 67, 164, 248, 24, 193, 85, 116,
+        119, 111, 218, 104, 151, 197, 160, 173, 224, 88, 108, 226, 254, 8, 150, 114, 210, 211, 37,
+        244, 206, 136, 237, 139, 229, 246, 115, 36, 161, 256, 174, 50, 38, 70, 156, 98, 167, 240,
+        131, 79, 132, 162, 82, 124, 12, 225, 171, 58, 188, 184, 109, 52, 204, 227, 80, 215, 112, 44,
+        54, 113, 127, 4, 75, 57, 105, 234, 147, 122, 103, 68, 247, 198, 243, 123, 186, 18, 209, 128,
+        87, 25, 19, 35, 78, 49, 212, 120, 194, 168, 66, 81, 41, 62, 6, 241, 214, 29, 94, 92, 183,
+        26, 102, 242, 40, 236, 56, 22, 27, 185, 192, 2, 166, 157, 181, 117, 202, 61, 180, 34, 252,
+        99, 250, 190, 93, 9, 233, 64, 172, 141, 138, 146, 39, 153, 106, 60, 97, 84, 33, 169, 149,
+        31, 3, 249, 107, 143, 47, 46, 220, 13, 51, 121, 20, 118, 28, 11, 142, 221, 96, 1,
+    ],
+    [
+        1, 84, 117, 62, 68, 58, 246, 104, 255, 89, 23, 133, 121, 141, 22, 49, 4, 79, 211, 248, 15,
+        232, 213, 159, 249, 99, 92, 18, 227, 50, 88, 196, 16, 59, 73, 221, 60, 157, 81, 122, 225,
+        139, 111, 72, 137, 200, 95, 13, 64, 236, 35, 113, 240, 114, 67, 231, 129, 42, 187, 31, 34,
+        29, 123, 52, 256, 173, 140, 195, 189, 199, 11, 153, 2, 168, 234, 124, 136, 116, 235, 208,
+        253, 178, 46, 9, 242, 25, 44, 98, 8, 158, 165, 239, 30, 207, 169, 61, 241, 198, 184, 36,
+        197, 100, 176, 135, 32, 118, 146, 185, 120, 57, 162, 244, 193, 21, 222, 144, 17, 143, 190,
+        26, 128, 215, 70, 226, 223, 228, 134, 205, 1, 84, 117, 62, 68, 58, 246, 104, 255, 89, 23,
+        133, 121, 141, 22, 49, 4, 79, 211, 248, 15, 232, 213, 159, 249, 99, 92, 18, 227, 50, 88,
+        196, 16, 59, 73, 221, 60, 157, 81, 122, 225, 139, 111, 72, 137, 200, 95, 13, 64, 236, 35,
+        113, 240, 114, 67, 231, 129, 42, 187, 31, 34, 29, 123, 52, 256, 173, 140, 195, 189, 199, 11,
+        153, 2, 168, 234, 124, 136, 116, 235, 208, 253, 178, 46, 9, 242, 25, 44, 98, 8, 158, 165,
+        239, 30, 207, 169, 61, 241, 198, 184, 36, 197, 100, 176, 135, 32, 118, 146, 185, 120, 57,
+        162, 244, 193, 21, 222, 144, 17, 143, 190, 26, 128, 215, 70, 226, 223, 228, 134, 205, 1,
+    ],
+    [
+        1, 85, 29, 152, 70, 39, 231, 103, 17, 160, 236, 14, 162, 149, 72, 209, 32, 150, 157, 238,
+        184, 220, 196, 212, 30, 237, 99, 191, 44, 142, 248, 6, 253, 174, 141, 163, 234, 101, 104,
+        102, 189, 131, 84, 201, 123, 175, 226, 192, 129, 171, 143, 76, 35, 148, 244, 180, 137, 80,
+        118, 7, 81, 203, 36, 233, 16, 75, 207, 119, 92, 110, 98, 106, 15, 247, 178, 224, 22, 71,
+        124, 3, 255, 87, 199, 210, 117, 179, 52, 51, 223, 194, 42, 229, 190, 216, 113, 96, 193, 214,
+        200, 38, 146, 74, 122, 90, 197, 40, 59, 132, 169, 230, 18, 245, 8, 166, 232, 188, 46, 55,
+        49, 53, 136, 252, 89, 112, 11, 164, 62, 130, 256, 172, 228, 105, 187, 218, 26, 154, 240, 97,
+        21, 243, 95, 108, 185, 48, 225, 107, 100, 19, 73, 37, 61, 45, 227, 20, 158, 66, 213, 115, 9,
+        251, 4, 83, 116, 94, 23, 156, 153, 155, 68, 126, 173, 56, 134, 82, 31, 65, 128, 86, 114,
+        181, 222, 109, 13, 77, 120, 177, 139, 250, 176, 54, 221, 24, 241, 182, 50, 138, 165, 147,
+        159, 151, 242, 10, 79, 33, 235, 186, 133, 254, 2, 170, 58, 47, 140, 78, 205, 206, 34, 63,
+        215, 28, 67, 41, 144, 161, 64, 43, 57, 219, 111, 183, 135, 167, 60, 217, 198, 125, 88, 27,
+        239, 12, 249, 91, 25, 69, 211, 202, 208, 204, 121, 5, 168, 145, 246, 93, 195, 127, 1,
+    ],
+    [
+        1, 86, 200, 238, 165, 55, 104, 206, 240, 80, 198, 66, 22, 93, 31, 96, 32, 182, 232, 163,
+        140, 218, 244, 167, 227, 247, 168, 56, 190, 149, 221, 245, 253, 170, 228, 76, 111, 37, 98,
+        204, 68, 194, 236, 250, 169, 142, 133, 130, 129, 43, 100, 119, 211, 156, 52, 103, 120, 40,
+        99, 33, 11, 175, 144, 48, 16, 91, 116, 210, 70, 109, 122, 212, 242, 252, 84, 28, 95, 203,
+        239, 251, 255, 85, 114, 38, 184, 147, 49, 102, 34, 97, 118, 125, 213, 71, 195, 65, 193, 150,
+        50, 188, 234, 78, 26, 180, 60, 20, 178, 145, 134, 216, 72, 24, 8, 174, 58, 105, 35, 183, 61,
+        106, 121, 126, 42, 14, 176, 230, 248, 254, 256, 171, 57, 19, 92, 202, 153, 51, 17, 177, 59,
+        191, 235, 164, 226, 161, 225, 75, 25, 94, 117, 39, 13, 90, 30, 10, 89, 201, 67, 108, 36, 12,
+        4, 87, 29, 181, 146, 220, 159, 53, 189, 63, 21, 7, 88, 115, 124, 127, 128, 214, 157, 138,
+        46, 101, 205, 154, 137, 217, 158, 224, 246, 82, 113, 209, 241, 166, 141, 47, 187, 148, 135,
+        45, 15, 5, 173, 229, 162, 54, 18, 6, 2, 172, 143, 219, 73, 110, 208, 155, 223, 160, 139,
+        132, 44, 186, 62, 192, 64, 107, 207, 69, 23, 179, 231, 77, 197, 237, 79, 112, 123, 41, 185,
+        233, 249, 83, 199, 152, 222, 74, 196, 151, 136, 131, 215, 243, 81, 27, 9, 3, 1,
+    ],
+    [
+        1, 87, 116, 69, 92, 37, 135, 180, 240, 63, 84, 112, 235, 142, 18, 24, 32, 214, 114, 152,
+        117, 156, 208, 106, 227, 217, 118, 243, 67, 175, 62, 254, 253, 166, 50, 238, 146, 109, 231,
+        51, 68, 5, 178, 66, 88, 203, 185, 161, 129, 172, 58, 163, 46, 147, 196, 90, 120, 160, 42,
+        56, 246, 71, 9, 12, 16, 107, 57, 76, 187, 78, 104, 53, 242, 237, 59, 250, 162, 216, 31, 127,
+        255, 83, 25, 119, 73, 183, 244, 154, 34, 131, 89, 33, 44, 230, 221, 209, 193, 86, 29, 210,
+        23, 202, 98, 45, 60, 80, 21, 28, 123, 164, 133, 6, 8, 182, 157, 38, 222, 39, 52, 155, 121,
+        247, 158, 125, 81, 108, 144, 192, 256, 170, 141, 188, 165, 220, 122, 77, 17, 194, 173, 145,
+        22, 115, 239, 233, 225, 43, 143, 105, 140, 101, 49, 151, 30, 40, 139, 14, 190, 82, 195, 3,
+        4, 91, 207, 19, 111, 148, 26, 206, 189, 252, 79, 191, 169, 54, 72, 96, 128, 85, 199, 94,
+        211, 110, 61, 167, 137, 97, 215, 201, 11, 186, 248, 245, 241, 150, 200, 181, 70, 179, 153,
+        204, 15, 20, 198, 7, 95, 41, 226, 130, 2, 174, 232, 138, 184, 74, 13, 103, 223, 126, 168,
+        224, 213, 27, 36, 48, 64, 171, 228, 47, 234, 55, 159, 212, 197, 177, 236, 229, 134, 93, 124,
+        251, 249, 75, 100, 219, 35, 218, 205, 102, 136, 10, 99, 132, 176, 149, 113, 65, 1,
+    ],
+    [
+        1, 88, 34, 165, 128, 213, 240, 46, 193, 22, 137, 234, 32, 246, 60, 140, 241, 134, 227, 187,
+        8, 190, 15, 35, 253, 162, 121, 111, 2, 176, 68, 73, 256, 169, 223, 92, 129, 44, 17, 211, 64,
+        235, 120, 23, 225, 11, 197, 117, 16, 123, 30, 70, 249, 67, 242, 222, 4, 95, 136, 146, 255,
+        81, 189, 184, 1, 88, 34, 165, 128, 213, 240, 46, 193, 22, 137, 234, 32, 246, 60, 140, 241,
+        134, 227, 187, 8, 190, 15, 35, 253, 162, 121, 111, 2, 176, 68, 73, 256, 169, 223, 92, 129,
+        44, 17, 211, 64, 235, 120, 23, 225, 11, 197, 117, 16, 123, 30, 70, 249, 67, 242, 222, 4, 95,
+        136, 146, 255, 81, 189, 184, 1, 88, 34, 165, 128, 213, 240, 46, 193, 22, 137, 234, 32, 246,
+        60, 140, 241, 134, 227, 187, 8, 190, 15, 35, 253, 162, 121, 111, 2, 176, 68, 73, 256, 169,
+        223, 92, 129, 44, 17, 211, 64, 235, 120, 23, 225, 11, 197, 117, 16, 123, 30, 70, 249, 67,
+        242, 222, 4, 95, 136, 146, 255, 81, 189, 184, 1, 88, 34, 165, 128, 213, 240, 46, 193, 22,
+        137, 234, 32, 246, 60, 140, 241, 134, 227, 187, 8, 190, 15, 35, 253, 162, 121, 111, 2, 176,
+        68, 73, 256, 169, 223, 92, 129, 44, 17, 211, 64, 235, 120, 23, 225, 11, 197, 117, 16, 123,
+        30, 70, 249, 67, 242, 222, 4, 95, 136, 146, 255, 81, 189, 184, 1,
+    ],
+    [
+        1, 89, 211, 18, 60, 200, 67, 52, 2, 178, 165, 36, 120, 143, 134, 104, 4, 99, 73, 72, 240,
+        29, 11, 208, 8, 198, 146, 144, 223, 58, 22, 159, 16, 139, 35, 31, 189, 116, 44, 61, 32, 21,
+        70, 62, 121, 232, 88, 122, 64, 42, 140, 124, 242, 207, 176, 244, 128, 84, 23, 248, 227, 157,
+        95, 231, 256, 168, 46, 239, 197, 57, 190, 205, 255, 79, 92, 221, 137, 114, 123, 153, 253,
+        158, 184, 185, 17, 228, 246, 49, 249, 59, 111, 113, 34, 199, 235, 98, 241, 118, 222, 226,
+        68, 141, 213, 196, 225, 236, 187, 195, 136, 25, 169, 135, 193, 215, 117, 133, 15, 50, 81,
+        13, 129, 173, 234, 9, 30, 100, 162, 26, 1, 89, 211, 18, 60, 200, 67, 52, 2, 178, 165, 36,
+        120, 143, 134, 104, 4, 99, 73, 72, 240, 29, 11, 208, 8, 198, 146, 144, 223, 58, 22, 159, 16,
+        139, 35, 31, 189, 116, 44, 61, 32, 21, 70, 62, 121, 232, 88, 122, 64, 42, 140, 124, 242,
+        207, 176, 244, 128, 84, 23, 248, 227, 157, 95, 231, 256, 168, 46, 239, 197, 57, 190, 205,
+        255, 79, 92, 221, 137, 114, 123, 153, 253, 158, 184, 185, 17, 228, 246, 49, 249, 59, 111,
+        113, 34, 199, 235, 98, 241, 118, 222, 226, 68, 141, 213, 196, 225, 236, 187, 195, 136, 25,
+        169, 135, 193, 215, 117, 133, 15, 50, 81, 13, 129, 173, 234, 9, 30, 100, 162, 26, 1,
+    ],
+    [
+        1, 90, 133, 148, 213, 152, 59, 170, 137, 251, 231, 230, 140, 7, 116, 160, 8, 206, 36, 156,
+        162, 188, 215, 75, 68, 209, 49, 41, 92, 56, 157, 252, 64, 106, 31, 220, 11, 219, 178, 86,
+        30, 130, 135, 71, 222, 191, 228, 217, 255, 77, 248, 218, 88, 210, 139, 174, 240, 12, 52, 54,
+        234, 243, 25, 194, 241, 102, 185, 202, 190, 138, 84, 107, 121, 96, 159, 175, 73, 145, 200,
+        10, 129, 45, 195, 74, 235, 76, 158, 85, 197, 254, 244, 115, 70, 132, 58, 80, 4, 103, 18, 78,
+        81, 94, 236, 166, 34, 233, 153, 149, 46, 28, 207, 126, 32, 53, 144, 110, 134, 238, 89, 43,
+        15, 65, 196, 164, 111, 224, 114, 237, 256, 167, 124, 109, 44, 105, 198, 87, 120, 6, 26, 27,
+        117, 250, 141, 97, 249, 51, 221, 101, 95, 69, 42, 182, 189, 48, 208, 216, 165, 201, 100, 5,
+        193, 151, 226, 37, 246, 38, 79, 171, 227, 127, 122, 186, 35, 66, 29, 40, 2, 180, 9, 39, 169,
+        47, 118, 83, 17, 245, 205, 203, 23, 14, 232, 63, 16, 155, 72, 55, 67, 119, 173, 150, 136,
+        161, 98, 82, 184, 112, 57, 247, 128, 212, 62, 183, 22, 181, 99, 172, 60, 3, 13, 142, 187,
+        125, 199, 177, 253, 154, 239, 179, 176, 163, 21, 91, 223, 24, 104, 108, 211, 229, 50, 131,
+        225, 204, 113, 147, 123, 19, 168, 214, 242, 192, 61, 93, 146, 33, 143, 20, 1,
+    ],
+    [
+        1, 91, 57, 47, 165, 109, 153, 45, 240, 252, 59, 229, 22, 203, 226, 6, 32, 85, 25, 219, 140,
+        147, 13, 155, 227, 97, 89, 132, 190, 71, 36, 192, 253, 150, 29, 69, 111, 78, 159, 77, 68,
+        20, 21, 112, 169, 216, 124, 233, 129, 174, 157, 152, 211, 183, 205, 151, 120, 126, 158, 243,
+        11, 230, 113, 3, 16, 171, 141, 238, 70, 202, 135, 206, 242, 177, 173, 66, 95, 164, 18, 96,
+        255, 75, 143, 163, 184, 39, 208, 167, 34, 10, 139, 56, 213, 108, 62, 245, 193, 87, 207, 76,
+        234, 220, 231, 204, 60, 63, 79, 250, 134, 115, 185, 130, 8, 214, 199, 119, 35, 101, 196,
+        103, 121, 217, 215, 33, 176, 82, 9, 48, 256, 166, 200, 210, 92, 148, 104, 212, 17, 5, 198,
+        28, 235, 54, 31, 251, 225, 172, 232, 38, 117, 110, 244, 102, 30, 160, 168, 125, 67, 186,
+        221, 65, 4, 107, 228, 188, 146, 179, 98, 180, 189, 237, 236, 145, 88, 41, 133, 24, 128, 83,
+        100, 105, 46, 74, 52, 106, 137, 131, 99, 14, 246, 27, 144, 254, 241, 86, 116, 19, 187, 55,
+        122, 51, 15, 80, 84, 191, 162, 93, 239, 161, 2, 182, 114, 94, 73, 218, 49, 90, 223, 247,
+        118, 201, 44, 149, 195, 12, 64, 170, 50, 181, 23, 37, 26, 53, 197, 194, 178, 7, 123, 142,
+        72, 127, 249, 43, 58, 138, 222, 156, 61, 154, 136, 40, 42, 224, 81, 175, 248, 209, 1,
+    ],
+    [
+        1, 92, 240, 235, 32, 117, 227, 67, 253, 146, 68, 88, 129, 46, 120, 246, 16, 187, 242, 162,
+        255, 73, 34, 44, 193, 23, 60, 123, 8, 222, 121, 81, 256, 165, 17, 22, 225, 140, 30, 190, 4,
+        111, 189, 169, 128, 211, 137, 11, 241, 70, 15, 95, 2, 184, 223, 213, 64, 234, 197, 134, 249,
+        35, 136, 176, 1, 92, 240, 235, 32, 117, 227, 67, 253, 146, 68, 88, 129, 46, 120, 246, 16,
+        187, 242, 162, 255, 73, 34, 44, 193, 23, 60, 123, 8, 222, 121, 81, 256, 165, 17, 22, 225,
+        140, 30, 190, 4, 111, 189, 169, 128, 211, 137, 11, 241, 70, 15, 95, 2, 184, 223, 213, 64,
+        234, 197, 134, 249, 35, 136, 176, 1, 92, 240, 235, 32, 117, 227, 67, 253, 146, 68, 88, 129,
+        46, 120, 246, 16, 187, 242, 162, 255, 73, 34, 44, 193, 23, 60, 123, 8, 222, 121, 81, 256,
+        165, 17, 22, 225, 140, 30, 190, 4, 111, 189, 169, 128, 211, 137, 11, 241, 70, 15, 95, 2,
+        184, 223, 213, 64, 234, 197, 134, 249, 35, 136, 176, 1, 92, 240, 235, 32, 117, 227, 67, 253,
+        146, 68, 88, 129, 46, 120, 246, 16, 187, 242, 162, 255, 73, 34, 44, 193, 23, 60, 123, 8,
+        222, 121, 81, 256, 165, 17, 22, 225, 140, 30, 190, 4, 111, 189, 169, 128, 211, 137, 11, 241,
+        70, 15, 95, 2, 184, 223, 213, 64, 234, 197, 134, 249, 35, 136, 176, 1,
+    ],
+    [
+        1, 93, 168, 204, 211, 91, 239, 125, 60, 183, 57, 161, 67, 63, 205, 47, 2, 186, 79, 151, 165,
+        182, 221, 250, 120, 109, 114, 65, 134, 126, 153, 94, 4, 115, 158, 45, 73, 107, 185, 243,
+        240, 218, 228, 130, 11, 252, 49, 188, 8, 230, 59, 90, 146, 214, 113, 229, 223, 179, 199, 3,
+        22, 247, 98, 119, 16, 203, 118, 180, 35, 171, 226, 201, 189, 101, 141, 6, 44, 237, 196, 238,
+        32, 149, 236, 103, 70, 85, 195, 145, 121, 202, 25, 12, 88, 217, 135, 219, 64, 41, 215, 206,
+        140, 170, 133, 33, 242, 147, 50, 24, 176, 177, 13, 181, 128, 82, 173, 155, 23, 83, 9, 66,
+        227, 37, 100, 48, 95, 97, 26, 105, 256, 164, 89, 53, 46, 166, 18, 132, 197, 74, 200, 96,
+        190, 194, 52, 210, 255, 71, 178, 106, 92, 75, 36, 7, 137, 148, 143, 192, 123, 131, 104, 163,
+        253, 142, 99, 212, 184, 150, 72, 14, 17, 39, 29, 127, 246, 5, 208, 69, 249, 27, 198, 167,
+        111, 43, 144, 28, 34, 78, 58, 254, 235, 10, 159, 138, 241, 54, 139, 77, 222, 86, 31, 56, 68,
+        156, 116, 251, 213, 20, 61, 19, 225, 108, 21, 154, 187, 172, 62, 112, 136, 55, 232, 245,
+        169, 40, 122, 38, 193, 216, 42, 51, 117, 87, 124, 224, 15, 110, 207, 233, 81, 80, 244, 76,
+        129, 175, 84, 102, 234, 174, 248, 191, 30, 220, 157, 209, 162, 160, 231, 152, 1,
+    ],
+    [
+        1, 94, 98, 217, 95, 192, 58, 55, 30, 250, 113, 85, 23, 106, 198, 108, 129, 47, 49, 237, 176,
+        96, 29, 156, 15, 125, 185, 171, 140, 53, 99, 54, 193, 152, 153, 247, 88, 48, 143, 78, 136,
+        191, 221, 214, 70, 155, 178, 27, 225, 76, 205, 252, 44, 24, 200, 39, 68, 224, 239, 107, 35,
+        206, 89, 142, 241, 38, 231, 126, 22, 12, 100, 148, 34, 112, 248, 182, 146, 103, 173, 71,
+        249, 19, 244, 63, 11, 6, 50, 74, 17, 56, 124, 91, 73, 180, 215, 164, 253, 138, 122, 160,
+        134, 3, 25, 37, 137, 28, 62, 174, 165, 90, 236, 82, 255, 69, 61, 80, 67, 130, 141, 147, 197,
+        14, 31, 87, 211, 45, 118, 41, 256, 163, 159, 40, 162, 65, 199, 202, 227, 7, 144, 172, 234,
+        151, 59, 149, 128, 210, 208, 20, 81, 161, 228, 101, 242, 132, 72, 86, 117, 204, 158, 203,
+        64, 105, 104, 10, 169, 209, 114, 179, 121, 66, 36, 43, 187, 102, 79, 230, 32, 181, 52, 5,
+        213, 233, 57, 218, 189, 33, 18, 150, 222, 51, 168, 115, 16, 219, 26, 131, 235, 245, 157,
+        109, 223, 145, 9, 75, 111, 154, 84, 186, 8, 238, 13, 194, 246, 251, 207, 183, 240, 201, 133,
+        166, 184, 77, 42, 93, 4, 119, 135, 97, 123, 254, 232, 220, 120, 229, 195, 83, 92, 167, 21,
+        175, 2, 188, 196, 177, 190, 127, 116, 110, 60, 243, 226, 170, 46, 212, 139, 216, 1,
+    ],
+    [
+        1, 95, 30, 23, 129, 176, 15, 140, 193, 88, 136, 70, 225, 44, 68, 35, 241, 22, 34, 146, 249,
+        11, 17, 73, 253, 134, 137, 165, 255, 67, 197, 211, 256, 162, 227, 234, 128, 81, 242, 117,
+        64, 169, 121, 187, 32, 213, 189, 222, 16, 235, 223, 111, 8, 246, 240, 184, 4, 123, 120, 92,
+        2, 190, 60, 46, 1, 95, 30, 23, 129, 176, 15, 140, 193, 88, 136, 70, 225, 44, 68, 35, 241,
+        22, 34, 146, 249, 11, 17, 73, 253, 134, 137, 165, 255, 67, 197, 211, 256, 162, 227, 234,
+        128, 81, 242, 117, 64, 169, 121, 187, 32, 213, 189, 222, 16, 235, 223, 111, 8, 246, 240,
+        184, 4, 123, 120, 92, 2, 190, 60, 46, 1, 95, 30, 23, 129, 176, 15, 140, 193, 88, 136, 70,
+        225, 44, 68, 35, 241, 22, 34, 146, 249, 11, 17, 73, 253, 134, 137, 165, 255, 67, 197, 211,
+        256, 162, 227, 234, 128, 81, 242, 117, 64, 169, 121, 187, 32, 213, 189, 222, 16, 235, 223,
+        111, 8, 246, 240, 184, 4, 123, 120, 92, 2, 190, 60, 46, 1, 95, 30, 23, 129, 176, 15, 140,
+        193, 88, 136, 70, 225, 44, 68, 35, 241, 22, 34, 146, 249, 11, 17, 73, 253, 134, 137, 165,
+        255, 67, 197, 211, 256, 162, 227, 234, 128, 81, 242, 117, 64, 169, 121, 187, 32, 213, 189,
+        222, 16, 235, 223, 111, 8, 246, 240, 184, 4, 123, 120, 92, 2, 190, 60, 46, 1,
+    ],
+    [
+        1, 96, 221, 142, 11, 28, 118, 20, 121, 51, 13, 220, 46, 47, 143, 107, 249, 3, 31, 149, 169,
+        33, 84, 97, 60, 106, 153, 39, 146, 138, 141, 172, 64, 233, 9, 93, 190, 250, 99, 252, 34,
+        180, 61, 202, 117, 181, 157, 166, 2, 192, 185, 27, 22, 56, 236, 40, 242, 102, 26, 183, 92,
+        94, 29, 214, 241, 6, 62, 41, 81, 66, 168, 194, 120, 212, 49, 78, 35, 19, 25, 87, 128, 209,
+        18, 186, 123, 243, 198, 247, 68, 103, 122, 147, 234, 105, 57, 75, 4, 127, 113, 54, 44, 112,
+        215, 80, 227, 204, 52, 109, 184, 188, 58, 171, 225, 12, 124, 82, 162, 132, 79, 131, 240,
+        167, 98, 156, 70, 38, 50, 174, 256, 161, 36, 115, 246, 229, 139, 237, 136, 206, 244, 37,
+        211, 210, 114, 150, 8, 254, 226, 108, 88, 224, 173, 160, 197, 151, 104, 218, 111, 119, 116,
+        85, 193, 24, 248, 164, 67, 7, 158, 5, 223, 77, 196, 55, 140, 76, 100, 91, 255, 65, 72, 230,
+        235, 201, 21, 217, 15, 155, 231, 74, 165, 163, 228, 43, 16, 251, 195, 216, 176, 191, 89, 63,
+        137, 45, 208, 179, 222, 238, 232, 170, 129, 48, 239, 71, 134, 14, 59, 10, 189, 154, 135,
+        110, 23, 152, 200, 182, 253, 130, 144, 203, 213, 145, 42, 177, 30, 53, 205, 148, 73, 69,
+        199, 86, 32, 245, 133, 175, 95, 125, 178, 126, 17, 90, 159, 101, 187, 219, 207, 83, 1,
+    ],
+    [
+        1, 97, 157, 66, 234, 82, 244, 24, 15, 170, 42, 219, 169, 202, 62, 103, 225, 237, 116, 201,
+        222, 203, 159, 3, 34, 214, 198, 188, 246, 218, 72, 45, 253, 126, 143, 250, 92, 186, 52, 161,
+        197, 91, 89, 152, 95, 220, 9, 102, 128, 80, 50, 224, 140, 216, 135, 245, 121, 172, 236, 19,
+        44, 156, 226, 77, 16, 10, 199, 28, 146, 27, 49, 127, 240, 150, 158, 163, 134, 148, 221, 106,
+        2, 194, 57, 132, 211, 164, 231, 48, 30, 83, 84, 181, 81, 147, 124, 206, 193, 217, 232, 145,
+        187, 149, 61, 6, 68, 171, 139, 119, 235, 179, 144, 90, 249, 252, 29, 243, 184, 115, 104, 65,
+        137, 182, 178, 47, 190, 183, 18, 204, 256, 160, 100, 191, 23, 175, 13, 233, 242, 87, 215,
+        38, 88, 55, 195, 154, 32, 20, 141, 56, 35, 54, 98, 254, 223, 43, 59, 69, 11, 39, 185, 212,
+        4, 131, 114, 7, 165, 71, 205, 96, 60, 166, 168, 105, 162, 37, 248, 155, 129, 177, 207, 33,
+        117, 41, 122, 12, 136, 85, 21, 238, 213, 101, 31, 180, 241, 247, 58, 229, 111, 230, 208,
+        130, 17, 107, 99, 94, 123, 109, 36, 151, 255, 63, 200, 125, 46, 93, 26, 209, 227, 174, 173,
+        76, 176, 110, 133, 51, 64, 40, 25, 112, 70, 108, 196, 251, 189, 86, 118, 138, 22, 78, 113,
+        167, 8, 5, 228, 14, 73, 142, 153, 192, 120, 75, 79, 210, 67, 74, 239, 53, 1,
+    ],
+    [
+        1, 98, 95, 58, 30, 113, 23, 198, 129, 49, 176, 29, 15, 185, 140, 99, 193, 153, 88, 143, 136,
+        221, 70, 178, 225, 205, 44, 200, 68, 239, 35, 89, 241, 231, 22, 100, 34, 248, 146, 173, 249,
+        244, 11, 50, 17, 124, 73, 215, 253, 122, 134, 25, 137, 62, 165, 236, 255, 61, 67, 141, 197,
+        31, 211, 118, 256, 159, 162, 199, 227, 144, 234, 59, 128, 208, 81, 228, 242, 72, 117, 158,
+        64, 104, 169, 114, 121, 36, 187, 79, 32, 52, 213, 57, 189, 18, 222, 168, 16, 26, 235, 157,
+        223, 9, 111, 84, 8, 13, 246, 207, 240, 133, 184, 42, 4, 135, 123, 232, 120, 195, 92, 21, 2,
+        196, 190, 116, 60, 226, 46, 139, 1, 98, 95, 58, 30, 113, 23, 198, 129, 49, 176, 29, 15, 185,
+        140, 99, 193, 153, 88, 143, 136, 221, 70, 178, 225, 205, 44, 200, 68, 239, 35, 89, 241, 231,
+        22, 100, 34, 248, 146, 173, 249, 244, 11, 50, 17, 124, 73, 215, 253, 122, 134, 25, 137, 62,
+        165, 236, 255, 61, 67, 141, 197, 31, 211, 118, 256, 159, 162, 199, 227, 144, 234, 59, 128,
+        208, 81, 228, 242, 72, 117, 158, 64, 104, 169, 114, 121, 36, 187, 79, 32, 52, 213, 57, 189,
+        18, 222, 168, 16, 26, 235, 157, 223, 9, 111, 84, 8, 13, 246, 207, 240, 133, 184, 42, 4, 135,
+        123, 232, 120, 195, 92, 21, 2, 196, 190, 116, 60, 226, 46, 139, 1,
+    ],
+    [
+        1, 99, 35, 124, 197, 228, 213, 13, 2, 198, 70, 248, 137, 199, 169, 26, 4, 139, 140, 239, 17,
+        141, 81, 52, 8, 21, 23, 221, 34, 25, 162, 104, 16, 42, 46, 185, 68, 50, 67, 208, 32, 84, 92,
+        113, 136, 100, 134, 159, 64, 168, 184, 226, 15, 200, 11, 61, 128, 79, 111, 195, 30, 143, 22,
+        122, 256, 158, 222, 133, 60, 29, 44, 244, 255, 59, 187, 9, 120, 58, 88, 231, 253, 118, 117,
+        18, 240, 116, 176, 205, 249, 236, 234, 36, 223, 232, 95, 153, 241, 215, 211, 72, 189, 207,
+        190, 49, 225, 173, 165, 144, 121, 157, 123, 98, 193, 89, 73, 31, 242, 57, 246, 196, 129,
+        178, 146, 62, 227, 114, 235, 135, 1, 99, 35, 124, 197, 228, 213, 13, 2, 198, 70, 248, 137,
+        199, 169, 26, 4, 139, 140, 239, 17, 141, 81, 52, 8, 21, 23, 221, 34, 25, 162, 104, 16, 42,
+        46, 185, 68, 50, 67, 208, 32, 84, 92, 113, 136, 100, 134, 159, 64, 168, 184, 226, 15, 200,
+        11, 61, 128, 79, 111, 195, 30, 143, 22, 122, 256, 158, 222, 133, 60, 29, 44, 244, 255, 59,
+        187, 9, 120, 58, 88, 231, 253, 118, 117, 18, 240, 116, 176, 205, 249, 236, 234, 36, 223,
+        232, 95, 153, 241, 215, 211, 72, 189, 207, 190, 49, 225, 173, 165, 144, 121, 157, 123, 98,
+        193, 89, 73, 31, 242, 57, 246, 196, 129, 178, 146, 62, 227, 114, 235, 135, 1,
+    ],
+    [
+        1, 100, 234, 13, 15, 215, 169, 195, 225, 141, 222, 98, 34, 59, 246, 185, 253, 114, 92, 205,
+        197, 168, 95, 248, 128, 207, 140, 122, 121, 21, 44, 31, 16, 58, 146, 208, 240, 99, 134, 36,
+        2, 200, 211, 26, 30, 173, 81, 133, 193, 25, 187, 196, 68, 118, 235, 113, 249, 228, 184, 153,
+        137, 79, 190, 239, 256, 157, 23, 244, 242, 42, 88, 62, 32, 116, 35, 159, 223, 198, 11, 72,
+        4, 143, 165, 52, 60, 89, 162, 9, 129, 50, 117, 135, 136, 236, 213, 226, 241, 199, 111, 49,
+        17, 158, 123, 221, 255, 57, 46, 231, 227, 84, 176, 124, 64, 232, 70, 61, 189, 139, 22, 144,
+        8, 29, 73, 104, 120, 178, 67, 18, 1, 100, 234, 13, 15, 215, 169, 195, 225, 141, 222, 98, 34,
+        59, 246, 185, 253, 114, 92, 205, 197, 168, 95, 248, 128, 207, 140, 122, 121, 21, 44, 31, 16,
+        58, 146, 208, 240, 99, 134, 36, 2, 200, 211, 26, 30, 173, 81, 133, 193, 25, 187, 196, 68,
+        118, 235, 113, 249, 228, 184, 153, 137, 79, 190, 239, 256, 157, 23, 244, 242, 42, 88, 62,
+        32, 116, 35, 159, 223, 198, 11, 72, 4, 143, 165, 52, 60, 89, 162, 9, 129, 50, 117, 135, 136,
+        236, 213, 226, 241, 199, 111, 49, 17, 158, 123, 221, 255, 57, 46, 231, 227, 84, 176, 124,
+        64, 232, 70, 61, 189, 139, 22, 144, 8, 29, 73, 104, 120, 178, 67, 18, 1,
+    ],
+    [
+        1, 101, 178, 245, 73, 177, 144, 152, 189, 71, 232, 45, 176, 43, 231, 201, 255, 55, 158, 24,
+        111, 160, 226, 210, 136, 115, 50, 167, 162, 171, 52, 112, 4, 147, 198, 209, 35, 194, 62, 94,
+        242, 27, 157, 180, 190, 172, 153, 33, 249, 220, 118, 96, 187, 126, 133, 69, 30, 203, 200,
+        154, 134, 170, 208, 191, 16, 74, 21, 65, 140, 5, 248, 119, 197, 108, 114, 206, 246, 174, 98,
+        132, 225, 109, 215, 127, 234, 247, 18, 19, 120, 41, 29, 102, 22, 166, 61, 250, 64, 39, 84,
+        3, 46, 20, 221, 219, 17, 175, 199, 53, 213, 182, 135, 14, 129, 179, 89, 251, 165, 217, 72,
+        76, 223, 164, 116, 151, 88, 150, 244, 229, 256, 156, 79, 12, 184, 80, 113, 105, 68, 186, 25,
+        212, 81, 214, 26, 56, 2, 202, 99, 233, 146, 97, 31, 47, 121, 142, 207, 90, 95, 86, 205, 145,
+        253, 110, 59, 48, 222, 63, 195, 163, 15, 230, 100, 77, 67, 85, 104, 224, 8, 37, 139, 161,
+        70, 131, 124, 188, 227, 54, 57, 103, 123, 87, 49, 66, 241, 183, 236, 192, 117, 252, 9, 138,
+        60, 149, 143, 51, 11, 83, 159, 125, 32, 148, 42, 130, 23, 10, 239, 238, 137, 216, 228, 155,
+        235, 91, 196, 7, 193, 218, 173, 254, 211, 237, 36, 38, 240, 82, 58, 204, 44, 75, 122, 243,
+        128, 78, 168, 6, 92, 40, 185, 181, 34, 93, 141, 106, 169, 107, 13, 28, 1,
+    ],
+    [
+        1, 102, 124, 55, 213, 138, 198, 150, 137, 96, 26, 82, 140, 145, 141, 247, 8, 45, 221, 183,
+        162, 76, 42, 172, 68, 254, 208, 142, 92, 132, 100, 177, 64, 103, 226, 179, 11, 94, 79, 91,
+        30, 233, 122, 108, 222, 28, 29, 131, 255, 53, 9, 147, 88, 238, 118, 214, 240, 65, 205, 93,
+        234, 224, 232, 20, 241, 167, 72, 148, 190, 105, 173, 170, 121, 6, 98, 230, 73, 250, 57, 160,
+        129, 51, 62, 156, 235, 69, 99, 75, 197, 48, 13, 41, 70, 201, 199, 252, 4, 151, 239, 220, 81,
+        38, 21, 86, 34, 127, 104, 71, 46, 66, 50, 217, 32, 180, 113, 218, 134, 47, 168, 174, 15,
+        245, 61, 54, 111, 14, 143, 194, 256, 155, 133, 202, 44, 119, 59, 107, 120, 161, 231, 175,
+        117, 112, 116, 10, 249, 212, 36, 74, 95, 181, 215, 85, 189, 3, 49, 115, 165, 125, 157, 80,
+        193, 154, 31, 78, 246, 163, 178, 166, 227, 24, 135, 149, 35, 229, 228, 126, 2, 204, 248,
+        110, 169, 19, 139, 43, 17, 192, 52, 164, 23, 33, 25, 237, 16, 90, 185, 109, 67, 152, 84, 87,
+        136, 251, 159, 27, 184, 7, 200, 97, 128, 206, 195, 101, 22, 188, 158, 182, 60, 209, 244,
+        216, 187, 56, 58, 5, 253, 106, 18, 37, 176, 219, 236, 171, 223, 130, 153, 186, 211, 191,
+        207, 40, 225, 77, 144, 39, 123, 210, 89, 83, 242, 12, 196, 203, 146, 243, 114, 63, 1,
+    ],
+    [
+        1, 103, 72, 220, 44, 163, 84, 171, 137, 233, 98, 71, 117, 229, 200, 40, 8, 53, 62, 218, 95,
+        19, 158, 83, 68, 65, 13, 54, 165, 33, 58, 63, 64, 167, 239, 202, 246, 152, 236, 150, 30, 6,
+        104, 175, 35, 7, 207, 247, 255, 51, 113, 74, 169, 188, 89, 172, 240, 48, 61, 115, 23, 56,
+        114, 177, 241, 151, 133, 78, 67, 219, 198, 91, 121, 127, 231, 149, 184, 191, 141, 131, 129,
+        180, 36, 110, 22, 210, 42, 214, 197, 245, 49, 164, 187, 243, 100, 20, 4, 155, 31, 109, 176,
+        138, 79, 170, 34, 161, 135, 27, 211, 145, 29, 160, 32, 212, 248, 101, 123, 76, 118, 75, 15,
+        3, 52, 216, 146, 132, 232, 252, 256, 154, 185, 37, 213, 94, 173, 86, 120, 24, 159, 186, 140,
+        28, 57, 217, 249, 204, 195, 39, 162, 238, 99, 174, 189, 192, 244, 203, 92, 224, 199, 194,
+        193, 90, 18, 55, 11, 105, 21, 107, 227, 251, 153, 82, 222, 250, 50, 10, 2, 206, 144, 183,
+        88, 69, 168, 85, 17, 209, 196, 142, 234, 201, 143, 80, 16, 106, 124, 179, 190, 38, 59, 166,
+        136, 130, 26, 108, 73, 66, 116, 126, 128, 77, 221, 147, 235, 47, 215, 43, 60, 12, 208, 93,
+        70, 14, 157, 237, 253, 102, 226, 148, 81, 119, 178, 87, 223, 96, 122, 230, 46, 112, 228, 97,
+        225, 45, 9, 156, 134, 181, 139, 182, 242, 254, 205, 41, 111, 125, 25, 5, 1,
+    ],
+    [
+        1, 104, 22, 232, 227, 221, 111, 236, 129, 52, 11, 116, 242, 239, 184, 118, 193, 26, 134, 58,
+        121, 248, 92, 59, 225, 13, 67, 29, 189, 124, 46, 158, 241, 135, 162, 143, 223, 62, 23, 79,
+        249, 196, 81, 200, 240, 31, 140, 168, 253, 98, 169, 100, 120, 144, 70, 84, 255, 49, 213, 50,
+        60, 72, 35, 42, 256, 153, 235, 25, 30, 36, 146, 21, 128, 205, 246, 141, 15, 18, 73, 139, 64,
+        231, 123, 199, 136, 9, 165, 198, 32, 244, 190, 228, 68, 133, 211, 99, 16, 122, 95, 114, 34,
+        195, 234, 178, 8, 61, 176, 57, 17, 226, 117, 89, 4, 159, 88, 157, 137, 113, 187, 173, 2,
+        208, 44, 207, 197, 185, 222, 215, 1, 104, 22, 232, 227, 221, 111, 236, 129, 52, 11, 116,
+        242, 239, 184, 118, 193, 26, 134, 58, 121, 248, 92, 59, 225, 13, 67, 29, 189, 124, 46, 158,
+        241, 135, 162, 143, 223, 62, 23, 79, 249, 196, 81, 200, 240, 31, 140, 168, 253, 98, 169,
+        100, 120, 144, 70, 84, 255, 49, 213, 50, 60, 72, 35, 42, 256, 153, 235, 25, 30, 36, 146, 21,
+        128, 205, 246, 141, 15, 18, 73, 139, 64, 231, 123, 199, 136, 9, 165, 198, 32, 244, 190, 228,
+        68, 133, 211, 99, 16, 122, 95, 114, 34, 195, 234, 178, 8, 61, 176, 57, 17, 226, 117, 89, 4,
+        159, 88, 157, 137, 113, 187, 173, 2, 208, 44, 207, 197, 185, 222, 215, 1,
+    ],
+    [
+        1, 105, 231, 97, 162, 48, 157, 37, 30, 66, 248, 83, 234, 155, 84, 82, 129, 181, 244, 177,
+        81, 24, 207, 147, 15, 33, 124, 170, 117, 206, 42, 41, 193, 219, 122, 217, 169, 12, 232, 202,
+        136, 145, 62, 85, 187, 103, 21, 149, 225, 238, 61, 237, 213, 6, 116, 101, 68, 201, 31, 171,
+        222, 180, 139, 203, 241, 119, 159, 247, 235, 3, 58, 179, 34, 229, 144, 214, 111, 90, 198,
+        230, 249, 188, 208, 252, 246, 130, 29, 218, 17, 243, 72, 107, 184, 45, 99, 115, 253, 94,
+        104, 126, 123, 65, 143, 109, 137, 250, 36, 182, 92, 151, 178, 186, 255, 47, 52, 63, 190,
+        161, 200, 183, 197, 125, 18, 91, 46, 204, 89, 93, 256, 152, 26, 160, 95, 209, 100, 220, 227,
+        191, 9, 174, 23, 102, 173, 175, 128, 76, 13, 80, 176, 233, 50, 110, 242, 224, 133, 87, 140,
+        51, 215, 216, 64, 38, 135, 40, 88, 245, 25, 55, 121, 112, 195, 172, 70, 154, 236, 108, 32,
+        19, 196, 20, 44, 251, 141, 156, 189, 56, 226, 86, 35, 77, 118, 54, 16, 138, 98, 10, 22, 254,
+        199, 78, 223, 28, 113, 43, 146, 167, 59, 27, 8, 69, 49, 5, 11, 127, 228, 39, 240, 14, 185,
+        150, 73, 212, 158, 142, 4, 163, 153, 131, 134, 192, 114, 148, 120, 7, 221, 75, 165, 106, 79,
+        71, 2, 210, 205, 194, 67, 96, 57, 74, 60, 132, 239, 166, 211, 53, 168, 164, 1,
+    ],
+    [
+        1, 106, 185, 78, 44, 38, 173, 91, 137, 130, 159, 149, 117, 66, 57, 131, 8, 77, 195, 110, 95,
+        47, 99, 214, 68, 12, 244, 164, 165, 14, 199, 20, 64, 102, 18, 109, 246, 119, 21, 170, 30,
+        96, 153, 27, 35, 112, 50, 160, 255, 45, 144, 101, 169, 181, 168, 75, 240, 254, 196, 216, 23,
+        125, 143, 252, 241, 103, 124, 37, 67, 163, 59, 86, 121, 233, 26, 186, 184, 229, 116, 217,
+        129, 53, 221, 39, 22, 19, 215, 174, 197, 65, 208, 203, 187, 33, 157, 194, 4, 167, 226, 55,
+        176, 152, 178, 107, 34, 6, 122, 82, 211, 7, 228, 10, 32, 51, 9, 183, 123, 188, 139, 85, 15,
+        48, 205, 142, 146, 56, 25, 80, 256, 151, 72, 179, 213, 219, 84, 166, 120, 127, 98, 108, 140,
+        191, 200, 126, 249, 180, 62, 147, 162, 210, 158, 43, 189, 245, 13, 93, 92, 243, 58, 237,
+        193, 155, 239, 148, 11, 138, 236, 87, 227, 161, 104, 230, 222, 145, 207, 97, 2, 212, 113,
+        156, 88, 76, 89, 182, 17, 3, 61, 41, 234, 132, 114, 5, 16, 154, 133, 220, 190, 94, 198, 171,
+        136, 24, 231, 71, 73, 28, 141, 40, 128, 204, 36, 218, 235, 238, 42, 83, 60, 192, 49, 54, 70,
+        224, 100, 63, 253, 90, 31, 202, 81, 105, 79, 150, 223, 251, 135, 175, 46, 250, 29, 247, 225,
+        206, 248, 74, 134, 69, 118, 172, 242, 209, 52, 115, 111, 201, 232, 177, 1,
+    ],
+    [
+        1, 107, 141, 181, 92, 78, 122, 204, 240, 237, 173, 7, 235, 216, 239, 130, 32, 83, 143, 138,
+        117, 183, 49, 103, 227, 131, 139, 224, 67, 230, 195, 48, 253, 86, 207, 47, 146, 202, 26,
+        212, 68, 80, 79, 229, 88, 164, 72, 251, 129, 182, 199, 219, 46, 39, 61, 102, 120, 247, 215,
+        132, 246, 108, 248, 65, 16, 170, 200, 69, 187, 220, 153, 180, 242, 194, 198, 112, 162, 115,
+        226, 24, 255, 43, 232, 152, 73, 101, 13, 106, 34, 40, 168, 243, 44, 82, 36, 254, 193, 91,
+        228, 238, 23, 148, 159, 51, 60, 252, 236, 66, 123, 54, 124, 161, 8, 85, 100, 163, 222, 110,
+        205, 90, 121, 97, 99, 56, 81, 186, 113, 12, 256, 150, 116, 76, 165, 179, 135, 53, 17, 20,
+        84, 250, 22, 41, 18, 127, 225, 174, 114, 119, 140, 74, 208, 154, 30, 126, 118, 33, 190, 27,
+        62, 209, 4, 171, 50, 210, 111, 55, 231, 45, 189, 177, 178, 28, 169, 93, 185, 6, 128, 75, 58,
+        38, 211, 218, 196, 155, 137, 10, 42, 125, 11, 149, 9, 192, 241, 87, 57, 188, 70, 37, 104,
+        77, 15, 63, 59, 145, 95, 142, 31, 233, 2, 214, 25, 105, 184, 156, 244, 151, 223, 217, 89,
+        14, 213, 175, 221, 3, 64, 166, 29, 19, 234, 109, 98, 206, 197, 5, 21, 191, 134, 203, 133,
+        96, 249, 172, 157, 94, 35, 147, 52, 167, 136, 160, 158, 201, 176, 71, 144, 245, 1,
+    ],
+    [
+        1, 108, 99, 155, 35, 182, 124, 28, 197, 202, 228, 209, 213, 131, 13, 119, 2, 216, 198, 53,
+        70, 107, 248, 56, 137, 147, 199, 161, 169, 5, 26, 238, 4, 175, 139, 106, 140, 214, 239, 112,
+        17, 37, 141, 65, 81, 10, 52, 219, 8, 93, 21, 212, 23, 171, 221, 224, 34, 74, 25, 130, 162,
+        20, 104, 181, 16, 186, 42, 167, 46, 85, 185, 191, 68, 148, 50, 3, 67, 40, 208, 105, 32, 115,
+        84, 77, 92, 170, 113, 125, 136, 39, 100, 6, 134, 80, 159, 210, 64, 230, 168, 154, 184, 83,
+        226, 250, 15, 78, 200, 12, 11, 160, 61, 163, 128, 203, 79, 51, 111, 166, 195, 243, 30, 156,
+        143, 24, 22, 63, 122, 69, 256, 149, 158, 102, 222, 75, 133, 229, 60, 55, 29, 48, 44, 126,
+        244, 138, 255, 41, 59, 204, 187, 150, 9, 201, 120, 110, 58, 96, 88, 252, 231, 19, 253, 82,
+        118, 151, 117, 43, 18, 145, 240, 220, 116, 192, 176, 247, 205, 38, 249, 164, 236, 45, 234,
+        86, 36, 33, 223, 183, 232, 127, 95, 237, 153, 76, 241, 71, 215, 90, 211, 172, 72, 66, 189,
+        109, 207, 254, 190, 217, 49, 152, 225, 142, 173, 180, 165, 87, 144, 132, 121, 218, 157, 251,
+        123, 177, 98, 47, 193, 27, 89, 103, 73, 174, 31, 7, 242, 179, 57, 245, 246, 97, 196, 94,
+        129, 54, 178, 206, 146, 91, 62, 14, 227, 101, 114, 233, 235, 194, 135, 188, 1,
+    ],
+    [
+        1, 109, 59, 6, 140, 97, 36, 69, 68, 216, 157, 151, 11, 171, 135, 66, 255, 39, 139, 245, 234,
+        63, 185, 119, 121, 82, 200, 212, 235, 172, 244, 125, 4, 179, 236, 24, 46, 131, 144, 19, 15,
+        93, 114, 90, 44, 170, 26, 7, 249, 156, 42, 209, 165, 252, 226, 219, 227, 71, 29, 77, 169,
+        174, 205, 243, 16, 202, 173, 96, 184, 10, 62, 76, 60, 115, 199, 103, 176, 166, 104, 28, 225,
+        110, 168, 65, 146, 237, 133, 105, 137, 27, 116, 51, 162, 182, 49, 201, 64, 37, 178, 127,
+        222, 40, 248, 47, 240, 203, 25, 155, 190, 150, 159, 112, 129, 183, 158, 3, 70, 177, 18, 163,
+        34, 108, 207, 204, 134, 214, 196, 33, 256, 148, 198, 251, 117, 160, 221, 188, 189, 41, 100,
+        106, 246, 86, 122, 191, 2, 218, 118, 12, 23, 194, 72, 138, 136, 175, 57, 45, 22, 85, 13,
+        132, 253, 78, 21, 233, 211, 126, 113, 238, 242, 164, 143, 167, 213, 87, 231, 250, 8, 101,
+        215, 48, 92, 5, 31, 38, 30, 186, 228, 180, 88, 83, 52, 14, 241, 55, 84, 161, 73, 247, 195,
+        181, 197, 142, 58, 154, 81, 91, 153, 229, 32, 147, 89, 192, 111, 20, 124, 152, 120, 230,
+        141, 206, 95, 75, 208, 56, 193, 220, 79, 130, 35, 217, 9, 210, 17, 54, 232, 102, 67, 107,
+        98, 145, 128, 74, 99, 254, 187, 80, 239, 94, 223, 149, 50, 53, 123, 43, 61, 224, 1,
+    ],
+    [
+        1, 110, 21, 254, 184, 194, 9, 219, 189, 230, 114, 204, 81, 172, 159, 14, 255, 37, 215, 6,
+        146, 126, 239, 76, 136, 54, 29, 106, 95, 170, 196, 229, 4, 183, 84, 245, 222, 5, 36, 105,
+        242, 149, 199, 45, 67, 174, 122, 56, 249, 148, 89, 24, 70, 247, 185, 47, 30, 216, 116, 167,
+        123, 166, 13, 145, 16, 218, 79, 209, 117, 20, 144, 163, 197, 82, 25, 180, 11, 182, 231, 224,
+        225, 78, 99, 96, 23, 217, 226, 188, 120, 93, 207, 154, 235, 150, 52, 66, 64, 101, 59, 65,
+        211, 80, 62, 138, 17, 71, 100, 206, 44, 214, 153, 125, 129, 55, 139, 127, 92, 97, 133, 238,
+        223, 115, 57, 102, 169, 86, 208, 7, 256, 147, 236, 3, 73, 63, 248, 38, 68, 27, 143, 53, 176,
+        85, 98, 243, 2, 220, 42, 251, 111, 131, 18, 181, 121, 203, 228, 151, 162, 87, 61, 28, 253,
+        74, 173, 12, 35, 252, 221, 152, 15, 108, 58, 212, 190, 83, 135, 201, 8, 109, 168, 233, 187,
+        10, 72, 210, 227, 41, 141, 90, 134, 91, 244, 112, 241, 39, 178, 48, 140, 237, 113, 94, 60,
+        175, 232, 77, 246, 75, 26, 33, 32, 179, 158, 161, 234, 40, 31, 69, 137, 164, 50, 103, 22,
+        107, 205, 191, 193, 156, 198, 192, 46, 177, 195, 119, 240, 186, 157, 51, 213, 43, 104, 132,
+        128, 202, 118, 130, 165, 160, 124, 19, 34, 142, 200, 155, 88, 171, 49, 250, 1,
+    ],
+    [
+        1, 111, 242, 134, 225, 46, 223, 81, 253, 70, 60, 235, 128, 73, 136, 190, 16, 234, 17, 88, 2,
+        222, 227, 11, 193, 92, 189, 162, 249, 140, 120, 213, 256, 146, 15, 123, 32, 211, 34, 176, 4,
+        187, 197, 22, 129, 184, 121, 67, 241, 23, 240, 169, 255, 35, 30, 246, 64, 165, 68, 95, 8,
+        117, 137, 44, 1, 111, 242, 134, 225, 46, 223, 81, 253, 70, 60, 235, 128, 73, 136, 190, 16,
+        234, 17, 88, 2, 222, 227, 11, 193, 92, 189, 162, 249, 140, 120, 213, 256, 146, 15, 123, 32,
+        211, 34, 176, 4, 187, 197, 22, 129, 184, 121, 67, 241, 23, 240, 169, 255, 35, 30, 246, 64,
+        165, 68, 95, 8, 117, 137, 44, 1, 111, 242, 134, 225, 46, 223, 81, 253, 70, 60, 235, 128, 73,
+        136, 190, 16, 234, 17, 88, 2, 222, 227, 11, 193, 92, 189, 162, 249, 140, 120, 213, 256, 146,
+        15, 123, 32, 211, 34, 176, 4, 187, 197, 22, 129, 184, 121, 67, 241, 23, 240, 169, 255, 35,
+        30, 246, 64, 165, 68, 95, 8, 117, 137, 44, 1, 111, 242, 134, 225, 46, 223, 81, 253, 70, 60,
+        235, 128, 73, 136, 190, 16, 234, 17, 88, 2, 222, 227, 11, 193, 92, 189, 162, 249, 140, 120,
+        213, 256, 146, 15, 123, 32, 211, 34, 176, 4, 187, 197, 22, 129, 184, 121, 67, 241, 23, 240,
+        169, 255, 35, 30, 246, 64, 165, 68, 95, 8, 117, 137, 44, 1,
+    ],
+    [
+        1, 112, 208, 166, 88, 90, 57, 216, 34, 210, 133, 247, 165, 233, 139, 148, 128, 201, 153,
+        174, 213, 212, 100, 149, 240, 152, 62, 5, 46, 12, 59, 183, 193, 28, 52, 170, 22, 151, 207,
+        54, 137, 181, 226, 126, 234, 251, 99, 37, 32, 243, 231, 172, 246, 53, 25, 230, 60, 38, 144,
+        194, 140, 3, 79, 110, 241, 7, 13, 171, 134, 102, 116, 142, 227, 238, 185, 160, 187, 127, 89,
+        202, 8, 125, 122, 43, 190, 206, 199, 186, 15, 138, 36, 177, 35, 65, 84, 156, 253, 66, 196,
+        107, 162, 154, 29, 164, 121, 188, 239, 40, 111, 96, 215, 179, 2, 224, 159, 75, 176, 180,
+        114, 175, 68, 163, 9, 237, 73, 209, 21, 39, 256, 145, 49, 91, 169, 167, 200, 41, 223, 47,
+        124, 10, 92, 24, 118, 109, 129, 56, 104, 83, 44, 45, 157, 108, 17, 105, 195, 252, 211, 245,
+        198, 74, 64, 229, 205, 87, 235, 106, 50, 203, 120, 76, 31, 131, 23, 6, 158, 220, 225, 14,
+        26, 85, 11, 204, 232, 27, 197, 219, 113, 63, 117, 254, 178, 147, 16, 250, 244, 86, 123, 155,
+        141, 115, 30, 19, 72, 97, 70, 130, 168, 55, 249, 132, 135, 214, 67, 51, 58, 71, 242, 119,
+        221, 80, 222, 192, 173, 101, 4, 191, 61, 150, 95, 103, 228, 93, 136, 69, 18, 217, 146, 161,
+        42, 78, 255, 33, 98, 182, 81, 77, 143, 82, 189, 94, 248, 20, 184, 48, 236, 218, 1,
+    ],
+    [
+        1, 113, 176, 99, 136, 205, 35, 100, 249, 124, 134, 236, 197, 159, 234, 228, 64, 36, 213,
+        168, 223, 13, 184, 232, 2, 226, 95, 198, 15, 153, 70, 200, 241, 248, 11, 215, 137, 61, 211,
+        199, 128, 72, 169, 79, 189, 26, 111, 207, 4, 195, 190, 139, 30, 49, 140, 143, 225, 239, 22,
+        173, 17, 122, 165, 141, 256, 144, 81, 158, 121, 52, 222, 157, 8, 133, 123, 21, 60, 98, 23,
+        29, 193, 221, 44, 89, 34, 244, 73, 25, 255, 31, 162, 59, 242, 104, 187, 57, 16, 9, 246, 42,
+        120, 196, 46, 58, 129, 185, 88, 178, 68, 231, 146, 50, 253, 62, 67, 118, 227, 208, 117, 114,
+        32, 18, 235, 84, 240, 135, 92, 116, 1, 113, 176, 99, 136, 205, 35, 100, 249, 124, 134, 236,
+        197, 159, 234, 228, 64, 36, 213, 168, 223, 13, 184, 232, 2, 226, 95, 198, 15, 153, 70, 200,
+        241, 248, 11, 215, 137, 61, 211, 199, 128, 72, 169, 79, 189, 26, 111, 207, 4, 195, 190, 139,
+        30, 49, 140, 143, 225, 239, 22, 173, 17, 122, 165, 141, 256, 144, 81, 158, 121, 52, 222,
+        157, 8, 133, 123, 21, 60, 98, 23, 29, 193, 221, 44, 89, 34, 244, 73, 25, 255, 31, 162, 59,
+        242, 104, 187, 57, 16, 9, 246, 42, 120, 196, 46, 58, 129, 185, 88, 178, 68, 231, 146, 50,
+        253, 62, 67, 118, 227, 208, 117, 114, 32, 18, 235, 84, 240, 135, 92, 116, 1,
+    ],
+    [
+        1, 114, 146, 196, 242, 89, 123, 144, 225, 207, 211, 153, 223, 236, 176, 18, 253, 58, 187,
+        244, 60, 158, 22, 195, 128, 200, 184, 159, 136, 84, 67, 185, 16, 25, 23, 52, 17, 139, 169,
+        248, 2, 228, 35, 135, 227, 178, 246, 31, 193, 157, 165, 49, 189, 215, 95, 36, 249, 116, 117,
+        231, 120, 59, 44, 133, 256, 143, 111, 61, 15, 168, 134, 113, 32, 50, 46, 104, 34, 21, 81,
+        239, 4, 199, 70, 13, 197, 99, 235, 62, 129, 57, 73, 98, 121, 173, 190, 72, 241, 232, 234,
+        205, 240, 118, 88, 9, 255, 29, 222, 122, 30, 79, 11, 226, 64, 100, 92, 208, 68, 42, 162,
+        221, 8, 141, 140, 26, 137, 198, 213, 124, 1, 114, 146, 196, 242, 89, 123, 144, 225, 207,
+        211, 153, 223, 236, 176, 18, 253, 58, 187, 244, 60, 158, 22, 195, 128, 200, 184, 159, 136,
+        84, 67, 185, 16, 25, 23, 52, 17, 139, 169, 248, 2, 228, 35, 135, 227, 178, 246, 31, 193,
+        157, 165, 49, 189, 215, 95, 36, 249, 116, 117, 231, 120, 59, 44, 133, 256, 143, 111, 61, 15,
+        168, 134, 113, 32, 50, 46, 104, 34, 21, 81, 239, 4, 199, 70, 13, 197, 99, 235, 62, 129, 57,
+        73, 98, 121, 173, 190, 72, 241, 232, 234, 205, 240, 118, 88, 9, 255, 29, 222, 122, 30, 79,
+        11, 226, 64, 100, 92, 208, 68, 42, 162, 221, 8, 141, 140, 26, 137, 198, 213, 124, 1,
+    ],
+    [
+        1, 115, 118, 206, 46, 150, 31, 224, 60, 218, 141, 24, 190, 5, 61, 76, 2, 230, 236, 155, 92,
+        43, 62, 191, 120, 179, 25, 48, 123, 10, 122, 152, 4, 203, 215, 53, 184, 86, 124, 125, 240,
+        101, 50, 96, 246, 20, 244, 47, 8, 149, 173, 106, 111, 172, 248, 250, 223, 202, 100, 192,
+        235, 40, 231, 94, 16, 41, 89, 212, 222, 87, 239, 243, 189, 147, 200, 127, 213, 80, 205, 188,
+        32, 82, 178, 167, 187, 174, 221, 229, 121, 37, 143, 254, 169, 160, 153, 119, 64, 164, 99,
+        77, 117, 91, 185, 201, 242, 74, 29, 251, 81, 63, 49, 238, 128, 71, 198, 154, 234, 182, 113,
+        145, 227, 148, 58, 245, 162, 126, 98, 219, 256, 142, 139, 51, 211, 107, 226, 33, 197, 39,
+        116, 233, 67, 252, 196, 181, 255, 27, 21, 102, 165, 214, 195, 66, 137, 78, 232, 209, 134,
+        247, 135, 105, 253, 54, 42, 204, 73, 171, 133, 132, 17, 156, 207, 161, 11, 237, 13, 210,
+        249, 108, 84, 151, 146, 85, 9, 7, 34, 55, 157, 65, 22, 217, 26, 163, 241, 216, 168, 45, 35,
+        170, 18, 14, 68, 110, 57, 130, 44, 177, 52, 69, 225, 175, 79, 90, 70, 83, 36, 28, 136, 220,
+        114, 3, 88, 97, 104, 138, 193, 93, 158, 180, 140, 166, 72, 56, 15, 183, 228, 6, 176, 194,
+        208, 19, 129, 186, 59, 103, 23, 75, 144, 112, 30, 109, 199, 12, 95, 131, 159, 38, 1,
+    ],
+    [
+        1, 116, 92, 135, 240, 84, 235, 18, 32, 114, 117, 208, 227, 118, 67, 62, 253, 50, 146, 231,
+        68, 178, 88, 185, 129, 58, 46, 196, 120, 42, 246, 9, 16, 57, 187, 104, 242, 59, 162, 31,
+        255, 25, 73, 244, 34, 89, 44, 221, 193, 29, 23, 98, 60, 21, 123, 133, 8, 157, 222, 52, 121,
+        158, 81, 144, 256, 141, 165, 122, 17, 173, 22, 239, 225, 143, 140, 49, 30, 139, 190, 195, 4,
+        207, 111, 26, 189, 79, 169, 72, 128, 199, 211, 61, 137, 215, 11, 248, 241, 200, 70, 153, 15,
+        198, 95, 226, 2, 232, 184, 13, 223, 168, 213, 36, 64, 228, 234, 159, 197, 236, 134, 124,
+        249, 100, 35, 205, 136, 99, 176, 113, 1, 116, 92, 135, 240, 84, 235, 18, 32, 114, 117, 208,
+        227, 118, 67, 62, 253, 50, 146, 231, 68, 178, 88, 185, 129, 58, 46, 196, 120, 42, 246, 9,
+        16, 57, 187, 104, 242, 59, 162, 31, 255, 25, 73, 244, 34, 89, 44, 221, 193, 29, 23, 98, 60,
+        21, 123, 133, 8, 157, 222, 52, 121, 158, 81, 144, 256, 141, 165, 122, 17, 173, 22, 239, 225,
+        143, 140, 49, 30, 139, 190, 195, 4, 207, 111, 26, 189, 79, 169, 72, 128, 199, 211, 61, 137,
+        215, 11, 248, 241, 200, 70, 153, 15, 198, 95, 226, 2, 232, 184, 13, 223, 168, 213, 36, 64,
+        228, 234, 159, 197, 236, 134, 124, 249, 100, 35, 205, 136, 99, 176, 113, 1,
+    ],
+    [
+        1, 117, 68, 246, 255, 23, 121, 22, 4, 211, 15, 213, 249, 92, 227, 88, 16, 73, 60, 81, 225,
+        111, 137, 95, 64, 35, 240, 67, 129, 187, 34, 123, 256, 140, 189, 11, 2, 234, 136, 235, 253,
+        46, 242, 44, 8, 165, 30, 169, 241, 184, 197, 176, 32, 146, 120, 162, 193, 222, 17, 190, 128,
+        70, 223, 134, 1, 117, 68, 246, 255, 23, 121, 22, 4, 211, 15, 213, 249, 92, 227, 88, 16, 73,
+        60, 81, 225, 111, 137, 95, 64, 35, 240, 67, 129, 187, 34, 123, 256, 140, 189, 11, 2, 234,
+        136, 235, 253, 46, 242, 44, 8, 165, 30, 169, 241, 184, 197, 176, 32, 146, 120, 162, 193,
+        222, 17, 190, 128, 70, 223, 134, 1, 117, 68, 246, 255, 23, 121, 22, 4, 211, 15, 213, 249,
+        92, 227, 88, 16, 73, 60, 81, 225, 111, 137, 95, 64, 35, 240, 67, 129, 187, 34, 123, 256,
+        140, 189, 11, 2, 234, 136, 235, 253, 46, 242, 44, 8, 165, 30, 169, 241, 184, 197, 176, 32,
+        146, 120, 162, 193, 222, 17, 190, 128, 70, 223, 134, 1, 117, 68, 246, 255, 23, 121, 22, 4,
+        211, 15, 213, 249, 92, 227, 88, 16, 73, 60, 81, 225, 111, 137, 95, 64, 35, 240, 67, 129,
+        187, 34, 123, 256, 140, 189, 11, 2, 234, 136, 235, 253, 46, 242, 44, 8, 165, 30, 169, 241,
+        184, 197, 176, 32, 146, 120, 162, 193, 222, 17, 190, 128, 70, 223, 134, 1,
+    ],
+    [
+        1, 118, 46, 31, 60, 141, 190, 61, 2, 236, 92, 62, 120, 25, 123, 122, 4, 215, 184, 124, 240,
+        50, 246, 244, 8, 173, 111, 248, 223, 100, 235, 231, 16, 89, 222, 239, 189, 200, 213, 205,
+        32, 178, 187, 221, 121, 143, 169, 153, 64, 99, 117, 185, 242, 29, 81, 49, 128, 198, 234,
+        113, 227, 58, 162, 98, 256, 139, 211, 226, 197, 116, 67, 196, 255, 21, 165, 195, 137, 232,
+        134, 135, 253, 42, 73, 133, 17, 207, 11, 13, 249, 84, 146, 9, 34, 157, 22, 26, 241, 168, 35,
+        18, 68, 57, 44, 52, 225, 79, 70, 36, 136, 114, 88, 104, 193, 158, 140, 72, 15, 228, 176,
+        208, 129, 59, 23, 144, 30, 199, 95, 159, 1, 118, 46, 31, 60, 141, 190, 61, 2, 236, 92, 62,
+        120, 25, 123, 122, 4, 215, 184, 124, 240, 50, 246, 244, 8, 173, 111, 248, 223, 100, 235,
+        231, 16, 89, 222, 239, 189, 200, 213, 205, 32, 178, 187, 221, 121, 143, 169, 153, 64, 99,
+        117, 185, 242, 29, 81, 49, 128, 198, 234, 113, 227, 58, 162, 98, 256, 139, 211, 226, 197,
+        116, 67, 196, 255, 21, 165, 195, 137, 232, 134, 135, 253, 42, 73, 133, 17, 207, 11, 13, 249,
+        84, 146, 9, 34, 157, 22, 26, 241, 168, 35, 18, 68, 57, 44, 52, 225, 79, 70, 36, 136, 114,
+        88, 104, 193, 158, 140, 72, 15, 228, 176, 208, 129, 59, 23, 144, 30, 199, 95, 159, 1,
+    ],
+    [
+        1, 119, 26, 10, 162, 3, 100, 78, 30, 229, 9, 43, 234, 90, 173, 27, 129, 188, 13, 5, 81, 130,
+        50, 39, 15, 243, 133, 150, 117, 45, 215, 142, 193, 94, 135, 131, 169, 65, 25, 148, 136, 250,
+        195, 75, 187, 151, 236, 71, 225, 47, 196, 194, 213, 161, 141, 74, 68, 125, 226, 166, 222,
+        204, 118, 164, 241, 152, 98, 97, 235, 209, 199, 37, 34, 191, 113, 83, 111, 102, 59, 82, 249,
+        76, 49, 177, 246, 233, 228, 147, 17, 224, 185, 170, 184, 51, 158, 41, 253, 38, 153, 217,
+        123, 245, 114, 202, 137, 112, 221, 85, 92, 154, 79, 149, 255, 19, 205, 237, 190, 251, 57,
+        101, 197, 56, 239, 171, 46, 77, 168, 203, 256, 138, 231, 247, 95, 254, 157, 179, 227, 28,
+        248, 214, 23, 167, 84, 230, 128, 69, 244, 252, 176, 127, 207, 218, 242, 14, 124, 107, 140,
+        212, 42, 115, 64, 163, 122, 126, 88, 192, 232, 109, 121, 7, 62, 182, 70, 106, 21, 186, 32,
+        210, 61, 63, 44, 96, 116, 183, 189, 132, 31, 91, 35, 53, 139, 93, 16, 105, 159, 160, 22, 48,
+        58, 220, 223, 66, 144, 174, 146, 155, 198, 175, 8, 181, 208, 80, 11, 24, 29, 110, 240, 33,
+        72, 87, 73, 206, 99, 216, 4, 219, 104, 40, 134, 12, 143, 55, 120, 145, 36, 172, 165, 103,
+        178, 108, 2, 238, 52, 20, 67, 6, 200, 156, 60, 201, 18, 86, 211, 180, 89, 54, 1,
+    ],
+    [
+        1, 120, 8, 189, 64, 227, 255, 17, 241, 136, 129, 60, 4, 223, 32, 242, 256, 137, 249, 68,
+        193, 30, 2, 240, 16, 121, 128, 197, 253, 34, 225, 15, 1, 120, 8, 189, 64, 227, 255, 17, 241,
+        136, 129, 60, 4, 223, 32, 242, 256, 137, 249, 68, 193, 30, 2, 240, 16, 121, 128, 197, 253,
+        34, 225, 15, 1, 120, 8, 189, 64, 227, 255, 17, 241, 136, 129, 60, 4, 223, 32, 242, 256, 137,
+        249, 68, 193, 30, 2, 240, 16, 121, 128, 197, 253, 34, 225, 15, 1, 120, 8, 189, 64, 227, 255,
+        17, 241, 136, 129, 60, 4, 223, 32, 242, 256, 137, 249, 68, 193, 30, 2, 240, 16, 121, 128,
+        197, 253, 34, 225, 15, 1, 120, 8, 189, 64, 227, 255, 17, 241, 136, 129, 60, 4, 223, 32, 242,
+        256, 137, 249, 68, 193, 30, 2, 240, 16, 121, 128, 197, 253, 34, 225, 15, 1, 120, 8, 189, 64,
+        227, 255, 17, 241, 136, 129, 60, 4, 223, 32, 242, 256, 137, 249, 68, 193, 30, 2, 240, 16,
+        121, 128, 197, 253, 34, 225, 15, 1, 120, 8, 189, 64, 227, 255, 17, 241, 136, 129, 60, 4,
+        223, 32, 242, 256, 137, 249, 68, 193, 30, 2, 240, 16, 121, 128, 197, 253, 34, 225, 15, 1,
+        120, 8, 189, 64, 227, 255, 17, 241, 136, 129, 60, 4, 223, 32, 242, 256, 137, 249, 68, 193,
+        30, 2, 240, 16, 121, 128, 197, 253, 34, 225, 15, 1,
+    ],
+    [
+        1, 121, 249, 60, 64, 34, 2, 242, 241, 120, 128, 68, 4, 227, 225, 240, 256, 136, 8, 197, 193,
+        223, 255, 15, 16, 137, 129, 189, 253, 30, 32, 17, 1, 121, 249, 60, 64, 34, 2, 242, 241, 120,
+        128, 68, 4, 227, 225, 240, 256, 136, 8, 197, 193, 223, 255, 15, 16, 137, 129, 189, 253, 30,
+        32, 17, 1, 121, 249, 60, 64, 34, 2, 242, 241, 120, 128, 68, 4, 227, 225, 240, 256, 136, 8,
+        197, 193, 223, 255, 15, 16, 137, 129, 189, 253, 30, 32, 17, 1, 121, 249, 60, 64, 34, 2, 242,
+        241, 120, 128, 68, 4, 227, 225, 240, 256, 136, 8, 197, 193, 223, 255, 15, 16, 137, 129, 189,
+        253, 30, 32, 17, 1, 121, 249, 60, 64, 34, 2, 242, 241, 120, 128, 68, 4, 227, 225, 240, 256,
+        136, 8, 197, 193, 223, 255, 15, 16, 137, 129, 189, 253, 30, 32, 17, 1, 121, 249, 60, 64, 34,
+        2, 242, 241, 120, 128, 68, 4, 227, 225, 240, 256, 136, 8, 197, 193, 223, 255, 15, 16, 137,
+        129, 189, 253, 30, 32, 17, 1, 121, 249, 60, 64, 34, 2, 242, 241, 120, 128, 68, 4, 227, 225,
+        240, 256, 136, 8, 197, 193, 223, 255, 15, 16, 137, 129, 189, 253, 30, 32, 17, 1, 121, 249,
+        60, 64, 34, 2, 242, 241, 120, 128, 68, 4, 227, 225, 240, 256, 136, 8, 197, 193, 223, 255,
+        15, 16, 137, 129, 189, 253, 30, 32, 17, 1,
+    ],
+    [
+        1, 122, 235, 143, 227, 195, 146, 79, 129, 61, 246, 200, 242, 226, 73, 168, 193, 159, 123,
+        100, 121, 113, 165, 84, 225, 208, 190, 50, 189, 185, 211, 42, 241, 104, 95, 25, 223, 221,
+        234, 21, 249, 52, 176, 141, 240, 239, 117, 139, 253, 26, 88, 199, 120, 248, 187, 198, 255,
+        13, 44, 228, 60, 124, 222, 99, 256, 135, 22, 114, 30, 62, 111, 178, 128, 196, 11, 57, 15,
+        31, 184, 89, 64, 98, 134, 157, 136, 144, 92, 173, 32, 49, 67, 207, 68, 72, 46, 215, 16, 153,
+        162, 232, 34, 36, 23, 236, 8, 205, 81, 116, 17, 18, 140, 118, 4, 231, 169, 58, 137, 9, 70,
+        59, 2, 244, 213, 29, 197, 133, 35, 158, 1, 122, 235, 143, 227, 195, 146, 79, 129, 61, 246,
+        200, 242, 226, 73, 168, 193, 159, 123, 100, 121, 113, 165, 84, 225, 208, 190, 50, 189, 185,
+        211, 42, 241, 104, 95, 25, 223, 221, 234, 21, 249, 52, 176, 141, 240, 239, 117, 139, 253,
+        26, 88, 199, 120, 248, 187, 198, 255, 13, 44, 228, 60, 124, 222, 99, 256, 135, 22, 114, 30,
+        62, 111, 178, 128, 196, 11, 57, 15, 31, 184, 89, 64, 98, 134, 157, 136, 144, 92, 173, 32,
+        49, 67, 207, 68, 72, 46, 215, 16, 153, 162, 232, 34, 36, 23, 236, 8, 205, 81, 116, 17, 18,
+        140, 118, 4, 231, 169, 58, 137, 9, 70, 59, 2, 244, 213, 29, 197, 133, 35, 158, 1,
+    ],
+    [
+        1, 123, 223, 187, 128, 67, 17, 35, 193, 95, 120, 111, 32, 81, 197, 73, 241, 88, 30, 92, 8,
+        213, 242, 211, 253, 22, 136, 23, 2, 246, 189, 117, 256, 134, 34, 70, 129, 190, 240, 222, 64,
+        162, 137, 146, 225, 176, 60, 184, 16, 169, 227, 165, 249, 44, 15, 46, 4, 235, 121, 234, 255,
+        11, 68, 140, 1, 123, 223, 187, 128, 67, 17, 35, 193, 95, 120, 111, 32, 81, 197, 73, 241, 88,
+        30, 92, 8, 213, 242, 211, 253, 22, 136, 23, 2, 246, 189, 117, 256, 134, 34, 70, 129, 190,
+        240, 222, 64, 162, 137, 146, 225, 176, 60, 184, 16, 169, 227, 165, 249, 44, 15, 46, 4, 235,
+        121, 234, 255, 11, 68, 140, 1, 123, 223, 187, 128, 67, 17, 35, 193, 95, 120, 111, 32, 81,
+        197, 73, 241, 88, 30, 92, 8, 213, 242, 211, 253, 22, 136, 23, 2, 246, 189, 117, 256, 134,
+        34, 70, 129, 190, 240, 222, 64, 162, 137, 146, 225, 176, 60, 184, 16, 169, 227, 165, 249,
+        44, 15, 46, 4, 235, 121, 234, 255, 11, 68, 140, 1, 123, 223, 187, 128, 67, 17, 35, 193, 95,
+        120, 111, 32, 81, 197, 73, 241, 88, 30, 92, 8, 213, 242, 211, 253, 22, 136, 23, 2, 246, 189,
+        117, 256, 134, 34, 70, 129, 190, 240, 222, 64, 162, 137, 146, 225, 176, 60, 184, 16, 169,
+        227, 165, 249, 44, 15, 46, 4, 235, 121, 234, 255, 11, 68, 140, 1,
+    ],
+    [
+        1, 124, 213, 198, 137, 26, 140, 141, 8, 221, 162, 42, 68, 208, 92, 100, 64, 226, 11, 79, 30,
+        122, 222, 29, 255, 9, 88, 118, 240, 205, 234, 232, 241, 72, 190, 173, 121, 98, 73, 57, 129,
+        62, 235, 99, 197, 13, 70, 199, 4, 239, 81, 21, 34, 104, 46, 50, 32, 113, 134, 168, 15, 61,
+        111, 143, 256, 133, 44, 59, 120, 231, 117, 116, 249, 36, 95, 215, 189, 49, 165, 157, 193,
+        31, 246, 178, 227, 135, 35, 228, 2, 248, 169, 139, 17, 52, 23, 25, 16, 185, 67, 84, 136,
+        159, 184, 200, 128, 195, 22, 158, 60, 244, 187, 58, 253, 18, 176, 236, 223, 153, 211, 207,
+        225, 144, 123, 89, 242, 196, 146, 114, 1, 124, 213, 198, 137, 26, 140, 141, 8, 221, 162, 42,
+        68, 208, 92, 100, 64, 226, 11, 79, 30, 122, 222, 29, 255, 9, 88, 118, 240, 205, 234, 232,
+        241, 72, 190, 173, 121, 98, 73, 57, 129, 62, 235, 99, 197, 13, 70, 199, 4, 239, 81, 21, 34,
+        104, 46, 50, 32, 113, 134, 168, 15, 61, 111, 143, 256, 133, 44, 59, 120, 231, 117, 116, 249,
+        36, 95, 215, 189, 49, 165, 157, 193, 31, 246, 178, 227, 135, 35, 228, 2, 248, 169, 139, 17,
+        52, 23, 25, 16, 185, 67, 84, 136, 159, 184, 200, 128, 195, 22, 158, 60, 244, 187, 58, 253,
+        18, 176, 236, 223, 153, 211, 207, 225, 144, 123, 89, 242, 196, 146, 114, 1,
+    ],
+    [
+        1, 125, 205, 182, 134, 45, 228, 230, 223, 119, 226, 237, 70, 12, 215, 147, 128, 66, 26, 166,
+        190, 106, 143, 142, 17, 69, 144, 10, 222, 251, 21, 55, 193, 224, 244, 174, 162, 204, 57,
+        186, 120, 94, 185, 252, 146, 3, 118, 101, 32, 145, 135, 170, 176, 155, 100, 164, 197, 210,
+        36, 131, 184, 127, 198, 78, 241, 56, 61, 172, 169, 51, 207, 175, 30, 152, 239, 63, 165, 65,
+        158, 218, 8, 229, 98, 171, 44, 103, 25, 41, 242, 181, 9, 97, 46, 96, 178, 148, 253, 14, 208,
+        43, 235, 77, 116, 108, 136, 38, 124, 80, 234, 209, 168, 183, 2, 250, 153, 107, 11, 90, 199,
+        203, 189, 238, 195, 217, 140, 24, 173, 37, 256, 132, 52, 75, 123, 212, 29, 27, 34, 138, 31,
+        20, 187, 245, 42, 110, 129, 191, 231, 91, 67, 151, 114, 115, 240, 188, 113, 247, 35, 6, 236,
+        202, 64, 33, 13, 83, 95, 53, 200, 71, 137, 163, 72, 5, 111, 254, 139, 156, 225, 112, 122,
+        87, 81, 102, 157, 93, 60, 47, 221, 126, 73, 130, 59, 179, 16, 201, 196, 85, 88, 206, 50, 82,
+        227, 105, 18, 194, 92, 192, 99, 39, 249, 28, 159, 86, 213, 154, 232, 216, 15, 76, 248, 160,
+        211, 161, 79, 109, 4, 243, 49, 214, 22, 180, 141, 149, 121, 219, 133, 177, 23, 48, 89, 74,
+        255, 7, 104, 150, 246, 167, 58, 54, 68, 19, 62, 40, 117, 233, 84, 220, 1,
+    ],
+    [
+        1, 126, 199, 145, 23, 71, 208, 251, 15, 91, 158, 119, 88, 37, 36, 167, 225, 80, 57, 243, 35,
+        41, 26, 192, 34, 172, 84, 47, 11, 101, 133, 53, 253, 10, 232, 191, 165, 230, 196, 24, 197,
+        150, 139, 38, 162, 109, 113, 103, 128, 194, 29, 56, 117, 93, 153, 3, 121, 83, 178, 69, 213,
+        110, 239, 45, 16, 217, 100, 7, 111, 108, 244, 161, 240, 171, 215, 105, 123, 78, 62, 102, 2,
+        252, 141, 33, 46, 142, 159, 245, 30, 182, 59, 238, 176, 74, 72, 77, 193, 160, 114, 229, 70,
+        82, 52, 127, 68, 87, 168, 94, 22, 202, 9, 106, 249, 20, 207, 125, 73, 203, 135, 48, 137, 43,
+        21, 76, 67, 218, 226, 206, 256, 131, 58, 112, 234, 186, 49, 6, 242, 166, 99, 138, 169, 220,
+        221, 90, 32, 177, 200, 14, 222, 216, 231, 65, 223, 85, 173, 210, 246, 156, 124, 204, 4, 247,
+        25, 66, 92, 27, 61, 233, 60, 107, 118, 219, 95, 148, 144, 154, 129, 63, 228, 201, 140, 164,
+        104, 254, 136, 174, 79, 188, 44, 147, 18, 212, 241, 40, 157, 250, 146, 149, 13, 96, 17, 86,
+        42, 152, 134, 179, 195, 155, 255, 5, 116, 224, 211, 115, 98, 12, 227, 75, 198, 19, 81, 183,
+        185, 180, 64, 97, 143, 28, 187, 175, 205, 130, 189, 170, 89, 163, 235, 55, 248, 151, 8, 237,
+        50, 132, 184, 54, 122, 209, 120, 214, 236, 181, 190, 39, 31, 51, 1,
+    ],
+    [
+        1, 127, 195, 93, 246, 145, 168, 5, 121, 204, 208, 202, 211, 69, 25, 91, 249, 12, 239, 27,
+        88, 125, 198, 217, 60, 167, 135, 183, 111, 219, 57, 43, 64, 161, 144, 41, 67, 28, 215, 63,
+        34, 206, 205, 78, 140, 47, 58, 170, 2, 254, 133, 186, 235, 33, 79, 10, 242, 151, 159, 147,
+        165, 138, 50, 182, 241, 24, 221, 54, 176, 250, 139, 177, 120, 77, 13, 109, 222, 181, 114,
+        86, 128, 65, 31, 82, 134, 56, 173, 126, 68, 155, 153, 156, 23, 94, 116, 83, 4, 251, 9, 115,
+        213, 66, 158, 20, 227, 45, 61, 37, 73, 19, 100, 107, 225, 48, 185, 108, 95, 243, 21, 97,
+        240, 154, 26, 218, 187, 105, 228, 172, 256, 130, 62, 164, 11, 112, 89, 252, 136, 53, 49, 55,
+        46, 188, 232, 166, 8, 245, 18, 230, 169, 132, 59, 40, 197, 90, 122, 74, 146, 38, 200, 214,
+        193, 96, 113, 216, 190, 229, 42, 194, 223, 51, 52, 179, 117, 210, 199, 87, 255, 3, 124, 71,
+        22, 224, 178, 247, 15, 106, 98, 110, 92, 119, 207, 75, 16, 233, 36, 203, 81, 7, 118, 80,
+        137, 180, 244, 148, 35, 76, 143, 171, 129, 192, 226, 175, 123, 201, 84, 131, 189, 102, 104,
+        101, 234, 163, 141, 174, 253, 6, 248, 142, 44, 191, 99, 237, 30, 212, 196, 220, 184, 238,
+        157, 150, 32, 209, 72, 149, 162, 14, 236, 160, 17, 103, 231, 39, 70, 152, 29, 85, 1,
+    ],
+    [
+        1, 128, 193, 32, 241, 8, 253, 2, 256, 129, 64, 225, 16, 249, 4, 255, 1, 128, 193, 32, 241,
+        8, 253, 2, 256, 129, 64, 225, 16, 249, 4, 255, 1, 128, 193, 32, 241, 8, 253, 2, 256, 129,
+        64, 225, 16, 249, 4, 255, 1, 128, 193, 32, 241, 8, 253, 2, 256, 129, 64, 225, 16, 249, 4,
+        255, 1, 128, 193, 32, 241, 8, 253, 2, 256, 129, 64, 225, 16, 249, 4, 255, 1, 128, 193, 32,
+        241, 8, 253, 2, 256, 129, 64, 225, 16, 249, 4, 255, 1, 128, 193, 32, 241, 8, 253, 2, 256,
+        129, 64, 225, 16, 249, 4, 255, 1, 128, 193, 32, 241, 8, 253, 2, 256, 129, 64, 225, 16, 249,
+        4, 255, 1, 128, 193, 32, 241, 8, 253, 2, 256, 129, 64, 225, 16, 249, 4, 255, 1, 128, 193,
+        32, 241, 8, 253, 2, 256, 129, 64, 225, 16, 249, 4, 255, 1, 128, 193, 32, 241, 8, 253, 2,
+        256, 129, 64, 225, 16, 249, 4, 255, 1, 128, 193, 32, 241, 8, 253, 2, 256, 129, 64, 225, 16,
+        249, 4, 255, 1, 128, 193, 32, 241, 8, 253, 2, 256, 129, 64, 225, 16, 249, 4, 255, 1, 128,
+        193, 32, 241, 8, 253, 2, 256, 129, 64, 225, 16, 249, 4, 255, 1, 128, 193, 32, 241, 8, 253,
+        2, 256, 129, 64, 225, 16, 249, 4, 255, 1, 128, 193, 32, 241, 8, 253, 2, 256, 129, 64, 225,
+        16, 249, 4, 255, 1,
+    ],
+    [
+        1, 129, 193, 225, 241, 249, 253, 255, 256, 128, 64, 32, 16, 8, 4, 2, 1, 129, 193, 225, 241,
+        249, 253, 255, 256, 128, 64, 32, 16, 8, 4, 2, 1, 129, 193, 225, 241, 249, 253, 255, 256,
+        128, 64, 32, 16, 8, 4, 2, 1, 129, 193, 225, 241, 249, 253, 255, 256, 128, 64, 32, 16, 8, 4,
+        2, 1, 129, 193, 225, 241, 249, 253, 255, 256, 128, 64, 32, 16, 8, 4, 2, 1, 129, 193, 225,
+        241, 249, 253, 255, 256, 128, 64, 32, 16, 8, 4, 2, 1, 129, 193, 225, 241, 249, 253, 255,
+        256, 128, 64, 32, 16, 8, 4, 2, 1, 129, 193, 225, 241, 249, 253, 255, 256, 128, 64, 32, 16,
+        8, 4, 2, 1, 129, 193, 225, 241, 249, 253, 255, 256, 128, 64, 32, 16, 8, 4, 2, 1, 129, 193,
+        225, 241, 249, 253, 255, 256, 128, 64, 32, 16, 8, 4, 2, 1, 129, 193, 225, 241, 249, 253,
+        255, 256, 128, 64, 32, 16, 8, 4, 2, 1, 129, 193, 225, 241, 249, 253, 255, 256, 128, 64, 32,
+        16, 8, 4, 2, 1, 129, 193, 225, 241, 249, 253, 255, 256, 128, 64, 32, 16, 8, 4, 2, 1, 129,
+        193, 225, 241, 249, 253, 255, 256, 128, 64, 32, 16, 8, 4, 2, 1, 129, 193, 225, 241, 249,
+        253, 255, 256, 128, 64, 32, 16, 8, 4, 2, 1, 129, 193, 225, 241, 249, 253, 255, 256, 128, 64,
+        32, 16, 8, 4, 2, 1,
+    ],
+    [
+        1, 130, 195, 164, 246, 112, 168, 252, 121, 53, 208, 55, 211, 188, 25, 166, 249, 245, 239,
+        230, 88, 132, 198, 40, 60, 90, 135, 74, 111, 38, 57, 214, 64, 96, 144, 216, 67, 229, 215,
+        194, 34, 51, 205, 179, 140, 210, 58, 87, 2, 3, 133, 71, 235, 224, 79, 247, 242, 106, 159,
+        110, 165, 119, 50, 75, 241, 233, 221, 203, 176, 7, 139, 80, 120, 180, 13, 148, 222, 76, 114,
+        171, 128, 192, 31, 175, 134, 201, 173, 131, 68, 102, 153, 101, 23, 163, 116, 174, 4, 6, 9,
+        142, 213, 191, 158, 237, 227, 212, 61, 220, 73, 238, 100, 150, 225, 209, 185, 149, 95, 14,
+        21, 160, 240, 103, 26, 39, 187, 152, 228, 85, 256, 127, 62, 93, 11, 145, 89, 5, 136, 204,
+        49, 202, 46, 69, 232, 91, 8, 12, 18, 27, 169, 125, 59, 217, 197, 167, 122, 183, 146, 219,
+        200, 43, 193, 161, 113, 41, 190, 28, 42, 63, 223, 206, 52, 78, 117, 47, 199, 170, 255, 254,
+        124, 186, 22, 33, 178, 10, 15, 151, 98, 147, 92, 138, 207, 182, 16, 24, 36, 54, 81, 250,
+        118, 177, 137, 77, 244, 109, 35, 181, 143, 86, 129, 65, 226, 82, 123, 56, 84, 126, 189, 155,
+        104, 156, 234, 94, 141, 83, 253, 251, 248, 115, 44, 66, 99, 20, 30, 45, 196, 37, 184, 19,
+        157, 107, 32, 48, 72, 108, 162, 243, 236, 97, 17, 154, 231, 218, 70, 105, 29, 172, 1,
+    ],
+    [
+        1, 131, 199, 112, 23, 186, 208, 6, 15, 166, 158, 138, 88, 220, 36, 90, 225, 177, 57, 14, 35,
+        216, 26, 65, 34, 85, 84, 210, 11, 156, 133, 204, 253, 247, 232, 66, 165, 27, 196, 233, 197,
+        107, 139, 219, 162, 148, 113, 154, 128, 63, 29, 201, 117, 164, 153, 254, 121, 174, 178, 188,
+        213, 147, 239, 212, 16, 40, 100, 250, 111, 149, 244, 96, 240, 86, 215, 152, 123, 179, 62,
+        155, 2, 5, 141, 224, 46, 115, 159, 12, 30, 75, 59, 19, 176, 183, 72, 180, 193, 97, 114, 28,
+        70, 175, 52, 130, 68, 170, 168, 163, 22, 55, 9, 151, 249, 237, 207, 132, 73, 54, 135, 209,
+        137, 214, 21, 181, 67, 39, 226, 51, 256, 126, 58, 145, 234, 71, 49, 251, 242, 91, 99, 119,
+        169, 37, 221, 167, 32, 80, 200, 243, 222, 41, 231, 192, 223, 172, 173, 47, 246, 101, 124,
+        53, 4, 10, 25, 191, 92, 230, 61, 24, 60, 150, 118, 38, 95, 109, 144, 103, 129, 194, 228, 56,
+        140, 93, 104, 3, 136, 83, 79, 69, 44, 110, 18, 45, 241, 217, 157, 7, 146, 108, 13, 161, 17,
+        171, 42, 105, 134, 78, 195, 102, 255, 252, 116, 33, 211, 142, 98, 245, 227, 182, 198, 238,
+        81, 74, 185, 77, 64, 160, 143, 229, 187, 82, 205, 127, 189, 87, 89, 94, 235, 202, 248, 106,
+        8, 20, 50, 125, 184, 203, 122, 48, 120, 43, 236, 76, 190, 218, 31, 206, 1,
+    ],
+    [
+        1, 132, 205, 75, 134, 212, 228, 27, 223, 138, 226, 20, 70, 245, 215, 110, 128, 191, 26, 91,
+        190, 151, 143, 115, 17, 188, 144, 247, 222, 6, 21, 202, 193, 33, 244, 83, 162, 53, 57, 71,
+        120, 163, 185, 5, 146, 254, 118, 156, 32, 112, 135, 87, 176, 102, 100, 93, 197, 47, 36, 126,
+        184, 130, 198, 179, 241, 201, 61, 85, 169, 206, 207, 82, 30, 105, 239, 194, 165, 192, 158,
+        39, 8, 28, 98, 86, 44, 154, 25, 216, 242, 76, 9, 160, 46, 161, 178, 109, 253, 243, 208, 214,
+        235, 180, 116, 149, 136, 219, 124, 177, 234, 48, 168, 74, 2, 7, 153, 150, 11, 167, 199, 54,
+        189, 19, 195, 40, 140, 233, 173, 220, 256, 125, 52, 182, 123, 45, 29, 230, 34, 119, 31, 237,
+        187, 12, 42, 147, 129, 66, 231, 166, 67, 106, 114, 142, 240, 69, 113, 10, 35, 251, 236, 55,
+        64, 224, 13, 174, 95, 204, 200, 186, 137, 94, 72, 252, 111, 3, 139, 101, 225, 145, 122, 170,
+        81, 155, 157, 164, 60, 210, 221, 131, 73, 127, 59, 78, 16, 56, 196, 172, 88, 51, 50, 175,
+        227, 152, 18, 63, 92, 65, 99, 218, 249, 229, 159, 171, 213, 103, 232, 41, 15, 181, 248, 97,
+        211, 96, 79, 148, 4, 14, 49, 43, 22, 77, 141, 108, 121, 38, 133, 80, 23, 209, 89, 183, 255,
+        250, 104, 107, 246, 90, 58, 203, 68, 238, 62, 217, 117, 24, 84, 37, 1,
+    ],
+    [
+        1, 133, 213, 59, 137, 231, 140, 116, 8, 36, 162, 215, 68, 49, 92, 157, 64, 31, 11, 178, 30,
+        135, 222, 228, 255, 248, 88, 139, 240, 52, 234, 25, 241, 185, 190, 84, 121, 159, 73, 200,
+        129, 195, 235, 158, 197, 244, 70, 58, 4, 18, 81, 236, 34, 153, 46, 207, 32, 144, 134, 89,
+        15, 196, 111, 114, 256, 124, 44, 198, 120, 26, 117, 141, 249, 221, 95, 42, 189, 208, 165,
+        100, 193, 226, 246, 79, 227, 122, 35, 29, 2, 9, 169, 118, 17, 205, 23, 232, 16, 72, 67, 173,
+        136, 98, 184, 57, 128, 62, 22, 99, 60, 13, 187, 199, 253, 239, 176, 21, 223, 104, 211, 50,
+        225, 113, 123, 168, 242, 61, 146, 143, 1, 133, 213, 59, 137, 231, 140, 116, 8, 36, 162, 215,
+        68, 49, 92, 157, 64, 31, 11, 178, 30, 135, 222, 228, 255, 248, 88, 139, 240, 52, 234, 25,
+        241, 185, 190, 84, 121, 159, 73, 200, 129, 195, 235, 158, 197, 244, 70, 58, 4, 18, 81, 236,
+        34, 153, 46, 207, 32, 144, 134, 89, 15, 196, 111, 114, 256, 124, 44, 198, 120, 26, 117, 141,
+        249, 221, 95, 42, 189, 208, 165, 100, 193, 226, 246, 79, 227, 122, 35, 29, 2, 9, 169, 118,
+        17, 205, 23, 232, 16, 72, 67, 173, 136, 98, 184, 57, 128, 62, 22, 99, 60, 13, 187, 199, 253,
+        239, 176, 21, 223, 104, 211, 50, 225, 113, 123, 168, 242, 61, 146, 143, 1,
+    ],
+    [
+        1, 134, 223, 70, 128, 190, 17, 222, 193, 162, 120, 146, 32, 176, 197, 184, 241, 169, 30,
+        165, 8, 44, 242, 46, 253, 235, 136, 234, 2, 11, 189, 140, 256, 123, 34, 187, 129, 67, 240,
+        35, 64, 95, 137, 111, 225, 81, 60, 73, 16, 88, 227, 92, 249, 213, 15, 211, 4, 22, 121, 23,
+        255, 246, 68, 117, 1, 134, 223, 70, 128, 190, 17, 222, 193, 162, 120, 146, 32, 176, 197,
+        184, 241, 169, 30, 165, 8, 44, 242, 46, 253, 235, 136, 234, 2, 11, 189, 140, 256, 123, 34,
+        187, 129, 67, 240, 35, 64, 95, 137, 111, 225, 81, 60, 73, 16, 88, 227, 92, 249, 213, 15,
+        211, 4, 22, 121, 23, 255, 246, 68, 117, 1, 134, 223, 70, 128, 190, 17, 222, 193, 162, 120,
+        146, 32, 176, 197, 184, 241, 169, 30, 165, 8, 44, 242, 46, 253, 235, 136, 234, 2, 11, 189,
+        140, 256, 123, 34, 187, 129, 67, 240, 35, 64, 95, 137, 111, 225, 81, 60, 73, 16, 88, 227,
+        92, 249, 213, 15, 211, 4, 22, 121, 23, 255, 246, 68, 117, 1, 134, 223, 70, 128, 190, 17,
+        222, 193, 162, 120, 146, 32, 176, 197, 184, 241, 169, 30, 165, 8, 44, 242, 46, 253, 235,
+        136, 234, 2, 11, 189, 140, 256, 123, 34, 187, 129, 67, 240, 35, 64, 95, 137, 111, 225, 81,
+        60, 73, 16, 88, 227, 92, 249, 213, 15, 211, 4, 22, 121, 23, 255, 246, 68, 117, 1,
+    ],
+    [
+        1, 135, 235, 114, 227, 62, 146, 178, 129, 196, 246, 57, 242, 31, 73, 89, 193, 98, 123, 157,
+        121, 144, 165, 173, 225, 49, 190, 207, 189, 72, 211, 215, 241, 153, 95, 232, 223, 36, 234,
+        236, 249, 205, 176, 116, 240, 18, 117, 118, 253, 231, 88, 58, 120, 9, 187, 59, 255, 244, 44,
+        29, 60, 133, 222, 158, 256, 122, 22, 143, 30, 195, 111, 79, 128, 61, 11, 200, 15, 226, 184,
+        168, 64, 159, 134, 100, 136, 113, 92, 84, 32, 208, 67, 50, 68, 185, 46, 42, 16, 104, 162,
+        25, 34, 221, 23, 21, 8, 52, 81, 141, 17, 239, 140, 139, 4, 26, 169, 199, 137, 248, 70, 198,
+        2, 13, 213, 228, 197, 124, 35, 99, 1, 135, 235, 114, 227, 62, 146, 178, 129, 196, 246, 57,
+        242, 31, 73, 89, 193, 98, 123, 157, 121, 144, 165, 173, 225, 49, 190, 207, 189, 72, 211,
+        215, 241, 153, 95, 232, 223, 36, 234, 236, 249, 205, 176, 116, 240, 18, 117, 118, 253, 231,
+        88, 58, 120, 9, 187, 59, 255, 244, 44, 29, 60, 133, 222, 158, 256, 122, 22, 143, 30, 195,
+        111, 79, 128, 61, 11, 200, 15, 226, 184, 168, 64, 159, 134, 100, 136, 113, 92, 84, 32, 208,
+        67, 50, 68, 185, 46, 42, 16, 104, 162, 25, 34, 221, 23, 21, 8, 52, 81, 141, 17, 239, 140,
+        139, 4, 26, 169, 199, 137, 248, 70, 198, 2, 13, 213, 228, 197, 124, 35, 99, 1,
+    ],
+    [
+        1, 136, 249, 197, 64, 223, 2, 15, 241, 137, 128, 189, 4, 30, 225, 17, 256, 121, 8, 60, 193,
+        34, 255, 242, 16, 120, 129, 68, 253, 227, 32, 240, 1, 136, 249, 197, 64, 223, 2, 15, 241,
+        137, 128, 189, 4, 30, 225, 17, 256, 121, 8, 60, 193, 34, 255, 242, 16, 120, 129, 68, 253,
+        227, 32, 240, 1, 136, 249, 197, 64, 223, 2, 15, 241, 137, 128, 189, 4, 30, 225, 17, 256,
+        121, 8, 60, 193, 34, 255, 242, 16, 120, 129, 68, 253, 227, 32, 240, 1, 136, 249, 197, 64,
+        223, 2, 15, 241, 137, 128, 189, 4, 30, 225, 17, 256, 121, 8, 60, 193, 34, 255, 242, 16, 120,
+        129, 68, 253, 227, 32, 240, 1, 136, 249, 197, 64, 223, 2, 15, 241, 137, 128, 189, 4, 30,
+        225, 17, 256, 121, 8, 60, 193, 34, 255, 242, 16, 120, 129, 68, 253, 227, 32, 240, 1, 136,
+        249, 197, 64, 223, 2, 15, 241, 137, 128, 189, 4, 30, 225, 17, 256, 121, 8, 60, 193, 34, 255,
+        242, 16, 120, 129, 68, 253, 227, 32, 240, 1, 136, 249, 197, 64, 223, 2, 15, 241, 137, 128,
+        189, 4, 30, 225, 17, 256, 121, 8, 60, 193, 34, 255, 242, 16, 120, 129, 68, 253, 227, 32,
+        240, 1, 136, 249, 197, 64, 223, 2, 15, 241, 137, 128, 189, 4, 30, 225, 17, 256, 121, 8, 60,
+        193, 34, 255, 242, 16, 120, 129, 68, 253, 227, 32, 240, 1,
+    ],
+    [
+        1, 137, 8, 68, 64, 30, 255, 240, 241, 121, 129, 197, 4, 34, 32, 15, 256, 120, 249, 189, 193,
+        227, 2, 17, 16, 136, 128, 60, 253, 223, 225, 242, 1, 137, 8, 68, 64, 30, 255, 240, 241, 121,
+        129, 197, 4, 34, 32, 15, 256, 120, 249, 189, 193, 227, 2, 17, 16, 136, 128, 60, 253, 223,
+        225, 242, 1, 137, 8, 68, 64, 30, 255, 240, 241, 121, 129, 197, 4, 34, 32, 15, 256, 120, 249,
+        189, 193, 227, 2, 17, 16, 136, 128, 60, 253, 223, 225, 242, 1, 137, 8, 68, 64, 30, 255, 240,
+        241, 121, 129, 197, 4, 34, 32, 15, 256, 120, 249, 189, 193, 227, 2, 17, 16, 136, 128, 60,
+        253, 223, 225, 242, 1, 137, 8, 68, 64, 30, 255, 240, 241, 121, 129, 197, 4, 34, 32, 15, 256,
+        120, 249, 189, 193, 227, 2, 17, 16, 136, 128, 60, 253, 223, 225, 242, 1, 137, 8, 68, 64, 30,
+        255, 240, 241, 121, 129, 197, 4, 34, 32, 15, 256, 120, 249, 189, 193, 227, 2, 17, 16, 136,
+        128, 60, 253, 223, 225, 242, 1, 137, 8, 68, 64, 30, 255, 240, 241, 121, 129, 197, 4, 34, 32,
+        15, 256, 120, 249, 189, 193, 227, 2, 17, 16, 136, 128, 60, 253, 223, 225, 242, 1, 137, 8,
+        68, 64, 30, 255, 240, 241, 121, 129, 197, 4, 34, 32, 15, 256, 120, 249, 189, 193, 227, 2,
+        17, 16, 136, 128, 60, 253, 223, 225, 242, 1,
+    ],
+    [
+        1, 138, 26, 247, 162, 254, 100, 179, 30, 28, 9, 214, 234, 167, 173, 230, 129, 69, 13, 252,
+        81, 127, 50, 218, 15, 14, 133, 107, 117, 212, 215, 115, 193, 163, 135, 126, 169, 192, 25,
+        109, 136, 7, 195, 182, 187, 106, 236, 186, 225, 210, 196, 63, 213, 96, 141, 183, 68, 132,
+        226, 91, 222, 53, 118, 93, 241, 105, 98, 160, 235, 48, 199, 220, 34, 66, 113, 174, 111, 155,
+        59, 175, 249, 181, 49, 80, 246, 24, 228, 110, 17, 33, 185, 87, 184, 206, 158, 216, 253, 219,
+        153, 40, 123, 12, 114, 55, 137, 145, 221, 172, 92, 103, 79, 108, 255, 238, 205, 20, 190, 6,
+        57, 156, 197, 201, 239, 86, 46, 180, 168, 54, 256, 119, 231, 10, 95, 3, 157, 78, 227, 229,
+        248, 43, 23, 90, 84, 27, 128, 188, 244, 5, 176, 130, 207, 39, 242, 243, 124, 150, 140, 45,
+        42, 142, 64, 94, 122, 131, 88, 65, 232, 148, 121, 250, 62, 75, 70, 151, 21, 71, 32, 47, 61,
+        194, 44, 161, 116, 74, 189, 125, 31, 166, 35, 204, 139, 164, 16, 152, 159, 97, 22, 209, 58,
+        37, 223, 191, 144, 83, 146, 102, 198, 82, 8, 76, 208, 177, 11, 233, 29, 147, 240, 224, 72,
+        170, 73, 51, 99, 41, 4, 38, 104, 217, 134, 245, 143, 202, 120, 112, 36, 85, 165, 154, 178,
+        149, 2, 19, 52, 237, 67, 251, 200, 101, 60, 56, 18, 171, 211, 77, 89, 203, 1,
+    ],
+    [
+        1, 139, 46, 226, 60, 116, 190, 196, 2, 21, 92, 195, 120, 232, 123, 135, 4, 42, 184, 133,
+        240, 207, 246, 13, 8, 84, 111, 9, 223, 157, 235, 26, 16, 168, 222, 18, 189, 57, 213, 52, 32,
+        79, 187, 36, 121, 114, 169, 104, 64, 158, 117, 72, 242, 228, 81, 208, 128, 59, 234, 144,
+        227, 199, 162, 159, 256, 118, 211, 31, 197, 141, 67, 61, 255, 236, 165, 62, 137, 25, 134,
+        122, 253, 215, 73, 124, 17, 50, 11, 244, 249, 173, 146, 248, 34, 100, 22, 231, 241, 89, 35,
+        239, 68, 200, 44, 205, 225, 178, 70, 221, 136, 143, 88, 153, 193, 99, 140, 185, 15, 29, 176,
+        49, 129, 198, 23, 113, 30, 58, 95, 98, 1, 139, 46, 226, 60, 116, 190, 196, 2, 21, 92, 195,
+        120, 232, 123, 135, 4, 42, 184, 133, 240, 207, 246, 13, 8, 84, 111, 9, 223, 157, 235, 26,
+        16, 168, 222, 18, 189, 57, 213, 52, 32, 79, 187, 36, 121, 114, 169, 104, 64, 158, 117, 72,
+        242, 228, 81, 208, 128, 59, 234, 144, 227, 199, 162, 159, 256, 118, 211, 31, 197, 141, 67,
+        61, 255, 236, 165, 62, 137, 25, 134, 122, 253, 215, 73, 124, 17, 50, 11, 244, 249, 173, 146,
+        248, 34, 100, 22, 231, 241, 89, 35, 239, 68, 200, 44, 205, 225, 178, 70, 221, 136, 143, 88,
+        153, 193, 99, 140, 185, 15, 29, 176, 49, 129, 198, 23, 113, 30, 58, 95, 98, 1,
+    ],
+    [
+        1, 140, 68, 11, 255, 234, 121, 235, 4, 46, 15, 44, 249, 165, 227, 169, 16, 184, 60, 176,
+        225, 146, 137, 162, 64, 222, 240, 190, 129, 70, 34, 134, 256, 117, 189, 246, 2, 23, 136, 22,
+        253, 211, 242, 213, 8, 92, 30, 88, 241, 73, 197, 81, 32, 111, 120, 95, 193, 35, 17, 67, 128,
+        187, 223, 123, 1, 140, 68, 11, 255, 234, 121, 235, 4, 46, 15, 44, 249, 165, 227, 169, 16,
+        184, 60, 176, 225, 146, 137, 162, 64, 222, 240, 190, 129, 70, 34, 134, 256, 117, 189, 246,
+        2, 23, 136, 22, 253, 211, 242, 213, 8, 92, 30, 88, 241, 73, 197, 81, 32, 111, 120, 95, 193,
+        35, 17, 67, 128, 187, 223, 123, 1, 140, 68, 11, 255, 234, 121, 235, 4, 46, 15, 44, 249, 165,
+        227, 169, 16, 184, 60, 176, 225, 146, 137, 162, 64, 222, 240, 190, 129, 70, 34, 134, 256,
+        117, 189, 246, 2, 23, 136, 22, 253, 211, 242, 213, 8, 92, 30, 88, 241, 73, 197, 81, 32, 111,
+        120, 95, 193, 35, 17, 67, 128, 187, 223, 123, 1, 140, 68, 11, 255, 234, 121, 235, 4, 46, 15,
+        44, 249, 165, 227, 169, 16, 184, 60, 176, 225, 146, 137, 162, 64, 222, 240, 190, 129, 70,
+        34, 134, 256, 117, 189, 246, 2, 23, 136, 22, 253, 211, 242, 213, 8, 92, 30, 88, 241, 73,
+        197, 81, 32, 111, 120, 95, 193, 35, 17, 67, 128, 187, 223, 123, 1,
+    ],
+    [
+        1, 141, 92, 122, 240, 173, 235, 239, 32, 143, 117, 49, 227, 139, 67, 195, 253, 207, 146, 26,
+        68, 79, 88, 72, 129, 199, 46, 61, 120, 215, 246, 248, 16, 200, 187, 153, 242, 198, 162, 226,
+        255, 232, 73, 13, 34, 168, 44, 36, 193, 228, 23, 159, 60, 236, 123, 124, 8, 100, 222, 205,
+        121, 99, 81, 113, 256, 116, 165, 135, 17, 84, 22, 18, 225, 114, 140, 208, 30, 118, 190, 62,
+        4, 50, 111, 231, 189, 178, 169, 185, 128, 58, 211, 196, 137, 42, 11, 9, 241, 57, 70, 104,
+        15, 59, 95, 31, 2, 25, 184, 244, 223, 89, 213, 221, 64, 29, 234, 98, 197, 21, 134, 133, 249,
+        157, 35, 52, 136, 158, 176, 144, 1, 141, 92, 122, 240, 173, 235, 239, 32, 143, 117, 49, 227,
+        139, 67, 195, 253, 207, 146, 26, 68, 79, 88, 72, 129, 199, 46, 61, 120, 215, 246, 248, 16,
+        200, 187, 153, 242, 198, 162, 226, 255, 232, 73, 13, 34, 168, 44, 36, 193, 228, 23, 159, 60,
+        236, 123, 124, 8, 100, 222, 205, 121, 99, 81, 113, 256, 116, 165, 135, 17, 84, 22, 18, 225,
+        114, 140, 208, 30, 118, 190, 62, 4, 50, 111, 231, 189, 178, 169, 185, 128, 58, 211, 196,
+        137, 42, 11, 9, 241, 57, 70, 104, 15, 59, 95, 31, 2, 25, 184, 244, 223, 89, 213, 221, 64,
+        29, 234, 98, 197, 21, 134, 133, 249, 157, 35, 52, 136, 158, 176, 144, 1,
+    ],
+    [
+        1, 142, 118, 51, 46, 107, 31, 33, 60, 39, 141, 233, 190, 252, 61, 181, 2, 27, 236, 102, 92,
+        214, 62, 66, 120, 78, 25, 209, 123, 247, 122, 105, 4, 54, 215, 204, 184, 171, 124, 132, 240,
+        156, 50, 161, 246, 237, 244, 210, 8, 108, 173, 151, 111, 85, 248, 7, 223, 55, 100, 65, 235,
+        217, 231, 163, 16, 216, 89, 45, 222, 170, 239, 14, 189, 110, 200, 130, 213, 177, 205, 69,
+        32, 175, 178, 90, 187, 83, 221, 28, 121, 220, 143, 3, 169, 97, 153, 138, 64, 93, 99, 180,
+        117, 166, 185, 56, 242, 183, 29, 6, 81, 194, 49, 19, 128, 186, 198, 103, 234, 75, 113, 112,
+        227, 109, 58, 12, 162, 131, 98, 38, 256, 115, 139, 206, 211, 150, 226, 224, 197, 218, 116,
+        24, 67, 5, 196, 76, 255, 230, 21, 155, 165, 43, 195, 191, 137, 179, 232, 48, 134, 10, 135,
+        152, 253, 203, 42, 53, 73, 86, 133, 125, 17, 101, 207, 96, 11, 20, 13, 47, 249, 149, 84,
+        106, 146, 172, 9, 250, 34, 202, 157, 192, 22, 40, 26, 94, 241, 41, 168, 212, 35, 87, 18,
+        243, 68, 147, 57, 127, 44, 80, 52, 188, 225, 82, 79, 167, 70, 174, 36, 229, 136, 37, 114,
+        254, 88, 160, 104, 119, 193, 164, 158, 77, 140, 91, 72, 201, 15, 74, 228, 251, 176, 63, 208,
+        238, 129, 71, 59, 154, 23, 182, 144, 145, 30, 148, 199, 245, 95, 126, 159, 219, 1,
+    ],
+    [
+        1, 143, 146, 61, 242, 168, 123, 113, 225, 50, 211, 104, 223, 21, 176, 239, 253, 199, 187,
+        13, 60, 99, 22, 62, 128, 57, 184, 98, 136, 173, 67, 72, 16, 232, 23, 205, 17, 118, 169, 9,
+        2, 29, 35, 122, 227, 79, 246, 226, 193, 100, 165, 208, 189, 42, 95, 221, 249, 141, 117, 26,
+        120, 198, 44, 124, 256, 114, 111, 196, 15, 89, 134, 144, 32, 207, 46, 153, 34, 236, 81, 18,
+        4, 58, 70, 244, 197, 158, 235, 195, 129, 200, 73, 159, 121, 84, 190, 185, 241, 25, 234, 52,
+        240, 139, 88, 248, 255, 228, 222, 135, 30, 178, 11, 31, 64, 157, 92, 49, 68, 215, 162, 36,
+        8, 116, 140, 231, 137, 59, 213, 133, 1, 143, 146, 61, 242, 168, 123, 113, 225, 50, 211, 104,
+        223, 21, 176, 239, 253, 199, 187, 13, 60, 99, 22, 62, 128, 57, 184, 98, 136, 173, 67, 72,
+        16, 232, 23, 205, 17, 118, 169, 9, 2, 29, 35, 122, 227, 79, 246, 226, 193, 100, 165, 208,
+        189, 42, 95, 221, 249, 141, 117, 26, 120, 198, 44, 124, 256, 114, 111, 196, 15, 89, 134,
+        144, 32, 207, 46, 153, 34, 236, 81, 18, 4, 58, 70, 244, 197, 158, 235, 195, 129, 200, 73,
+        159, 121, 84, 190, 185, 241, 25, 234, 52, 240, 139, 88, 248, 255, 228, 222, 135, 30, 178,
+        11, 31, 64, 157, 92, 49, 68, 215, 162, 36, 8, 116, 140, 231, 137, 59, 213, 133, 1,
+    ],
+    [
+        1, 144, 176, 158, 136, 52, 35, 157, 249, 133, 134, 21, 197, 98, 234, 29, 64, 221, 213, 89,
+        223, 244, 184, 25, 2, 31, 95, 59, 15, 104, 70, 57, 241, 9, 11, 42, 137, 196, 211, 58, 128,
+        185, 169, 178, 189, 231, 111, 50, 4, 62, 190, 118, 30, 208, 140, 114, 225, 18, 22, 84, 17,
+        135, 165, 116, 256, 113, 81, 99, 121, 205, 222, 100, 8, 124, 123, 236, 60, 159, 23, 228,
+        193, 36, 44, 168, 34, 13, 73, 232, 255, 226, 162, 198, 242, 153, 187, 200, 16, 248, 246,
+        215, 120, 61, 46, 199, 129, 72, 88, 79, 68, 26, 146, 207, 253, 195, 67, 139, 227, 49, 117,
+        143, 32, 239, 235, 173, 240, 122, 92, 141, 1, 144, 176, 158, 136, 52, 35, 157, 249, 133,
+        134, 21, 197, 98, 234, 29, 64, 221, 213, 89, 223, 244, 184, 25, 2, 31, 95, 59, 15, 104, 70,
+        57, 241, 9, 11, 42, 137, 196, 211, 58, 128, 185, 169, 178, 189, 231, 111, 50, 4, 62, 190,
+        118, 30, 208, 140, 114, 225, 18, 22, 84, 17, 135, 165, 116, 256, 113, 81, 99, 121, 205, 222,
+        100, 8, 124, 123, 236, 60, 159, 23, 228, 193, 36, 44, 168, 34, 13, 73, 232, 255, 226, 162,
+        198, 242, 153, 187, 200, 16, 248, 246, 215, 120, 61, 46, 199, 129, 72, 88, 79, 68, 26, 146,
+        207, 253, 195, 67, 139, 227, 49, 117, 143, 32, 239, 235, 173, 240, 122, 92, 141, 1,
+    ],
+    [
+        1, 145, 208, 91, 88, 167, 57, 41, 34, 47, 133, 10, 165, 24, 139, 109, 128, 56, 153, 83, 213,
+        45, 100, 108, 240, 105, 62, 252, 46, 245, 59, 74, 193, 229, 52, 87, 22, 106, 207, 203, 137,
+        76, 226, 131, 234, 6, 99, 220, 32, 14, 231, 85, 246, 204, 25, 27, 60, 219, 144, 63, 140,
+        254, 79, 147, 241, 250, 13, 86, 134, 155, 116, 115, 227, 19, 185, 97, 187, 130, 89, 55, 8,
+        132, 122, 214, 190, 51, 199, 71, 15, 119, 36, 80, 35, 192, 84, 101, 253, 191, 196, 150, 162,
+        103, 29, 93, 121, 69, 239, 217, 111, 161, 215, 78, 2, 33, 159, 182, 176, 77, 114, 82, 68,
+        94, 9, 20, 73, 48, 21, 218, 256, 112, 49, 166, 169, 90, 200, 216, 223, 210, 124, 247, 92,
+        233, 118, 148, 129, 201, 104, 174, 44, 212, 157, 149, 17, 152, 195, 5, 211, 12, 198, 183,
+        64, 28, 205, 170, 235, 151, 50, 54, 120, 181, 31, 126, 23, 251, 158, 37, 225, 243, 26, 172,
+        11, 53, 232, 230, 197, 38, 113, 194, 117, 3, 178, 110, 16, 7, 244, 171, 123, 102, 141, 142,
+        30, 238, 72, 160, 70, 127, 168, 202, 249, 125, 135, 43, 67, 206, 58, 186, 242, 138, 221,
+        177, 222, 65, 173, 156, 4, 66, 61, 107, 95, 154, 228, 164, 136, 188, 18, 40, 146, 96, 42,
+        179, 255, 224, 98, 75, 81, 180, 143, 175, 189, 163, 248, 237, 184, 209, 236, 39, 1,
+    ],
+    [
+        1, 146, 242, 123, 225, 211, 223, 176, 253, 187, 60, 22, 128, 184, 136, 67, 16, 23, 17, 169,
+        2, 35, 227, 246, 193, 165, 189, 95, 249, 117, 120, 44, 256, 111, 15, 134, 32, 46, 34, 81, 4,
+        70, 197, 235, 129, 73, 121, 190, 241, 234, 240, 88, 255, 222, 30, 11, 64, 92, 68, 162, 8,
+        140, 137, 213, 1, 146, 242, 123, 225, 211, 223, 176, 253, 187, 60, 22, 128, 184, 136, 67,
+        16, 23, 17, 169, 2, 35, 227, 246, 193, 165, 189, 95, 249, 117, 120, 44, 256, 111, 15, 134,
+        32, 46, 34, 81, 4, 70, 197, 235, 129, 73, 121, 190, 241, 234, 240, 88, 255, 222, 30, 11, 64,
+        92, 68, 162, 8, 140, 137, 213, 1, 146, 242, 123, 225, 211, 223, 176, 253, 187, 60, 22, 128,
+        184, 136, 67, 16, 23, 17, 169, 2, 35, 227, 246, 193, 165, 189, 95, 249, 117, 120, 44, 256,
+        111, 15, 134, 32, 46, 34, 81, 4, 70, 197, 235, 129, 73, 121, 190, 241, 234, 240, 88, 255,
+        222, 30, 11, 64, 92, 68, 162, 8, 140, 137, 213, 1, 146, 242, 123, 225, 211, 223, 176, 253,
+        187, 60, 22, 128, 184, 136, 67, 16, 23, 17, 169, 2, 35, 227, 246, 193, 165, 189, 95, 249,
+        117, 120, 44, 256, 111, 15, 134, 32, 46, 34, 81, 4, 70, 197, 235, 129, 73, 121, 190, 241,
+        234, 240, 88, 255, 222, 30, 11, 64, 92, 68, 162, 8, 140, 137, 213, 1,
+    ],
+    [
+        1, 147, 21, 3, 184, 63, 9, 38, 189, 27, 114, 53, 81, 85, 159, 243, 255, 220, 215, 251, 146,
+        131, 239, 181, 136, 203, 29, 151, 95, 87, 196, 28, 4, 74, 84, 12, 222, 252, 36, 152, 242,
+        108, 199, 212, 67, 83, 122, 201, 249, 109, 89, 233, 70, 10, 185, 210, 30, 41, 116, 90, 123,
+        91, 13, 112, 16, 39, 79, 48, 117, 237, 144, 94, 197, 175, 25, 77, 11, 75, 231, 33, 225, 179,
+        99, 161, 23, 40, 226, 69, 120, 164, 207, 103, 235, 107, 52, 191, 64, 156, 59, 192, 211, 177,
+        62, 119, 17, 186, 100, 51, 44, 43, 153, 132, 129, 202, 139, 130, 92, 160, 133, 19, 223, 142,
+        57, 155, 169, 171, 208, 250, 256, 110, 236, 254, 73, 194, 248, 219, 68, 230, 143, 204, 176,
+        172, 98, 14, 2, 37, 42, 6, 111, 126, 18, 76, 121, 54, 228, 106, 162, 170, 61, 229, 253, 183,
+        173, 245, 35, 5, 221, 105, 15, 149, 58, 45, 190, 174, 135, 56, 8, 148, 168, 24, 187, 247,
+        72, 47, 227, 216, 141, 167, 134, 166, 244, 145, 241, 218, 178, 209, 140, 20, 113, 163, 60,
+        82, 232, 180, 246, 182, 26, 224, 32, 78, 158, 96, 234, 217, 31, 188, 137, 93, 50, 154, 22,
+        150, 205, 66, 193, 101, 198, 65, 46, 80, 195, 138, 240, 71, 157, 206, 213, 214, 104, 125,
+        128, 55, 118, 127, 165, 97, 124, 238, 34, 115, 200, 102, 88, 86, 49, 7, 1,
+    ],
+    [
+        1, 148, 59, 251, 140, 160, 36, 188, 68, 41, 157, 106, 11, 86, 135, 191, 255, 218, 139, 12,
+        234, 194, 185, 138, 121, 175, 200, 45, 235, 85, 244, 132, 4, 78, 236, 233, 46, 126, 144,
+        238, 15, 164, 114, 167, 44, 87, 26, 250, 249, 101, 42, 48, 165, 5, 226, 38, 227, 186, 29,
+        180, 169, 83, 205, 14, 16, 55, 173, 161, 184, 247, 62, 181, 60, 142, 199, 154, 176, 91, 104,
+        229, 225, 147, 168, 192, 146, 20, 133, 152, 137, 230, 116, 206, 162, 75, 49, 56, 64, 220,
+        178, 130, 222, 217, 248, 210, 240, 54, 25, 102, 190, 107, 159, 145, 129, 74, 158, 254, 70,
+        80, 18, 94, 34, 149, 207, 53, 134, 43, 196, 224, 256, 109, 198, 6, 117, 97, 221, 69, 189,
+        216, 100, 151, 246, 171, 122, 66, 2, 39, 118, 245, 23, 63, 72, 119, 136, 82, 57, 212, 22,
+        172, 13, 125, 253, 179, 21, 24, 211, 131, 113, 19, 242, 93, 143, 90, 213, 170, 231, 7, 8,
+        156, 215, 209, 92, 252, 31, 219, 30, 71, 228, 77, 88, 174, 52, 243, 241, 202, 84, 96, 73,
+        10, 195, 76, 197, 115, 58, 103, 81, 166, 153, 28, 32, 110, 89, 65, 111, 237, 124, 105, 120,
+        27, 141, 51, 95, 182, 208, 201, 193, 37, 79, 127, 35, 40, 9, 47, 17, 203, 232, 155, 67, 150,
+        98, 112, 128, 183, 99, 3, 187, 177, 239, 163, 223, 108, 50, 204, 123, 214, 61, 33, 1,
+    ],
+    [
+        1, 149, 99, 102, 35, 75, 124, 229, 197, 55, 228, 48, 213, 126, 13, 138, 2, 41, 198, 204, 70,
+        150, 248, 201, 137, 110, 199, 96, 169, 252, 26, 19, 4, 82, 139, 151, 140, 43, 239, 145, 17,
+        220, 141, 192, 81, 247, 52, 38, 8, 164, 21, 45, 23, 86, 221, 33, 34, 183, 25, 127, 162, 237,
+        104, 76, 16, 71, 42, 90, 46, 172, 185, 66, 68, 109, 50, 254, 67, 217, 208, 152, 32, 142, 84,
+        180, 92, 87, 113, 132, 136, 218, 100, 251, 134, 177, 159, 47, 64, 27, 168, 103, 184, 174,
+        226, 7, 15, 179, 200, 245, 11, 97, 61, 94, 128, 54, 79, 206, 111, 91, 195, 14, 30, 101, 143,
+        233, 22, 194, 122, 188, 256, 108, 158, 155, 222, 182, 133, 28, 60, 202, 29, 209, 44, 131,
+        244, 119, 255, 216, 59, 53, 187, 107, 9, 56, 120, 147, 58, 161, 88, 5, 231, 238, 253, 175,
+        118, 106, 117, 214, 18, 112, 240, 37, 116, 65, 176, 10, 205, 219, 249, 93, 236, 212, 234,
+        171, 36, 224, 223, 74, 232, 130, 95, 20, 153, 181, 241, 186, 215, 167, 211, 85, 72, 191,
+        189, 148, 207, 3, 190, 40, 49, 105, 225, 115, 173, 77, 165, 170, 144, 125, 121, 39, 157, 6,
+        123, 80, 98, 210, 193, 230, 89, 154, 73, 83, 31, 250, 242, 78, 57, 12, 246, 160, 196, 163,
+        129, 203, 178, 51, 146, 166, 62, 243, 227, 156, 114, 24, 235, 63, 135, 69, 1,
+    ],
+    [
+        1, 150, 141, 76, 92, 179, 122, 53, 240, 20, 173, 250, 235, 41, 239, 127, 32, 174, 143, 119,
+        117, 74, 49, 154, 227, 126, 139, 33, 67, 27, 195, 209, 253, 171, 207, 210, 146, 55, 26, 45,
+        68, 177, 79, 28, 88, 93, 72, 6, 129, 75, 199, 38, 46, 218, 61, 155, 120, 10, 215, 125, 246,
+        149, 248, 192, 16, 87, 200, 188, 187, 37, 153, 77, 242, 63, 198, 145, 162, 142, 226, 233,
+        255, 214, 232, 105, 73, 156, 13, 151, 34, 217, 168, 14, 44, 175, 36, 3, 193, 166, 228, 19,
+        23, 109, 159, 206, 60, 5, 236, 191, 123, 203, 124, 96, 8, 172, 100, 94, 222, 147, 205, 167,
+        121, 160, 99, 201, 81, 71, 113, 245, 256, 107, 116, 181, 165, 78, 135, 204, 17, 237, 84, 7,
+        22, 216, 18, 130, 225, 83, 114, 138, 140, 183, 208, 103, 30, 131, 118, 224, 190, 230, 62,
+        48, 4, 86, 50, 47, 111, 202, 231, 212, 189, 80, 178, 229, 169, 164, 185, 251, 128, 182, 58,
+        219, 211, 39, 196, 102, 137, 247, 42, 132, 11, 108, 9, 65, 241, 170, 57, 69, 70, 220, 104,
+        180, 15, 194, 59, 112, 95, 115, 31, 24, 2, 43, 25, 152, 184, 101, 244, 106, 223, 40, 89,
+        243, 213, 82, 221, 254, 64, 91, 29, 238, 234, 148, 98, 51, 197, 252, 21, 66, 134, 54, 133,
+        161, 249, 85, 157, 163, 35, 110, 52, 90, 136, 97, 158, 56, 176, 186, 144, 12, 1,
+    ],
+    [
+        1, 151, 185, 179, 44, 219, 173, 166, 137, 127, 159, 108, 117, 191, 57, 126, 8, 180, 195,
+        147, 95, 210, 99, 43, 68, 245, 244, 93, 165, 243, 199, 237, 64, 155, 18, 148, 246, 138, 21,
+        87, 30, 161, 153, 230, 35, 145, 50, 97, 255, 212, 144, 156, 169, 76, 168, 182, 240, 3, 196,
+        41, 23, 132, 143, 5, 241, 154, 124, 220, 67, 94, 59, 171, 121, 24, 26, 71, 184, 28, 116, 40,
+        129, 204, 221, 218, 22, 238, 215, 83, 197, 192, 208, 54, 187, 224, 157, 63, 4, 90, 226, 202,
+        176, 105, 178, 150, 34, 251, 122, 175, 211, 250, 228, 247, 32, 206, 9, 74, 123, 69, 139,
+        172, 15, 209, 205, 115, 146, 201, 25, 177, 256, 106, 72, 78, 213, 38, 84, 91, 120, 130, 98,
+        149, 140, 66, 200, 131, 249, 77, 62, 110, 162, 47, 158, 214, 189, 12, 13, 164, 92, 14, 58,
+        20, 193, 102, 239, 109, 11, 119, 236, 170, 227, 96, 104, 27, 222, 112, 207, 160, 2, 45, 113,
+        101, 88, 181, 89, 75, 17, 254, 61, 216, 234, 125, 114, 252, 16, 103, 133, 37, 190, 163, 198,
+        86, 136, 233, 231, 186, 73, 229, 141, 217, 128, 53, 36, 39, 235, 19, 42, 174, 60, 65, 49,
+        203, 70, 33, 100, 194, 253, 167, 31, 55, 81, 152, 79, 107, 223, 6, 135, 82, 46, 7, 29, 10,
+        225, 51, 248, 183, 134, 188, 118, 85, 242, 48, 52, 142, 111, 56, 232, 80, 1,
+    ],
+    [
+        1, 152, 231, 160, 162, 209, 157, 220, 30, 191, 248, 174, 234, 102, 84, 175, 129, 76, 244,
+        80, 81, 233, 207, 110, 15, 224, 124, 87, 117, 51, 42, 216, 193, 38, 122, 40, 169, 245, 232,
+        55, 136, 112, 62, 172, 187, 154, 21, 108, 225, 19, 61, 20, 213, 251, 116, 156, 68, 56, 31,
+        86, 222, 77, 139, 54, 241, 138, 159, 10, 235, 254, 58, 78, 34, 28, 144, 43, 111, 167, 198,
+        27, 249, 69, 208, 5, 246, 127, 29, 39, 17, 14, 72, 150, 184, 212, 99, 142, 253, 163, 104,
+        131, 123, 192, 143, 148, 137, 7, 36, 75, 92, 106, 178, 71, 255, 210, 52, 194, 190, 96, 200,
+        74, 197, 132, 18, 166, 46, 53, 89, 164, 256, 105, 26, 97, 95, 48, 100, 37, 227, 66, 9, 83,
+        23, 155, 173, 82, 128, 181, 13, 177, 176, 24, 50, 147, 242, 33, 133, 170, 140, 206, 215, 41,
+        64, 219, 135, 217, 88, 12, 25, 202, 121, 145, 195, 85, 70, 103, 236, 149, 32, 238, 196, 237,
+        44, 6, 141, 101, 189, 201, 226, 171, 35, 180, 118, 203, 16, 119, 98, 247, 22, 3, 199, 179,
+        223, 229, 113, 214, 146, 90, 59, 230, 8, 188, 49, 252, 11, 130, 228, 218, 240, 243, 185,
+        107, 73, 45, 158, 115, 4, 94, 153, 126, 134, 65, 114, 109, 120, 250, 221, 182, 165, 151, 79,
+        186, 2, 47, 205, 63, 67, 161, 57, 183, 60, 125, 239, 91, 211, 204, 168, 93, 1,
+    ],
+    [
+        1, 153, 22, 25, 227, 36, 111, 21, 129, 205, 11, 141, 242, 18, 184, 139, 193, 231, 134, 199,
+        121, 9, 92, 198, 225, 244, 67, 228, 189, 133, 46, 99, 241, 122, 162, 114, 223, 195, 23, 178,
+        249, 61, 81, 57, 240, 226, 140, 89, 253, 159, 169, 157, 120, 113, 70, 173, 255, 208, 213,
+        207, 60, 185, 35, 215, 256, 104, 235, 232, 30, 221, 146, 236, 128, 52, 246, 116, 15, 239,
+        73, 118, 64, 26, 123, 58, 136, 248, 165, 59, 32, 13, 190, 29, 68, 124, 211, 158, 16, 135,
+        95, 143, 34, 62, 234, 79, 8, 196, 176, 200, 17, 31, 117, 168, 4, 98, 88, 100, 137, 144, 187,
+        84, 2, 49, 44, 50, 197, 72, 222, 42, 1, 153, 22, 25, 227, 36, 111, 21, 129, 205, 11, 141,
+        242, 18, 184, 139, 193, 231, 134, 199, 121, 9, 92, 198, 225, 244, 67, 228, 189, 133, 46, 99,
+        241, 122, 162, 114, 223, 195, 23, 178, 249, 61, 81, 57, 240, 226, 140, 89, 253, 159, 169,
+        157, 120, 113, 70, 173, 255, 208, 213, 207, 60, 185, 35, 215, 256, 104, 235, 232, 30, 221,
+        146, 236, 128, 52, 246, 116, 15, 239, 73, 118, 64, 26, 123, 58, 136, 248, 165, 59, 32, 13,
+        190, 29, 68, 124, 211, 158, 16, 135, 95, 143, 34, 62, 234, 79, 8, 196, 176, 200, 17, 31,
+        117, 168, 4, 98, 88, 100, 137, 144, 187, 84, 2, 49, 44, 50, 197, 72, 222, 42, 1,
+    ],
+    [
+        1, 154, 72, 37, 44, 94, 84, 86, 137, 24, 98, 186, 117, 28, 200, 217, 8, 204, 62, 39, 95,
+        238, 158, 174, 68, 192, 13, 203, 165, 224, 58, 194, 64, 90, 239, 55, 246, 105, 236, 107, 30,
+        251, 104, 82, 35, 250, 207, 10, 255, 206, 113, 183, 169, 69, 89, 85, 240, 209, 61, 142, 23,
+        201, 114, 80, 241, 106, 133, 179, 67, 38, 198, 166, 121, 130, 231, 108, 184, 66, 141, 126,
+        129, 77, 36, 147, 22, 47, 42, 43, 197, 12, 49, 93, 187, 14, 100, 237, 4, 102, 31, 148, 176,
+        119, 79, 87, 34, 96, 135, 230, 211, 112, 29, 97, 32, 45, 248, 156, 123, 181, 118, 182, 15,
+        254, 52, 41, 146, 125, 232, 5, 256, 103, 185, 220, 213, 163, 173, 171, 120, 233, 159, 71,
+        140, 229, 57, 40, 249, 53, 195, 218, 162, 19, 99, 83, 189, 65, 244, 54, 92, 33, 199, 63,
+        193, 167, 18, 202, 11, 152, 21, 150, 227, 6, 153, 175, 222, 7, 50, 247, 2, 51, 144, 74, 88,
+        188, 168, 172, 17, 48, 196, 115, 234, 56, 143, 177, 16, 151, 124, 78, 190, 219, 59, 91, 136,
+        127, 26, 149, 73, 191, 116, 131, 128, 180, 221, 110, 235, 210, 215, 214, 60, 245, 208, 164,
+        70, 243, 157, 20, 253, 155, 226, 109, 81, 138, 178, 170, 223, 161, 122, 27, 46, 145, 228,
+        160, 225, 212, 9, 101, 134, 76, 139, 75, 242, 3, 205, 216, 111, 132, 25, 252, 1,
+    ],
+    [
+        1, 155, 124, 202, 213, 119, 198, 107, 137, 161, 26, 175, 140, 112, 141, 10, 8, 212, 221, 74,
+        162, 181, 42, 85, 68, 3, 208, 115, 92, 125, 100, 80, 64, 154, 226, 78, 11, 163, 79, 166, 30,
+        24, 122, 149, 222, 229, 29, 126, 255, 204, 9, 110, 88, 19, 118, 43, 240, 192, 205, 164, 234,
+        33, 232, 237, 241, 90, 72, 109, 190, 152, 173, 87, 121, 251, 98, 27, 73, 7, 57, 97, 129,
+        206, 62, 101, 235, 188, 99, 182, 197, 209, 13, 216, 70, 56, 199, 5, 4, 106, 239, 37, 81,
+        219, 21, 171, 34, 130, 104, 186, 46, 191, 50, 40, 32, 77, 113, 39, 134, 210, 168, 83, 15,
+        12, 61, 203, 111, 243, 143, 63, 256, 102, 133, 55, 44, 138, 59, 150, 120, 96, 231, 82, 117,
+        145, 116, 247, 249, 45, 36, 183, 95, 76, 215, 172, 189, 254, 49, 142, 165, 132, 157, 177,
+        193, 103, 31, 179, 246, 94, 178, 91, 227, 233, 135, 108, 35, 28, 228, 131, 2, 53, 248, 147,
+        169, 238, 139, 214, 17, 65, 52, 93, 23, 224, 25, 20, 16, 167, 185, 148, 67, 105, 84, 170,
+        136, 6, 159, 230, 184, 250, 200, 160, 128, 51, 195, 156, 22, 69, 158, 75, 60, 48, 244, 41,
+        187, 201, 58, 252, 253, 151, 18, 220, 176, 38, 236, 86, 223, 127, 153, 71, 211, 66, 207,
+        217, 225, 180, 144, 218, 123, 47, 89, 174, 242, 245, 196, 54, 146, 14, 114, 194, 1,
+    ],
+    [
+        1, 156, 178, 12, 73, 80, 144, 105, 189, 186, 232, 212, 176, 214, 231, 56, 255, 202, 158,
+        233, 111, 97, 226, 47, 136, 142, 50, 90, 162, 86, 52, 145, 4, 110, 198, 48, 35, 63, 62, 163,
+        242, 230, 157, 77, 190, 85, 153, 224, 249, 37, 118, 161, 187, 131, 133, 188, 30, 54, 200,
+        103, 134, 87, 208, 66, 16, 183, 21, 192, 140, 252, 248, 138, 197, 149, 114, 51, 246, 83, 98,
+        125, 225, 148, 215, 130, 234, 10, 18, 238, 120, 216, 29, 155, 22, 91, 61, 7, 64, 218, 84,
+        254, 46, 237, 221, 38, 17, 82, 199, 204, 213, 75, 135, 243, 129, 78, 89, 6, 165, 40, 72,
+        181, 223, 93, 116, 106, 88, 107, 244, 28, 256, 101, 79, 245, 184, 177, 113, 152, 68, 71, 25,
+        45, 81, 43, 26, 201, 2, 55, 99, 24, 146, 160, 31, 210, 121, 115, 207, 167, 95, 171, 205,
+        112, 253, 147, 59, 209, 222, 194, 195, 94, 15, 27, 100, 180, 67, 172, 104, 33, 8, 220, 139,
+        96, 70, 126, 124, 69, 227, 203, 57, 154, 123, 170, 49, 191, 241, 74, 236, 65, 117, 5, 9,
+        119, 60, 108, 143, 206, 11, 174, 159, 132, 32, 109, 42, 127, 23, 247, 239, 19, 137, 41, 228,
+        102, 235, 166, 196, 250, 193, 39, 173, 3, 211, 20, 36, 219, 240, 175, 58, 53, 44, 182, 122,
+        14, 128, 179, 168, 251, 92, 217, 185, 76, 34, 164, 141, 151, 169, 150, 13, 229, 1,
+    ],
+    [
+        1, 157, 234, 244, 15, 42, 169, 62, 225, 116, 222, 159, 34, 198, 246, 72, 253, 143, 92, 52,
+        197, 89, 95, 9, 128, 50, 140, 135, 121, 236, 44, 226, 16, 199, 146, 49, 240, 158, 134, 221,
+        2, 57, 211, 231, 30, 84, 81, 124, 193, 232, 187, 61, 68, 139, 235, 144, 249, 29, 184, 104,
+        137, 178, 190, 18, 256, 100, 23, 13, 242, 215, 88, 195, 32, 141, 35, 98, 223, 59, 11, 185,
+        4, 114, 165, 205, 60, 168, 162, 248, 129, 207, 117, 122, 136, 21, 213, 31, 241, 58, 111,
+        208, 17, 99, 123, 36, 255, 200, 46, 26, 227, 173, 176, 133, 64, 25, 70, 196, 189, 118, 22,
+        113, 8, 228, 73, 153, 120, 79, 67, 239, 1, 157, 234, 244, 15, 42, 169, 62, 225, 116, 222,
+        159, 34, 198, 246, 72, 253, 143, 92, 52, 197, 89, 95, 9, 128, 50, 140, 135, 121, 236, 44,
+        226, 16, 199, 146, 49, 240, 158, 134, 221, 2, 57, 211, 231, 30, 84, 81, 124, 193, 232, 187,
+        61, 68, 139, 235, 144, 249, 29, 184, 104, 137, 178, 190, 18, 256, 100, 23, 13, 242, 215, 88,
+        195, 32, 141, 35, 98, 223, 59, 11, 185, 4, 114, 165, 205, 60, 168, 162, 248, 129, 207, 117,
+        122, 136, 21, 213, 31, 241, 58, 111, 208, 17, 99, 123, 36, 255, 200, 46, 26, 227, 173, 176,
+        133, 64, 25, 70, 196, 189, 118, 22, 113, 8, 228, 73, 153, 120, 79, 67, 239, 1,
+    ],
+    [
+        1, 158, 35, 133, 197, 29, 213, 244, 2, 59, 70, 9, 137, 58, 169, 231, 4, 118, 140, 18, 17,
+        116, 81, 205, 8, 236, 23, 36, 34, 232, 162, 153, 16, 215, 46, 72, 68, 207, 67, 49, 32, 173,
+        92, 144, 136, 157, 134, 98, 64, 89, 184, 31, 15, 57, 11, 196, 128, 178, 111, 62, 30, 114,
+        22, 135, 256, 99, 222, 124, 60, 228, 44, 13, 255, 198, 187, 248, 120, 199, 88, 26, 253, 139,
+        117, 239, 240, 141, 176, 52, 249, 21, 234, 221, 223, 25, 95, 104, 241, 42, 211, 185, 189,
+        50, 190, 208, 225, 84, 165, 113, 121, 100, 123, 159, 193, 168, 73, 226, 242, 200, 246, 61,
+        129, 79, 146, 195, 227, 143, 235, 122, 1, 158, 35, 133, 197, 29, 213, 244, 2, 59, 70, 9,
+        137, 58, 169, 231, 4, 118, 140, 18, 17, 116, 81, 205, 8, 236, 23, 36, 34, 232, 162, 153, 16,
+        215, 46, 72, 68, 207, 67, 49, 32, 173, 92, 144, 136, 157, 134, 98, 64, 89, 184, 31, 15, 57,
+        11, 196, 128, 178, 111, 62, 30, 114, 22, 135, 256, 99, 222, 124, 60, 228, 44, 13, 255, 198,
+        187, 248, 120, 199, 88, 26, 253, 139, 117, 239, 240, 141, 176, 52, 249, 21, 234, 221, 223,
+        25, 95, 104, 241, 42, 211, 185, 189, 50, 190, 208, 225, 84, 165, 113, 121, 100, 123, 159,
+        193, 168, 73, 226, 242, 200, 246, 61, 129, 79, 146, 195, 227, 143, 235, 122, 1,
+    ],
+    [
+        1, 159, 95, 199, 30, 144, 23, 59, 129, 208, 176, 228, 15, 72, 140, 158, 193, 104, 88, 114,
+        136, 36, 70, 79, 225, 52, 44, 57, 68, 18, 35, 168, 241, 26, 22, 157, 34, 9, 146, 84, 249,
+        13, 11, 207, 17, 133, 73, 42, 253, 135, 134, 232, 137, 195, 165, 21, 255, 196, 67, 116, 197,
+        226, 211, 139, 256, 98, 162, 58, 227, 113, 234, 198, 128, 49, 81, 29, 242, 185, 117, 99, 64,
+        153, 169, 143, 121, 221, 187, 178, 32, 205, 213, 200, 189, 239, 222, 89, 16, 231, 235, 100,
+        223, 248, 111, 173, 8, 244, 246, 50, 240, 124, 184, 215, 4, 122, 123, 25, 120, 62, 92, 236,
+        2, 61, 190, 141, 60, 31, 46, 118, 1, 159, 95, 199, 30, 144, 23, 59, 129, 208, 176, 228, 15,
+        72, 140, 158, 193, 104, 88, 114, 136, 36, 70, 79, 225, 52, 44, 57, 68, 18, 35, 168, 241, 26,
+        22, 157, 34, 9, 146, 84, 249, 13, 11, 207, 17, 133, 73, 42, 253, 135, 134, 232, 137, 195,
+        165, 21, 255, 196, 67, 116, 197, 226, 211, 139, 256, 98, 162, 58, 227, 113, 234, 198, 128,
+        49, 81, 29, 242, 185, 117, 99, 64, 153, 169, 143, 121, 221, 187, 178, 32, 205, 213, 200,
+        189, 239, 222, 89, 16, 231, 235, 100, 223, 248, 111, 173, 8, 244, 246, 50, 240, 124, 184,
+        215, 4, 122, 123, 25, 120, 62, 92, 236, 2, 61, 190, 141, 60, 31, 46, 118, 1,
+    ],
+    [
+        1, 160, 157, 191, 234, 175, 244, 233, 15, 87, 42, 38, 169, 55, 62, 154, 225, 20, 116, 56,
+        222, 54, 159, 254, 34, 43, 198, 69, 246, 39, 72, 212, 253, 131, 143, 7, 92, 71, 52, 96, 197,
+        166, 89, 105, 95, 37, 9, 155, 128, 177, 50, 33, 140, 41, 135, 12, 121, 85, 236, 238, 44,
+        101, 226, 180, 16, 247, 199, 229, 146, 230, 49, 130, 240, 107, 158, 94, 134, 109, 221, 151,
+        2, 63, 57, 125, 211, 93, 231, 209, 30, 174, 84, 76, 81, 110, 124, 51, 193, 40, 232, 112,
+        187, 108, 61, 251, 68, 86, 139, 138, 235, 78, 144, 167, 249, 5, 29, 14, 184, 142, 104, 192,
+        137, 75, 178, 210, 190, 74, 18, 53, 256, 97, 100, 66, 23, 82, 13, 24, 242, 170, 215, 219,
+        88, 202, 195, 103, 32, 237, 141, 201, 35, 203, 98, 3, 223, 214, 59, 188, 11, 218, 185, 45,
+        4, 126, 114, 250, 165, 186, 205, 161, 60, 91, 168, 152, 162, 220, 248, 102, 129, 80, 207,
+        224, 117, 216, 122, 245, 136, 172, 21, 19, 213, 156, 31, 77, 241, 10, 58, 28, 111, 27, 208,
+        127, 17, 150, 99, 163, 123, 148, 36, 106, 255, 194, 200, 132, 46, 164, 26, 48, 227, 83, 173,
+        181, 176, 147, 133, 206, 64, 217, 25, 145, 70, 149, 196, 6, 189, 171, 118, 119, 22, 179,
+        113, 90, 8, 252, 228, 243, 73, 115, 153, 65, 120, 182, 79, 47, 67, 183, 239, 204, 1,
+    ],
+    [
+        1, 161, 221, 115, 11, 229, 118, 237, 121, 206, 13, 37, 46, 210, 143, 150, 249, 254, 31, 108,
+        169, 224, 84, 160, 60, 151, 153, 218, 146, 119, 141, 85, 64, 24, 9, 164, 190, 7, 99, 5, 34,
+        77, 61, 55, 117, 76, 157, 91, 2, 65, 185, 230, 22, 201, 236, 217, 242, 155, 26, 74, 92, 163,
+        29, 43, 241, 251, 62, 216, 81, 191, 168, 63, 120, 45, 49, 179, 35, 238, 25, 170, 128, 48,
+        18, 71, 123, 14, 198, 10, 68, 154, 122, 110, 234, 152, 57, 182, 4, 130, 113, 203, 44, 145,
+        215, 177, 227, 53, 52, 148, 184, 69, 58, 86, 225, 245, 124, 175, 162, 125, 79, 126, 240, 90,
+        98, 101, 70, 219, 50, 83, 256, 96, 36, 142, 246, 28, 139, 20, 136, 51, 244, 220, 211, 47,
+        114, 107, 8, 3, 226, 149, 88, 33, 173, 97, 197, 106, 104, 39, 111, 138, 116, 172, 193, 233,
+        248, 93, 67, 250, 158, 252, 223, 180, 196, 202, 140, 181, 100, 166, 255, 192, 72, 27, 235,
+        56, 21, 40, 15, 102, 231, 183, 165, 94, 228, 214, 16, 6, 195, 41, 176, 66, 89, 194, 137,
+        212, 208, 78, 222, 19, 232, 87, 129, 209, 239, 186, 134, 243, 59, 247, 189, 103, 135, 147,
+        23, 105, 200, 75, 253, 127, 144, 54, 213, 112, 42, 80, 30, 204, 205, 109, 73, 188, 199, 171,
+        32, 12, 133, 82, 95, 132, 178, 131, 17, 167, 159, 156, 187, 38, 207, 174, 1,
+    ],
+    [
+        1, 162, 30, 234, 129, 81, 15, 117, 193, 169, 136, 187, 225, 213, 68, 222, 241, 235, 34, 111,
+        249, 246, 17, 184, 253, 123, 137, 92, 255, 190, 197, 46, 256, 95, 227, 23, 128, 176, 242,
+        140, 64, 88, 121, 70, 32, 44, 189, 35, 16, 22, 223, 146, 8, 11, 240, 73, 4, 134, 120, 165,
+        2, 67, 60, 211, 1, 162, 30, 234, 129, 81, 15, 117, 193, 169, 136, 187, 225, 213, 68, 222,
+        241, 235, 34, 111, 249, 246, 17, 184, 253, 123, 137, 92, 255, 190, 197, 46, 256, 95, 227,
+        23, 128, 176, 242, 140, 64, 88, 121, 70, 32, 44, 189, 35, 16, 22, 223, 146, 8, 11, 240, 73,
+        4, 134, 120, 165, 2, 67, 60, 211, 1, 162, 30, 234, 129, 81, 15, 117, 193, 169, 136, 187,
+        225, 213, 68, 222, 241, 235, 34, 111, 249, 246, 17, 184, 253, 123, 137, 92, 255, 190, 197,
+        46, 256, 95, 227, 23, 128, 176, 242, 140, 64, 88, 121, 70, 32, 44, 189, 35, 16, 22, 223,
+        146, 8, 11, 240, 73, 4, 134, 120, 165, 2, 67, 60, 211, 1, 162, 30, 234, 129, 81, 15, 117,
+        193, 169, 136, 187, 225, 213, 68, 222, 241, 235, 34, 111, 249, 246, 17, 184, 253, 123, 137,
+        92, 255, 190, 197, 46, 256, 95, 227, 23, 128, 176, 242, 140, 64, 88, 121, 70, 32, 44, 189,
+        35, 16, 22, 223, 146, 8, 11, 240, 73, 4, 134, 120, 165, 2, 67, 60, 211, 1,
+    ],
+    [
+        1, 163, 98, 40, 95, 65, 58, 202, 30, 7, 113, 172, 23, 151, 198, 149, 129, 210, 49, 20, 176,
+        161, 29, 101, 15, 132, 185, 86, 140, 204, 99, 203, 193, 105, 153, 10, 88, 209, 143, 179,
+        136, 66, 221, 43, 70, 102, 178, 230, 225, 181, 205, 5, 44, 233, 200, 218, 68, 33, 239, 150,
+        35, 51, 89, 115, 241, 219, 231, 131, 22, 245, 100, 109, 34, 145, 248, 75, 146, 154, 173,
+        186, 249, 238, 244, 194, 11, 251, 50, 183, 17, 201, 124, 166, 73, 77, 215, 93, 253, 119,
+        122, 97, 134, 254, 25, 220, 137, 229, 62, 83, 165, 167, 236, 175, 255, 188, 61, 177, 67,
+        127, 141, 110, 197, 243, 31, 170, 211, 212, 118, 216, 256, 94, 159, 217, 162, 192, 199, 55,
+        227, 250, 144, 85, 234, 106, 59, 108, 128, 47, 208, 237, 81, 96, 228, 156, 242, 125, 72,
+        171, 117, 53, 158, 54, 64, 152, 104, 247, 169, 48, 114, 78, 121, 191, 36, 214, 187, 155, 79,
+        27, 32, 76, 52, 252, 213, 24, 57, 39, 189, 224, 18, 107, 222, 206, 168, 142, 16, 38, 26,
+        126, 235, 12, 157, 148, 223, 112, 9, 182, 111, 103, 84, 71, 8, 19, 13, 63, 246, 6, 207, 74,
+        240, 56, 133, 91, 184, 180, 42, 164, 4, 138, 135, 160, 123, 3, 232, 37, 120, 28, 195, 174,
+        92, 90, 21, 82, 2, 69, 196, 80, 190, 130, 116, 147, 60, 14, 226, 87, 46, 45, 139, 41, 1,
+    ],
+    [
+        1, 164, 168, 53, 211, 166, 239, 132, 60, 74, 57, 96, 67, 194, 205, 210, 2, 71, 79, 106, 165,
+        75, 221, 7, 120, 148, 114, 192, 134, 131, 153, 163, 4, 142, 158, 212, 73, 150, 185, 14, 240,
+        39, 228, 127, 11, 5, 49, 69, 8, 27, 59, 167, 146, 43, 113, 28, 223, 78, 199, 254, 22, 10,
+        98, 138, 16, 54, 118, 77, 35, 86, 226, 56, 189, 156, 141, 251, 44, 20, 196, 19, 32, 108,
+        236, 154, 70, 172, 195, 112, 121, 55, 25, 245, 88, 40, 135, 38, 64, 216, 215, 51, 140, 87,
+        133, 224, 242, 110, 50, 233, 176, 80, 13, 76, 128, 175, 173, 102, 23, 174, 9, 191, 227, 220,
+        100, 209, 95, 160, 26, 152, 256, 93, 89, 204, 46, 91, 18, 125, 197, 183, 200, 161, 190, 63,
+        52, 47, 255, 186, 178, 151, 92, 182, 36, 250, 137, 109, 143, 65, 123, 126, 104, 94, 253,
+        115, 99, 45, 184, 107, 72, 243, 17, 218, 29, 130, 246, 252, 208, 188, 249, 230, 198, 90,
+        111, 214, 144, 229, 34, 179, 58, 3, 235, 247, 159, 119, 241, 203, 139, 180, 222, 171, 31,
+        201, 68, 101, 116, 6, 213, 237, 61, 238, 225, 149, 21, 103, 187, 85, 62, 145, 136, 202, 232,
+        12, 169, 217, 122, 219, 193, 41, 42, 206, 117, 170, 124, 33, 15, 147, 207, 24, 81, 177, 244,
+        181, 129, 82, 84, 155, 234, 83, 248, 66, 30, 37, 157, 48, 162, 97, 231, 105, 1,
+    ],
+    [
+        1, 165, 240, 22, 32, 140, 227, 190, 253, 111, 68, 169, 129, 211, 120, 11, 16, 70, 242, 95,
+        255, 184, 34, 213, 193, 234, 60, 134, 8, 35, 121, 176, 256, 92, 17, 235, 225, 117, 30, 67,
+        4, 146, 189, 88, 128, 46, 137, 246, 241, 187, 15, 162, 2, 73, 223, 44, 64, 23, 197, 123,
+        249, 222, 136, 81, 1, 165, 240, 22, 32, 140, 227, 190, 253, 111, 68, 169, 129, 211, 120, 11,
+        16, 70, 242, 95, 255, 184, 34, 213, 193, 234, 60, 134, 8, 35, 121, 176, 256, 92, 17, 235,
+        225, 117, 30, 67, 4, 146, 189, 88, 128, 46, 137, 246, 241, 187, 15, 162, 2, 73, 223, 44, 64,
+        23, 197, 123, 249, 222, 136, 81, 1, 165, 240, 22, 32, 140, 227, 190, 253, 111, 68, 169, 129,
+        211, 120, 11, 16, 70, 242, 95, 255, 184, 34, 213, 193, 234, 60, 134, 8, 35, 121, 176, 256,
+        92, 17, 235, 225, 117, 30, 67, 4, 146, 189, 88, 128, 46, 137, 246, 241, 187, 15, 162, 2, 73,
+        223, 44, 64, 23, 197, 123, 249, 222, 136, 81, 1, 165, 240, 22, 32, 140, 227, 190, 253, 111,
+        68, 169, 129, 211, 120, 11, 16, 70, 242, 95, 255, 184, 34, 213, 193, 234, 60, 134, 8, 35,
+        121, 176, 256, 92, 17, 235, 225, 117, 30, 67, 4, 146, 189, 88, 128, 46, 137, 246, 241, 187,
+        15, 162, 2, 73, 223, 44, 64, 23, 197, 123, 249, 222, 136, 81, 1,
+    ],
+    [
+        1, 166, 57, 210, 165, 148, 153, 212, 240, 5, 59, 28, 22, 54, 226, 251, 32, 172, 25, 38, 140,
+        110, 13, 102, 227, 160, 89, 125, 190, 186, 36, 65, 253, 107, 29, 188, 111, 179, 159, 180,
+        68, 237, 21, 145, 169, 41, 124, 24, 129, 83, 157, 105, 211, 74, 205, 106, 120, 131, 158, 14,
+        11, 27, 113, 254, 16, 86, 141, 19, 70, 55, 135, 51, 242, 80, 173, 191, 95, 93, 18, 161, 255,
+        182, 143, 94, 184, 218, 208, 90, 34, 247, 139, 201, 213, 149, 62, 12, 193, 170, 207, 181,
+        234, 37, 231, 53, 60, 194, 79, 7, 134, 142, 185, 127, 8, 43, 199, 138, 35, 156, 196, 154,
+        121, 40, 215, 224, 176, 175, 9, 209, 256, 91, 200, 47, 92, 109, 104, 45, 17, 252, 198, 229,
+        235, 203, 31, 6, 225, 85, 232, 219, 117, 147, 244, 155, 30, 97, 168, 132, 67, 71, 221, 192,
+        4, 150, 228, 69, 146, 78, 98, 77, 189, 20, 236, 112, 88, 216, 133, 233, 128, 174, 100, 152,
+        46, 183, 52, 151, 137, 126, 99, 243, 246, 230, 144, 3, 241, 171, 116, 238, 187, 202, 122,
+        206, 15, 177, 84, 66, 162, 164, 239, 96, 2, 75, 114, 163, 73, 39, 49, 167, 223, 10, 118, 56,
+        44, 108, 195, 245, 64, 87, 50, 76, 23, 220, 26, 204, 197, 63, 178, 250, 123, 115, 72, 130,
+        249, 214, 58, 119, 222, 101, 61, 103, 136, 217, 42, 33, 81, 82, 248, 48, 1,
+    ],
+    [
+        1, 167, 133, 109, 213, 105, 59, 87, 137, 6, 231, 27, 140, 250, 116, 97, 8, 51, 36, 101, 162,
+        69, 215, 182, 68, 48, 49, 216, 92, 201, 157, 5, 64, 151, 31, 37, 11, 38, 178, 171, 30, 127,
+        135, 186, 222, 66, 228, 40, 255, 180, 248, 39, 88, 47, 139, 83, 240, 245, 52, 203, 234, 14,
+        25, 63, 241, 155, 185, 55, 190, 119, 84, 150, 121, 161, 159, 82, 73, 112, 200, 247, 129,
+        212, 195, 183, 235, 181, 158, 172, 197, 3, 244, 142, 70, 125, 58, 177, 4, 154, 18, 179, 81,
+        163, 236, 91, 34, 24, 153, 108, 46, 229, 207, 131, 32, 204, 144, 147, 134, 19, 89, 214, 15,
+        192, 196, 93, 111, 33, 114, 20, 256, 90, 124, 148, 44, 152, 198, 170, 120, 251, 26, 230,
+        117, 7, 141, 160, 249, 206, 221, 156, 95, 188, 42, 75, 189, 209, 208, 41, 165, 56, 100, 252,
+        193, 106, 226, 220, 246, 219, 79, 86, 227, 130, 122, 71, 35, 191, 29, 217, 2, 77, 9, 218,
+        169, 210, 118, 174, 17, 12, 205, 54, 23, 243, 232, 194, 16, 102, 72, 202, 67, 138, 173, 107,
+        136, 96, 98, 175, 184, 145, 57, 10, 128, 45, 62, 74, 22, 76, 99, 85, 60, 254, 13, 115, 187,
+        132, 199, 80, 253, 103, 239, 78, 176, 94, 21, 166, 223, 233, 104, 149, 211, 28, 50, 126,
+        225, 53, 113, 110, 123, 238, 168, 43, 242, 65, 61, 164, 146, 224, 143, 237, 1,
+    ],
+    [
+        1, 168, 211, 239, 60, 57, 67, 205, 2, 79, 165, 221, 120, 114, 134, 153, 4, 158, 73, 185,
+        240, 228, 11, 49, 8, 59, 146, 113, 223, 199, 22, 98, 16, 118, 35, 226, 189, 141, 44, 196,
+        32, 236, 70, 195, 121, 25, 88, 135, 64, 215, 140, 133, 242, 50, 176, 13, 128, 173, 23, 9,
+        227, 100, 95, 26, 256, 89, 46, 18, 197, 200, 190, 52, 255, 178, 92, 36, 137, 143, 123, 104,
+        253, 99, 184, 72, 17, 29, 246, 208, 249, 198, 111, 144, 34, 58, 235, 159, 241, 139, 222, 31,
+        68, 116, 213, 61, 225, 21, 187, 62, 136, 232, 169, 122, 193, 42, 117, 124, 15, 207, 81, 244,
+        129, 84, 234, 248, 30, 157, 162, 231, 1, 168, 211, 239, 60, 57, 67, 205, 2, 79, 165, 221,
+        120, 114, 134, 153, 4, 158, 73, 185, 240, 228, 11, 49, 8, 59, 146, 113, 223, 199, 22, 98,
+        16, 118, 35, 226, 189, 141, 44, 196, 32, 236, 70, 195, 121, 25, 88, 135, 64, 215, 140, 133,
+        242, 50, 176, 13, 128, 173, 23, 9, 227, 100, 95, 26, 256, 89, 46, 18, 197, 200, 190, 52,
+        255, 178, 92, 36, 137, 143, 123, 104, 253, 99, 184, 72, 17, 29, 246, 208, 249, 198, 111,
+        144, 34, 58, 235, 159, 241, 139, 222, 31, 68, 116, 213, 61, 225, 21, 187, 62, 136, 232, 169,
+        122, 193, 42, 117, 124, 15, 207, 81, 244, 129, 84, 234, 248, 30, 157, 162, 231, 1,
+    ],
+    [
+        1, 169, 34, 92, 128, 44, 240, 211, 193, 235, 137, 23, 32, 11, 60, 117, 241, 123, 227, 70, 8,
+        67, 15, 222, 253, 95, 121, 146, 2, 81, 68, 184, 256, 88, 223, 165, 129, 213, 17, 46, 64, 22,
+        120, 234, 225, 246, 197, 140, 16, 134, 30, 187, 249, 190, 242, 35, 4, 162, 136, 111, 255,
+        176, 189, 73, 1, 169, 34, 92, 128, 44, 240, 211, 193, 235, 137, 23, 32, 11, 60, 117, 241,
+        123, 227, 70, 8, 67, 15, 222, 253, 95, 121, 146, 2, 81, 68, 184, 256, 88, 223, 165, 129,
+        213, 17, 46, 64, 22, 120, 234, 225, 246, 197, 140, 16, 134, 30, 187, 249, 190, 242, 35, 4,
+        162, 136, 111, 255, 176, 189, 73, 1, 169, 34, 92, 128, 44, 240, 211, 193, 235, 137, 23, 32,
+        11, 60, 117, 241, 123, 227, 70, 8, 67, 15, 222, 253, 95, 121, 146, 2, 81, 68, 184, 256, 88,
+        223, 165, 129, 213, 17, 46, 64, 22, 120, 234, 225, 246, 197, 140, 16, 134, 30, 187, 249,
+        190, 242, 35, 4, 162, 136, 111, 255, 176, 189, 73, 1, 169, 34, 92, 128, 44, 240, 211, 193,
+        235, 137, 23, 32, 11, 60, 117, 241, 123, 227, 70, 8, 67, 15, 222, 253, 95, 121, 146, 2, 81,
+        68, 184, 256, 88, 223, 165, 129, 213, 17, 46, 64, 22, 120, 234, 225, 246, 197, 140, 16, 134,
+        30, 187, 249, 190, 242, 35, 4, 162, 136, 111, 255, 176, 189, 73, 1,
+    ],
+    [
+        1, 170, 116, 188, 92, 220, 135, 77, 240, 194, 84, 145, 235, 115, 18, 233, 32, 43, 114, 105,
+        117, 101, 208, 151, 227, 40, 118, 14, 67, 82, 62, 3, 253, 91, 50, 19, 146, 148, 231, 206,
+        68, 252, 178, 191, 88, 54, 185, 96, 129, 85, 58, 94, 46, 110, 196, 167, 120, 97, 42, 201,
+        246, 186, 9, 245, 16, 150, 57, 181, 187, 179, 104, 204, 242, 20, 59, 7, 162, 41, 31, 130,
+        255, 174, 25, 138, 73, 74, 244, 103, 34, 126, 89, 224, 44, 27, 221, 48, 193, 171, 29, 47,
+        23, 55, 98, 212, 60, 177, 21, 229, 123, 93, 133, 251, 8, 75, 157, 219, 222, 218, 52, 102,
+        121, 10, 158, 132, 81, 149, 144, 65, 256, 87, 141, 69, 165, 37, 122, 180, 17, 63, 173, 112,
+        22, 142, 239, 24, 225, 214, 143, 152, 140, 156, 49, 106, 30, 217, 139, 243, 190, 175, 195,
+        254, 4, 166, 207, 238, 111, 109, 26, 51, 189, 5, 79, 66, 169, 203, 72, 161, 128, 172, 199,
+        163, 211, 147, 61, 90, 137, 160, 215, 56, 11, 71, 248, 12, 241, 107, 200, 76, 70, 78, 153,
+        53, 15, 237, 198, 250, 95, 216, 226, 127, 2, 83, 232, 119, 184, 183, 13, 154, 223, 131, 168,
+        33, 213, 230, 36, 209, 64, 86, 228, 210, 234, 202, 159, 45, 197, 80, 236, 28, 134, 164, 124,
+        6, 249, 182, 100, 38, 35, 39, 205, 155, 136, 247, 99, 125, 176, 108, 113, 192, 1,
+    ],
+    [
+        1, 171, 200, 19, 165, 202, 104, 51, 240, 177, 198, 191, 22, 164, 31, 161, 32, 75, 232, 94,
+        140, 39, 244, 90, 227, 10, 168, 201, 190, 108, 221, 12, 253, 87, 228, 181, 111, 220, 98, 53,
+        68, 63, 236, 7, 169, 115, 133, 127, 129, 214, 100, 138, 211, 101, 52, 154, 120, 217, 99,
+        224, 11, 82, 144, 209, 16, 166, 116, 47, 70, 148, 122, 45, 242, 5, 84, 229, 95, 54, 239, 6,
+        255, 172, 114, 219, 184, 110, 49, 155, 34, 160, 118, 132, 213, 186, 195, 192, 193, 107, 50,
+        69, 234, 179, 26, 77, 60, 237, 178, 112, 134, 41, 72, 233, 8, 83, 58, 152, 35, 74, 61, 151,
+        121, 131, 42, 243, 176, 27, 248, 3, 256, 86, 57, 238, 92, 55, 153, 206, 17, 80, 59, 66, 235,
+        93, 226, 96, 225, 182, 25, 163, 117, 218, 13, 167, 30, 247, 89, 56, 67, 149, 36, 245, 4,
+        170, 29, 76, 146, 37, 159, 204, 189, 194, 21, 250, 88, 142, 124, 130, 128, 43, 157, 119, 46,
+        156, 205, 103, 137, 40, 158, 33, 246, 175, 113, 48, 241, 91, 141, 210, 187, 109, 135, 212,
+        15, 252, 173, 28, 162, 203, 18, 251, 2, 85, 143, 38, 73, 147, 208, 102, 223, 97, 139, 125,
+        44, 71, 62, 65, 64, 150, 207, 188, 23, 78, 231, 180, 197, 20, 79, 145, 123, 216, 185, 24,
+        249, 174, 199, 105, 222, 183, 196, 106, 136, 126, 215, 14, 81, 230, 9, 254, 1,
+    ],
+    [
+        1, 172, 29, 105, 70, 218, 231, 154, 17, 97, 236, 243, 162, 108, 72, 48, 32, 107, 157, 19,
+        184, 37, 196, 45, 30, 20, 99, 66, 44, 115, 248, 251, 253, 83, 141, 94, 234, 156, 104, 155,
+        189, 126, 84, 56, 123, 82, 226, 65, 129, 86, 143, 181, 35, 109, 244, 77, 137, 177, 118, 250,
+        81, 54, 36, 24, 16, 182, 207, 138, 92, 147, 98, 151, 15, 10, 178, 33, 22, 186, 124, 254,
+        255, 170, 199, 47, 117, 78, 52, 206, 223, 63, 42, 28, 190, 41, 113, 161, 193, 43, 200, 219,
+        146, 183, 122, 167, 197, 217, 59, 125, 169, 27, 18, 12, 8, 91, 232, 69, 46, 202, 49, 204,
+        136, 5, 89, 145, 11, 93, 62, 127, 256, 85, 228, 152, 187, 39, 26, 103, 240, 160, 21, 14, 95,
+        149, 185, 209, 225, 150, 100, 238, 73, 220, 61, 212, 227, 237, 158, 191, 213, 142, 9, 6, 4,
+        174, 116, 163, 23, 101, 153, 102, 68, 131, 173, 201, 134, 175, 31, 192, 128, 171, 114, 76,
+        222, 148, 13, 180, 120, 80, 139, 7, 176, 203, 221, 233, 241, 75, 50, 119, 165, 110, 159,
+        106, 242, 247, 79, 224, 235, 71, 133, 3, 2, 87, 58, 210, 140, 179, 205, 51, 34, 194, 215,
+        229, 67, 216, 144, 96, 64, 214, 57, 38, 111, 74, 135, 90, 60, 40, 198, 132, 88, 230, 239,
+        245, 249, 166, 25, 188, 211, 55, 208, 53, 121, 252, 168, 112, 246, 164, 195, 130, 1,
+    ],
+    [
+        1, 173, 117, 195, 68, 199, 246, 153, 255, 168, 23, 124, 121, 116, 22, 208, 4, 178, 211, 9,
+        15, 25, 213, 98, 249, 158, 92, 239, 227, 207, 88, 61, 16, 198, 73, 36, 60, 100, 81, 135,
+        225, 118, 111, 185, 137, 57, 95, 244, 64, 21, 35, 144, 240, 143, 67, 26, 129, 215, 187, 226,
+        34, 228, 123, 205, 256, 84, 140, 62, 189, 58, 11, 104, 2, 89, 234, 133, 136, 141, 235, 49,
+        253, 79, 46, 248, 242, 232, 44, 159, 8, 99, 165, 18, 30, 50, 169, 196, 241, 59, 184, 221,
+        197, 157, 176, 122, 32, 139, 146, 72, 120, 200, 162, 13, 193, 236, 222, 113, 17, 114, 190,
+        231, 128, 42, 70, 31, 223, 29, 134, 52, 1, 173, 117, 195, 68, 199, 246, 153, 255, 168, 23,
+        124, 121, 116, 22, 208, 4, 178, 211, 9, 15, 25, 213, 98, 249, 158, 92, 239, 227, 207, 88,
+        61, 16, 198, 73, 36, 60, 100, 81, 135, 225, 118, 111, 185, 137, 57, 95, 244, 64, 21, 35,
+        144, 240, 143, 67, 26, 129, 215, 187, 226, 34, 228, 123, 205, 256, 84, 140, 62, 189, 58, 11,
+        104, 2, 89, 234, 133, 136, 141, 235, 49, 253, 79, 46, 248, 242, 232, 44, 159, 8, 99, 165,
+        18, 30, 50, 169, 196, 241, 59, 184, 221, 197, 157, 176, 122, 32, 139, 146, 72, 120, 200,
+        162, 13, 193, 236, 222, 113, 17, 114, 190, 231, 128, 42, 70, 31, 223, 29, 134, 52, 1,
+    ],
+    [
+        1, 174, 207, 38, 187, 156, 159, 167, 17, 131, 178, 132, 95, 82, 133, 12, 32, 171, 199, 188,
+        73, 109, 205, 204, 30, 80, 42, 112, 213, 54, 144, 127, 253, 75, 200, 105, 23, 147, 135, 103,
+        189, 247, 59, 243, 134, 186, 239, 209, 129, 87, 232, 19, 222, 78, 208, 212, 137, 194, 89,
+        66, 176, 41, 195, 6, 16, 214, 228, 94, 165, 183, 231, 102, 15, 40, 21, 56, 235, 27, 72, 192,
+        255, 166, 100, 181, 140, 202, 196, 180, 223, 252, 158, 250, 67, 93, 248, 233, 193, 172, 116,
+        138, 111, 39, 104, 106, 197, 97, 173, 33, 88, 149, 226, 3, 8, 107, 114, 47, 211, 220, 244,
+        51, 136, 20, 139, 28, 246, 142, 36, 96, 256, 83, 50, 219, 70, 101, 98, 90, 240, 126, 79,
+        125, 162, 175, 124, 245, 225, 86, 58, 69, 184, 148, 52, 53, 227, 177, 215, 145, 44, 203,
+        113, 130, 4, 182, 57, 152, 234, 110, 122, 154, 68, 10, 198, 14, 123, 71, 18, 48, 128, 170,
+        25, 238, 35, 179, 49, 45, 120, 63, 168, 191, 81, 216, 62, 251, 241, 43, 29, 163, 92, 74, 26,
+        155, 242, 217, 236, 201, 22, 230, 185, 65, 2, 91, 157, 76, 117, 55, 61, 77, 34, 5, 99, 7,
+        190, 164, 9, 24, 64, 85, 141, 119, 146, 218, 153, 151, 60, 160, 84, 224, 169, 108, 31, 254,
+        249, 150, 143, 210, 46, 37, 13, 206, 121, 237, 118, 229, 11, 115, 221, 161, 1,
+    ],
+    [
+        1, 175, 42, 154, 222, 43, 72, 7, 197, 37, 50, 12, 44, 247, 49, 94, 2, 93, 84, 51, 187, 86,
+        144, 14, 137, 74, 100, 24, 88, 237, 98, 188, 4, 186, 168, 102, 117, 172, 31, 28, 17, 148,
+        200, 48, 176, 217, 196, 119, 8, 115, 79, 204, 234, 87, 62, 56, 34, 39, 143, 96, 95, 177,
+        135, 238, 16, 230, 158, 151, 211, 174, 124, 112, 68, 78, 29, 192, 190, 97, 13, 219, 32, 203,
+        59, 45, 165, 91, 248, 224, 136, 156, 58, 127, 123, 194, 26, 181, 64, 149, 118, 90, 73, 182,
+        239, 191, 15, 55, 116, 254, 246, 131, 52, 105, 128, 41, 236, 180, 146, 107, 221, 125, 30,
+        110, 232, 251, 235, 5, 104, 210, 256, 82, 215, 103, 35, 214, 185, 250, 60, 220, 207, 245,
+        213, 10, 208, 163, 255, 164, 173, 206, 70, 171, 113, 243, 120, 183, 157, 233, 169, 20, 159,
+        69, 253, 71, 89, 155, 140, 85, 226, 229, 240, 109, 57, 209, 81, 40, 61, 138, 249, 142, 178,
+        53, 23, 170, 195, 201, 223, 218, 114, 161, 162, 80, 122, 19, 241, 27, 99, 106, 46, 83, 133,
+        145, 189, 179, 228, 65, 67, 160, 244, 38, 225, 54, 198, 212, 92, 166, 9, 33, 121, 101, 199,
+        130, 134, 63, 231, 76, 193, 108, 139, 167, 184, 75, 18, 66, 242, 202, 141, 3, 11, 126, 205,
+        152, 129, 216, 21, 77, 111, 150, 36, 132, 227, 147, 25, 6, 22, 252, 153, 47, 1,
+    ],
+    [
+        1, 176, 136, 35, 249, 134, 197, 234, 64, 213, 223, 184, 2, 95, 15, 70, 241, 11, 137, 211,
+        128, 169, 189, 111, 4, 190, 30, 140, 225, 22, 17, 165, 256, 81, 121, 222, 8, 123, 60, 23,
+        193, 44, 34, 73, 255, 162, 242, 187, 16, 246, 120, 46, 129, 88, 68, 146, 253, 67, 227, 117,
+        32, 235, 240, 92, 1, 176, 136, 35, 249, 134, 197, 234, 64, 213, 223, 184, 2, 95, 15, 70,
+        241, 11, 137, 211, 128, 169, 189, 111, 4, 190, 30, 140, 225, 22, 17, 165, 256, 81, 121, 222,
+        8, 123, 60, 23, 193, 44, 34, 73, 255, 162, 242, 187, 16, 246, 120, 46, 129, 88, 68, 146,
+        253, 67, 227, 117, 32, 235, 240, 92, 1, 176, 136, 35, 249, 134, 197, 234, 64, 213, 223, 184,
+        2, 95, 15, 70, 241, 11, 137, 211, 128, 169, 189, 111, 4, 190, 30, 140, 225, 22, 17, 165,
+        256, 81, 121, 222, 8, 123, 60, 23, 193, 44, 34, 73, 255, 162, 242, 187, 16, 246, 120, 46,
+        129, 88, 68, 146, 253, 67, 227, 117, 32, 235, 240, 92, 1, 176, 136, 35, 249, 134, 197, 234,
+        64, 213, 223, 184, 2, 95, 15, 70, 241, 11, 137, 211, 128, 169, 189, 111, 4, 190, 30, 140,
+        225, 22, 17, 165, 256, 81, 121, 222, 8, 123, 60, 23, 193, 44, 34, 73, 255, 162, 242, 187,
+        16, 246, 120, 46, 129, 88, 68, 146, 253, 67, 227, 117, 32, 235, 240, 92, 1,
+    ],
+    [
+        1, 177, 232, 201, 111, 115, 52, 209, 242, 172, 118, 69, 134, 74, 248, 206, 225, 247, 29,
+        250, 46, 175, 135, 251, 223, 150, 79, 105, 81, 202, 31, 90, 253, 63, 100, 224, 70, 54, 49,
+        192, 60, 83, 42, 238, 235, 218, 36, 204, 128, 40, 141, 28, 73, 71, 231, 24, 136, 171, 198,
+        94, 190, 220, 133, 154, 16, 5, 114, 132, 234, 41, 61, 3, 17, 182, 89, 76, 88, 156, 113, 212,
+        2, 97, 207, 145, 222, 230, 104, 161, 227, 87, 236, 138, 11, 148, 239, 155, 193, 237, 58,
+        243, 92, 93, 13, 245, 189, 43, 158, 210, 162, 147, 62, 180, 249, 126, 200, 191, 140, 108,
+        98, 127, 120, 166, 84, 219, 213, 179, 72, 151, 256, 80, 25, 56, 146, 142, 205, 48, 15, 85,
+        139, 188, 123, 183, 9, 51, 32, 10, 228, 7, 211, 82, 122, 6, 34, 107, 178, 152, 176, 55, 226,
+        167, 4, 194, 157, 33, 187, 203, 208, 65, 197, 174, 215, 19, 22, 39, 221, 53, 129, 217, 116,
+        229, 184, 186, 26, 233, 121, 86, 59, 163, 67, 37, 124, 103, 241, 252, 143, 125, 23, 216,
+        196, 254, 240, 75, 168, 181, 169, 101, 144, 45, 255, 160, 50, 112, 35, 27, 153, 96, 30, 170,
+        21, 119, 246, 109, 18, 102, 64, 20, 199, 14, 165, 164, 244, 12, 68, 214, 99, 47, 95, 110,
+        195, 77, 8, 131, 57, 66, 117, 149, 159, 130, 137, 91, 173, 38, 44, 78, 185, 106, 1,
+    ],
+    [
+        1, 178, 73, 144, 189, 232, 176, 231, 255, 158, 111, 226, 136, 50, 162, 52, 4, 198, 35, 62,
+        242, 157, 190, 153, 249, 118, 187, 133, 30, 200, 134, 208, 16, 21, 140, 248, 197, 114, 246,
+        98, 225, 215, 234, 18, 120, 29, 22, 61, 64, 84, 46, 221, 17, 199, 213, 135, 129, 89, 165,
+        72, 223, 116, 88, 244, 256, 79, 184, 113, 68, 25, 81, 26, 2, 99, 146, 31, 121, 207, 95, 205,
+        253, 59, 222, 195, 15, 100, 67, 104, 8, 139, 70, 124, 227, 57, 123, 49, 241, 236, 117, 9,
+        60, 143, 11, 159, 32, 42, 23, 239, 137, 228, 235, 196, 193, 173, 211, 36, 240, 58, 44, 122,
+        128, 168, 92, 185, 34, 141, 169, 13, 1, 178, 73, 144, 189, 232, 176, 231, 255, 158, 111,
+        226, 136, 50, 162, 52, 4, 198, 35, 62, 242, 157, 190, 153, 249, 118, 187, 133, 30, 200, 134,
+        208, 16, 21, 140, 248, 197, 114, 246, 98, 225, 215, 234, 18, 120, 29, 22, 61, 64, 84, 46,
+        221, 17, 199, 213, 135, 129, 89, 165, 72, 223, 116, 88, 244, 256, 79, 184, 113, 68, 25, 81,
+        26, 2, 99, 146, 31, 121, 207, 95, 205, 253, 59, 222, 195, 15, 100, 67, 104, 8, 139, 70, 124,
+        227, 57, 123, 49, 241, 236, 117, 9, 60, 143, 11, 159, 32, 42, 23, 239, 137, 228, 235, 196,
+        193, 173, 211, 36, 240, 58, 44, 122, 128, 168, 92, 185, 34, 141, 169, 13, 1,
+    ],
+    [
+        1, 179, 173, 127, 117, 126, 195, 210, 68, 93, 199, 155, 246, 87, 153, 145, 255, 156, 168, 3,
+        23, 5, 124, 94, 121, 71, 116, 204, 22, 83, 208, 224, 4, 202, 178, 251, 211, 247, 9, 69, 15,
+        115, 25, 106, 213, 91, 98, 66, 249, 110, 158, 12, 92, 20, 239, 119, 227, 27, 207, 45, 88,
+        75, 61, 125, 16, 37, 198, 233, 73, 217, 36, 19, 60, 203, 100, 167, 81, 107, 135, 7, 225,
+        183, 118, 48, 111, 80, 185, 219, 137, 108, 57, 180, 95, 43, 244, 243, 64, 148, 21, 161, 35,
+        97, 144, 76, 240, 41, 143, 154, 67, 171, 26, 28, 129, 218, 215, 192, 187, 63, 226, 105, 34,
+        175, 228, 206, 123, 172, 205, 201, 256, 78, 84, 130, 140, 131, 62, 47, 189, 164, 58, 102,
+        11, 170, 104, 112, 2, 101, 89, 254, 234, 252, 133, 163, 136, 186, 141, 53, 235, 174, 49, 33,
+        253, 55, 79, 6, 46, 10, 248, 188, 242, 142, 232, 151, 44, 166, 159, 191, 8, 147, 99, 245,
+        165, 237, 18, 138, 30, 230, 50, 212, 169, 182, 196, 132, 241, 220, 59, 24, 184, 40, 221,
+        238, 197, 54, 157, 90, 176, 150, 122, 250, 32, 74, 139, 209, 146, 177, 72, 38, 120, 149,
+        200, 77, 162, 214, 13, 14, 193, 109, 236, 96, 222, 160, 113, 181, 17, 216, 114, 103, 190,
+        86, 231, 229, 128, 39, 42, 65, 70, 194, 31, 152, 223, 82, 29, 51, 134, 85, 52, 56, 1,
+    ],
+    [
+        1, 180, 18, 156, 67, 238, 178, 172, 120, 12, 104, 216, 73, 33, 29, 80, 8, 155, 144, 220, 22,
+        105, 139, 91, 189, 96, 61, 186, 70, 7, 232, 126, 64, 212, 124, 218, 176, 69, 84, 214, 227,
+        254, 231, 203, 46, 56, 57, 237, 255, 154, 221, 202, 123, 38, 158, 170, 17, 233, 49, 82, 111,
+        191, 199, 97, 241, 204, 226, 74, 213, 47, 236, 75, 136, 65, 135, 142, 117, 243, 50, 5, 129,
+        90, 9, 78, 162, 119, 89, 86, 60, 6, 52, 108, 165, 145, 143, 40, 4, 206, 72, 110, 11, 181,
+        198, 174, 223, 48, 159, 93, 35, 132, 116, 63, 32, 106, 62, 109, 88, 163, 42, 107, 242, 127,
+        244, 230, 23, 28, 157, 247, 256, 77, 239, 101, 190, 19, 79, 85, 137, 245, 153, 41, 184, 224,
+        228, 177, 249, 102, 113, 37, 235, 152, 118, 166, 68, 161, 196, 71, 187, 250, 25, 131, 193,
+        45, 133, 39, 81, 188, 173, 43, 30, 3, 26, 54, 211, 201, 200, 20, 2, 103, 36, 55, 134, 219,
+        99, 87, 240, 24, 208, 175, 146, 66, 58, 160, 16, 53, 31, 183, 44, 210, 21, 182, 121, 192,
+        122, 115, 140, 14, 207, 252, 128, 167, 248, 179, 95, 138, 168, 171, 197, 251, 205, 149, 92,
+        112, 114, 217, 253, 51, 185, 147, 246, 76, 59, 83, 34, 209, 98, 164, 222, 125, 141, 194,
+        225, 151, 195, 148, 169, 94, 215, 150, 15, 130, 13, 27, 234, 229, 100, 10, 1,
+    ],
+    [
+        1, 181, 122, 237, 235, 130, 143, 183, 227, 224, 195, 86, 146, 212, 79, 164, 129, 219, 61,
+        247, 246, 65, 200, 220, 242, 112, 226, 43, 73, 106, 168, 82, 193, 238, 159, 252, 123, 161,
+        100, 110, 121, 56, 113, 150, 165, 53, 84, 41, 225, 119, 208, 126, 190, 209, 50, 55, 189, 28,
+        185, 75, 211, 155, 42, 149, 241, 188, 104, 63, 95, 233, 25, 156, 223, 14, 221, 166, 234,
+        206, 21, 203, 249, 94, 52, 160, 176, 245, 141, 78, 240, 7, 239, 83, 117, 103, 139, 230, 253,
+        47, 26, 80, 88, 251, 199, 39, 120, 132, 248, 170, 187, 180, 198, 115, 255, 152, 13, 40, 44,
+        254, 228, 148, 60, 66, 124, 85, 222, 90, 99, 186, 256, 76, 135, 20, 22, 127, 114, 74, 30,
+        33, 62, 171, 111, 45, 178, 93, 128, 38, 196, 10, 11, 192, 57, 37, 15, 145, 31, 214, 184,
+        151, 89, 175, 64, 19, 98, 5, 134, 96, 157, 147, 136, 201, 144, 107, 92, 204, 173, 216, 32,
+        138, 49, 131, 67, 48, 207, 202, 68, 229, 72, 182, 46, 102, 215, 108, 16, 69, 153, 194, 162,
+        24, 232, 101, 34, 243, 36, 91, 23, 51, 236, 54, 8, 163, 205, 97, 81, 12, 116, 179, 17, 250,
+        18, 174, 140, 154, 118, 27, 4, 210, 231, 177, 169, 6, 58, 218, 137, 125, 9, 87, 70, 77, 59,
+        142, 2, 105, 244, 217, 213, 3, 29, 109, 197, 191, 133, 172, 35, 167, 158, 71, 1,
+    ],
+    [
+        1, 182, 228, 119, 70, 147, 26, 106, 17, 10, 21, 224, 162, 186, 185, 3, 32, 170, 100, 210,
+        184, 78, 61, 51, 30, 63, 158, 229, 44, 41, 9, 96, 253, 43, 116, 38, 234, 183, 153, 90, 189,
+        217, 173, 132, 123, 27, 31, 245, 129, 91, 114, 188, 35, 202, 13, 53, 137, 5, 139, 112, 81,
+        93, 221, 130, 16, 85, 50, 105, 92, 39, 159, 154, 15, 160, 79, 243, 22, 149, 133, 48, 255,
+        150, 58, 19, 117, 220, 205, 45, 223, 237, 215, 66, 190, 142, 144, 251, 193, 174, 57, 94,
+        146, 101, 135, 155, 197, 131, 198, 56, 169, 175, 239, 65, 8, 171, 25, 181, 46, 148, 208, 77,
+        136, 80, 168, 250, 11, 203, 195, 24, 256, 75, 29, 138, 187, 110, 231, 151, 240, 247, 236,
+        33, 95, 71, 72, 254, 225, 87, 157, 47, 73, 179, 196, 206, 227, 194, 99, 28, 213, 216, 248,
+        161, 4, 214, 141, 219, 23, 74, 104, 167, 68, 40, 84, 125, 134, 230, 226, 12, 128, 166, 143,
+        69, 222, 55, 244, 204, 120, 252, 118, 145, 176, 164, 36, 127, 241, 172, 207, 152, 165, 218,
+        98, 103, 242, 97, 178, 14, 235, 108, 124, 209, 2, 107, 199, 238, 140, 37, 52, 212, 34, 20,
+        42, 191, 67, 115, 113, 6, 64, 83, 200, 163, 111, 156, 122, 102, 60, 126, 59, 201, 88, 82,
+        18, 192, 249, 86, 232, 76, 211, 109, 49, 180, 121, 177, 89, 7, 246, 54, 62, 233, 1,
+    ],
+    [
+        1, 183, 79, 65, 73, 252, 113, 119, 189, 149, 25, 206, 176, 83, 26, 132, 255, 148, 99, 127,
+        111, 10, 31, 19, 136, 216, 207, 102, 162, 91, 205, 250, 4, 218, 59, 3, 35, 237, 195, 219,
+        242, 82, 100, 53, 190, 75, 104, 14, 249, 78, 139, 251, 187, 40, 124, 76, 30, 93, 57, 151,
+        134, 107, 49, 229, 16, 101, 236, 12, 140, 177, 9, 105, 197, 71, 143, 212, 246, 43, 159, 56,
+        225, 55, 42, 233, 234, 160, 239, 47, 120, 115, 228, 90, 22, 171, 196, 145, 64, 147, 173, 48,
+        46, 194, 36, 163, 17, 27, 58, 77, 213, 172, 122, 224, 129, 220, 168, 161, 165, 126, 185,
+        188, 223, 203, 141, 103, 88, 170, 13, 66, 256, 74, 178, 192, 184, 5, 144, 138, 68, 108, 232,
+        51, 81, 174, 231, 125, 2, 109, 158, 130, 146, 247, 226, 238, 121, 41, 50, 155, 95, 166, 52,
+        7, 253, 39, 198, 254, 222, 20, 62, 38, 15, 175, 157, 204, 67, 182, 153, 243, 8, 179, 118, 6,
+        70, 217, 133, 181, 227, 164, 200, 106, 123, 150, 208, 28, 241, 156, 21, 245, 117, 80, 248,
+        152, 60, 186, 114, 45, 11, 214, 98, 201, 32, 202, 215, 24, 23, 97, 18, 210, 137, 142, 29,
+        167, 235, 86, 61, 112, 193, 110, 84, 209, 211, 63, 221, 94, 240, 230, 199, 180, 44, 85, 135,
+        33, 128, 37, 89, 96, 92, 131, 72, 69, 34, 54, 116, 154, 169, 87, 244, 191, 1,
+    ],
+    [
+        1, 184, 189, 81, 255, 146, 136, 95, 4, 222, 242, 67, 249, 70, 30, 123, 16, 117, 197, 11,
+        225, 23, 120, 235, 64, 211, 17, 44, 129, 92, 223, 169, 256, 73, 68, 176, 2, 111, 121, 162,
+        253, 35, 15, 190, 8, 187, 227, 134, 241, 140, 60, 246, 32, 234, 137, 22, 193, 46, 240, 213,
+        128, 165, 34, 88, 1, 184, 189, 81, 255, 146, 136, 95, 4, 222, 242, 67, 249, 70, 30, 123, 16,
+        117, 197, 11, 225, 23, 120, 235, 64, 211, 17, 44, 129, 92, 223, 169, 256, 73, 68, 176, 2,
+        111, 121, 162, 253, 35, 15, 190, 8, 187, 227, 134, 241, 140, 60, 246, 32, 234, 137, 22, 193,
+        46, 240, 213, 128, 165, 34, 88, 1, 184, 189, 81, 255, 146, 136, 95, 4, 222, 242, 67, 249,
+        70, 30, 123, 16, 117, 197, 11, 225, 23, 120, 235, 64, 211, 17, 44, 129, 92, 223, 169, 256,
+        73, 68, 176, 2, 111, 121, 162, 253, 35, 15, 190, 8, 187, 227, 134, 241, 140, 60, 246, 32,
+        234, 137, 22, 193, 46, 240, 213, 128, 165, 34, 88, 1, 184, 189, 81, 255, 146, 136, 95, 4,
+        222, 242, 67, 249, 70, 30, 123, 16, 117, 197, 11, 225, 23, 120, 235, 64, 211, 17, 44, 129,
+        92, 223, 169, 256, 73, 68, 176, 2, 111, 121, 162, 253, 35, 15, 190, 8, 187, 227, 134, 241,
+        140, 60, 246, 32, 234, 137, 22, 193, 46, 240, 213, 128, 165, 34, 88, 1,
+    ],
+    [
+        1, 185, 44, 173, 137, 159, 117, 57, 8, 195, 95, 99, 68, 244, 165, 199, 64, 18, 246, 21, 30,
+        153, 35, 50, 255, 144, 169, 168, 240, 196, 23, 143, 241, 124, 67, 59, 121, 26, 184, 116,
+        129, 221, 22, 215, 197, 208, 187, 157, 4, 226, 176, 178, 34, 122, 211, 228, 32, 9, 123, 139,
+        15, 205, 146, 25, 256, 72, 213, 84, 120, 98, 140, 200, 249, 62, 162, 158, 189, 13, 92, 58,
+        193, 239, 11, 236, 227, 104, 222, 207, 2, 113, 88, 89, 17, 61, 234, 114, 16, 133, 190, 198,
+        136, 231, 73, 141, 128, 36, 235, 42, 60, 49, 70, 100, 253, 31, 81, 79, 223, 135, 46, 29,
+        225, 248, 134, 118, 242, 52, 111, 232, 1, 185, 44, 173, 137, 159, 117, 57, 8, 195, 95, 99,
+        68, 244, 165, 199, 64, 18, 246, 21, 30, 153, 35, 50, 255, 144, 169, 168, 240, 196, 23, 143,
+        241, 124, 67, 59, 121, 26, 184, 116, 129, 221, 22, 215, 197, 208, 187, 157, 4, 226, 176,
+        178, 34, 122, 211, 228, 32, 9, 123, 139, 15, 205, 146, 25, 256, 72, 213, 84, 120, 98, 140,
+        200, 249, 62, 162, 158, 189, 13, 92, 58, 193, 239, 11, 236, 227, 104, 222, 207, 2, 113, 88,
+        89, 17, 61, 234, 114, 16, 133, 190, 198, 136, 231, 73, 141, 128, 36, 235, 42, 60, 49, 70,
+        100, 253, 31, 81, 79, 223, 135, 46, 29, 225, 248, 134, 118, 242, 52, 111, 232, 1,
+    ],
+    [
+        1, 186, 158, 90, 35, 85, 133, 66, 197, 148, 29, 254, 213, 40, 244, 152, 2, 115, 59, 180, 70,
+        170, 9, 132, 137, 39, 58, 251, 169, 80, 231, 47, 4, 230, 118, 103, 140, 83, 18, 7, 17, 78,
+        116, 245, 81, 160, 205, 94, 8, 203, 236, 206, 23, 166, 36, 14, 34, 156, 232, 233, 162, 63,
+        153, 188, 16, 149, 215, 155, 46, 75, 72, 28, 68, 55, 207, 209, 67, 126, 49, 119, 32, 41,
+        173, 53, 92, 150, 144, 56, 136, 110, 157, 161, 134, 252, 98, 238, 64, 82, 89, 106, 184, 43,
+        31, 112, 15, 220, 57, 65, 11, 247, 196, 219, 128, 164, 178, 212, 111, 86, 62, 224, 30, 183,
+        114, 130, 22, 237, 135, 181, 256, 71, 99, 167, 222, 172, 124, 191, 60, 109, 228, 3, 44, 217,
+        13, 105, 255, 142, 198, 77, 187, 87, 248, 125, 120, 218, 199, 6, 88, 177, 26, 210, 253, 27,
+        139, 154, 117, 174, 239, 250, 240, 179, 141, 12, 176, 97, 52, 163, 249, 54, 21, 51, 234, 91,
+        221, 243, 223, 101, 25, 24, 95, 194, 104, 69, 241, 108, 42, 102, 211, 182, 185, 229, 189,
+        202, 50, 48, 190, 131, 208, 138, 225, 216, 84, 204, 165, 107, 113, 201, 121, 147, 100, 96,
+        123, 5, 159, 19, 193, 175, 168, 151, 73, 214, 226, 145, 242, 37, 200, 192, 246, 10, 61, 38,
+        129, 93, 79, 45, 146, 171, 195, 33, 227, 74, 143, 127, 235, 20, 122, 76, 1,
+    ],
+    [
+        1, 187, 17, 95, 32, 73, 30, 213, 253, 23, 189, 134, 129, 222, 137, 176, 16, 165, 15, 235,
+        255, 140, 223, 67, 193, 111, 197, 88, 8, 211, 136, 246, 256, 70, 240, 162, 225, 184, 227,
+        44, 4, 234, 68, 123, 128, 35, 120, 81, 241, 92, 242, 22, 2, 117, 34, 190, 64, 146, 60, 169,
+        249, 46, 121, 11, 1, 187, 17, 95, 32, 73, 30, 213, 253, 23, 189, 134, 129, 222, 137, 176,
+        16, 165, 15, 235, 255, 140, 223, 67, 193, 111, 197, 88, 8, 211, 136, 246, 256, 70, 240, 162,
+        225, 184, 227, 44, 4, 234, 68, 123, 128, 35, 120, 81, 241, 92, 242, 22, 2, 117, 34, 190, 64,
+        146, 60, 169, 249, 46, 121, 11, 1, 187, 17, 95, 32, 73, 30, 213, 253, 23, 189, 134, 129,
+        222, 137, 176, 16, 165, 15, 235, 255, 140, 223, 67, 193, 111, 197, 88, 8, 211, 136, 246,
+        256, 70, 240, 162, 225, 184, 227, 44, 4, 234, 68, 123, 128, 35, 120, 81, 241, 92, 242, 22,
+        2, 117, 34, 190, 64, 146, 60, 169, 249, 46, 121, 11, 1, 187, 17, 95, 32, 73, 30, 213, 253,
+        23, 189, 134, 129, 222, 137, 176, 16, 165, 15, 235, 255, 140, 223, 67, 193, 111, 197, 88, 8,
+        211, 136, 246, 256, 70, 240, 162, 225, 184, 227, 44, 4, 234, 68, 123, 128, 35, 120, 81, 241,
+        92, 242, 22, 2, 117, 34, 190, 64, 146, 60, 169, 249, 46, 121, 11, 1,
+    ],
+    [
+        1, 188, 135, 194, 235, 233, 114, 101, 227, 14, 62, 91, 146, 206, 178, 54, 129, 94, 196, 97,
+        246, 245, 57, 179, 242, 7, 31, 174, 73, 103, 89, 27, 193, 47, 98, 177, 123, 251, 157, 218,
+        121, 132, 144, 87, 165, 180, 173, 142, 225, 152, 49, 217, 190, 254, 207, 109, 189, 66, 72,
+        172, 211, 90, 215, 71, 241, 76, 153, 237, 95, 127, 232, 183, 223, 33, 36, 86, 234, 45, 236,
+        164, 249, 38, 205, 247, 176, 192, 116, 220, 240, 145, 18, 43, 117, 151, 118, 82, 253, 19,
+        231, 252, 88, 96, 58, 110, 120, 201, 9, 150, 187, 204, 59, 41, 255, 138, 244, 126, 44, 48,
+        29, 55, 60, 229, 133, 75, 222, 102, 158, 149, 256, 69, 122, 63, 22, 24, 143, 156, 30, 243,
+        195, 166, 111, 51, 79, 203, 128, 163, 61, 160, 11, 12, 200, 78, 15, 250, 226, 83, 184, 154,
+        168, 230, 64, 210, 159, 80, 134, 6, 100, 39, 136, 125, 113, 170, 92, 77, 84, 115, 32, 105,
+        208, 40, 67, 3, 50, 148, 68, 191, 185, 85, 46, 167, 42, 186, 16, 181, 104, 20, 162, 130, 25,
+        74, 34, 224, 221, 171, 23, 212, 21, 93, 8, 219, 52, 10, 81, 65, 141, 37, 17, 112, 239, 214,
+        140, 106, 139, 175, 4, 238, 26, 5, 169, 161, 199, 147, 137, 56, 248, 107, 70, 53, 198, 216,
+        2, 119, 13, 131, 213, 209, 228, 202, 197, 28, 124, 182, 35, 155, 99, 108, 1,
+    ],
+    [
+        1, 189, 255, 136, 4, 242, 249, 30, 16, 197, 225, 120, 64, 17, 129, 223, 256, 68, 2, 121,
+        253, 15, 8, 227, 241, 60, 32, 137, 193, 240, 128, 34, 1, 189, 255, 136, 4, 242, 249, 30, 16,
+        197, 225, 120, 64, 17, 129, 223, 256, 68, 2, 121, 253, 15, 8, 227, 241, 60, 32, 137, 193,
+        240, 128, 34, 1, 189, 255, 136, 4, 242, 249, 30, 16, 197, 225, 120, 64, 17, 129, 223, 256,
+        68, 2, 121, 253, 15, 8, 227, 241, 60, 32, 137, 193, 240, 128, 34, 1, 189, 255, 136, 4, 242,
+        249, 30, 16, 197, 225, 120, 64, 17, 129, 223, 256, 68, 2, 121, 253, 15, 8, 227, 241, 60, 32,
+        137, 193, 240, 128, 34, 1, 189, 255, 136, 4, 242, 249, 30, 16, 197, 225, 120, 64, 17, 129,
+        223, 256, 68, 2, 121, 253, 15, 8, 227, 241, 60, 32, 137, 193, 240, 128, 34, 1, 189, 255,
+        136, 4, 242, 249, 30, 16, 197, 225, 120, 64, 17, 129, 223, 256, 68, 2, 121, 253, 15, 8, 227,
+        241, 60, 32, 137, 193, 240, 128, 34, 1, 189, 255, 136, 4, 242, 249, 30, 16, 197, 225, 120,
+        64, 17, 129, 223, 256, 68, 2, 121, 253, 15, 8, 227, 241, 60, 32, 137, 193, 240, 128, 34, 1,
+        189, 255, 136, 4, 242, 249, 30, 16, 197, 225, 120, 64, 17, 129, 223, 256, 68, 2, 121, 253,
+        15, 8, 227, 241, 60, 32, 137, 193, 240, 128, 34, 1,
+    ],
+    [
+        1, 190, 120, 184, 8, 235, 189, 187, 64, 81, 227, 211, 255, 134, 17, 146, 241, 44, 136, 140,
+        129, 95, 60, 92, 4, 246, 223, 222, 32, 169, 242, 234, 256, 67, 137, 73, 249, 22, 68, 70,
+        193, 176, 30, 46, 2, 123, 240, 111, 16, 213, 121, 117, 128, 162, 197, 165, 253, 11, 34, 35,
+        225, 88, 15, 23, 1, 190, 120, 184, 8, 235, 189, 187, 64, 81, 227, 211, 255, 134, 17, 146,
+        241, 44, 136, 140, 129, 95, 60, 92, 4, 246, 223, 222, 32, 169, 242, 234, 256, 67, 137, 73,
+        249, 22, 68, 70, 193, 176, 30, 46, 2, 123, 240, 111, 16, 213, 121, 117, 128, 162, 197, 165,
+        253, 11, 34, 35, 225, 88, 15, 23, 1, 190, 120, 184, 8, 235, 189, 187, 64, 81, 227, 211, 255,
+        134, 17, 146, 241, 44, 136, 140, 129, 95, 60, 92, 4, 246, 223, 222, 32, 169, 242, 234, 256,
+        67, 137, 73, 249, 22, 68, 70, 193, 176, 30, 46, 2, 123, 240, 111, 16, 213, 121, 117, 128,
+        162, 197, 165, 253, 11, 34, 35, 225, 88, 15, 23, 1, 190, 120, 184, 8, 235, 189, 187, 64, 81,
+        227, 211, 255, 134, 17, 146, 241, 44, 136, 140, 129, 95, 60, 92, 4, 246, 223, 222, 32, 169,
+        242, 234, 256, 67, 137, 73, 249, 22, 68, 70, 193, 176, 30, 46, 2, 123, 240, 111, 16, 213,
+        121, 117, 128, 162, 197, 165, 253, 11, 34, 35, 225, 88, 15, 23, 1,
+    ],
+    [
+        1, 191, 244, 87, 169, 154, 116, 54, 34, 69, 72, 131, 92, 96, 89, 37, 128, 33, 135, 85, 44,
+        180, 199, 230, 240, 94, 221, 63, 211, 209, 84, 110, 193, 112, 61, 86, 235, 167, 29, 142,
+        137, 210, 18, 97, 23, 24, 215, 202, 32, 201, 98, 214, 11, 45, 114, 186, 60, 152, 248, 80,
+        117, 245, 21, 156, 241, 28, 208, 150, 123, 106, 200, 164, 227, 181, 133, 217, 70, 6, 118,
+        179, 8, 243, 153, 182, 67, 204, 157, 175, 15, 38, 62, 20, 222, 254, 198, 39, 253, 7, 52,
+        166, 95, 155, 50, 41, 121, 238, 226, 247, 146, 130, 158, 109, 2, 125, 231, 174, 81, 51, 232,
+        108, 68, 138, 144, 5, 184, 192, 178, 74, 256, 66, 13, 170, 88, 103, 141, 203, 223, 188, 185,
+        126, 165, 161, 168, 220, 129, 224, 122, 172, 213, 77, 58, 27, 17, 163, 36, 194, 46, 48, 173,
+        147, 64, 145, 196, 171, 22, 90, 228, 115, 120, 47, 239, 160, 234, 233, 42, 55, 225, 56, 159,
+        43, 246, 212, 143, 71, 197, 105, 9, 177, 140, 12, 236, 101, 16, 229, 49, 107, 134, 151, 57,
+        93, 30, 76, 124, 40, 187, 251, 139, 78, 249, 14, 104, 75, 190, 53, 100, 82, 242, 219, 195,
+        237, 35, 3, 59, 218, 4, 250, 205, 91, 162, 102, 207, 216, 136, 19, 31, 10, 111, 127, 99,
+        148, 255, 132, 26, 83, 176, 206, 25, 149, 189, 119, 113, 252, 73, 65, 79, 183, 1,
+    ],
+    [
+        1, 192, 113, 108, 176, 125, 99, 247, 136, 155, 205, 39, 35, 38, 100, 182, 249, 6, 124, 164,
+        134, 28, 236, 80, 197, 45, 159, 202, 234, 210, 228, 86, 64, 209, 36, 230, 213, 33, 168, 131,
+        223, 154, 13, 183, 184, 119, 232, 83, 2, 127, 226, 216, 95, 250, 198, 237, 15, 53, 153, 78,
+        70, 76, 200, 107, 241, 12, 248, 71, 11, 56, 215, 160, 137, 90, 61, 147, 211, 163, 199, 172,
+        128, 161, 72, 203, 169, 66, 79, 5, 189, 51, 26, 109, 111, 238, 207, 166, 4, 254, 195, 175,
+        190, 243, 139, 217, 30, 106, 49, 156, 140, 152, 143, 214, 225, 24, 239, 142, 22, 112, 173,
+        63, 17, 180, 122, 37, 165, 69, 141, 87, 256, 65, 144, 149, 81, 132, 158, 10, 121, 102, 52,
+        218, 222, 219, 157, 75, 8, 251, 133, 93, 123, 229, 21, 177, 60, 212, 98, 55, 23, 47, 29,
+        171, 193, 48, 221, 27, 44, 224, 89, 126, 34, 103, 244, 74, 73, 138, 25, 174, 255, 130, 31,
+        41, 162, 7, 59, 20, 242, 204, 104, 179, 187, 181, 57, 150, 16, 245, 9, 186, 246, 201, 42,
+        97, 120, 167, 196, 110, 46, 94, 58, 85, 129, 96, 185, 54, 88, 191, 178, 252, 68, 206, 231,
+        148, 146, 19, 50, 91, 253, 3, 62, 82, 67, 14, 118, 40, 227, 151, 208, 101, 117, 105, 114,
+        43, 32, 233, 18, 115, 235, 145, 84, 194, 240, 77, 135, 220, 92, 188, 116, 170, 1,
+    ],
+    [
+        1, 193, 241, 253, 256, 64, 16, 4, 1, 193, 241, 253, 256, 64, 16, 4, 1, 193, 241, 253, 256,
+        64, 16, 4, 1, 193, 241, 253, 256, 64, 16, 4, 1, 193, 241, 253, 256, 64, 16, 4, 1, 193, 241,
+        253, 256, 64, 16, 4, 1, 193, 241, 253, 256, 64, 16, 4, 1, 193, 241, 253, 256, 64, 16, 4, 1,
+        193, 241, 253, 256, 64, 16, 4, 1, 193, 241, 253, 256, 64, 16, 4, 1, 193, 241, 253, 256, 64,
+        16, 4, 1, 193, 241, 253, 256, 64, 16, 4, 1, 193, 241, 253, 256, 64, 16, 4, 1, 193, 241, 253,
+        256, 64, 16, 4, 1, 193, 241, 253, 256, 64, 16, 4, 1, 193, 241, 253, 256, 64, 16, 4, 1, 193,
+        241, 253, 256, 64, 16, 4, 1, 193, 241, 253, 256, 64, 16, 4, 1, 193, 241, 253, 256, 64, 16,
+        4, 1, 193, 241, 253, 256, 64, 16, 4, 1, 193, 241, 253, 256, 64, 16, 4, 1, 193, 241, 253,
+        256, 64, 16, 4, 1, 193, 241, 253, 256, 64, 16, 4, 1, 193, 241, 253, 256, 64, 16, 4, 1, 193,
+        241, 253, 256, 64, 16, 4, 1, 193, 241, 253, 256, 64, 16, 4, 1, 193, 241, 253, 256, 64, 16,
+        4, 1, 193, 241, 253, 256, 64, 16, 4, 1, 193, 241, 253, 256, 64, 16, 4, 1, 193, 241, 253,
+        256, 64, 16, 4, 1, 193, 241, 253, 256, 64, 16, 4, 1, 193, 241, 253, 256, 64, 16, 4, 1,
+    ],
+    [
+        1, 194, 114, 14, 146, 54, 196, 245, 242, 174, 89, 47, 123, 218, 144, 180, 225, 217, 207, 66,
+        211, 71, 153, 127, 223, 86, 236, 38, 176, 220, 18, 151, 253, 252, 58, 201, 187, 41, 244, 48,
+        60, 75, 158, 69, 22, 156, 195, 51, 128, 160, 200, 250, 184, 230, 159, 6, 136, 170, 84, 105,
+        67, 148, 185, 167, 16, 20, 25, 224, 23, 93, 52, 65, 17, 214, 139, 238, 169, 147, 248, 53, 2,
+        131, 228, 28, 35, 108, 135, 233, 227, 91, 178, 94, 246, 179, 31, 103, 193, 177, 157, 132,
+        165, 142, 49, 254, 189, 172, 215, 76, 95, 183, 36, 45, 249, 247, 116, 145, 117, 82, 231, 96,
+        120, 150, 59, 138, 44, 55, 133, 102, 256, 63, 143, 243, 111, 203, 61, 12, 15, 83, 168, 210,
+        134, 39, 113, 77, 32, 40, 50, 191, 46, 186, 104, 130, 34, 171, 21, 219, 81, 37, 239, 106, 4,
+        5, 199, 56, 70, 216, 13, 209, 197, 182, 99, 188, 235, 101, 62, 206, 129, 97, 57, 7, 73, 27,
+        98, 251, 121, 87, 173, 152, 190, 109, 72, 90, 241, 237, 232, 33, 234, 164, 205, 192, 240,
+        43, 118, 19, 88, 110, 9, 204, 255, 126, 29, 229, 222, 149, 122, 24, 30, 166, 79, 163, 11,
+        78, 226, 154, 64, 80, 100, 125, 92, 115, 208, 3, 68, 85, 42, 181, 162, 74, 221, 212, 8, 10,
+        141, 112, 140, 175, 26, 161, 137, 107, 198, 119, 213, 202, 124, 155, 1,
+    ],
+    [
+        1, 195, 246, 168, 121, 208, 211, 25, 249, 239, 88, 198, 60, 135, 111, 57, 64, 144, 67, 215,
+        34, 205, 140, 58, 2, 133, 235, 79, 242, 159, 165, 50, 241, 221, 176, 139, 120, 13, 222, 114,
+        128, 31, 134, 173, 68, 153, 23, 116, 4, 9, 213, 158, 227, 61, 73, 100, 225, 185, 95, 21,
+        240, 26, 187, 228, 256, 62, 11, 89, 136, 49, 46, 232, 8, 18, 169, 59, 197, 122, 146, 200,
+        193, 113, 190, 42, 223, 52, 117, 199, 255, 124, 22, 178, 15, 98, 92, 207, 16, 36, 81, 118,
+        137, 244, 35, 143, 129, 226, 123, 84, 189, 104, 234, 141, 253, 248, 44, 99, 30, 196, 184,
+        157, 32, 72, 162, 236, 17, 231, 70, 29, 1, 195, 246, 168, 121, 208, 211, 25, 249, 239, 88,
+        198, 60, 135, 111, 57, 64, 144, 67, 215, 34, 205, 140, 58, 2, 133, 235, 79, 242, 159, 165,
+        50, 241, 221, 176, 139, 120, 13, 222, 114, 128, 31, 134, 173, 68, 153, 23, 116, 4, 9, 213,
+        158, 227, 61, 73, 100, 225, 185, 95, 21, 240, 26, 187, 228, 256, 62, 11, 89, 136, 49, 46,
+        232, 8, 18, 169, 59, 197, 122, 146, 200, 193, 113, 190, 42, 223, 52, 117, 199, 255, 124, 22,
+        178, 15, 98, 92, 207, 16, 36, 81, 118, 137, 244, 35, 143, 129, 226, 123, 84, 189, 104, 234,
+        141, 253, 248, 44, 99, 30, 196, 184, 157, 32, 72, 162, 236, 17, 231, 70, 29, 1,
+    ],
+    [
+        1, 196, 123, 207, 223, 18, 187, 158, 128, 159, 67, 25, 17, 248, 35, 178, 193, 49, 95, 116,
+        120, 133, 111, 168, 32, 104, 81, 199, 197, 62, 73, 173, 241, 205, 88, 29, 30, 226, 92, 42,
+        8, 26, 213, 114, 242, 144, 211, 236, 253, 244, 22, 200, 136, 185, 23, 139, 2, 135, 246, 157,
+        189, 36, 117, 59, 256, 61, 134, 50, 34, 239, 70, 99, 129, 98, 190, 232, 240, 9, 222, 79, 64,
+        208, 162, 141, 137, 124, 146, 89, 225, 153, 176, 58, 60, 195, 184, 84, 16, 52, 169, 228,
+        227, 31, 165, 215, 249, 231, 44, 143, 15, 113, 46, 21, 4, 13, 235, 57, 121, 72, 234, 118,
+        255, 122, 11, 100, 68, 221, 140, 198, 1, 196, 123, 207, 223, 18, 187, 158, 128, 159, 67, 25,
+        17, 248, 35, 178, 193, 49, 95, 116, 120, 133, 111, 168, 32, 104, 81, 199, 197, 62, 73, 173,
+        241, 205, 88, 29, 30, 226, 92, 42, 8, 26, 213, 114, 242, 144, 211, 236, 253, 244, 22, 200,
+        136, 185, 23, 139, 2, 135, 246, 157, 189, 36, 117, 59, 256, 61, 134, 50, 34, 239, 70, 99,
+        129, 98, 190, 232, 240, 9, 222, 79, 64, 208, 162, 141, 137, 124, 146, 89, 225, 153, 176, 58,
+        60, 195, 184, 84, 16, 52, 169, 228, 227, 31, 165, 215, 249, 231, 44, 143, 15, 113, 46, 21,
+        4, 13, 235, 57, 121, 72, 234, 118, 255, 122, 11, 100, 68, 221, 140, 198, 1,
+    ],
+    [
+        1, 197, 2, 137, 4, 17, 8, 34, 16, 68, 32, 136, 64, 15, 128, 30, 256, 60, 255, 120, 253, 240,
+        249, 223, 241, 189, 225, 121, 193, 242, 129, 227, 1, 197, 2, 137, 4, 17, 8, 34, 16, 68, 32,
+        136, 64, 15, 128, 30, 256, 60, 255, 120, 253, 240, 249, 223, 241, 189, 225, 121, 193, 242,
+        129, 227, 1, 197, 2, 137, 4, 17, 8, 34, 16, 68, 32, 136, 64, 15, 128, 30, 256, 60, 255, 120,
+        253, 240, 249, 223, 241, 189, 225, 121, 193, 242, 129, 227, 1, 197, 2, 137, 4, 17, 8, 34,
+        16, 68, 32, 136, 64, 15, 128, 30, 256, 60, 255, 120, 253, 240, 249, 223, 241, 189, 225, 121,
+        193, 242, 129, 227, 1, 197, 2, 137, 4, 17, 8, 34, 16, 68, 32, 136, 64, 15, 128, 30, 256, 60,
+        255, 120, 253, 240, 249, 223, 241, 189, 225, 121, 193, 242, 129, 227, 1, 197, 2, 137, 4, 17,
+        8, 34, 16, 68, 32, 136, 64, 15, 128, 30, 256, 60, 255, 120, 253, 240, 249, 223, 241, 189,
+        225, 121, 193, 242, 129, 227, 1, 197, 2, 137, 4, 17, 8, 34, 16, 68, 32, 136, 64, 15, 128,
+        30, 256, 60, 255, 120, 253, 240, 249, 223, 241, 189, 225, 121, 193, 242, 129, 227, 1, 197,
+        2, 137, 4, 17, 8, 34, 16, 68, 32, 136, 64, 15, 128, 30, 256, 60, 255, 120, 253, 240, 249,
+        223, 241, 189, 225, 121, 193, 242, 129, 227, 1,
+    ],
+    [
+        1, 198, 140, 221, 68, 100, 11, 122, 255, 118, 234, 72, 121, 57, 235, 13, 4, 21, 46, 113, 15,
+        143, 44, 231, 249, 215, 165, 31, 227, 228, 169, 52, 16, 84, 184, 195, 60, 58, 176, 153, 225,
+        89, 146, 124, 137, 141, 162, 208, 64, 79, 222, 9, 240, 232, 190, 98, 129, 99, 70, 239, 34,
+        50, 134, 61, 256, 59, 117, 36, 189, 157, 246, 135, 2, 139, 23, 185, 136, 200, 22, 244, 253,
+        236, 211, 144, 242, 114, 213, 26, 8, 42, 92, 226, 30, 29, 88, 205, 241, 173, 73, 62, 197,
+        199, 81, 104, 32, 168, 111, 133, 120, 116, 95, 49, 193, 178, 35, 248, 17, 25, 67, 159, 128,
+        158, 187, 18, 223, 207, 123, 196, 1, 198, 140, 221, 68, 100, 11, 122, 255, 118, 234, 72,
+        121, 57, 235, 13, 4, 21, 46, 113, 15, 143, 44, 231, 249, 215, 165, 31, 227, 228, 169, 52,
+        16, 84, 184, 195, 60, 58, 176, 153, 225, 89, 146, 124, 137, 141, 162, 208, 64, 79, 222, 9,
+        240, 232, 190, 98, 129, 99, 70, 239, 34, 50, 134, 61, 256, 59, 117, 36, 189, 157, 246, 135,
+        2, 139, 23, 185, 136, 200, 22, 244, 253, 236, 211, 144, 242, 114, 213, 26, 8, 42, 92, 226,
+        30, 29, 88, 205, 241, 173, 73, 62, 197, 199, 81, 104, 32, 168, 111, 133, 120, 116, 95, 49,
+        193, 178, 35, 248, 17, 25, 67, 159, 128, 158, 187, 18, 223, 207, 123, 196, 1,
+    ],
+    [
+        1, 199, 23, 208, 15, 158, 88, 36, 225, 57, 35, 26, 34, 84, 11, 133, 253, 232, 165, 196, 197,
+        139, 162, 113, 128, 29, 117, 153, 121, 178, 213, 239, 16, 100, 111, 244, 240, 215, 123, 62,
+        2, 141, 46, 159, 30, 59, 176, 72, 193, 114, 70, 52, 68, 168, 22, 9, 249, 207, 73, 135, 137,
+        21, 67, 226, 256, 58, 234, 49, 242, 99, 169, 221, 32, 200, 222, 231, 223, 173, 246, 124, 4,
+        25, 92, 61, 60, 118, 95, 144, 129, 228, 140, 104, 136, 79, 44, 18, 241, 157, 146, 13, 17,
+        42, 134, 195, 255, 116, 211, 98, 227, 198, 81, 185, 64, 143, 187, 205, 189, 89, 235, 248, 8,
+        50, 184, 122, 120, 236, 190, 31, 1, 199, 23, 208, 15, 158, 88, 36, 225, 57, 35, 26, 34, 84,
+        11, 133, 253, 232, 165, 196, 197, 139, 162, 113, 128, 29, 117, 153, 121, 178, 213, 239, 16,
+        100, 111, 244, 240, 215, 123, 62, 2, 141, 46, 159, 30, 59, 176, 72, 193, 114, 70, 52, 68,
+        168, 22, 9, 249, 207, 73, 135, 137, 21, 67, 226, 256, 58, 234, 49, 242, 99, 169, 221, 32,
+        200, 222, 231, 223, 173, 246, 124, 4, 25, 92, 61, 60, 118, 95, 144, 129, 228, 140, 104, 136,
+        79, 44, 18, 241, 157, 146, 13, 17, 42, 134, 195, 255, 116, 211, 98, 227, 198, 81, 185, 64,
+        143, 187, 205, 189, 89, 235, 248, 8, 50, 184, 122, 120, 236, 190, 31, 1,
+    ],
+    [
+        1, 200, 165, 104, 240, 198, 22, 31, 32, 232, 140, 244, 227, 168, 190, 221, 253, 228, 111,
+        98, 68, 236, 169, 133, 129, 100, 211, 52, 120, 99, 11, 144, 16, 116, 70, 122, 242, 84, 95,
+        239, 255, 114, 184, 49, 34, 118, 213, 195, 193, 50, 234, 26, 60, 178, 134, 72, 8, 58, 35,
+        61, 121, 42, 176, 248, 256, 57, 92, 153, 17, 59, 235, 226, 225, 25, 117, 13, 30, 89, 67, 36,
+        4, 29, 146, 159, 189, 21, 88, 124, 128, 157, 46, 205, 137, 158, 246, 113, 241, 141, 187,
+        135, 15, 173, 162, 18, 2, 143, 73, 208, 223, 139, 44, 62, 64, 207, 23, 231, 197, 79, 123,
+        185, 249, 199, 222, 196, 136, 215, 81, 9, 1, 200, 165, 104, 240, 198, 22, 31, 32, 232, 140,
+        244, 227, 168, 190, 221, 253, 228, 111, 98, 68, 236, 169, 133, 129, 100, 211, 52, 120, 99,
+        11, 144, 16, 116, 70, 122, 242, 84, 95, 239, 255, 114, 184, 49, 34, 118, 213, 195, 193, 50,
+        234, 26, 60, 178, 134, 72, 8, 58, 35, 61, 121, 42, 176, 248, 256, 57, 92, 153, 17, 59, 235,
+        226, 225, 25, 117, 13, 30, 89, 67, 36, 4, 29, 146, 159, 189, 21, 88, 124, 128, 157, 46, 205,
+        137, 158, 246, 113, 241, 141, 187, 135, 15, 173, 162, 18, 2, 143, 73, 208, 223, 139, 44, 62,
+        64, 207, 23, 231, 197, 79, 123, 185, 249, 199, 222, 196, 136, 215, 81, 9, 1,
+    ],
+    [
+        1, 201, 52, 172, 134, 206, 29, 175, 223, 105, 31, 63, 70, 192, 42, 218, 128, 28, 231, 171,
+        190, 154, 114, 41, 17, 76, 113, 97, 222, 161, 236, 148, 193, 243, 13, 43, 162, 180, 200,
+        108, 120, 219, 72, 80, 146, 48, 139, 183, 32, 7, 122, 107, 176, 167, 157, 203, 197, 19, 221,
+        217, 184, 233, 59, 37, 241, 125, 196, 75, 169, 45, 50, 27, 30, 119, 18, 20, 165, 12, 99,
+        110, 8, 66, 159, 91, 44, 106, 232, 115, 242, 69, 248, 247, 46, 251, 79, 202, 253, 224, 49,
+        83, 235, 204, 141, 71, 136, 94, 133, 5, 234, 3, 89, 156, 2, 145, 104, 87, 11, 155, 58, 93,
+        189, 210, 62, 126, 140, 127, 84, 179, 256, 56, 205, 85, 123, 51, 228, 82, 34, 152, 226, 194,
+        187, 65, 215, 39, 129, 229, 26, 86, 67, 103, 143, 216, 240, 181, 144, 160, 35, 96, 21, 109,
+        64, 14, 244, 214, 95, 77, 57, 149, 137, 38, 185, 177, 111, 209, 118, 74, 225, 250, 135, 150,
+        81, 90, 100, 54, 60, 238, 36, 40, 73, 24, 198, 220, 16, 132, 61, 182, 88, 212, 207, 230,
+        227, 138, 239, 237, 92, 245, 158, 147, 249, 191, 98, 166, 213, 151, 25, 142, 15, 188, 9, 10,
+        211, 6, 178, 55, 4, 33, 208, 174, 22, 53, 116, 186, 121, 163, 124, 252, 23, 254, 168, 101,
+        255, 112, 153, 170, 246, 102, 199, 164, 68, 47, 195, 131, 117, 130, 173, 78, 1,
+    ],
+    [
+        1, 202, 198, 161, 140, 10, 221, 181, 68, 115, 100, 154, 11, 166, 122, 229, 255, 110, 118,
+        192, 234, 237, 72, 152, 121, 27, 57, 206, 235, 182, 13, 56, 4, 37, 21, 130, 46, 40, 113,
+        210, 15, 203, 143, 102, 44, 150, 231, 145, 249, 183, 215, 254, 165, 177, 31, 94, 227, 108,
+        228, 53, 169, 214, 52, 224, 16, 148, 84, 6, 184, 160, 195, 69, 60, 41, 58, 151, 176, 86,
+        153, 66, 225, 218, 89, 245, 146, 194, 124, 119, 137, 175, 141, 212, 162, 85, 208, 125, 64,
+        78, 79, 24, 222, 126, 9, 19, 240, 164, 232, 90, 190, 87, 98, 7, 129, 101, 99, 209, 70, 5,
+        239, 219, 34, 186, 50, 77, 134, 83, 61, 243, 256, 55, 59, 96, 117, 247, 36, 76, 189, 142,
+        157, 103, 246, 91, 135, 28, 2, 147, 139, 65, 23, 20, 185, 105, 136, 230, 200, 51, 22, 75,
+        244, 201, 253, 220, 236, 127, 211, 217, 144, 47, 242, 54, 114, 155, 213, 107, 26, 112, 8,
+        74, 42, 3, 92, 80, 226, 163, 30, 149, 29, 204, 88, 43, 205, 33, 241, 109, 173, 251, 73, 97,
+        62, 188, 197, 216, 199, 106, 81, 171, 104, 191, 32, 39, 168, 12, 111, 63, 133, 138, 120, 82,
+        116, 45, 95, 172, 49, 132, 193, 179, 178, 233, 35, 131, 248, 238, 17, 93, 25, 167, 67, 170,
+        159, 250, 128, 156, 158, 48, 187, 252, 18, 38, 223, 71, 207, 180, 123, 174, 196, 14, 1,
+    ],
+    [
+        1, 203, 89, 77, 211, 171, 18, 56, 60, 101, 200, 251, 67, 237, 52, 19, 2, 149, 178, 154, 165,
+        85, 36, 112, 120, 202, 143, 245, 134, 217, 104, 38, 4, 41, 99, 51, 73, 170, 72, 224, 240,
+        147, 29, 233, 11, 177, 208, 76, 8, 82, 198, 102, 146, 83, 144, 191, 223, 37, 58, 209, 22,
+        97, 159, 152, 16, 164, 139, 204, 35, 166, 31, 125, 189, 74, 116, 161, 44, 194, 61, 47, 32,
+        71, 21, 151, 70, 75, 62, 250, 121, 148, 232, 65, 88, 131, 122, 94, 64, 142, 42, 45, 140,
+        150, 124, 243, 242, 39, 207, 130, 176, 5, 244, 188, 128, 27, 84, 90, 23, 43, 248, 229, 227,
+        78, 157, 3, 95, 10, 231, 119, 256, 54, 168, 180, 46, 86, 239, 201, 197, 156, 57, 6, 190, 20,
+        205, 238, 255, 108, 79, 103, 92, 172, 221, 145, 137, 55, 114, 12, 123, 40, 153, 219, 253,
+        216, 158, 206, 184, 87, 185, 33, 17, 110, 228, 24, 246, 80, 49, 181, 249, 175, 59, 155, 111,
+        174, 113, 66, 34, 220, 199, 48, 235, 160, 98, 105, 241, 93, 118, 53, 222, 91, 226, 132, 68,
+        183, 141, 96, 213, 63, 196, 210, 225, 186, 236, 106, 187, 182, 195, 7, 136, 109, 25, 192,
+        169, 126, 135, 163, 193, 115, 215, 212, 117, 107, 133, 14, 15, 218, 50, 127, 81, 252, 13,
+        69, 129, 230, 173, 167, 234, 214, 9, 28, 30, 179, 100, 254, 162, 247, 26, 138, 1,
+    ],
+    [
+        1, 204, 239, 183, 67, 47, 79, 182, 120, 65, 153, 115, 73, 243, 228, 252, 8, 90, 113, 179,
+        22, 119, 118, 171, 189, 6, 196, 149, 70, 145, 25, 217, 64, 206, 133, 147, 176, 181, 173, 83,
+        227, 48, 26, 164, 46, 132, 200, 194, 255, 106, 36, 148, 123, 163, 99, 150, 17, 127, 208, 27,
+        111, 28, 58, 10, 241, 77, 31, 156, 213, 19, 21, 172, 136, 245, 122, 216, 117, 224, 207, 80,
+        129, 102, 248, 220, 162, 152, 168, 91, 60, 161, 205, 186, 165, 250, 114, 126, 4, 45, 185,
+        218, 11, 188, 59, 214, 223, 3, 98, 203, 35, 201, 141, 237, 32, 103, 195, 202, 88, 219, 215,
+        170, 242, 24, 13, 82, 23, 66, 100, 97, 256, 53, 18, 74, 190, 210, 178, 75, 137, 192, 104,
+        142, 184, 14, 29, 5, 249, 167, 144, 78, 235, 138, 139, 86, 68, 251, 61, 108, 187, 112, 232,
+        40, 193, 51, 124, 110, 81, 76, 84, 174, 30, 209, 231, 93, 211, 125, 57, 63, 2, 151, 221,
+        109, 134, 94, 158, 107, 240, 130, 49, 230, 146, 229, 199, 247, 16, 180, 226, 101, 44, 238,
+        236, 85, 121, 12, 135, 41, 140, 33, 50, 177, 128, 155, 9, 37, 95, 105, 89, 166, 197, 96, 52,
+        71, 92, 7, 143, 131, 253, 212, 72, 39, 246, 69, 198, 43, 34, 254, 159, 54, 222, 56, 116, 20,
+        225, 154, 62, 55, 169, 38, 42, 87, 15, 233, 244, 175, 234, 191, 157, 160, 1,
+    ],
+    [
+        1, 205, 134, 228, 223, 226, 70, 215, 128, 26, 190, 143, 17, 144, 222, 21, 193, 244, 162, 57,
+        120, 185, 146, 118, 32, 135, 176, 100, 197, 36, 184, 198, 241, 61, 169, 207, 30, 239, 165,
+        158, 8, 98, 44, 25, 242, 9, 46, 178, 253, 208, 235, 116, 136, 124, 234, 168, 2, 153, 11,
+        199, 189, 195, 140, 173, 256, 52, 123, 29, 34, 31, 187, 42, 129, 231, 67, 114, 240, 113, 35,
+        236, 64, 13, 95, 200, 137, 72, 111, 139, 225, 122, 81, 157, 60, 221, 73, 59, 16, 196, 88,
+        50, 227, 18, 92, 99, 249, 159, 213, 232, 15, 248, 211, 79, 4, 49, 22, 141, 121, 133, 23, 89,
+        255, 104, 246, 58, 68, 62, 117, 84, 1, 205, 134, 228, 223, 226, 70, 215, 128, 26, 190, 143,
+        17, 144, 222, 21, 193, 244, 162, 57, 120, 185, 146, 118, 32, 135, 176, 100, 197, 36, 184,
+        198, 241, 61, 169, 207, 30, 239, 165, 158, 8, 98, 44, 25, 242, 9, 46, 178, 253, 208, 235,
+        116, 136, 124, 234, 168, 2, 153, 11, 199, 189, 195, 140, 173, 256, 52, 123, 29, 34, 31, 187,
+        42, 129, 231, 67, 114, 240, 113, 35, 236, 64, 13, 95, 200, 137, 72, 111, 139, 225, 122, 81,
+        157, 60, 221, 73, 59, 16, 196, 88, 50, 227, 18, 92, 99, 249, 159, 213, 232, 15, 248, 211,
+        79, 4, 49, 22, 141, 121, 133, 23, 89, 255, 104, 246, 58, 68, 62, 117, 84, 1,
+    ],
+    [
+        1, 206, 31, 218, 190, 76, 236, 43, 120, 48, 122, 203, 184, 125, 50, 20, 8, 106, 248, 202,
+        235, 94, 89, 87, 189, 127, 205, 82, 187, 229, 143, 160, 64, 77, 185, 74, 81, 238, 198, 182,
+        227, 245, 98, 142, 211, 33, 116, 252, 255, 102, 195, 78, 134, 105, 42, 171, 17, 161, 13,
+        108, 146, 7, 157, 217, 241, 45, 18, 110, 44, 69, 79, 83, 136, 3, 104, 93, 140, 56, 228, 194,
+        129, 103, 144, 109, 95, 38, 118, 150, 60, 24, 61, 230, 92, 191, 25, 10, 4, 53, 124, 101,
+        246, 47, 173, 172, 223, 192, 231, 41, 222, 243, 200, 80, 32, 167, 221, 37, 169, 119, 99, 91,
+        242, 251, 49, 71, 234, 145, 58, 126, 256, 51, 226, 39, 67, 181, 21, 214, 137, 209, 135, 54,
+        73, 132, 207, 237, 249, 151, 9, 55, 22, 163, 168, 170, 68, 130, 52, 175, 70, 28, 114, 97,
+        193, 180, 72, 183, 176, 19, 59, 75, 30, 12, 159, 115, 46, 224, 141, 5, 2, 155, 62, 179, 123,
+        152, 215, 86, 240, 96, 244, 149, 111, 250, 100, 40, 16, 212, 239, 147, 213, 188, 178, 174,
+        121, 254, 153, 164, 117, 201, 29, 63, 128, 154, 113, 148, 162, 219, 139, 107, 197, 233, 196,
+        27, 165, 66, 232, 247, 253, 204, 133, 156, 11, 210, 84, 85, 34, 65, 26, 216, 35, 14, 57,
+        177, 225, 90, 36, 220, 88, 138, 158, 166, 15, 6, 208, 186, 23, 112, 199, 131, 1,
+    ],
+    [
+        1, 207, 187, 159, 17, 178, 95, 133, 32, 199, 73, 205, 30, 42, 213, 144, 253, 200, 23, 135,
+        189, 59, 134, 239, 129, 232, 222, 208, 137, 89, 176, 195, 16, 228, 165, 231, 15, 21, 235,
+        72, 255, 100, 140, 196, 223, 158, 67, 248, 193, 116, 111, 104, 197, 173, 88, 226, 8, 114,
+        211, 244, 136, 139, 246, 36, 256, 50, 70, 98, 240, 79, 162, 124, 225, 58, 184, 52, 227, 215,
+        44, 113, 4, 57, 234, 122, 68, 198, 123, 18, 128, 25, 35, 49, 120, 168, 81, 62, 241, 29, 92,
+        26, 242, 236, 22, 185, 2, 157, 117, 61, 34, 99, 190, 9, 64, 141, 146, 153, 60, 84, 169, 31,
+        249, 143, 46, 13, 121, 118, 11, 221, 1, 207, 187, 159, 17, 178, 95, 133, 32, 199, 73, 205,
+        30, 42, 213, 144, 253, 200, 23, 135, 189, 59, 134, 239, 129, 232, 222, 208, 137, 89, 176,
+        195, 16, 228, 165, 231, 15, 21, 235, 72, 255, 100, 140, 196, 223, 158, 67, 248, 193, 116,
+        111, 104, 197, 173, 88, 226, 8, 114, 211, 244, 136, 139, 246, 36, 256, 50, 70, 98, 240, 79,
+        162, 124, 225, 58, 184, 52, 227, 215, 44, 113, 4, 57, 234, 122, 68, 198, 123, 18, 128, 25,
+        35, 49, 120, 168, 81, 62, 241, 29, 92, 26, 242, 236, 22, 185, 2, 157, 117, 61, 34, 99, 190,
+        9, 64, 141, 146, 153, 60, 84, 169, 31, 249, 143, 46, 13, 121, 118, 11, 221, 1,
+    ],
+    [
+        1, 208, 88, 57, 34, 133, 165, 139, 128, 153, 213, 100, 240, 62, 46, 59, 193, 52, 22, 207,
+        137, 226, 234, 99, 32, 231, 246, 25, 60, 144, 140, 79, 241, 13, 134, 116, 227, 185, 187, 89,
+        8, 122, 190, 199, 15, 36, 35, 84, 253, 196, 162, 29, 121, 239, 111, 215, 2, 159, 176, 114,
+        68, 9, 73, 21, 256, 49, 169, 200, 223, 124, 92, 118, 129, 104, 44, 157, 17, 195, 211, 198,
+        64, 205, 235, 50, 120, 31, 23, 158, 225, 26, 11, 232, 197, 113, 117, 178, 16, 244, 123, 141,
+        30, 72, 70, 168, 249, 135, 67, 58, 242, 221, 222, 173, 4, 61, 95, 228, 136, 18, 146, 42,
+        255, 98, 81, 143, 189, 248, 184, 236, 1, 208, 88, 57, 34, 133, 165, 139, 128, 153, 213, 100,
+        240, 62, 46, 59, 193, 52, 22, 207, 137, 226, 234, 99, 32, 231, 246, 25, 60, 144, 140, 79,
+        241, 13, 134, 116, 227, 185, 187, 89, 8, 122, 190, 199, 15, 36, 35, 84, 253, 196, 162, 29,
+        121, 239, 111, 215, 2, 159, 176, 114, 68, 9, 73, 21, 256, 49, 169, 200, 223, 124, 92, 118,
+        129, 104, 44, 157, 17, 195, 211, 198, 64, 205, 235, 50, 120, 31, 23, 158, 225, 26, 11, 232,
+        197, 113, 117, 178, 16, 244, 123, 141, 30, 72, 70, 168, 249, 135, 67, 58, 242, 221, 222,
+        173, 4, 61, 95, 228, 136, 18, 146, 42, 255, 98, 81, 143, 189, 248, 184, 236, 1,
+    ],
+    [
+        1, 209, 248, 175, 81, 224, 42, 40, 136, 154, 61, 156, 222, 138, 58, 43, 249, 127, 72, 142,
+        123, 7, 178, 194, 197, 53, 26, 37, 23, 181, 50, 170, 64, 12, 195, 149, 44, 201, 118, 247,
+        223, 90, 49, 218, 73, 94, 114, 182, 2, 161, 239, 93, 162, 191, 84, 80, 15, 51, 122, 55, 187,
+        19, 116, 86, 241, 254, 144, 27, 246, 14, 99, 131, 137, 106, 52, 74, 46, 105, 100, 83, 128,
+        24, 133, 41, 88, 145, 236, 237, 189, 180, 98, 179, 146, 188, 228, 107, 4, 65, 221, 186, 67,
+        125, 168, 160, 30, 102, 244, 110, 117, 38, 232, 172, 225, 251, 31, 54, 235, 28, 198, 5, 17,
+        212, 104, 148, 92, 210, 200, 166, 256, 48, 9, 82, 176, 33, 215, 217, 121, 103, 196, 101, 35,
+        119, 199, 214, 8, 130, 185, 115, 134, 250, 79, 63, 60, 204, 231, 220, 234, 76, 207, 87, 193,
+        245, 62, 108, 213, 56, 139, 10, 34, 167, 208, 39, 184, 163, 143, 75, 255, 96, 18, 164, 95,
+        66, 173, 177, 242, 206, 135, 202, 70, 238, 141, 171, 16, 3, 113, 230, 11, 243, 158, 126,
+        120, 151, 205, 183, 211, 152, 157, 174, 129, 233, 124, 216, 169, 112, 21, 20, 68, 77, 159,
+        78, 111, 69, 29, 150, 253, 192, 36, 71, 190, 132, 89, 97, 227, 155, 13, 147, 140, 219, 25,
+        85, 32, 6, 226, 203, 22, 229, 59, 252, 240, 45, 153, 109, 165, 47, 57, 91, 1,
+    ],
+    [
+        1, 210, 153, 5, 22, 251, 25, 110, 227, 125, 36, 107, 111, 180, 21, 41, 129, 105, 205, 131,
+        11, 254, 141, 55, 242, 191, 18, 182, 184, 90, 139, 149, 193, 181, 231, 194, 134, 127, 199,
+        156, 121, 224, 9, 91, 92, 45, 198, 203, 225, 219, 244, 97, 67, 192, 228, 78, 189, 112, 133,
+        174, 46, 151, 99, 230, 241, 238, 122, 177, 162, 96, 114, 39, 223, 56, 195, 87, 23, 204, 178,
+        115, 249, 119, 61, 217, 81, 48, 57, 148, 240, 28, 226, 172, 140, 102, 89, 186, 253, 188,
+        159, 237, 169, 24, 157, 74, 120, 14, 113, 86, 70, 51, 173, 93, 255, 94, 208, 247, 213, 12,
+        207, 37, 60, 7, 185, 43, 35, 154, 215, 175, 256, 47, 104, 252, 235, 6, 232, 147, 30, 132,
+        221, 150, 146, 77, 236, 216, 128, 152, 52, 126, 246, 3, 116, 202, 15, 66, 239, 75, 73, 167,
+        118, 108, 64, 76, 26, 63, 123, 130, 58, 101, 136, 33, 248, 166, 165, 212, 59, 54, 32, 38,
+        13, 160, 190, 65, 29, 179, 68, 145, 124, 83, 211, 106, 158, 27, 16, 19, 135, 80, 95, 161,
+        143, 218, 34, 201, 62, 170, 234, 53, 79, 142, 8, 138, 196, 40, 176, 209, 200, 109, 17, 229,
+        31, 85, 117, 155, 168, 71, 4, 69, 98, 20, 88, 233, 100, 183, 137, 243, 144, 171, 187, 206,
+        84, 164, 2, 163, 49, 10, 44, 245, 50, 220, 197, 250, 72, 214, 222, 103, 42, 82, 1,
+    ],
+    [
+        1, 211, 60, 67, 2, 165, 120, 134, 4, 73, 240, 11, 8, 146, 223, 22, 16, 35, 189, 44, 32, 70,
+        121, 88, 64, 140, 242, 176, 128, 23, 227, 95, 256, 46, 197, 190, 255, 92, 137, 123, 253,
+        184, 17, 246, 249, 111, 34, 235, 241, 222, 68, 213, 225, 187, 136, 169, 193, 117, 15, 81,
+        129, 234, 30, 162, 1, 211, 60, 67, 2, 165, 120, 134, 4, 73, 240, 11, 8, 146, 223, 22, 16,
+        35, 189, 44, 32, 70, 121, 88, 64, 140, 242, 176, 128, 23, 227, 95, 256, 46, 197, 190, 255,
+        92, 137, 123, 253, 184, 17, 246, 249, 111, 34, 235, 241, 222, 68, 213, 225, 187, 136, 169,
+        193, 117, 15, 81, 129, 234, 30, 162, 1, 211, 60, 67, 2, 165, 120, 134, 4, 73, 240, 11, 8,
+        146, 223, 22, 16, 35, 189, 44, 32, 70, 121, 88, 64, 140, 242, 176, 128, 23, 227, 95, 256,
+        46, 197, 190, 255, 92, 137, 123, 253, 184, 17, 246, 249, 111, 34, 235, 241, 222, 68, 213,
+        225, 187, 136, 169, 193, 117, 15, 81, 129, 234, 30, 162, 1, 211, 60, 67, 2, 165, 120, 134,
+        4, 73, 240, 11, 8, 146, 223, 22, 16, 35, 189, 44, 32, 70, 121, 88, 64, 140, 242, 176, 128,
+        23, 227, 95, 256, 46, 197, 190, 255, 92, 137, 123, 253, 184, 17, 246, 249, 111, 34, 235,
+        241, 222, 68, 213, 225, 187, 136, 169, 193, 117, 15, 81, 129, 234, 30, 162, 1,
+    ],
+    [
+        1, 212, 226, 110, 190, 188, 21, 83, 120, 254, 135, 93, 184, 201, 207, 194, 8, 154, 9, 109,
+        235, 219, 168, 150, 189, 233, 52, 230, 187, 66, 114, 10, 64, 204, 72, 101, 81, 210, 59, 172,
+        227, 65, 159, 41, 211, 14, 141, 80, 255, 90, 62, 37, 134, 138, 215, 91, 17, 6, 244, 71, 146,
+        112, 100, 126, 241, 206, 239, 39, 44, 76, 178, 214, 136, 48, 153, 54, 140, 125, 29, 237,
+        129, 106, 113, 55, 95, 94, 139, 170, 60, 127, 196, 175, 92, 229, 232, 97, 4, 77, 133, 183,
+        246, 238, 84, 75, 223, 245, 26, 115, 222, 33, 57, 5, 32, 102, 36, 179, 169, 105, 158, 86,
+        242, 161, 208, 149, 234, 7, 199, 40, 256, 45, 31, 147, 67, 69, 236, 174, 137, 3, 122, 164,
+        73, 56, 50, 63, 249, 103, 248, 148, 22, 38, 89, 107, 68, 24, 205, 27, 70, 191, 143, 247,
+        193, 53, 185, 156, 176, 47, 198, 85, 30, 192, 98, 216, 46, 243, 116, 177, 2, 167, 195, 220,
+        123, 119, 42, 166, 240, 251, 13, 186, 111, 145, 157, 131, 16, 51, 18, 218, 213, 181, 79, 43,
+        121, 209, 104, 203, 117, 132, 228, 20, 128, 151, 144, 202, 162, 163, 118, 87, 197, 130, 61,
+        82, 165, 28, 25, 160, 253, 180, 124, 74, 11, 19, 173, 182, 34, 12, 231, 142, 35, 224, 200,
+        252, 225, 155, 221, 78, 88, 152, 99, 171, 15, 96, 49, 108, 23, 250, 58, 217, 1,
+    ],
+    [
+        1, 213, 137, 140, 8, 162, 68, 92, 64, 11, 30, 222, 255, 88, 240, 234, 241, 190, 121, 73,
+        129, 235, 197, 70, 4, 81, 34, 46, 32, 134, 15, 111, 256, 44, 120, 117, 249, 95, 189, 165,
+        193, 246, 227, 35, 2, 169, 17, 23, 16, 67, 136, 184, 128, 22, 60, 187, 253, 176, 223, 211,
+        225, 123, 242, 146, 1, 213, 137, 140, 8, 162, 68, 92, 64, 11, 30, 222, 255, 88, 240, 234,
+        241, 190, 121, 73, 129, 235, 197, 70, 4, 81, 34, 46, 32, 134, 15, 111, 256, 44, 120, 117,
+        249, 95, 189, 165, 193, 246, 227, 35, 2, 169, 17, 23, 16, 67, 136, 184, 128, 22, 60, 187,
+        253, 176, 223, 211, 225, 123, 242, 146, 1, 213, 137, 140, 8, 162, 68, 92, 64, 11, 30, 222,
+        255, 88, 240, 234, 241, 190, 121, 73, 129, 235, 197, 70, 4, 81, 34, 46, 32, 134, 15, 111,
+        256, 44, 120, 117, 249, 95, 189, 165, 193, 246, 227, 35, 2, 169, 17, 23, 16, 67, 136, 184,
+        128, 22, 60, 187, 253, 176, 223, 211, 225, 123, 242, 146, 1, 213, 137, 140, 8, 162, 68, 92,
+        64, 11, 30, 222, 255, 88, 240, 234, 241, 190, 121, 73, 129, 235, 197, 70, 4, 81, 34, 46, 32,
+        134, 15, 111, 256, 44, 120, 117, 249, 95, 189, 165, 193, 246, 227, 35, 2, 169, 17, 23, 16,
+        67, 136, 184, 128, 22, 60, 187, 253, 176, 223, 211, 225, 123, 242, 146, 1,
+    ],
+    [
+        1, 214, 50, 163, 187, 183, 98, 155, 17, 40, 79, 201, 95, 27, 124, 65, 32, 166, 58, 76, 73,
+        202, 52, 77, 30, 252, 215, 7, 213, 93, 113, 24, 253, 172, 57, 119, 23, 39, 122, 151, 189,
+        97, 198, 224, 134, 149, 18, 254, 129, 107, 25, 210, 222, 220, 49, 206, 137, 20, 168, 229,
+        176, 142, 62, 161, 16, 83, 29, 38, 165, 101, 26, 167, 15, 126, 236, 132, 235, 175, 185, 12,
+        255, 86, 157, 188, 140, 148, 61, 204, 223, 177, 99, 112, 67, 203, 9, 127, 193, 182, 141,
+        105, 111, 110, 153, 103, 197, 10, 84, 243, 88, 71, 31, 209, 8, 170, 143, 19, 211, 179, 13,
+        212, 136, 63, 118, 66, 246, 216, 221, 6, 256, 43, 207, 94, 70, 74, 159, 102, 240, 217, 178,
+        56, 162, 230, 133, 192, 225, 91, 199, 181, 184, 55, 205, 180, 227, 5, 42, 250, 44, 164, 144,
+        233, 4, 85, 200, 138, 234, 218, 135, 106, 68, 160, 59, 33, 123, 108, 239, 3, 128, 150, 232,
+        47, 35, 37, 208, 51, 120, 237, 89, 28, 81, 115, 195, 96, 241, 174, 228, 219, 92, 156, 231,
+        90, 242, 131, 21, 125, 22, 82, 72, 245, 2, 171, 100, 69, 117, 109, 196, 53, 34, 80, 158,
+        145, 190, 54, 248, 130, 64, 75, 116, 152, 146, 147, 104, 154, 60, 247, 173, 14, 169, 186,
+        226, 48, 249, 87, 114, 238, 46, 78, 244, 45, 121, 194, 139, 191, 11, 41, 36, 251, 1,
+    ],
+    [
+        1, 215, 222, 185, 197, 207, 44, 208, 2, 173, 187, 113, 137, 157, 88, 159, 4, 89, 117, 226,
+        17, 57, 176, 61, 8, 178, 234, 195, 34, 114, 95, 122, 16, 99, 211, 133, 68, 228, 190, 244,
+        32, 198, 165, 9, 136, 199, 123, 231, 64, 139, 73, 18, 15, 141, 246, 205, 128, 21, 146, 36,
+        30, 25, 235, 153, 256, 42, 35, 72, 60, 50, 213, 49, 255, 84, 70, 144, 120, 100, 169, 98,
+        253, 168, 140, 31, 240, 200, 81, 196, 249, 79, 23, 62, 223, 143, 162, 135, 241, 158, 46,
+        124, 189, 29, 67, 13, 225, 59, 92, 248, 121, 58, 134, 26, 193, 118, 184, 239, 242, 116, 11,
+        52, 129, 236, 111, 221, 227, 232, 22, 104, 1, 215, 222, 185, 197, 207, 44, 208, 2, 173, 187,
+        113, 137, 157, 88, 159, 4, 89, 117, 226, 17, 57, 176, 61, 8, 178, 234, 195, 34, 114, 95,
+        122, 16, 99, 211, 133, 68, 228, 190, 244, 32, 198, 165, 9, 136, 199, 123, 231, 64, 139, 73,
+        18, 15, 141, 246, 205, 128, 21, 146, 36, 30, 25, 235, 153, 256, 42, 35, 72, 60, 50, 213, 49,
+        255, 84, 70, 144, 120, 100, 169, 98, 253, 168, 140, 31, 240, 200, 81, 196, 249, 79, 23, 62,
+        223, 143, 162, 135, 241, 158, 46, 124, 189, 29, 67, 13, 225, 59, 92, 248, 121, 58, 134, 26,
+        193, 118, 184, 239, 242, 116, 11, 52, 129, 236, 111, 221, 227, 232, 22, 104, 1,
+    ],
+    [
+        1, 216, 139, 212, 46, 170, 226, 243, 60, 110, 116, 127, 190, 177, 196, 188, 2, 175, 21, 167,
+        92, 83, 195, 229, 120, 220, 232, 254, 123, 97, 135, 119, 4, 93, 42, 77, 184, 166, 133, 201,
+        240, 183, 207, 251, 246, 194, 13, 238, 8, 186, 84, 154, 111, 75, 9, 145, 223, 109, 157, 245,
+        235, 131, 26, 219, 16, 115, 168, 51, 222, 150, 18, 33, 189, 218, 57, 233, 213, 5, 52, 181,
+        32, 230, 79, 102, 187, 43, 36, 66, 121, 179, 114, 209, 169, 10, 104, 105, 64, 203, 158, 204,
+        117, 86, 72, 132, 242, 101, 228, 161, 81, 20, 208, 210, 128, 149, 59, 151, 234, 172, 144, 7,
+        227, 202, 199, 65, 162, 40, 159, 163, 256, 41, 118, 45, 211, 87, 31, 14, 197, 147, 141, 130,
+        67, 80, 61, 69, 255, 82, 236, 90, 165, 174, 62, 28, 137, 37, 25, 3, 134, 160, 122, 138, 253,
+        164, 215, 180, 73, 91, 124, 56, 17, 74, 50, 6, 11, 63, 244, 19, 249, 71, 173, 103, 146, 182,
+        248, 112, 34, 148, 100, 12, 22, 126, 231, 38, 241, 142, 89, 206, 35, 107, 239, 224, 68, 39,
+        200, 24, 44, 252, 205, 76, 225, 27, 178, 155, 70, 214, 221, 191, 136, 78, 143, 48, 88, 247,
+        153, 152, 193, 54, 99, 53, 140, 171, 185, 125, 15, 156, 29, 96, 176, 237, 49, 47, 129, 108,
+        198, 106, 23, 85, 113, 250, 30, 55, 58, 192, 95, 217, 98, 94, 1,
+    ],
+    [
+        1, 217, 58, 250, 23, 108, 49, 96, 15, 171, 99, 152, 88, 78, 221, 155, 225, 252, 200, 224,
+        35, 142, 231, 12, 34, 182, 173, 19, 11, 74, 124, 180, 253, 160, 25, 28, 165, 82, 61, 130,
+        197, 87, 118, 163, 162, 202, 144, 151, 128, 20, 228, 132, 117, 203, 104, 209, 121, 43, 79,
+        181, 213, 218, 18, 51, 16, 131, 157, 145, 111, 186, 13, 251, 240, 166, 42, 119, 123, 220,
+        195, 167, 2, 177, 116, 243, 46, 216, 98, 192, 30, 85, 198, 47, 176, 156, 185, 53, 193, 247,
+        143, 191, 70, 27, 205, 24, 68, 107, 89, 38, 22, 148, 248, 103, 249, 63, 50, 56, 73, 164,
+        122, 3, 137, 174, 236, 69, 67, 147, 31, 45, 256, 40, 199, 7, 234, 149, 208, 161, 242, 86,
+        158, 105, 169, 179, 36, 102, 32, 5, 57, 33, 222, 115, 26, 245, 223, 75, 84, 238, 246, 183,
+        133, 77, 4, 97, 232, 229, 92, 175, 196, 127, 60, 170, 139, 94, 95, 55, 113, 106, 129, 237,
+        29, 125, 140, 54, 153, 48, 136, 214, 178, 76, 44, 39, 239, 206, 241, 126, 100, 112, 146, 71,
+        244, 6, 17, 91, 215, 138, 134, 37, 62, 90, 255, 80, 141, 14, 211, 41, 159, 65, 227, 172, 59,
+        210, 81, 101, 72, 204, 64, 10, 114, 66, 187, 230, 52, 233, 189, 150, 168, 219, 235, 109, 9,
+        154, 8, 194, 207, 201, 184, 93, 135, 254, 120, 83, 21, 188, 190, 110, 226, 212, 1,
+    ],
+    [
+        1, 218, 236, 48, 184, 20, 248, 94, 189, 82, 143, 77, 81, 182, 98, 33, 255, 78, 42, 161, 146,
+        217, 18, 69, 136, 93, 228, 103, 95, 150, 61, 191, 4, 101, 173, 192, 222, 80, 221, 119, 242,
+        71, 58, 51, 67, 214, 135, 132, 249, 55, 168, 130, 70, 97, 72, 19, 30, 115, 141, 155, 123,
+        86, 244, 250, 16, 147, 178, 254, 117, 63, 113, 219, 197, 27, 232, 204, 11, 85, 26, 14, 225,
+        220, 158, 6, 23, 131, 31, 76, 120, 203, 50, 106, 235, 87, 205, 229, 64, 74, 198, 245, 211,
+        252, 195, 105, 17, 108, 157, 45, 44, 83, 104, 56, 129, 109, 118, 24, 92, 10, 124, 47, 223,
+        41, 200, 167, 169, 91, 49, 145, 256, 39, 21, 209, 73, 237, 9, 163, 68, 175, 114, 180, 176,
+        75, 159, 224, 2, 179, 215, 96, 111, 40, 239, 188, 121, 164, 29, 154, 162, 107, 196, 66, 253,
+        156, 84, 65, 35, 177, 36, 138, 15, 186, 199, 206, 190, 43, 122, 125, 8, 202, 89, 127, 187,
+        160, 185, 238, 227, 142, 116, 102, 134, 171, 13, 7, 241, 110, 79, 3, 140, 194, 144, 38, 60,
+        230, 25, 53, 246, 172, 231, 243, 32, 37, 99, 251, 234, 126, 226, 181, 137, 54, 207, 151, 22,
+        170, 52, 28, 193, 183, 59, 12, 46, 5, 62, 152, 240, 149, 100, 212, 213, 174, 153, 201, 128,
+        148, 139, 233, 165, 247, 133, 210, 34, 216, 57, 90, 88, 166, 208, 112, 1,
+    ],
+    [
+        1, 219, 159, 126, 95, 245, 199, 148, 30, 145, 144, 182, 23, 154, 59, 71, 129, 238, 208, 63,
+        176, 251, 228, 74, 15, 201, 72, 91, 140, 77, 158, 164, 193, 119, 104, 160, 88, 254, 114, 37,
+        136, 229, 36, 174, 70, 167, 79, 82, 225, 188, 52, 80, 44, 127, 57, 147, 68, 243, 18, 87, 35,
+        212, 168, 41, 241, 94, 26, 40, 22, 192, 157, 202, 34, 250, 9, 172, 146, 106, 84, 149, 249,
+        47, 13, 20, 11, 96, 207, 101, 17, 125, 133, 86, 73, 53, 42, 203, 253, 152, 135, 10, 134, 48,
+        232, 179, 137, 191, 195, 43, 165, 155, 21, 230, 255, 76, 196, 5, 67, 24, 116, 218, 197, 224,
+        226, 150, 211, 206, 139, 115, 256, 38, 98, 131, 162, 12, 58, 109, 227, 112, 113, 75, 234,
+        103, 198, 186, 128, 19, 49, 194, 81, 6, 29, 183, 242, 56, 185, 166, 117, 180, 99, 93, 64,
+        138, 153, 97, 169, 3, 143, 220, 121, 28, 221, 83, 187, 90, 178, 175, 32, 69, 205, 177, 213,
+        130, 200, 110, 189, 14, 239, 170, 222, 45, 89, 216, 16, 163, 231, 217, 235, 65, 100, 55,
+        223, 7, 248, 85, 111, 151, 173, 108, 8, 210, 244, 237, 246, 161, 50, 156, 240, 132, 124,
+        171, 184, 204, 215, 54, 4, 105, 122, 247, 123, 209, 25, 78, 120, 66, 62, 214, 92, 102, 236,
+        27, 2, 181, 61, 252, 190, 233, 141, 39, 60, 33, 31, 107, 46, 51, 118, 142, 1,
+    ],
+    [
+        1, 220, 84, 233, 117, 40, 62, 19, 68, 54, 58, 167, 246, 150, 104, 7, 255, 74, 89, 48, 23,
+        177, 133, 219, 121, 149, 141, 180, 22, 214, 49, 243, 4, 109, 79, 161, 211, 160, 248, 76, 15,
+        216, 232, 154, 213, 86, 159, 28, 249, 39, 99, 192, 92, 194, 18, 105, 227, 82, 50, 206, 88,
+        85, 196, 201, 16, 179, 59, 130, 73, 126, 221, 47, 60, 93, 157, 102, 81, 87, 122, 112, 225,
+        156, 139, 254, 111, 5, 72, 163, 137, 71, 200, 53, 95, 83, 13, 33, 64, 202, 236, 6, 35, 247,
+        113, 188, 240, 115, 114, 151, 67, 91, 231, 191, 129, 110, 42, 245, 187, 20, 31, 138, 34, 27,
+        29, 212, 123, 75, 52, 132, 256, 37, 173, 24, 140, 217, 195, 238, 189, 203, 199, 90, 11, 107,
+        153, 250, 2, 183, 168, 209, 234, 80, 124, 38, 136, 108, 116, 77, 235, 43, 208, 14, 253, 148,
+        178, 96, 46, 97, 9, 181, 242, 41, 25, 103, 44, 171, 98, 229, 8, 218, 158, 65, 165, 63, 239,
+        152, 30, 175, 207, 51, 169, 172, 61, 56, 241, 78, 198, 127, 184, 131, 36, 210, 197, 164,
+        100, 155, 176, 170, 135, 145, 32, 101, 118, 3, 146, 252, 185, 94, 120, 186, 57, 204, 162,
+        174, 244, 224, 193, 55, 21, 251, 222, 10, 144, 69, 17, 142, 143, 106, 190, 166, 26, 66, 128,
+        147, 215, 12, 70, 237, 226, 119, 223, 230, 228, 45, 134, 182, 205, 125, 1,
+    ],
+    [
+        1, 221, 11, 118, 121, 13, 46, 143, 249, 31, 169, 84, 60, 153, 146, 141, 64, 9, 190, 99, 34,
+        61, 117, 157, 2, 185, 22, 236, 242, 26, 92, 29, 241, 62, 81, 168, 120, 49, 35, 25, 128, 18,
+        123, 198, 68, 122, 234, 57, 4, 113, 44, 215, 227, 52, 184, 58, 225, 124, 162, 79, 240, 98,
+        70, 50, 256, 36, 246, 139, 136, 244, 211, 114, 8, 226, 88, 173, 197, 104, 111, 116, 193,
+        248, 67, 158, 223, 196, 140, 100, 255, 72, 235, 21, 15, 231, 165, 228, 16, 195, 176, 89,
+        137, 208, 222, 232, 129, 239, 134, 59, 189, 135, 23, 200, 253, 144, 213, 42, 30, 205, 73,
+        199, 32, 133, 95, 178, 17, 159, 187, 207, 1, 221, 11, 118, 121, 13, 46, 143, 249, 31, 169,
+        84, 60, 153, 146, 141, 64, 9, 190, 99, 34, 61, 117, 157, 2, 185, 22, 236, 242, 26, 92, 29,
+        241, 62, 81, 168, 120, 49, 35, 25, 128, 18, 123, 198, 68, 122, 234, 57, 4, 113, 44, 215,
+        227, 52, 184, 58, 225, 124, 162, 79, 240, 98, 70, 50, 256, 36, 246, 139, 136, 244, 211, 114,
+        8, 226, 88, 173, 197, 104, 111, 116, 193, 248, 67, 158, 223, 196, 140, 100, 255, 72, 235,
+        21, 15, 231, 165, 228, 16, 195, 176, 89, 137, 208, 222, 232, 129, 239, 134, 59, 189, 135,
+        23, 200, 253, 144, 213, 42, 30, 205, 73, 199, 32, 133, 95, 178, 17, 159, 187, 207, 1,
+    ],
+    [
+        1, 222, 197, 44, 2, 187, 137, 88, 4, 117, 17, 176, 8, 234, 34, 95, 16, 211, 68, 190, 32,
+        165, 136, 123, 64, 73, 15, 246, 128, 146, 30, 235, 256, 35, 60, 213, 255, 70, 120, 169, 253,
+        140, 240, 81, 249, 23, 223, 162, 241, 46, 189, 67, 225, 92, 121, 134, 193, 184, 242, 11,
+        129, 111, 227, 22, 1, 222, 197, 44, 2, 187, 137, 88, 4, 117, 17, 176, 8, 234, 34, 95, 16,
+        211, 68, 190, 32, 165, 136, 123, 64, 73, 15, 246, 128, 146, 30, 235, 256, 35, 60, 213, 255,
+        70, 120, 169, 253, 140, 240, 81, 249, 23, 223, 162, 241, 46, 189, 67, 225, 92, 121, 134,
+        193, 184, 242, 11, 129, 111, 227, 22, 1, 222, 197, 44, 2, 187, 137, 88, 4, 117, 17, 176, 8,
+        234, 34, 95, 16, 211, 68, 190, 32, 165, 136, 123, 64, 73, 15, 246, 128, 146, 30, 235, 256,
+        35, 60, 213, 255, 70, 120, 169, 253, 140, 240, 81, 249, 23, 223, 162, 241, 46, 189, 67, 225,
+        92, 121, 134, 193, 184, 242, 11, 129, 111, 227, 22, 1, 222, 197, 44, 2, 187, 137, 88, 4,
+        117, 17, 176, 8, 234, 34, 95, 16, 211, 68, 190, 32, 165, 136, 123, 64, 73, 15, 246, 128,
+        146, 30, 235, 256, 35, 60, 213, 255, 70, 120, 169, 253, 140, 240, 81, 249, 23, 223, 162,
+        241, 46, 189, 67, 225, 92, 121, 134, 193, 184, 242, 11, 129, 111, 227, 22, 1,
+    ],
+    [
+        1, 223, 128, 17, 193, 120, 32, 197, 241, 30, 8, 242, 253, 136, 2, 189, 256, 34, 129, 240,
+        64, 137, 225, 60, 16, 227, 249, 15, 4, 121, 255, 68, 1, 223, 128, 17, 193, 120, 32, 197,
+        241, 30, 8, 242, 253, 136, 2, 189, 256, 34, 129, 240, 64, 137, 225, 60, 16, 227, 249, 15, 4,
+        121, 255, 68, 1, 223, 128, 17, 193, 120, 32, 197, 241, 30, 8, 242, 253, 136, 2, 189, 256,
+        34, 129, 240, 64, 137, 225, 60, 16, 227, 249, 15, 4, 121, 255, 68, 1, 223, 128, 17, 193,
+        120, 32, 197, 241, 30, 8, 242, 253, 136, 2, 189, 256, 34, 129, 240, 64, 137, 225, 60, 16,
+        227, 249, 15, 4, 121, 255, 68, 1, 223, 128, 17, 193, 120, 32, 197, 241, 30, 8, 242, 253,
+        136, 2, 189, 256, 34, 129, 240, 64, 137, 225, 60, 16, 227, 249, 15, 4, 121, 255, 68, 1, 223,
+        128, 17, 193, 120, 32, 197, 241, 30, 8, 242, 253, 136, 2, 189, 256, 34, 129, 240, 64, 137,
+        225, 60, 16, 227, 249, 15, 4, 121, 255, 68, 1, 223, 128, 17, 193, 120, 32, 197, 241, 30, 8,
+        242, 253, 136, 2, 189, 256, 34, 129, 240, 64, 137, 225, 60, 16, 227, 249, 15, 4, 121, 255,
+        68, 1, 223, 128, 17, 193, 120, 32, 197, 241, 30, 8, 242, 253, 136, 2, 189, 256, 34, 129,
+        240, 64, 137, 225, 60, 16, 227, 249, 15, 4, 121, 255, 68, 1,
+    ],
+    [
+        1, 224, 61, 43, 123, 53, 50, 149, 223, 94, 239, 80, 187, 254, 99, 74, 128, 145, 98, 107, 67,
+        102, 232, 54, 17, 210, 9, 217, 35, 130, 79, 220, 193, 56, 208, 75, 95, 206, 141, 230, 120,
+        152, 124, 20, 111, 192, 89, 147, 32, 229, 153, 91, 81, 154, 58, 142, 197, 181, 195, 247, 73,
+        161, 84, 55, 241, 14, 52, 83, 88, 180, 228, 186, 30, 38, 31, 5, 92, 48, 215, 101, 8, 250,
+        231, 87, 213, 167, 143, 164, 242, 238, 113, 126, 211, 233, 21, 78, 253, 132, 13, 85, 22, 45,
+        57, 175, 136, 138, 72, 194, 23, 12, 118, 218, 2, 191, 122, 86, 246, 106, 100, 41, 189, 188,
+        221, 160, 117, 251, 198, 148, 256, 33, 196, 214, 134, 204, 207, 108, 34, 163, 18, 177, 70,
+        3, 158, 183, 129, 112, 159, 150, 190, 155, 25, 203, 240, 47, 248, 40, 222, 127, 178, 37, 64,
+        201, 49, 182, 162, 51, 116, 27, 137, 105, 133, 237, 146, 65, 168, 110, 225, 28, 104, 166,
+        176, 103, 199, 115, 60, 76, 62, 10, 184, 96, 173, 202, 16, 243, 205, 174, 169, 77, 29, 71,
+        227, 219, 226, 252, 165, 209, 42, 156, 249, 7, 26, 170, 44, 90, 114, 93, 15, 19, 144, 131,
+        46, 24, 236, 179, 4, 125, 244, 172, 235, 212, 200, 82, 121, 119, 185, 63, 234, 245, 139, 39,
+        255, 66, 135, 171, 11, 151, 157, 216, 68, 69, 36, 97, 140, 6, 59, 109, 1,
+    ],
+    [
+        1, 225, 253, 128, 16, 2, 193, 249, 256, 32, 4, 129, 241, 255, 64, 8, 1, 225, 253, 128, 16,
+        2, 193, 249, 256, 32, 4, 129, 241, 255, 64, 8, 1, 225, 253, 128, 16, 2, 193, 249, 256, 32,
+        4, 129, 241, 255, 64, 8, 1, 225, 253, 128, 16, 2, 193, 249, 256, 32, 4, 129, 241, 255, 64,
+        8, 1, 225, 253, 128, 16, 2, 193, 249, 256, 32, 4, 129, 241, 255, 64, 8, 1, 225, 253, 128,
+        16, 2, 193, 249, 256, 32, 4, 129, 241, 255, 64, 8, 1, 225, 253, 128, 16, 2, 193, 249, 256,
+        32, 4, 129, 241, 255, 64, 8, 1, 225, 253, 128, 16, 2, 193, 249, 256, 32, 4, 129, 241, 255,
+        64, 8, 1, 225, 253, 128, 16, 2, 193, 249, 256, 32, 4, 129, 241, 255, 64, 8, 1, 225, 253,
+        128, 16, 2, 193, 249, 256, 32, 4, 129, 241, 255, 64, 8, 1, 225, 253, 128, 16, 2, 193, 249,
+        256, 32, 4, 129, 241, 255, 64, 8, 1, 225, 253, 128, 16, 2, 193, 249, 256, 32, 4, 129, 241,
+        255, 64, 8, 1, 225, 253, 128, 16, 2, 193, 249, 256, 32, 4, 129, 241, 255, 64, 8, 1, 225,
+        253, 128, 16, 2, 193, 249, 256, 32, 4, 129, 241, 255, 64, 8, 1, 225, 253, 128, 16, 2, 193,
+        249, 256, 32, 4, 129, 241, 255, 64, 8, 1, 225, 253, 128, 16, 2, 193, 249, 256, 32, 4, 129,
+        241, 255, 64, 8, 1,
+    ],
+    [
+        1, 226, 190, 21, 120, 135, 184, 207, 8, 9, 235, 168, 189, 52, 187, 114, 64, 72, 81, 59, 227,
+        159, 211, 141, 255, 62, 134, 215, 17, 244, 146, 100, 241, 239, 44, 178, 136, 153, 140, 29,
+        129, 113, 95, 139, 60, 196, 92, 232, 4, 133, 246, 84, 223, 26, 222, 57, 32, 36, 169, 158,
+        242, 208, 234, 199, 256, 31, 67, 236, 137, 122, 73, 50, 249, 248, 22, 89, 68, 205, 70, 143,
+        193, 185, 176, 198, 30, 98, 46, 116, 2, 195, 123, 42, 240, 13, 111, 157, 16, 18, 213, 79,
+        121, 104, 117, 228, 128, 144, 162, 118, 197, 61, 165, 25, 253, 124, 11, 173, 34, 231, 35,
+        200, 225, 221, 88, 99, 15, 49, 23, 58, 1, 226, 190, 21, 120, 135, 184, 207, 8, 9, 235, 168,
+        189, 52, 187, 114, 64, 72, 81, 59, 227, 159, 211, 141, 255, 62, 134, 215, 17, 244, 146, 100,
+        241, 239, 44, 178, 136, 153, 140, 29, 129, 113, 95, 139, 60, 196, 92, 232, 4, 133, 246, 84,
+        223, 26, 222, 57, 32, 36, 169, 158, 242, 208, 234, 199, 256, 31, 67, 236, 137, 122, 73, 50,
+        249, 248, 22, 89, 68, 205, 70, 143, 193, 185, 176, 198, 30, 98, 46, 116, 2, 195, 123, 42,
+        240, 13, 111, 157, 16, 18, 213, 79, 121, 104, 117, 228, 128, 144, 162, 118, 197, 61, 165,
+        25, 253, 124, 11, 173, 34, 231, 35, 200, 225, 221, 88, 99, 15, 49, 23, 58, 1,
+    ],
+    [
+        1, 227, 129, 242, 193, 121, 225, 189, 241, 223, 249, 240, 253, 120, 255, 60, 256, 30, 128,
+        15, 64, 136, 32, 68, 16, 34, 8, 17, 4, 137, 2, 197, 1, 227, 129, 242, 193, 121, 225, 189,
+        241, 223, 249, 240, 253, 120, 255, 60, 256, 30, 128, 15, 64, 136, 32, 68, 16, 34, 8, 17, 4,
+        137, 2, 197, 1, 227, 129, 242, 193, 121, 225, 189, 241, 223, 249, 240, 253, 120, 255, 60,
+        256, 30, 128, 15, 64, 136, 32, 68, 16, 34, 8, 17, 4, 137, 2, 197, 1, 227, 129, 242, 193,
+        121, 225, 189, 241, 223, 249, 240, 253, 120, 255, 60, 256, 30, 128, 15, 64, 136, 32, 68, 16,
+        34, 8, 17, 4, 137, 2, 197, 1, 227, 129, 242, 193, 121, 225, 189, 241, 223, 249, 240, 253,
+        120, 255, 60, 256, 30, 128, 15, 64, 136, 32, 68, 16, 34, 8, 17, 4, 137, 2, 197, 1, 227, 129,
+        242, 193, 121, 225, 189, 241, 223, 249, 240, 253, 120, 255, 60, 256, 30, 128, 15, 64, 136,
+        32, 68, 16, 34, 8, 17, 4, 137, 2, 197, 1, 227, 129, 242, 193, 121, 225, 189, 241, 223, 249,
+        240, 253, 120, 255, 60, 256, 30, 128, 15, 64, 136, 32, 68, 16, 34, 8, 17, 4, 137, 2, 197, 1,
+        227, 129, 242, 193, 121, 225, 189, 241, 223, 249, 240, 253, 120, 255, 60, 256, 30, 128, 15,
+        64, 136, 32, 68, 16, 34, 8, 17, 4, 137, 2, 197, 1,
+    ],
+    [
+        1, 228, 70, 26, 17, 21, 162, 185, 32, 100, 184, 61, 30, 158, 44, 9, 253, 116, 234, 153, 189,
+        173, 123, 31, 129, 114, 35, 13, 137, 139, 81, 221, 16, 50, 92, 159, 15, 79, 22, 133, 255,
+        58, 117, 205, 223, 215, 190, 144, 193, 57, 146, 135, 197, 198, 169, 239, 8, 25, 46, 208,
+        136, 168, 11, 195, 256, 29, 187, 231, 240, 236, 95, 72, 225, 157, 73, 196, 227, 99, 213,
+        248, 4, 141, 23, 104, 68, 84, 134, 226, 128, 143, 222, 244, 120, 118, 176, 36, 241, 207,
+        165, 98, 242, 178, 235, 124, 2, 199, 140, 52, 34, 42, 67, 113, 64, 200, 111, 122, 60, 59,
+        88, 18, 249, 232, 211, 49, 121, 89, 246, 62, 1, 228, 70, 26, 17, 21, 162, 185, 32, 100, 184,
+        61, 30, 158, 44, 9, 253, 116, 234, 153, 189, 173, 123, 31, 129, 114, 35, 13, 137, 139, 81,
+        221, 16, 50, 92, 159, 15, 79, 22, 133, 255, 58, 117, 205, 223, 215, 190, 144, 193, 57, 146,
+        135, 197, 198, 169, 239, 8, 25, 46, 208, 136, 168, 11, 195, 256, 29, 187, 231, 240, 236, 95,
+        72, 225, 157, 73, 196, 227, 99, 213, 248, 4, 141, 23, 104, 68, 84, 134, 226, 128, 143, 222,
+        244, 120, 118, 176, 36, 241, 207, 165, 98, 242, 178, 235, 124, 2, 199, 140, 52, 34, 42, 67,
+        113, 64, 200, 111, 122, 60, 59, 88, 18, 249, 232, 211, 49, 121, 89, 246, 62, 1,
+    ],
+    [
+        1, 229, 13, 150, 169, 151, 141, 164, 34, 76, 185, 217, 92, 251, 168, 179, 128, 14, 122, 182,
+        44, 53, 58, 175, 240, 219, 36, 20, 211, 3, 173, 39, 193, 250, 196, 166, 235, 102, 228, 41,
+        137, 19, 239, 247, 23, 127, 42, 109, 32, 132, 159, 174, 11, 206, 143, 108, 60, 119, 9, 5,
+        117, 65, 236, 74, 241, 191, 49, 170, 123, 154, 57, 203, 227, 69, 124, 126, 70, 96, 139, 220,
+        8, 33, 104, 172, 67, 180, 100, 27, 15, 94, 195, 194, 222, 209, 59, 147, 253, 112, 205, 171,
+        95, 167, 207, 115, 121, 210, 31, 160, 146, 24, 99, 55, 2, 201, 26, 43, 81, 45, 25, 71, 68,
+        152, 113, 177, 184, 245, 79, 101, 256, 28, 244, 107, 88, 106, 116, 93, 223, 181, 72, 40,
+        165, 6, 89, 78, 129, 243, 135, 75, 213, 204, 199, 82, 17, 38, 221, 237, 46, 254, 84, 218,
+        64, 7, 61, 91, 22, 155, 29, 216, 120, 238, 18, 10, 234, 130, 215, 148, 225, 125, 98, 83,
+        246, 51, 114, 149, 197, 138, 248, 252, 140, 192, 21, 183, 16, 66, 208, 87, 134, 103, 200,
+        54, 30, 188, 133, 131, 187, 161, 118, 37, 249, 224, 153, 85, 190, 77, 157, 230, 242, 163,
+        62, 63, 35, 48, 198, 110, 4, 145, 52, 86, 162, 90, 50, 142, 136, 47, 226, 97, 111, 233, 158,
+        202, 255, 56, 231, 214, 176, 212, 232, 186, 189, 105, 144, 80, 73, 12, 178, 156, 1,
+    ],
+    [
+        1, 230, 215, 106, 222, 174, 185, 145, 197, 78, 207, 65, 44, 97, 208, 38, 2, 203, 173, 212,
+        187, 91, 113, 33, 137, 156, 157, 130, 88, 194, 159, 76, 4, 149, 89, 167, 117, 182, 226, 66,
+        17, 55, 57, 3, 176, 131, 61, 152, 8, 41, 178, 77, 234, 107, 195, 132, 34, 110, 114, 6, 95,
+        5, 122, 47, 16, 82, 99, 154, 211, 214, 133, 7, 68, 220, 228, 12, 190, 10, 244, 94, 32, 164,
+        198, 51, 165, 171, 9, 14, 136, 183, 199, 24, 123, 20, 231, 188, 64, 71, 139, 102, 73, 85,
+        18, 28, 15, 109, 141, 48, 246, 40, 205, 119, 128, 142, 21, 204, 146, 170, 36, 56, 30, 218,
+        25, 96, 235, 80, 153, 238, 256, 27, 42, 151, 35, 83, 72, 112, 60, 179, 50, 192, 213, 160,
+        49, 219, 255, 54, 84, 45, 70, 166, 144, 224, 120, 101, 100, 127, 169, 63, 98, 181, 253, 108,
+        168, 90, 140, 75, 31, 191, 240, 202, 200, 254, 81, 126, 196, 105, 249, 216, 79, 180, 23,
+        150, 62, 125, 223, 147, 143, 251, 162, 252, 135, 210, 241, 175, 158, 103, 46, 43, 124, 250,
+        189, 37, 29, 245, 67, 247, 13, 163, 225, 93, 59, 206, 92, 86, 248, 243, 121, 74, 58, 233,
+        134, 237, 26, 69, 193, 186, 118, 155, 184, 172, 239, 229, 242, 148, 116, 209, 11, 217, 52,
+        138, 129, 115, 236, 53, 111, 87, 221, 201, 227, 39, 232, 161, 22, 177, 104, 19, 1,
+    ],
+    [
+        1, 231, 162, 157, 30, 248, 234, 84, 129, 244, 81, 207, 15, 124, 117, 42, 193, 122, 169, 232,
+        136, 62, 187, 21, 225, 61, 213, 116, 68, 31, 222, 139, 241, 159, 235, 58, 34, 144, 111, 198,
+        249, 208, 246, 29, 17, 72, 184, 99, 253, 104, 123, 143, 137, 36, 92, 178, 255, 52, 190, 200,
+        197, 18, 46, 89, 256, 26, 95, 100, 227, 9, 23, 173, 128, 13, 176, 50, 242, 133, 140, 215,
+        64, 135, 88, 25, 121, 195, 70, 236, 32, 196, 44, 141, 189, 226, 35, 118, 16, 98, 22, 199,
+        223, 113, 146, 59, 8, 49, 11, 228, 240, 185, 73, 158, 4, 153, 134, 114, 120, 221, 165, 79,
+        2, 205, 67, 57, 60, 239, 211, 168, 1, 231, 162, 157, 30, 248, 234, 84, 129, 244, 81, 207,
+        15, 124, 117, 42, 193, 122, 169, 232, 136, 62, 187, 21, 225, 61, 213, 116, 68, 31, 222, 139,
+        241, 159, 235, 58, 34, 144, 111, 198, 249, 208, 246, 29, 17, 72, 184, 99, 253, 104, 123,
+        143, 137, 36, 92, 178, 255, 52, 190, 200, 197, 18, 46, 89, 256, 26, 95, 100, 227, 9, 23,
+        173, 128, 13, 176, 50, 242, 133, 140, 215, 64, 135, 88, 25, 121, 195, 70, 236, 32, 196, 44,
+        141, 189, 226, 35, 118, 16, 98, 22, 199, 223, 113, 146, 59, 8, 49, 11, 228, 240, 185, 73,
+        158, 4, 153, 134, 114, 120, 221, 165, 79, 2, 205, 67, 57, 60, 239, 211, 168, 1,
+    ],
+    [
+        1, 232, 111, 52, 242, 118, 134, 248, 225, 29, 46, 135, 223, 79, 81, 31, 253, 100, 70, 49,
+        60, 42, 235, 36, 128, 141, 73, 231, 136, 198, 190, 133, 16, 114, 234, 61, 17, 89, 88, 113,
+        2, 207, 222, 104, 227, 236, 11, 239, 193, 58, 92, 13, 189, 158, 162, 62, 249, 200, 140, 98,
+        120, 84, 213, 72, 256, 25, 146, 205, 15, 139, 123, 9, 32, 228, 211, 122, 34, 178, 176, 226,
+        4, 157, 187, 208, 197, 215, 22, 221, 129, 116, 184, 26, 121, 59, 67, 124, 241, 143, 23, 196,
+        240, 168, 169, 144, 255, 50, 35, 153, 30, 21, 246, 18, 64, 199, 165, 244, 68, 99, 95, 195,
+        8, 57, 117, 159, 137, 173, 44, 185, 1, 232, 111, 52, 242, 118, 134, 248, 225, 29, 46, 135,
+        223, 79, 81, 31, 253, 100, 70, 49, 60, 42, 235, 36, 128, 141, 73, 231, 136, 198, 190, 133,
+        16, 114, 234, 61, 17, 89, 88, 113, 2, 207, 222, 104, 227, 236, 11, 239, 193, 58, 92, 13,
+        189, 158, 162, 62, 249, 200, 140, 98, 120, 84, 213, 72, 256, 25, 146, 205, 15, 139, 123, 9,
+        32, 228, 211, 122, 34, 178, 176, 226, 4, 157, 187, 208, 197, 215, 22, 221, 129, 116, 184,
+        26, 121, 59, 67, 124, 241, 143, 23, 196, 240, 168, 169, 144, 255, 50, 35, 153, 30, 21, 246,
+        18, 64, 199, 165, 244, 68, 99, 95, 195, 8, 57, 117, 159, 137, 173, 44, 185, 1,
+    ],
+    [
+        1, 233, 62, 54, 246, 7, 89, 177, 121, 180, 49, 109, 211, 76, 232, 86, 249, 192, 18, 82, 88,
+        201, 59, 126, 60, 102, 122, 156, 111, 163, 200, 83, 64, 6, 113, 115, 67, 191, 42, 20, 34,
+        212, 52, 37, 140, 238, 199, 107, 2, 209, 124, 108, 235, 14, 178, 97, 242, 103, 98, 218, 165,
+        152, 207, 172, 241, 127, 36, 164, 176, 145, 118, 252, 120, 204, 244, 55, 222, 69, 143, 166,
+        128, 12, 226, 230, 134, 125, 84, 40, 68, 167, 104, 74, 23, 219, 141, 214, 4, 161, 248, 216,
+        213, 28, 99, 194, 227, 206, 196, 179, 73, 47, 157, 87, 225, 254, 72, 71, 95, 33, 236, 247,
+        240, 151, 231, 110, 187, 138, 29, 75, 256, 24, 195, 203, 11, 250, 168, 80, 136, 77, 208,
+        148, 46, 181, 25, 171, 8, 65, 239, 175, 169, 56, 198, 131, 197, 155, 135, 101, 146, 94, 57,
+        174, 193, 251, 144, 142, 190, 66, 215, 237, 223, 45, 205, 220, 117, 19, 58, 150, 255, 48,
+        133, 149, 22, 243, 79, 160, 15, 154, 159, 39, 92, 105, 50, 85, 16, 130, 221, 93, 81, 112,
+        139, 5, 137, 53, 13, 202, 35, 188, 114, 91, 129, 245, 31, 27, 123, 132, 173, 217, 189, 90,
+        153, 183, 234, 38, 116, 43, 253, 96, 9, 41, 44, 229, 158, 63, 30, 51, 61, 78, 184, 210, 100,
+        170, 32, 3, 185, 186, 162, 224, 21, 10, 17, 106, 26, 147, 70, 119, 228, 182, 1,
+    ],
+    [
+        1, 234, 15, 169, 225, 222, 34, 246, 253, 92, 197, 95, 128, 140, 121, 44, 16, 146, 240, 134,
+        2, 211, 30, 81, 193, 187, 68, 235, 249, 184, 137, 190, 256, 23, 242, 88, 32, 35, 223, 11, 4,
+        165, 60, 162, 129, 117, 136, 213, 241, 111, 17, 123, 255, 46, 227, 176, 64, 70, 189, 22, 8,
+        73, 120, 67, 1, 234, 15, 169, 225, 222, 34, 246, 253, 92, 197, 95, 128, 140, 121, 44, 16,
+        146, 240, 134, 2, 211, 30, 81, 193, 187, 68, 235, 249, 184, 137, 190, 256, 23, 242, 88, 32,
+        35, 223, 11, 4, 165, 60, 162, 129, 117, 136, 213, 241, 111, 17, 123, 255, 46, 227, 176, 64,
+        70, 189, 22, 8, 73, 120, 67, 1, 234, 15, 169, 225, 222, 34, 246, 253, 92, 197, 95, 128, 140,
+        121, 44, 16, 146, 240, 134, 2, 211, 30, 81, 193, 187, 68, 235, 249, 184, 137, 190, 256, 23,
+        242, 88, 32, 35, 223, 11, 4, 165, 60, 162, 129, 117, 136, 213, 241, 111, 17, 123, 255, 46,
+        227, 176, 64, 70, 189, 22, 8, 73, 120, 67, 1, 234, 15, 169, 225, 222, 34, 246, 253, 92, 197,
+        95, 128, 140, 121, 44, 16, 146, 240, 134, 2, 211, 30, 81, 193, 187, 68, 235, 249, 184, 137,
+        190, 256, 23, 242, 88, 32, 35, 223, 11, 4, 165, 60, 162, 129, 117, 136, 213, 241, 111, 17,
+        123, 255, 46, 227, 176, 64, 70, 189, 22, 8, 73, 120, 67, 1,
+    ],
+    [
+        1, 235, 227, 146, 129, 246, 242, 73, 193, 123, 121, 165, 225, 190, 189, 211, 241, 95, 223,
+        234, 249, 176, 240, 117, 253, 88, 120, 187, 255, 44, 60, 222, 256, 22, 30, 111, 128, 11, 15,
+        184, 64, 134, 136, 92, 32, 67, 68, 46, 16, 162, 34, 23, 8, 81, 17, 140, 4, 169, 137, 70, 2,
+        213, 197, 35, 1, 235, 227, 146, 129, 246, 242, 73, 193, 123, 121, 165, 225, 190, 189, 211,
+        241, 95, 223, 234, 249, 176, 240, 117, 253, 88, 120, 187, 255, 44, 60, 222, 256, 22, 30,
+        111, 128, 11, 15, 184, 64, 134, 136, 92, 32, 67, 68, 46, 16, 162, 34, 23, 8, 81, 17, 140, 4,
+        169, 137, 70, 2, 213, 197, 35, 1, 235, 227, 146, 129, 246, 242, 73, 193, 123, 121, 165, 225,
+        190, 189, 211, 241, 95, 223, 234, 249, 176, 240, 117, 253, 88, 120, 187, 255, 44, 60, 222,
+        256, 22, 30, 111, 128, 11, 15, 184, 64, 134, 136, 92, 32, 67, 68, 46, 16, 162, 34, 23, 8,
+        81, 17, 140, 4, 169, 137, 70, 2, 213, 197, 35, 1, 235, 227, 146, 129, 246, 242, 73, 193,
+        123, 121, 165, 225, 190, 189, 211, 241, 95, 223, 234, 249, 176, 240, 117, 253, 88, 120, 187,
+        255, 44, 60, 222, 256, 22, 30, 111, 128, 11, 15, 184, 64, 134, 136, 92, 32, 67, 68, 46, 16,
+        162, 34, 23, 8, 81, 17, 140, 4, 169, 137, 70, 2, 213, 197, 35, 1,
+    ],
+    [
+        1, 236, 184, 248, 189, 143, 81, 98, 255, 42, 146, 18, 136, 228, 95, 61, 4, 173, 222, 221,
+        242, 58, 67, 135, 249, 168, 70, 72, 30, 141, 123, 244, 16, 178, 117, 113, 197, 232, 11, 26,
+        225, 158, 23, 31, 120, 50, 235, 205, 64, 198, 211, 195, 17, 157, 44, 104, 129, 118, 92, 124,
+        223, 200, 169, 49, 256, 21, 73, 9, 68, 114, 176, 159, 2, 215, 111, 239, 121, 29, 162, 196,
+        253, 84, 35, 36, 15, 199, 190, 122, 8, 89, 187, 185, 227, 116, 134, 13, 241, 79, 140, 144,
+        60, 25, 246, 231, 32, 99, 234, 226, 137, 207, 22, 52, 193, 59, 46, 62, 240, 100, 213, 153,
+        128, 139, 165, 133, 34, 57, 88, 208, 1, 236, 184, 248, 189, 143, 81, 98, 255, 42, 146, 18,
+        136, 228, 95, 61, 4, 173, 222, 221, 242, 58, 67, 135, 249, 168, 70, 72, 30, 141, 123, 244,
+        16, 178, 117, 113, 197, 232, 11, 26, 225, 158, 23, 31, 120, 50, 235, 205, 64, 198, 211, 195,
+        17, 157, 44, 104, 129, 118, 92, 124, 223, 200, 169, 49, 256, 21, 73, 9, 68, 114, 176, 159,
+        2, 215, 111, 239, 121, 29, 162, 196, 253, 84, 35, 36, 15, 199, 190, 122, 8, 89, 187, 185,
+        227, 116, 134, 13, 241, 79, 140, 144, 60, 25, 246, 231, 32, 99, 234, 226, 137, 207, 22, 52,
+        193, 59, 46, 62, 240, 100, 213, 153, 128, 139, 165, 133, 34, 57, 88, 208, 1,
+    ],
+    [
+        1, 237, 143, 224, 146, 164, 61, 65, 242, 43, 168, 238, 123, 110, 113, 53, 225, 126, 50, 28,
+        211, 149, 104, 233, 223, 166, 21, 94, 176, 78, 239, 103, 253, 80, 199, 132, 187, 115, 13,
+        254, 60, 85, 99, 76, 22, 74, 62, 45, 128, 10, 57, 145, 184, 175, 98, 96, 136, 107, 173, 138,
+        67, 202, 72, 102, 16, 194, 232, 243, 23, 54, 205, 12, 17, 174, 118, 210, 169, 218, 9, 77, 2,
+        217, 29, 191, 35, 71, 122, 130, 227, 86, 79, 219, 246, 220, 226, 106, 193, 252, 100, 56,
+        165, 41, 208, 209, 189, 75, 42, 188, 95, 156, 221, 206, 249, 160, 141, 7, 117, 230, 26, 251,
+        120, 170, 198, 152, 44, 148, 124, 90, 256, 20, 114, 33, 111, 93, 196, 192, 15, 214, 89, 19,
+        134, 147, 144, 204, 32, 131, 207, 229, 46, 108, 153, 24, 34, 91, 236, 163, 81, 179, 18, 154,
+        4, 177, 58, 125, 70, 142, 244, 3, 197, 172, 158, 181, 235, 183, 195, 212, 129, 247, 200,
+        112, 73, 82, 159, 161, 121, 150, 84, 119, 190, 55, 185, 155, 241, 63, 25, 14, 234, 203, 52,
+        245, 240, 83, 139, 47, 88, 39, 248, 180, 255, 40, 228, 66, 222, 186, 135, 127, 30, 171, 178,
+        38, 11, 37, 31, 151, 64, 5, 157, 201, 92, 216, 49, 48, 68, 182, 215, 69, 162, 101, 36, 51,
+        8, 97, 116, 250, 140, 27, 231, 6, 137, 87, 59, 105, 213, 109, 133, 167, 1,
+    ],
+    [
+        1, 238, 104, 80, 22, 96, 232, 218, 227, 56, 221, 170, 111, 204, 236, 142, 129, 119, 52, 40,
+        11, 48, 116, 109, 242, 28, 239, 85, 184, 102, 118, 71, 193, 188, 26, 20, 134, 24, 58, 183,
+        121, 14, 248, 171, 92, 51, 59, 164, 225, 94, 13, 10, 67, 12, 29, 220, 189, 7, 124, 214, 46,
+        154, 158, 82, 241, 47, 135, 5, 162, 6, 143, 110, 223, 132, 62, 107, 23, 77, 79, 41, 249,
+        152, 196, 131, 81, 3, 200, 55, 240, 66, 31, 182, 140, 167, 168, 149, 253, 76, 98, 194, 169,
+        130, 100, 156, 120, 33, 144, 91, 70, 212, 84, 203, 255, 38, 49, 97, 213, 65, 50, 78, 60,
+        145, 72, 174, 35, 106, 42, 230, 256, 19, 153, 177, 235, 161, 25, 39, 30, 201, 36, 87, 146,
+        53, 21, 115, 128, 138, 205, 217, 246, 209, 141, 148, 15, 229, 18, 172, 73, 155, 139, 186,
+        64, 69, 231, 237, 123, 233, 199, 74, 136, 243, 9, 86, 165, 206, 198, 93, 32, 163, 244, 247,
+        190, 245, 228, 37, 68, 250, 133, 43, 211, 103, 99, 175, 16, 210, 122, 252, 95, 251, 114,
+        147, 34, 125, 195, 150, 234, 180, 178, 216, 8, 105, 61, 126, 176, 254, 57, 202, 17, 191,
+        226, 75, 117, 90, 89, 108, 4, 181, 159, 63, 88, 127, 157, 101, 137, 224, 113, 166, 187, 45,
+        173, 54, 2, 219, 208, 160, 44, 192, 207, 179, 197, 112, 185, 83, 222, 151, 215, 27, 1,
+    ],
+    [
+        1, 239, 67, 79, 120, 153, 73, 228, 8, 113, 22, 118, 189, 196, 70, 25, 64, 133, 176, 173,
+        227, 26, 46, 200, 255, 36, 123, 99, 17, 208, 111, 58, 241, 31, 213, 21, 136, 122, 117, 207,
+        129, 248, 162, 168, 60, 205, 165, 114, 4, 185, 11, 59, 223, 98, 35, 141, 32, 195, 88, 215,
+        242, 13, 23, 100, 256, 18, 190, 178, 137, 104, 184, 29, 249, 144, 235, 139, 68, 61, 187,
+        232, 193, 124, 81, 84, 30, 231, 211, 57, 2, 221, 134, 158, 240, 49, 146, 199, 16, 226, 44,
+        236, 121, 135, 140, 50, 128, 9, 95, 89, 197, 52, 92, 143, 253, 72, 246, 198, 34, 159, 222,
+        116, 225, 62, 169, 42, 15, 244, 234, 157, 1, 239, 67, 79, 120, 153, 73, 228, 8, 113, 22,
+        118, 189, 196, 70, 25, 64, 133, 176, 173, 227, 26, 46, 200, 255, 36, 123, 99, 17, 208, 111,
+        58, 241, 31, 213, 21, 136, 122, 117, 207, 129, 248, 162, 168, 60, 205, 165, 114, 4, 185, 11,
+        59, 223, 98, 35, 141, 32, 195, 88, 215, 242, 13, 23, 100, 256, 18, 190, 178, 137, 104, 184,
+        29, 249, 144, 235, 139, 68, 61, 187, 232, 193, 124, 81, 84, 30, 231, 211, 57, 2, 221, 134,
+        158, 240, 49, 146, 199, 16, 226, 44, 236, 121, 135, 140, 50, 128, 9, 95, 89, 197, 52, 92,
+        143, 253, 72, 246, 198, 34, 159, 222, 116, 225, 62, 169, 42, 15, 244, 234, 157, 1,
+    ],
+    [
+        1, 240, 32, 227, 253, 68, 129, 120, 16, 242, 255, 34, 193, 60, 8, 121, 256, 17, 225, 30, 4,
+        189, 128, 137, 241, 15, 2, 223, 64, 197, 249, 136, 1, 240, 32, 227, 253, 68, 129, 120, 16,
+        242, 255, 34, 193, 60, 8, 121, 256, 17, 225, 30, 4, 189, 128, 137, 241, 15, 2, 223, 64, 197,
+        249, 136, 1, 240, 32, 227, 253, 68, 129, 120, 16, 242, 255, 34, 193, 60, 8, 121, 256, 17,
+        225, 30, 4, 189, 128, 137, 241, 15, 2, 223, 64, 197, 249, 136, 1, 240, 32, 227, 253, 68,
+        129, 120, 16, 242, 255, 34, 193, 60, 8, 121, 256, 17, 225, 30, 4, 189, 128, 137, 241, 15, 2,
+        223, 64, 197, 249, 136, 1, 240, 32, 227, 253, 68, 129, 120, 16, 242, 255, 34, 193, 60, 8,
+        121, 256, 17, 225, 30, 4, 189, 128, 137, 241, 15, 2, 223, 64, 197, 249, 136, 1, 240, 32,
+        227, 253, 68, 129, 120, 16, 242, 255, 34, 193, 60, 8, 121, 256, 17, 225, 30, 4, 189, 128,
+        137, 241, 15, 2, 223, 64, 197, 249, 136, 1, 240, 32, 227, 253, 68, 129, 120, 16, 242, 255,
+        34, 193, 60, 8, 121, 256, 17, 225, 30, 4, 189, 128, 137, 241, 15, 2, 223, 64, 197, 249, 136,
+        1, 240, 32, 227, 253, 68, 129, 120, 16, 242, 255, 34, 193, 60, 8, 121, 256, 17, 225, 30, 4,
+        189, 128, 137, 241, 15, 2, 223, 64, 197, 249, 136, 1,
+    ],
+    [
+        1, 241, 256, 16, 1, 241, 256, 16, 1, 241, 256, 16, 1, 241, 256, 16, 1, 241, 256, 16, 1, 241,
+        256, 16, 1, 241, 256, 16, 1, 241, 256, 16, 1, 241, 256, 16, 1, 241, 256, 16, 1, 241, 256,
+        16, 1, 241, 256, 16, 1, 241, 256, 16, 1, 241, 256, 16, 1, 241, 256, 16, 1, 241, 256, 16, 1,
+        241, 256, 16, 1, 241, 256, 16, 1, 241, 256, 16, 1, 241, 256, 16, 1, 241, 256, 16, 1, 241,
+        256, 16, 1, 241, 256, 16, 1, 241, 256, 16, 1, 241, 256, 16, 1, 241, 256, 16, 1, 241, 256,
+        16, 1, 241, 256, 16, 1, 241, 256, 16, 1, 241, 256, 16, 1, 241, 256, 16, 1, 241, 256, 16, 1,
+        241, 256, 16, 1, 241, 256, 16, 1, 241, 256, 16, 1, 241, 256, 16, 1, 241, 256, 16, 1, 241,
+        256, 16, 1, 241, 256, 16, 1, 241, 256, 16, 1, 241, 256, 16, 1, 241, 256, 16, 1, 241, 256,
+        16, 1, 241, 256, 16, 1, 241, 256, 16, 1, 241, 256, 16, 1, 241, 256, 16, 1, 241, 256, 16, 1,
+        241, 256, 16, 1, 241, 256, 16, 1, 241, 256, 16, 1, 241, 256, 16, 1, 241, 256, 16, 1, 241,
+        256, 16, 1, 241, 256, 16, 1, 241, 256, 16, 1, 241, 256, 16, 1, 241, 256, 16, 1, 241, 256,
+        16, 1, 241, 256, 16, 1, 241, 256, 16, 1, 241, 256, 16, 1, 241, 256, 16, 1, 241, 256, 16, 1,
+    ],
+    [
+        1, 242, 225, 223, 253, 60, 128, 136, 16, 17, 2, 227, 193, 189, 249, 120, 256, 15, 32, 34, 4,
+        197, 129, 121, 241, 240, 255, 30, 64, 68, 8, 137, 1, 242, 225, 223, 253, 60, 128, 136, 16,
+        17, 2, 227, 193, 189, 249, 120, 256, 15, 32, 34, 4, 197, 129, 121, 241, 240, 255, 30, 64,
+        68, 8, 137, 1, 242, 225, 223, 253, 60, 128, 136, 16, 17, 2, 227, 193, 189, 249, 120, 256,
+        15, 32, 34, 4, 197, 129, 121, 241, 240, 255, 30, 64, 68, 8, 137, 1, 242, 225, 223, 253, 60,
+        128, 136, 16, 17, 2, 227, 193, 189, 249, 120, 256, 15, 32, 34, 4, 197, 129, 121, 241, 240,
+        255, 30, 64, 68, 8, 137, 1, 242, 225, 223, 253, 60, 128, 136, 16, 17, 2, 227, 193, 189, 249,
+        120, 256, 15, 32, 34, 4, 197, 129, 121, 241, 240, 255, 30, 64, 68, 8, 137, 1, 242, 225, 223,
+        253, 60, 128, 136, 16, 17, 2, 227, 193, 189, 249, 120, 256, 15, 32, 34, 4, 197, 129, 121,
+        241, 240, 255, 30, 64, 68, 8, 137, 1, 242, 225, 223, 253, 60, 128, 136, 16, 17, 2, 227, 193,
+        189, 249, 120, 256, 15, 32, 34, 4, 197, 129, 121, 241, 240, 255, 30, 64, 68, 8, 137, 1, 242,
+        225, 223, 253, 60, 128, 136, 16, 17, 2, 227, 193, 189, 249, 120, 256, 15, 32, 34, 4, 197,
+        129, 121, 241, 240, 255, 30, 64, 68, 8, 137, 1,
+    ],
+    [
+        1, 243, 196, 83, 123, 77, 207, 186, 223, 219, 18, 5, 187, 209, 158, 101, 128, 7, 159, 87,
+        67, 90, 25, 164, 17, 19, 248, 126, 35, 24, 178, 78, 193, 125, 49, 85, 95, 212, 116, 175,
+        120, 119, 133, 194, 111, 245, 168, 218, 32, 66, 104, 86, 81, 151, 199, 41, 197, 69, 62, 160,
+        73, 6, 173, 148, 241, 224, 205, 214, 88, 53, 29, 108, 30, 94, 226, 177, 92, 254, 42, 183, 8,
+        145, 26, 150, 213, 102, 114, 203, 242, 210, 144, 40, 211, 130, 236, 37, 253, 56, 244, 182,
+        22, 206, 200, 27, 136, 152, 185, 237, 23, 192, 139, 110, 2, 229, 135, 166, 246, 154, 157,
+        115, 189, 181, 36, 10, 117, 161, 59, 202, 256, 14, 61, 174, 134, 180, 50, 71, 34, 38, 239,
+        252, 70, 48, 99, 156, 129, 250, 98, 170, 190, 167, 232, 93, 240, 238, 9, 131, 222, 233, 79,
+        179, 64, 132, 208, 172, 162, 45, 141, 82, 137, 138, 124, 63, 146, 12, 89, 39, 225, 191, 153,
+        171, 176, 106, 58, 216, 60, 188, 195, 97, 184, 251, 84, 109, 16, 33, 52, 43, 169, 204, 228,
+        149, 227, 163, 31, 80, 165, 3, 215, 74, 249, 112, 231, 107, 44, 155, 143, 54, 15, 47, 113,
+        217, 46, 127, 21, 220, 4, 201, 13, 75, 235, 51, 57, 230, 121, 105, 72, 20, 234, 65, 118,
+        147, 255, 28, 122, 91, 11, 103, 100, 142, 68, 76, 221, 247, 140, 96, 198, 55, 1,
+    ],
+    [
+        1, 244, 169, 116, 34, 72, 92, 89, 128, 135, 44, 199, 240, 221, 211, 84, 193, 61, 235, 29,
+        137, 18, 23, 215, 32, 98, 11, 114, 60, 248, 117, 21, 241, 208, 123, 200, 227, 133, 70, 118,
+        8, 153, 67, 157, 15, 62, 222, 198, 253, 52, 95, 50, 121, 226, 146, 158, 2, 231, 81, 232, 68,
+        144, 184, 178, 256, 13, 88, 141, 223, 185, 165, 168, 129, 122, 213, 58, 17, 36, 46, 173, 64,
+        196, 22, 228, 120, 239, 234, 42, 225, 159, 246, 143, 197, 9, 140, 236, 16, 49, 134, 57, 30,
+        124, 187, 139, 249, 104, 190, 100, 242, 195, 35, 59, 4, 205, 162, 207, 136, 31, 111, 99,
+        255, 26, 176, 25, 189, 113, 73, 79, 1, 244, 169, 116, 34, 72, 92, 89, 128, 135, 44, 199,
+        240, 221, 211, 84, 193, 61, 235, 29, 137, 18, 23, 215, 32, 98, 11, 114, 60, 248, 117, 21,
+        241, 208, 123, 200, 227, 133, 70, 118, 8, 153, 67, 157, 15, 62, 222, 198, 253, 52, 95, 50,
+        121, 226, 146, 158, 2, 231, 81, 232, 68, 144, 184, 178, 256, 13, 88, 141, 223, 185, 165,
+        168, 129, 122, 213, 58, 17, 36, 46, 173, 64, 196, 22, 228, 120, 239, 234, 42, 225, 159, 246,
+        143, 197, 9, 140, 236, 16, 49, 134, 57, 30, 124, 187, 139, 249, 104, 190, 100, 242, 195, 35,
+        59, 4, 205, 162, 207, 136, 31, 111, 99, 255, 26, 176, 25, 189, 113, 73, 79, 1,
+    ],
+    [
+        1, 245, 144, 71, 176, 201, 158, 160, 136, 167, 52, 147, 35, 94, 157, 172, 249, 96, 133, 203,
+        134, 191, 21, 5, 197, 206, 98, 109, 234, 19, 29, 166, 64, 3, 221, 175, 213, 14, 89, 217,
+        223, 151, 244, 156, 184, 105, 25, 214, 2, 233, 31, 142, 95, 145, 59, 63, 15, 77, 104, 37,
+        70, 188, 57, 87, 241, 192, 9, 149, 11, 125, 42, 10, 137, 155, 196, 218, 211, 38, 58, 75,
+        128, 6, 185, 93, 169, 28, 178, 177, 189, 45, 231, 55, 111, 210, 50, 171, 4, 209, 62, 27,
+        190, 33, 118, 126, 30, 154, 208, 74, 140, 119, 114, 174, 225, 127, 18, 41, 22, 250, 84, 20,
+        17, 53, 135, 179, 165, 76, 116, 150, 256, 12, 113, 186, 81, 56, 99, 97, 121, 90, 205, 110,
+        222, 163, 100, 85, 8, 161, 124, 54, 123, 66, 236, 252, 60, 51, 159, 148, 23, 238, 228, 91,
+        193, 254, 36, 82, 44, 243, 168, 40, 34, 106, 13, 101, 73, 152, 232, 43, 255, 24, 226, 115,
+        162, 112, 198, 194, 242, 180, 153, 220, 187, 69, 200, 170, 16, 65, 248, 108, 246, 132, 215,
+        247, 120, 102, 61, 39, 46, 219, 199, 182, 129, 251, 72, 164, 88, 229, 79, 80, 68, 212, 26,
+        202, 146, 47, 207, 86, 253, 48, 195, 230, 67, 224, 139, 131, 227, 103, 49, 183, 117, 138,
+        143, 83, 32, 130, 239, 216, 235, 7, 173, 237, 240, 204, 122, 78, 92, 181, 141, 107, 1,
+    ],
+    [
+        1, 246, 121, 211, 249, 88, 60, 111, 64, 67, 34, 140, 2, 235, 242, 165, 241, 176, 120, 222,
+        128, 134, 68, 23, 4, 213, 227, 73, 225, 95, 240, 187, 256, 11, 136, 46, 8, 169, 197, 146,
+        193, 190, 223, 117, 255, 22, 15, 92, 16, 81, 137, 35, 129, 123, 189, 234, 253, 44, 30, 184,
+        32, 162, 17, 70, 1, 246, 121, 211, 249, 88, 60, 111, 64, 67, 34, 140, 2, 235, 242, 165, 241,
+        176, 120, 222, 128, 134, 68, 23, 4, 213, 227, 73, 225, 95, 240, 187, 256, 11, 136, 46, 8,
+        169, 197, 146, 193, 190, 223, 117, 255, 22, 15, 92, 16, 81, 137, 35, 129, 123, 189, 234,
+        253, 44, 30, 184, 32, 162, 17, 70, 1, 246, 121, 211, 249, 88, 60, 111, 64, 67, 34, 140, 2,
+        235, 242, 165, 241, 176, 120, 222, 128, 134, 68, 23, 4, 213, 227, 73, 225, 95, 240, 187,
+        256, 11, 136, 46, 8, 169, 197, 146, 193, 190, 223, 117, 255, 22, 15, 92, 16, 81, 137, 35,
+        129, 123, 189, 234, 253, 44, 30, 184, 32, 162, 17, 70, 1, 246, 121, 211, 249, 88, 60, 111,
+        64, 67, 34, 140, 2, 235, 242, 165, 241, 176, 120, 222, 128, 134, 68, 23, 4, 213, 227, 73,
+        225, 95, 240, 187, 256, 11, 136, 46, 8, 169, 197, 146, 193, 190, 223, 117, 255, 22, 15, 92,
+        16, 81, 137, 35, 129, 123, 189, 234, 253, 44, 30, 184, 32, 162, 17, 70, 1,
+    ],
+    [
+        1, 247, 100, 28, 234, 230, 13, 127, 15, 107, 215, 163, 169, 109, 195, 106, 225, 63, 141,
+        132, 222, 93, 98, 48, 34, 174, 59, 181, 246, 110, 185, 206, 253, 40, 114, 145, 92, 108, 205,
+        6, 197, 86, 168, 119, 95, 78, 248, 90, 128, 5, 207, 243, 140, 142, 122, 65, 121, 75, 21, 47,
+        44, 74, 31, 204, 16, 97, 58, 191, 146, 82, 208, 233, 240, 170, 99, 38, 134, 202, 36, 154, 2,
+        237, 200, 56, 211, 203, 26, 254, 30, 214, 173, 69, 81, 218, 133, 212, 193, 126, 25, 7, 187,
+        186, 196, 96, 68, 91, 118, 105, 235, 220, 113, 155, 249, 80, 228, 33, 184, 216, 153, 12,
+        137, 172, 79, 238, 190, 156, 239, 180, 256, 10, 157, 229, 23, 27, 244, 130, 242, 150, 42,
+        94, 88, 148, 62, 151, 32, 194, 116, 125, 35, 164, 159, 209, 223, 83, 198, 76, 11, 147, 72,
+        51, 4, 217, 143, 112, 165, 149, 52, 251, 60, 171, 89, 138, 162, 179, 9, 167, 129, 252, 50,
+        14, 117, 115, 135, 192, 136, 182, 236, 210, 213, 183, 226, 53, 241, 160, 199, 66, 111, 175,
+        49, 24, 17, 87, 158, 219, 123, 55, 221, 103, 255, 20, 57, 201, 46, 54, 231, 3, 227, 43, 84,
+        188, 176, 39, 124, 45, 64, 131, 232, 250, 70, 71, 61, 161, 189, 166, 139, 152, 22, 37, 144,
+        102, 8, 177, 29, 224, 73, 41, 104, 245, 120, 85, 178, 19, 67, 101, 18, 77, 1,
+    ],
+    [
+        1, 248, 81, 42, 136, 61, 222, 58, 249, 72, 123, 178, 197, 26, 23, 50, 64, 195, 44, 118, 223,
+        49, 73, 114, 2, 239, 162, 84, 15, 122, 187, 116, 241, 144, 246, 99, 137, 52, 46, 100, 128,
+        133, 88, 236, 189, 98, 146, 228, 4, 221, 67, 168, 30, 244, 117, 232, 225, 31, 235, 198, 17,
+        104, 92, 200, 256, 9, 176, 215, 121, 196, 35, 199, 8, 185, 134, 79, 60, 231, 234, 207, 193,
+        62, 213, 139, 34, 208, 184, 143, 255, 18, 95, 173, 242, 135, 70, 141, 16, 113, 11, 158, 120,
+        205, 211, 157, 129, 124, 169, 21, 68, 159, 111, 29, 253, 36, 190, 89, 227, 13, 140, 25, 32,
+        226, 22, 59, 240, 153, 165, 57, 1, 248, 81, 42, 136, 61, 222, 58, 249, 72, 123, 178, 197,
+        26, 23, 50, 64, 195, 44, 118, 223, 49, 73, 114, 2, 239, 162, 84, 15, 122, 187, 116, 241,
+        144, 246, 99, 137, 52, 46, 100, 128, 133, 88, 236, 189, 98, 146, 228, 4, 221, 67, 168, 30,
+        244, 117, 232, 225, 31, 235, 198, 17, 104, 92, 200, 256, 9, 176, 215, 121, 196, 35, 199, 8,
+        185, 134, 79, 60, 231, 234, 207, 193, 62, 213, 139, 34, 208, 184, 143, 255, 18, 95, 173,
+        242, 135, 70, 141, 16, 113, 11, 158, 120, 205, 211, 157, 129, 124, 169, 21, 68, 159, 111,
+        29, 253, 36, 190, 89, 227, 13, 140, 25, 32, 226, 22, 59, 240, 153, 165, 57, 1,
+    ],
+    [
+        1, 249, 64, 2, 241, 128, 4, 225, 256, 8, 193, 255, 16, 129, 253, 32, 1, 249, 64, 2, 241,
+        128, 4, 225, 256, 8, 193, 255, 16, 129, 253, 32, 1, 249, 64, 2, 241, 128, 4, 225, 256, 8,
+        193, 255, 16, 129, 253, 32, 1, 249, 64, 2, 241, 128, 4, 225, 256, 8, 193, 255, 16, 129, 253,
+        32, 1, 249, 64, 2, 241, 128, 4, 225, 256, 8, 193, 255, 16, 129, 253, 32, 1, 249, 64, 2, 241,
+        128, 4, 225, 256, 8, 193, 255, 16, 129, 253, 32, 1, 249, 64, 2, 241, 128, 4, 225, 256, 8,
+        193, 255, 16, 129, 253, 32, 1, 249, 64, 2, 241, 128, 4, 225, 256, 8, 193, 255, 16, 129, 253,
+        32, 1, 249, 64, 2, 241, 128, 4, 225, 256, 8, 193, 255, 16, 129, 253, 32, 1, 249, 64, 2, 241,
+        128, 4, 225, 256, 8, 193, 255, 16, 129, 253, 32, 1, 249, 64, 2, 241, 128, 4, 225, 256, 8,
+        193, 255, 16, 129, 253, 32, 1, 249, 64, 2, 241, 128, 4, 225, 256, 8, 193, 255, 16, 129, 253,
+        32, 1, 249, 64, 2, 241, 128, 4, 225, 256, 8, 193, 255, 16, 129, 253, 32, 1, 249, 64, 2, 241,
+        128, 4, 225, 256, 8, 193, 255, 16, 129, 253, 32, 1, 249, 64, 2, 241, 128, 4, 225, 256, 8,
+        193, 255, 16, 129, 253, 32, 1, 249, 64, 2, 241, 128, 4, 225, 256, 8, 193, 255, 16, 129, 253,
+        32, 1,
+    ],
+    [
+        1, 250, 49, 171, 88, 155, 200, 142, 34, 19, 124, 160, 165, 130, 118, 202, 128, 132, 104, 43,
+        213, 51, 157, 186, 240, 119, 195, 177, 46, 192, 198, 156, 193, 191, 205, 107, 22, 103, 50,
+        164, 137, 69, 31, 40, 234, 161, 158, 179, 32, 33, 26, 75, 246, 77, 232, 175, 60, 94, 113,
+        237, 140, 48, 178, 39, 241, 112, 244, 91, 134, 90, 141, 41, 227, 210, 72, 10, 187, 233, 168,
+        109, 8, 201, 135, 83, 190, 212, 58, 108, 15, 152, 221, 252, 35, 12, 173, 74, 253, 28, 61,
+        87, 162, 151, 228, 203, 121, 181, 18, 131, 111, 251, 42, 220, 2, 243, 98, 85, 176, 53, 143,
+        27, 68, 38, 248, 63, 73, 3, 236, 147, 256, 7, 208, 86, 169, 102, 57, 115, 223, 238, 133, 97,
+        92, 127, 139, 55, 129, 125, 153, 214, 44, 206, 100, 71, 17, 138, 62, 80, 211, 65, 59, 101,
+        64, 66, 52, 150, 235, 154, 207, 93, 120, 188, 226, 217, 23, 96, 99, 78, 225, 224, 231, 182,
+        11, 180, 25, 82, 197, 163, 144, 20, 117, 209, 79, 218, 16, 145, 13, 166, 123, 167, 116, 216,
+        30, 47, 185, 247, 70, 24, 89, 148, 249, 56, 122, 174, 67, 45, 199, 149, 242, 105, 36, 5,
+        222, 245, 84, 183, 4, 229, 196, 170, 95, 106, 29, 54, 136, 76, 239, 126, 146, 6, 215, 37,
+        255, 14, 159, 172, 81, 204, 114, 230, 189, 219, 9, 194, 184, 254, 21, 110, 1,
+    ],
+    [
+        1, 251, 36, 41, 11, 191, 139, 194, 121, 45, 244, 78, 46, 238, 114, 87, 249, 48, 226, 186,
+        169, 14, 173, 247, 60, 154, 104, 147, 146, 152, 116, 75, 64, 130, 248, 54, 190, 145, 158,
+        80, 34, 53, 196, 109, 117, 69, 100, 171, 2, 245, 72, 82, 22, 125, 21, 131, 242, 90, 231,
+        156, 92, 219, 228, 174, 241, 96, 195, 115, 81, 28, 89, 237, 120, 51, 208, 37, 35, 47, 232,
+        150, 128, 3, 239, 108, 123, 33, 59, 160, 68, 106, 135, 218, 234, 138, 200, 85, 4, 233, 144,
+        164, 44, 250, 42, 5, 227, 180, 205, 55, 184, 181, 199, 91, 225, 192, 133, 230, 162, 56, 178,
+        217, 240, 102, 159, 74, 70, 94, 207, 43, 256, 6, 221, 216, 246, 66, 118, 63, 136, 212, 13,
+        179, 211, 19, 143, 170, 8, 209, 31, 71, 88, 243, 84, 10, 197, 103, 153, 110, 111, 105, 141,
+        182, 193, 127, 9, 203, 67, 112, 99, 177, 223, 204, 61, 148, 140, 188, 157, 86, 255, 12, 185,
+        175, 235, 132, 236, 126, 15, 167, 26, 101, 165, 38, 29, 83, 16, 161, 62, 142, 176, 229, 168,
+        20, 137, 206, 49, 220, 222, 210, 25, 107, 129, 254, 18, 149, 134, 224, 198, 97, 189, 151,
+        122, 39, 23, 119, 57, 172, 253, 24, 113, 93, 213, 7, 215, 252, 30, 77, 52, 202, 73, 76, 58,
+        166, 32, 65, 124, 27, 95, 201, 79, 40, 17, 155, 98, 183, 187, 163, 50, 214, 1,
+    ],
+    [
+        1, 252, 25, 132, 111, 216, 205, 3, 242, 75, 139, 76, 134, 101, 9, 212, 225, 160, 228, 145,
+        46, 27, 122, 161, 223, 170, 178, 138, 81, 109, 226, 155, 253, 20, 157, 243, 70, 164, 208,
+        245, 60, 214, 215, 210, 235, 110, 221, 180, 128, 131, 116, 191, 73, 149, 26, 127, 136, 91,
+        59, 219, 190, 78, 124, 151, 16, 177, 143, 56, 234, 115, 196, 48, 17, 172, 168, 188, 88, 74,
+        144, 51, 2, 247, 50, 7, 222, 175, 153, 6, 227, 150, 21, 152, 11, 202, 18, 167, 193, 63, 199,
+        33, 92, 54, 244, 65, 189, 83, 99, 19, 162, 218, 195, 53, 249, 40, 57, 229, 140, 71, 159,
+        233, 120, 171, 173, 163, 213, 220, 185, 103, 256, 5, 232, 125, 146, 41, 52, 254, 15, 182,
+        118, 181, 123, 156, 248, 45, 32, 97, 29, 112, 211, 230, 135, 96, 34, 87, 79, 119, 176, 148,
+        31, 102, 4, 237, 100, 14, 187, 93, 49, 12, 197, 43, 42, 47, 22, 147, 36, 77, 129, 126, 141,
+        66, 184, 108, 231, 130, 121, 166, 198, 38, 67, 179, 133, 106, 241, 80, 114, 201, 23, 142,
+        61, 209, 240, 85, 89, 69, 169, 183, 113, 206, 255, 10, 207, 250, 35, 82, 104, 251, 30, 107,
+        236, 105, 246, 55, 239, 90, 64, 194, 58, 224, 165, 203, 13, 192, 68, 174, 158, 238, 95, 39,
+        62, 204, 8, 217, 200, 28, 117, 186, 98, 24, 137, 86, 84, 94, 44, 37, 72, 154, 1,
+    ],
+    [
+        1, 253, 16, 193, 256, 4, 241, 64, 1, 253, 16, 193, 256, 4, 241, 64, 1, 253, 16, 193, 256, 4,
+        241, 64, 1, 253, 16, 193, 256, 4, 241, 64, 1, 253, 16, 193, 256, 4, 241, 64, 1, 253, 16,
+        193, 256, 4, 241, 64, 1, 253, 16, 193, 256, 4, 241, 64, 1, 253, 16, 193, 256, 4, 241, 64, 1,
+        253, 16, 193, 256, 4, 241, 64, 1, 253, 16, 193, 256, 4, 241, 64, 1, 253, 16, 193, 256, 4,
+        241, 64, 1, 253, 16, 193, 256, 4, 241, 64, 1, 253, 16, 193, 256, 4, 241, 64, 1, 253, 16,
+        193, 256, 4, 241, 64, 1, 253, 16, 193, 256, 4, 241, 64, 1, 253, 16, 193, 256, 4, 241, 64, 1,
+        253, 16, 193, 256, 4, 241, 64, 1, 253, 16, 193, 256, 4, 241, 64, 1, 253, 16, 193, 256, 4,
+        241, 64, 1, 253, 16, 193, 256, 4, 241, 64, 1, 253, 16, 193, 256, 4, 241, 64, 1, 253, 16,
+        193, 256, 4, 241, 64, 1, 253, 16, 193, 256, 4, 241, 64, 1, 253, 16, 193, 256, 4, 241, 64, 1,
+        253, 16, 193, 256, 4, 241, 64, 1, 253, 16, 193, 256, 4, 241, 64, 1, 253, 16, 193, 256, 4,
+        241, 64, 1, 253, 16, 193, 256, 4, 241, 64, 1, 253, 16, 193, 256, 4, 241, 64, 1, 253, 16,
+        193, 256, 4, 241, 64, 1, 253, 16, 193, 256, 4, 241, 64, 1, 253, 16, 193, 256, 4, 241, 64, 1,
+    ],
+    [
+        1, 254, 9, 230, 81, 14, 215, 126, 136, 106, 196, 183, 222, 105, 199, 174, 249, 24, 185, 216,
+        123, 145, 79, 20, 197, 180, 231, 78, 23, 188, 207, 150, 64, 65, 62, 71, 44, 125, 139, 97,
+        223, 102, 208, 147, 73, 38, 143, 85, 2, 251, 18, 203, 162, 28, 173, 252, 15, 212, 135, 109,
+        187, 210, 141, 91, 241, 48, 113, 175, 246, 33, 158, 40, 137, 103, 205, 156, 46, 119, 157,
+        43, 128, 130, 124, 142, 88, 250, 21, 194, 189, 204, 159, 37, 146, 76, 29, 170, 4, 245, 36,
+        149, 67, 56, 89, 247, 30, 167, 13, 218, 117, 163, 25, 182, 225, 96, 226, 93, 235, 66, 59,
+        80, 17, 206, 153, 55, 92, 238, 57, 86, 256, 3, 248, 27, 176, 243, 42, 131, 121, 151, 61, 74,
+        35, 152, 58, 83, 8, 233, 72, 41, 134, 112, 178, 237, 60, 77, 26, 179, 234, 69, 50, 107, 193,
+        192, 195, 186, 213, 132, 118, 160, 34, 155, 49, 110, 184, 219, 114, 172, 255, 6, 239, 54,
+        95, 229, 84, 5, 242, 45, 122, 148, 70, 47, 116, 166, 16, 209, 144, 82, 11, 224, 99, 217,
+        120, 154, 52, 101, 211, 138, 100, 214, 129, 127, 133, 115, 169, 7, 236, 63, 68, 53, 98, 220,
+        111, 181, 228, 87, 253, 12, 221, 108, 190, 201, 168, 10, 227, 90, 244, 39, 140, 94, 232, 75,
+        32, 161, 31, 164, 22, 191, 198, 177, 240, 51, 104, 202, 165, 19, 200, 171, 1,
+    ],
+    [
+        1, 255, 4, 249, 16, 225, 64, 129, 256, 2, 253, 8, 241, 32, 193, 128, 1, 255, 4, 249, 16,
+        225, 64, 129, 256, 2, 253, 8, 241, 32, 193, 128, 1, 255, 4, 249, 16, 225, 64, 129, 256, 2,
+        253, 8, 241, 32, 193, 128, 1, 255, 4, 249, 16, 225, 64, 129, 256, 2, 253, 8, 241, 32, 193,
+        128, 1, 255, 4, 249, 16, 225, 64, 129, 256, 2, 253, 8, 241, 32, 193, 128, 1, 255, 4, 249,
+        16, 225, 64, 129, 256, 2, 253, 8, 241, 32, 193, 128, 1, 255, 4, 249, 16, 225, 64, 129, 256,
+        2, 253, 8, 241, 32, 193, 128, 1, 255, 4, 249, 16, 225, 64, 129, 256, 2, 253, 8, 241, 32,
+        193, 128, 1, 255, 4, 249, 16, 225, 64, 129, 256, 2, 253, 8, 241, 32, 193, 128, 1, 255, 4,
+        249, 16, 225, 64, 129, 256, 2, 253, 8, 241, 32, 193, 128, 1, 255, 4, 249, 16, 225, 64, 129,
+        256, 2, 253, 8, 241, 32, 193, 128, 1, 255, 4, 249, 16, 225, 64, 129, 256, 2, 253, 8, 241,
+        32, 193, 128, 1, 255, 4, 249, 16, 225, 64, 129, 256, 2, 253, 8, 241, 32, 193, 128, 1, 255,
+        4, 249, 16, 225, 64, 129, 256, 2, 253, 8, 241, 32, 193, 128, 1, 255, 4, 249, 16, 225, 64,
+        129, 256, 2, 253, 8, 241, 32, 193, 128, 1, 255, 4, 249, 16, 225, 64, 129, 256, 2, 253, 8,
+        241, 32, 193, 128, 1,
+    ],
+    [
+        1, 256, 1, 256, 1, 256, 1, 256, 1, 256, 1, 256, 1, 256, 1, 256, 1, 256, 1, 256, 1, 256, 1,
+        256, 1, 256, 1, 256, 1, 256, 1, 256, 1, 256, 1, 256, 1, 256, 1, 256, 1, 256, 1, 256, 1, 256,
+        1, 256, 1, 256, 1, 256, 1, 256, 1, 256, 1, 256, 1, 256, 1, 256, 1, 256, 1, 256, 1, 256, 1,
+        256, 1, 256, 1, 256, 1, 256, 1, 256, 1, 256, 1, 256, 1, 256, 1, 256, 1, 256, 1, 256, 1, 256,
+        1, 256, 1, 256, 1, 256, 1, 256, 1, 256, 1, 256, 1, 256, 1, 256, 1, 256, 1, 256, 1, 256, 1,
+        256, 1, 256, 1, 256, 1, 256, 1, 256, 1, 256, 1, 256, 1, 256, 1, 256, 1, 256, 1, 256, 1, 256,
+        1, 256, 1, 256, 1, 256, 1, 256, 1, 256, 1, 256, 1, 256, 1, 256, 1, 256, 1, 256, 1, 256, 1,
+        256, 1, 256, 1, 256, 1, 256, 1, 256, 1, 256, 1, 256, 1, 256, 1, 256, 1, 256, 1, 256, 1, 256,
+        1, 256, 1, 256, 1, 256, 1, 256, 1, 256, 1, 256, 1, 256, 1, 256, 1, 256, 1, 256, 1, 256, 1,
+        256, 1, 256, 1, 256, 1, 256, 1, 256, 1, 256, 1, 256, 1, 256, 1, 256, 1, 256, 1, 256, 1, 256,
+        1, 256, 1, 256, 1, 256, 1, 256, 1, 256, 1, 256, 1, 256, 1, 256, 1, 256, 1, 256, 1, 256, 1,
+        256, 1, 256, 1,
+    ],
 ];
 
 fn main(x: Field, y: pub Field) {
diff --git a/test_programs/execution_success/regression_5045/src/main.nr b/test_programs/execution_success/regression_5045/src/main.nr
index d1bc4f663fd..545694368fd 100644
--- a/test_programs/execution_success/regression_5045/src/main.nr
+++ b/test_programs/execution_success/regression_5045/src/main.nr
@@ -5,7 +5,7 @@ fn main(is_active: bool) {
     let a = EmbeddedCurvePoint {
         x: 0x1d8eb4378a3bde41e0b6a9a8dcbd21b7ff9c51bdd6ca13ce989abbbf90df3666,
         y: 0x06075b63354f2504f9cddba0b94ed0cef35fc88615e69ec1f853b51eb79a24a0,
-        is_infinite: false
+        is_infinite: false,
     };
 
     if is_active {
@@ -13,7 +13,7 @@ fn main(is_active: bool) {
         let d = bad.double();
         let e = std::embedded_curve_ops::multi_scalar_mul(
             [a, bad],
-            [EmbeddedCurveScalar { lo: 1, hi: 0 }, EmbeddedCurveScalar { lo: 1, hi: 0 }]
+            [EmbeddedCurveScalar { lo: 1, hi: 0 }, EmbeddedCurveScalar { lo: 1, hi: 0 }],
         );
         assert(e.x != d.x);
     }
diff --git a/test_programs/execution_success/regression_5252/src/main.nr b/test_programs/execution_success/regression_5252/src/main.nr
index 4b4d1937c0e..5f56b7f7f35 100644
--- a/test_programs/execution_success/regression_5252/src/main.nr
+++ b/test_programs/execution_success/regression_5252/src/main.nr
@@ -1,7 +1,7 @@
-use std::hash::{mimc, poseidon, poseidon2::Poseidon2};
+use std::hash::{poseidon, poseidon2::Poseidon2};
 
-global NUM_HASHES = 3;
-global HASH_LENGTH = 20;
+global NUM_HASHES: u32 = 3;
+global HASH_LENGTH: u32 = 20;
 
 pub fn poseidon_hash<let N: u32>(inputs: [Field; N]) -> Field {
     Poseidon2::hash(inputs, inputs.len())
@@ -9,14 +9,14 @@ pub fn poseidon_hash<let N: u32>(inputs: [Field; N]) -> Field {
 
 fn main(
     to_hash: [[Field; HASH_LENGTH]; NUM_HASHES],
-    enable: [bool; NUM_HASHES]
+    enable: [bool; NUM_HASHES],
 ) -> pub [Field; NUM_HASHES] {
     let mut result = [0; NUM_HASHES];
     for i in 0..NUM_HASHES {
         let enable = enable[i];
         let to_hash = to_hash[i];
         if enable {
-            result[i] = poseidon_hash(to_hash) + poseidon::bn254::sponge(to_hash) + mimc::mimc_bn254(to_hash);
+            result[i] = poseidon_hash(to_hash) + poseidon::bn254::sponge(to_hash);
         }
     }
     result
diff --git a/test_programs/execution_success/regression_5435/src/main.nr b/test_programs/execution_success/regression_5435/src/main.nr
index d8aeb76356b..895a6983ad9 100644
--- a/test_programs/execution_success/regression_5435/src/main.nr
+++ b/test_programs/execution_success/regression_5435/src/main.nr
@@ -3,16 +3,18 @@ fn main(input: Field, enable: bool) {
         let hash = no_predicate_function(input);
         // `EnableSideEffects` instruction from above instruction leaks out and removes the predicate from this call,
         // resulting in execution failure.
-        unsafe {
-            fail(hash)
-        };
+        unsafe { fail(hash) };
     }
 }
 
 #[no_predicates]
 fn no_predicate_function(enable: Field) -> Field {
     // if-statement ensures that an `EnableSideEffects` instruction is emitted.
-    if enable == 0 { 1 } else { 0 }
+    if enable == 0 {
+        1
+    } else {
+        0
+    }
 }
 
 unconstrained fn fail(_: Field) {
diff --git a/test_programs/execution_success/regression_5462/Nargo.toml b/test_programs/execution_success/regression_5462/Nargo.toml
new file mode 100644
index 00000000000..97015f78963
--- /dev/null
+++ b/test_programs/execution_success/regression_5462/Nargo.toml
@@ -0,0 +1,7 @@
+[package]
+name = "regression_5462"
+type = "bin"
+authors = [""]
+compiler_version = ">=0.35.0"
+
+[dependencies]
diff --git a/test_programs/execution_success/regression_5462/src/main.nr b/test_programs/execution_success/regression_5462/src/main.nr
new file mode 100644
index 00000000000..092f7ab96a5
--- /dev/null
+++ b/test_programs/execution_success/regression_5462/src/main.nr
@@ -0,0 +1,11 @@
+fn main() {
+    let empty_slice: [u8] = &[];
+
+    if empty_slice != &[] {
+        let _ = empty_slice.pop_front();
+    }
+
+    if empty_slice.len() != 0 {
+        let _ = empty_slice.pop_front();
+    }
+}
diff --git a/test_programs/execution_success/regression_5615/src/main.nr b/test_programs/execution_success/regression_5615/src/main.nr
index afb641e510d..1d8e0a045cd 100644
--- a/test_programs/execution_success/regression_5615/src/main.nr
+++ b/test_programs/execution_success/regression_5615/src/main.nr
@@ -3,9 +3,9 @@ use std::hash::BuildHasherDefault;
 use std::hash::poseidon2::Poseidon2Hasher;
 
 unconstrained fn main() {
-    comptime
-    {
-        let mut map: UHashMap<u32, Field, BuildHasherDefault<Poseidon2Hasher>> = UHashMap::default();
+    comptime {
+        let mut map: UHashMap<u32, Field, BuildHasherDefault<Poseidon2Hasher>> =
+            UHashMap::default();
 
         map.insert(1, 2);
     }
diff --git a/test_programs/execution_success/brillig_sha256/Nargo.toml b/test_programs/execution_success/regression_6451/Nargo.toml
similarity index 67%
rename from test_programs/execution_success/brillig_sha256/Nargo.toml
rename to test_programs/execution_success/regression_6451/Nargo.toml
index 7140fa0fd0b..e109747c7f6 100644
--- a/test_programs/execution_success/brillig_sha256/Nargo.toml
+++ b/test_programs/execution_success/regression_6451/Nargo.toml
@@ -1,6 +1,5 @@
 [package]
-name = "brillig_sha256"
+name = "regression_6451"
 type = "bin"
 authors = [""]
-
 [dependencies]
diff --git a/test_programs/execution_success/regression_6451/Prover.toml b/test_programs/execution_success/regression_6451/Prover.toml
new file mode 100644
index 00000000000..74213d097ec
--- /dev/null
+++ b/test_programs/execution_success/regression_6451/Prover.toml
@@ -0,0 +1 @@
+x = 0
\ No newline at end of file
diff --git a/test_programs/execution_success/regression_6451/src/main.nr b/test_programs/execution_success/regression_6451/src/main.nr
new file mode 100644
index 00000000000..b13b6c25a7e
--- /dev/null
+++ b/test_programs/execution_success/regression_6451/src/main.nr
@@ -0,0 +1,23 @@
+fn main(x: Field) {
+    // Regression test for #6451
+    let y = unsafe { empty(x) };
+    let mut value = 0;
+    let term1 = x * x - x * y;
+    std::as_witness(term1);
+    value += term1;
+    let term2 = x * x - y * x;
+    value += term2;
+    value.assert_max_bit_size::<1>();
+
+    // Regression test for #6447 (Aztec Packages issue #9488)
+    let y = unsafe { empty(x + 1) };
+    let z = y + x + 1;
+    let z1 = z + y;
+    assert(z + z1 != 3);
+    let w = y + 2 * x + 3;
+    assert(w + z1 != z);
+}
+
+unconstrained fn empty(_: Field) -> Field {
+    0
+}
diff --git a/test_programs/execution_success/brillig_keccak/Nargo.toml b/test_programs/execution_success/regression_6674_1/Nargo.toml
similarity index 66%
rename from test_programs/execution_success/brillig_keccak/Nargo.toml
rename to test_programs/execution_success/regression_6674_1/Nargo.toml
index 8cacf2186b8..ad87f9deb46 100644
--- a/test_programs/execution_success/brillig_keccak/Nargo.toml
+++ b/test_programs/execution_success/regression_6674_1/Nargo.toml
@@ -1,5 +1,5 @@
 [package]
-name = "brillig_keccak"
+name = "regression_6674_1"
 type = "bin"
 authors = [""]
 
diff --git a/test_programs/execution_success/regression_6674_1/src/main.nr b/test_programs/execution_success/regression_6674_1/src/main.nr
new file mode 100644
index 00000000000..70315c16b78
--- /dev/null
+++ b/test_programs/execution_success/regression_6674_1/src/main.nr
@@ -0,0 +1,85 @@
+use std::mem::zeroed;
+
+pub struct BoundedVec4 {
+    storage: [Field; 4],
+    len: u32,
+}
+
+impl BoundedVec4 {
+    pub fn new() -> Self {
+        BoundedVec4 { storage: [0; 4], len: 0 }
+    }
+
+    pub fn push(&mut self, elem: Field) {
+        self.storage[self.len] = elem;
+        self.len += 1;
+    }
+}
+
+pub struct PrivateKernelCircuitPublicInputs {
+    pub l2_to_l1_msgs: [Field; 4],
+    pub public_call_requests: [Field; 4],
+}
+
+pub struct FixtureBuilder {
+    pub public_call_requests: BoundedVec4,
+    pub counter: Field,
+}
+
+impl FixtureBuilder {
+    pub fn new() -> Self {
+        FixtureBuilder { public_call_requests: zeroed(), counter: 0 }
+    }
+
+    pub fn append_public_call_requests_inner(&mut self) {
+        self.public_call_requests.push(self.next_counter());
+    }
+
+    pub fn append_public_call_requests(&mut self) {
+        for _ in 0..4 {
+            // Note that here we push via a method call
+            self.append_public_call_requests_inner();
+        }
+    }
+
+    fn next_counter(&mut self) -> Field {
+        let counter = self.counter;
+        self.counter += 1;
+        counter
+    }
+}
+
+pub struct PrivateKernelCircuitPublicInputsComposer {
+    pub l2_to_l1_msgs: [Field; 4],
+    pub public_call_requests: [Field; 4],
+}
+
+pub unconstrained fn sort_by(array: [Field; 4]) -> [Field; 4] {
+    let result = array;
+    get_sorting_index(array);
+    result
+}
+
+unconstrained fn get_sorting_index(array: [Field; 4]) {
+    let _ = [0; 4];
+    let mut a = array;
+    for i in 1..4 {
+        for j in 0..i {
+            a[i] = a[j];
+        }
+    }
+}
+
+unconstrained fn main() {
+    let mut previous_kernel = FixtureBuilder::new();
+    previous_kernel.append_public_call_requests();
+
+    let mut output_composer = PrivateKernelCircuitPublicInputsComposer {
+        l2_to_l1_msgs: [0; 4],
+        public_call_requests: previous_kernel.public_call_requests.storage,
+    };
+    output_composer.l2_to_l1_msgs = sort_by(output_composer.l2_to_l1_msgs);
+    output_composer.public_call_requests = sort_by(output_composer.public_call_requests);
+
+    assert_eq(previous_kernel.public_call_requests.storage[1], 1, "equality");
+}
diff --git a/test_programs/execution_success/regression_6674_2/Nargo.toml b/test_programs/execution_success/regression_6674_2/Nargo.toml
new file mode 100644
index 00000000000..666765c8172
--- /dev/null
+++ b/test_programs/execution_success/regression_6674_2/Nargo.toml
@@ -0,0 +1,6 @@
+[package]
+name = "regression_6674_2"
+type = "bin"
+authors = [""]
+
+[dependencies]
diff --git a/test_programs/execution_success/regression_6674_2/src/main.nr b/test_programs/execution_success/regression_6674_2/src/main.nr
new file mode 100644
index 00000000000..42ad4fa4031
--- /dev/null
+++ b/test_programs/execution_success/regression_6674_2/src/main.nr
@@ -0,0 +1,87 @@
+use std::mem::zeroed;
+
+pub struct BoundedVec4 {
+    storage: [Field; 4],
+    len: u32,
+}
+
+impl BoundedVec4 {
+    pub fn new() -> Self {
+        BoundedVec4 { storage: [0; 4], len: 0 }
+    }
+
+    pub fn push(&mut self, elem: Field) {
+        self.storage[self.len] = elem;
+        self.len += 1;
+    }
+}
+
+pub struct PrivateKernelCircuitPublicInputs {
+    pub l2_to_l1_msgs: [Field; 4],
+    pub public_call_requests: [Field; 4],
+}
+
+pub struct FixtureBuilder {
+    pub public_call_requests: BoundedVec4,
+    pub counter: Field,
+}
+
+impl FixtureBuilder {
+    pub fn new() -> Self {
+        FixtureBuilder { public_call_requests: zeroed(), counter: 0 }
+    }
+
+    pub fn append_public_call_requests(&mut self) {
+        for _ in 0..4 {
+            // Note that here we push directly, not through a method call
+            self.public_call_requests.push(self.next_counter());
+        }
+    }
+
+    fn next_counter(&mut self) -> Field {
+        let counter = self.counter;
+        self.counter += 1;
+        counter
+    }
+}
+
+pub struct PrivateKernelCircuitPublicInputsComposer {
+    pub l2_to_l1_msgs: [Field; 4],
+    pub public_call_requests: [Field; 4],
+}
+
+impl PrivateKernelCircuitPublicInputsComposer {
+    pub unconstrained fn sort_ordered_values(&mut self) {
+        self.l2_to_l1_msgs = sort_by(self.l2_to_l1_msgs);
+        self.public_call_requests = sort_by(self.public_call_requests);
+    }
+}
+
+pub unconstrained fn sort_by(array: [Field; 4]) -> [Field; 4] {
+    let result = array;
+    get_sorting_index(array);
+    result
+}
+
+unconstrained fn get_sorting_index(array: [Field; 4]) {
+    let _ = [0; 4];
+    let mut a = array;
+    for i in 1..4 {
+        for j in 0..i {
+            a[i] = a[j];
+        }
+    }
+}
+
+unconstrained fn main() {
+    let mut previous_kernel = FixtureBuilder::new();
+    previous_kernel.append_public_call_requests();
+
+    let mut output_composer = PrivateKernelCircuitPublicInputsComposer {
+        l2_to_l1_msgs: [0; 4],
+        public_call_requests: previous_kernel.public_call_requests.storage,
+    };
+    output_composer.sort_ordered_values();
+
+    assert_eq(previous_kernel.public_call_requests.storage[1], 1, "equality");
+}
diff --git a/test_programs/execution_success/regression_6674_3/Nargo.toml b/test_programs/execution_success/regression_6674_3/Nargo.toml
new file mode 100644
index 00000000000..7b396f63693
--- /dev/null
+++ b/test_programs/execution_success/regression_6674_3/Nargo.toml
@@ -0,0 +1,6 @@
+[package]
+name = "regression_6674_3"
+type = "bin"
+authors = [""]
+
+[dependencies]
diff --git a/test_programs/execution_success/regression_6674_3/src/main.nr b/test_programs/execution_success/regression_6674_3/src/main.nr
new file mode 100644
index 00000000000..2c87a4c679c
--- /dev/null
+++ b/test_programs/execution_success/regression_6674_3/src/main.nr
@@ -0,0 +1,191 @@
+use std::mem::zeroed;
+
+pub struct PrivateAccumulatedData {
+    pub public_call_requests: [Counted<Field>; 4],
+}
+
+pub struct PrivateAccumulatedDataBuilder {
+    pub l2_to_l1_msgs: BoundedVec<Field, 4>,
+    pub public_call_requests: BoundedVec<Counted<Field>, 4>,
+    pub private_call_stack: BoundedVec<Field, 4>,
+}
+
+impl PrivateAccumulatedDataBuilder {
+    pub fn finish(self) -> PrivateAccumulatedData {
+        PrivateAccumulatedData { public_call_requests: self.public_call_requests.storage() }
+    }
+}
+
+pub struct Counted<T> {
+    pub inner: T,
+    pub counter: u32,
+}
+
+impl<T> Counted<T> {
+    pub fn new(inner: T, counter: u32) -> Self {
+        Self { inner, counter }
+    }
+}
+
+pub struct PrivateKernelCircuitPublicInputs {
+    pub end: PrivateAccumulatedData,
+}
+
+pub struct PrivateKernelData {
+    pub public_inputs: PrivateKernelCircuitPublicInputs,
+}
+
+pub struct FixtureBuilder2 {
+    pub public_teardown_call_request: Field,
+    pub private_call_requests: BoundedVec<Field, 4>,
+    pub public_call_requests: BoundedVec<Counted<Field>, 4>,
+    pub counter: u32,
+}
+
+impl FixtureBuilder2 {
+    pub fn new() -> Self {
+        let mut builder: FixtureBuilder2 = zeroed();
+        builder.counter = 1;
+        builder
+    }
+
+    pub fn to_private_accumulated_data_builder(self) -> PrivateAccumulatedDataBuilder {
+        PrivateAccumulatedDataBuilder {
+            l2_to_l1_msgs: zeroed(),
+            public_call_requests: self.public_call_requests,
+            private_call_stack: vec_reverse(self.private_call_requests),
+        }
+    }
+
+    pub fn to_private_accumulated_data(self) -> PrivateAccumulatedData {
+        self.to_private_accumulated_data_builder().finish()
+    }
+
+    pub fn to_private_kernel_circuit_public_inputs(self) -> PrivateKernelCircuitPublicInputs {
+        PrivateKernelCircuitPublicInputs { end: self.to_private_accumulated_data() }
+    }
+
+    pub fn to_private_kernel_data(self) -> PrivateKernelData {
+        let public_inputs =
+            PrivateKernelCircuitPublicInputs { end: self.to_private_accumulated_data() };
+        PrivateKernelData { public_inputs }
+    }
+
+    pub fn add_public_call_request(&mut self) {
+        self.public_call_requests.push(Counted::new(zeroed(), self.next_counter()));
+    }
+
+    pub fn append_public_call_requests(&mut self, num: u32) {
+        for _ in 0..num {
+            self.add_public_call_request();
+        }
+    }
+
+    pub fn set_public_teardown_call_request(&mut self) {
+        let mut fields = [0; 5];
+        for i in 0..5 {
+            fields[i] = i as Field;
+        }
+
+        self.public_teardown_call_request = zeroed();
+    }
+
+    fn next_counter(&mut self) -> u32 {
+        let counter = self.counter;
+        self.counter += 1;
+        counter
+    }
+}
+
+struct PrivateKernelTailToPublicInputsBuilder {
+    previous_kernel: FixtureBuilder2,
+}
+
+impl PrivateKernelTailToPublicInputsBuilder {
+    pub unconstrained fn execute(&mut self) {
+        let kernel = PrivateKernelTailToPublicCircuitPrivateInputs {
+            previous_kernel: self.previous_kernel.to_private_kernel_data(),
+        };
+        let mut output_composer = PrivateKernelCircuitPublicInputsComposer::new_from_previous_kernel(
+            kernel.previous_kernel.public_inputs,
+        );
+        output_composer.sort_ordered_values();
+    }
+}
+
+pub struct PrivateKernelTailToPublicCircuitPrivateInputs {
+    previous_kernel: PrivateKernelData,
+}
+
+pub struct PrivateKernelCircuitPublicInputsComposer {
+    public_inputs: PrivateKernelCircuitPublicInputsBuilder,
+}
+
+impl PrivateKernelCircuitPublicInputsComposer {
+    pub unconstrained fn sort_ordered_values(&mut self) {
+        // Note hashes, nullifiers, and private logs are sorted in the reset circuit.
+        self.public_inputs.end.l2_to_l1_msgs.storage =
+            sort_by_counter_desc(self.public_inputs.end.l2_to_l1_msgs.storage);
+        self.public_inputs.end.public_call_requests.storage =
+            sort_by_counter_desc(self.public_inputs.end.public_call_requests.storage);
+    }
+}
+
+impl PrivateKernelCircuitPublicInputsComposer {
+    pub fn new_from_previous_kernel(
+        previous_kernel_public_inputs: PrivateKernelCircuitPublicInputs,
+    ) -> Self {
+        let mut public_inputs: PrivateKernelCircuitPublicInputsBuilder = zeroed();
+        let start = previous_kernel_public_inputs.end;
+        public_inputs.end.public_call_requests = BoundedVec {
+            storage: start.public_call_requests,
+            len: start.public_call_requests.len(),
+        };
+        PrivateKernelCircuitPublicInputsComposer { public_inputs }
+    }
+}
+
+pub struct PrivateKernelCircuitPublicInputsBuilder {
+    end: PrivateAccumulatedDataBuilder,
+}
+
+fn vec_reverse<T, let N: u32>(vec: BoundedVec<T, N>) -> BoundedVec<T, N> {
+    let mut reversed = BoundedVec::new();
+    let len = vec.len();
+    for i in 0..N {
+        if i < len {
+            reversed.push(vec.get_unchecked(len - i - 1));
+        }
+    }
+    reversed
+}
+
+pub unconstrained fn sort_by_counter_desc<T, let N: u32>(array: [T; N]) -> [T; N] {
+    sort_by(array)
+}
+
+pub unconstrained fn sort_by<T, let N: u32>(array: [T; N]) -> [T; N] {
+    let mut result = array;
+    unsafe { get_sorting_index(array) };
+    result
+}
+
+unconstrained fn get_sorting_index<T, let N: u32>(array: [T; N]) {
+    let _ = [0; 4];
+    let mut a = array;
+    for i in 1..4 {
+        for j in 0..i {
+            a[i] = a[j];
+        }
+    }
+}
+
+unconstrained fn main() {
+    let mut previous_kernel = FixtureBuilder2::new();
+    let mut builder = PrivateKernelTailToPublicInputsBuilder { previous_kernel };
+    builder.previous_kernel.append_public_call_requests(4);
+    assert_eq(builder.previous_kernel.public_call_requests.storage[3].counter, 4);
+    builder.previous_kernel.set_public_teardown_call_request();
+    builder.execute();
+    assert_eq(builder.previous_kernel.public_call_requests.storage[3].counter, 4);
+}
diff --git a/test_programs/execution_success/brillig_assert/Nargo.toml b/test_programs/execution_success/regression_6734/Nargo.toml
similarity index 68%
rename from test_programs/execution_success/brillig_assert/Nargo.toml
rename to test_programs/execution_success/regression_6734/Nargo.toml
index b7d9231ab75..4c757bab454 100644
--- a/test_programs/execution_success/brillig_assert/Nargo.toml
+++ b/test_programs/execution_success/regression_6734/Nargo.toml
@@ -1,5 +1,5 @@
 [package]
-name = "brillig_assert"
+name = "regression_6734"
 type = "bin"
 authors = [""]
 
diff --git a/test_programs/execution_success/regression_6734/src/main.nr b/test_programs/execution_success/regression_6734/src/main.nr
new file mode 100644
index 00000000000..87cac64aaa1
--- /dev/null
+++ b/test_programs/execution_success/regression_6734/src/main.nr
@@ -0,0 +1,24 @@
+// https://github.com/noir-lang/noir/issues/6734
+
+pub fn sub_array_extended<let SRC_LEN: u32, let DST_LEN: u32>(
+    src: [Field; SRC_LEN],
+    offset: u32,
+) -> [Field; DST_LEN] {
+    let available_elements_to_copy = SRC_LEN - offset;
+    let elements_to_copy = if DST_LEN > available_elements_to_copy {
+        available_elements_to_copy
+    } else {
+        DST_LEN
+    };
+
+    let mut dst: [Field; DST_LEN] = std::mem::zeroed();
+    for i in 0..elements_to_copy {
+        dst[i] = src[i + offset];
+    }
+
+    dst
+}
+
+unconstrained fn main() {
+    assert_eq(sub_array_extended([], 0), []);
+}
diff --git a/test_programs/execution_success/regression_capacity_tracker/src/main.nr b/test_programs/execution_success/regression_capacity_tracker/src/main.nr
index be645c811d2..11690b5c186 100644
--- a/test_programs/execution_success/regression_capacity_tracker/src/main.nr
+++ b/test_programs/execution_success/regression_capacity_tracker/src/main.nr
@@ -1,14 +1,14 @@
 // Reference https://github.com/noir-lang/noir/issues/4395#issuecomment-2018948631
-// for context. 
+// for context.
 // We were not accurately accounting for situations where the slice capacity tracker
 // was expecting a capacity from slice intrinsic results.
 fn main(expected: pub Field, first: Field, input: [Field; 20]) {
     let mut hasher_slice = input.as_slice();
     hasher_slice = hasher_slice.push_front(first);
     assert(hasher_slice[0] == expected);
-    // We need a conditional based upon witnesses 
-    // to force a store of the slice. 
-    // If this successfully compiles it means we have stored 
+    // We need a conditional based upon witnesses
+    // to force a store of the slice.
+    // If this successfully compiles it means we have stored
     // the results of the slice intrinsics used above.
     if expected as u32 > 10 {
         hasher_slice[expected - 10] = 100;
diff --git a/test_programs/execution_success/regression_struct_array_conditional/src/main.nr b/test_programs/execution_success/regression_struct_array_conditional/src/main.nr
index 17502a9fe50..fe5f1ef1918 100644
--- a/test_programs/execution_success/regression_struct_array_conditional/src/main.nr
+++ b/test_programs/execution_success/regression_struct_array_conditional/src/main.nr
@@ -1,15 +1,15 @@
-struct foo { 
+struct foo {
     value: Field,
     counter: u8,
     dummy: u8,
 }
 struct bar {
-    dummy: [u8;3],
+    dummy: [u8; 3],
     value: Field,
     counter: u8,
 }
 struct bar_field {
-    dummy: [Field;3],
+    dummy: [Field; 3],
     value: Field,
     counter: u8,
 }
diff --git a/test_programs/execution_success/regression_unsafe_no_predicates/src/main.nr b/test_programs/execution_success/regression_unsafe_no_predicates/src/main.nr
index 63c2493fc89..fc1e55ee641 100644
--- a/test_programs/execution_success/regression_unsafe_no_predicates/src/main.nr
+++ b/test_programs/execution_success/regression_unsafe_no_predicates/src/main.nr
@@ -7,9 +7,7 @@ fn main(x: u8, nest: bool) {
 
 #[no_predicates]
 pub fn unsafe_assert<let N: u32>(msg: [u8; N]) -> u8 {
-    let block = unsafe {
-        get_block(msg)
-    };
+    let block = unsafe { get_block(msg) };
     verify_block(msg, block);
     block[0]
 }
diff --git a/test_programs/execution_success/return_twice/Nargo.toml b/test_programs/execution_success/return_twice/Nargo.toml
new file mode 100644
index 00000000000..defd68f37b8
--- /dev/null
+++ b/test_programs/execution_success/return_twice/Nargo.toml
@@ -0,0 +1,7 @@
+[package]
+name = "return_twice"
+version = "0.1.0"
+type = "bin"
+authors = [""]
+
+[dependencies]
diff --git a/test_programs/execution_success/return_twice/Prover.toml b/test_programs/execution_success/return_twice/Prover.toml
new file mode 100644
index 00000000000..b343065a7fc
--- /dev/null
+++ b/test_programs/execution_success/return_twice/Prover.toml
@@ -0,0 +1,2 @@
+return = [100, 100]
+in0 = 10
diff --git a/test_programs/execution_success/return_twice/src/main.nr b/test_programs/execution_success/return_twice/src/main.nr
new file mode 100644
index 00000000000..68bd5f916ce
--- /dev/null
+++ b/test_programs/execution_success/return_twice/src/main.nr
@@ -0,0 +1,5 @@
+pub fn main(in0: Field) -> pub (Field, Field) {
+    let out0 = (in0 * in0);
+    let out1 = (in0 * in0);
+    (out0, out1)
+}
diff --git a/test_programs/execution_success/schnorr/Prover.toml b/test_programs/execution_success/schnorr/Prover.toml
deleted file mode 100644
index 2faf2018e07..00000000000
--- a/test_programs/execution_success/schnorr/Prover.toml
+++ /dev/null
@@ -1,70 +0,0 @@
-message = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
-message_field = "0x010203040506070809"
-pub_key_x = "0x04b260954662e97f00cab9adb773a259097f7a274b83b113532bce27fa3fb96a"
-pub_key_y = "0x2fd51571db6c08666b0edfbfbc57d432068bccd0110a39b166ab243da0037197"
-signature = [
-    1,
-    13,
-    119,
-    112,
-    212,
-    39,
-    233,
-    41,
-    84,
-    235,
-    255,
-    93,
-    245,
-    172,
-    186,
-    83,
-    157,
-    253,
-    76,
-    77,
-    33,
-    128,
-    178,
-    15,
-    214,
-    67,
-    105,
-    107,
-    177,
-    234,
-    77,
-    48,
-    27,
-    237,
-    155,
-    84,
-    39,
-    84,
-    247,
-    27,
-    22,
-    8,
-    176,
-    230,
-    24,
-    115,
-    145,
-    220,
-    254,
-    122,
-    135,
-    179,
-    171,
-    4,
-    214,
-    202,
-    64,
-    199,
-    19,
-    84,
-    239,
-    138,
-    124,
-    12,
-]
diff --git a/test_programs/execution_success/schnorr/src/main.nr b/test_programs/execution_success/schnorr/src/main.nr
deleted file mode 100644
index 835ea2ffb1f..00000000000
--- a/test_programs/execution_success/schnorr/src/main.nr
+++ /dev/null
@@ -1,28 +0,0 @@
-use std::embedded_curve_ops;
-
-// Note: If main has any unsized types, then the verifier will never be able
-// to figure out the circuit instance
-fn main(
-    message: [u8; 10],
-    message_field: Field,
-    pub_key_x: Field,
-    pub_key_y: Field,
-    signature: [u8; 64]
-) {
-    // Regression for issue #2421
-    // We want to make sure that we can accurately verify a signature whose message is a slice vs. an array
-    let message_field_bytes: [u8; 10] = message_field.to_be_bytes();
-
-    // Is there ever a situation where someone would want 
-    // to ensure that a signature was invalid?
-    // Check that passing a slice as the message is valid
-    let valid_signature = std::schnorr::verify_signature_slice(pub_key_x, pub_key_y, signature, message_field_bytes);
-    assert(valid_signature);
-    // Check that passing an array as the message is valid
-    let valid_signature = std::schnorr::verify_signature(pub_key_x, pub_key_y, signature, message);
-    assert(valid_signature);
-    let pub_key = embedded_curve_ops::EmbeddedCurvePoint { x: pub_key_x, y: pub_key_y, is_infinite: false };
-    let valid_signature = std::schnorr::verify_signature_noir(pub_key, signature, message);
-    assert(valid_signature);
-    std::schnorr::assert_valid_signature(pub_key, signature, message);
-}
diff --git a/test_programs/execution_success/sha256/src/main.nr b/test_programs/execution_success/sha256/src/main.nr
index 29bc9ac371a..8e5e46b9837 100644
--- a/test_programs/execution_success/sha256/src/main.nr
+++ b/test_programs/execution_success/sha256/src/main.nr
@@ -1,5 +1,5 @@
 // Sha256 example
-// 
+//
 // Calls Sha256 from the standard library.
 //
 // The Compiler sees this special function and creates an ACIR gate
@@ -9,7 +9,6 @@
 //
 // Not yet here: For R1CS, it is more about manipulating arithmetic gates to get performance
 // This can be done in ACIR!
-
 fn main(x: Field, result: [u8; 32], input: [u8; 2], toggle: bool) {
     // We use the `as` keyword here to denote the fact that we want to take just the first byte from the x Field
     // The padding is taken care of by the program
@@ -18,6 +17,9 @@ fn main(x: Field, result: [u8; 32], input: [u8; 2], toggle: bool) {
     // docs:end:sha256_var
     assert(digest == result);
 
+    let digest = std::hash::sha256([x as u8]);
+    assert(digest == result);
+
     // variable size
     let size: Field = 1 + toggle as Field;
     let var_sha = std::hash::sha256_var(input, size as u64);
diff --git a/test_programs/execution_success/sha256_brillig_performance_regression/Nargo.toml b/test_programs/execution_success/sha256_brillig_performance_regression/Nargo.toml
new file mode 100644
index 00000000000..f7076311e1d
--- /dev/null
+++ b/test_programs/execution_success/sha256_brillig_performance_regression/Nargo.toml
@@ -0,0 +1,7 @@
+[package]
+name = "sha256_brillig_performance_regression"
+type = "bin"
+authors = [""]
+compiler_version = ">=0.33.0"
+
+[dependencies]
diff --git a/test_programs/execution_success/sha256_brillig_performance_regression/Prover.toml b/test_programs/execution_success/sha256_brillig_performance_regression/Prover.toml
new file mode 100644
index 00000000000..5bb7f354257
--- /dev/null
+++ b/test_programs/execution_success/sha256_brillig_performance_regression/Prover.toml
@@ -0,0 +1,16 @@
+input_amount = "1"
+minimum_output_amount = "2"
+secret_hash_for_L1_to_l2_message = "3"
+uniswap_fee_tier = "4"
+
+[aztec_recipient]
+inner = "5"
+
+[caller_on_L1]
+inner = "6"
+
+[input_asset_bridge_portal_address]
+inner = "7"
+
+[output_asset_bridge_portal_address]
+inner = "8"
diff --git a/test_programs/execution_success/sha256_brillig_performance_regression/src/main.nr b/test_programs/execution_success/sha256_brillig_performance_regression/src/main.nr
new file mode 100644
index 00000000000..42cc6d4ff3b
--- /dev/null
+++ b/test_programs/execution_success/sha256_brillig_performance_regression/src/main.nr
@@ -0,0 +1,104 @@
+// Performance regression extracted from an aztec protocol contract.
+
+unconstrained fn main(
+    input_asset_bridge_portal_address: EthAddress,
+    input_amount: Field,
+    uniswap_fee_tier: Field,
+    output_asset_bridge_portal_address: EthAddress,
+    minimum_output_amount: Field,
+    aztec_recipient: AztecAddress,
+    secret_hash_for_L1_to_l2_message: Field,
+    caller_on_L1: EthAddress,
+) -> pub Field {
+    let mut hash_bytes = [0; 260]; // 8 fields of 32 bytes each + 4 bytes fn selector
+    let input_token_portal_bytes: [u8; 32] =
+        input_asset_bridge_portal_address.to_field().to_be_bytes();
+    let in_amount_bytes: [u8; 32] = input_amount.to_be_bytes();
+    let uniswap_fee_tier_bytes: [u8; 32] = uniswap_fee_tier.to_be_bytes();
+    let output_token_portal_bytes: [u8; 32] =
+        output_asset_bridge_portal_address.to_field().to_be_bytes();
+    let amount_out_min_bytes: [u8; 32] = minimum_output_amount.to_be_bytes();
+    let aztec_recipient_bytes: [u8; 32] = aztec_recipient.to_field().to_be_bytes();
+    let secret_hash_for_L1_to_l2_message_bytes: [u8; 32] =
+        secret_hash_for_L1_to_l2_message.to_be_bytes();
+    let caller_on_L1_bytes: [u8; 32] = caller_on_L1.to_field().to_be_bytes();
+
+    // The purpose of including the following selector is to make the message unique to that specific call. Note that
+    // it has nothing to do with calling the function.
+    let selector = comptime {
+        std::hash::keccak256(
+            "swap_public(address,uint256,uint24,address,uint256,bytes32,bytes32,address)".as_bytes(),
+            75,
+        )
+    };
+
+    hash_bytes[0] = selector[0];
+    hash_bytes[1] = selector[1];
+    hash_bytes[2] = selector[2];
+    hash_bytes[3] = selector[3];
+
+    for i in 0..32 {
+        hash_bytes[i + 4] = input_token_portal_bytes[i];
+        hash_bytes[i + 36] = in_amount_bytes[i];
+        hash_bytes[i + 68] = uniswap_fee_tier_bytes[i];
+        hash_bytes[i + 100] = output_token_portal_bytes[i];
+        hash_bytes[i + 132] = amount_out_min_bytes[i];
+        hash_bytes[i + 164] = aztec_recipient_bytes[i];
+        hash_bytes[i + 196] = secret_hash_for_L1_to_l2_message_bytes[i];
+        hash_bytes[i + 228] = caller_on_L1_bytes[i];
+    }
+
+    let content_hash = sha256_to_field(hash_bytes);
+    content_hash
+}
+
+// Convert a 32 byte array to a field element by truncating the final byte
+pub fn field_from_bytes_32_trunc(bytes32: [u8; 32]) -> Field {
+    // Convert it to a field element
+    let mut v = 1;
+    let mut high = 0 as Field;
+    let mut low = 0 as Field;
+
+    for i in 0..15 {
+        // covers bytes 16..30 (31 is truncated and ignored)
+        low = low + (bytes32[15 + 15 - i] as Field) * v;
+        v = v * 256;
+        // covers bytes 0..14
+        high = high + (bytes32[14 - i] as Field) * v;
+    }
+    // covers byte 15
+    low = low + (bytes32[15] as Field) * v;
+
+    low + high * v
+}
+
+pub fn sha256_to_field<let N: u32>(bytes_to_hash: [u8; N]) -> Field {
+    let sha256_hashed = std::hash::sha256(bytes_to_hash);
+    let hash_in_a_field = field_from_bytes_32_trunc(sha256_hashed);
+
+    hash_in_a_field
+}
+
+pub trait ToField {
+    fn to_field(self) -> Field;
+}
+
+pub struct EthAddress {
+    inner: Field,
+}
+
+impl ToField for EthAddress {
+    fn to_field(self) -> Field {
+        self.inner
+    }
+}
+
+pub struct AztecAddress {
+    pub inner: Field,
+}
+
+impl ToField for AztecAddress {
+    fn to_field(self) -> Field {
+        self.inner
+    }
+}
diff --git a/test_programs/execution_success/sha256_regression/src/main.nr b/test_programs/execution_success/sha256_regression/src/main.nr
index 83049640ac4..dbbcc07e501 100644
--- a/test_programs/execution_success/sha256_regression/src/main.nr
+++ b/test_programs/execution_success/sha256_regression/src/main.nr
@@ -14,7 +14,7 @@ fn main(
     // This is the same as `msg_big_with_padding` but with no padding
     msg_big_no_padding: [u8; 297],
     message_size: u64,
-    result_big_with_padding: pub [u8; 32]
+    result_big_with_padding: pub [u8; 32],
 ) {
     let hash = std::hash::sha256_var(msg_just_over_block, msg_just_over_block.len() as u64);
     assert_eq(hash, result_just_over_block);
@@ -27,7 +27,7 @@ fn main(
 
     let hash = std::hash::sha256_var(
         msg_big_not_block_multiple,
-        msg_big_not_block_multiple.len() as u64
+        msg_big_not_block_multiple.len() as u64,
     );
     assert_eq(hash, result_big);
 
diff --git a/test_programs/execution_success/sha256_var_padding_regression/Nargo.toml b/test_programs/execution_success/sha256_var_padding_regression/Nargo.toml
new file mode 100644
index 00000000000..a80677c585d
--- /dev/null
+++ b/test_programs/execution_success/sha256_var_padding_regression/Nargo.toml
@@ -0,0 +1,7 @@
+[package]
+name = "sha256_var_padding_regression"
+type = "bin"
+authors = [""]
+compiler_version = ">=0.34.0"
+
+[dependencies]
\ No newline at end of file
diff --git a/test_programs/execution_success/sha256_var_padding_regression/Prover.toml b/test_programs/execution_success/sha256_var_padding_regression/Prover.toml
new file mode 100644
index 00000000000..7b20e870128
--- /dev/null
+++ b/test_programs/execution_success/sha256_var_padding_regression/Prover.toml
@@ -0,0 +1,2 @@
+preimage = [29, 81, 165, 84, 243, 114, 101, 37, 242, 146, 127, 99, 69, 145, 39, 72, 213, 39, 253, 179, 218, 37, 217, 201, 172, 93, 198, 50, 249, 70, 15, 30, 162, 112, 187, 40, 140, 9, 236, 53, 32, 44, 38, 163, 113, 254, 192, 197, 44, 89, 71, 130, 169, 242, 17, 211, 214, 72, 19, 178, 186, 168, 147, 127, 99, 101, 252, 227, 8, 147, 150, 85, 97, 158, 17, 107, 218, 244, 82, 113, 247, 91, 208, 214, 60, 244, 87, 137, 173, 201, 130, 18, 66, 56, 198, 149, 207, 189, 175, 120, 123, 224, 177, 167, 251, 159, 143, 110, 68, 183, 189, 70, 126, 32, 35, 164, 44, 30, 44, 12, 65, 18, 62, 239, 242, 2, 248, 104, 2, 178, 64, 28, 126, 36, 137, 24, 14, 116, 91, 98, 90, 159, 218, 102, 45, 11, 110, 223, 245, 184, 52, 99, 59, 245, 136, 175, 3, 72, 164, 146, 145, 116, 22, 66, 24, 49, 193, 121, 3, 60, 37, 41, 97, 3, 190, 66, 195, 225, 63, 46, 3, 118, 4, 208, 15, 1, 40, 254, 235, 151, 123, 70, 180, 170, 44, 172, 90, 4, 254, 53, 239, 116, 246, 67, 56, 129, 61, 22, 169, 213, 65, 27, 216, 116, 162, 239, 214, 207, 126, 177, 20, 100, 25, 48, 143, 84, 215, 70, 197, 53, 65, 70, 86, 172, 61, 62, 9, 212, 167, 169, 133, 41, 126, 213, 196, 33, 192, 238, 0, 63, 246, 215, 58, 128, 110, 101, 92, 3, 170, 214, 130, 149, 52, 81, 125, 118, 233, 3, 118, 193, 104, 207, 120, 115, 77, 253, 191, 122, 0, 107, 164, 207, 113, 81, 169, 36, 201, 228, 74, 134, 131, 218, 178, 35, 30, 216, 101, 2, 103, 174, 87, 95, 50, 50, 215, 157, 5, 210, 188, 54, 211, 78, 45, 199, 96, 121, 241, 241, 176, 226, 194, 134, 130, 89, 217, 210, 186, 32, 140, 39, 91, 103, 212, 26, 87, 32, 72, 144, 228, 230, 117, 99, 188, 50, 15, 69, 79, 179, 50, 12, 106, 86, 218, 101, 73, 142, 243, 29, 250, 122, 228, 233, 29, 255, 22, 121, 114, 125, 103, 41, 250, 241, 179, 126, 158, 198, 116, 209, 65, 94, 98, 228, 175, 169, 96, 3, 9, 233, 133, 214, 55, 161, 164, 103, 80, 85, 24, 186, 64, 167, 92, 131, 53, 101, 202, 47, 25, 104, 118, 155, 14, 12, 12, 25, 116, 45, 221, 249, 28, 246, 212, 200, 157, 167, 169, 56, 197, 181, 4, 245, 146, 1, 140, 234, 191, 212, 228, 125, 87, 81, 86, 119, 30, 63, 129, 143, 32, 96]
+result = [205, 74, 73, 134, 202, 93, 199, 152, 171, 244, 133, 193, 132, 40, 42, 9, 248, 11, 99, 200, 135, 58, 220, 227, 45, 253, 183, 241, 69, 69, 80, 219]
\ No newline at end of file
diff --git a/test_programs/execution_success/sha256_var_padding_regression/src/main.nr b/test_programs/execution_success/sha256_var_padding_regression/src/main.nr
new file mode 100644
index 00000000000..13f87a0efc5
--- /dev/null
+++ b/test_programs/execution_success/sha256_var_padding_regression/src/main.nr
@@ -0,0 +1,29 @@
+// Test to check sha256_var produces same results irrespective of number of padding bytes after message.length
+// Ref: https://github.com/noir-lang/noir/issues/6163, https://gist.github.com/jp4g/d5953faae9eadb2909357474f7901e58
+fn main(preimage: [u8; 448], result: [u8; 32]) {
+    // Construct arrays of different lengths
+    let mut preimage_511 = [0; 511];
+    let mut preimage_512 = [0; 512]; // Next block
+    let mut preimage_575 = [0; 575];
+    let mut preimage_576 = [0; 576]; // Next block
+    for i in 0..preimage.len() {
+        preimage_511[i] = preimage[i];
+        preimage_512[i] = preimage[i];
+        preimage_575[i] = preimage[i];
+        preimage_576[i] = preimage[i];
+    }
+    let fixed_length_hash = std::hash::sha256::digest(preimage);
+    let var_full_length_hash = std::hash::sha256::sha256_var(preimage, preimage.len() as u64);
+    let var_length_hash_511 = std::hash::sha256::sha256_var(preimage_511, preimage.len() as u64);
+    let var_length_hash_512 = std::hash::sha256::sha256_var(preimage_512, preimage.len() as u64);
+    let var_length_hash_575 = std::hash::sha256::sha256_var(preimage_575, preimage.len() as u64);
+    let var_length_hash_576 = std::hash::sha256::sha256_var(preimage_576, preimage.len() as u64);
+
+    // All of the above should have produced the same hash (result)
+    assert(fixed_length_hash == result);
+    assert(var_full_length_hash == result);
+    assert(var_length_hash_511 == result);
+    assert(var_length_hash_512 == result);
+    assert(var_length_hash_575 == result);
+    assert(var_length_hash_576 == result);
+}
diff --git a/test_programs/execution_success/sha256_var_size_regression/src/main.nr b/test_programs/execution_success/sha256_var_size_regression/src/main.nr
index de1c2b23c5f..4278cdda8a3 100644
--- a/test_programs/execution_success/sha256_var_size_regression/src/main.nr
+++ b/test_programs/execution_success/sha256_var_size_regression/src/main.nr
@@ -1,4 +1,4 @@
-global NUM_HASHES = 2;
+global NUM_HASHES: u32 = 2;
 
 fn main(foo: [u8; 95], toggle: bool, enable: [bool; NUM_HASHES]) {
     let mut result = [[0; 32]; NUM_HASHES];
diff --git a/test_programs/execution_success/sha2_byte/src/main.nr b/test_programs/execution_success/sha2_byte/src/main.nr
index aecd9fba2f3..1b4bed1a643 100644
--- a/test_programs/execution_success/sha2_byte/src/main.nr
+++ b/test_programs/execution_success/sha2_byte/src/main.nr
@@ -1,5 +1,4 @@
 // Test Noir implementations of SHA256 and SHA512 on a one-byte message.
-
 fn main(x: Field, result256: [u8; 32], result512: [u8; 64]) {
     let digest256 = std::sha256::digest([x as u8]);
     assert(digest256 == result256);
diff --git a/test_programs/execution_success/signed_arithmetic/src/main.nr b/test_programs/execution_success/signed_arithmetic/src/main.nr
index 7a997d177ba..9b72b688bc5 100644
--- a/test_programs/execution_success/signed_arithmetic/src/main.nr
+++ b/test_programs/execution_success/signed_arithmetic/src/main.nr
@@ -4,7 +4,7 @@ fn main(mut x: i32, mut y: i32, z: i32) {
     assert(s1 + s2 == 13);
     assert(x + y == 13);
 
-    s2= -8;
+    s2 = -8;
     y = -y;
     assert(s1 + s2 == -3);
     assert(x + y == -3);
diff --git a/test_programs/execution_success/signed_division/src/main.nr b/test_programs/execution_success/signed_division/src/main.nr
index 207ef59986b..64ba4a5354c 100644
--- a/test_programs/execution_success/signed_division/src/main.nr
+++ b/test_programs/execution_success/signed_division/src/main.nr
@@ -1,4 +1,4 @@
-// Testing signed integer division: 
+// Testing signed integer division:
 //  7/3  = 2
 // -7/3  = -2
 // -7/-3 = 2
diff --git a/test_programs/execution_success/simple_add_and_ret_arr/src/main.nr b/test_programs/execution_success/simple_add_and_ret_arr/src/main.nr
index 016c4fedf40..891ea9c4982 100644
--- a/test_programs/execution_success/simple_add_and_ret_arr/src/main.nr
+++ b/test_programs/execution_success/simple_add_and_ret_arr/src/main.nr
@@ -1,4 +1,4 @@
-// A simple program to test that SSA array values elements 
+// A simple program to test that SSA array values elements
 // aren't disconnected from their instruction results, and
 // that dead instruction elemination looks inside of arrays
 // when deciding whether of not an instruction should be
diff --git a/test_programs/execution_success/simple_comparison/src/main.nr b/test_programs/execution_success/simple_comparison/src/main.nr
index 05800440459..45c4e4a0321 100644
--- a/test_programs/execution_success/simple_comparison/src/main.nr
+++ b/test_programs/execution_success/simple_comparison/src/main.nr
@@ -1,5 +1,5 @@
 // Tests a very simple program.
-// 
+//
 // The features being tested is comparison
 fn main(x: Field, y: Field) {
     assert(x as u32 < y as u32);
diff --git a/test_programs/execution_success/simple_print/src/main.nr b/test_programs/execution_success/simple_print/src/main.nr
index 3a68f8cc4c3..938f770c5a5 100644
--- a/test_programs/execution_success/simple_print/src/main.nr
+++ b/test_programs/execution_success/simple_print/src/main.nr
@@ -1,6 +1,5 @@
 // Simple program for testing the logging
 // of single witnesses and witness arrays.
-
 fn main(x: Field, y: pub Field) {
     std::println(x);
     std::println([x, y]);
diff --git a/test_programs/execution_success/simple_shield/src/main.nr b/test_programs/execution_success/simple_shield/src/main.nr
index fd2fc20d08f..35b50150986 100644
--- a/test_programs/execution_success/simple_shield/src/main.nr
+++ b/test_programs/execution_success/simple_shield/src/main.nr
@@ -1,6 +1,6 @@
 fn main(
     // Public key of note
-  // all notes have the same denomination
+    // all notes have the same denomination
     priv_key: Field,
     // Merkle membership proof
     note_root: pub Field,
@@ -8,7 +8,7 @@ fn main(
     note_hash_path: [Field; 3],
     // Receiver public key
     to_pubkey_x: Field,
-    to_pubkey_y: Field
+    to_pubkey_y: Field,
 ) -> pub [Field; 2] {
     let priv_key_as_scalar = std::embedded_curve_ops::EmbeddedCurveScalar { lo: priv_key, hi: 0 };
     // Compute public key from private key to show ownership
diff --git a/test_programs/execution_success/simple_shift_left_right/src/main.nr b/test_programs/execution_success/simple_shift_left_right/src/main.nr
index 40698af6ce7..f5d06eff25a 100644
--- a/test_programs/execution_success/simple_shift_left_right/src/main.nr
+++ b/test_programs/execution_success/simple_shift_left_right/src/main.nr
@@ -1,5 +1,5 @@
 // Tests a very simple program.
-// 
+//
 // The features being tested are left and right shifts.
 fn main(x: u32) {
     let z = x >> 4;
diff --git a/test_programs/execution_success/single_verify_proof/src/main.nr b/test_programs/execution_success/single_verify_proof/src/main.nr
index 4eb0cfdf6d0..6073087d644 100644
--- a/test_programs/execution_success/single_verify_proof/src/main.nr
+++ b/test_programs/execution_success/single_verify_proof/src/main.nr
@@ -1,5 +1,4 @@
-
-// This circuit aggregates one proof from `assert_statement_recursive`.
+// This circuit aggregates one proof from `assert_statement`.
 fn main(
     verification_key: [Field; 114],
     // This is the proof without public inputs attached.
@@ -9,7 +8,7 @@ fn main(
     public_inputs: pub [Field; 1],
     // This is currently not public. It is fine given that the vk is a part of the circuit definition.
     // I believe we want to eventually make it public too though.
-    key_hash: Field
+    key_hash: Field,
 ) {
     std::verify_proof(verification_key, proof, public_inputs, key_hash);
 }
diff --git a/test_programs/execution_success/slice_regex/src/main.nr b/test_programs/execution_success/slice_regex/src/main.nr
index 15768248473..4ba33e83903 100644
--- a/test_programs/execution_success/slice_regex/src/main.nr
+++ b/test_programs/execution_success/slice_regex/src/main.nr
@@ -55,7 +55,11 @@ impl<let N: u32> Regex for str<N> {
 }
 
 // And
-impl<T, U> Regex for (T, U) where T: Regex, U: Regex {
+impl<T, U> Regex for (T, U)
+where
+    T: Regex,
+    U: Regex,
+{
     fn match(self, input: [u8]) -> Match {
         let lhs_result = self.0.match(input);
         if lhs_result.succeeded {
@@ -64,7 +68,7 @@ impl<T, U> Regex for (T, U) where T: Regex, U: Regex {
                 Match {
                     succeeded: true,
                     match_ends: lhs_result.match_ends + rhs_result.match_ends,
-                    leftover: rhs_result.leftover
+                    leftover: rhs_result.leftover,
                 }
             } else {
                 Match { succeeded: false, match_ends: 0, leftover: input }
@@ -80,7 +84,10 @@ struct Repeated<T, let N: u32> {
     inner: T,
 }
 
-impl<T, let N: u32> Regex for Repeated<T, N> where T: Regex {
+impl<T, let N: u32> Regex for Repeated<T, N>
+where
+    T: Regex,
+{
     fn match(self, input: [u8]) -> Match {
         let mut result = Match::empty(input);
         for _ in 0..N {
@@ -102,7 +109,11 @@ struct Or<T, U> {
     rhs: U,
 }
 
-impl<T, U> Regex for Or<T, U> where T: Regex, U: Regex {
+impl<T, U> Regex for Or<T, U>
+where
+    T: Regex,
+    U: Regex,
+{
     fn match(self, input: [u8]) -> Match {
         let lhs_result = self.lhs.match(input);
         if lhs_result.succeeded {
@@ -117,7 +128,10 @@ struct Question<T> {
     inner: T,
 }
 
-impl<T> Regex for Question<T> where T: Regex {
+impl<T> Regex for Question<T>
+where
+    T: Regex,
+{
     fn match(self, input: [u8]) -> Match {
         Or { lhs: self.inner, rhs: () }.match(input)
     }
@@ -128,7 +142,10 @@ struct Star<T, let N: u32> {
     inner: T,
 }
 
-impl<T, let N: u32> Regex for Star<T, N> where T: Regex {
+impl<T, let N: u32> Regex for Star<T, N>
+where
+    T: Regex,
+{
     fn match(self, input: [u8]) -> Match {
         let regex: Repeated<_, N> = Repeated { inner: Question { inner: self.inner } };
         regex.match(input)
@@ -140,7 +157,10 @@ struct Plus<T, let N: u32, let N_PRED: u32> {
     inner: T,
 }
 
-impl<T, let N: u32, let N_PRED: u32> Regex for Plus<T, N, N_PRED> where T: Regex {
+impl<T, let N: u32, let N_PRED: u32> Regex for Plus<T, N, N_PRED>
+where
+    T: Regex,
+{
     fn match(self, input: [u8]) -> Match {
         std::static_assert(N_PRED + 1 == N, "N - 1 != N_PRED");
         let star: Star<T, N_PRED> = Star { inner: self.inner };
@@ -208,34 +228,34 @@ fn main() {
     let result = three_ones_regex.match("1111".as_bytes().as_slice());
     println(result);
     assert_eq(result, Match { succeeded: true, match_ends: 3, leftover: &[] });
-    // TODO(https://github.com/noir-lang/noir/issues/5462): re-enable these cases and complete the test using array_regex below
-    // 
+    // TODO(https://github.com/noir-lang/noir/issues/6285): re-enable these cases and complete the test using array_regex below
+    //
     // // 1*
     // let ones_regex: Star<str<1>, 5> = Star { inner: "1" };
-    // 
+    //
     // let result = ones_regex.match("11000".as_bytes().as_slice());
     // println(result);
     // assert_eq(result, Match { succeeded: true, match_ends: 2, leftover: &[] });
-    // 
+    //
     // let result = ones_regex.match("11".as_bytes().as_slice());
     // println(result);
     // assert_eq(result, Match { succeeded: true, match_ends: 2, leftover: &[] });
-    // 
+    //
     // let result = ones_regex.match("111111".as_bytes().as_slice());
     // println(result);
     // assert_eq(result, Match { succeeded: true, match_ends: 5, leftover: &[] });
-    // 
-    // 
+    //
+    //
     // // 1+
     // let nonempty_ones_regex: Plus<str<1>, 5, 4> = Plus { inner: "1" };
-    // 
+    //
     // let result = nonempty_ones_regex.match("111111".as_bytes().as_slice());
     // println(result);
     // assert_eq(result, Match { succeeded: true, match_ends: 5, leftover: &[] });
-    // 
+    //
     // // 2^n-1 in binary: 1+0
     // let pred_pow_two_regex = (nonempty_ones_regex, "0");
-    // 
+    //
     // let result = pred_pow_two_regex.match("1110".as_bytes().as_slice());
     // println(result);
     // assert_eq(result, Match { succeeded: true, match_ends: 3, leftover: &[] });
@@ -279,14 +299,16 @@ fn main() {
     // });
 }
 
-// array_regex: use to complete test once https://github.com/noir-lang/noir/issues/5462 is resolved
+// TODO
+// array_regex execution_success test:
+// use to complete test once https://github.com/noir-lang/noir/issues/6285 is resolved
 //
 // // offset <= len <= N
 // struct Bvec<T, let N: u32> {
 //     inner: [T; N],
 //
 //     // elements at indices < offset are zero
-//     offset: u32, 
+//     offset: u32,
 //
 //     // elements at indices >= len are zero
 //     len: u32,
diff --git a/test_programs/execution_success/slices/src/main.nr b/test_programs/execution_success/slices/src/main.nr
index 47272869b04..f1f2580d6c8 100644
--- a/test_programs/execution_success/slices/src/main.nr
+++ b/test_programs/execution_success/slices/src/main.nr
@@ -160,7 +160,11 @@ fn merge_slices_else(x: Field) {
 fn merge_slices_return(x: Field, y: Field) -> [Field] {
     let slice = &[0; 2];
     if x != y {
-        if x != 20 { slice.push_back(y) } else { slice }
+        if x != 20 {
+            slice.push_back(y)
+        } else {
+            slice
+        }
     } else {
         slice
     }
diff --git a/test_programs/execution_success/strings/src/main.nr b/test_programs/execution_success/strings/src/main.nr
index d28a9f483ac..c4fa0539745 100644
--- a/test_programs/execution_success/strings/src/main.nr
+++ b/test_programs/execution_success/strings/src/main.nr
@@ -1,5 +1,5 @@
 // Test global string literals
-global HELLO_WORLD = "hello world";
+global HELLO_WORLD: str<11> = "hello world";
 
 fn main(message: pub str<11>, y: Field, hex_as_string: str<4>, hex_as_field: Field) {
     let mut bad_message = "hello world";
diff --git a/test_programs/execution_success/struct/src/main.nr b/test_programs/execution_success/struct/src/main.nr
index de08f42f79d..e4611b90b7d 100644
--- a/test_programs/execution_success/struct/src/main.nr
+++ b/test_programs/execution_success/struct/src/main.nr
@@ -26,7 +26,7 @@ impl Pair {
 
 struct Nested {
     a: Field,
-    b: Field
+    b: Field,
 }
 struct MyStruct {
     my_bool: bool,
diff --git a/test_programs/execution_success/struct_inputs/src/foo/bar.nr b/test_programs/execution_success/struct_inputs/src/foo/bar.nr
index 6d879326677..7a79528f8ab 100644
--- a/test_programs/execution_success/struct_inputs/src/foo/bar.nr
+++ b/test_programs/execution_success/struct_inputs/src/foo/bar.nr
@@ -1,4 +1,4 @@
-global N = 2;
+global N: Field = 2;
 
 struct barStruct {
     val: Field,
diff --git a/test_programs/execution_success/to_be_bytes/src/main.nr b/test_programs/execution_success/to_be_bytes/src/main.nr
index 809d8ad4563..062f9f763d5 100644
--- a/test_programs/execution_success/to_be_bytes/src/main.nr
+++ b/test_programs/execution_success/to_be_bytes/src/main.nr
@@ -8,5 +8,6 @@ fn main(x: Field) -> pub [u8; 31] {
     if (bytes[30] != 60) | (bytes[29] != 33) | (bytes[28] != 31) {
         assert(false);
     }
+    assert(Field::from_be_bytes::<31>(bytes) == x);
     bytes
 }
diff --git a/test_programs/execution_success/to_bytes_consistent/src/main.nr b/test_programs/execution_success/to_bytes_consistent/src/main.nr
index a51d52da855..171ac9dfbc0 100644
--- a/test_programs/execution_success/to_bytes_consistent/src/main.nr
+++ b/test_programs/execution_success/to_bytes_consistent/src/main.nr
@@ -1,5 +1,5 @@
-// This test aims to check that we have consistent behavior 
-// between a `to_be_bytes` call (which is radix decomposition under the hood) 
+// This test aims to check that we have consistent behavior
+// between a `to_be_bytes` call (which is radix decomposition under the hood)
 // with constant inputs or with witness inputs.
 // x = 2040124
 fn main(x: Field) {
diff --git a/test_programs/execution_success/to_le_bytes/src/main.nr b/test_programs/execution_success/to_le_bytes/src/main.nr
index 4e232b025aa..867551b6dbd 100644
--- a/test_programs/execution_success/to_le_bytes/src/main.nr
+++ b/test_programs/execution_success/to_le_bytes/src/main.nr
@@ -2,17 +2,12 @@ fn main(x: Field, cond: bool) -> pub [u8; 31] {
     // The result of this byte array will be little-endian
     let byte_array: [u8; 31] = x.to_le_bytes();
     assert(byte_array.len() == 31);
-
-    let mut bytes = [0; 31];
-    for i in 0..31 {
-        bytes[i] = byte_array[i];
-    }
-
+    assert(Field::from_le_bytes::<31>(byte_array) == x);
     if cond {
         // We've set x = "2040124" so we shouldn't be able to represent this as a single byte.
         let bad_byte_array: [u8; 1] = x.to_le_bytes();
         assert_eq(bad_byte_array.len(), 1);
     }
 
-    bytes
+    byte_array
 }
diff --git a/test_programs/execution_success/trait_as_return_type/src/main.nr b/test_programs/execution_success/trait_as_return_type/src/main.nr
index f6828a356c1..905f7f5d8b3 100644
--- a/test_programs/execution_success/trait_as_return_type/src/main.nr
+++ b/test_programs/execution_success/trait_as_return_type/src/main.nr
@@ -5,7 +5,7 @@ trait SomeTrait {
 struct A {}
 struct B {}
 struct C {
-    x: Field
+    x: Field,
 }
 
 impl SomeTrait for A {
diff --git a/test_programs/execution_success/trait_impl_base_type/src/main.nr b/test_programs/execution_success/trait_impl_base_type/src/main.nr
index e12cf019e0b..d12da11bc54 100644
--- a/test_programs/execution_success/trait_impl_base_type/src/main.nr
+++ b/test_programs/execution_success/trait_impl_base_type/src/main.nr
@@ -18,13 +18,21 @@ impl Fieldable for [u32; 3] {
 
 impl Fieldable for bool {
     fn to_field(self) -> Field {
-        if self { 14 } else { 3 }
+        if self {
+            14
+        } else {
+            3
+        }
     }
 }
 
 impl Fieldable for (u32, bool) {
     fn to_field(self) -> Field {
-        if self.1 { self.0 as Field } else { 32 }
+        if self.1 {
+            self.0 as Field
+        } else {
+            32
+        }
     }
 }
 
diff --git a/test_programs/execution_success/trait_inheritance/Nargo.toml b/test_programs/execution_success/trait_inheritance/Nargo.toml
new file mode 100644
index 00000000000..b8390fc800d
--- /dev/null
+++ b/test_programs/execution_success/trait_inheritance/Nargo.toml
@@ -0,0 +1,5 @@
+[package]
+name = "trait_inheritance"
+type = "bin"
+authors = [""]
+[dependencies]
\ No newline at end of file
diff --git a/test_programs/execution_success/trait_inheritance/Prover.toml b/test_programs/execution_success/trait_inheritance/Prover.toml
new file mode 100644
index 00000000000..e69de29bb2d
diff --git a/test_programs/execution_success/trait_inheritance/src/main.nr b/test_programs/execution_success/trait_inheritance/src/main.nr
new file mode 100644
index 00000000000..1d17d386189
--- /dev/null
+++ b/test_programs/execution_success/trait_inheritance/src/main.nr
@@ -0,0 +1,33 @@
+trait Foo {
+    fn foo(self) -> Field;
+}
+
+trait Bar: Foo {
+    fn bar(self) -> Field {
+        self.foo() + 1
+    }
+
+    fn baz(self) -> Field;
+}
+
+struct Struct {
+    x: Field,
+}
+
+impl Foo for Struct {
+    fn foo(self) -> Field {
+        self.x
+    }
+}
+
+impl Bar for Struct {
+    fn baz(self) -> Field {
+        self.foo() + 2
+    }
+}
+
+fn main() {
+    let s = Struct { x: 1 };
+    assert_eq(s.bar(), 2);
+    assert_eq(s.baz(), 3);
+}
diff --git a/test_programs/execution_success/u128/src/main.nr b/test_programs/execution_success/u128/src/main.nr
index d0835ccf30f..4ea93437814 100644
--- a/test_programs/execution_success/u128/src/main.nr
+++ b/test_programs/execution_success/u128/src/main.nr
@@ -22,7 +22,7 @@ fn main(mut x: u32, y: u32, z: u32, big_int: U128, hexa: str<7>) {
 
     assert(
         (U128::from_hex("0x71f03a23783f9d9c7a8777") * U128::from_hex("0x8BFCF39041")).hi
-        == U128::from_hex("0x3e4e0471b873470e247c824e61445537").hi
+            == U128::from_hex("0x3e4e0471b873470e247c824e61445537").hi,
     );
     let q = U128::from_hex("0x3e4e0471b873470e247c824e61445537") / U128::from_hex("0x8BFCF39041");
     assert(q == U128::from_hex("0x71f03a23783f9d9c7a8777"));
diff --git a/test_programs/execution_success/uhashmap/src/main.nr b/test_programs/execution_success/uhashmap/src/main.nr
index f2ca6813713..689ba9d4a04 100644
--- a/test_programs/execution_success/uhashmap/src/main.nr
+++ b/test_programs/execution_success/uhashmap/src/main.nr
@@ -6,21 +6,21 @@ type K = Field;
 type V = Field;
 
 // It is more convenient and readable to use structs as input.
-struct Entry{
+struct Entry {
     key: Field,
-    value: Field
+    value: Field,
 }
 
-global HASHMAP_LEN = 6;
+global HASHMAP_LEN: u32 = 6;
 
-global FIELD_CMP = |a: Field, b: Field| a.lt(b);
+global FIELD_CMP: fn(Field, Field) -> bool = |a: Field, b: Field| a.lt(b);
 
-global K_CMP = FIELD_CMP;
-global V_CMP = FIELD_CMP;
-global KV_CMP = |a: (K, V), b: (K, V)| a.0.lt(b.0);
+global K_CMP: fn(Field, Field) -> bool = FIELD_CMP;
+global V_CMP: fn(Field, Field) -> bool = FIELD_CMP;
+global KV_CMP: fn((K, V), (K, V)) -> bool = |a: (K, V), b: (K, V)| a.0.lt(b.0);
 
-global ALLOCATE_HASHMAP = || -> UHashMap<K, V, BuildHasherDefault<Poseidon2Hasher>> 
-    UHashMap::default();
+global ALLOCATE_HASHMAP: fn() -> UHashMap<K, V, BuildHasherDefault<Poseidon2Hasher>> =
+    || -> UHashMap<K, V, BuildHasherDefault<Poseidon2Hasher>> UHashMap::default();
 
 unconstrained fn main(input: [Entry; HASHMAP_LEN]) {
     test_sequential(input[0].key, input[0].value);
@@ -49,7 +49,10 @@ unconstrained fn test_sequential(key: K, value: V) {
     assert(value == got, f"Inserted {value} but got {got} for the same key.");
 
     hashmap.remove(key);
-    assert(hashmap.is_empty(), "UHashMap after one insert and corresponding removal should be empty.");
+    assert(
+        hashmap.is_empty(),
+        "UHashMap after one insert and corresponding removal should be empty.",
+    );
     let got = hashmap.get(key);
     assert(got.is_none(), "Value has been removed, but is still available (not none).");
 }
@@ -101,7 +104,8 @@ unconstrained fn test_insert_and_methods(input: [Entry; HASHMAP_LEN]) {
     assert(hashmap.len() == HASHMAP_LEN, "hashmap.len() does not match input length.");
 
     for entry in input {
-        assert(hashmap.contains_key(entry.key), f"Not found inserted key {entry.key}.");
+        let entry_key = entry.key;
+        assert(hashmap.contains_key(entry.key), f"Not found inserted key {entry_key}.");
     }
 
     hashmap.clear();
@@ -120,11 +124,14 @@ unconstrained fn test_retain() {
     let (key, value) = (11, 5);
     hashmap.insert(key, value);
 
-    let predicate = |key: K, value: V| -> bool {key * value == 55};
+    let predicate = |key: K, value: V| -> bool { key * value == 55 };
     hashmap.retain(predicate);
 
     assert(hashmap.len() == 2, "UHashMap should have retained 2 elements.");
-    assert(hashmap.get(2).is_none(), "Pair should have been removed, since it does not match predicate.");
+    assert(
+        hashmap.get(2).is_none(),
+        "Pair should have been removed, since it does not match predicate.",
+    );
 }
 
 // Equality trait check.
@@ -169,10 +176,10 @@ unconstrained fn test_mut_iterators() {
     hashmap.insert(5, 7);
     hashmap.insert(11, 13);
 
-    let f = |k: K| -> K{ k * 3};
+    let f = |k: K| -> K { k * 3 };
     hashmap.iter_keys_mut(f);
 
-    let f = |v: V| -> V{ v * 5};
+    let f = |v: V| -> V { v * 5 };
     hashmap.iter_values_mut(f);
 
     let keys: [K; 3] = hashmap.keys().as_array().sort_via(K_CMP);
@@ -181,7 +188,7 @@ unconstrained fn test_mut_iterators() {
     assert(keys == [6, 15, 33], f"Got incorrect iteration of keys: {keys}");
     assert(values == [15, 35, 65], "Got incorrect iteration of values.");
 
-    let f = |k: K, v: V| -> (K, V){(k * 2, v * 2)};
+    let f = |k: K, v: V| -> (K, V) { (k * 2, v * 2) };
     hashmap.iter_mut(f);
 
     let entries: [(K, V); 3] = hashmap.entries().as_array().sort_via(KV_CMP);
@@ -199,19 +206,17 @@ unconstrained fn doc_tests() {
     let hashmap: UHashMap<u8, u32, BuildHasherDefault<Poseidon2Hasher>> = UHashMap::default();
     assert(hashmap.is_empty());
     // docs:end:default_example
-
     // docs:start:with_hasher_example
     let my_hasher: BuildHasherDefault<Poseidon2Hasher> = Default::default();
-    let hashmap: UHashMap<u8, u32, BuildHasherDefault<Poseidon2Hasher>> = UHashMap::with_hasher(my_hasher);
+    let hashmap: UHashMap<u8, u32, BuildHasherDefault<Poseidon2Hasher>> =
+        UHashMap::with_hasher(my_hasher);
     assert(hashmap.is_empty());
     // docs:end:with_hasher_example
-
     // docs:start:insert_example
     let mut map: UHashMap<Field, Field, BuildHasherDefault<Poseidon2Hasher>> = UHashMap::default();
     map.insert(12, 42);
     assert(map.len() == 1);
     // docs:end:insert_example
-
     get_example(map);
 
     // docs:start:remove_example
@@ -222,7 +227,6 @@ unconstrained fn doc_tests() {
     map.remove(12);
     assert(map.is_empty());
     // docs:end:remove_example
-
     // docs:start:is_empty_example
     assert(map.is_empty());
 
@@ -232,7 +236,6 @@ unconstrained fn doc_tests() {
     map.remove(1);
     assert(map.is_empty());
     // docs:end:is_empty_example
-
     // docs:start:len_example
     // This is equivalent to checking map.is_empty()
     assert(map.len() == 0);
@@ -249,19 +252,17 @@ unconstrained fn doc_tests() {
     map.remove(1);
     assert(map.len() == 2);
     // docs:end:len_example
-
     // docs:start:capacity_example
-    let empty_map: UHashMap<Field, Field, BuildHasherDefault<Poseidon2Hasher>> = UHashMap::default();
+    let empty_map: UHashMap<Field, Field, BuildHasherDefault<Poseidon2Hasher>> =
+        UHashMap::default();
     assert(empty_map.len() == 0);
     println(empty_map.capacity());
     // docs:end:capacity_example
-
     // docs:start:clear_example
     assert(!map.is_empty());
     map.clear();
     assert(map.is_empty());
     // docs:end:clear_example
-
     // docs:start:contains_key_example
     if map.contains_key(7) {
         let value = map.get(7);
@@ -270,14 +271,12 @@ unconstrained fn doc_tests() {
         println("No value for key 7!");
     }
     // docs:end:contains_key_example
-
     entries_examples(map);
     iter_examples(map);
 
     // docs:start:retain_example
     map.retain(|k, v| (k != 0) & (v != 0));
     // docs:end:retain_example
-
     // docs:start:eq_example
     let mut map1: UHashMap<Field, u64, BuildHasherDefault<Poseidon2Hasher>> = UHashMap::default();
     let mut map2: UHashMap<Field, u64, BuildHasherDefault<Poseidon2Hasher>> = UHashMap::default();
@@ -294,9 +293,7 @@ unconstrained fn doc_tests() {
 
 // docs:start:get_example
 fn get_example(map: UHashMap<Field, Field, BuildHasherDefault<Poseidon2Hasher>>) {
-    let x = unsafe {
-        map.get(12)
-    };
+    let x = unsafe { map.get(12) };
 
     if x.is_some() {
         assert(x.unwrap() == 42);
@@ -317,18 +314,14 @@ fn entries_examples(map: UHashMap<Field, Field, BuildHasherDefault<Poseidon2Hash
         }
     }
     // docs:end:entries_example
-
     // docs:start:keys_example
     let keys = map.keys();
 
     for key in keys {
-        let value = unsafe {
-            map.get(key)
-        }.unwrap_unchecked();
+        let value = unsafe { map.get(key) }.unwrap_unchecked();
         println(f"{key} -> {value}");
     }
     // docs:end:keys_example
-
     // docs:start:values_example
     let values = map.values();
 
@@ -338,17 +331,17 @@ fn entries_examples(map: UHashMap<Field, Field, BuildHasherDefault<Poseidon2Hash
     // docs:end:values_example
 }
 
-unconstrained fn iter_examples(mut map: UHashMap<Field, Field, BuildHasherDefault<Poseidon2Hasher>>) {
+unconstrained fn iter_examples(
+    mut map: UHashMap<Field, Field, BuildHasherDefault<Poseidon2Hasher>>,
+) {
     // docs:start:iter_mut_example
     // Add 1 to each key in the map, and double the value associated with that key.
     map.iter_mut(|k, v| (k + 1, v * 2));
     // docs:end:iter_mut_example
-
     // docs:start:iter_keys_mut_example
     // Double each key, leaving the value associated with that key untouched
     map.iter_keys_mut(|k| k * 2);
     // docs:end:iter_keys_mut_example
-
     // docs:start:iter_values_mut_example
     // Halve each value
     map.iter_values_mut(|v| v / 2);
diff --git a/test_programs/execution_success/unary_operator_overloading/src/main.nr b/test_programs/execution_success/unary_operator_overloading/src/main.nr
index 20cdac51434..bf931d8dafb 100644
--- a/test_programs/execution_success/unary_operator_overloading/src/main.nr
+++ b/test_programs/execution_success/unary_operator_overloading/src/main.nr
@@ -14,7 +14,7 @@ fn main(x: u32) {
 }
 
 struct Wrapper {
-    inner: i32
+    inner: i32,
 }
 
 impl Wrapper {
diff --git a/test_programs/execution_success/unsafe_range_constraint/src/main.nr b/test_programs/execution_success/unsafe_range_constraint/src/main.nr
index ead5613bcce..ed846ec20b4 100644
--- a/test_programs/execution_success/unsafe_range_constraint/src/main.nr
+++ b/test_programs/execution_success/unsafe_range_constraint/src/main.nr
@@ -1,5 +1,5 @@
-// Test that we can apply a range constraint to a field using 
+// Test that we can apply a range constraint to a field using
 // a builtin.
 fn main(x: Field) {
-    x.assert_max_bit_size(48);
+    x.assert_max_bit_size::<48>();
 }
diff --git a/test_programs/execution_success/verify_honk_proof/Nargo.toml b/test_programs/execution_success/verify_honk_proof/Nargo.toml
new file mode 100644
index 00000000000..8fce1bf44b6
--- /dev/null
+++ b/test_programs/execution_success/verify_honk_proof/Nargo.toml
@@ -0,0 +1,6 @@
+[package]
+name = "verify_honk_proof"
+type = "bin"
+authors = [""]
+
+[dependencies]
diff --git a/test_programs/execution_success/verify_honk_proof/Prover.toml b/test_programs/execution_success/verify_honk_proof/Prover.toml
new file mode 100644
index 00000000000..45a84c26eb8
--- /dev/null
+++ b/test_programs/execution_success/verify_honk_proof/Prover.toml
@@ -0,0 +1,4 @@
+key_hash = "0x0000000000000000000000000000000000000000000000000000000000000000"
+proof = ["0x0000000000000000000000000000000000000000000000000000000000000040", "0x0000000000000000000000000000000000000000000000000000000000000011", "0x0000000000000000000000000000000000000000000000000000000000000001", "0x0000000000000000000000000000000000000000000000042ab5d6d1986846cf", "0x00000000000000000000000000000000000000000000000b75c020998797da78", "0x0000000000000000000000000000000000000000000000005a107acb64952eca", "0x000000000000000000000000000000000000000000000000000031e97a575e9d", "0x00000000000000000000000000000000000000000000000b5666547acf8bd5a4", "0x00000000000000000000000000000000000000000000000c410db10a01750aeb", "0x00000000000000000000000000000000000000000000000d722669117f9758a4", "0x000000000000000000000000000000000000000000000000000178cbf4206471", "0x000000000000000000000000000000000000000000000000e91b8a11e7842c38", "0x000000000000000000000000000000000000000000000007fd51009034b3357f", "0x000000000000000000000000000000000000000000000009889939f81e9c7402", "0x0000000000000000000000000000000000000000000000000000f94656a2ca48", "0x000000000000000000000000000000000000000000000006fb128b46c1ddb67f", "0x0000000000000000000000000000000000000000000000093fe27776f50224bd", "0x000000000000000000000000000000000000000000000004a0c80c0da527a081", "0x0000000000000000000000000000000000000000000000000001b52c2020d746", "0x0000000000000000000000000000005a9bae947e1e91af9e4033d8d6aa6ed632", "0x000000000000000000000000000000000025e485e013446d4ac7981c88ba6ecc", "0x000000000000000000000000000000ff1e0496e30ab24a63b32b2d1120b76e62", "0x00000000000000000000000000000000001afe0a8a685d7cd85d1010e55d9d7c", "0x000000000000000000000000000000b0804efd6573805f991458295f510a2004", "0x00000000000000000000000000000000000c81a178016e2fe18605022d5a8b0e", "0x000000000000000000000000000000eba51e76eb1cfff60a53a0092a3c3dea47", "0x000000000000000000000000000000000022e7466247b533282f5936ac4e6c15", "0x00000000000000000000000000000071b1d76edf770edff98f00ff4deec264cd", "0x00000000000000000000000000000000001e48128e68794d8861fcbb2986a383", "0x000000000000000000000000000000d3a2af4915ae6d86b097adc377fafda2d4", "0x000000000000000000000000000000000006359de9ca452dab3a4f1f8d9c9d98", "0x0000000000000000000000000000006cf7dd96d7636fda5953191b1ad776d491", "0x00000000000000000000000000000000001633d881a08d136e834cb13a28fcc6", "0x00000000000000000000000000000001254956cff6908b069fca0e6cf1c47eb1", "0x000000000000000000000000000000000006f4d4dd3890e997e75e75886bf8f7", "0x0000000000000000000000000000006cf7dd96d7636fda5953191b1ad776d491", "0x00000000000000000000000000000000001633d881a08d136e834cb13a28fcc6", "0x00000000000000000000000000000001254956cff6908b069fca0e6cf1c47eb1", "0x000000000000000000000000000000000006f4d4dd3890e997e75e75886bf8f7", "0x000000000000000000000000000000f968b227a358a305607f3efc933823d288", "0x00000000000000000000000000000000000eaf8adb390375a76d95e918b65e08", "0x000000000000000000000000000000bb34b4b447aae56f5e24f81c3acd6d547f", "0x00000000000000000000000000000000002175d012746260ebcfe339a91a81e1", "0x00000000000000000000000000000052eebbd1f6f7554e837f60c44000ed14b6", "0x00000000000000000000000000000000001c1c045a3ec94b8801f2272cc0b3f4", "0x0000000000000000000000000000004d2ef74134578f6b431a9df071ffca4292", "0x0000000000000000000000000000000000291326ade7aa6f0dfc8900eab5580b", "0x0000000000000000000000000000002433eec6418a6dba820c9527e2581fc8bc", "0x00000000000000000000000000000000000e88b7daad19af2ac2f9bdf9e50ee2", "0x000000000000000000000000000000dcfce2c427155cc3e4d035735d3dd5ece8", "0x00000000000000000000000000000000002d7d473cac1a15d0fee8b22c1a7b3e", "0x1a4249b90be4602c8ff40c7c276160ee41b2a0f8a238ce7706e9face2db03d48", "0x162204b9d54d3ffd285c393a5a1ff76ee681474fd780a21a3cf7fac5c24fc2b9", "0x30279eb953d8ee79b2155c69c04e6443c5de6bf7e02886256dd7b3cd3c9502a4", "0x0d32c1bd21baf43e72d5d82d461ef54833807ff81a877adc822f27a6db88d754", "0x0fe15e055c0803d5ebe6dd77689b70cfd82138f008810ce24535c992daaff27d", "0x1fba82c012671212ce2fc13fd09bf8fba4f7d5875ab8d37495d1ccfcff287331", "0x090738a5842fa4d2699b3726aa0dd97cb59569b4be2c6825335ec4969f859dc2", "0x0c6cb72dabbc28abcf4a50c203534e066c29f48c24ca64d672092f263df3f9d7", "0x0f27fbea0d9145f815c288b50fe7e8c10b8185d325b5264624fd57102855d05d", "0x2a815cd3fd1c43c72ee0130465250ff771d1e7be2347e4ada331b83265a03450", "0x148b4ecf2ad7ed17409417086867ee27bc1b0906dbc9cbb3714c285071e2db70", "0x08e700a42b1d6d36ee65f8ebedf47d3a44463ff9fa579dce13b7492e20142c3a", "0x2e23c69521d572ff2152c50f8c9a9191535f4cf37f95f1e0428692e78842b642", "0x14519e0354365923fb41400c19866135b45e975d56a0980260bc99f0390b1d5f", "0x04caded1f05738f736cb5bcf08d785e395e58eb7738523a20638aa16bc51593e", "0x28787eaccd38383215ea21ec02895c32d979f68ca155f534a2e2d377bff6698b", "0x20a1b81fa96c58cf11c5762c5ceb731efdcb081fca2d34d5c463d2cf40e6da18", "0x11789a06fe3bf53833741d180f068d29534d5bb58a5c64b8119542e62b189fb4", "0x23d00fcd032ace719ffcbc513bfa177a55b04377d76455c2788d999d05d011e2", "0x01f0e81b57b4a73cc118e51ede18f8724debf25c2d109db6ef45280f99f1a3fa", "0x156d1c9b61749810de728f259c2c1c1fd4dbff97101426e26087ca461c93307c", "0x1c5d619ac3a478cfd06d5eebfd879960bb321236be173813f5e78d1366d32c69", "0x250cfae4e1dfc551406f1f3d10b649a637dcb7bcb0f6f697994cf96afd35d0c1", "0x242b999f58cf5f53c874d1092bd38725aa9ea076f5bc8f176efa9ea23393874b", "0x2e15748255c4a5e0e9fe38047341b692a967257de27a85a3a38681bc9f1602ea", "0x01ef83886ea7017253699cb6371988eb8e21b4f7023d7479ece4907fe6d4a6fd", "0x08db2dbc271e375b9312f695c59c48f313235b3432cad50921c8d9ad6dd7ad7a", "0x199309f2c2cd45c15a4abb0e6554a1615ff5a6e9488a8d900bbf835fc8f664ef", "0x074be7a3d88e31ab1b59c9208c012bcfb1f85f351c709e68134996891db52b57", "0x301b1011354d2ebf46134fc4d6d734bb6ed8542d719f38f5e09a376a580cad7f", "0x12968f3eccaa27e44f14d5aaac6ecb70c00d040e07536292e685d7cab03fc563", "0x2110a023c8c22fd2ed70270a2d0a265b92a32ce2217ffe1be9a5d7d5c25f512f", "0x1e8cf4c60c53900f0430d5b44de5804fe8b38299bc803beeb4216e1a289cf624", "0x12301cb908ccb28a2616e29b831ec7105b5d3ebf45ff5fe91d50a9dd53a50b52", "0x0f1029ed107d84ff2d6d4a416cbd01da3f3d7bf5b2209ce93ba424f4b85616fc", "0x1b431d016611b8abd684afd9e92331c3325967b1116bfa91d4f44e2f8e2c9fc2", "0x281e335a0fd117064c8ace3f01e02b134a19e9b9220571ebfaaaa0e3a12d34db", "0x22559c106f77e2ae95677d5e38e288343e3b7168371aec7d3aaab9ef8150af70", "0x13f113b1d9b590149cf08c3f6e90589cda5c7b98528866b891256cb9d5d814e7", "0x10252ef388e4c80246962e98b9e976fab2cd25e1e6f1e3fd2a7d4786c5218a97", "0x16b890723dfdebd9912a9207255f95cb800222165b6fae97ec46e461f23e83f3", "0x25caf77c7d2e8e069341ec90f3c8f6d64319cfd2d77cab0625cf0377285ba11c", "0x016c84288b0bc3c50eebbe250cdd5a4ee50b2c65a24ac64d0c930cbdecb95141", "0x20a537c045b069d47dc6315f45b391f60681222381e5059ec7c8b17bf677d911", "0x2594c0edfcd4064d215a3d797bc8e3b2f401c61f3961ae96ccbec8f8fd29e81f", "0x1c831d7047483ca00ed59bdb84c47ffb8bbebbae92aa164c7b35fcffbb8a35d3", "0x2ea7f60de52b8cd6b0bd06f861fc1f2c5ed1d1fbfa53caccdb836400a03df434", "0x275c6c8bd115f7d2ce196439e2330fad305c6745bab0bf1ce3f2fa32dadc3c43", "0x0000000000000000000000000000000000000000000000000000000000000000", "0x0000000000000000000000000000000000000000000000000000000000000000", "0x0000000000000000000000000000000000000000000000000000000000000000", "0x0000000000000000000000000000000000000000000000000000000000000000", "0x0000000000000000000000000000000000000000000000000000000000000000", "0x0000000000000000000000000000000000000000000000000000000000000000", "0x0000000000000000000000000000000000000000000000000000000000000000", "0x0000000000000000000000000000000000000000000000000000000000000000", "0x0000000000000000000000000000000000000000000000000000000000000000", "0x0000000000000000000000000000000000000000000000000000000000000000", "0x0000000000000000000000000000000000000000000000000000000000000000", "0x0000000000000000000000000000000000000000000000000000000000000000", "0x0000000000000000000000000000000000000000000000000000000000000000", "0x0000000000000000000000000000000000000000000000000000000000000000", "0x0000000000000000000000000000000000000000000000000000000000000000", "0x0000000000000000000000000000000000000000000000000000000000000000", "0x0000000000000000000000000000000000000000000000000000000000000000", "0x0000000000000000000000000000000000000000000000000000000000000000", "0x0000000000000000000000000000000000000000000000000000000000000000", "0x0000000000000000000000000000000000000000000000000000000000000000", "0x0000000000000000000000000000000000000000000000000000000000000000", "0x0000000000000000000000000000000000000000000000000000000000000000", "0x0000000000000000000000000000000000000000000000000000000000000000", "0x0000000000000000000000000000000000000000000000000000000000000000", "0x0000000000000000000000000000000000000000000000000000000000000000", "0x0000000000000000000000000000000000000000000000000000000000000000", "0x0000000000000000000000000000000000000000000000000000000000000000", "0x0000000000000000000000000000000000000000000000000000000000000000", "0x0000000000000000000000000000000000000000000000000000000000000000", "0x0000000000000000000000000000000000000000000000000000000000000000", "0x0000000000000000000000000000000000000000000000000000000000000000", "0x0000000000000000000000000000000000000000000000000000000000000000", "0x0000000000000000000000000000000000000000000000000000000000000000", "0x0000000000000000000000000000000000000000000000000000000000000000", "0x0000000000000000000000000000000000000000000000000000000000000000", "0x0000000000000000000000000000000000000000000000000000000000000000", "0x0000000000000000000000000000000000000000000000000000000000000000", "0x0000000000000000000000000000000000000000000000000000000000000000", "0x0000000000000000000000000000000000000000000000000000000000000000", "0x0000000000000000000000000000000000000000000000000000000000000000", "0x0000000000000000000000000000000000000000000000000000000000000000", "0x0000000000000000000000000000000000000000000000000000000000000000", "0x0000000000000000000000000000000000000000000000000000000000000000", "0x0000000000000000000000000000000000000000000000000000000000000000", "0x0000000000000000000000000000000000000000000000000000000000000000", "0x0000000000000000000000000000000000000000000000000000000000000000", "0x0000000000000000000000000000000000000000000000000000000000000000", "0x0000000000000000000000000000000000000000000000000000000000000000", "0x0000000000000000000000000000000000000000000000000000000000000000", "0x0000000000000000000000000000000000000000000000000000000000000000", "0x0000000000000000000000000000000000000000000000000000000000000000", "0x0000000000000000000000000000000000000000000000000000000000000000", "0x0000000000000000000000000000000000000000000000000000000000000000", "0x0000000000000000000000000000000000000000000000000000000000000000", "0x0000000000000000000000000000000000000000000000000000000000000000", "0x0000000000000000000000000000000000000000000000000000000000000000", "0x0000000000000000000000000000000000000000000000000000000000000000", "0x0000000000000000000000000000000000000000000000000000000000000000", "0x0000000000000000000000000000000000000000000000000000000000000000", "0x0000000000000000000000000000000000000000000000000000000000000000", "0x0000000000000000000000000000000000000000000000000000000000000000", "0x0000000000000000000000000000000000000000000000000000000000000000", "0x0000000000000000000000000000000000000000000000000000000000000000", "0x0000000000000000000000000000000000000000000000000000000000000000", "0x0000000000000000000000000000000000000000000000000000000000000000", "0x0000000000000000000000000000000000000000000000000000000000000000", "0x0000000000000000000000000000000000000000000000000000000000000000", "0x0000000000000000000000000000000000000000000000000000000000000000", "0x0000000000000000000000000000000000000000000000000000000000000000", "0x0000000000000000000000000000000000000000000000000000000000000000", "0x0000000000000000000000000000000000000000000000000000000000000000", "0x0000000000000000000000000000000000000000000000000000000000000000", "0x0000000000000000000000000000000000000000000000000000000000000000", "0x0000000000000000000000000000000000000000000000000000000000000000", "0x0000000000000000000000000000000000000000000000000000000000000000", "0x0000000000000000000000000000000000000000000000000000000000000000", "0x0000000000000000000000000000000000000000000000000000000000000000", "0x0000000000000000000000000000000000000000000000000000000000000000", "0x0000000000000000000000000000000000000000000000000000000000000000", "0x0000000000000000000000000000000000000000000000000000000000000000", "0x0000000000000000000000000000000000000000000000000000000000000000", "0x0000000000000000000000000000000000000000000000000000000000000000", "0x0000000000000000000000000000000000000000000000000000000000000000", "0x0000000000000000000000000000000000000000000000000000000000000000", "0x0000000000000000000000000000000000000000000000000000000000000000", "0x0000000000000000000000000000000000000000000000000000000000000000", "0x0000000000000000000000000000000000000000000000000000000000000000", "0x0000000000000000000000000000000000000000000000000000000000000000", "0x0000000000000000000000000000000000000000000000000000000000000000", "0x0000000000000000000000000000000000000000000000000000000000000000", "0x0000000000000000000000000000000000000000000000000000000000000000", "0x0000000000000000000000000000000000000000000000000000000000000000", "0x0000000000000000000000000000000000000000000000000000000000000000", "0x0000000000000000000000000000000000000000000000000000000000000000", "0x0000000000000000000000000000000000000000000000000000000000000000", "0x0000000000000000000000000000000000000000000000000000000000000000", "0x0000000000000000000000000000000000000000000000000000000000000000", "0x0000000000000000000000000000000000000000000000000000000000000000", "0x0000000000000000000000000000000000000000000000000000000000000000", "0x0000000000000000000000000000000000000000000000000000000000000000", "0x0000000000000000000000000000000000000000000000000000000000000000", "0x0000000000000000000000000000000000000000000000000000000000000000", "0x0000000000000000000000000000000000000000000000000000000000000000", "0x0000000000000000000000000000000000000000000000000000000000000000", "0x0000000000000000000000000000000000000000000000000000000000000000", "0x0000000000000000000000000000000000000000000000000000000000000000", "0x0000000000000000000000000000000000000000000000000000000000000000", "0x0000000000000000000000000000000000000000000000000000000000000000", "0x0000000000000000000000000000000000000000000000000000000000000000", "0x0000000000000000000000000000000000000000000000000000000000000000", "0x0000000000000000000000000000000000000000000000000000000000000000", "0x0000000000000000000000000000000000000000000000000000000000000000", "0x0000000000000000000000000000000000000000000000000000000000000000", "0x0000000000000000000000000000000000000000000000000000000000000000", "0x0000000000000000000000000000000000000000000000000000000000000000", "0x0000000000000000000000000000000000000000000000000000000000000000", "0x0000000000000000000000000000000000000000000000000000000000000000", "0x0000000000000000000000000000000000000000000000000000000000000000", "0x0000000000000000000000000000000000000000000000000000000000000000", "0x0000000000000000000000000000000000000000000000000000000000000000", "0x0000000000000000000000000000000000000000000000000000000000000000", "0x0000000000000000000000000000000000000000000000000000000000000000", "0x0000000000000000000000000000000000000000000000000000000000000000", "0x0000000000000000000000000000000000000000000000000000000000000000", "0x0000000000000000000000000000000000000000000000000000000000000000", "0x0000000000000000000000000000000000000000000000000000000000000000", "0x0000000000000000000000000000000000000000000000000000000000000000", "0x0000000000000000000000000000000000000000000000000000000000000000", "0x0000000000000000000000000000000000000000000000000000000000000000", "0x0000000000000000000000000000000000000000000000000000000000000000", "0x0000000000000000000000000000000000000000000000000000000000000000", "0x0000000000000000000000000000000000000000000000000000000000000000", "0x0000000000000000000000000000000000000000000000000000000000000000", "0x0000000000000000000000000000000000000000000000000000000000000000", "0x0000000000000000000000000000000000000000000000000000000000000000", "0x0000000000000000000000000000000000000000000000000000000000000000", "0x0000000000000000000000000000000000000000000000000000000000000000", "0x0000000000000000000000000000000000000000000000000000000000000000", "0x0000000000000000000000000000000000000000000000000000000000000000", "0x0000000000000000000000000000000000000000000000000000000000000000", "0x0000000000000000000000000000000000000000000000000000000000000000", "0x0000000000000000000000000000000000000000000000000000000000000000", "0x0000000000000000000000000000000000000000000000000000000000000000", "0x0000000000000000000000000000000000000000000000000000000000000000", "0x0000000000000000000000000000000000000000000000000000000000000000", "0x0000000000000000000000000000000000000000000000000000000000000000", "0x0000000000000000000000000000000000000000000000000000000000000000", "0x0000000000000000000000000000000000000000000000000000000000000000", "0x0000000000000000000000000000000000000000000000000000000000000000", "0x0000000000000000000000000000000000000000000000000000000000000000", "0x0000000000000000000000000000000000000000000000000000000000000000", "0x0000000000000000000000000000000000000000000000000000000000000000", "0x0000000000000000000000000000000000000000000000000000000000000000", "0x0000000000000000000000000000000000000000000000000000000000000000", "0x0000000000000000000000000000000000000000000000000000000000000000", "0x0000000000000000000000000000000000000000000000000000000000000000", "0x0000000000000000000000000000000000000000000000000000000000000000", "0x0000000000000000000000000000000000000000000000000000000000000000", "0x0000000000000000000000000000000000000000000000000000000000000000", "0x0000000000000000000000000000000000000000000000000000000000000000", "0x0000000000000000000000000000000000000000000000000000000000000000", "0x0000000000000000000000000000000000000000000000000000000000000000", "0x0000000000000000000000000000000000000000000000000000000000000000", "0x0000000000000000000000000000000000000000000000000000000000000000", "0x0000000000000000000000000000000000000000000000000000000000000000", "0x0000000000000000000000000000000000000000000000000000000000000000", "0x0000000000000000000000000000000000000000000000000000000000000000", "0x0000000000000000000000000000000000000000000000000000000000000000", "0x0000000000000000000000000000000000000000000000000000000000000000", "0x0000000000000000000000000000000000000000000000000000000000000000", "0x0000000000000000000000000000000000000000000000000000000000000000", "0x0000000000000000000000000000000000000000000000000000000000000000", "0x0000000000000000000000000000000000000000000000000000000000000000", "0x0000000000000000000000000000000000000000000000000000000000000000", "0x0000000000000000000000000000000000000000000000000000000000000000", "0x0000000000000000000000000000000000000000000000000000000000000000", "0x2b3f4e210619347288731e7f0eea1ae60dd8696fe87319044864d099a03a9536", "0x0fecd3d2aebedeb8be2b0b7e3a74de9ec8bd2cb72851541463729e0715aef48b", "0x10bee385ad0c2cd3ff88ef4d630840749e4367f9add4a300fc4f545a7778e92c", "0x1fe792730eeafbd22c4eb80e86e2b40108b1e55b2a08db786289eea5745b9e3b", "0x04d411679da432816b213cd5580dda1fd6c2f258684c036be19b5b26baca583c", "0x159f17b655d2b8a803e0cfb564918628be52d3baa950ca1b127854491624f8f4", "0x225340463867d9252a1269013536e2e1dd219aa18eadef13c324b63d44679334", "0x1885e231554e02abb40ed54b72ebf09b883d0298a6bc06fc645a30365f370ef2", "0x233344517f25170972b8ba35d01f2df2e073d322993abce7df26796126e93498", "0x08990e8faa13b18b4433ec417c5cc596885e11ffd372d5f612c08cc79a5d5c80", "0x1e960a0c892b755c28e21dcbed816c1b182d7da43bae07f8ee622bd4485f79e7", "0x27b58e2ee290a179d349ace82752528b2ff946d60c092b99ef42f53c25d0c99f", "0x2a5cf8a3193107d982edd253002c7a52ab876b445dde8307ab78fbdca022d93c", "0x2b1ab4d5277f8c82750c1c7bd043889b71465ec64a9afc1bfa37d06b1ebd0725", "0x2a0dbf5c4373a58a83d5f2a031ea0615bf12800e33b70c3191a7cbb15966ced8", "0x1f272bb4a19d14a0abdfebc9fc83125e10623b9aef730f8d25f2bf5bead38ea9", "0x2c2339cf0ae7aff56091a568c1e2c3f01f52d8ed13400737fd31eaabcaffb9bd", "0x21f5fefe6b5fa0b5da71089befb74a1a39e52b4f830cb330c3c284e154614dfd", "0x1e6f6ba4b2444586b380dc4e2b3fad111ff1f4754420a846f53ea0789ebfb0ad", "0x1193d170b0b2dd0c4a04331a4b4aa3f12920f182ec3ab547837e30f1116ca584", "0x00000000000000000000000000000025704a15c9e2ce8a69558e7bbcdcbc7784", "0x2e5d36112770fb6c985681cafe40a8c99ad13f702309e7969801dd0ed080e727", "0x0eefc2585f591bb457183134e19ad643966272234d645514bf7868d6dd8ae2cb", "0x300803e4e2339ad39b9c31f228949bbeaf9c74b7101e7be1930b088126247eaa", "0x2bb562a50ed944b438b83b01f200101a34faef7f296a75c84c731755ebddbc1a", "0x1288e0b9c742af39cbcac21357c1b29511b0bbdd3d0e3cf5e14b2eef68a28ab3", "0x20f089131cc96d86ff1cfb67fa3f51670f4bad30158751b2587354bbec76cdf9", "0x1a26c6d3e633f9bf8434cf755b5f1217dad0d455071a97a7bcf85b824f5cf07a", "0x0d7e9b8a51fccf910ec25bdbd13e70b34bd6ea6f4d629fa744f9cdf5f2beb1cf", "0x0b40f28ce428e64df9cf5a024133fc420f39decf5f6af020cc3211ab298d4631", "0x0ca4f189dde7a55fe829f46681232904f6670249a22e0deb47222bd309523a8a", "0x2c544f2e31143783977645edb2a6bdb39b875053963bfa1a5b3ae9de204a7ebe", "0x00aae4454eb48fb18ff60db6b9d015abea2e770a2f7d86d121522b834c791ba5", "0x07d74e351fd4cccf4e18475d25211efa8a359066fc693a5c8505ddb507e4b74b", "0x07d74e351fd4cccf4e18475d25211efa8a359066fc693a5c8505ddb507e4b74b", "0x2d9e5bff47207d82533e2445959941181cc890c5779bc7f24d6e8a7b9e425b5c", "0x0aea3c0c317c441a5775a9849108d7a6889b39128235f717b09b184aa08e4eb7", "0x1ca5bc6fb37c55a562f4991901c39902f42d14db71284116df74cb4e7d55e493", "0x220fed26d64cd69f40e6d145a423e4a3c8cd0dce747e7d51647441270ad4d774", "0x15be574c9358889257aa2a30ff7b5fcc31a57da7032296e2c1201c49a44bbdb6", "0x2de539925525bedd3b7f43a9c6bf0f713151a17f79ac7ff4a9cd27b15ffe892a", "0x083086693dbf465211741e2cbff70ff38eb08383faf22d397eb2742c8ad7396a", "0x1fdfa258a890598816e807c50058d7a1462edd5ff196a2eae0f862e454b49aa1", "0x10c434c6daaa8226fa8e3e302123dfdc4455cf68063df518949df5a65a945213", "0x0000000000000000000000000000006472a7874de2c454a4591ed7784df1c104", "0x000000000000000000000000000000000008c46ac53d2c4ad0c26a5d6c790082", "0x0000000000000000000000000000005e422f9cfb8725800de60dfe0a8d4104c0", "0x000000000000000000000000000000000000f10fd4e4de81a0c00073ec91c274", "0x000000000000000000000000000000b20813090eca76bc6aa4a699b1ec8d5d6d", "0x0000000000000000000000000000000000292cc9f8a744eb00e0903c29ce87a7", "0x000000000000000000000000000000350a368b415fbb99fa90a26a42b1a3affd", "0x0000000000000000000000000000000000280eb9275cb05a3435f464d1dc369d", "0x000000000000000000000000000000280df6505e20c7725fe6d29439f96ee05d", "0x000000000000000000000000000000000017ef5033a08535451e2747827aa94b", "0x0000000000000000000000000000002f9ba89ae91b4e4a4ff8ccbd0526faad2f", "0x00000000000000000000000000000000001c2013561dafcc02cb03220bdf23c4", "0x000000000000000000000000000000aac102c400f9e5da0321ded4510994434b", "0x00000000000000000000000000000000001ec8ab9cc834b492fde124962f04a1", "0x0000000000000000000000000000000673dbd698da8b8cce450d2a083aba9987", "0x00000000000000000000000000000000000a49e55bb040249cb41c63cea901cd", "0x000000000000000000000000000000133d92af8d76ee0c74a12081ee7b2ef8c4", "0x0000000000000000000000000000000000240f552d1c6cbb007650e4b142e0a5", "0x000000000000000000000000000000e29c6e7d982ec08d51c79d6261c28d742d", "0x000000000000000000000000000000000021baeec04d9be419c923626034e7b3", "0x0000000000000000000000000000000000000000000000000000000000000001", "0x0000000000000000000000000000000000000000000000000000000000000000", "0x0000000000000000000000000000000000000000000000000000000000000002", "0x0000000000000000000000000000000000000000000000000000000000000000", "0x0000000000000000000000000000000000000000000000000000000000000001", "0x0000000000000000000000000000000000000000000000000000000000000000", "0x0000000000000000000000000000000000000000000000000000000000000002", "0x0000000000000000000000000000000000000000000000000000000000000000", "0x0000000000000000000000000000000000000000000000000000000000000001", "0x0000000000000000000000000000000000000000000000000000000000000000", "0x0000000000000000000000000000000000000000000000000000000000000002", "0x0000000000000000000000000000000000000000000000000000000000000000", "0x0000000000000000000000000000000000000000000000000000000000000001", "0x0000000000000000000000000000000000000000000000000000000000000000", "0x0000000000000000000000000000000000000000000000000000000000000002", "0x0000000000000000000000000000000000000000000000000000000000000000", "0x0000000000000000000000000000000000000000000000000000000000000001", "0x0000000000000000000000000000000000000000000000000000000000000000", "0x0000000000000000000000000000000000000000000000000000000000000002", "0x0000000000000000000000000000000000000000000000000000000000000000", "0x0000000000000000000000000000000000000000000000000000000000000001", "0x0000000000000000000000000000000000000000000000000000000000000000", "0x0000000000000000000000000000000000000000000000000000000000000002", "0x0000000000000000000000000000000000000000000000000000000000000000", "0x0000000000000000000000000000000000000000000000000000000000000001", "0x0000000000000000000000000000000000000000000000000000000000000000", "0x0000000000000000000000000000000000000000000000000000000000000002", "0x0000000000000000000000000000000000000000000000000000000000000000", "0x0000000000000000000000000000000000000000000000000000000000000001", "0x0000000000000000000000000000000000000000000000000000000000000000", "0x0000000000000000000000000000000000000000000000000000000000000002", "0x0000000000000000000000000000000000000000000000000000000000000000", "0x0000000000000000000000000000000000000000000000000000000000000001", "0x0000000000000000000000000000000000000000000000000000000000000000", "0x0000000000000000000000000000000000000000000000000000000000000002", "0x0000000000000000000000000000000000000000000000000000000000000000", "0x0000000000000000000000000000000000000000000000000000000000000001", "0x0000000000000000000000000000000000000000000000000000000000000000", "0x0000000000000000000000000000000000000000000000000000000000000002", "0x0000000000000000000000000000000000000000000000000000000000000000", "0x0000000000000000000000000000000000000000000000000000000000000001", "0x0000000000000000000000000000000000000000000000000000000000000000", "0x0000000000000000000000000000000000000000000000000000000000000002", "0x0000000000000000000000000000000000000000000000000000000000000000", "0x0000000000000000000000000000000000000000000000000000000000000001", "0x0000000000000000000000000000000000000000000000000000000000000000", "0x0000000000000000000000000000000000000000000000000000000000000002", "0x0000000000000000000000000000000000000000000000000000000000000000", "0x0000000000000000000000000000000000000000000000000000000000000001", "0x0000000000000000000000000000000000000000000000000000000000000000", "0x0000000000000000000000000000000000000000000000000000000000000002", "0x0000000000000000000000000000000000000000000000000000000000000000", "0x0000000000000000000000000000000000000000000000000000000000000001", "0x0000000000000000000000000000000000000000000000000000000000000000", "0x0000000000000000000000000000000000000000000000000000000000000002", "0x0000000000000000000000000000000000000000000000000000000000000000", "0x0000000000000000000000000000000000000000000000000000000000000001", "0x0000000000000000000000000000000000000000000000000000000000000000", "0x0000000000000000000000000000000000000000000000000000000000000002", "0x0000000000000000000000000000000000000000000000000000000000000000", "0x0000000000000000000000000000000000000000000000000000000000000001", "0x0000000000000000000000000000000000000000000000000000000000000000", "0x0000000000000000000000000000000000000000000000000000000000000002", "0x0000000000000000000000000000000000000000000000000000000000000000", "0x0000000000000000000000000000000000000000000000000000000000000001", "0x0000000000000000000000000000000000000000000000000000000000000000", "0x0000000000000000000000000000000000000000000000000000000000000002", "0x0000000000000000000000000000000000000000000000000000000000000000", "0x0000000000000000000000000000000000000000000000000000000000000001", "0x0000000000000000000000000000000000000000000000000000000000000000", "0x0000000000000000000000000000000000000000000000000000000000000002", "0x0000000000000000000000000000000000000000000000000000000000000000", "0x0000000000000000000000000000000000000000000000000000000000000001", "0x0000000000000000000000000000000000000000000000000000000000000000", "0x0000000000000000000000000000000000000000000000000000000000000002", "0x0000000000000000000000000000000000000000000000000000000000000000", "0x0000000000000000000000000000000000000000000000000000000000000001", "0x0000000000000000000000000000000000000000000000000000000000000000", "0x0000000000000000000000000000000000000000000000000000000000000002", "0x0000000000000000000000000000000000000000000000000000000000000000", "0x0000000000000000000000000000000000000000000000000000000000000001", "0x0000000000000000000000000000000000000000000000000000000000000000", "0x0000000000000000000000000000000000000000000000000000000000000002", "0x0000000000000000000000000000000000000000000000000000000000000000", "0x0000000000000000000000000000000000000000000000000000000000000001", "0x0000000000000000000000000000000000000000000000000000000000000000", "0x0000000000000000000000000000000000000000000000000000000000000002", "0x0000000000000000000000000000000000000000000000000000000000000000", "0x1e940a528b42d8230e7d4dff76262a80986c0d00b2c02a9bc0559e36212d1547", "0x1ceccf21ac39f70d76ad6f7fe0dcb33b6af04555a0b1959e4714d65925e4e253", "0x096139d757046cdbdb7ee89a95f112f70882a43a46c2f739d9be115dda013420", "0x2f9c8ac67c7825b08eff0e7f7656a671f4c64e5601f2efab35b1b795801eec04", "0x2077e648e1704851cdffd7e6e56311634a7b741bab77ca34d9dff12a6a2bfe99", "0x115d48c4a97aeb3c447a060f9e0d675b0dc7f4a05a3f5776e2f279f3a165d7dc", "0x0000000000000000000000000000000000000000000000000000000000000000", "0x0000000000000000000000000000000000000000000000000000000000000000", "0x0000000000000000000000000000000000000000000000000000000000000000", "0x0000000000000000000000000000000000000000000000000000000000000000", "0x0000000000000000000000000000000000000000000000000000000000000000", "0x0000000000000000000000000000000000000000000000000000000000000000", "0x0000000000000000000000000000000000000000000000000000000000000000", "0x0000000000000000000000000000000000000000000000000000000000000000", "0x0000000000000000000000000000000000000000000000000000000000000000", "0x0000000000000000000000000000000000000000000000000000000000000000", "0x0000000000000000000000000000000000000000000000000000000000000000", "0x0000000000000000000000000000000000000000000000000000000000000000", "0x0000000000000000000000000000000000000000000000000000000000000000", "0x0000000000000000000000000000000000000000000000000000000000000000", "0x0000000000000000000000000000000000000000000000000000000000000000", "0x0000000000000000000000000000000000000000000000000000000000000000", "0x0000000000000000000000000000000000000000000000000000000000000000", "0x0000000000000000000000000000000000000000000000000000000000000000", "0x0000000000000000000000000000000000000000000000000000000000000000", "0x0000000000000000000000000000000000000000000000000000000000000000", "0x0000000000000000000000000000000000000000000000000000000000000000", "0x0000000000000000000000000000000000000000000000000000000000000000", "0x000000000000000000000000000000fd38c45c3ec5b841482a80e3a56ce82555", "0x00000000000000000000000000000000000ad70b03f092f60af3e0ce1bb29d2c", "0x0000000000000000000000000000007a184d5342c90c634c0b1a050f0b97c9fb", "0x0000000000000000000000000000000000271f42abcb3bc1f0332e4b3ca85e1d", "0x0000000000000000000000000000008256322bbe2c1b8cd9d84e5ff6123477f2", "0x000000000000000000000000000000000025cab962761681dd9547f4c78814df", "0x0000000000000000000000000000008c4234510e5825c02b9ac427bcbf8e279a", "0x000000000000000000000000000000000013a14e0d7fc073c44643af38cc5396"]
+public_inputs = ["0x0000000000000000000000000000000000000000000000000000000000000003"]
+verification_key = ["0x0000000000000000000000000000000000000000000000000000000000000040", "0x0000000000000000000000000000000000000000000000000000000000000011", "0x0000000000000000000000000000000000000000000000000000000000000001", "0x0000000000000000000000000000000000000000000000000000000000000001", "0x0000000000000000000000000000000000000000000000000000000000000001", "0x0000000000000000000000000000000000000000000000000000000000000002", "0x0000000000000000000000000000000000000000000000000000000000000003", "0x0000000000000000000000000000000000000000000000000000000000000004", "0x0000000000000000000000000000000000000000000000000000000000000005", "0x0000000000000000000000000000000000000000000000000000000000000006", "0x0000000000000000000000000000000000000000000000000000000000000007", "0x0000000000000000000000000000000000000000000000000000000000000008", "0x0000000000000000000000000000000000000000000000000000000000000009", "0x000000000000000000000000000000000000000000000000000000000000000a", "0x000000000000000000000000000000000000000000000000000000000000000b", "0x000000000000000000000000000000000000000000000000000000000000000c", "0x000000000000000000000000000000000000000000000000000000000000000d", "0x000000000000000000000000000000000000000000000000000000000000000e", "0x000000000000000000000000000000000000000000000000000000000000000f", "0x0000000000000000000000000000000000000000000000000000000000000010", "0x00000000000000000000000000000060e430ad1c23bfcf3514323aae3f206e84", "0x00000000000000000000000000000000001b5c3ff4c2458d8f481b1c068f27ae", "0x000000000000000000000000000000bb510ab2112def34980e4fc6998ad9dd16", "0x00000000000000000000000000000000000576e7c105b43e061e13cb877fefe1", "0x000000000000000000000000000000ced074785d11857b065d8199e6669a601c", "0x00000000000000000000000000000000000053b48a4098c1c0ae268f273952f7", "0x000000000000000000000000000000d1d4b26e941db8168cee8f6de548ae0fd8", "0x00000000000000000000000000000000001a9adf5a6dadc3d948bb61dfd63f4c", "0x0000000000000000000000000000009ce1faac6f8de6ebb18f1db17372c82ad5", "0x00000000000000000000000000000000002002681bb417184b2df070a16a3858", "0x000000000000000000000000000000161baa651a8092e0e84725594de5aba511", "0x00000000000000000000000000000000000be0064399c2a1efff9eb0cdcb2223", "0x0000000000000000000000000000008673be6fd1bdbe980a29d8c1ded54381e7", "0x000000000000000000000000000000000008a5158a7d9648cf1d234524c9fa0c", "0x0000000000000000000000000000002b4fce6e4b1c72062b296d49bca2aa4130", "0x00000000000000000000000000000000002e45a9eff4b6769e55fb710cded44f", "0x00000000000000000000000000000072b85bf733758b76bcf97333efb85a23e3", "0x000000000000000000000000000000000017da0ea508994fc82862715e4b5592", "0x00000000000000000000000000000094fa74695cf058dba8ff35aec95456c6c3", "0x0000000000000000000000000000000000211acddb851061c24b8f159e832bd1", "0x000000000000000000000000000000303b5e5c531384b9a792e11702ad3bcab0", "0x00000000000000000000000000000000000d336dff51a60b8833d5d7f6d4314c", "0x0000000000000000000000000000009f825dde88092070747180d581c342444a", "0x0000000000000000000000000000000000237fbd6511a03cca8cac01b555fe01", "0x0000000000000000000000000000007c313205159495df6d8de292079a4844ff", "0x000000000000000000000000000000000018facdfc468530dd45e8f7a1d38ce9", "0x0000000000000000000000000000000d1ce33446fc3dc4ab40ca38d92dac74e1", "0x00000000000000000000000000000000000852d8e3e0e8f4435af3e94222688b", "0x0000000000000000000000000000006c04ee19ec1dfec87ed47d6d04aa158de2", "0x000000000000000000000000000000000013240f97a584b45184c8ec31319b5f", "0x000000000000000000000000000000cefb5d240b07ceb4be26ea429b6dc9d9e0", "0x00000000000000000000000000000000002dad22022121d689f57fb38ca21349", "0x000000000000000000000000000000c9f189f2a91aeb664ce376d8b157ba98f8", "0x00000000000000000000000000000000002531a51ad54f124d58094b219818d2", "0x000000000000000000000000000000ef1e6db71809307f677677e62b4163f556", "0x0000000000000000000000000000000000272da4396fb2a7ee0638b9140e523d", "0x0000000000000000000000000000002e54c0244a7732c87bc4712a76dd8c83fb", "0x000000000000000000000000000000000007db77b3e04b7eba9643da57cbbe4d", "0x000000000000000000000000000000e0dfe1ddd7f74ae0d636c910c3e85830d8", "0x00000000000000000000000000000000000466fa9b57ec4664abd1505b490862", "0x0000000000000000000000000000009ee55ae8a32fe5384c79907067cc27192e", "0x00000000000000000000000000000000000799d0e465cec07ecb5238c854e830", "0x0000000000000000000000000000001d5910ad361e76e1c241247a823733c39f", "0x00000000000000000000000000000000002b03f2ccf7507564da2e6678bef8fe", "0x000000000000000000000000000000ee40d90bea71fba7a412dd61fcf34e8ceb", "0x0000000000000000000000000000000000140b0936c323fd2471155617b6af56", "0x0000000000000000000000000000002b90071823185c5ff8e440fd3d73b6fefc", "0x00000000000000000000000000000000002b6c10790a5f6631c87d652e059df4", "0x00000000000000000000000000000029a17181c7934fc3fdbd352eac5cb521b9", "0x00000000000000000000000000000000001f497cbf5284ff29a2d336e5991999", "0x000000000000000000000000000000072bd9c0c6beda1fdee6d4ff0432ba9e1b", "0x000000000000000000000000000000000013ea38a0bd2aa751a490a724fac818", "0x000000000000000000000000000000c599f63dcd3edd49f08ae5c3141c1e3493", "0x00000000000000000000000000000000002bdb36be0bea09950dd32a8ccf6fbc", "0x00000000000000000000000000000047f27f29724e7f19eba0340256a0bd4b7d", "0x00000000000000000000000000000000001c1c5ccf87a962129ca785f8f35120", "0x000000000000000000000000000000c5c71efdae00679bbe4a95096e012b1817", "0x000000000000000000000000000000000017a365de041e317817d0135f2b48e0", "0x0000000000000000000000000000008ae711ac402f7848d719c93a89ba8d39f1", "0x00000000000000000000000000000000002b6fb40ed8a1935226f4f9786a0499", "0x0000000000000000000000000000002f03a71501d83de1da5715a4e9462d6198", "0x00000000000000000000000000000000001644064443b8546f48eae693af47b8", "0x00000000000000000000000000000083763ab1b6e8fe269b2fe4c7b9c448c08d", "0x000000000000000000000000000000000021d7cc18c59676a8eeb47c0111c251", "0x000000000000000000000000000000b5f937153073e03ea7d51a996e0ebc2e6b", "0x000000000000000000000000000000000011ddd0e26457373eb06e0493177672", "0x000000000000000000000000000000c5f6eb9f6fc8fa99811a4a88c74a6d018b", "0x000000000000000000000000000000000025bcd07a0732c123567834f5109558", "0x000000000000000000000000000000aeb08a0b1a4442189448b4e97490568146", "0x000000000000000000000000000000000002a1744e4771705536a88f07e0f90f", "0x000000000000000000000000000000b938568293bd0724b0ea76c2ec34c4a829", "0x0000000000000000000000000000000000053296e8f3b9ad3af877dfa9c7c2a7", "0x000000000000000000000000000000f0ca1db6323996eba26bdc86dafef9d10b", "0x00000000000000000000000000000000001441a46c58af03d5645d52721d956a", "0x0000000000000000000000000000008bbf8f884013c66c28ba09c2fbd573b656", "0x0000000000000000000000000000000000206c391ca06fac27d1908e94570243", "0x0000000000000000000000000000002d4f5aaed88ba4f79612d53b804ca8f194", "0x00000000000000000000000000000000001674011c96392df08970fa6b7b4cb8", "0x0000000000000000000000000000009f88297c1729d76c4d9306853598c91325", "0x0000000000000000000000000000000000256f51adfcacc3c1e340be4d32d3e9", "0x0000000000000000000000000000000ab9955eec0d74eb799afed2a802b24d75", "0x00000000000000000000000000000000001fcbe43ea105b30d36ed0b21b03411", "0x000000000000000000000000000000d66b1d5433f1aa5305cd1edce7c22de466", "0x00000000000000000000000000000000002331546a256b8a3b751956806680d4", "0x000000000000000000000000000000e97954ad6cd6f45fb15c91434121db4304", "0x00000000000000000000000000000000002e20a97e09d50f227ced47e7a98250", "0x0000000000000000000000000000001ebbc27eb9ebededefba79522eb58ae89b", "0x0000000000000000000000000000000000090efa4974e566e81d1177b85a30be", "0x0000000000000000000000000000005eafa070b9c9632404052642e3bc14f9fd", "0x00000000000000000000000000000000001489068864102daca6a6b8bc4d448b", "0x0000000000000000000000000000009ebc91aaaac036a6477cadbe54e8556dfd", "0x00000000000000000000000000000000000ef6d835e2ed3343b95c82c8c54037", "0x00000000000000000000000000000033b28b529dff46e93af4e7422530478e4a", "0x000000000000000000000000000000000020a86c2f8591bf190bcddcc03c42fb", "0x000000000000000000000000000000a9679d0acc088f7dc27bf6d866bcd2dda2", "0x00000000000000000000000000000000002fb9d0d2d4099402bed74f738f64cc", "0x00000000000000000000000000000023b09f876a29a061582848a8b9a5870c12", "0x00000000000000000000000000000000001d5bb906f03f0d49e9c4791bc43af9", "0x00000000000000000000000000000017aac9854ea240d8ec97bf760c4d4ba870", "0x00000000000000000000000000000000000b227a556c414ada0dc75bb303e30e", "0x0000000000000000000000000000000000000000000000000000000000000001", "0x0000000000000000000000000000000000000000000000000000000000000000", "0x0000000000000000000000000000000000000000000000000000000000000002", "0x0000000000000000000000000000000000000000000000000000000000000000", "0x0000000000000000000000000000009b624fa65d1a24b7f14a8f25f3789622af", "0x000000000000000000000000000000000013d47bff8c630e847b70e2732fd3f0", "0x00000000000000000000000000000061d21663e93132f32921075f4c936a84df", "0x00000000000000000000000000000000001a74ca4e118fb480b9b999902989a3"]
diff --git a/test_programs/execution_success/verify_honk_proof/src/main.nr b/test_programs/execution_success/verify_honk_proof/src/main.nr
new file mode 100644
index 00000000000..25f140a9688
--- /dev/null
+++ b/test_programs/execution_success/verify_honk_proof/src/main.nr
@@ -0,0 +1,21 @@
+// This circuit aggregates a single Honk proof from `assert_statement`.
+global SIZE_OF_PROOF_IF_LOGN_IS_28: u32 = 463;
+global HONK_IDENTIFIER: u32 = 1;
+fn main(
+    verification_key: [Field; 128],
+    // This is the proof without public inputs attached.
+    // This means: the size of this does not change with the number of public inputs.
+    proof: [Field; SIZE_OF_PROOF_IF_LOGN_IS_28],
+    public_inputs: pub [Field; 1],
+    // This is currently not public. It is fine given that the vk is a part of the circuit definition.
+    // I believe we want to eventually make it public too though.
+    key_hash: Field,
+) {
+    std::verify_proof_with_type(
+        verification_key,
+        proof,
+        public_inputs,
+        key_hash,
+        HONK_IDENTIFIER,
+    );
+}
diff --git a/test_programs/execution_success/wildcard_type/src/main.nr b/test_programs/execution_success/wildcard_type/src/main.nr
index c27f9987c48..2227dfbf3c7 100644
--- a/test_programs/execution_success/wildcard_type/src/main.nr
+++ b/test_programs/execution_success/wildcard_type/src/main.nr
@@ -18,6 +18,6 @@ fn foo(x: Field) -> [bar; 4] {
         bar { enable: [true, true, false, false], data: [x, x + 1], pad: 0 },
         bar { enable: [true, false, false, false], data: [x + 2, x + 7], pad: 0 },
         bar { enable: [true, true, false, true], data: [x + 3, x + 5], pad: 0 },
-        bar { enable: [false, false, false, false], data: [x + 4, x - 1], pad: 0 }
+        bar { enable: [false, false, false, false], data: [x + 4, x - 1], pad: 0 },
     ]
 }
diff --git a/test_programs/gates_report.sh b/test_programs/gates_report.sh
index 6c901ff24bc..12e9ae0f864 100755
--- a/test_programs/gates_report.sh
+++ b/test_programs/gates_report.sh
@@ -4,7 +4,7 @@ set -e
 BACKEND=${BACKEND:-bb}
 
 # These tests are incompatible with gas reporting
-excluded_dirs=("workspace" "workspace_default_member" "databus")
+excluded_dirs=("workspace" "workspace_default_member" "databus" "double_verify_honk_proof" "verify_honk_proof")
 
 current_dir=$(pwd)
 artifacts_path="$current_dir/acir_artifacts"
diff --git a/test_programs/gates_report_brillig.sh b/test_programs/gates_report_brillig.sh
old mode 100644
new mode 100755
diff --git a/test_programs/gates_report_brillig_execution.sh b/test_programs/gates_report_brillig_execution.sh
new file mode 100755
index 00000000000..b3f4a8bda98
--- /dev/null
+++ b/test_programs/gates_report_brillig_execution.sh
@@ -0,0 +1,43 @@
+#!/usr/bin/env bash
+set -e
+
+# These tests are incompatible with gas reporting
+excluded_dirs=(
+  "workspace" 
+  "workspace_default_member" 
+  "double_verify_nested_proof" 
+  "overlapping_dep_and_mod" 
+  "comptime_println"
+  #  bit sizes for bigint operation doesn't match up.
+  "bigint"
+  #  Expected to fail as test asserts on which runtime it is in.
+  "is_unconstrained"
+)
+
+current_dir=$(pwd)
+base_path="$current_dir/execution_success"
+test_dirs=$(ls $base_path)
+
+# We generate a Noir workspace which contains all of the test cases
+# This allows us to generate a gates report using `nargo info` for all of them at once.
+
+echo "[workspace]" > Nargo.toml
+echo "members = [" >> Nargo.toml
+
+for dir in $test_dirs; do
+    if [[ " ${excluded_dirs[@]} " =~ " ${dir} " ]]; then
+      continue
+    fi
+
+    if [[ ${CI-false} = "true" ]] && [[ " ${ci_excluded_dirs[@]} " =~ " ${dir} " ]]; then
+      continue
+    fi
+
+    echo "  \"execution_success/$dir\"," >> Nargo.toml
+done
+
+echo "]" >> Nargo.toml
+
+nargo info --profile-execution --json > gates_report_brillig_execution.json
+
+rm Nargo.toml
\ No newline at end of file
diff --git a/test_programs/memory_report.sh b/test_programs/memory_report.sh
new file mode 100755
index 00000000000..4d03726d374
--- /dev/null
+++ b/test_programs/memory_report.sh
@@ -0,0 +1,55 @@
+#!/usr/bin/env bash
+set -e
+
+sudo apt-get install heaptrack
+
+NARGO="nargo"
+
+# Tests to be profiled for memory report
+tests_to_profile=("keccak256" "workspace" "regression_4709" "ram_blowup_regression")
+
+current_dir=$(pwd)
+base_path="$current_dir/execution_success"
+
+# If there is an argument that means we want to generate a report for only the current directory
+if [ "$#" -ne 0 ]; then
+  base_path="$current_dir"
+  tests_to_profile=(".")
+fi
+
+FIRST="1"
+
+echo "{\"memory_reports\": [ " > memory_report.json
+
+for test_name in ${tests_to_profile[@]}; do    
+        cd $base_path/$test_name
+
+        if [ $FIRST = "1" ]
+        then
+            FIRST="0"
+        else
+            echo " ," >> $current_dir"/memory_report.json"
+        fi
+
+        if [ "$#" -ne 0 ]; then
+            test_name=$(basename $current_dir)
+        fi
+
+        heaptrack --output $current_dir/$test_name"_heap" $NARGO compile --force
+        if test -f $current_dir/$test_name"_heap.gz"; 
+        then 
+            heaptrack --analyze $current_dir/$test_name"_heap.gz" > $current_dir/$test_name"_heap_analysis.txt"
+            rm $current_dir/$test_name"_heap.gz"
+        else 
+            heaptrack --analyze $current_dir/$test_name"_heap.zst" > $current_dir/$test_name"_heap_analysis.txt"
+            rm $current_dir/$test_name"_heap.zst"
+        fi
+        consumption="$(grep 'peak heap memory consumption'  $current_dir/$test_name'_heap_analysis.txt')"
+        len=${#consumption}-30
+        peak=${consumption:30:len}
+        rm $current_dir/$test_name"_heap_analysis.txt"
+        echo -e " {\n    \"artifact_name\":\"$test_name\",\n    \"peak_memory\":\"$peak\"\n }" >> $current_dir"/memory_report.json"
+done
+
+echo "]}" >> $current_dir"/memory_report.json"
+
diff --git a/test_programs/execution_success/assert_statement_recursive/Nargo.toml b/test_programs/noir_test_success/assert_message/Nargo.toml
similarity index 57%
rename from test_programs/execution_success/assert_statement_recursive/Nargo.toml
rename to test_programs/noir_test_success/assert_message/Nargo.toml
index 2a5b02cad00..667035339bd 100644
--- a/test_programs/execution_success/assert_statement_recursive/Nargo.toml
+++ b/test_programs/noir_test_success/assert_message/Nargo.toml
@@ -1,7 +1,7 @@
 [package]
-name = "assert_statement_recursive"
+name = "assert_message"
 type = "bin"
 authors = [""]
 compiler_version = ">=0.23.0"
 
-[dependencies]
\ No newline at end of file
+[dependencies]
diff --git a/test_programs/noir_test_success/assert_message/src/main.nr b/test_programs/noir_test_success/assert_message/src/main.nr
new file mode 100644
index 00000000000..073e42daf4a
--- /dev/null
+++ b/test_programs/noir_test_success/assert_message/src/main.nr
@@ -0,0 +1,15 @@
+// Have to use inputs otherwise the ACIR gets optimized away due to constants.
+// With the original ACIR the optimizations can rearrange or merge opcodes,
+// which might end up getting out of sync with assertion messages.
+#[test(should_fail_with = "first")]
+fn test_assert_message_preserved_during_optimization(a: Field, b: Field, c: Field) {
+    if (a + b) * (a - b) != c {
+        assert((a + b) * (a - b) == c, "first");
+        assert((a - b) * (a + b) == c, "second");
+        assert((a + b) * (a - b) == c, "third");
+        assert((2 * a + b) * (a - b / 2) == c * c, "fourth");
+    } else {
+        // The fuzzer might have generated a passing test.
+        assert((a + b) * (a - b) != c, "first");
+    }
+}
diff --git a/test_programs/noir_test_success/bounded_vec/src/main.nr b/test_programs/noir_test_success/bounded_vec/src/main.nr
index cb9879b1c9e..fa2c55e6934 100644
--- a/test_programs/noir_test_success/bounded_vec/src/main.nr
+++ b/test_programs/noir_test_success/bounded_vec/src/main.nr
@@ -20,7 +20,7 @@ fn good() -> BoundedVec<Field, 10> {
 
 fn bad() {
     // Error: Type annotation needed
-    // The compiller can't infer `MaxLen` from this code.
+    // The compiler can't infer `MaxLen` from this code.
     let mut v3 = BoundedVec::new();
     v3.push(5);
 }
@@ -79,7 +79,7 @@ fn set_unchecked_example() {
 
     // We've now written past the end of `vec`.
     // As this index is still within the maximum potential length of `v`,
-    // it won't cause a constraint failure. 
+    // it won't cause a constraint failure.
     vec.set_unchecked(2, 42);
     println(vec);
 
@@ -189,13 +189,13 @@ fn test_vec_extend_from_bounded_vec() {
     // docs:end:bounded-vec-extend-from-bounded-vec-example
 }
 
-#[test(should_fail_with="extend_from_array out of bounds")]
+#[test(should_fail_with = "extend_from_array out of bounds")]
 fn test_vec_extend_from_array_out_of_bound() {
     let mut vec: BoundedVec<Field, 2> = BoundedVec::new();
     vec.extend_from_array([2, 4, 6]);
 }
 
-#[test(should_fail_with="extend_from_array out of bounds")]
+#[test(should_fail_with = "extend_from_array out of bounds")]
 fn test_vec_extend_from_array_twice_out_of_bound() {
     let mut vec: BoundedVec<Field, 2> = BoundedVec::new();
     vec.extend_from_array([2]);
@@ -223,14 +223,14 @@ fn test_vec_get_uninitialized() {
     let _x = vec.get(0);
 }
 
-#[test(should_fail_with="push out of bounds")]
+#[test(should_fail_with = "push out of bounds")]
 fn test_vec_push_out_of_bound() {
     let mut vec: BoundedVec<Field, 1> = BoundedVec::new();
     vec.push(1);
     vec.push(2);
 }
 
-#[test(should_fail_with="extend_from_bounded_vec out of bounds")]
+#[test(should_fail_with = "extend_from_bounded_vec out of bounds")]
 fn test_vec_extend_from_bounded_vec_out_of_bound() {
     let mut vec: BoundedVec<Field, 2> = BoundedVec::new();
 
@@ -240,7 +240,7 @@ fn test_vec_extend_from_bounded_vec_out_of_bound() {
     vec.extend_from_bounded_vec(another_vec);
 }
 
-#[test(should_fail_with="extend_from_bounded_vec out of bounds")]
+#[test(should_fail_with = "extend_from_bounded_vec out of bounds")]
 fn test_vec_extend_from_bounded_vec_twice_out_of_bound() {
     let mut vec: BoundedVec<Field, 2> = BoundedVec::new();
     vec.extend_from_array([1, 2]);
diff --git a/test_programs/noir_test_success/comptime_blackbox/Nargo.toml b/test_programs/noir_test_success/comptime_blackbox/Nargo.toml
new file mode 100644
index 00000000000..5eac6f3c91a
--- /dev/null
+++ b/test_programs/noir_test_success/comptime_blackbox/Nargo.toml
@@ -0,0 +1,7 @@
+[package]
+name = "comptime_blackbox"
+type = "bin"
+authors = [""]
+compiler_version = ">=0.27.0"
+
+[dependencies]
diff --git a/test_programs/noir_test_success/comptime_blackbox/src/main.nr b/test_programs/noir_test_success/comptime_blackbox/src/main.nr
new file mode 100644
index 00000000000..c3784e73b09
--- /dev/null
+++ b/test_programs/noir_test_success/comptime_blackbox/src/main.nr
@@ -0,0 +1,155 @@
+//! Tests to show that the comptime interpreter implement blackbox functions.
+use std::bigint;
+use std::embedded_curve_ops::{EmbeddedCurvePoint, EmbeddedCurveScalar, multi_scalar_mul};
+
+/// Test that all bigint operations work in comptime.
+#[test]
+fn test_bigint() {
+    let result: [u8] = comptime {
+        let a = bigint::Secpk1Fq::from_le_bytes(&[0, 1, 2, 3, 4]);
+        let b = bigint::Secpk1Fq::from_le_bytes(&[5, 6, 7, 8, 9]);
+        let c = (a + b) * b / a - a;
+        c.to_le_bytes()
+    };
+    // Do the same calculation outside comptime.
+    let a = bigint::Secpk1Fq::from_le_bytes(&[0, 1, 2, 3, 4]);
+    let b = bigint::Secpk1Fq::from_le_bytes(&[5, 6, 7, 8, 9]);
+    let c = bigint::Secpk1Fq::from_le_bytes(result);
+    assert_eq(c, (a + b) * b / a - a);
+}
+
+/// Test that to_le_radix returns an array.
+#[test]
+fn test_to_le_radix() {
+    comptime {
+        let field = 2;
+        let bytes: [u8; 8] = field.to_le_radix(256);
+        let _num = bigint::BigInt::from_le_bytes(bytes, bigint::bn254_fq);
+    };
+}
+
+#[test]
+fn test_bitshift() {
+    let c = comptime {
+        let a: i32 = 10;
+        let b: u32 = 4;
+        a << b as u8
+    };
+    assert_eq(c, 160);
+}
+
+#[test]
+fn test_aes128_encrypt() {
+    let ciphertext = comptime {
+        let plaintext: [u8; 5] = [1, 2, 3, 4, 5];
+        let iv: [u8; 16] = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15];
+        let key: [u8; 16] = [10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25];
+        std::aes128::aes128_encrypt(plaintext, iv, key)
+    };
+    let clear_len = 5;
+    let cipher_len = clear_len + 16 - clear_len % 16;
+    assert_eq(ciphertext.len(), cipher_len);
+}
+
+#[test]
+fn test_blake2s() {
+    let hash = comptime {
+        let input = [104, 101, 108, 108, 111];
+        std::hash::blake2s(input)
+    };
+    assert_eq(hash[0], 0x19);
+    assert_eq(hash[31], 0x25);
+}
+
+#[test]
+fn test_blake3() {
+    let hash = comptime {
+        let input = [104, 101, 108, 108, 111];
+        std::hash::blake3(input)
+    };
+    assert_eq(hash[0], 0xea);
+    assert_eq(hash[31], 0x0f);
+}
+
+/// Test that ecdsa_secp256k1 is implemented.
+#[test]
+fn test_ecdsa_secp256k1() {
+    let (valid_array, valid_slice) = comptime {
+        let pub_key_x: [u8; 32] = hex_to_bytes("a0434d9e47f3c86235477c7b1ae6ae5d3442d49b1943c2b752a68e2a47e247c7").as_array();
+        let pub_key_y: [u8; 32] = hex_to_bytes("893aba425419bc27a3b6c7e693a24c696f794c2ed877a1593cbee53b037368d7").as_array();
+        let signature: [u8; 64] = hex_to_bytes("e5081c80ab427dc370346f4a0e31aa2bad8d9798c38061db9ae55a4e8df454fd28119894344e71b78770cc931d61f480ecbb0b89d6eb69690161e49a715fcd55").as_array();
+        let hashed_message: [u8; 32] = hex_to_bytes("3a73f4123a5cd2121f21cd7e8d358835476949d035d9c2da6806b4633ac8c1e2").as_array();
+
+        let valid_array = std::ecdsa_secp256k1::verify_signature(pub_key_x, pub_key_y, signature, hashed_message);
+        let valid_slice = std::ecdsa_secp256k1::verify_signature_slice(pub_key_x, pub_key_y, signature, hashed_message.as_slice());
+
+        (valid_array, valid_slice)
+    };
+    assert(valid_array);
+    assert(valid_slice);
+}
+
+/// Test that ecdsa_secp256r1 is implemented.
+#[test]
+fn test_ecdsa_secp256r1() {
+    let (valid_array, valid_slice) = comptime {
+        let pub_key_x: [u8; 32] = hex_to_bytes("550f471003f3df97c3df506ac797f6721fb1a1fb7b8f6f83d224498a65c88e24").as_array();
+        let pub_key_y: [u8; 32] = hex_to_bytes("136093d7012e509a73715cbd0b00a3cc0ff4b5c01b3ffa196ab1fb327036b8e6").as_array();
+        let signature: [u8; 64] = hex_to_bytes("2c70a8d084b62bfc5ce03641caf9f72ad4da8c81bfe6ec9487bb5e1bef62a13218ad9ee29eaf351fdc50f1520c425e9b908a07278b43b0ec7b872778c14e0784").as_array();
+        let hashed_message: [u8; 32] = hex_to_bytes("54705ba3baafdbdfba8c5f9a70f7a89bee98d906b53e31074da7baecdc0da9ad").as_array();
+
+        let valid_array = std::ecdsa_secp256r1::verify_signature(pub_key_x, pub_key_y, signature, hashed_message);
+        let valid_slice = std::ecdsa_secp256r1::verify_signature_slice(pub_key_x, pub_key_y, signature, hashed_message.as_slice());
+        (valid_array, valid_slice)
+    };
+    assert(valid_array);
+    assert(valid_slice);
+}
+
+/// Test that sha256_compression is implemented.
+#[test]
+fn test_sha256() {
+    let hash = comptime {
+        let input: [u8; 1] = [0xbd];
+        std::hash::sha256(input)
+    };
+    assert_eq(hash[0], 0x68);
+    assert_eq(hash[31], 0x2b);
+}
+
+/// Test that `embedded_curve_add` and `multi_scalar_mul` are implemented.
+#[test]
+fn test_embedded_curve_ops() {
+    let (sum, mul) = comptime {
+        let g1 = EmbeddedCurvePoint { x: 1, y: 17631683881184975370165255887551781615748388533673675138860, is_infinite: false };
+        let s1 = EmbeddedCurveScalar { lo: 1, hi: 0 };
+        let sum = g1 + g1;
+        let mul = multi_scalar_mul([g1, g1], [s1, s1]);
+        (sum, mul)
+    };
+    assert_eq(sum, mul);
+}
+
+/// Parse a lowercase hexadecimal string (without 0x prefix) as byte slice.
+comptime fn hex_to_bytes<let N: u32>(s: str<N>) -> [u8] {
+    assert(N % 2 == 0);
+    let mut out = &[];
+    let bz = s.as_bytes();
+    let mut h: u32 = 0;
+    for i in 0 .. bz.len() {
+        let ascii = bz[i];
+        let d = if ascii < 58 {
+            ascii - 48
+        } else {
+            assert(ascii >= 97); // enforce >= 'a'
+            assert(ascii <= 102); // enforce <= 'f'
+            ascii - 87
+        };
+        h = h * 16 + d as u32;
+        if i % 2 == 1 {
+            out = out.push_back(h as u8);
+            h = 0;
+        }
+    }
+    out
+}
diff --git a/test_programs/noir_test_success/fuzzer_checks/src/main.nr b/test_programs/noir_test_success/fuzzer_checks/src/main.nr
index 2b928db092e..70e5e29b855 100644
--- a/test_programs/noir_test_success/fuzzer_checks/src/main.nr
+++ b/test_programs/noir_test_success/fuzzer_checks/src/main.nr
@@ -1,6 +1,9 @@
-
 #[test(should_fail_with = "42 is not allowed")]
 fn finds_magic_value(x: u32) {
     let x = x as u64;
-    assert(2 * x != 42, "42 is not allowed");
+    if x == 21 {
+        assert(2 * x != 42, "42 is not allowed");
+    } else {
+        assert(2 * x == 42, "42 is not allowed");
+    }
 }
diff --git a/test_programs/test_libraries/diamond_deps_2/src/lib.nr b/test_programs/test_libraries/diamond_deps_2/src/lib.nr
index 46dce3d5600..23de4d4c0f3 100644
--- a/test_programs/test_libraries/diamond_deps_2/src/lib.nr
+++ b/test_programs/test_libraries/diamond_deps_2/src/lib.nr
@@ -1,4 +1,4 @@
-global RESOLVE_THIS = 3;
+global RESOLVE_THIS: Field = 3;
 
 pub fn call_dep2(x: Field, y: Field) -> Field {
     x + y
diff --git a/test_programs/test_libraries/exporting_lib/src/lib.nr b/test_programs/test_libraries/exporting_lib/src/lib.nr
index fdd9f139d41..7da75ce5413 100644
--- a/test_programs/test_libraries/exporting_lib/src/lib.nr
+++ b/test_programs/test_libraries/exporting_lib/src/lib.nr
@@ -1,8 +1,8 @@
-struct MyStruct {
-    inner: Field
+pub struct MyStruct {
+    pub inner: Field
 }
 
-type FooStruct = MyStruct;
+pub type FooStruct = MyStruct;
 
 pub fn is_struct_zero(val: MyStruct) -> bool {
     val.inner == 0
diff --git a/test_programs/test_libraries/reexporting_lib/src/lib.nr b/test_programs/test_libraries/reexporting_lib/src/lib.nr
index 1bced548304..f106971028d 100644
--- a/test_programs/test_libraries/reexporting_lib/src/lib.nr
+++ b/test_programs/test_libraries/reexporting_lib/src/lib.nr
@@ -1,3 +1,3 @@
-use exporting_lib::{MyStruct, FooStruct};
+pub use exporting_lib::{MyStruct, FooStruct};
 
-use exporting_lib as lib;
+pub use exporting_lib as lib;
diff --git a/tooling/acvm_cli/src/cli/execute_cmd.rs b/tooling/acvm_cli/src/cli/execute_cmd.rs
index c453936568c..d4473eb3eef 100644
--- a/tooling/acvm_cli/src/cli/execute_cmd.rs
+++ b/tooling/acvm_cli/src/cli/execute_cmd.rs
@@ -5,10 +5,11 @@ use acir::native_types::{WitnessMap, WitnessStack};
 use acir::FieldElement;
 use bn254_blackbox_solver::Bn254BlackBoxSolver;
 use clap::Args;
+use nargo::PrintOutput;
 
 use crate::cli::fs::inputs::{read_bytecode_from_file, read_inputs_from_file};
 use crate::errors::CliError;
-use nargo::ops::{execute_program, DefaultForeignCallExecutor};
+use nargo::{foreign_calls::DefaultForeignCallExecutor, ops::execute_program};
 
 use super::fs::witness::{create_output_witness_string, save_witness_to_dir};
 
@@ -73,7 +74,7 @@ pub(crate) fn execute_program_from_witness(
         &program,
         inputs_map,
         &Bn254BlackBoxSolver,
-        &mut DefaultForeignCallExecutor::new(true, None, None, None),
+        &mut DefaultForeignCallExecutor::new(PrintOutput::Stdout, None, None, None),
     )
     .map_err(CliError::CircuitExecutionError)
 }
diff --git a/tooling/debugger/ignored-tests.txt b/tooling/debugger/ignored-tests.txt
index 0037b8e5d5f..e0548fe1e1a 100644
--- a/tooling/debugger/ignored-tests.txt
+++ b/tooling/debugger/ignored-tests.txt
@@ -2,7 +2,8 @@ brillig_references
 debug_logs
 is_unconstrained
 macros
+reference_counts
 references
 regression_4709
 reference_only_used_as_alias
-brillig_rc_regression_6123
\ No newline at end of file
+brillig_rc_regression_6123
diff --git a/tooling/debugger/src/context.rs b/tooling/debugger/src/context.rs
index dde3fe84d88..77c186fe707 100644
--- a/tooling/debugger/src/context.rs
+++ b/tooling/debugger/src/context.rs
@@ -954,7 +954,7 @@ mod tests {
     use crate::foreign_calls::DefaultDebugForeignCallExecutor;
     use acvm::{
         acir::{
-            brillig::IntegerBitSize,
+            brillig::{HeapVector, IntegerBitSize},
             circuit::{
                 brillig::{BrilligFunctionId, BrilligInputs, BrilligOutputs},
                 opcodes::{AcirFunctionId, BlockId, BlockType},
@@ -967,43 +967,43 @@ mod tests {
             BinaryFieldOp, HeapValueType, MemoryAddress, Opcode as BrilligOpcode, ValueOrArray,
         },
     };
+    use nargo::PrintOutput;
 
     #[test]
     fn test_resolve_foreign_calls_stepping_into_brillig() {
-        let fe_0 = FieldElement::zero();
         let fe_1 = FieldElement::one();
         let w_x = Witness(1);
 
         let brillig_bytecode = BrilligBytecode {
             bytecode: vec![
                 BrilligOpcode::Const {
-                    destination: MemoryAddress(0),
+                    destination: MemoryAddress::direct(1),
                     bit_size: BitSize::Integer(IntegerBitSize::U32),
                     value: FieldElement::from(1u64),
                 },
                 BrilligOpcode::Const {
-                    destination: MemoryAddress(1),
+                    destination: MemoryAddress::direct(2),
                     bit_size: BitSize::Integer(IntegerBitSize::U32),
                     value: FieldElement::from(0u64),
                 },
                 BrilligOpcode::CalldataCopy {
-                    destination_address: MemoryAddress(0),
-                    size_address: MemoryAddress(0),
-                    offset_address: MemoryAddress(1),
-                },
-                BrilligOpcode::Const {
-                    destination: MemoryAddress::from(1),
-                    value: fe_0,
-                    bit_size: BitSize::Integer(IntegerBitSize::U32),
+                    destination_address: MemoryAddress::direct(0),
+                    size_address: MemoryAddress::direct(1),
+                    offset_address: MemoryAddress::direct(2),
                 },
                 BrilligOpcode::ForeignCall {
                     function: "clear_mock".into(),
                     destinations: vec![],
                     destination_value_types: vec![],
-                    inputs: vec![ValueOrArray::MemoryAddress(MemoryAddress::from(0))],
+                    inputs: vec![ValueOrArray::MemoryAddress(MemoryAddress::direct(0))],
                     input_value_types: vec![HeapValueType::field()],
                 },
-                BrilligOpcode::Stop { return_data_offset: 0, return_data_size: 0 },
+                BrilligOpcode::Stop {
+                    return_data: HeapVector {
+                        pointer: MemoryAddress::direct(2),
+                        size: MemoryAddress::direct(2),
+                    },
+                },
             ],
         };
         let opcodes = vec![Opcode::BrilligCall {
@@ -1026,8 +1026,10 @@ mod tests {
 
         let initial_witness = BTreeMap::from([(Witness(1), fe_1)]).into();
 
-        let foreign_call_executor =
-            Box::new(DefaultDebugForeignCallExecutor::from_artifact(true, debug_artifact));
+        let foreign_call_executor = Box::new(DefaultDebugForeignCallExecutor::from_artifact(
+            PrintOutput::Stdout,
+            debug_artifact,
+        ));
         let mut context = DebugContext::new(
             &StubbedBlackBoxSolver,
             circuits,
@@ -1082,18 +1084,6 @@ mod tests {
             })
         );
 
-        // Const
-        let result = context.step_into_opcode();
-        assert!(matches!(result, DebugCommandResult::Ok));
-        assert_eq!(
-            context.get_current_debug_location(),
-            Some(DebugLocation {
-                circuit_id: 0,
-                opcode_location: OpcodeLocation::Brillig { acir_index: 0, brillig_index: 4 },
-                brillig_function_id: Some(BrilligFunctionId(0)),
-            })
-        );
-
         // try to execute the Brillig opcode (and resolve the foreign call)
         let result = context.step_into_opcode();
         assert!(matches!(result, DebugCommandResult::Ok));
@@ -1101,7 +1091,7 @@ mod tests {
             context.get_current_debug_location(),
             Some(DebugLocation {
                 circuit_id: 0,
-                opcode_location: OpcodeLocation::Brillig { acir_index: 0, brillig_index: 4 },
+                opcode_location: OpcodeLocation::Brillig { acir_index: 0, brillig_index: 3 },
                 brillig_function_id: Some(BrilligFunctionId(0)),
             })
         );
@@ -1113,7 +1103,7 @@ mod tests {
             context.get_current_debug_location(),
             Some(DebugLocation {
                 circuit_id: 0,
-                opcode_location: OpcodeLocation::Brillig { acir_index: 0, brillig_index: 5 },
+                opcode_location: OpcodeLocation::Brillig { acir_index: 0, brillig_index: 4 },
                 brillig_function_id: Some(BrilligFunctionId(0)),
             })
         );
@@ -1132,31 +1122,41 @@ mod tests {
         let w_y = Witness(2);
         let w_z = Witness(3);
 
+        let zero_usize = MemoryAddress::direct(2);
+        let one_usize = MemoryAddress::direct(3);
+
         // This Brillig block is equivalent to: z = x + y
         let brillig_bytecode = BrilligBytecode {
             bytecode: vec![
                 BrilligOpcode::Const {
-                    destination: MemoryAddress(0),
+                    destination: MemoryAddress::direct(0),
                     bit_size: BitSize::Integer(IntegerBitSize::U32),
                     value: FieldElement::from(2u64),
                 },
                 BrilligOpcode::Const {
-                    destination: MemoryAddress(1),
+                    destination: zero_usize,
                     bit_size: BitSize::Integer(IntegerBitSize::U32),
                     value: FieldElement::from(0u64),
                 },
+                BrilligOpcode::Const {
+                    destination: one_usize,
+                    bit_size: BitSize::Integer(IntegerBitSize::U32),
+                    value: FieldElement::from(1u64),
+                },
                 BrilligOpcode::CalldataCopy {
-                    destination_address: MemoryAddress(0),
-                    size_address: MemoryAddress(0),
-                    offset_address: MemoryAddress(1),
+                    destination_address: MemoryAddress::direct(0),
+                    size_address: MemoryAddress::direct(0),
+                    offset_address: zero_usize,
                 },
                 BrilligOpcode::BinaryFieldOp {
-                    destination: MemoryAddress::from(0),
+                    destination: MemoryAddress::direct(0),
                     op: BinaryFieldOp::Add,
-                    lhs: MemoryAddress::from(0),
-                    rhs: MemoryAddress::from(1),
+                    lhs: MemoryAddress::direct(0),
+                    rhs: MemoryAddress::direct(1),
+                },
+                BrilligOpcode::Stop {
+                    return_data: HeapVector { pointer: zero_usize, size: one_usize },
                 },
-                BrilligOpcode::Stop { return_data_offset: 0, return_data_size: 1 },
             ],
         };
         let opcodes = vec![
@@ -1193,8 +1193,10 @@ mod tests {
 
         let initial_witness = BTreeMap::from([(Witness(1), fe_1), (Witness(2), fe_1)]).into();
 
-        let foreign_call_executor =
-            Box::new(DefaultDebugForeignCallExecutor::from_artifact(true, debug_artifact));
+        let foreign_call_executor = Box::new(DefaultDebugForeignCallExecutor::from_artifact(
+            PrintOutput::Stdout,
+            debug_artifact,
+        ));
         let brillig_funcs = &vec![brillig_bytecode];
         let mut context = DebugContext::new(
             &StubbedBlackBoxSolver,
@@ -1238,18 +1240,10 @@ mod tests {
 
     #[test]
     fn test_address_debug_location_mapping() {
-        let brillig_one = BrilligBytecode {
-            bytecode: vec![
-                BrilligOpcode::Stop { return_data_offset: 0, return_data_size: 0 },
-                BrilligOpcode::Stop { return_data_offset: 0, return_data_size: 0 },
-            ],
-        };
+        let brillig_one =
+            BrilligBytecode { bytecode: vec![BrilligOpcode::Return, BrilligOpcode::Return] };
         let brillig_two = BrilligBytecode {
-            bytecode: vec![
-                BrilligOpcode::Stop { return_data_offset: 0, return_data_size: 0 },
-                BrilligOpcode::Stop { return_data_offset: 0, return_data_size: 0 },
-                BrilligOpcode::Stop { return_data_offset: 0, return_data_size: 0 },
-            ],
+            bytecode: vec![BrilligOpcode::Return, BrilligOpcode::Return, BrilligOpcode::Return],
         };
 
         let circuit_one = Circuit {
@@ -1296,7 +1290,7 @@ mod tests {
             &circuits,
             &debug_artifact,
             WitnessMap::new(),
-            Box::new(DefaultDebugForeignCallExecutor::new(true)),
+            Box::new(DefaultDebugForeignCallExecutor::new(PrintOutput::Stdout)),
             brillig_funcs,
         );
 
diff --git a/tooling/debugger/src/dap.rs b/tooling/debugger/src/dap.rs
index cfe33a61cb5..0d2095954e0 100644
--- a/tooling/debugger/src/dap.rs
+++ b/tooling/debugger/src/dap.rs
@@ -5,6 +5,7 @@ use acvm::acir::circuit::brillig::BrilligBytecode;
 use acvm::acir::circuit::Circuit;
 use acvm::acir::native_types::WitnessMap;
 use acvm::{BlackBoxFunctionSolver, FieldElement};
+use nargo::PrintOutput;
 
 use crate::context::DebugContext;
 use crate::context::{DebugCommandResult, DebugLocation};
@@ -71,7 +72,10 @@ impl<'a, R: Read, W: Write, B: BlackBoxFunctionSolver<FieldElement>> DapSession<
             circuits,
             debug_artifact,
             initial_witness,
-            Box::new(DefaultDebugForeignCallExecutor::from_artifact(true, debug_artifact)),
+            Box::new(DefaultDebugForeignCallExecutor::from_artifact(
+                PrintOutput::Stdout,
+                debug_artifact,
+            )),
             unconstrained_functions,
         );
         Self {
diff --git a/tooling/debugger/src/foreign_calls.rs b/tooling/debugger/src/foreign_calls.rs
index 6a773a4b348..899ba892d8f 100644
--- a/tooling/debugger/src/foreign_calls.rs
+++ b/tooling/debugger/src/foreign_calls.rs
@@ -3,7 +3,10 @@ use acvm::{
     pwg::ForeignCallWaitInfo,
     AcirField, FieldElement,
 };
-use nargo::ops::{DefaultForeignCallExecutor, ForeignCallExecutor};
+use nargo::{
+    foreign_calls::{DefaultForeignCallExecutor, ForeignCallExecutor},
+    PrintOutput,
+};
 use noirc_artifacts::debug::{DebugArtifact, DebugVars, StackFrame};
 use noirc_errors::debug_info::{DebugFnId, DebugVarId};
 use noirc_printable_type::ForeignCallError;
@@ -41,21 +44,21 @@ pub trait DebugForeignCallExecutor: ForeignCallExecutor<FieldElement> {
     fn current_stack_frame(&self) -> Option<StackFrame<FieldElement>>;
 }
 
-pub struct DefaultDebugForeignCallExecutor {
-    executor: DefaultForeignCallExecutor<FieldElement>,
+pub struct DefaultDebugForeignCallExecutor<'a> {
+    executor: DefaultForeignCallExecutor<'a, FieldElement>,
     pub debug_vars: DebugVars<FieldElement>,
 }
 
-impl DefaultDebugForeignCallExecutor {
-    pub fn new(show_output: bool) -> Self {
+impl<'a> DefaultDebugForeignCallExecutor<'a> {
+    pub fn new(output: PrintOutput<'a>) -> Self {
         Self {
-            executor: DefaultForeignCallExecutor::new(show_output, None, None, None),
+            executor: DefaultForeignCallExecutor::new(output, None, None, None),
             debug_vars: DebugVars::default(),
         }
     }
 
-    pub fn from_artifact(show_output: bool, artifact: &DebugArtifact) -> Self {
-        let mut ex = Self::new(show_output);
+    pub fn from_artifact(output: PrintOutput<'a>, artifact: &DebugArtifact) -> Self {
+        let mut ex = Self::new(output);
         ex.load_artifact(artifact);
         ex
     }
@@ -70,7 +73,7 @@ impl DefaultDebugForeignCallExecutor {
     }
 }
 
-impl DebugForeignCallExecutor for DefaultDebugForeignCallExecutor {
+impl DebugForeignCallExecutor for DefaultDebugForeignCallExecutor<'_> {
     fn get_variables(&self) -> Vec<StackFrame<FieldElement>> {
         self.debug_vars.get_variables()
     }
@@ -88,7 +91,7 @@ fn debug_fn_id(value: &FieldElement) -> DebugFnId {
     DebugFnId(value.to_u128() as u32)
 }
 
-impl ForeignCallExecutor<FieldElement> for DefaultDebugForeignCallExecutor {
+impl ForeignCallExecutor<FieldElement> for DefaultDebugForeignCallExecutor<'_> {
     fn execute(
         &mut self,
         foreign_call: &ForeignCallWaitInfo<FieldElement>,
diff --git a/tooling/debugger/src/repl.rs b/tooling/debugger/src/repl.rs
index 1a7c2d6c7a8..eda3cbfd895 100644
--- a/tooling/debugger/src/repl.rs
+++ b/tooling/debugger/src/repl.rs
@@ -1,13 +1,14 @@
 use crate::context::{DebugCommandResult, DebugContext, DebugLocation};
 
-use acvm::acir::brillig::{BitSize, IntegerBitSize};
+use acvm::acir::brillig::BitSize;
 use acvm::acir::circuit::brillig::{BrilligBytecode, BrilligFunctionId};
 use acvm::acir::circuit::{Circuit, Opcode, OpcodeLocation};
 use acvm::acir::native_types::{Witness, WitnessMap, WitnessStack};
 use acvm::brillig_vm::brillig::Opcode as BrilligOpcode;
 use acvm::brillig_vm::MemoryValue;
+use acvm::AcirField;
 use acvm::{BlackBoxFunctionSolver, FieldElement};
-use nargo::NargoError;
+use nargo::{NargoError, PrintOutput};
 use noirc_driver::CompiledProgram;
 
 use crate::foreign_calls::DefaultDebugForeignCallExecutor;
@@ -41,8 +42,10 @@ impl<'a, B: BlackBoxFunctionSolver<FieldElement>> ReplDebugger<'a, B> {
         initial_witness: WitnessMap<FieldElement>,
         unconstrained_functions: &'a [BrilligBytecode<FieldElement>],
     ) -> Self {
-        let foreign_call_executor =
-            Box::new(DefaultDebugForeignCallExecutor::from_artifact(true, debug_artifact));
+        let foreign_call_executor = Box::new(DefaultDebugForeignCallExecutor::from_artifact(
+            PrintOutput::Stdout,
+            debug_artifact,
+        ));
         let context = DebugContext::new(
             blackbox_solver,
             circuits,
@@ -312,8 +315,10 @@ impl<'a, B: BlackBoxFunctionSolver<FieldElement>> ReplDebugger<'a, B> {
 
     fn restart_session(&mut self) {
         let breakpoints: Vec<DebugLocation> = self.context.iterate_breakpoints().copied().collect();
-        let foreign_call_executor =
-            Box::new(DefaultDebugForeignCallExecutor::from_artifact(true, self.debug_artifact));
+        let foreign_call_executor = Box::new(DefaultDebugForeignCallExecutor::from_artifact(
+            PrintOutput::Stdout,
+            self.debug_artifact,
+        ));
         self.context = DebugContext::new(
             self.blackbox_solver,
             self.circuits,
@@ -369,11 +374,13 @@ impl<'a, B: BlackBoxFunctionSolver<FieldElement>> ReplDebugger<'a, B> {
             return;
         };
 
-        for (index, value) in memory
-            .iter()
-            .enumerate()
-            .filter(|(_, value)| !matches!(value, MemoryValue::Integer(_, IntegerBitSize::U0)))
-        {
+        for (index, value) in memory.iter().enumerate() {
+            // Zero field is the default value, we omit it when printing memory
+            if let MemoryValue::Field(field) = value {
+                if field == &FieldElement::zero() {
+                    continue;
+                }
+            }
             println!("{index} = {}", value);
         }
     }
diff --git a/tooling/debugger/src/source_code_printer.rs b/tooling/debugger/src/source_code_printer.rs
index d1c82ad96ba..b3682c9016f 100644
--- a/tooling/debugger/src/source_code_printer.rs
+++ b/tooling/debugger/src/source_code_printer.rs
@@ -275,6 +275,7 @@ mod tests {
             BTreeMap::default(),
             BTreeMap::default(),
             BTreeMap::default(),
+            BTreeMap::default(),
         )];
         let debug_artifact = DebugArtifact::new(debug_symbols, &fm);
 
diff --git a/tooling/debugger/tests/debug.rs b/tooling/debugger/tests/debug.rs
index 2dca6b95f0e..eb43cf9cc6d 100644
--- a/tooling/debugger/tests/debug.rs
+++ b/tooling/debugger/tests/debug.rs
@@ -12,7 +12,7 @@ mod tests {
         let nargo_bin =
             cargo_bin("nargo").into_os_string().into_string().expect("Cannot parse nargo path");
 
-        let timeout_seconds = 25;
+        let timeout_seconds = 30;
         let mut dbg_session =
             spawn_bash(Some(timeout_seconds * 1000)).expect("Could not start bash session");
 
diff --git a/tooling/fuzzer/src/dictionary/mod.rs b/tooling/fuzzer/src/dictionary/mod.rs
index e10da8cc54a..172edfa54c2 100644
--- a/tooling/fuzzer/src/dictionary/mod.rs
+++ b/tooling/fuzzer/src/dictionary/mod.rs
@@ -9,7 +9,6 @@ use acvm::{
     acir::{
         circuit::{
             brillig::{BrilligBytecode, BrilligInputs},
-            directives::Directive,
             opcodes::{BlackBoxFuncCall, ConstantOrWitnessEnum},
             Circuit, Opcode, Program,
         },
@@ -60,10 +59,7 @@ fn build_dictionary_from_circuit<F: AcirField>(circuit: &Circuit<F>) -> HashSet<
         match opcode {
             Opcode::AssertZero(expr)
             | Opcode::Call { predicate: Some(expr), .. }
-            | Opcode::MemoryOp { predicate: Some(expr), .. }
-            | Opcode::Directive(Directive::ToLeRadix { a: expr, .. }) => {
-                insert_expr(&mut constants, expr)
-            }
+            | Opcode::MemoryOp { predicate: Some(expr), .. } => insert_expr(&mut constants, expr),
 
             Opcode::MemoryInit { init, .. } => insert_array_len(&mut constants, init),
 
diff --git a/tooling/lsp/Cargo.toml b/tooling/lsp/Cargo.toml
index 209f2afe4a4..04c8edf7ea9 100644
--- a/tooling/lsp/Cargo.toml
+++ b/tooling/lsp/Cargo.toml
@@ -14,7 +14,6 @@ workspace = true
 
 [dependencies]
 acvm.workspace = true
-chumsky.workspace = true
 codespan-lsp.workspace = true
 lsp-types.workspace = true
 nargo.workspace = true
@@ -23,13 +22,11 @@ nargo_toml.workspace = true
 noirc_driver.workspace = true
 noirc_errors.workspace = true
 noirc_frontend.workspace = true
-noirc_artifacts.workspace = true
 serde.workspace = true
 serde_json.workspace = true
 strum = "0.24"
 tower.workspace = true
 async-lsp = { workspace = true, features = ["omni-trait"] }
-serde_with = "3.2.0"
 thiserror.workspace = true
 fm.workspace = true
 rayon.workspace = true
diff --git a/tooling/lsp/src/attribute_reference_finder.rs b/tooling/lsp/src/attribute_reference_finder.rs
index f08c8073a79..e3f31b65b46 100644
--- a/tooling/lsp/src/attribute_reference_finder.rs
+++ b/tooling/lsp/src/attribute_reference_finder.rs
@@ -6,7 +6,6 @@
 /// will give not only the attribute function but also any type generated by it.
 use std::collections::BTreeMap;
 
-use chumsky::Parser;
 use fm::FileId;
 use noirc_errors::Span;
 use noirc_frontend::{
@@ -14,12 +13,11 @@ use noirc_frontend::{
     graph::CrateId,
     hir::{
         def_map::{CrateDefMap, LocalModuleId, ModuleId},
-        resolution::path_resolver::{PathResolver, StandardPathResolver},
+        resolution::import::resolve_import,
     },
-    lexer::Lexer,
     node_interner::ReferenceId,
-    parser::{path_no_turbofish, ParsedSubModule},
-    token::CustomAttribute,
+    parser::ParsedSubModule,
+    token::MetaAttribute,
     usage_tracker::UsageTracker,
     ParsedModule,
 };
@@ -87,29 +85,31 @@ impl<'a> Visitor for AttributeReferenceFinder<'a> {
         false
     }
 
-    fn visit_custom_attribute(&mut self, attribute: &CustomAttribute, _target: AttributeTarget) {
-        if !self.includes_span(attribute.contents_span) {
-            return;
+    fn visit_meta_attribute(
+        &mut self,
+        attribute: &MetaAttribute,
+        _target: AttributeTarget,
+    ) -> bool {
+        if !self.includes_span(attribute.span) {
+            return false;
         }
 
-        let name = match attribute.contents.split_once('(') {
-            Some((left, _right)) => left.to_string(),
-            None => attribute.contents.to_string(),
+        let path = attribute.name.clone();
+        // The path here must resolve to a function and it's a simple path (can't have turbofish)
+        // so it can (and must) be solved as an import.
+        let Ok(Some((module_def_id, _, _))) = resolve_import(
+            path,
+            self.module_id,
+            self.def_maps,
+            &mut UsageTracker::default(),
+            None, // references tracker
+        )
+        .map(|result| result.namespace.values) else {
+            return true;
         };
-        let (tokens, _) = Lexer::lex(&name);
 
-        let parser = path_no_turbofish();
-        let Ok(path) = parser.parse(tokens) else {
-            return;
-        };
-
-        let resolver = StandardPathResolver::new(self.module_id);
-        let mut usage_tracker = UsageTracker::default();
-        let Ok(result) = resolver.resolve(self.def_maps, path, &mut usage_tracker, &mut None)
-        else {
-            return;
-        };
+        self.reference_id = Some(module_def_id_to_reference_id(module_def_id));
 
-        self.reference_id = Some(module_def_id_to_reference_id(result.module_def_id));
+        true
     }
 }
diff --git a/tooling/lsp/src/lib.rs b/tooling/lsp/src/lib.rs
index 771f67e1fa2..a152cc17c7b 100644
--- a/tooling/lsp/src/lib.rs
+++ b/tooling/lsp/src/lib.rs
@@ -42,6 +42,7 @@ use noirc_frontend::{
     },
     node_interner::NodeInterner,
     parser::ParserError,
+    usage_tracker::UsageTracker,
     ParsedModule,
 };
 use rayon::prelude::*;
@@ -54,9 +55,9 @@ use requests::{
     on_code_action_request, on_code_lens_request, on_completion_request,
     on_document_symbol_request, on_formatting, on_goto_declaration_request,
     on_goto_definition_request, on_goto_type_definition_request, on_hover_request, on_initialize,
-    on_inlay_hint_request, on_prepare_rename_request, on_profile_run_request,
-    on_references_request, on_rename_request, on_shutdown, on_signature_help_request,
-    on_test_run_request, on_tests_request, LspInitializationOptions,
+    on_inlay_hint_request, on_prepare_rename_request, on_references_request, on_rename_request,
+    on_shutdown, on_signature_help_request, on_test_run_request, on_tests_request,
+    LspInitializationOptions,
 };
 use serde_json::Value as JsonValue;
 use thiserror::Error;
@@ -67,8 +68,10 @@ mod modules;
 mod notifications;
 mod requests;
 mod solver;
+mod tests;
 mod trait_impl_method_stub_generator;
 mod types;
+mod use_segment_positions;
 mod utils;
 mod visibility;
 
@@ -111,6 +114,7 @@ struct PackageCacheData {
     crate_graph: CrateGraph,
     node_interner: NodeInterner,
     def_maps: BTreeMap<CrateId, CrateDefMap>,
+    usage_tracker: UsageTracker,
 }
 
 impl LspState {
@@ -152,7 +156,6 @@ impl NargoLspService {
             .request::<request::CodeLens, _>(on_code_lens_request)
             .request::<request::NargoTests, _>(on_tests_request)
             .request::<request::NargoTestRun, _>(on_test_run_request)
-            .request::<request::NargoProfileRun, _>(on_profile_run_request)
             .request::<request::GotoDefinition, _>(on_goto_definition_request)
             .request::<request::GotoDeclaration, _>(on_goto_declaration_request)
             .request::<request::GotoTypeDefinition, _>(on_goto_type_definition_request)
@@ -267,12 +270,16 @@ fn byte_span_to_range<'a, F: files::Files<'a> + ?Sized>(
 
 pub(crate) fn resolve_workspace_for_source_path(file_path: &Path) -> Result<Workspace, LspError> {
     if let Some(toml_path) = find_file_manifest(file_path) {
-        return resolve_workspace_from_toml(
+        match resolve_workspace_from_toml(
             &toml_path,
             PackageSelection::All,
             Some(NOIR_ARTIFACT_VERSION_STRING.to_string()),
-        )
-        .map_err(|err| LspError::WorkspaceResolutionError(err.to_string()));
+        ) {
+            Ok(workspace) => return Ok(workspace),
+            Err(error) => {
+                eprintln!("Error while processing {:?}: {}", toml_path, error);
+            }
+        }
     }
 
     let Some(parent_folder) = file_path
@@ -285,14 +292,22 @@ pub(crate) fn resolve_workspace_for_source_path(file_path: &Path) -> Result<Work
             file_path
         )));
     };
+
+    let crate_name = match CrateName::from_str(parent_folder) {
+        Ok(name) => name,
+        Err(error) => {
+            eprintln!("{}", error);
+            CrateName::from_str("root").unwrap()
+        }
+    };
+
     let assumed_package = Package {
         version: None,
         compiler_required_version: Some(NOIR_ARTIFACT_VERSION_STRING.to_string()),
         root_dir: PathBuf::from(parent_folder),
         package_type: PackageType::Binary,
         entry_path: PathBuf::from(file_path),
-        name: CrateName::from_str(parent_folder)
-            .map_err(|err| LspError::WorkspaceResolutionError(err.to_string()))?,
+        name: crate_name,
         dependencies: BTreeMap::new(),
         expression_width: None,
     };
@@ -309,7 +324,11 @@ pub(crate) fn workspace_package_for_file<'a>(
     workspace: &'a Workspace,
     file_path: &Path,
 ) -> Option<&'a Package> {
-    workspace.members.iter().find(|package| file_path.starts_with(&package.root_dir))
+    if workspace.is_assumed {
+        workspace.members.first()
+    } else {
+        workspace.members.iter().find(|package| file_path.starts_with(&package.root_dir))
+    }
 }
 
 pub(crate) fn prepare_package<'file_manager, 'parsed_files>(
diff --git a/tooling/lsp/src/modules.rs b/tooling/lsp/src/modules.rs
index f1eff3b5a7d..cadf71b2eec 100644
--- a/tooling/lsp/src/modules.rs
+++ b/tooling/lsp/src/modules.rs
@@ -1,15 +1,9 @@
-use std::collections::BTreeMap;
-
 use noirc_frontend::{
-    ast::ItemVisibility,
     graph::{CrateId, Dependency},
-    hir::def_map::{CrateDefMap, ModuleId},
-    macros_api::{ModuleDefId, NodeInterner},
-    node_interner::ReferenceId,
+    hir::def_map::{ModuleDefId, ModuleId},
+    node_interner::{NodeInterner, ReferenceId},
 };
 
-use crate::visibility::is_visible;
-
 pub(crate) fn get_parent_module(
     interner: &NodeInterner,
     module_def_id: ModuleDefId,
@@ -34,18 +28,12 @@ pub(crate) fn module_def_id_to_reference_id(module_def_id: ModuleDefId) -> Refer
 /// - Otherwise, that item's parent module's path is returned
 pub(crate) fn relative_module_full_path(
     module_def_id: ModuleDefId,
-    visibility: ItemVisibility,
     current_module_id: ModuleId,
     current_module_parent_id: Option<ModuleId>,
     interner: &NodeInterner,
-    def_maps: &BTreeMap<CrateId, CrateDefMap>,
 ) -> Option<String> {
     let full_path;
     if let ModuleDefId::ModuleId(module_id) = module_def_id {
-        if !is_visible(module_id, current_module_id, visibility, def_maps) {
-            return None;
-        }
-
         full_path = relative_module_id_path(
             module_id,
             &current_module_id,
@@ -57,10 +45,6 @@ pub(crate) fn relative_module_full_path(
             return None;
         };
 
-        if !is_visible(parent_module, current_module_id, visibility, def_maps) {
-            return None;
-        }
-
         full_path = relative_module_id_path(
             parent_module,
             &current_module_id,
diff --git a/tooling/lsp/src/notifications/mod.rs b/tooling/lsp/src/notifications/mod.rs
index 6cddd278e62..f6fdd082d0b 100644
--- a/tooling/lsp/src/notifications/mod.rs
+++ b/tooling/lsp/src/notifications/mod.rs
@@ -6,11 +6,12 @@ use crate::{
     insert_all_files_for_workspace_into_file_manager, PackageCacheData, WorkspaceCacheData,
 };
 use async_lsp::{ErrorCode, LanguageClient, ResponseError};
-use fm::{FileManager, FileMap};
+use fm::{FileId, FileManager, FileMap};
 use fxhash::FxHashMap as HashMap;
-use lsp_types::{DiagnosticTag, Url};
+use lsp_types::{DiagnosticRelatedInformation, DiagnosticTag, Url};
 use noirc_driver::check_crate;
-use noirc_errors::{DiagnosticKind, FileDiagnostic};
+use noirc_errors::reporter::CustomLabel;
+use noirc_errors::{DiagnosticKind, FileDiagnostic, Location};
 
 use crate::types::{
     notification, Diagnostic, DiagnosticSeverity, DidChangeConfigurationParams,
@@ -165,6 +166,7 @@ pub(crate) fn process_workspace_for_noir_document(
                 crate_graph: context.crate_graph,
                 node_interner: context.def_interner,
                 def_maps: context.def_maps,
+                usage_tracker: context.usage_tracker,
             },
         );
 
@@ -195,11 +197,13 @@ fn publish_diagnostics(
 
     for file_diagnostic in file_diagnostics.into_iter() {
         let file_id = file_diagnostic.file_id;
-        let diagnostic = file_diagnostic_to_diagnostic(file_diagnostic, files);
-
         let path = fm.path(file_id).expect("file must exist to have emitted diagnostic");
         if let Ok(uri) = Url::from_file_path(path) {
-            diagnostics_per_url.entry(uri).or_default().push(diagnostic);
+            if let Some(diagnostic) =
+                file_diagnostic_to_diagnostic(file_diagnostic, files, fm, uri.clone())
+            {
+                diagnostics_per_url.entry(uri).or_default().push(diagnostic);
+            }
         }
     }
 
@@ -228,17 +232,21 @@ fn publish_diagnostics(
     state.files_with_errors.insert(package_root_dir.clone(), new_files_with_errors);
 }
 
-fn file_diagnostic_to_diagnostic(file_diagnostic: FileDiagnostic, files: &FileMap) -> Diagnostic {
+fn file_diagnostic_to_diagnostic(
+    file_diagnostic: FileDiagnostic,
+    files: &FileMap,
+    fm: &FileManager,
+    uri: Url,
+) -> Option<Diagnostic> {
     let file_id = file_diagnostic.file_id;
     let diagnostic = file_diagnostic.diagnostic;
 
-    // TODO: Should this be the first item in secondaries? Should we bail when we find a range?
-    let range = diagnostic
-        .secondaries
-        .into_iter()
-        .filter_map(|sec| byte_span_to_range(files, file_id, sec.span.into()))
-        .last()
-        .unwrap_or_default();
+    if diagnostic.secondaries.is_empty() {
+        return None;
+    }
+
+    let span = diagnostic.secondaries.first().unwrap().span;
+    let range = byte_span_to_range(files, file_id, span.into())?;
 
     let severity = match diagnostic.kind {
         DiagnosticKind::Error => DiagnosticSeverity::ERROR,
@@ -255,13 +263,60 @@ fn file_diagnostic_to_diagnostic(file_diagnostic: FileDiagnostic, files: &FileMa
         tags.push(DiagnosticTag::DEPRECATED);
     }
 
-    Diagnostic {
+    let secondaries = diagnostic
+        .secondaries
+        .into_iter()
+        .filter_map(|secondary| secondary_to_related_information(secondary, file_id, files, fm));
+    let notes = diagnostic.notes.into_iter().map(|message| DiagnosticRelatedInformation {
+        location: lsp_types::Location { uri: uri.clone(), range },
+        message,
+    });
+    let call_stack = diagnostic
+        .call_stack
+        .into_iter()
+        .filter_map(|frame| call_stack_frame_to_related_information(frame, files, fm));
+    let related_information: Vec<_> = secondaries.chain(notes).chain(call_stack).collect();
+
+    Some(Diagnostic {
         range,
         severity: Some(severity),
         message: diagnostic.message,
         tags: if tags.is_empty() { None } else { Some(tags) },
+        related_information: if related_information.is_empty() {
+            None
+        } else {
+            Some(related_information)
+        },
         ..Default::default()
-    }
+    })
+}
+
+fn secondary_to_related_information(
+    secondary: CustomLabel,
+    file_id: FileId,
+    files: &FileMap,
+    fm: &FileManager,
+) -> Option<DiagnosticRelatedInformation> {
+    let secondary_file = secondary.file.unwrap_or(file_id);
+    let path = fm.path(secondary_file)?;
+    let uri = Url::from_file_path(path).ok()?;
+    let range = byte_span_to_range(files, file_id, secondary.span.into())?;
+    let message = secondary.message;
+    Some(DiagnosticRelatedInformation { location: lsp_types::Location { uri, range }, message })
+}
+
+fn call_stack_frame_to_related_information(
+    frame: Location,
+    files: &FileMap,
+    fm: &FileManager,
+) -> Option<DiagnosticRelatedInformation> {
+    let path = fm.path(frame.file)?;
+    let uri = Url::from_file_path(path).ok()?;
+    let range = byte_span_to_range(files, frame.file, frame.span.into())?;
+    Some(DiagnosticRelatedInformation {
+        location: lsp_types::Location { uri, range },
+        message: "Error originated here".to_string(),
+    })
 }
 
 pub(super) fn on_exit(
diff --git a/tooling/lsp/src/requests/code_action.rs b/tooling/lsp/src/requests/code_action.rs
index 64eccab8947..38cc6bddf64 100644
--- a/tooling/lsp/src/requests/code_action.rs
+++ b/tooling/lsp/src/requests/code_action.rs
@@ -12,23 +12,28 @@ use lsp_types::{
 };
 use noirc_errors::Span;
 use noirc_frontend::{
-    ast::{ConstructorExpression, ItemVisibility, NoirTraitImpl, Path, UseTree, Visitor},
+    ast::{
+        CallExpression, ConstructorExpression, ItemVisibility, MethodCallExpression, NoirTraitImpl,
+        Path, UseTree, Visitor,
+    },
     graph::CrateId,
     hir::def_map::{CrateDefMap, LocalModuleId, ModuleId},
-    macros_api::NodeInterner,
+    node_interner::NodeInterner,
+    usage_tracker::UsageTracker,
 };
 use noirc_frontend::{
     parser::{Item, ItemKind, ParsedSubModule},
     ParsedModule,
 };
 
-use crate::{utils, LspState};
+use crate::{use_segment_positions::UseSegmentPositions, utils, LspState};
 
 use super::{process_request, to_lsp_location};
 
 mod fill_struct_fields;
 mod implement_missing_members;
 mod import_or_qualify;
+mod remove_bang_from_call;
 mod remove_unused_import;
 mod tests;
 
@@ -58,6 +63,7 @@ pub(crate) fn on_code_action_request(
                     args.crate_id,
                     args.def_maps,
                     args.interner,
+                    args.usage_tracker,
                 );
                 finder.find(&parsed_module)
             })
@@ -78,10 +84,12 @@ struct CodeActionFinder<'a> {
     module_id: ModuleId,
     def_maps: &'a BTreeMap<CrateId, CrateDefMap>,
     interner: &'a NodeInterner,
+    usage_tracker: &'a UsageTracker,
     /// How many nested `mod` we are in deep
     nesting: usize,
     /// The line where an auto_import must be inserted
     auto_import_line: usize,
+    use_segment_positions: UseSegmentPositions,
     /// Text edits for the "Remove all unused imports" code action
     unused_imports_text_edits: Vec<TextEdit>,
     code_actions: Vec<CodeAction>,
@@ -98,6 +106,7 @@ impl<'a> CodeActionFinder<'a> {
         krate: CrateId,
         def_maps: &'a BTreeMap<CrateId, CrateDefMap>,
         interner: &'a NodeInterner,
+        usage_tracker: &'a UsageTracker,
     ) -> Self {
         // Find the module the current file belongs to
         let def_map = &def_maps[&krate];
@@ -119,8 +128,10 @@ impl<'a> CodeActionFinder<'a> {
             module_id,
             def_maps,
             interner,
+            usage_tracker,
             nesting: 0,
             auto_import_line: 0,
+            use_segment_positions: UseSegmentPositions::default(),
             unused_imports_text_edits: vec![],
             code_actions: vec![],
         }
@@ -184,10 +195,11 @@ impl<'a> CodeActionFinder<'a> {
 
 impl<'a> Visitor for CodeActionFinder<'a> {
     fn visit_item(&mut self, item: &Item) -> bool {
-        if let ItemKind::Import(..) = &item.kind {
+        if let ItemKind::Import(use_tree, _) = &item.kind {
             if let Some(lsp_location) = to_lsp_location(self.files, self.file, item.span) {
                 self.auto_import_line = (lsp_location.range.end.line + 1) as usize;
             }
+            self.use_segment_positions.add(use_tree);
         }
 
         self.includes_span(item.span)
@@ -247,4 +259,32 @@ impl<'a> Visitor for CodeActionFinder<'a> {
 
         true
     }
+
+    fn visit_call_expression(&mut self, call: &CallExpression, span: Span) -> bool {
+        if !self.includes_span(span) {
+            return false;
+        }
+
+        if call.is_macro_call {
+            self.remove_bang_from_call(call.func.span);
+        }
+
+        true
+    }
+
+    fn visit_method_call_expression(
+        &mut self,
+        method_call: &MethodCallExpression,
+        span: Span,
+    ) -> bool {
+        if !self.includes_span(span) {
+            return false;
+        }
+
+        if method_call.is_macro_call {
+            self.remove_bang_from_call(method_call.method_name.span());
+        }
+
+        true
+    }
 }
diff --git a/tooling/lsp/src/requests/code_action/fill_struct_fields.rs b/tooling/lsp/src/requests/code_action/fill_struct_fields.rs
index be8602d99a9..739f0bf4a21 100644
--- a/tooling/lsp/src/requests/code_action/fill_struct_fields.rs
+++ b/tooling/lsp/src/requests/code_action/fill_struct_fields.rs
@@ -31,8 +31,8 @@ impl<'a> CodeActionFinder<'a> {
         let mut fields = struct_type.get_fields_as_written();
 
         // Remove the ones that already exists in the constructor
-        for (field, _) in &constructor.fields {
-            fields.retain(|(name, _)| name != &field.0.contents);
+        for (constructor_field, _) in &constructor.fields {
+            fields.retain(|field| field.name.0.contents != constructor_field.0.contents);
         }
 
         if fields.is_empty() {
@@ -93,7 +93,7 @@ impl<'a> CodeActionFinder<'a> {
             new_text.push(' ');
         }
 
-        for (index, (name, _)) in fields.iter().enumerate() {
+        for (index, field) in fields.iter().enumerate() {
             if index > 0 {
                 new_text.push(',');
                 if let Some(line_indent) = &line_indent {
@@ -103,7 +103,7 @@ impl<'a> CodeActionFinder<'a> {
                     new_text.push(' ');
                 }
             }
-            new_text.push_str(name);
+            new_text.push_str(&field.name.0.contents);
             new_text.push_str(": ()");
         }
 
diff --git a/tooling/lsp/src/requests/code_action/import_or_qualify.rs b/tooling/lsp/src/requests/code_action/import_or_qualify.rs
index 0d97ccde2ed..609a81bdfe7 100644
--- a/tooling/lsp/src/requests/code_action/import_or_qualify.rs
+++ b/tooling/lsp/src/requests/code_action/import_or_qualify.rs
@@ -1,13 +1,17 @@
-use lsp_types::{Position, Range, TextEdit};
+use lsp_types::TextEdit;
 use noirc_errors::Location;
 use noirc_frontend::{
     ast::{Ident, Path},
-    macros_api::ModuleDefId,
+    hir::def_map::ModuleDefId,
 };
 
 use crate::{
     byte_span_to_range,
     modules::{relative_module_full_path, relative_module_id_path},
+    use_segment_positions::{
+        use_completion_item_additional_text_edits, UseCompletionItemAdditionTextEditsRequest,
+    },
+    visibility::module_def_id_is_visible,
 };
 
 use super::CodeActionFinder;
@@ -38,6 +42,17 @@ impl<'a> CodeActionFinder<'a> {
             }
 
             for (module_def_id, visibility, defining_module) in entries {
+                if !module_def_id_is_visible(
+                    *module_def_id,
+                    self.module_id,
+                    *visibility,
+                    *defining_module,
+                    self.interner,
+                    self.def_maps,
+                ) {
+                    continue;
+                }
+
                 let module_full_path = if let Some(defining_module) = defining_module {
                     relative_module_id_path(
                         *defining_module,
@@ -48,11 +63,9 @@ impl<'a> CodeActionFinder<'a> {
                 } else {
                     let Some(module_full_path) = relative_module_full_path(
                         *module_def_id,
-                        *visibility,
                         self.module_id,
                         current_module_parent_id,
                         self.interner,
-                        self.def_maps,
                     ) else {
                         continue;
                     };
@@ -82,25 +95,21 @@ impl<'a> CodeActionFinder<'a> {
     }
 
     fn push_import_code_action(&mut self, full_path: &str) {
-        let line = self.auto_import_line as u32;
-        let character = (self.nesting * 4) as u32;
-        let indent = " ".repeat(self.nesting * 4);
-        let mut newlines = "\n";
-
-        // If the line we are inserting into is not an empty line, insert an extra line to make some room
-        if let Some(line_text) = self.lines.get(line as usize) {
-            if !line_text.trim().is_empty() {
-                newlines = "\n\n";
-            }
-        }
-
         let title = format!("Import {}", full_path);
-        let text_edit = TextEdit {
-            range: Range { start: Position { line, character }, end: Position { line, character } },
-            new_text: format!("use {};{}{}", full_path, newlines, indent),
-        };
 
-        let code_action = self.new_quick_fix(title, text_edit);
+        let text_edits = use_completion_item_additional_text_edits(
+            UseCompletionItemAdditionTextEditsRequest {
+                full_path,
+                files: self.files,
+                file: self.file,
+                lines: &self.lines,
+                nesting: self.nesting,
+                auto_import_line: self.auto_import_line,
+            },
+            &self.use_segment_positions,
+        );
+
+        let code_action = self.new_quick_fix_multiple_edits(title, text_edits);
         self.code_actions.push(code_action);
     }
 
@@ -133,7 +142,7 @@ mod tests {
 
         let src = r#"
         mod foo {
-            mod bar {
+            pub mod bar {
                 pub struct SomeTypeInBar {}
             }
         }
@@ -143,7 +152,7 @@ mod tests {
 
         let expected = r#"
         mod foo {
-            mod bar {
+            pub mod bar {
                 pub struct SomeTypeInBar {}
             }
         }
@@ -159,7 +168,7 @@ mod tests {
         let title = "Import foo::bar::SomeTypeInBar";
 
         let src = r#"mod foo {
-    mod bar {
+    pub mod bar {
         pub struct SomeTypeInBar {}
     }
 }
@@ -169,7 +178,32 @@ fn foo(x: SomeType>|<InBar) {}"#;
         let expected = r#"use foo::bar::SomeTypeInBar;
 
 mod foo {
-    mod bar {
+    pub mod bar {
+        pub struct SomeTypeInBar {}
+    }
+}
+
+fn foo(x: SomeTypeInBar) {}"#;
+
+        assert_code_action(title, src, expected).await;
+    }
+
+    #[test]
+    async fn test_import_code_action_for_struct_at_beginning_of_name() {
+        let title = "Import foo::bar::SomeTypeInBar";
+
+        let src = r#"mod foo {
+    pub mod bar {
+        pub struct SomeTypeInBar {}
+    }
+}
+
+fn foo(x: >|<SomeTypeInBar) {}"#;
+
+        let expected = r#"use foo::bar::SomeTypeInBar;
+
+mod foo {
+    pub mod bar {
         pub struct SomeTypeInBar {}
     }
 }
@@ -185,8 +219,8 @@ fn foo(x: SomeTypeInBar) {}"#;
 
         let src = r#"
         mod foo {
-            mod bar {
-                mod some_module_in_bar {}
+            pub mod bar {
+                pub mod some_module_in_bar {}
             }
         }
 
@@ -197,8 +231,8 @@ fn foo(x: SomeTypeInBar) {}"#;
 
         let expected = r#"
         mod foo {
-            mod bar {
-                mod some_module_in_bar {}
+            pub mod bar {
+                pub mod some_module_in_bar {}
             }
         }
 
@@ -215,8 +249,8 @@ fn foo(x: SomeTypeInBar) {}"#;
         let title = "Import foo::bar::some_module_in_bar";
 
         let src = r#"mod foo {
-    mod bar {
-        mod some_module_in_bar {}
+    pub mod bar {
+        pub(crate) mod some_module_in_bar {}
     }
 }
 
@@ -227,8 +261,8 @@ fn main() {
         let expected = r#"use foo::bar::some_module_in_bar;
 
 mod foo {
-    mod bar {
-        mod some_module_in_bar {}
+    pub mod bar {
+        pub(crate) mod some_module_in_bar {}
     }
 }
 
@@ -238,4 +272,31 @@ fn main() {
 
         assert_code_action(title, src, expected).await;
     }
+
+    #[test]
+    async fn test_import_code_action_for_struct_inserts_into_existing_use() {
+        let title = "Import foo::bar::SomeTypeInBar";
+
+        let src = r#"use foo::bar::SomeOtherType;
+
+mod foo {
+    pub mod bar {
+        pub struct SomeTypeInBar {}
+    }
+}
+
+fn foo(x: SomeType>|<InBar) {}"#;
+
+        let expected = r#"use foo::bar::{SomeOtherType, SomeTypeInBar};
+
+mod foo {
+    pub mod bar {
+        pub struct SomeTypeInBar {}
+    }
+}
+
+fn foo(x: SomeTypeInBar) {}"#;
+
+        assert_code_action(title, src, expected).await;
+    }
 }
diff --git a/tooling/lsp/src/requests/code_action/remove_bang_from_call.rs b/tooling/lsp/src/requests/code_action/remove_bang_from_call.rs
new file mode 100644
index 00000000000..90f4fef0efd
--- /dev/null
+++ b/tooling/lsp/src/requests/code_action/remove_bang_from_call.rs
@@ -0,0 +1,97 @@
+use lsp_types::TextEdit;
+use noirc_errors::{Location, Span};
+use noirc_frontend::{node_interner::ReferenceId, QuotedType, Type};
+
+use crate::byte_span_to_range;
+
+use super::CodeActionFinder;
+
+impl<'a> CodeActionFinder<'a> {
+    pub(super) fn remove_bang_from_call(&mut self, span: Span) {
+        // If we can't find the referenced function, there's nothing we can do
+        let Some(ReferenceId::Function(func_id)) =
+            self.interner.find_referenced(Location::new(span, self.file))
+        else {
+            return;
+        };
+
+        // If the return type is Quoted, all is good
+        let func_meta = self.interner.function_meta(&func_id);
+        if let Type::Quoted(QuotedType::Quoted) = func_meta.return_type() {
+            return;
+        }
+
+        // The `!` comes right after the name
+        let byte_span = span.end() as usize..span.end() as usize + 1;
+        let Some(range) = byte_span_to_range(self.files, self.file, byte_span) else {
+            return;
+        };
+
+        let title = "Remove `!` from call".to_string();
+        let text_edit = TextEdit { range, new_text: "".to_string() };
+
+        let code_action = self.new_quick_fix(title, text_edit);
+        self.code_actions.push(code_action);
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use tokio::test;
+
+    use crate::requests::code_action::tests::assert_code_action;
+
+    #[test]
+    async fn test_removes_bang_from_call() {
+        let title = "Remove `!` from call";
+
+        let src = r#"
+        fn foo() {}
+
+        fn main() {
+            fo>|<o!();
+        }
+        "#;
+
+        let expected = r#"
+        fn foo() {}
+
+        fn main() {
+            foo();
+        }
+        "#;
+
+        assert_code_action(title, src, expected).await;
+    }
+
+    #[test]
+    async fn test_removes_bang_from_method_call() {
+        let title = "Remove `!` from call";
+
+        let src = r#"
+        struct Foo {}
+
+        impl Foo {
+          fn foo(self) {}
+        }
+
+        fn bar(foo: Foo) {
+            foo.fo>|<o!();
+        }
+        "#;
+
+        let expected = r#"
+        struct Foo {}
+
+        impl Foo {
+          fn foo(self) {}
+        }
+
+        fn bar(foo: Foo) {
+            foo.foo();
+        }
+        "#;
+
+        assert_code_action(title, src, expected).await;
+    }
+}
diff --git a/tooling/lsp/src/requests/code_action/remove_unused_import.rs b/tooling/lsp/src/requests/code_action/remove_unused_import.rs
index f5f0b520149..4822a9d61ec 100644
--- a/tooling/lsp/src/requests/code_action/remove_unused_import.rs
+++ b/tooling/lsp/src/requests/code_action/remove_unused_import.rs
@@ -24,7 +24,7 @@ impl<'a> CodeActionFinder<'a> {
             return;
         }
 
-        let Some(unused_items) = self.interner.unused_items().get(&self.module_id) else {
+        let Some(unused_items) = self.usage_tracker.unused_items().get(&self.module_id) else {
             return;
         };
 
@@ -106,11 +106,12 @@ fn use_tree_without_unused_import(
                 let mut prefix = use_tree.prefix.clone();
                 prefix.segments.extend(new_use_tree.prefix.segments);
 
-                Some(UseTree { prefix, kind: new_use_tree.kind })
+                Some(UseTree { prefix, kind: new_use_tree.kind, span: use_tree.span })
             } else {
                 Some(UseTree {
                     prefix: use_tree.prefix.clone(),
                     kind: UseTreeKind::List(new_use_trees),
+                    span: use_tree.span,
                 })
             };
 
diff --git a/tooling/lsp/src/requests/code_action/tests.rs b/tooling/lsp/src/requests/code_action/tests.rs
index ef592ee9d53..d1611381117 100644
--- a/tooling/lsp/src/requests/code_action/tests.rs
+++ b/tooling/lsp/src/requests/code_action/tests.rs
@@ -1,11 +1,11 @@
 #![cfg(test)]
 
-use crate::{notifications::on_did_open_text_document, test_utils};
+use crate::{notifications::on_did_open_text_document, test_utils, tests::apply_text_edits};
 
 use lsp_types::{
     CodeActionContext, CodeActionOrCommand, CodeActionParams, CodeActionResponse,
     DidOpenTextDocumentParams, PartialResultParams, Position, Range, TextDocumentIdentifier,
-    TextDocumentItem, TextEdit, WorkDoneProgressParams,
+    TextDocumentItem, WorkDoneProgressParams,
 };
 
 use super::on_code_action_request;
@@ -70,24 +70,10 @@ pub(crate) async fn assert_code_action(title: &str, src: &str, expected: &str) {
 
     let workspace_edit = action.edit.as_ref().unwrap();
     let text_edits = workspace_edit.changes.as_ref().unwrap().iter().next().unwrap().1;
-    assert_eq!(text_edits.len(), 1);
 
-    let result = apply_text_edit(&src.replace(">|<", ""), &text_edits[0]);
+    let result = apply_text_edits(&src.replace(">|<", ""), text_edits);
     if result != expected {
         println!("Expected:\n```\n{}\n```\n\nGot:\n```\n{}\n```", expected, result);
         assert_eq!(result, expected);
     }
 }
-
-fn apply_text_edit(src: &str, text_edit: &TextEdit) -> String {
-    let mut lines: Vec<_> = src.lines().collect();
-    assert_eq!(text_edit.range.start.line, text_edit.range.end.line);
-
-    let mut line = lines[text_edit.range.start.line as usize].to_string();
-    line.replace_range(
-        text_edit.range.start.character as usize..text_edit.range.end.character as usize,
-        &text_edit.new_text,
-    );
-    lines[text_edit.range.start.line as usize] = &line;
-    lines.join("\n")
-}
diff --git a/tooling/lsp/src/requests/code_lens_request.rs b/tooling/lsp/src/requests/code_lens_request.rs
index 4565569e67b..0c1877c156d 100644
--- a/tooling/lsp/src/requests/code_lens_request.rs
+++ b/tooling/lsp/src/requests/code_lens_request.rs
@@ -24,9 +24,6 @@ const EXECUTE_CODELENS_TITLE: &str = "Execute";
 const DEBUG_COMMAND: &str = "nargo.debug.dap";
 const DEBUG_CODELENS_TITLE: &str = "Debug";
 
-const PROFILE_COMMAND: &str = "nargo.profile";
-const PROFILE_CODELENS_TITLE: &str = "Profile";
-
 fn with_arrow(title: &str) -> String {
     format!("{ARROW} {title}")
 }
@@ -89,8 +86,8 @@ fn on_code_lens_request_inner(
 }
 
 pub(crate) fn collect_lenses_for_package(
-    context: &noirc_frontend::macros_api::HirContext,
-    crate_id: noirc_frontend::macros_api::CrateId,
+    context: &noirc_frontend::hir::Context,
+    crate_id: noirc_frontend::graph::CrateId,
     workspace: &Workspace,
     package: &Package,
     file_path: Option<&std::path::PathBuf>,
@@ -162,7 +159,6 @@ pub(crate) fn collect_lenses_for_package(
             let internal_command_lenses = [
                 (INFO_CODELENS_TITLE, INFO_COMMAND),
                 (EXECUTE_CODELENS_TITLE, EXECUTE_COMMAND),
-                (PROFILE_CODELENS_TITLE, PROFILE_COMMAND),
                 (DEBUG_CODELENS_TITLE, DEBUG_COMMAND),
             ]
             .map(|(title, command)| {
@@ -214,16 +210,6 @@ pub(crate) fn collect_lenses_for_package(
             let info_lens = CodeLens { range, command: Some(info_command), data: None };
 
             lenses.push(info_lens);
-
-            let profile_command = Command {
-                title: PROFILE_CODELENS_TITLE.to_string(),
-                command: PROFILE_COMMAND.into(),
-                arguments: Some(package_selection_args(workspace, package)),
-            };
-
-            let profile_lens = CodeLens { range, command: Some(profile_command), data: None };
-
-            lenses.push(profile_lens);
         }
     }
 
diff --git a/tooling/lsp/src/requests/completion.rs b/tooling/lsp/src/requests/completion.rs
index 588f5b18f1b..3762ba9cf8d 100644
--- a/tooling/lsp/src/requests/completion.rs
+++ b/tooling/lsp/src/requests/completion.rs
@@ -19,24 +19,28 @@ use noirc_frontend::{
         Expression, ExpressionKind, ForLoopStatement, GenericTypeArgs, Ident, IfExpression,
         IntegerBitSize, ItemVisibility, LValue, Lambda, LetStatement, MemberAccessExpression,
         MethodCallExpression, NoirFunction, NoirStruct, NoirTraitImpl, Path, PathKind, Pattern,
-        Signedness, Statement, TraitImplItemKind, TypeImpl, TypePath, UnresolvedGeneric,
-        UnresolvedGenerics, UnresolvedType, UnresolvedTypeData, UnresolvedTypeExpression, UseTree,
-        UseTreeKind, Visitor,
+        Signedness, Statement, TraitBound, TraitImplItemKind, TypeImpl, TypePath,
+        UnresolvedGeneric, UnresolvedGenerics, UnresolvedType, UnresolvedTypeData,
+        UnresolvedTypeExpression, UseTree, UseTreeKind, Visitor,
     },
     graph::{CrateId, Dependency},
-    hir::def_map::{CrateDefMap, LocalModuleId, ModuleId},
+    hir::{
+        def_map::{CrateDefMap, LocalModuleId, ModuleDefId, ModuleId},
+        resolution::visibility::{
+            item_in_module_is_visible, method_call_is_visible, struct_member_is_visible,
+        },
+    },
     hir_def::traits::Trait,
-    macros_api::{ModuleDefId, NodeInterner},
-    node_interner::ReferenceId,
+    node_interner::{NodeInterner, ReferenceId, StructId},
     parser::{Item, ItemKind, ParsedSubModule},
-    token::{CustomAttribute, Token, Tokens},
+    token::{MetaAttribute, Token, Tokens},
     Kind, ParsedModule, StructType, Type, TypeBinding,
 };
 use sort_text::underscore_sort_text;
 
 use crate::{
     requests::to_lsp_location, trait_impl_method_stub_generator::TraitImplMethodStubGenerator,
-    utils, visibility::is_visible, LspState,
+    use_segment_positions::UseSegmentPositions, utils, LspState,
 };
 
 use super::process_request;
@@ -113,6 +117,7 @@ struct NodeFinder<'a> {
     nesting: usize,
     /// The line where an auto_import must be inserted
     auto_import_line: usize,
+    use_segment_positions: UseSegmentPositions,
     self_type: Option<Type>,
     in_comptime: bool,
 }
@@ -157,6 +162,7 @@ impl<'a> NodeFinder<'a> {
             suggested_module_def_ids: HashSet::new(),
             nesting: 0,
             auto_import_line: 0,
+            use_segment_positions: UseSegmentPositions::default(),
             self_type: None,
             in_comptime: false,
         }
@@ -202,14 +208,14 @@ impl<'a> NodeFinder<'a> {
 
         // Remove the ones that already exists in the constructor
         for (used_name, _) in &constructor_expression.fields {
-            fields.retain(|(_, (name, _))| name != &used_name.0.contents);
+            fields.retain(|(_, field)| field.name.0.contents != used_name.0.contents);
         }
 
         let self_prefix = false;
-        for (field_index, (field, typ)) in &fields {
+        for (field_index, field) in &fields {
             self.completion_items.push(self.struct_field_completion_item(
-                field,
-                typ,
+                &field.name.0.contents,
+                &field.typ,
                 struct_type.id,
                 *field_index,
                 self_prefix,
@@ -379,7 +385,7 @@ impl<'a> NodeFinder<'a> {
                     self.builtin_types_completion(&prefix);
                     self.type_parameters_completion(&prefix);
                 }
-                RequestedItems::OnlyAttributeFunctions(..) => (),
+                RequestedItems::OnlyTraits | RequestedItems::OnlyAttributeFunctions(..) => (),
             }
             self.complete_auto_imports(&prefix, requested_items, function_completion_kind);
         }
@@ -578,11 +584,19 @@ impl<'a> NodeFinder<'a> {
                     self_prefix,
                 );
             }
+            Type::CheckedCast { to, .. } => {
+                return self.complete_type_fields_and_methods(
+                    to,
+                    prefix,
+                    function_completion_kind,
+                    self_prefix,
+                );
+            }
             Type::Tuple(types) => {
                 self.complete_tuple_fields(types, self_prefix);
             }
-            Type::TypeVariable(var, _) | Type::NamedGeneric(var, _, _) => {
-                if let TypeBinding::Bound(typ) = &*var.borrow() {
+            Type::TypeVariable(var) | Type::NamedGeneric(var, _) => {
+                if let TypeBinding::Bound(ref typ) = &*var.borrow() {
                     return self.complete_type_fields_and_methods(
                         typ,
                         prefix,
@@ -629,29 +643,55 @@ impl<'a> NodeFinder<'a> {
             return;
         };
 
+        let struct_id = get_type_struct_id(typ);
+        let is_primitive = typ.is_primitive();
+        let has_self_param = matches!(function_kind, FunctionKind::SelfType(..));
+
         for (name, methods) in methods_by_name {
-            for (func_id, method_type) in methods.iter() {
-                if function_kind == FunctionKind::Any {
-                    if let Some(method_type) = method_type {
-                        if method_type.unify(typ).is_err() {
-                            continue;
-                        }
-                    }
+            let Some(func_id) =
+                methods.find_matching_method(typ, has_self_param, self.interner).or_else(|| {
+                    // Also try to find a method assuming typ is `&mut typ`:
+                    // we want to suggest methods that take `&mut self` even though a variable might not
+                    // be mutable, so a user can know they need to mark it as mutable.
+                    let typ = Type::MutableReference(Box::new(typ.clone()));
+                    methods.find_matching_method(&typ, has_self_param, self.interner)
+                })
+            else {
+                continue;
+            };
+
+            if let Some(struct_id) = struct_id {
+                let modifiers = self.interner.function_modifiers(&func_id);
+                let visibility = modifiers.visibility;
+                if !struct_member_is_visible(struct_id, visibility, self.module_id, self.def_maps) {
+                    continue;
                 }
+            }
 
-                if name_matches(name, prefix) {
-                    let completion_items = self.function_completion_items(
-                        name,
-                        func_id,
-                        function_completion_kind,
-                        function_kind,
-                        None, // attribute first type
-                        self_prefix,
-                    );
-                    if !completion_items.is_empty() {
-                        self.completion_items.extend(completion_items);
-                        self.suggested_module_def_ids.insert(ModuleDefId::FunctionId(func_id));
-                    }
+            if is_primitive
+                && !method_call_is_visible(
+                    typ,
+                    func_id,
+                    self.module_id,
+                    self.interner,
+                    self.def_maps,
+                )
+            {
+                continue;
+            }
+
+            if name_matches(name, prefix) {
+                let completion_items = self.function_completion_items(
+                    name,
+                    func_id,
+                    function_completion_kind,
+                    function_kind,
+                    None, // attribute first type
+                    self_prefix,
+                );
+                if !completion_items.is_empty() {
+                    self.completion_items.extend(completion_items);
+                    self.suggested_module_def_ids.insert(ModuleDefId::FunctionId(func_id));
                 }
             }
         }
@@ -691,16 +731,25 @@ impl<'a> NodeFinder<'a> {
         prefix: &str,
         self_prefix: bool,
     ) {
-        for (field_index, (name, typ)) in struct_type.get_fields(generics).iter().enumerate() {
-            if name_matches(name, prefix) {
-                self.completion_items.push(self.struct_field_completion_item(
-                    name,
-                    typ,
-                    struct_type.id,
-                    field_index,
-                    self_prefix,
-                ));
+        for (field_index, (name, visibility, typ)) in
+            struct_type.get_fields_with_visibility(generics).iter().enumerate()
+        {
+            if !struct_member_is_visible(struct_type.id, *visibility, self.module_id, self.def_maps)
+            {
+                continue;
+            }
+
+            if !name_matches(name, prefix) {
+                continue;
             }
+
+            self.completion_items.push(self.struct_field_completion_item(
+                name,
+                typ,
+                struct_type.id,
+                field_index,
+                self_prefix,
+            ));
         }
     }
 
@@ -756,7 +805,12 @@ impl<'a> NodeFinder<'a> {
             if name_matches(name, prefix) {
                 let per_ns = module_data.find_name(ident);
                 if let Some((module_def_id, visibility, _)) = per_ns.types {
-                    if is_visible(module_id, self.module_id, visibility, self.def_maps) {
+                    if item_in_module_is_visible(
+                        self.def_maps,
+                        self.module_id,
+                        module_id,
+                        visibility,
+                    ) {
                         let completion_items = self.module_def_id_completion_items(
                             module_def_id,
                             name.clone(),
@@ -772,7 +826,12 @@ impl<'a> NodeFinder<'a> {
                 }
 
                 if let Some((module_def_id, visibility, _)) = per_ns.values {
-                    if is_visible(module_id, self.module_id, visibility, self.def_maps) {
+                    if item_in_module_is_visible(
+                        self.def_maps,
+                        self.module_id,
+                        module_id,
+                        visibility,
+                    ) {
                         let completion_items = self.module_def_id_completion_items(
                             module_def_id,
                             name.clone(),
@@ -840,24 +899,6 @@ impl<'a> NodeFinder<'a> {
         None
     }
 
-    fn suggest_attributes(&mut self, prefix: &str, target: AttributeTarget) {
-        self.suggest_builtin_attributes(prefix, target);
-
-        let function_completion_kind = FunctionCompletionKind::NameAndParameters;
-        let requested_items = RequestedItems::OnlyAttributeFunctions(target);
-
-        self.complete_in_module(
-            self.module_id,
-            prefix,
-            PathKind::Plain,
-            true,
-            function_completion_kind,
-            requested_items,
-        );
-
-        self.complete_auto_imports(prefix, requested_items, function_completion_kind);
-    }
-
     fn suggest_no_arguments_attributes(&mut self, prefix: &str, attributes: &[&str]) {
         for name in attributes {
             if name_matches(name, prefix) {
@@ -996,6 +1037,8 @@ impl<'a> NodeFinder<'a> {
         }
     }
 
+    /// Determine where each segment in a `use` statement is located.
+
     fn includes_span(&self, span: Span) -> bool {
         span.start() as usize <= self.byte_index && self.byte_index <= span.end() as usize
     }
@@ -1003,10 +1046,11 @@ impl<'a> NodeFinder<'a> {
 
 impl<'a> Visitor for NodeFinder<'a> {
     fn visit_item(&mut self, item: &Item) -> bool {
-        if let ItemKind::Import(..) = &item.kind {
+        if let ItemKind::Import(use_tree, _) = &item.kind {
             if let Some(lsp_location) = to_lsp_location(self.files, self.file, item.span) {
                 self.auto_import_line = (lsp_location.range.end.line + 1) as usize;
             }
+            self.use_segment_positions.add(use_tree);
         }
 
         self.includes_span(item.span)
@@ -1069,6 +1113,10 @@ impl<'a> Visitor for NodeFinder<'a> {
 
         noir_function.def.return_type.accept(self);
 
+        for constraint in &noir_function.def.where_clause {
+            constraint.accept(self);
+        }
+
         self.local_variables.clear();
         for param in &noir_function.def.parameters {
             self.collect_local_variables(&param.pattern);
@@ -1176,7 +1224,7 @@ impl<'a> Visitor for NodeFinder<'a> {
         return_type.accept(self);
 
         for unresolved_trait_constraint in where_clause {
-            unresolved_trait_constraint.typ.accept(self);
+            unresolved_trait_constraint.accept(self);
         }
 
         if let Some(body) = body {
@@ -1607,12 +1655,14 @@ impl<'a> Visitor for NodeFinder<'a> {
         false
     }
 
-    fn visit_custom_attribute(&mut self, attribute: &CustomAttribute, target: AttributeTarget) {
-        if self.byte_index != attribute.contents_span.end() as usize {
-            return;
+    fn visit_meta_attribute(&mut self, attribute: &MetaAttribute, target: AttributeTarget) -> bool {
+        if self.byte_index == attribute.name.span.end() as usize {
+            self.suggest_builtin_attributes(&attribute.name.to_string(), target);
         }
 
-        self.suggest_attributes(&attribute.contents, target);
+        self.find_in_path(&attribute.name, RequestedItems::OnlyAttributeFunctions(target));
+
+        true
     }
 
     fn visit_quote(&mut self, tokens: &Tokens) {
@@ -1647,6 +1697,12 @@ impl<'a> Visitor for NodeFinder<'a> {
             last_was_dollar = false;
         }
     }
+
+    fn visit_trait_bound(&mut self, trait_bound: &TraitBound) -> bool {
+        self.find_in_path(&trait_bound.trait_path, RequestedItems::OnlyTraits);
+        trait_bound.trait_generics.accept(self);
+        false
+    }
 }
 
 fn get_field_type(typ: &Type, name: &str) -> Option<Type> {
@@ -1662,8 +1718,8 @@ fn get_field_type(typ: &Type, name: &str) -> Option<Type> {
             }
         }
         Type::Alias(alias_type, generics) => Some(alias_type.borrow().get_type(generics)),
-        Type::TypeVariable(var, _) | Type::NamedGeneric(var, _, _) => {
-            if let TypeBinding::Bound(typ) = &*var.borrow() {
+        Type::TypeVariable(var) | Type::NamedGeneric(var, _) => {
+            if let TypeBinding::Bound(ref typ) = &*var.borrow() {
                 get_field_type(typ, name)
             } else {
                 None
@@ -1680,7 +1736,7 @@ fn get_array_element_type(typ: Type) -> Option<Type> {
             let typ = alias_type.borrow().get_type(&generics);
             get_array_element_type(typ)
         }
-        Type::TypeVariable(var, _) | Type::NamedGeneric(var, _, _) => {
+        Type::TypeVariable(var) | Type::NamedGeneric(var, _) => {
             if let TypeBinding::Bound(typ) = &*var.borrow() {
                 get_array_element_type(typ.clone())
             } else {
@@ -1691,6 +1747,18 @@ fn get_array_element_type(typ: Type) -> Option<Type> {
     }
 }
 
+fn get_type_struct_id(typ: &Type) -> Option<StructId> {
+    match typ {
+        Type::Struct(struct_type, _) => Some(struct_type.borrow().id),
+        Type::Alias(type_alias, generics) => {
+            let type_alias = type_alias.borrow();
+            let typ = type_alias.get_type(generics);
+            get_type_struct_id(&typ)
+        }
+        _ => None,
+    }
+}
+
 /// Returns true if name matches a prefix written in code.
 /// `prefix` must already be in snake case.
 /// This method splits both name and prefix by underscore,
diff --git a/tooling/lsp/src/requests/completion/auto_import.rs b/tooling/lsp/src/requests/completion/auto_import.rs
index 20b126a248d..0e80b284f32 100644
--- a/tooling/lsp/src/requests/completion/auto_import.rs
+++ b/tooling/lsp/src/requests/completion/auto_import.rs
@@ -1,7 +1,12 @@
-use lsp_types::{Position, Range, TextEdit};
-use noirc_frontend::macros_api::ModuleDefId;
-
-use crate::modules::{relative_module_full_path, relative_module_id_path};
+use noirc_frontend::hir::def_map::ModuleDefId;
+
+use crate::{
+    modules::{relative_module_full_path, relative_module_id_path},
+    use_segment_positions::{
+        use_completion_item_additional_text_edits, UseCompletionItemAdditionTextEditsRequest,
+    },
+    visibility::module_def_id_is_visible,
+};
 
 use super::{
     kinds::{FunctionCompletionKind, FunctionKind, RequestedItems},
@@ -29,6 +34,17 @@ impl<'a> NodeFinder<'a> {
                     continue;
                 }
 
+                if !module_def_id_is_visible(
+                    *module_def_id,
+                    self.module_id,
+                    *visibility,
+                    *defining_module,
+                    self.interner,
+                    self.def_maps,
+                ) {
+                    continue;
+                }
+
                 let completion_items = self.module_def_id_completion_items(
                     *module_def_id,
                     name.clone(),
@@ -54,11 +70,9 @@ impl<'a> NodeFinder<'a> {
                     } else {
                         let Some(module_full_path) = relative_module_full_path(
                             *module_def_id,
-                            *visibility,
                             self.module_id,
                             current_module_parent_id,
                             self.interner,
-                            self.def_maps,
                         ) else {
                             continue;
                         };
@@ -76,27 +90,18 @@ impl<'a> NodeFinder<'a> {
                     let mut label_details = completion_item.label_details.unwrap();
                     label_details.detail = Some(format!("(use {})", full_path));
                     completion_item.label_details = Some(label_details);
-
-                    let line = self.auto_import_line as u32;
-                    let character = (self.nesting * 4) as u32;
-                    let indent = " ".repeat(self.nesting * 4);
-                    let mut newlines = "\n";
-
-                    // If the line we are inserting into is not an empty line, insert an extra line to make some room
-                    if let Some(line_text) = self.lines.get(line as usize) {
-                        if !line_text.trim().is_empty() {
-                            newlines = "\n\n";
-                        }
-                    }
-
-                    completion_item.additional_text_edits = Some(vec![TextEdit {
-                        range: Range {
-                            start: Position { line, character },
-                            end: Position { line, character },
-                        },
-                        new_text: format!("use {};{}{}", full_path, newlines, indent),
-                    }]);
-
+                    completion_item.additional_text_edits =
+                        Some(use_completion_item_additional_text_edits(
+                            UseCompletionItemAdditionTextEditsRequest {
+                                full_path: &full_path,
+                                files: self.files,
+                                file: self.file,
+                                lines: &self.lines,
+                                nesting: self.nesting,
+                                auto_import_line: self.auto_import_line,
+                            },
+                            &self.use_segment_positions,
+                        ));
                     completion_item.sort_text = Some(auto_import_sort_text());
 
                     self.completion_items.push(completion_item);
diff --git a/tooling/lsp/src/requests/completion/builtins.rs b/tooling/lsp/src/requests/completion/builtins.rs
index cf2af4036f7..b4c7d8b6e01 100644
--- a/tooling/lsp/src/requests/completion/builtins.rs
+++ b/tooling/lsp/src/requests/completion/builtins.rs
@@ -107,11 +107,29 @@ impl<'a> NodeFinder<'a> {
                 let one_argument_attributes = &["abi", "field", "foreign", "oracle"];
                 self.suggest_one_argument_attributes(prefix, one_argument_attributes);
 
+                if name_matches("deprecated", prefix) {
+                    self.completion_items.push(snippet_completion_item(
+                        "deprecated(\"...\")",
+                        CompletionItemKind::METHOD,
+                        "deprecated(\"${1:message}\")",
+                        None,
+                    ));
+                }
+
+                if name_matches("test", prefix) || name_matches("should_fail", prefix) {
+                    self.completion_items.push(snippet_completion_item(
+                        "test(should_fail)",
+                        CompletionItemKind::METHOD,
+                        "test(should_fail)",
+                        None,
+                    ));
+                }
+
                 if name_matches("test", prefix) || name_matches("should_fail_with", prefix) {
                     self.completion_items.push(snippet_completion_item(
-                        "test(should_fail_with=\"...\")",
+                        "test(should_fail_with = \"...\")",
                         CompletionItemKind::METHOD,
-                        "test(should_fail_with=\"${1:message}\")",
+                        "test(should_fail_with = \"${1:message}\")",
                         None,
                     ));
                 }
diff --git a/tooling/lsp/src/requests/completion/completion_items.rs b/tooling/lsp/src/requests/completion/completion_items.rs
index 809988c34a5..49e4474738e 100644
--- a/tooling/lsp/src/requests/completion/completion_items.rs
+++ b/tooling/lsp/src/requests/completion/completion_items.rs
@@ -4,10 +4,9 @@ use lsp_types::{
 };
 use noirc_frontend::{
     ast::AttributeTarget,
-    hir::def_map::ModuleId,
+    hir::def_map::{ModuleDefId, ModuleId},
     hir_def::{function::FuncMeta, stmt::HirPattern},
-    macros_api::{ModuleDefId, StructId},
-    node_interner::{FuncId, GlobalId, ReferenceId, TraitId, TypeAliasId},
+    node_interner::{FuncId, GlobalId, ReferenceId, StructId, TraitId, TypeAliasId},
     QuotedType, Type,
 };
 
@@ -36,6 +35,14 @@ impl<'a> NodeFinder<'a> {
                 | ModuleDefId::TypeAliasId(_)
                 | ModuleDefId::TraitId(_) => (),
             },
+            RequestedItems::OnlyTraits => match module_def_id {
+                ModuleDefId::FunctionId(_) | ModuleDefId::GlobalId(_) | ModuleDefId::TypeId(_) => {
+                    return Vec::new()
+                }
+                ModuleDefId::ModuleId(_)
+                | ModuleDefId::TypeAliasId(_)
+                | ModuleDefId::TraitId(_) => (),
+            },
             RequestedItems::OnlyAttributeFunctions(..) => {
                 if !matches!(module_def_id, ModuleDefId::FunctionId(..)) {
                     return Vec::new();
diff --git a/tooling/lsp/src/requests/completion/kinds.rs b/tooling/lsp/src/requests/completion/kinds.rs
index 6fa74ffdb1a..ba6faada6f4 100644
--- a/tooling/lsp/src/requests/completion/kinds.rs
+++ b/tooling/lsp/src/requests/completion/kinds.rs
@@ -25,8 +25,10 @@ pub(super) enum FunctionKind<'a> {
 pub(super) enum RequestedItems {
     // Suggest any items (types, functions, etc.).
     AnyItems,
-    // Only suggest types.
+    // Only suggest types (and modules, because they can contain types).
     OnlyTypes,
+    // Only suggest traits (and modules, because they can contain traits).
+    OnlyTraits,
     // Only attribute functions
     OnlyAttributeFunctions(AttributeTarget),
 }
diff --git a/tooling/lsp/src/requests/completion/tests.rs b/tooling/lsp/src/requests/completion/tests.rs
index 147fb5be4f3..97c7ad86d5a 100644
--- a/tooling/lsp/src/requests/completion/tests.rs
+++ b/tooling/lsp/src/requests/completion/tests.rs
@@ -15,12 +15,13 @@ mod completion_tests {
             on_completion_request,
         },
         test_utils,
+        tests::apply_text_edits,
     };
 
     use lsp_types::{
         CompletionItem, CompletionItemKind, CompletionItemLabelDetails, CompletionParams,
-        CompletionResponse, DidOpenTextDocumentParams, PartialResultParams, Position, Range,
-        TextDocumentIdentifier, TextDocumentItem, TextDocumentPositionParams, TextEdit,
+        CompletionResponse, DidOpenTextDocumentParams, PartialResultParams, Position,
+        TextDocumentIdentifier, TextDocumentItem, TextDocumentPositionParams,
         WorkDoneProgressParams,
     };
     use tokio::test;
@@ -595,7 +596,7 @@ mod completion_tests {
             vec![simple_completion_item(
                 "lambda_var",
                 CompletionItemKind::VARIABLE,
-                Some("_".to_string()),
+                Some("i32".to_string()),
             )],
         )
         .await;
@@ -1071,6 +1072,22 @@ mod completion_tests {
         assert_completion(src, vec![field_completion_item("bar", "i32")]).await;
     }
 
+    #[test]
+    async fn test_does_not_suggest_private_struct_field() {
+        let src = r#"
+            mod moo {
+                pub struct Some {
+                    property: i32,
+                }
+            }
+
+            fn foo(s: moo::Some) {
+                s.>|<
+            }
+        "#;
+        assert_completion(src, vec![]).await;
+    }
+
     #[test]
     async fn test_suggests_struct_impl_method() {
         let src = r#"
@@ -1376,29 +1393,50 @@ mod completion_tests {
 
     #[test]
     async fn test_auto_imports() {
-        let src = r#"
-            mod foo {
-                mod bar {
-                    pub fn hello_world() {}
+        let src = r#"mod foo {
+    pub mod bar {
+        pub fn hello_world() {}
 
-                    struct Foo {
-                    }
+        struct Foo {
+        }
 
-                    impl Foo {
-                        // This is here to make sure it's not offered for completion
-                        fn hello_world() {}
-                    }
-                }
-            }
+        impl Foo {
+            // This is here to make sure it's not offered for completion
+            fn hello_world() {}
+        }
+    }
+}
 
-            fn main() {
-                hel>|<
-            }
+fn main() {
+    hel>|<
+}
         "#;
-        let items = get_completions(src).await;
+
+        let expected = r#"use foo::bar::hello_world;
+
+mod foo {
+    pub mod bar {
+        pub fn hello_world() {}
+
+        struct Foo {
+        }
+
+        impl Foo {
+            // This is here to make sure it's not offered for completion
+            fn hello_world() {}
+        }
+    }
+}
+
+fn main() {
+    hel
+}
+        "#;
+
+        let mut items = get_completions(src).await;
         assert_eq!(items.len(), 1);
 
-        let item = &items[0];
+        let item = items.remove(0);
         assert_eq!(item.label, "hello_world()");
         assert_eq!(
             item.label_details,
@@ -1408,38 +1446,43 @@ mod completion_tests {
             })
         );
 
-        assert_eq!(
-            item.additional_text_edits,
-            Some(vec![TextEdit {
-                range: Range {
-                    start: Position { line: 0, character: 0 },
-                    end: Position { line: 0, character: 0 },
-                },
-                new_text: "use foo::bar::hello_world;\n".to_string(),
-            }])
-        );
-
+        let changed =
+            apply_text_edits(&src.replace(">|<", ""), &item.additional_text_edits.unwrap());
+        assert_eq!(changed, expected);
         assert_eq!(item.sort_text, Some(auto_import_sort_text()));
     }
 
     #[test]
     async fn test_auto_imports_when_in_nested_module_and_item_is_further_nested() {
-        let src = r#"
-            #[something]
-            mod foo {
-                mod bar {
-                    pub fn hello_world() {}
-                }
+        let src = r#"#[something]
+mod foo {
+    pub mod bar {
+        pub fn hello_world() {}
+    }
 
-                fn foo() {
-                    hel>|<
-                }
-            }
+    fn foo() {
+        hel>|<
+    }
+}
         "#;
-        let items = get_completions(src).await;
+
+        let expected = r#"#[something]
+mod foo {
+    use bar::hello_world;
+
+    pub mod bar {
+        pub fn hello_world() {}
+    }
+
+    fn foo() {
+        hel
+    }
+}
+        "#;
+        let mut items = get_completions(src).await;
         assert_eq!(items.len(), 1);
 
-        let item = &items[0];
+        let item = items.remove(0);
         assert_eq!(item.label, "hello_world()");
         assert_eq!(
             item.label_details,
@@ -1449,37 +1492,42 @@ mod completion_tests {
             })
         );
 
-        assert_eq!(
-            item.additional_text_edits,
-            Some(vec![TextEdit {
-                range: Range {
-                    start: Position { line: 3, character: 4 },
-                    end: Position { line: 3, character: 4 },
-                },
-                new_text: "use bar::hello_world;\n\n    ".to_string(),
-            }])
-        );
+        let changed =
+            apply_text_edits(&src.replace(">|<", ""), &item.additional_text_edits.unwrap());
+        assert_eq!(changed, expected);
     }
 
     #[test]
     async fn test_auto_imports_when_in_nested_module_and_item_is_not_further_nested() {
-        let src = r#"
-            mod foo {
-                mod bar {
-                    pub fn hello_world() {}
-                }
+        let src = r#"mod foo {
+    pub mod bar {
+        pub fn hello_world() {}
+    }
 
-                mod baz {
-                    fn foo() {
-                        hel>|<
-                    }
-                }
-            }
-        "#;
-        let items = get_completions(src).await;
+    pub mod baz {
+        fn foo() {
+            hel>|<
+        }
+    }
+}"#;
+
+        let expected = r#"mod foo {
+    pub mod bar {
+        pub fn hello_world() {}
+    }
+
+    pub mod baz {
+        use super::bar::hello_world;
+
+        fn foo() {
+            hel
+        }
+    }
+}"#;
+        let mut items = get_completions(src).await;
         assert_eq!(items.len(), 1);
 
-        let item = &items[0];
+        let item = items.remove(0);
         assert_eq!(item.label, "hello_world()");
         assert_eq!(
             item.label_details,
@@ -1489,23 +1537,109 @@ mod completion_tests {
             })
         );
 
-        assert_eq!(
-            item.additional_text_edits,
-            Some(vec![TextEdit {
-                range: Range {
-                    start: Position { line: 7, character: 8 },
-                    end: Position { line: 7, character: 8 },
-                },
-                new_text: "use super::bar::hello_world;\n\n        ".to_string(),
-            }])
-        );
+        let changed =
+            apply_text_edits(&src.replace(">|<", ""), &item.additional_text_edits.unwrap());
+        assert_eq!(changed, expected);
     }
 
     #[test]
     async fn test_auto_import_inserts_after_last_use() {
+        let src = r#"mod foo {
+    pub mod bar {
+        pub fn hello_world() {}
+    }
+}
+
+mod baz {
+    fn qux() {}
+}
+
+use baz::qux;
+
+fn main() {
+    hel>|<
+}"#;
+
+        let expected = r#"mod foo {
+    pub mod bar {
+        pub fn hello_world() {}
+    }
+}
+
+mod baz {
+    fn qux() {}
+}
+
+use baz::qux;
+use foo::bar::hello_world;
+
+fn main() {
+    hel
+}"#;
+        let mut items = get_completions(src).await;
+        assert_eq!(items.len(), 1);
+
+        let item = items.remove(0);
+
+        let changed =
+            apply_text_edits(&src.replace(">|<", ""), &item.additional_text_edits.unwrap());
+        assert_eq!(changed, expected);
+    }
+
+    #[test]
+    async fn test_auto_import_inserts_after_last_use_in_nested_module() {
+        let src = r#"mod foo {
+    pub mod bar {
+        pub fn hello_world() {}
+    }
+}
+
+mod baz {
+    fn qux() {}
+}
+
+mod other {
+    use baz::qux;
+
+    fn main() {
+        hel>|<
+    }
+}"#;
+
+        let expected = r#"mod foo {
+    pub mod bar {
+        pub fn hello_world() {}
+    }
+}
+
+mod baz {
+    fn qux() {}
+}
+
+mod other {
+    use baz::qux;
+    use super::foo::bar::hello_world;
+
+    fn main() {
+        hel
+    }
+}"#;
+        let mut items = get_completions(src).await;
+        assert_eq!(items.len(), 1);
+
+        let item = items.remove(0);
+
+        let changed =
+            apply_text_edits(&src.replace(">|<", ""), &item.additional_text_edits.unwrap());
+        assert_eq!(changed, expected);
+    }
+
+    #[test]
+    async fn test_does_not_auto_import_test_functions() {
         let src = r#"
             mod foo {
                 mod bar {
+                    #[test]
                     pub fn hello_world() {}
                 }
             }
@@ -1517,28 +1651,15 @@ mod completion_tests {
             }
         "#;
         let items = get_completions(src).await;
-        assert_eq!(items.len(), 1);
-
-        let item = &items[0];
-        assert_eq!(
-            item.additional_text_edits,
-            Some(vec![TextEdit {
-                range: Range {
-                    start: Position { line: 8, character: 0 },
-                    end: Position { line: 8, character: 0 },
-                },
-                new_text: "use foo::bar::hello_world;\n".to_string(),
-            }])
-        );
+        assert!(items.is_empty());
     }
 
     #[test]
-    async fn test_does_not_auto_import_test_functions() {
+    async fn test_does_not_auto_import_private_functions() {
         let src = r#"
             mod foo {
                 mod bar {
-                    #[test]
-                    pub fn hello_world() {}
+                    fn hello_world() {}
                 }
             }
 
@@ -1553,16 +1674,14 @@ mod completion_tests {
     }
 
     #[test]
-    async fn test_does_not_auto_import_private_functions() {
+    async fn test_does_not_auto_import_public_function_in_private_module() {
         let src = r#"
             mod foo {
                 mod bar {
-                    fn hello_world() {}
+                    pub fn hello_world() {}
                 }
             }
 
-            use foo::bar;
-
             fn main() {
                 hel>|<
             }
@@ -1572,23 +1691,60 @@ mod completion_tests {
     }
 
     #[test]
-    async fn test_auto_import_suggests_modules_too() {
+    async fn checks_visibility_of_module_that_exports_item_if_any() {
         let src = r#"
             mod foo {
-                mod barbaz {
-                    fn hello_world() {}
+                mod bar {
+                    pub fn hello_world() {}
                 }
+
+                pub use bar::hello_world;
             }
 
             fn main() {
-                barb>|<
+                hello_w>|<
             }
         "#;
-        let items = get_completions(src).await;
+        let mut items = get_completions(src).await;
         assert_eq!(items.len(), 1);
 
-        let item = &items[0];
+        let item = items.remove(0);
+        assert_eq!(item.label, "hello_world()");
+        assert_eq!(item.label_details.unwrap().detail.unwrap(), "(use foo::hello_world)");
+    }
+
+    #[test]
+    async fn test_auto_import_suggests_modules_too() {
+        let src = r#"mod foo {
+        pub mod barbaz {
+            fn hello_world() {}
+        }
+    }
+
+    fn main() {
+        barb>|<
+    }
+}"#;
+
+        let expected = r#"use foo::barbaz;
+
+mod foo {
+        pub mod barbaz {
+            fn hello_world() {}
+        }
+    }
+
+    fn main() {
+        barb
+    }
+}"#;
+
+        let mut items = get_completions(src).await;
+        assert_eq!(items.len(), 1);
+
+        let item = items.remove(0);
         assert_eq!(item.label, "barbaz");
+
         assert_eq!(
             item.label_details,
             Some(CompletionItemLabelDetails {
@@ -1596,6 +1752,286 @@ mod completion_tests {
                 description: None
             })
         );
+
+        let changed =
+            apply_text_edits(&src.replace(">|<", ""), &item.additional_text_edits.unwrap());
+        assert_eq!(changed, expected);
+    }
+
+    #[test]
+    async fn test_auto_imports_expands_existing_use_before_one_segment_not_in_list() {
+        let src = r#"use foo::bar::one_hello_world;
+
+mod foo {
+    pub mod bar {
+        pub fn one_hello_world() {}
+        pub fn two_hello_world() {}
+    }
+}
+
+fn main() {
+    two_hello_>|<
+}"#;
+
+        let expected = r#"use foo::bar::{one_hello_world, two_hello_world};
+
+mod foo {
+    pub mod bar {
+        pub fn one_hello_world() {}
+        pub fn two_hello_world() {}
+    }
+}
+
+fn main() {
+    two_hello_
+}"#;
+
+        let mut items = get_completions(src).await;
+        assert_eq!(items.len(), 1);
+
+        let item = items.remove(0);
+        let changed =
+            apply_text_edits(&src.replace(">|<", ""), &item.additional_text_edits.unwrap());
+        assert_eq!(changed, expected);
+        assert_eq!(item.sort_text, Some(auto_import_sort_text()));
+    }
+
+    #[test]
+    async fn test_auto_imports_expands_existing_use_before_two_segments() {
+        let src = r#"use foo::bar::one_hello_world;
+
+mod foo {
+    pub mod bar {
+        pub fn one_hello_world() {}
+    }
+    pub fn two_hello_world() {}
+}
+
+fn main() {
+    two_hello_>|<
+}"#;
+
+        let expected = r#"use foo::{bar::one_hello_world, two_hello_world};
+
+mod foo {
+    pub mod bar {
+        pub fn one_hello_world() {}
+    }
+    pub fn two_hello_world() {}
+}
+
+fn main() {
+    two_hello_
+}"#;
+
+        let mut items = get_completions(src).await;
+        assert_eq!(items.len(), 1);
+
+        let item = items.remove(0);
+        let changed =
+            apply_text_edits(&src.replace(">|<", ""), &item.additional_text_edits.unwrap());
+        assert_eq!(changed, expected);
+        assert_eq!(item.sort_text, Some(auto_import_sort_text()));
+    }
+
+    #[test]
+    async fn test_auto_imports_expands_existing_use_before_one_segment_inside_list() {
+        let src = r#"use foo::{bar::one_hello_world, baz};
+
+mod foo {
+    pub mod bar {
+        pub fn one_hello_world() {}
+        pub fn two_hello_world() {}
+    }
+    pub mod baz {}
+}
+
+fn main() {
+    two_hello_>|<
+}"#;
+
+        let expected = r#"use foo::{bar::{one_hello_world, two_hello_world}, baz};
+
+mod foo {
+    pub mod bar {
+        pub fn one_hello_world() {}
+        pub fn two_hello_world() {}
+    }
+    pub mod baz {}
+}
+
+fn main() {
+    two_hello_
+}"#;
+
+        let mut items = get_completions(src).await;
+        assert_eq!(items.len(), 1);
+
+        let item = items.remove(0);
+        let changed =
+            apply_text_edits(&src.replace(">|<", ""), &item.additional_text_edits.unwrap());
+        assert_eq!(changed, expected);
+        assert_eq!(item.sort_text, Some(auto_import_sort_text()));
+    }
+
+    #[test]
+    async fn test_auto_imports_expands_existing_use_before_one_segment_checks_parents() {
+        let src = r#"use foo::bar::baz;
+
+mod foo {
+    pub mod bar {
+        pub mod baz {
+            pub fn one_hello_world() {}
+        }
+        pub mod qux {
+            pub fn two_hello_world() {}
+        }
+    }
+}
+
+fn main() {
+    two_hello_>|<
+}"#;
+
+        let expected = r#"use foo::bar::{baz, qux::two_hello_world};
+
+mod foo {
+    pub mod bar {
+        pub mod baz {
+            pub fn one_hello_world() {}
+        }
+        pub mod qux {
+            pub fn two_hello_world() {}
+        }
+    }
+}
+
+fn main() {
+    two_hello_
+}"#;
+
+        let mut items = get_completions(src).await;
+        assert_eq!(items.len(), 1);
+
+        let item = items.remove(0);
+        let changed =
+            apply_text_edits(&src.replace(">|<", ""), &item.additional_text_edits.unwrap());
+        assert_eq!(changed, expected);
+        assert_eq!(item.sort_text, Some(auto_import_sort_text()));
+    }
+
+    #[test]
+    async fn test_auto_imports_expands_existing_use_last_segment() {
+        let src = r#"use foo::bar;
+
+mod foo {
+    pub mod bar {
+        pub fn one_hello_world() {}
+        pub fn two_hello_world() {}
+    }
+}
+
+fn main() {
+    two_hello_>|<
+}"#;
+
+        let expected = r#"use foo::bar::{self, two_hello_world};
+
+mod foo {
+    pub mod bar {
+        pub fn one_hello_world() {}
+        pub fn two_hello_world() {}
+    }
+}
+
+fn main() {
+    two_hello_
+}"#;
+
+        let mut items = get_completions(src).await;
+        assert_eq!(items.len(), 1);
+
+        let item = items.remove(0);
+        let changed =
+            apply_text_edits(&src.replace(">|<", ""), &item.additional_text_edits.unwrap());
+        assert_eq!(changed, expected);
+        assert_eq!(item.sort_text, Some(auto_import_sort_text()));
+    }
+
+    #[test]
+    async fn test_auto_imports_expands_existing_use_before_list() {
+        let src = r#"use foo::bar::{one_hello_world, three_hello_world};
+
+mod foo {
+    pub mod bar {
+        pub fn one_hello_world() {}
+        pub fn two_hello_world() {}
+        pub fn three_hello_world() {}
+    }
+}
+
+fn main() {
+    two_hello_>|<
+}"#;
+
+        let expected = r#"use foo::bar::{two_hello_world, one_hello_world, three_hello_world};
+
+mod foo {
+    pub mod bar {
+        pub fn one_hello_world() {}
+        pub fn two_hello_world() {}
+        pub fn three_hello_world() {}
+    }
+}
+
+fn main() {
+    two_hello_
+}"#;
+
+        let mut items = get_completions(src).await;
+        assert_eq!(items.len(), 1);
+
+        let item = items.remove(0);
+        let changed =
+            apply_text_edits(&src.replace(">|<", ""), &item.additional_text_edits.unwrap());
+        assert_eq!(changed, expected);
+        assert_eq!(item.sort_text, Some(auto_import_sort_text()));
+    }
+
+    #[test]
+    async fn test_auto_imports_expands_existing_use_before_empty_list() {
+        let src = r#"use foo::bar::{};
+
+mod foo {
+    pub mod bar {
+        pub fn two_hello_world() {}
+    }
+}
+
+fn main() {
+    two_hello_>|<
+}"#;
+
+        let expected = r#"use foo::bar::{two_hello_world};
+
+mod foo {
+    pub mod bar {
+        pub fn two_hello_world() {}
+    }
+}
+
+fn main() {
+    two_hello_
+}"#;
+
+        let mut items = get_completions(src).await;
+        assert_eq!(items.len(), 1);
+
+        let item = items.remove(0);
+        let changed =
+            apply_text_edits(&src.replace(">|<", ""), &item.additional_text_edits.unwrap());
+        assert_eq!(changed, expected);
+        assert_eq!(item.sort_text, Some(auto_import_sort_text()));
     }
 
     #[test]
@@ -1805,6 +2241,37 @@ mod completion_tests {
         .await;
     }
 
+    #[test]
+    async fn test_does_not_suggest_private_struct_methods() {
+        let src = r#"
+            mod moo {
+                pub struct Foo {}
+
+                impl Foo {
+                    fn bar(self) {}
+                }
+            }
+
+            fn x(f: moo::Foo) {
+                f.>|<()
+            }
+        "#;
+        assert_completion(src, vec![]).await;
+    }
+
+    #[test]
+    async fn test_does_not_suggest_private_primitive_methods() {
+        let src = r#"
+            fn foo(x: Field) {
+                x.>|<
+            }
+        "#;
+        let items = get_completions(src).await;
+        if items.iter().any(|item| item.label == "__assert_max_bit_size") {
+            panic!("Private method __assert_max_bit_size was suggested");
+        }
+    }
+
     #[test]
     async fn test_suggests_pub_use() {
         let src = r#"
@@ -1854,7 +2321,7 @@ mod completion_tests {
     async fn test_auto_import_suggests_pub_use_for_function() {
         let src = r#"
             mod bar {
-                mod baz {
+                pub mod baz {
                     pub fn coco() {}
                 }
 
@@ -1931,13 +2398,13 @@ mod completion_tests {
     #[test]
     async fn test_suggests_built_in_function_attribute() {
         let src = r#"
-            #[dep>|<]
+            #[no_pred>|<]
             fn foo() {}
         "#;
 
         assert_completion_excluding_auto_import(
             src,
-            vec![simple_completion_item("deprecated", CompletionItemKind::METHOD, None)],
+            vec![simple_completion_item("no_predicates", CompletionItemKind::METHOD, None)],
         )
         .await;
     }
@@ -2271,4 +2738,127 @@ mod completion_tests {
         )
         .await;
     }
+
+    #[test]
+    async fn test_does_not_auto_import_private_global() {
+        let src = r#"mod moo {
+            global foobar = 1;
+        }
+
+        fn main() {
+            fooba>|<
+        }"#;
+
+        assert_completion(src, Vec::new()).await;
+    }
+
+    #[test]
+    async fn test_does_not_auto_import_private_type_alias() {
+        let src = r#"mod moo {
+            type foobar = i32;
+        }
+
+        fn main() {
+            fooba>|<
+        }"#;
+
+        assert_completion(src, Vec::new()).await;
+    }
+
+    #[test]
+    async fn test_does_not_auto_import_private_trait() {
+        let src = r#"mod moo {
+            trait Foobar {}
+        }
+
+        fn main() {
+            Fooba>|<
+        }"#;
+
+        assert_completion(src, Vec::new()).await;
+    }
+
+    #[test]
+    async fn test_does_not_auto_import_private_module() {
+        let src = r#"mod moo {
+            mod foobar {}
+        }
+
+        fn main() {
+            fooba>|<
+        }"#;
+
+        assert_completion(src, Vec::new()).await;
+    }
+
+    #[test]
+    async fn test_suggests_trait_in_trait_parent_bounds() {
+        let src = r#"
+        trait Foobar {}
+        struct Foobarbaz {}
+
+        trait Bar: Foob>|< {}
+        "#;
+        assert_completion(
+            src,
+            vec![simple_completion_item(
+                "Foobar",
+                CompletionItemKind::INTERFACE,
+                Some("Foobar".to_string()),
+            )],
+        )
+        .await;
+    }
+
+    #[test]
+    async fn test_suggests_trait_in_function_where_clause() {
+        let src = r#"
+        trait Foobar {}
+        struct Foobarbaz {}
+
+        fn foo<T>() where T: Foob>|< {}
+        "#;
+        assert_completion(
+            src,
+            vec![simple_completion_item(
+                "Foobar",
+                CompletionItemKind::INTERFACE,
+                Some("Foobar".to_string()),
+            )],
+        )
+        .await;
+    }
+
+    #[test]
+    async fn test_suggests_methods_based_on_type_generics() {
+        let src = r#"
+        struct Foo<T> {
+            t: T,
+        }
+
+        impl Foo<Field> {
+            fn bar_baz(_self: Self) -> Field {
+                5
+            }
+        }
+
+        impl Foo<u32> {
+            fn bar(_self: Self) -> Field {
+                5
+            }
+
+            fn baz(_self: Self) -> Field {
+                6
+            }
+        }
+
+        fn main() -> pub Field {
+            let foo: Foo<Field> = Foo { t: 5 };
+            foo.b>|<
+        }
+        "#;
+        let items = get_completions(src).await;
+        assert_eq!(items.len(), 1);
+        assert!(items[0].label == "bar_baz()");
+    }
 }
diff --git a/tooling/lsp/src/requests/document_symbol.rs b/tooling/lsp/src/requests/document_symbol.rs
index 6c41f4dc2e5..0fc2dc4622e 100644
--- a/tooling/lsp/src/requests/document_symbol.rs
+++ b/tooling/lsp/src/requests/document_symbol.rs
@@ -66,6 +66,10 @@ impl<'a> DocumentSymbolCollector<'a> {
     }
 
     fn collect_in_type(&mut self, name: &Ident, typ: Option<&UnresolvedType>) {
+        if name.0.contents.is_empty() {
+            return;
+        }
+
         let Some(name_location) = self.to_lsp_location(name.span()) else {
             return;
         };
@@ -99,6 +103,10 @@ impl<'a> DocumentSymbolCollector<'a> {
         typ: &UnresolvedType,
         default_value: Option<&Expression>,
     ) {
+        if name.0.contents.is_empty() {
+            return;
+        }
+
         let Some(name_location) = self.to_lsp_location(name.span()) else {
             return;
         };
@@ -137,6 +145,10 @@ impl<'a> DocumentSymbolCollector<'a> {
 
 impl<'a> Visitor for DocumentSymbolCollector<'a> {
     fn visit_noir_function(&mut self, noir_function: &NoirFunction, span: Span) -> bool {
+        if noir_function.def.name.0.contents.is_empty() {
+            return false;
+        }
+
         let Some(location) = self.to_lsp_location(span) else {
             return false;
         };
@@ -162,6 +174,10 @@ impl<'a> Visitor for DocumentSymbolCollector<'a> {
     }
 
     fn visit_noir_struct(&mut self, noir_struct: &NoirStruct, span: Span) -> bool {
+        if noir_struct.name.0.contents.is_empty() {
+            return false;
+        }
+
         let Some(location) = self.to_lsp_location(span) else {
             return false;
         };
@@ -213,6 +229,10 @@ impl<'a> Visitor for DocumentSymbolCollector<'a> {
     }
 
     fn visit_noir_trait(&mut self, noir_trait: &NoirTrait, span: Span) -> bool {
+        if noir_trait.name.0.contents.is_empty() {
+            return false;
+        }
+
         let Some(location) = self.to_lsp_location(span) else {
             return false;
         };
@@ -255,6 +275,10 @@ impl<'a> Visitor for DocumentSymbolCollector<'a> {
         _where_clause: &[noirc_frontend::ast::UnresolvedTraitConstraint],
         body: &Option<noirc_frontend::ast::BlockExpression>,
     ) -> bool {
+        if name.0.contents.is_empty() {
+            return false;
+        }
+
         let Some(name_location) = self.to_lsp_location(name.span()) else {
             return false;
         };
@@ -308,6 +332,10 @@ impl<'a> Visitor for DocumentSymbolCollector<'a> {
         typ: &UnresolvedType,
         default_value: &Option<Expression>,
     ) -> bool {
+        if name.0.contents.is_empty() {
+            return false;
+        }
+
         self.collect_in_constant(name, typ, default_value.as_ref());
         false
     }
@@ -400,6 +428,9 @@ impl<'a> Visitor for DocumentSymbolCollector<'a> {
         };
 
         let name = type_impl.object_type.typ.to_string();
+        if name.is_empty() {
+            return false;
+        }
 
         let Some(name_location) = self.to_lsp_location(type_impl.object_type.span) else {
             return false;
@@ -431,6 +462,10 @@ impl<'a> Visitor for DocumentSymbolCollector<'a> {
     }
 
     fn visit_parsed_submodule(&mut self, parsed_sub_module: &ParsedSubModule, span: Span) -> bool {
+        if parsed_sub_module.name.0.contents.is_empty() {
+            return false;
+        }
+
         let Some(name_location) = self.to_lsp_location(parsed_sub_module.name.span()) else {
             return false;
         };
@@ -465,6 +500,11 @@ impl<'a> Visitor for DocumentSymbolCollector<'a> {
     }
 
     fn visit_global(&mut self, global: &LetStatement, span: Span) -> bool {
+        let name = global.pattern.to_string();
+        if name.is_empty() {
+            return false;
+        }
+
         let Some(name_location) = self.to_lsp_location(global.pattern.span()) else {
             return false;
         };
@@ -475,7 +515,7 @@ impl<'a> Visitor for DocumentSymbolCollector<'a> {
 
         #[allow(deprecated)]
         self.symbols.push(DocumentSymbol {
-            name: global.pattern.to_string(),
+            name,
             detail: None,
             kind: SymbolKind::CONSTANT,
             tags: None,
@@ -634,7 +674,7 @@ mod document_symbol_tests {
                             deprecated: None,
                             range: Range {
                                 start: Position { line: 15, character: 7 },
-                                end: Position { line: 15, character: 25 },
+                                end: Position { line: 15, character: 24 },
                             },
                             selection_range: Range {
                                 start: Position { line: 15, character: 7 },
diff --git a/tooling/lsp/src/requests/hover.rs b/tooling/lsp/src/requests/hover.rs
index 2628c9b2ab6..bb1ea661719 100644
--- a/tooling/lsp/src/requests/hover.rs
+++ b/tooling/lsp/src/requests/hover.rs
@@ -4,13 +4,17 @@ use async_lsp::ResponseError;
 use fm::{FileMap, PathString};
 use lsp_types::{Hover, HoverContents, HoverParams, MarkupContent, MarkupKind};
 use noirc_frontend::{
-    ast::Visibility,
+    ast::{ItemVisibility, Visibility},
     elaborator::types::try_eval_array_length_id,
     hir::def_map::ModuleId,
-    hir_def::{expr::HirArrayLiteral, stmt::HirPattern, traits::Trait},
-    macros_api::{HirExpression, HirLiteral, NodeInterner, StructId},
+    hir_def::{
+        expr::{HirArrayLiteral, HirExpression, HirLiteral},
+        stmt::HirPattern,
+        traits::Trait,
+    },
     node_interner::{
-        DefinitionId, DefinitionKind, ExprId, FuncId, GlobalId, ReferenceId, TraitId, TypeAliasId,
+        DefinitionId, DefinitionKind, ExprId, FuncId, GlobalId, NodeInterner, ReferenceId,
+        StructId, TraitId, TypeAliasId,
     },
     Generics, Shared, StructType, Type, TypeAlias, TypeBinding, TypeVariable,
 };
@@ -133,11 +137,11 @@ fn format_struct(id: StructId, args: &ProcessRequestCallbackArgs) -> String {
     string.push_str(&struct_type.name.0.contents);
     format_generics(&struct_type.generics, &mut string);
     string.push_str(" {\n");
-    for (field_name, field_type) in struct_type.get_fields_as_written() {
+    for field in struct_type.get_fields_as_written() {
         string.push_str("        ");
-        string.push_str(&field_name);
+        string.push_str(&field.name.0.contents);
         string.push_str(": ");
-        string.push_str(&format!("{}", field_type));
+        string.push_str(&format!("{}", field.typ));
         string.push_str(",\n");
     }
     string.push_str("    }");
@@ -154,7 +158,7 @@ fn format_struct_member(
 ) -> String {
     let struct_type = args.interner.get_struct(id);
     let struct_type = struct_type.borrow();
-    let (field_name, field_type) = struct_type.field_at(field_index);
+    let field = struct_type.field_at(field_index);
 
     let mut string = String::new();
     if format_parent_module(ReferenceId::Struct(id), args, &mut string) {
@@ -163,10 +167,10 @@ fn format_struct_member(
     string.push_str(&struct_type.name.0.contents);
     string.push('\n');
     string.push_str("    ");
-    string.push_str(&field_name.0.contents);
+    string.push_str(&field.name.0.contents);
     string.push_str(": ");
-    string.push_str(&format!("{}", field_type));
-    string.push_str(&go_to_type_links(field_type, args.interner, args.files));
+    string.push_str(&format!("{}", field.typ));
+    string.push_str(&go_to_type_links(&field.typ, args.interner, args.files));
 
     append_doc_comments(args.interner, ReferenceId::StructMember(id, field_index), &mut string);
 
@@ -296,26 +300,113 @@ fn get_exprs_global_value(interner: &NodeInterner, exprs: &[ExprId]) -> Option<S
 
 fn format_function(id: FuncId, args: &ProcessRequestCallbackArgs) -> String {
     let func_meta = args.interner.function_meta(&id);
+    let func_modifiers = args.interner.function_modifiers(&id);
+
     let func_name_definition_id = args.interner.definition(func_meta.name.id);
 
     let mut string = String::new();
     let formatted_parent_module =
         format_parent_module(ReferenceId::Function(id), args, &mut string);
-    let formatted_parent_struct = if let Some(struct_id) = func_meta.struct_id {
+
+    let formatted_parent_type = if let Some(trait_impl_id) = func_meta.trait_impl {
+        let trait_impl = args.interner.get_trait_implementation(trait_impl_id);
+        let trait_impl = trait_impl.borrow();
+        let trait_ = args.interner.get_trait(trait_impl.trait_id);
+
+        let generics: Vec<_> =
+            trait_impl
+                .trait_generics
+                .iter()
+                .filter_map(|generic| {
+                    if let Type::NamedGeneric(_, name) = generic {
+                        Some(name)
+                    } else {
+                        None
+                    }
+                })
+                .collect();
+
+        string.push('\n');
+        string.push_str("    impl");
+        if !generics.is_empty() {
+            string.push('<');
+            for (index, generic) in generics.into_iter().enumerate() {
+                if index > 0 {
+                    string.push_str(", ");
+                }
+                string.push_str(generic);
+            }
+            string.push('>');
+        }
+
+        string.push(' ');
+        string.push_str(&trait_.name.0.contents);
+        if !trait_impl.trait_generics.is_empty() {
+            string.push('<');
+            for (index, generic) in trait_impl.trait_generics.iter().enumerate() {
+                if index > 0 {
+                    string.push_str(", ");
+                }
+                string.push_str(&generic.to_string());
+            }
+            string.push('>');
+        }
+
+        string.push_str(" for ");
+        string.push_str(&trait_impl.typ.to_string());
+
+        true
+    } else if let Some(trait_id) = func_meta.trait_id {
+        let trait_ = args.interner.get_trait(trait_id);
+        string.push('\n');
+        string.push_str("    trait ");
+        string.push_str(&trait_.name.0.contents);
+        format_generics(&trait_.generics, &mut string);
+
+        true
+    } else if let Some(struct_id) = func_meta.struct_id {
         let struct_type = args.interner.get_struct(struct_id);
         let struct_type = struct_type.borrow();
         if formatted_parent_module {
             string.push_str("::");
         }
         string.push_str(&struct_type.name.0.contents);
+        string.push('\n');
+        string.push_str("    ");
+        string.push_str("impl");
+
+        let impl_generics: Vec<_> = func_meta
+            .all_generics
+            .iter()
+            .take(func_meta.all_generics.len() - func_meta.direct_generics.len())
+            .cloned()
+            .collect();
+        format_generics(&impl_generics, &mut string);
+
+        string.push(' ');
+        string.push_str(&struct_type.name.0.contents);
+        format_generic_names(&impl_generics, &mut string);
+
         true
     } else {
         false
     };
-    if formatted_parent_module || formatted_parent_struct {
+    if formatted_parent_module || formatted_parent_type {
         string.push('\n');
     }
     string.push_str("    ");
+
+    if func_modifiers.visibility != ItemVisibility::Private {
+        string.push_str(&func_modifiers.visibility.to_string());
+        string.push(' ');
+    }
+    if func_modifiers.is_unconstrained {
+        string.push_str("unconstrained ");
+    }
+    if func_modifiers.is_comptime {
+        string.push_str("comptime ");
+    }
+
     string.push_str("fn ");
     string.push_str(&func_name_definition_id.name);
     format_generics(&func_meta.direct_generics, &mut string);
@@ -407,21 +498,55 @@ fn format_local(id: DefinitionId, args: &ProcessRequestCallbackArgs) -> String {
     string
 }
 
-/// Some doc comments
 fn format_generics(generics: &Generics, string: &mut String) {
+    format_generics_impl(
+        generics, false, // only show names
+        string,
+    );
+}
+
+fn format_generic_names(generics: &Generics, string: &mut String) {
+    format_generics_impl(
+        generics, true, // only show names
+        string,
+    );
+}
+
+fn format_generics_impl(generics: &Generics, only_show_names: bool, string: &mut String) {
     if generics.is_empty() {
         return;
     }
 
     string.push('<');
     for (index, generic) in generics.iter().enumerate() {
-        string.push_str(&generic.name);
-        if index != generics.len() - 1 {
+        if index > 0 {
             string.push_str(", ");
         }
+
+        if only_show_names {
+            string.push_str(&generic.name);
+        } else {
+            match generic.kind() {
+                noirc_frontend::Kind::Any | noirc_frontend::Kind::Normal => {
+                    string.push_str(&generic.name);
+                }
+                noirc_frontend::Kind::IntegerOrField | noirc_frontend::Kind::Integer => {
+                    string.push_str("let ");
+                    string.push_str(&generic.name);
+                    string.push_str(": u32");
+                }
+                noirc_frontend::Kind::Numeric(typ) => {
+                    string.push_str("let ");
+                    string.push_str(&generic.name);
+                    string.push_str(": ");
+                    string.push_str(&typ.to_string());
+                }
+            }
+        }
     }
     string.push('>');
 }
+
 fn format_pattern(pattern: &HirPattern, interner: &NodeInterner, string: &mut String) {
     match pattern {
         HirPattern::Identifier(ident) => {
@@ -526,7 +651,7 @@ impl<'a> TypeLinksGatherer<'a> {
                     self.gather_type_links(generic);
                 }
             }
-            Type::TypeVariable(var, _) => {
+            Type::TypeVariable(var) => {
                 self.gather_type_variable_links(var);
             }
             Type::TraitAsType(trait_id, _, generics) => {
@@ -539,7 +664,7 @@ impl<'a> TypeLinksGatherer<'a> {
                     self.gather_type_links(&named_type.typ);
                 }
             }
-            Type::NamedGeneric(var, _, _) => {
+            Type::NamedGeneric(var, _) => {
                 self.gather_type_variable_links(var);
             }
             Type::Function(args, return_type, env, _) => {
@@ -554,6 +679,7 @@ impl<'a> TypeLinksGatherer<'a> {
                 self.gather_type_links(lhs);
                 self.gather_type_links(rhs);
             }
+            Type::CheckedCast { to, .. } => self.gather_type_links(to),
             Type::FieldElement
             | Type::Integer(..)
             | Type::Bool
@@ -643,6 +769,11 @@ mod hover_tests {
     use tokio::test;
 
     async fn assert_hover(directory: &str, file: &str, position: Position, expected_text: &str) {
+        let hover_text = get_hover_text(directory, file, position).await;
+        assert_eq!(hover_text, expected_text);
+    }
+
+    async fn get_hover_text(directory: &str, file: &str, position: Position) -> String {
         let (mut state, noir_text_document) = test_utils::init_lsp_server(directory).await;
 
         // noir_text_document is always `src/main.nr` in the workspace directory, so let's go to the workspace dir
@@ -669,7 +800,7 @@ mod hover_tests {
             panic!("Expected hover contents to be Markup");
         };
 
-        assert_eq!(markup.value, expected_text);
+        markup.value
     }
 
     #[test]
@@ -755,7 +886,7 @@ mod hover_tests {
             "two/src/lib.nr",
             Position { line: 3, character: 4 },
             r#"    one
-    fn function_one<A, B>()"#,
+    pub fn function_one<A, B>()"#,
         )
         .await;
     }
@@ -767,7 +898,7 @@ mod hover_tests {
             "two/src/lib.nr",
             Position { line: 2, character: 7 },
             r#"    two
-    fn function_two()"#,
+    pub fn function_two()"#,
         )
         .await;
     }
@@ -779,6 +910,7 @@ mod hover_tests {
             "two/src/lib.nr",
             Position { line: 20, character: 6 },
             r#"    one::subone::SubOneStruct
+    impl SubOneStruct
     fn foo(self, x: i32, y: i32) -> Field"#,
         )
         .await;
@@ -888,7 +1020,7 @@ mod hover_tests {
         assert_hover(
             "workspace",
             "two/src/lib.nr",
-            Position { line: 43, character: 4 },
+            Position { line: 42, character: 4 },
             r#"    two
     mod other"#,
         )
@@ -900,7 +1032,7 @@ mod hover_tests {
         assert_hover(
             "workspace",
             "two/src/lib.nr",
-            Position { line: 44, character: 11 },
+            Position { line: 43, character: 11 },
             r#"    two
     mod other"#,
         )
@@ -951,8 +1083,32 @@ mod hover_tests {
             "workspace",
             "two/src/lib.nr",
             Position { line: 54, character: 2 },
-            "    two\n    fn attr(_: FunctionDefinition) -> Quoted",
+            "    two\n    comptime fn attr(_: FunctionDefinition) -> Quoted",
         )
         .await;
     }
+
+    #[test]
+    async fn hover_on_generic_struct_function() {
+        let hover_text =
+            get_hover_text("workspace", "two/src/lib.nr", Position { line: 70, character: 11 })
+                .await;
+        assert!(hover_text.starts_with(
+            "    two::Foo
+    impl<U> Foo<U>
+    fn new() -> Foo<U>"
+        ));
+    }
+
+    #[test]
+    async fn hover_on_trait_impl_function_call() {
+        let hover_text =
+            get_hover_text("workspace", "two/src/lib.nr", Position { line: 83, character: 16 })
+                .await;
+        assert!(hover_text.starts_with(
+            "    two
+    impl<A> Bar<A, i32> for Foo<A>
+    pub fn bar_stuff(self)"
+        ));
+    }
 }
diff --git a/tooling/lsp/src/requests/inlay_hint.rs b/tooling/lsp/src/requests/inlay_hint.rs
index 2eef4f6e262..c6415acb545 100644
--- a/tooling/lsp/src/requests/inlay_hint.rs
+++ b/tooling/lsp/src/requests/inlay_hint.rs
@@ -15,10 +15,9 @@ use noirc_frontend::{
         UnresolvedTypeData, Visitor,
     },
     hir_def::stmt::HirPattern,
-    macros_api::NodeInterner,
-    node_interner::ReferenceId,
+    node_interner::{NodeInterner, ReferenceId},
     parser::{Item, ParsedSubModule},
-    Type, TypeBinding, TypeVariable, TypeVariableKind,
+    Kind, Type, TypeBinding, TypeVariable,
 };
 
 use crate::{utils, LspState};
@@ -98,8 +97,8 @@ impl<'a> InlayHintCollector<'a> {
                     ReferenceId::StructMember(struct_id, field_index) => {
                         let struct_type = self.interner.get_struct(struct_id);
                         let struct_type = struct_type.borrow();
-                        let (_field_name, field_type) = struct_type.field_at(field_index);
-                        self.push_type_hint(lsp_location, field_type, false);
+                        let field = struct_type.field_at(field_index);
+                        self.push_type_hint(lsp_location, &field.typ, false);
                     }
                     ReferenceId::Module(_)
                     | ReferenceId::Struct(_)
@@ -460,23 +459,19 @@ fn push_type_parts(typ: &Type, parts: &mut Vec<InlayHintLabelPart>, files: &File
             parts.push(string_part("&mut "));
             push_type_parts(typ, parts, files);
         }
-        Type::TypeVariable(var, TypeVariableKind::Normal) => {
-            push_type_variable_parts(var, parts, files);
-        }
-        Type::TypeVariable(binding, TypeVariableKind::Integer) => {
-            if let TypeBinding::Unbound(_) = &*binding.borrow() {
-                push_type_parts(&Type::default_int_type(), parts, files);
-            } else {
-                push_type_variable_parts(binding, parts, files);
-            }
-        }
-        Type::TypeVariable(binding, TypeVariableKind::IntegerOrField) => {
-            if let TypeBinding::Unbound(_) = &*binding.borrow() {
-                parts.push(string_part("Field"));
+        Type::TypeVariable(binding) => {
+            if let TypeBinding::Unbound(_, kind) = &*binding.borrow() {
+                match kind {
+                    Kind::Any | Kind::Normal => push_type_variable_parts(binding, parts, files),
+                    Kind::Integer => push_type_parts(&Type::default_int_type(), parts, files),
+                    Kind::IntegerOrField => parts.push(string_part("Field")),
+                    Kind::Numeric(ref typ) => push_type_parts(typ, parts, files),
+                }
             } else {
                 push_type_variable_parts(binding, parts, files);
             }
         }
+        Type::CheckedCast { to, .. } => push_type_parts(to, parts, files),
 
         Type::FieldElement
         | Type::Integer(..)
diff --git a/tooling/lsp/src/requests/mod.rs b/tooling/lsp/src/requests/mod.rs
index 576d026081d..22bdda8d7d7 100644
--- a/tooling/lsp/src/requests/mod.rs
+++ b/tooling/lsp/src/requests/mod.rs
@@ -18,7 +18,8 @@ use nargo_fmt::Config;
 
 use noirc_frontend::graph::CrateId;
 use noirc_frontend::hir::def_map::CrateDefMap;
-use noirc_frontend::{graph::Dependency, macros_api::NodeInterner};
+use noirc_frontend::usage_tracker::UsageTracker;
+use noirc_frontend::{graph::Dependency, node_interner::NodeInterner};
 use serde::{Deserialize, Serialize};
 
 use crate::{
@@ -44,7 +45,6 @@ mod goto_declaration;
 mod goto_definition;
 mod hover;
 mod inlay_hint;
-mod profile_run;
 mod references;
 mod rename;
 mod signature_help;
@@ -56,8 +56,7 @@ pub(crate) use {
     code_lens_request::on_code_lens_request, completion::on_completion_request,
     document_symbol::on_document_symbol_request, goto_declaration::on_goto_declaration_request,
     goto_definition::on_goto_definition_request, goto_definition::on_goto_type_definition_request,
-    hover::on_hover_request, inlay_hint::on_inlay_hint_request,
-    profile_run::on_profile_run_request, references::on_references_request,
+    hover::on_hover_request, inlay_hint::on_inlay_hint_request, references::on_references_request,
     rename::on_prepare_rename_request, rename::on_rename_request,
     signature_help::on_signature_help_request, test_run::on_test_run_request,
     tests::on_tests_request,
@@ -378,7 +377,7 @@ fn character_to_line_offset(line: &str, character: u32) -> Result<usize, Error>
     }
 }
 
-fn to_lsp_location<'a, F>(
+pub(crate) fn to_lsp_location<'a, F>(
     files: &'a F,
     file_id: F::FileId,
     definition_span: noirc_errors::Span,
@@ -416,6 +415,7 @@ pub(crate) struct ProcessRequestCallbackArgs<'a> {
     crate_name: String,
     dependencies: &'a Vec<Dependency>,
     def_maps: &'a BTreeMap<CrateId, CrateDefMap>,
+    usage_tracker: &'a UsageTracker,
 }
 
 pub(crate) fn process_request<F, T>(
@@ -452,6 +452,7 @@ where
     let file_manager = &workspace_cache_data.file_manager;
     let interner = &package_cache_data.node_interner;
     let def_maps = &package_cache_data.def_maps;
+    let usage_tracker = &package_cache_data.usage_tracker;
     let crate_graph = &package_cache_data.crate_graph;
     let crate_id = package_cache_data.crate_id;
 
@@ -472,6 +473,7 @@ where
         crate_name: package.name.to_string(),
         dependencies: &crate_graph[crate_id].dependencies,
         def_maps,
+        usage_tracker,
     }))
 }
 
@@ -506,14 +508,17 @@ where
 
     let interner;
     let def_maps;
+    let usage_tracker;
     if let Some(package_cache) = state.package_cache.get(&package.root_dir) {
         interner = &package_cache.node_interner;
         def_maps = &package_cache.def_maps;
+        usage_tracker = &package_cache.usage_tracker;
     } else {
         // We ignore the warnings and errors produced by compilation while resolving the definition
         let _ = noirc_driver::check_crate(&mut context, crate_id, &Default::default());
         interner = &context.def_interner;
         def_maps = &context.def_maps;
+        usage_tracker = &context.usage_tracker;
     }
 
     let files = workspace_file_manager.as_file_map();
@@ -533,6 +538,7 @@ where
         crate_name: package.name.to_string(),
         dependencies: &context.crate_graph[crate_id].dependencies,
         def_maps,
+        usage_tracker,
     }))
 }
 
diff --git a/tooling/lsp/src/requests/profile_run.rs b/tooling/lsp/src/requests/profile_run.rs
deleted file mode 100644
index a7362300adc..00000000000
--- a/tooling/lsp/src/requests/profile_run.rs
+++ /dev/null
@@ -1,122 +0,0 @@
-use std::{
-    collections::{BTreeMap, HashMap},
-    future::{self, Future},
-};
-
-use crate::insert_all_files_for_workspace_into_file_manager;
-use acvm::acir::circuit::ExpressionWidth;
-use async_lsp::{ErrorCode, ResponseError};
-use nargo::ops::report_errors;
-use nargo_toml::{find_package_manifest, resolve_workspace_from_toml, PackageSelection};
-use noirc_artifacts::debug::DebugArtifact;
-use noirc_driver::{CompileOptions, DebugFile, NOIR_ARTIFACT_VERSION_STRING};
-use noirc_errors::{debug_info::OpCodesCount, Location};
-
-use crate::{
-    parse_diff,
-    types::{NargoProfileRunParams, NargoProfileRunResult},
-    LspState,
-};
-use fm::FileId;
-
-pub(crate) fn on_profile_run_request(
-    state: &mut LspState,
-    params: NargoProfileRunParams,
-) -> impl Future<Output = Result<NargoProfileRunResult, ResponseError>> {
-    future::ready(on_profile_run_request_inner(state, params))
-}
-
-fn on_profile_run_request_inner(
-    state: &mut LspState,
-    params: NargoProfileRunParams,
-) -> Result<NargoProfileRunResult, ResponseError> {
-    let root_path = state.root_path.as_deref().ok_or_else(|| {
-        ResponseError::new(ErrorCode::REQUEST_FAILED, "Could not find project root")
-    })?;
-
-    let toml_path = find_package_manifest(root_path, root_path).map_err(|err| {
-        // If we cannot find a manifest, we can't run the test
-        ResponseError::new(ErrorCode::REQUEST_FAILED, err)
-    })?;
-
-    let crate_name = params.package;
-
-    let workspace = resolve_workspace_from_toml(
-        &toml_path,
-        PackageSelection::DefaultOrAll,
-        Some(NOIR_ARTIFACT_VERSION_STRING.to_string()),
-    )
-    .map_err(|err| {
-        // If we found a manifest, but the workspace is invalid, we raise an error about it
-        ResponseError::new(ErrorCode::REQUEST_FAILED, err)
-    })?;
-
-    let mut workspace_file_manager = workspace.new_file_manager();
-    insert_all_files_for_workspace_into_file_manager(
-        state,
-        &workspace,
-        &mut workspace_file_manager,
-    );
-    let parsed_files = parse_diff(&workspace_file_manager, state);
-
-    // Since we filtered on crate name, this should be the only item in the iterator
-    match workspace.into_iter().next() {
-        Some(_package) => {
-            let expression_width = ExpressionWidth::Bounded { width: 3 };
-
-            let compiled_workspace = nargo::ops::compile_workspace(
-                &workspace_file_manager,
-                &parsed_files,
-                &workspace,
-                &CompileOptions::default(),
-            );
-
-            let (compiled_programs, compiled_contracts) = report_errors(
-                compiled_workspace,
-                &workspace_file_manager,
-                CompileOptions::default().deny_warnings,
-                CompileOptions::default().silence_warnings,
-            )
-            .map_err(|err| ResponseError::new(ErrorCode::REQUEST_FAILED, err))?;
-
-            let mut opcodes_counts: HashMap<Location, OpCodesCount> = HashMap::new();
-            let mut file_map: BTreeMap<FileId, DebugFile> = BTreeMap::new();
-            for compiled_program in compiled_programs {
-                let compiled_program =
-                    nargo::ops::transform_program(compiled_program, expression_width);
-
-                for function_debug in compiled_program.debug.iter() {
-                    let span_opcodes = function_debug.count_span_opcodes();
-                    opcodes_counts.extend(span_opcodes);
-                }
-                let debug_artifact: DebugArtifact = compiled_program.into();
-                file_map.extend(debug_artifact.file_map);
-            }
-
-            for compiled_contract in compiled_contracts {
-                let compiled_contract =
-                    nargo::ops::transform_contract(compiled_contract, expression_width);
-
-                let function_debug_info = compiled_contract
-                    .functions
-                    .iter()
-                    .flat_map(|func| &func.debug)
-                    .collect::<Vec<_>>();
-                for contract_function_debug in function_debug_info {
-                    let span_opcodes = contract_function_debug.count_span_opcodes();
-                    opcodes_counts.extend(span_opcodes);
-                }
-                let debug_artifact: DebugArtifact = compiled_contract.into();
-                file_map.extend(debug_artifact.file_map);
-            }
-
-            let result = NargoProfileRunResult { file_map, opcodes_counts };
-
-            Ok(result)
-        }
-        None => Err(ResponseError::new(
-            ErrorCode::REQUEST_FAILED,
-            format!("Could not locate package named: {crate_name}"),
-        )),
-    }
-}
diff --git a/tooling/lsp/src/requests/signature_help.rs b/tooling/lsp/src/requests/signature_help.rs
index b075fea1d1e..c0d40656c19 100644
--- a/tooling/lsp/src/requests/signature_help.rs
+++ b/tooling/lsp/src/requests/signature_help.rs
@@ -12,8 +12,7 @@ use noirc_frontend::{
         MethodCallExpression, Statement, Visitor,
     },
     hir_def::{function::FuncMeta, stmt::HirPattern},
-    macros_api::NodeInterner,
-    node_interner::ReferenceId,
+    node_interner::{NodeInterner, ReferenceId},
     parser::Item,
     ParsedModule, Type,
 };
diff --git a/tooling/lsp/src/requests/test_run.rs b/tooling/lsp/src/requests/test_run.rs
index 50c699bb6a6..72ae6695b82 100644
--- a/tooling/lsp/src/requests/test_run.rs
+++ b/tooling/lsp/src/requests/test_run.rs
@@ -2,7 +2,10 @@ use std::future::{self, Future};
 
 use crate::insert_all_files_for_workspace_into_file_manager;
 use async_lsp::{ErrorCode, ResponseError};
-use nargo::ops::{run_test, TestStatus};
+use nargo::{
+    ops::{run_test, TestStatus},
+    PrintOutput,
+};
 use nargo_toml::{find_package_manifest, resolve_workspace_from_toml, PackageSelection};
 use noirc_driver::{check_crate, CompileOptions, NOIR_ARTIFACT_VERSION_STRING};
 use noirc_frontend::hir::FunctionNameMatch;
@@ -84,7 +87,7 @@ fn on_test_run_request_inner(
                 &state.solver,
                 &mut context,
                 &test_function,
-                true,
+                PrintOutput::Stdout,
                 None,
                 Some(workspace.root_dir.clone()),
                 Some(package.name.to_string()),
@@ -101,6 +104,11 @@ fn on_test_run_request_inner(
                     result: "fail".to_string(),
                     message: Some(message),
                 },
+                TestStatus::Skipped => NargoTestRunResult {
+                    id: params.id.clone(),
+                    result: "skipped".to_string(),
+                    message: None,
+                },
                 TestStatus::CompileError(diag) => NargoTestRunResult {
                     id: params.id.clone(),
                     result: "error".to_string(),
diff --git a/tooling/lsp/src/solver.rs b/tooling/lsp/src/solver.rs
index 9d1185e3a79..a36e30a944e 100644
--- a/tooling/lsp/src/solver.rs
+++ b/tooling/lsp/src/solver.rs
@@ -6,32 +6,6 @@ use acvm::BlackBoxFunctionSolver;
 pub(super) struct WrapperSolver(pub(super) Box<dyn BlackBoxFunctionSolver<acvm::FieldElement>>);
 
 impl BlackBoxFunctionSolver<acvm::FieldElement> for WrapperSolver {
-    fn schnorr_verify(
-        &self,
-        public_key_x: &acvm::FieldElement,
-        public_key_y: &acvm::FieldElement,
-        signature: &[u8; 64],
-        message: &[u8],
-    ) -> Result<bool, acvm::BlackBoxResolutionError> {
-        self.0.schnorr_verify(public_key_x, public_key_y, signature, message)
-    }
-
-    fn pedersen_commitment(
-        &self,
-        inputs: &[acvm::FieldElement],
-        domain_separator: u32,
-    ) -> Result<(acvm::FieldElement, acvm::FieldElement), acvm::BlackBoxResolutionError> {
-        self.0.pedersen_commitment(inputs, domain_separator)
-    }
-
-    fn pedersen_hash(
-        &self,
-        inputs: &[acvm::FieldElement],
-        domain_separator: u32,
-    ) -> Result<acvm::FieldElement, acvm::BlackBoxResolutionError> {
-        self.0.pedersen_hash(inputs, domain_separator)
-    }
-
     fn multi_scalar_mul(
         &self,
         points: &[acvm::FieldElement],
diff --git a/tooling/lsp/src/tests.rs b/tooling/lsp/src/tests.rs
new file mode 100644
index 00000000000..7f2d48cd23f
--- /dev/null
+++ b/tooling/lsp/src/tests.rs
@@ -0,0 +1,33 @@
+#![cfg(test)]
+
+use lsp_types::TextEdit;
+
+pub(crate) fn apply_text_edit(src: &str, text_edit: &TextEdit) -> String {
+    let mut lines: Vec<_> = src.lines().collect();
+    assert_eq!(text_edit.range.start.line, text_edit.range.end.line);
+
+    let mut line = lines[text_edit.range.start.line as usize].to_string();
+    line.replace_range(
+        text_edit.range.start.character as usize..text_edit.range.end.character as usize,
+        &text_edit.new_text,
+    );
+    lines[text_edit.range.start.line as usize] = &line;
+    lines.join("\n")
+}
+
+pub(crate) fn apply_text_edits(src: &str, text_edits: &[TextEdit]) -> String {
+    let mut text = src.to_string();
+
+    // Text edits must be applied from last to first, otherwise if we apply a text edit
+    // that comes before another one, that other one becomes invalid (it will edit the wrong
+    // piece of code).
+    let mut text_edits = text_edits.to_vec();
+    text_edits.sort_by_key(|edit| (edit.range.start.line, edit.range.start.character));
+    text_edits.reverse();
+
+    for text_edit in text_edits {
+        text = apply_text_edit(&text, &text_edit);
+    }
+
+    text
+}
diff --git a/tooling/lsp/src/trait_impl_method_stub_generator.rs b/tooling/lsp/src/trait_impl_method_stub_generator.rs
index 56d2e5e1ea1..2ae0d526f3e 100644
--- a/tooling/lsp/src/trait_impl_method_stub_generator.rs
+++ b/tooling/lsp/src/trait_impl_method_stub_generator.rs
@@ -3,14 +3,14 @@ use std::collections::BTreeMap;
 use noirc_frontend::{
     ast::NoirTraitImpl,
     graph::CrateId,
+    hir::def_map::ModuleDefId,
     hir::{
         def_map::{CrateDefMap, ModuleId},
         type_check::generics::TraitGenerics,
     },
     hir_def::{function::FuncMeta, stmt::HirPattern, traits::Trait},
-    macros_api::{ModuleDefId, NodeInterner},
-    node_interner::{FunctionModifiers, ReferenceId},
-    Kind, ResolvedGeneric, Type, TypeVariableKind,
+    node_interner::{FunctionModifiers, NodeInterner, ReferenceId},
+    Kind, ResolvedGeneric, Type,
 };
 
 use crate::modules::relative_module_id_path;
@@ -98,9 +98,9 @@ impl<'a> TraitImplMethodStubGenerator<'a> {
                 }
                 self.append_type(&constraint.typ);
                 self.string.push_str(": ");
-                let trait_ = self.interner.get_trait(constraint.trait_id);
+                let trait_ = self.interner.get_trait(constraint.trait_bound.trait_id);
                 self.string.push_str(&trait_.name.0.contents);
-                self.append_trait_generics(&constraint.trait_generics);
+                self.append_trait_generics(&constraint.trait_bound.trait_generics);
             }
         }
 
@@ -290,7 +290,7 @@ impl<'a> TraitImplMethodStubGenerator<'a> {
                 self.string.push_str(&trait_.name.0.contents);
                 self.append_trait_generics(trait_generics);
             }
-            Type::TypeVariable(typevar, _) => {
+            Type::TypeVariable(typevar) => {
                 if typevar.id() == self.trait_.self_type_typevar.id() {
                     self.string.push_str("Self");
                     return;
@@ -323,8 +323,8 @@ impl<'a> TraitImplMethodStubGenerator<'a> {
 
                 self.string.push_str("error");
             }
-            Type::NamedGeneric(typevar, _name, _kind) => {
-                self.append_type(&Type::TypeVariable(typevar.clone(), TypeVariableKind::Normal));
+            Type::NamedGeneric(typevar, _name) => {
+                self.append_type(&Type::TypeVariable(typevar.clone()));
             }
             Type::Function(args, ret, env, unconstrained) => {
                 if *unconstrained {
@@ -368,6 +368,7 @@ impl<'a> TraitImplMethodStubGenerator<'a> {
                 self.string.push(' ');
                 self.append_type(right);
             }
+            Type::CheckedCast { to, .. } => self.append_type(to),
             Type::Constant(..)
             | Type::Integer(_, _)
             | Type::Bool
@@ -437,9 +438,11 @@ impl<'a> TraitImplMethodStubGenerator<'a> {
     }
 
     fn append_resolved_generic(&mut self, generic: &ResolvedGeneric) {
-        match &generic.kind {
-            Kind::Normal => self.string.push_str(&generic.name),
-            Kind::Numeric(typ) => {
+        match &generic.kind() {
+            Kind::Any | Kind::Normal | Kind::Integer | Kind::IntegerOrField => {
+                self.string.push_str(&generic.name);
+            }
+            Kind::Numeric(ref typ) => {
                 self.string.push_str("let ");
                 self.string.push_str(&generic.name);
                 self.string.push_str(": ");
diff --git a/tooling/lsp/src/types.rs b/tooling/lsp/src/types.rs
index 043c50a87fd..b49377787e8 100644
--- a/tooling/lsp/src/types.rs
+++ b/tooling/lsp/src/types.rs
@@ -1,15 +1,10 @@
-use fm::FileId;
 use lsp_types::{
     CodeActionOptions, CompletionOptions, DeclarationCapability, DefinitionOptions,
     DocumentSymbolOptions, HoverOptions, InlayHintOptions, OneOf, ReferencesOptions, RenameOptions,
     SignatureHelpOptions, TypeDefinitionProviderCapability,
 };
-use noirc_driver::DebugFile;
-use noirc_errors::{debug_info::OpCodesCount, Location};
 use noirc_frontend::graph::CrateName;
 use serde::{Deserialize, Serialize};
-use serde_with::serde_as;
-use std::collections::{BTreeMap, HashMap};
 
 // Re-providing lsp_types that we don't need to override
 pub(crate) use lsp_types::{
@@ -23,8 +18,8 @@ pub(crate) mod request {
     use lsp_types::{request::Request, InitializeParams};
 
     use super::{
-        InitializeResult, NargoProfileRunParams, NargoProfileRunResult, NargoTestRunParams,
-        NargoTestRunResult, NargoTestsParams, NargoTestsResult,
+        InitializeResult, NargoTestRunParams, NargoTestRunResult, NargoTestsParams,
+        NargoTestsResult,
     };
 
     // Re-providing lsp_types that we don't need to override
@@ -56,14 +51,6 @@ pub(crate) mod request {
         type Result = NargoTestsResult;
         const METHOD: &'static str = "nargo/tests";
     }
-
-    #[derive(Debug)]
-    pub(crate) struct NargoProfileRun;
-    impl Request for NargoProfileRun {
-        type Params = NargoProfileRunParams;
-        type Result = NargoProfileRunResult;
-        const METHOD: &'static str = "nargo/profile/run";
-    }
 }
 
 pub(crate) mod notification {
@@ -253,17 +240,6 @@ pub(crate) struct NargoTestRunResult {
     pub(crate) result: String,
     pub(crate) message: Option<String>,
 }
-#[derive(Debug, Serialize, Deserialize)]
-pub(crate) struct NargoProfileRunParams {
-    pub(crate) package: CrateName,
-}
-#[serde_as]
-#[derive(Debug, Serialize, Deserialize)]
-pub(crate) struct NargoProfileRunResult {
-    pub(crate) file_map: BTreeMap<FileId, DebugFile>,
-    #[serde_as(as = "Vec<(_, _)>")]
-    pub(crate) opcodes_counts: HashMap<Location, OpCodesCount>,
-}
 
 pub(crate) type CodeLensResult = Option<Vec<CodeLens>>;
 pub(crate) type GotoDefinitionResult = Option<lsp_types::GotoDefinitionResponse>;
diff --git a/tooling/lsp/src/use_segment_positions.rs b/tooling/lsp/src/use_segment_positions.rs
new file mode 100644
index 00000000000..246ff653245
--- /dev/null
+++ b/tooling/lsp/src/use_segment_positions.rs
@@ -0,0 +1,336 @@
+use std::collections::HashMap;
+
+use fm::{FileId, FileMap};
+use lsp_types::{Position, Range, TextEdit};
+use noirc_errors::Span;
+use noirc_frontend::ast::{PathKind, UseTree, UseTreeKind};
+
+use crate::requests::to_lsp_location;
+
+/// The position of a segment in a `use` statement.
+/// We use this to determine how an auto-import should be inserted.
+#[derive(Debug, Default, Copy, Clone)]
+pub(crate) enum UseSegmentPosition {
+    /// The segment either doesn't exist in the source code or there are multiple segments.
+    /// In this case auto-import will add a new use statement.
+    #[default]
+    NoneOrMultiple,
+    /// The segment is the last one in the `use` statement (or nested use statement):
+    ///
+    /// use foo::bar;
+    ///          ^^^
+    ///
+    /// Auto-import will transform it to this:
+    ///
+    /// use foo::bar::{self, baz};
+    Last { span: Span },
+    /// The segment happens before another simple (ident) segment:
+    ///
+    /// use foo::bar::qux;
+    ///          ^^^
+    ///
+    /// Auto-import will transform it to this:
+    ///
+    /// use foo::bar::{qux, baz};
+    BeforeSegment { segment_span_until_end: Span },
+    /// The segment happens before a list:
+    ///
+    /// use foo::bar::{qux, another};
+    ///
+    /// Auto-import will transform it to this:
+    ///
+    /// use foo::bar::{qux, another, baz};
+    BeforeList { first_entry_span: Span, list_is_empty: bool },
+}
+
+/// Remembers where each segment in a `use` statement is located.
+/// The key is the full segment, so for `use foo::bar::baz` we'll have three
+/// segments: `foo`, `foo::bar` and `foo::bar::baz`, where the span is just
+/// for the last identifier (`foo`, `bar` and `baz` in the previous example).
+#[derive(Default)]
+pub(crate) struct UseSegmentPositions {
+    use_segment_positions: HashMap<String, UseSegmentPosition>,
+}
+
+impl UseSegmentPositions {
+    pub(crate) fn add(&mut self, use_tree: &UseTree) {
+        self.gather_use_tree_segments(use_tree, String::new());
+    }
+
+    /// Given a full path like `foo::bar::baz`, returns the first non-"NoneOrMultiple" segment position
+    /// trying each successive parent, together with the name after the parent.
+    ///
+    /// For example, first we'll check if `foo::bar` has a single position. If not, we'll try with `foo`.
+    pub(crate) fn get(&self, full_path: &str) -> (UseSegmentPosition, String) {
+        // Build a parent path to know in which full segment we need to add this import
+        let mut segments: Vec<_> = full_path.split("::").collect();
+        let mut name = segments.pop().unwrap().to_string();
+        let mut parent_path = segments.join("::");
+
+        loop {
+            let use_segment_position =
+                self.use_segment_positions.get(&parent_path).cloned().unwrap_or_default();
+
+            if let UseSegmentPosition::NoneOrMultiple = use_segment_position {
+                if let Some(next_name) = segments.pop() {
+                    name = format!("{next_name}::{name}");
+                    parent_path = segments.join("::");
+                } else {
+                    return (UseSegmentPosition::NoneOrMultiple, String::new());
+                }
+            } else {
+                return (use_segment_position, name);
+            }
+        }
+    }
+
+    fn gather_use_tree_segments(&mut self, use_tree: &UseTree, mut prefix: String) {
+        let kind_string = match use_tree.prefix.kind {
+            PathKind::Crate => Some("crate".to_string()),
+            PathKind::Super => Some("super".to_string()),
+            PathKind::Dep | PathKind::Plain => None,
+        };
+        if let Some(kind_string) = kind_string {
+            if let Some(segment) = use_tree.prefix.segments.first() {
+                self.insert_use_segment_position(
+                    kind_string,
+                    UseSegmentPosition::BeforeSegment {
+                        segment_span_until_end: Span::from(
+                            segment.ident.span().start()..use_tree.span.end() - 1,
+                        ),
+                    },
+                );
+            } else {
+                self.insert_use_segment_position_before_use_tree_kind(use_tree, kind_string);
+            }
+        }
+
+        let prefix_segments_len = use_tree.prefix.segments.len();
+        for (index, segment) in use_tree.prefix.segments.iter().enumerate() {
+            let ident = &segment.ident;
+            if !prefix.is_empty() {
+                prefix.push_str("::");
+            };
+            prefix.push_str(&ident.0.contents);
+
+            if index < prefix_segments_len - 1 {
+                self.insert_use_segment_position(
+                    prefix.clone(),
+                    UseSegmentPosition::BeforeSegment {
+                        segment_span_until_end: Span::from(
+                            use_tree.prefix.segments[index + 1].ident.span().start()
+                                ..use_tree.span.end() - 1,
+                        ),
+                    },
+                );
+            } else {
+                self.insert_use_segment_position_before_use_tree_kind(use_tree, prefix.clone());
+            }
+        }
+
+        match &use_tree.kind {
+            UseTreeKind::Path(ident, alias) => {
+                if !prefix.is_empty() {
+                    prefix.push_str("::");
+                }
+                prefix.push_str(&ident.0.contents);
+
+                if alias.is_none() {
+                    self.insert_use_segment_position(
+                        prefix,
+                        UseSegmentPosition::Last { span: ident.span() },
+                    );
+                } else {
+                    self.insert_use_segment_position(prefix, UseSegmentPosition::NoneOrMultiple);
+                }
+            }
+            UseTreeKind::List(use_trees) => {
+                for use_tree in use_trees {
+                    self.gather_use_tree_segments(use_tree, prefix.clone());
+                }
+            }
+        }
+    }
+
+    fn insert_use_segment_position_before_use_tree_kind(
+        &mut self,
+        use_tree: &UseTree,
+        prefix: String,
+    ) {
+        match &use_tree.kind {
+            UseTreeKind::Path(ident, _alias) => {
+                self.insert_use_segment_position(
+                    prefix,
+                    UseSegmentPosition::BeforeSegment {
+                        segment_span_until_end: Span::from(
+                            ident.span().start()..use_tree.span.end() - 1,
+                        ),
+                    },
+                );
+            }
+            UseTreeKind::List(use_trees) => {
+                if let Some(first_use_tree) = use_trees.first() {
+                    self.insert_use_segment_position(
+                        prefix,
+                        UseSegmentPosition::BeforeList {
+                            first_entry_span: first_use_tree.prefix.span(),
+                            list_is_empty: false,
+                        },
+                    );
+                } else {
+                    self.insert_use_segment_position(
+                        prefix,
+                        UseSegmentPosition::BeforeList {
+                            first_entry_span: Span::from(
+                                use_tree.span.end() - 1..use_tree.span.end() - 1,
+                            ),
+                            list_is_empty: true,
+                        },
+                    );
+                }
+            }
+        }
+    }
+
+    fn insert_use_segment_position(&mut self, segment: String, position: UseSegmentPosition) {
+        if self.use_segment_positions.get(&segment).is_none() {
+            self.use_segment_positions.insert(segment, position);
+        } else {
+            self.use_segment_positions.insert(segment, UseSegmentPosition::NoneOrMultiple);
+        }
+    }
+}
+
+pub(crate) struct UseCompletionItemAdditionTextEditsRequest<'a> {
+    /// The full path of the use statement to insert
+    pub(crate) full_path: &'a str,
+    pub(crate) files: &'a FileMap,
+    pub(crate) file: FileId,
+    /// All of the current source lines
+    pub(crate) lines: &'a Vec<&'a str>,
+    /// How many nested `mod` we are in deep
+    pub(crate) nesting: usize,
+    /// The line where an auto_import must be inserted
+    pub(crate) auto_import_line: usize,
+}
+
+/// Returns the text edits needed to add an auto-import for a given full path.
+pub(crate) fn use_completion_item_additional_text_edits(
+    request: UseCompletionItemAdditionTextEditsRequest,
+    positions: &UseSegmentPositions,
+) -> Vec<TextEdit> {
+    let (use_segment_position, name) = positions.get(request.full_path);
+    match use_segment_position {
+        UseSegmentPosition::NoneOrMultiple => {
+            // The parent path either isn't in any use statement, or it exists in multiple
+            // use statements. In either case we'll add a new use statement.
+
+            new_use_completion_item_additional_text_edits(request)
+        }
+        UseSegmentPosition::Last { span } => {
+            // We have
+            //
+            // use foo::bar;
+            //          ^^^ -> span
+            //
+            // and we want to transform it to:
+            //
+            // use foo::bar::{self, baz};
+            //             ^^^^^^^^^^^^^
+            //
+            // So we need one text edit:
+            // 1. insert "::{self, baz}" right after the span
+            if let Some(lsp_location) = to_lsp_location(request.files, request.file, span) {
+                let range = lsp_location.range;
+                vec![TextEdit {
+                    new_text: format!("::{{self, {}}}", name),
+                    range: Range { start: range.end, end: range.end },
+                }]
+            } else {
+                new_use_completion_item_additional_text_edits(request)
+            }
+        }
+        UseSegmentPosition::BeforeSegment { segment_span_until_end } => {
+            // Go past the end
+            let segment_span_until_end =
+                Span::from(segment_span_until_end.start()..segment_span_until_end.end() + 1);
+
+            // We have
+            //
+            // use foo::bar::{one, two};
+            //          ^^^^^^^^^^^^^^^ -> segment_span_until_end
+            //
+            // and we want to transform it to:
+            //
+            // use foo::{bar::{one, two}, baz};
+            //          ^               ^^^^^^
+            //
+            // So we need two text edits:
+            // 1. insert "{" right before the segment span
+            // 2. insert ", baz}" right after the segment span
+            if let Some(lsp_location) =
+                to_lsp_location(request.files, request.file, segment_span_until_end)
+            {
+                let range = lsp_location.range;
+                vec![
+                    TextEdit {
+                        new_text: "{".to_string(),
+                        range: Range { start: range.start, end: range.start },
+                    },
+                    TextEdit {
+                        new_text: format!(", {}}}", name),
+                        range: Range { start: range.end, end: range.end },
+                    },
+                ]
+            } else {
+                new_use_completion_item_additional_text_edits(request)
+            }
+        }
+        UseSegmentPosition::BeforeList { first_entry_span, list_is_empty } => {
+            // We have
+            //
+            // use foo::bar::{one, two};
+            //                ^^^ -> first_entry_span
+            //
+            // and we want to transform it to:
+            //
+            // use foo::bar::{baz, one, two};
+            //                ^^^^
+            //
+            // So we need one text edit:
+            // 1. insert "baz, " right before the first entry span
+            if let Some(lsp_location) =
+                to_lsp_location(request.files, request.file, first_entry_span)
+            {
+                let range = lsp_location.range;
+                vec![TextEdit {
+                    new_text: if list_is_empty { name } else { format!("{}, ", name) },
+                    range: Range { start: range.start, end: range.start },
+                }]
+            } else {
+                new_use_completion_item_additional_text_edits(request)
+            }
+        }
+    }
+}
+
+fn new_use_completion_item_additional_text_edits(
+    request: UseCompletionItemAdditionTextEditsRequest,
+) -> Vec<TextEdit> {
+    let line = request.auto_import_line as u32;
+    let character = 0;
+    let indent = " ".repeat(request.nesting * 4);
+    let mut newlines = "\n";
+
+    // If the line we are inserting into is not an empty line, insert an extra line to make some room
+    if let Some(line_text) = request.lines.get(line as usize) {
+        if !line_text.trim().is_empty() {
+            newlines = "\n\n";
+        }
+    }
+
+    vec![TextEdit {
+        range: Range { start: Position { line, character }, end: Position { line, character } },
+        new_text: format!("{}use {};{}", indent, request.full_path, newlines),
+    }]
+}
diff --git a/tooling/lsp/src/visibility.rs b/tooling/lsp/src/visibility.rs
index d6e26f7bc48..6724a0ba505 100644
--- a/tooling/lsp/src/visibility.rs
+++ b/tooling/lsp/src/visibility.rs
@@ -4,22 +4,52 @@ use noirc_frontend::{
     ast::ItemVisibility,
     graph::CrateId,
     hir::{
-        def_map::{CrateDefMap, ModuleId},
-        resolution::import::can_reference_module_id,
+        def_map::{CrateDefMap, ModuleDefId, ModuleId},
+        resolution::visibility::item_in_module_is_visible,
     },
+    node_interner::NodeInterner,
 };
 
-pub(super) fn is_visible(
-    target_module_id: ModuleId,
+use crate::modules::get_parent_module;
+
+/// Returns true if the given ModuleDefId is visible from the current module, given its visibility.
+/// This will in turn check if the ModuleDefId parent modules are visible from the current module.
+/// If `defining_module` is Some, it will be considered as the parent of the item to check
+/// (this is the case when the item is re-exported with `pub use` or similar).
+pub(super) fn module_def_id_is_visible(
+    module_def_id: ModuleDefId,
     current_module_id: ModuleId,
-    visibility: ItemVisibility,
+    mut visibility: ItemVisibility,
+    mut defining_module: Option<ModuleId>,
+    interner: &NodeInterner,
     def_maps: &BTreeMap<CrateId, CrateDefMap>,
 ) -> bool {
-    can_reference_module_id(
-        def_maps,
-        current_module_id.krate,
-        current_module_id.local_id,
-        target_module_id,
-        visibility,
-    )
+    // First find out which module we need to check.
+    // If a module is trying to be referenced, it's that module. Otherwise it's the module that contains the item.
+    let mut target_module_id = if let ModuleDefId::ModuleId(module_id) = module_def_id {
+        Some(module_id)
+    } else {
+        std::mem::take(&mut defining_module).or_else(|| get_parent_module(interner, module_def_id))
+    };
+
+    // Then check if it's visible, and upwards
+    while let Some(module_id) = target_module_id {
+        if !item_in_module_is_visible(def_maps, current_module_id, module_id, visibility) {
+            return false;
+        }
+
+        target_module_id = std::mem::take(&mut defining_module).or_else(|| {
+            let module_data = &def_maps[&module_id.krate].modules()[module_id.local_id.0];
+            let parent_local_id = module_data.parent;
+            parent_local_id.map(|local_id| ModuleId { krate: module_id.krate, local_id })
+        });
+
+        // This is a bit strange, but the visibility is always that of the item inside another module,
+        // so the visibility we update here is for the next loop check.
+        visibility = interner
+            .try_module_attributes(&module_id)
+            .map_or(ItemVisibility::Public, |attributes| attributes.visibility);
+    }
+
+    true
 }
diff --git a/tooling/lsp/test_programs/workspace/two/src/lib.nr b/tooling/lsp/test_programs/workspace/two/src/lib.nr
index c6b516d88ab..2dec902f327 100644
--- a/tooling/lsp/test_programs/workspace/two/src/lib.nr
+++ b/tooling/lsp/test_programs/workspace/two/src/lib.nr
@@ -41,8 +41,8 @@ fn use_impl_method() {
 }
 
 mod other;
-use other::another_function;
 use crate::other::other_function;
+use other::another_function;
 
 use one::subone::GenericStruct;
 
@@ -57,4 +57,30 @@ pub fn foo() {}
 
 comptime fn attr(_: FunctionDefinition) -> Quoted {
     quote { pub fn hello() {} }
-}
\ No newline at end of file
+}
+
+struct Foo<T> {}
+
+impl<U> Foo<U> {
+    fn new() -> Self {
+        Foo {}
+    }
+}
+
+fn new_foo() -> Foo<i32> {
+    Foo::new()
+}
+
+trait Bar<T, U> {
+    fn bar_stuff(self);
+}
+
+impl<A> Bar<A, i32> for Foo<A> {
+    fn bar_stuff(self) {}
+}
+
+fn bar_stuff() {
+    let foo = Foo::new();
+    foo.bar_stuff();
+}
+
diff --git a/tooling/nargo/Cargo.toml b/tooling/nargo/Cargo.toml
index c5d4bbc9788..1dbb9978b0b 100644
--- a/tooling/nargo/Cargo.toml
+++ b/tooling/nargo/Cargo.toml
@@ -27,15 +27,13 @@ rayon.workspace = true
 jsonrpc.workspace = true
 rand.workspace = true
 serde.workspace = true
+walkdir = "2.5.0"
 
 [target.'cfg(not(target_arch = "wasm32"))'.dependencies]
 noir_fuzzer.workspace = true
 proptest.workspace = true
 
 [dev-dependencies]
-# TODO: This dependency is used to generate unit tests for `get_all_paths_in_dir`
-# TODO: once that method is moved to nargo_cli, we can move this dependency to nargo_cli
-tempfile.workspace = true
 jsonrpc-http-server = "18.0"
 jsonrpc-core-client = "18.0"
 jsonrpc-derive = "18.0"
diff --git a/tooling/nargo/src/foreign_calls/mocker.rs b/tooling/nargo/src/foreign_calls/mocker.rs
new file mode 100644
index 00000000000..c93d16bbaf6
--- /dev/null
+++ b/tooling/nargo/src/foreign_calls/mocker.rs
@@ -0,0 +1,176 @@
+use acvm::{
+    acir::brillig::{ForeignCallParam, ForeignCallResult},
+    pwg::ForeignCallWaitInfo,
+    AcirField,
+};
+use noirc_printable_type::{decode_string_value, ForeignCallError};
+use serde::{Deserialize, Serialize};
+
+use super::{ForeignCall, ForeignCallExecutor};
+
+/// This struct represents an oracle mock. It can be used for testing programs that use oracles.
+#[derive(Debug, PartialEq, Eq, Clone)]
+struct MockedCall<F> {
+    /// The id of the mock, used to update or remove it
+    id: usize,
+    /// The oracle it's mocking
+    name: String,
+    /// Optionally match the parameters
+    params: Option<Vec<ForeignCallParam<F>>>,
+    /// The parameters with which the mock was last called
+    last_called_params: Option<Vec<ForeignCallParam<F>>>,
+    /// The result to return when this mock is called
+    result: ForeignCallResult<F>,
+    /// How many times should this mock be called before it is removed
+    times_left: Option<u64>,
+}
+
+impl<F> MockedCall<F> {
+    fn new(id: usize, name: String) -> Self {
+        Self {
+            id,
+            name,
+            params: None,
+            last_called_params: None,
+            result: ForeignCallResult { values: vec![] },
+            times_left: None,
+        }
+    }
+}
+
+impl<F: PartialEq> MockedCall<F> {
+    fn matches(&self, name: &str, params: &[ForeignCallParam<F>]) -> bool {
+        self.name == name && (self.params.is_none() || self.params.as_deref() == Some(params))
+    }
+}
+
+#[derive(Debug, Default)]
+pub(crate) struct MockForeignCallExecutor<F> {
+    /// Mocks have unique ids used to identify them in Noir, allowing to update or remove them.
+    last_mock_id: usize,
+    /// The registered mocks
+    mocked_responses: Vec<MockedCall<F>>,
+}
+
+impl<F: AcirField> MockForeignCallExecutor<F> {
+    fn extract_mock_id(
+        foreign_call_inputs: &[ForeignCallParam<F>],
+    ) -> Result<(usize, &[ForeignCallParam<F>]), ForeignCallError> {
+        let (id, params) =
+            foreign_call_inputs.split_first().ok_or(ForeignCallError::MissingForeignCallInputs)?;
+        let id =
+            usize::try_from(id.unwrap_field().try_to_u64().expect("value does not fit into u64"))
+                .expect("value does not fit into usize");
+        Ok((id, params))
+    }
+
+    fn find_mock_by_id(&self, id: usize) -> Option<&MockedCall<F>> {
+        self.mocked_responses.iter().find(|response| response.id == id)
+    }
+
+    fn find_mock_by_id_mut(&mut self, id: usize) -> Option<&mut MockedCall<F>> {
+        self.mocked_responses.iter_mut().find(|response| response.id == id)
+    }
+
+    fn parse_string(param: &ForeignCallParam<F>) -> String {
+        let fields: Vec<_> = param.fields().to_vec();
+        decode_string_value(&fields)
+    }
+}
+
+impl<F: AcirField + Serialize + for<'a> Deserialize<'a>> ForeignCallExecutor<F>
+    for MockForeignCallExecutor<F>
+{
+    fn execute(
+        &mut self,
+        foreign_call: &ForeignCallWaitInfo<F>,
+    ) -> Result<ForeignCallResult<F>, ForeignCallError> {
+        let foreign_call_name = foreign_call.function.as_str();
+        match ForeignCall::lookup(foreign_call_name) {
+            Some(ForeignCall::CreateMock) => {
+                let mock_oracle_name = Self::parse_string(&foreign_call.inputs[0]);
+                assert!(ForeignCall::lookup(&mock_oracle_name).is_none());
+                let id = self.last_mock_id;
+                self.mocked_responses.push(MockedCall::new(id, mock_oracle_name));
+                self.last_mock_id += 1;
+
+                Ok(F::from(id).into())
+            }
+            Some(ForeignCall::SetMockParams) => {
+                let (id, params) = Self::extract_mock_id(&foreign_call.inputs)?;
+                self.find_mock_by_id_mut(id)
+                    .unwrap_or_else(|| panic!("Unknown mock id {}", id))
+                    .params = Some(params.to_vec());
+
+                Ok(ForeignCallResult::default())
+            }
+            Some(ForeignCall::GetMockLastParams) => {
+                let (id, _) = Self::extract_mock_id(&foreign_call.inputs)?;
+                let mock =
+                    self.find_mock_by_id(id).unwrap_or_else(|| panic!("Unknown mock id {}", id));
+
+                let last_called_params = mock
+                    .last_called_params
+                    .clone()
+                    .unwrap_or_else(|| panic!("Mock {} was never called", mock.name));
+
+                Ok(last_called_params.into())
+            }
+            Some(ForeignCall::SetMockReturns) => {
+                let (id, params) = Self::extract_mock_id(&foreign_call.inputs)?;
+                self.find_mock_by_id_mut(id)
+                    .unwrap_or_else(|| panic!("Unknown mock id {}", id))
+                    .result = ForeignCallResult { values: params.to_vec() };
+
+                Ok(ForeignCallResult::default())
+            }
+            Some(ForeignCall::SetMockTimes) => {
+                let (id, params) = Self::extract_mock_id(&foreign_call.inputs)?;
+                let times =
+                    params[0].unwrap_field().try_to_u64().expect("Invalid bit size of times");
+
+                self.find_mock_by_id_mut(id)
+                    .unwrap_or_else(|| panic!("Unknown mock id {}", id))
+                    .times_left = Some(times);
+
+                Ok(ForeignCallResult::default())
+            }
+            Some(ForeignCall::ClearMock) => {
+                let (id, _) = Self::extract_mock_id(&foreign_call.inputs)?;
+                self.mocked_responses.retain(|response| response.id != id);
+                Ok(ForeignCallResult::default())
+            }
+            _ => {
+                let mock_response_position = self
+                    .mocked_responses
+                    .iter()
+                    .position(|response| response.matches(foreign_call_name, &foreign_call.inputs));
+
+                if let Some(response_position) = mock_response_position {
+                    // If the program has registered a mocked response to this oracle call then we prefer responding
+                    // with that.
+
+                    let mock = self
+                        .mocked_responses
+                        .get_mut(response_position)
+                        .expect("Invalid position of mocked response");
+
+                    mock.last_called_params = Some(foreign_call.inputs.clone());
+
+                    let result = mock.result.values.clone();
+
+                    if let Some(times_left) = &mut mock.times_left {
+                        *times_left -= 1;
+                        if *times_left == 0 {
+                            self.mocked_responses.remove(response_position);
+                        }
+                    }
+
+                    Ok(result.into())
+                } else {
+                    Err(ForeignCallError::NoHandler(foreign_call_name.to_string()))
+                }
+            }
+        }
+    }
+}
diff --git a/tooling/nargo/src/foreign_calls/mod.rs b/tooling/nargo/src/foreign_calls/mod.rs
new file mode 100644
index 00000000000..65ff051bcbf
--- /dev/null
+++ b/tooling/nargo/src/foreign_calls/mod.rs
@@ -0,0 +1,140 @@
+use std::path::PathBuf;
+
+use acvm::{acir::brillig::ForeignCallResult, pwg::ForeignCallWaitInfo, AcirField};
+use mocker::MockForeignCallExecutor;
+use noirc_printable_type::ForeignCallError;
+use print::{PrintForeignCallExecutor, PrintOutput};
+use rand::Rng;
+use rpc::RPCForeignCallExecutor;
+use serde::{Deserialize, Serialize};
+
+pub(crate) mod mocker;
+pub(crate) mod print;
+pub(crate) mod rpc;
+
+pub trait ForeignCallExecutor<F> {
+    fn execute(
+        &mut self,
+        foreign_call: &ForeignCallWaitInfo<F>,
+    ) -> Result<ForeignCallResult<F>, ForeignCallError>;
+}
+
+/// This enumeration represents the Brillig foreign calls that are natively supported by nargo.
+/// After resolution of a foreign call, nargo will restart execution of the ACVM
+pub enum ForeignCall {
+    Print,
+    CreateMock,
+    SetMockParams,
+    GetMockLastParams,
+    SetMockReturns,
+    SetMockTimes,
+    ClearMock,
+}
+
+impl std::fmt::Display for ForeignCall {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        write!(f, "{}", self.name())
+    }
+}
+
+impl ForeignCall {
+    pub(crate) fn name(&self) -> &'static str {
+        match self {
+            ForeignCall::Print => "print",
+            ForeignCall::CreateMock => "create_mock",
+            ForeignCall::SetMockParams => "set_mock_params",
+            ForeignCall::GetMockLastParams => "get_mock_last_params",
+            ForeignCall::SetMockReturns => "set_mock_returns",
+            ForeignCall::SetMockTimes => "set_mock_times",
+            ForeignCall::ClearMock => "clear_mock",
+        }
+    }
+
+    pub(crate) fn lookup(op_name: &str) -> Option<ForeignCall> {
+        match op_name {
+            "print" => Some(ForeignCall::Print),
+            "create_mock" => Some(ForeignCall::CreateMock),
+            "set_mock_params" => Some(ForeignCall::SetMockParams),
+            "get_mock_last_params" => Some(ForeignCall::GetMockLastParams),
+            "set_mock_returns" => Some(ForeignCall::SetMockReturns),
+            "set_mock_times" => Some(ForeignCall::SetMockTimes),
+            "clear_mock" => Some(ForeignCall::ClearMock),
+            _ => None,
+        }
+    }
+}
+
+#[derive(Debug, Default)]
+pub struct DefaultForeignCallExecutor<'a, F> {
+    /// The executor for any [`ForeignCall::Print`] calls.
+    printer: PrintForeignCallExecutor<'a>,
+    mocker: MockForeignCallExecutor<F>,
+    external: Option<RPCForeignCallExecutor>,
+}
+
+impl<'a, F: Default> DefaultForeignCallExecutor<'a, F> {
+    pub fn new(
+        output: PrintOutput<'a>,
+        resolver_url: Option<&str>,
+        root_path: Option<PathBuf>,
+        package_name: Option<String>,
+    ) -> Self {
+        let id = rand::thread_rng().gen();
+        let printer = PrintForeignCallExecutor { output };
+        let external_resolver = resolver_url.map(|resolver_url| {
+            RPCForeignCallExecutor::new(resolver_url, id, root_path, package_name)
+        });
+        DefaultForeignCallExecutor {
+            printer,
+            mocker: MockForeignCallExecutor::default(),
+            external: external_resolver,
+        }
+    }
+}
+
+impl<'a, F: AcirField + Serialize + for<'b> Deserialize<'b>> ForeignCallExecutor<F>
+    for DefaultForeignCallExecutor<'a, F>
+{
+    fn execute(
+        &mut self,
+        foreign_call: &ForeignCallWaitInfo<F>,
+    ) -> Result<ForeignCallResult<F>, ForeignCallError> {
+        let foreign_call_name = foreign_call.function.as_str();
+        match ForeignCall::lookup(foreign_call_name) {
+            Some(ForeignCall::Print) => self.printer.execute(foreign_call),
+            Some(
+                ForeignCall::CreateMock
+                | ForeignCall::SetMockParams
+                | ForeignCall::GetMockLastParams
+                | ForeignCall::SetMockReturns
+                | ForeignCall::SetMockTimes
+                | ForeignCall::ClearMock,
+            ) => self.mocker.execute(foreign_call),
+
+            None => {
+                // First check if there's any defined mock responses for this foreign call.
+                match self.mocker.execute(foreign_call) {
+                    Err(ForeignCallError::NoHandler(_)) => (),
+                    response_or_error => return response_or_error,
+                };
+
+                if let Some(external_resolver) = &mut self.external {
+                    // If the user has registered an external resolver then we forward any remaining oracle calls there.
+                    match external_resolver.execute(foreign_call) {
+                        Err(ForeignCallError::NoHandler(_)) => (),
+                        response_or_error => return response_or_error,
+                    };
+                }
+
+                // If all executors have no handler for the given foreign call then we cannot
+                // return a correct response to the ACVM. The best we can do is to return an empty response,
+                // this allows us to ignore any foreign calls which exist solely to pass information from inside
+                // the circuit to the environment (e.g. custom logging) as the execution will still be able to progress.
+                //
+                // We optimistically return an empty response for all oracle calls as the ACVM will error
+                // should a response have been required.
+                Ok(ForeignCallResult::default())
+            }
+        }
+    }
+}
diff --git a/tooling/nargo/src/foreign_calls/print.rs b/tooling/nargo/src/foreign_calls/print.rs
new file mode 100644
index 00000000000..8b2b5efd8b6
--- /dev/null
+++ b/tooling/nargo/src/foreign_calls/print.rs
@@ -0,0 +1,52 @@
+use acvm::{acir::brillig::ForeignCallResult, pwg::ForeignCallWaitInfo, AcirField};
+use noirc_printable_type::{ForeignCallError, PrintableValueDisplay};
+
+use super::{ForeignCall, ForeignCallExecutor};
+
+#[derive(Debug, Default)]
+pub enum PrintOutput<'a> {
+    #[default]
+    None,
+    Stdout,
+    String(&'a mut String),
+}
+
+#[derive(Debug, Default)]
+pub(crate) struct PrintForeignCallExecutor<'a> {
+    pub(crate) output: PrintOutput<'a>,
+}
+
+impl<F: AcirField> ForeignCallExecutor<F> for PrintForeignCallExecutor<'_> {
+    fn execute(
+        &mut self,
+        foreign_call: &ForeignCallWaitInfo<F>,
+    ) -> Result<ForeignCallResult<F>, ForeignCallError> {
+        let foreign_call_name = foreign_call.function.as_str();
+        match ForeignCall::lookup(foreign_call_name) {
+            Some(ForeignCall::Print) => {
+                let skip_newline = foreign_call.inputs[0].unwrap_field().is_zero();
+
+                let foreign_call_inputs = foreign_call
+                    .inputs
+                    .split_first()
+                    .ok_or(ForeignCallError::MissingForeignCallInputs)?
+                    .1;
+
+                let display_values: PrintableValueDisplay<F> = foreign_call_inputs.try_into()?;
+                let display_string =
+                    format!("{display_values}{}", if skip_newline { "" } else { "\n" });
+
+                match &mut self.output {
+                    PrintOutput::None => (),
+                    PrintOutput::Stdout => print!("{display_string}"),
+                    PrintOutput::String(string) => {
+                        string.push_str(&display_string);
+                    }
+                }
+
+                Ok(ForeignCallResult::default())
+            }
+            _ => Err(ForeignCallError::NoHandler(foreign_call_name.to_string())),
+        }
+    }
+}
diff --git a/tooling/nargo/src/foreign_calls/rpc.rs b/tooling/nargo/src/foreign_calls/rpc.rs
new file mode 100644
index 00000000000..0653eb1c7e3
--- /dev/null
+++ b/tooling/nargo/src/foreign_calls/rpc.rs
@@ -0,0 +1,227 @@
+use std::path::PathBuf;
+
+use acvm::{acir::brillig::ForeignCallResult, pwg::ForeignCallWaitInfo, AcirField};
+use jsonrpc::{arg as build_json_rpc_arg, minreq_http::Builder, Client};
+use noirc_printable_type::ForeignCallError;
+use serde::{Deserialize, Serialize};
+
+use super::ForeignCallExecutor;
+
+#[derive(Debug)]
+pub(crate) struct RPCForeignCallExecutor {
+    /// A randomly generated id for this `DefaultForeignCallExecutor`.
+    ///
+    /// This is used so that a single `external_resolver` can distinguish between requests from multiple
+    /// instantiations of `DefaultForeignCallExecutor`.
+    id: u64,
+    /// JSON RPC client to resolve foreign calls
+    external_resolver: Client,
+    /// Root path to the program or workspace in execution.
+    root_path: Option<PathBuf>,
+    /// Name of the package in execution
+    package_name: Option<String>,
+}
+
+#[derive(Debug, Serialize, Deserialize)]
+struct ResolveForeignCallRequest<F> {
+    /// A session ID which allows the external RPC server to link this foreign call request to other foreign calls
+    /// for the same program execution.
+    ///
+    /// This is intended to allow a single RPC server to maintain state related to multiple program executions being
+    /// performed in parallel.
+    session_id: u64,
+
+    #[serde(flatten)]
+    /// The foreign call which the external RPC server is to provide a response for.
+    function_call: ForeignCallWaitInfo<F>,
+
+    #[serde(skip_serializing_if = "Option::is_none")]
+    /// Root path to the program or workspace in execution.
+    root_path: Option<String>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    /// Name of the package in execution
+    package_name: Option<String>,
+}
+
+impl RPCForeignCallExecutor {
+    pub(crate) fn new(
+        resolver_url: &str,
+        id: u64,
+        root_path: Option<PathBuf>,
+        package_name: Option<String>,
+    ) -> Self {
+        let mut transport_builder =
+            Builder::new().url(resolver_url).expect("Invalid oracle resolver URL");
+
+        if let Some(Ok(timeout)) =
+            std::env::var("NARGO_FOREIGN_CALL_TIMEOUT").ok().map(|timeout| timeout.parse())
+        {
+            let timeout_duration = std::time::Duration::from_millis(timeout);
+            transport_builder = transport_builder.timeout(timeout_duration);
+        };
+        let oracle_resolver = Client::with_transport(transport_builder.build());
+
+        RPCForeignCallExecutor { external_resolver: oracle_resolver, id, root_path, package_name }
+    }
+}
+
+impl<F: AcirField + Serialize + for<'a> Deserialize<'a>> ForeignCallExecutor<F>
+    for RPCForeignCallExecutor
+{
+    fn execute(
+        &mut self,
+        foreign_call: &ForeignCallWaitInfo<F>,
+    ) -> Result<ForeignCallResult<F>, ForeignCallError> {
+        let encoded_params = vec![build_json_rpc_arg(ResolveForeignCallRequest {
+            session_id: self.id,
+            function_call: foreign_call.clone(),
+            root_path: self.root_path.clone().map(|path| path.to_str().unwrap().to_string()),
+            package_name: self.package_name.clone(),
+        })];
+
+        let req = self.external_resolver.build_request("resolve_foreign_call", &encoded_params);
+
+        let response = self.external_resolver.send_request(req)?;
+
+        let parsed_response: ForeignCallResult<F> = response.result()?;
+
+        Ok(parsed_response)
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use acvm::{
+        acir::brillig::ForeignCallParam, brillig_vm::brillig::ForeignCallResult,
+        pwg::ForeignCallWaitInfo, FieldElement,
+    };
+    use jsonrpc_core::Result as RpcResult;
+    use jsonrpc_derive::rpc;
+    use jsonrpc_http_server::{Server, ServerBuilder};
+
+    use super::{ForeignCallExecutor, RPCForeignCallExecutor, ResolveForeignCallRequest};
+
+    #[allow(unreachable_pub)]
+    #[rpc]
+    pub trait OracleResolver {
+        #[rpc(name = "resolve_foreign_call")]
+        fn resolve_foreign_call(
+            &self,
+            req: ResolveForeignCallRequest<FieldElement>,
+        ) -> RpcResult<ForeignCallResult<FieldElement>>;
+    }
+
+    struct OracleResolverImpl;
+
+    impl OracleResolverImpl {
+        fn echo(&self, param: ForeignCallParam<FieldElement>) -> ForeignCallResult<FieldElement> {
+            vec![param].into()
+        }
+
+        fn sum(&self, array: ForeignCallParam<FieldElement>) -> ForeignCallResult<FieldElement> {
+            let mut res: FieldElement = 0_usize.into();
+
+            for value in array.fields() {
+                res += value;
+            }
+
+            res.into()
+        }
+    }
+
+    impl OracleResolver for OracleResolverImpl {
+        fn resolve_foreign_call(
+            &self,
+            req: ResolveForeignCallRequest<FieldElement>,
+        ) -> RpcResult<ForeignCallResult<FieldElement>> {
+            let response = match req.function_call.function.as_str() {
+                "sum" => self.sum(req.function_call.inputs[0].clone()),
+                "echo" => self.echo(req.function_call.inputs[0].clone()),
+                "id" => FieldElement::from(req.session_id as u128).into(),
+
+                _ => panic!("unexpected foreign call"),
+            };
+            Ok(response)
+        }
+    }
+
+    fn build_oracle_server() -> (Server, String) {
+        let mut io = jsonrpc_core::IoHandler::new();
+        io.extend_with(OracleResolverImpl.to_delegate());
+
+        // Choosing port 0 results in a random port being assigned.
+        let server = ServerBuilder::new(io)
+            .start_http(&"127.0.0.1:0".parse().expect("Invalid address"))
+            .expect("Could not start server");
+
+        let url = format!("http://{}", server.address());
+        (server, url)
+    }
+
+    #[test]
+    fn test_oracle_resolver_echo() {
+        let (server, url) = build_oracle_server();
+
+        let mut executor = RPCForeignCallExecutor::new(&url, 1, None, None);
+
+        let foreign_call: ForeignCallWaitInfo<FieldElement> = ForeignCallWaitInfo {
+            function: "echo".to_string(),
+            inputs: vec![ForeignCallParam::Single(1_u128.into())],
+        };
+
+        let result = executor.execute(&foreign_call);
+        assert_eq!(result.unwrap(), ForeignCallResult { values: foreign_call.inputs });
+
+        server.close();
+    }
+
+    #[test]
+    fn test_oracle_resolver_sum() {
+        let (server, url) = build_oracle_server();
+
+        let mut executor = RPCForeignCallExecutor::new(&url, 2, None, None);
+
+        let foreign_call: ForeignCallWaitInfo<FieldElement> = ForeignCallWaitInfo {
+            function: "sum".to_string(),
+            inputs: vec![ForeignCallParam::Array(vec![1_usize.into(), 2_usize.into()])],
+        };
+
+        let result = executor.execute(&foreign_call);
+        assert_eq!(result.unwrap(), FieldElement::from(3_usize).into());
+
+        server.close();
+    }
+
+    #[test]
+    fn foreign_call_executor_id_is_persistent() {
+        let (server, url) = build_oracle_server();
+
+        let mut executor = RPCForeignCallExecutor::new(&url, 3, None, None);
+
+        let foreign_call: ForeignCallWaitInfo<FieldElement> =
+            ForeignCallWaitInfo { function: "id".to_string(), inputs: Vec::new() };
+
+        let result_1 = executor.execute(&foreign_call).unwrap();
+        let result_2 = executor.execute(&foreign_call).unwrap();
+        assert_eq!(result_1, result_2);
+
+        server.close();
+    }
+
+    #[test]
+    fn oracle_resolver_rpc_can_distinguish_executors() {
+        let (server, url) = build_oracle_server();
+
+        let mut executor_1 = RPCForeignCallExecutor::new(&url, 4, None, None);
+        let mut executor_2 = RPCForeignCallExecutor::new(&url, 5, None, None);
+
+        let foreign_call: ForeignCallWaitInfo<FieldElement> =
+            ForeignCallWaitInfo { function: "id".to_string(), inputs: Vec::new() };
+
+        let result_1 = executor_1.execute(&foreign_call).unwrap();
+        let result_2 = executor_2.execute(&foreign_call).unwrap();
+        assert_ne!(result_1, result_2);
+
+        server.close();
+    }
+}
diff --git a/tooling/nargo/src/lib.rs b/tooling/nargo/src/lib.rs
index 0118e83d2a3..ee7b2e4809a 100644
--- a/tooling/nargo/src/lib.rs
+++ b/tooling/nargo/src/lib.rs
@@ -9,11 +9,15 @@
 
 pub mod constants;
 pub mod errors;
+pub mod foreign_calls;
 pub mod ops;
 pub mod package;
 pub mod workspace;
 
-use std::collections::{BTreeMap, HashMap};
+use std::{
+    collections::{BTreeMap, HashMap, HashSet},
+    path::PathBuf,
+};
 
 use fm::{FileManager, FILE_EXTENSION};
 use noirc_driver::{add_dep, prepare_crate, prepare_dependency};
@@ -23,8 +27,10 @@ use noirc_frontend::{
 };
 use package::{Dependency, Package};
 use rayon::prelude::*;
+use walkdir::WalkDir;
 
 pub use self::errors::NargoError;
+pub use self::foreign_calls::print::PrintOutput;
 
 pub fn prepare_dependencies(
     context: &mut Context,
@@ -58,8 +64,14 @@ pub fn insert_all_files_for_workspace_into_file_manager_with_overrides(
     file_manager: &mut FileManager,
     overrides: &HashMap<&std::path::Path, &str>,
 ) {
+    let mut processed_entry_paths = HashSet::new();
     for package in workspace.clone().into_iter() {
-        insert_all_files_for_package_into_file_manager(package, file_manager, overrides);
+        insert_all_files_for_package_into_file_manager(
+            package,
+            file_manager,
+            overrides,
+            &mut processed_entry_paths,
+        );
     }
 }
 // We will pre-populate the file manager with all the files in the package
@@ -72,27 +84,55 @@ fn insert_all_files_for_package_into_file_manager(
     package: &Package,
     file_manager: &mut FileManager,
     overrides: &HashMap<&std::path::Path, &str>,
+    processed_entry_paths: &mut HashSet<PathBuf>,
 ) {
+    if processed_entry_paths.contains(&package.entry_path) {
+        return;
+    }
+    processed_entry_paths.insert(package.entry_path.clone());
+
     // Start off at the entry path and read all files in the parent directory.
     let entry_path_parent = package
         .entry_path
         .parent()
         .unwrap_or_else(|| panic!("The entry path is expected to be a single file within a directory and so should have a parent {:?}", package.entry_path));
 
-    // Get all files in the package and add them to the file manager
-    let paths = get_all_noir_source_in_dir(entry_path_parent)
-        .expect("could not get all paths in the package");
-    for path in paths {
+    for entry in WalkDir::new(entry_path_parent) {
+        let Ok(entry) = entry else {
+            continue;
+        };
+
+        if !entry.file_type().is_file() {
+            continue;
+        }
+
+        if !entry.path().extension().map_or(false, |ext| ext == FILE_EXTENSION) {
+            continue;
+        };
+
+        let path = entry.into_path();
+
+        // Avoid reading the source if the file is already there
+        if file_manager.has_file(&path) {
+            continue;
+        }
+
         let source = if let Some(src) = overrides.get(path.as_path()) {
             src.to_string()
         } else {
             std::fs::read_to_string(path.as_path())
                 .unwrap_or_else(|_| panic!("could not read file {:?} into string", path))
         };
+
         file_manager.add_file_with_source(path.as_path(), source);
     }
 
-    insert_all_files_for_packages_dependencies_into_file_manager(package, file_manager);
+    insert_all_files_for_packages_dependencies_into_file_manager(
+        package,
+        file_manager,
+        overrides,
+        processed_entry_paths,
+    );
 }
 
 // Inserts all files for the dependencies of the package into the file manager
@@ -100,6 +140,8 @@ fn insert_all_files_for_package_into_file_manager(
 fn insert_all_files_for_packages_dependencies_into_file_manager(
     package: &Package,
     file_manager: &mut FileManager,
+    overrides: &HashMap<&std::path::Path, &str>,
+    processed_entry_paths: &mut HashSet<PathBuf>,
 ) {
     for (_, dep) in package.dependencies.iter() {
         match dep {
@@ -107,9 +149,9 @@ fn insert_all_files_for_packages_dependencies_into_file_manager(
                 insert_all_files_for_package_into_file_manager(
                     package,
                     file_manager,
-                    &HashMap::new(),
+                    overrides,
+                    processed_entry_paths,
                 );
-                insert_all_files_for_packages_dependencies_into_file_manager(package, file_manager);
             }
         }
     }
@@ -143,84 +185,3 @@ pub fn prepare_package<'file_manager, 'parsed_files>(
 
     (context, crate_id)
 }
-
-// Get all Noir source files in the directory and subdirectories.
-//
-// Panics: If the path is not a path to a directory.
-fn get_all_noir_source_in_dir(dir: &std::path::Path) -> std::io::Result<Vec<std::path::PathBuf>> {
-    get_all_paths_in_dir(dir, |path| {
-        path.extension().map_or(false, |extension| extension == FILE_EXTENSION)
-    })
-}
-
-// Get all paths in the directory and subdirectories.
-//
-// Panics: If the path is not a path to a directory.
-//
-// TODO: Along with prepare_package, this function is an abstraction leak
-// TODO: given that this crate should not know about the file manager.
-// TODO: We can clean this up in a future refactor
-fn get_all_paths_in_dir(
-    dir: &std::path::Path,
-    predicate: fn(&std::path::Path) -> bool,
-) -> std::io::Result<Vec<std::path::PathBuf>> {
-    assert!(dir.is_dir(), "directory {dir:?} is not a path to a directory");
-
-    let mut paths = Vec::new();
-
-    if dir.is_dir() {
-        for entry in std::fs::read_dir(dir)? {
-            let entry = entry?;
-            let path = entry.path();
-            if path.is_dir() {
-                let mut sub_paths = get_all_paths_in_dir(&path, predicate)?;
-                paths.append(&mut sub_paths);
-            } else if predicate(&path) {
-                paths.push(path);
-            }
-        }
-    }
-
-    Ok(paths)
-}
-
-#[cfg(test)]
-mod tests {
-    use crate::get_all_paths_in_dir;
-    use std::{
-        fs::{self, File},
-        path::Path,
-    };
-    use tempfile::tempdir;
-
-    fn create_test_dir_structure(temp_dir: &Path) -> std::io::Result<()> {
-        fs::create_dir(temp_dir.join("sub_dir1"))?;
-        File::create(temp_dir.join("sub_dir1/file1.txt"))?;
-        fs::create_dir(temp_dir.join("sub_dir2"))?;
-        File::create(temp_dir.join("sub_dir2/file2.txt"))?;
-        File::create(temp_dir.join("file3.txt"))?;
-        Ok(())
-    }
-
-    #[test]
-    fn test_get_all_paths_in_dir() {
-        let temp_dir = tempdir().expect("could not create a temporary directory");
-        create_test_dir_structure(temp_dir.path())
-            .expect("could not create test directory structure");
-
-        let paths = get_all_paths_in_dir(temp_dir.path(), |_| true)
-            .expect("could not get all paths in the test directory");
-
-        // This should be the paths to all of the files in the directory and the subdirectory
-        let expected_paths = vec![
-            temp_dir.path().join("file3.txt"),
-            temp_dir.path().join("sub_dir1/file1.txt"),
-            temp_dir.path().join("sub_dir2/file2.txt"),
-        ];
-
-        assert_eq!(paths.len(), expected_paths.len());
-        for path in expected_paths {
-            assert!(paths.contains(&path));
-        }
-    }
-}
diff --git a/tooling/nargo/src/ops/check.rs b/tooling/nargo/src/ops/check.rs
new file mode 100644
index 00000000000..707353ccdad
--- /dev/null
+++ b/tooling/nargo/src/ops/check.rs
@@ -0,0 +1,21 @@
+use acvm::compiler::CircuitSimulator;
+use noirc_driver::{CompiledProgram, ErrorsAndWarnings};
+use noirc_errors::{CustomDiagnostic, FileDiagnostic};
+
+/// Run each function through a circuit simulator to check that they are solvable.
+pub fn check_program(compiled_program: &CompiledProgram) -> Result<(), ErrorsAndWarnings> {
+    for (i, circuit) in compiled_program.program.functions.iter().enumerate() {
+        let mut simulator = CircuitSimulator::default();
+        if !simulator.check_circuit(circuit) {
+            let diag = FileDiagnostic {
+                file_id: fm::FileId::dummy(),
+                diagnostic: CustomDiagnostic::from_message(&format!(
+                    "Circuit \"{}\" is not solvable",
+                    compiled_program.names[i]
+                )),
+            };
+            return Err(vec![diag]);
+        }
+    }
+    Ok(())
+}
diff --git a/tooling/nargo/src/ops/compile.rs b/tooling/nargo/src/ops/compile.rs
index cd9ccf67957..8c44bf35243 100644
--- a/tooling/nargo/src/ops/compile.rs
+++ b/tooling/nargo/src/ops/compile.rs
@@ -75,6 +75,7 @@ pub fn compile_program(
     )
 }
 
+#[tracing::instrument(level = "trace", name = "compile_program" skip_all, fields(package = package.name.to_string()))]
 pub fn compile_program_with_debug_instrumenter(
     file_manager: &FileManager,
     parsed_files: &ParsedFiles,
@@ -92,6 +93,7 @@ pub fn compile_program_with_debug_instrumenter(
     noirc_driver::compile_main(&mut context, crate_id, compile_options, cached_program)
 }
 
+#[tracing::instrument(level = "trace", skip_all, fields(package_name = package.name.to_string()))]
 pub fn compile_contract(
     file_manager: &FileManager,
     parsed_files: &ParsedFiles,
diff --git a/tooling/nargo/src/ops/execute.rs b/tooling/nargo/src/ops/execute.rs
index eb03bdf01c1..57116ec2efd 100644
--- a/tooling/nargo/src/ops/execute.rs
+++ b/tooling/nargo/src/ops/execute.rs
@@ -3,15 +3,16 @@ use acvm::acir::circuit::{
     OpcodeLocation, Program, ResolvedAssertionPayload, ResolvedOpcodeLocation,
 };
 use acvm::acir::native_types::WitnessStack;
-use acvm::pwg::{ACVMStatus, ErrorLocation, OpcodeNotSolvable, OpcodeResolutionError, ACVM};
+use acvm::pwg::{
+    ACVMStatus, ErrorLocation, OpcodeNotSolvable, OpcodeResolutionError, ProfilingSamples, ACVM,
+};
 use acvm::{acir::circuit::Circuit, acir::native_types::WitnessMap};
 use acvm::{AcirField, BlackBoxFunctionSolver};
 
 use crate::errors::ExecutionError;
+use crate::foreign_calls::ForeignCallExecutor;
 use crate::NargoError;
 
-use super::foreign_calls::ForeignCallExecutor;
-
 struct ProgramExecutor<'a, F, B: BlackBoxFunctionSolver<F>, E: ForeignCallExecutor<F>> {
     functions: &'a [Circuit<F>],
 
@@ -32,6 +33,10 @@ struct ProgramExecutor<'a, F, B: BlackBoxFunctionSolver<F>, E: ForeignCallExecut
     // This is used to fetch the function we want to execute
     // and to resolve call stack locations across many function calls.
     current_function_index: usize,
+
+    // Flag that states whether we want to profile the VM. Profiling can add extra
+    // execution costs so we want to make sure we only trigger it explicitly.
+    profiling_active: bool,
 }
 
 impl<'a, F: AcirField, B: BlackBoxFunctionSolver<F>, E: ForeignCallExecutor<F>>
@@ -42,6 +47,7 @@ impl<'a, F: AcirField, B: BlackBoxFunctionSolver<F>, E: ForeignCallExecutor<F>>
         unconstrained_functions: &'a [BrilligBytecode<F>],
         blackbox_solver: &'a B,
         foreign_call_executor: &'a mut E,
+        profiling_active: bool,
     ) -> Self {
         ProgramExecutor {
             functions,
@@ -51,6 +57,7 @@ impl<'a, F: AcirField, B: BlackBoxFunctionSolver<F>, E: ForeignCallExecutor<F>>
             foreign_call_executor,
             call_stack: Vec::default(),
             current_function_index: 0,
+            profiling_active,
         }
     }
 
@@ -62,7 +69,7 @@ impl<'a, F: AcirField, B: BlackBoxFunctionSolver<F>, E: ForeignCallExecutor<F>>
     fn execute_circuit(
         &mut self,
         initial_witness: WitnessMap<F>,
-    ) -> Result<WitnessMap<F>, NargoError<F>> {
+    ) -> Result<(WitnessMap<F>, ProfilingSamples), NargoError<F>> {
         let circuit = &self.functions[self.current_function_index];
         let mut acvm = ACVM::new(
             self.blackbox_solver,
@@ -71,6 +78,7 @@ impl<'a, F: AcirField, B: BlackBoxFunctionSolver<F>, E: ForeignCallExecutor<F>>
             self.unconstrained_functions,
             &circuit.assert_messages,
         );
+        acvm.with_profiler(self.profiling_active);
 
         loop {
             let solver_status = acvm.solve();
@@ -155,7 +163,8 @@ impl<'a, F: AcirField, B: BlackBoxFunctionSolver<F>, E: ForeignCallExecutor<F>>
                     // Execute the ACIR call
                     let acir_to_call = &self.functions[call_info.id.as_usize()];
                     let initial_witness = call_info.initial_witness;
-                    let call_solved_witness = self.execute_circuit(initial_witness)?;
+                    // TODO: Profiling among multiple circuits is not supported
+                    let (call_solved_witness, _) = self.execute_circuit(initial_witness)?;
 
                     // Set tracking index back to the parent function after ACIR call execution
                     self.current_function_index = acir_function_caller;
@@ -184,25 +193,67 @@ impl<'a, F: AcirField, B: BlackBoxFunctionSolver<F>, E: ForeignCallExecutor<F>>
         // included in a failure case.
         self.call_stack.clear();
 
-        Ok(acvm.finalize())
+        let profiling_samples = acvm.take_profiling_samples();
+        Ok((acvm.finalize(), profiling_samples))
     }
 }
 
-#[tracing::instrument(level = "trace", skip_all)]
 pub fn execute_program<F: AcirField, B: BlackBoxFunctionSolver<F>, E: ForeignCallExecutor<F>>(
     program: &Program<F>,
     initial_witness: WitnessMap<F>,
     blackbox_solver: &B,
     foreign_call_executor: &mut E,
 ) -> Result<WitnessStack<F>, NargoError<F>> {
+    let profiling_active = false;
+    let (witness_stack, profiling_samples) = execute_program_inner(
+        program,
+        initial_witness,
+        blackbox_solver,
+        foreign_call_executor,
+        profiling_active,
+    )?;
+    assert!(profiling_samples.is_empty(), "Expected no profiling samples");
+
+    Ok(witness_stack)
+}
+
+pub fn execute_program_with_profiling<
+    F: AcirField,
+    B: BlackBoxFunctionSolver<F>,
+    E: ForeignCallExecutor<F>,
+>(
+    program: &Program<F>,
+    initial_witness: WitnessMap<F>,
+    blackbox_solver: &B,
+    foreign_call_executor: &mut E,
+) -> Result<(WitnessStack<F>, ProfilingSamples), NargoError<F>> {
+    let profiling_active = true;
+    execute_program_inner(
+        program,
+        initial_witness,
+        blackbox_solver,
+        foreign_call_executor,
+        profiling_active,
+    )
+}
+
+#[tracing::instrument(level = "trace", skip_all)]
+fn execute_program_inner<F: AcirField, B: BlackBoxFunctionSolver<F>, E: ForeignCallExecutor<F>>(
+    program: &Program<F>,
+    initial_witness: WitnessMap<F>,
+    blackbox_solver: &B,
+    foreign_call_executor: &mut E,
+    profiling_active: bool,
+) -> Result<(WitnessStack<F>, ProfilingSamples), NargoError<F>> {
     let mut executor = ProgramExecutor::new(
         &program.functions,
         &program.unconstrained_functions,
         blackbox_solver,
         foreign_call_executor,
+        profiling_active,
     );
-    let main_witness = executor.execute_circuit(initial_witness)?;
+    let (main_witness, profiling_samples) = executor.execute_circuit(initial_witness)?;
     executor.witness_stack.push(0, main_witness);
 
-    Ok(executor.finalize())
+    Ok((executor.finalize(), profiling_samples))
 }
diff --git a/tooling/nargo/src/ops/foreign_calls.rs b/tooling/nargo/src/ops/foreign_calls.rs
deleted file mode 100644
index 30785949a46..00000000000
--- a/tooling/nargo/src/ops/foreign_calls.rs
+++ /dev/null
@@ -1,494 +0,0 @@
-use std::path::PathBuf;
-
-use acvm::{
-    acir::brillig::{ForeignCallParam, ForeignCallResult},
-    pwg::ForeignCallWaitInfo,
-    AcirField,
-};
-use jsonrpc::{arg as build_json_rpc_arg, minreq_http::Builder, Client};
-use noirc_printable_type::{decode_string_value, ForeignCallError, PrintableValueDisplay};
-use rand::Rng;
-use serde::{Deserialize, Serialize};
-
-pub trait ForeignCallExecutor<F> {
-    fn execute(
-        &mut self,
-        foreign_call: &ForeignCallWaitInfo<F>,
-    ) -> Result<ForeignCallResult<F>, ForeignCallError>;
-}
-
-/// This enumeration represents the Brillig foreign calls that are natively supported by nargo.
-/// After resolution of a foreign call, nargo will restart execution of the ACVM
-pub enum ForeignCall {
-    Print,
-    CreateMock,
-    SetMockParams,
-    GetMockLastParams,
-    SetMockReturns,
-    SetMockTimes,
-    ClearMock,
-}
-
-impl std::fmt::Display for ForeignCall {
-    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
-        write!(f, "{}", self.name())
-    }
-}
-
-impl ForeignCall {
-    pub(crate) fn name(&self) -> &'static str {
-        match self {
-            ForeignCall::Print => "print",
-            ForeignCall::CreateMock => "create_mock",
-            ForeignCall::SetMockParams => "set_mock_params",
-            ForeignCall::GetMockLastParams => "get_mock_last_params",
-            ForeignCall::SetMockReturns => "set_mock_returns",
-            ForeignCall::SetMockTimes => "set_mock_times",
-            ForeignCall::ClearMock => "clear_mock",
-        }
-    }
-
-    pub(crate) fn lookup(op_name: &str) -> Option<ForeignCall> {
-        match op_name {
-            "print" => Some(ForeignCall::Print),
-            "create_mock" => Some(ForeignCall::CreateMock),
-            "set_mock_params" => Some(ForeignCall::SetMockParams),
-            "get_mock_last_params" => Some(ForeignCall::GetMockLastParams),
-            "set_mock_returns" => Some(ForeignCall::SetMockReturns),
-            "set_mock_times" => Some(ForeignCall::SetMockTimes),
-            "clear_mock" => Some(ForeignCall::ClearMock),
-            _ => None,
-        }
-    }
-}
-
-/// This struct represents an oracle mock. It can be used for testing programs that use oracles.
-#[derive(Debug, PartialEq, Eq, Clone)]
-struct MockedCall<F> {
-    /// The id of the mock, used to update or remove it
-    id: usize,
-    /// The oracle it's mocking
-    name: String,
-    /// Optionally match the parameters
-    params: Option<Vec<ForeignCallParam<F>>>,
-    /// The parameters with which the mock was last called
-    last_called_params: Option<Vec<ForeignCallParam<F>>>,
-    /// The result to return when this mock is called
-    result: ForeignCallResult<F>,
-    /// How many times should this mock be called before it is removed
-    times_left: Option<u64>,
-}
-
-impl<F> MockedCall<F> {
-    fn new(id: usize, name: String) -> Self {
-        Self {
-            id,
-            name,
-            params: None,
-            last_called_params: None,
-            result: ForeignCallResult { values: vec![] },
-            times_left: None,
-        }
-    }
-}
-
-impl<F: PartialEq> MockedCall<F> {
-    fn matches(&self, name: &str, params: &[ForeignCallParam<F>]) -> bool {
-        self.name == name && (self.params.is_none() || self.params.as_deref() == Some(params))
-    }
-}
-
-#[derive(Debug, Default)]
-pub struct DefaultForeignCallExecutor<F> {
-    /// A randomly generated id for this `DefaultForeignCallExecutor`.
-    ///
-    /// This is used so that a single `external_resolver` can distinguish between requests from multiple
-    /// instantiations of `DefaultForeignCallExecutor`.
-    id: u64,
-
-    /// Mocks have unique ids used to identify them in Noir, allowing to update or remove them.
-    last_mock_id: usize,
-    /// The registered mocks
-    mocked_responses: Vec<MockedCall<F>>,
-    /// Whether to print [`ForeignCall::Print`] output.
-    show_output: bool,
-    /// JSON RPC client to resolve foreign calls
-    external_resolver: Option<Client>,
-    /// Root path to the program or workspace in execution.
-    root_path: Option<PathBuf>,
-    /// Name of the package in execution
-    package_name: Option<String>,
-}
-
-#[derive(Debug, Serialize, Deserialize)]
-struct ResolveForeignCallRequest<F> {
-    /// A session ID which allows the external RPC server to link this foreign call request to other foreign calls
-    /// for the same program execution.
-    ///
-    /// This is intended to allow a single RPC server to maintain state related to multiple program executions being
-    /// performed in parallel.
-    session_id: u64,
-
-    #[serde(flatten)]
-    /// The foreign call which the external RPC server is to provide a response for.
-    function_call: ForeignCallWaitInfo<F>,
-
-    #[serde(skip_serializing_if = "Option::is_none")]
-    /// Root path to the program or workspace in execution.
-    root_path: Option<String>,
-    #[serde(skip_serializing_if = "Option::is_none")]
-    /// Name of the package in execution
-    package_name: Option<String>,
-}
-
-impl<F> DefaultForeignCallExecutor<F> {
-    pub fn new(
-        show_output: bool,
-        resolver_url: Option<&str>,
-        root_path: Option<PathBuf>,
-        package_name: Option<String>,
-    ) -> Self {
-        let oracle_resolver = resolver_url.map(|resolver_url| {
-            let mut transport_builder =
-                Builder::new().url(resolver_url).expect("Invalid oracle resolver URL");
-
-            if let Some(Ok(timeout)) =
-                std::env::var("NARGO_FOREIGN_CALL_TIMEOUT").ok().map(|timeout| timeout.parse())
-            {
-                let timeout_duration = std::time::Duration::from_millis(timeout);
-                transport_builder = transport_builder.timeout(timeout_duration);
-            };
-            Client::with_transport(transport_builder.build())
-        });
-        DefaultForeignCallExecutor {
-            show_output,
-            external_resolver: oracle_resolver,
-            id: rand::thread_rng().gen(),
-            mocked_responses: Vec::new(),
-            last_mock_id: 0,
-            root_path,
-            package_name,
-        }
-    }
-}
-
-impl<F: AcirField> DefaultForeignCallExecutor<F> {
-    fn extract_mock_id(
-        foreign_call_inputs: &[ForeignCallParam<F>],
-    ) -> Result<(usize, &[ForeignCallParam<F>]), ForeignCallError> {
-        let (id, params) =
-            foreign_call_inputs.split_first().ok_or(ForeignCallError::MissingForeignCallInputs)?;
-        let id =
-            usize::try_from(id.unwrap_field().try_to_u64().expect("value does not fit into u64"))
-                .expect("value does not fit into usize");
-        Ok((id, params))
-    }
-
-    fn find_mock_by_id(&self, id: usize) -> Option<&MockedCall<F>> {
-        self.mocked_responses.iter().find(|response| response.id == id)
-    }
-
-    fn find_mock_by_id_mut(&mut self, id: usize) -> Option<&mut MockedCall<F>> {
-        self.mocked_responses.iter_mut().find(|response| response.id == id)
-    }
-
-    fn parse_string(param: &ForeignCallParam<F>) -> String {
-        let fields: Vec<_> = param.fields().to_vec();
-        decode_string_value(&fields)
-    }
-
-    fn execute_print(foreign_call_inputs: &[ForeignCallParam<F>]) -> Result<(), ForeignCallError> {
-        let skip_newline = foreign_call_inputs[0].unwrap_field().is_zero();
-
-        let foreign_call_inputs =
-            foreign_call_inputs.split_first().ok_or(ForeignCallError::MissingForeignCallInputs)?.1;
-        let display_string = Self::format_printable_value(foreign_call_inputs, skip_newline)?;
-
-        print!("{display_string}");
-
-        Ok(())
-    }
-
-    fn format_printable_value(
-        foreign_call_inputs: &[ForeignCallParam<F>],
-        skip_newline: bool,
-    ) -> Result<String, ForeignCallError> {
-        let display_values: PrintableValueDisplay<F> = foreign_call_inputs.try_into()?;
-
-        let result = format!("{display_values}{}", if skip_newline { "" } else { "\n" });
-
-        Ok(result)
-    }
-}
-
-impl<F: AcirField + Serialize + for<'a> Deserialize<'a>> ForeignCallExecutor<F>
-    for DefaultForeignCallExecutor<F>
-{
-    fn execute(
-        &mut self,
-        foreign_call: &ForeignCallWaitInfo<F>,
-    ) -> Result<ForeignCallResult<F>, ForeignCallError> {
-        let foreign_call_name = foreign_call.function.as_str();
-        match ForeignCall::lookup(foreign_call_name) {
-            Some(ForeignCall::Print) => {
-                if self.show_output {
-                    Self::execute_print(&foreign_call.inputs)?;
-                }
-                Ok(ForeignCallResult::default())
-            }
-            Some(ForeignCall::CreateMock) => {
-                let mock_oracle_name = Self::parse_string(&foreign_call.inputs[0]);
-                assert!(ForeignCall::lookup(&mock_oracle_name).is_none());
-                let id = self.last_mock_id;
-                self.mocked_responses.push(MockedCall::new(id, mock_oracle_name));
-                self.last_mock_id += 1;
-
-                Ok(F::from(id).into())
-            }
-            Some(ForeignCall::SetMockParams) => {
-                let (id, params) = Self::extract_mock_id(&foreign_call.inputs)?;
-                self.find_mock_by_id_mut(id)
-                    .unwrap_or_else(|| panic!("Unknown mock id {}", id))
-                    .params = Some(params.to_vec());
-
-                Ok(ForeignCallResult::default())
-            }
-            Some(ForeignCall::GetMockLastParams) => {
-                let (id, _) = Self::extract_mock_id(&foreign_call.inputs)?;
-                let mock =
-                    self.find_mock_by_id(id).unwrap_or_else(|| panic!("Unknown mock id {}", id));
-
-                let last_called_params = mock
-                    .last_called_params
-                    .clone()
-                    .unwrap_or_else(|| panic!("Mock {} was never called", mock.name));
-
-                Ok(last_called_params.into())
-            }
-            Some(ForeignCall::SetMockReturns) => {
-                let (id, params) = Self::extract_mock_id(&foreign_call.inputs)?;
-                self.find_mock_by_id_mut(id)
-                    .unwrap_or_else(|| panic!("Unknown mock id {}", id))
-                    .result = ForeignCallResult { values: params.to_vec() };
-
-                Ok(ForeignCallResult::default())
-            }
-            Some(ForeignCall::SetMockTimes) => {
-                let (id, params) = Self::extract_mock_id(&foreign_call.inputs)?;
-                let times =
-                    params[0].unwrap_field().try_to_u64().expect("Invalid bit size of times");
-
-                self.find_mock_by_id_mut(id)
-                    .unwrap_or_else(|| panic!("Unknown mock id {}", id))
-                    .times_left = Some(times);
-
-                Ok(ForeignCallResult::default())
-            }
-            Some(ForeignCall::ClearMock) => {
-                let (id, _) = Self::extract_mock_id(&foreign_call.inputs)?;
-                self.mocked_responses.retain(|response| response.id != id);
-                Ok(ForeignCallResult::default())
-            }
-            None => {
-                let mock_response_position = self
-                    .mocked_responses
-                    .iter()
-                    .position(|response| response.matches(foreign_call_name, &foreign_call.inputs));
-
-                if let Some(response_position) = mock_response_position {
-                    // If the program has registered a mocked response to this oracle call then we prefer responding
-                    // with that.
-
-                    let mock = self
-                        .mocked_responses
-                        .get_mut(response_position)
-                        .expect("Invalid position of mocked response");
-
-                    mock.last_called_params = Some(foreign_call.inputs.clone());
-
-                    let result = mock.result.values.clone();
-
-                    if let Some(times_left) = &mut mock.times_left {
-                        *times_left -= 1;
-                        if *times_left == 0 {
-                            self.mocked_responses.remove(response_position);
-                        }
-                    }
-
-                    Ok(result.into())
-                } else if let Some(external_resolver) = &self.external_resolver {
-                    // If the user has registered an external resolver then we forward any remaining oracle calls there.
-
-                    let encoded_params = vec![build_json_rpc_arg(ResolveForeignCallRequest {
-                        session_id: self.id,
-                        function_call: foreign_call.clone(),
-                        root_path: self
-                            .root_path
-                            .clone()
-                            .map(|path| path.to_str().unwrap().to_string()),
-                        package_name: self.package_name.clone(),
-                    })];
-
-                    let req =
-                        external_resolver.build_request("resolve_foreign_call", &encoded_params);
-
-                    let response = external_resolver.send_request(req)?;
-
-                    let parsed_response: ForeignCallResult<F> = response.result()?;
-
-                    Ok(parsed_response)
-                } else {
-                    // If there's no registered mock oracle response and no registered resolver then we cannot
-                    // return a correct response to the ACVM. The best we can do is to return an empty response,
-                    // this allows us to ignore any foreign calls which exist solely to pass information from inside
-                    // the circuit to the environment (e.g. custom logging) as the execution will still be able to progress.
-                    //
-                    // We optimistically return an empty response for all oracle calls as the ACVM will error
-                    // should a response have been required.
-                    Ok(ForeignCallResult::default())
-                }
-            }
-        }
-    }
-}
-
-#[cfg(test)]
-mod tests {
-    use acvm::{
-        acir::brillig::ForeignCallParam, brillig_vm::brillig::ForeignCallResult,
-        pwg::ForeignCallWaitInfo, FieldElement,
-    };
-    use jsonrpc_core::Result as RpcResult;
-    use jsonrpc_derive::rpc;
-    use jsonrpc_http_server::{Server, ServerBuilder};
-
-    use crate::ops::{DefaultForeignCallExecutor, ForeignCallExecutor};
-
-    use super::ResolveForeignCallRequest;
-
-    #[allow(unreachable_pub)]
-    #[rpc]
-    pub trait OracleResolver {
-        #[rpc(name = "resolve_foreign_call")]
-        fn resolve_foreign_call(
-            &self,
-            req: ResolveForeignCallRequest<FieldElement>,
-        ) -> RpcResult<ForeignCallResult<FieldElement>>;
-    }
-
-    struct OracleResolverImpl;
-
-    impl OracleResolverImpl {
-        fn echo(&self, param: ForeignCallParam<FieldElement>) -> ForeignCallResult<FieldElement> {
-            vec![param].into()
-        }
-
-        fn sum(&self, array: ForeignCallParam<FieldElement>) -> ForeignCallResult<FieldElement> {
-            let mut res: FieldElement = 0_usize.into();
-
-            for value in array.fields() {
-                res += value;
-            }
-
-            res.into()
-        }
-    }
-
-    impl OracleResolver for OracleResolverImpl {
-        fn resolve_foreign_call(
-            &self,
-            req: ResolveForeignCallRequest<FieldElement>,
-        ) -> RpcResult<ForeignCallResult<FieldElement>> {
-            let response = match req.function_call.function.as_str() {
-                "sum" => self.sum(req.function_call.inputs[0].clone()),
-                "echo" => self.echo(req.function_call.inputs[0].clone()),
-                "id" => FieldElement::from(req.session_id as u128).into(),
-
-                _ => panic!("unexpected foreign call"),
-            };
-            Ok(response)
-        }
-    }
-
-    fn build_oracle_server() -> (Server, String) {
-        let mut io = jsonrpc_core::IoHandler::new();
-        io.extend_with(OracleResolverImpl.to_delegate());
-
-        // Choosing port 0 results in a random port being assigned.
-        let server = ServerBuilder::new(io)
-            .start_http(&"127.0.0.1:0".parse().expect("Invalid address"))
-            .expect("Could not start server");
-
-        let url = format!("http://{}", server.address());
-        (server, url)
-    }
-
-    #[test]
-    fn test_oracle_resolver_echo() {
-        let (server, url) = build_oracle_server();
-
-        let mut executor =
-            DefaultForeignCallExecutor::<FieldElement>::new(false, Some(&url), None, None);
-
-        let foreign_call = ForeignCallWaitInfo {
-            function: "echo".to_string(),
-            inputs: vec![ForeignCallParam::Single(1_u128.into())],
-        };
-
-        let result = executor.execute(&foreign_call);
-        assert_eq!(result.unwrap(), ForeignCallResult { values: foreign_call.inputs });
-
-        server.close();
-    }
-
-    #[test]
-    fn test_oracle_resolver_sum() {
-        let (server, url) = build_oracle_server();
-
-        let mut executor = DefaultForeignCallExecutor::new(false, Some(&url), None, None);
-
-        let foreign_call = ForeignCallWaitInfo {
-            function: "sum".to_string(),
-            inputs: vec![ForeignCallParam::Array(vec![1_usize.into(), 2_usize.into()])],
-        };
-
-        let result = executor.execute(&foreign_call);
-        assert_eq!(result.unwrap(), FieldElement::from(3_usize).into());
-
-        server.close();
-    }
-
-    #[test]
-    fn foreign_call_executor_id_is_persistent() {
-        let (server, url) = build_oracle_server();
-
-        let mut executor =
-            DefaultForeignCallExecutor::<FieldElement>::new(false, Some(&url), None, None);
-
-        let foreign_call = ForeignCallWaitInfo { function: "id".to_string(), inputs: Vec::new() };
-
-        let result_1 = executor.execute(&foreign_call).unwrap();
-        let result_2 = executor.execute(&foreign_call).unwrap();
-        assert_eq!(result_1, result_2);
-
-        server.close();
-    }
-
-    #[test]
-    fn oracle_resolver_rpc_can_distinguish_executors() {
-        let (server, url) = build_oracle_server();
-
-        let mut executor_1 =
-            DefaultForeignCallExecutor::<FieldElement>::new(false, Some(&url), None, None);
-        let mut executor_2 =
-            DefaultForeignCallExecutor::<FieldElement>::new(false, Some(&url), None, None);
-
-        let foreign_call = ForeignCallWaitInfo { function: "id".to_string(), inputs: Vec::new() };
-
-        let result_1 = executor_1.execute(&foreign_call).unwrap();
-        let result_2 = executor_2.execute(&foreign_call).unwrap();
-        assert_ne!(result_1, result_2);
-
-        server.close();
-    }
-}
diff --git a/tooling/nargo/src/ops/mod.rs b/tooling/nargo/src/ops/mod.rs
index cada2f0e915..04efeb5a9ec 100644
--- a/tooling/nargo/src/ops/mod.rs
+++ b/tooling/nargo/src/ops/mod.rs
@@ -1,17 +1,17 @@
+pub use self::check::check_program;
 pub use self::compile::{
     collect_errors, compile_contract, compile_program, compile_program_with_debug_instrumenter,
     compile_workspace, report_errors,
 };
-pub use self::execute::execute_program;
-pub use self::foreign_calls::{DefaultForeignCallExecutor, ForeignCall, ForeignCallExecutor};
+pub use self::execute::{execute_program, execute_program_with_profiling};
 pub use self::optimize::{optimize_contract, optimize_program};
 pub use self::transform::{transform_contract, transform_program};
 
 pub use self::test::{run_test, TestStatus};
 
+mod check;
 mod compile;
 mod execute;
-mod foreign_calls;
 mod optimize;
 mod test;
 mod transform;
diff --git a/tooling/nargo/src/ops/test.rs b/tooling/nargo/src/ops/test.rs
index 370a4235f61..1306150518d 100644
--- a/tooling/nargo/src/ops/test.rs
+++ b/tooling/nargo/src/ops/test.rs
@@ -1,27 +1,45 @@
 use std::path::PathBuf;
 
 use acvm::{
-    acir::native_types::{WitnessMap, WitnessStack},
-    BlackBoxFunctionSolver, FieldElement,
+    acir::{
+        brillig::ForeignCallResult,
+        native_types::{WitnessMap, WitnessStack},
+    },
+    pwg::ForeignCallWaitInfo,
+    AcirField, BlackBoxFunctionSolver, FieldElement,
 };
 use noirc_abi::Abi;
-use noirc_driver::{compile_no_check, CompileError, CompileOptions};
+use noirc_driver::{compile_no_check, CompileError, CompileOptions, DEFAULT_EXPRESSION_WIDTH};
 use noirc_errors::{debug_info::DebugInfo, FileDiagnostic};
 use noirc_frontend::hir::{def_map::TestFunction, Context};
+use noirc_printable_type::ForeignCallError;
+use rand::Rng;
+use serde::{Deserialize, Serialize};
 
-use crate::{errors::try_to_diagnose_runtime_error, NargoError};
+use crate::{
+    errors::try_to_diagnose_runtime_error,
+    foreign_calls::{
+        mocker::MockForeignCallExecutor,
+        print::{PrintForeignCallExecutor, PrintOutput},
+        rpc::RPCForeignCallExecutor,
+        ForeignCall, ForeignCallExecutor,
+    },
+    NargoError,
+};
 
-use super::{execute_program, DefaultForeignCallExecutor};
+use super::execute_program;
 
+#[derive(Debug)]
 pub enum TestStatus {
     Pass,
     Fail { message: String, error_diagnostic: Option<FileDiagnostic> },
+    Skipped,
     CompileError(FileDiagnostic),
 }
 
 impl TestStatus {
     pub fn failed(&self) -> bool {
-        !matches!(self, TestStatus::Pass)
+        !matches!(self, TestStatus::Pass | TestStatus::Skipped)
     }
 }
 
@@ -30,7 +48,7 @@ pub fn run_test<B: BlackBoxFunctionSolver<FieldElement>>(
     blackbox_solver: &B,
     context: &mut Context,
     test_function: &TestFunction,
-    show_output: bool,
+    output: PrintOutput<'_>,
     foreign_call_resolver_url: Option<&str>,
     root_path: Option<PathBuf>,
     package_name: Option<String>,
@@ -45,26 +63,49 @@ pub fn run_test<B: BlackBoxFunctionSolver<FieldElement>>(
 
     match compile_no_check(context, config, test_function.get_id(), None, false) {
         Ok(compiled_program) => {
+            // Do the same optimizations as `compile_cmd`.
+            let target_width = config.expression_width.unwrap_or(DEFAULT_EXPRESSION_WIDTH);
+            let compiled_program = crate::ops::transform_program(compiled_program, target_width);
+
             if test_function_has_no_arguments {
                 // Run the backend to ensure the PWG evaluates functions like std::hash::pedersen,
                 // otherwise constraints involving these expressions will not error.
+                let mut foreign_call_executor = TestForeignCallExecutor::new(
+                    output,
+                    foreign_call_resolver_url,
+                    root_path,
+                    package_name,
+                );
+
                 let circuit_execution = execute_program(
                     &compiled_program.program,
                     WitnessMap::new(),
                     blackbox_solver,
-                    &mut DefaultForeignCallExecutor::new(
-                        show_output,
-                        foreign_call_resolver_url,
-                        root_path,
-                        package_name,
-                    ),
+                    &mut foreign_call_executor,
                 );
-                test_status_program_compile_pass(
+
+                let status = test_status_program_compile_pass(
                     test_function,
-                    compiled_program.abi,
-                    compiled_program.debug,
-                    circuit_execution,
-                )
+                    &compiled_program.abi,
+                    &compiled_program.debug,
+                    &circuit_execution,
+                );
+
+                let ignore_foreign_call_failures =
+                    std::env::var("NARGO_IGNORE_TEST_FAILURES_FROM_FOREIGN_CALLS")
+                        .is_ok_and(|var| &var == "true");
+
+                if let TestStatus::Fail { .. } = status {
+                    if ignore_foreign_call_failures
+                        && foreign_call_executor.encountered_unknown_foreign_call
+                    {
+                        TestStatus::Skipped
+                    } else {
+                        status
+                    }
+                } else {
+                    status
+                }
             } else {
                 #[cfg(target_arch = "wasm32")]
                 {
@@ -79,26 +120,46 @@ pub fn run_test<B: BlackBoxFunctionSolver<FieldElement>>(
                 {
                     use acvm::acir::circuit::Program;
                     use noir_fuzzer::FuzzedExecutor;
+                    use proptest::test_runner::Config;
                     use proptest::test_runner::TestRunner;
-                    let runner = TestRunner::default();
+
+                    let runner =
+                        TestRunner::new(Config { failure_persistence: None, ..Config::default() });
+
+                    let abi = compiled_program.abi.clone();
+                    let debug = compiled_program.debug.clone();
 
                     let executor =
                         |program: &Program<FieldElement>,
                          initial_witness: WitnessMap<FieldElement>|
                          -> Result<WitnessStack<FieldElement>, String> {
-                            execute_program(
+                            let circuit_execution = execute_program(
                                 program,
                                 initial_witness,
                                 blackbox_solver,
-                                &mut DefaultForeignCallExecutor::<FieldElement>::new(
-                                    false,
+                                &mut TestForeignCallExecutor::<FieldElement>::new(
+                                    PrintOutput::None,
                                     foreign_call_resolver_url,
                                     root_path.clone(),
                                     package_name.clone(),
                                 ),
-                            )
-                            .map_err(|err| err.to_string())
+                            );
+
+                            let status = test_status_program_compile_pass(
+                                test_function,
+                                &abi,
+                                &debug,
+                                &circuit_execution,
+                            );
+
+                            if let TestStatus::Fail { message, error_diagnostic: _ } = status {
+                                Err(message)
+                            } else {
+                                // The fuzzer doesn't care about the actual result.
+                                Ok(WitnessStack::default())
+                            }
                         };
+
                     let fuzzer = FuzzedExecutor::new(compiled_program.into(), executor, runner);
 
                     let result = fuzzer.fuzz();
@@ -138,9 +199,9 @@ fn test_status_program_compile_fail(err: CompileError, test_function: &TestFunct
 /// passed/failed to determine the test status.
 fn test_status_program_compile_pass(
     test_function: &TestFunction,
-    abi: Abi,
-    debug: Vec<DebugInfo>,
-    circuit_execution: Result<WitnessStack<FieldElement>, NargoError<FieldElement>>,
+    abi: &Abi,
+    debug: &[DebugInfo],
+    circuit_execution: &Result<WitnessStack<FieldElement>, NargoError<FieldElement>>,
 ) -> TestStatus {
     let circuit_execution_err = match circuit_execution {
         // Circuit execution was successful; ie no errors or unsatisfied constraints
@@ -160,7 +221,7 @@ fn test_status_program_compile_pass(
     // If we reach here, then the circuit execution failed.
     //
     // Check if the function should have passed
-    let diagnostic = try_to_diagnose_runtime_error(&circuit_execution_err, &abi, &debug);
+    let diagnostic = try_to_diagnose_runtime_error(circuit_execution_err, abi, debug);
     let test_should_have_passed = !test_function.should_fail();
     if test_should_have_passed {
         return TestStatus::Fail {
@@ -215,3 +276,87 @@ fn check_expected_failure_message(
         error_diagnostic,
     }
 }
+
+/// A specialized foreign call executor which tracks whether it has encountered any unknown foreign calls
+struct TestForeignCallExecutor<'a, F> {
+    /// The executor for any [`ForeignCall::Print`] calls.
+    printer: PrintForeignCallExecutor<'a>,
+    mocker: MockForeignCallExecutor<F>,
+    external: Option<RPCForeignCallExecutor>,
+
+    encountered_unknown_foreign_call: bool,
+}
+
+impl<'a, F: Default> TestForeignCallExecutor<'a, F> {
+    fn new(
+        output: PrintOutput<'a>,
+        resolver_url: Option<&str>,
+        root_path: Option<PathBuf>,
+        package_name: Option<String>,
+    ) -> Self {
+        let id = rand::thread_rng().gen();
+        let printer = PrintForeignCallExecutor { output };
+        let external_resolver = resolver_url.map(|resolver_url| {
+            RPCForeignCallExecutor::new(resolver_url, id, root_path, package_name)
+        });
+        TestForeignCallExecutor {
+            printer,
+            mocker: MockForeignCallExecutor::default(),
+            external: external_resolver,
+            encountered_unknown_foreign_call: false,
+        }
+    }
+}
+
+impl<'a, F: AcirField + Serialize + for<'b> Deserialize<'b>> ForeignCallExecutor<F>
+    for TestForeignCallExecutor<'a, F>
+{
+    fn execute(
+        &mut self,
+        foreign_call: &ForeignCallWaitInfo<F>,
+    ) -> Result<ForeignCallResult<F>, ForeignCallError> {
+        // If the circuit has reached a new foreign call opcode then it can't have failed from any previous unknown foreign calls.
+        self.encountered_unknown_foreign_call = false;
+
+        let foreign_call_name = foreign_call.function.as_str();
+        match ForeignCall::lookup(foreign_call_name) {
+            Some(ForeignCall::Print) => self.printer.execute(foreign_call),
+
+            Some(
+                ForeignCall::CreateMock
+                | ForeignCall::SetMockParams
+                | ForeignCall::GetMockLastParams
+                | ForeignCall::SetMockReturns
+                | ForeignCall::SetMockTimes
+                | ForeignCall::ClearMock,
+            ) => self.mocker.execute(foreign_call),
+
+            None => {
+                // First check if there's any defined mock responses for this foreign call.
+                match self.mocker.execute(foreign_call) {
+                    Err(ForeignCallError::NoHandler(_)) => (),
+                    response_or_error => return response_or_error,
+                };
+
+                if let Some(external_resolver) = &mut self.external {
+                    // If the user has registered an external resolver then we forward any remaining oracle calls there.
+                    match external_resolver.execute(foreign_call) {
+                        Err(ForeignCallError::NoHandler(_)) => (),
+                        response_or_error => return response_or_error,
+                    };
+                }
+
+                self.encountered_unknown_foreign_call = true;
+
+                // If all executors have no handler for the given foreign call then we cannot
+                // return a correct response to the ACVM. The best we can do is to return an empty response,
+                // this allows us to ignore any foreign calls which exist solely to pass information from inside
+                // the circuit to the environment (e.g. custom logging) as the execution will still be able to progress.
+                //
+                // We optimistically return an empty response for all oracle calls as the ACVM will error
+                // should a response have been required.
+                Ok(ForeignCallResult::default())
+            }
+        }
+    }
+}
diff --git a/tooling/nargo/src/ops/transform.rs b/tooling/nargo/src/ops/transform.rs
index 9255ac3e0ec..fdda368d150 100644
--- a/tooling/nargo/src/ops/transform.rs
+++ b/tooling/nargo/src/ops/transform.rs
@@ -6,6 +6,7 @@ use iter_extended::vecmap;
 use noirc_driver::{CompiledContract, CompiledProgram};
 use noirc_errors::debug_info::DebugInfo;
 
+/// Apply ACVM optimizations on the circuit.
 pub fn transform_program(
     mut compiled_program: CompiledProgram,
     expression_width: ExpressionWidth,
@@ -18,6 +19,7 @@ pub fn transform_program(
     compiled_program
 }
 
+/// Apply the optimizing transformation on each function in the contract.
 pub fn transform_contract(
     contract: CompiledContract,
     expression_width: ExpressionWidth,
@@ -25,7 +27,6 @@ pub fn transform_contract(
     let functions = vecmap(contract.functions, |mut func| {
         func.bytecode =
             transform_program_internal(func.bytecode, &mut func.debug, expression_width);
-
         func
     });
 
diff --git a/tooling/nargo_cli/Cargo.toml b/tooling/nargo_cli/Cargo.toml
index 284be56d247..5603b7f4fca 100644
--- a/tooling/nargo_cli/Cargo.toml
+++ b/tooling/nargo_cli/Cargo.toml
@@ -25,6 +25,7 @@ toml.workspace = true
 [dependencies]
 clap.workspace = true
 fm.workspace = true
+fxhash.workspace = true
 iter-extended.workspace = true
 nargo.workspace = true
 nargo_fmt.workspace = true
@@ -45,7 +46,12 @@ prettytable-rs = "0.10"
 rayon.workspace = true
 thiserror.workspace = true
 tower.workspace = true
-async-lsp = { workspace = true, features = ["client-monitor", "stdio", "tracing", "tokio"] }
+async-lsp = { workspace = true, features = [
+    "client-monitor",
+    "stdio",
+    "tracing",
+    "tokio",
+] }
 const_format.workspace = true
 similar-asserts.workspace = true
 termcolor = "1.1.2"
@@ -61,22 +67,32 @@ termion = "3.0.0"
 # Logs
 tracing-subscriber.workspace = true
 tracing-appender = "0.2.3"
+clap_complete = "4.5.36"
 
 [target.'cfg(not(unix))'.dependencies]
 tokio-util = { version = "0.7.8", features = ["compat"] }
 
 [dev-dependencies]
+ark-bn254.workspace = true
 tempfile.workspace = true
 dirs.workspace = true
 assert_cmd = "2.0.8"
 assert_fs = "1.0.10"
 predicates = "2.1.5"
+file-lock = "2.1.11"
 fm.workspace = true
 criterion.workspace = true
 pprof.workspace = true
 paste = "1.0.14"
+proptest.workspace = true
+sha2.workspace = true
+sha3.workspace = true
 iai = "0.1.1"
 test-binary = "3.0.2"
+test-case.workspace = true
+lazy_static.workspace = true
+light-poseidon = "0.2.0"
+
 
 [[bench]]
 name = "criterion"
diff --git a/tooling/nargo_cli/benches/README.md b/tooling/nargo_cli/benches/README.md
new file mode 100644
index 00000000000..a579b82bbb5
--- /dev/null
+++ b/tooling/nargo_cli/benches/README.md
@@ -0,0 +1,13 @@
+# Benchmarks 
+
+To generate flamegraphs for the execution of a specific program, execute the following commands:
+
+```shell
+./scripts/benchmark_start.sh
+cargo bench -p nargo_cli --bench criterion <test-program-name> -- --profile-time=30
+./scripts/benchmark_stop.sh
+```
+
+Afterwards the flamegraph is available at `target/criterion/<test-program-name>_execute/profile/flamegraph.svg`
+
+Alternatively, omit `<test-program-name>` to run profiling on all test programs defined in [utils.rs](./utils.rs).
\ No newline at end of file
diff --git a/tooling/nargo_cli/benches/criterion.rs b/tooling/nargo_cli/benches/criterion.rs
index effab7d7c27..9bc50f87d8e 100644
--- a/tooling/nargo_cli/benches/criterion.rs
+++ b/tooling/nargo_cli/benches/criterion.rs
@@ -1,33 +1,169 @@
 //! Select representative tests to bench with criterion
+use acvm::{acir::native_types::WitnessMap, FieldElement};
 use assert_cmd::prelude::{CommandCargoExt, OutputAssertExt};
 use criterion::{criterion_group, criterion_main, Criterion};
 
-use paste::paste;
+use nargo::PrintOutput;
+use noirc_abi::{
+    input_parser::{Format, InputValue},
+    Abi, InputMap,
+};
+use noirc_artifacts::program::ProgramArtifact;
+use noirc_driver::CompiledProgram;
 use pprof::criterion::{Output, PProfProfiler};
+use std::hint::black_box;
+use std::path::Path;
+use std::{cell::RefCell, collections::BTreeMap};
 use std::{process::Command, time::Duration};
+
 include!("./utils.rs");
 
-macro_rules! criterion_command {
-    ($command_name:tt, $command_string:expr) => {
-        paste! {
-            fn [<criterion_selected_tests_ $command_name>](c: &mut Criterion) {
-                let test_program_dirs = get_selected_tests();
-                for test_program_dir in test_program_dirs {
-                    let mut cmd = Command::cargo_bin("nargo").unwrap();
-                    cmd.arg("--program-dir").arg(&test_program_dir);
-                    cmd.arg($command_string);
-                    cmd.arg("--force");
-
-                    let benchmark_name = format!("{}_{}", test_program_dir.file_name().unwrap().to_str().unwrap(), $command_string);
-                    c.bench_function(&benchmark_name, |b| {
-                        b.iter(|| cmd.assert().success())
-                    });
+/// Compile the test program in a sub-process
+/// The `force_brillig` option is used to benchmark the program as if it was executed by the AVM.
+fn compile_program(test_program_dir: &Path, force_brillig: bool) {
+    let mut cmd = Command::cargo_bin("nargo").unwrap();
+    cmd.arg("--program-dir").arg(test_program_dir);
+    cmd.arg("compile");
+    cmd.arg("--force");
+    if force_brillig {
+        cmd.arg("--force-brillig");
+    }
+    cmd.assert().success();
+}
+
+/// Read the bytecode(s) of the program(s) from the compilation artifacts
+/// from all the binary packages. Pair them up with their respective input.
+///
+/// Based on `ExecuteCommand::run`.
+fn read_compiled_programs_and_inputs(
+    dir: &Path,
+) -> Vec<(CompiledProgram, WitnessMap<FieldElement>)> {
+    let toml_path = nargo_toml::get_package_manifest(dir).expect("failed to read manifest");
+    let workspace = nargo_toml::resolve_workspace_from_toml(
+        &toml_path,
+        nargo_toml::PackageSelection::All,
+        Some(noirc_driver::NOIR_ARTIFACT_VERSION_STRING.to_string()),
+    )
+    .expect("failed to resolve workspace");
+
+    let mut programs = Vec::new();
+    let binary_packages = workspace.into_iter().filter(|package| package.is_binary());
+
+    for package in binary_packages {
+        let program_artifact_path = workspace.package_build_path(package);
+        let program: CompiledProgram = read_program_from_file(&program_artifact_path).into();
+
+        let (inputs, _) = read_inputs_from_file(
+            &package.root_dir,
+            nargo::constants::PROVER_INPUT_FILE,
+            Format::Toml,
+            &program.abi,
+        );
+
+        let initial_witness =
+            program.abi.encode(&inputs, None).expect("failed to encode input witness");
+
+        programs.push((program, initial_witness));
+    }
+    programs
+}
+
+/// Read the bytecode and ABI from the compilation output
+fn read_program_from_file(circuit_path: &Path) -> ProgramArtifact {
+    let file_path = circuit_path.with_extension("json");
+    let input_string = std::fs::read(file_path).expect("failed to read artifact file");
+    serde_json::from_slice(&input_string).expect("failed to deserialize artifact")
+}
+
+/// Read the inputs from Prover.toml
+fn read_inputs_from_file(
+    path: &Path,
+    file_name: &str,
+    format: Format,
+    abi: &Abi,
+) -> (InputMap, Option<InputValue>) {
+    if abi.is_empty() {
+        return (BTreeMap::new(), None);
+    }
+
+    let file_path = path.join(file_name).with_extension(format.ext());
+    if !file_path.exists() {
+        if abi.parameters.is_empty() {
+            return (BTreeMap::new(), None);
+        } else {
+            panic!("input file doesn't exist: {}", file_path.display());
+        }
+    }
+
+    let input_string = std::fs::read_to_string(file_path).expect("failed to read input file");
+    let mut input_map = format.parse(&input_string, abi).expect("failed to parse input");
+    let return_value = input_map.remove(noirc_abi::MAIN_RETURN_NAME);
+
+    (input_map, return_value)
+}
+
+/// Use the nargo CLI to compile a test program, then benchmark its execution
+/// by executing the command directly from the benchmark, so that we can have
+/// meaningful flamegraphs about the ACVM.
+fn criterion_test_execution(c: &mut Criterion, test_program_dir: &Path, force_brillig: bool) {
+    let benchmark_name = format!(
+        "{}_execute{}",
+        test_program_dir.file_name().unwrap().to_str().unwrap(),
+        if force_brillig { "_brillig" } else { "" }
+    );
+
+    // The program and its inputs will be populated in the first setup.
+    let artifacts = RefCell::new(None);
+
+    let mut foreign_call_executor =
+        nargo::foreign_calls::DefaultForeignCallExecutor::new(PrintOutput::None, None, None, None);
+
+    c.bench_function(&benchmark_name, |b| {
+        b.iter_batched(
+            || {
+                // Setup will be called many times to set a batch (which we don't use),
+                // but we can compile it only once, and then the executions will not have to do so.
+                // It is done as a setup so that we only compile the test programs that we filter for.
+                if artifacts.borrow().is_some() {
+                    return;
+                }
+                compile_program(test_program_dir, force_brillig);
+                // Parse the artifacts for use in the benchmark routine
+                let programs = read_compiled_programs_and_inputs(test_program_dir);
+                // Warn, but don't stop, if we haven't found any binary packages.
+                if programs.is_empty() {
+                    eprintln!("\nWARNING: There is nothing to benchmark in {benchmark_name}");
+                }
+                // Store them for execution
+                artifacts.replace(Some(programs));
+            },
+            |_| {
+                let artifacts = artifacts.borrow();
+                let artifacts = artifacts.as_ref().expect("setup compiled them");
+
+                for (program, initial_witness) in artifacts {
+                    let _witness_stack = black_box(nargo::ops::execute_program(
+                        black_box(&program.program),
+                        black_box(initial_witness.clone()),
+                        &bn254_blackbox_solver::Bn254BlackBoxSolver,
+                        &mut foreign_call_executor,
+                    ))
+                    .expect("failed to execute program");
                 }
-            }
+            },
+            criterion::BatchSize::SmallInput,
+        );
+    });
+}
+
+/// Go through all the selected tests and executem with and without Brillig.
+fn criterion_selected_tests_execution(c: &mut Criterion) {
+    for test_program_dir in get_selected_tests() {
+        for force_brillig in [false, true] {
+            criterion_test_execution(c, &test_program_dir, force_brillig);
         }
-    };
+    }
 }
-criterion_command!(execution, "execute");
 
 criterion_group! {
     name = execution_benches;
diff --git a/tooling/nargo_cli/benches/utils.rs b/tooling/nargo_cli/benches/utils.rs
index 47968f7e898..37c94241b08 100644
--- a/tooling/nargo_cli/benches/utils.rs
+++ b/tooling/nargo_cli/benches/utils.rs
@@ -6,6 +6,7 @@ fn get_selected_tests() -> Vec<PathBuf> {
         Ok(dir) => PathBuf::from(dir),
         Err(_) => std::env::current_dir().unwrap(),
     };
+
     let test_dir = manifest_dir
         .parent()
         .unwrap()
@@ -15,5 +16,11 @@ fn get_selected_tests() -> Vec<PathBuf> {
         .join("execution_success");
 
     let selected_tests = vec!["struct", "eddsa", "regression"];
-    selected_tests.into_iter().map(|t| test_dir.join(t)).collect()
+    let mut selected_tests =
+        selected_tests.into_iter().map(|t| test_dir.join(t)).collect::<Vec<_>>();
+
+    let test_dir = test_dir.parent().unwrap().join("benchmarks");
+    selected_tests.extend(test_dir.read_dir().unwrap().filter_map(|e| e.ok()).map(|e| e.path()));
+
+    selected_tests
 }
diff --git a/tooling/nargo_cli/build.rs b/tooling/nargo_cli/build.rs
index 9f694080cf5..8db2c1786d8 100644
--- a/tooling/nargo_cli/build.rs
+++ b/tooling/nargo_cli/build.rs
@@ -36,14 +36,13 @@ fn main() {
     generate_compile_success_empty_tests(&mut test_file, &test_dir);
     generate_compile_success_contract_tests(&mut test_file, &test_dir);
     generate_compile_success_no_bug_tests(&mut test_file, &test_dir);
+    generate_compile_success_with_bug_tests(&mut test_file, &test_dir);
     generate_compile_failure_tests(&mut test_file, &test_dir);
 }
 
 /// Some tests are explicitly ignored in brillig due to them failing.
 /// These should be fixed and removed from this list.
-const IGNORED_BRILLIG_TESTS: [&str; 11] = [
-    // Takes a very long time to execute as large loops do not get simplified.
-    "regression_4709",
+const IGNORED_BRILLIG_TESTS: [&str; 10] = [
     // bit sizes for bigint operation doesn't match up.
     "bigint",
     // ICE due to looking for function which doesn't exist.
@@ -59,6 +58,21 @@ const IGNORED_BRILLIG_TESTS: [&str; 11] = [
     "is_unconstrained",
 ];
 
+/// Tests which aren't expected to work with the default inliner cases.
+const INLINER_MIN_OVERRIDES: [(&str, i64); 1] = [
+    // 0 works if PoseidonHasher::write is tagged as `inline_always`, otherwise 22.
+    ("eddsa", 0),
+];
+
+/// Some tests are expected to have warnings
+/// These should be fixed and removed from this list.
+const TESTS_WITH_EXPECTED_WARNINGS: [&str; 2] = [
+    // TODO(https://github.com/noir-lang/noir/issues/6238): remove from list once issue is closed
+    "brillig_cast",
+    // TODO(https://github.com/noir-lang/noir/issues/6238): remove from list once issue is closed
+    "macros_in_comptime",
+];
+
 fn read_test_cases(
     test_data_dir: &Path,
     test_sub_dir: &str,
@@ -67,7 +81,14 @@ fn read_test_cases(
     let test_case_dirs =
         fs::read_dir(test_data_dir).unwrap().flatten().filter(|c| c.path().is_dir());
 
-    test_case_dirs.into_iter().map(|dir| {
+    test_case_dirs.into_iter().filter_map(|dir| {
+        // When switching git branches we might end up with non-empty directories that have a `target`
+        // directory inside them but no `Nargo.toml`.
+        // These "tests" would always fail, but it's okay to ignore them so we do that here.
+        if !dir.path().join("Nargo.toml").exists() {
+            return None;
+        }
+
         let test_name =
             dir.file_name().into_string().expect("Directory can't be converted to string");
         if test_name.contains('-') {
@@ -75,26 +96,131 @@ fn read_test_cases(
                 "Invalid test directory: {test_name}. Cannot include `-`, please convert to `_`"
             );
         }
-        (test_name, dir.path())
+        Some((test_name, dir.path()))
     })
 }
 
-fn generate_test_case(
+#[derive(Default)]
+struct MatrixConfig {
+    // Only used with execution, and only on selected tests.
+    vary_brillig: bool,
+    // Only seems to have an effect on the `execute_success` cases.
+    vary_inliner: bool,
+    // If there is a non-default minimum inliner aggressiveness to use with the brillig tests.
+    min_inliner: i64,
+}
+
+// Enum to be able to preserve readable test labels and also compare to numbers.
+enum Inliner {
+    Min,
+    Default,
+    Max,
+    Custom(i64),
+}
+
+impl Inliner {
+    fn value(&self) -> i64 {
+        match self {
+            Inliner::Min => i64::MIN,
+            Inliner::Default => 0,
+            Inliner::Max => i64::MAX,
+            Inliner::Custom(i) => *i,
+        }
+    }
+    fn label(&self) -> String {
+        match self {
+            Inliner::Min => "i64::MIN".to_string(),
+            Inliner::Default => "0".to_string(),
+            Inliner::Max => "i64::MAX".to_string(),
+            Inliner::Custom(i) => i.to_string(),
+        }
+    }
+}
+
+/// Generate all test cases for a given test name (expected to be unique for the test directory),
+/// based on the matrix configuration. These will be executed serially, but concurrently with
+/// other test directories. Running multiple tests on the same directory would risk overriding
+/// each others compilation artifacts, which is why this method injects a mutex shared by
+/// all cases in the test matrix, as long as the test name and directory has a 1-to-1 relationship.
+fn generate_test_cases(
     test_file: &mut File,
     test_name: &str,
     test_dir: &std::path::Display,
+    test_command: &str,
     test_content: &str,
+    matrix_config: &MatrixConfig,
 ) {
+    let brillig_cases = if matrix_config.vary_brillig { vec![false, true] } else { vec![false] };
+    let inliner_cases = if matrix_config.vary_inliner {
+        let mut cases = vec![Inliner::Min, Inliner::Default, Inliner::Max];
+        if !cases.iter().any(|c| c.value() == matrix_config.min_inliner) {
+            cases.push(Inliner::Custom(matrix_config.min_inliner));
+        }
+        cases
+    } else {
+        vec![Inliner::Default]
+    };
+
+    // We can't use a `#[test_matrix(brillig_cases, inliner_cases)` if we only want to limit the
+    // aggressiveness range for the brillig tests, and let them go full range on the ACIR case.
+    let mut test_cases = Vec::new();
+    for brillig in &brillig_cases {
+        for inliner in &inliner_cases {
+            if *brillig && inliner.value() < matrix_config.min_inliner {
+                continue;
+            }
+            test_cases.push(format!(
+                "#[test_case::test_case(ForceBrillig({brillig}), Inliner({}))]",
+                inliner.label()
+            ));
+        }
+    }
+    let test_cases = test_cases.join("\n");
+
+    // We need to isolate test cases in the same group, otherwise they overwrite each other's artifacts.
+    // On CI we use `cargo nextest`, which runs tests in different processes; for this we use a file lock.
+    // Locally we might be using `cargo test`, which run tests in the same process; in this case the file lock
+    // wouldn't work, becuase the process itself has the lock, and it looks like it can have N instances without
+    // any problems; for this reason we also use a `Mutex`.
+    let mutex_name = format! {"TEST_MUTEX_{}", test_name.to_uppercase()};
     write!(
         test_file,
         r#"
-#[test]
-fn test_{test_name}() {{
+lazy_static::lazy_static! {{
+    /// Prevent concurrent tests in the matrix from overwriting the compilation artifacts in {test_dir}
+    static ref {mutex_name}: std::sync::Mutex<()> = std::sync::Mutex::new(());
+}}
+
+{test_cases}
+fn test_{test_name}(force_brillig: ForceBrillig, inliner_aggressiveness: Inliner) {{
     let test_program_dir = PathBuf::from("{test_dir}");
 
+    // Ignore poisoning errors if some of the matrix cases failed.
+    let mutex_guard = {mutex_name}.lock().unwrap_or_else(|e| e.into_inner());
+
+    let file_guard = file_lock::FileLock::lock(
+        test_program_dir.join("Nargo.toml"),
+        true,
+        file_lock::FileOptions::new().read(true).write(true).append(true)
+    ).expect("failed to lock Nargo.toml");
+
     let mut nargo = Command::cargo_bin("nargo").unwrap();
     nargo.arg("--program-dir").arg(test_program_dir);
+    nargo.arg("{test_command}").arg("--force");
+    nargo.arg("--inliner-aggressiveness").arg(inliner_aggressiveness.0.to_string());
+
+    if force_brillig.0 {{
+        nargo.arg("--force-brillig");
+
+        // Set the maximum increase so that part of the optimization is exercised (it might fail).
+        nargo.arg("--max-bytecode-increase-percent");
+        nargo.arg("50");
+    }}
+
     {test_content}
+
+    drop(file_guard);
+    drop(mutex_guard);
 }}
 "#
     )
@@ -115,27 +241,24 @@ fn generate_execution_success_tests(test_file: &mut File, test_data_dir: &Path)
     for (test_name, test_dir) in test_cases {
         let test_dir = test_dir.display();
 
-        generate_test_case(
+        generate_test_cases(
             test_file,
             &test_name,
             &test_dir,
+            "execute",
             r#"
-                nargo.arg("execute").arg("--force");
-            
-                nargo.assert().success();"#,
+                nargo.assert().success();
+            "#,
+            &MatrixConfig {
+                vary_brillig: !IGNORED_BRILLIG_TESTS.contains(&test_name.as_str()),
+                vary_inliner: true,
+                min_inliner: INLINER_MIN_OVERRIDES
+                    .iter()
+                    .find(|(n, _)| *n == test_name.as_str())
+                    .map(|(_, i)| *i)
+                    .unwrap_or(i64::MIN),
+            },
         );
-
-        if !IGNORED_BRILLIG_TESTS.contains(&test_name.as_str()) {
-            generate_test_case(
-                test_file,
-                &format!("{test_name}_brillig"),
-                &test_dir,
-                r#"
-                nargo.arg("execute").arg("--force").arg("--force-brillig");
-            
-                nargo.assert().success();"#,
-            );
-        }
     }
     writeln!(test_file, "}}").unwrap();
 }
@@ -154,14 +277,15 @@ fn generate_execution_failure_tests(test_file: &mut File, test_data_dir: &Path)
     for (test_name, test_dir) in test_cases {
         let test_dir = test_dir.display();
 
-        generate_test_case(
+        generate_test_cases(
             test_file,
             &test_name,
             &test_dir,
+            "execute",
             r#"
-                nargo.arg("execute").arg("--force");
-            
-                nargo.assert().failure().stderr(predicate::str::contains("The application panicked (crashed).").not());"#,
+                nargo.assert().failure().stderr(predicate::str::contains("The application panicked (crashed).").not());
+            "#,
+            &MatrixConfig::default(),
         );
     }
     writeln!(test_file, "}}").unwrap();
@@ -181,14 +305,15 @@ fn generate_noir_test_success_tests(test_file: &mut File, test_data_dir: &Path)
     for (test_name, test_dir) in test_cases {
         let test_dir = test_dir.display();
 
-        generate_test_case(
+        generate_test_cases(
             test_file,
             &test_name,
             &test_dir,
+            "test",
             r#"
-        nargo.arg("test");
-        
-        nargo.assert().success();"#,
+                nargo.assert().success();
+            "#,
+            &MatrixConfig::default(),
         );
     }
     writeln!(test_file, "}}").unwrap();
@@ -207,14 +332,15 @@ fn generate_noir_test_failure_tests(test_file: &mut File, test_data_dir: &Path)
     .unwrap();
     for (test_name, test_dir) in test_cases {
         let test_dir = test_dir.display();
-        generate_test_case(
+        generate_test_cases(
             test_file,
             &test_name,
             &test_dir,
+            "test",
             r#"
-        nargo.arg("test");
-        
-        nargo.assert().failure();"#,
+                nargo.assert().failure();
+            "#,
+            &MatrixConfig::default(),
         );
     }
     writeln!(test_file, "}}").unwrap();
@@ -234,13 +360,21 @@ fn generate_compile_success_empty_tests(test_file: &mut File, test_data_dir: &Pa
     for (test_name, test_dir) in test_cases {
         let test_dir = test_dir.display();
 
-        let assert_zero_opcodes = r#"
+        let mut assert_zero_opcodes = r#"
         let output = nargo.output().expect("Failed to execute command");
 
         if !output.status.success() {{
             panic!("`nargo info` failed with: {}", String::from_utf8(output.stderr).unwrap_or_default());
         }}
-    
+        "#.to_string();
+
+        if !TESTS_WITH_EXPECTED_WARNINGS.contains(&test_name.as_str()) {
+            assert_zero_opcodes += r#"
+            nargo.assert().success().stderr(predicate::str::contains("warning:").not());
+            "#;
+        }
+
+        assert_zero_opcodes += r#"
         // `compile_success_empty` tests should be able to compile down to an empty circuit.
         let json: serde_json::Value = serde_json::from_slice(&output.stdout).unwrap_or_else(|e| {{
             panic!("JSON was not well-formatted {:?}\n\n{:?}", e, std::str::from_utf8(&output.stdout))
@@ -249,16 +383,18 @@ fn generate_compile_success_empty_tests(test_file: &mut File, test_data_dir: &Pa
         assert_eq!(num_opcodes.as_u64().expect("number of opcodes should fit in a u64"), 0);
         "#;
 
-        generate_test_case(
+        generate_test_cases(
             test_file,
             &test_name,
             &test_dir,
+            "info",
             &format!(
                 r#"
-                nargo.arg("info").arg("--json").arg("--force");
-                
-                {assert_zero_opcodes}"#,
+                nargo.arg("--json");
+                {assert_zero_opcodes}
+            "#,
             ),
+            &MatrixConfig::default(),
         );
     }
     writeln!(test_file, "}}").unwrap();
@@ -278,13 +414,15 @@ fn generate_compile_success_contract_tests(test_file: &mut File, test_data_dir:
     for (test_name, test_dir) in test_cases {
         let test_dir = test_dir.display();
 
-        generate_test_case(
+        generate_test_cases(
             test_file,
             &test_name,
             &test_dir,
+            "compile",
             r#"
-        nargo.arg("compile").arg("--force");
-        nargo.assert().success();"#,
+                nargo.assert().success().stderr(predicate::str::contains("warning:").not());
+            "#,
+            &MatrixConfig::default(),
         );
     }
     writeln!(test_file, "}}").unwrap();
@@ -305,13 +443,44 @@ fn generate_compile_success_no_bug_tests(test_file: &mut File, test_data_dir: &P
     for (test_name, test_dir) in test_cases {
         let test_dir = test_dir.display();
 
-        generate_test_case(
+        generate_test_cases(
             test_file,
             &test_name,
             &test_dir,
+            "compile",
             r#"
-        nargo.arg("compile").arg("--force");
-        nargo.assert().success().stderr(predicate::str::contains("bug:").not());"#,
+                nargo.assert().success().stderr(predicate::str::contains("bug:").not());
+            "#,
+            &MatrixConfig::default(),
+        );
+    }
+    writeln!(test_file, "}}").unwrap();
+}
+
+/// Generate tests for checking that the contract compiles and there are "bugs" in stderr
+fn generate_compile_success_with_bug_tests(test_file: &mut File, test_data_dir: &Path) {
+    let test_type = "compile_success_with_bug";
+    let test_cases = read_test_cases(test_data_dir, test_type);
+
+    writeln!(
+        test_file,
+        "mod {test_type} {{
+        use super::*;
+    "
+    )
+    .unwrap();
+    for (test_name, test_dir) in test_cases {
+        let test_dir = test_dir.display();
+
+        generate_test_cases(
+            test_file,
+            &test_name,
+            &test_dir,
+            "compile",
+            r#"
+                nargo.assert().success().stderr(predicate::str::contains("bug:"));
+            "#,
+            &MatrixConfig::default(),
         );
     }
     writeln!(test_file, "}}").unwrap();
@@ -331,13 +500,15 @@ fn generate_compile_failure_tests(test_file: &mut File, test_data_dir: &Path) {
     for (test_name, test_dir) in test_cases {
         let test_dir = test_dir.display();
 
-        generate_test_case(
+        generate_test_cases(
             test_file,
             &test_name,
             &test_dir,
-            r#"nargo.arg("compile").arg("--force");
-        
-        nargo.assert().failure().stderr(predicate::str::contains("The application panicked (crashed).").not());"#,
+            "compile",
+            r#"
+                nargo.assert().failure().stderr(predicate::str::contains("The application panicked (crashed).").not());
+            "#,
+            &MatrixConfig::default(),
         );
     }
     writeln!(test_file, "}}").unwrap();
diff --git a/tooling/nargo_cli/src/cli/check_cmd.rs b/tooling/nargo_cli/src/cli/check_cmd.rs
index 9059f1dd8e8..c8695a8f626 100644
--- a/tooling/nargo_cli/src/cli/check_cmd.rs
+++ b/tooling/nargo_cli/src/cli/check_cmd.rs
@@ -4,33 +4,25 @@ use clap::Args;
 use fm::FileManager;
 use iter_extended::btree_map;
 use nargo::{
-    errors::CompileError,
-    insert_all_files_for_workspace_into_file_manager,
-    ops::report_errors,
-    package::{CrateName, Package},
-    parse_all, prepare_package,
+    errors::CompileError, insert_all_files_for_workspace_into_file_manager, ops::report_errors,
+    package::Package, parse_all, prepare_package,
 };
-use nargo_toml::{get_package_manifest, resolve_workspace_from_toml, PackageSelection};
+use nargo_toml::{get_package_manifest, resolve_workspace_from_toml};
 use noirc_abi::{AbiParameter, AbiType, MAIN_RETURN_NAME};
 use noirc_driver::{
     check_crate, compute_function_abi, CompileOptions, CrateId, NOIR_ARTIFACT_VERSION_STRING,
 };
 use noirc_frontend::hir::{Context, ParsedFiles};
 
-use super::fs::write_to_file;
 use super::NargoConfig;
+use super::{fs::write_to_file, PackageOptions};
 
 /// Checks the constraint system for errors
 #[derive(Debug, Clone, Args)]
 #[clap(visible_alias = "c")]
 pub(crate) struct CheckCommand {
-    /// The name of the package to check
-    #[clap(long, conflicts_with = "workspace")]
-    package: Option<CrateName>,
-
-    /// Check all packages in the workspace
-    #[clap(long, conflicts_with = "package")]
-    workspace: bool,
+    #[clap(flatten)]
+    pub(super) package_options: PackageOptions,
 
     /// Force overwrite of existing files
     #[clap(long = "overwrite")]
@@ -42,9 +34,7 @@ pub(crate) struct CheckCommand {
 
 pub(crate) fn run(args: CheckCommand, config: NargoConfig) -> Result<(), CliError> {
     let toml_path = get_package_manifest(&config.program_dir)?;
-    let default_selection =
-        if args.workspace { PackageSelection::All } else { PackageSelection::DefaultOrAll };
-    let selection = args.package.map_or(default_selection, PackageSelection::Selected);
+    let selection = args.package_options.package_selection();
     let workspace = resolve_workspace_from_toml(
         &toml_path,
         selection,
diff --git a/tooling/nargo_cli/src/cli/compile_cmd.rs b/tooling/nargo_cli/src/cli/compile_cmd.rs
index 0ad07c91ff4..2ecf6959a94 100644
--- a/tooling/nargo_cli/src/cli/compile_cmd.rs
+++ b/tooling/nargo_cli/src/cli/compile_cmd.rs
@@ -5,10 +5,12 @@ use std::time::Duration;
 use acvm::acir::circuit::ExpressionWidth;
 use fm::FileManager;
 use nargo::ops::{collect_errors, compile_contract, compile_program, report_errors};
-use nargo::package::{CrateName, Package};
+use nargo::package::Package;
 use nargo::workspace::Workspace;
 use nargo::{insert_all_files_for_workspace_into_file_manager, parse_all};
-use nargo_toml::{get_package_manifest, resolve_workspace_from_toml, PackageSelection};
+use nargo_toml::{
+    get_package_manifest, resolve_workspace_from_toml, ManifestError, PackageSelection,
+};
 use noirc_driver::DEFAULT_EXPRESSION_WIDTH;
 use noirc_driver::NOIR_ARTIFACT_VERSION_STRING;
 use noirc_driver::{CompilationResult, CompileOptions, CompiledContract};
@@ -21,19 +23,14 @@ use notify_debouncer_full::new_debouncer;
 use crate::errors::CliError;
 
 use super::fs::program::{read_program_from_file, save_contract_to_file, save_program_to_file};
-use super::NargoConfig;
+use super::{NargoConfig, PackageOptions};
 use rayon::prelude::*;
 
 /// Compile the program and its secret execution trace into ACIR format
 #[derive(Debug, Clone, Args)]
 pub(crate) struct CompileCommand {
-    /// The name of the package to compile
-    #[clap(long, conflicts_with = "workspace")]
-    package: Option<CrateName>,
-
-    /// Compile all packages in the workspace.
-    #[clap(long, conflicts_with = "package")]
-    workspace: bool,
+    #[clap(flatten)]
+    pub(super) package_options: PackageOptions,
 
     #[clap(flatten)]
     compile_options: CompileOptions,
@@ -44,16 +41,8 @@ pub(crate) struct CompileCommand {
 }
 
 pub(crate) fn run(args: CompileCommand, config: NargoConfig) -> Result<(), CliError> {
-    let toml_path = get_package_manifest(&config.program_dir)?;
-    let default_selection =
-        if args.workspace { PackageSelection::All } else { PackageSelection::DefaultOrAll };
-    let selection = args.package.map_or(default_selection, PackageSelection::Selected);
-
-    let workspace = resolve_workspace_from_toml(
-        &toml_path,
-        selection,
-        Some(NOIR_ARTIFACT_VERSION_STRING.to_owned()),
-    )?;
+    let selection = args.package_options.package_selection();
+    let workspace = read_workspace(&config.program_dir, selection)?;
 
     if args.watch {
         watch_workspace(&workspace, &args.compile_options)
@@ -65,6 +54,23 @@ pub(crate) fn run(args: CompileCommand, config: NargoConfig) -> Result<(), CliEr
     Ok(())
 }
 
+/// Read a given program directory into a workspace.
+fn read_workspace(
+    program_dir: &Path,
+    selection: PackageSelection,
+) -> Result<Workspace, ManifestError> {
+    let toml_path = get_package_manifest(program_dir)?;
+
+    let workspace = resolve_workspace_from_toml(
+        &toml_path,
+        selection,
+        Some(NOIR_ARTIFACT_VERSION_STRING.to_owned()),
+    )?;
+
+    Ok(workspace)
+}
+
+/// Continuously recompile the workspace on any Noir file change event.
 fn watch_workspace(workspace: &Workspace, compile_options: &CompileOptions) -> notify::Result<()> {
     let (tx, rx) = std::sync::mpsc::channel();
 
@@ -108,13 +114,21 @@ fn watch_workspace(workspace: &Workspace, compile_options: &CompileOptions) -> n
     Ok(())
 }
 
+/// Parse all files in the workspace.
+fn parse_workspace(workspace: &Workspace) -> (FileManager, ParsedFiles) {
+    let mut file_manager = workspace.new_file_manager();
+    insert_all_files_for_workspace_into_file_manager(workspace, &mut file_manager);
+    let parsed_files = parse_all(&file_manager);
+    (file_manager, parsed_files)
+}
+
+/// Parse and compile the entire workspace, then report errors.
+/// This is the main entry point used by all other commands that need compilation.
 pub(super) fn compile_workspace_full(
     workspace: &Workspace,
     compile_options: &CompileOptions,
 ) -> Result<(), CliError> {
-    let mut workspace_file_manager = workspace.new_file_manager();
-    insert_all_files_for_workspace_into_file_manager(workspace, &mut workspace_file_manager);
-    let parsed_files = parse_all(&workspace_file_manager);
+    let (workspace_file_manager, parsed_files) = parse_workspace(workspace);
 
     let compiled_workspace =
         compile_workspace(&workspace_file_manager, &parsed_files, workspace, compile_options);
@@ -129,6 +143,8 @@ pub(super) fn compile_workspace_full(
     Ok(())
 }
 
+/// Compile binary and contract packages.
+/// Returns the merged warnings or errors.
 fn compile_workspace(
     file_manager: &FileManager,
     parsed_files: &ParsedFiles,
@@ -144,7 +160,8 @@ fn compile_workspace(
     // Compile all of the packages in parallel.
     let program_warnings_or_errors: CompilationResult<()> =
         compile_programs(file_manager, parsed_files, workspace, &binary_packages, compile_options);
-    let contract_warnings_or_errors: CompilationResult<()> = compiled_contracts(
+
+    let contract_warnings_or_errors: CompilationResult<()> = compile_contracts(
         file_manager,
         parsed_files,
         &contract_packages,
@@ -164,6 +181,7 @@ fn compile_workspace(
     }
 }
 
+/// Compile the given binary packages in the workspace.
 fn compile_programs(
     file_manager: &FileManager,
     parsed_files: &ParsedFiles,
@@ -171,6 +189,8 @@ fn compile_programs(
     binary_packages: &[Package],
     compile_options: &CompileOptions,
 ) -> CompilationResult<()> {
+    // Load any existing artifact for a given package, _iff_ it was compiled with the same nargo version.
+    // The loaded circuit includes backend specific transformations, which might be different from the current target.
     let load_cached_program = |package| {
         let program_artifact_path = workspace.package_build_path(package);
         read_program_from_file(program_artifact_path)
@@ -180,19 +200,45 @@ fn compile_programs(
     };
 
     let compile_package = |package| {
+        let cached_program = load_cached_program(package);
+
+        // Hash over the entire compiled program, including any post-compile transformations.
+        // This is used to detect whether `cached_program` is returned by `compile_program`.
+        let cached_hash = cached_program.as_ref().map(fxhash::hash64);
+
+        // Compile the program, or use the cached artifacts if it matches.
         let (program, warnings) = compile_program(
             file_manager,
             parsed_files,
             workspace,
             package,
             compile_options,
-            load_cached_program(package),
+            cached_program,
         )?;
 
+        // Choose the target width for the final, backend specific transformation.
         let target_width =
             get_target_width(package.expression_width, compile_options.expression_width);
-        let program = nargo::ops::transform_program(program, target_width);
 
+        // If the compiled program is the same as the cached one, we don't apply transformations again, unless the target width has changed.
+        // The transformations might not be idempotent, which would risk creating witnesses that don't work with earlier versions,
+        // based on which we might have generated a verifier already.
+        if cached_hash == Some(fxhash::hash64(&program)) {
+            let width_matches = program
+                .program
+                .functions
+                .iter()
+                .all(|circuit| circuit.expression_width == target_width);
+
+            if width_matches {
+                return Ok(((), warnings));
+            }
+        }
+        // Run ACVM optimizations and set the target width.
+        let program = nargo::ops::transform_program(program, target_width);
+        // Check solvability.
+        nargo::ops::check_program(&program)?;
+        // Overwrite the build artifacts with the final circuit, which includes the backend specific transformations.
         save_program_to_file(&program.into(), &package.name, workspace.target_directory_path());
 
         Ok(((), warnings))
@@ -208,7 +254,8 @@ fn compile_programs(
     collect_errors(program_results).map(|(_, warnings)| ((), warnings))
 }
 
-fn compiled_contracts(
+/// Compile the given contracts in the workspace.
+fn compile_contracts(
     file_manager: &FileManager,
     parsed_files: &ParsedFiles,
     contract_packages: &[Package],
@@ -260,3 +307,138 @@ pub(crate) fn get_target_width(
         compile_options_width.unwrap_or(DEFAULT_EXPRESSION_WIDTH)
     }
 }
+
+#[cfg(test)]
+mod tests {
+    use std::{
+        path::{Path, PathBuf},
+        str::FromStr,
+    };
+
+    use clap::Parser;
+    use nargo::ops::compile_program;
+    use nargo_toml::PackageSelection;
+    use noirc_driver::{CompileOptions, CrateName};
+    use rayon::prelude::*;
+
+    use crate::cli::compile_cmd::{get_target_width, parse_workspace, read_workspace};
+
+    /// Try to find the directory that Cargo sets when it is running;
+    /// otherwise fallback to assuming the CWD is the root of the repository
+    /// and append the crate path.
+    fn test_programs_dir() -> PathBuf {
+        let root_dir = match std::env::var("CARGO_MANIFEST_DIR") {
+            Ok(dir) => PathBuf::from(dir).parent().unwrap().parent().unwrap().to_path_buf(),
+            Err(_) => std::env::current_dir().unwrap(),
+        };
+        root_dir.join("test_programs")
+    }
+
+    /// Collect the test programs under a sub-directory.
+    fn read_test_program_dirs(
+        test_programs_dir: &Path,
+        test_sub_dir: &str,
+    ) -> impl Iterator<Item = PathBuf> {
+        let test_case_dir = test_programs_dir.join(test_sub_dir);
+        std::fs::read_dir(test_case_dir)
+            .unwrap()
+            .flatten()
+            .filter(|c| c.path().is_dir())
+            .map(|c| c.path())
+    }
+
+    #[derive(Parser, Debug)]
+    #[command(ignore_errors = true)]
+    struct Options {
+        /// Test name to filter for.
+        ///
+        /// For example:
+        /// ```text
+        /// cargo test -p nargo_cli -- test_transform_program_is_idempotent slice_loop
+        /// ```
+        args: Vec<String>,
+    }
+
+    impl Options {
+        fn package_selection(&self) -> PackageSelection {
+            match self.args.as_slice() {
+                [_test_name, test_program] => {
+                    PackageSelection::Selected(CrateName::from_str(test_program).unwrap())
+                }
+                _ => PackageSelection::DefaultOrAll,
+            }
+        }
+    }
+
+    /// Check that `nargo::ops::transform_program` is idempotent by compiling the
+    /// test programs and running them through the optimizer twice.
+    ///
+    /// This test is here purely because of the convenience of having access to
+    /// the utility functions to process workspaces.
+    #[test]
+    fn test_transform_program_is_idempotent() {
+        let opts = Options::parse();
+
+        let sel = opts.package_selection();
+        let verbose = matches!(sel, PackageSelection::Selected(_));
+
+        let test_workspaces = read_test_program_dirs(&test_programs_dir(), "execution_success")
+            .filter_map(|dir| read_workspace(&dir, sel.clone()).ok())
+            .collect::<Vec<_>>();
+
+        assert!(!test_workspaces.is_empty(), "should find some test workspaces");
+
+        test_workspaces.par_iter().for_each(|workspace| {
+            let (file_manager, parsed_files) = parse_workspace(workspace);
+            let binary_packages = workspace.into_iter().filter(|package| package.is_binary());
+
+            for package in binary_packages {
+                let (program_0, _warnings) = compile_program(
+                    &file_manager,
+                    &parsed_files,
+                    workspace,
+                    package,
+                    &CompileOptions::default(),
+                    None,
+                )
+                .expect("failed to compile");
+
+                let width = get_target_width(package.expression_width, None);
+
+                let program_1 = nargo::ops::transform_program(program_0, width);
+                let program_2 = nargo::ops::transform_program(program_1.clone(), width);
+
+                if verbose {
+                    // Compare where the most likely difference is.
+                    similar_asserts::assert_eq!(
+                        format!("{}", program_1.program),
+                        format!("{}", program_2.program),
+                        "optimization not idempotent for test program '{}'",
+                        package.name
+                    );
+                    assert_eq!(
+                        program_1.program, program_2.program,
+                        "optimization not idempotent for test program '{}'",
+                        package.name
+                    );
+
+                    // Compare the whole content.
+                    similar_asserts::assert_eq!(
+                        serde_json::to_string_pretty(&program_1).unwrap(),
+                        serde_json::to_string_pretty(&program_2).unwrap(),
+                        "optimization not idempotent for test program '{}'",
+                        package.name
+                    );
+                } else {
+                    // Just compare hashes, which would just state that the program failed.
+                    // Then we can use the filter option to zoom in one one to see why.
+                    assert!(
+                        fxhash::hash64(&program_1) == fxhash::hash64(&program_2),
+                        "optimization not idempotent for test program '{}'",
+                        package.name
+                    );
+                }
+            }
+        });
+    }
+}
diff --git a/tooling/nargo_cli/src/cli/debug_cmd.rs b/tooling/nargo_cli/src/cli/debug_cmd.rs
index e837f297475..f4dd607a53e 100644
--- a/tooling/nargo_cli/src/cli/debug_cmd.rs
+++ b/tooling/nargo_cli/src/cli/debug_cmd.rs
@@ -38,7 +38,7 @@ pub(crate) struct DebugCommand {
 
     /// The name of the package to execute
     #[clap(long)]
-    package: Option<CrateName>,
+    pub(super) package: Option<CrateName>,
 
     #[clap(flatten)]
     compile_options: CompileOptions,
diff --git a/tooling/nargo_cli/src/cli/execute_cmd.rs b/tooling/nargo_cli/src/cli/execute_cmd.rs
index 8dc71b1c7e5..49a23a7ea62 100644
--- a/tooling/nargo_cli/src/cli/execute_cmd.rs
+++ b/tooling/nargo_cli/src/cli/execute_cmd.rs
@@ -7,9 +7,10 @@ use clap::Args;
 
 use nargo::constants::PROVER_INPUT_FILE;
 use nargo::errors::try_to_diagnose_runtime_error;
-use nargo::ops::DefaultForeignCallExecutor;
-use nargo::package::{CrateName, Package};
-use nargo_toml::{get_package_manifest, resolve_workspace_from_toml, PackageSelection};
+use nargo::foreign_calls::DefaultForeignCallExecutor;
+use nargo::package::Package;
+use nargo::PrintOutput;
+use nargo_toml::{get_package_manifest, resolve_workspace_from_toml};
 use noirc_abi::input_parser::{Format, InputValue};
 use noirc_abi::InputMap;
 use noirc_artifacts::debug::DebugArtifact;
@@ -17,7 +18,7 @@ use noirc_driver::{CompileOptions, CompiledProgram, NOIR_ARTIFACT_VERSION_STRING
 
 use super::compile_cmd::compile_workspace_full;
 use super::fs::{inputs::read_inputs_from_file, witness::save_witness_to_dir};
-use super::NargoConfig;
+use super::{NargoConfig, PackageOptions};
 use crate::cli::fs::program::read_program_from_file;
 use crate::errors::CliError;
 
@@ -34,13 +35,8 @@ pub(crate) struct ExecuteCommand {
     #[clap(long, short, default_value = PROVER_INPUT_FILE)]
     prover_name: String,
 
-    /// The name of the package to execute
-    #[clap(long, conflicts_with = "workspace")]
-    package: Option<CrateName>,
-
-    /// Execute all packages in the workspace
-    #[clap(long, conflicts_with = "package")]
-    workspace: bool,
+    #[clap(flatten)]
+    pub(super) package_options: PackageOptions,
 
     #[clap(flatten)]
     compile_options: CompileOptions,
@@ -52,9 +48,7 @@ pub(crate) struct ExecuteCommand {
 
 pub(crate) fn run(args: ExecuteCommand, config: NargoConfig) -> Result<(), CliError> {
     let toml_path = get_package_manifest(&config.program_dir)?;
-    let default_selection =
-        if args.workspace { PackageSelection::All } else { PackageSelection::DefaultOrAll };
-    let selection = args.package.map_or(default_selection, PackageSelection::Selected);
+    let selection = args.package_options.package_selection();
     let workspace = resolve_workspace_from_toml(
         &toml_path,
         selection,
@@ -70,8 +64,9 @@ pub(crate) fn run(args: ExecuteCommand, config: NargoConfig) -> Result<(), CliEr
         let program_artifact_path = workspace.package_build_path(package);
         let program: CompiledProgram =
             read_program_from_file(program_artifact_path.clone())?.into();
+        let abi = program.abi.clone();
 
-        let (return_value, witness_stack) = execute_program_and_decode(
+        let results = execute_program_and_decode(
             program,
             package,
             &args.prover_name,
@@ -81,14 +76,27 @@ pub(crate) fn run(args: ExecuteCommand, config: NargoConfig) -> Result<(), CliEr
         )?;
 
         println!("[{}] Circuit witness successfully solved", package.name);
-        if let Some(return_value) = return_value {
+        if let Some(ref return_value) = results.actual_return {
             println!("[{}] Circuit output: {return_value:?}", package.name);
         }
 
         let package_name = package.name.clone().into();
         let witness_name = args.witness_name.as_ref().unwrap_or(&package_name);
-        let witness_path = save_witness_to_dir(witness_stack, witness_name, target_dir)?;
+        let witness_path = save_witness_to_dir(results.witness_stack, witness_name, target_dir)?;
         println!("[{}] Witness saved to {}", package.name, witness_path.display());
+
+        // Sanity checks on the return value after the witness has been saved, so it can be inspected if necessary.
+        if let Some(expected) = results.expected_return {
+            if results.actual_return.as_ref() != Some(&expected) {
+                return Err(CliError::UnexpectedReturn { expected, actual: results.actual_return });
+            }
+        }
+        // We can expect that if the circuit returns something, it should be non-empty after execution.
+        if let Some(ref expected) = abi.return_type {
+            if results.actual_return.is_none() {
+                return Err(CliError::MissingReturn { expected: expected.clone() });
+            }
+        }
     }
     Ok(())
 }
@@ -100,18 +108,24 @@ fn execute_program_and_decode(
     foreign_call_resolver_url: Option<&str>,
     root_path: Option<PathBuf>,
     package_name: Option<String>,
-) -> Result<(Option<InputValue>, WitnessStack<FieldElement>), CliError> {
+) -> Result<ExecutionResults, CliError> {
     // Parse the initial witness values from Prover.toml
-    let (inputs_map, _) =
+    let (inputs_map, expected_return) =
         read_inputs_from_file(&package.root_dir, prover_name, Format::Toml, &program.abi)?;
     let witness_stack =
         execute_program(&program, &inputs_map, foreign_call_resolver_url, root_path, package_name)?;
     // Get the entry point witness for the ABI
     let main_witness =
         &witness_stack.peek().expect("Should have at least one witness on the stack").witness;
-    let (_, return_value) = program.abi.decode(main_witness)?;
+    let (_, actual_return) = program.abi.decode(main_witness)?;
+
+    Ok(ExecutionResults { expected_return, actual_return, witness_stack })
+}
 
-    Ok((return_value, witness_stack))
+struct ExecutionResults {
+    expected_return: Option<InputValue>,
+    actual_return: Option<InputValue>,
+    witness_stack: WitnessStack<FieldElement>,
 }
 
 pub(crate) fn execute_program(
@@ -128,7 +142,7 @@ pub(crate) fn execute_program(
         initial_witness,
         &Bn254BlackBoxSolver,
         &mut DefaultForeignCallExecutor::new(
-            true,
+            PrintOutput::Stdout,
             foreign_call_resolver_url,
             root_path,
             package_name,
diff --git a/tooling/nargo_cli/src/cli/export_cmd.rs b/tooling/nargo_cli/src/cli/export_cmd.rs
index c3752db7fbd..cb92b987c4e 100644
--- a/tooling/nargo_cli/src/cli/export_cmd.rs
+++ b/tooling/nargo_cli/src/cli/export_cmd.rs
@@ -10,13 +10,11 @@ use nargo::package::Package;
 use nargo::prepare_package;
 use nargo::workspace::Workspace;
 use nargo::{insert_all_files_for_workspace_into_file_manager, parse_all};
-use nargo_toml::{get_package_manifest, resolve_workspace_from_toml, PackageSelection};
+use nargo_toml::{get_package_manifest, resolve_workspace_from_toml};
 use noirc_driver::{
     compile_no_check, CompileOptions, CompiledProgram, NOIR_ARTIFACT_VERSION_STRING,
 };
 
-use noirc_frontend::graph::CrateName;
-
 use clap::Args;
 
 use crate::errors::CliError;
@@ -24,18 +22,13 @@ use crate::errors::CliError;
 use super::check_cmd::check_crate_and_report_errors;
 
 use super::fs::program::save_program_to_file;
-use super::NargoConfig;
+use super::{NargoConfig, PackageOptions};
 
 /// Exports functions marked with #[export] attribute
 #[derive(Debug, Clone, Args)]
 pub(crate) struct ExportCommand {
-    /// The name of the package to compile
-    #[clap(long, conflicts_with = "workspace")]
-    package: Option<CrateName>,
-
-    /// Compile all packages in the workspace
-    #[clap(long, conflicts_with = "package")]
-    workspace: bool,
+    #[clap(flatten)]
+    pub(super) package_options: PackageOptions,
 
     #[clap(flatten)]
     compile_options: CompileOptions,
@@ -43,10 +36,7 @@ pub(crate) struct ExportCommand {
 
 pub(crate) fn run(args: ExportCommand, config: NargoConfig) -> Result<(), CliError> {
     let toml_path = get_package_manifest(&config.program_dir)?;
-    let default_selection =
-        if args.workspace { PackageSelection::All } else { PackageSelection::DefaultOrAll };
-    let selection = args.package.map_or(default_selection, PackageSelection::Selected);
-
+    let selection = args.package_options.package_selection();
     let workspace = resolve_workspace_from_toml(
         &toml_path,
         selection,
diff --git a/tooling/nargo_cli/src/cli/fmt_cmd.rs b/tooling/nargo_cli/src/cli/fmt_cmd.rs
index 66496db517c..7b29a90c5c0 100644
--- a/tooling/nargo_cli/src/cli/fmt_cmd.rs
+++ b/tooling/nargo_cli/src/cli/fmt_cmd.rs
@@ -9,7 +9,7 @@ use noirc_frontend::{hir::def_map::parse_file, parser::ParserError};
 
 use crate::errors::CliError;
 
-use super::NargoConfig;
+use super::{NargoConfig, PackageOptions};
 
 /// Format the Noir files in a workspace
 #[derive(Debug, Clone, Args)]
@@ -17,15 +17,22 @@ pub(crate) struct FormatCommand {
     /// Run noirfmt in check mode
     #[arg(long)]
     check: bool,
+
+    #[clap(flatten)]
+    pub(super) package_options: PackageOptions,
 }
 
 pub(crate) fn run(args: FormatCommand, config: NargoConfig) -> Result<(), CliError> {
     let check_mode = args.check;
 
     let toml_path = get_package_manifest(&config.program_dir)?;
+    let selection = match args.package_options.package_selection() {
+        PackageSelection::DefaultOrAll => PackageSelection::All,
+        other => other,
+    };
     let workspace = resolve_workspace_from_toml(
         &toml_path,
-        PackageSelection::All,
+        selection,
         Some(NOIR_ARTIFACT_VERSION_STRING.to_string()),
     )?;
 
diff --git a/tooling/nargo_cli/src/cli/generate_completion_script_cmd.rs b/tooling/nargo_cli/src/cli/generate_completion_script_cmd.rs
new file mode 100644
index 00000000000..0b8fa1ee3e7
--- /dev/null
+++ b/tooling/nargo_cli/src/cli/generate_completion_script_cmd.rs
@@ -0,0 +1,33 @@
+use clap::{Args, CommandFactory};
+use clap_complete::Shell;
+
+use crate::errors::CliError;
+
+use super::NargoCli;
+
+/// Generates a shell completion script for your favorite shell
+#[derive(Debug, Clone, Args)]
+pub(crate) struct GenerateCompletionScriptCommand {
+    /// The shell to generate completions for. One of: bash, elvish, fish, powershell, zsh
+    pub(crate) shell: String,
+}
+
+pub(crate) fn run(command: GenerateCompletionScriptCommand) -> Result<(), CliError> {
+    let shell = match command.shell.to_lowercase().as_str() {
+        "bash" => Shell::Bash,
+        "elvish" => Shell::Elvish,
+        "fish" => Shell::Fish,
+        "powershell" => Shell::PowerShell,
+        "zsh" => Shell::Zsh,
+        _ => {
+            return Err(CliError::Generic(
+                "Invalid shell. Supported shells are: bash, elvish, fish, powershell, zsh"
+                    .to_string(),
+            ))
+        }
+    };
+
+    clap_complete::generate(shell, &mut NargoCli::command(), "nargo", &mut std::io::stdout());
+
+    Ok(())
+}
diff --git a/tooling/nargo_cli/src/cli/info_cmd.rs b/tooling/nargo_cli/src/cli/info_cmd.rs
index f2e44fa893c..ee8ff32922e 100644
--- a/tooling/nargo_cli/src/cli/info_cmd.rs
+++ b/tooling/nargo_cli/src/cli/info_cmd.rs
@@ -1,23 +1,25 @@
-use std::collections::HashMap;
-
 use acvm::acir::circuit::ExpressionWidth;
+use bn254_blackbox_solver::Bn254BlackBoxSolver;
 use clap::Args;
 use iter_extended::vecmap;
-use nargo::package::{CrateName, Package};
-use nargo_toml::{get_package_manifest, resolve_workspace_from_toml, PackageSelection};
-use noirc_artifacts::{debug::DebugArtifact, program::ProgramArtifact};
+use nargo::{
+    constants::PROVER_INPUT_FILE, foreign_calls::DefaultForeignCallExecutor, package::Package,
+    PrintOutput,
+};
+use nargo_toml::{get_package_manifest, resolve_workspace_from_toml};
+use noirc_abi::input_parser::Format;
+use noirc_artifacts::program::ProgramArtifact;
 use noirc_driver::{CompileOptions, NOIR_ARTIFACT_VERSION_STRING};
-use noirc_errors::{debug_info::OpCodesCount, Location};
 use prettytable::{row, table, Row};
 use rayon::prelude::*;
 use serde::Serialize;
 
-use crate::errors::CliError;
+use crate::{cli::fs::inputs::read_inputs_from_file, errors::CliError};
 
 use super::{
     compile_cmd::{compile_workspace_full, get_target_width},
     fs::program::read_program_from_file,
-    NargoConfig,
+    NargoConfig, PackageOptions,
 };
 
 /// Provides detailed information on each of a program's function (represented by a single circuit)
@@ -28,36 +30,38 @@ use super::{
 #[derive(Debug, Clone, Args)]
 #[clap(visible_alias = "i")]
 pub(crate) struct InfoCommand {
-    /// The name of the package to detail
-    #[clap(long, conflicts_with = "workspace")]
-    package: Option<CrateName>,
-
-    /// Detail all packages in the workspace
-    #[clap(long, conflicts_with = "package")]
-    workspace: bool,
+    #[clap(flatten)]
+    pub(super) package_options: PackageOptions,
 
     /// Output a JSON formatted report. Changes to this format are not currently considered breaking.
     #[clap(long, hide = true)]
     json: bool,
 
-    #[clap(long, hide = true)]
-    profile_info: bool,
+    #[clap(long)]
+    profile_execution: bool,
+
+    /// The name of the toml file which contains the inputs for the prover
+    #[clap(long, short, default_value = PROVER_INPUT_FILE)]
+    prover_name: String,
 
     #[clap(flatten)]
     compile_options: CompileOptions,
 }
 
-pub(crate) fn run(args: InfoCommand, config: NargoConfig) -> Result<(), CliError> {
+pub(crate) fn run(mut args: InfoCommand, config: NargoConfig) -> Result<(), CliError> {
     let toml_path = get_package_manifest(&config.program_dir)?;
-    let default_selection =
-        if args.workspace { PackageSelection::All } else { PackageSelection::DefaultOrAll };
-    let selection = args.package.map_or(default_selection, PackageSelection::Selected);
+    let selection = args.package_options.package_selection();
     let workspace = resolve_workspace_from_toml(
         &toml_path,
         selection,
         Some(NOIR_ARTIFACT_VERSION_STRING.to_string()),
     )?;
 
+    if args.profile_execution {
+        // Execution profiling is only relevant with the Brillig VM
+        // as a constrained circuit should have totally flattened control flow (e.g. loops and if statements).
+        args.compile_options.force_brillig = true;
+    }
     // Compile the full workspace in order to generate any build artifacts.
     compile_workspace_full(&workspace, &args.compile_options)?;
 
@@ -71,25 +75,29 @@ pub(crate) fn run(args: InfoCommand, config: NargoConfig) -> Result<(), CliError
         })
         .collect::<Result<_, _>>()?;
 
-    if args.profile_info {
-        for (_, compiled_program) in &binary_packages {
-            let debug_artifact = DebugArtifact::from(compiled_program.clone());
-            for function_debug in compiled_program.debug_symbols.debug_infos.iter() {
-                let span_opcodes = function_debug.count_span_opcodes();
-                print_span_opcodes(span_opcodes, &debug_artifact);
-            }
-        }
-    }
-
-    let program_info = binary_packages
-        .into_iter()
-        .par_bridge()
-        .map(|(package, program)| {
-            let target_width =
-                get_target_width(package.expression_width, args.compile_options.expression_width);
-            count_opcodes_and_gates_in_program(program, &package, target_width)
-        })
-        .collect();
+    let program_info = if args.profile_execution {
+        assert!(
+            args.compile_options.force_brillig,
+            "Internal CLI Error: --force-brillig must be active when --profile-execution is active"
+        );
+        profile_brillig_execution(
+            binary_packages,
+            &args.prover_name,
+            args.compile_options.expression_width,
+        )?
+    } else {
+        binary_packages
+            .into_iter()
+            .par_bridge()
+            .map(|(package, program)| {
+                let target_width = get_target_width(
+                    package.expression_width,
+                    args.compile_options.expression_width,
+                );
+                count_opcodes_and_gates_in_program(program, &package, target_width)
+            })
+            .collect()
+    };
 
     let info_report = InfoReport { programs: program_info };
 
@@ -114,55 +122,6 @@ pub(crate) fn run(args: InfoCommand, config: NargoConfig) -> Result<(), CliError
     Ok(())
 }
 
-/// Provides profiling information on
-///
-/// Number of OpCodes in relation to Noir source file
-/// and line number information
-fn print_span_opcodes(
-    span_opcodes_map: HashMap<Location, OpCodesCount>,
-    debug_artifact: &DebugArtifact,
-) {
-    let mut pairs: Vec<(&Location, &OpCodesCount)> = span_opcodes_map.iter().collect();
-
-    pairs.sort_by(|a, b| {
-        a.1.acir_size.cmp(&b.1.acir_size).then_with(|| a.1.brillig_size.cmp(&b.1.brillig_size))
-    });
-
-    for (location, opcodes_count) in pairs {
-        let debug_file = debug_artifact.file_map.get(&location.file).unwrap();
-
-        let start_byte = byte_index(&debug_file.source, location.span.start() + 1);
-        let end_byte = byte_index(&debug_file.source, location.span.end() + 1);
-        let range = start_byte..end_byte;
-        let span_content = &debug_file.source[range];
-        let line = debug_artifact.location_line_index(*location).unwrap() + 1;
-        println!(
-            "Ln. {}: {} (ACIR:{}, Brillig:{} opcode|s) in file: {}",
-            line,
-            span_content,
-            opcodes_count.acir_size,
-            opcodes_count.brillig_size,
-            debug_file.path.to_str().unwrap()
-        );
-    }
-}
-fn byte_index(string: &str, index: u32) -> usize {
-    let mut byte_index = 0;
-    let mut char_index = 0;
-
-    #[allow(clippy::explicit_counter_loop)]
-    for (byte_offset, _) in string.char_indices() {
-        if char_index == index {
-            return byte_index;
-        }
-
-        byte_index = byte_offset;
-        char_index += 1;
-    }
-
-    byte_index
-}
-
 #[derive(Debug, Default, Serialize)]
 struct InfoReport {
     programs: Vec<ProgramInfo>,
@@ -275,3 +234,42 @@ fn count_opcodes_and_gates_in_program(
         unconstrained_functions: unconstrained_info,
     }
 }
+
+fn profile_brillig_execution(
+    binary_packages: Vec<(Package, ProgramArtifact)>,
+    prover_name: &str,
+    expression_width: Option<ExpressionWidth>,
+) -> Result<Vec<ProgramInfo>, CliError> {
+    let mut program_info = Vec::new();
+    for (package, program_artifact) in binary_packages.iter() {
+        // Parse the initial witness values from Prover.toml
+        let (inputs_map, _) = read_inputs_from_file(
+            &package.root_dir,
+            prover_name,
+            Format::Toml,
+            &program_artifact.abi,
+        )?;
+        let initial_witness = program_artifact.abi.encode(&inputs_map, None)?;
+
+        let (_, profiling_samples) = nargo::ops::execute_program_with_profiling(
+            &program_artifact.bytecode,
+            initial_witness,
+            &Bn254BlackBoxSolver,
+            &mut DefaultForeignCallExecutor::new(PrintOutput::None, None, None, None),
+        )?;
+
+        let expression_width = get_target_width(package.expression_width, expression_width);
+
+        program_info.push(ProgramInfo {
+            package_name: package.name.to_string(),
+            expression_width,
+            functions: vec![FunctionInfo { name: "main".to_string(), opcodes: 0 }],
+            unconstrained_functions_opcodes: profiling_samples.len(),
+            unconstrained_functions: vec![FunctionInfo {
+                name: "main".to_string(),
+                opcodes: profiling_samples.len(),
+            }],
+        });
+    }
+    Ok(program_info)
+}
diff --git a/tooling/nargo_cli/src/cli/init_cmd.rs b/tooling/nargo_cli/src/cli/init_cmd.rs
index c69775d3323..ffeb5d9ba74 100644
--- a/tooling/nargo_cli/src/cli/init_cmd.rs
+++ b/tooling/nargo_cli/src/cli/init_cmd.rs
@@ -5,7 +5,6 @@ use super::NargoConfig;
 use clap::Args;
 use nargo::constants::{PKG_FILE, SRC_DIR};
 use nargo::package::{CrateName, PackageType};
-use noirc_driver::NOIRC_VERSION;
 use std::path::PathBuf;
 
 /// Create a Noir project in the current directory.
@@ -66,7 +65,6 @@ pub(crate) fn initialize_project(
 name = "{package_name}"
 type = "{package_type}"
 authors = [""]
-compiler_version = ">={NOIRC_VERSION}"
 
 [dependencies]"#
     );
diff --git a/tooling/nargo_cli/src/cli/mod.rs b/tooling/nargo_cli/src/cli/mod.rs
index 10ec38ad1d5..cc72092daa1 100644
--- a/tooling/nargo_cli/src/cli/mod.rs
+++ b/tooling/nargo_cli/src/cli/mod.rs
@@ -1,8 +1,8 @@
 use clap::{Args, Parser, Subcommand};
 use const_format::formatcp;
-use nargo_toml::find_package_root;
-use noirc_driver::NOIR_ARTIFACT_VERSION_STRING;
-use std::path::PathBuf;
+use nargo_toml::{ManifestError, PackageSelection};
+use noirc_driver::{CrateName, NOIR_ARTIFACT_VERSION_STRING};
+use std::path::{Path, PathBuf};
 
 use color_eyre::eyre;
 
@@ -15,6 +15,7 @@ mod debug_cmd;
 mod execute_cmd;
 mod export_cmd;
 mod fmt_cmd;
+mod generate_completion_script_cmd;
 mod info_cmd;
 mod init_cmd;
 mod lsp_cmd;
@@ -51,6 +52,48 @@ pub(crate) struct NargoConfig {
     program_dir: PathBuf,
 }
 
+/// Options for commands that work on either workspace or package scope.
+#[derive(Args, Clone, Debug, Default)]
+pub(crate) struct PackageOptions {
+    /// The name of the package to run the command on.
+    /// By default run on the first one found moving up along the ancestors of the current directory.
+    #[clap(long, conflicts_with = "workspace")]
+    package: Option<CrateName>,
+
+    /// Run on all packages in the workspace
+    #[clap(long, conflicts_with = "package")]
+    workspace: bool,
+}
+
+impl PackageOptions {
+    /// Decide which package to run the command on:
+    /// * `package` if non-empty
+    /// * all packages if `workspace` is `true`
+    /// * otherwise the default package
+    pub(crate) fn package_selection(&self) -> PackageSelection {
+        let default_selection =
+            if self.workspace { PackageSelection::All } else { PackageSelection::DefaultOrAll };
+
+        self.package.clone().map_or(default_selection, PackageSelection::Selected)
+    }
+
+    /// Whether we need to look for the package manifest at the workspace level.
+    /// If a package is specified, it might not be the current package.
+    fn scope(&self) -> CommandScope {
+        if self.workspace || self.package.is_some() {
+            CommandScope::Workspace
+        } else {
+            CommandScope::CurrentPackage
+        }
+    }
+}
+
+enum CommandScope {
+    Workspace,
+    CurrentPackage,
+    Any,
+}
+
 #[non_exhaustive]
 #[derive(Subcommand, Clone, Debug)]
 enum NargoCommand {
@@ -69,6 +112,7 @@ enum NargoCommand {
     Lsp(lsp_cmd::LspCommand),
     #[command(hide = true)]
     Dap(dap_cmd::DapCommand),
+    GenerateCompletionScript(generate_completion_script_cmd::GenerateCompletionScriptCommand),
 }
 
 #[cfg(not(feature = "codegen-docs"))]
@@ -81,11 +125,8 @@ pub(crate) fn start_cli() -> eyre::Result<()> {
     }
 
     // Search through parent directories to find package root if necessary.
-    if !matches!(
-        command,
-        NargoCommand::New(_) | NargoCommand::Init(_) | NargoCommand::Lsp(_) | NargoCommand::Dap(_)
-    ) {
-        config.program_dir = find_package_root(&config.program_dir)?;
+    if let Some(program_dir) = command_dir(&command, &config.program_dir)? {
+        config.program_dir = program_dir;
     }
 
     match command {
@@ -101,6 +142,7 @@ pub(crate) fn start_cli() -> eyre::Result<()> {
         NargoCommand::Lsp(args) => lsp_cmd::run(args, config),
         NargoCommand::Dap(args) => dap_cmd::run(args, config),
         NargoCommand::Fmt(args) => fmt_cmd::run(args, config),
+        NargoCommand::GenerateCompletionScript(args) => generate_completion_script_cmd::run(args),
     }?;
 
     Ok(())
@@ -112,3 +154,56 @@ pub(crate) fn start_cli() -> eyre::Result<()> {
     println!("{markdown}");
     Ok(())
 }
+
+/// Some commands have package options, which we use here to decide whether to
+/// alter `--program-dir` to point at a manifest, depending on whether we want
+/// to work on a specific package or the entire workspace.
+fn command_scope(cmd: &NargoCommand) -> CommandScope {
+    match &cmd {
+        NargoCommand::Check(cmd) => cmd.package_options.scope(),
+        NargoCommand::Compile(cmd) => cmd.package_options.scope(),
+        NargoCommand::Execute(cmd) => cmd.package_options.scope(),
+        NargoCommand::Export(cmd) => cmd.package_options.scope(),
+        NargoCommand::Test(cmd) => cmd.package_options.scope(),
+        NargoCommand::Info(cmd) => cmd.package_options.scope(),
+        NargoCommand::Fmt(cmd) => cmd.package_options.scope(),
+        NargoCommand::Debug(cmd) => {
+            if cmd.package.is_some() {
+                CommandScope::Workspace
+            } else {
+                CommandScope::CurrentPackage
+            }
+        }
+        NargoCommand::New(..)
+        | NargoCommand::Init(..)
+        | NargoCommand::Lsp(..)
+        | NargoCommand::Dap(..)
+        | NargoCommand::GenerateCompletionScript(..) => CommandScope::Any,
+    }
+}
+
+/// A manifest directory we need to change into, if the command needs it.
+fn command_dir(cmd: &NargoCommand, program_dir: &Path) -> Result<Option<PathBuf>, ManifestError> {
+    let workspace = match command_scope(cmd) {
+        CommandScope::Workspace => true,
+        CommandScope::CurrentPackage => false,
+        CommandScope::Any => return Ok(None),
+    };
+    Ok(Some(nargo_toml::find_root(program_dir, workspace)?))
+}
+
+#[cfg(test)]
+mod tests {
+    use clap::Parser;
+    #[test]
+    fn test_parse_invalid_expression_width() {
+        let cmd = "nargo --program-dir . compile --expression-width 1";
+        let res = super::NargoCli::try_parse_from(cmd.split_ascii_whitespace());
+
+        let err = res.expect_err("should fail because of invalid width");
+        assert!(err.to_string().contains("expression-width"));
+        assert!(err
+            .to_string()
+            .contains(acvm::compiler::MIN_EXPRESSION_WIDTH.to_string().as_str()));
+    }
+}
diff --git a/tooling/nargo_cli/src/cli/test_cmd.rs b/tooling/nargo_cli/src/cli/test_cmd.rs
index 7b0201226ef..1fd4ed2d873 100644
--- a/tooling/nargo_cli/src/cli/test_cmd.rs
+++ b/tooling/nargo_cli/src/cli/test_cmd.rs
@@ -1,24 +1,31 @@
-use std::{io::Write, path::PathBuf};
+use std::{
+    collections::{BTreeMap, HashMap},
+    fmt::Display,
+    panic::{catch_unwind, UnwindSafe},
+    path::PathBuf,
+    sync::{mpsc, Mutex},
+    thread,
+    time::Duration,
+};
 
 use acvm::{BlackBoxFunctionSolver, FieldElement};
 use bn254_blackbox_solver::Bn254BlackBoxSolver;
 use clap::Args;
 use fm::FileManager;
+use formatters::{Formatter, JsonFormatter, PrettyFormatter, TerseFormatter};
 use nargo::{
-    insert_all_files_for_workspace_into_file_manager,
-    ops::TestStatus,
-    package::{CrateName, Package},
-    parse_all, prepare_package,
+    insert_all_files_for_workspace_into_file_manager, ops::TestStatus, package::Package, parse_all,
+    prepare_package, workspace::Workspace, PrintOutput,
 };
-use nargo_toml::{get_package_manifest, resolve_workspace_from_toml, PackageSelection};
+use nargo_toml::{get_package_manifest, resolve_workspace_from_toml};
 use noirc_driver::{check_crate, CompileOptions, NOIR_ARTIFACT_VERSION_STRING};
 use noirc_frontend::hir::{FunctionNameMatch, ParsedFiles};
-use rayon::prelude::{IntoParallelIterator, ParallelBridge, ParallelIterator};
-use termcolor::{Color, ColorChoice, ColorSpec, StandardStream, WriteColor};
 
 use crate::{cli::check_cmd::check_crate_and_report_errors, errors::CliError};
 
-use super::NargoConfig;
+use super::{NargoConfig, PackageOptions};
+
+mod formatters;
 
 /// Run the tests for this program
 #[derive(Debug, Clone, Args)]
@@ -35,13 +42,8 @@ pub(crate) struct TestCommand {
     #[clap(long)]
     exact: bool,
 
-    /// The name of the package to test
-    #[clap(long, conflicts_with = "workspace")]
-    package: Option<CrateName>,
-
-    /// Test all packages in the workspace
-    #[clap(long, conflicts_with = "package")]
-    workspace: bool,
+    #[clap(flatten)]
+    pub(super) package_options: PackageOptions,
 
     #[clap(flatten)]
     compile_options: CompileOptions,
@@ -49,22 +51,78 @@ pub(crate) struct TestCommand {
     /// JSON RPC url to solve oracle calls
     #[clap(long)]
     oracle_resolver: Option<String>,
+
+    /// Number of threads used for running tests in parallel
+    #[clap(long, default_value_t = rayon::current_num_threads())]
+    test_threads: usize,
+
+    /// Configure formatting of output
+    #[clap(long)]
+    format: Option<Format>,
+
+    /// Display one character per test instead of one line
+    #[clap(short = 'q', long = "quiet")]
+    quiet: bool,
+}
+
+#[derive(Debug, Copy, Clone, clap::ValueEnum)]
+enum Format {
+    /// Print verbose output
+    Pretty,
+    /// Display one character per test
+    Terse,
+    /// Output a JSON Lines document
+    Json,
+}
+
+impl Format {
+    fn formatter(&self) -> Box<dyn Formatter> {
+        match self {
+            Format::Pretty => Box::new(PrettyFormatter),
+            Format::Terse => Box::new(TerseFormatter),
+            Format::Json => Box::new(JsonFormatter),
+        }
+    }
+}
+
+impl Display for Format {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        match self {
+            Format::Pretty => write!(f, "pretty"),
+            Format::Terse => write!(f, "terse"),
+            Format::Json => write!(f, "json"),
+        }
+    }
 }
 
+struct Test<'a> {
+    name: String,
+    package_name: String,
+    runner: Box<dyn FnOnce() -> (TestStatus, String) + Send + UnwindSafe + 'a>,
+}
+
+struct TestResult {
+    name: String,
+    package_name: String,
+    status: TestStatus,
+    output: String,
+    time_to_run: Duration,
+}
+
+const STACK_SIZE: usize = 4 * 1024 * 1024;
+
 pub(crate) fn run(args: TestCommand, config: NargoConfig) -> Result<(), CliError> {
     let toml_path = get_package_manifest(&config.program_dir)?;
-    let default_selection =
-        if args.workspace { PackageSelection::All } else { PackageSelection::DefaultOrAll };
-    let selection = args.package.map_or(default_selection, PackageSelection::Selected);
+    let selection = args.package_options.package_selection();
     let workspace = resolve_workspace_from_toml(
         &toml_path,
         selection,
         Some(NOIR_ARTIFACT_VERSION_STRING.to_string()),
     )?;
 
-    let mut workspace_file_manager = workspace.new_file_manager();
-    insert_all_files_for_workspace_into_file_manager(&workspace, &mut workspace_file_manager);
-    let parsed_files = parse_all(&workspace_file_manager);
+    let mut file_manager = workspace.new_file_manager();
+    insert_all_files_for_workspace_into_file_manager(&workspace, &mut file_manager);
+    let parsed_files = parse_all(&file_manager);
 
     let pattern = match &args.test_name {
         Some(name) => {
@@ -77,224 +135,388 @@ pub(crate) fn run(args: TestCommand, config: NargoConfig) -> Result<(), CliError
         None => FunctionNameMatch::Anything,
     };
 
-    // Configure a thread pool with a larger stack size to prevent overflowing stack in large programs.
-    // Default is 2MB.
-    let pool = rayon::ThreadPoolBuilder::new().stack_size(4 * 1024 * 1024).build().unwrap();
-    let test_reports: Vec<Vec<(String, TestStatus)>> = pool.install(|| {
-        workspace
-            .into_iter()
-            .par_bridge()
-            .map(|package| {
-                run_tests::<Bn254BlackBoxSolver>(
-                    &workspace_file_manager,
-                    &parsed_files,
-                    package,
-                    pattern,
-                    args.show_output,
-                    args.oracle_resolver.as_deref(),
-                    Some(workspace.root_dir.clone()),
-                    Some(package.name.to_string()),
-                    &args.compile_options,
-                )
-            })
-            .collect::<Result<_, _>>()
-    })?;
-    let test_report: Vec<(String, TestStatus)> = test_reports.into_iter().flatten().collect();
-
-    if test_report.is_empty() {
-        match &pattern {
-            FunctionNameMatch::Exact(pattern) => {
-                return Err(CliError::Generic(
-                    format!("Found 0 tests matching input '{pattern}'.",),
-                ))
-            }
-            FunctionNameMatch::Contains(pattern) => {
-                return Err(CliError::Generic(format!("Found 0 tests containing '{pattern}'.",)))
-            }
-            // If we are running all tests in a crate, having none is not an error
-            FunctionNameMatch::Anything => {}
-        };
-    }
-
-    if test_report.iter().any(|(_, status)| status.failed()) {
-        Err(CliError::Generic(String::new()))
+    let formatter: Box<dyn Formatter> = if let Some(format) = args.format {
+        format.formatter()
+    } else if args.quiet {
+        Box::new(TerseFormatter)
     } else {
-        Ok(())
-    }
-}
+        Box::new(PrettyFormatter)
+    };
 
-#[allow(clippy::too_many_arguments)]
-fn run_tests<S: BlackBoxFunctionSolver<FieldElement> + Default>(
-    file_manager: &FileManager,
-    parsed_files: &ParsedFiles,
-    package: &Package,
-    fn_name: FunctionNameMatch,
-    show_output: bool,
-    foreign_call_resolver_url: Option<&str>,
-    root_path: Option<PathBuf>,
-    package_name: Option<String>,
-    compile_options: &CompileOptions,
-) -> Result<Vec<(String, TestStatus)>, CliError> {
-    let test_functions =
-        get_tests_in_package(file_manager, parsed_files, package, fn_name, compile_options)?;
-
-    let count_all = test_functions.len();
-
-    let plural = if count_all == 1 { "" } else { "s" };
-    println!("[{}] Running {count_all} test function{plural}", package.name);
-
-    let test_report: Vec<(String, TestStatus)> = test_functions
-        .into_par_iter()
-        .map(|test_name| {
-            let status = run_test::<S>(
-                file_manager,
-                parsed_files,
-                package,
-                &test_name,
-                show_output,
-                foreign_call_resolver_url,
-                root_path.clone(),
-                package_name.clone(),
-                compile_options,
-            );
-
-            (test_name, status)
-        })
-        .collect();
-
-    display_test_report(file_manager, package, compile_options, &test_report)?;
-    Ok(test_report)
+    let runner = TestRunner {
+        file_manager: &file_manager,
+        parsed_files: &parsed_files,
+        workspace,
+        args: &args,
+        pattern,
+        num_threads: args.test_threads,
+        formatter,
+    };
+    runner.run()
 }
 
-#[allow(clippy::too_many_arguments)]
-fn run_test<S: BlackBoxFunctionSolver<FieldElement> + Default>(
-    file_manager: &FileManager,
-    parsed_files: &ParsedFiles,
-    package: &Package,
-    fn_name: &str,
-    show_output: bool,
-    foreign_call_resolver_url: Option<&str>,
-    root_path: Option<PathBuf>,
-    package_name: Option<String>,
-    compile_options: &CompileOptions,
-) -> TestStatus {
-    // This is really hacky but we can't share `Context` or `S` across threads.
-    // We then need to construct a separate copy for each test.
-
-    let (mut context, crate_id) = prepare_package(file_manager, parsed_files, package);
-    check_crate(&mut context, crate_id, compile_options)
-        .expect("Any errors should have occurred when collecting test functions");
-
-    let test_functions = context
-        .get_all_test_functions_in_crate_matching(&crate_id, FunctionNameMatch::Exact(fn_name));
-    let (_, test_function) = test_functions.first().expect("Test function should exist");
-
-    let blackbox_solver = S::default();
-
-    nargo::ops::run_test(
-        &blackbox_solver,
-        &mut context,
-        test_function,
-        show_output,
-        foreign_call_resolver_url,
-        root_path,
-        package_name,
-        compile_options,
-    )
+struct TestRunner<'a> {
+    file_manager: &'a FileManager,
+    parsed_files: &'a ParsedFiles,
+    workspace: Workspace,
+    args: &'a TestCommand,
+    pattern: FunctionNameMatch<'a>,
+    num_threads: usize,
+    formatter: Box<dyn Formatter>,
 }
 
-fn get_tests_in_package(
-    file_manager: &FileManager,
-    parsed_files: &ParsedFiles,
-    package: &Package,
-    fn_name: FunctionNameMatch,
-    options: &CompileOptions,
-) -> Result<Vec<String>, CliError> {
-    let (mut context, crate_id) = prepare_package(file_manager, parsed_files, package);
-    check_crate_and_report_errors(&mut context, crate_id, options)?;
-
-    Ok(context
-        .get_all_test_functions_in_crate_matching(&crate_id, fn_name)
-        .into_iter()
-        .map(|(test_name, _)| test_name)
-        .collect())
-}
+impl<'a> TestRunner<'a> {
+    fn run(&self) -> Result<(), CliError> {
+        // First compile all packages and collect their tests
+        let packages_tests = self.collect_packages_tests()?;
+
+        // Now gather all tests and how many are per packages
+        let mut tests = Vec::new();
+        let mut test_count_per_package = BTreeMap::new();
+
+        for (package_name, package_tests) in packages_tests {
+            test_count_per_package.insert(package_name, package_tests.len());
+            tests.extend(package_tests);
+        }
+
+        // Now run all tests in parallel, but show output for each package sequentially
+        let tests_count = tests.len();
+        let all_passed = self.run_all_tests(tests, &test_count_per_package);
+
+        if tests_count == 0 {
+            match &self.pattern {
+                FunctionNameMatch::Exact(pattern) => {
+                    return Err(CliError::Generic(format!(
+                        "Found 0 tests matching input '{pattern}'.",
+                    )))
+                }
+                FunctionNameMatch::Contains(pattern) => {
+                    return Err(CliError::Generic(
+                        format!("Found 0 tests containing '{pattern}'.",),
+                    ))
+                }
+                // If we are running all tests in a crate, having none is not an error
+                FunctionNameMatch::Anything => {}
+            };
+        }
 
-fn display_test_report(
-    file_manager: &FileManager,
-    package: &Package,
-    compile_options: &CompileOptions,
-    test_report: &[(String, TestStatus)],
-) -> Result<(), CliError> {
-    let writer = StandardStream::stderr(ColorChoice::Always);
-    let mut writer = writer.lock();
-
-    for (test_name, test_status) in test_report {
-        write!(writer, "[{}] Testing {test_name}... ", package.name)
-            .expect("Failed to write to stderr");
-        writer.flush().expect("Failed to flush writer");
-
-        match &test_status {
-            TestStatus::Pass { .. } => {
-                writer
-                    .set_color(ColorSpec::new().set_fg(Some(Color::Green)))
-                    .expect("Failed to set color");
-                writeln!(writer, "ok").expect("Failed to write to stderr");
+        if all_passed {
+            Ok(())
+        } else {
+            Err(CliError::Generic(String::new()))
+        }
+    }
+
+    /// Runs all tests. Returns `true` if all tests passed, `false` otherwise.
+    fn run_all_tests(
+        &self,
+        tests: Vec<Test<'a>>,
+        test_count_per_package: &BTreeMap<String, usize>,
+    ) -> bool {
+        let mut all_passed = true;
+
+        for (package_name, total_test_count) in test_count_per_package {
+            self.formatter
+                .package_start_async(package_name, *total_test_count)
+                .expect("Could not display package start");
+        }
+
+        let (sender, receiver) = mpsc::channel();
+        let iter = &Mutex::new(tests.into_iter());
+        thread::scope(|scope| {
+            // Start worker threads
+            for _ in 0..self.num_threads {
+                // Clone sender so it's dropped once the thread finishes
+                let thread_sender = sender.clone();
+                thread::Builder::new()
+                    // Specify a larger-than-default stack size to prevent overflowing stack in large programs.
+                    // (the default is 2MB)
+                    .stack_size(STACK_SIZE)
+                    .spawn_scoped(scope, move || loop {
+                        // Get next test to process from the iterator.
+                        let Some(test) = iter.lock().unwrap().next() else {
+                            break;
+                        };
+
+                        self.formatter
+                            .test_start_async(&test.name, &test.package_name)
+                            .expect("Could not display test start");
+
+                        let time_before_test = std::time::Instant::now();
+                        let (status, output) = match catch_unwind(test.runner) {
+                            Ok((status, output)) => (status, output),
+                            Err(err) => (
+                                TestStatus::Fail {
+                                    message:
+                                        // It seems `panic!("...")` makes the error be `&str`, so we handle this common case
+                                        if let Some(message) = err.downcast_ref::<&str>() {
+                                            message.to_string()
+                                        } else {
+                                            "An unexpected error happened".to_string()
+                                        },
+                                    error_diagnostic: None,
+                                },
+                                String::new(),
+                            ),
+                        };
+                        let time_to_run = time_before_test.elapsed();
+
+                        let test_result = TestResult {
+                            name: test.name,
+                            package_name: test.package_name,
+                            status,
+                            output,
+                            time_to_run,
+                        };
+
+                        self.formatter
+                            .test_end_async(
+                                &test_result,
+                                self.file_manager,
+                                self.args.show_output,
+                                self.args.compile_options.deny_warnings,
+                                self.args.compile_options.silence_warnings,
+                            )
+                            .expect("Could not display test start");
+
+                        if thread_sender.send(test_result).is_err() {
+                            break;
+                        }
+                    })
+                    .unwrap();
             }
-            TestStatus::Fail { message, error_diagnostic } => {
-                writer
-                    .set_color(ColorSpec::new().set_fg(Some(Color::Red)))
-                    .expect("Failed to set color");
-                writeln!(writer, "FAIL\n{message}\n").expect("Failed to write to stderr");
-                if let Some(diag) = error_diagnostic {
-                    noirc_errors::reporter::report_all(
-                        file_manager.as_file_map(),
-                        &[diag.clone()],
-                        compile_options.deny_warnings,
-                        compile_options.silence_warnings,
-                    );
+
+            // Also drop main sender so the channel closes
+            drop(sender);
+
+            // We'll go package by package, but we might get test results from packages ahead of us.
+            // We'll buffer those here and show them all at once when we get to those packages.
+            let mut buffer: HashMap<String, Vec<TestResult>> = HashMap::new();
+            for (package_name, total_test_count) in test_count_per_package {
+                let mut test_report = Vec::new();
+
+                let mut current_test_count = 0;
+                let total_test_count = *total_test_count;
+
+                self.formatter
+                    .package_start_sync(package_name, total_test_count)
+                    .expect("Could not display package start");
+
+                // Check if we have buffered test results for this package
+                if let Some(buffered_tests) = buffer.remove(package_name) {
+                    for test_result in buffered_tests {
+                        self.display_test_result(
+                            &test_result,
+                            current_test_count + 1,
+                            total_test_count,
+                        )
+                        .expect("Could not display test status");
+                        test_report.push(test_result);
+                        current_test_count += 1;
+                    }
+                }
+
+                if current_test_count < total_test_count {
+                    while let Ok(test_result) = receiver.recv() {
+                        if test_result.status.failed() {
+                            all_passed = false;
+                        }
+
+                        // This is a test result from a different package: buffer it.
+                        if &test_result.package_name != package_name {
+                            buffer
+                                .entry(test_result.package_name.clone())
+                                .or_default()
+                                .push(test_result);
+                            continue;
+                        }
+
+                        self.display_test_result(
+                            &test_result,
+                            current_test_count + 1,
+                            total_test_count,
+                        )
+                        .expect("Could not display test status");
+                        test_report.push(test_result);
+                        current_test_count += 1;
+                        if current_test_count == total_test_count {
+                            break;
+                        }
+                    }
                 }
+
+                self.formatter
+                    .package_end(
+                        package_name,
+                        &test_report,
+                        self.file_manager,
+                        self.args.show_output,
+                        self.args.compile_options.deny_warnings,
+                        self.args.compile_options.silence_warnings,
+                    )
+                    .expect("Could not display test report");
             }
-            TestStatus::CompileError(err) => {
-                noirc_errors::reporter::report_all(
-                    file_manager.as_file_map(),
-                    &[err.clone()],
-                    compile_options.deny_warnings,
-                    compile_options.silence_warnings,
-                );
+        });
+
+        all_passed
+    }
+
+    /// Compiles all packages in parallel and returns their tests
+    fn collect_packages_tests(&'a self) -> Result<BTreeMap<String, Vec<Test<'a>>>, CliError> {
+        let mut package_tests = BTreeMap::new();
+        let mut error = None;
+
+        let (sender, receiver) = mpsc::channel();
+        let iter = &Mutex::new(self.workspace.into_iter());
+
+        thread::scope(|scope| {
+            // Start worker threads
+            for _ in 0..self.num_threads {
+                // Clone sender so it's dropped once the thread finishes
+                let thread_sender = sender.clone();
+                thread::Builder::new()
+                    // Specify a larger-than-default stack size to prevent overflowing stack in large programs.
+                    // (the default is 2MB)
+                    .stack_size(STACK_SIZE)
+                    .spawn_scoped(scope, move || loop {
+                        // Get next package to process from the iterator.
+                        let Some(package) = iter.lock().unwrap().next() else {
+                            break;
+                        };
+                        let tests = self.collect_package_tests::<Bn254BlackBoxSolver>(
+                            package,
+                            self.args.oracle_resolver.as_deref(),
+                            Some(self.workspace.root_dir.clone()),
+                            package.name.to_string(),
+                        );
+                        if thread_sender.send((package, tests)).is_err() {
+                            break;
+                        }
+                    })
+                    .unwrap();
             }
+
+            // Also drop main sender so the channel closes
+            drop(sender);
+
+            for (package, tests) in receiver.iter() {
+                match tests {
+                    Ok(tests) => {
+                        package_tests.insert(package.name.to_string(), tests);
+                    }
+                    Err(err) => {
+                        error = Some(err);
+                    }
+                }
+            }
+        });
+
+        if let Some(error) = error {
+            Err(error)
+        } else {
+            Ok(package_tests)
         }
-        writer.reset().expect("Failed to reset writer");
     }
 
-    write!(writer, "[{}] ", package.name).expect("Failed to write to stderr");
+    /// Compiles a single package and returns all of its tests
+    fn collect_package_tests<S: BlackBoxFunctionSolver<FieldElement> + Default>(
+        &'a self,
+        package: &'a Package,
+        foreign_call_resolver_url: Option<&'a str>,
+        root_path: Option<PathBuf>,
+        package_name: String,
+    ) -> Result<Vec<Test<'a>>, CliError> {
+        let test_functions = self.get_tests_in_package(package)?;
+
+        let tests: Vec<Test> = test_functions
+            .into_iter()
+            .map(|test_name| {
+                let test_name_copy = test_name.clone();
+                let root_path = root_path.clone();
+                let package_name_clone = package_name.clone();
+                let package_name_clone2 = package_name.clone();
+                let runner = Box::new(move || {
+                    self.run_test::<S>(
+                        package,
+                        &test_name,
+                        foreign_call_resolver_url,
+                        root_path,
+                        package_name_clone.clone(),
+                    )
+                });
+                Test { name: test_name_copy, package_name: package_name_clone2, runner }
+            })
+            .collect();
 
-    let count_all = test_report.len();
-    let count_failed = test_report.iter().filter(|(_, status)| status.failed()).count();
-    let plural = if count_all == 1 { "" } else { "s" };
-    if count_failed == 0 {
-        writer.set_color(ColorSpec::new().set_fg(Some(Color::Green))).expect("Failed to set color");
-        write!(writer, "{count_all} test{plural} passed").expect("Failed to write to stderr");
-        writer.reset().expect("Failed to reset writer");
-        writeln!(writer).expect("Failed to write to stderr");
-    } else {
-        let count_passed = count_all - count_failed;
-        let plural_failed = if count_failed == 1 { "" } else { "s" };
-        let plural_passed = if count_passed == 1 { "" } else { "s" };
-
-        if count_passed != 0 {
-            writer
-                .set_color(ColorSpec::new().set_fg(Some(Color::Green)))
-                .expect("Failed to set color");
-            write!(writer, "{count_passed} test{plural_passed} passed, ",)
-                .expect("Failed to write to stderr");
-        }
+        Ok(tests)
+    }
+
+    /// Compiles a single package and returns all of its test names
+    fn get_tests_in_package(&'a self, package: &'a Package) -> Result<Vec<String>, CliError> {
+        let (mut context, crate_id) =
+            prepare_package(self.file_manager, self.parsed_files, package);
+        check_crate_and_report_errors(&mut context, crate_id, &self.args.compile_options)?;
 
-        writer.set_color(ColorSpec::new().set_fg(Some(Color::Red))).expect("Failed to set color");
-        writeln!(writer, "{count_failed} test{plural_failed} failed")
-            .expect("Failed to write to stderr");
-        writer.reset().expect("Failed to reset writer");
+        Ok(context
+            .get_all_test_functions_in_crate_matching(&crate_id, self.pattern)
+            .into_iter()
+            .map(|(test_name, _)| test_name)
+            .collect())
+    }
+
+    /// Runs a single test and returns its status together with whatever was printed to stdout
+    /// during the test.
+    fn run_test<S: BlackBoxFunctionSolver<FieldElement> + Default>(
+        &'a self,
+        package: &Package,
+        fn_name: &str,
+        foreign_call_resolver_url: Option<&str>,
+        root_path: Option<PathBuf>,
+        package_name: String,
+    ) -> (TestStatus, String) {
+        // This is really hacky but we can't share `Context` or `S` across threads.
+        // We then need to construct a separate copy for each test.
+
+        let (mut context, crate_id) =
+            prepare_package(self.file_manager, self.parsed_files, package);
+        check_crate(&mut context, crate_id, &self.args.compile_options)
+            .expect("Any errors should have occurred when collecting test functions");
+
+        let test_functions = context
+            .get_all_test_functions_in_crate_matching(&crate_id, FunctionNameMatch::Exact(fn_name));
+        let (_, test_function) = test_functions.first().expect("Test function should exist");
+
+        let blackbox_solver = S::default();
+        let mut output_string = String::new();
+
+        let test_status = nargo::ops::run_test(
+            &blackbox_solver,
+            &mut context,
+            test_function,
+            PrintOutput::String(&mut output_string),
+            foreign_call_resolver_url,
+            root_path,
+            Some(package_name),
+            &self.args.compile_options,
+        );
+        (test_status, output_string)
     }
 
-    Ok(())
+    /// Display the status of a single test
+    fn display_test_result(
+        &'a self,
+        test_result: &'a TestResult,
+        current_test_count: usize,
+        total_test_count: usize,
+    ) -> std::io::Result<()> {
+        self.formatter.test_end_sync(
+            test_result,
+            current_test_count,
+            total_test_count,
+            self.file_manager,
+            self.args.show_output,
+            self.args.compile_options.deny_warnings,
+            self.args.compile_options.silence_warnings,
+        )
+    }
 }
diff --git a/tooling/nargo_cli/src/cli/test_cmd/formatters.rs b/tooling/nargo_cli/src/cli/test_cmd/formatters.rs
new file mode 100644
index 00000000000..1b9b2d50378
--- /dev/null
+++ b/tooling/nargo_cli/src/cli/test_cmd/formatters.rs
@@ -0,0 +1,539 @@
+use std::{io::Write, panic::RefUnwindSafe, time::Duration};
+
+use fm::FileManager;
+use nargo::ops::TestStatus;
+use noirc_errors::{reporter::stack_trace, FileDiagnostic};
+use serde_json::{json, Map};
+use termcolor::{Color, ColorChoice, ColorSpec, StandardStream, StandardStreamLock, WriteColor};
+
+use super::TestResult;
+
+/// A formatter for showing test results.
+///
+/// The order of events is:
+/// 1. Compilation of all packages happen (in parallel). There's no formatter method for this.
+/// 2. If compilation is successful, one `package_start_async` for each package.
+/// 3. For each test, one `test_start_async` event
+///    (there's no `test_start_sync` event because it would happen right before `test_end_sync`)
+/// 4. For each package, sequentially:
+///     a. A `package_start_sync` event
+///     b. One `test_end` event for each test
+///     a. A `package_end` event
+///
+/// The reason we have some `sync` and `async` events is that formatters that show output
+/// to humans rely on the `sync` events to show a more predictable output (package by package),
+/// and formatters that output to a machine-readable format (like JSON) rely on the `async`
+/// events to show things as soon as they happen, regardless of a package ordering.
+pub(super) trait Formatter: Send + Sync + RefUnwindSafe {
+    fn package_start_async(&self, package_name: &str, test_count: usize) -> std::io::Result<()>;
+
+    fn package_start_sync(&self, package_name: &str, test_count: usize) -> std::io::Result<()>;
+
+    fn test_start_async(&self, name: &str, package_name: &str) -> std::io::Result<()>;
+
+    #[allow(clippy::too_many_arguments)]
+    fn test_end_async(
+        &self,
+        test_result: &TestResult,
+        file_manager: &FileManager,
+        show_output: bool,
+        deny_warnings: bool,
+        silence_warnings: bool,
+    ) -> std::io::Result<()>;
+
+    #[allow(clippy::too_many_arguments)]
+    fn test_end_sync(
+        &self,
+        test_result: &TestResult,
+        current_test_count: usize,
+        total_test_count: usize,
+        file_manager: &FileManager,
+        show_output: bool,
+        deny_warnings: bool,
+        silence_warnings: bool,
+    ) -> std::io::Result<()>;
+
+    fn package_end(
+        &self,
+        package_name: &str,
+        test_results: &[TestResult],
+        file_manager: &FileManager,
+        show_output: bool,
+        deny_warnings: bool,
+        silence_warnings: bool,
+    ) -> std::io::Result<()>;
+}
+
+pub(super) struct PrettyFormatter;
+
+impl Formatter for PrettyFormatter {
+    fn package_start_async(&self, _package_name: &str, _test_count: usize) -> std::io::Result<()> {
+        Ok(())
+    }
+
+    fn package_start_sync(&self, package_name: &str, test_count: usize) -> std::io::Result<()> {
+        package_start(package_name, test_count)
+    }
+
+    fn test_start_async(&self, _name: &str, _package_name: &str) -> std::io::Result<()> {
+        Ok(())
+    }
+
+    fn test_end_async(
+        &self,
+        _test_result: &TestResult,
+        _file_manager: &FileManager,
+        _show_output: bool,
+        _deny_warnings: bool,
+        _silence_warnings: bool,
+    ) -> std::io::Result<()> {
+        Ok(())
+    }
+
+    fn test_end_sync(
+        &self,
+        test_result: &TestResult,
+        _current_test_count: usize,
+        _total_test_count: usize,
+        file_manager: &FileManager,
+        show_output: bool,
+        deny_warnings: bool,
+        silence_warnings: bool,
+    ) -> std::io::Result<()> {
+        let writer = StandardStream::stderr(ColorChoice::Always);
+        let mut writer = writer.lock();
+
+        let is_slow = test_result.time_to_run >= Duration::from_secs(30);
+        let show_time = |writer: &mut StandardStreamLock<'_>| {
+            if is_slow {
+                write!(writer, " <{:.3}s>", test_result.time_to_run.as_secs_f64())
+            } else {
+                Ok(())
+            }
+        };
+
+        write!(writer, "[{}] Testing {}... ", &test_result.package_name, &test_result.name)?;
+        writer.flush()?;
+
+        match &test_result.status {
+            TestStatus::Pass { .. } => {
+                writer.set_color(ColorSpec::new().set_fg(Some(Color::Green)))?;
+                write!(writer, "ok")?;
+                writer.reset()?;
+                show_time(&mut writer)?;
+                writeln!(writer)?;
+            }
+            TestStatus::Fail { message, error_diagnostic } => {
+                writer.set_color(ColorSpec::new().set_fg(Some(Color::Red)))?;
+                write!(writer, "FAIL\n{message}\n")?;
+                writer.reset()?;
+                show_time(&mut writer)?;
+                writeln!(writer)?;
+                if let Some(diag) = error_diagnostic {
+                    noirc_errors::reporter::report_all(
+                        file_manager.as_file_map(),
+                        &[diag.clone()],
+                        deny_warnings,
+                        silence_warnings,
+                    );
+                }
+            }
+            TestStatus::Skipped { .. } => {
+                writer.set_color(ColorSpec::new().set_fg(Some(Color::Yellow)))?;
+                write!(writer, "skipped")?;
+                writer.reset()?;
+                show_time(&mut writer)?;
+                writeln!(writer)?;
+            }
+            TestStatus::CompileError(file_diagnostic) => {
+                noirc_errors::reporter::report_all(
+                    file_manager.as_file_map(),
+                    &[file_diagnostic.clone()],
+                    deny_warnings,
+                    silence_warnings,
+                );
+            }
+        }
+
+        if show_output && !test_result.output.is_empty() {
+            writeln!(writer, "--- {} stdout ---", test_result.name)?;
+            write!(writer, "{}", test_result.output)?;
+            let name_len = test_result.name.len();
+            writeln!(writer, "{}", "-".repeat(name_len + "---  stdout ---".len()))
+        } else {
+            Ok(())
+        }
+    }
+
+    fn package_end(
+        &self,
+        package_name: &str,
+        test_results: &[TestResult],
+        _file_manager: &FileManager,
+        _show_output: bool,
+        _deny_warnings: bool,
+        _silence_warnings: bool,
+    ) -> std::io::Result<()> {
+        let writer = StandardStream::stderr(ColorChoice::Always);
+        let mut writer = writer.lock();
+
+        let failed_tests: Vec<_> = test_results
+            .iter()
+            .filter_map(|test_result| test_result.status.failed().then_some(&test_result.name))
+            .collect();
+
+        if !failed_tests.is_empty() {
+            writeln!(writer)?;
+            writeln!(writer, "[{}] Failures:", package_name)?;
+            for failed_test in failed_tests {
+                writeln!(writer, "     {}", failed_test)?;
+            }
+            writeln!(writer)?;
+        }
+
+        write!(writer, "[{}] ", package_name)?;
+
+        let count_all = test_results.len();
+        let count_failed =
+            test_results.iter().filter(|test_result| test_result.status.failed()).count();
+        let plural = if count_all == 1 { "" } else { "s" };
+        if count_failed == 0 {
+            writer.set_color(ColorSpec::new().set_fg(Some(Color::Green)))?;
+            write!(writer, "{count_all} test{plural} passed")?;
+            writer.reset()?;
+            writeln!(writer)?;
+        } else {
+            let count_passed = count_all - count_failed;
+            let plural_failed = if count_failed == 1 { "" } else { "s" };
+            let plural_passed = if count_passed == 1 { "" } else { "s" };
+
+            if count_passed != 0 {
+                writer.set_color(ColorSpec::new().set_fg(Some(Color::Green)))?;
+                write!(writer, "{count_passed} test{plural_passed} passed, ")?;
+            }
+
+            writer.set_color(ColorSpec::new().set_fg(Some(Color::Red)))?;
+            writeln!(writer, "{count_failed} test{plural_failed} failed")?;
+            writer.reset()?;
+        }
+
+        Ok(())
+    }
+}
+
+pub(super) struct TerseFormatter;
+
+impl Formatter for TerseFormatter {
+    fn package_start_async(&self, _package_name: &str, _test_count: usize) -> std::io::Result<()> {
+        Ok(())
+    }
+
+    fn package_start_sync(&self, package_name: &str, test_count: usize) -> std::io::Result<()> {
+        package_start(package_name, test_count)
+    }
+
+    fn test_start_async(&self, _name: &str, _package_name: &str) -> std::io::Result<()> {
+        Ok(())
+    }
+
+    fn test_end_async(
+        &self,
+        _test_result: &TestResult,
+        _file_manager: &FileManager,
+        _show_output: bool,
+        _deny_warnings: bool,
+        _silence_warnings: bool,
+    ) -> std::io::Result<()> {
+        Ok(())
+    }
+
+    fn test_end_sync(
+        &self,
+        test_result: &TestResult,
+        current_test_count: usize,
+        total_test_count: usize,
+        _file_manager: &FileManager,
+        _show_output: bool,
+        _deny_warnings: bool,
+        _silence_warnings: bool,
+    ) -> std::io::Result<()> {
+        let writer = StandardStream::stderr(ColorChoice::Always);
+        let mut writer = writer.lock();
+
+        match &test_result.status {
+            TestStatus::Pass => {
+                writer.set_color(ColorSpec::new().set_fg(Some(Color::Green)))?;
+                write!(writer, ".")?;
+                writer.reset()?;
+            }
+            TestStatus::Fail { .. } | TestStatus::CompileError(_) => {
+                writer.set_color(ColorSpec::new().set_fg(Some(Color::Red)))?;
+                write!(writer, "F")?;
+                writer.reset()?;
+            }
+            TestStatus::Skipped => {
+                writer.set_color(ColorSpec::new().set_fg(Some(Color::Yellow)))?;
+                write!(writer, "s")?;
+                writer.reset()?;
+            }
+        }
+
+        // How many tests ('.', 'F', etc.) to print per line.
+        // We use 88 which is a bit more than the traditional 80 columns (screens are larger these days)
+        // but we also want the output to be readable in case the terminal isn't maximized.
+        const MAX_TESTS_PER_LINE: usize = 88;
+
+        if current_test_count % MAX_TESTS_PER_LINE == 0 && current_test_count < total_test_count {
+            writeln!(writer, " {}/{}", current_test_count, total_test_count)?;
+        }
+
+        Ok(())
+    }
+
+    fn package_end(
+        &self,
+        package_name: &str,
+        test_results: &[TestResult],
+        file_manager: &FileManager,
+        show_output: bool,
+        deny_warnings: bool,
+        silence_warnings: bool,
+    ) -> std::io::Result<()> {
+        let writer = StandardStream::stderr(ColorChoice::Always);
+        let mut writer = writer.lock();
+
+        if !test_results.is_empty() {
+            writeln!(writer)?;
+        }
+
+        for test_result in test_results {
+            if (show_output && !test_result.output.is_empty()) || test_result.status.failed() {
+                writeln!(writer, "--- {} stdout ---", test_result.name)?;
+                if !test_result.output.is_empty() {
+                    write!(writer, "{}", test_result.output)?;
+                }
+
+                match &test_result.status {
+                    TestStatus::Pass | TestStatus::Skipped => (),
+                    TestStatus::Fail { message, error_diagnostic } => {
+                        writer.set_color(ColorSpec::new().set_fg(Some(Color::Red)))?;
+                        writeln!(writer, "{message}")?;
+                        writer.reset()?;
+                        if let Some(diag) = error_diagnostic {
+                            noirc_errors::reporter::report_all(
+                                file_manager.as_file_map(),
+                                &[diag.clone()],
+                                deny_warnings,
+                                silence_warnings,
+                            );
+                        }
+                    }
+                    TestStatus::CompileError(file_diagnostic) => {
+                        noirc_errors::reporter::report_all(
+                            file_manager.as_file_map(),
+                            &[file_diagnostic.clone()],
+                            deny_warnings,
+                            silence_warnings,
+                        );
+                    }
+                }
+
+                let name_len = test_result.name.len();
+                writeln!(writer, "{}", "-".repeat(name_len + "---  stdout ---".len()))?;
+            }
+        }
+
+        let failed_tests: Vec<_> = test_results
+            .iter()
+            .filter_map(|test_result| test_result.status.failed().then_some(&test_result.name))
+            .collect();
+
+        if !failed_tests.is_empty() {
+            writeln!(writer)?;
+            writeln!(writer, "[{}] Failures:", package_name)?;
+            for failed_test in failed_tests {
+                writeln!(writer, "     {}", failed_test)?;
+            }
+            writeln!(writer)?;
+        }
+
+        write!(writer, "[{}] ", package_name)?;
+
+        let count_all = test_results.len();
+        let count_failed =
+            test_results.iter().filter(|test_result| test_result.status.failed()).count();
+        let plural = if count_all == 1 { "" } else { "s" };
+        if count_failed == 0 {
+            writer.set_color(ColorSpec::new().set_fg(Some(Color::Green)))?;
+            write!(writer, "{count_all} test{plural} passed")?;
+            writer.reset()?;
+            writeln!(writer)?;
+        } else {
+            let count_passed = count_all - count_failed;
+            let plural_failed = if count_failed == 1 { "" } else { "s" };
+            let plural_passed = if count_passed == 1 { "" } else { "s" };
+
+            if count_passed != 0 {
+                writer.set_color(ColorSpec::new().set_fg(Some(Color::Green)))?;
+                write!(writer, "{count_passed} test{plural_passed} passed, ")?;
+            }
+
+            writer.set_color(ColorSpec::new().set_fg(Some(Color::Red)))?;
+            writeln!(writer, "{count_failed} test{plural_failed} failed")?;
+            writer.reset()?;
+        }
+
+        Ok(())
+    }
+}
+
+pub(super) struct JsonFormatter;
+
+impl Formatter for JsonFormatter {
+    fn package_start_async(&self, package_name: &str, test_count: usize) -> std::io::Result<()> {
+        let json = json!({"type": "suite", "event": "started", "name": package_name, "test_count": test_count});
+        println!("{json}");
+        Ok(())
+    }
+
+    fn package_start_sync(&self, _package_name: &str, _test_count: usize) -> std::io::Result<()> {
+        Ok(())
+    }
+
+    fn test_start_async(&self, name: &str, package_name: &str) -> std::io::Result<()> {
+        let json = json!({"type": "test", "event": "started", "name": name, "suite": package_name});
+        println!("{json}");
+        Ok(())
+    }
+
+    fn test_end_async(
+        &self,
+        test_result: &TestResult,
+        file_manager: &FileManager,
+        show_output: bool,
+        _deny_warnings: bool,
+        silence_warnings: bool,
+    ) -> std::io::Result<()> {
+        let mut json = Map::new();
+        json.insert("type".to_string(), json!("test"));
+        json.insert("name".to_string(), json!(&test_result.name));
+        json.insert("exec_time".to_string(), json!(test_result.time_to_run.as_secs_f64()));
+
+        let mut stdout = String::new();
+        if show_output && !test_result.output.is_empty() {
+            stdout.push_str(test_result.output.trim());
+        }
+
+        match &test_result.status {
+            TestStatus::Pass => {
+                json.insert("event".to_string(), json!("ok"));
+            }
+            TestStatus::Fail { message, error_diagnostic } => {
+                json.insert("event".to_string(), json!("failed"));
+
+                if !stdout.is_empty() {
+                    stdout.push('\n');
+                }
+                stdout.push_str(message.trim());
+
+                if let Some(diagnostic) = error_diagnostic {
+                    if !(diagnostic.diagnostic.is_warning() && silence_warnings) {
+                        stdout.push('\n');
+                        stdout.push_str(&diagnostic_to_string(diagnostic, file_manager));
+                    }
+                }
+            }
+            TestStatus::Skipped => {
+                json.insert("event".to_string(), json!("ignored"));
+            }
+            TestStatus::CompileError(diagnostic) => {
+                json.insert("event".to_string(), json!("failed"));
+
+                if !(diagnostic.diagnostic.is_warning() && silence_warnings) {
+                    if !stdout.is_empty() {
+                        stdout.push('\n');
+                    }
+                    stdout.push_str(&diagnostic_to_string(diagnostic, file_manager));
+                }
+            }
+        }
+
+        if !stdout.is_empty() {
+            json.insert("stdout".to_string(), json!(stdout));
+        }
+
+        let json = json!(json);
+        println!("{json}");
+
+        Ok(())
+    }
+
+    fn test_end_sync(
+        &self,
+        _test_result: &TestResult,
+        _current_test_count: usize,
+        _total_test_count: usize,
+        _file_manager: &FileManager,
+        _show_output: bool,
+        _deny_warnings: bool,
+        _silence_warnings: bool,
+    ) -> std::io::Result<()> {
+        Ok(())
+    }
+
+    fn package_end(
+        &self,
+        _package_name: &str,
+        test_results: &[TestResult],
+        _file_manager: &FileManager,
+        _show_output: bool,
+        _deny_warnings: bool,
+        _silence_warnings: bool,
+    ) -> std::io::Result<()> {
+        let mut passed = 0;
+        let mut failed = 0;
+        let mut ignored = 0;
+        for test_result in test_results {
+            match &test_result.status {
+                TestStatus::Pass => passed += 1,
+                TestStatus::Fail { .. } | TestStatus::CompileError(..) => failed += 1,
+                TestStatus::Skipped => ignored += 1,
+            }
+        }
+        let event = if failed == 0 { "ok" } else { "failed" };
+        let json = json!({"type": "suite", "event": event, "passed": passed, "failed": failed, "ignored": ignored});
+        println!("{json}");
+        Ok(())
+    }
+}
+
+fn package_start(package_name: &str, test_count: usize) -> std::io::Result<()> {
+    let plural = if test_count == 1 { "" } else { "s" };
+    println!("[{package_name}] Running {test_count} test function{plural}");
+    Ok(())
+}
+
+fn diagnostic_to_string(file_diagnostic: &FileDiagnostic, file_manager: &FileManager) -> String {
+    let file_map = file_manager.as_file_map();
+
+    let custom_diagnostic = &file_diagnostic.diagnostic;
+    let mut message = String::new();
+    message.push_str(custom_diagnostic.message.trim());
+
+    for note in &custom_diagnostic.notes {
+        message.push('\n');
+        message.push_str(note.trim());
+    }
+
+    if let Ok(name) = file_map.get_name(file_diagnostic.file_id) {
+        message.push('\n');
+        message.push_str(&format!("at {name}"));
+    }
+
+    if !custom_diagnostic.call_stack.is_empty() {
+        message.push('\n');
+        message.push_str(&stack_trace(file_map, &custom_diagnostic.call_stack));
+    }
+
+    message
+}
diff --git a/tooling/nargo_cli/src/errors.rs b/tooling/nargo_cli/src/errors.rs
index b28012ae7aa..9255d6fc6a6 100644
--- a/tooling/nargo_cli/src/errors.rs
+++ b/tooling/nargo_cli/src/errors.rs
@@ -2,7 +2,11 @@ use acvm::{acir::native_types::WitnessStackError, FieldElement};
 use nargo::{errors::CompileError, NargoError};
 use nargo_toml::ManifestError;
 use noir_debugger::errors::DapError;
-use noirc_abi::errors::{AbiError, InputParserError};
+use noirc_abi::{
+    errors::{AbiError, InputParserError},
+    input_parser::InputValue,
+    AbiReturnType,
+};
 use std::path::PathBuf;
 use thiserror::Error;
 
@@ -32,6 +36,7 @@ pub(crate) enum FilesystemError {
 pub(crate) enum CliError {
     #[error("{0}")]
     Generic(String),
+
     #[error("Error: destination {} already exists", .0.display())]
     DestinationAlreadyExists(PathBuf),
 
@@ -63,4 +68,10 @@ pub(crate) enum CliError {
     /// Error from the compilation pipeline
     #[error(transparent)]
     CompileError(#[from] CompileError),
+
+    #[error("Unexpected return value: expected {expected:?}; got {actual:?}")]
+    UnexpectedReturn { expected: InputValue, actual: Option<InputValue> },
+
+    #[error("Missing return witnesses; expected {expected:?}")]
+    MissingReturn { expected: AbiReturnType },
 }
diff --git a/tooling/nargo_cli/tests/execute.rs b/tooling/nargo_cli/tests/execute.rs
index e2bef43b571..561520c57a9 100644
--- a/tooling/nargo_cli/tests/execute.rs
+++ b/tooling/nargo_cli/tests/execute.rs
@@ -14,6 +14,12 @@ mod tests {
 
     test_binary::build_test_binary_once!(mock_backend, "../backend_interface/test-binaries");
 
+    // Utilities to keep the test matrix labels more intuitive.
+    #[derive(Debug, Clone, Copy)]
+    struct ForceBrillig(pub bool);
+    #[derive(Debug, Clone, Copy)]
+    struct Inliner(pub i64);
+
     // include tests generated by `build.rs`
     include!(concat!(env!("OUT_DIR"), "/execute.rs"));
 }
diff --git a/tooling/nargo_cli/tests/stdlib-props.proptest-regressions b/tooling/nargo_cli/tests/stdlib-props.proptest-regressions
new file mode 100644
index 00000000000..d41d504e530
--- /dev/null
+++ b/tooling/nargo_cli/tests/stdlib-props.proptest-regressions
@@ -0,0 +1,8 @@
+# Seeds for failure cases proptest has generated in the past. It is
+# automatically read and these particular cases re-run before any
+# novel cases are generated.
+#
+# It is recommended to check this file in to source control so that
+# everyone who runs the test benefits from these saved cases.
+cc 88db0227d5547742f771c14b1679f6783570b46bf7cf9e6897ee1aca4bd5034d # shrinks to io = SnippetInputOutput { description: "force_brillig = false, max_len = 200", inputs: {"input": Vec([Field(0), Field(0), Field(0), Field(0), Field(0), Field(0), Field(0), Field(0), Field(0), Field(0), Field(0), Field(0), Field(0), Field(0), Field(0), Field(0), Field(0), Field(0), Field(0), Field(0), Field(0), Field(0), Field(0), Field(0), Field(0), Field(0), Field(0), Field(0), Field(0), Field(0), Field(0), Field(0), Field(0), Field(0), Field(0), Field(0), Field(0), Field(0), Field(0), Field(0), Field(0), Field(0), Field(0), Field(0), Field(0), Field(0), Field(0), Field(0), Field(0), Field(0), Field(0), Field(0), Field(0), Field(0), Field(0), Field(1), Field(5), Field(20), Field(133), Field(233), Field(99), Field(2⁶), Field(196), Field(232), Field(0), Field(0), Field(0), Field(0), Field(0), Field(0), Field(0), Field(0), Field(0), Field(0), Field(0), Field(0), Field(0), Field(0), Field(0), Field(0), Field(0), Field(0), Field(0), Field(0), Field(0), Field(0), Field(0), Field(0), Field(0), Field(0), Field(0), Field(0), Field(0), Field(0), Field(0), Field(0), Field(0), Field(0), Field(0), Field(0), Field(0), Field(0), Field(0), Field(0), Field(0), Field(0), Field(0), Field(0), Field(0), Field(0), Field(0), Field(0), Field(0), Field(0), Field(0), Field(0), Field(0), Field(0), Field(0), Field(0), Field(0), Field(0), Field(0), Field(0), Field(0), Field(0), Field(0), Field(0), Field(0), Field(0), Field(0), Field(0), Field(0), Field(0), Field(0), Field(0), Field(0), Field(0), Field(0), Field(0), Field(0), Field(0), Field(0), Field(0), Field(0), Field(0), Field(0), Field(0), Field(0), Field(0), Field(0), Field(0), Field(0), Field(0), Field(0), Field(0), Field(0), Field(0), Field(0), Field(0), Field(0), Field(0), Field(0), Field(0), Field(0), Field(0), Field(0), Field(0), Field(0), Field(0), Field(0), Field(0), Field(0), Field(0), Field(0), Field(0), Field(0), Field(0), Field(0), Field(0), Field(0), Field(0), Field(0), Field(0), Field(0), Field(0), Field(0), Field(0), Field(0), Field(0), Field(0), Field(0), Field(0), Field(0), Field(0), Field(0), Field(0), Field(0), Field(0), Field(0)]), "message_size": Field(2⁶)}, expected_output: Vec([Field(102), Field(26), Field(94), Field(212), Field(102), Field(1), Field(215), Field(217), Field(167), Field(175), Field(158), Field(18), Field(20), Field(244), Field(158), Field(200), Field(2⁷), Field(186), Field(251), Field(243), Field(20), Field(207), Field(22), Field(3), Field(139), Field(81), Field(207), Field(2⁴), Field(50), Field(167), Field(1), Field(163)]) }
+cc 0f334fe0c29748e8d0964d63f0d1f3a4eee536afa665eabc838045d8e1c67792 # shrinks to io = SnippetInputOutput { description: "force_brillig = true, max_len = 135", inputs: {"input": Vec([Field(0), Field(0), Field(0), Field(0), Field(0), Field(0), Field(0), Field(0), Field(0), Field(0), Field(0), Field(0), Field(0), Field(0), Field(0), Field(0), Field(0), Field(0), Field(0), Field(0), Field(0), Field(0), Field(0), Field(0), Field(0), Field(0), Field(0), Field(0), Field(0), Field(0), Field(0), Field(0), Field(0), Field(0), Field(0), Field(0), Field(0), Field(0), Field(0), Field(0), Field(0), Field(0), Field(0), Field(0), Field(0), Field(0), Field(0), Field(0), Field(0), Field(0), Field(0), Field(0), Field(0), Field(0), Field(0), Field(0), Field(29), Field(131), Field(217), Field(115), Field(221), Field(92), Field(23), Field(14), Field(58), Field(90), Field(232), Field(155), Field(59), Field(209), Field(2⁴×15), Field(137), Field(214), Field(129), Field(11), Field(140), Field(99), Field(131), Field(188), Field(159), Field(27), Field(206), Field(89), Field(137), Field(248), Field(30), Field(149), Field(194), Field(121), Field(127), Field(245), Field(202), Field(155), Field(203), Field(122), Field(2⁵), Field(209), Field(194), Field(214), Field(11), Field(82), Field(26), Field(244), Field(34), Field(30), Field(125), Field(83), Field(2⁴×13), Field(30), Field(2⁴×10), Field(85), Field(245), Field(220), Field(211), Field(190), Field(46), Field(159), Field(87), Field(74), Field(51), Field(42), Field(202), Field(230), Field(137), Field(127), Field(29), Field(126), Field(243), Field(106), Field(156), Field(2⁴×6), Field(154), Field(70), Field(100), Field(130)]), "message_size": Field(135)}, expected_output: Vec([Field(149), Field(114), Field(68), Field(219), Field(215), Field(147), Field(139), Field(34), Field(145), Field(204), Field(248), Field(145), Field(21), Field(119), Field(2⁵), Field(125), Field(181), Field(142), Field(106), Field(169), Field(202), Field(111), Field(110), Field(6), Field(210), Field(250), Field(2⁴), Field(110), Field(209), Field(2), Field(33), Field(104)]) }
diff --git a/tooling/nargo_cli/tests/stdlib-props.rs b/tooling/nargo_cli/tests/stdlib-props.rs
new file mode 100644
index 00000000000..a19408bd5fd
--- /dev/null
+++ b/tooling/nargo_cli/tests/stdlib-props.rs
@@ -0,0 +1,345 @@
+use std::{cell::RefCell, collections::BTreeMap, path::Path};
+
+use acvm::{acir::native_types::WitnessStack, AcirField, FieldElement};
+use iter_extended::vecmap;
+use nargo::{
+    foreign_calls::DefaultForeignCallExecutor, ops::execute_program, parse_all, PrintOutput,
+};
+use noirc_abi::input_parser::InputValue;
+use noirc_driver::{
+    compile_main, file_manager_with_stdlib, prepare_crate, CompilationResult, CompileOptions,
+    CompiledProgram, CrateId,
+};
+use noirc_frontend::hir::Context;
+use proptest::prelude::*;
+use sha3::Digest;
+
+/// Inputs and expected output of a snippet encoded in ABI format.
+#[derive(Debug)]
+struct SnippetInputOutput {
+    description: String,
+    inputs: BTreeMap<String, InputValue>,
+    expected_output: InputValue,
+}
+impl SnippetInputOutput {
+    fn new(inputs: Vec<(&str, InputValue)>, output: InputValue) -> Self {
+        Self {
+            description: "".to_string(),
+            inputs: inputs.into_iter().map(|(k, v)| (k.to_string(), v)).collect(),
+            expected_output: output,
+        }
+    }
+
+    /// Attach some description to hint at the scenario we are testing.
+    fn with_description(mut self, description: String) -> Self {
+        self.description = description;
+        self
+    }
+}
+
+/// Prepare a code snippet.
+fn prepare_snippet(source: String) -> (Context<'static, 'static>, CrateId) {
+    let root = Path::new("");
+    let file_name = Path::new("main.nr");
+    let mut file_manager = file_manager_with_stdlib(root);
+    file_manager.add_file_with_source(file_name, source).expect(
+        "Adding source buffer to file manager should never fail when file manager is empty",
+    );
+    let parsed_files = parse_all(&file_manager);
+
+    let mut context = Context::new(file_manager, parsed_files);
+    let root_crate_id = prepare_crate(&mut context, file_name);
+
+    (context, root_crate_id)
+}
+
+/// Compile the main function in a code snippet.
+///
+/// Use `force_brillig` to test it as an unconstrained function without having to change the code.
+/// This is useful for methods that use the `runtime::is_unconstrained()` method to change their behavior.
+fn prepare_and_compile_snippet(
+    source: String,
+    force_brillig: bool,
+) -> CompilationResult<CompiledProgram> {
+    let (mut context, root_crate_id) = prepare_snippet(source);
+    let options = CompileOptions { force_brillig, ..Default::default() };
+    // TODO: Run nargo::ops::transform_program?
+    compile_main(&mut context, root_crate_id, &options, None)
+}
+
+/// Compile a snippet and run property tests against it by generating random input/output pairs
+/// according to the strategy, executing the snippet with the input, and asserting that the
+/// output it returns is the one we expect.
+fn run_snippet_proptest(
+    source: String,
+    force_brillig: bool,
+    strategy: BoxedStrategy<SnippetInputOutput>,
+) {
+    let program = match prepare_and_compile_snippet(source.clone(), force_brillig) {
+        Ok((program, _)) => program,
+        Err(e) => panic!("failed to compile program; brillig = {force_brillig}:\n{source}\n{e:?}"),
+    };
+
+    let blackbox_solver = bn254_blackbox_solver::Bn254BlackBoxSolver;
+    let foreign_call_executor =
+        RefCell::new(DefaultForeignCallExecutor::new(PrintOutput::None, None, None, None));
+
+    // Generate multiple input/output
+    proptest!(ProptestConfig::with_cases(100), |(io in strategy)| {
+        let initial_witness = program.abi.encode(&io.inputs, None).expect("failed to encode");
+        let mut foreign_call_executor = foreign_call_executor.borrow_mut();
+
+        let witness_stack: WitnessStack<FieldElement> = execute_program(
+            &program.program,
+            initial_witness,
+            &blackbox_solver,
+            &mut *foreign_call_executor,
+        )
+        .expect("failed to execute");
+
+        let main_witness = witness_stack.peek().expect("should have return value on witness stack");
+        let main_witness = &main_witness.witness;
+
+        let (_, return_value) = program.abi.decode(main_witness).expect("failed to decode");
+        let return_value = return_value.expect("should decode a return value");
+
+        prop_assert_eq!(return_value, io.expected_output, "{}", io.description);
+    });
+}
+
+/// Run property tests on a code snippet which is assumed to execute a hashing function with the following signature:
+///
+/// ```ignore
+/// fn main(input: [u8; {max_len}], message_size: u32) -> pub [u8; 32]
+/// ```
+///
+/// The calls are executed with and without forcing brillig, because it seems common for hash functions to run different
+/// code paths based on `runtime::is_unconstrained()`.
+fn run_hash_proptest<const N: usize>(
+    // Different generic maximum input sizes to try.
+    max_lengths: &[usize],
+    // Some hash functions allow inputs which are less than the generic parameters, others don't.
+    variable_length: bool,
+    // Make the source code specialized for a given expected input size.
+    source: impl Fn(usize) -> String,
+    // Rust implementation of the hash function.
+    hash: fn(&[u8]) -> [u8; N],
+) {
+    for max_len in max_lengths {
+        let max_len = *max_len;
+        // The maximum length is used to pick the generic version of the method.
+        let source = source(max_len);
+        // Hash functions runs differently depending on whether the code is unconstrained or not.
+        for force_brillig in [false, true] {
+            let length_strategy =
+                if variable_length { (0..=max_len).boxed() } else { Just(max_len).boxed() };
+            // The actual input length can be up to the maximum.
+            let strategy = length_strategy
+                .prop_flat_map(|len| prop::collection::vec(any::<u8>(), len))
+                .prop_map(move |mut msg| {
+                    // The output is the hash of the data as it is.
+                    let output = hash(&msg);
+
+                    // The input has to be padded to the maximum length.
+                    let msg_size = msg.len();
+                    msg.resize(max_len, 0u8);
+
+                    let mut inputs = vec![("input", bytes_input(&msg))];
+
+                    // Omit the `message_size` if the hash function doesn't support it.
+                    if variable_length {
+                        inputs.push((
+                            "message_size",
+                            InputValue::Field(FieldElement::from(msg_size)),
+                        ));
+                    }
+
+                    SnippetInputOutput::new(inputs, bytes_input(&output)).with_description(format!(
+                        "force_brillig = {force_brillig}, max_len = {max_len}"
+                    ))
+                })
+                .boxed();
+
+            run_snippet_proptest(source.clone(), force_brillig, strategy);
+        }
+    }
+}
+
+/// This is just a simple test to check that property testing works.
+#[test]
+fn fuzz_basic() {
+    let program = "fn main(init: u32) -> pub u32 {
+        let mut x = init;
+        for i in 0 .. 6 {
+            x += i;
+        }
+        x
+    }";
+
+    let strategy = any::<u32>()
+        .prop_map(|init| {
+            let init = init / 2;
+            SnippetInputOutput::new(
+                vec![("init", InputValue::Field(init.into()))],
+                InputValue::Field((init + 15).into()),
+            )
+        })
+        .boxed();
+
+    run_snippet_proptest(program.to_string(), false, strategy);
+}
+
+#[test]
+fn fuzz_keccak256_equivalence() {
+    run_hash_proptest(
+        // XXX: Currently it fails with inputs >= 135 bytes
+        &[0, 1, 100, 134],
+        true,
+        |max_len| {
+            format!(
+                "fn main(input: [u8; {max_len}], message_size: u32) -> pub [u8; 32] {{
+                    std::hash::keccak256(input, message_size)
+                }}"
+            )
+        },
+        |data| sha3::Keccak256::digest(data).try_into().unwrap(),
+    );
+}
+
+#[test]
+#[should_panic] // Remove once fixed
+fn fuzz_keccak256_equivalence_over_135() {
+    run_hash_proptest(
+        &[135, 150],
+        true,
+        |max_len| {
+            format!(
+                "fn main(input: [u8; {max_len}], message_size: u32) -> pub [u8; 32] {{
+                    std::hash::keccak256(input, message_size)
+                }}"
+            )
+        },
+        |data| sha3::Keccak256::digest(data).try_into().unwrap(),
+    );
+}
+
+#[test]
+fn fuzz_sha256_equivalence() {
+    run_hash_proptest(
+        &[0, 1, 200, 511, 512],
+        true,
+        |max_len| {
+            format!(
+                "fn main(input: [u8; {max_len}], message_size: u64) -> pub [u8; 32] {{
+                    std::hash::sha256_var(input, message_size)
+                }}"
+            )
+        },
+        |data| sha2::Sha256::digest(data).try_into().unwrap(),
+    );
+}
+
+#[test]
+fn fuzz_sha512_equivalence() {
+    run_hash_proptest(
+        &[0, 1, 200],
+        false,
+        |max_len| {
+            format!(
+                "fn main(input: [u8; {max_len}]) -> pub [u8; 64] {{
+                    std::hash::sha512::digest(input)
+                }}"
+            )
+        },
+        |data| sha2::Sha512::digest(data).try_into().unwrap(),
+    );
+}
+
+#[test]
+fn fuzz_poseidon2_equivalence() {
+    use bn254_blackbox_solver::poseidon_hash;
+
+    // Test empty, small, then around the RATE value, then bigger inputs.
+    for max_len in [0, 1, 3, 4, 100] {
+        let source = format!(
+            "fn main(input: [Field; {max_len}], message_size: u32) -> pub Field {{
+                std::hash::poseidon2::Poseidon2::hash(input, message_size)
+            }}"
+        );
+
+        let strategy = (0..=max_len)
+            .prop_flat_map(field_vec_strategy)
+            .prop_map(move |mut msg| {
+                let output = poseidon_hash(&msg, msg.len() < max_len).expect("failed to hash");
+
+                // The input has to be padded to the maximum length.
+                let msg_size = msg.len();
+                msg.resize(max_len, FieldElement::from(0u64));
+
+                let inputs = vec![
+                    ("input", InputValue::Vec(vecmap(msg, InputValue::Field))),
+                    ("message_size", InputValue::Field(FieldElement::from(msg_size))),
+                ];
+
+                SnippetInputOutput::new(inputs, InputValue::Field(output))
+                    .with_description(format!("max_len = {max_len}"))
+            })
+            .boxed();
+
+        run_snippet_proptest(source.clone(), false, strategy);
+    }
+}
+
+#[test]
+fn fuzz_poseidon_equivalence() {
+    use light_poseidon::{Poseidon, PoseidonHasher};
+
+    let poseidon_hash = |inputs: &[FieldElement]| {
+        let mut poseidon = Poseidon::<ark_bn254::Fr>::new_circom(inputs.len()).unwrap();
+        let frs: Vec<ark_bn254::Fr> = inputs.iter().map(|f| f.into_repr()).collect::<Vec<_>>();
+        let hash = poseidon.hash(&frs).expect("failed to hash");
+        FieldElement::from_repr(hash)
+    };
+
+    // Noir has hashes up to length 16, but the reference library won't work with more than 12.
+    for len in 1..light_poseidon::MAX_X5_LEN {
+        let source = format!(
+            "fn main(input: [Field; {len}]) -> pub Field {{
+                let h1 = std::hash::poseidon::bn254::hash_{len}(input);
+                let h2 = {{
+                    let mut hasher = std::hash::poseidon::PoseidonHasher::default();
+                    input.hash(&mut hasher);
+                    hasher.finish()
+                }};
+                assert_eq(h1, h2);
+                h1
+            }}"
+        );
+
+        let strategy = field_vec_strategy(len)
+            .prop_map(move |msg| {
+                let output = poseidon_hash(&msg);
+                let inputs = vec![("input", InputValue::Vec(vecmap(msg, InputValue::Field)))];
+
+                SnippetInputOutput::new(inputs, InputValue::Field(output))
+                    .with_description(format!("len = {len}"))
+            })
+            .boxed();
+
+        run_snippet_proptest(source.clone(), false, strategy);
+    }
+}
+
+fn bytes_input(bytes: &[u8]) -> InputValue {
+    InputValue::Vec(
+        bytes.iter().map(|b| InputValue::Field(FieldElement::from(*b as u32))).collect(),
+    )
+}
+
+fn field_vec_strategy(len: usize) -> impl Strategy<Value = Vec<FieldElement>> {
+    // Generate Field elements from random 32 byte vectors.
+    let field = prop::collection::vec(any::<u8>(), 32)
+        .prop_map(|bytes| FieldElement::from_be_bytes_reduce(&bytes));
+
+    prop::collection::vec(field, len)
+}
diff --git a/tooling/nargo_cli/tests/stdlib-tests.rs b/tooling/nargo_cli/tests/stdlib-tests.rs
index 847250c1dc0..29b871814b8 100644
--- a/tooling/nargo_cli/tests/stdlib-tests.rs
+++ b/tooling/nargo_cli/tests/stdlib-tests.rs
@@ -1,9 +1,12 @@
-use std::io::Write;
-use std::{collections::BTreeMap, path::PathBuf};
-
+//! Execute unit tests in the Noir standard library.
+#![allow(clippy::items_after_test_module)]
+use clap::Parser;
 use fm::FileManager;
+use nargo::PrintOutput;
 use noirc_driver::{check_crate, file_manager_with_stdlib, CompileOptions};
 use noirc_frontend::hir::FunctionNameMatch;
+use std::io::Write;
+use std::{collections::BTreeMap, path::PathBuf};
 
 use nargo::{
     ops::{report_errors, run_test, TestStatus},
@@ -11,9 +14,42 @@ use nargo::{
     parse_all, prepare_package,
 };
 use termcolor::{Color, ColorChoice, ColorSpec, StandardStream, WriteColor};
+use test_case::test_matrix;
+
+#[derive(Parser, Debug)]
+#[command(ignore_errors = true)]
+pub struct Options {
+    /// Test name to filter for.
+    ///
+    /// First is assumed to be `run_stdlib_tests` and the second the of the stdlib tests, e.g.:
+    ///
+    /// ```text
+    /// cargo test -p nargo_cli --test stdlib-tests -- run_stdlib_tests sha256
+    /// ```
+    args: Vec<String>,
+}
+
+impl Options {
+    pub fn function_name_match(&self) -> FunctionNameMatch {
+        match self.args.as_slice() {
+            [_test_name, lib] => FunctionNameMatch::Contains(lib.as_str()),
+            _ => FunctionNameMatch::Anything,
+        }
+    }
+}
+
+/// Inliner aggressiveness results in different SSA.
+/// Inlining happens if `inline_cost - retain_cost < aggressiveness` (see `inlining.rs`).
+/// NB the CLI uses maximum aggressiveness.
+///
+/// Even with the same inlining aggressiveness, forcing Brillig can trigger different behaviour.
+#[test_matrix(
+    [false, true],
+    [i64::MIN, 0, i64::MAX]
+)]
+fn run_stdlib_tests(force_brillig: bool, inliner_aggressiveness: i64) {
+    let opts = Options::parse();
 
-#[test]
-fn run_stdlib_tests() {
     let mut file_manager = file_manager_with_stdlib(&PathBuf::from("."));
     file_manager.add_file_with_source_canonical_path(&PathBuf::from("main.nr"), "".to_owned());
     let parsed_files = parse_all(&file_manager);
@@ -41,7 +77,7 @@ fn run_stdlib_tests() {
 
     let test_functions = context.get_all_test_functions_in_crate_matching(
         context.stdlib_crate_id(),
-        FunctionNameMatch::Anything,
+        opts.function_name_match(),
     );
 
     let test_report: Vec<(String, TestStatus)> = test_functions
@@ -51,11 +87,11 @@ fn run_stdlib_tests() {
                 &bn254_blackbox_solver::Bn254BlackBoxSolver,
                 &mut context,
                 &test_function,
-                false,
+                PrintOutput::Stdout,
                 None,
                 Some(dummy_package.root_dir.clone()),
                 Some(dummy_package.name.to_string()),
-                &CompileOptions::default(),
+                &CompileOptions { force_brillig, inliner_aggressiveness, ..Default::default() },
             );
             (test_name, status)
         })
@@ -103,6 +139,12 @@ fn display_test_report(
                     );
                 }
             }
+            TestStatus::Skipped { .. } => {
+                writer
+                    .set_color(ColorSpec::new().set_fg(Some(Color::Yellow)))
+                    .expect("Failed to set color");
+                writeln!(writer, "skipped").expect("Failed to write to stderr");
+            }
             TestStatus::CompileError(err) => {
                 noirc_errors::reporter::report_all(
                     file_manager.as_file_map(),
diff --git a/tooling/nargo_fmt/Cargo.toml b/tooling/nargo_fmt/Cargo.toml
index 9868f259097..710519712a2 100644
--- a/tooling/nargo_fmt/Cargo.toml
+++ b/tooling/nargo_fmt/Cargo.toml
@@ -10,7 +10,6 @@ license.workspace = true
 workspace = true
 
 [dependencies]
-bytecount = "0.6.3"
 noirc_frontend.workspace = true
 serde.workspace = true
 toml.workspace = true
diff --git a/tooling/nargo_fmt/build.rs b/tooling/nargo_fmt/build.rs
index 7d5f07c43bf..bd2db5f5b18 100644
--- a/tooling/nargo_fmt/build.rs
+++ b/tooling/nargo_fmt/build.rs
@@ -12,7 +12,7 @@ fn main() {
     // is the root of the repository and append the crate path
     let manifest_dir = match std::env::var("CARGO_MANIFEST_DIR") {
         Ok(dir) => PathBuf::from(dir),
-        Err(_) => std::env::current_dir().unwrap().join("crates").join("nargo_cli"),
+        Err(_) => std::env::current_dir().unwrap().join("tooling").join("nargo_fmt"),
     };
     let test_dir = manifest_dir.join("tests");
 
@@ -47,14 +47,10 @@ fn generate_formatter_tests(test_file: &mut File, test_data_dir: &Path) {
             .join("\n");
 
         let output_source_path = outputs_dir.join(file_name).display().to_string();
-        let output_source = std::fs::read_to_string(output_source_path.clone()).unwrap();
-
-        let skip_idempotent_test =
-            // TODO(https://github.com/noir-lang/noir/issues/4766): spurious trailing space
-            test_name == "array" ||
-            // TODO(https://github.com/noir-lang/noir/issues/4767): pre-comment space
-            // TODO(https://github.com/noir-lang/noir/issues/4768): spurious newline
-            test_name == "tuple";
+        let output_source =
+            std::fs::read_to_string(output_source_path.clone()).unwrap_or_else(|_| {
+                panic!("expected output source at {:?} was not found", &output_source_path)
+            });
 
         write!(
             test_file,
@@ -80,10 +76,9 @@ fn generate_formatter_tests(test_file: &mut File, test_data_dir: &Path) {
         )
         .expect("Could not write templated test file.");
 
-        if !skip_idempotent_test {
-            write!(
-                test_file,
-                r##"
+        write!(
+            test_file,
+            r##"
         #[test]
         fn format_idempotent_{test_name}() {{
             let expected_output = r#"{output_source}"#;
@@ -96,8 +91,7 @@ fn generate_formatter_tests(test_file: &mut File, test_data_dir: &Path) {
             similar_asserts::assert_eq!(fmt_text, expected_output);
         }}
                 "##
-            )
-            .expect("Could not write templated test file.");
-        }
+        )
+        .expect("Could not write templated test file.");
     }
 }
diff --git a/tooling/nargo_fmt/src/chunks.rs b/tooling/nargo_fmt/src/chunks.rs
new file mode 100644
index 00000000000..fcef261284d
--- /dev/null
+++ b/tooling/nargo_fmt/src/chunks.rs
@@ -0,0 +1,1047 @@
+//! This module has all the logic to format a series of chunks (a piece of text) in a way
+//! that we (almost always) never exceed the configurable maximum line width.
+//!
+//! It's heavily inspired by this excellent blog post:
+//!
+//! https://yorickpeterse.com/articles/how-to-write-a-code-formatter/
+//!
+//! However, some changes were introduces to handle comments and other particularities of Noir.
+use std::ops::Deref;
+
+use noirc_frontend::token::Token;
+
+use super::Formatter;
+
+/// A text chunk. It precomputes the text width and whether it has newlines.
+#[derive(Debug)]
+pub(crate) struct TextChunk {
+    pub(crate) string: String,
+    pub(crate) width: usize,
+    pub(crate) has_newlines: bool,
+}
+
+impl TextChunk {
+    pub(crate) fn new(string: String) -> Self {
+        TextChunk {
+            width: string.chars().count(),
+            has_newlines: string.chars().any(|char| char == '\n'),
+            string,
+        }
+    }
+}
+
+/// A chunk can either be text or a directive that instructs the formatter to do something
+/// (for example: increase or decrease the current indentation).
+#[derive(Debug)]
+pub(crate) enum Chunk {
+    /// A text chunk. It might contain leading comments.
+    Text(TextChunk),
+    /// A text chunk that should be printed unmodified (used for `quote { ... }` contents).
+    Verbatim(TextChunk),
+    /// A trailing comma that's only written if we decide to format chunks in multiple lines
+    /// (for example for a call we'll add a trailing comma to the last argument).
+    TrailingComma,
+    /// A trailing comment (happens at the end of a line, and always after something else have been written).
+    TrailingComment(TextChunk),
+    /// A leading comment. Happens at the beginning of a line.
+    LeadingComment(TextChunk),
+    /// A group of chunks.
+    Group(ChunkGroup),
+    /// Write a line (or two) if we decide to format chunks in multiple lines, otherwise do nothing.
+    Line { two: bool },
+    /// Writes a space if we can write a group in one line, otherwise writes a line.
+    /// However, a space might be written if `one_chunk_per_line` of a Chunks object is set to false.
+    SpaceOrLine,
+    /// Command to increase the current indentation.
+    IncreaseIndentation,
+    /// Command to decrease the current indentation.
+    DecreaseIndentation,
+    /// Push the current indentation to the indentation stack.
+    PushIndentation,
+    /// Set the current indentation by popping it from the indentation stack.
+    PopIndentation,
+}
+
+impl Chunk {
+    pub(crate) fn width(&self) -> usize {
+        match self {
+            Chunk::Text(chunk)
+            | Chunk::Verbatim(chunk)
+            | Chunk::TrailingComment(chunk)
+            | Chunk::LeadingComment(chunk) => chunk.width,
+            Chunk::Group(group) => group.width(),
+            Chunk::SpaceOrLine => 1,
+            Chunk::Line { .. }
+            | Chunk::IncreaseIndentation
+            | Chunk::DecreaseIndentation
+            | Chunk::TrailingComma
+            | Chunk::PushIndentation
+            | Chunk::PopIndentation => 0,
+        }
+    }
+
+    /// Computes the width of this chunk considering it's inside an ExpressionList.
+    /// The only thing that changes here compared to `width` is that a LambdaAsLastExpressionInList's
+    /// width is considered to be only the first line, so we can avoid splitting the entire call
+    /// arguments into separate lines.
+    pub(crate) fn width_inside_an_expression_list(&self) -> usize {
+        if let Chunk::Group(group) = &self {
+            if let GroupKind::LambdaAsLastExpressionInList { first_line_width, .. } = &group.kind {
+                return *first_line_width;
+            }
+        }
+
+        self.width()
+    }
+
+    pub(crate) fn has_newlines(&self) -> bool {
+        match self {
+            Chunk::Text(chunk)
+            | Chunk::Verbatim(chunk)
+            | Chunk::TrailingComment(chunk)
+            | Chunk::LeadingComment(chunk) => chunk.has_newlines,
+            Chunk::Group(group) => group.has_newlines(),
+            Chunk::TrailingComma
+            | Chunk::Line { .. }
+            | Chunk::SpaceOrLine
+            | Chunk::IncreaseIndentation
+            | Chunk::DecreaseIndentation
+            | Chunk::PushIndentation
+            | Chunk::PopIndentation => false,
+        }
+    }
+
+    /// Returns the current chunk as a Group, if it is one. Otherwise returns None.
+    pub(crate) fn group(self) -> Option<ChunkGroup> {
+        if let Chunk::Group(group) = self {
+            Some(group)
+        } else {
+            None
+        }
+    }
+}
+
+#[derive(Debug)]
+pub(crate) struct ChunkGroup {
+    pub(crate) chunks: Vec<Chunk>,
+
+    /// If `true`, when formatting in multiple lines, and after a SpaceOrLine,
+    /// a line will be written.
+    /// If `false`, when formatting in multiple lines, and after a SpaceOrLine,
+    /// a space will be inserted and the next chunk will go in the same line if
+    /// it fits that line.
+    ///
+    /// This is used to, for example, control how arrays are formatted. If each
+    /// element is short, we'll format the array like this:
+    ///
+    /// [
+    ///   1, 2, 3,
+    ///   4, 5
+    /// ]
+    ///
+    /// but if one of the elements is long, each one will go in a separate line:
+    ///
+    /// ```text
+    /// [
+    ///     1,
+    ///     1234567890123,
+    ///     3
+    /// ]
+    /// ```
+    pub(crate) one_chunk_per_line: bool,
+
+    /// If true, regardless of this group's chunks, this group will be formatted in
+    /// multiple lines.
+    /// This is set to true when, for example, we format a block that has at least
+    /// two statements: we always want to show that in multiple lines.
+    pub(crate) force_multiple_lines: bool,
+
+    /// Groups can be tagged. For example we tag all consequences and alternative blocks
+    /// of an `if` expression. If we determine one of them needs to be formatted in multiple
+    /// lines, we find all other chunks with the same tag and mark them too to be formatted
+    /// in multiple lines.
+    pub(crate) tag: Option<GroupTag>,
+
+    /// The kind of this group. Some group kinds are formatted in a special way
+    /// (mainly lambda arguments that are the last expression in a list).
+    pub(crate) kind: GroupKind,
+
+    /// This name is a bit long and explicit, but it's to make things clearer:
+    /// if we determine that this group needs to be formatted in multiple lines,
+    /// children groups with the same tag will also be formatted in multiple lines.
+    ///
+    /// This is used for example in infix expressions like `a + b + c + d`, where if we
+    /// determine that `a + b` needs to be formatted in multiple lines, we want the entire
+    /// tree (of those infix expressions) to be formatted in multiple lines.
+    pub(crate) force_multiline_on_children_with_same_tag_if_multiline: bool,
+}
+
+impl ChunkGroup {
+    pub(crate) fn new() -> Self {
+        Self {
+            chunks: Vec::new(),
+            one_chunk_per_line: true,
+            force_multiple_lines: false,
+            tag: None,
+            kind: GroupKind::Regular,
+            force_multiline_on_children_with_same_tag_if_multiline: false,
+        }
+    }
+
+    /// Appends a text to this group.
+    /// If the last chunk in this group is a text, no new chunk is inserted and
+    /// instead the last text chunk is extended.
+    pub(crate) fn text(&mut self, chunk: TextChunk) {
+        if chunk.width == 0 {
+            return;
+        }
+
+        if let Some(Chunk::Text(text_chunk)) = self.chunks.last_mut() {
+            text_chunk.string.push_str(&chunk.string);
+            text_chunk.width += chunk.width;
+            text_chunk.has_newlines |= chunk.has_newlines;
+        } else {
+            self.push(Chunk::Text(chunk));
+        }
+    }
+
+    /// Appends a verbatim text chunk to this group.
+    pub(crate) fn verbatim(&mut self, chunk: TextChunk) {
+        if chunk.width == 0 {
+            return;
+        }
+
+        self.push(Chunk::Verbatim(chunk));
+    }
+
+    /// Appends a single space to this group by reading it from the given formatter.
+    pub(crate) fn space(&mut self, formatter: &mut ChunkFormatter<'_, '_>) {
+        self.text(formatter.chunk(|formatter| {
+            formatter.write_space();
+        }));
+    }
+
+    /// Appends a semicolon to this group by reading it from the given formatter.
+    /// This will actually end up attaching the semicolon to the last text in this
+    /// group so that we don't end up with stray semicolons.
+    pub(crate) fn semicolon(&mut self, formatter: &mut ChunkFormatter<'_, '_>) {
+        self.text_attached_to_last_group(formatter.chunk(|formatter| {
+            formatter.write_semicolon();
+        }));
+    }
+
+    /// Appends a TextChunk to this chunks chunks. However, if the last chunk is a group,
+    /// it's appended to that group's last text.
+    pub(crate) fn text_attached_to_last_group(&mut self, chunk: TextChunk) {
+        if chunk.width == 0 {
+            return;
+        }
+
+        if let Some(Chunk::Group(group)) = self.chunks.last_mut() {
+            group.text(chunk);
+        } else {
+            self.text(chunk);
+        }
+    }
+
+    /// Appends a trailing comment (it's formatted slightly differently than a regular text chunk).
+    pub(crate) fn trailing_comment(&mut self, chunk: TextChunk) {
+        if chunk.width > 0 {
+            self.push(Chunk::TrailingComment(chunk));
+        }
+    }
+
+    /// Appends a leading comment (it's formatted slightly differently than a regular text chunk).
+    pub(crate) fn leading_comment(&mut self, chunk: TextChunk) {
+        if chunk.width > 0 {
+            self.push(Chunk::LeadingComment(chunk));
+        }
+    }
+
+    /// Appends a trailing comma (will only show up if the group is formatted in multiple lines).
+    pub(crate) fn trailing_comma(&mut self) {
+        self.push(Chunk::TrailingComma);
+    }
+
+    /// Appends another group as a nested group.
+    pub(crate) fn group(&mut self, group: ChunkGroup) {
+        self.push(Chunk::Group(group));
+    }
+
+    /// Append one line to this chunk.
+    pub(crate) fn line(&mut self) {
+        self.lines(false);
+    }
+
+    /// Append one or two lines to this chunk.
+    pub(crate) fn lines(&mut self, two: bool) {
+        self.push(Chunk::Line { two });
+    }
+
+    /// Appends a SpaceOrLine chunk, which means that it's a space when this group is
+    /// formatted in a single line, or a line when it's formatted in multiple lines.
+    pub(crate) fn space_or_line(&mut self) {
+        self.push(Chunk::SpaceOrLine);
+    }
+
+    pub(crate) fn increase_indentation(&mut self) {
+        self.push(Chunk::IncreaseIndentation);
+    }
+
+    pub(crate) fn decrease_indentation(&mut self) {
+        self.push(Chunk::DecreaseIndentation);
+    }
+
+    pub(crate) fn push_indentation(&mut self) {
+        self.push(Chunk::PushIndentation);
+    }
+
+    pub(crate) fn pop_indentation(&mut self) {
+        self.push(Chunk::PopIndentation);
+    }
+
+    pub(crate) fn push(&mut self, chunk: Chunk) {
+        self.chunks.push(chunk);
+    }
+
+    pub(crate) fn width(&self) -> usize {
+        self.chunks.iter().map(|chunk| chunk.width()).sum()
+    }
+
+    pub(crate) fn expression_list_width(&self) -> usize {
+        self.chunks.iter().map(|chunk| chunk.width_inside_an_expression_list()).sum()
+    }
+
+    pub(crate) fn has_newlines(&self) -> bool {
+        self.force_multiple_lines || self.chunks.iter().any(|chunk| chunk.has_newlines())
+    }
+
+    /// Determines if this group has a LambdaAsLastExpressionInList chunk.
+    /// Note that if this group is a MethodCall, this is checked for the ExpressionList group
+    /// inside it.
+    pub(crate) fn has_lambda_as_last_expression_in_list(&self) -> bool {
+        self.chunks.iter().any(|chunk| {
+            if let Chunk::Group(group) = chunk {
+                if self.kind.is_method_call() && group.kind.is_expression_list() {
+                    group.has_lambda_as_last_expression_in_list()
+                } else {
+                    matches!(group.kind, GroupKind::LambdaAsLastExpressionInList { .. })
+                }
+            } else {
+                false
+            }
+        })
+    }
+
+    /// Finds the `LambdaAsLastExpressionInList` associated to this group and sets its indentation
+    /// to the given value.
+    pub(crate) fn set_lambda_as_last_expression_in_list_indentation(
+        &mut self,
+        indentation_to_set: i32,
+    ) {
+        for chunk in self.chunks.iter_mut() {
+            if let Chunk::Group(group) = chunk {
+                if self.kind.is_method_call() && group.kind.is_expression_list() {
+                    group.set_lambda_as_last_expression_in_list_indentation(indentation_to_set);
+                } else if let GroupKind::LambdaAsLastExpressionInList { indentation, .. } =
+                    &mut group.kind
+                {
+                    if indentation.is_none() {
+                        *indentation = Some(indentation_to_set);
+                    }
+                }
+            }
+        }
+    }
+
+    /// Before writing a Chunks object in multiple lines, create a new one where `TrailingComma`
+    /// is turned into `Text`. Because Chunks will glue two consecutive `Text`s together, if we
+    /// have two chunks `Text("123"), TrailingComma`, we'll consider the entire string "123,"
+    /// when deciding whether we can still write in the current line or not.
+    pub(crate) fn prepare_for_multiple_lines(self) -> ChunkGroup {
+        let mut group = ChunkGroup { chunks: Vec::new(), ..self };
+
+        for chunk in self.chunks {
+            match chunk {
+                Chunk::Text(chunk) => group.text(chunk),
+                Chunk::Verbatim(chunk) => group.verbatim(chunk),
+                Chunk::TrailingComma => {
+                    // If there's a trailing comma after a group, append the text to that group
+                    // so that it glues with the last text present there (if any)
+                    group.add_trailing_comma_to_last_text();
+                }
+                Chunk::TrailingComment(chunk) => group.trailing_comment(chunk),
+                Chunk::LeadingComment(chunk) => group.leading_comment(chunk),
+                Chunk::Group(inner_group) => group.group(inner_group),
+                Chunk::Line { two } => group.lines(two),
+                Chunk::SpaceOrLine => group.space_or_line(),
+                Chunk::IncreaseIndentation => group.increase_indentation(),
+                Chunk::DecreaseIndentation => group.decrease_indentation(),
+                Chunk::PushIndentation => group.push_indentation(),
+                Chunk::PopIndentation => group.pop_indentation(),
+            }
+        }
+        group
+    }
+
+    fn add_trailing_comma_to_last_text(&mut self) {
+        if let Some(Chunk::Group(group)) = self.chunks.last_mut() {
+            group.add_trailing_comma_to_last_text();
+        } else {
+            self.text(TextChunk::new(",".to_string()));
+        }
+    }
+
+    /// Returns the width of text until we hit a Line or LineOrSpace, together
+    /// with whether we hit a Line or LineOrSpace.
+    fn width_until_line(&self) -> (usize, bool) {
+        let mut width = 0;
+        for chunk in &self.chunks {
+            match chunk {
+                Chunk::Text(text_chunk)
+                | Chunk::Verbatim(text_chunk)
+                | Chunk::TrailingComment(text_chunk)
+                | Chunk::LeadingComment(text_chunk) => {
+                    width += text_chunk.width;
+                }
+                Chunk::Group(chunk_group) => {
+                    let (group_width, hit_line) = chunk_group.width_until_line();
+                    width += group_width;
+                    if hit_line {
+                        return (width, true);
+                    }
+                }
+                Chunk::Line { .. } | Chunk::SpaceOrLine => {
+                    return (width, true);
+                }
+                Chunk::IncreaseIndentation
+                | Chunk::DecreaseIndentation
+                | Chunk::PushIndentation
+                | Chunk::PopIndentation
+                | Chunk::TrailingComma => (),
+            }
+        }
+
+        (width, false)
+    }
+
+    fn first_group(&self) -> Option<&ChunkGroup> {
+        self.chunks
+            .iter()
+            .filter_map(|chunk| if let Chunk::Group(group) = chunk { Some(group) } else { None })
+            .next()
+    }
+
+    fn has_expression_list_or_method_call_group(&self) -> bool {
+        for chunk in &self.chunks {
+            if let Chunk::Group(group) = chunk {
+                if group.kind.is_expression_list() || group.kind.is_method_call() {
+                    return true;
+                }
+            }
+        }
+
+        false
+    }
+}
+
+#[derive(Debug, Copy, Clone, PartialEq, Eq)]
+pub(crate) struct GroupTag(usize);
+
+#[derive(Debug, Copy, Clone, PartialEq, Eq)]
+pub(crate) enum GroupKind {
+    /// Most chunks are regular chunks and are not of interest.
+    Regular,
+    /// This is a chunk that has a list of expression in it, for example:
+    /// a call, a method call, an array literal, a tuple literal, etc.
+    /// `prefix_width` is the width of whatever is before the actual expression list.
+    /// For example, for an array this is 1 (for "["), for a slice it's 2 ("&["), etc.
+    ExpressionList { prefix_width: usize, expressions_count: usize },
+    /// This is a chunk for a lambda argument that is the last expression of an ExpressionList.
+    /// `first_line_width` is the width of the first line of the lambda argument: the parameters
+    /// list and the left bracket.
+    LambdaAsLastExpressionInList { first_line_width: usize, indentation: Option<i32> },
+    /// The body of a lambda.
+    /// We track this as a group kind so that when we have to write it, if it doesn't
+    /// fit in the current line and it's not a block, instead of splitting that expression
+    /// somewhere that's probably undesired, we'll "turn it" into a block
+    /// (write the "{" and "}" delimiters) and write the lambda body in the next line.
+    LambdaBody {
+        block_statement_count: Option<usize>,
+        has_comments: bool,
+        lambda_has_return_type: bool,
+    },
+    /// A method call.
+    /// We track all this information to see, if we end up needing to format this call
+    /// in multiple lines, if we can write everything up to the left parentheses (inclusive)
+    /// in one line, and just the call arguments in multiple lines.
+    MethodCall {
+        /// This is the width of the group until the left parenthesis (inclusive).
+        width_until_left_paren_inclusive: usize,
+        /// Are there newlines before the left parentheses in this group?
+        has_newlines_before_left_paren: bool,
+        /// Is this method call the left-hand side of a call chain? If so, this is true,
+        /// otherwise this is false an it means it's the outermost call.
+        lhs: bool,
+    },
+    /// The value of an assignment or let statement. We know this is the last group in a chunk so
+    /// if it doesn't fit in the current line but it fits in the next line, we can
+    /// write a newline, indent, and put it there (instead of writing the value in
+    /// multiple lines).
+    AssignValue,
+}
+
+impl GroupKind {
+    fn is_method_call(&self) -> bool {
+        matches!(self, GroupKind::MethodCall { .. })
+    }
+
+    fn is_expression_list(&self) -> bool {
+        matches!(self, GroupKind::ExpressionList { .. })
+    }
+}
+
+/// Interface for creating TextChunks.
+pub(crate) struct ChunkFormatter<'a, 'b>(&'b mut Formatter<'a>);
+
+impl<'a, 'b> ChunkFormatter<'a, 'b> {
+    pub(crate) fn new(formatter: &'b mut Formatter<'a>) -> Self {
+        Self(formatter)
+    }
+
+    /// Stops writing to the current buffer for the duration of the `f` call, which takes
+    /// a formatter to write to. Then, returns a `TextChunk` with the written text.
+    ///
+    /// This allows a caller to format pieces of code and then pre-process them before
+    /// writing to the main buffer.
+    pub(crate) fn chunk(&mut self, f: impl FnOnce(&mut Formatter)) -> TextChunk {
+        let previous_buffer = std::mem::take(&mut self.0.buffer);
+        let previous_indentation = self.0.indentation;
+        self.0.indentation = 0;
+
+        f(self.0);
+
+        self.0.indentation = previous_indentation;
+
+        let buffer = std::mem::replace(&mut self.0.buffer, previous_buffer);
+        TextChunk::new(buffer.contents())
+    }
+
+    /// Stops writing to the current buffer, skips comments and whitespaces (formatting them)
+    /// and returns the formatted result as a `TextChunk`.
+    pub(crate) fn skip_comments_and_whitespace_chunk(&mut self) -> TextChunk {
+        self.chunk(|formatter| {
+            formatter.skip_comments_and_whitespace();
+        })
+    }
+
+    pub(super) fn new_group_tag(&mut self) -> GroupTag {
+        self.0.new_group_tag()
+    }
+
+    pub(super) fn bump(&mut self) -> Token {
+        self.0.bump()
+    }
+}
+
+/// Treating a `ChunkFormatter` as a `Formatter` in read-only mode is always fine,
+/// and reduces some boilerplate.
+impl<'a, 'b> Deref for ChunkFormatter<'a, 'b> {
+    type Target = Formatter<'b>;
+
+    fn deref(&self) -> &Self::Target {
+        self.0
+    }
+}
+
+impl<'a> Formatter<'a> {
+    /// Returns an object that has a `chunk` method to get a TextChunk.
+    /// This method exists so that we can't mix the two operation modes:
+    /// using the formatter directly while writing to the buffer, or creating text chunks.
+    pub(super) fn chunk_formatter(&mut self) -> ChunkFormatter<'a, '_> {
+        ChunkFormatter::new(self)
+    }
+
+    /// Main interface to format a chunk group.
+    /// Here it's determined if the chunk will group in a single line or multiple lines.
+    pub(super) fn format_chunk_group(&mut self, group: ChunkGroup) {
+        let previous_indentation = self.indentation;
+        self.format_chunk_group_impl(group);
+        self.indentation = previous_indentation;
+    }
+
+    pub(super) fn format_chunk_group_impl(&mut self, group: ChunkGroup) {
+        if let GroupKind::LambdaAsLastExpressionInList { indentation: Some(indentation), .. } =
+            group.kind
+        {
+            let previous_indentation = self.indentation;
+            self.indentation = indentation;
+            self.format_chunks_group_impl_without_lambda_handling(group);
+            self.indentation = previous_indentation;
+        } else {
+            self.format_chunks_group_impl_without_lambda_handling(group);
+        }
+    }
+
+    pub(super) fn format_chunks_group_impl_without_lambda_handling(
+        &mut self,
+        mut group: ChunkGroup,
+    ) {
+        let chunks_width = group.width();
+        let total_width = self.current_line_width() + chunks_width;
+
+        if total_width > self.max_width {
+            // If this is a method call that doesn't fit in the current line, we check if
+            // everything that follows up to the left parentheses fits in the current line.
+            // If so, we write that and we'll end up formatting the arguments in multiple
+            // lines, instead of splitting this entire call chain in multiple lines.
+            //
+            // For example, a call like this:
+            //
+            // foo.bar.baz.qux(1)
+            //
+            // if it exceeds the maximum width, will end up being formatted like this:
+            //
+            // foo.bar.baz.qux(
+            //     1,
+            // )
+            //
+            // instead of like this (many more lines):
+            //
+            // foo
+            //     .bar
+            //     .baz
+            //     .qux(1)
+            //
+            // This is something that rustfmt seems to do too.
+            if let GroupKind::MethodCall {
+                width_until_left_paren_inclusive,
+                has_newlines_before_left_paren: false,
+                lhs: false,
+            } = group.kind
+            {
+                let total_width = self.current_line_width() + width_until_left_paren_inclusive;
+                if total_width <= self.max_width {
+                    // Check if this method call has another call or method call nested in it.
+                    // If not, it means tis is the last nested call and after it we'll need to start
+                    // writing at least one closing parentheses. So the argument list will actually
+                    // have one less character available for writing, and that's why we (temporarily) decrease
+                    // max width.
+                    let expression_list_group = group.first_group().unwrap();
+                    let has_expression_list_or_call_group =
+                        expression_list_group.has_expression_list_or_method_call_group();
+                    if !has_expression_list_or_call_group {
+                        self.max_width -= 1;
+                    }
+
+                    // When a method call's group is formed, we indent after the first dot. But with that
+                    // indentation, and the arguments indentation, we'll end up with too much indentation,
+                    // so here we decrease it to compensate that.
+                    self.decrease_indentation();
+                    self.format_chunk_group_in_one_line(group);
+                    self.increase_indentation();
+
+                    if !has_expression_list_or_call_group {
+                        self.max_width += 1;
+                    }
+                    return;
+                }
+            }
+
+            // If this is an expression list with a single expression, see if we can fit whatever
+            // comes next until a line in the current line. For example, if we have this:
+            //
+            // foo(bar(baz(1)))
+            //
+            // then `foo(...)` is an ExpressionList. We check if `foo(` fits in the current line.
+            // If yes, we write it in the current line and continue. Then we'll find `bar(...)`,
+            // which is also an ExpressionList, and if `bar(` fits the current line, we'll write it,
+            // etc. But we only do this if we have nested calls (nested expression lists, etc.)
+            //
+            // This is to avoid formatting the above like this:
+            //
+            // foo(
+            //     bar(
+            //         baz(
+            //             1,
+            //         ),
+            //     ),
+            // )
+            //
+            // (rustfmt seems to do the same thing)
+            if let GroupKind::ExpressionList { prefix_width, expressions_count: 1 } = group.kind {
+                if let Some(inner_group) = group.first_group() {
+                    if inner_group.kind.is_expression_list() || inner_group.kind.is_method_call() {
+                        let total_width = self.current_line_width()
+                            + prefix_width
+                            + inner_group.width_until_line().0;
+                        if total_width <= self.max_width {
+                            self.decrease_indentation();
+                            self.format_chunk_group_in_one_line(group);
+                            self.increase_indentation();
+                            return;
+                        }
+                    }
+                }
+            }
+        }
+
+        if group.force_multiple_lines {
+            self.format_chunk_group_in_multiple_lines(group);
+            return;
+        }
+
+        // if chunks.has_newlines() {
+        // When formatting an expression list we have to check if the last argument is a lambda,
+        // because we format that in a special way:
+        // 1. to compute the group width we'll consider only the `|...| {` part of the lambda
+        // 2. If it fits in a line, we'll format this expression list in a single line
+        // 3. However, an expression list is instructed to increase indentation after, say,
+        //    `(` or `[` (depending on the expression list) and then the `{` part of a lambda
+        //    will also increase the indentation, resulting in too much indentation.
+        // 4. For that reason we adjust the lambda to be formatted with the indentation
+        //    we have right that (that is, that of the call that holds the lambda).
+        //    We do that by setting the `indentation` field of the LambdaAsLastExpressionInList.
+        //
+        // Note that this logic is a bit complex because for method calls, the arguments list
+        // is in a group so all arguments can potentially be formatted in a single line, and
+        // that group has the `ExpressionList` kind. The method call itself has the `MethodCall`
+        // kind. So when determining the first line width of a method call with a lambda as
+        // the last argument we have to find the nested ExpressionList and do some nested calls.
+        if (group.kind.is_expression_list() || group.kind.is_method_call())
+            && group.has_lambda_as_last_expression_in_list()
+        {
+            let chunks_width = group.expression_list_width();
+            let total_width = self.current_line_width() + chunks_width;
+            if total_width <= self.max_width {
+                group.set_lambda_as_last_expression_in_list_indentation(self.indentation);
+                self.format_chunk_group_in_one_line(group);
+                return;
+            }
+        }
+
+        if group.has_newlines() {
+            self.format_chunk_group_in_multiple_lines(group);
+            return;
+        }
+
+        // Check if the group first in the remainder of the current line.
+        if total_width > self.max_width {
+            // If this chunk is the value of an assignment (either a normal assignment or a let statement)
+            // and it doesn't fit the current line, we check if it fits the next line with an increased
+            // indentation.
+            //
+            // That way this:
+            //
+            // let x = foo(1, 2);
+            //                 ^
+            //                 assume the max width is here
+            //
+            // is formatted like this:
+            //
+            // let x =
+            //     foo(1, 2);
+            //
+            // instead of:
+            //
+            // let x = foo(
+            //     1,
+            //     2,
+            // )
+            if group.kind == GroupKind::AssignValue {
+                let total_width_next_line =
+                    (self.indentation as usize + 1) * self.config.tab_spaces + chunks_width;
+                if total_width_next_line <= self.max_width {
+                    // We might have trailing spaces
+                    // (for example a space after the `=` of a let statement or an assignment)
+                    self.trim_spaces();
+                    self.write_line_without_skipping_whitespace_and_comments();
+                    self.increase_indentation();
+                    self.write_indentation();
+                    self.format_chunk_group_in_one_line(group);
+                    self.decrease_indentation();
+                    return;
+                }
+            }
+
+            // If a lambda body doesn't fit in the current line and it's not a block,
+            // we can turn it into a block and write it in the next line, so its contents fit.
+            if let GroupKind::LambdaBody { block_statement_count: None, .. } = group.kind {
+                // Try to format it again in the next line, but we don't want to recurse
+                // infinitely so we change the group kind.
+                group.kind = GroupKind::Regular;
+                self.write("{");
+                self.trim_spaces();
+                self.increase_indentation();
+                self.write_line_without_skipping_whitespace_and_comments();
+                self.write_indentation();
+                self.format_chunk_group_impl(group);
+
+                // If this lambda was in an expression list and it was formatted in multiple
+                // lines, it might be that the trailing comma happened after the lambda body:
+                //
+                // foo(
+                //     1,
+                //     |lambda| body,
+                // )
+                //
+                // Because we attach commas to the last text to avoid splitting it, the body
+                // in this case is "body,", so if we end up writing it as a block it will
+                // look like this:
+                //
+                // foo(
+                //     1,
+                //     |lambda| {
+                //         body,
+                //     }
+                // )
+                //
+                // So, if after writing the body we find a comma (there will be at most one)
+                // we remove it, but place it after the right brace, so it looks like this:
+                //
+                // foo(
+                //     1,
+                //     |lambda| {
+                //         body
+                //     },
+                // )
+                let comma_trimmed = self.trim_comma();
+                self.decrease_indentation();
+                self.write_line_without_skipping_whitespace_and_comments();
+                self.write_indentation();
+                self.write("}");
+                if comma_trimmed {
+                    self.write(",");
+                }
+                return;
+            }
+
+            self.format_chunk_group_in_multiple_lines(group);
+            return;
+        }
+
+        // At this point we determined we are going to write this group in a single line.
+        // If the current group is a lambda body that is a block with a single statement, like this:
+        //
+        // |x| { 1 + 2 }
+        //
+        // given that we determined the block fits the current line, if we remove the surrounding
+        // `{ .. }` it will still fit the current line, and reduce some noise from the code
+        // (this is what rustfmt seems to do too).
+        if let GroupKind::LambdaBody {
+            block_statement_count: Some(1),
+            has_comments: false,
+            lambda_has_return_type: false,
+        } = group.kind
+        {
+            self.format_lambda_body_removing_braces(group);
+            return;
+        }
+
+        self.format_chunk_group_in_one_line(group);
+    }
+
+    pub(super) fn format_chunk_group_in_one_line(&mut self, group: ChunkGroup) {
+        for chunk in group.chunks {
+            match chunk {
+                Chunk::Text(text_chunk) | Chunk::Verbatim(text_chunk) => {
+                    self.write(&text_chunk.string);
+                }
+                Chunk::TrailingComment(text_chunk) | Chunk::LeadingComment(text_chunk) => {
+                    self.write(&text_chunk.string);
+                    self.write_space_without_skipping_whitespace_and_comments();
+                }
+                Chunk::Group(chunks) => self.format_chunk_group_impl(chunks),
+                Chunk::SpaceOrLine => self.write_space_without_skipping_whitespace_and_comments(),
+                Chunk::IncreaseIndentation => self.increase_indentation(),
+                Chunk::DecreaseIndentation => self.decrease_indentation(),
+                Chunk::PushIndentation => self.push_indentation(),
+                Chunk::PopIndentation => self.pop_indentation(),
+                Chunk::TrailingComma | Chunk::Line { .. } => (),
+            }
+        }
+    }
+
+    pub(super) fn format_chunk_group_in_multiple_lines(&mut self, group: ChunkGroup) {
+        let chunks = group.prepare_for_multiple_lines();
+
+        let mut last_was_space_or_line = false;
+
+        for chunk in chunks.chunks {
+            if last_was_space_or_line {
+                if chunks.one_chunk_per_line {
+                    self.write_line_without_skipping_whitespace_and_comments();
+                    self.write_indentation();
+                } else {
+                    // "+ 1" because we still need to add a space before the next chunk
+                    if self.current_line_width() + chunk.width() + 1 > self.max_width {
+                        self.write_line_without_skipping_whitespace_and_comments();
+                        self.write_indentation();
+                    } else {
+                        self.write_space_without_skipping_whitespace_and_comments();
+                    }
+                }
+            }
+
+            last_was_space_or_line = false;
+
+            match chunk {
+                Chunk::Text(text_chunk) => {
+                    if text_chunk.has_newlines {
+                        self.write_chunk_lines(&text_chunk.string);
+                    } else {
+                        // If we didn't exceed the max width, but this chunk will, insert a newline,
+                        // increase indentation and indent (the indentation will be undone
+                        // after `format_chunks` finishes).
+                        // This is the logic to automatically wrap a line when a ChunkGroup doesn't
+                        // have Line or SpaceOrLine in it.
+                        if self.current_line_width() <= self.max_width
+                            && self.current_line_width() + text_chunk.width > self.max_width
+                            && !self.buffer.ends_with_space()
+                        {
+                            self.write_line_without_skipping_whitespace_and_comments();
+                            self.increase_indentation();
+                            self.write_indentation();
+                        }
+                        self.write(&text_chunk.string);
+                    }
+                }
+                Chunk::Verbatim(text_chunk) => {
+                    self.write(&text_chunk.string);
+                }
+                Chunk::TrailingComment(text_chunk) => {
+                    self.write_chunk_lines(&text_chunk.string);
+                    self.write_line_without_skipping_whitespace_and_comments();
+                    self.write_indentation();
+                }
+                Chunk::LeadingComment(text_chunk) => {
+                    let ends_with_multiple_newlines = text_chunk.string.ends_with("\n\n");
+                    let ends_with_newline =
+                        ends_with_multiple_newlines || text_chunk.string.ends_with('\n');
+                    self.write_chunk_lines(text_chunk.string.trim());
+
+                    // Respect whether the leading comment had a newline before what comes next or not
+                    if ends_with_multiple_newlines {
+                        // Remove any indentation that could exist (we'll add it later)
+                        self.buffer.trim_spaces();
+                        self.write_multiple_lines_without_skipping_whitespace_and_comments();
+                        self.write_indentation();
+                    } else if ends_with_newline {
+                        self.write_line_without_skipping_whitespace_and_comments();
+                        self.write_indentation();
+                    } else {
+                        self.write_space_without_skipping_whitespace_and_comments();
+                    }
+                }
+                Chunk::Group(mut group) => {
+                    if chunks.force_multiline_on_children_with_same_tag_if_multiline
+                        && chunks.tag == group.tag
+                    {
+                        group.force_multiple_lines = true;
+                        group.force_multiline_on_children_with_same_tag_if_multiline = true;
+                    }
+
+                    self.format_chunk_group_impl(group);
+                }
+                Chunk::Line { two } => {
+                    if two {
+                        self.write_multiple_lines_without_skipping_whitespace_and_comments();
+                    } else {
+                        self.write_line_without_skipping_whitespace_and_comments();
+                    }
+                    self.write_indentation();
+                }
+                Chunk::SpaceOrLine => {
+                    last_was_space_or_line = true;
+                }
+                Chunk::IncreaseIndentation => {
+                    self.increase_indentation();
+                }
+                Chunk::DecreaseIndentation => {
+                    self.decrease_indentation();
+                }
+                Chunk::PushIndentation => {
+                    self.push_indentation();
+                }
+                Chunk::PopIndentation => {
+                    self.pop_indentation();
+                }
+                Chunk::TrailingComma => {
+                    unreachable!(
+                        "TrailingComma should have been removed by `prepare_for_multiple_lines`"
+                    )
+                }
+            }
+        }
+    }
+
+    fn format_lambda_body_removing_braces(&mut self, group: ChunkGroup) {
+        // Write to an intermediate string so we can remove the braces if needed.
+        let text_chunk = self.chunk_formatter().chunk(|formatter| {
+            formatter.format_chunk_group_in_one_line(group);
+        });
+        let string = text_chunk.string;
+
+        // Don't remove the braces if the lambda's body is a Semi expression.
+        if string.ends_with("; }") || string.ends_with("; },") {
+            self.write(&string);
+            return;
+        }
+
+        let string = string.strip_prefix("{ ").unwrap();
+
+        // The lambda might have a trailing comma if it's inside an arguments list
+        if let Some(string) = string.strip_suffix(" },") {
+            self.write(string);
+            self.write(",");
+        } else {
+            let string = string.strip_suffix(" }").unwrap();
+            self.write(string);
+        }
+    }
+
+    /// Appends the string to the current buffer line by line, with some pre-checks.
+    fn write_chunk_lines(&mut self, string: &str) {
+        let lines: Vec<_> = string.lines().collect();
+
+        let mut index = 0;
+        while index < lines.len() {
+            let line = &lines[index];
+
+            // Don't indent the first line (it should already be indented).
+            // Also don't indent if the current line already has a space as the last char
+            // (it means it's already indented)
+            if index > 0 && !self.buffer.ends_with_space() {
+                self.write_line_without_skipping_whitespace_and_comments();
+                // Only indent if the line doesn't start with a space. When that happens
+                // it's likely a block comment part that we don't want to modify.
+                if !line.starts_with(' ') {
+                    self.write_indentation();
+                }
+            }
+
+            // If we already have a space in the buffer and the line starts with a space,
+            // don't repeat that space.
+            if self.buffer.ends_with_space() && line.starts_with(' ') {
+                self.write(line.trim_start());
+            } else {
+                self.write(line);
+            }
+
+            index += 1;
+
+            // If a newline comes next too, write multiple lines to preserve original formatting
+            while index < lines.len() && lines[index].is_empty() {
+                self.write_multiple_lines_without_skipping_whitespace_and_comments();
+                index += 1;
+            }
+        }
+    }
+
+    /// Returns a new GroupTag that is unique compared to other `new_group_tag` calls.
+    pub(super) fn new_group_tag(&mut self) -> GroupTag {
+        let tag = GroupTag(self.group_tag_counter);
+        self.group_tag_counter += 1;
+        tag
+    }
+}
diff --git a/tooling/nargo_fmt/src/config.rs b/tooling/nargo_fmt/src/config.rs
index 5e38dc7d8b0..488647c0b39 100644
--- a/tooling/nargo_fmt/src/config.rs
+++ b/tooling/nargo_fmt/src/config.rs
@@ -1,5 +1,7 @@
 use std::path::Path;
 
+use serde::{Deserialize, Serialize};
+
 use crate::errors::ConfigError;
 
 macro_rules! config {
@@ -45,11 +47,12 @@ config! {
     max_width: usize, 100, "Maximum width of each line";
     tab_spaces: usize, 4, "Number of spaces per tab";
     remove_nested_parens: bool, true, "Remove nested parens";
-    error_on_lost_comment: bool, false, "Error if unable to get comments";
     short_array_element_width_threshold: usize, 10, "Width threshold for an array element to be considered short";
     array_width: usize, 100, "Maximum width of an array literal before falling back to vertical formatting";
     fn_call_width: usize, 60, "Maximum width of the args of a function call before falling back to vertical formatting";
     single_line_if_else_max_width: usize, 50, "Maximum line length for single line if-else expressions";
+    imports_granularity: ImportsGranularity, ImportsGranularity::Preserve, "How imports should be grouped into use statements.";
+    reorder_imports: bool, true, "Reorder imports alphabetically";
 }
 
 impl Config {
@@ -72,3 +75,13 @@ impl Config {
         Ok(config)
     }
 }
+
+/// How imports should be grouped into use statements.
+/// Imports will be merged or split to the configured level of granularity.
+#[derive(Serialize, Deserialize, Copy, Clone, PartialEq, Eq)]
+pub enum ImportsGranularity {
+    /// Do not change the granularity of any imports and preserve the original structure written by the developer.
+    Preserve,
+    /// Merge imports from the same crate into a single use statement.
+    Crate,
+}
diff --git a/tooling/nargo_fmt/src/formatter.rs b/tooling/nargo_fmt/src/formatter.rs
new file mode 100644
index 00000000000..9a9386e1911
--- /dev/null
+++ b/tooling/nargo_fmt/src/formatter.rs
@@ -0,0 +1,314 @@
+use buffer::Buffer;
+use noirc_frontend::{
+    ast::Ident,
+    hir::resolution::errors::Span,
+    lexer::Lexer,
+    token::{Keyword, SpannedToken, Token},
+    ParsedModule,
+};
+
+use crate::Config;
+
+mod alias;
+mod attribute;
+mod buffer;
+mod comments_and_whitespace;
+mod doc_comments;
+mod expression;
+mod function;
+mod generics;
+mod global;
+mod impls;
+mod item;
+mod lvalue;
+mod module;
+mod path;
+mod pattern;
+mod statement;
+mod structs;
+mod trait_impl;
+mod traits;
+mod type_expression;
+mod types;
+mod use_tree;
+mod use_tree_merge;
+mod visibility;
+mod where_clause;
+
+pub(crate) struct Formatter<'a> {
+    pub(crate) config: &'a Config,
+    source: &'a str,
+    lexer: Lexer<'a>,
+    token: Token,
+    token_span: Span,
+
+    /// The current indentation level.
+    /// We allow it to be negative because in some cases we just want to decrease indentation
+    /// to preemptively cancel out an indentation that will come later which we don't want to take effect,
+    /// and we don't want to panic when reaching those negative values.
+    pub(crate) indentation: i32,
+
+    /// When formatting chunks we sometimes need to remember the current indentation
+    /// and restore it later. This is what this stack is used for.
+    indentation_stack: Vec<i32>,
+
+    /// Whenever a comment is written, this counter is incremented.
+    /// In this way we can know if comments were written while formatting some code:
+    /// we remember the previous value, format, then see if it increased.
+    /// This is used, for example, when transforming `foo::{bar}` into `foo::bar`:
+    /// we only do that if there were no comments between `{` and `}`.
+    written_comments_count: usize,
+
+    /// If we find a comment like this one:
+    ///
+    /// // noir-fmt:ignore
+    ///
+    /// we won't format the next node (in some cases: only applies to statements and items).
+    ignore_next: bool,
+
+    /// A counter to create GroupTags.
+    pub(crate) group_tag_counter: usize,
+
+    /// We keep a copy of the config's max width because when we format chunk groups
+    /// we somethings change this so that a group has less space to write to.
+    pub(crate) max_width: usize,
+
+    /// This is the buffer where we write the formatted code.
+    pub(crate) buffer: Buffer,
+}
+
+impl<'a> Formatter<'a> {
+    pub(crate) fn new(source: &'a str, config: &'a Config) -> Self {
+        let lexer = Lexer::new(source).skip_comments(false).skip_whitespaces(false);
+        let mut formatter = Self {
+            config,
+            source,
+            lexer,
+            token: Token::EOF,
+            token_span: Default::default(),
+            indentation: 0,
+            indentation_stack: Vec::new(),
+            written_comments_count: 0,
+            ignore_next: false,
+            group_tag_counter: 0,
+            max_width: config.max_width,
+            buffer: Buffer::default(),
+        };
+        formatter.bump();
+        formatter
+    }
+
+    pub(crate) fn format_program(&mut self, parsed_module: ParsedModule) {
+        self.skip_whitespace();
+        self.skip_comments_and_whitespace_impl(
+            true, // write lines
+            true, // at beginning
+        );
+
+        self.format_parsed_module(parsed_module, self.ignore_next);
+    }
+
+    pub(crate) fn format_parsed_module(&mut self, parsed_module: ParsedModule, ignore_next: bool) {
+        if !parsed_module.inner_doc_comments.is_empty() {
+            self.format_inner_doc_comments();
+        }
+
+        self.format_items(parsed_module.items, ignore_next);
+        self.write_line();
+    }
+
+    pub(crate) fn write_identifier(&mut self, ident: Ident) {
+        self.skip_comments_and_whitespace();
+
+        let Token::Ident(..) = self.token else {
+            panic!("Expected identifier, got {:?}", self.token);
+        };
+        self.write(&ident.0.contents);
+        self.bump();
+    }
+
+    pub(crate) fn write_identifier_or_integer(&mut self, ident: Ident) {
+        self.skip_comments_and_whitespace();
+
+        if !matches!(self.token, Token::Ident(..) | Token::Int(..)) {
+            panic!("Expected identifier or integer, got {:?}", self.token);
+        }
+        self.write(&ident.0.contents);
+        self.bump();
+    }
+
+    pub(crate) fn write_left_paren(&mut self) {
+        self.write_token(Token::LeftParen);
+    }
+
+    pub(crate) fn write_right_paren(&mut self) {
+        self.write_token(Token::RightParen);
+    }
+
+    pub(crate) fn write_left_brace(&mut self) {
+        self.write_token(Token::LeftBrace);
+    }
+
+    pub(crate) fn write_right_brace(&mut self) {
+        self.write_token(Token::RightBrace);
+    }
+
+    pub(crate) fn write_left_bracket(&mut self) {
+        self.write_token(Token::LeftBracket);
+    }
+
+    pub(crate) fn write_right_bracket(&mut self) {
+        self.write_token(Token::RightBracket);
+    }
+
+    pub(crate) fn write_comma(&mut self) {
+        self.write_token(Token::Comma);
+    }
+
+    pub(crate) fn write_semicolon(&mut self) {
+        self.write_token(Token::Semicolon);
+    }
+
+    /// Writes the given keyword, if the current token is that keyword
+    /// (so this is a check that we are producing a token we expect to be in the source
+    /// we are traversing). Then advances to the next token.
+    ///
+    /// Calls `write_token` so comments and whitespaces are skipped before writing the keyword.
+    pub(crate) fn write_keyword(&mut self, keyword: Keyword) {
+        self.write_token(Token::Keyword(keyword));
+    }
+
+    /// Writes the given token, if the current token is the same as the given one
+    /// (so this is a check that we are producing a token we expect to be in the source
+    /// we are traversing). Then advances to the next token.
+    ///
+    /// Before writing the token any comments and spaces are skipped. This is so that
+    /// a caller can call `write_token`, `write_keyword`, `write_space`, etc., without
+    /// having to explicitly call `skip_comments_and_whitespace` in between those calls.
+    pub(crate) fn write_token(&mut self, token: Token) {
+        self.skip_comments_and_whitespace();
+        if self.token == token {
+            self.write_current_token_and_bump();
+        } else {
+            panic!("Expected token {:?}, got: {:?}", token, self.token);
+        }
+    }
+
+    /// Writes the current token but doesn't advance to the next one.
+    pub(crate) fn write_current_token(&mut self) {
+        self.write(&self.token.to_string());
+    }
+
+    /// Writes the current token and advances to the next one
+    pub(crate) fn write_current_token_and_bump(&mut self) {
+        self.write(&self.token.to_string());
+        self.bump();
+    }
+
+    /// Writes the current token trimming its end but doesn't advance to the next one.
+    /// Mainly used when writing comment lines, because we never want trailing spaces
+    /// inside comments.
+    pub(crate) fn write_current_token_trimming_end(&mut self) {
+        self.write(self.token.to_string().trim_end());
+    }
+
+    /// Writes the current token but without turning it into a string using `to_string()`.
+    /// Instead, we check the token's span and format what's in the original source there
+    /// (useful when formatting integer tokens, because a token like 0xFF ends up being an
+    /// integer with a value 255, but we don't want to change 0xFF to 255).
+    pub(crate) fn write_current_token_as_in_source(&mut self) {
+        self.write_source_span(self.token_span);
+    }
+
+    /// Writes whatever is in the given span relative to the file's source that's being formatted.
+    pub(crate) fn write_source_span(&mut self, span: Span) {
+        self.write(&self.source[span.start() as usize..span.end() as usize]);
+    }
+
+    /// Writes the current indentation to the buffer, but only if the buffer
+    /// is empty or it ends with a newline (otherwise we'd be indenting when not needed).
+    pub(crate) fn write_indentation(&mut self) {
+        if !(self.buffer.is_empty() || self.buffer.ends_with_newline()) {
+            return;
+        }
+
+        for _ in 0..self.indentation {
+            for _ in 0..self.config.tab_spaces {
+                self.write(" ");
+            }
+        }
+    }
+
+    /// Writes whatever is in the source at the given span without formatting it,
+    /// then advances the lexer until past the end of the span.
+    /// This is mainly used to avoid formatting items and statements when a
+    /// `noir-fmt:ignore` comment is found.
+    pub(super) fn write_and_skip_span_without_formatting(&mut self, span: Span) {
+        self.write_source_span(span);
+
+        while self.token_span.start() < span.end() && self.token != Token::EOF {
+            self.bump();
+        }
+    }
+
+    /// Advances the lexer until past the given span end without writing anything to the buffer.
+    pub(super) fn skip_past_span_end_without_formatting(&mut self, span_end: u32) {
+        while self.token_span.start() < span_end && self.token != Token::EOF {
+            self.bump();
+        }
+    }
+
+    /// Writes a string to the buffer.
+    pub(crate) fn write(&mut self, str: &str) {
+        self.buffer.write(str);
+    }
+
+    pub(crate) fn current_line_width(&self) -> usize {
+        self.buffer.current_line_width()
+    }
+
+    pub(crate) fn increase_indentation(&mut self) {
+        self.indentation += 1;
+    }
+
+    pub(crate) fn decrease_indentation(&mut self) {
+        self.indentation -= 1;
+    }
+
+    pub(crate) fn push_indentation(&mut self) {
+        self.indentation_stack.push(self.indentation);
+    }
+
+    pub(crate) fn pop_indentation(&mut self) {
+        self.indentation = self.indentation_stack.pop().unwrap();
+    }
+
+    pub(crate) fn is_at_keyword(&self, keyword: Keyword) -> bool {
+        self.is_at(Token::Keyword(keyword))
+    }
+
+    pub(crate) fn is_at(&self, token: Token) -> bool {
+        self.token == token
+    }
+
+    /// Advances to the next token (the current token is not written).
+    pub(crate) fn bump(&mut self) -> Token {
+        self.ignore_next = false;
+
+        let next_token = self.read_token_internal();
+        self.token_span = next_token.to_span();
+        std::mem::replace(&mut self.token, next_token.into_token())
+    }
+
+    pub(crate) fn read_token_internal(&mut self) -> SpannedToken {
+        let token = self.lexer.next();
+        if let Some(token) = token {
+            match token {
+                Ok(token) => token,
+                Err(err) => panic!("Expected lexer not to error, but got: {:?}", err),
+            }
+        } else {
+            SpannedToken::new(Token::EOF, Default::default())
+        }
+    }
+}
diff --git a/tooling/nargo_fmt/src/formatter/alias.rs b/tooling/nargo_fmt/src/formatter/alias.rs
new file mode 100644
index 00000000000..d4c63ebdd9e
--- /dev/null
+++ b/tooling/nargo_fmt/src/formatter/alias.rs
@@ -0,0 +1,41 @@
+use noirc_frontend::{
+    ast::NoirTypeAlias,
+    token::{Keyword, Token},
+};
+
+use super::Formatter;
+
+impl<'a> Formatter<'a> {
+    pub(super) fn format_type_alias(&mut self, type_alias: NoirTypeAlias) {
+        self.write_indentation();
+        self.format_item_visibility(type_alias.visibility);
+        self.write_keyword(Keyword::Type);
+        self.write_space();
+        self.write_identifier(type_alias.name);
+        self.format_generics(type_alias.generics);
+        self.write_space();
+        self.write_token(Token::Assign);
+        self.write_space();
+        self.format_type(type_alias.typ);
+        self.write_semicolon();
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use crate::assert_format;
+
+    #[test]
+    fn format_type_alias() {
+        let src = "  pub  type  Foo  =   i32  ; ";
+        let expected = "pub type Foo = i32;\n";
+        assert_format(src, expected);
+    }
+
+    #[test]
+    fn format_generic_type_alias() {
+        let src = "  pub  type  Foo < A, B > =   i32  ; ";
+        let expected = "pub type Foo<A, B> = i32;\n";
+        assert_format(src, expected);
+    }
+}
diff --git a/tooling/nargo_fmt/src/formatter/attribute.rs b/tooling/nargo_fmt/src/formatter/attribute.rs
new file mode 100644
index 00000000000..19d5730a546
--- /dev/null
+++ b/tooling/nargo_fmt/src/formatter/attribute.rs
@@ -0,0 +1,342 @@
+use noirc_frontend::token::{
+    Attribute, Attributes, FunctionAttribute, MetaAttribute, SecondaryAttribute, TestScope, Token,
+};
+
+use crate::chunks::ChunkGroup;
+
+use super::Formatter;
+
+impl<'a> Formatter<'a> {
+    pub(super) fn format_attributes(&mut self, attributes: Attributes) {
+        let mut all_attributes = Vec::new();
+        for attribute in attributes.secondary {
+            all_attributes.push(Attribute::Secondary(attribute));
+        }
+        if let Some((function_attribute, index)) = attributes.function {
+            all_attributes.insert(index, Attribute::Function(function_attribute));
+        }
+        for attribute in all_attributes {
+            self.format_attribute(attribute);
+        }
+    }
+
+    pub(super) fn format_secondary_attributes(&mut self, attributes: Vec<SecondaryAttribute>) {
+        for attribute in attributes {
+            self.format_secondary_attribute(attribute);
+        }
+    }
+
+    fn format_attribute(&mut self, attribute: Attribute) {
+        match attribute {
+            Attribute::Function(function_attribute) => {
+                self.format_function_attribute(function_attribute);
+            }
+            Attribute::Secondary(secondary_attribute) => {
+                self.format_secondary_attribute(secondary_attribute);
+            }
+        }
+    }
+
+    fn format_function_attribute(&mut self, attribute: FunctionAttribute) {
+        self.skip_comments_and_whitespace();
+        self.write_indentation();
+
+        if !matches!(self.token, Token::AttributeStart { .. }) {
+            panic!("Expected attribute start, got: {:?}", self.token);
+        }
+
+        match attribute {
+            FunctionAttribute::Foreign(_)
+            | FunctionAttribute::Builtin(_)
+            | FunctionAttribute::Oracle(_) => self.format_one_arg_attribute(),
+            FunctionAttribute::Test(test_scope) => self.format_test_attribute(test_scope),
+            FunctionAttribute::Fold
+            | FunctionAttribute::NoPredicates
+            | FunctionAttribute::InlineAlways => self.format_no_args_attribute(),
+        }
+
+        self.write_line();
+    }
+
+    pub(super) fn format_secondary_attribute(&mut self, attribute: SecondaryAttribute) {
+        self.skip_comments_and_whitespace();
+        self.write_indentation();
+
+        if !matches!(self.token, Token::AttributeStart { .. }) {
+            panic!("Expected attribute start, got: {:?}", self.token);
+        }
+
+        match attribute {
+            SecondaryAttribute::Deprecated(message) => {
+                self.format_deprecated_attribute(message);
+            }
+            SecondaryAttribute::ContractLibraryMethod
+            | SecondaryAttribute::Export
+            | SecondaryAttribute::Varargs
+            | SecondaryAttribute::UseCallersScope => {
+                self.format_no_args_attribute();
+            }
+            SecondaryAttribute::Field(_)
+            | SecondaryAttribute::Abi(_)
+            | SecondaryAttribute::Allow(_) => {
+                self.format_one_arg_attribute();
+            }
+            SecondaryAttribute::Tag(custom_attribute) => {
+                self.write_and_skip_span_without_formatting(custom_attribute.span);
+            }
+            SecondaryAttribute::Meta(meta_attribute) => {
+                self.format_meta_attribute(meta_attribute);
+            }
+        }
+
+        self.write_line();
+    }
+
+    fn format_deprecated_attribute(&mut self, message: Option<String>) {
+        self.write_current_token_and_bump(); // #[
+        self.skip_comments_and_whitespace();
+        if message.is_some() {
+            self.write_current_token_and_bump(); // deprecated
+            self.write_left_paren(); // (
+            self.skip_comments_and_whitespace(); // message
+            self.write_current_token_and_bump(); // )
+            self.write_right_paren();
+        } else {
+            self.write_current_token_and_bump();
+        }
+        self.write_right_bracket(); // ]
+    }
+
+    fn format_test_attribute(&mut self, test_scope: TestScope) {
+        self.write_current_token_and_bump(); // #[
+        self.skip_comments_and_whitespace();
+        self.write_current_token_and_bump(); // test
+
+        match test_scope {
+            TestScope::None => (),
+            TestScope::ShouldFailWith { reason: None } => {
+                self.write_left_paren(); // (
+                self.skip_comments_and_whitespace();
+                self.write_current_token_and_bump(); // should_fail
+                self.write_right_paren(); // )
+            }
+            TestScope::ShouldFailWith { reason: Some(..) } => {
+                self.write_left_paren(); // (
+                self.skip_comments_and_whitespace();
+                self.write_current_token_and_bump(); // should_fail_with
+                self.write_space();
+                self.write_token(Token::Assign);
+                self.write_space();
+                self.skip_comments_and_whitespace();
+                self.write_current_token_and_bump(); // "reason"
+                self.write_right_paren(); // )
+            }
+        }
+
+        self.write_right_bracket(); // ]
+    }
+
+    fn format_meta_attribute(&mut self, meta_attribute: MetaAttribute) {
+        self.write_current_token_and_bump(); // #[
+        self.skip_comments_and_whitespace();
+        self.format_path(meta_attribute.name);
+        self.skip_comments_and_whitespace();
+        if self.is_at(Token::LeftParen) {
+            let comments_count_before_arguments = self.written_comments_count;
+            let has_arguments = !meta_attribute.arguments.is_empty();
+
+            let mut chunk_formatter = self.chunk_formatter();
+            let mut group = ChunkGroup::new();
+            group.text(chunk_formatter.chunk(|formatter| {
+                formatter.write_left_paren();
+            }));
+            chunk_formatter.format_expressions_separated_by_comma(
+                meta_attribute.arguments,
+                false, // force trailing comma
+                &mut group,
+            );
+            group.text(chunk_formatter.chunk(|formatter| {
+                formatter.write_right_paren();
+            }));
+            if has_arguments || self.written_comments_count > comments_count_before_arguments {
+                self.format_chunk_group(group);
+            }
+        }
+        self.write_right_bracket();
+    }
+
+    fn format_no_args_attribute(&mut self) {
+        self.write_current_token_and_bump(); // #[
+        self.skip_comments_and_whitespace();
+        self.write_current_token_and_bump(); // name
+        self.write_right_bracket(); // ]
+    }
+
+    fn format_one_arg_attribute(&mut self) {
+        self.write_current_token_and_bump(); // #[
+        self.skip_comments_and_whitespace();
+        self.write_current_token_and_bump(); // name
+        self.write_left_paren(); // (
+        loop {
+            self.skip_comments_and_whitespace();
+            if self.is_at(Token::RightParen) {
+                self.write_right_paren();
+                break;
+            } else {
+                self.write_current_token_and_bump();
+            }
+        }
+        self.write_right_bracket(); // ]
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use crate::assert_format;
+
+    fn assert_format_attribute(src: &str, expected: &str) {
+        let src = format!("  {src} fn foo() {{}}");
+        let expected = format!("{expected}\nfn foo() {{}}\n");
+        assert_format(&src, &expected);
+    }
+
+    #[test]
+    fn format_inner_tag_attribute() {
+        let src = "  #!['foo] ";
+        let expected = "#!['foo]\n";
+        assert_format(src, expected);
+    }
+
+    #[test]
+    fn format_deprecated_attribute() {
+        let src = "  #[ deprecated ] ";
+        let expected = "#[deprecated]";
+        assert_format_attribute(src, expected);
+    }
+
+    #[test]
+    fn format_deprecated_attribute_with_message() {
+        let src = "  #[ deprecated ( \"use something else\" ) ] ";
+        let expected = "#[deprecated(\"use something else\")]";
+        assert_format_attribute(src, expected);
+    }
+
+    #[test]
+    fn format_contract_library_method() {
+        let src = "  #[ contract_library_method ] ";
+        let expected = "#[contract_library_method]";
+        assert_format_attribute(src, expected);
+    }
+
+    #[test]
+    fn format_export() {
+        let src = "  #[ export ] ";
+        let expected = "#[export]";
+        assert_format_attribute(src, expected);
+    }
+
+    #[test]
+    fn format_varargs() {
+        let src = "  #[ varargs ] ";
+        let expected = "#[varargs]";
+        assert_format_attribute(src, expected);
+    }
+
+    #[test]
+    fn format_use_callers_scope() {
+        let src = "  #[ use_callers_scope ] ";
+        let expected = "#[use_callers_scope]";
+        assert_format_attribute(src, expected);
+    }
+
+    #[test]
+    fn format_field_attribute() {
+        let src = "  #[ field ( bn256 ) ] ";
+        let expected = "#[field(bn256)]";
+        assert_format_attribute(src, expected);
+    }
+
+    #[test]
+    fn format_abi_attribute() {
+        let src = "  #[ abi ( foo ) ] ";
+        let expected = "#[abi(foo)]";
+        assert_format_attribute(src, expected);
+    }
+
+    #[test]
+    fn format_allow_attribute() {
+        let src = "  #[ allow ( unused_vars ) ] ";
+        let expected = "#[allow(unused_vars)]";
+        assert_format_attribute(src, expected);
+    }
+
+    #[test]
+    fn format_meta_attribute_without_arguments() {
+        let src = "  #[ custom  ] ";
+        let expected = "#[custom]";
+        assert_format_attribute(src, expected);
+    }
+
+    #[test]
+    fn format_meta_attribute_without_arguments_removes_parentheses() {
+        let src = "  #[ custom (  ) ] ";
+        let expected = "#[custom]";
+        assert_format_attribute(src, expected);
+    }
+
+    #[test]
+    fn format_meta_attribute_without_arguments_but_comment() {
+        let src = "  #[ custom ( /* nothing */ ) ] ";
+        let expected = "#[custom( /* nothing */ )]";
+        assert_format_attribute(src, expected);
+    }
+
+    #[test]
+    fn format_meta_attribute_with_arguments() {
+        let src = "  #[ custom ( 1 , 2,  [ 3, 4 ],  ) ] ";
+        let expected = "#[custom(1, 2, [3, 4])]";
+        assert_format_attribute(src, expected);
+    }
+
+    #[test]
+    fn format_foreign_attribute() {
+        let src = "  #[ foreign ( foo ) ] ";
+        let expected = "#[foreign(foo)]";
+        assert_format_attribute(src, expected);
+    }
+
+    #[test]
+    fn format_recursive_attribute() {
+        let src = "  #[ recursive ] ";
+        let expected = "#[recursive]";
+        assert_format_attribute(src, expected);
+    }
+
+    #[test]
+    fn format_test_attribute() {
+        let src = "  #[ test ] ";
+        let expected = "#[test]";
+        assert_format_attribute(src, expected);
+    }
+
+    #[test]
+    fn format_test_should_fail_attribute() {
+        let src = "  #[ test ( should_fail )] ";
+        let expected = "#[test(should_fail)]";
+        assert_format_attribute(src, expected);
+    }
+
+    #[test]
+    fn format_test_should_fail_with_reason_attribute() {
+        let src = "  #[ test ( should_fail_with=\"reason\" )] ";
+        let expected = "#[test(should_fail_with = \"reason\")]";
+        assert_format_attribute(src, expected);
+    }
+
+    #[test]
+    fn format_multiple_function_attributes() {
+        let src = " #[foo] #[test] #[bar]  ";
+        let expected = "#[foo]\n#[test]\n#[bar]";
+        assert_format_attribute(src, expected);
+    }
+}
diff --git a/tooling/nargo_fmt/src/formatter/buffer.rs b/tooling/nargo_fmt/src/formatter/buffer.rs
new file mode 100644
index 00000000000..3e4bebef608
--- /dev/null
+++ b/tooling/nargo_fmt/src/formatter/buffer.rs
@@ -0,0 +1,66 @@
+/// A buffer to write to.
+/// It keeps track of the current line width and provides a few useful methods
+/// to deal with the buffer contents.
+#[derive(Default, Debug)]
+pub(crate) struct Buffer {
+    buffer: String,
+
+    /// How many characters we've written so far in the current line
+    /// (useful to avoid exceeding the configurable maximum)
+    current_line_width: usize,
+}
+
+impl Buffer {
+    pub(crate) fn is_empty(&self) -> bool {
+        self.buffer.is_empty()
+    }
+
+    pub(crate) fn ends_with_newline(&self) -> bool {
+        self.buffer.ends_with('\n')
+    }
+
+    pub(crate) fn ends_with_double_newline(&self) -> bool {
+        self.buffer.ends_with("\n\n")
+    }
+
+    pub(crate) fn ends_with_space(&self) -> bool {
+        self.buffer.ends_with(' ')
+    }
+
+    pub(crate) fn write(&mut self, str: &str) {
+        self.buffer.push_str(str);
+
+        if str.ends_with('\n') {
+            self.current_line_width = 0;
+        } else {
+            self.current_line_width += str.chars().count();
+        }
+    }
+
+    /// Trim spaces from the end of the buffer.
+    pub(crate) fn trim_spaces(&mut self) {
+        while self.buffer.ends_with(' ') {
+            self.buffer.truncate(self.buffer.len() - 1);
+            self.current_line_width -= 1;
+        }
+    }
+
+    /// Trim commas from the end of the buffer. Returns true if a comma was trimmed.
+    pub(super) fn trim_comma(&mut self) -> bool {
+        if self.buffer.ends_with(',') {
+            self.buffer.truncate(self.buffer.len() - 1);
+            self.current_line_width -= 1;
+            true
+        } else {
+            false
+        }
+    }
+
+    pub(crate) fn contents(self) -> String {
+        self.buffer
+    }
+
+    pub(crate) fn current_line_width(&self) -> usize {
+        self.current_line_width
+    }
+}
diff --git a/tooling/nargo_fmt/src/formatter/comments_and_whitespace.rs b/tooling/nargo_fmt/src/formatter/comments_and_whitespace.rs
new file mode 100644
index 00000000000..e20eb4291d1
--- /dev/null
+++ b/tooling/nargo_fmt/src/formatter/comments_and_whitespace.rs
@@ -0,0 +1,861 @@
+use noirc_frontend::token::Token;
+
+use super::Formatter;
+
+#[cfg(windows)]
+const NEWLINE: &str = "\r\n";
+#[cfg(not(windows))]
+const NEWLINE: &str = "\n";
+
+impl<'a> Formatter<'a> {
+    /// Writes a single space, skipping any whitespace and comments.
+    /// That is, suppose the next token is a big whitespace, possibly with multiple lines.
+    /// Those are skipped but only one space is written. In this way if we have
+    /// "mod     foo" it's transformed to "mod foo".
+    /// If there are comments in between `mod` and `foo` they are written, though!
+    /// No comment is ever lost.
+    ///
+    /// A space is not appended to the buffer is it already ends with a space.
+    pub(crate) fn write_space(&mut self) {
+        self.skip_comments_and_whitespace();
+        self.write_space_without_skipping_whitespace_and_comments();
+    }
+
+    /// Writes a single space, but doesn't skip whitespace and comments before doing that.
+    ///
+    /// A space is not appended to the buffer is it already ends with a space.
+    pub(crate) fn write_space_without_skipping_whitespace_and_comments(&mut self) {
+        if !self.buffer.ends_with_newline() && !self.buffer.ends_with_space() {
+            self.write(" ");
+        }
+    }
+
+    pub(crate) fn skip_whitespace(&mut self) {
+        while let Token::Whitespace(..) = &self.token {
+            self.bump();
+        }
+    }
+
+    /// Only skips whitespace if it doesn't have newlines in it.
+    /// Note that this doesn't write whitespace or comments at all.
+    pub(crate) fn skip_whitespace_if_it_is_not_a_newline(&mut self) {
+        while let Token::Whitespace(whitespace) = &self.token {
+            if whitespace.contains('\n') {
+                break;
+            }
+            self.bump();
+        }
+    }
+
+    /// Skips comments and whitespace, writing newlines if there are any.
+    /// If there are multiple consecutive newlines, only one is written.
+    pub(crate) fn skip_comments_and_whitespace(&mut self) {
+        self.skip_comments_and_whitespace_impl(
+            false, // write multiple lines
+            false, // at beginning
+        );
+    }
+
+    /// Similar to skip_comments_and_whitespace, but will write two lines if
+    /// multiple newlines are found (but at most two lines at a time).
+    pub(crate) fn skip_comments_and_whitespace_writing_multiple_lines_if_found(&mut self) {
+        self.skip_comments_and_whitespace_impl(
+            true,  // write multiple lines
+            false, // at beginning
+        );
+    }
+
+    pub(crate) fn skip_comments_and_whitespace_impl(
+        &mut self,
+        write_multiple_lines: bool,
+        at_beginning: bool,
+    ) {
+        // Number of newlines we just skipped.
+        let mut number_of_newlines = 0;
+
+        // Did we just passed some whitespace?
+        let mut passed_whitespace = false;
+
+        // Was the last token we processed a block comment?
+        let mut last_was_block_comment = false;
+
+        let mut ignore_next = false;
+
+        loop {
+            match &self.token {
+                Token::Whitespace(whitespace) => {
+                    number_of_newlines = whitespace.chars().filter(|char| *char == '\n').count();
+                    passed_whitespace = whitespace.ends_with(' ');
+
+                    if last_was_block_comment && number_of_newlines > 0 {
+                        if number_of_newlines > 1 {
+                            self.write_multiple_lines_without_skipping_whitespace_and_comments();
+                        } else {
+                            self.write_line_without_skipping_whitespace_and_comments();
+                        }
+
+                        self.bump();
+
+                        // Only indent for what's coming next if it's a comment
+                        // (otherwise a closing brace must come and we wouldn't want to indent that)
+                        if matches!(
+                            &self.token,
+                            Token::LineComment(_, None) | Token::BlockComment(_, None),
+                        ) {
+                            self.write_indentation();
+                        }
+
+                        number_of_newlines = 0;
+                        passed_whitespace = false;
+                    } else {
+                        self.bump();
+                    }
+
+                    last_was_block_comment = false;
+                }
+                Token::LineComment(comment, None) => {
+                    if comment.trim() == "noir-fmt:ignore" {
+                        ignore_next = true;
+                    }
+
+                    // Here we check if we need to write one line, two lines or none after the
+                    // end of the line comment.
+                    if number_of_newlines > 1 && write_multiple_lines {
+                        self.write_multiple_lines_without_skipping_whitespace_and_comments();
+                        self.write_indentation();
+                    } else if number_of_newlines > 0 {
+                        self.write_line_without_skipping_whitespace_and_comments();
+                        self.write_indentation();
+                    } else if !(at_beginning && self.buffer.is_empty()) {
+                        // We write a space before a line comment so if you have code like this:
+                        // "1// comment" it's transformed to "1 // comment".
+                        // What if there was already a space? It's all good, `write_space`
+                        // will never write two consecutive spaces.
+                        self.write_space_without_skipping_whitespace_and_comments();
+                    }
+
+                    self.write_current_token_trimming_end();
+                    self.write_line_without_skipping_whitespace_and_comments();
+                    number_of_newlines = 1;
+                    self.bump();
+                    passed_whitespace = false;
+                    last_was_block_comment = false;
+                    self.written_comments_count += 1;
+                }
+                Token::BlockComment(comment, None) => {
+                    if comment.trim() == "noir-fmt:ignore" {
+                        ignore_next = true;
+                    }
+
+                    // Here we check if we need to write one line, two lines or none after the
+                    // end of the block comment.
+                    if number_of_newlines > 1 && write_multiple_lines {
+                        self.write_multiple_lines_without_skipping_whitespace_and_comments();
+                        self.write_indentation();
+                    } else if number_of_newlines > 0 {
+                        self.write_line_without_skipping_whitespace_and_comments();
+                        self.write_indentation();
+                    } else if passed_whitespace {
+                        // We write a space before a line comment so if you have code like this:
+                        // "1/* comment */" it's transformed to "1 /* comment */".
+                        // What if there was already a space? It's all good, `write_space`
+                        // will never write two consecutive spaces.
+                        self.write_space_without_skipping_whitespace_and_comments();
+                    }
+                    self.write_current_token_and_bump();
+                    passed_whitespace = false;
+                    last_was_block_comment = true;
+                    self.written_comments_count += 1;
+                }
+                _ => break,
+            }
+        }
+
+        // Case when we passed some whitespace with newlines but no comments followed it.
+        if number_of_newlines > 1 && write_multiple_lines {
+            self.write_multiple_lines_without_skipping_whitespace_and_comments();
+        }
+
+        self.ignore_next = ignore_next;
+    }
+
+    /// Returns the number of newlines that come next, if we are at a whitespace
+    /// token (otherwise returns 0).
+    pub(crate) fn following_newlines_count(&self) -> usize {
+        let Token::Whitespace(whitespace) = &self.token else {
+            return 0;
+        };
+
+        whitespace.chars().filter(|char| *char == '\n').count()
+    }
+
+    /// Writes a single newline, if the last thing we wrote wasn't also a newline
+    /// (this prevents multiple consecutive newlines, though that's still possible to
+    /// do if you call `write_multiple_lines_...`).
+    ///
+    /// Any whitespace or comments found right at and after the current token are "skipped"
+    /// (whitespace is discarded, comments are written).
+    pub(crate) fn write_line(&mut self) {
+        self.skip_comments_and_whitespace_impl(
+            true,  // writing newline
+            false, // at beginning
+        );
+        self.write_line_without_skipping_whitespace_and_comments();
+    }
+
+    pub(crate) fn write_line_without_skipping_whitespace_and_comments(&mut self) -> bool {
+        if !self.buffer.ends_with_newline() && !self.buffer.ends_with_space() {
+            self.write(NEWLINE);
+            true
+        } else {
+            false
+        }
+    }
+
+    // Modifies the current buffer so that it will always have two newlines at the end.
+    pub(crate) fn write_multiple_lines_without_skipping_whitespace_and_comments(&mut self) {
+        if self.buffer.ends_with_double_newline() {
+            // Nothing
+        } else if self.buffer.ends_with_newline() {
+            self.write(NEWLINE);
+        } else {
+            self.write(NEWLINE);
+            self.write(NEWLINE);
+        }
+    }
+
+    /// Trim spaces from the end of the buffer.
+    pub(crate) fn trim_spaces(&mut self) {
+        self.buffer.trim_spaces();
+    }
+
+    /// Trim commas from the end of the buffer. Returns true if a comma was trimmed.
+    pub(crate) fn trim_comma(&mut self) -> bool {
+        self.buffer.trim_comma()
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use crate::{assert_format, assert_format_with_max_width};
+
+    #[test]
+    fn format_array_in_global_with_line_comments() {
+        let src = "global x = [ // hello
+        1 , 2 ] ;";
+        let expected = "global x = [
+    // hello
+    1, 2,
+];
+";
+        assert_format(src, expected);
+    }
+
+    #[test]
+    fn format_array_in_global_with_line_comments_2() {
+        let src = "global x = [ // hello
+         [ 1 , 2 ]  ] ;";
+        let expected = "global x = [
+    // hello
+    [1, 2],
+];
+";
+        assert_format(src, expected);
+    }
+
+    #[test]
+    fn format_array_in_global_with_line_comments_3() {
+        let src = "global x =
+    [ 
+        // hello
+        [1, 2],  
+    ];
+";
+        let expected = "global x = [
+    // hello
+    [1, 2],
+];
+";
+        assert_format(src, expected);
+    }
+
+    #[test]
+    fn format_array_in_global_with_line_comments_4() {
+        let src = "global x =
+    [
+        1, // world 
+        2, 3,
+    ];
+";
+        let expected = "global x = [
+    1, // world
+    2, 3,
+];
+";
+        assert_format(src, expected);
+    }
+
+    #[test]
+    fn format_array_in_global_with_block_comments() {
+        let src = "global x = [ /* hello */
+        1 , 2 ] ;";
+        let expected = "global x = [
+    /* hello */ 1,
+    2,
+];
+";
+        assert_format_with_max_width(src, expected, 20);
+    }
+
+    #[test]
+    fn format_if_with_comment_after_condition() {
+        let src = "global x = if  123  // some comment  
+        {   456   }  ;";
+        let expected = "global x = if 123 // some comment
+{
+    456
+};
+";
+        assert_format(src, expected);
+    }
+
+    #[test]
+    fn format_if_with_comment_after_else() {
+        let src = "global x = if  123  {   456   } else  // some comment 
+        { 789 };";
+        let expected = "global x = if 123 {
+    456
+} else // some comment
+{
+    789
+};
+";
+        assert_format(src, expected);
+    }
+
+    #[test]
+    fn format_function_when_some_args_are_multiline_because_of_line_comments() {
+        let src = "fn  foo ( a: i32, // comment
+         b: i32
+         )  { }  ";
+        let expected = "fn foo(
+    a: i32, // comment
+    b: i32,
+) {}
+";
+        assert_format(src, expected);
+    }
+
+    #[test]
+    fn format_function_when_some_args_are_multiline_because_of_line_comments_2() {
+        let src = "fn  foo ( a: i32, // comment
+        // another
+         b: i32 // another comment
+         )  { }  ";
+        let expected = "fn foo(
+    a: i32, // comment
+    // another
+    b: i32, // another comment
+) {}
+";
+        assert_format(src, expected);
+    }
+
+    #[test]
+    fn format_function_when_some_args_are_multiline_because_of_block_comments() {
+        let src = "fn  foo ( a: i32 /*
+        some
+        comment */, b: i32
+         )  { }  ";
+        let expected = "fn foo(
+    a: i32 /*
+        some
+        comment */,
+    b: i32,
+) {}\n";
+        assert_format(src, expected);
+    }
+
+    #[test]
+    fn format_function_with_comment_after_parameters() {
+        let src = "fn main()
+        // hello 
+    {}";
+        let expected = "fn main()
+// hello
+{}
+";
+        assert_format(src, expected);
+    }
+
+    #[test]
+    fn format_function_with_line_comment_in_parameters() {
+        let src = "fn main(
+        // hello
+        )
+    {}";
+        let expected = "fn main(
+    // hello
+) {}
+";
+        assert_format(src, expected);
+    }
+
+    #[test]
+    fn format_function_with_line_comment_on_top_of_parameter() {
+        let src = "fn main(
+// hello
+unit: ()
+) {}";
+        let expected = "fn main(
+    // hello
+    unit: (),
+) {}
+";
+        assert_format(src, expected);
+    }
+
+    #[test]
+    fn format_function_with_block_comment_in_params() {
+        let src = "fn main(/* test */) {}";
+        let expected = "fn main(/* test */) {}\n";
+        assert_format(src, expected);
+    }
+
+    #[test]
+    fn format_function_with_body_and_block_comment() {
+        let src = "fn main() { 
+        /* foo */ 
+        1 }";
+        let expected = "fn main() {
+    /* foo */
+    1
+}
+";
+        assert_format(src, expected);
+    }
+
+    #[test]
+    fn format_function_with_body_one_expr_trailing_comment() {
+        let src = "mod moo { fn main() { 1   // yes
+        } }";
+        let expected = "mod moo {
+    fn main() {
+        1 // yes
+    }
+}
+";
+        assert_format(src, expected);
+    }
+
+    #[test]
+    fn format_function_with_body_one_expr_semicolon_trailing_comment() {
+        let src = "mod moo { fn main() { 1  ; // yes
+        } }";
+        let expected = "mod moo {
+    fn main() {
+        1; // yes
+    }
+}
+";
+        assert_format(src, expected);
+    }
+
+    #[test]
+    fn format_function_with_many_exprs_trailing_comments() {
+        let src = "mod moo { fn main() { 1  ; // yes
+        2 ; // no
+        3 // maybe
+        } }";
+        let expected = "mod moo {
+    fn main() {
+        1; // yes
+        2; // no
+        3 // maybe
+    }
+}
+";
+        assert_format(src, expected);
+    }
+
+    #[test]
+    fn format_function_with_block_comment_after_two_newlines() {
+        let src = "fn foo() {
+    1;
+
+    /* world */
+    2
+}
+";
+        let expected = "fn foo() {
+    1;
+
+    /* world */
+    2
+}
+";
+        assert_format(src, expected);
+    }
+
+    #[test]
+    fn format_comment_on_top_of_let_followed_by_statement() {
+        let src = "fn foo() {
+    1;
+
+    // Comment
+    let x = 1;
+}
+";
+        let expected = "fn foo() {
+    1;
+
+    // Comment
+    let x = 1;
+}
+";
+        assert_format(src, expected);
+    }
+
+    #[test]
+    fn format_module_declaration_with_block_comments() {
+        let src = "  mod/*a*/ foo /*b*/ ; ";
+        let expected = "mod/*a*/ foo /*b*/;\n";
+        assert_format(src, expected);
+    }
+
+    #[test]
+    fn format_module_declaration_with_inline_comments() {
+        let src = "  mod // a  
+ foo // b 
+  ; ";
+        let expected = "mod // a
+foo // b
+;
+";
+        assert_format(src, expected);
+    }
+
+    #[test]
+    fn format_submodule_with_line_comments_in_separate_line() {
+        let src = " #[foo] pub  mod foo { 
+// one
+#[hello]
+mod bar; 
+// two
+}";
+        let expected = "#[foo]
+pub mod foo {
+    // one
+    #[hello]
+    mod bar;
+    // two
+}
+";
+        assert_format(src, expected);
+    }
+
+    #[test]
+    fn format_submodule_with_line_comment_in_same_line() {
+        let src = " #[foo] pub  mod foo {  // one
+mod bar; 
+}";
+        let expected = "#[foo]
+pub mod foo { // one
+    mod bar;
+}
+";
+        assert_format(src, expected);
+    }
+
+    #[test]
+    fn format_submodule_with_block_comment() {
+        let src = " #[foo] pub  mod foo {  /* one */
+/* two */
+mod bar; 
+}";
+        let expected = "#[foo]
+pub mod foo { /* one */
+    /* two */
+    mod bar;
+}
+";
+        assert_format(src, expected);
+    }
+
+    #[test]
+    fn format_submodule_with_block_comment_2() {
+        let src = "mod foo {
+        /* one */
+}";
+        let expected = "mod foo {
+    /* one */
+}
+";
+        assert_format(src, expected);
+    }
+
+    #[test]
+    fn keeps_spaces_between_comments() {
+        let src = "  mod  foo { 
+
+// hello
+
+// world
+
+} ";
+        let expected = "mod foo {
+
+    // hello
+
+    // world
+
+}
+";
+        assert_format(src, expected);
+    }
+
+    #[test]
+    fn comment_with_leading_space() {
+        let src = "    // comment
+        // hello
+mod  foo ; ";
+        let expected = "// comment
+// hello
+mod foo;
+";
+        assert_format(src, expected);
+    }
+
+    #[test]
+    fn format_empty_block_statement_with_inline_block_comment() {
+        let src = " fn foo() { { /* hello */ } } ";
+        let expected = "fn foo() {
+    { /* hello */ }
+}
+";
+        assert_format(src, expected);
+    }
+
+    #[test]
+    fn format_empty_struct_with_block_comments() {
+        let src = " struct Foo {
+        /* hello */
+    }
+        ";
+        let expected = "struct Foo {
+    /* hello */
+}
+";
+        assert_format(src, expected);
+    }
+
+    #[test]
+    fn format_struct_with_just_comments() {
+        let src = " mod foo { struct Foo {
+// hello
+    } }
+        ";
+        let expected = "mod foo {
+    struct Foo {
+        // hello
+    }
+}
+";
+        assert_format(src, expected);
+    }
+
+    #[test]
+    fn format_block_comment_no_whitespace_in_block_single_line() {
+        let src = "global x = {/*foo*/};";
+        let expected = "global x = { /*foo*/ };\n";
+        assert_format(src, expected);
+    }
+
+    #[test]
+    fn format_block_comment_no_whitespace_but_newline_in_block_single_line() {
+        let src = "global x = {/*foo*/
+        };";
+        let expected = "global x = { /*foo*/ };\n";
+        assert_format(src, expected);
+    }
+
+    #[test]
+    fn format_line_comment_in_block_same_line() {
+        let src = "global x = {       // foo
+        };";
+        let expected = "global x = { // foo
+};
+";
+        assert_format(src, expected);
+    }
+
+    #[test]
+    fn format_line_comment_in_block_separate_line() {
+        let src = "global x = {
+        // foo
+        };";
+        let expected = "global x = {
+    // foo
+};
+";
+        assert_format(src, expected);
+    }
+
+    #[test]
+    fn format_block_comment_in_parenthesized_expression() {
+        let src = "global x = ( /* foo */ 1 );";
+        let expected = "global x = ( /* foo */ 1);\n";
+        assert_format(src, expected);
+    }
+
+    #[test]
+    fn format_line_comment_in_parenthesized() {
+        let src = "global x = ( // hello 
+        1 );";
+        let expected = "global x = (
+    // hello
+    1
+);\n";
+        assert_format(src, expected);
+    }
+
+    #[test]
+    fn format_index_with_comment() {
+        let src = "global x = foo[// hello
+        1];";
+        let expected = "global x = foo[
+    // hello
+    1
+];\n";
+        assert_format(src, expected);
+    }
+
+    #[test]
+    fn format_comment_in_infix_between_lhs_and_operator() {
+        let src = "global x = 1/* comment */+ 2 ;";
+        let expected = "global x = 1 /* comment */ + 2;\n";
+        assert_format(src, expected);
+    }
+
+    #[test]
+    fn format_comment_in_constructor_inside_function() {
+        let src = "fn foo() { MyStruct {/*test*/}; } ";
+        let expected = "fn foo() {
+    MyStruct { /*test*/ };
+}
+";
+        assert_format(src, expected);
+    }
+
+    #[test]
+    fn format_block_comment_before_constructor_field() {
+        let src = "global x = Foo {/*comment*/field}; ";
+        let expected = "global x = Foo { /*comment*/ field };\n";
+        assert_format(src, expected);
+    }
+
+    #[test]
+    fn format_line_comment_before_constructor_field() {
+        let src = "global x = Foo { // foo
+        field}; ";
+        let expected = "global x = Foo {
+    // foo
+    field,
+};\n";
+        assert_format(src, expected);
+    }
+
+    #[test]
+    fn format_comment_in_empty_constructor() {
+        let src = "global x = Foo { // comment
+        }; ";
+        let expected = "global x = Foo { // comment
+};\n";
+        assert_format(src, expected);
+    }
+
+    #[test]
+    fn format_comment_after_parenthesized() {
+        let src = "global x = (
+            1
+            // hello
+        )
+        ; ";
+        let expected = "global x = (
+    1
+    // hello
+);\n";
+        assert_format(src, expected);
+    }
+
+    #[test]
+    fn format_comment_in_single_element_tuple() {
+        let src = "global x = ( 1 /* hello */ , );";
+        let expected = "global x = (1 /* hello */,);\n";
+        assert_format(src, expected);
+    }
+
+    #[test]
+    fn format_comment_after_impl_function() {
+        let src = "impl Foo { fn foo() {} 
+        // bar 
+        }";
+        let expected = "impl Foo {
+    fn foo() {}
+    // bar
+}
+";
+        assert_format(src, expected);
+    }
+
+    #[test]
+    fn format_comment_after_trait_impl_function() {
+        let src = "impl Foo for Bar { fn foo() {} 
+        // bar 
+        }";
+        let expected = "impl Foo for Bar {
+    fn foo() {}
+    // bar
+}
+";
+        assert_format(src, expected);
+    }
+
+    #[test]
+    fn format_comment_after_trait_function() {
+        let src = "trait Foo { fn foo() {} 
+        // bar 
+        }";
+        let expected = "trait Foo {
+    fn foo() {}
+    // bar
+}
+";
+        assert_format(src, expected);
+    }
+
+    #[test]
+    fn keeps_newlines_after_comment_at_the_beginning() {
+        let src = "// foo
+
+global x = 1;
+";
+        let expected = src;
+        assert_format(src, expected);
+    }
+
+    #[test]
+    fn keeps_newlines_after_comment_at_the_beginning_2() {
+        let src = "
+        
+        // foo
+
+global x = 1;
+";
+        let expected = "// foo
+
+global x = 1;
+";
+        assert_format(src, expected);
+    }
+}
diff --git a/tooling/nargo_fmt/src/formatter/doc_comments.rs b/tooling/nargo_fmt/src/formatter/doc_comments.rs
new file mode 100644
index 00000000000..ac2cae10c78
--- /dev/null
+++ b/tooling/nargo_fmt/src/formatter/doc_comments.rs
@@ -0,0 +1,72 @@
+use noirc_frontend::token::{DocStyle, Token};
+
+use super::Formatter;
+
+impl<'a> Formatter<'a> {
+    pub(super) fn format_inner_doc_comments(&mut self) {
+        loop {
+            self.skip_comments_and_whitespace();
+
+            match self.token {
+                Token::LineComment(_, Some(DocStyle::Inner))
+                | Token::BlockComment(_, Some(DocStyle::Inner)) => {
+                    self.write_indentation();
+                    self.write_current_token_trimming_end();
+                    self.bump();
+                    self.write_line();
+                }
+                _ => break,
+            }
+        }
+    }
+
+    pub(super) fn format_outer_doc_comments(&mut self) {
+        loop {
+            self.skip_comments_and_whitespace();
+
+            match self.token {
+                Token::LineComment(_, Some(DocStyle::Outer))
+                | Token::BlockComment(_, Some(DocStyle::Outer)) => {
+                    self.write_indentation();
+                    self.write_current_token_trimming_end();
+                    self.bump();
+                    self.write_line();
+                }
+                _ => break,
+            }
+        }
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use crate::assert_format;
+
+    #[test]
+    fn format_inner_doc_comments() {
+        let src = " #![hello] #![world]";
+        let expected = "#![hello]\n#![world]\n";
+        assert_format(src, expected);
+    }
+
+    #[test]
+    fn format_inner_doc_comments_with_line_comments() {
+        let src = " #![hello]  // foo   
+   // bar   
+    #![world]";
+        let expected = "#![hello] // foo
+// bar
+#![world]
+";
+        assert_format(src, expected);
+    }
+
+    #[test]
+    fn format_inner_doc_comments_with_block_comments() {
+        let src = " #![hello]    /* foo */    #![world]";
+        let expected = "#![hello] /* foo */
+#![world]
+";
+        assert_format(src, expected);
+    }
+}
diff --git a/tooling/nargo_fmt/src/formatter/expression.rs b/tooling/nargo_fmt/src/formatter/expression.rs
new file mode 100644
index 00000000000..ecc9fab18ce
--- /dev/null
+++ b/tooling/nargo_fmt/src/formatter/expression.rs
@@ -0,0 +1,2311 @@
+use noirc_frontend::{
+    ast::{
+        ArrayLiteral, BinaryOpKind, BlockExpression, CallExpression, CastExpression,
+        ConstructorExpression, Expression, ExpressionKind, IfExpression, IndexExpression,
+        InfixExpression, Lambda, Literal, MemberAccessExpression, MethodCallExpression,
+        PrefixExpression, TypePath, UnaryOp, UnresolvedTypeData,
+    },
+    token::{Keyword, Token},
+};
+
+use crate::chunks::{Chunk, ChunkFormatter, ChunkGroup, GroupKind, GroupTag, TextChunk};
+
+use super::Formatter;
+
+#[derive(Debug)]
+struct FormattedLambda {
+    group: ChunkGroup,
+    first_line_width: usize,
+}
+
+impl<'a, 'b> ChunkFormatter<'a, 'b> {
+    pub(super) fn format_expression(&mut self, expression: Expression, group: &mut ChunkGroup) {
+        group.leading_comment(self.skip_comments_and_whitespace_chunk());
+
+        match expression.kind {
+            ExpressionKind::Literal(literal) => self.format_literal(literal, group),
+            ExpressionKind::Block(block) => {
+                group.group(self.format_block_expression(
+                    block, false, // force multiple lines
+                ));
+            }
+            ExpressionKind::Prefix(prefix_expression) => {
+                group.group(self.format_prefix(*prefix_expression));
+            }
+            ExpressionKind::Index(index_expression) => {
+                group.group(self.format_index_expression(*index_expression));
+            }
+            ExpressionKind::Call(call) => group.group(self.format_call(*call)),
+            ExpressionKind::MethodCall(method_call) => {
+                group.group(self.format_method_call(*method_call));
+            }
+            ExpressionKind::Constructor(constructor) => {
+                group.group(self.format_constructor(*constructor));
+            }
+            ExpressionKind::MemberAccess(member_access) => {
+                group.group(self.format_member_access(*member_access));
+            }
+            ExpressionKind::Cast(cast_expression) => {
+                group.group(self.format_cast(*cast_expression));
+            }
+            ExpressionKind::Infix(infix_expression) => {
+                group.group(self.format_infix_expression(*infix_expression));
+            }
+            ExpressionKind::If(if_expression) => {
+                group.group(self.format_if_expression(
+                    *if_expression,
+                    false, // force multiple lines
+                ));
+            }
+            ExpressionKind::Variable(path) => {
+                group.text(self.chunk(|formatter| {
+                    formatter.format_path(path);
+                }));
+            }
+            ExpressionKind::Tuple(exprs) => group.group(self.format_tuple(exprs)),
+            ExpressionKind::Lambda(lambda) => group.group(self.format_lambda(*lambda).group),
+            ExpressionKind::Parenthesized(expression) => {
+                group.group(self.format_parenthesized_expression(*expression));
+            }
+            ExpressionKind::Quote(..) => {
+                group.group(self.format_quote());
+            }
+            ExpressionKind::Unquote(..) => {
+                unreachable!("Should not be present in the AST")
+            }
+            ExpressionKind::Comptime(block_expression, _span) => {
+                group.group(self.format_comptime_expression(
+                    block_expression,
+                    false, // force multiple lines
+                ));
+            }
+            ExpressionKind::Unsafe(block_expression, _span) => {
+                group.group(self.format_unsafe_expression(
+                    block_expression,
+                    false, // force multiple lines
+                ));
+            }
+            ExpressionKind::AsTraitPath(as_trait_path) => {
+                group.text(self.chunk(|formatter| formatter.format_as_trait_path(as_trait_path)));
+            }
+            ExpressionKind::TypePath(type_path) => {
+                group.group(self.format_type_path(type_path));
+            }
+            ExpressionKind::Resolved(..)
+            | ExpressionKind::Interned(..)
+            | ExpressionKind::InternedStatement(..)
+            | ExpressionKind::Error => unreachable!("Should not be present in the AST"),
+        }
+    }
+
+    fn format_literal(&mut self, literal: Literal, group: &mut ChunkGroup) {
+        match literal {
+            Literal::Unit => group.text(self.chunk(|formatter| {
+                formatter.write_left_paren();
+                formatter.write_right_paren();
+            })),
+            Literal::Bool(_) | Literal::Str(_) | Literal::FmtStr(_, _) | Literal::RawStr(..) => {
+                group.text(self.chunk(|formatter| {
+                    formatter.write_current_token_as_in_source();
+                    formatter.bump();
+                }));
+            }
+            Literal::Integer(..) => group.text(self.chunk(|formatter| {
+                if formatter.is_at(Token::Minus) {
+                    formatter.write_token(Token::Minus);
+                    formatter.skip_comments_and_whitespace();
+                }
+                formatter.write_current_token_as_in_source();
+                formatter.bump();
+            })),
+            Literal::Array(array_literal) => group.group(self.format_array_literal(
+                array_literal,
+                false, // is slice
+            )),
+            Literal::Slice(array_literal) => {
+                group.group(self.format_array_literal(
+                    array_literal,
+                    true, // is slice
+                ));
+            }
+        }
+    }
+
+    fn format_array_literal(&mut self, literal: ArrayLiteral, is_slice: bool) -> ChunkGroup {
+        let mut group = ChunkGroup::new();
+
+        group.text(self.chunk(|formatter| {
+            if is_slice {
+                formatter.write_token(Token::Ampersand);
+            }
+            formatter.write_left_bracket();
+        }));
+
+        match literal {
+            ArrayLiteral::Standard(exprs) => {
+                group.kind = GroupKind::ExpressionList {
+                    prefix_width: group.width(),
+                    expressions_count: exprs.len(),
+                };
+
+                let maximum_element_width = self.format_expressions_separated_by_comma(
+                    exprs, false, // force trailing comma
+                    &mut group,
+                );
+                group.one_chunk_per_line =
+                    maximum_element_width > self.config.short_array_element_width_threshold;
+            }
+            ArrayLiteral::Repeated { repeated_element, length } => {
+                group.increase_indentation();
+                group.line();
+
+                self.format_expression(*repeated_element, &mut group);
+                group.semicolon(self);
+                group.space(self);
+                self.format_expression(*length, &mut group);
+
+                group.decrease_indentation();
+                group.line();
+            }
+        }
+
+        group.text(self.chunk(|formatter| formatter.write_right_bracket()));
+
+        group
+    }
+
+    fn format_tuple(&mut self, exprs: Vec<Expression>) -> ChunkGroup {
+        let mut group = ChunkGroup::new();
+        group.one_chunk_per_line = false;
+
+        let force_trailing_comma = exprs.len() == 1;
+
+        group.text(self.chunk(|formatter| {
+            formatter.write_left_paren();
+        }));
+
+        group.kind = GroupKind::ExpressionList {
+            prefix_width: group.width(),
+            expressions_count: exprs.len(),
+        };
+
+        self.format_expressions_separated_by_comma(exprs, force_trailing_comma, &mut group);
+
+        group.text(self.chunk(|formatter| formatter.write_right_paren()));
+
+        group
+    }
+
+    fn format_lambda(&mut self, lambda: Lambda) -> FormattedLambda {
+        let mut group = ChunkGroup::new();
+
+        let lambda_has_return_type = lambda.return_type.typ != UnresolvedTypeData::Unspecified;
+
+        let params_and_return_type_chunk = self.chunk(|formatter| {
+            formatter.write_token(Token::Pipe);
+            for (index, (pattern, typ)) in lambda.parameters.into_iter().enumerate() {
+                if index > 0 {
+                    formatter.write_comma();
+                    formatter.write_space();
+                }
+                formatter.format_pattern(pattern);
+                if typ.typ != UnresolvedTypeData::Unspecified {
+                    formatter.write_token(Token::Colon);
+                    formatter.write_space();
+                    formatter.format_type(typ);
+                }
+            }
+            formatter.skip_comments_and_whitespace();
+            if formatter.is_at(Token::Comma) {
+                formatter.bump();
+            }
+            formatter.write_token(Token::Pipe);
+            formatter.write_space();
+            if lambda_has_return_type {
+                formatter.write_token(Token::Arrow);
+                formatter.write_space();
+                formatter.format_type(lambda.return_type);
+                formatter.write_space();
+            }
+        });
+
+        let params_and_return_type_chunk_width = params_and_return_type_chunk.width;
+
+        group.text(params_and_return_type_chunk);
+
+        let block_statement_count = if let ExpressionKind::Block(block) = &lambda.body.kind {
+            Some(block.statements.len())
+        } else {
+            None
+        };
+
+        let mut body_group = ChunkGroup::new();
+
+        let comments_count_before_body = self.written_comments_count;
+        self.format_expression(lambda.body, &mut body_group);
+
+        body_group.kind = GroupKind::LambdaBody {
+            block_statement_count,
+            has_comments: self.written_comments_count > comments_count_before_body,
+            lambda_has_return_type,
+        };
+
+        group.group(body_group);
+
+        let first_line_width = params_and_return_type_chunk_width
+            + (if block_statement_count.is_some() {
+                // 1 because we already have `|param1, param2, ..., paramN| ` (including the space)
+                // so all that's left is a `{`.
+                1
+            } else {
+                // The body is not a block so we can write it right away
+                0
+            });
+
+        FormattedLambda { group, first_line_width }
+    }
+
+    fn format_parenthesized_expression(&mut self, expr: Expression) -> ChunkGroup {
+        let is_nested_parenthesized = matches!(expr.kind, ExpressionKind::Parenthesized(..));
+
+        let mut group = ChunkGroup::new();
+        let left_paren_chunk = self.chunk(|formatter| {
+            formatter.write_left_paren();
+        });
+
+        let mut expr_group = ChunkGroup::new();
+        let mut has_comments = false;
+
+        let comment_after_left_paren_chunk = self.skip_comments_and_whitespace_chunk();
+        if !comment_after_left_paren_chunk.string.trim().is_empty() {
+            has_comments = true;
+        }
+
+        expr_group.leading_comment(comment_after_left_paren_chunk);
+
+        self.format_expression(expr, &mut expr_group);
+
+        let comment_before_right_parent_chunk = self.skip_comments_and_whitespace_chunk();
+        if !comment_before_right_parent_chunk.string.trim().is_empty() {
+            has_comments = true;
+        }
+
+        let right_paren_chunk = self.chunk(|formatter| {
+            formatter.write_right_paren();
+        });
+
+        if is_nested_parenthesized && !has_comments && self.config.remove_nested_parens {
+            group.chunks.extend(expr_group.chunks);
+        } else {
+            group.text(left_paren_chunk);
+            group.increase_indentation();
+            group.line();
+            group.chunks.extend(expr_group.chunks);
+            group.text(comment_before_right_parent_chunk);
+            group.decrease_indentation();
+            group.line();
+            group.text(right_paren_chunk);
+        }
+
+        group
+    }
+
+    pub(super) fn format_quote(&mut self) -> ChunkGroup {
+        // A quote's prefix isn't captured in the token, so let's figure it out which one
+        // is it by looking at the source code.
+        let mut quote_source_code =
+            &self.source[self.token_span.start() as usize..self.token_span.end() as usize];
+
+        // Remove "quote" and any whitespace following it
+        quote_source_code = quote_source_code.strip_prefix("quote").unwrap();
+        quote_source_code = quote_source_code.trim_start();
+
+        // The first char is the delimiter
+        let delimiter_start = quote_source_code.chars().next().unwrap();
+        let delimiter_end = match delimiter_start {
+            '(' => ')',
+            '{' => '}',
+            '[' => ']',
+            _ => panic!("Unexpected delimiter: {}", delimiter_start),
+        };
+
+        // We use the current token rather than the Tokens we got from `Token::Quote` because
+        // the current token has whitespace and comments in it, while the one we got from
+        // the parser doesn't.
+        let Token::Quote(tokens) = self.bump() else {
+            panic!("Expected current token to be Quote");
+        };
+
+        let mut group = ChunkGroup::new();
+        group.verbatim(self.chunk(|formatter| {
+            formatter.write("quote");
+            formatter.write_space();
+            formatter.write(&delimiter_start.to_string());
+            for token in tokens.0 {
+                formatter.write_source_span(token.to_span());
+            }
+            formatter.write(&delimiter_end.to_string());
+        }));
+        group
+    }
+
+    pub(super) fn format_comptime_expression(
+        &mut self,
+        block: BlockExpression,
+        force_multiple_lines: bool,
+    ) -> ChunkGroup {
+        let mut group = ChunkGroup::new();
+        group.text(self.chunk(|formatter| {
+            formatter.write_keyword(Keyword::Comptime);
+            formatter.write_space();
+        }));
+        group.group(self.format_block_expression(block, force_multiple_lines));
+        group
+    }
+
+    pub(super) fn format_unsafe_expression(
+        &mut self,
+        block: BlockExpression,
+        force_multiple_lines: bool,
+    ) -> ChunkGroup {
+        let mut group = ChunkGroup::new();
+        group.text(self.chunk(|formatter| {
+            formatter.write_keyword(Keyword::Unsafe);
+            formatter.write_space();
+        }));
+        group.group(self.format_block_expression(block, force_multiple_lines));
+        group
+    }
+
+    pub(super) fn format_type_path(&mut self, type_path: TypePath) -> ChunkGroup {
+        let mut group = ChunkGroup::new();
+        group.text(self.chunk(|formatter| {
+            formatter.format_type(type_path.typ);
+            formatter.write_token(Token::DoubleColon);
+            formatter.write_identifier(type_path.item);
+            if let Some(turbofish) = type_path.turbofish {
+                formatter.write_token(Token::DoubleColon);
+                formatter.format_generic_type_args(turbofish);
+            }
+        }));
+        group
+    }
+
+    /// Returns the maximum width of each expression to format. For example,
+    /// if the list is [1, 234, 56], the maximum width is 3 (that of `234`).
+    pub(super) fn format_expressions_separated_by_comma(
+        &mut self,
+        exprs: Vec<Expression>,
+        force_trailing_comma: bool,
+        group: &mut ChunkGroup,
+    ) -> usize {
+        if exprs.is_empty() {
+            if let Some(inner_group) = self.empty_block_contents_chunk() {
+                group.group(inner_group);
+            }
+            0
+        } else {
+            let exprs_len = exprs.len();
+            let mut expr_index = 0;
+            let mut max_width = 0;
+
+            self.format_items_separated_by_comma(
+                exprs,
+                force_trailing_comma,
+                false, // surround with spaces
+                group,
+                |formatter, expr, chunks| {
+                    // If the last expression in the list is a lambda, we format it but we mark
+                    // the chunk in a special way: it likely has newlines, but we don't want
+                    // those newlines to affect the parent group. For example:
+                    //
+                    //     foo(1, 2, |x| {
+                    //       let y = x + 1;
+                    //       y * 2
+                    //     })
+                    if expr_index == exprs_len - 1 {
+                        if let ExpressionKind::Lambda(lambda) = expr.kind {
+                            let mut lambda_group = formatter.format_lambda(*lambda);
+                            lambda_group.group.kind = GroupKind::LambdaAsLastExpressionInList {
+                                first_line_width: lambda_group.first_line_width,
+                                indentation: None,
+                            };
+                            chunks.group(lambda_group.group);
+                            return;
+                        }
+                    }
+                    expr_index += 1;
+
+                    let chunks_len_before_expression = chunks.chunks.len();
+
+                    formatter.format_expression(expr, chunks);
+
+                    let chunks_len_after_expression = chunks.chunks.len();
+                    let expression_width: usize = (chunks_len_before_expression
+                        ..chunks_len_after_expression)
+                        .map(|index| chunks.chunks[index].width())
+                        .sum();
+                    if expression_width > max_width {
+                        max_width = expression_width;
+                    }
+                },
+            );
+
+            max_width
+        }
+    }
+
+    pub(super) fn format_items_separated_by_comma<Item, F>(
+        &mut self,
+        items: Vec<Item>,
+        force_trailing_comma: bool,
+        surround_with_spaces: bool,
+        group: &mut ChunkGroup,
+        mut format_item: F,
+    ) where
+        F: FnMut(&mut Self, Item, &mut ChunkGroup),
+    {
+        let mut comments_chunk = self.skip_comments_and_whitespace_chunk();
+
+        // Handle leading block vs. line comments a bit differently.
+        if comments_chunk.string.trim().starts_with("/*") {
+            group.increase_indentation();
+            if surround_with_spaces {
+                group.space_or_line();
+            } else {
+                group.line();
+            }
+
+            // Note: there's no space before `{}` because it was just produced
+            comments_chunk.string = if surround_with_spaces {
+                comments_chunk.string.trim().to_string()
+            } else {
+                format!("{} ", comments_chunk.string.trim())
+            };
+            group.leading_comment(comments_chunk);
+        } else {
+            group.increase_indentation();
+            if surround_with_spaces {
+                group.space_or_line();
+            } else {
+                group.line();
+            }
+
+            group.trailing_comment(comments_chunk);
+        }
+
+        for (index, expr) in items.into_iter().enumerate() {
+            if index > 0 {
+                group.text_attached_to_last_group(self.chunk(|formatter| {
+                    formatter.write_comma();
+                }));
+                let newlines_count_before_comment = self.following_newlines_count();
+                group.text(self.chunk(|formatter| {
+                    formatter.skip_whitespace();
+                }));
+                if let Token::BlockComment(..) = &self.token {
+                    // We let block comments be part of the item that's going to be formatted
+                } else {
+                    // Line comments can be trailing or leading, depending on whether there are newlines before them
+                    let comments_and_whitespace_chunk = self.skip_comments_and_whitespace_chunk();
+                    if !comments_and_whitespace_chunk.string.trim().is_empty() {
+                        if newlines_count_before_comment > 0 {
+                            group.line();
+                            group.leading_comment(comments_and_whitespace_chunk);
+                        } else {
+                            group.trailing_comment(comments_and_whitespace_chunk);
+                        }
+                    }
+                }
+                group.space_or_line();
+            }
+            format_item(self, expr, group);
+        }
+
+        let chunk = self.chunk(|formatter| {
+            formatter.skip_comments_and_whitespace();
+
+            // Trailing comma
+            if formatter.is_at(Token::Comma) {
+                formatter.bump();
+                formatter.skip_comments_and_whitespace();
+            }
+        });
+
+        // Make sure to put a trailing comma before the last parameter comments, if there were any
+        if !force_trailing_comma {
+            group.trailing_comma();
+        }
+
+        group.text(chunk);
+
+        if force_trailing_comma {
+            group.text(TextChunk::new(",".to_string()));
+        }
+
+        group.decrease_indentation();
+        if surround_with_spaces {
+            group.space_or_line();
+        } else {
+            group.line();
+        }
+    }
+
+    fn format_constructor(&mut self, constructor: ConstructorExpression) -> ChunkGroup {
+        let mut group = ChunkGroup::new();
+        group.text(self.chunk(|formatter| {
+            formatter.format_type(constructor.typ);
+            formatter.write_space();
+            formatter.write_left_brace();
+        }));
+
+        if constructor.fields.is_empty() {
+            if let Some(inner_group) = self.empty_block_contents_chunk() {
+                group.group(inner_group);
+            }
+        } else {
+            self.format_items_separated_by_comma(
+                constructor.fields,
+                false, // force trailing comma
+                true,  // surround with spaces
+                &mut group,
+                |formatter, (name, value), chunks| {
+                    chunks.text(formatter.chunk(|formatter| {
+                        formatter.write_identifier(name);
+                        formatter.skip_comments_and_whitespace();
+                    }));
+
+                    if formatter.is_at(Token::Colon) {
+                        chunks.text(formatter.chunk(|formatter| {
+                            formatter.write_token(Token::Colon);
+                            formatter.write_space();
+                        }));
+                        formatter.format_expression(value, chunks);
+                    }
+                },
+            );
+        }
+        group.text(self.chunk(|formatter| {
+            formatter.write_right_brace();
+        }));
+
+        group
+    }
+
+    fn format_member_access(&mut self, member_access: MemberAccessExpression) -> ChunkGroup {
+        let group_tag = self.new_group_tag();
+
+        let mut group = self.format_member_access_impl(
+            member_access,
+            false, // nested
+            group_tag,
+        );
+        group.force_multiline_on_children_with_same_tag_if_multiline = true;
+        group
+    }
+
+    fn format_member_access_impl(
+        &mut self,
+        member_access: MemberAccessExpression,
+        nested: bool,
+        group_tag: GroupTag,
+    ) -> ChunkGroup {
+        let mut group = ChunkGroup::new();
+        group.tag = Some(group_tag);
+
+        if !nested {
+            group.push_indentation();
+        }
+
+        // If we have code like `foo.bar.baz.qux`, where `member_access.lhs` is also a MemberAccessExpression,
+        // we'll format it with the same tag. Once the lhs is not a MemberAccessExpression, we'll format it
+        // and add an increase in indentation, but just once so that it ends up being formatted like this
+        // in case it needs to be formatted in multiple lines:
+        //
+        //    foo.bar
+        //        .baz
+        //        .qux
+        //
+        // Note that we do the same if the lhs is a MethodCallExpression.
+        //
+        // Also note that we don't format it like this:
+        //
+        //    foo
+        //        .bar
+        //        .baz
+        //        .qux
+        //
+        // For that, we check if the lhs'lhs is also a MemberAccess/MethodCall to determine where we need
+        // to put a line and an indentation.
+        let mut increase_indentation = false;
+
+        match member_access.lhs.kind {
+            ExpressionKind::MemberAccess(lhs_member_access) => {
+                group.group(self.format_member_access_impl(
+                    *lhs_member_access,
+                    true, // nested
+                    group_tag,
+                ));
+            }
+            ExpressionKind::MethodCall(lhs_method_call) => {
+                group.group(self.format_method_call_impl(
+                    *lhs_method_call,
+                    true, // nested
+                    group_tag,
+                ));
+            }
+            _ => {
+                self.format_expression(member_access.lhs, &mut group);
+
+                increase_indentation = true;
+            }
+        };
+
+        group.trailing_comment(self.skip_comments_and_whitespace_chunk());
+
+        if increase_indentation {
+            group.increase_indentation();
+        }
+
+        group.line();
+
+        group.text(self.chunk(|formatter| {
+            formatter.write_token(Token::Dot);
+            formatter.write_identifier_or_integer(member_access.rhs);
+        }));
+
+        if !nested {
+            group.pop_indentation();
+        }
+
+        group
+    }
+
+    fn format_cast(&mut self, cast_expression: CastExpression) -> ChunkGroup {
+        let mut group = ChunkGroup::new();
+        self.format_expression(cast_expression.lhs, &mut group);
+        group.text(self.chunk(|formatter| {
+            formatter.write_space();
+            formatter.write_keyword(Keyword::As);
+            formatter.write_space();
+            formatter.format_type(cast_expression.r#type);
+        }));
+        group
+    }
+
+    fn format_prefix(&mut self, prefix: PrefixExpression) -> ChunkGroup {
+        let mut group = ChunkGroup::new();
+        group.text(self.chunk(|formatter| {
+            if let UnaryOp::MutableReference = prefix.operator {
+                formatter.write_current_token();
+                formatter.bump();
+                formatter.skip_comments_and_whitespace();
+                formatter.write_current_token();
+                formatter.bump();
+                formatter.write_space();
+            } else {
+                formatter.write_current_token();
+                formatter.bump();
+            }
+        }));
+        self.format_expression(prefix.rhs, &mut group);
+        group
+    }
+
+    fn format_infix_expression(&mut self, infix: InfixExpression) -> ChunkGroup {
+        let group_tag = self.new_group_tag();
+
+        let mut group = self.format_infix_expression_with_group_tag(
+            infix, group_tag, false, // nested
+        );
+        group.force_multiline_on_children_with_same_tag_if_multiline = true;
+        group
+    }
+
+    fn format_infix_expression_with_group_tag(
+        &mut self,
+        infix: InfixExpression,
+        group_tag: GroupTag,
+        nested: bool,
+    ) -> ChunkGroup {
+        let mut group = ChunkGroup::new();
+        group.tag = Some(group_tag);
+
+        if !nested {
+            group.push_indentation();
+        }
+
+        // If we have code like `a + b + c + d`, that's always parsed as `((a + b) + c) + d` where each
+        // parentheses denotes an InfixExpression. So, if the lhs of the current infix expression is also
+        // an infix expression with the same operator, we format it with the same tag.
+        // If the lhs is not an infix expression or has a different operator, we format it normally,
+        // and afterwards signal an increase in indentation. That way if this infix expression has
+        // to be formatted in multiple lines, we'll only indent after the first operand
+        // (we still produce "space or line" after each operator).
+        let increase_indentation = match infix.lhs.kind {
+            ExpressionKind::Infix(lhs_infix) if lhs_infix.operator == infix.operator => {
+                group.group(self.format_infix_expression_with_group_tag(
+                    *lhs_infix, group_tag, true, // nested
+                ));
+                false
+            }
+            _ => {
+                self.format_expression(infix.lhs, &mut group);
+                true
+            }
+        };
+
+        // Indent right after the lhs so that if there's a trailing comment,
+        // the next line is indented correctly.
+        if increase_indentation {
+            group.increase_indentation();
+        }
+
+        let mut comment_chunk_after_lhs = self.skip_comments_and_whitespace_chunk();
+
+        // If the comment is not empty but doesn't have newlines, it's surely `/* comment */`.
+        // We format that with spaces surrounding it so it looks like `a /* comment */ + b`.
+        if !comment_chunk_after_lhs.string.trim().is_empty()
+            && !comment_chunk_after_lhs.has_newlines
+        {
+            // Note: there's no space after `{}` because a bit below comes "space_or_line".
+            comment_chunk_after_lhs.string = format!(" {}", comment_chunk_after_lhs.string.trim());
+            group.text(comment_chunk_after_lhs);
+        } else {
+            group.trailing_comment(comment_chunk_after_lhs);
+        }
+
+        group.space_or_line();
+        group.text(self.chunk(|formatter| {
+            let tokens_count =
+                if infix.operator.contents == BinaryOpKind::ShiftRight { 2 } else { 1 };
+            for _ in 0..tokens_count {
+                formatter.write_current_token();
+                formatter.bump();
+            }
+            formatter.write_space();
+        }));
+
+        self.format_expression(infix.rhs, &mut group);
+
+        if !nested {
+            group.pop_indentation();
+        }
+
+        group
+    }
+
+    pub(super) fn format_if_expression(
+        &mut self,
+        if_expression: IfExpression,
+        mut force_multiple_lines: bool,
+    ) -> ChunkGroup {
+        let group_tag = self.new_group_tag();
+        let mut group = self.format_if_expression_with_group_tag(
+            if_expression,
+            &mut force_multiple_lines,
+            group_tag,
+        );
+
+        if force_multiple_lines || group.width() > self.config.single_line_if_else_max_width {
+            force_if_chunks_to_multiple_lines(&mut group, group_tag);
+        }
+
+        group
+    }
+
+    pub(super) fn format_if_expression_with_group_tag(
+        &mut self,
+        if_expression: IfExpression,
+        force_multiple_lines: &mut bool,
+        group_tag: GroupTag,
+    ) -> ChunkGroup {
+        let mut group = ChunkGroup::new();
+        group.tag = Some(group_tag);
+
+        group.text(self.chunk(|formatter| {
+            formatter.write_keyword(Keyword::If);
+            formatter.write_space();
+        }));
+
+        self.format_expression(if_expression.condition, &mut group);
+
+        let comment_chunk_after_condition = self.skip_comments_and_whitespace_chunk();
+        if comment_chunk_after_condition.has_newlines {
+            *force_multiple_lines = true;
+            group.trailing_comment(comment_chunk_after_condition);
+        } else {
+            group.space(self);
+        }
+
+        let ExpressionKind::Block(consequence_block) = if_expression.consequence.kind else {
+            panic!("Expected if expression consequence to be a block");
+        };
+
+        if let Some(alternative) = &if_expression.alternative {
+            match &alternative.kind {
+                ExpressionKind::Block(block) => {
+                    if block.statements.len() > 1 {
+                        *force_multiple_lines = true;
+                    }
+                }
+                ExpressionKind::If(..) => {
+                    *force_multiple_lines = true;
+                }
+                _ => panic!("Unexpected if alternative expression kind"),
+            }
+        }
+
+        let mut consequence_group =
+            self.format_block_expression(consequence_block, *force_multiple_lines);
+        consequence_group.tag = Some(group_tag);
+        group.group(consequence_group);
+
+        if let Some(alternative) = if_expression.alternative {
+            group.text(self.chunk(|formatter| {
+                formatter.write_space();
+                formatter.write_keyword(Keyword::Else);
+            }));
+
+            let comment_chunk_after_else = self.skip_comments_and_whitespace_chunk();
+            if comment_chunk_after_else.has_newlines {
+                *force_multiple_lines = true;
+                group.trailing_comment(comment_chunk_after_else);
+            } else {
+                group.space(self);
+            }
+
+            let mut alternative_group = match alternative.kind {
+                ExpressionKind::Block(block) => {
+                    self.format_block_expression(block, *force_multiple_lines)
+                }
+                ExpressionKind::If(if_expression) => self.format_if_expression_with_group_tag(
+                    *if_expression,
+                    force_multiple_lines,
+                    group_tag,
+                ),
+                _ => panic!("Unexpected if alternative expression kind"),
+            };
+
+            alternative_group.tag = Some(group_tag);
+            group.group(alternative_group);
+        }
+
+        group
+    }
+
+    fn format_index_expression(&mut self, index: IndexExpression) -> ChunkGroup {
+        let mut group = ChunkGroup::new();
+        self.format_expression(index.collection, &mut group);
+        group.text(self.chunk(|formatter| {
+            formatter.write_left_bracket();
+        }));
+
+        // If we have:
+        //
+        //     foo[ // bar
+        //       1]
+        //
+        // and there were newlines in the comment section, we format it like this:
+        //
+        //     foo[
+        //       // bar
+        //       1
+        //     ]
+        //
+        // That is, we first put a newline before the comment so it looks a bit better.
+        // This is a rare scenario, but we had a test for this before the formatter was
+        // rewritten, so...
+        let comments_chunk = self.skip_comments_and_whitespace_chunk();
+        let comments_chunk_has_newlines = comments_chunk.has_newlines;
+
+        if comments_chunk_has_newlines {
+            group.increase_indentation();
+            group.line();
+        }
+
+        group.leading_comment(comments_chunk);
+
+        self.format_expression(index.index, &mut group);
+
+        if comments_chunk_has_newlines {
+            group.decrease_indentation();
+            group.line();
+        }
+
+        group.text(self.chunk(|formatter| {
+            formatter.write_right_bracket();
+        }));
+        group
+    }
+
+    fn format_call(&mut self, call: CallExpression) -> ChunkGroup {
+        let mut group = ChunkGroup::new();
+
+        self.format_expression(*call.func, &mut group);
+
+        group.text(self.chunk(|formatter| {
+            if call.is_macro_call {
+                formatter.write_token(Token::Bang);
+            }
+            formatter.write_left_paren();
+        }));
+
+        group.kind = GroupKind::ExpressionList {
+            prefix_width: group.width(),
+            expressions_count: call.arguments.len(),
+        };
+
+        // Format arguments in a separate group so we can calculate the arguments
+        // width and determine if we need to format this call in multiple lines.
+        let mut args_group = ChunkGroup::new();
+        self.format_expressions_separated_by_comma(
+            call.arguments,
+            false, // force trailing comma
+            &mut args_group,
+        );
+
+        if args_group.width() > self.config.fn_call_width {
+            group.force_multiple_lines = true;
+        }
+
+        // We no longer need this subgroup, so put all its chunks into the main chunks
+        group.chunks.extend(args_group.chunks);
+
+        group.text(self.chunk(|formatter| {
+            formatter.write_right_paren();
+        }));
+
+        group
+    }
+
+    fn format_method_call(&mut self, method_call: MethodCallExpression) -> ChunkGroup {
+        let group_tag = self.new_group_tag();
+
+        let mut group = self.format_method_call_impl(
+            method_call,
+            false, // nested
+            group_tag,
+        );
+        group.force_multiline_on_children_with_same_tag_if_multiline = true;
+        group
+    }
+
+    fn format_method_call_impl(
+        &mut self,
+        method_call: MethodCallExpression,
+        nested: bool,
+        group_tag: GroupTag,
+    ) -> ChunkGroup {
+        let mut group = ChunkGroup::new();
+        group.tag = Some(group_tag);
+
+        if !nested {
+            group.push_indentation();
+        }
+
+        // The logic here is similar to that of `format_member_access_with_group_tag`, so
+        // please that function inner comments for details.
+        let mut increase_indentation_before_dot = false;
+
+        match method_call.object.kind {
+            ExpressionKind::MethodCall(lhs_method_call) => {
+                group.group(self.format_method_call_impl(
+                    *lhs_method_call,
+                    true, // nested
+                    group_tag,
+                ));
+            }
+            ExpressionKind::MemberAccess(lhs_member_access) => {
+                group.group(self.format_member_access_impl(
+                    *lhs_member_access,
+                    true, // nested
+                    group_tag,
+                ));
+            }
+            _ => {
+                self.format_expression(method_call.object, &mut group);
+
+                increase_indentation_before_dot = true;
+            }
+        }
+
+        group.trailing_comment(self.skip_comments_and_whitespace_chunk());
+
+        if increase_indentation_before_dot {
+            group.increase_indentation();
+        }
+
+        group.line();
+
+        group.text(self.chunk(|formatter| {
+            formatter.write_token(Token::Dot);
+            formatter.write_identifier(method_call.method_name);
+            if method_call.is_macro_call {
+                formatter.write_token(Token::Bang);
+            }
+            if let Some(generics) = method_call.generics {
+                formatter.format_turbofish(generics);
+            }
+            formatter.write_left_paren();
+        }));
+
+        group.kind = GroupKind::MethodCall {
+            width_until_left_paren_inclusive: group.width(),
+            has_newlines_before_left_paren: group.has_newlines(),
+            lhs: nested,
+        };
+
+        let mut args_group = ChunkGroup::new();
+        args_group.kind = GroupKind::ExpressionList {
+            prefix_width: 0,
+            expressions_count: method_call.arguments.len(),
+        };
+        self.format_expressions_separated_by_comma(
+            method_call.arguments,
+            false, // force trailing comma
+            &mut args_group,
+        );
+        group.group(args_group);
+
+        group.text(self.chunk(|formatter| {
+            formatter.write_right_paren();
+        }));
+
+        if !nested {
+            group.pop_indentation();
+        }
+
+        group
+    }
+
+    pub(super) fn format_block_expression(
+        &mut self,
+        block: BlockExpression,
+        force_multiple_lines: bool,
+    ) -> ChunkGroup {
+        let mut group = ChunkGroup::new();
+        group.text(self.chunk(|formatter| {
+            formatter.write_left_brace();
+        }));
+        self.format_block_expression_contents(block, force_multiple_lines, &mut group);
+        group.text(self.chunk(|formatter| {
+            formatter.write_right_brace();
+        }));
+        group
+    }
+
+    pub(super) fn format_block_expression_contents(
+        &mut self,
+        block: BlockExpression,
+        force_multiple_lines: bool,
+        group: &mut ChunkGroup,
+    ) {
+        if block.is_empty() {
+            if let Some(block_group) = self.empty_block_contents_chunk() {
+                group.chunks.extend(block_group.chunks);
+            }
+        } else {
+            self.format_non_empty_block_expression_contents(block, force_multiple_lines, group);
+        }
+    }
+
+    pub(super) fn format_non_empty_block_expression_contents(
+        &mut self,
+        block: BlockExpression,
+        force_multiple_lines: bool,
+        group: &mut ChunkGroup,
+    ) {
+        group.force_multiple_lines = force_multiple_lines || block.statements.len() > 1;
+        let surround_with_spaces = !group.force_multiple_lines && block.statements.len() == 1;
+
+        group.increase_indentation();
+        if surround_with_spaces {
+            group.space_or_line();
+        } else {
+            group.line();
+        }
+
+        for (index, statement) in block.statements.into_iter().enumerate() {
+            let mut ignore_next = false;
+
+            if index > 0 {
+                let count = self.following_newlines_count();
+                if count > 0 {
+                    // If newlines follow, we first add a line, then add the comment chunk
+                    group.lines(count > 1);
+                    group.leading_comment(self.chunk(|formatter| {
+                        formatter.skip_comments_and_whitespace_writing_multiple_lines_if_found();
+                    }));
+                    ignore_next = self.ignore_next;
+                } else {
+                    // Otherwise, add the comment first as it's a trailing comment
+                    group.trailing_comment(self.chunk(|formatter| {
+                        formatter.skip_comments_and_whitespace_writing_multiple_lines_if_found();
+                    }));
+                    ignore_next = self.ignore_next;
+                    group.line();
+                }
+            }
+
+            self.format_statement(statement, group, ignore_next);
+        }
+
+        // See how many newlines follow the last statement
+        let count = self.following_newlines_count();
+
+        group.text(self.chunk(|formatter| {
+            formatter.skip_whitespace();
+        }));
+
+        // After skipping whitespace we check if there's a comment. If so, we respect
+        // how many lines were before that comment.
+        if count > 0 && matches!(self.token, Token::LineComment(..) | Token::BlockComment(..)) {
+            group.lines(count > 1);
+        }
+
+        // Finally format the comment, if any
+        group.text(self.chunk(|formatter| {
+            formatter.skip_comments_and_whitespace_writing_multiple_lines_if_found();
+        }));
+
+        group.decrease_indentation();
+
+        if surround_with_spaces {
+            group.space_or_line();
+        } else {
+            group.line();
+        }
+    }
+
+    pub(super) fn empty_block_contents_chunk(&mut self) -> Option<ChunkGroup> {
+        let mut group = ChunkGroup::new();
+        group.increase_indentation();
+
+        let newlines_count = self.following_newlines_count();
+
+        let mut chunk = self.chunk(|formatter| {
+            formatter.skip_comments_and_whitespace_writing_multiple_lines_if_found();
+        });
+
+        if chunk.string.trim().is_empty() {
+            // We only found whitespace until the next non-whitespace-non-comment token,
+            // so there's nothing to write.
+            None
+        } else {
+            // If we have a trailing comment, preserve it in the same line
+            if newlines_count == 0 && !chunk.string.trim_start().starts_with("//") {
+                chunk.string = format!(" {} ", chunk.string.trim());
+            }
+            group.text(chunk);
+            group.decrease_indentation();
+            group.line();
+            Some(group)
+        }
+    }
+}
+
+impl<'a> Formatter<'a> {
+    pub(super) fn format_empty_block_contents(&mut self) {
+        if let Some(chunks) = self.chunk_formatter().empty_block_contents_chunk() {
+            self.format_chunk_group(chunks);
+        }
+    }
+}
+
+fn force_if_chunks_to_multiple_lines(group: &mut ChunkGroup, group_tag: GroupTag) {
+    if group.tag == Some(group_tag) {
+        group.force_multiple_lines = true;
+    }
+
+    for chunk in group.chunks.iter_mut() {
+        if let Chunk::Group(inner_group) = chunk {
+            force_if_chunks_to_multiple_lines(inner_group, group_tag);
+        }
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use crate::{assert_format, assert_format_with_config, assert_format_with_max_width, Config};
+
+    #[test]
+    fn format_unit() {
+        let src = "global x =  ( ) ;";
+        let expected = "global x = ();\n";
+        assert_format(src, expected);
+    }
+
+    #[test]
+    fn format_false() {
+        let src = "global x =  false ;";
+        let expected = "global x = false;\n";
+        assert_format(src, expected);
+    }
+
+    #[test]
+    fn format_true() {
+        let src = "global x =  true ;";
+        let expected = "global x = true;\n";
+        assert_format(src, expected);
+    }
+
+    #[test]
+    fn format_integer() {
+        let src = "global x =  42 ;";
+        let expected = "global x = 42;\n";
+        assert_format(src, expected);
+    }
+
+    #[test]
+    fn format_negative_integer() {
+        let src = "global x =  - 42 ;";
+        let expected = "global x = -42;\n";
+        assert_format(src, expected);
+    }
+
+    #[test]
+    fn format_ref_mut_integer() {
+        let src = "global x = & mut 42 ;";
+        let expected = "global x = &mut 42;\n";
+        assert_format(src, expected);
+    }
+
+    #[test]
+    fn format_hex_integer() {
+        let src = "global x =  0xff ;";
+        let expected = "global x = 0xff;\n";
+        assert_format(src, expected);
+    }
+
+    #[test]
+    fn format_string() {
+        let src = "global x =  \"hello\" ;";
+        let expected = "global x = \"hello\";\n";
+        assert_format(src, expected);
+    }
+
+    #[test]
+    fn format_fmtstr() {
+        let src = "global x =  f\"hello\" ;";
+        let expected = "global x = f\"hello\";\n";
+        assert_format(src, expected);
+    }
+
+    #[test]
+    fn format_standard_array() {
+        let src = "global x = [ 1 , 2 , 3 , ] ;";
+        let expected = "global x = [1, 2, 3];\n";
+        assert_format(src, expected);
+    }
+
+    #[test]
+    fn format_standard_slice() {
+        let src = "global x = & [ 1 , 2 , 3 , ] ;";
+        let expected = "global x = &[1, 2, 3];\n";
+        assert_format(src, expected);
+    }
+
+    #[test]
+    fn format_repeated_array() {
+        let src = "global x = [ 1 ; 3 ] ;";
+        let expected = "global x = [1; 3];\n";
+        assert_format(src, expected);
+    }
+
+    #[test]
+    fn format_long_array_in_global() {
+        let src = "global x = [ 1 , 2 , 3 , 4, 5, ] ;";
+        let expected = "global x =
+    [1, 2, 3, 4, 5];
+";
+        assert_format_with_max_width(src, expected, 20);
+    }
+
+    #[test]
+    fn format_long_array_in_global_in_mod() {
+        let src = "mod moo { mod bar { global x = [ 1 , 2 , 3 , 4, 5, ] ; } }";
+        let expected = "mod moo {
+    mod bar {
+        global x = [
+            1, 2, 3, 4,
+            5,
+        ];
+    }
+}
+";
+        assert_format_with_max_width(src, expected, 25);
+    }
+
+    #[test]
+    fn format_long_array_in_global_2() {
+        let src = "global x = [ 1 , 2 , 3 , 4, 5, ] ;
+
+global y = 1;
+        ";
+        let expected = "global x =
+    [1, 2, 3, 4, 5];
+
+global y = 1;
+";
+        assert_format_with_max_width(src, expected, 20);
+    }
+
+    #[test]
+    fn format_very_long_array_in_global() {
+        let src = "global x = [ 1 , 2 , 3 , 4, 5, 6, 789, 123, 234, 345] ;";
+        let expected = "global x = [
+    1, 2, 3, 4, 5, 6,
+    789, 123, 234, 345,
+];
+";
+        assert_format_with_max_width(src, expected, 25);
+    }
+
+    #[test]
+    fn format_long_array_element() {
+        let src = "global x = [ 123, 1234, 12345, 123, 1234, 12345, 123456, 123] ;";
+        let expected = "global x = [
+    123,
+    1234,
+    12345,
+    123,
+    1234,
+    12345,
+    123456,
+    123,
+];
+";
+
+        let config =
+            Config { short_array_element_width_threshold: 5, max_width: 30, ..Default::default() };
+        assert_format_with_config(src, expected, config);
+    }
+
+    #[test]
+    fn format_short_array_with_block_comment_before_elements() {
+        let src = "global x = [ /* one */ 1, /* two */ 2 ] ;";
+        let expected = "global x = [/* one */ 1, /* two */ 2];\n";
+
+        assert_format(src, expected);
+    }
+
+    #[test]
+    fn format_long_array_with_block_comment_before_elements() {
+        let src = "global x = [ /* one */ 1, /* two */ 123456789012345, 3, 4 ] ;";
+        let expected = "global x = [
+    /* one */ 1,
+    /* two */ 123456789012345,
+    3,
+    4,
+];
+";
+
+        let config =
+            Config { short_array_element_width_threshold: 5, max_width: 30, ..Config::default() };
+        assert_format_with_config(src, expected, config);
+    }
+
+    #[test]
+    fn format_long_array_with_line_comment_before_elements() {
+        let src = "global x = [
+    // one
+    1,
+    // two
+    123456789012345,
+    3,
+    4,
+];
+";
+        let expected = "global x = [
+    // one
+    1,
+    // two
+    123456789012345,
+    3,
+    4,
+];
+";
+
+        let config =
+            Config { short_array_element_width_threshold: 5, max_width: 30, ..Config::default() };
+        assert_format_with_config(src, expected, config);
+    }
+
+    #[test]
+    fn format_cast() {
+        let src = "global x =  1  as  u8 ;";
+        let expected = "global x = 1 as u8;\n";
+        assert_format(src, expected);
+    }
+
+    #[test]
+    fn format_variable() {
+        let src = "global x =  y ;";
+        let expected = "global x = y;\n";
+        assert_format(src, expected);
+    }
+
+    #[test]
+    fn format_tuple() {
+        let src = "global x = ( 1 , 2 , 3 , ) ;";
+        let expected = "global x = (1, 2, 3);\n";
+        assert_format(src, expected);
+    }
+
+    #[test]
+    fn format_tuple_length_one() {
+        let src = "global x = ( 1 , ) ;";
+        let expected = "global x = (1,);\n";
+        assert_format(src, expected);
+    }
+
+    #[test]
+    fn format_as_trait_path() {
+        let src = "global x = < i32 as foo > :: bar ;";
+        let expected = "global x = <i32 as foo>::bar;\n";
+        assert_format(src, expected);
+    }
+
+    #[test]
+    fn format_index() {
+        let src = "global x = foo [ bar ] ;";
+        let expected = "global x = foo[bar];\n";
+        assert_format(src, expected);
+    }
+
+    #[test]
+    fn format_long_index() {
+        let src = "global x = foo [ bar [ baz [ qux [ one [ two ]]]] ] ; global y = 1;";
+        let expected = "global x = foo[bar[baz[
+    qux[one[two]]]]];
+global y = 1;
+";
+        assert_format_with_max_width(src, expected, 25);
+    }
+
+    #[test]
+    fn format_long_index_2() {
+        let src = "global x = foo [ bar ] [ baz ] [ qux ] [ one ] [ two ] ; global y = 1;";
+        let expected = "global x = foo[bar][baz]
+    [qux][one][two];
+global y = 1;
+";
+        assert_format_with_max_width(src, expected, 25);
+    }
+
+    #[test]
+    fn format_prefix() {
+        let src = "global x = - a ;";
+        let expected = "global x = -a;\n";
+        assert_format(src, expected);
+    }
+
+    #[test]
+    fn format_infix() {
+        let src = "global x =  a  +  b  ;";
+        let expected = "global x = a + b;\n";
+        assert_format(src, expected);
+    }
+
+    #[test]
+    fn format_long_infix_same_operator_1() {
+        let src = "global x =  one + two + three;";
+        let expected = "global x = one
+    + two
+    + three;
+";
+        assert_format_with_max_width(src, expected, "one + two + three".len() - 1);
+    }
+
+    #[test]
+    fn format_long_infix_same_operator_2() {
+        let src = "global x =  one + two + three + four;";
+        let expected = "global x = one
+    + two
+    + three
+    + four;
+";
+        assert_format_with_max_width(src, expected, "one + two + three + four".len() - 1);
+    }
+
+    #[test]
+    fn format_long_infix_same_operator_3() {
+        let src = "fn foo() { one + two + three + four }";
+        let expected = "fn foo() {
+    one
+        + two
+        + three
+        + four
+}
+";
+        assert_format_with_max_width(src, expected, "one + two + three + four".len() - 1);
+    }
+
+    #[test]
+    fn format_infix_with_trailing_comments() {
+        let src = "fn foo() {
+    let x = 1 // one
++ 2 // two
++ 3; // three
+}
+";
+        let expected = "fn foo() {
+    let x = 1 // one
+        + 2 // two
+        + 3; // three
+}
+";
+        assert_format(src, expected);
+    }
+
+    #[test]
+    fn format_empty_block() {
+        let src = "global x =  {  }  ;";
+        let expected = "global x = {};\n";
+        assert_format(src, expected);
+    }
+
+    #[test]
+    fn format_block_with_one_statement() {
+        let src = "global x =  {  1  }  ;";
+        let expected = "global x = { 1 };\n";
+        assert_format(src, expected);
+    }
+
+    #[test]
+    fn format_block_with_two_statements() {
+        let src = "global x =  {  1; 2  }  ;";
+        let expected = "global x = {
+    1;
+    2
+};
+";
+        assert_format(src, expected);
+    }
+
+    #[test]
+    fn format_call() {
+        let src = "global x =  foo :: bar ( 1, 2 )  ;";
+        let expected = "global x = foo::bar(1, 2);\n";
+        assert_format(src, expected);
+    }
+
+    #[test]
+    fn format_call_with_turbofish() {
+        let src = "global x =  foo :: bar :: < Field, i32 > ( 1, 2 )  ;";
+        let expected = "global x = foo::bar::<Field, i32>(1, 2);\n";
+        assert_format(src, expected);
+    }
+
+    #[test]
+    fn format_call_with_maximum_width() {
+        let src = "global x =  foo :: bar ( 1, 2, 3 )  ;";
+        let expected = "global x = foo::bar(
+    1,
+    2,
+    3,
+);\n";
+
+        let config = Config { fn_call_width: "1, 2, 3".len() - 1, ..Default::default() };
+        assert_format_with_config(src, expected, config);
+    }
+
+    #[test]
+    fn format_call_with_maximum_width_2() {
+        let src = "global x =  foo::bar::baz( );";
+        let expected = "global x = foo::bar::baz();\n";
+        assert_format_with_max_width(src, expected, "foo::bar::baz".len() - 1);
+    }
+
+    #[test]
+    fn format_nested_call_with_maximum_width() {
+        let src = "fn foo() { foo(bar(123, 456, 789)) } ";
+        let expected = "fn foo() {
+    foo(bar(
+        123,
+        456,
+        789,
+    ))
+}
+";
+        assert_format_with_max_width(src, expected, "    foo(bar(".len());
+    }
+
+    #[test]
+    fn format_nested_call_with_maximum_width_2() {
+        let src = "fn foo() {
+    let note_interface_impl = s.as_type().get_trait_impl(quote { crate::note::note_interface::NoteInterface<$serialized_len_type> }
+        .as_trait_constraint());
+}
+";
+        let expected = "fn foo() {
+    let note_interface_impl = s.as_type().get_trait_impl(
+        quote { crate::note::note_interface::NoteInterface<$serialized_len_type> }
+            .as_trait_constraint(),
+    );
+}
+";
+        assert_format(src, expected);
+    }
+
+    #[test]
+    fn format_nested_call_with_maximum_width_3() {
+        let src = "mod foo {
+    fn bar() {
+        assert(foo(bar.baz(x12345)));
+    }
+}
+";
+        let expected = "mod foo {
+    fn bar() {
+        assert(foo(bar.baz(
+            x12345,
+        )));
+    }
+}
+";
+        assert_format_with_max_width(src, expected, 33);
+    }
+
+    #[test]
+    fn format_nested_call_with_maximum_width_4() {
+        let src = "mod foo {
+    fn bar() {
+        assert(foo(bar_baz(x1, x2)));
+    }
+}
+";
+        let expected = "mod foo {
+    fn bar() {
+        assert(foo(bar_baz(
+            x1,
+            x2,
+        )));
+    }
+}
+";
+        assert_format_with_max_width(src, expected, 33);
+    }
+
+    #[test]
+    fn format_call_with_maximum_width_comma_exceeds() {
+        let src = "global x = foo::bar(
+    baz::qux(1, 2, 3),
+);";
+        let expected = "global x = foo::bar(
+    baz::qux(
+        1,
+        2,
+        3,
+    ),
+);
+";
+        assert_format_with_max_width(src, expected, "    baz::qux(1, 2, 3),".len() - 1);
+    }
+
+    #[test]
+    fn format_call_with_maximum_width_comma_exceeds_2() {
+        let src = "global x = foo::bar(
+    |x, y| { some_chunk_of_code },
+);";
+        let expected = "global x = foo::bar(|x, y| {
+    some_chunk_of_code
+});
+";
+        assert_format_with_max_width(src, expected, "    |x, y| { some_chunk_of_code },".len() - 1);
+    }
+
+    #[test]
+    fn format_nested_call_max_width() {
+        let src = "global _callStackItem1 = context.call_public_function(
+            context.this_address(),
+            comptime {
+            FunctionSelector::from_signature(\"broadcast(Field)\")
+        },
+            [owner]
+        );";
+        let expected = "global _callStackItem1 = context.call_public_function(
+    context.this_address(),
+    comptime { FunctionSelector::from_signature(\"broadcast(Field)\") },
+    [owner],
+);
+";
+        assert_format(src, expected);
+    }
+
+    #[test]
+    fn format_method_call() {
+        let src = "global x =  bar . baz ( 1, 2 )  ;";
+        let expected = "global x = bar.baz(1, 2);\n";
+        assert_format(src, expected);
+    }
+
+    #[test]
+    fn format_method_call_with_long_arguments() {
+        let src = "global x =  bar . baz ( 123456789, 123456789, 123456789, 123456789, 123456789, 123456789, 123456789 )  ;";
+        let expected = "global x = bar.baz(
+    123456789,
+    123456789,
+    123456789,
+    123456789,
+    123456789,
+    123456789,
+    123456789,
+);
+";
+        assert_format_with_max_width(src, expected, 40);
+    }
+
+    #[test]
+    fn format_method_call_with_generics() {
+        let src = "global x =  bar . baz :: < T >  ( 1, 2 )  ;";
+        let expected = "global x = bar.baz::<T>(1, 2);\n";
+        assert_format(src, expected);
+    }
+
+    #[test]
+    fn format_method_call_chain() {
+        let src = "global x =  bar . baz ( 1, 2 ) . qux ( 1 , 2, 3) . one ( 5, 6)  ;";
+        let expected = "global x = bar
+    .baz(1, 2)
+    .qux(1, 2, 3)
+    .one(5, 6);
+";
+        assert_format_with_max_width(src, expected, 25);
+    }
+
+    #[test]
+    fn format_method_call_chain_2() {
+        let src = "fn foo() { bar . baz ( 1, 2 ) . qux ( 1 , 2, 3) . one ( 5, 6)   }";
+        let expected = "fn foo() {
+    bar.baz(1, 2).qux(1, 2, 3).one(
+        5,
+        6,
+    )
+}
+";
+        assert_format_with_max_width(src, expected, "    bar.baz(1, 2).qux(1, 2, 3).one(".len());
+    }
+
+    #[test]
+    fn format_method_call_chain_3() {
+        let src = "fn foo() {     assert(p4_affine.eq(Gaffine::new(6890855772600357754907169075114257697580319025794532037257385534741338397365, 4338620300185947561074059802482547481416142213883829469920100239455078257889)));  }";
+        let expected = "fn foo() {
+    assert(p4_affine.eq(Gaffine::new(
+        6890855772600357754907169075114257697580319025794532037257385534741338397365,
+        4338620300185947561074059802482547481416142213883829469920100239455078257889,
+    )));
+}
+";
+        assert_format(src, expected);
+    }
+
+    #[test]
+    fn format_method_call_with_maximum_width() {
+        let src = "global x =  foo::bar.baz( );";
+        let expected = "global x = foo::bar
+    .baz();
+";
+        assert_format_with_max_width(src, expected, "foo::bar.baz".len() - 1);
+    }
+
+    #[test]
+    fn format_nested_method_call_with_maximum_width() {
+        let src = "fn foo() { foo.bar(baz.qux(123, 456, 789)) } ";
+        let expected = "fn foo() {
+    foo.bar(baz.qux(
+        123,
+        456,
+        789,
+    ))
+}
+";
+        assert_format_with_max_width(src, expected, "    foo.bar(bar.qux(".len());
+    }
+
+    #[test]
+    fn format_nested_method_call_with_maximum_width_2() {
+        let src = "fn foo() {
+    assert(
+        p4_affine.eq(Gaffine::new(
+            6890855772600357754907169075114257697580319025794532037257385534741338397365,
+            4338620300185947561074059802482547481416142213883829469920100239455078257889,
+        )),
+    );
+}
+";
+        let expected = "fn foo() {
+    assert(p4_affine.eq(Gaffine::new(
+        6890855772600357754907169075114257697580319025794532037257385534741338397365,
+        4338620300185947561074059802482547481416142213883829469920100239455078257889,
+    )));
+}
+";
+        assert_format(src, expected);
+    }
+
+    #[test]
+    fn format_member_access() {
+        let src = "global x =  bar . baz   ;";
+        let expected = "global x = bar.baz;\n";
+        assert_format(src, expected);
+    }
+
+    #[test]
+    fn format_long_member_access_alone() {
+        let src = "global x =  foo . bar . baz . qux . final   ;";
+        let expected = "global x = foo
+    .bar
+    .baz
+    .qux
+    .final;
+";
+        assert_format_with_max_width(src, expected, "foo.bar.baz.qux.final".len() - 1);
+    }
+
+    #[test]
+    fn format_long_member_access_and_method_call_chain() {
+        let src = "global x =  foo . bar(1, 2) . baz . qux(2, 3) . this_is_a_long_name   ;";
+        let expected = "global x = foo
+    .bar(1, 2)
+    .baz
+    .qux(2, 3)
+    .this_is_a_long_name;
+";
+        assert_format_with_max_width(src, expected, 25);
+    }
+
+    #[test]
+    fn format_long_member_access_and_method_call_chain_2() {
+        let src = "fn burn() {
+    storage
+        .at(from)
+        .sub(from_keys.npk_m, U128::from_integer(amount))
+        .emit(encode_and_encrypt_note!());
+}
+";
+        let expected = "fn burn() {
+    storage.at(from).sub(from_keys.npk_m, U128::from_integer(amount)).emit(
+        encode_and_encrypt_note!(),
+    );
+}
+";
+        assert_format(src, expected);
+    }
+
+    #[test]
+    fn format_tuple_member_access() {
+        let src = "global x =  bar . 0   ;";
+        let expected = "global x = bar.0;\n";
+        assert_format(src, expected);
+    }
+
+    #[test]
+    fn format_parenthesized() {
+        let src = "global x =  ( 1 )   ;";
+        let expected = "global x = (1);\n";
+        assert_format(src, expected);
+    }
+
+    #[test]
+    fn format_unsafe_one_expression() {
+        let src = "global x = unsafe { 1  } ;";
+        let expected = "global x = unsafe { 1 };\n";
+        assert_format(src, expected);
+    }
+
+    #[test]
+    fn format_unsafe_two_expressions() {
+        let src = "global x = unsafe { 1; 2  } ;";
+        let expected = "global x = unsafe {
+    1;
+    2
+};
+";
+        assert_format(src, expected);
+    }
+
+    #[test]
+    fn format_comptime_one_expression() {
+        let src = "global x = comptime { 1  } ;";
+        let expected = "global x = comptime { 1 };\n";
+        assert_format(src, expected);
+    }
+
+    #[test]
+    fn format_comptime_two_expressions() {
+        let src = "global x = comptime { 1; 2  } ;";
+        let expected = "global x = comptime {
+    1;
+    2
+};
+";
+        assert_format(src, expected);
+    }
+
+    #[test]
+    fn format_empty_constructor() {
+        let src = "global x = Foo { } ;";
+        let expected = "global x = Foo {};\n";
+        assert_format(src, expected);
+    }
+
+    #[test]
+    fn format_constructor() {
+        let src = "global x = Foo { one: 1 , two : 2 , three } ;";
+        let expected = "global x = Foo { one: 1, two: 2, three };\n";
+        assert_format(src, expected);
+    }
+
+    #[test]
+    fn format_constructor_with_turbofish() {
+        let src = "global x = Foo :: < Bar > { one } ;";
+        let expected = "global x = Foo::<Bar> { one };\n";
+        assert_format(src, expected);
+    }
+
+    #[test]
+    fn format_type_path() {
+        let src = "global x = Field :: max  ;";
+        let expected = "global x = Field::max;\n";
+        assert_format(src, expected);
+    }
+
+    #[test]
+    fn format_type_path_with_turbofish() {
+        let src = "global x = Field :: max :: < i32 > ;";
+        let expected = "global x = Field::max::<i32>;\n";
+        assert_format(src, expected);
+    }
+
+    #[test]
+    fn format_if_expression_without_else_one_expression() {
+        let src = "global x = if  1   {   2   } ;";
+        let expected = "global x = if 1 { 2 };\n";
+        assert_format(src, expected);
+    }
+
+    #[test]
+    fn format_if_expression_without_else_two_expressions() {
+        let src = "global x = if  1   {   2; 3   } ;";
+        let expected = "global x = if 1 {
+    2;
+    3
+};
+";
+        assert_format(src, expected);
+    }
+
+    #[test]
+    fn format_if_expression_with_else() {
+        let src = "global x = if  1   {   2   }  else  {  3  };";
+        let expected = "global x = if 1 { 2 } else { 3 };\n";
+        assert_format(src, expected);
+    }
+
+    #[test]
+    fn format_if_expression_with_else_multiple_exprs() {
+        let src = "global x = if  1   {   2   }  else  {  3; 4  };";
+        let expected = "global x = if 1 {
+    2
+} else {
+    3;
+    4
+};
+";
+        assert_format(src, expected);
+    }
+
+    #[test]
+    fn format_if_expression_else_if() {
+        let src = "global x = if  1   {   2   }  else if 3 {  4  };";
+        let expected = "global x = if 1 {
+    2
+} else if 3 {
+    4
+};
+";
+        assert_format(src, expected);
+    }
+
+    #[test]
+    fn format_if_with_configurable_maximum_if_width() {
+        let src = "global x = if  123   {   456   }  else  {  789  };";
+        let expected = "global x = if 123 {
+    456
+} else {
+    789
+};\n";
+
+        let config = Config {
+            single_line_if_else_max_width: "if 123 { 456 } else { 789 }".len() - 1,
+            ..Config::default()
+        };
+        assert_format_with_config(src, expected, config);
+    }
+
+    #[test]
+    fn format_if_with_configurable_maximum_if_width_2() {
+        let src = "global x = if  foo(123)   {   456   }  else  {  789  };";
+        let expected = "global x = if foo(123) {
+    456
+} else {
+    789
+};\n";
+
+        let config = Config {
+            single_line_if_else_max_width: "if foo(123) { 456 } else { 789 }".len() - 1,
+            ..Config::default()
+        };
+        assert_format_with_config(src, expected, config);
+    }
+
+    #[test]
+    fn format_quote() {
+        let src = "global x = quote { 1  2  3 $four $(five) };";
+        let expected = "global x = quote { 1  2  3 $four $(five) };\n";
+        assert_format(src, expected);
+    }
+
+    #[test]
+    fn format_quote_with_newlines() {
+        let src = "fn foo() {
+    quote {
+
+        foo
+
+        bar
+
+    }
+}
+";
+        let expected = src;
+        assert_format(src, expected);
+    }
+
+    #[test]
+    fn format_quote_with_bracket_delimiter() {
+        let src = "global x = quote [ 1  2  3 $four $(five) ];";
+        let expected = "global x = quote [ 1  2  3 $four $(five) ];\n";
+        assert_format(src, expected);
+    }
+
+    #[test]
+    fn format_lambda_no_parameters() {
+        let src = "global x = | |  1 ;";
+        let expected = "global x = || 1;\n";
+        assert_format(src, expected);
+    }
+
+    #[test]
+    fn format_lambda_with_parameters() {
+        let src = "global x = | x , y : Field , z |  1 ;";
+        let expected = "global x = |x, y: Field, z| 1;\n";
+        assert_format(src, expected);
+    }
+
+    #[test]
+    fn format_lambda_with_block_simplifies() {
+        let src = "global x = | |  {  1  } ;";
+        let expected = "global x = || 1;\n";
+        assert_format(src, expected);
+    }
+
+    #[test]
+    fn format_lambda_with_block_does_not_simplify_if_it_ends_with_semicolon() {
+        let src = "global x = | |  {  1;  } ;";
+        let expected = "global x = || { 1; };\n";
+        assert_format(src, expected);
+    }
+
+    #[test]
+    fn format_lambda_with_block_does_not_simplify_if_it_has_return_type() {
+        let src = "global x = | | -> i32  {  1  } ;";
+        let expected = "global x = || -> i32 { 1 };\n";
+        assert_format(src, expected);
+    }
+
+    #[test]
+    fn format_lambda_with_simplifies_block_with_quote() {
+        let src = "global x = | | {  quote { 1 }   } ;";
+        let expected = "global x = || quote { 1 };\n";
+        assert_format(src, expected);
+    }
+
+    #[test]
+    fn format_lambda_with_block_simplifies_inside_arguments_list() {
+        let src = "global x = some_call(this_is_a_long_argument, | |  {  1  });";
+        let expected = "global x = some_call(
+    this_is_a_long_argument,
+    || 1,
+);
+";
+        assert_format_with_max_width(src, expected, 20);
+    }
+
+    #[test]
+    fn format_lambda_with_block_multiple_statements() {
+        let src = "global x = | a, b |  {  1; 2  } ;";
+        let expected = "global x = |a, b| {
+    1;
+    2
+};
+";
+        assert_format(src, expected);
+    }
+
+    #[test]
+    fn format_lambda_as_last_call_argument() {
+        let src = "global x = foo(1, |x| { 1; 2 });";
+        let expected = "global x = foo(1, |x| {
+    1;
+    2
+});
+";
+        assert_format(src, expected);
+    }
+
+    #[test]
+    fn format_lambda_as_last_method_call_argument() {
+        let src = "global x = foo.bar(1, |x| { 1; 2 });";
+        let expected = "global x = foo.bar(1, |x| {
+    1;
+    2
+});
+";
+        assert_format(src, expected);
+    }
+
+    #[test]
+    fn format_lambda_as_last_method_call_argument_2() {
+        let src = "fn foo(){
+    m.structs().any(|s: StructDefinition| s.has_named_attribute(\"storage\") | s.has_named_attribute(\"storage_no_init\"),
+    )
+}
+";
+        let expected = "fn foo() {
+    m.structs().any(|s: StructDefinition| {
+        s.has_named_attribute(\"storage\") | s.has_named_attribute(\"storage_no_init\")
+    })
+}
+";
+        assert_format(src, expected);
+    }
+
+    #[test]
+    fn format_lambda_as_last_method_call_argument_3() {
+        let src = "mod moo {
+    fn foo() {
+        let mut sorted_write_tuples = unsafe {
+            get_sorted_tuple(
+                final_public_data_writes.storage,
+                |(_, leaf_a): (u32, PublicDataTreeLeaf), (_, leaf_b): (u32, PublicDataTreeLeaf)| full_field_less_than(
+                    1, 2,
+                ),
+            )
+        };
+    }
+}
+";
+        let expected = "mod moo {
+    fn foo() {
+        let mut sorted_write_tuples = unsafe {
+            get_sorted_tuple(
+                final_public_data_writes.storage,
+                |(_, leaf_a): (u32, PublicDataTreeLeaf), (_, leaf_b): (u32, PublicDataTreeLeaf)| {
+                    full_field_less_than(1, 2)
+                },
+            )
+        };
+    }
+}
+";
+        assert_format(src, expected);
+    }
+
+    #[test]
+    fn format_lambda_as_last_method_call_chain_argument() {
+        let src = "global x = foo.bar(1).baz(2, |x| { 1; 2 });";
+        let expected = "global x = foo.bar(1).baz(2, |x| {
+    1;
+    2
+});
+";
+        assert_format(src, expected);
+    }
+
+    #[test]
+    fn format_lambda_as_last_method_call_chain_argument_2() {
+        let src = "fn foo() { expr.as_unsafe().map(|exprs| { a; aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa }) }
+        ";
+        let expected = "fn foo() {
+    expr.as_unsafe().map(|exprs| {
+        a;
+        aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa
+    })
+}
+";
+        assert_format(src, expected);
+    }
+
+    #[test]
+    fn format_lambda_as_last_method_call_has_to_wrap() {
+        let src = "global foo = bar(1, 2, 3, |argument| { 1; 2 });";
+        let expected = "global foo = bar(
+    1,
+    2,
+    3,
+    |argument| {
+        1;
+        2
+    },
+);
+";
+        assert_format_with_max_width(src, expected, src.len() - 10);
+    }
+
+    #[test]
+    fn removes_nested_parens() {
+        let src = "global x = ( ( ( ( ) ) ) ) ;";
+        let expected = "global x = (());\n";
+        assert_format(src, expected);
+    }
+
+    #[test]
+    fn does_not_remove_nested_parens_if_not_told_so() {
+        let src = "global x = ( ( ( ( ) ) ) ) ;";
+        let expected = "global x = (((())));\n";
+
+        let config = Config { remove_nested_parens: false, ..Config::default() };
+        assert_format_with_config(src, expected, config);
+    }
+
+    #[test]
+    fn attaches_comma_to_last_group() {
+        let src = " mod moo {
+    fn foo() {
+        [
+            Foo { a: 1 }, Foo { a: 1 }
+            ];
+            bar;
+        }
+}
+";
+        let expected = "mod moo {
+    fn foo() {
+        [
+            Foo {
+                a: 1,
+            },
+            Foo {
+                a: 1,
+            },
+        ];
+        bar;
+    }
+}
+";
+        assert_format_with_max_width(src, expected, "            Foo { a: 1 },".len() - 1);
+    }
+}
diff --git a/tooling/nargo_fmt/src/formatter/function.rs b/tooling/nargo_fmt/src/formatter/function.rs
new file mode 100644
index 00000000000..8207db5e486
--- /dev/null
+++ b/tooling/nargo_fmt/src/formatter/function.rs
@@ -0,0 +1,608 @@
+use noirc_frontend::{
+    ast::{
+        BlockExpression, FunctionReturnType, Ident, ItemVisibility, NoirFunction, Param,
+        UnresolvedGenerics, UnresolvedTraitConstraint, Visibility,
+    },
+    token::{Attributes, Keyword, Token},
+};
+
+use super::Formatter;
+use crate::chunks::{ChunkGroup, TextChunk};
+
+pub(super) struct FunctionToFormat {
+    pub(super) attributes: Attributes,
+    pub(super) visibility: ItemVisibility,
+    pub(super) name: Ident,
+    pub(super) generics: UnresolvedGenerics,
+    pub(super) parameters: Vec<Param>,
+    pub(super) return_type: FunctionReturnType,
+    pub(super) return_visibility: Visibility,
+    pub(super) where_clause: Vec<UnresolvedTraitConstraint>,
+    pub(super) body: Option<BlockExpression>,
+}
+
+impl<'a> Formatter<'a> {
+    pub(super) fn format_function(&mut self, func: NoirFunction) {
+        self.format_function_impl(FunctionToFormat {
+            attributes: func.def.attributes,
+            visibility: func.def.visibility,
+            name: func.def.name,
+            generics: func.def.generics,
+            parameters: func.def.parameters,
+            return_type: func.def.return_type,
+            return_visibility: func.def.return_visibility,
+            where_clause: func.def.where_clause,
+            body: Some(func.def.body),
+        });
+    }
+
+    pub(super) fn format_function_impl(&mut self, func: FunctionToFormat) {
+        let has_where_clause = !func.where_clause.is_empty();
+
+        self.format_attributes(func.attributes);
+        self.write_indentation();
+        self.format_function_modifiers(func.visibility);
+        self.write_keyword(Keyword::Fn);
+        self.write_space();
+        self.write_identifier(func.name);
+        self.format_generics(func.generics);
+        self.write_left_paren();
+
+        // When the function has no parameters we can format everything in a single line
+        if func.parameters.is_empty() {
+            self.increase_indentation();
+            self.skip_comments_and_whitespace();
+            self.decrease_indentation();
+
+            let group = ChunkGroup::new();
+            self.format_function_right_paren_until_left_brace_or_semicolon(
+                func.return_type,
+                func.return_visibility,
+                has_where_clause,
+                false,               // has parameters
+                func.body.is_none(), // semicolon
+                group,
+            );
+        } else {
+            let mut group = ChunkGroup::new();
+            self.format_function_parameters(func.parameters, &mut group);
+            self.format_function_right_paren_until_left_brace_or_semicolon(
+                func.return_type,
+                func.return_visibility,
+                has_where_clause,
+                true,                // has parameters
+                func.body.is_none(), // semicolon
+                group,
+            );
+        }
+
+        if has_where_clause {
+            self.format_where_clause(
+                func.where_clause,
+                func.body.is_some(), // write trailing comma and newline
+            );
+            if func.body.is_some() {
+                self.write_left_brace();
+            } else {
+                self.write_semicolon();
+            }
+        }
+
+        if let Some(body) = func.body {
+            self.format_function_body(body);
+            self.write_right_brace();
+        }
+    }
+
+    pub(super) fn format_function_modifiers(&mut self, visibility: ItemVisibility) {
+        // For backwards compatibility, unconstrained might come before visibility.
+        // We'll remember this but put it after the visibility.
+        let unconstrained = if self.is_at_keyword(Keyword::Unconstrained) {
+            self.bump();
+            self.skip_comments_and_whitespace();
+            true
+        } else {
+            false
+        };
+
+        self.format_item_visibility(visibility);
+
+        if unconstrained {
+            self.write("unconstrained ");
+        } else if self.is_at_keyword(Keyword::Unconstrained) {
+            self.write_keyword(Keyword::Unconstrained);
+            self.write_space();
+        }
+
+        if self.is_at_keyword(Keyword::Comptime) {
+            self.write_keyword(Keyword::Comptime);
+            self.write_space();
+        }
+    }
+
+    pub(super) fn format_function_parameters(
+        &mut self,
+        parameters: Vec<Param>,
+        group: &mut ChunkGroup,
+    ) {
+        self.chunk_formatter().format_items_separated_by_comma(
+            parameters,
+            false, // force trailing comma
+            false, // surround with spaces
+            group,
+            |formatter, param, group| {
+                group.text(formatter.chunk(|formatter| {
+                    formatter.format_function_param(param);
+                }));
+            },
+        );
+    }
+
+    fn format_function_param(&mut self, param: Param) {
+        self.format_pattern(param.pattern);
+        self.skip_comments_and_whitespace();
+
+        // There might not be a colon if the parameter is self
+        if self.is_at(Token::Colon) {
+            self.write_token(Token::Colon);
+            self.write_space();
+            self.format_visibility(param.visibility);
+            self.format_type(param.typ);
+        }
+    }
+
+    /// Returns whether the left brace of semicolon was written
+    /// (we don't write it when there's a comment before those tokens)
+    pub(super) fn format_function_right_paren_until_left_brace_or_semicolon(
+        &mut self,
+        return_type: FunctionReturnType,
+        visibility: Visibility,
+        has_where_clause: bool,
+        has_parameters: bool,
+        semicolon: bool,
+        mut group: ChunkGroup,
+    ) {
+        let mut chunk_formatter = self.chunk_formatter();
+
+        group.text(chunk_formatter.chunk(|formatter| {
+            formatter.write_right_paren();
+            formatter.format_function_return_type(return_type, visibility);
+        }));
+
+        // The following code is a bit long because it takes into account three scenarios:
+        //
+        // 1.
+        // fn foo() -> Field {}
+        //
+        // 2.
+        // fn foo() -> Field // comment
+        // {}
+        //
+        // 3.
+        // fn foo() -> Field
+        // // comment
+        // {}
+        //
+        // We want to preserve the above formatting when there are trailing comments,
+        // possibly considering a trailing comment in the same line to count towards the
+        // maximum width of the line.
+        //
+        // For that, we take the comment chunk and depending on whether it has leading newlines
+        // or if it even exists we take different paths.
+        let comment_chunk = chunk_formatter.skip_comments_and_whitespace_chunk();
+        let comment_chunk = TextChunk::new(comment_chunk.string.trim_end().to_string());
+
+        let comment_starts_with_newline = comment_chunk.string.trim_matches(' ').starts_with('\n');
+        if comment_starts_with_newline {
+            // After the return type we found a newline and a comment. We want to format the group
+            // right away, then keep formatting everything else (at that point there's no need to
+            // use chunks anymore).
+            self.format_chunk_group(group);
+
+            let mut comment_group = ChunkGroup::new();
+            comment_group.text(comment_chunk);
+            self.format_chunk_group(comment_group);
+            self.write_line();
+
+            // If there's no where clause the left brace goes on the same line as the function signature
+            if !has_where_clause {
+                self.skip_stray_where_keyword();
+
+                if semicolon {
+                    self.write_semicolon();
+                } else {
+                    self.write_left_brace();
+                }
+            }
+            return;
+        }
+
+        let wrote_comment = !comment_chunk.string.trim().is_empty();
+        group.text(comment_chunk);
+
+        // If there's no where clause the left brace goes on the same line as the function signature
+        if !has_where_clause {
+            group.text(chunk_formatter.chunk(|formatter| {
+                formatter.skip_stray_where_keyword();
+            }));
+        }
+
+        if !has_where_clause && !wrote_comment {
+            if semicolon {
+                group.semicolon(&mut chunk_formatter);
+            } else {
+                group.text(chunk_formatter.chunk(|formatter| {
+                    formatter.write_space();
+                    formatter.write_left_brace();
+                }));
+            }
+        }
+
+        if has_parameters {
+            self.format_chunk_group(group);
+        } else {
+            self.format_chunk_group_in_one_line(group);
+        }
+
+        if wrote_comment {
+            self.write_line();
+            if semicolon {
+                self.write_semicolon();
+            } else {
+                self.write_left_brace();
+            }
+        }
+    }
+
+    fn skip_stray_where_keyword(&mut self) {
+        // There might still be a where keyword that we'll remove
+        if self.is_at_keyword(Keyword::Where) {
+            self.bump();
+            self.skip_comments_and_whitespace();
+        }
+    }
+
+    fn format_function_return_type(
+        &mut self,
+        return_type: FunctionReturnType,
+        visibility: Visibility,
+    ) {
+        match return_type {
+            FunctionReturnType::Default(..) => (),
+            FunctionReturnType::Ty(typ) => {
+                self.write_space();
+                self.write_token(Token::Arrow);
+                self.write_space();
+                self.format_visibility(visibility);
+                self.format_type(typ);
+            }
+        }
+    }
+
+    pub(super) fn format_function_body(&mut self, body: BlockExpression) {
+        let mut group = ChunkGroup::new();
+        self.chunk_formatter().format_block_expression_contents(
+            body, true, // force multiple newlines
+            &mut group,
+        );
+        self.format_chunk_group(group);
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use crate::{assert_format, assert_format_with_max_width};
+
+    #[test]
+    fn format_simple_function() {
+        let src = "mod moo { 
+        /// hello 
+#[attr]  pub  fn  foo (  )  { }  }";
+        let expected = "mod moo {
+    /// hello
+    #[attr]
+    pub fn foo() {}
+}
+";
+        assert_format(src, expected);
+    }
+
+    #[test]
+    fn format_function_with_args() {
+        let src = "fn  foo ( x:  i32 , y:i32 , )  { }  ";
+        let expected = "fn foo(x: i32, y: i32) {}\n";
+        assert_format(src, expected);
+    }
+
+    #[test]
+    fn format_function_with_args_that_exceed_max_width() {
+        let src = "fn  foo ( this_is_long:  i32 , like_really_long:i32 , )  { }  ";
+        let expected = "fn foo(
+    this_is_long: i32,
+    like_really_long: i32,
+) {}\n";
+        assert_format_with_max_width(src, expected, 40);
+    }
+
+    #[test]
+    fn format_function_with_modifiers() {
+        let src = "pub  unconstrained  comptime  fn  foo ( ) {  }";
+        let expected = "pub unconstrained comptime fn foo() {}\n";
+        assert_format(src, expected);
+    }
+
+    #[test]
+    fn format_function_with_unconstrained_before_pub() {
+        let src = "unconstrained pub  fn  foo ( ) {  }";
+        let expected = "pub unconstrained fn foo() {}\n";
+        assert_format(src, expected);
+    }
+
+    #[test]
+    fn format_function_generics() {
+        let src = "fn  foo < A, B, >( ) {  }";
+        let expected = "fn foo<A, B>() {}\n";
+        assert_format(src, expected);
+    }
+
+    #[test]
+    fn format_function_return_type() {
+        let src = "fn  foo( )  ->   Field  {  }";
+        let expected = "fn foo() -> Field {}\n";
+        assert_format(src, expected);
+    }
+
+    #[test]
+    fn format_function_parameter_pub_visibility() {
+        let src = "fn  foo( x : pub u8 ) {  }";
+        let expected = "fn foo(x: pub u8) {}\n";
+        assert_format(src, expected);
+    }
+
+    #[test]
+    fn format_function_parameter_calldata_visibility() {
+        let src = "fn  foo( x :  call_data ( 1 )  u8 ) {  }";
+        let expected = "fn foo(x: call_data(1) u8) {}\n";
+        assert_format(src, expected);
+    }
+
+    #[test]
+    fn format_function_parameter_return_data_visibility() {
+        let src = "fn  foo( x :  return_data   u8 ) {  }";
+        let expected = "fn foo(x: return_data u8) {}\n";
+        assert_format(src, expected);
+    }
+
+    #[test]
+    fn format_function_return_visibility() {
+        let src = "fn  foo( )  ->  pub   Field  {  }";
+        let expected = "fn foo() -> pub Field {}\n";
+        assert_format(src, expected);
+    }
+
+    #[test]
+    fn format_function_empty_where_clause() {
+        let src = "mod foo { fn  foo( )  where    {  } } ";
+        let expected = "mod foo {
+    fn foo() {}
+}
+";
+        assert_format(src, expected);
+    }
+
+    #[test]
+    fn format_function_where_clause() {
+        let src = "mod foo { fn  foo( )  where  T : Foo , U :  Bar   {  } } ";
+        let expected = "mod foo {
+    fn foo()
+    where
+        T: Foo,
+        U: Bar,
+    {}
+}
+";
+        assert_format(src, expected);
+    }
+
+    #[test]
+    fn format_function_where_clause_multiple_bounds() {
+        let src = "mod foo { fn  foo( )  where  T : Foo+Bar , U :  Baz  +  Qux   {  } } ";
+        let expected = "mod foo {
+    fn foo()
+    where
+        T: Foo + Bar,
+        U: Baz + Qux,
+    {}
+}
+";
+        assert_format(src, expected);
+    }
+
+    #[test]
+    fn format_function_with_body() {
+        let src = "fn main() { 1; 2; 3 }";
+        let expected = "fn main() {
+    1;
+    2;
+    3
+}
+";
+        assert_format(src, expected);
+    }
+
+    #[test]
+    fn format_function_with_body_newlines() {
+        let src = "fn main() { 
+
+        1; 
+        
+        2; 
+        
+        3 
+
+        }";
+        let expected = "fn main() {
+    1;
+
+    2;
+
+    3
+}
+";
+        assert_format(src, expected);
+    }
+
+    #[test]
+    fn format_function_with_body_one_expr() {
+        let src = "mod moo { fn main() { 1 } }";
+        let expected = "mod moo {
+    fn main() {
+        1
+    }
+}
+";
+        assert_format(src, expected);
+    }
+
+    #[test]
+    fn format_function_with_empty_body_multiple_lines() {
+        let src = "fn foo() {
+
+        }";
+        let expected = "fn foo() {}\n";
+        assert_format(src, expected);
+    }
+
+    #[test]
+    fn format_function_with_trailing_comment_in_same_line_before_left_brace() {
+        let src = "fn foo(x: Field) // comment 
+        {
+        }";
+        let expected = "fn foo(x: Field) // comment
+{}
+";
+        assert_format(src, expected);
+    }
+
+    #[test]
+    fn format_function_with_trailing_comment_in_separate_line_before_left_brace() {
+        let src = "fn foo(x: Field)
+        // comment 
+        {
+        }";
+        let expected = "fn foo(x: Field)
+// comment
+{}
+";
+        assert_format(src, expected);
+    }
+
+    #[test]
+    fn format_long_function_signature_no_parameters() {
+        let src = "fn foo() -> Field {}";
+        let expected = "fn foo() -> Field {}\n";
+        assert_format_with_max_width(src, expected, 15);
+    }
+
+    #[test]
+    fn does_not_format_function_if_there_is_a_directive_not_to() {
+        let src = "// noir-fmt:ignore
+fn foo() { let  x  = 1  ; 
+            }
+                   
+fn bar() { let  y  = 2  ; 
+            }
+
+// noir-fmt:ignore
+fn baz() { let  z  = 3  ; 
+            }
+
+";
+        let expected = "// noir-fmt:ignore
+fn foo() { let  x  = 1  ; 
+            }
+
+fn bar() {
+    let y = 2;
+}
+
+// noir-fmt:ignore
+fn baz() { let  z  = 3  ; 
+            }
+
+";
+        assert_format(src, expected);
+    }
+
+    #[test]
+    fn comment_in_body_respects_newlines() {
+        let src = "fn foo() {
+    let x = 1;
+
+    // comment
+
+    let y = 2;
+}
+";
+        let expected = src;
+        assert_format(src, expected);
+    }
+
+    #[test]
+    fn final_comment_in_body_respects_newlines() {
+        let src = "fn foo() {
+    let x = 1;
+
+    let y = 2;
+
+    // comment
+}
+";
+        let expected = src;
+        assert_format(src, expected);
+    }
+
+    #[test]
+    fn initial_comment_in_body_respects_newlines() {
+        let src = "fn foo() {
+    // comment
+
+    let x = 1;
+
+    let y = 2;
+}
+";
+        let expected = src;
+        assert_format(src, expected);
+    }
+
+    #[test]
+    fn keeps_newlines_between_comments_no_statements() {
+        let src = "fn foo() {
+    // foo
+
+    // bar
+
+    // baz
+}
+";
+        let expected = src;
+        assert_format(src, expected);
+    }
+
+    #[test]
+    fn keeps_newlines_between_comments_one_statement() {
+        let src = "fn foo() {
+    let x = 1;
+
+    // foo
+
+    // bar
+
+    // baz
+}
+";
+        let expected = src;
+        assert_format(src, expected);
+    }
+}
diff --git a/tooling/nargo_fmt/src/formatter/generics.rs b/tooling/nargo_fmt/src/formatter/generics.rs
new file mode 100644
index 00000000000..4ee5a743942
--- /dev/null
+++ b/tooling/nargo_fmt/src/formatter/generics.rs
@@ -0,0 +1,96 @@
+use noirc_frontend::{
+    ast::{GenericTypeArgKind, GenericTypeArgs, UnresolvedGeneric},
+    token::{Keyword, Token},
+};
+
+use super::Formatter;
+
+impl<'a> Formatter<'a> {
+    pub(super) fn format_generics(&mut self, generics: Vec<UnresolvedGeneric>) {
+        self.skip_comments_and_whitespace();
+
+        if self.token != Token::Less {
+            return;
+        }
+
+        self.write_token(Token::Less);
+        for (index, generic) in generics.into_iter().enumerate() {
+            if index > 0 {
+                self.write_comma();
+                self.write_space();
+            }
+            self.format_generic(generic);
+        }
+        self.skip_comments_and_whitespace();
+
+        // Trailing comma
+        if self.is_at(Token::Comma) {
+            self.bump();
+        }
+
+        self.write_token(Token::Greater);
+    }
+
+    fn format_generic(&mut self, generic: UnresolvedGeneric) {
+        self.skip_comments_and_whitespace();
+        match generic {
+            UnresolvedGeneric::Variable(ident) => {
+                self.write_identifier(ident);
+            }
+            UnresolvedGeneric::Numeric { ident, typ } => {
+                self.write_keyword(Keyword::Let);
+                self.write_space();
+                self.write_identifier(ident);
+                self.write_token(Token::Colon);
+                self.write_space();
+                self.format_type(typ);
+            }
+            UnresolvedGeneric::Resolved(..) => {
+                unreachable!("Resolved generics should not be present in the AST")
+            }
+        }
+    }
+
+    pub(super) fn format_generic_type_args(&mut self, mut generics: GenericTypeArgs) {
+        self.skip_comments_and_whitespace();
+        if self.token != Token::Less {
+            return;
+        }
+
+        self.write_token(Token::Less);
+
+        for (index, kind) in generics.kinds.into_iter().enumerate() {
+            self.skip_comments_and_whitespace();
+
+            if index > 0 {
+                self.write_token(Token::Comma);
+                self.write_space();
+            }
+
+            match kind {
+                GenericTypeArgKind::Ordered => {
+                    let typ = generics.ordered_args.remove(0);
+                    self.format_type(typ);
+                }
+                GenericTypeArgKind::Named => {
+                    let (name, typ) = generics.named_args.remove(0);
+                    self.write_identifier(name);
+                    self.write_space();
+                    self.write_token(Token::Assign);
+                    self.write_space();
+                    self.format_type(typ);
+                }
+            }
+        }
+
+        self.skip_comments_and_whitespace();
+
+        // Don't include a trailing comma if there is one
+        if self.is_at(Token::Comma) {
+            self.bump();
+            self.skip_comments_and_whitespace();
+        }
+
+        self.write_token(Token::Greater);
+    }
+}
diff --git a/tooling/nargo_fmt/src/formatter/global.rs b/tooling/nargo_fmt/src/formatter/global.rs
new file mode 100644
index 00000000000..783629c8e32
--- /dev/null
+++ b/tooling/nargo_fmt/src/formatter/global.rs
@@ -0,0 +1,102 @@
+use noirc_frontend::{
+    ast::{ItemVisibility, LetStatement, Pattern},
+    token::Keyword,
+};
+
+use super::Formatter;
+use crate::chunks::{ChunkFormatter, ChunkGroup};
+
+impl<'a> Formatter<'a> {
+    pub(super) fn format_global(
+        &mut self,
+        let_statement: LetStatement,
+        visibility: ItemVisibility,
+    ) {
+        let group = self.chunk_formatter().format_global(let_statement, visibility);
+        self.write_indentation();
+        self.format_chunk_group(group);
+    }
+}
+
+impl<'a, 'b> ChunkFormatter<'a, 'b> {
+    pub(super) fn format_global(
+        &mut self,
+        let_statement: LetStatement,
+        visibility: ItemVisibility,
+    ) -> ChunkGroup {
+        let mut group = ChunkGroup::new();
+        group.text(self.chunk(|formatter| {
+            formatter.format_item_visibility(visibility);
+        }));
+
+        if let_statement.comptime {
+            group.text(self.chunk(|formatter| {
+                formatter.write_keyword(Keyword::Comptime);
+                formatter.write_space();
+            }));
+        }
+
+        let pattern = let_statement.pattern;
+        let pattern = match pattern {
+            Pattern::Identifier(..) => pattern,
+            Pattern::Mutable(pattern, _span, _) => {
+                // `mut global x` is represented in the AST with a mutable pattern.
+                // A mutable pattern would be `mut x` but here we have `mut global x`,
+                // so in that case we write `mut` now, then the pattern we'll write doesn't
+                // have the `mut` part.
+                group.text(self.chunk(|formatter| {
+                    formatter.write_keyword(Keyword::Mut);
+                    formatter.write_space();
+                }));
+
+                *pattern
+            }
+            Pattern::Tuple(..) | Pattern::Struct(..) | Pattern::Interned(..) => {
+                unreachable!("Global pattern cannot be a tuple, struct or interned")
+            }
+        };
+
+        group.group(self.format_let_or_global(
+            Keyword::Global,
+            pattern,
+            let_statement.r#type,
+            Some(let_statement.expression),
+            Vec::new(), // Attributes
+        ));
+
+        group
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use crate::assert_format;
+
+    #[test]
+    fn format_global_without_type() {
+        let src = " pub  global  x  =  1  ; ";
+        let expected = "pub global x = 1;\n";
+        assert_format(src, expected);
+    }
+
+    #[test]
+    fn format_global_with_type() {
+        let src = " pub  global  x  :  Field  =  1  ; ";
+        let expected = "pub global x: Field = 1;\n";
+        assert_format(src, expected);
+    }
+
+    #[test]
+    fn format_comptime_global() {
+        let src = " pub  comptime  global  x  :  Field  =  1  ; ";
+        let expected = "pub comptime global x: Field = 1;\n";
+        assert_format(src, expected);
+    }
+
+    #[test]
+    fn format_comptime_mut_global() {
+        let src = " pub  comptime  mut  global  x  :  Field  =  1  ; ";
+        let expected = "pub comptime mut global x: Field = 1;\n";
+        assert_format(src, expected);
+    }
+}
diff --git a/tooling/nargo_fmt/src/formatter/impls.rs b/tooling/nargo_fmt/src/formatter/impls.rs
new file mode 100644
index 00000000000..1c2c25c9200
--- /dev/null
+++ b/tooling/nargo_fmt/src/formatter/impls.rs
@@ -0,0 +1,123 @@
+use noirc_frontend::{ast::TypeImpl, token::Keyword};
+
+use super::Formatter;
+
+impl<'a> Formatter<'a> {
+    pub(super) fn format_impl(&mut self, type_impl: TypeImpl) {
+        let has_where_clause = !type_impl.where_clause.is_empty();
+
+        self.write_indentation();
+        self.write_keyword(Keyword::Impl);
+        self.format_generics(type_impl.generics);
+        self.write_space();
+        self.format_type(type_impl.object_type);
+
+        if has_where_clause {
+            self.format_where_clause(
+                type_impl.where_clause,
+                true, // write trailing comma and newline
+            );
+        } else {
+            self.write_space();
+        }
+        self.write_left_brace();
+
+        if type_impl.methods.is_empty() {
+            self.format_empty_block_contents();
+        } else {
+            self.increase_indentation();
+            self.write_line();
+
+            for (index, (documented_method, _span)) in type_impl.methods.into_iter().enumerate() {
+                if index > 0 {
+                    self.write_line();
+                }
+
+                let doc_comments = documented_method.doc_comments;
+                let method = documented_method.item;
+                if !doc_comments.is_empty() {
+                    self.format_outer_doc_comments();
+                }
+                self.format_function(method);
+            }
+
+            self.skip_comments_and_whitespace();
+            self.decrease_indentation();
+            self.write_line();
+            self.write_indentation();
+        }
+
+        self.write_right_brace();
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use crate::assert_format;
+
+    #[test]
+    fn format_empty_impl() {
+        let src = " mod moo { impl Foo {  } }";
+        let expected = "mod moo {
+    impl Foo {}
+}
+";
+        assert_format(src, expected);
+    }
+
+    #[test]
+    fn format_empty_impl_with_generics() {
+        let src = " mod moo { impl < A,  B > Foo < A, B > {  } }";
+        let expected = "mod moo {
+    impl<A, B> Foo<A, B> {}
+}
+";
+        assert_format(src, expected);
+    }
+
+    #[test]
+    fn format_empty_impl_with_where_clause() {
+        let src = " mod moo { impl Foo where A: B  {  } }";
+        let expected = "mod moo {
+    impl Foo
+    where
+        A: B,
+    {}
+}
+";
+        assert_format(src, expected);
+    }
+
+    #[test]
+    fn format_impl_with_functions() {
+        let src = " mod moo { impl Foo {  
+/// hello
+pub fn foo () { 1 }
+
+/// world
+pub ( crate ) fn bar () {
+    }
+
+fn one(self) {}
+fn two(mut self) {}
+fn three(&mut self) {}
+ } }";
+        let expected = "mod moo {
+    impl Foo {
+        /// hello
+        pub fn foo() {
+            1
+        }
+
+        /// world
+        pub(crate) fn bar() {}
+
+        fn one(self) {}
+        fn two(mut self) {}
+        fn three(&mut self) {}
+    }
+}
+";
+        assert_format(src, expected);
+    }
+}
diff --git a/tooling/nargo_fmt/src/formatter/item.rs b/tooling/nargo_fmt/src/formatter/item.rs
new file mode 100644
index 00000000000..521e476fe71
--- /dev/null
+++ b/tooling/nargo_fmt/src/formatter/item.rs
@@ -0,0 +1,175 @@
+use noirc_frontend::{
+    ast::{ItemVisibility, UseTree},
+    hir::resolution::errors::Span,
+    parser::{Item, ItemKind},
+};
+
+use crate::config::ImportsGranularity;
+
+use super::Formatter;
+
+impl<'a> Formatter<'a> {
+    pub(super) fn format_items(&mut self, mut items: Vec<Item>, mut ignore_next: bool) {
+        // Reverse the items because we'll be processing them one by one, and it's a bit
+        // more efficient to pop than to shift.
+        items.reverse();
+
+        while !items.is_empty() {
+            // Format the next import group, if there is one.
+            let import_group = self.next_import_group(&mut items);
+            if let Some(import_group) = import_group {
+                self.merge_and_format_imports(import_group.imports, import_group.visibility);
+                self.skip_past_span_end_without_formatting(import_group.span_end);
+                self.write_line();
+                ignore_next = self.ignore_next;
+
+                // Continue from the top because the next thing that comes might be another import group
+                continue;
+            }
+
+            if let Some(item) = items.pop() {
+                self.format_item(item, ignore_next);
+                self.write_line();
+                ignore_next = self.ignore_next;
+            } else {
+                break;
+            }
+        }
+    }
+
+    pub(super) fn format_item(&mut self, item: Item, mut ignore_next: bool) {
+        self.skip_comments_and_whitespace();
+
+        ignore_next |= self.ignore_next;
+
+        if !item.doc_comments.is_empty() {
+            self.format_outer_doc_comments();
+            self.skip_comments_and_whitespace();
+        }
+
+        ignore_next |= self.ignore_next;
+
+        if ignore_next {
+            self.write_and_skip_span_without_formatting(item.span);
+            return;
+        }
+
+        match item.kind {
+            ItemKind::Import(use_tree, item_visibility) => {
+                self.format_import(use_tree, item_visibility);
+            }
+            ItemKind::Function(noir_function) => self.format_function(noir_function),
+            ItemKind::Struct(noir_struct) => self.format_struct(noir_struct),
+            ItemKind::Trait(noir_trait) => self.format_trait(noir_trait),
+            ItemKind::TraitImpl(noir_trait_impl) => self.format_trait_impl(noir_trait_impl),
+            ItemKind::Impl(type_impl) => self.format_impl(type_impl),
+            ItemKind::TypeAlias(noir_type_alias) => self.format_type_alias(noir_type_alias),
+            ItemKind::Global(let_statement, visibility) => {
+                self.format_global(let_statement, visibility);
+            }
+            ItemKind::ModuleDecl(module_declaration) => {
+                self.format_module_declaration(module_declaration);
+            }
+            ItemKind::Submodules(parsed_sub_module) => {
+                self.format_submodule(parsed_sub_module);
+            }
+            ItemKind::InnerAttribute(attribute) => self.format_secondary_attribute(attribute),
+        }
+    }
+
+    /// Returns the next import group, if there's is one.
+    ///
+    /// An import group is one or more `use` statements that all have the same visibility,
+    /// as long as exactly one newline separates them, and as long as there are no comments
+    /// in the `use` statements or trailing comments in them.
+    ///
+    /// Each import group will be sorted and merged, if the configuration is set to do so.
+    fn next_import_group(&self, items: &mut Vec<Item>) -> Option<ImportGroup> {
+        if self.config.imports_granularity == ImportsGranularity::Preserve
+            && !self.config.reorder_imports
+        {
+            return None;
+        }
+
+        let mut imports = Vec::new();
+
+        let item = items.last()?;
+        if self.span_has_comments(item.span) {
+            return None;
+        }
+
+        let ItemKind::Import(..) = item.kind else {
+            return None;
+        };
+
+        let item = items.pop().unwrap();
+        let ItemKind::Import(use_tree, visibility) = item.kind else {
+            panic!("Expected import, got {:?}", item.kind);
+        };
+
+        imports.push(use_tree);
+        let mut span_end = item.span.end();
+
+        while let Some(item) = items.last() {
+            if self.span_is_import_group_separator(Span::from(span_end..item.span.start())) {
+                break;
+            }
+
+            let next_item_start = if items.len() > 1 {
+                if let Some(next_item) = items.get(items.len() - 2) {
+                    next_item.span.start()
+                } else {
+                    self.source.len() as u32
+                }
+            } else {
+                self.source.len() as u32
+            };
+
+            if self.span_starts_with_trailing_comment(Span::from(item.span.end()..next_item_start))
+            {
+                break;
+            }
+
+            let ItemKind::Import(_, next_visibility) = &item.kind else {
+                break;
+            };
+
+            if visibility != *next_visibility {
+                break;
+            }
+
+            let item = items.pop().unwrap();
+            let ItemKind::Import(use_tree, _) = item.kind else {
+                panic!("Expected import, got {:?}", item.kind);
+            };
+            imports.push(use_tree);
+            span_end = item.span.end();
+        }
+
+        Some(ImportGroup { imports, visibility, span_end })
+    }
+
+    fn span_has_comments(&self, span: Span) -> bool {
+        let slice = &self.source[span.start() as usize..span.end() as usize];
+        slice.contains("/*") || slice.contains("//")
+    }
+
+    fn span_starts_with_trailing_comment(&self, span: Span) -> bool {
+        let slice = &self.source[span.start() as usize..span.end() as usize];
+        slice.trim_start_matches(' ').starts_with("//")
+    }
+
+    /// Returns true if there at most one newline in the given span and it contains no comments.
+    fn span_is_import_group_separator(&self, span: Span) -> bool {
+        let slice = &self.source[span.start() as usize..span.end() as usize];
+        let number_of_newlines = slice.chars().filter(|char| *char == '\n').count();
+        number_of_newlines > 1 || slice.contains("//") || slice.contains("/*")
+    }
+}
+
+#[derive(Debug)]
+struct ImportGroup {
+    imports: Vec<UseTree>,
+    visibility: ItemVisibility,
+    span_end: u32,
+}
diff --git a/tooling/nargo_fmt/src/formatter/lvalue.rs b/tooling/nargo_fmt/src/formatter/lvalue.rs
new file mode 100644
index 00000000000..15fb7f5fa26
--- /dev/null
+++ b/tooling/nargo_fmt/src/formatter/lvalue.rs
@@ -0,0 +1,44 @@
+use noirc_frontend::{ast::LValue, token::Token};
+
+use super::Formatter;
+use crate::chunks::ChunkGroup;
+
+impl<'a> Formatter<'a> {
+    pub(super) fn format_lvalue(&mut self, lvalue: LValue) {
+        // Parenthesized l-values exist but are not represented in the AST
+        while let Token::LeftParen = self.token {
+            self.write_left_paren();
+        }
+
+        match lvalue {
+            LValue::Ident(ident) => self.write_identifier(ident),
+            LValue::MemberAccess { object, field_name, span: _ } => {
+                self.format_lvalue(*object);
+                self.write_token(Token::Dot);
+                self.write_identifier_or_integer(field_name);
+            }
+            LValue::Index { array, index, span: _ } => {
+                self.format_lvalue(*array);
+                self.write_left_bracket();
+                let mut group = ChunkGroup::new();
+                self.chunk_formatter().format_expression(index, &mut group);
+                self.format_chunk_group(group);
+                self.write_right_bracket();
+            }
+            LValue::Dereference(lvalue, _span) => {
+                self.write_token(Token::Star);
+                self.format_lvalue(*lvalue);
+            }
+            LValue::Interned(..) => {
+                unreachable!("Should not be present in the AST")
+            }
+        }
+
+        self.skip_comments_and_whitespace();
+
+        // Parenthesized l-values exist but are not represented in the AST
+        while let Token::RightParen = self.token {
+            self.write_right_paren();
+        }
+    }
+}
diff --git a/tooling/nargo_fmt/src/formatter/module.rs b/tooling/nargo_fmt/src/formatter/module.rs
new file mode 100644
index 00000000000..e07d22c7586
--- /dev/null
+++ b/tooling/nargo_fmt/src/formatter/module.rs
@@ -0,0 +1,140 @@
+use noirc_frontend::{
+    ast::ModuleDeclaration, parser::ParsedSubModule, token::Keyword, ParsedModule,
+};
+
+use super::Formatter;
+
+impl<'a> Formatter<'a> {
+    pub(super) fn format_module_declaration(&mut self, module_declaration: ModuleDeclaration) {
+        self.format_secondary_attributes(module_declaration.outer_attributes);
+        self.write_indentation();
+        self.format_item_visibility(module_declaration.visibility);
+        self.write_keyword(Keyword::Mod);
+        self.write_space();
+        self.write_identifier(module_declaration.ident);
+        self.write_semicolon();
+    }
+
+    pub(super) fn format_submodule(&mut self, submodule: ParsedSubModule) {
+        self.format_secondary_attributes(submodule.outer_attributes);
+        self.write_indentation();
+        self.format_item_visibility(submodule.visibility);
+        if submodule.is_contract {
+            self.write_keyword(Keyword::Contract);
+        } else {
+            self.write_keyword(Keyword::Mod);
+        }
+        self.write_space();
+        self.write_identifier(submodule.name);
+        self.write_space();
+        self.write_left_brace();
+        if parsed_module_is_empty(&submodule.contents) {
+            self.format_empty_block_contents();
+        } else {
+            self.increase_indentation();
+            self.write_line();
+            self.format_parsed_module(submodule.contents, self.ignore_next);
+            self.decrease_indentation();
+            self.write_indentation();
+        }
+        self.write_right_brace();
+    }
+}
+
+fn parsed_module_is_empty(parsed_module: &ParsedModule) -> bool {
+    parsed_module.inner_doc_comments.is_empty() && parsed_module.items.is_empty()
+}
+
+#[cfg(test)]
+mod tests {
+    use crate::{assert_format, assert_format_with_config, Config};
+
+    #[test]
+    fn format_module_declaration() {
+        let src = "  mod  foo ; ";
+        let expected = "mod foo;\n";
+        assert_format(src, expected);
+    }
+
+    #[test]
+    fn format_module_declaration_with_doc_comments() {
+        let src = " /// hello
+/// world 
+mod  foo ; ";
+        let expected = "/// hello
+/// world
+mod foo;\n";
+        assert_format(src, expected);
+    }
+
+    #[test]
+    fn format_module_declaration_with_pub_visibility() {
+        let src = "  pub   mod  foo  ;";
+        let expected = "pub mod foo;\n";
+        assert_format(src, expected);
+    }
+
+    #[test]
+    fn format_module_declaration_with_pub_crate_visibility() {
+        let src = "  pub ( crate )  mod  foo  ;";
+        let expected = "pub(crate) mod foo;\n";
+        assert_format(src, expected);
+    }
+
+    #[test]
+    fn format_empty_submodule() {
+        let src = "mod foo {    }";
+        let expected = "mod foo {}\n";
+        assert_format(src, expected);
+    }
+
+    #[test]
+    fn format_empty_submodule_2() {
+        let src = "mod foo { mod bar {    
+
+    } }";
+        let expected = "mod foo {
+    mod bar {}
+}
+";
+        assert_format(src, expected);
+    }
+
+    #[test]
+    fn format_empty_subcontract() {
+        let src = "contract foo {    }";
+        let expected = "contract foo {}\n";
+        assert_format(src, expected);
+    }
+
+    #[test]
+    fn format_multiple_modules() {
+        let src = "  mod  foo { 
+// hello
+mod bar {
+// world
+}
+} ";
+        let expected = "mod foo {
+    // hello
+    mod bar {
+        // world
+    }
+}
+";
+        assert_format(src, expected);
+    }
+
+    #[test]
+    fn format_submodule_with_configurable_tab_spaces() {
+        let src = " mod foo {
+        mod bar ;
+    }";
+        let expected = "mod foo {
+  mod bar;
+}
+";
+        let config = Config { tab_spaces: 2, ..Config::default() };
+        assert_format_with_config(src, expected, config);
+    }
+}
diff --git a/tooling/nargo_fmt/src/formatter/path.rs b/tooling/nargo_fmt/src/formatter/path.rs
new file mode 100644
index 00000000000..2a46467bf72
--- /dev/null
+++ b/tooling/nargo_fmt/src/formatter/path.rs
@@ -0,0 +1,59 @@
+use noirc_frontend::{
+    ast::{Path, PathKind, UnresolvedType},
+    token::{Keyword, Token},
+};
+
+use super::Formatter;
+
+impl<'a> Formatter<'a> {
+    pub(super) fn format_path(&mut self, path: Path) {
+        self.skip_comments_and_whitespace();
+
+        match path.kind {
+            PathKind::Plain => (),
+            PathKind::Crate => {
+                self.write_keyword(Keyword::Crate);
+                self.write_token(Token::DoubleColon);
+            }
+            PathKind::Dep => {
+                self.write_keyword(Keyword::Dep);
+                self.write_token(Token::DoubleColon);
+            }
+            PathKind::Super => {
+                self.write_keyword(Keyword::Super);
+                self.write_token(Token::DoubleColon);
+            }
+        }
+
+        for (index, segment) in path.segments.into_iter().enumerate() {
+            if index > 0 {
+                self.write_token(Token::DoubleColon);
+            }
+            self.write_identifier(segment.ident);
+
+            if let Some(generics) = segment.generics {
+                self.format_turbofish(generics);
+            }
+        }
+    }
+
+    pub(super) fn format_turbofish(&mut self, generics: Vec<UnresolvedType>) {
+        self.write_token(Token::DoubleColon);
+        self.write_token(Token::Less);
+        for (index, typ) in generics.into_iter().enumerate() {
+            if index > 0 {
+                self.write_comma();
+                self.write_space();
+            }
+            self.format_type(typ);
+        }
+
+        // Skip trailing comma, if any
+        self.skip_comments_and_whitespace();
+        if self.is_at(Token::Comma) {
+            self.bump();
+        }
+
+        self.write_token(Token::Greater);
+    }
+}
diff --git a/tooling/nargo_fmt/src/formatter/pattern.rs b/tooling/nargo_fmt/src/formatter/pattern.rs
new file mode 100644
index 00000000000..9a76612109b
--- /dev/null
+++ b/tooling/nargo_fmt/src/formatter/pattern.rs
@@ -0,0 +1,162 @@
+use noirc_frontend::{
+    ast::{Ident, Pattern},
+    token::{Keyword, Token},
+};
+
+use super::Formatter;
+use crate::chunks::ChunkGroup;
+
+impl<'a> Formatter<'a> {
+    pub(super) fn format_pattern(&mut self, pattern: Pattern) {
+        self.skip_comments_and_whitespace();
+
+        // Special case: `&mut self` (this is reflected in the param type, not the pattern)
+        if self.is_at(Token::Ampersand) {
+            self.write_token(Token::Ampersand);
+            self.write_keyword(Keyword::Mut);
+            self.write_space();
+        }
+
+        match pattern {
+            Pattern::Identifier(ident) => self.write_identifier(ident),
+            Pattern::Mutable(pattern, _span, _) => {
+                self.write_keyword(Keyword::Mut);
+                self.write_space();
+                self.format_pattern(*pattern);
+            }
+            Pattern::Tuple(patterns, _span) => {
+                let patterns_len = patterns.len();
+
+                self.write_left_paren();
+                for (index, pattern) in patterns.into_iter().enumerate() {
+                    if index > 0 {
+                        self.write_comma();
+                        self.write_space();
+                    }
+                    self.format_pattern(pattern);
+                }
+
+                // Check for trailing comma
+                self.skip_comments_and_whitespace();
+                if self.is_at(Token::Comma) {
+                    if patterns_len == 1 {
+                        self.write_comma();
+                    } else {
+                        self.bump();
+                    }
+                }
+
+                self.write_right_paren();
+            }
+            Pattern::Struct(path, fields, _span) => {
+                self.format_path(path);
+                self.write_space();
+                self.write_left_brace();
+                if fields.is_empty() {
+                    self.format_empty_block_contents();
+                } else {
+                    let mut group = ChunkGroup::new();
+                    self.chunk_formatter().format_items_separated_by_comma(
+                        fields,
+                        false, // force trailing comma,
+                        true,  // surround with spaces
+                        &mut group,
+                        |formatter, (name, pattern), chunks| {
+                            let is_identifier_pattern = is_identifier_pattern(&pattern, &name);
+
+                            chunks.text(formatter.chunk(|formatter| {
+                                formatter.write_identifier(name);
+                                formatter.skip_comments_and_whitespace();
+                            }));
+                            if formatter.is_at(Token::Colon) {
+                                let value_chunk = formatter.chunk(|formatter| {
+                                    formatter.write_token(Token::Colon);
+                                    formatter.write_space();
+                                    formatter.format_pattern(pattern);
+                                });
+                                if !is_identifier_pattern {
+                                    chunks.text(value_chunk);
+                                }
+                            }
+                        },
+                    );
+                    self.format_chunk_group(group);
+                }
+
+                self.write_right_brace();
+            }
+            Pattern::Interned(..) => {
+                unreachable!("Should not be present in the AST")
+            }
+        }
+    }
+}
+
+fn is_identifier_pattern(pattern: &Pattern, ident: &Ident) -> bool {
+    if let Pattern::Identifier(pattern_ident) = pattern {
+        pattern_ident == ident
+    } else {
+        false
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use crate::assert_format;
+
+    #[test]
+    fn format_identifier_pattern() {
+        let src = "fn foo( x : i32) {}";
+        let expected = "fn foo(x: i32) {}\n";
+        assert_format(src, expected);
+    }
+
+    #[test]
+    fn format_mutable_pattern() {
+        let src = "fn foo( mut x : i32) {}";
+        let expected = "fn foo(mut x: i32) {}\n";
+        assert_format(src, expected);
+    }
+
+    #[test]
+    fn format_tuple_pattern_no_trailing_comma() {
+        let src = "fn foo( (  x  ,  y  ) : i32) {}";
+        let expected = "fn foo((x, y): i32) {}\n";
+        assert_format(src, expected);
+    }
+
+    #[test]
+    fn format_tuple_pattern_trailing_comma() {
+        let src = "fn foo( (  x  ,  y , ) : i32) {}";
+        let expected = "fn foo((x, y): i32) {}\n";
+        assert_format(src, expected);
+    }
+
+    #[test]
+    fn format_tuple_pattern_one_element() {
+        let src = "fn foo( (  x  ,    ) : i32) {}";
+        let expected = "fn foo((x,): i32) {}\n";
+        assert_format(src, expected);
+    }
+
+    #[test]
+    fn format_struct_pattern_empty() {
+        let src = "fn foo( Foo {  } : i32) {}";
+        let expected = "fn foo(Foo {}: i32) {}\n";
+        assert_format(src, expected);
+    }
+
+    #[test]
+    fn format_struct_pattern() {
+        let src = "fn foo( Foo { x : one , y : two } : i32) {}";
+        let expected = "fn foo(Foo { x: one, y: two }: i32) {}\n";
+        assert_format(src, expected);
+    }
+
+    #[test]
+    fn format_struct_pattern_no_pattern() {
+        let src = "fn foo( Foo { x  , y : y } : i32) {}";
+        let expected = "fn foo(Foo { x, y }: i32) {}\n";
+        assert_format(src, expected);
+    }
+}
diff --git a/tooling/nargo_fmt/src/formatter/statement.rs b/tooling/nargo_fmt/src/formatter/statement.rs
new file mode 100644
index 00000000000..50c286ff161
--- /dev/null
+++ b/tooling/nargo_fmt/src/formatter/statement.rs
@@ -0,0 +1,713 @@
+use noirc_frontend::{
+    ast::{
+        AssignStatement, ConstrainKind, ConstrainStatement, Expression, ExpressionKind,
+        ForLoopStatement, ForRange, LetStatement, Pattern, Statement, StatementKind,
+        UnresolvedType, UnresolvedTypeData,
+    },
+    token::{Keyword, SecondaryAttribute, Token},
+};
+
+use crate::chunks::{ChunkFormatter, ChunkGroup, GroupKind};
+
+impl<'a, 'b> ChunkFormatter<'a, 'b> {
+    pub(super) fn format_statement(
+        &mut self,
+        statement: Statement,
+        group: &mut ChunkGroup,
+        mut ignore_next: bool,
+    ) {
+        // First skip any whitespace to avoid writing multiple lines
+        group.text(self.chunk(|formatter| {
+            formatter.skip_whitespace();
+        }));
+
+        // Now write any leading comment respecting multiple newlines after them
+        group.leading_comment(self.chunk(|formatter| {
+            formatter.skip_comments_and_whitespace_writing_multiple_lines_if_found();
+        }));
+
+        ignore_next |= self.ignore_next;
+
+        if ignore_next {
+            group.text(self.chunk(|formatter| {
+                formatter.write_and_skip_span_without_formatting(statement.span);
+            }));
+            return;
+        }
+
+        match statement.kind {
+            StatementKind::Let(let_statement) => {
+                group.group(self.format_let_statement(let_statement));
+            }
+            StatementKind::Constrain(constrain_statement) => {
+                group.group(self.format_constrain_statement(constrain_statement));
+            }
+            StatementKind::Expression(expression) => match expression.kind {
+                ExpressionKind::Block(block) => group.group(self.format_block_expression(
+                    block, true, // force multiple lines
+                )),
+                ExpressionKind::Unsafe(block, _) => {
+                    group.group(self.format_unsafe_expression(
+                        block, true, // force multiple lines
+                    ));
+                }
+                ExpressionKind::If(if_expression) => {
+                    group.group(self.format_if_expression(
+                        *if_expression,
+                        true, // force multiple lines
+                    ));
+                }
+                _ => self.format_expression(expression, group),
+            },
+            StatementKind::Assign(assign_statement) => {
+                group.group(self.format_assign(assign_statement));
+            }
+            StatementKind::For(for_loop_statement) => {
+                group.group(self.format_for_loop(for_loop_statement));
+            }
+            StatementKind::Break => {
+                group.text(self.chunk(|formatter| {
+                    formatter.write_keyword(Keyword::Break);
+                    formatter.write_semicolon();
+                }));
+            }
+            StatementKind::Continue => {
+                group.text(self.chunk(|formatter| {
+                    formatter.write_keyword(Keyword::Continue);
+                    formatter.write_semicolon();
+                }));
+            }
+            StatementKind::Comptime(statement) => {
+                group.group(self.format_comptime_statement(*statement));
+            }
+            StatementKind::Semi(expression) => {
+                group.group(self.format_semi_statement(expression));
+            }
+            StatementKind::Interned(..) | StatementKind::Error => {
+                unreachable!("Should not be present in the AST")
+            }
+        }
+    }
+
+    fn format_let_statement(&mut self, let_statement: LetStatement) -> ChunkGroup {
+        self.format_let_or_global(
+            Keyword::Let,
+            let_statement.pattern,
+            let_statement.r#type,
+            Some(let_statement.expression),
+            let_statement.attributes,
+        )
+    }
+
+    pub(super) fn format_let_or_global(
+        &mut self,
+        keyword: Keyword,
+        pattern: Pattern,
+        typ: UnresolvedType,
+        value: Option<Expression>,
+        attributes: Vec<SecondaryAttribute>,
+    ) -> ChunkGroup {
+        let mut group = ChunkGroup::new();
+
+        group.text(self.chunk(|formatter| {
+            formatter.format_secondary_attributes(attributes);
+            formatter.write_keyword(keyword);
+            formatter.write_space();
+            formatter.format_pattern(pattern);
+            if typ.typ != UnresolvedTypeData::Unspecified {
+                formatter.write_token(Token::Colon);
+                formatter.write_space();
+                formatter.format_type(typ);
+            }
+        }));
+
+        if let Some(value) = value {
+            group.text(self.chunk(|formatter| {
+                formatter.write_space();
+                formatter.write_token(Token::Assign);
+                formatter.write_space();
+            }));
+
+            let mut value_group = ChunkGroup::new();
+            value_group.kind = GroupKind::AssignValue;
+            self.format_expression(value, &mut value_group);
+            value_group.semicolon(self);
+            group.group(value_group);
+        } else {
+            group.semicolon(self);
+        }
+
+        group
+    }
+
+    fn format_constrain_statement(
+        &mut self,
+        constrain_statement: ConstrainStatement,
+    ) -> ChunkGroup {
+        let mut group = ChunkGroup::new();
+
+        let keyword = match constrain_statement.kind {
+            ConstrainKind::Assert => Keyword::Assert,
+            ConstrainKind::AssertEq => Keyword::AssertEq,
+            ConstrainKind::Constrain => {
+                unreachable!("constrain always produces an error, and the formatter doesn't run when there are errors")
+            }
+        };
+
+        group.text(self.chunk(|formatter| {
+            formatter.write_keyword(keyword);
+            formatter.write_left_paren();
+        }));
+
+        group.kind = GroupKind::ExpressionList {
+            prefix_width: group.width(),
+            expressions_count: constrain_statement.arguments.len(),
+        };
+
+        self.format_expressions_separated_by_comma(
+            constrain_statement.arguments,
+            false, // force trailing comma
+            &mut group,
+        );
+
+        group.text(self.chunk(|formatter| {
+            formatter.write_right_paren();
+            formatter.write_semicolon();
+        }));
+
+        group
+    }
+
+    fn format_assign(&mut self, assign_statement: AssignStatement) -> ChunkGroup {
+        let mut group = ChunkGroup::new();
+        let mut is_op_assign = false;
+
+        group.text(self.chunk(|formatter| {
+            formatter.format_lvalue(assign_statement.lvalue);
+            formatter.write_space();
+            if formatter.is_at(Token::Assign) {
+                formatter.write_token(Token::Assign);
+            } else {
+                // This is something like `x += 1`, which is parsed as an
+                // Assign with an InfixExpression as its right-hand side: `x = x + 1`.
+                // There will always be two tokens here, like `+ =` or `> >=`.
+                formatter.write_current_token();
+                formatter.bump();
+                formatter.skip_comments_and_whitespace();
+                formatter.write_current_token();
+                formatter.bump();
+
+                is_op_assign = true;
+            }
+            formatter.write_space();
+        }));
+
+        let mut value_group = ChunkGroup::new();
+        value_group.kind = GroupKind::AssignValue;
+
+        if is_op_assign {
+            let ExpressionKind::Infix(infix) = assign_statement.expression.kind else {
+                panic!("Expected an infix expression for op assign");
+            };
+            self.format_expression(infix.rhs, &mut value_group);
+        } else {
+            self.format_expression(assign_statement.expression, &mut value_group);
+        }
+        value_group.semicolon(self);
+        group.group(value_group);
+
+        group
+    }
+
+    fn format_for_loop(&mut self, for_loop: ForLoopStatement) -> ChunkGroup {
+        let mut group = ChunkGroup::new();
+
+        group.text(self.chunk(|formatter| {
+            formatter.write_keyword(Keyword::For);
+            formatter.write_space();
+            formatter.write_identifier(for_loop.identifier);
+            formatter.write_space();
+            formatter.write_keyword(Keyword::In);
+            formatter.write_space();
+        }));
+
+        match for_loop.range {
+            ForRange::Range(for_bounds) => {
+                self.format_expression(for_bounds.start, &mut group);
+                group.text(self.chunk(|formatter| {
+                    formatter.skip_comments_and_whitespace();
+                    formatter.write_current_token();
+                    formatter.bump();
+                }));
+                self.format_expression(for_bounds.end, &mut group);
+            }
+            ForRange::Array(expression) => {
+                self.format_expression(expression, &mut group);
+            }
+        }
+
+        group.space(self);
+
+        let ExpressionKind::Block(block) = for_loop.block.kind else {
+            panic!("Expected a block expression for for loop body");
+        };
+
+        group.group(self.format_block_expression(
+            block, true, // force multiple lines
+        ));
+
+        // If there's a trailing semicolon, remove it
+        group.text(self.chunk(|formatter| {
+            formatter.skip_whitespace_if_it_is_not_a_newline();
+            if formatter.is_at(Token::Semicolon) {
+                formatter.bump();
+            }
+        }));
+
+        group
+    }
+
+    fn format_comptime_statement(&mut self, statement: Statement) -> ChunkGroup {
+        let mut group = ChunkGroup::new();
+
+        // A comptime statement can be a let, a block or a for.
+        // We always want to force multiple lines except for let.
+        group.force_multiple_lines = !matches!(statement.kind, StatementKind::Let(..));
+
+        group.text(self.chunk(|formatter| {
+            formatter.write_keyword(Keyword::Comptime);
+            formatter.write_space();
+        }));
+        self.format_statement(
+            statement, &mut group, false, // ignore next
+        );
+        group
+    }
+
+    fn format_semi_statement(&mut self, expression: Expression) -> ChunkGroup {
+        let mut group = ChunkGroup::new();
+
+        self.format_expression(expression, &mut group);
+
+        group.text(self.chunk(|formatter| {
+            formatter.skip_comments_and_whitespace();
+        }));
+
+        group.semicolon(self);
+
+        group
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use crate::{assert_format, assert_format_with_max_width};
+
+    #[test]
+    fn format_expression_statement() {
+        let src = " fn foo() { 1 } ";
+        let expected = "fn foo() {
+    1
+}
+";
+        assert_format(src, expected);
+    }
+
+    #[test]
+    fn format_semi_statement() {
+        let src = " fn foo() { 1 ; } ";
+        let expected = "fn foo() {
+    1;
+}
+";
+        assert_format(src, expected);
+    }
+
+    #[test]
+    fn format_break_statement() {
+        let src = " fn foo() { break  ; } ";
+        let expected = "fn foo() {
+    break;
+}
+";
+        assert_format(src, expected);
+    }
+
+    #[test]
+    fn format_continue_statement() {
+        let src = " fn foo() { continue  ; } ";
+        let expected = "fn foo() {
+    continue;
+}
+";
+        assert_format(src, expected);
+    }
+
+    #[test]
+    fn format_let_statement_no_type() {
+        let src = " fn foo() { let  x  =  1 ; } ";
+        let expected = "fn foo() {
+    let x = 1;
+}
+";
+        assert_format(src, expected);
+    }
+
+    #[test]
+    fn format_let_statement_with_type() {
+        let src = " fn foo() { let  x  :  Field  =  1 ; } ";
+        let expected = "fn foo() {
+    let x: Field = 1;
+}
+";
+        assert_format(src, expected);
+    }
+
+    #[test]
+    fn format_let_statement_with_attribute() {
+        let src = " fn foo() {   #[allow(unused_variables)] let  x  =  1 ; } ";
+        let expected = "fn foo() {
+    #[allow(unused_variables)]
+    let x = 1;
+}
+";
+        assert_format(src, expected);
+    }
+
+    #[test]
+    fn format_assign() {
+        let src = " fn foo() { x  =  2 ; } ";
+        let expected = "fn foo() {
+    x = 2;
+}
+";
+        assert_format(src, expected);
+    }
+
+    #[test]
+    fn format_assign_to_member() {
+        let src = " fn foo() { x . y  =  2 ; } ";
+        let expected = "fn foo() {
+    x.y = 2;
+}
+";
+        assert_format(src, expected);
+    }
+
+    #[test]
+    fn format_assign_to_tuple_member() {
+        let src = " fn foo() { x . 0  =  2 ; } ";
+        let expected = "fn foo() {
+    x.0 = 2;
+}
+";
+        assert_format(src, expected);
+    }
+
+    #[test]
+    fn format_assign_to_index() {
+        let src = " fn foo() { x [ y ]  =  2 ; } ";
+        let expected = "fn foo() {
+    x[y] = 2;
+}
+";
+        assert_format(src, expected);
+    }
+
+    #[test]
+    fn format_assign_to_dereference() {
+        let src = " fn foo() { * x  =  2 ; } ";
+        let expected = "fn foo() {
+    *x = 2;
+}
+";
+        assert_format(src, expected);
+    }
+
+    #[test]
+    fn format_assign_with_parentheses() {
+        let src = " fn foo() { ( array[0] )[1] = 2; } ";
+        let expected = "fn foo() {
+    (array[0])[1] = 2;
+}
+";
+        assert_format(src, expected);
+    }
+
+    #[test]
+    fn format_op_assign() {
+        let src = " fn foo() { x  + =  2 ; } ";
+        let expected = "fn foo() {
+    x += 2;
+}
+";
+        assert_format(src, expected);
+    }
+
+    #[test]
+    fn format_shift_right_assign() {
+        let src = " fn foo() { x  >>=  2 ; } ";
+        let expected = "fn foo() {
+    x >>= 2;
+}
+";
+        assert_format(src, expected);
+    }
+
+    #[test]
+    fn format_comptime_let_statement() {
+        let src = " fn foo() { comptime  let  x  =  1 ; } ";
+        let expected = "fn foo() {
+    comptime let x = 1;
+}
+";
+        assert_format(src, expected);
+    }
+
+    #[test]
+    fn format_empty_block_statement() {
+        let src = " fn foo() { { } } ";
+        let expected = "fn foo() {
+    {}
+}
+";
+        assert_format(src, expected);
+    }
+
+    #[test]
+    fn format_block_statement() {
+        let src = " fn foo() { { 1 ; 2 } } ";
+        let expected = "fn foo() {
+    {
+        1;
+        2
+    }
+}
+";
+        assert_format(src, expected);
+    }
+
+    #[test]
+    fn format_unsafe_statement() {
+        let src = " fn foo() { unsafe { 1  } } ";
+        let expected = "fn foo() {
+    unsafe {
+        1
+    }
+}
+";
+        assert_format(src, expected);
+    }
+
+    #[test]
+    fn format_comptime_statement_one_statement() {
+        let src = " fn foo() { comptime { 1  } } ";
+        let expected = "fn foo() {
+    comptime {
+        1
+    }
+}
+";
+        assert_format(src, expected);
+    }
+
+    #[test]
+    fn format_comptime_block_statement() {
+        let src = " fn foo() { comptime { 1 ; 2 } } ";
+        let expected = "fn foo() {
+    comptime {
+        1;
+        2
+    }
+}
+";
+        assert_format(src, expected);
+    }
+
+    #[test]
+    fn format_for_array() {
+        let src = " fn foo() {  for  x  in  array  {  1  } } ";
+        let expected = "fn foo() {
+    for x in array {
+        1
+    }
+}
+";
+        assert_format(src, expected);
+    }
+
+    #[test]
+    fn format_for_array_trailing_semicolon() {
+        let src = " fn foo() {  for  x  in  array  {  1  } ; } ";
+        let expected = "fn foo() {
+    for x in array {
+        1
+    }
+}
+";
+        assert_format(src, expected);
+    }
+
+    #[test]
+    fn format_for_range_exclusive() {
+        let src = " fn foo() {  for  x  in  1 .. 10  {  1  } } ";
+        let expected = "fn foo() {
+    for x in 1..10 {
+        1
+    }
+}
+";
+        assert_format(src, expected);
+    }
+
+    #[test]
+    fn format_for_range_inclusive() {
+        let src = " fn foo() {  for  x  in  1 ..= 10  {  1  } } ";
+        let expected = "fn foo() {
+    for x in 1..=10 {
+        1
+    }
+}
+";
+        assert_format(src, expected);
+    }
+
+    #[test]
+    fn format_two_for_separated_by_multiple_lines() {
+        let src = " fn foo() {  for  x  in  array  {  1  } 
+        
+        for  x  in  array  {  1  }
+        
+        } ";
+        let expected = "fn foo() {
+    for x in array {
+        1
+    }
+
+    for x in array {
+        1
+    }
+}
+";
+        assert_format(src, expected);
+    }
+
+    #[test]
+    fn format_assert() {
+        let src = r#" fn foo() {  assert ( true , "hello" ) ;  } "#;
+        let expected = r#"fn foo() {
+    assert(true, "hello");
+}
+"#;
+        assert_format(src, expected);
+    }
+
+    #[test]
+    fn format_assert_eq() {
+        let src = r#" fn foo() {  assert ( 1 , 2 , "hello" ) ;  } "#;
+        let expected = r#"fn foo() {
+    assert(1, 2, "hello");
+}
+"#;
+        assert_format(src, expected);
+    }
+
+    #[test]
+    fn format_if_statement() {
+        let src = r#" fn foo() {  if 1 {  2  }  } "#;
+        let expected = r#"fn foo() {
+    if 1 {
+        2
+    }
+}
+"#;
+        assert_format(src, expected);
+    }
+
+    #[test]
+    fn does_not_format_statement_if_there_is_a_directive_not_to() {
+        let src = "fn foo() {
+    // noir-fmt:ignore
+    let  x  =
+                  1  ;
+
+    let  y  =
+                  2 ;
+
+    // noir-fmt:ignore
+    let  z  =
+                  3  ;
+}\n";
+        let expected = "fn foo() {
+    // noir-fmt:ignore
+    let  x  =
+                  1  ;
+
+    let y = 2;
+
+    // noir-fmt:ignore
+    let  z  =
+                  3  ;
+}\n";
+        assert_format(src, expected);
+    }
+
+    #[test]
+    fn attaches_semicolon_to_last_group_in_let_statement() {
+        let src = "fn foo() {
+    let x = foo(1, 2);
+}
+";
+        let expected = "fn foo() {
+    let x =
+        foo(1, 2);
+}
+";
+        assert_format_with_max_width(src, expected, "    let x = foo(1, 2);".len() - 1);
+    }
+
+    #[test]
+    fn attaches_semicolon_to_last_group_in_semi_statement() {
+        let src = "fn foo() {
+    foo(1, 2, 3, 4, 5);
+}
+";
+        let expected = "fn foo() {
+    foo(
+        1,
+        2,
+        3,
+        4,
+        5,
+    );
+}
+";
+        assert_format_with_max_width(src, expected, "    foo(1, 2, 3, 4, 5);".len() - 1);
+    }
+
+    #[test]
+    fn attaches_semicolon_to_last_group_in_assign() {
+        let src = "fn foo() {
+    a_long_variable = foo(1, 2);
+}
+";
+        let expected = "fn foo() {
+    a_long_variable =
+        foo(1, 2);
+}
+";
+        assert_format_with_max_width(src, expected, "    a_long_variable = foo(1, 2);".len() - 1);
+    }
+
+    #[test]
+    fn long_let_preceded_by_two_newlines() {
+        let src = "fn foo() {
+    let y = 0;
+
+    let x = 123456;
+}
+";
+        let expected = src;
+        assert_format_with_max_width(src, expected, "    let x = 123456;".len());
+    }
+}
diff --git a/tooling/nargo_fmt/src/formatter/structs.rs b/tooling/nargo_fmt/src/formatter/structs.rs
new file mode 100644
index 00000000000..c26ab552f30
--- /dev/null
+++ b/tooling/nargo_fmt/src/formatter/structs.rs
@@ -0,0 +1,198 @@
+use noirc_frontend::{
+    ast::NoirStruct,
+    token::{Keyword, Token},
+};
+
+use super::Formatter;
+use crate::chunks::ChunkGroup;
+
+impl<'a> Formatter<'a> {
+    pub(super) fn format_struct(&mut self, noir_struct: NoirStruct) {
+        self.format_secondary_attributes(noir_struct.attributes);
+        self.write_indentation();
+        self.format_item_visibility(noir_struct.visibility);
+        self.write_keyword(Keyword::Struct);
+        self.write_space();
+        self.write_identifier(noir_struct.name);
+        self.format_generics(noir_struct.generics);
+        self.skip_comments_and_whitespace();
+
+        // A case like `struct Foo;`
+        if self.is_at(Token::Semicolon) {
+            self.write_semicolon();
+            return;
+        }
+
+        // A case like `struct Foo { ... }`
+        self.write_space();
+        self.write_left_brace();
+
+        if noir_struct.fields.is_empty() {
+            self.format_empty_block_contents();
+        } else {
+            self.increase_indentation();
+            self.write_line();
+
+            for (index, documented_field) in noir_struct.fields.into_iter().enumerate() {
+                if index > 0 {
+                    self.write_comma();
+                    self.write_line();
+                }
+
+                let doc_comments = documented_field.doc_comments;
+                if !doc_comments.is_empty() {
+                    self.format_outer_doc_comments();
+                }
+
+                let field = documented_field.item;
+                self.write_indentation();
+                self.format_item_visibility(field.visibility);
+                self.write_identifier(field.name);
+                self.write_token(Token::Colon);
+                self.write_space();
+                self.format_type(field.typ);
+            }
+
+            // Take the comment chunk so we can put it after a trailing comma we add, in case there's no comma
+            let mut group = ChunkGroup::new();
+            let mut comments_and_whitespace_chunk =
+                self.chunk_formatter().skip_comments_and_whitespace_chunk();
+            comments_and_whitespace_chunk.string =
+                comments_and_whitespace_chunk.string.trim_end().to_string();
+            group.text(comments_and_whitespace_chunk);
+
+            if self.is_at(Token::Comma) {
+                self.bump();
+            }
+            self.write(",");
+
+            self.format_chunk_group(group);
+            self.skip_comments_and_whitespace();
+
+            self.decrease_indentation();
+            self.write_line();
+            self.write_indentation();
+        }
+
+        self.write_right_brace();
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use crate::assert_format;
+
+    #[test]
+    fn format_empty_struct_semicolon() {
+        let src = " mod moo { 
+    /// hello
+    #[foo] pub ( crate ) struct Foo  ; }";
+        let expected = "mod moo {
+    /// hello
+    #[foo]
+    pub(crate) struct Foo;
+}
+";
+        assert_format(src, expected);
+    }
+
+    #[test]
+    fn format_empty_struct_with_generics() {
+        let src = " mod moo { struct Foo < A, B, let N : u32  > ; }";
+        let expected = "mod moo {
+    struct Foo<A, B, let N: u32>;
+}
+";
+        assert_format(src, expected);
+    }
+
+    #[test]
+    fn format_struct_with_fields() {
+        let src = " mod moo { struct Foo { 
+// hello
+/// comment
+  pub field  : Field  ,
+  // comment
+pub another : ( ),
+        } }";
+        let expected = "mod moo {
+    struct Foo {
+        // hello
+        /// comment
+        pub field: Field,
+        // comment
+        pub another: (),
+    }
+}
+";
+        assert_format(src, expected);
+    }
+
+    #[test]
+    fn format_struct_with_multiple_newlines() {
+        let src = " mod moo { 
+
+
+    struct Foo { 
+
+
+x: Field  ,
+
+
+y: Field
+
+
+} 
+
+
+}";
+        let expected = "mod moo {
+
+    struct Foo {
+
+        x: Field,
+
+        y: Field,
+    }
+
+}
+";
+        assert_format(src, expected);
+    }
+
+    #[test]
+    fn format_two_structs() {
+        let src = " struct Foo { } struct Bar {}
+        ";
+        let expected = "struct Foo {}
+struct Bar {}
+";
+        assert_format(src, expected);
+    }
+
+    #[test]
+    fn format_struct_field_without_trailing_comma_but_comment() {
+        let src = "struct Foo {
+    field: Field // comment
+        }";
+        let expected = "struct Foo {
+    field: Field, // comment
+}
+";
+        assert_format(src, expected);
+    }
+
+    #[test]
+    fn format_comment_after_last_struct_field() {
+        let src = "struct Foo {
+    field: Field 
+    /* comment */
+        }";
+        let expected = "struct Foo {
+    field: Field,
+    /* comment */
+}
+";
+        assert_format(src, expected);
+    }
+}
diff --git a/tooling/nargo_fmt/src/formatter/trait_impl.rs b/tooling/nargo_fmt/src/formatter/trait_impl.rs
new file mode 100644
index 00000000000..b31da8a4101
--- /dev/null
+++ b/tooling/nargo_fmt/src/formatter/trait_impl.rs
@@ -0,0 +1,223 @@
+use noirc_frontend::{
+    ast::{
+        FunctionDefinition, ItemVisibility, NoirFunction, NoirTraitImpl, Pattern, TraitImplItem,
+        TraitImplItemKind,
+    },
+    token::{Keyword, Token},
+};
+
+use super::Formatter;
+
+impl<'a> Formatter<'a> {
+    pub(super) fn format_trait_impl(&mut self, trait_impl: NoirTraitImpl) {
+        // skip synthetic trait impl's, e.g. generated from trait aliases
+        if trait_impl.is_synthetic {
+            return;
+        }
+
+        let has_where_clause = !trait_impl.where_clause.is_empty();
+
+        self.write_indentation();
+        self.write_keyword(Keyword::Impl);
+        self.format_generics(trait_impl.impl_generics);
+        self.write_space();
+        self.format_path(trait_impl.trait_name);
+        self.format_generic_type_args(trait_impl.trait_generics);
+        self.write_space();
+        self.write_keyword(Keyword::For);
+        self.write_space();
+        self.format_type(trait_impl.object_type);
+
+        if has_where_clause {
+            self.format_where_clause(
+                trait_impl.where_clause,
+                true, // write trailing comma and newline
+            );
+        } else {
+            self.write_space();
+        }
+        self.write_left_brace();
+
+        if trait_impl.items.is_empty() {
+            self.format_empty_block_contents();
+        } else {
+            self.increase_indentation();
+            self.write_line();
+
+            for (index, documented_item) in trait_impl.items.into_iter().enumerate() {
+                if index > 0 {
+                    self.write_line();
+                }
+
+                let doc_comments = documented_item.doc_comments;
+                let item = documented_item.item;
+                if !doc_comments.is_empty() {
+                    self.format_outer_doc_comments();
+                }
+                self.format_trait_impl_item(item);
+            }
+
+            self.skip_comments_and_whitespace();
+            self.decrease_indentation();
+            self.write_line();
+            self.write_indentation();
+        }
+
+        self.write_right_brace();
+    }
+
+    fn format_trait_impl_item(&mut self, item: TraitImplItem) {
+        match item.kind {
+            TraitImplItemKind::Function(noir_function) => {
+                // Trait impl functions are public, but there's no `pub` keyword in the source code,
+                // so to format it we pass a private one.
+                let def =
+                    FunctionDefinition { visibility: ItemVisibility::Private, ..noir_function.def };
+                let noir_function = NoirFunction { def, ..noir_function };
+                self.format_function(noir_function);
+            }
+            TraitImplItemKind::Constant(name, typ, value) => {
+                let pattern = Pattern::Identifier(name);
+                let chunks = self.chunk_formatter().format_let_or_global(
+                    Keyword::Let,
+                    pattern,
+                    typ,
+                    Some(value),
+                    Vec::new(), // Attributes
+                );
+
+                self.write_indentation();
+                self.format_chunk_group(chunks);
+            }
+            TraitImplItemKind::Type { name, alias } => {
+                self.write_indentation();
+                self.write_keyword(Keyword::Type);
+                self.write_space();
+                self.write_identifier(name);
+                self.write_space();
+                self.write_token(Token::Assign);
+                self.write_space();
+                self.format_type(alias);
+                self.write_semicolon();
+            }
+        }
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use crate::assert_format;
+
+    #[test]
+    fn format_empty_trait_impl() {
+        let src = " mod moo { impl  Foo  for  Bar {  } }";
+        let expected = "mod moo {
+    impl Foo for Bar {}
+}
+";
+        assert_format(src, expected);
+    }
+
+    #[test]
+    fn format_empty_trait_impl_with_trait_generics() {
+        let src = " mod moo { impl  Foo < T >   for  Bar {  } }";
+        let expected = "mod moo {
+    impl Foo<T> for Bar {}
+}
+";
+        assert_format(src, expected);
+    }
+
+    #[test]
+    fn format_empty_trait_impl_with_impl_generics() {
+        let src = " mod moo { impl<T> Default for Option {
+} }";
+        let expected = "mod moo {
+    impl<T> Default for Option {}
+}
+";
+        assert_format(src, expected);
+    }
+
+    #[test]
+    fn format_empty_trait_impl_with_where_clause() {
+        let src = " mod moo { impl  Foo < T >   for  Bar  where  T : Baz {  } }";
+        let expected = "mod moo {
+    impl Foo<T> for Bar
+    where
+        T: Baz,
+    {}
+}
+";
+        assert_format(src, expected);
+    }
+
+    #[test]
+    fn format_empty_trait_impl_with_where_clause_with_trait_bound_generics() {
+        let src = "impl<T, U> Into<T> for U where T: From<U> { }";
+        let expected = "impl<T, U> Into<T> for U
+where
+    T: From<U>,
+{}
+";
+        assert_format(src, expected);
+    }
+
+    #[test]
+    fn format_trait_impl_function() {
+        let src = " mod moo { impl  Foo  for  Bar {  
+        /// Some doc comment
+fn foo ( ) { }
+         } }";
+        let expected = "mod moo {
+    impl Foo for Bar {
+        /// Some doc comment
+        fn foo() {}
+    }
+}
+";
+        assert_format(src, expected);
+    }
+
+    #[test]
+    fn format_trait_impl_constant_without_type() {
+        let src = " mod moo { impl  Foo  for  Bar {  
+            let X =42 ;
+         } }";
+        let expected = "mod moo {
+    impl Foo for Bar {
+        let X = 42;
+    }
+}
+";
+        assert_format(src, expected);
+    }
+
+    #[test]
+    fn format_trait_impl_constant_with_type() {
+        let src = " mod moo { impl  Foo  for  Bar {  
+            let X : i32=42 ;
+         } }";
+        let expected = "mod moo {
+    impl Foo for Bar {
+        let X: i32 = 42;
+    }
+}
+";
+        assert_format(src, expected);
+    }
+
+    #[test]
+    fn format_trait_impl_type() {
+        let src = " mod moo { impl  Foo  for  Bar {  
+            type  X  =  i32 ;
+         } }";
+        let expected = "mod moo {
+    impl Foo for Bar {
+        type X = i32;
+    }
+}
+";
+        assert_format(src, expected);
+    }
+}
diff --git a/tooling/nargo_fmt/src/formatter/traits.rs b/tooling/nargo_fmt/src/formatter/traits.rs
new file mode 100644
index 00000000000..1f192be471e
--- /dev/null
+++ b/tooling/nargo_fmt/src/formatter/traits.rs
@@ -0,0 +1,312 @@
+use noirc_frontend::{
+    ast::{NoirTrait, Param, Pattern, TraitItem, Visibility},
+    token::{Attributes, Keyword, Token},
+};
+
+use super::{function::FunctionToFormat, Formatter};
+
+impl<'a> Formatter<'a> {
+    pub(super) fn format_trait(&mut self, noir_trait: NoirTrait) {
+        self.format_secondary_attributes(noir_trait.attributes);
+        self.write_indentation();
+        self.format_item_visibility(noir_trait.visibility);
+        self.write_keyword(Keyword::Trait);
+        self.write_space();
+        self.write_identifier(noir_trait.name);
+        self.format_generics(noir_trait.generics);
+
+        if noir_trait.is_alias {
+            self.write_space();
+            self.write_token(Token::Assign);
+        }
+
+        if !noir_trait.bounds.is_empty() {
+            self.skip_comments_and_whitespace();
+
+            if !noir_trait.is_alias {
+                self.write_token(Token::Colon);
+            }
+
+            self.write_space();
+
+            for (index, trait_bound) in noir_trait.bounds.into_iter().enumerate() {
+                if index > 0 {
+                    self.write_space();
+                    self.write_token(Token::Plus);
+                    self.write_space();
+                }
+                self.format_trait_bound(trait_bound);
+            }
+        }
+
+        if !noir_trait.where_clause.is_empty() {
+            self.format_where_clause(noir_trait.where_clause, true);
+        }
+
+        // aliases have ';' in lieu of '{ items }'
+        if noir_trait.is_alias {
+            self.write_semicolon();
+            return;
+        }
+
+        self.write_space();
+        self.write_left_brace();
+        if noir_trait.items.is_empty() {
+            self.increase_indentation();
+            self.skip_comments_and_whitespace();
+            self.decrease_indentation();
+        } else {
+            self.increase_indentation();
+            self.write_line();
+
+            for (index, documented_item) in noir_trait.items.into_iter().enumerate() {
+                if index > 0 {
+                    self.write_line();
+                }
+
+                let doc_comments = documented_item.doc_comments;
+                let item = documented_item.item;
+                if !doc_comments.is_empty() {
+                    self.format_outer_doc_comments();
+                }
+                self.format_trait_item(item);
+            }
+
+            self.skip_comments_and_whitespace();
+            self.decrease_indentation();
+            self.write_line();
+            self.write_indentation();
+        }
+        self.write_right_brace();
+    }
+
+    fn format_trait_item(&mut self, item: TraitItem) {
+        match item {
+            TraitItem::Function {
+                is_unconstrained: _,
+                visibility,
+                is_comptime: _,
+                name,
+                generics,
+                parameters,
+                return_type,
+                where_clause,
+                body,
+            } => {
+                let parameters = parameters
+                    .into_iter()
+                    .map(|(name, typ)| Param {
+                        visibility: Visibility::Private,
+                        pattern: Pattern::Identifier(name),
+                        typ,
+                        span: Default::default(), // Doesn't matter
+                    })
+                    .collect();
+
+                let func = FunctionToFormat {
+                    attributes: Attributes::empty(),
+                    visibility,
+                    name,
+                    generics,
+                    parameters,
+                    return_type,
+                    return_visibility: Visibility::Private,
+                    where_clause,
+                    body,
+                };
+                self.format_function_impl(func);
+            }
+            TraitItem::Constant { name, typ, default_value } => {
+                let pattern = Pattern::Identifier(name);
+                let chunks = self.chunk_formatter().format_let_or_global(
+                    Keyword::Let,
+                    pattern,
+                    typ,
+                    default_value,
+                    Vec::new(), // Attributes
+                );
+                self.write_indentation();
+                self.format_chunk_group(chunks);
+            }
+            TraitItem::Type { name } => {
+                self.write_indentation();
+                self.write_keyword(Keyword::Type);
+                self.write_space();
+                self.write_identifier(name);
+                self.write_semicolon();
+            }
+        }
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use crate::assert_format;
+
+    #[test]
+    fn format_empty_trait() {
+        let src = " mod moo { /// Comment
+        pub  trait Foo {  } }";
+        let expected = "mod moo {
+    /// Comment
+    pub trait Foo {}
+}
+";
+        assert_format(src, expected);
+    }
+
+    #[test]
+    fn format_empty_trait_with_generics() {
+        let src = " mod moo { trait Foo < A, B, > {  } }";
+        let expected = "mod moo {
+    trait Foo<A, B> {}
+}
+";
+        assert_format(src, expected);
+    }
+
+    #[test]
+    fn format_trait_with_parents() {
+        let src = " mod moo { trait Foo : Bar  +  Baz {  } }";
+        let expected = "mod moo {
+    trait Foo: Bar + Baz {}
+}
+";
+        assert_format(src, expected);
+    }
+
+    #[test]
+    fn format_trait_with_where_clause() {
+        let src = " mod moo { trait Foo < T >  where  T : Bar {  } }";
+        let expected = "mod moo {
+    trait Foo<T>
+    where
+        T: Bar,
+    {}
+}
+";
+        assert_format(src, expected);
+    }
+
+    #[test]
+    fn format_trait_with_type() {
+        let src = " mod moo { trait Foo { 
+    /// hello
+            type X;
+         } }";
+        let expected = "mod moo {
+    trait Foo {
+        /// hello
+        type X;
+    }
+}
+";
+        assert_format(src, expected);
+    }
+
+    #[test]
+    fn format_trait_with_constant_no_value() {
+        let src = " mod moo { trait Foo { 
+            let  x  : i32 ;
+         } }";
+        let expected = "mod moo {
+    trait Foo {
+        let x: i32;
+    }
+}
+";
+        assert_format(src, expected);
+    }
+
+    #[test]
+    fn format_trait_with_constant_with_value() {
+        let src = " mod moo { trait Foo { 
+            let  x  : i32  =  1 ;
+         } }";
+        let expected = "mod moo {
+    trait Foo {
+        let x: i32 = 1;
+    }
+}
+";
+        assert_format(src, expected);
+    }
+
+    #[test]
+    fn format_trait_with_function_without_body() {
+        let src = " mod moo { trait Foo { 
+    /// hello 
+            pub  fn  foo ( );
+         } }";
+        let expected = "mod moo {
+    trait Foo {
+        /// hello
+        pub fn foo();
+    }
+}
+";
+        assert_format(src, expected);
+    }
+
+    #[test]
+    fn format_trait_with_function_with_body() {
+        let src = " mod moo { trait Foo { 
+    /// hello 
+            pub  fn  foo ( ) { 1 }
+         } }";
+        let expected = "mod moo {
+    trait Foo {
+        /// hello
+        pub fn foo() {
+            1
+        }
+    }
+}
+";
+        assert_format(src, expected);
+    }
+
+    #[test]
+    fn format_trait_with_function_with_params() {
+        let src = " mod moo { trait Foo { 
+    /// hello 
+            pub  fn  foo ( x : i32 , y : Field );
+         } }";
+        let expected = "mod moo {
+    trait Foo {
+        /// hello
+        pub fn foo(x: i32, y: Field);
+    }
+}
+";
+        assert_format(src, expected);
+    }
+
+    #[test]
+    fn format_trait_with_function_with_where_clause() {
+        let src = " mod moo { trait Foo { 
+            fn  foo<T> () where  T : Bar;
+         } }";
+        let expected = "mod moo {
+    trait Foo {
+        fn foo<T>()
+        where
+            T: Bar;
+    }
+}
+";
+        assert_format(src, expected);
+    }
+
+    #[test]
+    fn format_multiple_traits() {
+        let src = " trait Foo {}
+
+        trait Bar {}";
+        let expected = "trait Foo {}
+
+trait Bar {}
+";
+        assert_format(src, expected);
+    }
+}
diff --git a/tooling/nargo_fmt/src/formatter/type_expression.rs b/tooling/nargo_fmt/src/formatter/type_expression.rs
new file mode 100644
index 00000000000..95b0c045156
--- /dev/null
+++ b/tooling/nargo_fmt/src/formatter/type_expression.rs
@@ -0,0 +1,38 @@
+use noirc_frontend::{ast::UnresolvedTypeExpression, token::Token};
+
+use super::Formatter;
+
+impl<'a> Formatter<'a> {
+    pub(super) fn format_type_expression(&mut self, type_expr: UnresolvedTypeExpression) {
+        self.skip_comments_and_whitespace();
+
+        // Parenthesized type expressions exist but are not represented in the AST
+        while let Token::LeftParen = self.token {
+            self.write_left_paren();
+        }
+
+        match type_expr {
+            UnresolvedTypeExpression::Variable(path) => self.format_path(path),
+            UnresolvedTypeExpression::Constant(..) => {
+                self.write_current_token_and_bump();
+            }
+            UnresolvedTypeExpression::BinaryOperation(lhs, _operator, rhs, _span) => {
+                self.format_type_expression(*lhs);
+                self.write_space();
+                self.write_current_token_and_bump();
+                self.write_space();
+                self.format_type_expression(*rhs);
+            }
+            UnresolvedTypeExpression::AsTraitPath(..) => {
+                unreachable!("Should not be present in the AST")
+            }
+        }
+
+        self.skip_comments_and_whitespace();
+
+        // Parenthesized type expressions exist but are not represented in the AST
+        while let Token::RightParen = self.token {
+            self.write_right_paren();
+        }
+    }
+}
diff --git a/tooling/nargo_fmt/src/formatter/types.rs b/tooling/nargo_fmt/src/formatter/types.rs
new file mode 100644
index 00000000000..e52704ddaa7
--- /dev/null
+++ b/tooling/nargo_fmt/src/formatter/types.rs
@@ -0,0 +1,353 @@
+use noirc_frontend::{
+    ast::{AsTraitPath, UnresolvedType, UnresolvedTypeData},
+    token::{Keyword, Token},
+};
+
+use super::Formatter;
+
+impl<'a> Formatter<'a> {
+    pub(super) fn format_type(&mut self, typ: UnresolvedType) {
+        self.skip_comments_and_whitespace();
+
+        match typ.typ {
+            UnresolvedTypeData::Unit => {
+                self.write_left_paren();
+                self.write_right_paren();
+            }
+            UnresolvedTypeData::Bool => {
+                self.write_keyword(Keyword::Bool);
+            }
+            UnresolvedTypeData::Integer(..) | UnresolvedTypeData::FieldElement => {
+                self.write_current_token_and_bump();
+            }
+            UnresolvedTypeData::Array(type_expr, typ) => {
+                self.write_left_bracket();
+                self.format_type(*typ);
+                self.write_semicolon();
+                self.write_space();
+                self.format_type_expression(type_expr);
+                self.write_right_bracket();
+            }
+            UnresolvedTypeData::Slice(typ) => {
+                self.write_left_bracket();
+                self.format_type(*typ);
+                self.write_right_bracket();
+            }
+            UnresolvedTypeData::Expression(type_expr) => {
+                self.format_type_expression(type_expr);
+            }
+            UnresolvedTypeData::String(type_expr) => {
+                self.write_keyword(Keyword::String);
+                self.write_token(Token::Less);
+                self.format_type_expression(type_expr);
+                self.write_token(Token::Greater);
+            }
+            UnresolvedTypeData::FormatString(type_expr, typ) => {
+                self.write_keyword(Keyword::FormatString);
+                self.write_token(Token::Less);
+                self.format_type_expression(type_expr);
+                self.write_comma();
+                self.write_space();
+                self.format_type(*typ);
+                self.write_token(Token::Greater);
+            }
+            UnresolvedTypeData::Parenthesized(typ) => {
+                self.write_left_paren();
+                self.format_type(*typ);
+                self.write_right_paren();
+            }
+            UnresolvedTypeData::Named(path, generic_type_args, _) => {
+                self.format_path(path);
+                if !generic_type_args.is_empty() {
+                    self.skip_comments_and_whitespace();
+
+                    // Apparently some Named types with generics have `::` before the generics
+                    // while others don't, so we have to account for both cases.
+                    if self.is_at(Token::DoubleColon) {
+                        self.write_token(Token::DoubleColon);
+                    }
+                    self.format_generic_type_args(generic_type_args);
+                }
+            }
+            UnresolvedTypeData::TraitAsType(path, generic_type_args) => {
+                self.write_keyword(Keyword::Impl);
+                self.write_space();
+                self.format_path(path);
+                self.format_generic_type_args(generic_type_args);
+            }
+            UnresolvedTypeData::MutableReference(typ) => {
+                self.write_token(Token::Ampersand);
+                self.write_keyword(Keyword::Mut);
+                self.write_space();
+                self.format_type(*typ);
+            }
+            UnresolvedTypeData::Tuple(types) => {
+                let types_len = types.len();
+
+                self.write_left_paren();
+                for (index, typ) in types.into_iter().enumerate() {
+                    if index > 0 {
+                        self.write_comma();
+                        self.write_space();
+                    }
+                    self.format_type(typ);
+                }
+
+                self.skip_comments_and_whitespace();
+                if self.is_at(Token::Comma) {
+                    if types_len == 1 {
+                        self.write_comma();
+                    } else {
+                        self.bump();
+                    }
+                }
+
+                self.write_right_paren();
+            }
+            UnresolvedTypeData::Function(args, return_type, env, unconstrained) => {
+                if unconstrained {
+                    self.write_keyword(Keyword::Unconstrained);
+                    self.write_space();
+                }
+
+                self.write_keyword(Keyword::Fn);
+                self.skip_comments_and_whitespace();
+
+                if self.is_at(Token::LeftBracket) {
+                    self.write_left_bracket();
+                    self.format_type(*env);
+                    self.write_right_bracket();
+                }
+
+                self.write_left_paren();
+                for (index, arg) in args.into_iter().enumerate() {
+                    if index > 0 {
+                        self.write_comma();
+                        self.write_space();
+                    }
+                    self.format_type(arg);
+                }
+
+                self.skip_comments_and_whitespace();
+                // Remove trailing comma if there's one
+                if self.is_at(Token::Comma) {
+                    self.bump();
+                }
+
+                self.write_right_paren();
+                self.skip_comments_and_whitespace();
+                if self.is_at(Token::Arrow) {
+                    self.write_space();
+                    self.write_token(Token::Arrow);
+                    self.write_space();
+                    self.format_type(*return_type);
+                }
+            }
+            UnresolvedTypeData::Quoted(..) => {
+                self.write_current_token_and_bump();
+            }
+            UnresolvedTypeData::AsTraitPath(as_trait_path) => {
+                self.format_as_trait_path(*as_trait_path);
+            }
+            UnresolvedTypeData::Resolved(..)
+            | UnresolvedTypeData::Interned(..)
+            | UnresolvedTypeData::Error => unreachable!("Should not be present in the AST"),
+            UnresolvedTypeData::Unspecified => panic!("Unspecified type should have been handled"),
+        }
+    }
+
+    pub(super) fn format_as_trait_path(&mut self, as_trait_path: AsTraitPath) {
+        self.write_token(Token::Less);
+        self.format_type(as_trait_path.typ);
+        self.write_space();
+        self.write_keyword(Keyword::As);
+        self.write_space();
+        self.format_path(as_trait_path.trait_path);
+        self.format_generic_type_args(as_trait_path.trait_generics);
+        self.write_token(Token::Greater);
+        self.write_token(Token::DoubleColon);
+        self.write_identifier(as_trait_path.impl_item);
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use noirc_frontend::parser;
+
+    use crate::Config;
+
+    fn assert_format_type(src: &str, expected: &str) {
+        let module_src = format!("type X = {};", src);
+        let (parsed_module, errors) = parser::parse_program(&module_src);
+        if !errors.is_empty() {
+            panic!("Expected no errors, got: {:?}", errors);
+        }
+        let result = crate::format(&module_src, parsed_module, &Config::default());
+        let type_result = &result["type X = ".len()..];
+        let type_result = &type_result[..type_result.len() - 2];
+        similar_asserts::assert_eq!(type_result, expected);
+
+        let (parsed_module, errors) = parser::parse_program(&result);
+        if !errors.is_empty() {
+            panic!("Expected no errors in idempotent check, got: {:?}", errors);
+        }
+        let result = crate::format(&result, parsed_module, &Config::default());
+        let type_result = &result["type X = ".len()..];
+        let type_result = &type_result[..type_result.len() - 2];
+        similar_asserts::assert_eq!(type_result, expected);
+    }
+
+    #[test]
+    fn format_unit_type() {
+        let src = " ( ) ";
+        let expected = "()";
+        assert_format_type(src, expected);
+    }
+
+    #[test]
+    fn format_bool_type() {
+        let src = " bool ";
+        let expected = "bool";
+        assert_format_type(src, expected);
+    }
+
+    #[test]
+    fn format_integer_type() {
+        let src = " i32 ";
+        let expected = "i32";
+        assert_format_type(src, expected);
+    }
+
+    #[test]
+    fn format_named_type() {
+        let src = " foo :: bar :: Baz ";
+        let expected = "foo::bar::Baz";
+        assert_format_type(src, expected);
+    }
+
+    #[test]
+    fn format_named_type_with_generics() {
+        let src = " foo :: bar < A,  B  =  Field , C = i32 , D , >";
+        let expected = "foo::bar<A, B = Field, C = i32, D>";
+        assert_format_type(src, expected);
+    }
+
+    #[test]
+    fn format_array_type_with_constant() {
+        let src = " [ Field ; 1 ] ";
+        let expected = "[Field; 1]";
+        assert_format_type(src, expected);
+    }
+
+    #[test]
+    fn format_array_type_with_var() {
+        let src = " [ Field ; LEN ] ";
+        let expected = "[Field; LEN]";
+        assert_format_type(src, expected);
+    }
+
+    #[test]
+    fn format_array_type_with_binary() {
+        let src = " [ Field ; 1+2 ] ";
+        let expected = "[Field; 1 + 2]";
+        assert_format_type(src, expected);
+    }
+
+    #[test]
+    fn format_array_type_with_parenthesized() {
+        let src = " [ Field ; ( 1 + 2 ) * ( 3 + 4 )  ] ";
+        let expected = "[Field; (1 + 2) * (3 + 4)]";
+        assert_format_type(src, expected);
+    }
+
+    #[test]
+    fn format_slice_type() {
+        let src = " [ Field  ] ";
+        let expected = "[Field]";
+        assert_format_type(src, expected);
+    }
+
+    #[test]
+    fn format_mutable_reference_type() {
+        let src = " &  mut  Field ";
+        let expected = "&mut Field";
+        assert_format_type(src, expected);
+    }
+
+    #[test]
+    fn format_parenthesized_type() {
+        let src = " ( Field )";
+        let expected = "(Field)";
+        assert_format_type(src, expected);
+    }
+
+    #[test]
+    fn format_simple_function_type() {
+        let src = " fn ( ) -> Field ";
+        let expected = "fn() -> Field";
+        assert_format_type(src, expected);
+    }
+
+    #[test]
+    fn format_function_type_with_args_and_unconstrained() {
+        let src = "  unconstrained  fn  (  Field , i32 , ) -> Field ";
+        let expected = "unconstrained fn(Field, i32) -> Field";
+        assert_format_type(src, expected);
+    }
+
+    #[test]
+    fn format_function_type_with_env() {
+        let src = "  fn  [ Env ] ( ) -> Field ";
+        let expected = "fn[Env]() -> Field";
+        assert_format_type(src, expected);
+    }
+
+    #[test]
+    fn format_tuple_type_one_type() {
+        let src = " ( Field , )";
+        let expected = "(Field,)";
+        assert_format_type(src, expected);
+    }
+
+    #[test]
+    fn format_tuple_type_two_types() {
+        let src = " ( Field ,  i32 , )";
+        let expected = "(Field, i32)";
+        assert_format_type(src, expected);
+    }
+
+    #[test]
+    fn format_trait_as_type() {
+        let src = " impl Foo < Bar > ";
+        let expected = "impl Foo<Bar>";
+        assert_format_type(src, expected);
+    }
+
+    #[test]
+    fn format_string_type() {
+        let src = "str < 6 >";
+        let expected = "str<6>";
+        assert_format_type(src, expected);
+    }
+
+    #[test]
+    fn format_fmtstr_type() {
+        let src = "fmtstr < 6, ( ) >";
+        let expected = "fmtstr<6, ()>";
+        assert_format_type(src, expected);
+    }
+
+    #[test]
+    fn format_quoted_type() {
+        let src = " Expr ";
+        let expected = "Expr";
+        assert_format_type(src, expected);
+    }
+
+    #[test]
+    fn format_as_trait_path_type() {
+        let src = " < Field as foo :: Bar> :: baz ";
+        let expected = "<Field as foo::Bar>::baz";
+        assert_format_type(src, expected);
+    }
+}
diff --git a/tooling/nargo_fmt/src/formatter/use_tree.rs b/tooling/nargo_fmt/src/formatter/use_tree.rs
new file mode 100644
index 00000000000..98d63ef6611
--- /dev/null
+++ b/tooling/nargo_fmt/src/formatter/use_tree.rs
@@ -0,0 +1,263 @@
+use noirc_frontend::{
+    ast::{ItemVisibility, UseTree, UseTreeKind},
+    token::{Keyword, Token},
+};
+
+use crate::chunks::{Chunk, ChunkFormatter, ChunkGroup};
+
+use super::Formatter;
+
+impl<'a> Formatter<'a> {
+    pub(super) fn format_import(&mut self, use_tree: UseTree, visibility: ItemVisibility) {
+        let group = self.chunk_formatter().format_import(use_tree, visibility);
+
+        self.write_indentation();
+        self.format_chunk_group(group);
+    }
+}
+
+impl<'a, 'b> ChunkFormatter<'a, 'b> {
+    pub(super) fn format_import(
+        &mut self,
+        use_tree: UseTree,
+        visibility: ItemVisibility,
+    ) -> ChunkGroup {
+        let mut group = ChunkGroup::new();
+
+        group.text(self.chunk(|formatter| {
+            formatter.format_item_visibility(visibility);
+            formatter.write_keyword(Keyword::Use);
+            formatter.write_space();
+        }));
+
+        group.group(self.format_use_tree(use_tree));
+        group.semicolon(self);
+
+        group
+    }
+
+    fn format_use_tree(&mut self, use_tree: UseTree) -> ChunkGroup {
+        let mut group = ChunkGroup::new();
+        group.one_chunk_per_line = false;
+
+        if !use_tree.prefix.is_empty() {
+            group.text(self.chunk(|formatter| {
+                let has_segments = !use_tree.prefix.segments.is_empty();
+
+                formatter.format_path(use_tree.prefix);
+
+                // If the path has segments, like in `foo` or `crate::foo`, we need to add a double colon.
+                // But for example for `crate::` we don't need to add a double colon (there are no segments
+                // and `crate::` was already written).
+                if has_segments {
+                    formatter.write_token(Token::DoubleColon);
+                }
+            }));
+        }
+
+        match use_tree.kind {
+            UseTreeKind::Path(name, alias) => {
+                group.text(self.chunk(|formatter| {
+                    formatter.write_identifier(name);
+                    if let Some(alias) = alias {
+                        formatter.write_space();
+                        formatter.write_keyword(Keyword::As);
+                        formatter.write_space();
+                        formatter.write_identifier(alias);
+                    }
+                }));
+            }
+            UseTreeKind::List(use_trees) => {
+                // We check if there are nested lists. If yes, then each item will be on a separate line
+                // (it reads better, and this is what rustfmt seems to do too)
+                let has_nested_list =
+                    use_trees.iter().any(|use_tree| matches!(use_tree.kind, UseTreeKind::List(..)));
+
+                let use_trees_len = use_trees.len();
+
+                let left_brace_chunk = self.chunk(|formatter| {
+                    formatter.write_left_brace();
+                });
+
+                let comments_count_before = self.written_comments_count;
+
+                let mut items_chunk = ChunkGroup::new();
+                self.format_items_separated_by_comma(
+                    use_trees,
+                    false, // force trailing comma
+                    false, // surround with spaces
+                    &mut items_chunk,
+                    |formatter, use_tree, chunks| chunks.group(formatter.format_use_tree(use_tree)),
+                );
+
+                let wrote_comment = self.written_comments_count > comments_count_before;
+
+                let right_brace_chunk = self.chunk(|formatter| {
+                    formatter.write_right_brace();
+                });
+
+                if use_trees_len == 1 && !wrote_comment {
+                    // We are only interested in keeping the single Group: everything else
+                    // is lines, indentation and trailing comma that we don't need and would
+                    // actually produce incorrect code.
+                    let single_group =
+                        items_chunk.chunks.into_iter().filter_map(Chunk::group).next().unwrap();
+                    group.chunks.extend(single_group.chunks);
+                } else {
+                    if has_nested_list {
+                        group.one_chunk_per_line = true;
+                    }
+
+                    group.text(left_brace_chunk);
+                    group.chunks.extend(items_chunk.chunks);
+                    group.text(right_brace_chunk);
+                }
+            }
+        }
+
+        group
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use crate::{assert_format_with_config, config::ImportsGranularity, Config};
+
+    fn assert_format(src: &str, expected: &str) {
+        let config = Config {
+            imports_granularity: ImportsGranularity::Preserve,
+            reorder_imports: false,
+            ..Config::default()
+        };
+        assert_format_with_config(src, expected, config);
+    }
+
+    fn assert_format_with_max_width(src: &str, expected: &str, max_width: usize) {
+        let config = Config {
+            imports_granularity: ImportsGranularity::Preserve,
+            reorder_imports: false,
+            max_width,
+            ..Config::default()
+        };
+        assert_format_with_config(src, expected, config);
+    }
+
+    #[test]
+    fn format_simple_use_without_alias() {
+        let src = " mod moo {  pub  use  foo ;  }";
+        let expected = "mod moo {
+    pub use foo;
+}
+";
+        assert_format(src, expected);
+    }
+
+    #[test]
+    fn format_simple_use_with_alias() {
+        let src = " mod moo {  use  foo :: bar   as   baz ;  }";
+        let expected = "mod moo {
+    use foo::bar as baz;
+}
+";
+        assert_format(src, expected);
+    }
+
+    #[test]
+    fn format_simple_use_with_path_kind() {
+        let src = "use  super :: foo ;";
+        let expected = "use super::foo;\n";
+        assert_format(src, expected);
+    }
+
+    #[test]
+    fn format_use_list_two_items() {
+        let src = " use foo::{ bar,  baz  };";
+        let expected = "use foo::{bar, baz};\n";
+        assert_format(src, expected);
+    }
+
+    #[test]
+    fn format_use_trees_with_max_width() {
+        let src = " use foo::{ bar,  baz , qux , one::{two, three} };";
+        let expected = "use foo::{
+    bar,
+    baz,
+    qux,
+    one::{
+        two, three,
+    },
+};
+";
+        assert_format_with_max_width(src, expected, 20);
+    }
+
+    #[test]
+    fn format_use_list_one_item() {
+        let src = " use foo::{  bar,  };";
+        let expected = "use foo::bar;\n";
+        assert_format(src, expected);
+    }
+
+    #[test]
+    fn format_long_use_list_one_item() {
+        let src = "use one::two::{three::{four, five}};";
+        let expected = "use one::two::three::{
+    four, five,
+};
+";
+        assert_format_with_max_width(src, expected, 25);
+    }
+
+    #[test]
+    fn format_use_list_one_item_with_comments() {
+        let src = " use foo::{  /* do not remove me */ bar,  };";
+        let expected = "use foo::{/* do not remove me */ bar};\n";
+        assert_format(src, expected);
+    }
+
+    #[test]
+    fn format_use_crate_with_list() {
+        let src = " use crate :: hash :: { Hash, Hasher };  ";
+        let expected = "use crate::hash::{Hash, Hasher};\n";
+        assert_format(src, expected);
+    }
+
+    #[test]
+    fn attaches_semicolon_to_last_group() {
+        let src = " use crate::hash::{Hash, Hasher};  ";
+        let expected = "use crate::hash::{
+    Hash, Hasher,
+};
+";
+        assert_format_with_max_width(src, expected, "use crate::hash::{Hash, Hasher}".len());
+    }
+
+    #[test]
+    fn do_not_merge_and_sort_imports() {
+        let src = "
+use aztec::{
+    context::Context, log::emit_unencrypted_log, note::{
+        note_getter_options::NoteGetterOptions, note_header::NoteHeader,
+    }, state_vars::{
+        Map, PrivateSet, PublicMutable,
+    }, types::{
+        address::AztecAddress, type_serialization::field_serialization::{
+            FIELD_SERIALIZED_LEN, FieldSerializationMethods,
+        },
+    },
+};
+        ";
+        let expected = "use aztec::{
+    context::Context,
+    log::emit_unencrypted_log,
+    note::{note_getter_options::NoteGetterOptions, note_header::NoteHeader},
+    state_vars::{Map, PrivateSet, PublicMutable},
+    types::{
+        address::AztecAddress,
+        type_serialization::field_serialization::{FIELD_SERIALIZED_LEN, FieldSerializationMethods},
+    },
+};
+";
+        assert_format(src, expected);
+    }
+}
diff --git a/tooling/nargo_fmt/src/formatter/use_tree_merge.rs b/tooling/nargo_fmt/src/formatter/use_tree_merge.rs
new file mode 100644
index 00000000000..834280ddba3
--- /dev/null
+++ b/tooling/nargo_fmt/src/formatter/use_tree_merge.rs
@@ -0,0 +1,627 @@
+use std::{
+    cmp::Ordering,
+    collections::BTreeMap,
+    fmt::{self, Display},
+};
+
+use noirc_frontend::ast::{ItemVisibility, PathKind, UseTree, UseTreeKind};
+
+use crate::{
+    chunks::{ChunkGroup, TextChunk},
+    config::ImportsGranularity,
+};
+
+use super::Formatter;
+
+impl<'a> Formatter<'a> {
+    pub(super) fn merge_and_format_imports(
+        &mut self,
+        imports: Vec<UseTree>,
+        visibility: ItemVisibility,
+    ) {
+        match self.config.imports_granularity {
+            ImportsGranularity::Preserve => {
+                let mut import_trees: Vec<ImportTree> =
+                    imports.into_iter().map(|import| merge_imports(vec![import])).collect();
+                import_trees.sort();
+
+                for (index, import_tree) in import_trees.into_iter().enumerate() {
+                    if index > 0 {
+                        self.write_line_without_skipping_whitespace_and_comments();
+                    }
+
+                    self.format_import_tree(import_tree, visibility);
+                }
+            }
+            ImportsGranularity::Crate => {
+                let import_tree = merge_imports(imports);
+                self.format_import_tree(import_tree, visibility);
+            }
+        }
+    }
+
+    fn format_import_tree(&mut self, import_tree: ImportTree, visibility: ItemVisibility) {
+        for (index, (segment, segment_tree)) in import_tree.tree.into_iter().enumerate() {
+            if index > 0 {
+                self.write_line_without_skipping_whitespace_and_comments();
+            }
+
+            let tree = ImportTree::single(segment, *segment_tree);
+            let tree = tree.simplify();
+
+            let group = format_merged_import_with_visibility(tree, visibility);
+            self.write_indentation();
+            self.format_chunk_group(group);
+        }
+    }
+}
+
+// The logic here is similar to that of `use_tree.rs`, except that it works with ImportTree
+// instead of UseTree and we never check or advance the lexer.
+
+fn format_merged_import_with_visibility(
+    mut import_tree: ImportTree,
+    visibility: ItemVisibility,
+) -> ChunkGroup {
+    let mut group = ChunkGroup::new();
+    match visibility {
+        ItemVisibility::Private => (),
+        ItemVisibility::PublicCrate => {
+            group.text(TextChunk::new("pub(crate) ".to_string()));
+        }
+        ItemVisibility::Public => {
+            group.text(TextChunk::new("pub ".to_string()));
+        }
+    }
+    group.text(TextChunk::new("use ".to_string()));
+
+    let (segment, tree) = import_tree.tree.pop_first().unwrap();
+    assert!(import_tree.tree.is_empty());
+
+    group.group(format_merged_import(segment, *tree));
+    group.text_attached_to_last_group(TextChunk::new(";".to_string()));
+    group
+}
+
+fn format_merged_import(segment: Segment, import_tree: ImportTree) -> ChunkGroup {
+    let mut group = ChunkGroup::new();
+
+    group.text(TextChunk::new(segment.to_string()));
+
+    if import_tree.tree.is_empty() {
+        return group;
+    }
+
+    // We check if there are nested lists. If yes, then each item will be on a separate line
+    // (it reads better, and this is what rustfmt seems to do too)
+    if import_tree.tree.values().all(|tree| tree.tree.is_empty()) {
+        group.one_chunk_per_line = false;
+    }
+
+    group.text(TextChunk::new("::{".to_string()));
+    group.increase_indentation();
+    group.line();
+
+    for (index, (segment, import_tree)) in import_tree.tree.into_iter().enumerate() {
+        if index > 0 {
+            group.text_attached_to_last_group(TextChunk::new(",".to_string()));
+            group.space_or_line();
+        }
+
+        group.group(format_merged_import(segment, *import_tree));
+    }
+
+    group.trailing_comma();
+    group.decrease_indentation();
+    group.line();
+    group.text(TextChunk::new("}".to_string()));
+
+    group
+}
+
+/// We keep Crate, Super and Dep as special segments so that they are ordered in that way
+/// (they'll come in that order before any plain segment).
+#[derive(Debug, PartialEq, Eq)]
+enum Segment {
+    /// Represents the end of a path.
+    /// This is needed because we have want to merge "foo" and "foo::bar",
+    /// we need to know that "foo" is the end of a path, and "foo::bar" is another one.
+    /// If we don't, merging "foo" and "foo::bar" will result in just "foo::bar", loosing "foo",
+    /// when we actually want "foo::{self, bar}".
+    SelfReference,
+    Crate,
+    Super,
+    Dep,
+    Plain(String),
+}
+
+impl Segment {
+    /// Combines two segments into a single one, by joining them with "::".
+    fn combine(self, other: Segment) -> Segment {
+        if other == Segment::SelfReference {
+            self
+        } else {
+            Segment::Plain(format!("{}::{}", self, other))
+        }
+    }
+
+    fn order_number(&self) -> usize {
+        match self {
+            Segment::SelfReference => 0,
+            Segment::Crate => 1,
+            Segment::Super => 2,
+            Segment::Dep => 3,
+            Segment::Plain(_) => 4,
+        }
+    }
+}
+
+impl Display for Segment {
+    fn fmt(&self, f: &mut std::fmt::Formatter) -> fmt::Result {
+        match self {
+            Segment::Crate => write!(f, "crate"),
+            Segment::Super => write!(f, "super"),
+            Segment::Dep => write!(f, "dep"),
+            Segment::Plain(s) => write!(f, "{}", s),
+            Segment::SelfReference => write!(f, "self"),
+        }
+    }
+}
+
+impl PartialOrd for Segment {
+    fn partial_cmp(&self, other: &Self) -> Option<Ordering> {
+        Some(self.cmp(other))
+    }
+}
+
+impl Ord for Segment {
+    fn cmp(&self, other: &Self) -> Ordering {
+        let order_number_ordering = self.order_number().cmp(&other.order_number());
+        if order_number_ordering != Ordering::Equal {
+            return order_number_ordering;
+        }
+
+        if let (Segment::Plain(self_string), Segment::Plain(other_string)) = (self, other) {
+            // Case-insensitive comparison for plain segments
+            self_string.to_lowercase().cmp(&other_string.to_lowercase())
+        } else {
+            order_number_ordering
+        }
+    }
+}
+
+/// An import tree to represent merged imports.
+/// For example for the given imports:
+///
+/// use foo::bar::{baz, qux};
+/// use foo::another;
+///
+/// an ImportTree that represents the merged imports would be:
+///
+/// {
+///     "foo" => {
+///         "another" => {}
+///         "bar" => {"baz", "qux"},
+///     }
+/// }
+#[derive(Debug, Default, PartialEq, Eq, PartialOrd, Ord)]
+struct ImportTree {
+    tree: BTreeMap<Segment, Box<ImportTree>>,
+}
+
+impl ImportTree {
+    fn new() -> Self {
+        Self { tree: BTreeMap::new() }
+    }
+
+    /// Creates an import tree that has `segment` as the only element with `tree` as its value.
+    fn single(segment: Segment, tree: ImportTree) -> Self {
+        let mut tree_map = BTreeMap::new();
+        tree_map.insert(segment, Box::new(tree));
+        Self { tree: tree_map }
+    }
+
+    /// Inserts a segment to the tree, creating the necessary empty children if they don't exist yet.
+    fn insert(&mut self, segment: Segment) -> &mut ImportTree {
+        self.tree.entry(segment).or_default()
+    }
+
+    /// Simplifies a tree by combining segments that only have one child.
+    ///
+    /// For example, this tree:
+    ///
+    /// {
+    ///     "foo" => {
+    ///         "bar" => {"baz", "qux"}
+    ///     }
+    /// }
+    ///
+    /// will be simplified to:
+    ///
+    /// {
+    ///     "foo::bar" => {"baz", "qux"}
+    /// }
+    fn simplify(self) -> ImportTree {
+        let mut new_tree = ImportTree::new();
+        for (segment, tree) in self.tree.into_iter() {
+            let mut tree = tree.simplify();
+            if tree.tree.len() == 1 {
+                let (first_segment, first_tree) = tree.tree.pop_first().unwrap();
+                let new_segment = segment.combine(first_segment);
+                new_tree.tree.insert(new_segment, first_tree);
+            } else {
+                new_tree.tree.insert(segment, Box::new(tree));
+            }
+        }
+        new_tree
+    }
+}
+
+/// Combines all use trees to form a single ImportTree.
+fn merge_imports(imports: Vec<UseTree>) -> ImportTree {
+    let mut tree = ImportTree::new();
+    merge_imports_in_tree(imports, &mut tree);
+    tree
+}
+
+fn merge_imports_in_tree(imports: Vec<UseTree>, mut tree: &mut ImportTree) {
+    for import in imports {
+        let mut tree = match import.prefix.kind {
+            PathKind::Crate => tree.insert(Segment::Crate),
+            PathKind::Super => tree.insert(Segment::Super),
+            PathKind::Dep => tree.insert(Segment::Dep),
+            PathKind::Plain => &mut tree,
+        };
+
+        for segment in import.prefix.segments {
+            tree = tree.insert(Segment::Plain(segment.ident.to_string()));
+        }
+
+        match import.kind {
+            UseTreeKind::Path(ident, alias) => {
+                if let Some(alias) = alias {
+                    tree = tree.insert(Segment::Plain(format!("{} as {}", ident, alias)));
+                    tree.insert(Segment::SelfReference);
+                } else if ident.0.contents == "self" {
+                    tree.insert(Segment::SelfReference);
+                } else {
+                    tree = tree.insert(Segment::Plain(ident.to_string()));
+                    tree.insert(Segment::SelfReference);
+                }
+            }
+            UseTreeKind::List(trees) => {
+                merge_imports_in_tree(trees, tree);
+            }
+        }
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use crate::{assert_format_with_config, config::ImportsGranularity, Config};
+
+    fn assert_format(src: &str, expected: &str) {
+        let config = Config {
+            imports_granularity: ImportsGranularity::Crate,
+            reorder_imports: true,
+            ..Config::default()
+        };
+        assert_format_with_config(src, expected, config);
+    }
+
+    fn assert_format_with_max_width(src: &str, expected: &str, max_width: usize) {
+        let config = Config {
+            imports_granularity: ImportsGranularity::Crate,
+            reorder_imports: true,
+            max_width,
+            ..Config::default()
+        };
+        assert_format_with_config(src, expected, config);
+    }
+
+    fn assert_format_preserving_granularity(src: &str, expected: &str) {
+        let config = Config {
+            imports_granularity: ImportsGranularity::Preserve,
+            reorder_imports: true,
+            ..Config::default()
+        };
+        assert_format_with_config(src, expected, config);
+    }
+
+    #[test]
+    fn format_simple_use_without_alias() {
+        let src = " mod moo {  pub  use  foo ;  }";
+        let expected = "mod moo {
+    pub use foo;
+}
+";
+        assert_format(src, expected);
+    }
+
+    #[test]
+    fn format_simple_use_with_alias() {
+        let src = " mod moo {  use  foo :: bar   as   baz ;  }";
+        let expected = "mod moo {
+    use foo::bar as baz;
+}
+";
+        assert_format(src, expected);
+    }
+
+    #[test]
+    fn format_simple_use_with_path_kind() {
+        let src = "use  super :: foo ;";
+        let expected = "use super::foo;\n";
+        assert_format(src, expected);
+    }
+
+    #[test]
+    fn format_use_list_two_items() {
+        let src = " use foo::{ bar,  baz  };";
+        let expected = "use foo::{bar, baz};\n";
+        assert_format(src, expected);
+    }
+
+    #[test]
+    fn format_use_trees_with_max_width() {
+        let src = " use foo::{ bar,  baz , qux , one::{two, three} };";
+        let expected = "use foo::{
+    bar,
+    baz,
+    one::{
+        three, two,
+    },
+    qux,
+};
+";
+        assert_format_with_max_width(src, expected, 20);
+    }
+
+    #[test]
+    fn format_use_list_one_item() {
+        let src = " use foo::{  bar,  };";
+        let expected = "use foo::bar;\n";
+        assert_format(src, expected);
+    }
+
+    #[test]
+    fn format_long_use_list_one_item() {
+        let src = "use one::two::{three::{four, five}};";
+        let expected = "use one::two::three::{
+    five, four,
+};
+";
+        assert_format_with_max_width(src, expected, 25);
+    }
+
+    #[test]
+    fn format_use_list_one_item_with_comments() {
+        let src = " use foo::{  /* do not remove me */ bar,  };";
+        let expected = "use foo::{/* do not remove me */ bar};\n";
+        assert_format(src, expected);
+    }
+
+    #[test]
+    fn format_use_crate_with_list() {
+        let src = " use crate :: hash :: { Hash, Hasher };  ";
+        let expected = "use crate::hash::{Hash, Hasher};\n";
+        assert_format(src, expected);
+    }
+
+    #[test]
+    fn attaches_semicolon_to_last_group() {
+        let src = " use crate::hash::{Hash, Hasher};  ";
+        let expected = "use crate::hash::{
+    Hash, Hasher,
+};
+";
+        assert_format_with_max_width(src, expected, "use crate::hash::{Hash, Hasher}".len());
+    }
+
+    #[test]
+    fn does_not_merge_imports_if_they_are_separated_by_two_lines() {
+        let src = "
+            use foo::baz;
+
+            use foo::{def, abc};
+";
+        let expected = "use foo::baz;
+
+use foo::{abc, def};
+";
+        assert_format(src, expected);
+    }
+
+    #[test]
+    fn does_not_merge_imports_if_they_have_different_visibilities() {
+        let src = "
+            pub use foo::baz;
+            use foo::{def, abc};
+";
+        let expected = "pub use foo::baz;
+use foo::{abc, def};
+";
+        assert_format(src, expected);
+    }
+
+    #[test]
+    fn does_not_merge_imports_if_they_have_trailing_comments_on_the_first_use() {
+        let src = "
+            use foo; // trailing
+            use bar;
+
+            fn foo() {}
+";
+        let expected = "use foo; // trailing
+use bar;
+
+fn foo() {}
+";
+        assert_format(src, expected);
+    }
+
+    #[test]
+    fn does_not_merge_imports_if_they_have_trailing_comments_followed_by_item() {
+        let src = "
+            use foo;
+            use bar; // trailing
+
+            fn foo() {}
+";
+        let expected = "use foo;
+use bar; // trailing
+
+fn foo() {}
+";
+        assert_format(src, expected);
+    }
+
+    #[test]
+    fn does_not_merge_imports_if_they_have_trailing_comments_followed_by_nothing() {
+        let src = "
+            use foo;
+            use bar; // trailing
+";
+        let expected = "use foo;
+use bar; // trailing
+";
+        assert_format(src, expected);
+    }
+
+    #[test]
+    fn merges_and_sorts_imports_just_two() {
+        let src = "
+            use foo::baz;
+            use foo::bar;
+        ";
+        let expected = "use foo::{bar, baz};\n";
+        assert_format(src, expected);
+    }
+
+    #[test]
+    fn sorts_but_not_merges_if_not_told_so() {
+        let src = "
+            use foo::baz;
+            use foo::{qux, bar};
+            use bar;
+        ";
+        let expected = "use bar;
+use foo::{bar, qux};
+use foo::baz;
+";
+        assert_format_preserving_granularity(src, expected);
+    }
+
+    #[test]
+    fn does_not_sort_imports_in_separate_groups() {
+        let src = "
+            use foo::baz;
+            use foo::{qux, bar};
+
+            use bar;
+        ";
+        let expected = "use foo::{bar, qux};
+use foo::baz;
+
+use bar;
+";
+        assert_format_preserving_granularity(src, expected);
+    }
+
+    #[test]
+    fn merges_and_sorts_imports_2() {
+        let src = "
+use aztec::{
+    context::Context, log::emit_unencrypted_log, note::{
+        note_getter_options::NoteGetterOptions, note_header::NoteHeader,
+    }, state_vars::{
+        Map, PrivateSet, PublicMutable,
+    }, types::{
+        address::AztecAddress, type_serialization::field_serialization::{
+            FIELD_SERIALIZED_LEN, FieldSerializationMethods,
+        },
+    },
+};
+        ";
+        let expected = "use aztec::{
+    context::Context,
+    log::emit_unencrypted_log,
+    note::{note_getter_options::NoteGetterOptions, note_header::NoteHeader},
+    state_vars::{Map, PrivateSet, PublicMutable},
+    types::{
+        address::AztecAddress,
+        type_serialization::field_serialization::{FIELD_SERIALIZED_LEN, FieldSerializationMethods},
+    },
+};
+";
+        assert_format(src, expected);
+    }
+
+    #[test]
+    fn merges_and_sorts_imports_with_different_path_kinds() {
+        let src = "
+            use bar::baz;
+            use foo::bar;
+            use crate::foo;
+        ";
+        let expected = "use crate::foo;
+use bar::baz;
+use foo::bar;
+";
+        assert_format(src, expected);
+    }
+
+    #[test]
+    fn sorts_import() {
+        let src = "
+        use value_note::{
+            utils::{increment, decrement}, value_note::{VALUE_NOTE_LEN, ValueNote, ValueNoteMethods},
+        };
+        ";
+        let expected = "use value_note::{
+    utils::{decrement, increment},
+    value_note::{VALUE_NOTE_LEN, ValueNote, ValueNoteMethods},
+};
+";
+        assert_format(src, expected);
+    }
+
+    #[test]
+    fn sorts_import_ignoring_case() {
+        let src = "
+        use foo::{def, ZETA, ABC, efg};
+        use BAR;
+        ";
+        let expected = "use BAR;
+use foo::{ABC, def, efg, ZETA};
+";
+        assert_format(src, expected);
+    }
+
+    #[test]
+    fn merges_nested_import() {
+        let src = "
+        use foo::bar;
+        use foo;
+        ";
+        let expected = "use foo::{self, bar};\n";
+        assert_format(src, expected);
+    }
+
+    #[test]
+    fn idempotent_test_check_next_test() {
+        let src = "
+        use std::as_witness;
+use std::merkle::compute_merkle_root;
+        ";
+        let expected = "use std::{as_witness, merkle::compute_merkle_root};\n";
+        assert_format(src, expected);
+    }
+
+    #[test]
+    fn idempotent_test_check_previous_test() {
+        let src = "use std::{as_witness, merkle::compute_merkle_root};";
+        let expected = "use std::{as_witness, merkle::compute_merkle_root};\n";
+        assert_format(src, expected);
+    }
+}
diff --git a/tooling/nargo_fmt/src/formatter/visibility.rs b/tooling/nargo_fmt/src/formatter/visibility.rs
new file mode 100644
index 00000000000..27441b977bb
--- /dev/null
+++ b/tooling/nargo_fmt/src/formatter/visibility.rs
@@ -0,0 +1,51 @@
+use super::Formatter;
+use noirc_frontend::{
+    ast::{ItemVisibility, Visibility},
+    token::Keyword,
+};
+
+impl<'a> Formatter<'a> {
+    pub(super) fn format_item_visibility(&mut self, visibility: ItemVisibility) {
+        self.skip_comments_and_whitespace();
+
+        match visibility {
+            ItemVisibility::Private => (),
+            ItemVisibility::PublicCrate => {
+                self.write_keyword(Keyword::Pub);
+                self.write_left_paren();
+                self.write_keyword(Keyword::Crate);
+                self.write_right_paren();
+                self.write_space();
+            }
+            ItemVisibility::Public => {
+                self.write_keyword(Keyword::Pub);
+                self.write_space();
+            }
+        }
+    }
+
+    pub(super) fn format_visibility(&mut self, visibility: Visibility) {
+        self.skip_comments_and_whitespace();
+
+        match visibility {
+            Visibility::Private => (),
+            Visibility::Public => {
+                self.write_keyword(Keyword::Pub);
+                self.write_space();
+            }
+            Visibility::CallData(..) => {
+                self.write_keyword(Keyword::CallData);
+                self.write_left_paren();
+                self.skip_comments_and_whitespace();
+                self.write_current_token_and_bump();
+                self.skip_comments_and_whitespace();
+                self.write_right_paren();
+                self.write_space();
+            }
+            Visibility::ReturnData => {
+                self.write_keyword(Keyword::ReturnData);
+                self.write_space();
+            }
+        }
+    }
+}
diff --git a/tooling/nargo_fmt/src/formatter/where_clause.rs b/tooling/nargo_fmt/src/formatter/where_clause.rs
new file mode 100644
index 00000000000..538d2ba8c01
--- /dev/null
+++ b/tooling/nargo_fmt/src/formatter/where_clause.rs
@@ -0,0 +1,72 @@
+use noirc_frontend::{
+    ast::{TraitBound, UnresolvedTraitConstraint},
+    token::{Keyword, Token},
+};
+
+use super::Formatter;
+
+impl<'a> Formatter<'a> {
+    pub(super) fn format_where_clause(
+        &mut self,
+        constraints: Vec<UnresolvedTraitConstraint>,
+        write_trailing_comma_and_new_line: bool,
+    ) {
+        assert!(!constraints.is_empty());
+
+        self.skip_comments_and_whitespace();
+        self.write_line();
+        self.write_indentation();
+        self.write_keyword(Keyword::Where);
+        self.increase_indentation();
+
+        // If we have `where F: Foo + Bar`, that's actually parsed as two constraints: `F: Foo` and `F: Bar`.
+        // To format it we'll have to skip the second type `F` if we find a `+` token.
+        let mut write_type = true;
+
+        for constraint in constraints {
+            if write_type {
+                self.write_line();
+                self.write_indentation();
+                self.format_type(constraint.typ);
+                self.write_token(Token::Colon);
+                self.write_space();
+            }
+
+            self.format_trait_bound(constraint.trait_bound);
+            self.skip_comments_and_whitespace();
+
+            if self.is_at(Token::Plus) {
+                self.write_space();
+                self.write_token(Token::Plus);
+                self.write_space();
+                write_type = false;
+                continue;
+            }
+
+            write_type = true;
+
+            if self.is_at(Token::Comma) {
+                if write_trailing_comma_and_new_line {
+                    self.write_token(Token::Comma);
+                } else {
+                    self.skip_comments_and_whitespace();
+                    self.bump();
+                }
+            } else if write_trailing_comma_and_new_line {
+                self.write(",");
+            }
+        }
+
+        self.decrease_indentation();
+
+        if write_trailing_comma_and_new_line {
+            self.write_line();
+            self.write_indentation();
+        }
+    }
+
+    pub(super) fn format_trait_bound(&mut self, trait_bound: TraitBound) {
+        self.format_path(trait_bound.trait_path);
+        self.format_generic_type_args(trait_bound.trait_generics);
+    }
+}
diff --git a/tooling/nargo_fmt/src/items.rs b/tooling/nargo_fmt/src/items.rs
deleted file mode 100644
index 57757982e83..00000000000
--- a/tooling/nargo_fmt/src/items.rs
+++ /dev/null
@@ -1,114 +0,0 @@
-use noirc_frontend::macros_api::Span;
-
-use crate::{
-    utils::{comment_len, find_comment_end},
-    visitor::{FmtVisitor, Shape},
-};
-
-#[derive(Debug)]
-pub(crate) struct Item {
-    pub(crate) leading: String,
-    pub(crate) value: String,
-    pub(crate) trailing: String,
-    pub(crate) different_line: bool,
-}
-
-impl Item {
-    pub(crate) fn total_width(&self) -> usize {
-        comment_len(&self.leading) + self.value.chars().count() + comment_len(&self.trailing)
-    }
-
-    pub(crate) fn is_multiline(&self) -> bool {
-        self.leading.contains('\n') || self.trailing.contains('\n')
-    }
-}
-
-pub(crate) struct Items<'me, T> {
-    visitor: &'me FmtVisitor<'me>,
-    shape: Shape,
-    elements: std::iter::Peekable<std::vec::IntoIter<T>>,
-    last_position: u32,
-    end_position: u32,
-}
-
-impl<'me, T: HasItem> Items<'me, T> {
-    pub(crate) fn new(
-        visitor: &'me FmtVisitor<'me>,
-        shape: Shape,
-        span: Span,
-        elements: Vec<T>,
-    ) -> Self {
-        Self {
-            visitor,
-            shape,
-            last_position: span.start() + 1,
-            end_position: span.end() - 1,
-            elements: elements.into_iter().peekable(),
-        }
-    }
-}
-
-impl<T: HasItem> Iterator for Items<'_, T> {
-    type Item = Item;
-
-    fn next(&mut self) -> Option<Self::Item> {
-        let element = self.elements.next()?;
-        let element_span = element.span();
-
-        let start = self.last_position;
-        let end = element_span.start();
-
-        let is_last = self.elements.peek().is_none();
-        let next_start = self.elements.peek().map_or(self.end_position, |expr| expr.start());
-
-        let (leading, different_line) = self.leading(start, end);
-        let expr = element.format(self.visitor, self.shape);
-        let trailing = self.trailing(element_span.end(), next_start, is_last);
-
-        Item { leading, value: expr, trailing, different_line }.into()
-    }
-}
-
-impl<'me, T> Items<'me, T> {
-    pub(crate) fn leading(&mut self, start: u32, end: u32) -> (String, bool) {
-        let mut different_line = false;
-
-        let leading = self.visitor.slice(start..end);
-        // Trim any possible whitespace before and after a comma separator
-        let leading_trimmed = leading.trim().trim_start_matches(',').trim();
-
-        let starts_with_block_comment = leading_trimmed.starts_with("/*");
-        let ends_with_block_comment = leading_trimmed.ends_with("*/");
-        let starts_with_single_line_comment = leading_trimmed.starts_with("//");
-
-        if ends_with_block_comment {
-            let comment_end = leading_trimmed.rfind(|c| c == '/').unwrap();
-
-            if leading[comment_end..].contains('\n') {
-                different_line = true;
-            }
-        } else if starts_with_single_line_comment || starts_with_block_comment {
-            different_line = true;
-        };
-
-        (leading_trimmed.to_string(), different_line)
-    }
-
-    pub(crate) fn trailing(&mut self, start: u32, end: u32, is_last: bool) -> String {
-        let slice = self.visitor.slice(start..end);
-        let comment_end = find_comment_end(slice, is_last);
-        let trailing = slice[..comment_end].trim_matches(',').trim();
-        self.last_position = start + (comment_end as u32);
-        trailing.to_string()
-    }
-}
-
-pub(crate) trait HasItem {
-    fn span(&self) -> Span;
-
-    fn format(self, visitor: &FmtVisitor, shape: Shape) -> String;
-
-    fn start(&self) -> u32 {
-        self.span().start()
-    }
-}
diff --git a/tooling/nargo_fmt/src/lib.rs b/tooling/nargo_fmt/src/lib.rs
index 0a7903f0ce1..eda77e78c7c 100644
--- a/tooling/nargo_fmt/src/lib.rs
+++ b/tooling/nargo_fmt/src/lib.rs
@@ -3,35 +3,87 @@
 #![warn(clippy::semicolon_if_nothing_returned)]
 #![cfg_attr(not(test), warn(unused_crate_dependencies, unused_extern_crates))]
 
-/// A Rust code formatting utility designed to manage and format untouched fragments of source code,
-/// including comments, whitespace, and other characters. While the module doesn't directly address comments,
-/// it treats them as unchanged fragments, ensuring their original placement and content remain preserved.
-///
-/// Key methods include:
-/// - `format_missing`: Addresses characters between the last processed position and a given end position,
-///   capturing comments and other untouched sequences.
-/// - `format_missing_indent`: Functions similarly to `format_missing`, but introduces added indentation.
-/// - `format_missing_inner`: The core method for handling missing fragments, appending them to the output buffer.
-///   Pure whitespace fragments might be replaced or adjusted based on context.
-/// - `push_vertical_spaces`: Standardizes vertical spacing, eliminating potential excessive empty lines
-///   or ensuring adequate vertical separation.
-///
-/// By recognizing and properly handling these untouched fragments, the utility ensures comments remain intact
-/// in both placement and content during the formatting process.
+//! The Noir formatter.
+//!
+//! It works by using two techniques:
+//!
+//! 1. Surfing a parsed module by using a lexer.
+//! 2. Trying to not exceed the maximum line width by formatting to intermediate chunk (see chunks.rs)
+//!
+//! What is lexer surfing?
+//!
+//! Suppose we need to format this code:
+//!
+//! fn foo ( ) { let x : Field = ( 2 , 3 ) ; }
+//!
+//! We first parse the above code so we end up with a ParsedModule. Next we traverse this module
+//! contents and process each item, statement, expression, type, etc., we find.
+//!
+//! For example, the first thing we'll find is a function. We know it has no visibility and no doc
+//! comments so we can expect an `fn` keyword to be there. We write it. Next will come the identifier.
+//! For that we "skip" any spaces and comments between `fn` and `foo`, writing only one space instead
+//! of possibly multiple spaces, then write "foo". If there were comments between `fn` and `foo`,
+//! we write them (the formatter will never lose comments).
+//!
+//! Next we know there are no generics, so we can expect a `(`, etc.
+//!
+//! In this way we go token by token, inserting newlines when needed, removing extra spaces,
+//! indenting things as we go deep inside structures, etc.
+//!
+//! But that's not all. The formatter will try to not exceed the configurable maximum width.
+//! It will do that but, for simplicity, only for function parameters list, statements and expressions
+//! (we assume an `impl Foo ...` line won't exceed the maximum length, and if it does it's not a big deal,
+//! or we can always improve things later). For this, read the comments in chunks.rs.
+mod chunks;
 mod config;
 pub mod errors;
-mod items;
-mod rewrite;
-mod utils;
-mod visitor;
+mod formatter;
 
+use formatter::Formatter;
 use noirc_frontend::ParsedModule;
-use visitor::FmtVisitor;
 
 pub use config::Config;
 
 pub fn format(source: &str, parsed_module: ParsedModule, config: &Config) -> String {
-    let mut fmt = FmtVisitor::new(source, config);
-    fmt.visit_file(parsed_module);
-    fmt.finish()
+    let mut formatter = Formatter::new(source, config);
+    formatter.format_program(parsed_module);
+    formatter.buffer.contents()
+}
+
+#[cfg(test)]
+pub(crate) fn assert_format(src: &str, expected: &str) {
+    assert_format_with_config(src, expected, Config::default());
+}
+
+#[cfg(test)]
+pub(crate) fn assert_format_with_max_width(src: &str, expected: &str, max_width: usize) {
+    let config = Config { max_width, ..Config::default() };
+    assert_format_with_config(src, expected, config);
+}
+
+#[cfg(test)]
+pub(crate) fn assert_format_with_config(src: &str, expected: &str, config: Config) {
+    use noirc_frontend::parser;
+
+    let (parsed_module, errors) = parser::parse_program(src);
+    if !errors.is_empty() {
+        panic!("Expected no errors, got: {:?}", errors);
+    }
+    let result = format(src, parsed_module, &config);
+    if result != expected {
+        println!("Expected:\n~~~\n{}\n~~~\nGot:\n~~~\n{}\n~~~", expected, result);
+    }
+
+    similar_asserts::assert_eq!(result, expected);
+
+    let src = &result;
+    let (parsed_module, errors) = parser::parse_program(src);
+    if !errors.is_empty() {
+        panic!("Expected no errors in idempotent check, got: {:?}", errors);
+    }
+    let result = format(src, parsed_module, &config);
+    if result != expected {
+        println!("Expected (idempotent):\n~~~\n{}\n~~~\nGot:\n~~~\n{}\n~~~", expected, result);
+    }
+    similar_asserts::assert_eq!(result, expected, "idempotent check failed");
 }
diff --git a/tooling/nargo_fmt/src/rewrite.rs b/tooling/nargo_fmt/src/rewrite.rs
deleted file mode 100644
index 61792c7a7fa..00000000000
--- a/tooling/nargo_fmt/src/rewrite.rs
+++ /dev/null
@@ -1,13 +0,0 @@
-mod array;
-mod expr;
-mod imports;
-mod infix;
-mod parenthesized;
-mod typ;
-
-pub(crate) use array::rewrite as array;
-pub(crate) use expr::{rewrite as expr, rewrite_sub_expr as sub_expr};
-pub(crate) use imports::UseTree;
-pub(crate) use infix::rewrite as infix;
-pub(crate) use parenthesized::rewrite as parenthesized;
-pub(crate) use typ::rewrite as typ;
diff --git a/tooling/nargo_fmt/src/rewrite/array.rs b/tooling/nargo_fmt/src/rewrite/array.rs
deleted file mode 100644
index 011e775a018..00000000000
--- a/tooling/nargo_fmt/src/rewrite/array.rs
+++ /dev/null
@@ -1,92 +0,0 @@
-use noirc_frontend::{ast::Expression, hir::resolution::errors::Span, token::Token};
-
-use crate::{
-    items::Item,
-    utils::FindToken,
-    visitor::{expr::NewlineMode, FmtVisitor},
-};
-
-pub(crate) fn rewrite(
-    mut visitor: FmtVisitor,
-    array: Vec<Expression>,
-    array_span: Span,
-    is_slice: bool,
-) -> String {
-    let pattern: &[_] = &[' ', '\t'];
-
-    visitor.indent.block_indent(visitor.config);
-    let nested_indent = visitor.shape();
-
-    let indent_str = nested_indent.indent.to_string();
-
-    let mut last_position = array_span.start() + 1;
-    let end_position = array_span.end() - 1;
-
-    let mut items = array.into_iter().peekable();
-
-    let mut result = Vec::new();
-    while let Some(item) = items.next() {
-        let item_span = item.span;
-
-        let start: u32 = last_position;
-        let end = item_span.start();
-
-        let leading = visitor.slice(start..end).trim_matches(pattern);
-        let item = super::sub_expr(&visitor, visitor.shape(), item);
-        let next_start = items.peek().map_or(end_position, |expr| expr.span.start());
-        let trailing = visitor.slice(item_span.end()..next_start);
-        let offset = trailing
-            .find_token(Token::Comma)
-            .map(|span| span.end() as usize)
-            .unwrap_or(trailing.len());
-        let trailing = trailing[..offset].trim_end_matches(',').trim_matches(pattern);
-        last_position = item_span.end() + offset as u32;
-
-        let (leading, _) = visitor.format_comment_in_block(leading);
-        let (trailing, _) = visitor.format_comment_in_block(trailing);
-
-        result.push(Item { leading, value: item, trailing, different_line: false });
-    }
-
-    let slice = visitor.slice(last_position..end_position);
-    let (comment, _) = visitor.format_comment_in_block(slice);
-    result.push(Item {
-        leading: "".into(),
-        value: "".into(),
-        trailing: comment,
-        different_line: false,
-    });
-
-    visitor.indent.block_unindent(visitor.config);
-
-    let mut items_str = String::new();
-    let mut items = result.into_iter().peekable();
-    while let Some(next) = items.next() {
-        items_str.push_str(&next.leading);
-        if next.leading.contains('\n') && !next.value.is_empty() {
-            items_str.push_str(&indent_str);
-        }
-        items_str.push_str(&next.value);
-        items_str.push_str(&next.trailing);
-
-        if let Some(item) = items.peek() {
-            if !item.value.is_empty() {
-                items_str.push(',');
-            }
-
-            if !item.leading.contains('\n') && !next.value.is_empty() {
-                items_str.push(' ');
-            }
-        }
-    }
-
-    let open_bracket = if is_slice { "&[" } else { "[" };
-    crate::visitor::expr::wrap_exprs(
-        open_bracket,
-        "]",
-        items_str.trim().into(),
-        nested_indent,
-        visitor.shape(),
-        NewlineMode::IfContainsNewLineAndWidth,
-    )
-}
diff --git a/tooling/nargo_fmt/src/rewrite/expr.rs b/tooling/nargo_fmt/src/rewrite/expr.rs
deleted file mode 100644
index 873b5c87056..00000000000
--- a/tooling/nargo_fmt/src/rewrite/expr.rs
+++ /dev/null
@@ -1,257 +0,0 @@
-use noirc_frontend::ast::{
-    ArrayLiteral, BlockExpression, Expression, ExpressionKind, Literal, Path, PathKind, UnaryOp,
-    UnresolvedType,
-};
-use noirc_frontend::{macros_api::Span, token::Token};
-
-use crate::rewrite;
-use crate::visitor::{
-    expr::{format_brackets, format_parens, NewlineMode},
-    ExpressionType, FmtVisitor, Indent, Shape,
-};
-
-pub(crate) fn rewrite_sub_expr(
-    visitor: &FmtVisitor,
-    shape: Shape,
-    expression: Expression,
-) -> String {
-    rewrite(visitor, expression, ExpressionType::SubExpression, shape)
-}
-
-pub(crate) fn rewrite(
-    visitor: &FmtVisitor,
-    Expression { kind, span }: Expression,
-    expr_type: ExpressionType,
-    shape: Shape,
-) -> String {
-    match kind {
-        ExpressionKind::Block(block) => rewrite_block(visitor, block, span),
-        ExpressionKind::Prefix(prefix) => {
-            let op = match prefix.operator {
-                UnaryOp::Minus => "-",
-                UnaryOp::Not => "!",
-                UnaryOp::MutableReference => "&mut ",
-                UnaryOp::Dereference { implicitly_added } => {
-                    if implicitly_added {
-                        ""
-                    } else {
-                        "*"
-                    }
-                }
-            };
-
-            format!("{op}{}", rewrite_sub_expr(visitor, shape, prefix.rhs))
-        }
-        ExpressionKind::Cast(cast) => {
-            format!("{} as {}", rewrite_sub_expr(visitor, shape, cast.lhs), cast.r#type)
-        }
-        kind @ ExpressionKind::Infix(_) => {
-            super::infix(visitor.fork(), Expression { kind, span }, shape)
-        }
-        ExpressionKind::Call(call_expr) => {
-            let args_span =
-                visitor.span_before(call_expr.func.span.end()..span.end(), Token::LeftParen);
-
-            let callee = rewrite_sub_expr(visitor, shape, *call_expr.func);
-            let args = format_parens(
-                visitor.config.fn_call_width.into(),
-                visitor.fork(),
-                shape,
-                false,
-                call_expr.arguments,
-                args_span,
-                true,
-                NewlineMode::IfContainsNewLineAndWidth,
-            );
-
-            let bang = if call_expr.is_macro_call { "!" } else { "" };
-            format!("{callee}{bang}{args}")
-        }
-        ExpressionKind::MethodCall(method_call_expr) => {
-            let args_span = visitor.span_before(
-                method_call_expr.method_name.span().end()..span.end(),
-                Token::LeftParen,
-            );
-
-            let object = rewrite_sub_expr(visitor, shape, method_call_expr.object);
-            let method = method_call_expr.method_name.to_string();
-            let turbofish = rewrite_turbofish(visitor, shape, method_call_expr.generics);
-            let args = format_parens(
-                visitor.config.fn_call_width.into(),
-                visitor.fork(),
-                shape,
-                false,
-                method_call_expr.arguments,
-                args_span,
-                true,
-                NewlineMode::IfContainsNewLineAndWidth,
-            );
-
-            let bang = if method_call_expr.is_macro_call { "!" } else { "" };
-            format!("{object}.{method}{turbofish}{bang}{args}")
-        }
-        ExpressionKind::MemberAccess(member_access_expr) => {
-            let lhs_str = rewrite_sub_expr(visitor, shape, member_access_expr.lhs);
-            format!("{}.{}", lhs_str, member_access_expr.rhs)
-        }
-        ExpressionKind::Index(index_expr) => {
-            let index_span = visitor
-                .span_before(index_expr.collection.span.end()..span.end(), Token::LeftBracket);
-
-            let collection = rewrite_sub_expr(visitor, shape, index_expr.collection);
-            let index = format_brackets(visitor.fork(), false, vec![index_expr.index], index_span);
-
-            format!("{collection}{index}")
-        }
-        ExpressionKind::Tuple(exprs) => format_parens(
-            None,
-            visitor.fork(),
-            shape,
-            exprs.len() == 1,
-            exprs,
-            span,
-            true,
-            NewlineMode::Normal,
-        ),
-        ExpressionKind::Literal(literal) => match literal {
-            Literal::Integer(_, _)
-            | Literal::Bool(_)
-            | Literal::Str(_)
-            | Literal::RawStr(..)
-            | Literal::FmtStr(_) => visitor.slice(span).to_string(),
-            Literal::Array(ArrayLiteral::Repeated { repeated_element, length }) => {
-                let repeated = rewrite_sub_expr(visitor, shape, *repeated_element);
-                let length = rewrite_sub_expr(visitor, shape, *length);
-
-                format!("[{repeated}; {length}]")
-            }
-            Literal::Array(ArrayLiteral::Standard(exprs)) => {
-                super::array(visitor.fork(), exprs, span, false)
-            }
-            Literal::Slice(ArrayLiteral::Repeated { repeated_element, length }) => {
-                let repeated = rewrite_sub_expr(visitor, shape, *repeated_element);
-                let length = rewrite_sub_expr(visitor, shape, *length);
-
-                format!("&[{repeated}; {length}]")
-            }
-            Literal::Slice(ArrayLiteral::Standard(exprs)) => {
-                super::array(visitor.fork(), exprs, span, true)
-            }
-            Literal::Unit => "()".to_string(),
-        },
-        ExpressionKind::Parenthesized(sub_expr) => {
-            super::parenthesized(visitor, shape, span, *sub_expr)
-        }
-        ExpressionKind::Constructor(constructor) => {
-            let type_name = visitor.slice(span.start()..constructor.typ.span.end());
-            let fields_span =
-                visitor.span_before(constructor.typ.span.end()..span.end(), Token::LeftBrace);
-
-            visitor.format_struct_lit(type_name, fields_span, *constructor)
-        }
-        ExpressionKind::If(if_expr) => {
-            let allow_single_line = expr_type == ExpressionType::SubExpression;
-
-            if allow_single_line {
-                let mut visitor = visitor.fork();
-                visitor.indent = Indent::default();
-                if let Some(line) = visitor.format_if_single_line(*if_expr.clone()) {
-                    return line;
-                }
-            }
-
-            visitor.format_if(*if_expr)
-        }
-        ExpressionKind::Variable(path) => rewrite_path(visitor, shape, path),
-        ExpressionKind::Lambda(_) => visitor.slice(span).to_string(),
-        ExpressionKind::Quote(_) => visitor.slice(span).to_string(),
-        ExpressionKind::Comptime(block, block_span) => {
-            format!("comptime {}", rewrite_block(visitor, block, block_span))
-        }
-        ExpressionKind::Unsafe(block, block_span) => {
-            format!("unsafe {}", rewrite_block(visitor, block, block_span))
-        }
-        ExpressionKind::Error => unreachable!(),
-        ExpressionKind::Resolved(_) => {
-            unreachable!("ExpressionKind::Resolved should only emitted by the comptime interpreter")
-        }
-        ExpressionKind::Interned(_) => {
-            unreachable!("ExpressionKind::Interned should only emitted by the comptime interpreter")
-        }
-        ExpressionKind::InternedStatement(_) => {
-            unreachable!(
-                "ExpressionKind::InternedStatement should only emitted by the comptime interpreter"
-            )
-        }
-        ExpressionKind::Unquote(expr) => {
-            if matches!(&expr.kind, ExpressionKind::Variable(..)) {
-                format!("${expr}")
-            } else {
-                format!("$({})", rewrite_sub_expr(visitor, shape, *expr))
-            }
-        }
-        ExpressionKind::AsTraitPath(path) => {
-            let trait_path = rewrite_path(visitor, shape, path.trait_path);
-
-            if path.trait_generics.is_empty() {
-                format!("<{} as {}>::{}", path.typ, trait_path, path.impl_item)
-            } else {
-                let generics = path.trait_generics;
-                format!("<{} as {}::{}>::{}", path.typ, trait_path, generics, path.impl_item)
-            }
-        }
-        ExpressionKind::TypePath(path) => {
-            if path.turbofish.is_empty() {
-                format!("{}::{}", path.typ, path.item)
-            } else {
-                format!("{}::{}::{}", path.typ, path.item, path.turbofish)
-            }
-        }
-    }
-}
-
-fn rewrite_block(visitor: &FmtVisitor, block: BlockExpression, span: Span) -> String {
-    let mut visitor = visitor.fork();
-    visitor.visit_block(block, span);
-    visitor.finish()
-}
-
-fn rewrite_path(visitor: &FmtVisitor, shape: Shape, path: Path) -> String {
-    let mut string = String::new();
-
-    if path.kind != PathKind::Plain {
-        string.push_str(&path.kind.to_string());
-        string.push_str("::");
-    }
-
-    for (index, segment) in path.segments.iter().enumerate() {
-        if index > 0 {
-            string.push_str("::");
-        }
-        string.push_str(&segment.ident.to_string());
-        string.push_str(&rewrite_turbofish(visitor, shape, segment.generics.clone()));
-    }
-
-    string
-}
-
-fn rewrite_turbofish(
-    visitor: &FmtVisitor,
-    shape: Shape,
-    generics: Option<Vec<UnresolvedType>>,
-) -> String {
-    if let Some(generics) = generics {
-        let mut turbofish = "".to_owned();
-        for (i, generic) in generics.into_iter().enumerate() {
-            let generic = rewrite::typ(visitor, shape, generic);
-            turbofish = if i == 0 {
-                format!("::<{}", generic)
-            } else {
-                format!("{turbofish}, {}", generic)
-            };
-        }
-        format!("{turbofish}>")
-    } else {
-        "".to_owned()
-    }
-}
diff --git a/tooling/nargo_fmt/src/rewrite/imports.rs b/tooling/nargo_fmt/src/rewrite/imports.rs
deleted file mode 100644
index 6c63c551f7d..00000000000
--- a/tooling/nargo_fmt/src/rewrite/imports.rs
+++ /dev/null
@@ -1,135 +0,0 @@
-use noirc_frontend::ast::{self, ItemVisibility};
-
-use crate::{
-    items::Item,
-    visitor::{
-        expr::{format_exprs, Tactic},
-        FmtVisitor, Shape,
-    },
-};
-
-#[derive(Debug)]
-pub(crate) enum UseSegment {
-    Ident(String, Option<String>),
-    List(Vec<UseTree>),
-    Dep,
-    Crate,
-    Super,
-}
-
-impl UseSegment {
-    fn rewrite(&self, visitor: &FmtVisitor, shape: Shape) -> String {
-        match self {
-            UseSegment::Ident(ident, None) => ident.clone(),
-            UseSegment::Ident(ident, Some(rename)) => format!("{ident} as {rename}"),
-            UseSegment::List(use_tree_list) => {
-                let mut nested_shape = shape;
-                nested_shape.indent.block_indent(visitor.config);
-
-                let items: Vec<_> = use_tree_list
-                    .iter()
-                    .map(|item| Item {
-                        leading: String::new(),
-                        value: item.rewrite(visitor, shape).clone(),
-                        trailing: String::new(),
-                        different_line: false,
-                    })
-                    .collect();
-
-                let list_str =
-                    format_exprs(visitor.config, Tactic::Mixed, false, items, nested_shape, true);
-
-                if list_str.contains('\n') {
-                    format!(
-                        "{{\n{}{list_str}\n{}}}",
-                        nested_shape.indent.to_string(),
-                        shape.indent.to_string()
-                    )
-                } else {
-                    format!("{{{list_str}}}")
-                }
-            }
-            UseSegment::Dep => "dep".into(),
-            UseSegment::Crate => "crate".into(),
-            UseSegment::Super => "super".into(),
-        }
-    }
-}
-
-#[derive(Debug)]
-pub(crate) struct UseTree {
-    path: Vec<UseSegment>,
-}
-
-impl UseTree {
-    pub(crate) fn from_ast(use_tree: ast::UseTree) -> Self {
-        let mut result = UseTree { path: vec![] };
-
-        match use_tree.prefix.kind {
-            ast::PathKind::Crate => result.path.push(UseSegment::Crate),
-            ast::PathKind::Dep => result.path.push(UseSegment::Dep),
-            ast::PathKind::Super => result.path.push(UseSegment::Super),
-            ast::PathKind::Plain => {}
-        };
-
-        result.path.extend(
-            use_tree
-                .prefix
-                .segments
-                .into_iter()
-                .map(|segment| UseSegment::Ident(segment.to_string(), None)),
-        );
-
-        match use_tree.kind {
-            ast::UseTreeKind::Path(name, alias) => {
-                result.path.push(UseSegment::Ident(
-                    name.to_string(),
-                    alias.map(|rename| rename.to_string()),
-                ));
-            }
-            ast::UseTreeKind::List(list) => {
-                let segment = UseSegment::List(list.into_iter().map(UseTree::from_ast).collect());
-                result.path.push(segment);
-            }
-        }
-
-        result
-    }
-
-    pub(crate) fn rewrite_top_level(
-        &self,
-        visitor: &FmtVisitor,
-        shape: Shape,
-        visibility: ItemVisibility,
-    ) -> String {
-        let rewrite = self.rewrite(visitor, shape);
-        if visibility == ItemVisibility::Private {
-            format!("use {};", rewrite)
-        } else {
-            format!("{} use {};", visibility, rewrite)
-        }
-    }
-
-    fn rewrite(&self, visitor: &FmtVisitor, shape: Shape) -> String {
-        let mut result = String::new();
-
-        let mut iter = self.path.iter().peekable();
-        while let Some(segment) = iter.next() {
-            let mut segment_str = segment.rewrite(visitor, shape);
-            if segment_str.contains('{')
-                && !segment_str.contains(',')
-                && !segment_str.contains("::")
-            {
-                let empty = "";
-                segment_str = segment_str.replace(['{', '}'], empty);
-            }
-            result.push_str(&segment_str);
-
-            if iter.peek().is_some() {
-                result.push_str("::");
-            }
-        }
-
-        result
-    }
-}
diff --git a/tooling/nargo_fmt/src/rewrite/infix.rs b/tooling/nargo_fmt/src/rewrite/infix.rs
deleted file mode 100644
index e2555f21187..00000000000
--- a/tooling/nargo_fmt/src/rewrite/infix.rs
+++ /dev/null
@@ -1,115 +0,0 @@
-use std::iter::zip;
-
-use noirc_frontend::ast::{Expression, ExpressionKind};
-
-use crate::{
-    rewrite,
-    utils::{first_line_width, is_single_line},
-    visitor::{FmtVisitor, Shape},
-};
-
-pub(crate) fn rewrite(visitor: FmtVisitor, expr: Expression, shape: Shape) -> String {
-    match flatten(visitor.fork(), &expr) {
-        Some((exprs, separators)) => rewrite_single_line(shape, &exprs, &separators)
-            .unwrap_or_else(|| rewrite_multiline(visitor, &exprs, &separators)),
-        None => {
-            let ExpressionKind::Infix(infix) = expr.kind else { unreachable!() };
-
-            format!(
-                "{} {} {}",
-                rewrite::sub_expr(&visitor, shape, infix.lhs),
-                infix.operator.contents.as_string(),
-                rewrite::sub_expr(&visitor, shape, infix.rhs)
-            )
-        }
-    }
-}
-
-fn rewrite_single_line(shape: Shape, exprs: &[String], separators: &[String]) -> Option<String> {
-    let mut result = String::new();
-
-    for (rewrite, separator) in zip(exprs, separators) {
-        if !is_single_line(rewrite) || result.len() > shape.width {
-            return None;
-        }
-
-        result.push_str(rewrite);
-        result.push(' ');
-        result.push_str(separator);
-        result.push(' ');
-    }
-
-    let last = exprs.last().unwrap();
-    result.push_str(last);
-
-    if first_line_width(&result) > shape.width {
-        return None;
-    }
-
-    result.into()
-}
-
-fn rewrite_multiline(visitor: FmtVisitor, exprs: &[String], separators: &[String]) -> String {
-    let mut visitor = visitor.fork();
-    visitor.indent.block_indent(visitor.config);
-    let indent_str = visitor.indent.to_string_with_newline();
-
-    let mut result = exprs[0].clone();
-
-    for (rewrite, separator) in exprs[1..].iter().zip(separators.iter()) {
-        result.push_str(&indent_str);
-        result.push_str(separator);
-        result.push(' ');
-        result.push_str(rewrite);
-    }
-
-    result
-}
-
-pub(crate) fn flatten(
-    mut visitor: FmtVisitor,
-    mut node: &Expression,
-) -> Option<(Vec<String>, Vec<String>)> {
-    let top_operator = match node.kind {
-        ExpressionKind::Infix(ref infix) => infix.operator.contents,
-        _ => return None,
-    };
-
-    let mut result = Vec::new();
-
-    let mut stack: Vec<&Expression> = Vec::new();
-    let mut separators = Vec::new();
-
-    loop {
-        match &node.kind {
-            ExpressionKind::Infix(infix) if top_operator == infix.operator.contents => {
-                stack.push(node);
-                node = &infix.lhs;
-            }
-            _ => {
-                let rewrite = if result.is_empty() {
-                    rewrite::sub_expr(&visitor, visitor.shape(), node.clone())
-                } else {
-                    visitor.indent.block_indent(visitor.config);
-                    rewrite::sub_expr(&visitor, visitor.shape(), node.clone())
-                };
-
-                result.push(rewrite);
-
-                let Some(pop) = stack.pop() else {
-                    break;
-                };
-
-                match &pop.kind {
-                    ExpressionKind::Infix(infix) => {
-                        separators.push(infix.operator.contents.to_string());
-                        node = &infix.rhs;
-                    }
-                    _ => unreachable!(),
-                }
-            }
-        }
-    }
-
-    (result, separators).into()
-}
diff --git a/tooling/nargo_fmt/src/rewrite/parenthesized.rs b/tooling/nargo_fmt/src/rewrite/parenthesized.rs
deleted file mode 100644
index 93e1538b042..00000000000
--- a/tooling/nargo_fmt/src/rewrite/parenthesized.rs
+++ /dev/null
@@ -1,68 +0,0 @@
-use noirc_frontend::ast::{Expression, ExpressionKind};
-use noirc_frontend::hir::resolution::errors::Span;
-
-use crate::visitor::{FmtVisitor, Shape};
-
-pub(crate) fn rewrite(
-    visitor: &FmtVisitor<'_>,
-    shape: Shape,
-    mut span: Span,
-    mut sub_expr: Expression,
-) -> String {
-    let remove_nested_parens = visitor.config.remove_nested_parens;
-
-    let mut leading;
-    let mut trailing;
-
-    loop {
-        let leading_span = span.start() + 1..sub_expr.span.start();
-        let trailing_span = sub_expr.span.end()..span.end() - 1;
-
-        leading = visitor.format_comment(leading_span.into());
-        trailing = visitor.format_comment(trailing_span.into());
-
-        if let ExpressionKind::Parenthesized(ref sub_sub_expr) = sub_expr.kind {
-            if remove_nested_parens && leading.is_empty() && trailing.is_empty() {
-                span = sub_expr.span;
-                sub_expr = *sub_sub_expr.clone();
-                continue;
-            }
-        }
-
-        break;
-    }
-
-    if !leading.contains("//") && !trailing.contains("//") {
-        let sub_expr = super::sub_expr(visitor, shape, sub_expr);
-        format!("({leading}{sub_expr}{trailing})")
-    } else {
-        let mut visitor = visitor.fork();
-
-        let indent = visitor.indent.to_string_with_newline();
-        visitor.indent.block_indent(visitor.config);
-        let nested_indent = visitor.indent.to_string_with_newline();
-
-        let sub_expr = super::sub_expr(&visitor, shape, sub_expr);
-
-        let mut result = String::new();
-        result.push('(');
-
-        if !leading.is_empty() {
-            result.push_str(&nested_indent);
-            result.push_str(&leading);
-        }
-
-        result.push_str(&nested_indent);
-        result.push_str(&sub_expr);
-
-        if !trailing.is_empty() {
-            result.push_str(&nested_indent);
-            result.push_str(&trailing);
-        }
-
-        result.push_str(&indent);
-        result.push(')');
-
-        result
-    }
-}
diff --git a/tooling/nargo_fmt/src/rewrite/typ.rs b/tooling/nargo_fmt/src/rewrite/typ.rs
deleted file mode 100644
index 6121f8debf6..00000000000
--- a/tooling/nargo_fmt/src/rewrite/typ.rs
+++ /dev/null
@@ -1,78 +0,0 @@
-use noirc_frontend::ast::{UnresolvedType, UnresolvedTypeData};
-
-use crate::{
-    utils::span_is_empty,
-    visitor::{FmtVisitor, Shape},
-};
-
-pub(crate) fn rewrite(visitor: &FmtVisitor, _shape: Shape, typ: UnresolvedType) -> String {
-    match typ.typ {
-        UnresolvedTypeData::Array(length, element) => {
-            let typ = rewrite(visitor, _shape, *element);
-            let length = visitor.slice(length.span());
-            format!("[{typ}; {length}]")
-        }
-        UnresolvedTypeData::Slice(element) => {
-            let typ = rewrite(visitor, _shape, *element);
-            format!("[{typ}]")
-        }
-        UnresolvedTypeData::Parenthesized(typ) => {
-            let typ = rewrite(visitor, _shape, *typ);
-            format!("({typ})")
-        }
-        UnresolvedTypeData::MutableReference(typ) => {
-            let typ = rewrite(visitor, _shape, *typ);
-            format!("&mut {typ}")
-        }
-        UnresolvedTypeData::Tuple(mut types) => {
-            if types.len() == 1 {
-                let typ = types.pop().unwrap();
-                let typ = rewrite(visitor, _shape, typ);
-
-                format!("({typ},)")
-            } else {
-                let types: Vec<_> =
-                    types.into_iter().map(|typ| rewrite(visitor, _shape, typ)).collect();
-                let types = types.join(", ");
-                format!("({types})")
-            }
-        }
-        UnresolvedTypeData::Function(args, return_type, env, unconstrained) => {
-            let unconstrained = if unconstrained { "unconstrained " } else { "" };
-
-            let env = if span_is_empty(env.span) {
-                "".into()
-            } else {
-                let ty = rewrite(visitor, _shape, *env);
-                format!("[{ty}]")
-            };
-
-            let args = args
-                .into_iter()
-                .map(|arg| rewrite(visitor, _shape, arg))
-                .collect::<Vec<_>>()
-                .join(", ");
-
-            let return_type = rewrite(visitor, _shape, *return_type);
-
-            format!("{unconstrained}fn{env}({args}) -> {return_type}")
-        }
-        UnresolvedTypeData::Resolved(_) => {
-            unreachable!("Unexpected macro expansion of a type in nargo fmt input")
-        }
-        UnresolvedTypeData::AsTraitPath(path) => path.to_string(),
-
-        UnresolvedTypeData::Unspecified => todo!(),
-        UnresolvedTypeData::FieldElement
-        | UnresolvedTypeData::Integer(_, _)
-        | UnresolvedTypeData::Bool
-        | UnresolvedTypeData::Named(_, _, _)
-        | UnresolvedTypeData::Unit
-        | UnresolvedTypeData::Expression(_)
-        | UnresolvedTypeData::String(_)
-        | UnresolvedTypeData::FormatString(_, _)
-        | UnresolvedTypeData::Quoted(_)
-        | UnresolvedTypeData::TraitAsType(_, _) => visitor.slice(typ.span).into(),
-        UnresolvedTypeData::Interned(_) | UnresolvedTypeData::Error => unreachable!(),
-    }
-}
diff --git a/tooling/nargo_fmt/src/utils.rs b/tooling/nargo_fmt/src/utils.rs
deleted file mode 100644
index 83634b718e2..00000000000
--- a/tooling/nargo_fmt/src/utils.rs
+++ /dev/null
@@ -1,233 +0,0 @@
-use std::borrow::Cow;
-
-use crate::items::HasItem;
-use crate::rewrite;
-use crate::visitor::{FmtVisitor, Shape};
-use noirc_frontend::ast::{Expression, Ident, Param, UnresolvedGeneric, Visibility};
-use noirc_frontend::hir::resolution::errors::Span;
-use noirc_frontend::lexer::Lexer;
-use noirc_frontend::token::Token;
-
-pub(crate) fn changed_comment_content(original: &str, new: &str) -> bool {
-    comments(original).ne(comments(new))
-}
-
-pub(crate) fn comments(source: &str) -> impl Iterator<Item = String> + '_ {
-    Lexer::new(source).skip_comments(false).flatten().filter_map(|spanned| {
-        if let Token::LineComment(content, _) | Token::BlockComment(content, _) =
-            spanned.into_token()
-        {
-            Some(content)
-        } else {
-            None
-        }
-    })
-}
-
-pub(crate) trait FindToken {
-    fn find_token(&self, token: Token) -> Option<Span>;
-    fn find_token_with(&self, f: impl Fn(&Token) -> bool) -> Option<Span>;
-}
-
-impl FindToken for str {
-    fn find_token(&self, token: Token) -> Option<Span> {
-        Lexer::new(self).flatten().find_map(|it| (it.token() == &token).then(|| it.to_span()))
-    }
-
-    fn find_token_with(&self, f: impl Fn(&Token) -> bool) -> Option<Span> {
-        Lexer::new(self)
-            .skip_comments(false)
-            .flatten()
-            .find_map(|spanned| f(spanned.token()).then(|| spanned.to_span()))
-    }
-}
-
-pub(crate) fn find_comment_end(slice: &str, is_last: bool) -> usize {
-    fn find_comment_end(slice: &str) -> usize {
-        slice
-            .find_token_with(|token| {
-                matches!(token, Token::LineComment(_, _) | Token::BlockComment(_, _))
-            })
-            .map(|index| index.end() as usize)
-            .unwrap_or(slice.len())
-    }
-
-    if is_last {
-        return slice.len();
-    }
-
-    let mut block_open_index = slice.find("/*");
-    if let Some(index) = block_open_index {
-        match slice.find('/') {
-            Some(slash) if slash < index => block_open_index = None,
-            _ if slice[..index].ends_with('/') => block_open_index = None,
-            _ => (),
-        }
-    }
-
-    let newline_index = slice.find('\n');
-    if let Some(separator_index) =
-        slice.find_token(Token::Comma).map(|index| index.start() as usize)
-    {
-        match (block_open_index, newline_index) {
-            (Some(block), None) if block > separator_index => separator_index + 1,
-            (Some(block), None) => {
-                let slice = &slice[block..];
-                std::cmp::max(find_comment_end(slice) + block, separator_index + 1)
-            }
-            (Some(block), Some(newline)) if block < newline => {
-                let slice = &slice[block..];
-                std::cmp::max(find_comment_end(slice) + block, separator_index + 1)
-            }
-            (_, Some(newline)) if newline > separator_index => newline + 1,
-            (None, None) => 0,
-            _ => slice.len(),
-        }
-    } else if let Some(newline_index) = newline_index {
-        newline_index + 1
-    } else {
-        0
-    }
-}
-
-pub(crate) fn comment_len(comment: &str) -> usize {
-    match comment {
-        "" => 0,
-        _ => {
-            let len = comment.trim().len();
-            if len > 0 {
-                len + 6
-            } else {
-                len
-            }
-        }
-    }
-}
-
-pub(crate) fn count_newlines(slice: &str) -> usize {
-    bytecount::count(slice.as_bytes(), b'\n')
-}
-
-impl HasItem for Expression {
-    fn span(&self) -> Span {
-        self.span
-    }
-
-    fn format(self, visitor: &FmtVisitor, shape: Shape) -> String {
-        rewrite::sub_expr(visitor, shape, self)
-    }
-}
-
-impl HasItem for (Ident, Expression) {
-    fn span(&self) -> Span {
-        let (name, value) = self;
-        (name.span().start()..value.span.end()).into()
-    }
-
-    fn format(self, visitor: &FmtVisitor, shape: Shape) -> String {
-        let (name, expr) = self;
-
-        let name = name.0.contents;
-        let expr = rewrite::sub_expr(visitor, shape, expr);
-
-        if name == expr {
-            name
-        } else {
-            format!("{name}: {expr}")
-        }
-    }
-}
-
-impl HasItem for Param {
-    fn span(&self) -> Span {
-        self.span
-    }
-
-    fn format(self, visitor: &FmtVisitor, shape: Shape) -> String {
-        let pattern = visitor.slice(self.pattern.span());
-        let visibility = match self.visibility {
-            Visibility::Public => "pub".to_string(),
-            Visibility::Private => "".to_string(),
-            Visibility::CallData(x) => format!("call_data({x})"),
-            Visibility::ReturnData => "return_data".to_string(),
-        };
-
-        if self.pattern.is_synthesized() || self.typ.is_synthesized() {
-            pattern.to_string()
-        } else {
-            let ty = rewrite::typ(visitor, shape, self.typ);
-            let visibility = append_space_if_nonempty(visibility.into());
-            format!("{pattern}: {visibility}{ty}")
-        }
-    }
-}
-
-impl HasItem for Ident {
-    fn span(&self) -> Span {
-        self.span()
-    }
-
-    fn format(self, visitor: &FmtVisitor, _shape: Shape) -> String {
-        visitor.slice(self.span()).into()
-    }
-}
-
-impl HasItem for UnresolvedGeneric {
-    fn span(&self) -> Span {
-        self.span()
-    }
-
-    fn format(self, visitor: &FmtVisitor, _shape: Shape) -> String {
-        match self {
-            UnresolvedGeneric::Variable(_) => visitor.slice(self.span()).into(),
-            UnresolvedGeneric::Numeric { ident, typ } => {
-                let mut result = "".to_owned();
-                result.push_str(&ident.0.contents);
-                result.push_str(": ");
-                let typ = rewrite::typ(visitor, _shape, typ);
-                result.push_str(&typ);
-                result
-            }
-            UnresolvedGeneric::Resolved(..) => {
-                unreachable!("Found macro result UnresolvedGeneric::Resolved in formatter")
-            }
-        }
-    }
-}
-
-pub(crate) fn first_line_width(exprs: &str) -> usize {
-    exprs.lines().next().map_or(0, |line: &str| line.chars().count())
-}
-
-pub(crate) fn last_line_width(s: &str) -> usize {
-    s.rsplit('\n').next().unwrap_or("").chars().count()
-}
-
-pub(crate) fn is_single_line(s: &str) -> bool {
-    !s.chars().any(|c| c == '\n')
-}
-
-pub(crate) fn last_line_contains_single_line_comment(s: &str) -> bool {
-    s.lines().last().map_or(false, |line| line.contains("//"))
-}
-
-pub(crate) fn append_space_if_nonempty(mut string: Cow<str>) -> Cow<str> {
-    if !string.is_empty() {
-        let inner = string.to_mut();
-        inner.push(' ');
-    }
-
-    string
-}
-
-pub(crate) fn last_line_used_width(s: &str, offset: usize) -> usize {
-    if s.contains('\n') {
-        last_line_width(s)
-    } else {
-        offset + s.chars().count()
-    }
-}
-
-pub(crate) fn span_is_empty(span: Span) -> bool {
-    span.start() == span.end()
-}
diff --git a/tooling/nargo_fmt/src/visitor.rs b/tooling/nargo_fmt/src/visitor.rs
deleted file mode 100644
index 50f1ca69fcd..00000000000
--- a/tooling/nargo_fmt/src/visitor.rs
+++ /dev/null
@@ -1,303 +0,0 @@
-pub(crate) mod expr;
-mod item;
-mod stmt;
-
-use noirc_frontend::{hir::resolution::errors::Span, lexer::Lexer, token::Token};
-
-use crate::{
-    config::Config,
-    utils::{self, FindToken},
-};
-
-pub(crate) struct FmtVisitor<'me> {
-    ignore_next_node: bool,
-    pub(crate) config: &'me Config,
-    buffer: String,
-    pub(crate) source: &'me str,
-    pub(crate) indent: Indent,
-    last_position: u32,
-}
-
-impl<'me> FmtVisitor<'me> {
-    pub(crate) fn new(source: &'me str, config: &'me Config) -> Self {
-        Self {
-            ignore_next_node: false,
-            buffer: String::new(),
-            config,
-            source,
-            last_position: 0,
-            indent: Indent { block_indent: 0 },
-        }
-    }
-
-    pub(crate) fn budget(&self, used_width: usize) -> usize {
-        self.config.max_width.saturating_sub(used_width)
-    }
-
-    pub(crate) fn slice(&self, span: impl Into<Span>) -> &'me str {
-        let span = span.into();
-        str_slice(self.source, span.start() as usize, span.end() as usize)
-    }
-
-    pub(crate) fn span_after(&self, span: impl Into<Span>, token: Token) -> Span {
-        let span = span.into();
-
-        let slice = self.slice(span);
-        let offset = slice.find_token(token).unwrap().end();
-
-        (span.start() + offset..span.end()).into()
-    }
-
-    pub(crate) fn span_before(&self, span: impl Into<Span>, token: Token) -> Span {
-        let span = span.into();
-
-        let slice = self.slice(span);
-        let offset = slice.find_token(token).unwrap().start();
-
-        (span.start() + offset..span.end()).into()
-    }
-
-    pub(crate) fn shape(&self) -> Shape {
-        Shape {
-            width: self.config.max_width.saturating_sub(self.indent.width()),
-            indent: self.indent,
-        }
-    }
-
-    pub(crate) fn fork(&self) -> Self {
-        Self {
-            buffer: String::new(),
-            ignore_next_node: self.ignore_next_node,
-            config: self.config,
-            source: self.source,
-            last_position: self.last_position,
-            indent: self.indent,
-        }
-    }
-
-    pub(crate) fn finish(self) -> String {
-        self.buffer
-    }
-
-    fn at_start(&self) -> bool {
-        self.buffer.is_empty()
-    }
-
-    fn push_str(&mut self, s: &str) {
-        let comments = Lexer::new(s).skip_comments(false).flatten().flat_map(|token| {
-            if let Token::LineComment(content, _) | Token::BlockComment(content, _) =
-                token.into_token()
-            {
-                let content = content.trim();
-                content.strip_prefix("noir-fmt:").map(ToOwned::to_owned)
-            } else {
-                None
-            }
-        });
-
-        for comment in comments {
-            match comment.as_str() {
-                "ignore" => self.ignore_next_node = true,
-                this => unreachable!("unknown settings {this}"),
-            }
-        }
-
-        self.buffer.push_str(s);
-    }
-
-    #[track_caller]
-    fn push_rewrite(&mut self, rewrite: String, span: Span) {
-        let original = self.slice(span);
-        let changed_comment_content = utils::changed_comment_content(original, &rewrite);
-
-        if changed_comment_content && self.config.error_on_lost_comment {
-            panic!("not formatted because a comment would be lost: {rewrite:?}");
-        }
-
-        self.format_missing_indent(span.start(), true);
-
-        let rewrite = if changed_comment_content || std::mem::take(&mut self.ignore_next_node) {
-            original.to_string()
-        } else {
-            rewrite
-        };
-
-        self.push_str(&rewrite);
-
-        if rewrite.starts_with('{') && rewrite.ends_with('}') {
-            self.ignore_next_node = false;
-        }
-    }
-
-    #[track_caller]
-    fn format_missing_indent(&mut self, end: u32, should_indent: bool) {
-        self.format_missing_inner(end, |this, last_slice, slice| {
-            this.push_str(last_slice.trim_end());
-
-            if (last_slice == slice && !this.at_start()) || this.buffer.ends_with("*/") {
-                this.push_str("\n");
-            }
-
-            if should_indent {
-                let indent = this.indent.to_string();
-                this.push_str(&indent);
-            }
-        });
-    }
-
-    #[track_caller]
-    fn format_missing_inner(
-        &mut self,
-        end: u32,
-        process_last_slice: impl Fn(&mut Self, &str, &str),
-    ) {
-        let start = self.last_position;
-
-        if start == end {
-            if !self.at_start() {
-                process_last_slice(self, "", "");
-            }
-            return;
-        }
-
-        let slice = self.slice(start..end);
-        self.last_position = end;
-
-        if slice.trim().is_empty() && !self.at_start() {
-            self.push_vertical_spaces(slice);
-            process_last_slice(self, "", slice);
-        } else {
-            let (result, last_end) = self.format_comment_in_block(slice);
-            if result.trim().is_empty() {
-                process_last_slice(self, slice, slice);
-            } else {
-                let last_snippet = &slice[last_end as usize..];
-                self.push_str(&result);
-                process_last_slice(self, last_snippet, &result);
-            }
-        }
-    }
-
-    pub(crate) fn format_comment_in_block(&mut self, slice: &str) -> (String, u32) {
-        let mut result = String::new();
-        let comments = Lexer::new(slice).skip_comments(false).skip_whitespaces(false).flatten();
-
-        let indent = self.indent.to_string();
-        for comment in comments {
-            let span = comment.to_span();
-
-            match comment.token() {
-                Token::LineComment(_, _) | Token::BlockComment(_, _) => {
-                    let comment = str_slice(slice, span.start() as usize, span.end() as usize);
-                    if result.ends_with('\n') {
-                        result.push_str(&indent);
-                    } else if !self.at_start() {
-                        result.push(' ');
-                    }
-                    result.push_str(comment);
-                }
-                Token::Whitespace(whitespaces) => {
-                    let mut visitor = self.fork();
-                    if whitespaces.contains('\n') {
-                        visitor.push_vertical_spaces(whitespaces.trim_matches(' '));
-                        result.push_str(&visitor.finish());
-                    }
-                }
-                _ => {}
-            }
-        }
-
-        (result, slice.len() as u32)
-    }
-
-    fn push_vertical_spaces(&mut self, slice: &str) {
-        let newline_upper_bound = 2;
-        let newline_lower_bound = 1;
-
-        let mut newline_count = utils::count_newlines(slice);
-        let offset = self.buffer.chars().rev().take_while(|c| *c == '\n').count();
-
-        if newline_count + offset > newline_upper_bound {
-            if offset >= newline_upper_bound {
-                newline_count = 0;
-            } else {
-                newline_count = newline_upper_bound - offset;
-            }
-        } else if newline_count + offset < newline_lower_bound {
-            if offset >= newline_lower_bound {
-                newline_count = 0;
-            } else {
-                newline_count = newline_lower_bound - offset;
-            }
-        }
-
-        let blank_lines = "\n".repeat(newline_count);
-        self.push_str(&blank_lines);
-    }
-
-    pub(crate) fn format_comment(&self, span: Span) -> String {
-        let slice = self.slice(span).trim();
-        let pos = slice.find('/');
-
-        if !slice.is_empty() && pos.is_some() {
-            slice.to_string()
-        } else {
-            String::new()
-        }
-    }
-}
-
-pub(crate) fn str_slice(s: &str, start: usize, end: usize) -> &str {
-    &s[start..ceil_char_boundary(s, end)]
-}
-
-pub(crate) fn ceil_char_boundary(s: &str, byte_index: usize) -> usize {
-    for i in byte_index..s.len() {
-        if s.is_char_boundary(i) {
-            return i;
-        }
-    }
-    s.len()
-}
-
-#[derive(Clone, Copy, Debug, Default)]
-pub(crate) struct Indent {
-    block_indent: usize,
-}
-
-impl Indent {
-    pub(crate) fn width(&self) -> usize {
-        self.block_indent
-    }
-
-    #[track_caller]
-    pub(crate) fn block_indent(&mut self, config: &Config) {
-        self.block_indent += config.tab_spaces;
-    }
-
-    #[track_caller]
-    pub(crate) fn block_unindent(&mut self, config: &Config) {
-        self.block_indent -= config.tab_spaces;
-    }
-
-    pub(crate) fn to_string_with_newline(self) -> String {
-        "\n".to_string() + &self.to_string()
-    }
-
-    #[allow(clippy::inherent_to_string)]
-    pub(crate) fn to_string(self) -> String {
-        " ".repeat(self.block_indent)
-    }
-}
-
-#[derive(Clone, Copy, Debug, Default)]
-pub(crate) struct Shape {
-    pub(crate) width: usize,
-    pub(crate) indent: Indent,
-}
-
-#[derive(PartialEq, Eq, Debug)]
-pub(crate) enum ExpressionType {
-    Statement,
-    SubExpression,
-}
diff --git a/tooling/nargo_fmt/src/visitor/expr.rs b/tooling/nargo_fmt/src/visitor/expr.rs
deleted file mode 100644
index 18b962a7f85..00000000000
--- a/tooling/nargo_fmt/src/visitor/expr.rs
+++ /dev/null
@@ -1,484 +0,0 @@
-use noirc_frontend::ast::Expression;
-use noirc_frontend::ast::{
-    BlockExpression, ConstructorExpression, ExpressionKind, IfExpression, Statement, StatementKind,
-};
-use noirc_frontend::{hir::resolution::errors::Span, lexer::Lexer, token::Token};
-
-use super::{ExpressionType, FmtVisitor, Shape};
-use crate::{
-    items::{HasItem, Item, Items},
-    rewrite,
-    utils::{first_line_width, FindToken},
-    Config,
-};
-
-impl FmtVisitor<'_> {
-    pub(crate) fn visit_expr(&mut self, expr: Expression, expr_type: ExpressionType) {
-        let span = expr.span;
-        let rewrite = rewrite::expr(self, expr, expr_type, self.shape());
-        self.push_rewrite(rewrite, span);
-        self.last_position = span.end();
-    }
-
-    pub(crate) fn format_if(&self, if_expr: IfExpression) -> String {
-        let condition_str = rewrite::sub_expr(self, self.shape(), if_expr.condition);
-        let consequence_str = rewrite::sub_expr(self, self.shape(), if_expr.consequence);
-
-        let mut result = format!("if {condition_str} {consequence_str}");
-
-        if let Some(alternative) = if_expr.alternative {
-            let alternative = if let Some(ExpressionKind::If(if_expr)) =
-                extract_simple_expr(alternative.clone()).map(|expr| expr.kind)
-            {
-                self.format_if(*if_expr)
-            } else {
-                rewrite::expr(self, alternative, ExpressionType::Statement, self.shape())
-            };
-
-            result.push_str(" else ");
-            result.push_str(&alternative);
-        };
-
-        result
-    }
-
-    pub(crate) fn format_if_single_line(&self, if_expr: IfExpression) -> Option<String> {
-        let condition_str = rewrite::sub_expr(self, self.shape(), if_expr.condition);
-        let consequence_str =
-            rewrite::sub_expr(self, self.shape(), extract_simple_expr(if_expr.consequence)?);
-
-        let if_str = if let Some(alternative) = if_expr.alternative {
-            let alternative_str = if let Some(ExpressionKind::If(_)) =
-                extract_simple_expr(alternative.clone()).map(|expr| expr.kind)
-            {
-                return None;
-            } else {
-                rewrite::expr(
-                    self,
-                    extract_simple_expr(alternative)?,
-                    ExpressionType::Statement,
-                    self.shape(),
-                )
-            };
-
-            format!("if {} {{ {} }} else {{ {} }}", condition_str, consequence_str, alternative_str)
-        } else {
-            format!("if {{{}}} {{{}}}", condition_str, consequence_str)
-        };
-
-        (if_str.len() <= self.config.single_line_if_else_max_width).then_some(if_str)
-    }
-
-    pub(crate) fn format_struct_lit(
-        &self,
-        type_name: &str,
-        fields_span: Span,
-        constructor: ConstructorExpression,
-    ) -> String {
-        let fields = {
-            let mut visitor = self.fork();
-            let is_unit_struct = constructor.fields.is_empty();
-
-            visitor.indent.block_indent(visitor.config);
-
-            let nested_indent = visitor.shape();
-            let exprs: Vec<_> =
-                Items::new(&visitor, nested_indent, fields_span, constructor.fields).collect();
-            let exprs = format_exprs(
-                visitor.config,
-                Tactic::HorizontalVertical,
-                false,
-                exprs,
-                nested_indent,
-                true,
-            );
-
-            visitor.indent.block_unindent(visitor.config);
-
-            if exprs.contains('\n') {
-                format!(
-                    "{}{exprs}{}",
-                    nested_indent.indent.to_string_with_newline(),
-                    visitor.shape().indent.to_string_with_newline()
-                )
-            } else if is_unit_struct {
-                exprs
-            } else {
-                format!(" {exprs} ")
-            }
-        };
-
-        format!("{type_name} {{{fields}}}")
-    }
-
-    pub(crate) fn visit_block(&mut self, block: BlockExpression, block_span: Span) {
-        if block.is_empty() {
-            self.visit_empty_block(block_span);
-            return;
-        }
-
-        self.last_position = block_span.start() + 1; // `{`
-        self.push_str("{");
-
-        self.trim_spaces_after_opening_brace(&block.statements);
-
-        self.indent.block_indent(self.config);
-
-        self.visit_stmts(block.statements);
-
-        let span = (self.last_position..block_span.end() - 1).into();
-        self.close_block(span);
-        self.last_position = block_span.end();
-    }
-
-    fn trim_spaces_after_opening_brace(&mut self, block: &[Statement]) {
-        if let Some(first_stmt) = block.first() {
-            let slice = self.slice(self.last_position..first_stmt.span.start());
-            let len =
-                slice.chars().take_while(|ch| ch.is_whitespace()).collect::<String>().rfind('\n');
-            self.last_position += len.unwrap_or(0) as u32;
-        }
-    }
-
-    pub(crate) fn visit_empty_block(&mut self, block_span: Span) {
-        let slice = self.slice(block_span);
-        let comment_str = slice[1..slice.len() - 1].trim();
-
-        if comment_str.is_empty() {
-            self.push_str("{}");
-        } else {
-            self.push_str("{");
-            self.indent.block_indent(self.config);
-            self.close_block(block_span);
-        };
-
-        self.last_position = block_span.end();
-    }
-
-    pub(crate) fn close_block(&mut self, span: Span) {
-        let slice = self.slice(span);
-
-        for spanned in Lexer::new(slice).skip_comments(false).flatten() {
-            match spanned.token() {
-                Token::LineComment(_, _) | Token::BlockComment(_, _) => {
-                    let token_span = spanned.to_span();
-
-                    let offset = token_span.start();
-                    let sub_slice = &slice[token_span.start() as usize..token_span.end() as usize];
-
-                    let span_in_between = span.start()..span.start() + offset;
-                    let slice_in_between = self.slice(span_in_between);
-                    let comment_on_same_line = !slice_in_between.contains('\n');
-
-                    if comment_on_same_line {
-                        self.push_str(" ");
-                        self.push_str(sub_slice);
-                    } else {
-                        self.push_str(&self.indent.to_string_with_newline());
-                        self.push_str(sub_slice);
-                    }
-                }
-                _ => {}
-            }
-        }
-
-        self.indent.block_unindent(self.config);
-        self.push_str(&self.indent.to_string_with_newline());
-        self.push_str("}");
-    }
-}
-
-// TODO: fixme
-#[allow(clippy::too_many_arguments)]
-pub(crate) fn format_seq<T: HasItem>(
-    shape: Shape,
-    prefix: &str,
-    suffix: &str,
-    visitor: FmtVisitor,
-    trailing_comma: bool,
-    exprs: Vec<T>,
-    span: Span,
-    tactic: Tactic,
-    mode: NewlineMode,
-    reduce: bool,
-) -> String {
-    let mut nested_indent = shape;
-
-    nested_indent.indent.block_indent(visitor.config);
-
-    let exprs: Vec<_> = Items::new(&visitor, nested_indent, span, exprs).collect();
-    let exprs = format_exprs(visitor.config, tactic, trailing_comma, exprs, nested_indent, reduce);
-
-    wrap_exprs(prefix, suffix, exprs, nested_indent, shape, mode)
-}
-
-pub(crate) fn format_brackets(
-    visitor: FmtVisitor,
-    trailing_comma: bool,
-    exprs: Vec<Expression>,
-    span: Span,
-) -> String {
-    let array_width = visitor.config.array_width;
-    format_seq(
-        visitor.shape(),
-        "[",
-        "]",
-        visitor,
-        trailing_comma,
-        exprs,
-        span,
-        Tactic::LimitedHorizontalVertical(array_width),
-        NewlineMode::Normal,
-        false,
-    )
-}
-
-// TODO: fixme
-#[allow(clippy::too_many_arguments)]
-pub(crate) fn format_parens(
-    max_width: Option<usize>,
-    visitor: FmtVisitor,
-    shape: Shape,
-    trailing_comma: bool,
-    exprs: Vec<Expression>,
-    span: Span,
-    reduce: bool,
-    mode: NewlineMode,
-) -> String {
-    let tactic = max_width.map(Tactic::LimitedHorizontalVertical).unwrap_or(Tactic::Horizontal);
-    format_seq(shape, "(", ")", visitor, trailing_comma, exprs, span, tactic, mode, reduce)
-}
-
-pub(crate) fn format_exprs(
-    config: &Config,
-    tactic: Tactic,
-    trailing_comma: bool,
-    exprs: Vec<Item>,
-    shape: Shape,
-    reduce: bool,
-) -> String {
-    let mut result = String::new();
-    let indent_str = shape.indent.to_string();
-
-    let tactic = tactic.definitive(&exprs, config.short_array_element_width_threshold, reduce);
-    let mut exprs = exprs.into_iter().enumerate().peekable();
-    let mut line_len = 0;
-    let mut prev_expr_trailing_comment = false;
-
-    while let Some((index, expr)) = exprs.next() {
-        let is_first = index == 0;
-        let separate = exprs.peek().is_some() || trailing_comma;
-        let separate_len = usize::from(separate);
-
-        match tactic {
-            DefinitiveTactic::Vertical
-                if !is_first && !expr.value.is_empty() && !result.is_empty() =>
-            {
-                result.push('\n');
-                result.push_str(&indent_str);
-            }
-            DefinitiveTactic::Horizontal if !is_first => {
-                result.push(' ');
-            }
-            DefinitiveTactic::Mixed => {
-                let total_width = expr.total_width() + separate_len;
-
-                if line_len > 0 && line_len + 1 + total_width > shape.width
-                    || prev_expr_trailing_comment
-                {
-                    result.push('\n');
-                    result.push_str(&indent_str);
-                    line_len = 0;
-                } else if line_len > 0 {
-                    result.push(' ');
-                    line_len += 1;
-                }
-
-                line_len += total_width;
-            }
-            _ => {}
-        }
-
-        result.push_str(&expr.leading);
-
-        if expr.different_line {
-            result.push('\n');
-            result.push_str(&indent_str);
-            line_len = expr.value.chars().count();
-        } else if !expr.leading.is_empty() {
-            result.push(' ');
-        }
-
-        result.push_str(&expr.value);
-
-        if tactic == DefinitiveTactic::Horizontal {
-            result.push_str(&expr.trailing);
-        }
-
-        if separate && expr.trailing.find_token(Token::Comma).is_none() {
-            result.push(',');
-        }
-
-        if tactic != DefinitiveTactic::Horizontal {
-            prev_expr_trailing_comment = !expr.trailing.is_empty();
-
-            if !expr.different_line && !expr.trailing.is_empty() {
-                result.push(' ');
-            }
-
-            result.push_str(&expr.trailing);
-        }
-    }
-
-    result
-}
-
-#[derive(PartialEq, Eq)]
-pub(crate) enum NewlineMode {
-    IfContainsNewLine,
-    IfContainsNewLineAndWidth,
-    Normal,
-}
-
-pub(crate) fn wrap_exprs(
-    prefix: &str,
-    suffix: &str,
-    exprs: String,
-    nested_shape: Shape,
-    shape: Shape,
-    newline_mode: NewlineMode,
-) -> String {
-    let mut force_one_line = if newline_mode == NewlineMode::IfContainsNewLine {
-        true
-    } else {
-        first_line_width(&exprs) <= shape.width
-    };
-
-    if matches!(
-        newline_mode,
-        NewlineMode::IfContainsNewLine | NewlineMode::IfContainsNewLineAndWidth
-    ) && force_one_line
-    {
-        force_one_line = !exprs.contains('\n');
-    }
-
-    if force_one_line {
-        let allow_trailing_newline = exprs
-            .lines()
-            .last()
-            .unwrap_or_default()
-            .find_token_with(|token| matches!(token, Token::LineComment(_, _)))
-            .is_some();
-
-        let trailing_newline = if allow_trailing_newline {
-            shape.indent.to_string_with_newline()
-        } else {
-            String::new()
-        };
-
-        format!("{prefix}{exprs}{trailing_newline}{suffix}")
-    } else {
-        let nested_indent_str = nested_shape.indent.to_string_with_newline();
-        let indent_str = shape.indent.to_string_with_newline();
-
-        format!("{prefix}{nested_indent_str}{exprs}{indent_str}{suffix}")
-    }
-}
-
-#[derive(PartialEq, Eq, Clone, Copy)]
-pub(crate) enum Tactic {
-    Horizontal,
-    HorizontalVertical,
-    LimitedHorizontalVertical(usize),
-    Mixed,
-}
-
-impl Tactic {
-    fn definitive(
-        self,
-        exprs: &[Item],
-        short_width_threshold: usize,
-        reduce: bool,
-    ) -> DefinitiveTactic {
-        let tactic = || {
-            let has_single_line_comment = exprs.iter().any(|item| {
-                has_single_line_comment(&item.leading) || has_single_line_comment(&item.trailing)
-            });
-
-            let limit = match self {
-                _ if has_single_line_comment => return DefinitiveTactic::Vertical,
-
-                Tactic::Horizontal => return DefinitiveTactic::Horizontal,
-                Tactic::LimitedHorizontalVertical(limit) => limit,
-                Tactic::HorizontalVertical | Tactic::Mixed => 100,
-            };
-
-            let (sep_count, total_width): (usize, usize) = exprs
-                .iter()
-                .map(|expr| expr.total_width())
-                .fold((0, 0), |(sep_count, total_width), width| {
-                    (sep_count + 1, total_width + width)
-                });
-
-            let total_sep_len = sep_count.saturating_sub(1);
-            let real_total = total_width + total_sep_len;
-
-            if real_total <= limit && !exprs.iter().any(|expr| expr.is_multiline()) {
-                DefinitiveTactic::Horizontal
-            } else if self == Tactic::Mixed {
-                DefinitiveTactic::Mixed
-            } else {
-                DefinitiveTactic::Vertical
-            }
-        };
-
-        let definitive_tactic = tactic();
-        if reduce {
-            definitive_tactic.reduce(exprs, short_width_threshold)
-        } else {
-            definitive_tactic
-        }
-    }
-}
-
-#[derive(Debug, PartialEq, Eq, Clone, Copy)]
-enum DefinitiveTactic {
-    Vertical,
-    Horizontal,
-    Mixed,
-}
-
-impl DefinitiveTactic {
-    fn reduce(self, exprs: &[Item], short_array_element_width_threshold: usize) -> Self {
-        match self {
-            DefinitiveTactic::Vertical
-                if no_long_exprs(exprs, short_array_element_width_threshold) =>
-            {
-                DefinitiveTactic::Mixed
-            }
-            DefinitiveTactic::Vertical | DefinitiveTactic::Horizontal | DefinitiveTactic::Mixed => {
-                self
-            }
-        }
-    }
-}
-
-fn has_single_line_comment(slice: &str) -> bool {
-    slice.trim_start().starts_with("//")
-}
-
-fn no_long_exprs(exprs: &[Item], max_width: usize) -> bool {
-    exprs.iter().all(|expr| expr.value.len() <= max_width)
-}
-
-fn extract_simple_expr(expr: Expression) -> Option<Expression> {
-    if let ExpressionKind::Block(mut block) = expr.kind {
-        if block.len() == 1 {
-            if let StatementKind::Expression(expr) = block.pop().unwrap() {
-                return expr.into();
-            }
-        }
-    }
-
-    None
-}
diff --git a/tooling/nargo_fmt/src/visitor/item.rs b/tooling/nargo_fmt/src/visitor/item.rs
deleted file mode 100644
index 2feae4b390c..00000000000
--- a/tooling/nargo_fmt/src/visitor/item.rs
+++ /dev/null
@@ -1,306 +0,0 @@
-use crate::{
-    rewrite::{self, UseTree},
-    utils::{
-        append_space_if_nonempty, last_line_contains_single_line_comment, last_line_used_width,
-        FindToken,
-    },
-    visitor::expr::{format_seq, NewlineMode},
-};
-use noirc_frontend::{
-    ast::{ItemVisibility, NoirFunction, TraitImplItemKind, Visibility},
-    macros_api::UnresolvedTypeData,
-};
-use noirc_frontend::{
-    hir::resolution::errors::Span,
-    parser::{Item, ItemKind},
-    token::{Keyword, Token},
-    ParsedModule,
-};
-
-use super::{
-    expr::Tactic::{HorizontalVertical, LimitedHorizontalVertical},
-    Shape,
-};
-
-impl super::FmtVisitor<'_> {
-    fn format_fn_before_block(&self, func: NoirFunction, start: u32) -> (String, bool) {
-        let name_span = func.name_ident().span();
-        let func_span = func.span();
-
-        let mut result = self.slice(start..name_span.end()).to_owned();
-
-        let params_open =
-            self.span_before(name_span.end()..func_span.start(), Token::LeftParen).start();
-
-        let last_span = if func.parameters().is_empty() {
-            params_open..func_span.start()
-        } else {
-            func.parameters().last().unwrap().span.end()..func_span.start()
-        };
-
-        let params_end = self.span_after(last_span, Token::RightParen).start();
-
-        let params_span = params_open..params_end;
-        let return_type_span = func.return_type().span;
-        let return_type = self.format_return_type(return_type_span, &func, func_span, params_end);
-        let parameters = func.def.parameters;
-
-        if !func.def.generics.is_empty() {
-            let full_span = name_span.end()..params_open;
-            let start = self.span_before(full_span.clone(), Token::Less).start();
-            let end = self.span_after(full_span, Token::Greater).start();
-
-            let generics = func.def.generics;
-            let span = (start..end).into();
-            let generics = format_seq(
-                self.shape(),
-                "<",
-                ">",
-                self.fork(),
-                false,
-                generics,
-                span,
-                HorizontalVertical,
-                NewlineMode::IfContainsNewLine,
-                false,
-            );
-
-            result.push_str(&generics);
-        }
-
-        let parameters = if parameters.is_empty() {
-            self.slice(params_span).into()
-        } else {
-            let fn_start = result
-                .find_token_with(|token| {
-                    matches!(token, Token::Keyword(Keyword::Fn | Keyword::Unconstrained))
-                })
-                .unwrap()
-                .start();
-
-            let slice = self.slice(fn_start..result.len() as u32);
-            let indent = self.indent;
-            let used_width = last_line_used_width(slice, indent.width());
-            let overhead = if return_type.is_empty() { 2 } else { 3 }; // 2 = `()`, 3 = `() `
-            let one_line_budget = self.budget(used_width + return_type.len() + overhead);
-            let shape = Shape { width: one_line_budget, indent };
-
-            let tactic = LimitedHorizontalVertical(one_line_budget);
-
-            format_seq(
-                shape,
-                "(",
-                ")",
-                self.fork(),
-                false,
-                parameters,
-                params_span.into(),
-                tactic,
-                NewlineMode::IfContainsNewLine,
-                false,
-            )
-        };
-
-        result.push_str(&parameters);
-        result.push_str(&return_type);
-
-        let maybe_comment = self.slice(params_end..func_span.start());
-
-        (result.trim_end().to_string(), last_line_contains_single_line_comment(maybe_comment))
-    }
-
-    fn format_return_type(
-        &self,
-        span: Span,
-        func: &NoirFunction,
-        func_span: Span,
-        params_end: u32,
-    ) -> String {
-        let mut result = String::new();
-
-        if func.return_type().typ == UnresolvedTypeData::Unit {
-            result.push_str(self.slice(params_end..func_span.start()));
-        } else {
-            result.push_str(" -> ");
-
-            let visibility = match func.def.return_visibility {
-                Visibility::Public => "pub",
-                Visibility::ReturnData => "return_data",
-                Visibility::Private => "",
-                Visibility::CallData(_) => {
-                    unreachable!("call_data cannot be used for return value")
-                }
-            };
-            result.push_str(&append_space_if_nonempty(visibility.into()));
-
-            let typ = rewrite::typ(self, self.shape(), func.return_type());
-            result.push_str(&typ);
-
-            let slice = self.slice(span.end()..func_span.start());
-            if !slice.trim().is_empty() {
-                result.push_str(slice);
-            }
-        }
-
-        result
-    }
-
-    pub(crate) fn visit_file(&mut self, module: ParsedModule) {
-        self.visit_module(module);
-        self.format_missing_indent(self.source.len() as u32, false);
-    }
-
-    fn visit_module(&mut self, module: ParsedModule) {
-        for Item { kind, span, doc_comments } in module.items {
-            match kind {
-                ItemKind::Function(func) => {
-                    self.visit_function(span, func);
-                }
-                ItemKind::Submodules(module) => {
-                    self.format_missing_indent(span.start(), true);
-
-                    if std::mem::take(&mut self.ignore_next_node) {
-                        self.push_str(self.slice(span));
-                        self.last_position = span.end();
-                        continue;
-                    }
-
-                    for doc_comment in doc_comments {
-                        self.push_str(&format!("///{doc_comment}\n"));
-                        self.push_str(&self.indent.to_string());
-                    }
-
-                    for attribute in module.outer_attributes {
-                        self.push_str(&format!("#[{}]\n", attribute.as_ref()));
-                        self.push_str(&self.indent.to_string());
-                    }
-
-                    let name = module.name;
-                    let after_brace = self.span_after(span, Token::LeftBrace).start();
-                    self.last_position = after_brace;
-
-                    let visibility = module.visibility;
-                    if visibility != ItemVisibility::Private {
-                        self.push_str(&format!("{visibility} "));
-                    }
-
-                    let keyword = if module.is_contract { "contract" } else { "mod" };
-                    self.push_str(&format!("{keyword} {name} "));
-
-                    if module.contents.items.is_empty() {
-                        self.visit_empty_block((after_brace - 1..span.end()).into());
-                        continue;
-                    } else {
-                        self.push_str("{");
-                        self.indent.block_indent(self.config);
-                        self.visit_module(module.contents);
-                    }
-
-                    self.close_block((self.last_position..span.end() - 1).into());
-                    self.last_position = span.end();
-                }
-                ItemKind::Impl(impl_) => {
-                    self.format_missing_indent(span.start(), true);
-
-                    if std::mem::take(&mut self.ignore_next_node) {
-                        self.push_str(self.slice(span));
-                        self.last_position = span.end();
-                        continue;
-                    }
-
-                    let before_brace = self.span_before(span, Token::LeftBrace).start();
-                    let slice = self.slice(self.last_position..before_brace).trim();
-                    let after_brace = self.span_after(span, Token::LeftBrace).start();
-                    self.last_position = after_brace;
-
-                    self.push_str(&format!("{slice} "));
-
-                    if impl_.methods.is_empty() {
-                        self.visit_empty_block((after_brace - 1..span.end()).into());
-                        continue;
-                    } else {
-                        self.push_str("{");
-                        self.indent.block_indent(self.config);
-
-                        for (method, span) in impl_.methods {
-                            self.visit_function(span, method.item);
-                        }
-
-                        self.close_block((self.last_position..span.end() - 1).into());
-                        self.last_position = span.end();
-                    }
-                }
-                ItemKind::TraitImpl(noir_trait_impl) => {
-                    self.format_missing_indent(span.start(), true);
-
-                    if std::mem::take(&mut self.ignore_next_node) {
-                        self.push_str(self.slice(span));
-                        self.last_position = span.end();
-                        continue;
-                    }
-
-                    let before_brace = self.span_before(span, Token::LeftBrace).start();
-                    let slice = self.slice(self.last_position..before_brace).trim();
-                    let after_brace = self.span_after(span, Token::LeftBrace).start();
-                    self.last_position = after_brace;
-
-                    self.push_str(&format!("{slice} "));
-
-                    if noir_trait_impl.items.is_empty() {
-                        self.visit_empty_block((after_brace - 1..span.end()).into());
-                        continue;
-                    } else {
-                        self.push_str("{");
-                        self.indent.block_indent(self.config);
-
-                        for documented_item in noir_trait_impl.items {
-                            let span = documented_item.item.span;
-                            match documented_item.item.kind {
-                                TraitImplItemKind::Function(method) => {
-                                    self.visit_function(span, method);
-                                }
-                                TraitImplItemKind::Constant(..)
-                                | TraitImplItemKind::Type { .. } => {
-                                    self.push_rewrite(self.slice(span).to_string(), span);
-                                    self.last_position = span.end();
-                                }
-                            }
-                        }
-
-                        self.close_block((self.last_position..span.end() - 1).into());
-                        self.last_position = span.end();
-                    }
-                }
-                ItemKind::Import(use_tree, visibility) => {
-                    let use_tree = UseTree::from_ast(use_tree);
-                    let use_tree = use_tree.rewrite_top_level(self, self.shape(), visibility);
-                    self.push_rewrite(use_tree, span);
-                    self.last_position = span.end();
-                }
-                ItemKind::Struct(_)
-                | ItemKind::Trait(_)
-                | ItemKind::TypeAlias(_)
-                | ItemKind::Global(..)
-                | ItemKind::ModuleDecl(_)
-                | ItemKind::InnerAttribute(_) => {
-                    self.push_rewrite(self.slice(span).to_string(), span);
-                    self.last_position = span.end();
-                }
-            }
-        }
-    }
-
-    fn visit_function(&mut self, span: Span, func: NoirFunction) {
-        self.format_missing_indent(span.start(), true);
-        if std::mem::take(&mut self.ignore_next_node) {
-            self.push_str(self.slice(span));
-            self.last_position = span.end();
-            return;
-        }
-        let (fn_before_block, force_brace_newline) =
-            self.format_fn_before_block(func.clone(), span.start());
-        self.push_str(&fn_before_block);
-        self.push_str(if force_brace_newline { "\n" } else { " " });
-        self.visit_block(func.def.body, func.def.span);
-    }
-}
diff --git a/tooling/nargo_fmt/src/visitor/stmt.rs b/tooling/nargo_fmt/src/visitor/stmt.rs
deleted file mode 100644
index 8908aabd87c..00000000000
--- a/tooling/nargo_fmt/src/visitor/stmt.rs
+++ /dev/null
@@ -1,94 +0,0 @@
-use std::iter::zip;
-
-use noirc_frontend::macros_api::Span;
-
-use noirc_frontend::ast::{ConstrainKind, ConstrainStatement, ForRange, Statement, StatementKind};
-
-use crate::{rewrite, visitor::expr::wrap_exprs};
-
-use super::{expr::NewlineMode, ExpressionType};
-
-impl super::FmtVisitor<'_> {
-    pub(crate) fn visit_stmts(&mut self, stmts: Vec<Statement>) {
-        let len = stmts.len();
-
-        for (Statement { kind, span }, index) in zip(stmts, 1..) {
-            let is_last = index == len;
-            self.visit_stmt(kind, span, is_last);
-            self.last_position = span.end();
-        }
-    }
-
-    fn visit_stmt(&mut self, kind: StatementKind, span: Span, is_last: bool) {
-        match kind {
-            StatementKind::Expression(expr) => self.visit_expr(
-                expr,
-                if is_last { ExpressionType::SubExpression } else { ExpressionType::Statement },
-            ),
-            StatementKind::Semi(expr) => {
-                self.visit_expr(expr, ExpressionType::Statement);
-                self.push_str(";");
-            }
-            StatementKind::Let(let_stmt) => {
-                let let_str = self.slice(span.start()..let_stmt.expression.span.start()).trim_end();
-
-                let expr_str = rewrite::sub_expr(self, self.shape(), let_stmt.expression);
-
-                self.push_rewrite(format!("{let_str} {expr_str};"), span);
-            }
-            StatementKind::Constrain(ConstrainStatement { kind, arguments, span: _ }) => {
-                let mut nested_shape = self.shape();
-                let shape = nested_shape;
-
-                nested_shape.indent.block_indent(self.config);
-
-                let callee = match kind {
-                    ConstrainKind::Assert | ConstrainKind::Constrain => "assert",
-                    ConstrainKind::AssertEq => "assert_eq",
-                };
-                let args = arguments
-                    .into_iter()
-                    .map(|arg| rewrite::sub_expr(self, nested_shape, arg))
-                    .collect::<Vec<String>>()
-                    .join(", ");
-
-                let args = wrap_exprs(
-                    "(",
-                    ")",
-                    args,
-                    nested_shape,
-                    shape,
-                    NewlineMode::IfContainsNewLineAndWidth,
-                );
-                let constrain = format!("{callee}{args};");
-
-                self.push_rewrite(constrain, span);
-            }
-            StatementKind::For(for_stmt) => {
-                let identifier = self.slice(for_stmt.identifier.span());
-                let range = match for_stmt.range {
-                    ForRange::Range(start, end) => format!(
-                        "{}..{}",
-                        rewrite::sub_expr(self, self.shape(), start),
-                        rewrite::sub_expr(self, self.shape(), end)
-                    ),
-                    ForRange::Array(array) => rewrite::sub_expr(self, self.shape(), array),
-                };
-                let block = rewrite::sub_expr(self, self.shape(), for_stmt.block);
-
-                let result = format!("for {identifier} in {range} {block}");
-                self.push_rewrite(result, span);
-            }
-            StatementKind::Assign(_) => {
-                self.push_rewrite(self.slice(span).to_string(), span);
-            }
-            StatementKind::Error => unreachable!(),
-            StatementKind::Break => self.push_rewrite("break;".into(), span),
-            StatementKind::Continue => self.push_rewrite("continue;".into(), span),
-            StatementKind::Comptime(statement) => self.visit_stmt(statement.kind, span, is_last),
-            StatementKind::Interned(_) => unreachable!(
-                "StatementKind::Resolved should only emitted by the comptime interpreter"
-            ),
-        }
-    }
-}
diff --git a/tooling/nargo_fmt/tests/expected/array.nr b/tooling/nargo_fmt/tests/expected/array.nr
index 3341afb31a5..b8e7d051368 100644
--- a/tooling/nargo_fmt/tests/expected/array.nr
+++ b/tooling/nargo_fmt/tests/expected/array.nr
@@ -1,37 +1,51 @@
 fn big_array() {
     [
-        1, 10, 100, 1000, 10000, 100000, 1000000, 10000000, 100000000, 1000000000, 10000000000, 100000000000, 1000000000000, 10000000000000, 100000000000000, 1000000000000000, 10000000000000000, 100000000000000000, 1000000000000000000,
+        1,
+        10,
+        100,
+        1000,
+        10000,
+        100000,
+        1000000,
+        10000000,
+        100000000,
+        1000000000,
+        10000000000,
+        100000000000,
+        1000000000000,
+        10000000000000,
+        100000000000000,
+        1000000000000000,
+        10000000000000000,
+        100000000000000000,
+        1000000000000000000,
         10000000000000000000,
         100000000000000000000,
         1000000000000000000000,
         10000000000000000000000,
         100000000000000000000000,
-        1000000000000000000000000
+        1000000000000000000000000,
     ];
 
-    [
-        1,
-        10
-    ];
+    [1, 10];
 
     [
         // hello!
-        1,
-        10
+        1, 10,
     ];
 
     [
         // hello!
         1,
         // asd
-        10
+        10,
     ];
 
     [
         // hello!
         1,
         // asd
-        10 
+        10,
         // asdasd
     ];
 
diff --git a/tooling/nargo_fmt/tests/expected/call.nr b/tooling/nargo_fmt/tests/expected/call.nr
index de78d7c4edb..8a1a529dfb7 100644
--- a/tooling/nargo_fmt/tests/expected/call.nr
+++ b/tooling/nargo_fmt/tests/expected/call.nr
@@ -3,12 +3,12 @@ fn foo() {
 
     outer_function(
         some_function(), // Original inner function call
-        another_function() // Original inner function call
+        another_function(), // Original inner function call
     );
 
     outer_function(
         some_function(), // Original inner function call
-        another_function() // Original inner function call
+        another_function(), // Original inner function call
     );
 
     my_function(
@@ -16,17 +16,17 @@ fn foo() {
         some_value,
         /* Multiline
         Comment */
-        another_func(20, 30)
+        another_func(20, 30),
     );
 
     my_function(
         some_function(10, "arg1", another_function()),
-        another_func(20, some_function(), 30)
+        another_func(20, some_function(), 30),
     );
 
     outer_function(
         some_function(),
-        another_function(some_function(), some_value)
+        another_function(some_function(), some_value),
     );
 
     assert_eq(x, y);
@@ -39,12 +39,8 @@ fn foo() {
 
     assert(x == y);
 
-    assert(
-        p4_affine.eq(
-            Gaffine::new(
-                6890855772600357754907169075114257697580319025794532037257385534741338397365,
-                4338620300185947561074059802482547481416142213883829469920100239455078257889
-            )
-        )
-    );
+    assert(p4_affine.eq(Gaffine::new(
+        6890855772600357754907169075114257697580319025794532037257385534741338397365,
+        4338620300185947561074059802482547481416142213883829469920100239455078257889,
+    )));
 }
diff --git a/tooling/nargo_fmt/tests/expected/contract.nr b/tooling/nargo_fmt/tests/expected/contract.nr
index cb7505f845c..86f8d56b62d 100644
--- a/tooling/nargo_fmt/tests/expected/contract.nr
+++ b/tooling/nargo_fmt/tests/expected/contract.nr
@@ -5,13 +5,22 @@
 contract Benchmarking {
     use aztec::protocol_types::abis::function_selector::FunctionSelector;
 
-    use value_note::{utils::{increment, decrement}, value_note::{VALUE_NOTE_LEN, ValueNote, ValueNoteMethods}};
+    use value_note::{
+        utils::{decrement, increment},
+        value_note::{VALUE_NOTE_LEN, ValueNote, ValueNoteMethods},
+    };
 
     use aztec::{
-        context::Context, note::{note_getter_options::NoteGetterOptions, note_header::NoteHeader},
-        log::emit_unencrypted_log, state_vars::{Map, PublicMutable, PrivateSet},
-        types::type_serialization::field_serialization::{FieldSerializationMethods, FIELD_SERIALIZED_LEN},
-        types::address::AztecAddress
+        context::Context,
+        log::emit_unencrypted_log,
+        note::{note_getter_options::NoteGetterOptions, note_header::NoteHeader},
+        state_vars::{Map, PrivateSet, PublicMutable},
+        types::{
+            address::AztecAddress,
+            type_serialization::field_serialization::{
+                FIELD_SERIALIZED_LEN, FieldSerializationMethods,
+            },
+        },
     };
 
     struct Storage {
@@ -25,13 +34,15 @@ contract Benchmarking {
                 notes: Map::new(
                     context,
                     1,
-                    |context, slot| { PrivateSet::new(context, slot, ValueNoteMethods) }
+                    |context, slot| PrivateSet::new(context, slot, ValueNoteMethods),
                 ),
                 balances: Map::new(
                     context,
                     2,
-                    |context, slot| { PublicMutable::new(context, slot, FieldSerializationMethods) }
-                )
+                    |context, slot| {
+                        PublicMutable::new(context, slot, FieldSerializationMethods)
+                    },
+                ),
             }
         }
     }
@@ -63,10 +74,8 @@ contract Benchmarking {
         storage.balances.at(owner).write(current + value);
         let _callStackItem1 = context.call_public_function(
             context.this_address(),
-            comptime {
-            FunctionSelector::from_signature("broadcast(Field)")
-        },
-            [owner]
+            comptime { FunctionSelector::from_signature("broadcast(Field)") },
+            [owner],
         );
     }
 
diff --git a/tooling/nargo_fmt/tests/expected/databus.nr b/tooling/nargo_fmt/tests/expected/databus.nr
index 60934b60b2f..0e9761ed52d 100644
--- a/tooling/nargo_fmt/tests/expected/databus.nr
+++ b/tooling/nargo_fmt/tests/expected/databus.nr
@@ -1,2 +1,2 @@
-fn main(x: pub u8, y: call_data u8) -> return_data u32 {}
+fn main(x: pub u8, y: call_data(0) u8) -> return_data u32 {}
 
diff --git a/tooling/nargo_fmt/tests/expected/empty.nr b/tooling/nargo_fmt/tests/expected/empty.nr
index e69de29bb2d..8b137891791 100644
--- a/tooling/nargo_fmt/tests/expected/empty.nr
+++ b/tooling/nargo_fmt/tests/expected/empty.nr
@@ -0,0 +1 @@
+
diff --git a/tooling/nargo_fmt/tests/expected/expr.nr b/tooling/nargo_fmt/tests/expected/expr.nr
index babaf5b356e..9bee940f900 100644
--- a/tooling/nargo_fmt/tests/expected/expr.nr
+++ b/tooling/nargo_fmt/tests/expected/expr.nr
@@ -2,8 +2,7 @@
 fn qux() {
     {}
 
-    { /* a block with a comment */
-    }
+    { /* a block with a comment */ }
     {}
     {
         // A block with a comment.
@@ -96,11 +95,12 @@ fn parenthesized() {
 }
 
 fn parenthesized() {
-    value + (/*test*/x as Field/*test*/)
+    value + ( /*test*/ x as Field /*test*/)
 }
 
 fn parenthesized() {
-    value + (
+    value
+        + (
             // line
             x as Field
         )
@@ -117,21 +117,23 @@ fn if_expr() {
 }
 
 fn return_if_expr() {
-    if true { 42 } else { 40 + 2 }
+    if true {
+        42
+    } else {
+        40 + 2
+    }
 }
 
 fn return_if_expr() {
+    if true { 42 };
+
     if true {
         42
-    };
-
-    if true { 42 } else { 40 + 2 }
+    } else {
+        40 + 2
+    }
 }
 
 fn if_if() {
-    (if cond {
-        some();
-    } else {
-        none();
-    }).bar().baz();
+    (if cond { some(); } else { none(); }).bar().baz();
 }
diff --git a/tooling/nargo_fmt/tests/expected/fn.nr b/tooling/nargo_fmt/tests/expected/fn.nr
index 73248d0c04f..afdb8883e15 100644
--- a/tooling/nargo_fmt/tests/expected/fn.nr
+++ b/tooling/nargo_fmt/tests/expected/fn.nr
@@ -2,7 +2,11 @@ fn main(x: pub u8, y: u8) {}
 
 fn main(x: pub u8, y: u8) -> pub Field {}
 
-fn main<A, B>(x: A, y: B) -> pub Field where A: Eq, B: Eq {}
+fn main<A, B>(x: A, y: B) -> pub Field
+where
+    A: Eq,
+    B: Eq,
+{}
 
 fn main()
 // hello
@@ -14,10 +18,13 @@ fn main(
 
 fn main(
     // hello
-    unit: ()
+    unit: (),
 ) {}
 
-fn main<T>() where T: Eq {}
+fn main<T>()
+where
+    T: Eq,
+{}
 
 fn main(
     tape: [Field; TAPE_LEN],
@@ -25,7 +32,7 @@ fn main(
     initial_memory: [Field; MEM_COUNT],
     initial_program_counter: Field,
     initial_call_stack: [Field; MAX_CALL_STACK],
-    initial_call_stack_pointer: u64
+    initial_call_stack_pointer: u64,
 ) -> pub ExecutionResult {}
 
 fn apply_binary_field_op<N>(
@@ -33,7 +40,7 @@ fn apply_binary_field_op<N>(
     rhs: RegisterIndex,
     result: RegisterIndex,
     op: u8,
-    registers: &mut Registers<N>
+    registers: &mut Registers<N>,
 ) -> bool {}
 
 fn main() -> pub [Field; 2] {}
@@ -57,7 +64,7 @@ fn main(
     message_field: Field,
     pub_key_x: Field,
     pub_key_y: Field,
-    signature: [u8; 64]
+    signature: [u8; 64],
 ) {}
 
 pub fn from_baz(x: [Field; crate::foo::MAGIC_NUMBER]) {}
@@ -71,3 +78,21 @@ fn whitespace_before_generics<T>(foo: T) {}
 fn more_whitespace_before_generics<T>(foo: T) {}
 
 fn with_unconstrained(x: unconstrained fn() -> ()) {}
+
+pub(crate) fn one() {}
+
+pub unconstrained fn two() {}
+
+pub unconstrained comptime fn two() {}
+
+/// Documented
+#[test]
+fn three() {}
+
+#[test(should_fail)]
+// comment
+fn four() {}
+
+#[test(should_fail_with = "oops")]
+fn five() {}
+
diff --git a/tooling/nargo_fmt/tests/expected/for.nr b/tooling/nargo_fmt/tests/expected/for.nr
index 98dff672bef..748c1fe008d 100644
--- a/tooling/nargo_fmt/tests/expected/for.nr
+++ b/tooling/nargo_fmt/tests/expected/for.nr
@@ -10,6 +10,10 @@ fn for_stmt() {
             b *= b;
         }
 
+        for k in 0..=C1 {
+            d *= d;
+        }
+
         z *= if b == 1 { 1 } else { c };
 
         c *= c;
diff --git a/tooling/nargo_fmt/tests/expected/if.nr b/tooling/nargo_fmt/tests/expected/if.nr
index 39ad7d18cdd..fa0d10a819b 100644
--- a/tooling/nargo_fmt/tests/expected/if.nr
+++ b/tooling/nargo_fmt/tests/expected/if.nr
@@ -1,13 +1,17 @@
 //@error_on_lost_comment=false
 fn main() {
-    let (x,y) = if is_square(gx1) {
+    let (x, y) = if is_square(gx1) {
         (x1, sqrt(gx1))
     } else {
         (x2, sqrt(gx2))
     };
 
     let n = if x != y {
-        if x != 20 { slice.push_back(y) } else { slice }
+        if x != 20 {
+            slice.push_back(y)
+        } else {
+            slice
+        }
     } else {
         slice
     };
@@ -39,8 +43,7 @@ fn main() {
     if true // else-if-chain if comment
     {
         ();
-    }
-    else if false // else-if-chain else-if comment
+    } else if false // else-if-chain else-if comment
     {
         ();
         ();
diff --git a/tooling/nargo_fmt/tests/expected/ignore.nr b/tooling/nargo_fmt/tests/expected/ignore.nr
index 1c84e178f34..6e957539405 100644
--- a/tooling/nargo_fmt/tests/expected/ignore.nr
+++ b/tooling/nargo_fmt/tests/expected/ignore.nr
@@ -24,3 +24,4 @@ fn mk_array() {
                 ];
     let array = [1];
 }
+
diff --git a/tooling/nargo_fmt/tests/expected/impl.nr b/tooling/nargo_fmt/tests/expected/impl.nr
index 3c2fa42837a..d3f986ca943 100644
--- a/tooling/nargo_fmt/tests/expected/impl.nr
+++ b/tooling/nargo_fmt/tests/expected/impl.nr
@@ -10,6 +10,10 @@ impl MyType {
     fn method(mut self) {}
 
     fn method(&mut self) {}
+
+    fn method(self: Self) {}
+
+    fn method(mut self: Self) {}
 }
 
 impl MyType {
@@ -20,7 +24,10 @@ impl MyType {
     fn method(self) {}
 }
 
-impl<T> MyStruct<T> where T: MyEq {
+impl<T> MyStruct<T>
+where
+    T: MyEq,
+{
     fn my_eq(self, other: Self) -> bool {
         (self.a == other.a) & self.b.my_eq(other.b)
     }
diff --git a/tooling/nargo_fmt/tests/expected/impl_trait_fn_parameter.nr b/tooling/nargo_fmt/tests/expected/impl_trait_fn_parameter.nr
index 5ace5c60dcf..f931a06c96c 100644
--- a/tooling/nargo_fmt/tests/expected/impl_trait_fn_parameter.nr
+++ b/tooling/nargo_fmt/tests/expected/impl_trait_fn_parameter.nr
@@ -1,3 +1,6 @@
 fn func_name(x: impl Eq) {}
 
-fn func_name<T>(x: impl Eq, y: T) where T: SomeTrait + Eq {}
+fn func_name<T>(x: impl Eq, y: T)
+where
+    T: SomeTrait + Eq,
+{}
diff --git a/tooling/nargo_fmt/tests/expected/index.nr b/tooling/nargo_fmt/tests/expected/index.nr
index 54f2ed2cf39..74356a9013f 100644
--- a/tooling/nargo_fmt/tests/expected/index.nr
+++ b/tooling/nargo_fmt/tests/expected/index.nr
@@ -4,6 +4,8 @@ fn foo() {
     arr[2];
     arr[/*test*/ 2];
     arr[2/*test*/];
-    arr[// test
-        2];
+    arr[
+        // test
+        2
+    ];
 }
diff --git a/tooling/nargo_fmt/tests/expected/infix.nr b/tooling/nargo_fmt/tests/expected/infix.nr
index 228dfdf68c4..7a43f4a70a1 100644
--- a/tooling/nargo_fmt/tests/expected/infix.nr
+++ b/tooling/nargo_fmt/tests/expected/infix.nr
@@ -4,17 +4,17 @@ fn foo() {
     !40 + 2;
     40 + 2 == 42;
 
-    40/*test*/ + 2 == 42;
-    40 + 2/*test*/ == 42;
+    40 /*test*/ + 2 == 42;
+    40 + 2 /*test*/ == 42;
 }
 
 fn big() {
     assert(
         bjj_affine.contains(bjj_affine.gen)
-        & bjj_affine.contains(p1_affine)
-        & bjj_affine.contains(p2_affine)
-        & bjj_affine.contains(p3_affine)
-        & bjj_affine.contains(p4_affine)
-        & bjj_affine.contains(p5_affine)
+            & bjj_affine.contains(p1_affine)
+            & bjj_affine.contains(p2_affine)
+            & bjj_affine.contains(p3_affine)
+            & bjj_affine.contains(p4_affine)
+            & bjj_affine.contains(p5_affine),
     );
 }
diff --git a/tooling/nargo_fmt/tests/expected/let.nr b/tooling/nargo_fmt/tests/expected/let.nr
index 0edc0eaf922..b5806d5f3d3 100644
--- a/tooling/nargo_fmt/tests/expected/let.nr
+++ b/tooling/nargo_fmt/tests/expected/let.nr
@@ -2,31 +2,36 @@
 fn let_() {
     let fn_call = my_function(
         some_function(10, "arg1", another_function()),
-        another_func(20, some_function(), 30)
+        another_func(20, some_function(), 30),
     );
     let array = [[[1, 2, 3], [4, 5, 6]], [[7, 8, 9], [10, 11, 12]], [[13, 14, 15], [16, 17, 18]]];
 
     let padded_sha256_hash: [u8; 259] = [
         // Padded hash
-        209, 50, 135, 178, 4, 155, 190, 229, 228, 111, 61, 174, 8, 49, 48, 116, 90, 226, 77, 7, 111, 27, 19, 113, 154, 48, 138, 136, 138, 15, 230, 132, 32, 4, 0, 5, 1, 2, 4, 3, 101, 1, 72, 134, 96, 9, 6, 13, 48, 49,
-        48, 0, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 1, 0,
+        209, 50, 135, 178, 4, 155, 190, 229, 228, 111, 61, 174, 8, 49, 48, 116, 90, 226, 77, 7, 111,
+        27, 19, 113, 154, 48, 138, 136, 138, 15, 230, 132, 32, 4, 0, 5, 1, 2, 4, 3, 101, 1, 72, 134,
+        96, 9, 6, 13, 48, 49, 48, 0, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 1, 0,
         // Rest is padded with 0s until max bytes
-        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, 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, 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, 0, 0, 0, 0, 0, 0,
     ];
 
     let a = BigUint56 {
         limbs: [
-            1, 2, 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, 2, 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,
+        ],
     };
 
     let person = Person {
         first_name: "John",
         last_name: "Doe",
-        home_address: Address { street: "123 Main St", city: "Exampleville", zip_code: "12345" }
+        home_address: Address { street: "123 Main St", city: "Exampleville", zip_code: "12345" },
     };
 
     let person = Person {
@@ -39,21 +44,25 @@ fn let_() {
             master: Person {
                 first_name: "John",
                 last_name: "Doe",
-                home_address: Address { street: "123 Main St", city: "Exampleville", zip_code: "12345" }
-            }
-        }
+                home_address: Address {
+                    street: "123 Main St",
+                    city: "Exampleville",
+                    zip_code: "12345",
+                },
+            },
+        },
     };
 
     let expr = MyExpr {
         // A boolean literal (true, false).
-        kind: ExprKind::Bool(true)
+        kind: ExprKind::Bool(true),
     };
 
     let expr = MyExpr { /*A boolean literal (true, false).*/ kind: ExprKind::Bool(true) };
 
     let mut V = crate2::MyStruct { Q: x };
     let mut V = crate2::MyStruct {};
-    let mut V = crate2::MyStruct {/*test*/};
+    let mut V = crate2::MyStruct { /*test*/ };
     let mut V = crate2::MyStruct {
         // sad
     };
diff --git a/tooling/nargo_fmt/tests/expected/module.nr b/tooling/nargo_fmt/tests/expected/module.nr
index 1d153b02078..9f8fb53d5cd 100644
--- a/tooling/nargo_fmt/tests/expected/module.nr
+++ b/tooling/nargo_fmt/tests/expected/module.nr
@@ -4,7 +4,7 @@
 mod a {
     mod b {
         struct Data {
-            a: Field
+            a: Field,
         }
     }
 
diff --git a/tooling/nargo_fmt/tests/expected/parens.nr b/tooling/nargo_fmt/tests/expected/parens.nr
index e6c4f91879c..2eaf3838ed6 100644
--- a/tooling/nargo_fmt/tests/expected/parens.nr
+++ b/tooling/nargo_fmt/tests/expected/parens.nr
@@ -23,23 +23,28 @@ fn main(x: u64, y: pub u64) {
         )
     );
 
-    (/*a*/(
-        // test
-        1
-    )/*b*/);
+    (
+        /*a*/
+
+        (
+            // test
+            1
+        )
+        /*b*/
+    );
 
     (
         // test
         1
     );
 
-    (/*a*/1);
+    ( /*a*/ 1);
 
-    (1/*b*/);
+    (1 /*b*/);
 
-    (/*c*/1/*d*/);
+    ( /*c*/ 1 /*d*/);
 
-    (/*test*/1/*test 2*/);
+    ( /*test*/ 1 /*test 2*/);
 
     (());
     (());
diff --git a/tooling/nargo_fmt/tests/expected/struct.nr b/tooling/nargo_fmt/tests/expected/struct.nr
index 8fc642f7cd5..d7a0cfc6d7c 100644
--- a/tooling/nargo_fmt/tests/expected/struct.nr
+++ b/tooling/nargo_fmt/tests/expected/struct.nr
@@ -5,7 +5,7 @@ struct Foo {
 
 struct Pair {
     first: Foo,
-    second: Field,
+    pub second: Field,
 }
 
 impl Foo {
@@ -26,7 +26,7 @@ impl Pair {
 
 struct Nested {
     a: Field,
-    b: Field
+    b: Field,
 }
 struct MyStruct {
     my_bool: bool,
diff --git a/tooling/nargo_fmt/tests/expected/trait.nr b/tooling/nargo_fmt/tests/expected/trait.nr
new file mode 100644
index 00000000000..0467585fac3
--- /dev/null
+++ b/tooling/nargo_fmt/tests/expected/trait.nr
@@ -0,0 +1,2 @@
+trait Foo: Bar + Baz {}
+
diff --git a/tooling/nargo_fmt/tests/expected/trait_alias.nr b/tooling/nargo_fmt/tests/expected/trait_alias.nr
new file mode 100644
index 00000000000..926f3160279
--- /dev/null
+++ b/tooling/nargo_fmt/tests/expected/trait_alias.nr
@@ -0,0 +1,86 @@
+trait Foo {
+    fn foo(self) -> Self;
+}
+
+trait Baz = Foo;
+
+impl Foo for Field {
+    fn foo(self) -> Self {
+        self
+    }
+}
+
+fn baz<T>(x: T) -> T
+where
+    T: Baz,
+{
+    x.foo()
+}
+
+pub trait Foo_2 {
+    fn foo_2(self) -> Self;
+}
+
+pub trait Bar_2 {
+    fn bar_2(self) -> Self;
+}
+
+pub trait Baz_2 = Foo_2 + Bar_2;
+
+fn baz_2<T>(x: T) -> T
+where
+    T: Baz_2,
+{
+    x.foo_2().bar_2()
+}
+
+impl Foo_2 for Field {
+    fn foo_2(self) -> Self {
+        self + 1
+    }
+}
+
+impl Bar_2 for Field {
+    fn bar_2(self) -> Self {
+        self + 2
+    }
+}
+
+trait Foo_3 {
+    fn foo_3(self) -> Self;
+}
+
+trait Bar_3<T> {
+    fn bar_3(self) -> T;
+}
+
+trait Baz_3<T> = Foo_3 + Bar_3<T>;
+
+fn baz_3<T, U>(x: T) -> U
+where
+    T: Baz_3<U>,
+{
+    x.foo_3().bar_3()
+}
+
+impl Foo_3 for Field {
+    fn foo_3(self) -> Self {
+        self + 1
+    }
+}
+
+impl Bar_3<bool> for Field {
+    fn bar_3(self) -> bool {
+        true
+    }
+}
+
+fn main() {
+    let x: Field = 0;
+    let _ = baz(x);
+
+    assert(0.foo_2().bar_2() == baz_2(0));
+
+    assert(0.foo_3().bar_3() == baz_3(0));
+}
+
diff --git a/tooling/nargo_fmt/tests/expected/tuple.nr b/tooling/nargo_fmt/tests/expected/tuple.nr
index c3b32904f15..29f32f83e55 100644
--- a/tooling/nargo_fmt/tests/expected/tuple.nr
+++ b/tooling/nargo_fmt/tests/expected/tuple.nr
@@ -1,7 +1,9 @@
 fn main() {
     (1,);
-    (// hello
-        1,);
+    (
+        // hello
+        1,
+    );
     (/*hello*/ 1,);
     (1/*hello*/,);
     (1,);
@@ -10,23 +12,35 @@ fn main() {
     (/*a*/ 1/*b*/, /*c*/ 2/*d*/, /*c*/ 2/*d*/);
     (/*a*/ 1/*b*/, /*c*/ 2/*d*/, /*c*/ 2/*d*/, /*e*/ 3/*f*/);
 
-    (1/*1*/, 2/* 2*/);
+    (1 /*1*/, 2 /* 2*/);
 
-    (1/*test*/,);
+    (1 /*test*/,);
 
-    (//
-        1,);
+    (
+        //
+        1,
+    );
 
-    (// 1
-        1, // 2,
-        2);
+    (
+        // 1
+        1,
+        // 2,
+        2,
+    );
 
     (/*1*/ 1, /*2*/ 2);
 
-    // FIXME:
-    (((//2
-                1,),),);
-    (/*a*/
-        1/*b*/,
-/*c*/ 2/*d*/, /*c*/ 2/*d*/, /*e*/ 3/*f*/);
+    (
+        (
+            (
+                //2
+                1,
+            ),
+        ),
+    );
+    (
+        /*a*/ 1
+        /*b*/, /*c*/
+        2/*d*/, /*c*/ 2/*d*/, /*e*/ 3,/*f*/
+    );
 }
diff --git a/tooling/nargo_fmt/tests/expected/turbofish_call.nr b/tooling/nargo_fmt/tests/expected/turbofish_call.nr
index bcf0df9a969..aac36db7985 100644
--- a/tooling/nargo_fmt/tests/expected/turbofish_call.nr
+++ b/tooling/nargo_fmt/tests/expected/turbofish_call.nr
@@ -3,6 +3,6 @@ fn foo() {
 
     outer_function::<Field>(
         some_function(), // Original inner function call
-        another_function() // Original inner function call
+        another_function(), // Original inner function call
     );
 }
diff --git a/tooling/nargo_fmt/tests/expected/turbofish_method_call.nr b/tooling/nargo_fmt/tests/expected/turbofish_method_call.nr
index 52fa3db2ac9..cd09d7fea56 100644
--- a/tooling/nargo_fmt/tests/expected/turbofish_method_call.nr
+++ b/tooling/nargo_fmt/tests/expected/turbofish_method_call.nr
@@ -1,12 +1,8 @@
 fn foo() {
     my_object.some_method::<Field>(10, var_value, inner_method::<u32>(20, 30));
 
-    assert(
-        p4_affine.eq::<Field>(
-            Gaffine::new::<Field>(
-                6890855772600357754907169075114257697580319025794532037257385534741338397365,
-                4338620300185947561074059802482547481416142213883829469920100239455078257889
-            )
-        )
-    );
+    assert(p4_affine.eq::<Field>(Gaffine::new::<Field>(
+        6890855772600357754907169075114257697580319025794532037257385534741338397365,
+        4338620300185947561074059802482547481416142213883829469920100239455078257889,
+    )));
 }
diff --git a/tooling/nargo_fmt/tests/expected/vec.nr b/tooling/nargo_fmt/tests/expected/vec.nr
index 466c9844e74..15c198efafb 100644
--- a/tooling/nargo_fmt/tests/expected/vec.nr
+++ b/tooling/nargo_fmt/tests/expected/vec.nr
@@ -1,5 +1,5 @@
-struct Vec<T> { 
-    slice: [T]
+struct Vec<T> {
+    slice: [T],
 }
 
 // A mutable vector type implemented as a wrapper around immutable slices.
@@ -39,7 +39,7 @@ impl<T> Vec<T> {
         last_elem
     }
 
-    /// Insert an element at a specified index, shifting all elements 
+    /// Insert an element at a specified index, shifting all elements
     /// after it to the right
     pub fn insert(&mut self, index: Field, elem: T) {
         self.slice = self.slice.insert(index, elem);
diff --git a/tooling/nargo_fmt/tests/input/databus.nr b/tooling/nargo_fmt/tests/input/databus.nr
index 60934b60b2f..e47fcc50210 100644
--- a/tooling/nargo_fmt/tests/input/databus.nr
+++ b/tooling/nargo_fmt/tests/input/databus.nr
@@ -1,2 +1,2 @@
-fn main(x: pub u8, y: call_data u8) -> return_data u32 {}
+fn main(x: pub u8, y: call_data(0) u8) -> return_data u32 {  }
 
diff --git a/tooling/nargo_fmt/tests/input/fn.nr b/tooling/nargo_fmt/tests/input/fn.nr
index 8db6022808f..9e19222decb 100644
--- a/tooling/nargo_fmt/tests/input/fn.nr
+++ b/tooling/nargo_fmt/tests/input/fn.nr
@@ -47,12 +47,29 @@ pub fn from_baz(x: [Field; crate::foo::MAGIC_NUMBER]) {}
 
 fn id< T   ,    let  I :  Field > ( x :  [ Field ;  I ] )  -> [Field; I ]  {  }
 
-fn id_two<T, 
+fn id_two<T,
 let   I :    Field >(x: [Field ;  I])  ->   [ Field; I] {}
 
 fn whitespace_before_generics <    T   >  (foo: T) {}
 
-fn more_whitespace_before_generics   <    
+fn more_whitespace_before_generics   <
 T   >  (foo: T) {}
 
 fn with_unconstrained(x: unconstrained fn() -> ()) {}
+
+pub ( crate ) fn one() {}
+
+unconstrained   pub   fn two() {}
+
+unconstrained   pub  comptime   fn two() {}
+
+/// Documented
+#[test] fn three() {}
+
+#[test(should_fail)]
+// comment
+fn four() {}
+
+#[test(should_fail_with = "oops")]
+fn five() {}
+
diff --git a/tooling/nargo_fmt/tests/input/for.nr b/tooling/nargo_fmt/tests/input/for.nr
index 99b796df820..bf0a497fe65 100644
--- a/tooling/nargo_fmt/tests/input/for.nr
+++ b/tooling/nargo_fmt/tests/input/for.nr
@@ -12,6 +12,10 @@ fn for_stmt() {
             b *= b;
             
         }
+
+            for k in 0 ..=  C1 
+            {
+            d *= d; }
  
         z *= if b == 1 { 1 } else { c };
  
diff --git a/tooling/nargo_fmt/tests/input/ignore.nr b/tooling/nargo_fmt/tests/input/ignore.nr
index e095d2e9f1f..7d5a187146b 100644
--- a/tooling/nargo_fmt/tests/input/ignore.nr
+++ b/tooling/nargo_fmt/tests/input/ignore.nr
@@ -25,3 +25,4 @@ fn mk_array() {
     let array = [1,
                 ];
 }
+
diff --git a/tooling/nargo_fmt/tests/input/impl.nr b/tooling/nargo_fmt/tests/input/impl.nr
index e4adb8ebd6a..dae62033a65 100644
--- a/tooling/nargo_fmt/tests/input/impl.nr
+++ b/tooling/nargo_fmt/tests/input/impl.nr
@@ -10,6 +10,10 @@ impl MyType {
     fn method(mut self) {}
 
     fn method(&mut self) {}
+
+    fn method(self: Self) {}
+
+    fn method(mut self: Self) {}
 }
 
 impl MyType {
diff --git a/tooling/nargo_fmt/tests/input/struct.nr b/tooling/nargo_fmt/tests/input/struct.nr
index 5e3530e8364..2e5fff47f9e 100644
--- a/tooling/nargo_fmt/tests/input/struct.nr
+++ b/tooling/nargo_fmt/tests/input/struct.nr
@@ -5,7 +5,7 @@ struct Foo {
 
 struct Pair {
     first: Foo,
-    second: Field,
+    pub second: Field,
 }
 
 impl Foo {
diff --git a/tooling/nargo_fmt/tests/input/trait.nr b/tooling/nargo_fmt/tests/input/trait.nr
new file mode 100644
index 00000000000..0467585fac3
--- /dev/null
+++ b/tooling/nargo_fmt/tests/input/trait.nr
@@ -0,0 +1,2 @@
+trait Foo: Bar + Baz {}
+
diff --git a/tooling/nargo_fmt/tests/input/trait_alias.nr b/tooling/nargo_fmt/tests/input/trait_alias.nr
new file mode 100644
index 00000000000..53ae756795b
--- /dev/null
+++ b/tooling/nargo_fmt/tests/input/trait_alias.nr
@@ -0,0 +1,78 @@
+trait Foo {
+    fn foo(self) -> Self;
+}
+
+trait Baz = Foo;
+
+impl Foo for Field {
+    fn foo(self) -> Self { self }
+}
+
+fn baz<T>(x: T) -> T where T: Baz {
+    x.foo()
+}
+
+
+pub trait Foo_2 {
+    fn foo_2(self) -> Self;
+}
+
+pub trait Bar_2 {
+    fn bar_2(self) -> Self;
+}
+
+pub trait Baz_2 = Foo_2 + Bar_2;
+
+fn baz_2<T>(x: T) -> T where T: Baz_2 {
+    x.foo_2().bar_2()
+}
+
+impl Foo_2 for Field {
+    fn foo_2(self) -> Self {
+        self + 1
+    }
+}
+
+impl Bar_2 for Field {
+    fn bar_2(self) -> Self {
+        self + 2
+    }
+}
+
+
+trait Foo_3 {
+    fn foo_3(self) -> Self;
+}
+
+trait Bar_3<T> {
+    fn bar_3(self) -> T;
+}
+
+trait Baz_3<T> = Foo_3 + Bar_3<T>;
+
+fn baz_3<T, U>(x: T) -> U where T: Baz_3<U> {
+    x.foo_3().bar_3()
+}
+
+impl Foo_3 for Field {
+    fn foo_3(self) -> Self {
+        self + 1
+    }
+}
+
+impl Bar_3<bool> for Field {
+    fn bar_3(self) -> bool {
+        true
+    }
+}
+
+
+fn main() {
+    let x: Field = 0;
+    let _ = baz(x);
+
+    assert(0.foo_2().bar_2() == baz_2(0));
+
+    assert(0.foo_3().bar_3() == baz_3(0));
+}
+
diff --git a/tooling/nargo_fmt/tests/input/tuple.nr b/tooling/nargo_fmt/tests/input/tuple.nr
index da3b6ed597b..5be07be6ff4 100644
--- a/tooling/nargo_fmt/tests/input/tuple.nr
+++ b/tooling/nargo_fmt/tests/input/tuple.nr
@@ -32,7 +32,6 @@ fn main() {
 
 (/*1*/1, /*2*/2);
 
-// FIXME:
 (((
 //2
 1,),),);
diff --git a/tooling/nargo_toml/Cargo.toml b/tooling/nargo_toml/Cargo.toml
index e4766e44859..f5f7d7cd595 100644
--- a/tooling/nargo_toml/Cargo.toml
+++ b/tooling/nargo_toml/Cargo.toml
@@ -25,3 +25,5 @@ noirc_driver.workspace = true
 semver = "1.0.20"
 
 [dev-dependencies]
+tempfile.workspace = true
+test-case.workspace = true
diff --git a/tooling/nargo_toml/src/errors.rs b/tooling/nargo_toml/src/errors.rs
index 1ee8e90c8e5..7e1003d04f7 100644
--- a/tooling/nargo_toml/src/errors.rs
+++ b/tooling/nargo_toml/src/errors.rs
@@ -80,6 +80,8 @@ pub enum ManifestError {
 #[allow(clippy::enum_variant_names)]
 #[derive(Error, Debug, PartialEq, Eq, Clone)]
 pub enum SemverError {
+    #[error("Invalid value for `compiler_version` in package {package_name}. Requirements may only refer to full releases")]
+    InvalidCompilerVersionRequirement { package_name: CrateName, required_compiler_version: String },
     #[error("Incompatible compiler version in package {package_name}. Required compiler version is {required_compiler_version} but the compiler version is {compiler_version_found}.\n Update the compiler_version field in Nargo.toml to >={required_compiler_version} or compile this project with version {required_compiler_version}")]
     IncompatibleVersion {
         package_name: CrateName,
diff --git a/tooling/nargo_toml/src/git.rs b/tooling/nargo_toml/src/git.rs
index 80e57247ae6..efaed4fabb9 100644
--- a/tooling/nargo_toml/src/git.rs
+++ b/tooling/nargo_toml/src/git.rs
@@ -3,16 +3,20 @@ use std::path::PathBuf;
 /// Creates a unique folder name for a GitHub repo
 /// by using its URL and tag
 fn resolve_folder_name(base: &url::Url, tag: &str) -> String {
-    let mut folder_name = base.domain().unwrap().to_owned();
-    folder_name.push_str(base.path());
-    folder_name.push_str(tag);
-    folder_name
+    let mut folder = PathBuf::from("");
+    for part in [base.domain().unwrap(), base.path(), tag] {
+        folder.push(part.trim_start_matches('/'));
+    }
+    folder.to_string_lossy().into_owned()
 }
 
+/// Path to the `nargo` directory under `$HOME`.
 fn nargo_crates() -> PathBuf {
     dirs::home_dir().unwrap().join("nargo")
 }
 
+/// Target directory to download dependencies into, e.g.
+/// `$HOME/nargo/github.com/noir-lang/noir-bignum/v0.1.2`
 fn git_dep_location(base: &url::Url, tag: &str) -> PathBuf {
     let folder_name = resolve_folder_name(base, tag);
 
@@ -53,3 +57,19 @@ pub(crate) fn clone_git_repo(url: &str, tag: &str) -> Result<PathBuf, String> {
 
     Ok(loc)
 }
+
+#[cfg(test)]
+mod tests {
+    use test_case::test_case;
+    use url::Url;
+
+    use super::resolve_folder_name;
+
+    #[test_case("https://github.com/noir-lang/noir-bignum/"; "with slash")]
+    #[test_case("https://github.com/noir-lang/noir-bignum"; "without slash")]
+    fn test_resolve_folder_name(url: &str) {
+        let tag = "v0.4.2";
+        let dir = resolve_folder_name(&Url::parse(url).unwrap(), tag);
+        assert_eq!(dir, "github.com/noir-lang/noir-bignum/v0.4.2");
+    }
+}
diff --git a/tooling/nargo_toml/src/lib.rs b/tooling/nargo_toml/src/lib.rs
index c0d8c7997fd..b5c45977618 100644
--- a/tooling/nargo_toml/src/lib.rs
+++ b/tooling/nargo_toml/src/lib.rs
@@ -47,6 +47,35 @@ pub fn find_file_manifest(current_path: &Path) -> Option<PathBuf> {
 }
 
 /// Returns the [PathBuf] of the directory containing the `Nargo.toml` by searching from `current_path` to the root of its [Path].
+/// When `workspace` is `true` it returns the topmost directory, when `false` the innermost one.
+///
+/// Returns a [ManifestError] if no parent directories of `current_path` contain a manifest file.
+pub fn find_root(current_path: &Path, workspace: bool) -> Result<PathBuf, ManifestError> {
+    if workspace {
+        find_package_root(current_path)
+    } else {
+        find_file_root(current_path)
+    }
+}
+
+/// Returns the [PathBuf] of the directory containing the `Nargo.toml` by searching from `current_path` to the root of its [Path],
+/// returning at the innermost directory found, i.e. the one corresponding to the package that contains the `current_path`.
+///
+/// Returns a [ManifestError] if no parent directories of `current_path` contain a manifest file.
+pub fn find_file_root(current_path: &Path) -> Result<PathBuf, ManifestError> {
+    match find_file_manifest(current_path) {
+        Some(manifest_path) => {
+            let package_root = manifest_path
+                .parent()
+                .expect("infallible: manifest file path can't be root directory");
+            Ok(package_root.to_path_buf())
+        }
+        None => Err(ManifestError::MissingFile(current_path.to_path_buf())),
+    }
+}
+
+/// Returns the [PathBuf] of the directory containing the `Nargo.toml` by searching from `current_path` to the root of its [Path],
+/// returning at the topmost directory found, i.e. the one corresponding to the entire workspace.
 ///
 /// Returns a [ManifestError] if no parent directories of `current_path` contain a manifest file.
 pub fn find_package_root(current_path: &Path) -> Result<PathBuf, ManifestError> {
@@ -60,6 +89,11 @@ pub fn find_package_root(current_path: &Path) -> Result<PathBuf, ManifestError>
 }
 
 // TODO(#2323): We are probably going to need a "filepath utils" crate soon
+/// Get the root of path, for example:
+/// * `C:\foo\bar` -> `C:\foo`
+/// * `//shared/foo/bar` -> `//shared/foo`
+/// * `/foo` -> `/foo`
+/// otherwise empty path.
 fn path_root(path: &Path) -> PathBuf {
     let mut components = path.components();
 
@@ -101,6 +135,7 @@ pub fn find_package_manifest(
         })
     }
 }
+
 /// Returns the [PathBuf] of the `Nargo.toml` file in the `current_path` directory.
 ///
 /// Returns a [ManifestError] if `current_path` does not contain a manifest file.
@@ -469,7 +504,7 @@ fn resolve_package_from_toml(
     result
 }
 
-#[derive(Debug, PartialEq, Eq)]
+#[derive(Debug, PartialEq, Eq, Clone)]
 pub enum PackageSelection {
     Selected(CrateName),
     DefaultOrAll,
@@ -490,9 +525,20 @@ pub fn resolve_workspace_from_toml(
     Ok(workspace)
 }
 
-#[test]
-fn parse_standard_toml() {
-    let src = r#"
+#[cfg(test)]
+mod tests {
+    use std::{
+        path::{Path, PathBuf},
+        str::FromStr,
+    };
+
+    use test_case::test_matrix;
+
+    use crate::{find_root, Config, ManifestError};
+
+    #[test]
+    fn parse_standard_toml() {
+        let src = r#"
 
         [package]
         name = "test"
@@ -505,49 +551,49 @@ fn parse_standard_toml() {
         hello = {path = "./noir_driver"}
     "#;
 
-    assert!(Config::try_from(String::from(src)).is_ok());
-    assert!(Config::try_from(src).is_ok());
-}
+        assert!(Config::try_from(String::from(src)).is_ok());
+        assert!(Config::try_from(src).is_ok());
+    }
 
-#[test]
-fn parse_package_toml_no_deps() {
-    let src = r#"
+    #[test]
+    fn parse_package_toml_no_deps() {
+        let src = r#"
         [package]
         name = "test"
         authors = ["kev", "foo"]
         compiler_version = "*"
     "#;
 
-    assert!(Config::try_from(String::from(src)).is_ok());
-    assert!(Config::try_from(src).is_ok());
-}
+        assert!(Config::try_from(String::from(src)).is_ok());
+        assert!(Config::try_from(src).is_ok());
+    }
 
-#[test]
-fn parse_workspace_toml() {
-    let src = r#"
+    #[test]
+    fn parse_workspace_toml() {
+        let src = r#"
         [workspace]
         members = ["a", "b"]
     "#;
 
-    assert!(Config::try_from(String::from(src)).is_ok());
-    assert!(Config::try_from(src).is_ok());
-}
+        assert!(Config::try_from(String::from(src)).is_ok());
+        assert!(Config::try_from(src).is_ok());
+    }
 
-#[test]
-fn parse_workspace_default_member_toml() {
-    let src = r#"
+    #[test]
+    fn parse_workspace_default_member_toml() {
+        let src = r#"
         [workspace]
         members = ["a", "b"]
         default-member = "a"
     "#;
 
-    assert!(Config::try_from(String::from(src)).is_ok());
-    assert!(Config::try_from(src).is_ok());
-}
+        assert!(Config::try_from(String::from(src)).is_ok());
+        assert!(Config::try_from(src).is_ok());
+    }
 
-#[test]
-fn parse_package_expression_width_toml() {
-    let src = r#"
+    #[test]
+    fn parse_package_expression_width_toml() {
+        let src = r#"
     [package]
     name = "test"
     version = "0.1.0"
@@ -556,6 +602,124 @@ fn parse_package_expression_width_toml() {
     expression_width = "3"
     "#;
 
-    assert!(Config::try_from(String::from(src)).is_ok());
-    assert!(Config::try_from(src).is_ok());
+        assert!(Config::try_from(String::from(src)).is_ok());
+        assert!(Config::try_from(src).is_ok());
+    }
+
+    /// Test that `find_root` handles all kinds of prefixes.
+    /// (It dispatches based on `workspace` to methods which handle paths differently).
+    #[test_matrix(
+        [true, false],
+        ["C:\\foo\\bar", "//shared/foo/bar", "/foo/bar", "bar/baz", ""]
+    )]
+    fn test_find_root_does_not_panic(workspace: bool, path: &str) {
+        let path = PathBuf::from_str(path).unwrap();
+        let error = find_root(&path, workspace).expect_err("non-existing paths");
+        assert!(matches!(error, ManifestError::MissingFile(_)));
+    }
+
+    /// Test to demonstrate how `find_root` works.
+    #[test]
+    fn test_find_root_example() {
+        const INDENT_SIZE: usize = 4;
+        /// Create directories and files according to a YAML-like layout below
+        fn setup(layout: &str, root: &Path) {
+            fn is_dir(item: &str) -> bool {
+                !item.contains('.')
+            }
+            let mut current_dir = root.to_path_buf();
+            let mut current_indent = 0;
+            let mut last_item: Option<String> = None;
+
+            for line in layout.lines() {
+                if let Some((prefix, item)) = line.split_once('-') {
+                    let item = item.replace(std::path::MAIN_SEPARATOR, "_").trim().to_string();
+
+                    let indent = prefix.len() / INDENT_SIZE;
+
+                    if last_item.is_none() {
+                        current_indent = indent;
+                    }
+
+                    assert!(
+                        indent <= current_indent + 1,
+                        "cannot increase indent by more than {INDENT_SIZE}; item = {item}, current_dir={}", current_dir.display()
+                    );
+
+                    // Go into the last created directory
+                    if indent > current_indent && last_item.is_some() {
+                        let last_item = last_item.unwrap();
+                        assert!(is_dir(&last_item), "last item was not a dir: {last_item}");
+                        current_dir.push(last_item);
+                        current_indent += 1;
+                    }
+                    // Go back into an ancestor directory
+                    while indent < current_indent {
+                        current_dir.pop();
+                        current_indent -= 1;
+                    }
+                    // Create a file or a directory
+                    let item_path = current_dir.join(&item);
+                    if is_dir(&item) {
+                        std::fs::create_dir(&item_path).unwrap_or_else(|e| {
+                            panic!("failed to create dir {}: {e}", item_path.display())
+                        });
+                    } else {
+                        std::fs::write(&item_path, "").expect("failed to create file");
+                    }
+
+                    last_item = Some(item);
+                }
+            }
+        }
+
+        // Temporary directory to hold the project.
+        let tmp = tempfile::tempdir().unwrap();
+        // Join a string path to the tmp dir
+        let path = |p: &str| tmp.path().join(p);
+        // Check that an expected root is found
+        let assert_ok = |current_dir: &str, ws: bool, exp: &str| {
+            let root = find_root(&path(current_dir), ws).expect("should find a root");
+            assert_eq!(root, path(exp));
+        };
+        // Check that a root is not found
+        let assert_err = |current_dir: &str| {
+            find_root(&path(current_dir), true).expect_err("shouldn't find a root");
+        };
+
+        let layout = r"
+            - project
+                - docs
+                - workspace
+                    - packages
+                        - foo
+                            - Nargo.toml
+                            - Prover.toml
+                            - src
+                                - main.nr
+                        - bar
+                            - Nargo.toml
+                            - src
+                                - lib.nr
+                    - Nargo.toml
+                - examples
+                    - baz
+                        - Nargo.toml
+                        - src
+                            - main.nr
+            ";
+
+        // Set up the file system.
+        setup(layout, tmp.path());
+
+        assert_err("dummy");
+        assert_err("project/docs");
+        assert_err("project/examples");
+        assert_ok("project/workspace", true, "project/workspace");
+        assert_ok("project/workspace", false, "project/workspace");
+        assert_ok("project/workspace/packages/foo", true, "project/workspace");
+        assert_ok("project/workspace/packages/bar", false, "project/workspace/packages/bar");
+        assert_ok("project/examples/baz/src", true, "project/examples/baz");
+        assert_ok("project/examples/baz/src", false, "project/examples/baz");
+    }
 }
diff --git a/tooling/nargo_toml/src/semver.rs b/tooling/nargo_toml/src/semver.rs
index 253ac82aa34..ececa1b30dd 100644
--- a/tooling/nargo_toml/src/semver.rs
+++ b/tooling/nargo_toml/src/semver.rs
@@ -3,11 +3,14 @@ use nargo::{
     package::{Dependency, Package},
     workspace::Workspace,
 };
-use semver::{Error, Version, VersionReq};
+use noirc_driver::CrateName;
+use semver::{Error, Prerelease, Version, VersionReq};
 
 // Parse a semver compatible version string
 pub(crate) fn parse_semver_compatible_version(version: &str) -> Result<Version, Error> {
-    Version::parse(version)
+    let mut version = Version::parse(version)?;
+    version.pre = Prerelease::EMPTY;
+    Ok(version)
 }
 
 // Check that all of the packages in the workspace are compatible with the current compiler version
@@ -25,10 +28,7 @@ pub(crate) fn semver_check_workspace(
 }
 
 // Check that a package and all of its dependencies are compatible with the current compiler version
-pub(crate) fn semver_check_package(
-    package: &Package,
-    compiler_version: &Version,
-) -> Result<(), SemverError> {
+fn semver_check_package(package: &Package, compiler_version: &Version) -> Result<(), SemverError> {
     // Check that this package's compiler version requirements are satisfied
     if let Some(version) = &package.compiler_required_version {
         let version_req = match VersionReq::parse(version) {
@@ -40,6 +40,9 @@ pub(crate) fn semver_check_package(
                 })
             }
         };
+
+        validate_compiler_version_requirement(&package.name, &version_req)?;
+
         if !version_req.matches(compiler_version) {
             return Err(SemverError::IncompatibleVersion {
                 package_name: package.name.clone(),
@@ -61,6 +64,20 @@ pub(crate) fn semver_check_package(
     Ok(())
 }
 
+fn validate_compiler_version_requirement(
+    package_name: &CrateName,
+    required_compiler_version: &VersionReq,
+) -> Result<(), SemverError> {
+    if required_compiler_version.comparators.iter().any(|comparator| !comparator.pre.is_empty()) {
+        return Err(SemverError::InvalidCompilerVersionRequirement {
+            package_name: package_name.clone(),
+            required_compiler_version: required_compiler_version.to_string(),
+        });
+    }
+
+    Ok(())
+}
+
 // Strip the build meta data from the version string since it is ignored by semver.
 fn strip_build_meta_data(version: &Version) -> String {
     let version_string = version.to_string();
@@ -191,6 +208,26 @@ mod tests {
         };
     }
 
+    #[test]
+    fn test_semver_prerelease() {
+        let compiler_version = parse_semver_compatible_version("1.0.0-beta.0").unwrap();
+
+        let package = Package {
+            compiler_required_version: Some(">=0.1.0".to_string()),
+            root_dir: PathBuf::new(),
+            package_type: PackageType::Library,
+            entry_path: PathBuf::new(),
+            name: CrateName::from_str("test").unwrap(),
+            dependencies: BTreeMap::new(),
+            version: Some("1.0".to_string()),
+            expression_width: None,
+        };
+
+        if let Err(err) = semver_check_package(&package, &compiler_version) {
+            panic!("{err}");
+        };
+    }
+
     #[test]
     fn test_semver_build_data() {
         let compiler_version = Version::parse("0.1.0+this-is-ignored-by-semver").unwrap();
diff --git a/tooling/noir_codegen/package.json b/tooling/noir_codegen/package.json
index 75429cc4281..c96ecd22230 100644
--- a/tooling/noir_codegen/package.json
+++ b/tooling/noir_codegen/package.json
@@ -3,7 +3,7 @@
   "contributors": [
     "The Noir Team <team@noir-lang.org>"
   ],
-  "version": "0.34.0",
+  "version": "1.0.0-beta.0",
   "packageManager": "yarn@3.5.1",
   "license": "(MIT OR Apache-2.0)",
   "type": "module",
diff --git a/tooling/noir_js/package.json b/tooling/noir_js/package.json
index 55347ec9af5..0f0e111c30b 100644
--- a/tooling/noir_js/package.json
+++ b/tooling/noir_js/package.json
@@ -3,7 +3,7 @@
   "contributors": [
     "The Noir Team <team@noir-lang.org>"
   ],
-  "version": "0.34.0",
+  "version": "1.0.0-beta.0",
   "packageManager": "yarn@3.5.1",
   "license": "(MIT OR Apache-2.0)",
   "type": "module",
diff --git a/tooling/noir_js/src/index.ts b/tooling/noir_js/src/index.ts
index f3016efd032..ed0999a960c 100644
--- a/tooling/noir_js/src/index.ts
+++ b/tooling/noir_js/src/index.ts
@@ -2,7 +2,7 @@ import * as acvm from '@noir-lang/acvm_js';
 import * as abi from '@noir-lang/noirc_abi';
 import { CompiledCircuit } from '@noir-lang/types';
 
-export { ecdsa_secp256r1_verify, ecdsa_secp256k1_verify, keccak256, blake2s256, xor, and } from '@noir-lang/acvm_js';
+export { ecdsa_secp256r1_verify, ecdsa_secp256k1_verify, blake2s256, xor, and } from '@noir-lang/acvm_js';
 
 export { InputMap } from '@noir-lang/noirc_abi';
 export { WitnessMap, ForeignCallHandler, ForeignCallInput, ForeignCallOutput } from '@noir-lang/acvm_js';
diff --git a/tooling/noir_js_backend_barretenberg/.eslintignore b/tooling/noir_js_backend_barretenberg/.eslintignore
deleted file mode 100644
index b512c09d476..00000000000
--- a/tooling/noir_js_backend_barretenberg/.eslintignore
+++ /dev/null
@@ -1 +0,0 @@
-node_modules
\ No newline at end of file
diff --git a/tooling/noir_js_backend_barretenberg/.eslintrc.cjs b/tooling/noir_js_backend_barretenberg/.eslintrc.cjs
deleted file mode 100644
index 33335c2a877..00000000000
--- a/tooling/noir_js_backend_barretenberg/.eslintrc.cjs
+++ /dev/null
@@ -1,3 +0,0 @@
-module.exports = {
-  extends: ["../../.eslintrc.js"],
-};
diff --git a/tooling/noir_js_backend_barretenberg/.gitignore b/tooling/noir_js_backend_barretenberg/.gitignore
deleted file mode 100644
index 689b3ca0701..00000000000
--- a/tooling/noir_js_backend_barretenberg/.gitignore
+++ /dev/null
@@ -1,2 +0,0 @@
-crs
-lib
diff --git a/tooling/noir_js_backend_barretenberg/.mocharc.json b/tooling/noir_js_backend_barretenberg/.mocharc.json
deleted file mode 100644
index e1023f56327..00000000000
--- a/tooling/noir_js_backend_barretenberg/.mocharc.json
+++ /dev/null
@@ -1,11 +0,0 @@
-{
-  "require": "ts-node/register",
-  "loader": "ts-node/esm",
-  "extensions": [
-    "ts",
-    "cjs"
-  ],
-  "spec": [
-    "test/**/*.test.ts*"
-  ]
-}
diff --git a/tooling/noir_js_backend_barretenberg/fixup.sh b/tooling/noir_js_backend_barretenberg/fixup.sh
deleted file mode 100755
index 80bd7ec71a5..00000000000
--- a/tooling/noir_js_backend_barretenberg/fixup.sh
+++ /dev/null
@@ -1,18 +0,0 @@
-#!/usr/bin/env bash
-
-# Put these package.json files in the cjs and
-# mjs directory respectively, so that 
-# tools can recognise that the .js files are either
-# commonjs or ESM files.
-self_path=$(dirname "$(readlink -f "$0")")
-
-cjs_package='{
-    "type": "commonjs"
-}'
-
-esm_package='{
-    "type": "module"
-}'
-
-echo "$cjs_package" > $self_path/lib/cjs/package.json
-echo "$esm_package" > $self_path/lib/esm/package.json
\ No newline at end of file
diff --git a/tooling/noir_js_backend_barretenberg/package.json b/tooling/noir_js_backend_barretenberg/package.json
deleted file mode 100644
index fd6d21132c9..00000000000
--- a/tooling/noir_js_backend_barretenberg/package.json
+++ /dev/null
@@ -1,57 +0,0 @@
-{
-  "name": "@noir-lang/backend_barretenberg",
-  "contributors": [
-    "The Noir Team <team@noir-lang.org>"
-  ],
-  "version": "0.34.0",
-  "packageManager": "yarn@3.5.1",
-  "license": "(MIT OR Apache-2.0)",
-  "type": "module",
-  "homepage": "https://noir-lang.org/",
-  "repository": {
-    "url": "https://github.com/noir-lang/noir.git",
-    "directory": "tooling/noir_js_backend_barretenberg",
-    "type": "git"
-  },
-  "bugs": {
-    "url": "https://github.com/noir-lang/noir/issues"
-  },
-  "source": "src/index.ts",
-  "main": "lib/cjs/index.js",
-  "module": "lib/esm/index.js",
-  "exports": {
-    "require": "./lib/cjs/index.js",
-    "types": "./lib/esm/index.d.ts",
-    "default": "./lib/esm/index.js"
-  },
-  "types": "lib/esm/index.d.ts",
-  "files": [
-    "lib",
-    "package.json"
-  ],
-  "scripts": {
-    "dev": "tsc --watch",
-    "generate:package": "bash ./fixup.sh",
-    "build": "yarn clean && tsc && tsc -p ./tsconfig.cjs.json && yarn generate:package",
-    "clean": "rm -rf ./lib",
-    "prettier": "prettier 'src/**/*.ts'",
-    "prettier:fix": "prettier --write 'src/**/*.ts' 'test/**/*.ts'",
-    "nightly:version": "jq --arg new_version \"-$(git rev-parse --short HEAD)$1\" '.version = .version + $new_version' package.json > package-tmp.json && mv package-tmp.json package.json",
-    "publish": "echo 📡 publishing `$npm_package_name` && yarn npm publish",
-    "lint": "NODE_NO_WARNINGS=1 eslint . --ext .ts --ignore-path ./.eslintignore  --max-warnings 0"
-  },
-  "dependencies": {
-    "@aztec/bb.js": "0.56.0",
-    "@noir-lang/types": "workspace:*",
-    "fflate": "^0.8.0"
-  },
-  "devDependencies": {
-    "@types/node": "^20.6.2",
-    "@types/prettier": "^3",
-    "eslint": "^8.57.0",
-    "eslint-plugin-prettier": "^5.1.3",
-    "prettier": "3.2.5",
-    "ts-node": "^10.9.1",
-    "typescript": "5.4.2"
-  }
-}
diff --git a/tooling/noir_js_backend_barretenberg/src/backend.ts b/tooling/noir_js_backend_barretenberg/src/backend.ts
deleted file mode 100644
index 2569c7d868d..00000000000
--- a/tooling/noir_js_backend_barretenberg/src/backend.ts
+++ /dev/null
@@ -1,144 +0,0 @@
-import { acirToUint8Array } from './serialize.js';
-import { Backend, CompiledCircuit, ProofData, VerifierBackend } from '@noir-lang/types';
-import { deflattenFields } from './public_inputs.js';
-import { reconstructProofWithPublicInputs, reconstructProofWithPublicInputsHonk } from './verifier.js';
-import { BackendOptions, UltraPlonkBackend, UltraHonkBackend as UltraHonkBackendInternal } from '@aztec/bb.js';
-import { decompressSync as gunzip } from 'fflate';
-
-// This is the number of bytes in a UltraPlonk proof
-// minus the public inputs.
-const numBytesInProofWithoutPublicInputs: number = 2144;
-
-export class BarretenbergBackend implements Backend, VerifierBackend {
-  protected backend!: UltraPlonkBackend;
-
-  constructor(acirCircuit: CompiledCircuit, options: BackendOptions = { threads: 1 }) {
-    const acirBytecodeBase64 = acirCircuit.bytecode;
-    const acirUncompressedBytecode = acirToUint8Array(acirBytecodeBase64);
-    this.backend = new UltraPlonkBackend(acirUncompressedBytecode, options);
-  }
-
-  /** @description Generates a proof */
-  async generateProof(compressedWitness: Uint8Array): Promise<ProofData> {
-    const proofWithPublicInputs = await this.backend.generateProof(gunzip(compressedWitness));
-
-    const splitIndex = proofWithPublicInputs.length - numBytesInProofWithoutPublicInputs;
-
-    const publicInputsConcatenated = proofWithPublicInputs.slice(0, splitIndex);
-    const proof = proofWithPublicInputs.slice(splitIndex);
-    const publicInputs = deflattenFields(publicInputsConcatenated);
-
-    return { proof, publicInputs };
-  }
-
-  /**
-   * Generates artifacts that will be passed to a circuit that will verify this proof.
-   *
-   * Instead of passing the proof and verification key as a byte array, we pass them
-   * as fields which makes it cheaper to verify in a circuit.
-   *
-   * The proof that is passed here will have been created using a circuit
-   * that has the #[recursive] attribute on its `main` method.
-   *
-   * The number of public inputs denotes how many public inputs are in the inner proof.
-   *
-   * @example
-   * ```typescript
-   * const artifacts = await backend.generateRecursiveProofArtifacts(proof, numOfPublicInputs);
-   * ```
-   */
-  async generateRecursiveProofArtifacts(
-    proofData: ProofData,
-    numOfPublicInputs = 0,
-  ): Promise<{
-    proofAsFields: string[];
-    vkAsFields: string[];
-    vkHash: string;
-  }> {
-    const proof = reconstructProofWithPublicInputs(proofData);
-    return this.backend.generateRecursiveProofArtifacts(proof, numOfPublicInputs);
-  }
-
-  /** @description Verifies a proof */
-  async verifyProof(proofData: ProofData): Promise<boolean> {
-    const proof = reconstructProofWithPublicInputs(proofData);
-    return this.backend.verifyProof(proof);
-  }
-
-  async getVerificationKey(): Promise<Uint8Array> {
-    return this.backend.getVerificationKey();
-  }
-
-  async destroy(): Promise<void> {
-    await this.backend.destroy();
-  }
-}
-
-// Buffers are prepended with their size. The size takes 4 bytes.
-const serializedBufferSize = 4;
-const fieldByteSize = 32;
-const publicInputOffset = 3;
-const publicInputsOffsetBytes = publicInputOffset * fieldByteSize;
-
-export class UltraHonkBackend implements Backend, VerifierBackend {
-  // These type assertions are used so that we don't
-  // have to initialize `api` in the constructor.
-  // These are initialized asynchronously in the `init` function,
-  // constructors cannot be asynchronous which is why we do this.
-
-  protected backend!: UltraHonkBackendInternal;
-
-  constructor(acirCircuit: CompiledCircuit, options: BackendOptions = { threads: 1 }) {
-    const acirBytecodeBase64 = acirCircuit.bytecode;
-    const acirUncompressedBytecode = acirToUint8Array(acirBytecodeBase64);
-    this.backend = new UltraHonkBackendInternal(acirUncompressedBytecode, options);
-  }
-
-  async generateProof(compressedWitness: Uint8Array): Promise<ProofData> {
-    const proofWithPublicInputs = await this.backend.generateProof(gunzip(compressedWitness));
-    const proofAsStrings = deflattenFields(proofWithPublicInputs.slice(4));
-
-    const numPublicInputs = Number(proofAsStrings[1]);
-
-    // Account for the serialized buffer size at start
-    const publicInputsOffset = publicInputsOffsetBytes + serializedBufferSize;
-    // Get the part before and after the public inputs
-    const proofStart = proofWithPublicInputs.slice(0, publicInputsOffset);
-    const publicInputsSplitIndex = numPublicInputs * fieldByteSize;
-    const proofEnd = proofWithPublicInputs.slice(publicInputsOffset + publicInputsSplitIndex);
-    // Construct the proof without the public inputs
-    const proof = new Uint8Array([...proofStart, ...proofEnd]);
-
-    // Fetch the number of public inputs out of the proof string
-    const publicInputsConcatenated = proofWithPublicInputs.slice(
-      publicInputsOffset,
-      publicInputsOffset + publicInputsSplitIndex,
-    );
-    const publicInputs = deflattenFields(publicInputsConcatenated);
-
-    return { proof, publicInputs };
-  }
-
-  async verifyProof(proofData: ProofData): Promise<boolean> {
-    const proof = reconstructProofWithPublicInputsHonk(proofData);
-
-    return this.backend.verifyProof(proof);
-  }
-
-  async getVerificationKey(): Promise<Uint8Array> {
-    return this.backend.getVerificationKey();
-  }
-
-  // TODO(https://github.com/noir-lang/noir/issues/5661): Update this to handle Honk recursive aggregation in the browser once it is ready in the backend itself
-  async generateRecursiveProofArtifacts(
-    proofData: ProofData,
-    numOfPublicInputs: number,
-  ): Promise<{ proofAsFields: string[]; vkAsFields: string[]; vkHash: string }> {
-    const proof = reconstructProofWithPublicInputsHonk(proofData);
-    return this.backend.generateRecursiveProofArtifacts(proof, numOfPublicInputs);
-  }
-
-  async destroy(): Promise<void> {
-    await this.backend.destroy();
-  }
-}
diff --git a/tooling/noir_js_backend_barretenberg/src/base64_decode.ts b/tooling/noir_js_backend_barretenberg/src/base64_decode.ts
deleted file mode 100644
index d53aed187c7..00000000000
--- a/tooling/noir_js_backend_barretenberg/src/base64_decode.ts
+++ /dev/null
@@ -1,13 +0,0 @@
-// Since this is a simple function, we can use feature detection to
-// see if we are in the nodeJs environment or the browser environment.
-export function base64Decode(input: string): Uint8Array {
-  if (typeof Buffer !== 'undefined') {
-    // Node.js environment
-    return Buffer.from(input, 'base64');
-  } else if (typeof atob === 'function') {
-    // Browser environment
-    return Uint8Array.from(atob(input), (c) => c.charCodeAt(0));
-  } else {
-    throw new Error('No implementation found for base64 decoding.');
-  }
-}
diff --git a/tooling/noir_js_backend_barretenberg/src/index.ts b/tooling/noir_js_backend_barretenberg/src/index.ts
deleted file mode 100644
index f1786396a2a..00000000000
--- a/tooling/noir_js_backend_barretenberg/src/index.ts
+++ /dev/null
@@ -1,6 +0,0 @@
-export { BarretenbergBackend, UltraHonkBackend } from './backend.js';
-export { BarretenbergVerifier, UltraHonkVerifier } from './verifier.js';
-
-// typedoc exports
-export { Backend, CompiledCircuit, ProofData } from '@noir-lang/types';
-export { BackendOptions } from '@aztec/bb.js';
diff --git a/tooling/noir_js_backend_barretenberg/src/public_inputs.ts b/tooling/noir_js_backend_barretenberg/src/public_inputs.ts
deleted file mode 100644
index 10b4ee6ab32..00000000000
--- a/tooling/noir_js_backend_barretenberg/src/public_inputs.ts
+++ /dev/null
@@ -1,68 +0,0 @@
-import { WitnessMap } from '@noir-lang/types';
-
-export function flattenFieldsAsArray(fields: string[]): Uint8Array {
-  const flattenedPublicInputs = fields.map(hexToUint8Array);
-  return flattenUint8Arrays(flattenedPublicInputs);
-}
-
-export function deflattenFields(flattenedFields: Uint8Array): string[] {
-  const publicInputSize = 32;
-  const chunkedFlattenedPublicInputs: Uint8Array[] = [];
-
-  for (let i = 0; i < flattenedFields.length; i += publicInputSize) {
-    const publicInput = flattenedFields.slice(i, i + publicInputSize);
-    chunkedFlattenedPublicInputs.push(publicInput);
-  }
-
-  return chunkedFlattenedPublicInputs.map(uint8ArrayToHex);
-}
-
-export function witnessMapToPublicInputs(publicInputs: WitnessMap): string[] {
-  const publicInputIndices = [...publicInputs.keys()].sort((a, b) => a - b);
-  const flattenedPublicInputs = publicInputIndices.map((index) => publicInputs.get(index) as string);
-  return flattenedPublicInputs;
-}
-
-function flattenUint8Arrays(arrays: Uint8Array[]): Uint8Array {
-  const totalLength = arrays.reduce((acc, val) => acc + val.length, 0);
-  const result = new Uint8Array(totalLength);
-
-  let offset = 0;
-  for (const arr of arrays) {
-    result.set(arr, offset);
-    offset += arr.length;
-  }
-
-  return result;
-}
-
-function uint8ArrayToHex(buffer: Uint8Array): string {
-  const hex: string[] = [];
-
-  buffer.forEach(function (i) {
-    let h = i.toString(16);
-    if (h.length % 2) {
-      h = '0' + h;
-    }
-    hex.push(h);
-  });
-
-  return '0x' + hex.join('');
-}
-
-function hexToUint8Array(hex: string): Uint8Array {
-  const sanitised_hex = BigInt(hex).toString(16).padStart(64, '0');
-
-  const len = sanitised_hex.length / 2;
-  const u8 = new Uint8Array(len);
-
-  let i = 0;
-  let j = 0;
-  while (i < len) {
-    u8[i] = parseInt(sanitised_hex.slice(j, j + 2), 16);
-    i += 1;
-    j += 2;
-  }
-
-  return u8;
-}
diff --git a/tooling/noir_js_backend_barretenberg/src/serialize.ts b/tooling/noir_js_backend_barretenberg/src/serialize.ts
deleted file mode 100644
index b15931848a0..00000000000
--- a/tooling/noir_js_backend_barretenberg/src/serialize.ts
+++ /dev/null
@@ -1,8 +0,0 @@
-import { decompressSync as gunzip } from 'fflate';
-import { base64Decode } from './base64_decode.js';
-
-// Converts bytecode from a base64 string to a Uint8Array
-export function acirToUint8Array(base64EncodedBytecode: string): Uint8Array {
-  const compressedByteCode = base64Decode(base64EncodedBytecode);
-  return gunzip(compressedByteCode);
-}
diff --git a/tooling/noir_js_backend_barretenberg/src/verifier.ts b/tooling/noir_js_backend_barretenberg/src/verifier.ts
deleted file mode 100644
index 885ec80caa8..00000000000
--- a/tooling/noir_js_backend_barretenberg/src/verifier.ts
+++ /dev/null
@@ -1,67 +0,0 @@
-import { ProofData } from '@noir-lang/types';
-import { flattenFieldsAsArray } from './public_inputs.js';
-import { BackendOptions, BarretenbergVerifier as BarretenbergVerifierInternal } from '@aztec/bb.js';
-
-export class BarretenbergVerifier {
-  private verifier!: BarretenbergVerifierInternal;
-
-  constructor(options: BackendOptions = { threads: 1 }) {
-    this.verifier = new BarretenbergVerifierInternal(options);
-  }
-
-  /** @description Verifies a proof */
-  async verifyProof(proofData: ProofData, verificationKey: Uint8Array): Promise<boolean> {
-    const proof = reconstructProofWithPublicInputs(proofData);
-    return this.verifier.verifyUltraplonkProof(proof, verificationKey);
-  }
-
-  async destroy(): Promise<void> {
-    await this.verifier.destroy();
-  }
-}
-
-export function reconstructProofWithPublicInputs(proofData: ProofData): Uint8Array {
-  // Flatten publicInputs
-  const publicInputsConcatenated = flattenFieldsAsArray(proofData.publicInputs);
-
-  // Concatenate publicInputs and proof
-  const proofWithPublicInputs = Uint8Array.from([...publicInputsConcatenated, ...proofData.proof]);
-
-  return proofWithPublicInputs;
-}
-
-export class UltraHonkVerifier {
-  private verifier!: BarretenbergVerifierInternal;
-
-  constructor(options: BackendOptions = { threads: 1 }) {
-    this.verifier = new BarretenbergVerifierInternal(options);
-  }
-
-  /** @description Verifies a proof */
-  async verifyProof(proofData: ProofData, verificationKey: Uint8Array): Promise<boolean> {
-    const proof = reconstructProofWithPublicInputsHonk(proofData);
-    return this.verifier.verifyUltrahonkProof(proof, verificationKey);
-  }
-
-  async destroy(): Promise<void> {
-    await this.verifier.destroy();
-  }
-}
-
-const serializedBufferSize = 4;
-const fieldByteSize = 32;
-const publicInputOffset = 3;
-const publicInputsOffsetBytes = publicInputOffset * fieldByteSize;
-
-export function reconstructProofWithPublicInputsHonk(proofData: ProofData): Uint8Array {
-  // Flatten publicInputs
-  const publicInputsConcatenated = flattenFieldsAsArray(proofData.publicInputs);
-
-  const proofStart = proofData.proof.slice(0, publicInputsOffsetBytes + serializedBufferSize);
-  const proofEnd = proofData.proof.slice(publicInputsOffsetBytes + serializedBufferSize);
-
-  // Concatenate publicInputs and proof
-  const proofWithPublicInputs = Uint8Array.from([...proofStart, ...publicInputsConcatenated, ...proofEnd]);
-
-  return proofWithPublicInputs;
-}
diff --git a/tooling/noir_js_backend_barretenberg/tsconfig.cjs.json b/tooling/noir_js_backend_barretenberg/tsconfig.cjs.json
deleted file mode 100644
index ac1e3784480..00000000000
--- a/tooling/noir_js_backend_barretenberg/tsconfig.cjs.json
+++ /dev/null
@@ -1,8 +0,0 @@
-{
-  "extends": "./tsconfig.json",
-  "compilerOptions": {
-    "module": "CommonJS",
-    "moduleResolution": "Node",
-    "outDir": "./lib/cjs"
-  },
-}
diff --git a/tooling/noir_js_backend_barretenberg/tsconfig.json b/tooling/noir_js_backend_barretenberg/tsconfig.json
deleted file mode 100644
index 1e28c044bba..00000000000
--- a/tooling/noir_js_backend_barretenberg/tsconfig.json
+++ /dev/null
@@ -1,21 +0,0 @@
-{
-  "compilerOptions": {
-    "target": "esnext",
-    "declaration": true,
-    "emitDeclarationOnly": false,
-    "module": "NodeNext",
-    "moduleResolution": "NodeNext",
-    "outDir": "./lib/esm",
-    "esModuleInterop": true,
-    "resolveJsonModule": true,
-    "strict": true,
-    "noImplicitAny": false,
-  },
-  "include": ["src/**/*.ts"],
-  "exclude": ["node_modules"],
-  "references": [
-    {
-      "path": "../noir_js_types"
-    }
-  ]
-}
diff --git a/tooling/noir_js_types/package.json b/tooling/noir_js_types/package.json
index 21dd5beabeb..17e9efc7678 100644
--- a/tooling/noir_js_types/package.json
+++ b/tooling/noir_js_types/package.json
@@ -4,7 +4,7 @@
     "The Noir Team <team@noir-lang.org>"
   ],
   "packageManager": "yarn@3.5.1",
-  "version": "0.34.0",
+  "version": "1.0.0-beta.0",
   "license": "(MIT OR Apache-2.0)",
   "homepage": "https://noir-lang.org/",
   "repository": {
diff --git a/tooling/noir_js_types/src/types.ts b/tooling/noir_js_types/src/types.ts
index dd6548ddb6c..0cfe5d05a17 100644
--- a/tooling/noir_js_types/src/types.ts
+++ b/tooling/noir_js_types/src/types.ts
@@ -1,5 +1,5 @@
 export type Field = string | number | boolean;
-export type InputValue = Field | InputMap | (Field | InputMap)[];
+export type InputValue = Field | InputMap | InputValue[];
 export type InputMap = { [key: string]: InputValue };
 
 export type Visibility = 'public' | 'private' | 'databus';
@@ -20,6 +20,7 @@ export type AbiParameter = {
 };
 
 export type AbiErrorType =
+  | { error_kind: 'string'; string: string }
   | {
       error_kind: 'fmtstring';
       length: number;
@@ -39,7 +40,7 @@ export type WitnessMap = Map<number, string>;
 export type Abi = {
   parameters: AbiParameter[];
   return_type: { abi_type: AbiType; visibility: Visibility } | null;
-  error_types: Record<string, AbiErrorType>;
+  error_types: Partial<Record<string, AbiErrorType>>;
 };
 
 export interface VerifierBackend {
diff --git a/tooling/noirc_abi/Cargo.toml b/tooling/noirc_abi/Cargo.toml
index a7baf334bff..22114408e18 100644
--- a/tooling/noirc_abi/Cargo.toml
+++ b/tooling/noirc_abi/Cargo.toml
@@ -23,8 +23,8 @@ num-bigint = "0.4"
 num-traits = "0.2"
 
 [dev-dependencies]
-strum = "0.24"
-strum_macros = "0.24"
+strum.workspace = true
+strum_macros.workspace = true
 proptest.workspace = true
 proptest-derive.workspace = true
 
diff --git a/tooling/noirc_abi/proptest-regressions/input_parser/json.txt b/tooling/noirc_abi/proptest-regressions/input_parser/json.txt
new file mode 100644
index 00000000000..19de8eeaf48
--- /dev/null
+++ b/tooling/noirc_abi/proptest-regressions/input_parser/json.txt
@@ -0,0 +1,7 @@
+# Seeds for failure cases proptest has generated in the past. It is
+# automatically read and these particular cases re-run before any
+# novel cases are generated.
+#
+# It is recommended to check this file in to source control so that
+# everyone who runs the test benefits from these saved cases.
+cc b3f9ae88d54944ca274764f4d99a2023d4b0ac09beb89bc599cbba1e45dd3620 # shrinks to (typ, value) = (Integer { sign: Signed, width: 1 }, -1)
diff --git a/tooling/noirc_abi/proptest-regressions/input_parser/toml.txt b/tooling/noirc_abi/proptest-regressions/input_parser/toml.txt
new file mode 100644
index 00000000000..1448cb67ef1
--- /dev/null
+++ b/tooling/noirc_abi/proptest-regressions/input_parser/toml.txt
@@ -0,0 +1,9 @@
+# Seeds for failure cases proptest has generated in the past. It is
+# automatically read and these particular cases re-run before any
+# novel cases are generated.
+#
+# It is recommended to check this file in to source control so that
+# everyone who runs the test benefits from these saved cases.
+cc 9d200afb8f5c01e3414d24eebe1436a7eef5377a46a9a9235aaa7f81e0b33656 # shrinks to (typ, value) = (Integer { sign: Signed, width: 8 }, -1)
+cc 7fd29637e5566d819992185c1a95438e9949a555928a911b3918eed2e3f7a1fd # shrinks to (typ, value) = (Integer { sign: Signed, width: 64 }, -1)
+cc 8ecbda39d887674b53ca23a861ac30fbb10c123bb70c57e69b336c86a3d9dea8 # shrinks to (abi, input_map) = (Abi { parameters: [AbiParameter { name: "¡", typ: Struct { path: "�)\u{1b}=�?Ⱥ\u{59424}?{\u{e4d5e}%Ѩ/Q\u{36a17}/*\";\u{b}&iC_\u{d313f}S\u{1b}\u{9dfec}\r/\u{10530d}", fields: [("?p*\"/\u{202e}\u{6f038}\u{537ca}.y@~𘛶?4\u{1b}*", Field), (".Ⱥ/$\u{7f}\u{103c06}%\\\u{202e}][0\u{88479}]\"*~\u{36fd5}\u{5}\u{feff}]{/", Tuple { fields: [String { length: 937 }] }), ("r\u{ac3a5}&:", Boolean), ("$d6🕴/:|�\u{37f8b}\r\u{a13b7}C$𲁹\\&\u{f8712}?\u{db61c}t%\u{57be1}\0", Field), ("/\u{6378b}\u{a426c}¥\u{7}/\u{fcb29}$\u{53c6b}\u{12d6f}\u{12bd3}.\u{f2f82}\u{8613e}*$\u{fd32f}\u{e29f7}\0𨺉'¬\"1", Struct { path: "\\\u{4a5ac}<\u{9e505}\u{4f3af}🕴&?<:^\u{7}\u{88}\u{3e1ff}(¥\u{531f3}K{:¥𦺀", fields: [("n\0Ѩ/\u{1b}𥐰\u{a4906}�¥`{\u{389d4}`1\u{7708a})\u{3dac4}8\u{93e5f}㒭\\\"\u{e6824}\u{b}Ѩ\u{88946}Ⱥ{", Integer { sign: Signed, width: 127 })] }), ("¥🕴\u{1b}¥🕴=sR\0\u{35f36}\u{867dc}>ä\u{202e}f:BȺ?:``*·¥\u{74ca5}\"", Tuple { fields: [Boolean, Field, String { length: 205 }, String { length: 575 }, Integer { sign: Signed, width: 124 }, String { length: 923 }, String { length: 294 }] })] }, visibility: Public }], return_type: None, error_types: {} }, {"¡": Struct({"$d6🕴/:|�\u{37f8b}\r\u{a13b7}C$𲁹\\&\u{f8712}?\u{db61c}t%\u{57be1}\0": Field(-8275115097504119425402713293372777967031130481426075481525511323101167533940), ".Ⱥ/$\u{7f}\u{103c06}%\\\u{202e}][0\u{88479}]\"*~\u{36fd5}\u{5}\u{feff}]{/": Vec([String("A  \0A 0 aA0  a0aa00 A\000  0   \0\0aA\0\0a \0   \0a 0A\0A\0 Aa0aAA0A\0aa\00 0\0\0\0\0\00a Aa0 \0 a A0 \0AA0A Aa  Aa\00aAaAaaA0A0 aA0 \0 Aa\00 \0000AAA a \0AAaaA\0\0a A0a0AA\0aA00 aA a0A\0AAa0a\0A0a\0\0A0A \00Aaaaa  a  A AO.*D\r.`bD4a\n*\u{15}\\B\"ace.8&A\t[AV8w<\u{18}\"\u{f}4`^Q\u{1b}U*$Z/\0\u{b}]qw${`\"=X&A\\\u{e}%`\\:\"$\u{1}.(6_C:\u{7}a`V=N**\u{1b})#Y\u{7f}#\u{b}$l\t}.Mns5!\t*$g\u{18}\rC\u{11}\"$=\u{7}.?&\u{1}yW\t.Y|<6\u{12}\u{e}/4J<X\n$.8Pwi;4.H*}0Q WU`}%CH6L{-K{'Ph:H\u{7f}Z\u{7f}wD;/\u{16}\u{5}|{t/.=z\u{1}\"\u{1e}\u{1b}<*\\\\\"?xX?j$>J*&/V$`\"&`x#R\np\\%'*\n:P\0K\u{b}*`\r7Ym\t_\u{b}=$\u{16}`0v\u{7f}'NV^N4J<9=G*A:!b\u{1c}:'c{ST&z![\u{7f}/.={E*pmaWC\u{7f}7p{<\"']\u{8}?`\u{1b}\"\\\u{1}$\u{18}/!\u{16}-\t:E7CUs%_qw*xf.S\t\u{4}'=\"&%t'\u{1f}\u{7f}\u{b}$<zt;?.ma&8\u{1b}$*//\0\u{1b}O.\u{7f}`\u{b}l&@r\n\u{7f}\u{16}krd?/_E7U</\u{1b}\\\u{b}{`:&.q*|$\u{14}F\\Y`88\u{1c}O|{L\u{15}e1;`slh\u{b}:=QM<*e\"?\u{17}\u{b}\t*\r<:*\u{b}\u{7f}'\u{18}\u{c}\u{17}&%\"\u{7f}$x'\u{18}$<A:t\u{19}L{}K\nlOwUP\u{7f},`%?{{:\u{8}?GU\u{10}F:\\*3}\u{b}Ka.\u{7f}<\ra\u{10}`#rF\nZ\rc*%\u{b}$/\u{b}%aEV<41]^\0=B|y3Q,\u{b}`p\u{b}<*Z4:XMWP\n\0\u{1a}T>.=f\u{6}\"$A}xV_$\u{1a}nH\n\u{1b}?<&\n\u{15}U\\-b\u{1d}|\u{b}\u{2}t \rwA{L\u{11}\u{6}\u{10}\0\u{1b}G[x?&Yi?&7\u{b}?\r\u{1f}b\\$=\u{b}x& Q/\t\u{4}|X\"7\"{\0\0j'.\0\\e1zR.\u{c}\n<\u{b}Q*R+y8\u{19}(o\u{1f}@m\nt+<S\nN\u{1e}j\u{1b}\"\r$\"&`\u{14}-<NE*nxC\r\u{14}'8\t.IN1V?$HC$\u{1b}I\"@\u{7f}\"s?\nVcjr\u{1b}\08/\"S=>\u{7f}Q\\+.Rn?\u{17}UZ\"$\u{b}/\0B=9=\t{\u{8}qZ&`!:D{\u{6}IO.H\u{7f}:?/3@\r\u{1b}o<OS\u{7f}a\0&lOy\n{w(**0c")]), "/\u{6378b}\u{a426c}¥\u{7}/\u{fcb29}$\u{53c6b}\u{12d6f}\u{12bd3}.\u{f2f82}\u{8613e}*$\u{fd32f}\u{e29f7}\0𨺉'¬\"1": Struct({"n\0Ѩ/\u{1b}𥐰\u{a4906}�¥`{\u{389d4}`1\u{7708a})\u{3dac4}8\u{93e5f}㒭\\\"\u{e6824}\u{b}Ѩ\u{88946}Ⱥ{": Field(96037160722359396044901023537963606465)}), "?p*\"/\u{202e}\u{6f038}\u{537ca}.y@~𘛶?4\u{1b}*": Field(0), "r\u{ac3a5}&:": Field(1), "¥🕴\u{1b}¥🕴=sR\0\u{35f36}\u{867dc}>ä\u{202e}f:BȺ?:``*·¥\u{74ca5}\"": Vec([Field(1), Field(8822392870083219098626030699076694602179106416928939583840848325203494062169), String("*TXn;{}\"_)_9\nk\\#ts\u{10}%\\c\n/2._::Oj*\u{7f}\0\r&PUMl\u{10}$/u?L}\u{7f}*P&<%=\u{7}S#%A\n \u{e}\\#v!\"\nepRp.{vH{&@\t\u{1f}\u{b}?=T\u{f}\"B\u{11}\n/{HY.\u{16}\n\nj<&\u{3}{f\n/9J*&x.$/,\r\0\u{1c}'\u{5}\u{13}\u{1b}`T\0`\n&/&\u{15}\u{b}w:{SK\u{7f}\\apR%/'0`0\n'd$$\u{7f}Vs\t<{\nDTT\\F\n\u{15}y.\\\t*-)&D$*u\u{b}\u{1b}?{\u{b}/\n\u{7f}0*.7\0\n:\u{b}.rSk<6~>{#"), String(".\"JA%q6i\ra/:F\u{16}?q<\t\rN\\13?H<;?{`\u{1d}p{.\"5?*@'N\"\u{1a}P,\u{1b}\u{7f}c+dt5':Y\u{1b}k/G>k/eM$XIX')\u{1b}'&\u{7f}\\\r\u{1b}`'P_.\n.?\0p`Y\u{c}`._\u{b}B\0\ng/*v$jfJ:\u{c}<b\r~o\u{7f}\u{b}\\lyE*'\u{7f}~j:.N0U <\0?*D\0%P\u{7f}\u{15}4j$\u{5}s\u{b}\"{F/:\u{1b}\u{b}\u{1b}.f\"+\tcw\\:\u{b}<@(V.}`Ws`h%j}x&'\u{5}!4e?KT#\u{b}'Y\\6\0m\u{b}\\\u{8}Eo7.Jk&\u{b},3\u{17}Jd\0y*\tC\u{3}\\\u{f}l\".*'\"\u{1b}\u{12} \"{^*!`\n\u{1b}#Ox\u{7f}{\u{1b}&?_$\u{1b}{G`'\0bdiouv`\u{17}\u{7f}B.zq?'\0Ys\tb\n&&:?\\u'h::l%\\'`i\t'{=2?1\u{b}N\u{7f}&`<;\0\u{1e}=\u{7f}\u{16}dHdri\u{7f}'`;LB$\nJ\u{16}\n.\u{1a}*eqr\rdgU\\\u{1b}\u{19}4Ry\n5$J`&\\\u{b}:f\"/=q\0{R+U\t*&W$\u{14}\0v~'<\u{1b}<>\u{1b}Pv}xn7ph@#{_<{.JD?r%'E\n7s9n/],u![;%*\u{2}{y`MgRdok8\"%<*>*{GyFJ}?\0W%#\0\u{1b}\u{7f}\u{16}G:\t=w\u{7f}:q\u{7f}:{k?\u{b}(:ca{$*1X/cw\u{1b}Z6I\rX\0\u{1b}(.^14\r\\=s\u{1b}w\u{3}F~\n\u{1e})/$0:=[\u{1},\\\\\t<K\0nI\\P&:.{<\u{18}g<+^.uk\0\u{13}b`.;\\G\\S{!/:&\"y8%7R\u{5}\u{12}j\u{b}\\Gf&N$|F><n$J<\u{b}z''\u{b})\u{7f}lwc\t/"), Field(21267647932558653966460912964485513215), String("\0\t3\u{b}M\n?B\u{7f}:n&C\u{6}`>g\u{16}:<Z\u{13}z}w{:^#>],J`\0N\n\u{1b}\u{1b}\u{1b}{.xb\u{1a}\r'12#?e\\#/\tA\u{7f}\".\\Ke=\\?!v+P\u{17}\r\u{12}x.=A.`0<&?\niR/*WW\rnV)5<yob%\u{7f}\u{16}wS`_\u{1a}\0`>vY.~\n _h\0&5f#\r\u{2}-S%\t s..\u{7f}!X}\"=\"<?Ia&\u{e}8\t\u{e}%?u'\u{1b}b\u{1b}\r1=\u{b}\u{1b}%m\tAN'l\u{3}V\u{7}:q{\n<\u{b}Q'\u{13}\\\r%#\"\\%i%\\\r\r:5=%',U?D\u{19}oS\u{1c}\"/\043\"x5Twu&\u{5}:G*.<\u{c}\u{7f}%1^\n=\u{3}\u{b}\norXp\"vF??&\u{16}eZdM.t%t/h@F&:O\u{11}xD=\n%`\nXT|cSH:\u{b}\u{15}19T$:\r\r/%\u{b}H\tJ\nY`u\u{2},&\0/\r\u{f}5L\0rFa\0\n(*,$p\r(oc\u{7f}Ua?3/\\\u{17}$&\n\u{e}G\"\\Kv]%={3U\u{7f}:{\":@wk7?C~t;\u{1b}!\u{1a}*V+&\"k\u{14}`9\u{7f}w\04\0sO\u{2}2Q\tZ\n>?\u{5}y\u{4}`fr&R&d: 1Ht\"4`y_/S.71#{|%$%&ehy\u{16}J_\u{e}=:.%'\"N=J:\r:{&.\u{12}\u{b})&N\u{10}R_3;11\u{b}Qd<`<{?xF:~\"%<=<<\03:t??&\r;{\u{13}<z\u{7f}\\\n>?__Y\u{6})\\k,vs?\n`G(*\n!\u{1b}[@z\0$?*yKLJh_\u{13}F<uZ?q{,\u{16}\0tLp!H\ra?&b?{{jWi\0/&`?5<\0$=m\"Q\"\u{1b}{J8\u{1}.*1\" t*~{.K\u{12}.1:`'#q$((q=I*['&\u{11}:\u{6}^v\u{17}{C.R<9#\u{1b}{\0\"K&xD0\u{15}d2u\u{b} p*k7\u{1b}:\u{16}L2x\u{1d}\u{b}{\t\tt\u{1b}U'\0\t+'\0g\u{b}'\r/\nio.\u{6}=@Z7\t?){\u{7f}\"\"={eW\u{7}:w._=<5\r%\n\u{6}\nws\0e<\\6\u{1a}<i.*s'\r{c'raI:\"?\n=]n[z\u{7f}+:\u{1b}4p&@?$e {H.%?:\u{12}\u{1b}z\\\u{b}\\aI?\t\u{1b}${/\rM*\u{1b}:]*\r.c$u'PmM(lLo@PH~1P}$H?_Ia5$Rg6]-JC`<$*/\u{7f}<TK(jMY\u{19}%<?A%!4'2\u{13}b$$=/q\u{18}=&\r\u{1b}?%5jK\0%2<:\u{7f}olOMXI*\u{1e}r2ua6\".u)k:A'\u{1b}Rh8k\u{19}\u{1a}=M#u;#>kY'\\?T^\u{1f}$1n`'[\n\u{7f}\0+l\u{b}\u{1a}E\u{b}&(/\u{b}\rr\t:&\0<s8/\u{b}\thCB\n\u{6}*%cO~<V/Ql*2r\t"), String("Z%*?]R{\u{b}\0T\\\u{1b}+J?=P4?\u{b}L\u{2}/\0\u{1b}\r\0.\n$4\u{b}:?a{SF\u{b}\u{1b}=\\j\t{\"\\B\u{5}'$.}`X\u{1b}\\.\u{1c}6*\u{7f}j<&?$b `<<\0KkAQ)</\0?9\u{18}N$%\0.\tO\u{7f}\0\tUkI*7'\u{1c}t=x\r*S{\u{5}I/\t\u{7f}5\":b=j\u{16}\"\u{b}8<\u{e}\u{7f}la\u{b}?.aV}\u{6}{(={P42Qo*uX=\u{1a}M:k}l2-&qM*{{\u{6}ut%\u{1b}\0\\\r\rw/\0\u{1d}+Bc\u{7}\u{b}f\"'Z l\u{7f}:nD4\u{1f}$5ONG\r\rFd\r.c'r'Nt\rn-Z\\\tk2s*GK!7D&KX/^6%>+N'N:oC:*``IN\u{b}*.:\t$7+'*U:\t<y<6nu'9/RIP/'\u{b}\\mj\u{6}\u{7f}#\u{1c}@Rh<*\\b*f\0xa6\n")])})})
diff --git a/tooling/noirc_abi/src/input_parser/json.rs b/tooling/noirc_abi/src/input_parser/json.rs
index 070f9effe42..a8ba83a3a65 100644
--- a/tooling/noirc_abi/src/input_parser/json.rs
+++ b/tooling/noirc_abi/src/input_parser/json.rs
@@ -1,4 +1,4 @@
-use super::{parse_str_to_field, InputValue};
+use super::{field_to_signed_hex, parse_str_to_field, parse_str_to_signed, InputValue};
 use crate::{errors::InputParserError, Abi, AbiType, MAIN_RETURN_NAME};
 use acvm::{AcirField, FieldElement};
 use iter_extended::{try_btree_map, try_vecmap};
@@ -60,7 +60,7 @@ pub(crate) fn serialize_to_json(
     Ok(json_string)
 }
 
-#[derive(Debug, Deserialize, Serialize, Clone)]
+#[derive(Debug, Deserialize, Serialize, Clone, PartialEq)]
 #[serde(untagged)]
 pub enum JsonTypes {
     // This is most likely going to be a hex string
@@ -86,6 +86,9 @@ impl JsonTypes {
         abi_type: &AbiType,
     ) -> Result<JsonTypes, InputParserError> {
         let json_value = match (value, abi_type) {
+            (InputValue::Field(f), AbiType::Integer { sign: crate::Sign::Signed, width }) => {
+                JsonTypes::String(field_to_signed_hex(*f, *width))
+            }
             (InputValue::Field(f), AbiType::Field | AbiType::Integer { .. }) => {
                 JsonTypes::String(Self::format_field_string(*f))
             }
@@ -143,6 +146,9 @@ impl InputValue {
     ) -> Result<InputValue, InputParserError> {
         let input_value = match (value, param_type) {
             (JsonTypes::String(string), AbiType::String { .. }) => InputValue::String(string),
+            (JsonTypes::String(string), AbiType::Integer { sign: crate::Sign::Signed, width }) => {
+                InputValue::Field(parse_str_to_signed(&string, *width)?)
+            }
             (
                 JsonTypes::String(string),
                 AbiType::Field | AbiType::Integer { .. } | AbiType::Boolean,
@@ -192,3 +198,40 @@ impl InputValue {
         Ok(input_value)
     }
 }
+
+#[cfg(test)]
+mod test {
+    use proptest::prelude::*;
+
+    use crate::{
+        arbitrary::arb_abi_and_input_map,
+        input_parser::{arbitrary::arb_signed_integer_type_and_value, json::JsonTypes, InputValue},
+    };
+
+    use super::{parse_json, serialize_to_json};
+
+    proptest! {
+        #[test]
+        fn serializing_and_parsing_returns_original_input((abi, input_map) in arb_abi_and_input_map()) {
+            let json = serialize_to_json(&input_map, &abi).expect("should be serializable");
+            let parsed_input_map = parse_json(&json, &abi).expect("should be parsable");
+
+            prop_assert_eq!(parsed_input_map, input_map);
+        }
+
+        #[test]
+        fn signed_integer_serialization_roundtrip((typ, value) in arb_signed_integer_type_and_value()) {
+            let string_input = JsonTypes::String(value.to_string());
+            let input_value = InputValue::try_from_json(string_input, &typ, "foo").expect("should be parsable");
+            let JsonTypes::String(output_string) = JsonTypes::try_from_input_value(&input_value, &typ).expect("should be serializable") else {
+                panic!("wrong type output");
+            };
+            let output_number = if let Some(output_string) = output_string.strip_prefix("-0x") {
+                -i64::from_str_radix(output_string, 16).unwrap()
+            } else {
+                i64::from_str_radix(output_string.strip_prefix("0x").unwrap(), 16).unwrap()
+            };
+            prop_assert_eq!(output_number, value);
+        }
+    }
+}
diff --git a/tooling/noirc_abi/src/input_parser/mod.rs b/tooling/noirc_abi/src/input_parser/mod.rs
index d7bbb0adfe3..b7732235eb2 100644
--- a/tooling/noirc_abi/src/input_parser/mod.rs
+++ b/tooling/noirc_abi/src/input_parser/mod.rs
@@ -248,6 +248,11 @@ mod serialization_tests {
                     typ: AbiType::Field,
                     visibility: AbiVisibility::Private,
                 },
+                AbiParameter {
+                    name: "signed_example".into(),
+                    typ: AbiType::Integer { sign: Sign::Signed, width: 8 },
+                    visibility: AbiVisibility::Private,
+                },
                 AbiParameter {
                     name: "bar".into(),
                     typ: AbiType::Struct {
@@ -272,6 +277,7 @@ mod serialization_tests {
 
         let input_map: BTreeMap<String, InputValue> = BTreeMap::from([
             ("foo".into(), InputValue::Field(FieldElement::one())),
+            ("signed_example".into(), InputValue::Field(FieldElement::from(240u128))),
             (
                 "bar".into(),
                 InputValue::Struct(BTreeMap::from([
@@ -317,7 +323,9 @@ fn parse_str_to_field(value: &str) -> Result<FieldElement, InputParserError> {
 }
 
 fn parse_str_to_signed(value: &str, width: u32) -> Result<FieldElement, InputParserError> {
-    let big_num = if let Some(hex) = value.strip_prefix("0x") {
+    let big_num = if let Some(hex) = value.strip_prefix("-0x") {
+        BigInt::from_str_radix(hex, 16).map(|value| -value)
+    } else if let Some(hex) = value.strip_prefix("0x") {
         BigInt::from_str_radix(hex, 16)
     } else {
         BigInt::from_str_radix(value, 10)
@@ -357,12 +365,23 @@ fn field_from_big_int(bigint: BigInt) -> FieldElement {
     }
 }
 
+fn field_to_signed_hex(f: FieldElement, bit_size: u32) -> String {
+    let f_u128 = f.to_u128();
+    let max = 2_u128.pow(bit_size - 1) - 1;
+    if f_u128 > max {
+        let f = FieldElement::from(2_u128.pow(bit_size) - f_u128);
+        format!("-0x{}", f.to_hex())
+    } else {
+        format!("0x{}", f.to_hex())
+    }
+}
+
 #[cfg(test)]
 mod test {
     use acvm::{AcirField, FieldElement};
     use num_bigint::BigUint;
 
-    use super::parse_str_to_field;
+    use super::{parse_str_to_field, parse_str_to_signed};
 
     fn big_uint_from_field(field: FieldElement) -> BigUint {
         BigUint::from_bytes_be(&field.to_be_bytes())
@@ -400,4 +419,38 @@ mod test {
         let noncanonical_field = FieldElement::modulus().to_string();
         assert!(parse_str_to_field(&noncanonical_field).is_err());
     }
+
+    #[test]
+    fn test_parse_str_to_signed() {
+        let value = parse_str_to_signed("1", 8).unwrap();
+        assert_eq!(value, FieldElement::from(1_u128));
+
+        let value = parse_str_to_signed("-1", 8).unwrap();
+        assert_eq!(value, FieldElement::from(255_u128));
+
+        let value = parse_str_to_signed("-1", 16).unwrap();
+        assert_eq!(value, FieldElement::from(65535_u128));
+    }
+}
+
+#[cfg(test)]
+mod arbitrary {
+    use proptest::prelude::*;
+
+    use crate::{AbiType, Sign};
+
+    pub(super) fn arb_signed_integer_type_and_value() -> BoxedStrategy<(AbiType, i64)> {
+        (2u32..=64)
+            .prop_flat_map(|width| {
+                let typ = Just(AbiType::Integer { width, sign: Sign::Signed });
+                let value = if width == 64 {
+                    // Avoid overflow
+                    i64::MIN..i64::MAX
+                } else {
+                    -(2i64.pow(width - 1))..(2i64.pow(width - 1) - 1)
+                };
+                (typ, value)
+            })
+            .boxed()
+    }
 }
diff --git a/tooling/noirc_abi/src/input_parser/toml.rs b/tooling/noirc_abi/src/input_parser/toml.rs
index 321d3511b5d..6f2be68a0c4 100644
--- a/tooling/noirc_abi/src/input_parser/toml.rs
+++ b/tooling/noirc_abi/src/input_parser/toml.rs
@@ -1,4 +1,4 @@
-use super::{parse_str_to_field, parse_str_to_signed, InputValue};
+use super::{field_to_signed_hex, parse_str_to_field, parse_str_to_signed, InputValue};
 use crate::{errors::InputParserError, Abi, AbiType, MAIN_RETURN_NAME};
 use acvm::{AcirField, FieldElement};
 use iter_extended::{try_btree_map, try_vecmap};
@@ -60,7 +60,7 @@ pub(crate) fn serialize_to_toml(
     Ok(toml_string)
 }
 
-#[derive(Debug, Deserialize, Serialize, Clone)]
+#[derive(Debug, Deserialize, Serialize, Clone, PartialEq)]
 #[serde(untagged)]
 enum TomlTypes {
     // This is most likely going to be a hex string
@@ -83,6 +83,9 @@ impl TomlTypes {
         abi_type: &AbiType,
     ) -> Result<TomlTypes, InputParserError> {
         let toml_value = match (value, abi_type) {
+            (InputValue::Field(f), AbiType::Integer { sign: crate::Sign::Signed, width }) => {
+                TomlTypes::String(field_to_signed_hex(*f, *width))
+            }
             (InputValue::Field(f), AbiType::Field | AbiType::Integer { .. }) => {
                 let f_str = format!("0x{}", f.to_hex());
                 TomlTypes::String(f_str)
@@ -126,6 +129,7 @@ impl InputValue {
     ) -> Result<InputValue, InputParserError> {
         let input_value = match (value, param_type) {
             (TomlTypes::String(string), AbiType::String { .. }) => InputValue::String(string),
+
             (
                 TomlTypes::String(string),
                 AbiType::Field
@@ -139,7 +143,7 @@ impl InputValue {
                 TomlTypes::Integer(integer),
                 AbiType::Field | AbiType::Integer { .. } | AbiType::Boolean,
             ) => {
-                let new_value = FieldElement::from(i128::from(integer));
+                let new_value = FieldElement::from(u128::from(integer));
 
                 InputValue::Field(new_value)
             }
@@ -179,3 +183,40 @@ impl InputValue {
         Ok(input_value)
     }
 }
+
+#[cfg(test)]
+mod test {
+    use proptest::prelude::*;
+
+    use crate::{
+        arbitrary::arb_abi_and_input_map,
+        input_parser::{arbitrary::arb_signed_integer_type_and_value, toml::TomlTypes, InputValue},
+    };
+
+    use super::{parse_toml, serialize_to_toml};
+
+    proptest! {
+        #[test]
+        fn serializing_and_parsing_returns_original_input((abi, input_map) in arb_abi_and_input_map()) {
+            let toml = serialize_to_toml(&input_map, &abi).expect("should be serializable");
+            let parsed_input_map = parse_toml(&toml, &abi).expect("should be parsable");
+
+            prop_assert_eq!(parsed_input_map, input_map);
+        }
+
+        #[test]
+        fn signed_integer_serialization_roundtrip((typ, value) in arb_signed_integer_type_and_value()) {
+            let string_input = TomlTypes::String(value.to_string());
+            let input_value = InputValue::try_from_toml(string_input.clone(), &typ, "foo").expect("should be parsable");
+            let TomlTypes::String(output_string) = TomlTypes::try_from_input_value(&input_value, &typ).expect("should be serializable") else {
+                panic!("wrong type output");
+            };
+            let output_number = if let Some(output_string) = output_string.strip_prefix("-0x") {
+                -i64::from_str_radix(output_string, 16).unwrap()
+            } else {
+                i64::from_str_radix(output_string.strip_prefix("0x").unwrap(), 16).unwrap()
+            };
+            prop_assert_eq!(output_number, value);
+        }
+    }
+}
diff --git a/tooling/noirc_abi/src/lib.rs b/tooling/noirc_abi/src/lib.rs
index 39f2e935618..bd5674d64f1 100644
--- a/tooling/noirc_abi/src/lib.rs
+++ b/tooling/noirc_abi/src/lib.rs
@@ -49,6 +49,7 @@ pub const MAIN_RETURN_NAME: &str = "return";
 /// depends on the types of programs that users want to do. I don't envision string manipulation
 /// in programs, however it is possible to support, with many complications like encoding character set
 /// support.
+#[derive(Hash)]
 pub enum AbiType {
     Field,
     Array {
@@ -77,7 +78,7 @@ pub enum AbiType {
     },
 }
 
-#[derive(Clone, Copy, Debug, PartialEq, Eq, Serialize, Deserialize)]
+#[derive(Clone, Copy, Debug, PartialEq, Eq, Serialize, Deserialize, Hash)]
 #[cfg_attr(test, derive(arbitrary::Arbitrary))]
 #[serde(rename_all = "lowercase")]
 /// Represents whether the parameter is public or known only to the prover.
@@ -89,7 +90,7 @@ pub enum AbiVisibility {
     DataBus,
 }
 
-#[derive(Clone, Copy, Debug, PartialEq, Eq, Serialize, Deserialize)]
+#[derive(Clone, Copy, Debug, PartialEq, Eq, Serialize, Deserialize, Hash)]
 #[cfg_attr(test, derive(arbitrary::Arbitrary))]
 #[serde(rename_all = "lowercase")]
 pub enum Sign {
@@ -146,7 +147,7 @@ impl From<&AbiType> for PrintableType {
     }
 }
 
-#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize, Hash)]
 #[cfg_attr(test, derive(arbitrary::Arbitrary))]
 /// An argument or return value of the circuit's `main` function.
 pub struct AbiParameter {
@@ -163,7 +164,7 @@ impl AbiParameter {
     }
 }
 
-#[derive(Clone, Debug, Serialize, Deserialize)]
+#[derive(Clone, Debug, Serialize, Deserialize, Hash)]
 #[cfg_attr(test, derive(arbitrary::Arbitrary))]
 pub struct AbiReturnType {
     #[cfg_attr(test, proptest(strategy = "arbitrary::arb_abi_type()"))]
@@ -171,7 +172,7 @@ pub struct AbiReturnType {
     pub visibility: AbiVisibility,
 }
 
-#[derive(Clone, Debug, Default, Serialize, Deserialize)]
+#[derive(Clone, Debug, Default, Serialize, Deserialize, Hash)]
 #[cfg_attr(test, derive(arbitrary::Arbitrary))]
 pub struct Abi {
     /// An ordered list of the arguments to the program's `main` function, specifying their types and visibility.
@@ -459,11 +460,12 @@ pub enum AbiValue {
     },
 }
 
-#[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize)]
+#[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize, Hash)]
 #[serde(tag = "error_kind", rename_all = "lowercase")]
 pub enum AbiErrorType {
     FmtString { length: u32, item_types: Vec<AbiType> },
     Custom(AbiType),
+    String { string: String },
 }
 
 pub fn display_abi_error<F: AcirField>(
@@ -491,6 +493,13 @@ pub fn display_abi_error<F: AcirField>(
             let decoded = printable_type_decode_value(&mut fields.iter().copied(), &printable_type);
             PrintableValueDisplay::Plain(decoded, printable_type)
         }
+        AbiErrorType::String { string } => {
+            let length = string.len() as u32;
+            PrintableValueDisplay::Plain(
+                PrintableValue::String(string),
+                PrintableType::String { length },
+            )
+        }
     }
 }
 
diff --git a/tooling/noirc_abi_wasm/Cargo.toml b/tooling/noirc_abi_wasm/Cargo.toml
index daa619ca01d..b00d580515e 100644
--- a/tooling/noirc_abi_wasm/Cargo.toml
+++ b/tooling/noirc_abi_wasm/Cargo.toml
@@ -1,9 +1,11 @@
 [package]
 name = "noirc_abi_wasm"
+description = "An ABI encoder for the Noir language"
 version.workspace = true
 authors.workspace = true
 edition.workspace = true
 license.workspace = true
+repository.workspace = true
 
 # See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
 
diff --git a/tooling/noirc_abi_wasm/package.json b/tooling/noirc_abi_wasm/package.json
index 021e80017aa..9194714454d 100644
--- a/tooling/noirc_abi_wasm/package.json
+++ b/tooling/noirc_abi_wasm/package.json
@@ -3,7 +3,7 @@
   "contributors": [
     "The Noir Team <team@noir-lang.org>"
   ],
-  "version": "0.34.0",
+  "version": "1.0.0-beta.0",
   "license": "(MIT OR Apache-2.0)",
   "homepage": "https://noir-lang.org/",
   "repository": {
diff --git a/tooling/noirc_abi_wasm/src/lib.rs b/tooling/noirc_abi_wasm/src/lib.rs
index b0c11979d17..79aecafa742 100644
--- a/tooling/noirc_abi_wasm/src/lib.rs
+++ b/tooling/noirc_abi_wasm/src/lib.rs
@@ -157,5 +157,6 @@ pub fn abi_decode_error(
             <JsValue as JsValueSerdeExt>::from_serde(&json_types)
                 .map_err(|err| err.to_string().into())
         }
+        AbiErrorType::String { string } => Ok(JsValue::from_str(&string)),
     }
 }
diff --git a/tooling/noirc_abi_wasm/test/browser/abi_encode.test.ts b/tooling/noirc_abi_wasm/test/browser/abi_encode.test.ts
index e1aaf0dc2c0..ac18495919c 100644
--- a/tooling/noirc_abi_wasm/test/browser/abi_encode.test.ts
+++ b/tooling/noirc_abi_wasm/test/browser/abi_encode.test.ts
@@ -15,7 +15,8 @@ it('recovers original inputs when abi encoding and decoding', async () => {
   const foo: Field = inputs.foo as Field;
   const bar: Field[] = inputs.bar as Field[];
   expect(BigInt(decoded_inputs.inputs.foo)).to.be.equal(BigInt(foo));
-  expect(BigInt(decoded_inputs.inputs.bar[0])).to.be.equal(BigInt(bar[0]));
-  expect(BigInt(decoded_inputs.inputs.bar[1])).to.be.equal(BigInt(bar[1]));
+  expect(parseInt(decoded_inputs.inputs.bar[0])).to.be.equal(parseInt(bar[0].toString()));
+  expect(parseInt(decoded_inputs.inputs.bar[1])).to.be.equal(parseInt(bar[1].toString()));
+  expect(parseInt(decoded_inputs.inputs.bar[2])).to.be.equal(parseInt(bar[2].toString()));
   expect(decoded_inputs.return_value).to.be.null;
 });
diff --git a/tooling/noirc_abi_wasm/test/browser/errors.test.ts b/tooling/noirc_abi_wasm/test/browser/errors.test.ts
index 0f75ff64a3e..cc060cff4d6 100644
--- a/tooling/noirc_abi_wasm/test/browser/errors.test.ts
+++ b/tooling/noirc_abi_wasm/test/browser/errors.test.ts
@@ -9,7 +9,7 @@ it('errors when an integer input overflows', async () => {
   const { abi, inputs } = await import('../shared/uint_overflow');
 
   expect(() => abiEncode(abi, inputs)).to.throw(
-    'The value passed for parameter `foo` does not match the specified type:\nValue Field(2³⁸) does not fall within range of allowable values for a Integer { sign: Unsigned, width: 32 }',
+    'The value passed for parameter `foo` does not match the specified type:\nValue Field(274877906944) does not fall within range of allowable values for a Integer { sign: Unsigned, width: 32 }',
   );
 });
 
diff --git a/tooling/noirc_abi_wasm/test/node/abi_encode.test.ts b/tooling/noirc_abi_wasm/test/node/abi_encode.test.ts
index a49c10b6ea6..e87618d84da 100644
--- a/tooling/noirc_abi_wasm/test/node/abi_encode.test.ts
+++ b/tooling/noirc_abi_wasm/test/node/abi_encode.test.ts
@@ -11,7 +11,8 @@ it('recovers original inputs when abi encoding and decoding', async () => {
   const foo: Field = inputs.foo as Field;
   const bar: Field[] = inputs.bar as Field[];
   expect(BigInt(decoded_inputs.inputs.foo)).to.be.equal(BigInt(foo));
-  expect(BigInt(decoded_inputs.inputs.bar[0])).to.be.equal(BigInt(bar[0]));
-  expect(BigInt(decoded_inputs.inputs.bar[1])).to.be.equal(BigInt(bar[1]));
+  expect(parseInt(decoded_inputs.inputs.bar[0])).to.be.equal(parseInt(bar[0].toString()));
+  expect(parseInt(decoded_inputs.inputs.bar[1])).to.be.equal(parseInt(bar[1].toString()));
+  expect(parseInt(decoded_inputs.inputs.bar[2])).to.be.equal(parseInt(bar[2].toString()));
   expect(decoded_inputs.return_value).to.be.null;
 });
diff --git a/tooling/noirc_abi_wasm/test/node/errors.test.ts b/tooling/noirc_abi_wasm/test/node/errors.test.ts
index fba451b4a8c..491fd5a5671 100644
--- a/tooling/noirc_abi_wasm/test/node/errors.test.ts
+++ b/tooling/noirc_abi_wasm/test/node/errors.test.ts
@@ -5,7 +5,7 @@ it('errors when an integer input overflows', async () => {
   const { abi, inputs } = await import('../shared/uint_overflow');
 
   expect(() => abiEncode(abi, inputs)).to.throw(
-    'The value passed for parameter `foo` does not match the specified type:\nValue Field(2³⁸) does not fall within range of allowable values for a Integer { sign: Unsigned, width: 32 }',
+    'The value passed for parameter `foo` does not match the specified type:\nValue Field(274877906944) does not fall within range of allowable values for a Integer { sign: Unsigned, width: 32 }',
   );
 });
 
diff --git a/tooling/noirc_abi_wasm/test/shared/abi_encode.ts b/tooling/noirc_abi_wasm/test/shared/abi_encode.ts
index 62eb7658f43..b789bb05371 100644
--- a/tooling/noirc_abi_wasm/test/shared/abi_encode.ts
+++ b/tooling/noirc_abi_wasm/test/shared/abi_encode.ts
@@ -5,7 +5,7 @@ export const abi: Abi = {
     { name: 'foo', type: { kind: 'field' }, visibility: 'private' },
     {
       name: 'bar',
-      type: { kind: 'array', length: 2, type: { kind: 'field' } },
+      type: { kind: 'array', length: 3, type: { kind: 'integer', sign: 'signed', width: 32 } },
       visibility: 'private',
     },
   ],
@@ -15,5 +15,5 @@ export const abi: Abi = {
 
 export const inputs: InputMap = {
   foo: '1',
-  bar: ['1', '2'],
+  bar: ['1', '2', '-1'],
 };
diff --git a/tooling/noirc_abi_wasm/test/shared/decode_error.ts b/tooling/noirc_abi_wasm/test/shared/decode_error.ts
index 662e0acb416..461cedd2694 100644
--- a/tooling/noirc_abi_wasm/test/shared/decode_error.ts
+++ b/tooling/noirc_abi_wasm/test/shared/decode_error.ts
@@ -4,8 +4,10 @@ export const FAKE_FIELD_SELECTOR = '1';
 export const FAKE_TUPLE_SELECTOR = '2';
 export const FAKE_FMT_STRING_SELECTOR = '3';
 export const FAKE_STRUCT_SELECTOR = '4';
+export const FAKE_STRING_SELECTOR = '5';
 
 export const SAMPLE_FMT_STRING = 'hello {a}';
+export const SAMPLE_STRING = 'hello world';
 
 export const abi: Abi = {
   parameters: [
@@ -40,5 +42,9 @@ export const abi: Abi = {
         { name: 'b', type: { kind: 'field' } },
       ],
     },
+    [FAKE_STRING_SELECTOR]: {
+      error_kind: 'string',
+      string: SAMPLE_STRING,
+    },
   },
 };
diff --git a/tooling/noirc_artifacts/src/debug.rs b/tooling/noirc_artifacts/src/debug.rs
index 8e2add70ae7..5c47f1f2652 100644
--- a/tooling/noirc_artifacts/src/debug.rs
+++ b/tooling/noirc_artifacts/src/debug.rs
@@ -264,6 +264,7 @@ mod tests {
             BTreeMap::default(),
             BTreeMap::default(),
             BTreeMap::default(),
+            BTreeMap::default(),
         )];
         let debug_artifact = DebugArtifact::new(debug_symbols, &fm);
 
diff --git a/tooling/profiler/Cargo.toml b/tooling/profiler/Cargo.toml
index 136775d5831..798a21ea0d6 100644
--- a/tooling/profiler/Cargo.toml
+++ b/tooling/profiler/Cargo.toml
@@ -18,8 +18,10 @@ name = "noir-profiler"
 path = "src/main.rs"
 
 [dependencies]
+bn254_blackbox_solver.workspace = true
 color-eyre.workspace = true
 clap.workspace = true
+fxhash.workspace = true
 noirc_artifacts.workspace = true
 const_format.workspace = true
 serde.workspace = true
@@ -28,7 +30,10 @@ fm.workspace = true
 inferno = "0.11.19"
 im.workspace = true
 acir.workspace = true
+nargo.workspace = true
 noirc_errors.workspace = true
+noirc_abi.workspace = true
+noirc_evaluator.workspace = true
 
 # Logs
 tracing-subscriber.workspace = true
@@ -39,6 +44,3 @@ noirc_abi.workspace = true
 noirc_driver.workspace = true
 tempfile.workspace = true
 
-[features]
-default = ["bn254"]
-bn254 = ["acir/bn254"]
diff --git a/tooling/profiler/src/cli/execution_flamegraph_cmd.rs b/tooling/profiler/src/cli/execution_flamegraph_cmd.rs
new file mode 100644
index 00000000000..76b23ebf739
--- /dev/null
+++ b/tooling/profiler/src/cli/execution_flamegraph_cmd.rs
@@ -0,0 +1,98 @@
+use std::path::{Path, PathBuf};
+
+use acir::circuit::OpcodeLocation;
+use clap::Args;
+use color_eyre::eyre::{self, Context};
+use nargo::PrintOutput;
+
+use crate::flamegraph::{BrilligExecutionSample, FlamegraphGenerator, InfernoFlamegraphGenerator};
+use crate::fs::{read_inputs_from_file, read_program_from_file};
+use crate::opcode_formatter::format_brillig_opcode;
+use bn254_blackbox_solver::Bn254BlackBoxSolver;
+use nargo::foreign_calls::DefaultForeignCallExecutor;
+use noirc_abi::input_parser::Format;
+use noirc_artifacts::debug::DebugArtifact;
+
+#[derive(Debug, Clone, Args)]
+pub(crate) struct ExecutionFlamegraphCommand {
+    /// The path to the artifact JSON file
+    #[clap(long, short)]
+    artifact_path: PathBuf,
+
+    /// The path to the Prover.toml file
+    #[clap(long, short)]
+    prover_toml_path: PathBuf,
+
+    /// The output folder for the flamegraph svg files
+    #[clap(long, short)]
+    output: PathBuf,
+}
+
+pub(crate) fn run(args: ExecutionFlamegraphCommand) -> eyre::Result<()> {
+    run_with_generator(
+        &args.artifact_path,
+        &args.prover_toml_path,
+        &InfernoFlamegraphGenerator { count_name: "samples".to_string() },
+        &args.output,
+    )
+}
+
+fn run_with_generator(
+    artifact_path: &Path,
+    prover_toml_path: &Path,
+    flamegraph_generator: &impl FlamegraphGenerator,
+    output_path: &Path,
+) -> eyre::Result<()> {
+    let program =
+        read_program_from_file(artifact_path).context("Error reading program from file")?;
+
+    let (inputs_map, _) = read_inputs_from_file(prover_toml_path, Format::Toml, &program.abi)?;
+
+    let initial_witness = program.abi.encode(&inputs_map, None)?;
+
+    println!("Executing");
+    let (_, mut profiling_samples) = nargo::ops::execute_program_with_profiling(
+        &program.bytecode,
+        initial_witness,
+        &Bn254BlackBoxSolver,
+        &mut DefaultForeignCallExecutor::new(PrintOutput::Stdout, None, None, None),
+    )?;
+    println!("Executed");
+
+    println!("Collecting {} samples", profiling_samples.len());
+
+    let profiling_samples: Vec<BrilligExecutionSample> = profiling_samples
+        .iter_mut()
+        .map(|sample| {
+            let call_stack = std::mem::take(&mut sample.call_stack);
+            let brillig_function_id = std::mem::take(&mut sample.brillig_function_id);
+            let last_entry = call_stack.last();
+            let opcode = brillig_function_id
+                .and_then(|id| program.bytecode.unconstrained_functions.get(id.0 as usize))
+                .and_then(|func| {
+                    if let Some(OpcodeLocation::Brillig { brillig_index, .. }) = last_entry {
+                        func.bytecode.get(*brillig_index)
+                    } else {
+                        None
+                    }
+                })
+                .map(format_brillig_opcode);
+            BrilligExecutionSample { opcode, call_stack, brillig_function_id }
+        })
+        .collect();
+
+    let debug_artifact: DebugArtifact = program.into();
+
+    println!("Generating flamegraph with {} samples", profiling_samples.len());
+
+    flamegraph_generator.generate_flamegraph(
+        profiling_samples,
+        &debug_artifact.debug_symbols[0],
+        &debug_artifact,
+        artifact_path.to_str().unwrap(),
+        "main",
+        &Path::new(&output_path).join(Path::new(&format!("{}.svg", "main"))),
+    )?;
+
+    Ok(())
+}
diff --git a/tooling/profiler/src/cli/gates_flamegraph_cmd.rs b/tooling/profiler/src/cli/gates_flamegraph_cmd.rs
index d5fefc4ecda..e68a8cd5bd2 100644
--- a/tooling/profiler/src/cli/gates_flamegraph_cmd.rs
+++ b/tooling/profiler/src/cli/gates_flamegraph_cmd.rs
@@ -6,10 +6,10 @@ use color_eyre::eyre::{self, Context};
 
 use noirc_artifacts::debug::DebugArtifact;
 
-use crate::flamegraph::{FlamegraphGenerator, InfernoFlamegraphGenerator, Sample};
+use crate::flamegraph::{CompilationSample, FlamegraphGenerator, InfernoFlamegraphGenerator};
 use crate::fs::read_program_from_file;
 use crate::gates_provider::{BackendGatesProvider, GatesProvider};
-use crate::opcode_formatter::AcirOrBrilligOpcode;
+use crate::opcode_formatter::format_acir_opcode;
 
 #[derive(Debug, Clone, Args)]
 pub(crate) struct GatesFlamegraphCommand {
@@ -31,6 +31,10 @@ pub(crate) struct GatesFlamegraphCommand {
     /// The output folder for the flamegraph svg files
     #[clap(long, short)]
     output: String,
+
+    /// The output name for the flamegraph svg files
+    #[clap(long, short = 'f')]
+    output_filename: Option<String>,
 }
 
 pub(crate) fn run(args: GatesFlamegraphCommand) -> eyre::Result<()> {
@@ -43,6 +47,7 @@ pub(crate) fn run(args: GatesFlamegraphCommand) -> eyre::Result<()> {
         },
         &InfernoFlamegraphGenerator { count_name: "gates".to_string() },
         &PathBuf::from(args.output),
+        args.output_filename,
     )
 }
 
@@ -51,6 +56,7 @@ fn run_with_provider<Provider: GatesProvider, Generator: FlamegraphGenerator>(
     gates_provider: &Provider,
     flamegraph_generator: &Generator,
     output_path: &Path,
+    output_filename: Option<String>,
 ) -> eyre::Result<()> {
     let mut program =
         read_program_from_file(artifact_path).context("Error reading program from file")?;
@@ -83,21 +89,26 @@ fn run_with_provider<Provider: GatesProvider, Generator: FlamegraphGenerator>(
             .into_iter()
             .zip(bytecode.opcodes)
             .enumerate()
-            .map(|(index, (gates, opcode))| Sample {
-                opcode: AcirOrBrilligOpcode::Acir(opcode),
+            .map(|(index, (gates, opcode))| CompilationSample {
+                opcode: Some(format_acir_opcode(&opcode)),
                 call_stack: vec![OpcodeLocation::Acir(index)],
                 count: gates,
                 brillig_function_id: None,
             })
             .collect();
 
+        let output_filename = if let Some(output_filename) = &output_filename {
+            format!("{}::{}::gates.svg", output_filename, func_name)
+        } else {
+            format!("{}::gates.svg", func_name)
+        };
         flamegraph_generator.generate_flamegraph(
             samples,
             &debug_artifact.debug_symbols[func_idx],
             &debug_artifact,
             artifact_path.to_str().unwrap(),
             &func_name,
-            &Path::new(&output_path).join(Path::new(&format!("{}_gates.svg", &func_name))),
+            &Path::new(&output_path).join(Path::new(&output_filename)),
         )?;
     }
 
@@ -106,10 +117,7 @@ fn run_with_provider<Provider: GatesProvider, Generator: FlamegraphGenerator>(
 
 #[cfg(test)]
 mod tests {
-    use acir::{
-        circuit::{Circuit, Program},
-        AcirField,
-    };
+    use acir::circuit::{Circuit, Program};
     use color_eyre::eyre::{self};
     use fm::codespan_files::Files;
     use noirc_artifacts::program::ProgramArtifact;
@@ -143,9 +151,9 @@ mod tests {
     struct TestFlamegraphGenerator {}
 
     impl super::FlamegraphGenerator for TestFlamegraphGenerator {
-        fn generate_flamegraph<'files, F: AcirField>(
+        fn generate_flamegraph<'files, S: Sample>(
             &self,
-            _samples: Vec<Sample<F>>,
+            _samples: Vec<S>,
             _debug_symbols: &DebugInfo,
             _files: &'files impl Files<'files, FileId = fm::FileId>,
             _artifact_name: &str,
@@ -192,11 +200,17 @@ mod tests {
         };
         let flamegraph_generator = TestFlamegraphGenerator::default();
 
-        super::run_with_provider(&artifact_path, &provider, &flamegraph_generator, temp_dir.path())
-            .expect("should run without errors");
+        super::run_with_provider(
+            &artifact_path,
+            &provider,
+            &flamegraph_generator,
+            temp_dir.path(),
+            Some(String::from("test_filename")),
+        )
+        .expect("should run without errors");
 
         // Check that the output file was written to
-        let output_file = temp_dir.path().join("main_gates.svg");
+        let output_file = temp_dir.path().join("test_filename::main::gates.svg");
         assert!(output_file.exists());
     }
 }
diff --git a/tooling/profiler/src/cli/mod.rs b/tooling/profiler/src/cli/mod.rs
index 7cfc6ed7c9e..80c6bceb3ce 100644
--- a/tooling/profiler/src/cli/mod.rs
+++ b/tooling/profiler/src/cli/mod.rs
@@ -2,6 +2,7 @@ use clap::{Parser, Subcommand};
 use color_eyre::eyre;
 use const_format::formatcp;
 
+mod execution_flamegraph_cmd;
 mod gates_flamegraph_cmd;
 mod opcodes_flamegraph_cmd;
 
@@ -19,15 +20,17 @@ struct ProfilerCli {
 #[non_exhaustive]
 #[derive(Subcommand, Clone, Debug)]
 enum ProfilerCommand {
-    GatesFlamegraph(gates_flamegraph_cmd::GatesFlamegraphCommand),
-    OpcodesFlamegraph(opcodes_flamegraph_cmd::OpcodesFlamegraphCommand),
+    Gates(gates_flamegraph_cmd::GatesFlamegraphCommand),
+    Opcodes(opcodes_flamegraph_cmd::OpcodesFlamegraphCommand),
+    ExecutionOpcodes(execution_flamegraph_cmd::ExecutionFlamegraphCommand),
 }
 
 pub(crate) fn start_cli() -> eyre::Result<()> {
     let ProfilerCli { command } = ProfilerCli::parse();
 
     match command {
-        ProfilerCommand::GatesFlamegraph(args) => gates_flamegraph_cmd::run(args),
-        ProfilerCommand::OpcodesFlamegraph(args) => opcodes_flamegraph_cmd::run(args),
+        ProfilerCommand::Gates(args) => gates_flamegraph_cmd::run(args),
+        ProfilerCommand::Opcodes(args) => opcodes_flamegraph_cmd::run(args),
+        ProfilerCommand::ExecutionOpcodes(args) => execution_flamegraph_cmd::run(args),
     }
 }
diff --git a/tooling/profiler/src/cli/opcodes_flamegraph_cmd.rs b/tooling/profiler/src/cli/opcodes_flamegraph_cmd.rs
index 863d45b96d1..4e271c9f838 100644
--- a/tooling/profiler/src/cli/opcodes_flamegraph_cmd.rs
+++ b/tooling/profiler/src/cli/opcodes_flamegraph_cmd.rs
@@ -7,9 +7,9 @@ use color_eyre::eyre::{self, Context};
 
 use noirc_artifacts::debug::DebugArtifact;
 
-use crate::flamegraph::{FlamegraphGenerator, InfernoFlamegraphGenerator, Sample};
+use crate::flamegraph::{CompilationSample, FlamegraphGenerator, InfernoFlamegraphGenerator};
 use crate::fs::read_program_from_file;
-use crate::opcode_formatter::AcirOrBrilligOpcode;
+use crate::opcode_formatter::{format_acir_opcode, format_brillig_opcode};
 
 #[derive(Debug, Clone, Args)]
 pub(crate) struct OpcodesFlamegraphCommand {
@@ -59,8 +59,8 @@ fn run_with_generator<Generator: FlamegraphGenerator>(
             .opcodes
             .iter()
             .enumerate()
-            .map(|(index, opcode)| Sample {
-                opcode: AcirOrBrilligOpcode::Acir(opcode.clone()),
+            .map(|(index, opcode)| CompilationSample {
+                opcode: Some(format_acir_opcode(opcode)),
                 call_stack: vec![OpcodeLocation::Acir(index)],
                 count: 1,
                 brillig_function_id: None,
@@ -96,8 +96,8 @@ fn run_with_generator<Generator: FlamegraphGenerator>(
                 .bytecode
                 .into_iter()
                 .enumerate()
-                .map(|(brillig_index, opcode)| Sample {
-                    opcode: AcirOrBrilligOpcode::Brillig(opcode),
+                .map(|(brillig_index, opcode)| CompilationSample {
+                    opcode: Some(format_brillig_opcode(&opcode)),
                     call_stack: vec![OpcodeLocation::Brillig {
                         acir_index: acir_opcode_index,
                         brillig_index,
@@ -146,7 +146,7 @@ mod tests {
             brillig::{BrilligBytecode, BrilligFunctionId},
             Circuit, Opcode, Program,
         },
-        AcirField, FieldElement,
+        FieldElement,
     };
     use color_eyre::eyre::{self};
     use fm::codespan_files::Files;
@@ -160,9 +160,9 @@ mod tests {
     struct TestFlamegraphGenerator {}
 
     impl super::FlamegraphGenerator for TestFlamegraphGenerator {
-        fn generate_flamegraph<'files, F: AcirField>(
+        fn generate_flamegraph<'files, S: Sample>(
             &self,
-            _samples: Vec<Sample<F>>,
+            _samples: Vec<S>,
             _debug_symbols: &DebugInfo,
             _files: &'files impl Files<'files, FileId = fm::FileId>,
             _artifact_name: &str,
diff --git a/tooling/profiler/src/flamegraph.rs b/tooling/profiler/src/flamegraph.rs
index 488079de50a..38966902314 100644
--- a/tooling/profiler/src/flamegraph.rs
+++ b/tooling/profiler/src/flamegraph.rs
@@ -3,26 +3,75 @@ use std::{collections::BTreeMap, io::BufWriter};
 
 use acir::circuit::brillig::BrilligFunctionId;
 use acir::circuit::OpcodeLocation;
-use acir::AcirField;
 use color_eyre::eyre::{self};
 use fm::codespan_files::Files;
+use fxhash::FxHashMap as HashMap;
 use inferno::flamegraph::{from_lines, Options, TextTruncateDirection};
 use noirc_errors::debug_info::DebugInfo;
 use noirc_errors::reporter::line_and_column_from_span;
 use noirc_errors::Location;
+use noirc_evaluator::brillig::ProcedureId;
 
-use crate::opcode_formatter::AcirOrBrilligOpcode;
+pub(crate) trait Sample {
+    fn count(&self) -> usize;
 
-use super::opcode_formatter::format_opcode;
+    fn brillig_function_id(&self) -> Option<BrilligFunctionId>;
+
+    fn call_stack(&self) -> &[OpcodeLocation];
+
+    fn opcode(self) -> Option<String>;
+}
 
 #[derive(Debug)]
-pub(crate) struct Sample<F: AcirField> {
-    pub(crate) opcode: AcirOrBrilligOpcode<F>,
+pub(crate) struct CompilationSample {
+    pub(crate) opcode: Option<String>,
     pub(crate) call_stack: Vec<OpcodeLocation>,
     pub(crate) count: usize,
     pub(crate) brillig_function_id: Option<BrilligFunctionId>,
 }
 
+impl Sample for CompilationSample {
+    fn count(&self) -> usize {
+        self.count
+    }
+
+    fn brillig_function_id(&self) -> Option<BrilligFunctionId> {
+        self.brillig_function_id
+    }
+
+    fn call_stack(&self) -> &[OpcodeLocation] {
+        &self.call_stack
+    }
+
+    fn opcode(self) -> Option<String> {
+        self.opcode
+    }
+}
+
+pub(crate) struct BrilligExecutionSample {
+    pub(crate) opcode: Option<String>,
+    pub(crate) call_stack: Vec<OpcodeLocation>,
+    pub(crate) brillig_function_id: Option<BrilligFunctionId>,
+}
+
+impl Sample for BrilligExecutionSample {
+    fn count(&self) -> usize {
+        1
+    }
+
+    fn brillig_function_id(&self) -> Option<BrilligFunctionId> {
+        self.brillig_function_id
+    }
+
+    fn call_stack(&self) -> &[OpcodeLocation] {
+        &self.call_stack
+    }
+
+    fn opcode(self) -> Option<String> {
+        self.opcode
+    }
+}
+
 #[derive(Debug, Default)]
 pub(crate) struct FoldedStackItem {
     pub(crate) total_samples: usize,
@@ -31,9 +80,9 @@ pub(crate) struct FoldedStackItem {
 
 pub(crate) trait FlamegraphGenerator {
     #[allow(clippy::too_many_arguments)]
-    fn generate_flamegraph<'files, F: AcirField>(
+    fn generate_flamegraph<'files, S: Sample>(
         &self,
-        samples: Vec<Sample<F>>,
+        samples: Vec<S>,
         debug_symbols: &DebugInfo,
         files: &'files impl Files<'files, FileId = fm::FileId>,
         artifact_name: &str,
@@ -47,9 +96,9 @@ pub(crate) struct InfernoFlamegraphGenerator {
 }
 
 impl FlamegraphGenerator for InfernoFlamegraphGenerator {
-    fn generate_flamegraph<'files, F: AcirField>(
+    fn generate_flamegraph<'files, S: Sample>(
         &self,
-        samples: Vec<Sample<F>>,
+        samples: Vec<S>,
         debug_symbols: &DebugInfo,
         files: &'files impl Files<'files, FileId = fm::FileId>,
         artifact_name: &str,
@@ -80,49 +129,89 @@ impl FlamegraphGenerator for InfernoFlamegraphGenerator {
     }
 }
 
-fn generate_folded_sorted_lines<'files, F: AcirField>(
-    samples: Vec<Sample<F>>,
+fn generate_folded_sorted_lines<'files, S: Sample>(
+    samples: Vec<S>,
     debug_symbols: &DebugInfo,
     files: &'files impl Files<'files, FileId = fm::FileId>,
 ) -> Vec<String> {
     // Create a nested hashmap with the stack items, folding the gates for all the callsites that are equal
     let mut folded_stack_items = BTreeMap::new();
 
-    samples.into_iter().for_each(|sample| {
-        let mut location_names: Vec<String> = sample
-            .call_stack
-            .into_iter()
-            .flat_map(|opcode_location| {
-                debug_symbols.opcode_location(&opcode_location).unwrap_or_else(|| {
-                    if let (Some(brillig_function_id), Some(brillig_location)) =
-                        (sample.brillig_function_id, opcode_location.to_brillig_location())
-                    {
-                        let brillig_locations =
-                            debug_symbols.brillig_locations.get(&brillig_function_id);
-                        if let Some(brillig_locations) = brillig_locations {
-                            brillig_locations.get(&brillig_location).cloned().unwrap_or_default()
-                        } else {
-                            vec![]
-                        }
-                    } else {
-                        vec![]
-                    }
+    let mut resolution_cache: HashMap<OpcodeLocation, Vec<String>> = HashMap::default();
+    for sample in samples {
+        let mut location_names = Vec::with_capacity(sample.call_stack().len());
+        for opcode_location in sample.call_stack() {
+            let callsite_labels = resolution_cache
+                .entry(*opcode_location)
+                .or_insert_with(|| {
+                    find_callsite_labels(
+                        debug_symbols,
+                        opcode_location,
+                        sample.brillig_function_id(),
+                        files,
+                    )
                 })
-            })
-            .map(|location| location_to_callsite_label(location, files))
-            .collect();
+                .clone();
 
-        if location_names.is_empty() {
-            location_names.push("unknown".to_string());
+            location_names.extend(callsite_labels);
         }
-        location_names.push(format_opcode(&sample.opcode));
 
-        add_locations_to_folded_stack_items(&mut folded_stack_items, location_names, sample.count);
-    });
+        // We move `sample` by calling `sample.opcode()` so we want to fetch the sample count here.
+        let count = sample.count();
+
+        if let Some(opcode) = sample.opcode() {
+            location_names.push(opcode);
+        }
+
+        add_locations_to_folded_stack_items(&mut folded_stack_items, location_names, count);
+    }
 
     to_folded_sorted_lines(&folded_stack_items, Default::default())
 }
 
+fn find_callsite_labels<'files>(
+    debug_symbols: &DebugInfo,
+    opcode_location: &OpcodeLocation,
+    brillig_function_id: Option<BrilligFunctionId>,
+    files: &'files impl Files<'files, FileId = fm::FileId>,
+) -> Vec<String> {
+    let mut procedure_id = None;
+    let source_locations = debug_symbols.opcode_location(opcode_location).unwrap_or_else(|| {
+        if let (Some(brillig_function_id), Some(brillig_location)) =
+            (brillig_function_id, opcode_location.to_brillig_location())
+        {
+            let procedure_locs = debug_symbols.brillig_procedure_locs.get(&brillig_function_id);
+            if let Some(procedure_locs) = procedure_locs {
+                for (procedure, range) in procedure_locs.iter() {
+                    if brillig_location.0 >= range.0 && brillig_location.0 <= range.1 {
+                        procedure_id = Some(*procedure);
+                        break;
+                    }
+                }
+            }
+            let brillig_locations = debug_symbols.brillig_locations.get(&brillig_function_id);
+            if let Some(brillig_locations) = brillig_locations {
+                brillig_locations.get(&brillig_location).cloned().unwrap_or_default()
+            } else {
+                vec![]
+            }
+        } else {
+            vec![]
+        }
+    });
+
+    let mut callsite_labels: Vec<_> = source_locations
+        .into_iter()
+        .map(|location| location_to_callsite_label(location, files))
+        .collect();
+
+    if let Some(procedure_id) = procedure_id {
+        callsite_labels.push(format!("procedure::{}", ProcedureId::from_debug_id(procedure_id)));
+    }
+
+    callsite_labels
+}
+
 fn location_to_callsite_label<'files>(
     location: Location,
     files: &'files impl Files<'files, FileId = fm::FileId>,
@@ -212,7 +301,7 @@ mod tests {
     use noirc_errors::{debug_info::DebugInfo, Location, Span};
     use std::{collections::BTreeMap, path::Path};
 
-    use crate::{flamegraph::Sample, opcode_formatter::AcirOrBrilligOpcode};
+    use crate::{flamegraph::CompilationSample, opcode_formatter::format_acir_opcode};
 
     use super::generate_folded_sorted_lines;
 
@@ -296,27 +385,32 @@ mod tests {
             BTreeMap::default(),
             BTreeMap::default(),
             BTreeMap::default(),
+            BTreeMap::default(),
         );
 
-        let samples: Vec<Sample<FieldElement>> = vec![
-            Sample {
-                opcode: AcirOrBrilligOpcode::Acir(AcirOpcode::AssertZero(Expression::default())),
+        let samples: Vec<CompilationSample> = vec![
+            CompilationSample {
+                opcode: Some(format_acir_opcode(&AcirOpcode::AssertZero::<FieldElement>(
+                    Expression::default(),
+                ))),
                 call_stack: vec![OpcodeLocation::Acir(0)],
                 count: 10,
                 brillig_function_id: None,
             },
-            Sample {
-                opcode: AcirOrBrilligOpcode::Acir(AcirOpcode::AssertZero(Expression::default())),
+            CompilationSample {
+                opcode: Some(format_acir_opcode(&AcirOpcode::AssertZero::<FieldElement>(
+                    Expression::default(),
+                ))),
                 call_stack: vec![OpcodeLocation::Acir(1)],
                 count: 20,
                 brillig_function_id: None,
             },
-            Sample {
-                opcode: AcirOrBrilligOpcode::Acir(AcirOpcode::MemoryInit {
+            CompilationSample {
+                opcode: Some(format_acir_opcode(&AcirOpcode::MemoryInit::<FieldElement> {
                     block_id: BlockId(0),
                     init: vec![],
                     block_type: acir::circuit::opcodes::BlockType::Memory,
-                }),
+                })),
                 call_stack: vec![OpcodeLocation::Acir(2)],
                 count: 30,
                 brillig_function_id: None,
diff --git a/tooling/profiler/src/fs.rs b/tooling/profiler/src/fs.rs
index e8eec2cbb14..43848504a7f 100644
--- a/tooling/profiler/src/fs.rs
+++ b/tooling/profiler/src/fs.rs
@@ -1,6 +1,10 @@
-use std::path::Path;
+use std::{collections::BTreeMap, path::Path};
 
 use color_eyre::eyre;
+use noirc_abi::{
+    input_parser::{Format, InputValue},
+    Abi, InputMap, MAIN_RETURN_NAME,
+};
 use noirc_artifacts::program::ProgramArtifact;
 
 pub(crate) fn read_program_from_file<P: AsRef<Path>>(
@@ -13,3 +17,26 @@ pub(crate) fn read_program_from_file<P: AsRef<Path>>(
 
     Ok(program)
 }
+
+/// Returns the circuit's parameters and its return value, if one exists.
+/// # Examples
+///
+/// ```ignore
+/// let (input_map, return_value): (InputMap, Option<InputValue>) =
+///   read_inputs_from_file(path, "Verifier", Format::Toml, &abi)?;
+/// ```
+pub(crate) fn read_inputs_from_file(
+    file_path: &Path,
+    format: Format,
+    abi: &Abi,
+) -> eyre::Result<(InputMap, Option<InputValue>)> {
+    if abi.is_empty() {
+        return Ok((BTreeMap::new(), None));
+    }
+
+    let input_string = std::fs::read_to_string(file_path)?;
+    let mut input_map = format.parse(&input_string, abi)?;
+    let return_value = input_map.remove(MAIN_RETURN_NAME);
+
+    Ok((input_map, return_value))
+}
diff --git a/tooling/profiler/src/opcode_formatter.rs b/tooling/profiler/src/opcode_formatter.rs
index f367360b189..d1081de6c8f 100644
--- a/tooling/profiler/src/opcode_formatter.rs
+++ b/tooling/profiler/src/opcode_formatter.rs
@@ -1,13 +1,7 @@
 use acir::brillig::{BinaryFieldOp, BinaryIntOp, BlackBoxOp, Opcode as BrilligOpcode};
-use acir::circuit::{directives::Directive, opcodes::BlackBoxFuncCall, Opcode as AcirOpcode};
+use acir::circuit::{opcodes::BlackBoxFuncCall, Opcode as AcirOpcode};
 use acir::AcirField;
 
-#[derive(Debug)]
-pub(crate) enum AcirOrBrilligOpcode<F: AcirField> {
-    Acir(AcirOpcode<F>),
-    Brillig(BrilligOpcode<F>),
-}
-
 fn format_blackbox_function<F>(call: &BlackBoxFuncCall<F>) -> String {
     match call {
         BlackBoxFuncCall::AES128Encrypt { .. } => "aes128_encrypt".to_string(),
@@ -16,14 +10,10 @@ fn format_blackbox_function<F>(call: &BlackBoxFuncCall<F>) -> String {
         BlackBoxFuncCall::RANGE { .. } => "range".to_string(),
         BlackBoxFuncCall::Blake2s { .. } => "blake2s".to_string(),
         BlackBoxFuncCall::Blake3 { .. } => "blake3".to_string(),
-        BlackBoxFuncCall::SchnorrVerify { .. } => "schnorr_verify".to_string(),
-        BlackBoxFuncCall::PedersenCommitment { .. } => "pedersen_commitment".to_string(),
-        BlackBoxFuncCall::PedersenHash { .. } => "pedersen_hash".to_string(),
         BlackBoxFuncCall::EcdsaSecp256k1 { .. } => "ecdsa_secp256k1".to_string(),
         BlackBoxFuncCall::EcdsaSecp256r1 { .. } => "ecdsa_secp256r1".to_string(),
         BlackBoxFuncCall::MultiScalarMul { .. } => "multi_scalar_mul".to_string(),
         BlackBoxFuncCall::EmbeddedCurveAdd { .. } => "embedded_curve_add".to_string(),
-        BlackBoxFuncCall::Keccak256 { .. } => "keccak256".to_string(),
         BlackBoxFuncCall::Keccakf1600 { .. } => "keccakf1600".to_string(),
         BlackBoxFuncCall::RecursiveAggregation { .. } => "recursive_aggregation".to_string(),
         BlackBoxFuncCall::BigIntAdd { .. } => "big_int_add".to_string(),
@@ -42,14 +32,10 @@ fn format_blackbox_op(call: &BlackBoxOp) -> String {
         BlackBoxOp::AES128Encrypt { .. } => "aes128_encrypt".to_string(),
         BlackBoxOp::Blake2s { .. } => "blake2s".to_string(),
         BlackBoxOp::Blake3 { .. } => "blake3".to_string(),
-        BlackBoxOp::SchnorrVerify { .. } => "schnorr_verify".to_string(),
-        BlackBoxOp::PedersenCommitment { .. } => "pedersen_commitment".to_string(),
-        BlackBoxOp::PedersenHash { .. } => "pedersen_hash".to_string(),
         BlackBoxOp::EcdsaSecp256k1 { .. } => "ecdsa_secp256k1".to_string(),
         BlackBoxOp::EcdsaSecp256r1 { .. } => "ecdsa_secp256r1".to_string(),
         BlackBoxOp::MultiScalarMul { .. } => "multi_scalar_mul".to_string(),
         BlackBoxOp::EmbeddedCurveAdd { .. } => "embedded_curve_add".to_string(),
-        BlackBoxOp::Keccak256 { .. } => "keccak256".to_string(),
         BlackBoxOp::Keccakf1600 { .. } => "keccakf1600".to_string(),
         BlackBoxOp::BigIntAdd { .. } => "big_int_add".to_string(),
         BlackBoxOp::BigIntSub { .. } => "big_int_sub".to_string(),
@@ -63,12 +49,6 @@ fn format_blackbox_op(call: &BlackBoxOp) -> String {
     }
 }
 
-fn format_directive_kind<F>(directive: &Directive<F>) -> String {
-    match directive {
-        Directive::ToLeRadix { .. } => "to_le_radix".to_string(),
-    }
-}
-
 fn format_acir_opcode_kind<F>(opcode: &AcirOpcode<F>) -> String {
     match opcode {
         AcirOpcode::AssertZero(_) => "arithmetic".to_string(),
@@ -77,9 +57,6 @@ fn format_acir_opcode_kind<F>(opcode: &AcirOpcode<F>) -> String {
         }
         AcirOpcode::MemoryOp { .. } => "memory::op".to_string(),
         AcirOpcode::MemoryInit { .. } => "memory::init".to_string(),
-        AcirOpcode::Directive(directive) => {
-            format!("directive::{}", format_directive_kind(directive))
-        }
         AcirOpcode::BrilligCall { id, .. } => format!("brillig_call({id})"),
         AcirOpcode::Call { .. } => "acir_call".to_string(),
     }
@@ -142,11 +119,10 @@ fn format_brillig_opcode_kind<F>(opcode: &BrilligOpcode<F>) -> String {
     }
 }
 
-pub(crate) fn format_opcode<F: AcirField>(opcode: &AcirOrBrilligOpcode<F>) -> String {
-    match opcode {
-        AcirOrBrilligOpcode::Acir(opcode) => format!("acir::{}", format_acir_opcode_kind(opcode)),
-        AcirOrBrilligOpcode::Brillig(opcode) => {
-            format!("brillig::{}", format_brillig_opcode_kind(opcode))
-        }
-    }
+pub(crate) fn format_acir_opcode<F: AcirField>(opcode: &AcirOpcode<F>) -> String {
+    format!("acir::{}", format_acir_opcode_kind(opcode))
+}
+
+pub(crate) fn format_brillig_opcode<F: AcirField>(opcode: &BrilligOpcode<F>) -> String {
+    format!("brillig::{}", format_brillig_opcode_kind(opcode))
 }
diff --git a/tooling/readme.md b/tooling/readme.md
index 20d1b560b5b..3172062241a 100644
--- a/tooling/readme.md
+++ b/tooling/readme.md
@@ -4,7 +4,7 @@ Below we briefly describe the purpose of each tool-related crate in this reposit
 
 ## nargo
 
-This is the default package manager used by Noir. One may draw similarities to Rusts' Cargo.
+This is the default package manager used by Noir. One may draw similarities to Rust's Cargo.
 
 ## nargo_fmt
 
diff --git a/yarn.lock b/yarn.lock
index ae9251ac205..77962512b08 100644
--- a/yarn.lock
+++ b/yarn.lock
@@ -221,17 +221,19 @@ __metadata:
   languageName: node
   linkType: hard
 
-"@aztec/bb.js@npm:0.56.0":
-  version: 0.56.0
-  resolution: "@aztec/bb.js@npm:0.56.0"
+"@aztec/bb.js@npm:0.66.0":
+  version: 0.66.0
+  resolution: "@aztec/bb.js@npm:0.66.0"
   dependencies:
     comlink: ^4.4.1
     commander: ^10.0.1
     debug: ^4.3.4
+    fflate: ^0.8.0
+    pako: ^2.1.0
     tslib: ^2.4.0
   bin:
     bb.js: dest/node/main.js
-  checksum: 199a1e6c408e4c1399b69169e1a0a48bac92688299312a7dd6eca242e4970808bc370808d2fe4194f17e0d1fe7f5d09676709a05e3ad6ed569ac5553134be34a
+  checksum: 7295bf6543afe1c2db795a95c7ed40806de63c77e44bb4dacb2ec6a9171d1d34749150844ab47bc2499d06676e623acb408857b6aa9da702d3c576efadb8c906
   languageName: node
   linkType: hard
 
@@ -245,6 +247,16 @@ __metadata:
   languageName: node
   linkType: hard
 
+"@babel/code-frame@npm:^7.24.7":
+  version: 7.24.7
+  resolution: "@babel/code-frame@npm:7.24.7"
+  dependencies:
+    "@babel/highlight": ^7.24.7
+    picocolors: ^1.0.0
+  checksum: 830e62cd38775fdf84d612544251ce773d544a8e63df667728cc9e0126eeef14c6ebda79be0f0bc307e8318316b7f58c27ce86702e0a1f5c321d842eb38ffda4
+  languageName: node
+  linkType: hard
+
 "@babel/compat-data@npm:^7.22.6, @babel/compat-data@npm:^7.22.9, @babel/compat-data@npm:^7.23.3, @babel/compat-data@npm:^7.23.5":
   version: 7.23.5
   resolution: "@babel/compat-data@npm:7.23.5"
@@ -252,6 +264,13 @@ __metadata:
   languageName: node
   linkType: hard
 
+"@babel/compat-data@npm:^7.25.2, @babel/compat-data@npm:^7.25.4":
+  version: 7.25.4
+  resolution: "@babel/compat-data@npm:7.25.4"
+  checksum: b12a91d27c3731a4b0bdc9312a50b1911f41f7f728aaf0d4b32486e2257fd2cb2d3ea1a295e98449600c48f2c7883a3196ca77cda1cef7d97a10c2e83d037974
+  languageName: node
+  linkType: hard
+
 "@babel/core@npm:7.12.9":
   version: 7.12.9
   resolution: "@babel/core@npm:7.12.9"
@@ -299,6 +318,29 @@ __metadata:
   languageName: node
   linkType: hard
 
+"@babel/core@npm:^7.21.3":
+  version: 7.25.2
+  resolution: "@babel/core@npm:7.25.2"
+  dependencies:
+    "@ampproject/remapping": ^2.2.0
+    "@babel/code-frame": ^7.24.7
+    "@babel/generator": ^7.25.0
+    "@babel/helper-compilation-targets": ^7.25.2
+    "@babel/helper-module-transforms": ^7.25.2
+    "@babel/helpers": ^7.25.0
+    "@babel/parser": ^7.25.0
+    "@babel/template": ^7.25.0
+    "@babel/traverse": ^7.25.2
+    "@babel/types": ^7.25.2
+    convert-source-map: ^2.0.0
+    debug: ^4.1.0
+    gensync: ^1.0.0-beta.2
+    json5: ^2.2.3
+    semver: ^6.3.1
+  checksum: 9a1ef604a7eb62195f70f9370cec45472a08114e3934e3eaaedee8fd754edf0730e62347c7b4b5e67d743ce57b5bb8cf3b92459482ca94d06e06246ef021390a
+  languageName: node
+  linkType: hard
+
 "@babel/generator@npm:^7.12.5, @babel/generator@npm:^7.18.7, @babel/generator@npm:^7.23.3, @babel/generator@npm:^7.23.5":
   version: 7.23.5
   resolution: "@babel/generator@npm:7.23.5"
@@ -311,6 +353,18 @@ __metadata:
   languageName: node
   linkType: hard
 
+"@babel/generator@npm:^7.25.0, @babel/generator@npm:^7.25.6":
+  version: 7.25.6
+  resolution: "@babel/generator@npm:7.25.6"
+  dependencies:
+    "@babel/types": ^7.25.6
+    "@jridgewell/gen-mapping": ^0.3.5
+    "@jridgewell/trace-mapping": ^0.3.25
+    jsesc: ^2.5.1
+  checksum: b55975cd664f5602304d868bb34f4ee3bed6f5c7ce8132cd92ff27a46a53a119def28a182d91992e86f75db904f63094a81247703c4dc96e4db0c03fd04bcd68
+  languageName: node
+  linkType: hard
+
 "@babel/helper-annotate-as-pure@npm:^7.22.5":
   version: 7.22.5
   resolution: "@babel/helper-annotate-as-pure@npm:7.22.5"
@@ -320,6 +374,15 @@ __metadata:
   languageName: node
   linkType: hard
 
+"@babel/helper-annotate-as-pure@npm:^7.24.7":
+  version: 7.24.7
+  resolution: "@babel/helper-annotate-as-pure@npm:7.24.7"
+  dependencies:
+    "@babel/types": ^7.24.7
+  checksum: 6178566099a6a0657db7a7fa601a54fb4731ca0b8614fbdccfd8e523c210c13963649bc8fdfd53ce7dd14d05e3dda2fb22dea5b30113c488b9eb1a906d60212e
+  languageName: node
+  linkType: hard
+
 "@babel/helper-builder-binary-assignment-operator-visitor@npm:^7.22.15":
   version: 7.22.15
   resolution: "@babel/helper-builder-binary-assignment-operator-visitor@npm:7.22.15"
@@ -329,6 +392,16 @@ __metadata:
   languageName: node
   linkType: hard
 
+"@babel/helper-builder-binary-assignment-operator-visitor@npm:^7.24.7":
+  version: 7.24.7
+  resolution: "@babel/helper-builder-binary-assignment-operator-visitor@npm:7.24.7"
+  dependencies:
+    "@babel/traverse": ^7.24.7
+    "@babel/types": ^7.24.7
+  checksum: 71a6158a9fdebffb82fdc400d5555ba8f2e370cea81a0d578155877bdc4db7d5252b75c43b2fdf3f72b3f68348891f99bd35ae315542daad1b7ace8322b1abcb
+  languageName: node
+  linkType: hard
+
 "@babel/helper-compilation-targets@npm:^7.22.15, @babel/helper-compilation-targets@npm:^7.22.6":
   version: 7.22.15
   resolution: "@babel/helper-compilation-targets@npm:7.22.15"
@@ -342,6 +415,19 @@ __metadata:
   languageName: node
   linkType: hard
 
+"@babel/helper-compilation-targets@npm:^7.24.7, @babel/helper-compilation-targets@npm:^7.24.8, @babel/helper-compilation-targets@npm:^7.25.2":
+  version: 7.25.2
+  resolution: "@babel/helper-compilation-targets@npm:7.25.2"
+  dependencies:
+    "@babel/compat-data": ^7.25.2
+    "@babel/helper-validator-option": ^7.24.8
+    browserslist: ^4.23.1
+    lru-cache: ^5.1.1
+    semver: ^6.3.1
+  checksum: aed33c5496cb9db4b5e2d44e26bf8bc474074cc7f7bb5ebe1d4a20fdeb362cb3ba9e1596ca18c7484bcd6e5c3a155ab975e420d520c0ae60df81f9de04d0fd16
+  languageName: node
+  linkType: hard
+
 "@babel/helper-create-class-features-plugin@npm:^7.22.15, @babel/helper-create-class-features-plugin@npm:^7.23.5":
   version: 7.23.5
   resolution: "@babel/helper-create-class-features-plugin@npm:7.23.5"
@@ -361,6 +447,23 @@ __metadata:
   languageName: node
   linkType: hard
 
+"@babel/helper-create-class-features-plugin@npm:^7.24.7, @babel/helper-create-class-features-plugin@npm:^7.25.0, @babel/helper-create-class-features-plugin@npm:^7.25.4":
+  version: 7.25.4
+  resolution: "@babel/helper-create-class-features-plugin@npm:7.25.4"
+  dependencies:
+    "@babel/helper-annotate-as-pure": ^7.24.7
+    "@babel/helper-member-expression-to-functions": ^7.24.8
+    "@babel/helper-optimise-call-expression": ^7.24.7
+    "@babel/helper-replace-supers": ^7.25.0
+    "@babel/helper-skip-transparent-expression-wrappers": ^7.24.7
+    "@babel/traverse": ^7.25.4
+    semver: ^6.3.1
+  peerDependencies:
+    "@babel/core": ^7.0.0
+  checksum: 4544ebda4516eb25efdebd47ca024bd7bdb1eb6e7cc3ad89688c8ef8e889734c2f4411ed78981899c641394f013f246f2af63d92a0e9270f6c453309b4cb89ba
+  languageName: node
+  linkType: hard
+
 "@babel/helper-create-regexp-features-plugin@npm:^7.18.6, @babel/helper-create-regexp-features-plugin@npm:^7.22.15, @babel/helper-create-regexp-features-plugin@npm:^7.22.5":
   version: 7.22.15
   resolution: "@babel/helper-create-regexp-features-plugin@npm:7.22.15"
@@ -374,6 +477,19 @@ __metadata:
   languageName: node
   linkType: hard
 
+"@babel/helper-create-regexp-features-plugin@npm:^7.24.7, @babel/helper-create-regexp-features-plugin@npm:^7.25.0, @babel/helper-create-regexp-features-plugin@npm:^7.25.2":
+  version: 7.25.2
+  resolution: "@babel/helper-create-regexp-features-plugin@npm:7.25.2"
+  dependencies:
+    "@babel/helper-annotate-as-pure": ^7.24.7
+    regexpu-core: ^5.3.1
+    semver: ^6.3.1
+  peerDependencies:
+    "@babel/core": ^7.0.0
+  checksum: df55fdc6a1f3090dd37d91347df52d9322d52affa239543808dc142f8fe35e6787e67d8612337668198fac85826fafa9e6772e6c28b7d249ec94e6fafae5da6e
+  languageName: node
+  linkType: hard
+
 "@babel/helper-define-polyfill-provider@npm:^0.4.3":
   version: 0.4.3
   resolution: "@babel/helper-define-polyfill-provider@npm:0.4.3"
@@ -389,6 +505,21 @@ __metadata:
   languageName: node
   linkType: hard
 
+"@babel/helper-define-polyfill-provider@npm:^0.6.2":
+  version: 0.6.2
+  resolution: "@babel/helper-define-polyfill-provider@npm:0.6.2"
+  dependencies:
+    "@babel/helper-compilation-targets": ^7.22.6
+    "@babel/helper-plugin-utils": ^7.22.5
+    debug: ^4.1.1
+    lodash.debounce: ^4.0.8
+    resolve: ^1.14.2
+  peerDependencies:
+    "@babel/core": ^7.4.0 || ^8.0.0-0 <8.0.0
+  checksum: 2bba965ea9a4887ddf9c11d51d740ab473bd7597b787d042c325f6a45912dfe908c2d6bb1d837bf82f7e9fa51e6ad5150563c58131d2bb85515e63d971414a9c
+  languageName: node
+  linkType: hard
+
 "@babel/helper-environment-visitor@npm:^7.22.20":
   version: 7.22.20
   resolution: "@babel/helper-environment-visitor@npm:7.22.20"
@@ -424,6 +555,16 @@ __metadata:
   languageName: node
   linkType: hard
 
+"@babel/helper-member-expression-to-functions@npm:^7.24.8":
+  version: 7.24.8
+  resolution: "@babel/helper-member-expression-to-functions@npm:7.24.8"
+  dependencies:
+    "@babel/traverse": ^7.24.8
+    "@babel/types": ^7.24.8
+  checksum: bf923d05d81b06857f4ca4fe9c528c9c447a58db5ea39595bb559eae2fce01a8266173db0fd6a2ec129d7bbbb9bb22f4e90008252f7c66b422c76630a878a4bc
+  languageName: node
+  linkType: hard
+
 "@babel/helper-module-imports@npm:^7.22.15":
   version: 7.22.15
   resolution: "@babel/helper-module-imports@npm:7.22.15"
@@ -433,6 +574,16 @@ __metadata:
   languageName: node
   linkType: hard
 
+"@babel/helper-module-imports@npm:^7.24.7":
+  version: 7.24.7
+  resolution: "@babel/helper-module-imports@npm:7.24.7"
+  dependencies:
+    "@babel/traverse": ^7.24.7
+    "@babel/types": ^7.24.7
+  checksum: 8ac15d96d262b8940bc469052a048e06430bba1296369be695fabdf6799f201dd0b00151762b56012a218464e706bc033f27c07f6cec20c6f8f5fd6543c67054
+  languageName: node
+  linkType: hard
+
 "@babel/helper-module-transforms@npm:^7.12.1, @babel/helper-module-transforms@npm:^7.23.3":
   version: 7.23.3
   resolution: "@babel/helper-module-transforms@npm:7.23.3"
@@ -448,6 +599,20 @@ __metadata:
   languageName: node
   linkType: hard
 
+"@babel/helper-module-transforms@npm:^7.24.7, @babel/helper-module-transforms@npm:^7.24.8, @babel/helper-module-transforms@npm:^7.25.0, @babel/helper-module-transforms@npm:^7.25.2":
+  version: 7.25.2
+  resolution: "@babel/helper-module-transforms@npm:7.25.2"
+  dependencies:
+    "@babel/helper-module-imports": ^7.24.7
+    "@babel/helper-simple-access": ^7.24.7
+    "@babel/helper-validator-identifier": ^7.24.7
+    "@babel/traverse": ^7.25.2
+  peerDependencies:
+    "@babel/core": ^7.0.0
+  checksum: 282d4e3308df6746289e46e9c39a0870819630af5f84d632559171e4fae6045684d771a65f62df3d569e88ccf81dc2def78b8338a449ae3a94bb421aa14fc367
+  languageName: node
+  linkType: hard
+
 "@babel/helper-optimise-call-expression@npm:^7.22.5":
   version: 7.22.5
   resolution: "@babel/helper-optimise-call-expression@npm:7.22.5"
@@ -457,6 +622,15 @@ __metadata:
   languageName: node
   linkType: hard
 
+"@babel/helper-optimise-call-expression@npm:^7.24.7":
+  version: 7.24.7
+  resolution: "@babel/helper-optimise-call-expression@npm:7.24.7"
+  dependencies:
+    "@babel/types": ^7.24.7
+  checksum: 280654eaf90e92bf383d7eed49019573fb35a98c9e992668f701ad099957246721044be2068cf6840cb2299e0ad393705a1981c88c23a1048096a8d59e5f79a3
+  languageName: node
+  linkType: hard
+
 "@babel/helper-plugin-utils@npm:7.10.4":
   version: 7.10.4
   resolution: "@babel/helper-plugin-utils@npm:7.10.4"
@@ -471,6 +645,13 @@ __metadata:
   languageName: node
   linkType: hard
 
+"@babel/helper-plugin-utils@npm:^7.24.7, @babel/helper-plugin-utils@npm:^7.24.8":
+  version: 7.24.8
+  resolution: "@babel/helper-plugin-utils@npm:7.24.8"
+  checksum: 73b1a83ba8bcee21dc94de2eb7323207391715e4369fd55844bb15cf13e3df6f3d13a40786d990e6370bf0f571d94fc31f70dec96c1d1002058258c35ca3767a
+  languageName: node
+  linkType: hard
+
 "@babel/helper-remap-async-to-generator@npm:^7.22.20":
   version: 7.22.20
   resolution: "@babel/helper-remap-async-to-generator@npm:7.22.20"
@@ -484,6 +665,19 @@ __metadata:
   languageName: node
   linkType: hard
 
+"@babel/helper-remap-async-to-generator@npm:^7.24.7, @babel/helper-remap-async-to-generator@npm:^7.25.0":
+  version: 7.25.0
+  resolution: "@babel/helper-remap-async-to-generator@npm:7.25.0"
+  dependencies:
+    "@babel/helper-annotate-as-pure": ^7.24.7
+    "@babel/helper-wrap-function": ^7.25.0
+    "@babel/traverse": ^7.25.0
+  peerDependencies:
+    "@babel/core": ^7.0.0
+  checksum: 47f3065e43fe9d6128ddb4291ffb9cf031935379265fd13de972b5f241943121f7583efb69cd2e1ecf39e3d0f76f047547d56c3fcc2c853b326fad5465da0bd7
+  languageName: node
+  linkType: hard
+
 "@babel/helper-replace-supers@npm:^7.22.20":
   version: 7.22.20
   resolution: "@babel/helper-replace-supers@npm:7.22.20"
@@ -497,6 +691,19 @@ __metadata:
   languageName: node
   linkType: hard
 
+"@babel/helper-replace-supers@npm:^7.24.7, @babel/helper-replace-supers@npm:^7.25.0":
+  version: 7.25.0
+  resolution: "@babel/helper-replace-supers@npm:7.25.0"
+  dependencies:
+    "@babel/helper-member-expression-to-functions": ^7.24.8
+    "@babel/helper-optimise-call-expression": ^7.24.7
+    "@babel/traverse": ^7.25.0
+  peerDependencies:
+    "@babel/core": ^7.0.0
+  checksum: f669fc2487c22d40b808f94b9c3ee41129484d5ef0ba689bdd70f216ff91e10b6b021d2f8cd37e7bdd700235a2a6ae6622526344f064528190383bf661ac65f8
+  languageName: node
+  linkType: hard
+
 "@babel/helper-simple-access@npm:^7.22.5":
   version: 7.22.5
   resolution: "@babel/helper-simple-access@npm:7.22.5"
@@ -506,6 +713,16 @@ __metadata:
   languageName: node
   linkType: hard
 
+"@babel/helper-simple-access@npm:^7.24.7":
+  version: 7.24.7
+  resolution: "@babel/helper-simple-access@npm:7.24.7"
+  dependencies:
+    "@babel/traverse": ^7.24.7
+    "@babel/types": ^7.24.7
+  checksum: ddbf55f9dea1900213f2a1a8500fabfd21c5a20f44dcfa957e4b0d8638c730f88751c77f678644f754f1a1dc73f4eb8b766c300deb45a9daad000e4247957819
+  languageName: node
+  linkType: hard
+
 "@babel/helper-skip-transparent-expression-wrappers@npm:^7.22.5":
   version: 7.22.5
   resolution: "@babel/helper-skip-transparent-expression-wrappers@npm:7.22.5"
@@ -515,6 +732,16 @@ __metadata:
   languageName: node
   linkType: hard
 
+"@babel/helper-skip-transparent-expression-wrappers@npm:^7.24.7":
+  version: 7.24.7
+  resolution: "@babel/helper-skip-transparent-expression-wrappers@npm:7.24.7"
+  dependencies:
+    "@babel/traverse": ^7.24.7
+    "@babel/types": ^7.24.7
+  checksum: 11b28fe534ce2b1a67c4d8e51a7b5711a2a0a0cae802f74614eee54cca58c744d9a62f6f60103c41759e81c537d270bfd665bf368a6bea214c6052f2094f8407
+  languageName: node
+  linkType: hard
+
 "@babel/helper-split-export-declaration@npm:^7.22.6":
   version: 7.22.6
   resolution: "@babel/helper-split-export-declaration@npm:7.22.6"
@@ -531,6 +758,13 @@ __metadata:
   languageName: node
   linkType: hard
 
+"@babel/helper-string-parser@npm:^7.24.8":
+  version: 7.24.8
+  resolution: "@babel/helper-string-parser@npm:7.24.8"
+  checksum: 39b03c5119216883878655b149148dc4d2e284791e969b19467a9411fccaa33f7a713add98f4db5ed519535f70ad273cdadfd2eb54d47ebbdeac5083351328ce
+  languageName: node
+  linkType: hard
+
 "@babel/helper-validator-identifier@npm:^7.22.20":
   version: 7.22.20
   resolution: "@babel/helper-validator-identifier@npm:7.22.20"
@@ -538,6 +772,13 @@ __metadata:
   languageName: node
   linkType: hard
 
+"@babel/helper-validator-identifier@npm:^7.24.7":
+  version: 7.24.7
+  resolution: "@babel/helper-validator-identifier@npm:7.24.7"
+  checksum: 6799ab117cefc0ecd35cd0b40ead320c621a298ecac88686a14cffceaac89d80cdb3c178f969861bf5fa5e4f766648f9161ea0752ecfe080d8e89e3147270257
+  languageName: node
+  linkType: hard
+
 "@babel/helper-validator-option@npm:^7.22.15, @babel/helper-validator-option@npm:^7.23.5":
   version: 7.23.5
   resolution: "@babel/helper-validator-option@npm:7.23.5"
@@ -545,6 +786,13 @@ __metadata:
   languageName: node
   linkType: hard
 
+"@babel/helper-validator-option@npm:^7.24.7, @babel/helper-validator-option@npm:^7.24.8":
+  version: 7.24.8
+  resolution: "@babel/helper-validator-option@npm:7.24.8"
+  checksum: a52442dfa74be6719c0608fee3225bd0493c4057459f3014681ea1a4643cd38b68ff477fe867c4b356da7330d085f247f0724d300582fa4ab9a02efaf34d107c
+  languageName: node
+  linkType: hard
+
 "@babel/helper-wrap-function@npm:^7.22.20":
   version: 7.22.20
   resolution: "@babel/helper-wrap-function@npm:7.22.20"
@@ -556,6 +804,17 @@ __metadata:
   languageName: node
   linkType: hard
 
+"@babel/helper-wrap-function@npm:^7.25.0":
+  version: 7.25.0
+  resolution: "@babel/helper-wrap-function@npm:7.25.0"
+  dependencies:
+    "@babel/template": ^7.25.0
+    "@babel/traverse": ^7.25.0
+    "@babel/types": ^7.25.0
+  checksum: 0095b4741704066d1687f9bbd5370bb88c733919e4275e49615f70c180208148ff5f24ab58d186ce92f8f5d28eab034ec6617e9264590cc4744c75302857629c
+  languageName: node
+  linkType: hard
+
 "@babel/helpers@npm:^7.12.5, @babel/helpers@npm:^7.23.5":
   version: 7.23.5
   resolution: "@babel/helpers@npm:7.23.5"
@@ -567,6 +826,16 @@ __metadata:
   languageName: node
   linkType: hard
 
+"@babel/helpers@npm:^7.25.0":
+  version: 7.25.6
+  resolution: "@babel/helpers@npm:7.25.6"
+  dependencies:
+    "@babel/template": ^7.25.0
+    "@babel/types": ^7.25.6
+  checksum: 5a548999db82049a5f7ac6de57576b4ed0d386ce07d058151698836ed411eae6230db12535487caeebb68a2ffc964491e8aead62364a5132ab0ae20e8b68e19f
+  languageName: node
+  linkType: hard
+
 "@babel/highlight@npm:^7.23.4":
   version: 7.23.4
   resolution: "@babel/highlight@npm:7.23.4"
@@ -578,7 +847,19 @@ __metadata:
   languageName: node
   linkType: hard
 
-"@babel/parser@npm:^7.12.7, @babel/parser@npm:^7.18.8, @babel/parser@npm:^7.22.15, @babel/parser@npm:^7.22.7, @babel/parser@npm:^7.23.5":
+"@babel/highlight@npm:^7.24.7":
+  version: 7.24.7
+  resolution: "@babel/highlight@npm:7.24.7"
+  dependencies:
+    "@babel/helper-validator-identifier": ^7.24.7
+    chalk: ^2.4.2
+    js-tokens: ^4.0.0
+    picocolors: ^1.0.0
+  checksum: 5cd3a89f143671c4ac129960024ba678b669e6fc673ce078030f5175002d1d3d52bc10b22c5b916a6faf644b5028e9a4bd2bb264d053d9b05b6a98690f1d46f1
+  languageName: node
+  linkType: hard
+
+"@babel/parser@npm:^7.12.7, @babel/parser@npm:^7.18.8, @babel/parser@npm:^7.22.15, @babel/parser@npm:^7.23.5":
   version: 7.23.5
   resolution: "@babel/parser@npm:7.23.5"
   bin:
@@ -587,6 +868,40 @@ __metadata:
   languageName: node
   linkType: hard
 
+"@babel/parser@npm:^7.25.0, @babel/parser@npm:^7.25.6":
+  version: 7.25.6
+  resolution: "@babel/parser@npm:7.25.6"
+  dependencies:
+    "@babel/types": ^7.25.6
+  bin:
+    parser: ./bin/babel-parser.js
+  checksum: 85b237ded09ee43cc984493c35f3b1ff8a83e8dbbb8026b8132e692db6567acc5a1659ec928e4baa25499ddd840d7dae9dee3062be7108fe23ec5f94a8066b1e
+  languageName: node
+  linkType: hard
+
+"@babel/plugin-bugfix-firefox-class-in-computed-class-key@npm:^7.25.3":
+  version: 7.25.3
+  resolution: "@babel/plugin-bugfix-firefox-class-in-computed-class-key@npm:7.25.3"
+  dependencies:
+    "@babel/helper-plugin-utils": ^7.24.8
+    "@babel/traverse": ^7.25.3
+  peerDependencies:
+    "@babel/core": ^7.0.0
+  checksum: d3dba60f360defe70eb43e35a1b17ea9dd4a99e734249e15be3d5c288019644f96f88d7ff51990118fda0845b4ad50f6d869e0382232b1d8b054d113d4eea7e2
+  languageName: node
+  linkType: hard
+
+"@babel/plugin-bugfix-safari-class-field-initializer-scope@npm:^7.25.0":
+  version: 7.25.0
+  resolution: "@babel/plugin-bugfix-safari-class-field-initializer-scope@npm:7.25.0"
+  dependencies:
+    "@babel/helper-plugin-utils": ^7.24.8
+  peerDependencies:
+    "@babel/core": ^7.0.0
+  checksum: fd56d1e6435f2c008ca9050ea906ff7eedcbec43f532f2bf2e7e905d8bf75bf5e4295ea9593f060394e2c8e45737266ccbf718050bad2dd7be4e7613c60d1b5b
+  languageName: node
+  linkType: hard
+
 "@babel/plugin-bugfix-safari-id-destructuring-collision-in-function-expression@npm:^7.23.3":
   version: 7.23.3
   resolution: "@babel/plugin-bugfix-safari-id-destructuring-collision-in-function-expression@npm:7.23.3"
@@ -598,6 +913,17 @@ __metadata:
   languageName: node
   linkType: hard
 
+"@babel/plugin-bugfix-safari-id-destructuring-collision-in-function-expression@npm:^7.25.0":
+  version: 7.25.0
+  resolution: "@babel/plugin-bugfix-safari-id-destructuring-collision-in-function-expression@npm:7.25.0"
+  dependencies:
+    "@babel/helper-plugin-utils": ^7.24.8
+  peerDependencies:
+    "@babel/core": ^7.0.0
+  checksum: 13ed301b108d85867d64226bbc4032b07dd1a23aab68e9e32452c4fe3930f2198bb65bdae9c262c4104bd5e45647bc1830d25d43d356ee9a137edd8d5fab8350
+  languageName: node
+  linkType: hard
+
 "@babel/plugin-bugfix-v8-spread-parameters-in-optional-chaining@npm:^7.23.3":
   version: 7.23.3
   resolution: "@babel/plugin-bugfix-v8-spread-parameters-in-optional-chaining@npm:7.23.3"
@@ -611,6 +937,19 @@ __metadata:
   languageName: node
   linkType: hard
 
+"@babel/plugin-bugfix-v8-spread-parameters-in-optional-chaining@npm:^7.24.7":
+  version: 7.24.7
+  resolution: "@babel/plugin-bugfix-v8-spread-parameters-in-optional-chaining@npm:7.24.7"
+  dependencies:
+    "@babel/helper-plugin-utils": ^7.24.7
+    "@babel/helper-skip-transparent-expression-wrappers": ^7.24.7
+    "@babel/plugin-transform-optional-chaining": ^7.24.7
+  peerDependencies:
+    "@babel/core": ^7.13.0
+  checksum: 07b92878ac58a98ea1fdf6a8b4ec3413ba4fa66924e28b694d63ec5b84463123fbf4d7153b56cf3cedfef4a3482c082fe3243c04f8fb2c041b32b0e29b4a9e21
+  languageName: node
+  linkType: hard
+
 "@babel/plugin-bugfix-v8-static-class-fields-redefine-readonly@npm:^7.23.3":
   version: 7.23.3
   resolution: "@babel/plugin-bugfix-v8-static-class-fields-redefine-readonly@npm:7.23.3"
@@ -623,6 +962,18 @@ __metadata:
   languageName: node
   linkType: hard
 
+"@babel/plugin-bugfix-v8-static-class-fields-redefine-readonly@npm:^7.25.0":
+  version: 7.25.0
+  resolution: "@babel/plugin-bugfix-v8-static-class-fields-redefine-readonly@npm:7.25.0"
+  dependencies:
+    "@babel/helper-plugin-utils": ^7.24.8
+    "@babel/traverse": ^7.25.0
+  peerDependencies:
+    "@babel/core": ^7.0.0
+  checksum: c8d08b8d6cc71451ad2a50cf7db72ab5b41c1e5e2e4d56cf6837a25a61270abd682c6b8881ab025f11a552d2024b3780519bb051459ebb71c27aed13d9917663
+  languageName: node
+  linkType: hard
+
 "@babel/plugin-proposal-object-rest-spread@npm:7.12.1":
   version: 7.12.1
   resolution: "@babel/plugin-proposal-object-rest-spread@npm:7.12.1"
@@ -711,6 +1062,17 @@ __metadata:
   languageName: node
   linkType: hard
 
+"@babel/plugin-syntax-import-assertions@npm:^7.24.7":
+  version: 7.25.6
+  resolution: "@babel/plugin-syntax-import-assertions@npm:7.25.6"
+  dependencies:
+    "@babel/helper-plugin-utils": ^7.24.8
+  peerDependencies:
+    "@babel/core": ^7.0.0-0
+  checksum: b3b251ace9f184c2d6369cde686ff01581050cb0796f2ff00ff4021f31cf86270b347df09579f2c0996e999e37e1dddafacec42ed1ef6aae21a265aff947e792
+  languageName: node
+  linkType: hard
+
 "@babel/plugin-syntax-import-attributes@npm:^7.23.3":
   version: 7.23.3
   resolution: "@babel/plugin-syntax-import-attributes@npm:7.23.3"
@@ -722,6 +1084,17 @@ __metadata:
   languageName: node
   linkType: hard
 
+"@babel/plugin-syntax-import-attributes@npm:^7.24.7":
+  version: 7.25.6
+  resolution: "@babel/plugin-syntax-import-attributes@npm:7.25.6"
+  dependencies:
+    "@babel/helper-plugin-utils": ^7.24.8
+  peerDependencies:
+    "@babel/core": ^7.0.0-0
+  checksum: 3b0928e73e42346e8a65760a3ff853c87ad693cdf11bb335a23e895e0b5b1f0601118521b3aff2a6946488a580a63afb6a5b5686153a7678b4dff0e4e4604dd7
+  languageName: node
+  linkType: hard
+
 "@babel/plugin-syntax-import-meta@npm:^7.10.4":
   version: 7.10.4
   resolution: "@babel/plugin-syntax-import-meta@npm:7.10.4"
@@ -766,6 +1139,17 @@ __metadata:
   languageName: node
   linkType: hard
 
+"@babel/plugin-syntax-jsx@npm:^7.24.7":
+  version: 7.24.7
+  resolution: "@babel/plugin-syntax-jsx@npm:7.24.7"
+  dependencies:
+    "@babel/helper-plugin-utils": ^7.24.7
+  peerDependencies:
+    "@babel/core": ^7.0.0-0
+  checksum: 7a5ca629d8ca1e1ee78705a78e58c12920d07ed8006d7e7232b31296a384ff5e41d7b649bde5561196041037bbb9f9715be1d1c20975df87ca204f34ad15b965
+  languageName: node
+  linkType: hard
+
 "@babel/plugin-syntax-logical-assignment-operators@npm:^7.10.4":
   version: 7.10.4
   resolution: "@babel/plugin-syntax-logical-assignment-operators@npm:7.10.4"
@@ -865,6 +1249,17 @@ __metadata:
   languageName: node
   linkType: hard
 
+"@babel/plugin-syntax-typescript@npm:^7.24.7":
+  version: 7.25.4
+  resolution: "@babel/plugin-syntax-typescript@npm:7.25.4"
+  dependencies:
+    "@babel/helper-plugin-utils": ^7.24.8
+  peerDependencies:
+    "@babel/core": ^7.0.0-0
+  checksum: 9b89b8930cd5983f64251d75c9fcdc17a8dc73837d6de12220ff972888ecff4054a6467cf0c423cad242aa96c0f0564a39a0823073728cc02239b80d13f02230
+  languageName: node
+  linkType: hard
+
 "@babel/plugin-syntax-unicode-sets-regex@npm:^7.18.6":
   version: 7.18.6
   resolution: "@babel/plugin-syntax-unicode-sets-regex@npm:7.18.6"
@@ -888,6 +1283,17 @@ __metadata:
   languageName: node
   linkType: hard
 
+"@babel/plugin-transform-arrow-functions@npm:^7.24.7":
+  version: 7.24.7
+  resolution: "@babel/plugin-transform-arrow-functions@npm:7.24.7"
+  dependencies:
+    "@babel/helper-plugin-utils": ^7.24.7
+  peerDependencies:
+    "@babel/core": ^7.0.0-0
+  checksum: 707c209b5331c7dc79bd326128c6a6640dbd62a78da1653c844db20c4f36bf7b68454f1bc4d2d051b3fde9136fa291f276ec03a071bb00ee653069ff82f91010
+  languageName: node
+  linkType: hard
+
 "@babel/plugin-transform-async-generator-functions@npm:^7.23.4":
   version: 7.23.4
   resolution: "@babel/plugin-transform-async-generator-functions@npm:7.23.4"
@@ -902,6 +1308,20 @@ __metadata:
   languageName: node
   linkType: hard
 
+"@babel/plugin-transform-async-generator-functions@npm:^7.25.4":
+  version: 7.25.4
+  resolution: "@babel/plugin-transform-async-generator-functions@npm:7.25.4"
+  dependencies:
+    "@babel/helper-plugin-utils": ^7.24.8
+    "@babel/helper-remap-async-to-generator": ^7.25.0
+    "@babel/plugin-syntax-async-generators": ^7.8.4
+    "@babel/traverse": ^7.25.4
+  peerDependencies:
+    "@babel/core": ^7.0.0-0
+  checksum: 4235444735a1946f8766fe56564a8134c2c36c73e6cf83b3f2ed5624ebc84ff5979506a6a5b39acdb23aa09d442a6af471710ed408ccce533a2c4d2990b9df6a
+  languageName: node
+  linkType: hard
+
 "@babel/plugin-transform-async-to-generator@npm:^7.23.3":
   version: 7.23.3
   resolution: "@babel/plugin-transform-async-to-generator@npm:7.23.3"
@@ -915,6 +1335,19 @@ __metadata:
   languageName: node
   linkType: hard
 
+"@babel/plugin-transform-async-to-generator@npm:^7.24.7":
+  version: 7.24.7
+  resolution: "@babel/plugin-transform-async-to-generator@npm:7.24.7"
+  dependencies:
+    "@babel/helper-module-imports": ^7.24.7
+    "@babel/helper-plugin-utils": ^7.24.7
+    "@babel/helper-remap-async-to-generator": ^7.24.7
+  peerDependencies:
+    "@babel/core": ^7.0.0-0
+  checksum: 13704fb3b83effc868db2b71bfb2c77b895c56cb891954fc362e95e200afd523313b0e7cf04ce02f45b05e76017c5b5fa8070c92613727a35131bb542c253a36
+  languageName: node
+  linkType: hard
+
 "@babel/plugin-transform-block-scoped-functions@npm:^7.23.3":
   version: 7.23.3
   resolution: "@babel/plugin-transform-block-scoped-functions@npm:7.23.3"
@@ -926,6 +1359,17 @@ __metadata:
   languageName: node
   linkType: hard
 
+"@babel/plugin-transform-block-scoped-functions@npm:^7.24.7":
+  version: 7.24.7
+  resolution: "@babel/plugin-transform-block-scoped-functions@npm:7.24.7"
+  dependencies:
+    "@babel/helper-plugin-utils": ^7.24.7
+  peerDependencies:
+    "@babel/core": ^7.0.0-0
+  checksum: 249cdcbff4e778b177245f9652b014ea4f3cd245d83297f10a7bf6d97790074089aa62bcde8c08eb299c5e68f2faed346b587d3ebac44d625ba9a83a4ee27028
+  languageName: node
+  linkType: hard
+
 "@babel/plugin-transform-block-scoping@npm:^7.23.4":
   version: 7.23.4
   resolution: "@babel/plugin-transform-block-scoping@npm:7.23.4"
@@ -937,6 +1381,17 @@ __metadata:
   languageName: node
   linkType: hard
 
+"@babel/plugin-transform-block-scoping@npm:^7.25.0":
+  version: 7.25.0
+  resolution: "@babel/plugin-transform-block-scoping@npm:7.25.0"
+  dependencies:
+    "@babel/helper-plugin-utils": ^7.24.8
+  peerDependencies:
+    "@babel/core": ^7.0.0-0
+  checksum: b1a8f932f69ad2a47ae3e02b4cedd2a876bfc2ac9cf72a503fd706cdc87272646fe9eed81e068c0fc639647033de29f7fa0c21cddd1da0026f83dbaac97316a8
+  languageName: node
+  linkType: hard
+
 "@babel/plugin-transform-class-properties@npm:^7.23.3":
   version: 7.23.3
   resolution: "@babel/plugin-transform-class-properties@npm:7.23.3"
@@ -949,6 +1404,18 @@ __metadata:
   languageName: node
   linkType: hard
 
+"@babel/plugin-transform-class-properties@npm:^7.25.4":
+  version: 7.25.4
+  resolution: "@babel/plugin-transform-class-properties@npm:7.25.4"
+  dependencies:
+    "@babel/helper-create-class-features-plugin": ^7.25.4
+    "@babel/helper-plugin-utils": ^7.24.8
+  peerDependencies:
+    "@babel/core": ^7.0.0-0
+  checksum: b73f7d968639c6c2dfc13f4c5a8fe45cefd260f0faa7890ae12e65d41211072544ff5e128c8b61a86887b29ffd3df8422dbdfbf61648488e71d4bb599c41f4a5
+  languageName: node
+  linkType: hard
+
 "@babel/plugin-transform-class-static-block@npm:^7.23.4":
   version: 7.23.4
   resolution: "@babel/plugin-transform-class-static-block@npm:7.23.4"
@@ -962,6 +1429,19 @@ __metadata:
   languageName: node
   linkType: hard
 
+"@babel/plugin-transform-class-static-block@npm:^7.24.7":
+  version: 7.24.7
+  resolution: "@babel/plugin-transform-class-static-block@npm:7.24.7"
+  dependencies:
+    "@babel/helper-create-class-features-plugin": ^7.24.7
+    "@babel/helper-plugin-utils": ^7.24.7
+    "@babel/plugin-syntax-class-static-block": ^7.14.5
+  peerDependencies:
+    "@babel/core": ^7.12.0
+  checksum: 324049263504f18416f1c3e24033baebfafd05480fdd885c8ebe6f2b415b0fc8e0b98d719360f9e30743cc78ac387fabc0b3c6606d2b54135756ffb92963b382
+  languageName: node
+  linkType: hard
+
 "@babel/plugin-transform-classes@npm:^7.23.5":
   version: 7.23.5
   resolution: "@babel/plugin-transform-classes@npm:7.23.5"
@@ -981,6 +1461,22 @@ __metadata:
   languageName: node
   linkType: hard
 
+"@babel/plugin-transform-classes@npm:^7.25.4":
+  version: 7.25.4
+  resolution: "@babel/plugin-transform-classes@npm:7.25.4"
+  dependencies:
+    "@babel/helper-annotate-as-pure": ^7.24.7
+    "@babel/helper-compilation-targets": ^7.25.2
+    "@babel/helper-plugin-utils": ^7.24.8
+    "@babel/helper-replace-supers": ^7.25.0
+    "@babel/traverse": ^7.25.4
+    globals: ^11.1.0
+  peerDependencies:
+    "@babel/core": ^7.0.0-0
+  checksum: 0bf20e46eeb691bd60cee5d1b01950fc37accec88018ecace25099f7c8d8509c1ac54d11b8caf9f2157c6945969520642a3bc421159c1a14e80224dc9a7611de
+  languageName: node
+  linkType: hard
+
 "@babel/plugin-transform-computed-properties@npm:^7.23.3":
   version: 7.23.3
   resolution: "@babel/plugin-transform-computed-properties@npm:7.23.3"
@@ -993,6 +1489,18 @@ __metadata:
   languageName: node
   linkType: hard
 
+"@babel/plugin-transform-computed-properties@npm:^7.24.7":
+  version: 7.24.7
+  resolution: "@babel/plugin-transform-computed-properties@npm:7.24.7"
+  dependencies:
+    "@babel/helper-plugin-utils": ^7.24.7
+    "@babel/template": ^7.24.7
+  peerDependencies:
+    "@babel/core": ^7.0.0-0
+  checksum: 0cf8c1b1e4ea57dec8d4612460d84fd4cdbf71a7499bb61ee34632cf89018a59eee818ffca88a8d99ee7057c20a4257044d7d463fda6daef9bf1db9fa81563cb
+  languageName: node
+  linkType: hard
+
 "@babel/plugin-transform-destructuring@npm:^7.23.3":
   version: 7.23.3
   resolution: "@babel/plugin-transform-destructuring@npm:7.23.3"
@@ -1004,6 +1512,17 @@ __metadata:
   languageName: node
   linkType: hard
 
+"@babel/plugin-transform-destructuring@npm:^7.24.8":
+  version: 7.24.8
+  resolution: "@babel/plugin-transform-destructuring@npm:7.24.8"
+  dependencies:
+    "@babel/helper-plugin-utils": ^7.24.8
+  peerDependencies:
+    "@babel/core": ^7.0.0-0
+  checksum: 0b4bd3d608979a1e5bd97d9d42acd5ad405c7fffa61efac4c7afd8e86ea6c2d91ab2d94b6a98d63919571363fe76e0b03c4ff161f0f60241b895842596e4a999
+  languageName: node
+  linkType: hard
+
 "@babel/plugin-transform-dotall-regex@npm:^7.23.3":
   version: 7.23.3
   resolution: "@babel/plugin-transform-dotall-regex@npm:7.23.3"
@@ -1016,6 +1535,18 @@ __metadata:
   languageName: node
   linkType: hard
 
+"@babel/plugin-transform-dotall-regex@npm:^7.24.7":
+  version: 7.24.7
+  resolution: "@babel/plugin-transform-dotall-regex@npm:7.24.7"
+  dependencies:
+    "@babel/helper-create-regexp-features-plugin": ^7.24.7
+    "@babel/helper-plugin-utils": ^7.24.7
+  peerDependencies:
+    "@babel/core": ^7.0.0-0
+  checksum: 67b10fc6abb1f61f0e765288eb4c6d63d1d0f9fc0660e69f6f2170c56fa16bc74e49857afc644beda112b41771cd90cf52df0940d11e97e52617c77c7dcff171
+  languageName: node
+  linkType: hard
+
 "@babel/plugin-transform-duplicate-keys@npm:^7.23.3":
   version: 7.23.3
   resolution: "@babel/plugin-transform-duplicate-keys@npm:7.23.3"
@@ -1027,6 +1558,29 @@ __metadata:
   languageName: node
   linkType: hard
 
+"@babel/plugin-transform-duplicate-keys@npm:^7.24.7":
+  version: 7.24.7
+  resolution: "@babel/plugin-transform-duplicate-keys@npm:7.24.7"
+  dependencies:
+    "@babel/helper-plugin-utils": ^7.24.7
+  peerDependencies:
+    "@babel/core": ^7.0.0-0
+  checksum: d1da2ff85ecb56a63f4ccfd9dc9ae69400d85f0dadf44ecddd9e71c6e5c7a9178e74e3a9637555f415a2bb14551e563f09f98534ab54f53d25e8439fdde6ba2d
+  languageName: node
+  linkType: hard
+
+"@babel/plugin-transform-duplicate-named-capturing-groups-regex@npm:^7.25.0":
+  version: 7.25.0
+  resolution: "@babel/plugin-transform-duplicate-named-capturing-groups-regex@npm:7.25.0"
+  dependencies:
+    "@babel/helper-create-regexp-features-plugin": ^7.25.0
+    "@babel/helper-plugin-utils": ^7.24.8
+  peerDependencies:
+    "@babel/core": ^7.0.0
+  checksum: 608d6b0e77341189508880fd1a9f605a38d0803dd6f678ea3920ab181b17b377f6d5221ae8cf0104c7a044d30d4ddb0366bd064447695671d78457a656bb264f
+  languageName: node
+  linkType: hard
+
 "@babel/plugin-transform-dynamic-import@npm:^7.23.4":
   version: 7.23.4
   resolution: "@babel/plugin-transform-dynamic-import@npm:7.23.4"
@@ -1039,6 +1593,18 @@ __metadata:
   languageName: node
   linkType: hard
 
+"@babel/plugin-transform-dynamic-import@npm:^7.24.7":
+  version: 7.24.7
+  resolution: "@babel/plugin-transform-dynamic-import@npm:7.24.7"
+  dependencies:
+    "@babel/helper-plugin-utils": ^7.24.7
+    "@babel/plugin-syntax-dynamic-import": ^7.8.3
+  peerDependencies:
+    "@babel/core": ^7.0.0-0
+  checksum: 776509ff62ab40c12be814a342fc56a5cc09b91fb63032b2633414b635875fd7da03734657be0f6db2891fe6e3033b75d5ddb6f2baabd1a02e4443754a785002
+  languageName: node
+  linkType: hard
+
 "@babel/plugin-transform-exponentiation-operator@npm:^7.23.3":
   version: 7.23.3
   resolution: "@babel/plugin-transform-exponentiation-operator@npm:7.23.3"
@@ -1051,6 +1617,18 @@ __metadata:
   languageName: node
   linkType: hard
 
+"@babel/plugin-transform-exponentiation-operator@npm:^7.24.7":
+  version: 7.24.7
+  resolution: "@babel/plugin-transform-exponentiation-operator@npm:7.24.7"
+  dependencies:
+    "@babel/helper-builder-binary-assignment-operator-visitor": ^7.24.7
+    "@babel/helper-plugin-utils": ^7.24.7
+  peerDependencies:
+    "@babel/core": ^7.0.0-0
+  checksum: 23c84a23eb56589fdd35a3540f9a1190615be069110a2270865223c03aee3ba4e0fc68fe14850800cf36f0712b26e4964d3026235261f58f0405a29fe8dac9b1
+  languageName: node
+  linkType: hard
+
 "@babel/plugin-transform-export-namespace-from@npm:^7.23.4":
   version: 7.23.4
   resolution: "@babel/plugin-transform-export-namespace-from@npm:7.23.4"
@@ -1063,6 +1641,18 @@ __metadata:
   languageName: node
   linkType: hard
 
+"@babel/plugin-transform-export-namespace-from@npm:^7.24.7":
+  version: 7.24.7
+  resolution: "@babel/plugin-transform-export-namespace-from@npm:7.24.7"
+  dependencies:
+    "@babel/helper-plugin-utils": ^7.24.7
+    "@babel/plugin-syntax-export-namespace-from": ^7.8.3
+  peerDependencies:
+    "@babel/core": ^7.0.0-0
+  checksum: 3bd3a10038f10ae0dea1ee42137f3edcf7036b5e9e570a0d1cbd0865f03658990c6c2d84fa2475f87a754e7dc5b46766c16f7ce5c9b32c3040150b6a21233a80
+  languageName: node
+  linkType: hard
+
 "@babel/plugin-transform-for-of@npm:^7.23.3":
   version: 7.23.3
   resolution: "@babel/plugin-transform-for-of@npm:7.23.3"
@@ -1074,6 +1664,18 @@ __metadata:
   languageName: node
   linkType: hard
 
+"@babel/plugin-transform-for-of@npm:^7.24.7":
+  version: 7.24.7
+  resolution: "@babel/plugin-transform-for-of@npm:7.24.7"
+  dependencies:
+    "@babel/helper-plugin-utils": ^7.24.7
+    "@babel/helper-skip-transparent-expression-wrappers": ^7.24.7
+  peerDependencies:
+    "@babel/core": ^7.0.0-0
+  checksum: a53b42dc93ab4b7d1ebd3c695b52be22b3d592f6a3dbdb3dc2fea2c8e0a7e1508fe919864c455cde552aec44ce7518625fccbb70c7063373ca228d884f4f49ea
+  languageName: node
+  linkType: hard
+
 "@babel/plugin-transform-function-name@npm:^7.23.3":
   version: 7.23.3
   resolution: "@babel/plugin-transform-function-name@npm:7.23.3"
@@ -1087,6 +1689,19 @@ __metadata:
   languageName: node
   linkType: hard
 
+"@babel/plugin-transform-function-name@npm:^7.25.1":
+  version: 7.25.1
+  resolution: "@babel/plugin-transform-function-name@npm:7.25.1"
+  dependencies:
+    "@babel/helper-compilation-targets": ^7.24.8
+    "@babel/helper-plugin-utils": ^7.24.8
+    "@babel/traverse": ^7.25.1
+  peerDependencies:
+    "@babel/core": ^7.0.0-0
+  checksum: 743f3ea03bbc5a90944849d5a880b6bd9243dddbde581a46952da76e53a0b74c1e2424133fe8129d7a152c1f8c872bcd27e0b6728d7caadabd1afa7bb892e1e0
+  languageName: node
+  linkType: hard
+
 "@babel/plugin-transform-json-strings@npm:^7.23.4":
   version: 7.23.4
   resolution: "@babel/plugin-transform-json-strings@npm:7.23.4"
@@ -1099,6 +1714,18 @@ __metadata:
   languageName: node
   linkType: hard
 
+"@babel/plugin-transform-json-strings@npm:^7.24.7":
+  version: 7.24.7
+  resolution: "@babel/plugin-transform-json-strings@npm:7.24.7"
+  dependencies:
+    "@babel/helper-plugin-utils": ^7.24.7
+    "@babel/plugin-syntax-json-strings": ^7.8.3
+  peerDependencies:
+    "@babel/core": ^7.0.0-0
+  checksum: 88874d0b7a1ddea66c097fc0abb68801ffae194468aa44b828dde9a0e20ac5d8647943793de86092eabaa2911c96f67a6b373793d4bb9c932ef81b2711c06c2e
+  languageName: node
+  linkType: hard
+
 "@babel/plugin-transform-literals@npm:^7.23.3":
   version: 7.23.3
   resolution: "@babel/plugin-transform-literals@npm:7.23.3"
@@ -1110,6 +1737,17 @@ __metadata:
   languageName: node
   linkType: hard
 
+"@babel/plugin-transform-literals@npm:^7.25.2":
+  version: 7.25.2
+  resolution: "@babel/plugin-transform-literals@npm:7.25.2"
+  dependencies:
+    "@babel/helper-plugin-utils": ^7.24.8
+  peerDependencies:
+    "@babel/core": ^7.0.0-0
+  checksum: 70c9bb40e377a306bd8f500899fb72127e527517914466e95dc6bb53fa7a0f51479db244a54a771b5780fc1eab488fedd706669bf11097b81a23c81ab7423eb1
+  languageName: node
+  linkType: hard
+
 "@babel/plugin-transform-logical-assignment-operators@npm:^7.23.4":
   version: 7.23.4
   resolution: "@babel/plugin-transform-logical-assignment-operators@npm:7.23.4"
@@ -1122,6 +1760,18 @@ __metadata:
   languageName: node
   linkType: hard
 
+"@babel/plugin-transform-logical-assignment-operators@npm:^7.24.7":
+  version: 7.24.7
+  resolution: "@babel/plugin-transform-logical-assignment-operators@npm:7.24.7"
+  dependencies:
+    "@babel/helper-plugin-utils": ^7.24.7
+    "@babel/plugin-syntax-logical-assignment-operators": ^7.10.4
+  peerDependencies:
+    "@babel/core": ^7.0.0-0
+  checksum: 3367ce0be243704dc6fce23e86a592c4380f01998ee5dd9f94c54b1ef7b971ac6f8a002901eb51599ac6cbdc0d067af8d1a720224fca1c40fde8bb8aab804aac
+  languageName: node
+  linkType: hard
+
 "@babel/plugin-transform-member-expression-literals@npm:^7.23.3":
   version: 7.23.3
   resolution: "@babel/plugin-transform-member-expression-literals@npm:7.23.3"
@@ -1133,6 +1783,17 @@ __metadata:
   languageName: node
   linkType: hard
 
+"@babel/plugin-transform-member-expression-literals@npm:^7.24.7":
+  version: 7.24.7
+  resolution: "@babel/plugin-transform-member-expression-literals@npm:7.24.7"
+  dependencies:
+    "@babel/helper-plugin-utils": ^7.24.7
+  peerDependencies:
+    "@babel/core": ^7.0.0-0
+  checksum: 2720c57aa3bf70576146ba7d6ea03227f4611852122d76d237924f7b008dafc952e6ae61a19e5024f26c665f44384bbd378466f01b6bd1305b3564a3b7fb1a5d
+  languageName: node
+  linkType: hard
+
 "@babel/plugin-transform-modules-amd@npm:^7.23.3":
   version: 7.23.3
   resolution: "@babel/plugin-transform-modules-amd@npm:7.23.3"
@@ -1145,6 +1806,18 @@ __metadata:
   languageName: node
   linkType: hard
 
+"@babel/plugin-transform-modules-amd@npm:^7.24.7":
+  version: 7.24.7
+  resolution: "@babel/plugin-transform-modules-amd@npm:7.24.7"
+  dependencies:
+    "@babel/helper-module-transforms": ^7.24.7
+    "@babel/helper-plugin-utils": ^7.24.7
+  peerDependencies:
+    "@babel/core": ^7.0.0-0
+  checksum: f1dd0fb2f46c0f8f21076b8c7ccd5b33a85ce6dcb31518ea4c648d9a5bb2474cd4bd87c9b1b752e68591e24b022e334ba0d07631fef2b6b4d8a4b85cf3d581f5
+  languageName: node
+  linkType: hard
+
 "@babel/plugin-transform-modules-commonjs@npm:^7.23.3":
   version: 7.23.3
   resolution: "@babel/plugin-transform-modules-commonjs@npm:7.23.3"
@@ -1158,6 +1831,19 @@ __metadata:
   languageName: node
   linkType: hard
 
+"@babel/plugin-transform-modules-commonjs@npm:^7.24.7, @babel/plugin-transform-modules-commonjs@npm:^7.24.8":
+  version: 7.24.8
+  resolution: "@babel/plugin-transform-modules-commonjs@npm:7.24.8"
+  dependencies:
+    "@babel/helper-module-transforms": ^7.24.8
+    "@babel/helper-plugin-utils": ^7.24.8
+    "@babel/helper-simple-access": ^7.24.7
+  peerDependencies:
+    "@babel/core": ^7.0.0-0
+  checksum: a4cf95b1639c33382064b44558f73ee5fac023f2a94d16e549d2bb55ceebd5cbc10fcddd505d08cd5bc97f5a64af9fd155512358b7dcf7b1a0082e8945cf21c5
+  languageName: node
+  linkType: hard
+
 "@babel/plugin-transform-modules-systemjs@npm:^7.23.3":
   version: 7.23.3
   resolution: "@babel/plugin-transform-modules-systemjs@npm:7.23.3"
@@ -1172,6 +1858,20 @@ __metadata:
   languageName: node
   linkType: hard
 
+"@babel/plugin-transform-modules-systemjs@npm:^7.25.0":
+  version: 7.25.0
+  resolution: "@babel/plugin-transform-modules-systemjs@npm:7.25.0"
+  dependencies:
+    "@babel/helper-module-transforms": ^7.25.0
+    "@babel/helper-plugin-utils": ^7.24.8
+    "@babel/helper-validator-identifier": ^7.24.7
+    "@babel/traverse": ^7.25.0
+  peerDependencies:
+    "@babel/core": ^7.0.0-0
+  checksum: fe673bec08564e491847324bb80a1e6edfb229f5c37e58a094d51e95306e7b098e1d130fc43e992d22debd93b9beac74441ffc3f6ea5d78f6b2535896efa0728
+  languageName: node
+  linkType: hard
+
 "@babel/plugin-transform-modules-umd@npm:^7.23.3":
   version: 7.23.3
   resolution: "@babel/plugin-transform-modules-umd@npm:7.23.3"
@@ -1184,6 +1884,18 @@ __metadata:
   languageName: node
   linkType: hard
 
+"@babel/plugin-transform-modules-umd@npm:^7.24.7":
+  version: 7.24.7
+  resolution: "@babel/plugin-transform-modules-umd@npm:7.24.7"
+  dependencies:
+    "@babel/helper-module-transforms": ^7.24.7
+    "@babel/helper-plugin-utils": ^7.24.7
+  peerDependencies:
+    "@babel/core": ^7.0.0-0
+  checksum: 9ff1c464892efe042952ba778468bda6131b196a2729615bdcc3f24cdc94014f016a4616ee5643c5845bade6ba698f386833e61056d7201314b13a7fd69fac88
+  languageName: node
+  linkType: hard
+
 "@babel/plugin-transform-named-capturing-groups-regex@npm:^7.22.5":
   version: 7.22.5
   resolution: "@babel/plugin-transform-named-capturing-groups-regex@npm:7.22.5"
@@ -1196,6 +1908,18 @@ __metadata:
   languageName: node
   linkType: hard
 
+"@babel/plugin-transform-named-capturing-groups-regex@npm:^7.24.7":
+  version: 7.24.7
+  resolution: "@babel/plugin-transform-named-capturing-groups-regex@npm:7.24.7"
+  dependencies:
+    "@babel/helper-create-regexp-features-plugin": ^7.24.7
+    "@babel/helper-plugin-utils": ^7.24.7
+  peerDependencies:
+    "@babel/core": ^7.0.0
+  checksum: f1c6c7b5d60a86b6d7e4dd098798e1d393d55e993a0b57a73b53640c7a94985b601a96bdacee063f809a9a700bcea3a2ff18e98fa561554484ac56b761d774bd
+  languageName: node
+  linkType: hard
+
 "@babel/plugin-transform-new-target@npm:^7.23.3":
   version: 7.23.3
   resolution: "@babel/plugin-transform-new-target@npm:7.23.3"
@@ -1207,6 +1931,17 @@ __metadata:
   languageName: node
   linkType: hard
 
+"@babel/plugin-transform-new-target@npm:^7.24.7":
+  version: 7.24.7
+  resolution: "@babel/plugin-transform-new-target@npm:7.24.7"
+  dependencies:
+    "@babel/helper-plugin-utils": ^7.24.7
+  peerDependencies:
+    "@babel/core": ^7.0.0-0
+  checksum: 3cb94cd1076b270f768f91fdcf9dd2f6d487f8dbfff3df7ca8d07b915900b86d02769a35ba1407d16fe49499012c8f055e1741299e2c880798b953d942a8fa1b
+  languageName: node
+  linkType: hard
+
 "@babel/plugin-transform-nullish-coalescing-operator@npm:^7.23.4":
   version: 7.23.4
   resolution: "@babel/plugin-transform-nullish-coalescing-operator@npm:7.23.4"
@@ -1219,6 +1954,18 @@ __metadata:
   languageName: node
   linkType: hard
 
+"@babel/plugin-transform-nullish-coalescing-operator@npm:^7.24.7":
+  version: 7.24.7
+  resolution: "@babel/plugin-transform-nullish-coalescing-operator@npm:7.24.7"
+  dependencies:
+    "@babel/helper-plugin-utils": ^7.24.7
+    "@babel/plugin-syntax-nullish-coalescing-operator": ^7.8.3
+  peerDependencies:
+    "@babel/core": ^7.0.0-0
+  checksum: 4a9221356401d87762afbc37a9e8e764afc2daf09c421117537820f8cfbed6876888372ad3a7bcfae2d45c95f026651f050ab4020b777be31d3ffb00908dbdd3
+  languageName: node
+  linkType: hard
+
 "@babel/plugin-transform-numeric-separator@npm:^7.23.4":
   version: 7.23.4
   resolution: "@babel/plugin-transform-numeric-separator@npm:7.23.4"
@@ -1231,6 +1978,18 @@ __metadata:
   languageName: node
   linkType: hard
 
+"@babel/plugin-transform-numeric-separator@npm:^7.24.7":
+  version: 7.24.7
+  resolution: "@babel/plugin-transform-numeric-separator@npm:7.24.7"
+  dependencies:
+    "@babel/helper-plugin-utils": ^7.24.7
+    "@babel/plugin-syntax-numeric-separator": ^7.10.4
+  peerDependencies:
+    "@babel/core": ^7.0.0-0
+  checksum: 561b5f1d08b2c3f92ce849f092751558b5e6cfeb7eb55c79e7375c34dd9c3066dce5e630bb439affef6adcf202b6cbcaaa23870070276fa5bb429c8f5b8c7514
+  languageName: node
+  linkType: hard
+
 "@babel/plugin-transform-object-rest-spread@npm:^7.23.4":
   version: 7.23.4
   resolution: "@babel/plugin-transform-object-rest-spread@npm:7.23.4"
@@ -1246,6 +2005,20 @@ __metadata:
   languageName: node
   linkType: hard
 
+"@babel/plugin-transform-object-rest-spread@npm:^7.24.7":
+  version: 7.24.7
+  resolution: "@babel/plugin-transform-object-rest-spread@npm:7.24.7"
+  dependencies:
+    "@babel/helper-compilation-targets": ^7.24.7
+    "@babel/helper-plugin-utils": ^7.24.7
+    "@babel/plugin-syntax-object-rest-spread": ^7.8.3
+    "@babel/plugin-transform-parameters": ^7.24.7
+  peerDependencies:
+    "@babel/core": ^7.0.0-0
+  checksum: 169d257b9800c13e1feb4c37fb05dae84f702e58b342bb76e19e82e6692b7b5337c9923ee89e3916a97c0dd04a3375bdeca14f5e126f110bbacbeb46d1886ca2
+  languageName: node
+  linkType: hard
+
 "@babel/plugin-transform-object-super@npm:^7.23.3":
   version: 7.23.3
   resolution: "@babel/plugin-transform-object-super@npm:7.23.3"
@@ -1258,6 +2031,18 @@ __metadata:
   languageName: node
   linkType: hard
 
+"@babel/plugin-transform-object-super@npm:^7.24.7":
+  version: 7.24.7
+  resolution: "@babel/plugin-transform-object-super@npm:7.24.7"
+  dependencies:
+    "@babel/helper-plugin-utils": ^7.24.7
+    "@babel/helper-replace-supers": ^7.24.7
+  peerDependencies:
+    "@babel/core": ^7.0.0-0
+  checksum: f71e607a830ee50a22fa1a2686524d3339440cf9dea63032f6efbd865cfe4e35000e1e3f3492459e5c986f7c0c07dc36938bf3ce61fc9ba5f8ab732d0b64ab37
+  languageName: node
+  linkType: hard
+
 "@babel/plugin-transform-optional-catch-binding@npm:^7.23.4":
   version: 7.23.4
   resolution: "@babel/plugin-transform-optional-catch-binding@npm:7.23.4"
@@ -1270,6 +2055,18 @@ __metadata:
   languageName: node
   linkType: hard
 
+"@babel/plugin-transform-optional-catch-binding@npm:^7.24.7":
+  version: 7.24.7
+  resolution: "@babel/plugin-transform-optional-catch-binding@npm:7.24.7"
+  dependencies:
+    "@babel/helper-plugin-utils": ^7.24.7
+    "@babel/plugin-syntax-optional-catch-binding": ^7.8.3
+  peerDependencies:
+    "@babel/core": ^7.0.0-0
+  checksum: 7229f3a5a4facaab40f4fdfc7faabc157dc38a67d66bed7936599f4bc509e0bff636f847ac2aa45294881fce9cf8a0a460b85d2a465b7b977de9739fce9b18f6
+  languageName: node
+  linkType: hard
+
 "@babel/plugin-transform-optional-chaining@npm:^7.23.3, @babel/plugin-transform-optional-chaining@npm:^7.23.4":
   version: 7.23.4
   resolution: "@babel/plugin-transform-optional-chaining@npm:7.23.4"
@@ -1283,6 +2080,19 @@ __metadata:
   languageName: node
   linkType: hard
 
+"@babel/plugin-transform-optional-chaining@npm:^7.24.7, @babel/plugin-transform-optional-chaining@npm:^7.24.8":
+  version: 7.24.8
+  resolution: "@babel/plugin-transform-optional-chaining@npm:7.24.8"
+  dependencies:
+    "@babel/helper-plugin-utils": ^7.24.8
+    "@babel/helper-skip-transparent-expression-wrappers": ^7.24.7
+    "@babel/plugin-syntax-optional-chaining": ^7.8.3
+  peerDependencies:
+    "@babel/core": ^7.0.0-0
+  checksum: 45e55e3a2fffb89002d3f89aef59c141610f23b60eee41e047380bffc40290b59f64fc649aa7ec5281f73d41b2065410d788acc6afaad2a9f44cad6e8af04442
+  languageName: node
+  linkType: hard
+
 "@babel/plugin-transform-parameters@npm:^7.12.1, @babel/plugin-transform-parameters@npm:^7.23.3":
   version: 7.23.3
   resolution: "@babel/plugin-transform-parameters@npm:7.23.3"
@@ -1294,6 +2104,17 @@ __metadata:
   languageName: node
   linkType: hard
 
+"@babel/plugin-transform-parameters@npm:^7.24.7":
+  version: 7.24.7
+  resolution: "@babel/plugin-transform-parameters@npm:7.24.7"
+  dependencies:
+    "@babel/helper-plugin-utils": ^7.24.7
+  peerDependencies:
+    "@babel/core": ^7.0.0-0
+  checksum: ab534b03ac2eff94bc79342b8f39a4584666f5305a6c63c1964afda0b1b004e6b861e49d1683548030defe248e3590d3ff6338ee0552cb90c064f7e1479968c3
+  languageName: node
+  linkType: hard
+
 "@babel/plugin-transform-private-methods@npm:^7.23.3":
   version: 7.23.3
   resolution: "@babel/plugin-transform-private-methods@npm:7.23.3"
@@ -1306,6 +2127,18 @@ __metadata:
   languageName: node
   linkType: hard
 
+"@babel/plugin-transform-private-methods@npm:^7.25.4":
+  version: 7.25.4
+  resolution: "@babel/plugin-transform-private-methods@npm:7.25.4"
+  dependencies:
+    "@babel/helper-create-class-features-plugin": ^7.25.4
+    "@babel/helper-plugin-utils": ^7.24.8
+  peerDependencies:
+    "@babel/core": ^7.0.0-0
+  checksum: cb1dabfc03e2977990263d65bc8f43a9037dffbb5d9a5f825c00d05447ff68015099408c1531d9dd88f18a41a90f5062dc48f3a1d52b415d2d2ee4827dedff09
+  languageName: node
+  linkType: hard
+
 "@babel/plugin-transform-private-property-in-object@npm:^7.23.4":
   version: 7.23.4
   resolution: "@babel/plugin-transform-private-property-in-object@npm:7.23.4"
@@ -1320,6 +2153,20 @@ __metadata:
   languageName: node
   linkType: hard
 
+"@babel/plugin-transform-private-property-in-object@npm:^7.24.7":
+  version: 7.24.7
+  resolution: "@babel/plugin-transform-private-property-in-object@npm:7.24.7"
+  dependencies:
+    "@babel/helper-annotate-as-pure": ^7.24.7
+    "@babel/helper-create-class-features-plugin": ^7.24.7
+    "@babel/helper-plugin-utils": ^7.24.7
+    "@babel/plugin-syntax-private-property-in-object": ^7.14.5
+  peerDependencies:
+    "@babel/core": ^7.0.0-0
+  checksum: 8cee9473095305cc787bb653fd681719b49363281feabf677db8a552e8e41c94441408055d7e5fd5c7d41b315e634fa70b145ad0c7c54456216049df4ed57350
+  languageName: node
+  linkType: hard
+
 "@babel/plugin-transform-property-literals@npm:^7.23.3":
   version: 7.23.3
   resolution: "@babel/plugin-transform-property-literals@npm:7.23.3"
@@ -1331,6 +2178,17 @@ __metadata:
   languageName: node
   linkType: hard
 
+"@babel/plugin-transform-property-literals@npm:^7.24.7":
+  version: 7.24.7
+  resolution: "@babel/plugin-transform-property-literals@npm:7.24.7"
+  dependencies:
+    "@babel/helper-plugin-utils": ^7.24.7
+  peerDependencies:
+    "@babel/core": ^7.0.0-0
+  checksum: 9aeefc3aab6c6bf9d1fae1cf3a2d38c7d886fd3c6c81b7c608c477f5758aee2e7abf52f32724310fe861da61af934ee2508b78a5b5f234b9740c9134e1c14437
+  languageName: node
+  linkType: hard
+
 "@babel/plugin-transform-react-constant-elements@npm:^7.18.12":
   version: 7.23.3
   resolution: "@babel/plugin-transform-react-constant-elements@npm:7.23.3"
@@ -1342,6 +2200,17 @@ __metadata:
   languageName: node
   linkType: hard
 
+"@babel/plugin-transform-react-constant-elements@npm:^7.21.3":
+  version: 7.25.1
+  resolution: "@babel/plugin-transform-react-constant-elements@npm:7.25.1"
+  dependencies:
+    "@babel/helper-plugin-utils": ^7.24.8
+  peerDependencies:
+    "@babel/core": ^7.0.0-0
+  checksum: 6126abf8bc3980c1e27fd217f8b2f226b20cce9be300eaf9d30548556dd1e906b7daa4580d9ae1dae35eb5ed5c98e7222e0cb91efb0a232d05aae5875dcfe55c
+  languageName: node
+  linkType: hard
+
 "@babel/plugin-transform-react-display-name@npm:^7.23.3":
   version: 7.23.3
   resolution: "@babel/plugin-transform-react-display-name@npm:7.23.3"
@@ -1403,6 +2272,18 @@ __metadata:
   languageName: node
   linkType: hard
 
+"@babel/plugin-transform-regenerator@npm:^7.24.7":
+  version: 7.24.7
+  resolution: "@babel/plugin-transform-regenerator@npm:7.24.7"
+  dependencies:
+    "@babel/helper-plugin-utils": ^7.24.7
+    regenerator-transform: ^0.15.2
+  peerDependencies:
+    "@babel/core": ^7.0.0-0
+  checksum: 20c6c3fb6fc9f407829087316653388d311e8c1816b007609bb09aeef254092a7157adace8b3aaa8f34be752503717cb85c88a5fe482180a9b11bcbd676063be
+  languageName: node
+  linkType: hard
+
 "@babel/plugin-transform-reserved-words@npm:^7.23.3":
   version: 7.23.3
   resolution: "@babel/plugin-transform-reserved-words@npm:7.23.3"
@@ -1414,6 +2295,17 @@ __metadata:
   languageName: node
   linkType: hard
 
+"@babel/plugin-transform-reserved-words@npm:^7.24.7":
+  version: 7.24.7
+  resolution: "@babel/plugin-transform-reserved-words@npm:7.24.7"
+  dependencies:
+    "@babel/helper-plugin-utils": ^7.24.7
+  peerDependencies:
+    "@babel/core": ^7.0.0-0
+  checksum: 3d5876954d5914d7270819479504f30c4bf5452a65c677f44e2dab2db50b3c9d4b47793c45dfad7abf4f377035dd79e4b3f554ae350df9f422201d370ce9f8dd
+  languageName: node
+  linkType: hard
+
 "@babel/plugin-transform-runtime@npm:^7.18.6, @babel/plugin-transform-runtime@npm:^7.22.9":
   version: 7.23.4
   resolution: "@babel/plugin-transform-runtime@npm:7.23.4"
@@ -1441,6 +2333,17 @@ __metadata:
   languageName: node
   linkType: hard
 
+"@babel/plugin-transform-shorthand-properties@npm:^7.24.7":
+  version: 7.24.7
+  resolution: "@babel/plugin-transform-shorthand-properties@npm:7.24.7"
+  dependencies:
+    "@babel/helper-plugin-utils": ^7.24.7
+  peerDependencies:
+    "@babel/core": ^7.0.0-0
+  checksum: 7b524245814607188212b8eb86d8c850e5974203328455a30881b4a92c364b93353fae14bc2af5b614ef16300b75b8c1d3b8f3a08355985b4794a7feb240adc3
+  languageName: node
+  linkType: hard
+
 "@babel/plugin-transform-spread@npm:^7.23.3":
   version: 7.23.3
   resolution: "@babel/plugin-transform-spread@npm:7.23.3"
@@ -1453,6 +2356,18 @@ __metadata:
   languageName: node
   linkType: hard
 
+"@babel/plugin-transform-spread@npm:^7.24.7":
+  version: 7.24.7
+  resolution: "@babel/plugin-transform-spread@npm:7.24.7"
+  dependencies:
+    "@babel/helper-plugin-utils": ^7.24.7
+    "@babel/helper-skip-transparent-expression-wrappers": ^7.24.7
+  peerDependencies:
+    "@babel/core": ^7.0.0-0
+  checksum: 4c4254c8b9cceb1a8f975fa9b92257ddb08380a35c0a3721b8f4b9e13a3d82e403af2e0fba577b9f2452dd8f06bc3dea71cc53b1e2c6af595af5db52a13429d6
+  languageName: node
+  linkType: hard
+
 "@babel/plugin-transform-sticky-regex@npm:^7.23.3":
   version: 7.23.3
   resolution: "@babel/plugin-transform-sticky-regex@npm:7.23.3"
@@ -1464,6 +2379,17 @@ __metadata:
   languageName: node
   linkType: hard
 
+"@babel/plugin-transform-sticky-regex@npm:^7.24.7":
+  version: 7.24.7
+  resolution: "@babel/plugin-transform-sticky-regex@npm:7.24.7"
+  dependencies:
+    "@babel/helper-plugin-utils": ^7.24.7
+  peerDependencies:
+    "@babel/core": ^7.0.0-0
+  checksum: 118fc7a7ebf7c20411b670c8a030535fdfe4a88bc5643bb625a584dbc4c8a468da46430a20e6bf78914246962b0f18f1b9d6a62561a7762c4f34a038a5a77179
+  languageName: node
+  linkType: hard
+
 "@babel/plugin-transform-template-literals@npm:^7.23.3":
   version: 7.23.3
   resolution: "@babel/plugin-transform-template-literals@npm:7.23.3"
@@ -1475,6 +2401,17 @@ __metadata:
   languageName: node
   linkType: hard
 
+"@babel/plugin-transform-template-literals@npm:^7.24.7":
+  version: 7.24.7
+  resolution: "@babel/plugin-transform-template-literals@npm:7.24.7"
+  dependencies:
+    "@babel/helper-plugin-utils": ^7.24.7
+  peerDependencies:
+    "@babel/core": ^7.0.0-0
+  checksum: ad44e5826f5a98c1575832dbdbd033adfe683cdff195e178528ead62507564bf02f479b282976cfd3caebad8b06d5fd7349c1cdb880dec3c56daea4f1f179619
+  languageName: node
+  linkType: hard
+
 "@babel/plugin-transform-typeof-symbol@npm:^7.23.3":
   version: 7.23.3
   resolution: "@babel/plugin-transform-typeof-symbol@npm:7.23.3"
@@ -1486,6 +2423,17 @@ __metadata:
   languageName: node
   linkType: hard
 
+"@babel/plugin-transform-typeof-symbol@npm:^7.24.8":
+  version: 7.24.8
+  resolution: "@babel/plugin-transform-typeof-symbol@npm:7.24.8"
+  dependencies:
+    "@babel/helper-plugin-utils": ^7.24.8
+  peerDependencies:
+    "@babel/core": ^7.0.0-0
+  checksum: 8663a8e7347cedf181001d99c88cf794b6598c3d82f324098510fe8fb8bd22113995526a77aa35a3cc5d70ffd0617a59dd0d10311a9bf0e1a3a7d3e59b900c00
+  languageName: node
+  linkType: hard
+
 "@babel/plugin-transform-typescript@npm:^7.23.3":
   version: 7.23.5
   resolution: "@babel/plugin-transform-typescript@npm:7.23.5"
@@ -1500,6 +2448,21 @@ __metadata:
   languageName: node
   linkType: hard
 
+"@babel/plugin-transform-typescript@npm:^7.24.7":
+  version: 7.25.2
+  resolution: "@babel/plugin-transform-typescript@npm:7.25.2"
+  dependencies:
+    "@babel/helper-annotate-as-pure": ^7.24.7
+    "@babel/helper-create-class-features-plugin": ^7.25.0
+    "@babel/helper-plugin-utils": ^7.24.8
+    "@babel/helper-skip-transparent-expression-wrappers": ^7.24.7
+    "@babel/plugin-syntax-typescript": ^7.24.7
+  peerDependencies:
+    "@babel/core": ^7.0.0-0
+  checksum: b0267128d93560a4350919f7230a3b497e20fb8611d9f04bb3560d6b38877305ccad4c40903160263361c6930a84dbcb5b21b8ea923531bda51f67bffdc2dd0b
+  languageName: node
+  linkType: hard
+
 "@babel/plugin-transform-unicode-escapes@npm:^7.23.3":
   version: 7.23.3
   resolution: "@babel/plugin-transform-unicode-escapes@npm:7.23.3"
@@ -1511,6 +2474,17 @@ __metadata:
   languageName: node
   linkType: hard
 
+"@babel/plugin-transform-unicode-escapes@npm:^7.24.7":
+  version: 7.24.7
+  resolution: "@babel/plugin-transform-unicode-escapes@npm:7.24.7"
+  dependencies:
+    "@babel/helper-plugin-utils": ^7.24.7
+  peerDependencies:
+    "@babel/core": ^7.0.0-0
+  checksum: 4af0a193e1ddea6ff82b2b15cc2501b872728050bd625740b813c8062fec917d32d530ff6b41de56c15e7296becdf3336a58db81f5ca8e7c445c1306c52f3e01
+  languageName: node
+  linkType: hard
+
 "@babel/plugin-transform-unicode-property-regex@npm:^7.23.3":
   version: 7.23.3
   resolution: "@babel/plugin-transform-unicode-property-regex@npm:7.23.3"
@@ -1523,6 +2497,18 @@ __metadata:
   languageName: node
   linkType: hard
 
+"@babel/plugin-transform-unicode-property-regex@npm:^7.24.7":
+  version: 7.24.7
+  resolution: "@babel/plugin-transform-unicode-property-regex@npm:7.24.7"
+  dependencies:
+    "@babel/helper-create-regexp-features-plugin": ^7.24.7
+    "@babel/helper-plugin-utils": ^7.24.7
+  peerDependencies:
+    "@babel/core": ^7.0.0-0
+  checksum: aae13350c50973f5802ca7906d022a6a0cc0e3aebac9122d0450bbd51e78252d4c2032ad69385e2759fcbdd3aac5d571bd7e26258907f51f8e1a51b53be626c2
+  languageName: node
+  linkType: hard
+
 "@babel/plugin-transform-unicode-regex@npm:^7.23.3":
   version: 7.23.3
   resolution: "@babel/plugin-transform-unicode-regex@npm:7.23.3"
@@ -1535,6 +2521,18 @@ __metadata:
   languageName: node
   linkType: hard
 
+"@babel/plugin-transform-unicode-regex@npm:^7.24.7":
+  version: 7.24.7
+  resolution: "@babel/plugin-transform-unicode-regex@npm:7.24.7"
+  dependencies:
+    "@babel/helper-create-regexp-features-plugin": ^7.24.7
+    "@babel/helper-plugin-utils": ^7.24.7
+  peerDependencies:
+    "@babel/core": ^7.0.0-0
+  checksum: 1cb4e70678906e431da0a05ac3f8350025fee290304ad7482d9cfaa1ca67b2e898654de537c9268efbdad5b80d3ebadf42b4a88ea84609bd8a4cce7b11b48afd
+  languageName: node
+  linkType: hard
+
 "@babel/plugin-transform-unicode-sets-regex@npm:^7.23.3":
   version: 7.23.3
   resolution: "@babel/plugin-transform-unicode-sets-regex@npm:7.23.3"
@@ -1547,6 +2545,18 @@ __metadata:
   languageName: node
   linkType: hard
 
+"@babel/plugin-transform-unicode-sets-regex@npm:^7.25.4":
+  version: 7.25.4
+  resolution: "@babel/plugin-transform-unicode-sets-regex@npm:7.25.4"
+  dependencies:
+    "@babel/helper-create-regexp-features-plugin": ^7.25.2
+    "@babel/helper-plugin-utils": ^7.24.8
+  peerDependencies:
+    "@babel/core": ^7.0.0
+  checksum: 6d1a7e9fdde4ffc9a81c0e3f261b96a9a0dfe65da282ec96fe63b36c597a7389feac638f1df2a8a4f8c9128337bba8e984f934e9f19077930f33abf1926759ea
+  languageName: node
+  linkType: hard
+
 "@babel/preset-env@npm:^7.18.6, @babel/preset-env@npm:^7.19.4, @babel/preset-env@npm:^7.22.9":
   version: 7.23.5
   resolution: "@babel/preset-env@npm:7.23.5"
@@ -1637,6 +2647,99 @@ __metadata:
   languageName: node
   linkType: hard
 
+"@babel/preset-env@npm:^7.20.2":
+  version: 7.25.4
+  resolution: "@babel/preset-env@npm:7.25.4"
+  dependencies:
+    "@babel/compat-data": ^7.25.4
+    "@babel/helper-compilation-targets": ^7.25.2
+    "@babel/helper-plugin-utils": ^7.24.8
+    "@babel/helper-validator-option": ^7.24.8
+    "@babel/plugin-bugfix-firefox-class-in-computed-class-key": ^7.25.3
+    "@babel/plugin-bugfix-safari-class-field-initializer-scope": ^7.25.0
+    "@babel/plugin-bugfix-safari-id-destructuring-collision-in-function-expression": ^7.25.0
+    "@babel/plugin-bugfix-v8-spread-parameters-in-optional-chaining": ^7.24.7
+    "@babel/plugin-bugfix-v8-static-class-fields-redefine-readonly": ^7.25.0
+    "@babel/plugin-proposal-private-property-in-object": 7.21.0-placeholder-for-preset-env.2
+    "@babel/plugin-syntax-async-generators": ^7.8.4
+    "@babel/plugin-syntax-class-properties": ^7.12.13
+    "@babel/plugin-syntax-class-static-block": ^7.14.5
+    "@babel/plugin-syntax-dynamic-import": ^7.8.3
+    "@babel/plugin-syntax-export-namespace-from": ^7.8.3
+    "@babel/plugin-syntax-import-assertions": ^7.24.7
+    "@babel/plugin-syntax-import-attributes": ^7.24.7
+    "@babel/plugin-syntax-import-meta": ^7.10.4
+    "@babel/plugin-syntax-json-strings": ^7.8.3
+    "@babel/plugin-syntax-logical-assignment-operators": ^7.10.4
+    "@babel/plugin-syntax-nullish-coalescing-operator": ^7.8.3
+    "@babel/plugin-syntax-numeric-separator": ^7.10.4
+    "@babel/plugin-syntax-object-rest-spread": ^7.8.3
+    "@babel/plugin-syntax-optional-catch-binding": ^7.8.3
+    "@babel/plugin-syntax-optional-chaining": ^7.8.3
+    "@babel/plugin-syntax-private-property-in-object": ^7.14.5
+    "@babel/plugin-syntax-top-level-await": ^7.14.5
+    "@babel/plugin-syntax-unicode-sets-regex": ^7.18.6
+    "@babel/plugin-transform-arrow-functions": ^7.24.7
+    "@babel/plugin-transform-async-generator-functions": ^7.25.4
+    "@babel/plugin-transform-async-to-generator": ^7.24.7
+    "@babel/plugin-transform-block-scoped-functions": ^7.24.7
+    "@babel/plugin-transform-block-scoping": ^7.25.0
+    "@babel/plugin-transform-class-properties": ^7.25.4
+    "@babel/plugin-transform-class-static-block": ^7.24.7
+    "@babel/plugin-transform-classes": ^7.25.4
+    "@babel/plugin-transform-computed-properties": ^7.24.7
+    "@babel/plugin-transform-destructuring": ^7.24.8
+    "@babel/plugin-transform-dotall-regex": ^7.24.7
+    "@babel/plugin-transform-duplicate-keys": ^7.24.7
+    "@babel/plugin-transform-duplicate-named-capturing-groups-regex": ^7.25.0
+    "@babel/plugin-transform-dynamic-import": ^7.24.7
+    "@babel/plugin-transform-exponentiation-operator": ^7.24.7
+    "@babel/plugin-transform-export-namespace-from": ^7.24.7
+    "@babel/plugin-transform-for-of": ^7.24.7
+    "@babel/plugin-transform-function-name": ^7.25.1
+    "@babel/plugin-transform-json-strings": ^7.24.7
+    "@babel/plugin-transform-literals": ^7.25.2
+    "@babel/plugin-transform-logical-assignment-operators": ^7.24.7
+    "@babel/plugin-transform-member-expression-literals": ^7.24.7
+    "@babel/plugin-transform-modules-amd": ^7.24.7
+    "@babel/plugin-transform-modules-commonjs": ^7.24.8
+    "@babel/plugin-transform-modules-systemjs": ^7.25.0
+    "@babel/plugin-transform-modules-umd": ^7.24.7
+    "@babel/plugin-transform-named-capturing-groups-regex": ^7.24.7
+    "@babel/plugin-transform-new-target": ^7.24.7
+    "@babel/plugin-transform-nullish-coalescing-operator": ^7.24.7
+    "@babel/plugin-transform-numeric-separator": ^7.24.7
+    "@babel/plugin-transform-object-rest-spread": ^7.24.7
+    "@babel/plugin-transform-object-super": ^7.24.7
+    "@babel/plugin-transform-optional-catch-binding": ^7.24.7
+    "@babel/plugin-transform-optional-chaining": ^7.24.8
+    "@babel/plugin-transform-parameters": ^7.24.7
+    "@babel/plugin-transform-private-methods": ^7.25.4
+    "@babel/plugin-transform-private-property-in-object": ^7.24.7
+    "@babel/plugin-transform-property-literals": ^7.24.7
+    "@babel/plugin-transform-regenerator": ^7.24.7
+    "@babel/plugin-transform-reserved-words": ^7.24.7
+    "@babel/plugin-transform-shorthand-properties": ^7.24.7
+    "@babel/plugin-transform-spread": ^7.24.7
+    "@babel/plugin-transform-sticky-regex": ^7.24.7
+    "@babel/plugin-transform-template-literals": ^7.24.7
+    "@babel/plugin-transform-typeof-symbol": ^7.24.8
+    "@babel/plugin-transform-unicode-escapes": ^7.24.7
+    "@babel/plugin-transform-unicode-property-regex": ^7.24.7
+    "@babel/plugin-transform-unicode-regex": ^7.24.7
+    "@babel/plugin-transform-unicode-sets-regex": ^7.25.4
+    "@babel/preset-modules": 0.1.6-no-external-plugins
+    babel-plugin-polyfill-corejs2: ^0.4.10
+    babel-plugin-polyfill-corejs3: ^0.10.6
+    babel-plugin-polyfill-regenerator: ^0.6.1
+    core-js-compat: ^3.37.1
+    semver: ^6.3.1
+  peerDependencies:
+    "@babel/core": ^7.0.0-0
+  checksum: 752be43f0b78a2eefe5007076aed3d21b505e1c09d134b61e7de8838f1bbb1e7af81023d39adb14b6eae23727fb5a9fd23f8115a44df043319be22319be17913
+  languageName: node
+  linkType: hard
+
 "@babel/preset-modules@npm:0.1.6-no-external-plugins":
   version: 0.1.6-no-external-plugins
   resolution: "@babel/preset-modules@npm:0.1.6-no-external-plugins"
@@ -1681,6 +2784,21 @@ __metadata:
   languageName: node
   linkType: hard
 
+"@babel/preset-typescript@npm:^7.21.0":
+  version: 7.24.7
+  resolution: "@babel/preset-typescript@npm:7.24.7"
+  dependencies:
+    "@babel/helper-plugin-utils": ^7.24.7
+    "@babel/helper-validator-option": ^7.24.7
+    "@babel/plugin-syntax-jsx": ^7.24.7
+    "@babel/plugin-transform-modules-commonjs": ^7.24.7
+    "@babel/plugin-transform-typescript": ^7.24.7
+  peerDependencies:
+    "@babel/core": ^7.0.0-0
+  checksum: 12929b24757f3bd6548103475f86478eda4c872bc7cefd920b29591eee8f4a4f350561d888e133d632d0c9402b8615fdcec9138e5127a6567dcb22f804ff207f
+  languageName: node
+  linkType: hard
+
 "@babel/regjsgen@npm:^0.8.0":
   version: 0.8.0
   resolution: "@babel/regjsgen@npm:0.8.0"
@@ -1718,6 +2836,17 @@ __metadata:
   languageName: node
   linkType: hard
 
+"@babel/template@npm:^7.24.7, @babel/template@npm:^7.25.0":
+  version: 7.25.0
+  resolution: "@babel/template@npm:7.25.0"
+  dependencies:
+    "@babel/code-frame": ^7.24.7
+    "@babel/parser": ^7.25.0
+    "@babel/types": ^7.25.0
+  checksum: 3f2db568718756d0daf2a16927b78f00c425046b654cd30b450006f2e84bdccaf0cbe6dc04994aa1f5f6a4398da2f11f3640a4d3ee31722e43539c4c919c817b
+  languageName: node
+  linkType: hard
+
 "@babel/traverse@npm:^7.12.9, @babel/traverse@npm:^7.18.8, @babel/traverse@npm:^7.22.8, @babel/traverse@npm:^7.23.5":
   version: 7.23.5
   resolution: "@babel/traverse@npm:7.23.5"
@@ -1736,6 +2865,21 @@ __metadata:
   languageName: node
   linkType: hard
 
+"@babel/traverse@npm:^7.24.7, @babel/traverse@npm:^7.24.8, @babel/traverse@npm:^7.25.0, @babel/traverse@npm:^7.25.1, @babel/traverse@npm:^7.25.2, @babel/traverse@npm:^7.25.3, @babel/traverse@npm:^7.25.4":
+  version: 7.25.6
+  resolution: "@babel/traverse@npm:7.25.6"
+  dependencies:
+    "@babel/code-frame": ^7.24.7
+    "@babel/generator": ^7.25.6
+    "@babel/parser": ^7.25.6
+    "@babel/template": ^7.25.0
+    "@babel/types": ^7.25.6
+    debug: ^4.3.1
+    globals: ^11.1.0
+  checksum: 11ee47269aa4356f2d6633a05b9af73405b5ed72c09378daf644289b686ef852035a6ac9aa410f601991993c6bbf72006795b5478283b78eb1ca77874ada7737
+  languageName: node
+  linkType: hard
+
 "@babel/types@npm:^7.12.7, @babel/types@npm:^7.20.0, @babel/types@npm:^7.22.15, @babel/types@npm:^7.22.19, @babel/types@npm:^7.22.5, @babel/types@npm:^7.23.0, @babel/types@npm:^7.23.4, @babel/types@npm:^7.23.5, @babel/types@npm:^7.4.4, @babel/types@npm:^7.8.3":
   version: 7.23.5
   resolution: "@babel/types@npm:7.23.5"
@@ -1747,6 +2891,17 @@ __metadata:
   languageName: node
   linkType: hard
 
+"@babel/types@npm:^7.21.3, @babel/types@npm:^7.24.7, @babel/types@npm:^7.24.8, @babel/types@npm:^7.25.0, @babel/types@npm:^7.25.2, @babel/types@npm:^7.25.6":
+  version: 7.25.6
+  resolution: "@babel/types@npm:7.25.6"
+  dependencies:
+    "@babel/helper-string-parser": ^7.24.8
+    "@babel/helper-validator-identifier": ^7.24.7
+    to-fast-properties: ^2.0.0
+  checksum: 9b2f84ff3f874ad05b0b9bf06862c56f478b65781801f82296b4cc01bee39e79c20a7c0a06959fed0ee582c8267e1cb21638318655c5e070b0287242a844d1c9
+  languageName: node
+  linkType: hard
+
 "@colors/colors@npm:1.5.0":
   version: 1.5.0
   resolution: "@colors/colors@npm:1.5.0"
@@ -2343,9 +3498,9 @@ __metadata:
   languageName: node
   linkType: hard
 
-"@docusaurus/core@npm:3.0.1, @docusaurus/core@npm:^3.0.1":
-  version: 3.0.1
-  resolution: "@docusaurus/core@npm:3.0.1"
+"@docusaurus/core@npm:3.5.2, @docusaurus/core@npm:^3.5.2":
+  version: 3.5.2
+  resolution: "@docusaurus/core@npm:3.5.2"
   dependencies:
     "@babel/core": ^7.23.3
     "@babel/generator": ^7.23.3
@@ -2357,15 +3512,12 @@ __metadata:
     "@babel/runtime": ^7.22.6
     "@babel/runtime-corejs3": ^7.22.6
     "@babel/traverse": ^7.22.8
-    "@docusaurus/cssnano-preset": 3.0.1
-    "@docusaurus/logger": 3.0.1
-    "@docusaurus/mdx-loader": 3.0.1
-    "@docusaurus/react-loadable": 5.5.2
-    "@docusaurus/utils": 3.0.1
-    "@docusaurus/utils-common": 3.0.1
-    "@docusaurus/utils-validation": 3.0.1
-    "@slorber/static-site-generator-webpack-plugin": ^4.0.7
-    "@svgr/webpack": ^6.5.1
+    "@docusaurus/cssnano-preset": 3.5.2
+    "@docusaurus/logger": 3.5.2
+    "@docusaurus/mdx-loader": 3.5.2
+    "@docusaurus/utils": 3.5.2
+    "@docusaurus/utils-common": 3.5.2
+    "@docusaurus/utils-validation": 3.5.2
     autoprefixer: ^10.4.14
     babel-loader: ^9.1.3
     babel-plugin-dynamic-import-node: ^2.3.3
@@ -2379,12 +3531,13 @@ __metadata:
     copy-webpack-plugin: ^11.0.0
     core-js: ^3.31.1
     css-loader: ^6.8.1
-    css-minimizer-webpack-plugin: ^4.2.2
-    cssnano: ^5.1.15
+    css-minimizer-webpack-plugin: ^5.0.1
+    cssnano: ^6.1.2
     del: ^6.1.1
     detect-port: ^1.5.1
     escape-html: ^1.0.3
     eta: ^2.2.0
+    eval: ^0.1.8
     file-loader: ^6.2.0
     fs-extra: ^11.1.1
     html-minifier-terser: ^7.2.0
@@ -2393,12 +3546,13 @@ __metadata:
     leven: ^3.1.0
     lodash: ^4.17.21
     mini-css-extract-plugin: ^2.7.6
+    p-map: ^4.0.0
     postcss: ^8.4.26
     postcss-loader: ^7.3.3
     prompts: ^2.4.2
     react-dev-utils: ^12.0.1
     react-helmet-async: ^1.3.0
-    react-loadable: "npm:@docusaurus/react-loadable@5.5.2"
+    react-loadable: "npm:@docusaurus/react-loadable@6.0.0"
     react-loadable-ssr-addon-v5-slorber: ^1.0.1
     react-router: ^5.3.4
     react-router-config: ^5.1.1
@@ -2417,11 +3571,12 @@ __metadata:
     webpack-merge: ^5.9.0
     webpackbar: ^5.0.2
   peerDependencies:
+    "@mdx-js/react": ^3.0.0
     react: ^18.0.0
     react-dom: ^18.0.0
   bin:
     docusaurus: bin/docusaurus.mjs
-  checksum: 56767f7e629edce4d23c19403abf4039daeea25db20c695fb7c3a1ce04a90f182f14ea1f70286afb221b8c1593823ebb0d28cbc2ca5d9d38d707a0338d544f64
+  checksum: 6c6282a75931f0f8f8f8768232b4436ff8679ae12b619f7bd01e0d83aa346e24ab0d9cecac034f9dc95c55059997efdd963d052d3e429583bfb8d3b54ab750d3
   languageName: node
   linkType: hard
 
@@ -2437,15 +3592,15 @@ __metadata:
   languageName: node
   linkType: hard
 
-"@docusaurus/cssnano-preset@npm:3.0.1":
-  version: 3.0.1
-  resolution: "@docusaurus/cssnano-preset@npm:3.0.1"
+"@docusaurus/cssnano-preset@npm:3.5.2":
+  version: 3.5.2
+  resolution: "@docusaurus/cssnano-preset@npm:3.5.2"
   dependencies:
-    cssnano-preset-advanced: ^5.3.10
-    postcss: ^8.4.26
-    postcss-sort-media-queries: ^4.4.1
+    cssnano-preset-advanced: ^6.1.2
+    postcss: ^8.4.38
+    postcss-sort-media-queries: ^5.2.0
     tslib: ^2.6.0
-  checksum: 3a04606d362c84398a5af9a98de4995958e2705086af83388479feaa157cbe3164281006e64036f9337e96b0cec62bd1362fc0f910075e6eeec930f0a519801d
+  checksum: 4bb1fae3741e14cbbdb64c1b0707435970838bf219831234a70cf382e6811ffac1cadf733d5e1fe7c278e7b2a9e533bfa802a5212b22ec46edd703208cf49f92
   languageName: node
   linkType: hard
 
@@ -2459,13 +3614,13 @@ __metadata:
   languageName: node
   linkType: hard
 
-"@docusaurus/logger@npm:3.0.1":
-  version: 3.0.1
-  resolution: "@docusaurus/logger@npm:3.0.1"
+"@docusaurus/logger@npm:3.5.2":
+  version: 3.5.2
+  resolution: "@docusaurus/logger@npm:3.5.2"
   dependencies:
     chalk: ^4.1.2
     tslib: ^2.6.0
-  checksum: 4d4ffcd08f9c76c105d2d2b95974f5c33941e5346c5de1b19ee3f55a4f5011bb7db3875349e25da02750cea5fb357ba00be271ea24368c75b8e29189d04e9f7c
+  checksum: 7cbdcf54acd6e7787ca5a10b9c884be4b9e8fdae837862c66550a0bf3d02737f72c3188b2bddd61da6d8530eb2eb2b646ea599a79416e33c4998f1a87d2f6a8c
   languageName: node
   linkType: hard
 
@@ -2497,15 +3652,13 @@ __metadata:
   languageName: node
   linkType: hard
 
-"@docusaurus/mdx-loader@npm:3.0.1":
-  version: 3.0.1
-  resolution: "@docusaurus/mdx-loader@npm:3.0.1"
+"@docusaurus/mdx-loader@npm:3.5.2":
+  version: 3.5.2
+  resolution: "@docusaurus/mdx-loader@npm:3.5.2"
   dependencies:
-    "@babel/parser": ^7.22.7
-    "@babel/traverse": ^7.22.8
-    "@docusaurus/logger": 3.0.1
-    "@docusaurus/utils": 3.0.1
-    "@docusaurus/utils-validation": 3.0.1
+    "@docusaurus/logger": 3.5.2
+    "@docusaurus/utils": 3.5.2
+    "@docusaurus/utils-validation": 3.5.2
     "@mdx-js/mdx": ^3.0.0
     "@slorber/remark-comment": ^1.0.0
     escape-html: ^1.0.3
@@ -2530,7 +3683,7 @@ __metadata:
   peerDependencies:
     react: ^18.0.0
     react-dom: ^18.0.0
-  checksum: 8ba9774cd2cc7216f645d54a6f6f6cba34e39e371f0de09e56f60a27dde95a8e42ab92cf0a6f384dce01960c68a1e720868c56b6aa8929d23bafe9f523941151
+  checksum: 36186c2f3487631757b24ba3a21575d2253ca1e6ada82d556bf323da7ae7637c0880eb388bf375e207bc5f26dcd8b58cc76d763e6c2caf6ed80f88748444ce8d
   languageName: node
   linkType: hard
 
@@ -2553,37 +3706,37 @@ __metadata:
   languageName: node
   linkType: hard
 
-"@docusaurus/module-type-aliases@npm:3.0.1, @docusaurus/module-type-aliases@npm:^3.0.1":
-  version: 3.0.1
-  resolution: "@docusaurus/module-type-aliases@npm:3.0.1"
+"@docusaurus/module-type-aliases@npm:3.5.2, @docusaurus/module-type-aliases@npm:^3.5.2":
+  version: 3.5.2
+  resolution: "@docusaurus/module-type-aliases@npm:3.5.2"
   dependencies:
-    "@docusaurus/react-loadable": 5.5.2
-    "@docusaurus/types": 3.0.1
+    "@docusaurus/types": 3.5.2
     "@types/history": ^4.7.11
     "@types/react": "*"
     "@types/react-router-config": "*"
     "@types/react-router-dom": "*"
     react-helmet-async: "*"
-    react-loadable: "npm:@docusaurus/react-loadable@5.5.2"
+    react-loadable: "npm:@docusaurus/react-loadable@6.0.0"
   peerDependencies:
     react: "*"
     react-dom: "*"
-  checksum: 08895f8b100df772bb9c9a8fcf9cd3ee83f0deafeb76fb9b14efd5cdd3313abb4a02032868bd458cb3a5f345942fd9f4c44833ce5042279b2241d462a1bf4cc2
+  checksum: 0161db859d459bb25ac162f0c509fb1316dfb403a9e89f325a9bc7d9f35ae1825b9703a435777903ba93de827d4413b189bbd0c03018ac13d66b50633302ea80
   languageName: node
   linkType: hard
 
-"@docusaurus/plugin-content-blog@npm:3.0.1":
-  version: 3.0.1
-  resolution: "@docusaurus/plugin-content-blog@npm:3.0.1"
-  dependencies:
-    "@docusaurus/core": 3.0.1
-    "@docusaurus/logger": 3.0.1
-    "@docusaurus/mdx-loader": 3.0.1
-    "@docusaurus/types": 3.0.1
-    "@docusaurus/utils": 3.0.1
-    "@docusaurus/utils-common": 3.0.1
-    "@docusaurus/utils-validation": 3.0.1
-    cheerio: ^1.0.0-rc.12
+"@docusaurus/plugin-content-blog@npm:3.5.2":
+  version: 3.5.2
+  resolution: "@docusaurus/plugin-content-blog@npm:3.5.2"
+  dependencies:
+    "@docusaurus/core": 3.5.2
+    "@docusaurus/logger": 3.5.2
+    "@docusaurus/mdx-loader": 3.5.2
+    "@docusaurus/theme-common": 3.5.2
+    "@docusaurus/types": 3.5.2
+    "@docusaurus/utils": 3.5.2
+    "@docusaurus/utils-common": 3.5.2
+    "@docusaurus/utils-validation": 3.5.2
+    cheerio: 1.0.0-rc.12
     feed: ^4.2.2
     fs-extra: ^11.1.1
     lodash: ^4.17.21
@@ -2594,23 +3747,26 @@ __metadata:
     utility-types: ^3.10.0
     webpack: ^5.88.1
   peerDependencies:
+    "@docusaurus/plugin-content-docs": "*"
     react: ^18.0.0
     react-dom: ^18.0.0
-  checksum: 20985fac48d2f77d560483d06d8fc21ea8c3a009be8d040da76bd4363279ad7fe8f98353bc6a50504403be3315508344faa62123ac3691912d27710fe3c6ec90
+  checksum: c5997b9d86ccf939998f9d56e65491ecf9e677d8425e95a79b3b428041d4dfc4ecb03a18ef595777c3ad5bd65f4a2dd30d99cb6f1b411161bf7cd32027ecc6d5
   languageName: node
   linkType: hard
 
-"@docusaurus/plugin-content-docs@npm:3.0.1":
-  version: 3.0.1
-  resolution: "@docusaurus/plugin-content-docs@npm:3.0.1"
-  dependencies:
-    "@docusaurus/core": 3.0.1
-    "@docusaurus/logger": 3.0.1
-    "@docusaurus/mdx-loader": 3.0.1
-    "@docusaurus/module-type-aliases": 3.0.1
-    "@docusaurus/types": 3.0.1
-    "@docusaurus/utils": 3.0.1
-    "@docusaurus/utils-validation": 3.0.1
+"@docusaurus/plugin-content-docs@npm:3.5.2":
+  version: 3.5.2
+  resolution: "@docusaurus/plugin-content-docs@npm:3.5.2"
+  dependencies:
+    "@docusaurus/core": 3.5.2
+    "@docusaurus/logger": 3.5.2
+    "@docusaurus/mdx-loader": 3.5.2
+    "@docusaurus/module-type-aliases": 3.5.2
+    "@docusaurus/theme-common": 3.5.2
+    "@docusaurus/types": 3.5.2
+    "@docusaurus/utils": 3.5.2
+    "@docusaurus/utils-common": 3.5.2
+    "@docusaurus/utils-validation": 3.5.2
     "@types/react-router-config": ^5.0.7
     combine-promises: ^1.1.0
     fs-extra: ^11.1.1
@@ -2622,7 +3778,7 @@ __metadata:
   peerDependencies:
     react: ^18.0.0
     react-dom: ^18.0.0
-  checksum: ee3a12a49df2db112798e8d080365c9cc2afc4959f28772abe03eb9c806b919a9837669354b04a1ff99bf473cab1aa3b8b6ad740947a440a6b9cae09823ef6b2
+  checksum: fb7ba7f8a6741b14bbe8db0bf1b12ff7a24d12c40d8276f32b9b393881d74bfed3bed4f1e5b0756cac0e43c4bd8106094d5cf6a3c527400e9713283fc3832dab
   languageName: node
   linkType: hard
 
@@ -2653,129 +3809,129 @@ __metadata:
   languageName: node
   linkType: hard
 
-"@docusaurus/plugin-content-pages@npm:3.0.1":
-  version: 3.0.1
-  resolution: "@docusaurus/plugin-content-pages@npm:3.0.1"
+"@docusaurus/plugin-content-pages@npm:3.5.2":
+  version: 3.5.2
+  resolution: "@docusaurus/plugin-content-pages@npm:3.5.2"
   dependencies:
-    "@docusaurus/core": 3.0.1
-    "@docusaurus/mdx-loader": 3.0.1
-    "@docusaurus/types": 3.0.1
-    "@docusaurus/utils": 3.0.1
-    "@docusaurus/utils-validation": 3.0.1
+    "@docusaurus/core": 3.5.2
+    "@docusaurus/mdx-loader": 3.5.2
+    "@docusaurus/types": 3.5.2
+    "@docusaurus/utils": 3.5.2
+    "@docusaurus/utils-validation": 3.5.2
     fs-extra: ^11.1.1
     tslib: ^2.6.0
     webpack: ^5.88.1
   peerDependencies:
     react: ^18.0.0
     react-dom: ^18.0.0
-  checksum: 0a3bd568e4b9df11b5926c5be10f2ced08b241f1a6b8a08f556c57ce707ebb788b19937ec1d884474c4e275dc71affb91dd55a2965ad02a03545e3eae4976141
+  checksum: 8b3f1040e8ec006c9431508e73ef3f61cd5759bece3770189f7d52609f91bd156c9b18d0608f9cb14c456a1d1823be6633c573d5eee7cf9bd142b0f978c7a745
   languageName: node
   linkType: hard
 
-"@docusaurus/plugin-debug@npm:3.0.1":
-  version: 3.0.1
-  resolution: "@docusaurus/plugin-debug@npm:3.0.1"
+"@docusaurus/plugin-debug@npm:3.5.2":
+  version: 3.5.2
+  resolution: "@docusaurus/plugin-debug@npm:3.5.2"
   dependencies:
-    "@docusaurus/core": 3.0.1
-    "@docusaurus/types": 3.0.1
-    "@docusaurus/utils": 3.0.1
+    "@docusaurus/core": 3.5.2
+    "@docusaurus/types": 3.5.2
+    "@docusaurus/utils": 3.5.2
     fs-extra: ^11.1.1
     react-json-view-lite: ^1.2.0
     tslib: ^2.6.0
   peerDependencies:
     react: ^18.0.0
     react-dom: ^18.0.0
-  checksum: 419f2bb61aceca70ffbba03e5e885303cea72055a41328d09d78fa2e40e7d5feb0ee4d66f056d54ac01f8d2361e890a072da6570da16f290c84746ced1582823
+  checksum: a839e6c3a595ea202fdd7fbce638ab8df26ba73a8c7ead8c04d1bbb509ebe34e9633e7fe9eb54a7a733e93a03d74a60df4d9f6597b9621ff464280d4dd71db34
   languageName: node
   linkType: hard
 
-"@docusaurus/plugin-google-analytics@npm:3.0.1":
-  version: 3.0.1
-  resolution: "@docusaurus/plugin-google-analytics@npm:3.0.1"
+"@docusaurus/plugin-google-analytics@npm:3.5.2":
+  version: 3.5.2
+  resolution: "@docusaurus/plugin-google-analytics@npm:3.5.2"
   dependencies:
-    "@docusaurus/core": 3.0.1
-    "@docusaurus/types": 3.0.1
-    "@docusaurus/utils-validation": 3.0.1
+    "@docusaurus/core": 3.5.2
+    "@docusaurus/types": 3.5.2
+    "@docusaurus/utils-validation": 3.5.2
     tslib: ^2.6.0
   peerDependencies:
     react: ^18.0.0
     react-dom: ^18.0.0
-  checksum: 850930ed0860411142fe058562040f0b3a776be755670790273f48bfa37c7ee904d9107ec23d2ce210904610b72769ce0996a558c89414ac3687bd38bb50edf4
+  checksum: 0b8c4d21333d40c2509d6ef807caaf69f085010c5deac514ab34f53b5486fd76766c90213dc98976a6c4d66fdfa14bf6b05594e51e8a53ec60c2a3fa08fd9a83
   languageName: node
   linkType: hard
 
-"@docusaurus/plugin-google-gtag@npm:3.0.1":
-  version: 3.0.1
-  resolution: "@docusaurus/plugin-google-gtag@npm:3.0.1"
+"@docusaurus/plugin-google-gtag@npm:3.5.2":
+  version: 3.5.2
+  resolution: "@docusaurus/plugin-google-gtag@npm:3.5.2"
   dependencies:
-    "@docusaurus/core": 3.0.1
-    "@docusaurus/types": 3.0.1
-    "@docusaurus/utils-validation": 3.0.1
+    "@docusaurus/core": 3.5.2
+    "@docusaurus/types": 3.5.2
+    "@docusaurus/utils-validation": 3.5.2
     "@types/gtag.js": ^0.0.12
     tslib: ^2.6.0
   peerDependencies:
     react: ^18.0.0
     react-dom: ^18.0.0
-  checksum: 579a19a6dad3940801a170efc7e5c763c7f90b68d5ecdb2707b61311af321122e84cd0bb5ceb45669e76df712ea1747d6d30fa5a0574b69a7f337dd66b346a04
+  checksum: 5d53c2483c8c7e3a8e842bd091a774d4041f0e165d216b3c02f031a224a77258c9456e8b2acd0500b4a0eff474a83c1b82803628db9d4b132514409936c68ac4
   languageName: node
   linkType: hard
 
-"@docusaurus/plugin-google-tag-manager@npm:3.0.1":
-  version: 3.0.1
-  resolution: "@docusaurus/plugin-google-tag-manager@npm:3.0.1"
+"@docusaurus/plugin-google-tag-manager@npm:3.5.2":
+  version: 3.5.2
+  resolution: "@docusaurus/plugin-google-tag-manager@npm:3.5.2"
   dependencies:
-    "@docusaurus/core": 3.0.1
-    "@docusaurus/types": 3.0.1
-    "@docusaurus/utils-validation": 3.0.1
+    "@docusaurus/core": 3.5.2
+    "@docusaurus/types": 3.5.2
+    "@docusaurus/utils-validation": 3.5.2
     tslib: ^2.6.0
   peerDependencies:
     react: ^18.0.0
     react-dom: ^18.0.0
-  checksum: 1e3faf9496f75d43a81a5ff2921e783c87ef13d852cf678b54275fa0f79d70efdc127df6ae9c90ddce58b81384f39ec62de75d7e64e34ae96ea938cf234268c0
+  checksum: 9a6fc2ca54ea677c6edfd78f4f392d7d9ae86afd085fcda96d5ac41efa441352c25a2519595d9d15fb9b838e2ae39837f0daf02e2406c5cd56199ae237bd7b7a
   languageName: node
   linkType: hard
 
-"@docusaurus/plugin-sitemap@npm:3.0.1":
-  version: 3.0.1
-  resolution: "@docusaurus/plugin-sitemap@npm:3.0.1"
-  dependencies:
-    "@docusaurus/core": 3.0.1
-    "@docusaurus/logger": 3.0.1
-    "@docusaurus/types": 3.0.1
-    "@docusaurus/utils": 3.0.1
-    "@docusaurus/utils-common": 3.0.1
-    "@docusaurus/utils-validation": 3.0.1
+"@docusaurus/plugin-sitemap@npm:3.5.2":
+  version: 3.5.2
+  resolution: "@docusaurus/plugin-sitemap@npm:3.5.2"
+  dependencies:
+    "@docusaurus/core": 3.5.2
+    "@docusaurus/logger": 3.5.2
+    "@docusaurus/types": 3.5.2
+    "@docusaurus/utils": 3.5.2
+    "@docusaurus/utils-common": 3.5.2
+    "@docusaurus/utils-validation": 3.5.2
     fs-extra: ^11.1.1
     sitemap: ^7.1.1
     tslib: ^2.6.0
   peerDependencies:
     react: ^18.0.0
     react-dom: ^18.0.0
-  checksum: 464359fa44143f3e686d02cd70f86741cdd4a74f29f212b83767617fc1dacbfddfa4321c16e0c253849ff41a75078fabbfdf8637d7a141fb1a0354360db2b2bb
+  checksum: 26b6bceb7ab87fe7f6f666742d1e81de32cdacc5aaa3d45d91002c7d64e3258f3d0aac87c6b0d442eaf34ede2af4b7521b50737f2e8e2718daff6fce10230213
   languageName: node
   linkType: hard
 
-"@docusaurus/preset-classic@npm:^3.0.1":
-  version: 3.0.1
-  resolution: "@docusaurus/preset-classic@npm:3.0.1"
-  dependencies:
-    "@docusaurus/core": 3.0.1
-    "@docusaurus/plugin-content-blog": 3.0.1
-    "@docusaurus/plugin-content-docs": 3.0.1
-    "@docusaurus/plugin-content-pages": 3.0.1
-    "@docusaurus/plugin-debug": 3.0.1
-    "@docusaurus/plugin-google-analytics": 3.0.1
-    "@docusaurus/plugin-google-gtag": 3.0.1
-    "@docusaurus/plugin-google-tag-manager": 3.0.1
-    "@docusaurus/plugin-sitemap": 3.0.1
-    "@docusaurus/theme-classic": 3.0.1
-    "@docusaurus/theme-common": 3.0.1
-    "@docusaurus/theme-search-algolia": 3.0.1
-    "@docusaurus/types": 3.0.1
+"@docusaurus/preset-classic@npm:^3.5.2":
+  version: 3.5.2
+  resolution: "@docusaurus/preset-classic@npm:3.5.2"
+  dependencies:
+    "@docusaurus/core": 3.5.2
+    "@docusaurus/plugin-content-blog": 3.5.2
+    "@docusaurus/plugin-content-docs": 3.5.2
+    "@docusaurus/plugin-content-pages": 3.5.2
+    "@docusaurus/plugin-debug": 3.5.2
+    "@docusaurus/plugin-google-analytics": 3.5.2
+    "@docusaurus/plugin-google-gtag": 3.5.2
+    "@docusaurus/plugin-google-tag-manager": 3.5.2
+    "@docusaurus/plugin-sitemap": 3.5.2
+    "@docusaurus/theme-classic": 3.5.2
+    "@docusaurus/theme-common": 3.5.2
+    "@docusaurus/theme-search-algolia": 3.5.2
+    "@docusaurus/types": 3.5.2
   peerDependencies:
     react: ^18.0.0
     react-dom: ^18.0.0
-  checksum: 03e75324c92a70aea9980f29a993e79967e5ca85d2db1b18bcb00e6c3d8711fec1a1728f92247d4d35a119ae5c3fb5b5d728ea33591f36e8bd43fa6acb1c791c
+  checksum: ec578e62b3b13b1874b14235a448a913c2d2358ea9b9d9c60bb250be468ab62387c88ec44e1ee82ad5b3d7243306e31919888a80eae62e5e8eab0ae12194bf69
   languageName: node
   linkType: hard
 
@@ -2791,26 +3947,26 @@ __metadata:
   languageName: node
   linkType: hard
 
-"@docusaurus/theme-classic@npm:3.0.1":
-  version: 3.0.1
-  resolution: "@docusaurus/theme-classic@npm:3.0.1"
-  dependencies:
-    "@docusaurus/core": 3.0.1
-    "@docusaurus/mdx-loader": 3.0.1
-    "@docusaurus/module-type-aliases": 3.0.1
-    "@docusaurus/plugin-content-blog": 3.0.1
-    "@docusaurus/plugin-content-docs": 3.0.1
-    "@docusaurus/plugin-content-pages": 3.0.1
-    "@docusaurus/theme-common": 3.0.1
-    "@docusaurus/theme-translations": 3.0.1
-    "@docusaurus/types": 3.0.1
-    "@docusaurus/utils": 3.0.1
-    "@docusaurus/utils-common": 3.0.1
-    "@docusaurus/utils-validation": 3.0.1
+"@docusaurus/theme-classic@npm:3.5.2":
+  version: 3.5.2
+  resolution: "@docusaurus/theme-classic@npm:3.5.2"
+  dependencies:
+    "@docusaurus/core": 3.5.2
+    "@docusaurus/mdx-loader": 3.5.2
+    "@docusaurus/module-type-aliases": 3.5.2
+    "@docusaurus/plugin-content-blog": 3.5.2
+    "@docusaurus/plugin-content-docs": 3.5.2
+    "@docusaurus/plugin-content-pages": 3.5.2
+    "@docusaurus/theme-common": 3.5.2
+    "@docusaurus/theme-translations": 3.5.2
+    "@docusaurus/types": 3.5.2
+    "@docusaurus/utils": 3.5.2
+    "@docusaurus/utils-common": 3.5.2
+    "@docusaurus/utils-validation": 3.5.2
     "@mdx-js/react": ^3.0.0
     clsx: ^2.0.0
     copy-text-to-clipboard: ^3.2.0
-    infima: 0.2.0-alpha.43
+    infima: 0.2.0-alpha.44
     lodash: ^4.17.21
     nprogress: ^0.2.0
     postcss: ^8.4.26
@@ -2823,21 +3979,18 @@ __metadata:
   peerDependencies:
     react: ^18.0.0
     react-dom: ^18.0.0
-  checksum: 86cef28b5f93d01f15cb134283b8d1006466d661cc39c09c585e56a6a98b09816f8e7cef24b164e8a378b6deb4ed8984fdc329d09fdcbe83fa51529091ccfad8
+  checksum: 6c415b01ad24bb43eb166e2b780a84356ff14a627627f6a541c2803832d56c4f9409a5636048693d2d24804f59c2cc7bda925d9ef999a8276fe125477d2b2e1e
   languageName: node
   linkType: hard
 
-"@docusaurus/theme-common@npm:3.0.1":
-  version: 3.0.1
-  resolution: "@docusaurus/theme-common@npm:3.0.1"
-  dependencies:
-    "@docusaurus/mdx-loader": 3.0.1
-    "@docusaurus/module-type-aliases": 3.0.1
-    "@docusaurus/plugin-content-blog": 3.0.1
-    "@docusaurus/plugin-content-docs": 3.0.1
-    "@docusaurus/plugin-content-pages": 3.0.1
-    "@docusaurus/utils": 3.0.1
-    "@docusaurus/utils-common": 3.0.1
+"@docusaurus/theme-common@npm:3.5.2":
+  version: 3.5.2
+  resolution: "@docusaurus/theme-common@npm:3.5.2"
+  dependencies:
+    "@docusaurus/mdx-loader": 3.5.2
+    "@docusaurus/module-type-aliases": 3.5.2
+    "@docusaurus/utils": 3.5.2
+    "@docusaurus/utils-common": 3.5.2
     "@types/history": ^4.7.11
     "@types/react": "*"
     "@types/react-router-config": "*"
@@ -2847,24 +4000,25 @@ __metadata:
     tslib: ^2.6.0
     utility-types: ^3.10.0
   peerDependencies:
+    "@docusaurus/plugin-content-docs": "*"
     react: ^18.0.0
     react-dom: ^18.0.0
-  checksum: 99fb138fd2fb499d53ee81ae717768b5cb6556ddd337b6d1a399815cb428eed2c04d2823e2040fd4db27bc79681f6333ac1ea78d760ff7fc4475d16d1790552a
+  checksum: c78ec7f6035abc920a2a0bc1ad78920178a5452538a3a70794eca8d4b976725f6ccc464ee3092afd31ca59b4e061ad4c21cdce7f5e10b06567075814b2fc2002
   languageName: node
   linkType: hard
 
-"@docusaurus/theme-search-algolia@npm:3.0.1":
-  version: 3.0.1
-  resolution: "@docusaurus/theme-search-algolia@npm:3.0.1"
+"@docusaurus/theme-search-algolia@npm:3.5.2":
+  version: 3.5.2
+  resolution: "@docusaurus/theme-search-algolia@npm:3.5.2"
   dependencies:
     "@docsearch/react": ^3.5.2
-    "@docusaurus/core": 3.0.1
-    "@docusaurus/logger": 3.0.1
-    "@docusaurus/plugin-content-docs": 3.0.1
-    "@docusaurus/theme-common": 3.0.1
-    "@docusaurus/theme-translations": 3.0.1
-    "@docusaurus/utils": 3.0.1
-    "@docusaurus/utils-validation": 3.0.1
+    "@docusaurus/core": 3.5.2
+    "@docusaurus/logger": 3.5.2
+    "@docusaurus/plugin-content-docs": 3.5.2
+    "@docusaurus/theme-common": 3.5.2
+    "@docusaurus/theme-translations": 3.5.2
+    "@docusaurus/utils": 3.5.2
+    "@docusaurus/utils-validation": 3.5.2
     algoliasearch: ^4.18.0
     algoliasearch-helper: ^3.13.3
     clsx: ^2.0.0
@@ -2876,17 +4030,17 @@ __metadata:
   peerDependencies:
     react: ^18.0.0
     react-dom: ^18.0.0
-  checksum: 24a38dbd7085ea78c412e50c94dda7e0ecb80046dd18c1fdb515d81b21be5cdbc706705a5155600510b0814698abb234885a576d90e0db9cf3c5983d0bf51462
+  checksum: e945e3001996477597bfad074eaef074cf4c5365ed3076c3109130a2252b266e4e2fac46904a0626eedeff23b9ac11e7b985cc71f5485ede52d3ddf379b7959b
   languageName: node
   linkType: hard
 
-"@docusaurus/theme-translations@npm:3.0.1":
-  version: 3.0.1
-  resolution: "@docusaurus/theme-translations@npm:3.0.1"
+"@docusaurus/theme-translations@npm:3.5.2":
+  version: 3.5.2
+  resolution: "@docusaurus/theme-translations@npm:3.5.2"
   dependencies:
     fs-extra: ^11.1.1
     tslib: ^2.6.0
-  checksum: a1df314ddaeb7f453867c5ee5424b36d31c6d6541f86b3927881b77333e997b87e720c0285f3be507283cb851537ff154ce0ddbd5e771c184c8aa10af721d7c2
+  checksum: dc523c74a13fb8552c03e547c6de1c21881d899cc74bf088a2bed716e0ef1a4ceba2726c43656d87fff60413ca191f5ea946b182e4ae4129c14da832b5194d82
   languageName: node
   linkType: hard
 
@@ -2900,10 +4054,10 @@ __metadata:
   languageName: node
   linkType: hard
 
-"@docusaurus/tsconfig@npm:^3.0.1":
-  version: 3.0.1
-  resolution: "@docusaurus/tsconfig@npm:3.0.1"
-  checksum: a191e527740ea09cc4783ab45f106989f692d100e83768a4398fc08d3d41f0645afdce83aa89a1b251d5899544105af09e795af4d0db54247403a180f3c43098
+"@docusaurus/tsconfig@npm:^3.5.2":
+  version: 3.5.2
+  resolution: "@docusaurus/tsconfig@npm:3.5.2"
+  checksum: 808a17eaf422ae9a948c6558dd1e92d4700b067ead3a63a84049c6845bf94f84e311cd0e4d517047fe9ea057efe393bb22c2d5c92d727d06c9f895e971f2c3ea
   languageName: node
   linkType: hard
 
@@ -2926,10 +4080,11 @@ __metadata:
   languageName: node
   linkType: hard
 
-"@docusaurus/types@npm:3.0.1, @docusaurus/types@npm:^3.0.1":
-  version: 3.0.1
-  resolution: "@docusaurus/types@npm:3.0.1"
+"@docusaurus/types@npm:3.5.2, @docusaurus/types@npm:^3.5.2":
+  version: 3.5.2
+  resolution: "@docusaurus/types@npm:3.5.2"
   dependencies:
+    "@mdx-js/mdx": ^3.0.0
     "@types/history": ^4.7.11
     "@types/react": "*"
     commander: ^5.1.0
@@ -2941,7 +4096,7 @@ __metadata:
   peerDependencies:
     react: ^18.0.0
     react-dom: ^18.0.0
-  checksum: 1874e66435e986262ad06639b812d49aa5c81a29815b27d31370d055335cebdad77ee0276504497b1765c489e5c5faf9795df97e52649af931d1cf381c4afa77
+  checksum: e39451b7b08673ad5e1551ee6e4286f90f2554cf9ba245abfa56670550f48afca9c57b01c10ffa21dacb734c0fcd067150eeb2b1c1ebb1692f1f538b1eed0029
   languageName: node
   linkType: hard
 
@@ -2959,9 +4114,9 @@ __metadata:
   languageName: node
   linkType: hard
 
-"@docusaurus/utils-common@npm:3.0.1":
-  version: 3.0.1
-  resolution: "@docusaurus/utils-common@npm:3.0.1"
+"@docusaurus/utils-common@npm:3.5.2":
+  version: 3.5.2
+  resolution: "@docusaurus/utils-common@npm:3.5.2"
   dependencies:
     tslib: ^2.6.0
   peerDependencies:
@@ -2969,7 +4124,7 @@ __metadata:
   peerDependenciesMeta:
     "@docusaurus/types":
       optional: true
-  checksum: 7d4eb39258539d594cf1432d07be0325de5a02c2a00418e022b0cd2d4374788a7cc5dd3febad6f34744e5a1e76646ae909ffbdf2024284f31c579d1f1ff055d8
+  checksum: 9d550c89663d4271456ae0832c82a1691207ccc95e21df3a05a4bd6bbd2624bb9e3ab7327d939c04b2023378987bcf99321b2c37be1af214852832f65d6db14a
   languageName: node
   linkType: hard
 
@@ -2986,16 +4141,19 @@ __metadata:
   languageName: node
   linkType: hard
 
-"@docusaurus/utils-validation@npm:3.0.1":
-  version: 3.0.1
-  resolution: "@docusaurus/utils-validation@npm:3.0.1"
+"@docusaurus/utils-validation@npm:3.5.2":
+  version: 3.5.2
+  resolution: "@docusaurus/utils-validation@npm:3.5.2"
   dependencies:
-    "@docusaurus/logger": 3.0.1
-    "@docusaurus/utils": 3.0.1
+    "@docusaurus/logger": 3.5.2
+    "@docusaurus/utils": 3.5.2
+    "@docusaurus/utils-common": 3.5.2
+    fs-extra: ^11.2.0
     joi: ^17.9.2
     js-yaml: ^4.1.0
+    lodash: ^4.17.21
     tslib: ^2.6.0
-  checksum: c52edd61906ee004cea95ca33f81ec10a40276cad29f1aef505220cea4b922c1734b765d9c55b0889822351876ea545a73f7f3a4fbbb574f625fe455f8387033
+  checksum: 5966e6d0e8f26292c629899f13b545501b53b345b0e2291bb47aaa80d7c9c5cf155e15a4ecd073a4095ee7c83c6db3612e0a34f81a8187fd20410b1aeb92d731
   languageName: node
   linkType: hard
 
@@ -3028,12 +4186,13 @@ __metadata:
   languageName: node
   linkType: hard
 
-"@docusaurus/utils@npm:3.0.1":
-  version: 3.0.1
-  resolution: "@docusaurus/utils@npm:3.0.1"
+"@docusaurus/utils@npm:3.5.2":
+  version: 3.5.2
+  resolution: "@docusaurus/utils@npm:3.5.2"
   dependencies:
-    "@docusaurus/logger": 3.0.1
-    "@svgr/webpack": ^6.5.1
+    "@docusaurus/logger": 3.5.2
+    "@docusaurus/utils-common": 3.5.2
+    "@svgr/webpack": ^8.1.0
     escape-string-regexp: ^4.0.0
     file-loader: ^6.2.0
     fs-extra: ^11.1.1
@@ -3044,17 +4203,19 @@ __metadata:
     js-yaml: ^4.1.0
     lodash: ^4.17.21
     micromatch: ^4.0.5
+    prompts: ^2.4.2
     resolve-pathname: ^3.0.0
     shelljs: ^0.8.5
     tslib: ^2.6.0
     url-loader: ^4.1.1
+    utility-types: ^3.10.0
     webpack: ^5.88.1
   peerDependencies:
     "@docusaurus/types": "*"
   peerDependenciesMeta:
     "@docusaurus/types":
       optional: true
-  checksum: 5a8c5d8dd9cf1ad9ed1cecff3be3cbe041ebf8f51e2744af8aa006df67367f24d0888181566ed9ab2837b931a4fb135d943eadfde99708468f90f18795d413b5
+  checksum: 0e0f4fc65ed076d4e4b551ecb61447b7c2468060d1655afff314515844ae34dc0546f467f53bff535f3144afc109e974da27fadb7c678a5d19966bed9e7a27c4
   languageName: node
   linkType: hard
 
@@ -3771,6 +4932,17 @@ __metadata:
   languageName: node
   linkType: hard
 
+"@jridgewell/gen-mapping@npm:^0.3.5":
+  version: 0.3.5
+  resolution: "@jridgewell/gen-mapping@npm:0.3.5"
+  dependencies:
+    "@jridgewell/set-array": ^1.2.1
+    "@jridgewell/sourcemap-codec": ^1.4.10
+    "@jridgewell/trace-mapping": ^0.3.24
+  checksum: ff7a1764ebd76a5e129c8890aa3e2f46045109dabde62b0b6c6a250152227647178ff2069ea234753a690d8f3c4ac8b5e7b267bbee272bffb7f3b0a370ab6e52
+  languageName: node
+  linkType: hard
+
 "@jridgewell/resolve-uri@npm:^3.0.3, @jridgewell/resolve-uri@npm:^3.1.0":
   version: 3.1.1
   resolution: "@jridgewell/resolve-uri@npm:3.1.1"
@@ -3785,6 +4957,13 @@ __metadata:
   languageName: node
   linkType: hard
 
+"@jridgewell/set-array@npm:^1.2.1":
+  version: 1.2.1
+  resolution: "@jridgewell/set-array@npm:1.2.1"
+  checksum: 832e513a85a588f8ed4f27d1279420d8547743cc37fcad5a5a76fc74bb895b013dfe614d0eed9cb860048e6546b798f8f2652020b4b2ba0561b05caa8c654b10
+  languageName: node
+  linkType: hard
+
 "@jridgewell/source-map@npm:^0.3.3":
   version: 0.3.5
   resolution: "@jridgewell/source-map@npm:0.3.5"
@@ -3822,6 +5001,16 @@ __metadata:
   languageName: node
   linkType: hard
 
+"@jridgewell/trace-mapping@npm:^0.3.18, @jridgewell/trace-mapping@npm:^0.3.24, @jridgewell/trace-mapping@npm:^0.3.25":
+  version: 0.3.25
+  resolution: "@jridgewell/trace-mapping@npm:0.3.25"
+  dependencies:
+    "@jridgewell/resolve-uri": ^3.1.0
+    "@jridgewell/sourcemap-codec": ^1.4.14
+  checksum: 9d3c40d225e139987b50c48988f8717a54a8c994d8a948ee42e1412e08988761d0754d7d10b803061cc3aebf35f92a5dbbab493bd0e1a9ef9e89a2130e83ba34
+  languageName: node
+  linkType: hard
+
 "@jridgewell/trace-mapping@npm:^0.3.20":
   version: 0.3.22
   resolution: "@jridgewell/trace-mapping@npm:0.3.22"
@@ -4157,23 +5346,6 @@ __metadata:
   languageName: unknown
   linkType: soft
 
-"@noir-lang/backend_barretenberg@workspace:*, @noir-lang/backend_barretenberg@workspace:tooling/noir_js_backend_barretenberg":
-  version: 0.0.0-use.local
-  resolution: "@noir-lang/backend_barretenberg@workspace:tooling/noir_js_backend_barretenberg"
-  dependencies:
-    "@aztec/bb.js": 0.56.0
-    "@noir-lang/types": "workspace:*"
-    "@types/node": ^20.6.2
-    "@types/prettier": ^3
-    eslint: ^8.57.0
-    eslint-plugin-prettier: ^5.1.3
-    fflate: ^0.8.0
-    prettier: 3.2.5
-    ts-node: ^10.9.1
-    typescript: 5.4.2
-  languageName: unknown
-  linkType: soft
-
 "@noir-lang/noir_codegen@workspace:tooling/noir_codegen":
   version: 0.0.0-use.local
   resolution: "@noir-lang/noir_codegen@workspace:tooling/noir_codegen"
@@ -5024,6 +6196,15 @@ __metadata:
   languageName: node
   linkType: hard
 
+"@svgr/babel-plugin-add-jsx-attribute@npm:8.0.0":
+  version: 8.0.0
+  resolution: "@svgr/babel-plugin-add-jsx-attribute@npm:8.0.0"
+  peerDependencies:
+    "@babel/core": ^7.0.0-0
+  checksum: 3fc8e35d16f5abe0af5efe5851f27581225ac405d6a1ca44cda0df064cddfcc29a428c48c2e4bef6cebf627c9ac2f652a096030edb02cf5a120ce28d3c234710
+  languageName: node
+  linkType: hard
+
 "@svgr/babel-plugin-add-jsx-attribute@npm:^6.5.1":
   version: 6.5.1
   resolution: "@svgr/babel-plugin-add-jsx-attribute@npm:6.5.1"
@@ -5033,7 +6214,7 @@ __metadata:
   languageName: node
   linkType: hard
 
-"@svgr/babel-plugin-remove-jsx-attribute@npm:*":
+"@svgr/babel-plugin-remove-jsx-attribute@npm:*, @svgr/babel-plugin-remove-jsx-attribute@npm:8.0.0":
   version: 8.0.0
   resolution: "@svgr/babel-plugin-remove-jsx-attribute@npm:8.0.0"
   peerDependencies:
@@ -5042,7 +6223,7 @@ __metadata:
   languageName: node
   linkType: hard
 
-"@svgr/babel-plugin-remove-jsx-empty-expression@npm:*":
+"@svgr/babel-plugin-remove-jsx-empty-expression@npm:*, @svgr/babel-plugin-remove-jsx-empty-expression@npm:8.0.0":
   version: 8.0.0
   resolution: "@svgr/babel-plugin-remove-jsx-empty-expression@npm:8.0.0"
   peerDependencies:
@@ -5051,6 +6232,15 @@ __metadata:
   languageName: node
   linkType: hard
 
+"@svgr/babel-plugin-replace-jsx-attribute-value@npm:8.0.0":
+  version: 8.0.0
+  resolution: "@svgr/babel-plugin-replace-jsx-attribute-value@npm:8.0.0"
+  peerDependencies:
+    "@babel/core": ^7.0.0-0
+  checksum: 1edda65ef4f4dd8f021143c8ec276a08f6baa6f733b8e8ee2e7775597bf6b97afb47fdeefd579d6ae6c959fe2e634f55cd61d99377631212228c8cfb351b8921
+  languageName: node
+  linkType: hard
+
 "@svgr/babel-plugin-replace-jsx-attribute-value@npm:^6.5.1":
   version: 6.5.1
   resolution: "@svgr/babel-plugin-replace-jsx-attribute-value@npm:6.5.1"
@@ -5060,6 +6250,15 @@ __metadata:
   languageName: node
   linkType: hard
 
+"@svgr/babel-plugin-svg-dynamic-title@npm:8.0.0":
+  version: 8.0.0
+  resolution: "@svgr/babel-plugin-svg-dynamic-title@npm:8.0.0"
+  peerDependencies:
+    "@babel/core": ^7.0.0-0
+  checksum: 876cec891488992e6a9aebb8155e2bea4ec461b4718c51de36e988e00e271c6d9d01ef6be17b9effd44b2b3d7db0b41c161a5904a46ae6f38b26b387ad7f3709
+  languageName: node
+  linkType: hard
+
 "@svgr/babel-plugin-svg-dynamic-title@npm:^6.5.1":
   version: 6.5.1
   resolution: "@svgr/babel-plugin-svg-dynamic-title@npm:6.5.1"
@@ -5069,6 +6268,15 @@ __metadata:
   languageName: node
   linkType: hard
 
+"@svgr/babel-plugin-svg-em-dimensions@npm:8.0.0":
+  version: 8.0.0
+  resolution: "@svgr/babel-plugin-svg-em-dimensions@npm:8.0.0"
+  peerDependencies:
+    "@babel/core": ^7.0.0-0
+  checksum: be0e2d391164428327d9ec469a52cea7d93189c6b0e2c290999e048f597d777852f701c64dca44cd45b31ed14a7f859520326e2e4ad7c3a4545d0aa235bc7e9a
+  languageName: node
+  linkType: hard
+
 "@svgr/babel-plugin-svg-em-dimensions@npm:^6.5.1":
   version: 6.5.1
   resolution: "@svgr/babel-plugin-svg-em-dimensions@npm:6.5.1"
@@ -5078,6 +6286,15 @@ __metadata:
   languageName: node
   linkType: hard
 
+"@svgr/babel-plugin-transform-react-native-svg@npm:8.1.0":
+  version: 8.1.0
+  resolution: "@svgr/babel-plugin-transform-react-native-svg@npm:8.1.0"
+  peerDependencies:
+    "@babel/core": ^7.0.0-0
+  checksum: 85b434a57572f53bd2b9f0606f253e1fcf57b4a8c554ec3f2d43ed17f50d8cae200cb3aaf1ec9d626e1456e8b135dce530ae047eb0bed6d4bf98a752d6640459
+  languageName: node
+  linkType: hard
+
 "@svgr/babel-plugin-transform-react-native-svg@npm:^6.5.1":
   version: 6.5.1
   resolution: "@svgr/babel-plugin-transform-react-native-svg@npm:6.5.1"
@@ -5087,6 +6304,15 @@ __metadata:
   languageName: node
   linkType: hard
 
+"@svgr/babel-plugin-transform-svg-component@npm:8.0.0":
+  version: 8.0.0
+  resolution: "@svgr/babel-plugin-transform-svg-component@npm:8.0.0"
+  peerDependencies:
+    "@babel/core": ^7.0.0-0
+  checksum: 04e2023d75693eeb0890341c40e449881184663056c249be7e5c80168e4aabb0fadd255e8d5d2dbf54b8c2a6e700efba994377135bfa4060dc4a2e860116ef8c
+  languageName: node
+  linkType: hard
+
 "@svgr/babel-plugin-transform-svg-component@npm:^6.5.1":
   version: 6.5.1
   resolution: "@svgr/babel-plugin-transform-svg-component@npm:6.5.1"
@@ -5096,6 +6322,24 @@ __metadata:
   languageName: node
   linkType: hard
 
+"@svgr/babel-preset@npm:8.1.0":
+  version: 8.1.0
+  resolution: "@svgr/babel-preset@npm:8.1.0"
+  dependencies:
+    "@svgr/babel-plugin-add-jsx-attribute": 8.0.0
+    "@svgr/babel-plugin-remove-jsx-attribute": 8.0.0
+    "@svgr/babel-plugin-remove-jsx-empty-expression": 8.0.0
+    "@svgr/babel-plugin-replace-jsx-attribute-value": 8.0.0
+    "@svgr/babel-plugin-svg-dynamic-title": 8.0.0
+    "@svgr/babel-plugin-svg-em-dimensions": 8.0.0
+    "@svgr/babel-plugin-transform-react-native-svg": 8.1.0
+    "@svgr/babel-plugin-transform-svg-component": 8.0.0
+  peerDependencies:
+    "@babel/core": ^7.0.0-0
+  checksum: 3a67930f080b8891e1e8e2595716b879c944d253112bae763dce59807ba23454d162216c8d66a0a0e3d4f38a649ecd6c387e545d1e1261dd69a68e9a3392ee08
+  languageName: node
+  linkType: hard
+
 "@svgr/babel-preset@npm:^6.5.1":
   version: 6.5.1
   resolution: "@svgr/babel-preset@npm:6.5.1"
@@ -5114,6 +6358,19 @@ __metadata:
   languageName: node
   linkType: hard
 
+"@svgr/core@npm:8.1.0":
+  version: 8.1.0
+  resolution: "@svgr/core@npm:8.1.0"
+  dependencies:
+    "@babel/core": ^7.21.3
+    "@svgr/babel-preset": 8.1.0
+    camelcase: ^6.2.0
+    cosmiconfig: ^8.1.3
+    snake-case: ^3.0.4
+  checksum: da4a12865c7dc59829d58df8bd232d6c85b7115fda40da0d2f844a1a51886e2e945560596ecfc0345d37837ac457de86a931e8b8d8550e729e0c688c02250d8a
+  languageName: node
+  linkType: hard
+
 "@svgr/core@npm:^6.5.1":
   version: 6.5.1
   resolution: "@svgr/core@npm:6.5.1"
@@ -5127,6 +6384,16 @@ __metadata:
   languageName: node
   linkType: hard
 
+"@svgr/hast-util-to-babel-ast@npm:8.0.0":
+  version: 8.0.0
+  resolution: "@svgr/hast-util-to-babel-ast@npm:8.0.0"
+  dependencies:
+    "@babel/types": ^7.21.3
+    entities: ^4.4.0
+  checksum: 88401281a38bbc7527e65ff5437970414391a86158ef4b4046c89764c156d2d39ecd7cce77be8a51994c9fb3249170cb1eb8b9128b62faaa81743ef6ed3534ab
+  languageName: node
+  linkType: hard
+
 "@svgr/hast-util-to-babel-ast@npm:^6.5.1":
   version: 6.5.1
   resolution: "@svgr/hast-util-to-babel-ast@npm:6.5.1"
@@ -5137,6 +6404,20 @@ __metadata:
   languageName: node
   linkType: hard
 
+"@svgr/plugin-jsx@npm:8.1.0":
+  version: 8.1.0
+  resolution: "@svgr/plugin-jsx@npm:8.1.0"
+  dependencies:
+    "@babel/core": ^7.21.3
+    "@svgr/babel-preset": 8.1.0
+    "@svgr/hast-util-to-babel-ast": 8.0.0
+    svg-parser: ^2.0.4
+  peerDependencies:
+    "@svgr/core": "*"
+  checksum: 0418a9780753d3544912ee2dad5d2cf8d12e1ba74df8053651b3886aeda54d5f0f7d2dece0af5e0d838332c4f139a57f0dabaa3ca1afa4d1a765efce6a7656f2
+  languageName: node
+  linkType: hard
+
 "@svgr/plugin-jsx@npm:^6.5.1":
   version: 6.5.1
   resolution: "@svgr/plugin-jsx@npm:6.5.1"
@@ -5151,6 +6432,19 @@ __metadata:
   languageName: node
   linkType: hard
 
+"@svgr/plugin-svgo@npm:8.1.0":
+  version: 8.1.0
+  resolution: "@svgr/plugin-svgo@npm:8.1.0"
+  dependencies:
+    cosmiconfig: ^8.1.3
+    deepmerge: ^4.3.1
+    svgo: ^3.0.2
+  peerDependencies:
+    "@svgr/core": "*"
+  checksum: 59d9d214cebaacca9ca71a561f463d8b7e5a68ca9443e4792a42d903acd52259b1790c0680bc6afecc3f00a255a6cbd7ea278a9f625bac443620ea58a590c2d0
+  languageName: node
+  linkType: hard
+
 "@svgr/plugin-svgo@npm:^6.5.1":
   version: 6.5.1
   resolution: "@svgr/plugin-svgo@npm:6.5.1"
@@ -5164,7 +6458,7 @@ __metadata:
   languageName: node
   linkType: hard
 
-"@svgr/webpack@npm:^6.2.1, @svgr/webpack@npm:^6.5.1":
+"@svgr/webpack@npm:^6.2.1":
   version: 6.5.1
   resolution: "@svgr/webpack@npm:6.5.1"
   dependencies:
@@ -5180,6 +6474,22 @@ __metadata:
   languageName: node
   linkType: hard
 
+"@svgr/webpack@npm:^8.1.0":
+  version: 8.1.0
+  resolution: "@svgr/webpack@npm:8.1.0"
+  dependencies:
+    "@babel/core": ^7.21.3
+    "@babel/plugin-transform-react-constant-elements": ^7.21.3
+    "@babel/preset-env": ^7.20.2
+    "@babel/preset-react": ^7.18.6
+    "@babel/preset-typescript": ^7.21.0
+    "@svgr/core": 8.1.0
+    "@svgr/plugin-jsx": 8.1.0
+    "@svgr/plugin-svgo": 8.1.0
+  checksum: c6eec5b0cf2fb2ecd3a7a362d272eda35330b17c76802a3481f499b5d07ff8f87b31d2571043bff399b051a1767b1e2e499dbf186104d1c06d76f9f1535fac01
+  languageName: node
+  linkType: hard
+
 "@szmarczak/http-timer@npm:^1.1.2":
   version: 1.1.2
   resolution: "@szmarczak/http-timer@npm:1.1.2"
@@ -7155,6 +8465,24 @@ __metadata:
   languageName: node
   linkType: hard
 
+"autoprefixer@npm:^10.4.19":
+  version: 10.4.20
+  resolution: "autoprefixer@npm:10.4.20"
+  dependencies:
+    browserslist: ^4.23.3
+    caniuse-lite: ^1.0.30001646
+    fraction.js: ^4.3.7
+    normalize-range: ^0.1.2
+    picocolors: ^1.0.1
+    postcss-value-parser: ^4.2.0
+  peerDependencies:
+    postcss: ^8.1.0
+  bin:
+    autoprefixer: bin/autoprefixer
+  checksum: 187cec2ec356631932b212f76dc64f4419c117fdb2fb9eeeb40867d38ba5ca5ba734e6ceefc9e3af4eec8258e60accdf5cbf2b7708798598fde35cdc3de562d6
+  languageName: node
+  linkType: hard
+
 "available-typed-arrays@npm:^1.0.5":
   version: 1.0.5
   resolution: "available-typed-arrays@npm:1.0.5"
@@ -7247,6 +8575,19 @@ __metadata:
   languageName: node
   linkType: hard
 
+"babel-plugin-polyfill-corejs2@npm:^0.4.10":
+  version: 0.4.11
+  resolution: "babel-plugin-polyfill-corejs2@npm:0.4.11"
+  dependencies:
+    "@babel/compat-data": ^7.22.6
+    "@babel/helper-define-polyfill-provider": ^0.6.2
+    semver: ^6.3.1
+  peerDependencies:
+    "@babel/core": ^7.4.0 || ^8.0.0-0 <8.0.0
+  checksum: f098353ce7c7dde1a1d2710858e01b471e85689110c9e37813e009072347eb8c55d5f84d20d3bf1cab31755f20078ba90f8855fdc4686a9daa826a95ff280bd7
+  languageName: node
+  linkType: hard
+
 "babel-plugin-polyfill-corejs2@npm:^0.4.6":
   version: 0.4.6
   resolution: "babel-plugin-polyfill-corejs2@npm:0.4.6"
@@ -7260,6 +8601,18 @@ __metadata:
   languageName: node
   linkType: hard
 
+"babel-plugin-polyfill-corejs3@npm:^0.10.6":
+  version: 0.10.6
+  resolution: "babel-plugin-polyfill-corejs3@npm:0.10.6"
+  dependencies:
+    "@babel/helper-define-polyfill-provider": ^0.6.2
+    core-js-compat: ^3.38.0
+  peerDependencies:
+    "@babel/core": ^7.4.0 || ^8.0.0-0 <8.0.0
+  checksum: f762f29f7acca576897c63149c850f0a72babd3fb9ea436a2e36f0c339161c4b912a77828541d8188ce8a91e50965c6687120cf36071eabb1b7aa92f279e2164
+  languageName: node
+  linkType: hard
+
 "babel-plugin-polyfill-corejs3@npm:^0.8.5":
   version: 0.8.6
   resolution: "babel-plugin-polyfill-corejs3@npm:0.8.6"
@@ -7283,6 +8636,17 @@ __metadata:
   languageName: node
   linkType: hard
 
+"babel-plugin-polyfill-regenerator@npm:^0.6.1":
+  version: 0.6.2
+  resolution: "babel-plugin-polyfill-regenerator@npm:0.6.2"
+  dependencies:
+    "@babel/helper-define-polyfill-provider": ^0.6.2
+  peerDependencies:
+    "@babel/core": ^7.4.0 || ^8.0.0-0 <8.0.0
+  checksum: 150233571072b6b3dfe946242da39cba8587b7f908d1c006f7545fc88b0e3c3018d445739beb61e7a75835f0c2751dbe884a94ff9b245ec42369d9267e0e1b3f
+  languageName: node
+  linkType: hard
+
 "bail@npm:^1.0.0":
   version: 1.0.5
   resolution: "bail@npm:1.0.5"
@@ -7607,6 +8971,20 @@ __metadata:
   languageName: node
   linkType: hard
 
+"browserslist@npm:^4.23.0, browserslist@npm:^4.23.1, browserslist@npm:^4.23.3":
+  version: 4.24.0
+  resolution: "browserslist@npm:4.24.0"
+  dependencies:
+    caniuse-lite: ^1.0.30001663
+    electron-to-chromium: ^1.5.28
+    node-releases: ^2.0.18
+    update-browserslist-db: ^1.1.0
+  bin:
+    browserslist: cli.js
+  checksum: de200d3eb8d6ed819dad99719099a28fb6ebeb88016a5ac42fbdc11607e910c236a84ca1b0bbf232477d4b88ab64e8ab6aa67557cdd40a73ca9c2834f92ccce0
+  languageName: node
+  linkType: hard
+
 "bs58@npm:^4.0.0":
   version: 4.0.1
   resolution: "bs58@npm:4.0.1"
@@ -7833,6 +9211,13 @@ __metadata:
   languageName: node
   linkType: hard
 
+"caniuse-lite@npm:^1.0.30001646, caniuse-lite@npm:^1.0.30001663":
+  version: 1.0.30001664
+  resolution: "caniuse-lite@npm:1.0.30001664"
+  checksum: cee25b4ea8a84779b7c9a60c1f9e304f6d99b79ef622b25fbc7873b4e55e8722a1091dd6c8b77bd7723e9f26a84b4a820a50a864989dd477e7ee51dc30461dca
+  languageName: node
+  linkType: hard
+
 "ccount@npm:^1.0.0":
   version: 1.1.0
   resolution: "ccount@npm:1.1.0"
@@ -8005,7 +9390,7 @@ __metadata:
   languageName: node
   linkType: hard
 
-"cheerio@npm:^1.0.0-rc.12, cheerio@npm:^1.0.0-rc.3":
+"cheerio@npm:1.0.0-rc.12, cheerio@npm:^1.0.0-rc.3":
   version: 1.0.0-rc.12
   resolution: "cheerio@npm:1.0.0-rc.12"
   dependencies:
@@ -8330,7 +9715,7 @@ __metadata:
   languageName: node
   linkType: hard
 
-"colord@npm:^2.9.1":
+"colord@npm:^2.9.1, colord@npm:^2.9.3":
   version: 2.9.3
   resolution: "colord@npm:2.9.3"
   checksum: 95d909bfbcfd8d5605cbb5af56f2d1ce2b323990258fd7c0d2eb0e6d3bb177254d7fb8213758db56bb4ede708964f78c6b992b326615f81a18a6aaf11d64c650
@@ -8703,6 +10088,15 @@ __metadata:
   languageName: node
   linkType: hard
 
+"core-js-compat@npm:^3.37.1, core-js-compat@npm:^3.38.0":
+  version: 3.38.1
+  resolution: "core-js-compat@npm:3.38.1"
+  dependencies:
+    browserslist: ^4.23.3
+  checksum: a0a5673bcd59f588f0cd0b59cdacd4712b82909738a87406d334dd412eb3d273ae72b275bdd8e8fef63fca9ef12b42ed651be139c7c44c8a1acb423c8906992e
+  languageName: node
+  linkType: hard
+
 "core-js-pure@npm:^3.30.2":
   version: 3.34.0
   resolution: "core-js-pure@npm:3.34.0"
@@ -8750,7 +10144,7 @@ __metadata:
   languageName: node
   linkType: hard
 
-"cosmiconfig@npm:^8.2.0":
+"cosmiconfig@npm:^8.1.3, cosmiconfig@npm:^8.2.0":
   version: 8.3.6
   resolution: "cosmiconfig@npm:8.3.6"
   dependencies:
@@ -8981,6 +10375,15 @@ __metadata:
   languageName: node
   linkType: hard
 
+"css-declaration-sorter@npm:^7.2.0":
+  version: 7.2.0
+  resolution: "css-declaration-sorter@npm:7.2.0"
+  peerDependencies:
+    postcss: ^8.0.9
+  checksum: 69b2f63a1c7c593123fabcbb353618ed01eb75f6404da9321328fbb30d603d89c47195129fadf1dc316e1406a0881400b324c2bded9438c47196e1c96ec726dd
+  languageName: node
+  linkType: hard
+
 "css-loader@npm:^6.7.1, css-loader@npm:^6.8.1":
   version: 6.8.1
   resolution: "css-loader@npm:6.8.1"
@@ -8999,7 +10402,7 @@ __metadata:
   languageName: node
   linkType: hard
 
-"css-minimizer-webpack-plugin@npm:^4.0.0, css-minimizer-webpack-plugin@npm:^4.2.2":
+"css-minimizer-webpack-plugin@npm:^4.0.0":
   version: 4.2.2
   resolution: "css-minimizer-webpack-plugin@npm:4.2.2"
   dependencies:
@@ -9028,6 +10431,35 @@ __metadata:
   languageName: node
   linkType: hard
 
+"css-minimizer-webpack-plugin@npm:^5.0.1":
+  version: 5.0.1
+  resolution: "css-minimizer-webpack-plugin@npm:5.0.1"
+  dependencies:
+    "@jridgewell/trace-mapping": ^0.3.18
+    cssnano: ^6.0.1
+    jest-worker: ^29.4.3
+    postcss: ^8.4.24
+    schema-utils: ^4.0.1
+    serialize-javascript: ^6.0.1
+  peerDependencies:
+    webpack: ^5.0.0
+  peerDependenciesMeta:
+    "@parcel/css":
+      optional: true
+    "@swc/css":
+      optional: true
+    clean-css:
+      optional: true
+    csso:
+      optional: true
+    esbuild:
+      optional: true
+    lightningcss:
+      optional: true
+  checksum: 10055802c61d1ae72584eac03b6bd221ecbefde11d337be44a5459d8de075b38f91b80949f95cd0c3a10295615ee013f82130bfac5fe9b5b3e8e75531f232680
+  languageName: node
+  linkType: hard
+
 "css-select@npm:^4.1.3":
   version: 4.3.0
   resolution: "css-select@npm:4.3.0"
@@ -9064,6 +10496,26 @@ __metadata:
   languageName: node
   linkType: hard
 
+"css-tree@npm:^2.3.1":
+  version: 2.3.1
+  resolution: "css-tree@npm:2.3.1"
+  dependencies:
+    mdn-data: 2.0.30
+    source-map-js: ^1.0.1
+  checksum: 493cc24b5c22b05ee5314b8a0d72d8a5869491c1458017ae5ed75aeb6c3596637dbe1b11dac2548974624adec9f7a1f3a6cf40593dc1f9185eb0e8279543fbc0
+  languageName: node
+  linkType: hard
+
+"css-tree@npm:~2.2.0":
+  version: 2.2.1
+  resolution: "css-tree@npm:2.2.1"
+  dependencies:
+    mdn-data: 2.0.28
+    source-map-js: ^1.0.1
+  checksum: b94aa8cc2f09e6f66c91548411fcf74badcbad3e150345074715012d16333ce573596ff5dfca03c2a87edf1924716db765120f94247e919d72753628ba3aba27
+  languageName: node
+  linkType: hard
+
 "css-what@npm:^6.0.1, css-what@npm:^6.1.0":
   version: 6.1.0
   resolution: "css-what@npm:6.1.0"
@@ -9080,7 +10532,7 @@ __metadata:
   languageName: node
   linkType: hard
 
-"cssnano-preset-advanced@npm:^5.3.10, cssnano-preset-advanced@npm:^5.3.8":
+"cssnano-preset-advanced@npm:^5.3.8":
   version: 5.3.10
   resolution: "cssnano-preset-advanced@npm:5.3.10"
   dependencies:
@@ -9096,6 +10548,23 @@ __metadata:
   languageName: node
   linkType: hard
 
+"cssnano-preset-advanced@npm:^6.1.2":
+  version: 6.1.2
+  resolution: "cssnano-preset-advanced@npm:6.1.2"
+  dependencies:
+    autoprefixer: ^10.4.19
+    browserslist: ^4.23.0
+    cssnano-preset-default: ^6.1.2
+    postcss-discard-unused: ^6.0.5
+    postcss-merge-idents: ^6.0.3
+    postcss-reduce-idents: ^6.0.3
+    postcss-zindex: ^6.0.2
+  peerDependencies:
+    postcss: ^8.4.31
+  checksum: cf70e27915947412730abb3075587efb66bcea58d7f1b906a7225bb4a40c9ca40150251a2ac33363d4f55bbdeb9ba000c242fa6244ee36cba2477ac07fbbe791
+  languageName: node
+  linkType: hard
+
 "cssnano-preset-default@npm:^5.2.14":
   version: 5.2.14
   resolution: "cssnano-preset-default@npm:5.2.14"
@@ -9135,6 +10604,46 @@ __metadata:
   languageName: node
   linkType: hard
 
+"cssnano-preset-default@npm:^6.1.2":
+  version: 6.1.2
+  resolution: "cssnano-preset-default@npm:6.1.2"
+  dependencies:
+    browserslist: ^4.23.0
+    css-declaration-sorter: ^7.2.0
+    cssnano-utils: ^4.0.2
+    postcss-calc: ^9.0.1
+    postcss-colormin: ^6.1.0
+    postcss-convert-values: ^6.1.0
+    postcss-discard-comments: ^6.0.2
+    postcss-discard-duplicates: ^6.0.3
+    postcss-discard-empty: ^6.0.3
+    postcss-discard-overridden: ^6.0.2
+    postcss-merge-longhand: ^6.0.5
+    postcss-merge-rules: ^6.1.1
+    postcss-minify-font-values: ^6.1.0
+    postcss-minify-gradients: ^6.0.3
+    postcss-minify-params: ^6.1.0
+    postcss-minify-selectors: ^6.0.4
+    postcss-normalize-charset: ^6.0.2
+    postcss-normalize-display-values: ^6.0.2
+    postcss-normalize-positions: ^6.0.2
+    postcss-normalize-repeat-style: ^6.0.2
+    postcss-normalize-string: ^6.0.2
+    postcss-normalize-timing-functions: ^6.0.2
+    postcss-normalize-unicode: ^6.1.0
+    postcss-normalize-url: ^6.0.2
+    postcss-normalize-whitespace: ^6.0.2
+    postcss-ordered-values: ^6.0.2
+    postcss-reduce-initial: ^6.1.0
+    postcss-reduce-transforms: ^6.0.2
+    postcss-svgo: ^6.0.3
+    postcss-unique-selectors: ^6.0.4
+  peerDependencies:
+    postcss: ^8.4.31
+  checksum: 51d93e52df7141143947dc4695b5087c04b41ea153e4f4c0282ac012b62c7457c6aca244f604ae94fa3b4840903a30a1e7df38f8610e0b304d05e3065375ee56
+  languageName: node
+  linkType: hard
+
 "cssnano-utils@npm:^3.1.0":
   version: 3.1.0
   resolution: "cssnano-utils@npm:3.1.0"
@@ -9144,7 +10653,16 @@ __metadata:
   languageName: node
   linkType: hard
 
-"cssnano@npm:^5.1.12, cssnano@npm:^5.1.15, cssnano@npm:^5.1.8":
+"cssnano-utils@npm:^4.0.2":
+  version: 4.0.2
+  resolution: "cssnano-utils@npm:4.0.2"
+  peerDependencies:
+    postcss: ^8.4.31
+  checksum: f04c6854e75d847c7a43aff835e003d5bc7387ddfc476f0ad3a2d63663d0cec41047d46604c1717bf6b5a8e24e54bb519e465ff78d62c7e073c7cbe2279bebaf
+  languageName: node
+  linkType: hard
+
+"cssnano@npm:^5.1.12, cssnano@npm:^5.1.8":
   version: 5.1.15
   resolution: "cssnano@npm:5.1.15"
   dependencies:
@@ -9157,6 +10675,18 @@ __metadata:
   languageName: node
   linkType: hard
 
+"cssnano@npm:^6.0.1, cssnano@npm:^6.1.2":
+  version: 6.1.2
+  resolution: "cssnano@npm:6.1.2"
+  dependencies:
+    cssnano-preset-default: ^6.1.2
+    lilconfig: ^3.1.1
+  peerDependencies:
+    postcss: ^8.4.31
+  checksum: 65aad92c5ee0089ffd4cd933c18c65edbf7634f7c3cd833a499dc948aa7e4168be22130dfe83bde07fcdc87f7c45a02d09040b7f439498208bc90b8d5a9abcc8
+  languageName: node
+  linkType: hard
+
 "csso@npm:^4.2.0":
   version: 4.2.0
   resolution: "csso@npm:4.2.0"
@@ -9166,6 +10696,15 @@ __metadata:
   languageName: node
   linkType: hard
 
+"csso@npm:^5.0.5":
+  version: 5.0.5
+  resolution: "csso@npm:5.0.5"
+  dependencies:
+    css-tree: ~2.2.0
+  checksum: 0ad858d36bf5012ed243e9ec69962a867509061986d2ee07cc040a4b26e4d062c00d4c07e5ba8d430706ceb02dd87edd30a52b5937fd45b1b6f2119c4993d59a
+  languageName: node
+  linkType: hard
+
 "csstype@npm:^3.0.2":
   version: 3.1.3
   resolution: "csstype@npm:3.1.3"
@@ -9281,7 +10820,7 @@ __metadata:
   languageName: node
   linkType: hard
 
-"deepmerge@npm:^4.2.2":
+"deepmerge@npm:^4.2.2, deepmerge@npm:^4.3.1":
   version: 4.3.1
   resolution: "deepmerge@npm:4.3.1"
   checksum: 2024c6a980a1b7128084170c4cf56b0fd58a63f2da1660dcfe977415f27b17dbe5888668b59d0b063753f3220719d5e400b7f113609489c90160bb9a5518d052
@@ -9557,11 +11096,11 @@ __metadata:
   version: 0.0.0-use.local
   resolution: "docs@workspace:docs"
   dependencies:
-    "@docusaurus/core": ^3.0.1
-    "@docusaurus/module-type-aliases": ^3.0.1
-    "@docusaurus/preset-classic": ^3.0.1
-    "@docusaurus/tsconfig": ^3.0.1
-    "@docusaurus/types": ^3.0.1
+    "@docusaurus/core": ^3.5.2
+    "@docusaurus/module-type-aliases": ^3.5.2
+    "@docusaurus/preset-classic": ^3.5.2
+    "@docusaurus/tsconfig": ^3.5.2
+    "@docusaurus/types": ^3.5.2
     "@easyops-cn/docusaurus-search-local": ^0.35.0
     "@mdx-js/react": ^3.0.0
     "@noir-lang/noir_js": "workspace:*"
@@ -9751,6 +11290,13 @@ __metadata:
   languageName: node
   linkType: hard
 
+"electron-to-chromium@npm:^1.5.28":
+  version: 1.5.29
+  resolution: "electron-to-chromium@npm:1.5.29"
+  checksum: c1de62aaea88c9b3ba32f8f2703b9d77a81633099a8f61365eaf9855d36e72189dcd99b9c3b8b2804afa403ac2ce0b00c23affa6f19d17b04ce0076f66a546b6
+  languageName: node
+  linkType: hard
+
 "elliptic@npm:6.5.4, elliptic@npm:^6.5.2, elliptic@npm:^6.5.4":
   version: 6.5.4
   resolution: "elliptic@npm:6.5.4"
@@ -10085,6 +11631,13 @@ __metadata:
   languageName: node
   linkType: hard
 
+"escalade@npm:^3.2.0":
+  version: 3.2.0
+  resolution: "escalade@npm:3.2.0"
+  checksum: 47b029c83de01b0d17ad99ed766347b974b0d628e848de404018f3abee728e987da0d2d370ad4574aa3d5b5bfc368754fd085d69a30f8e75903486ec4b5b709e
+  languageName: node
+  linkType: hard
+
 "escape-goat@npm:^2.0.0":
   version: 2.1.1
   resolution: "escape-goat@npm:2.1.1"
@@ -11032,7 +12585,7 @@ __metadata:
   languageName: node
   linkType: hard
 
-"fraction.js@npm:^4.3.6":
+"fraction.js@npm:^4.3.6, fraction.js@npm:^4.3.7":
   version: 4.3.7
   resolution: "fraction.js@npm:4.3.7"
   checksum: e1553ae3f08e3ba0e8c06e43a3ab20b319966dfb7ddb96fd9b5d0ee11a66571af7f993229c88ebbb0d4a816eb813a24ed48207b140d442a8f76f33763b8d1f3f
@@ -11057,7 +12610,7 @@ __metadata:
   languageName: node
   linkType: hard
 
-"fs-extra@npm:^11.1.1":
+"fs-extra@npm:^11.1.1, fs-extra@npm:^11.2.0":
   version: 11.2.0
   resolution: "fs-extra@npm:11.2.0"
   dependencies:
@@ -12494,10 +14047,10 @@ __metadata:
   languageName: node
   linkType: hard
 
-"infima@npm:0.2.0-alpha.43":
-  version: 0.2.0-alpha.43
-  resolution: "infima@npm:0.2.0-alpha.43"
-  checksum: fc5f79240e940eddd750439511767092ccb4051e5e91d253ec7630a9e7ce691812da3aa0f05e46b4c0a95dbfadeae5714fd0073f8d2df12e5aaff0697a1d6aa2
+"infima@npm:0.2.0-alpha.44":
+  version: 0.2.0-alpha.44
+  resolution: "infima@npm:0.2.0-alpha.44"
+  checksum: e9871f4056c0c8b311fcd32e2864d23a8f6807af5ff32d3c4d8271ad9971b5a7ea5016787a6b215893bb3e9f5f14326816bc05151d576dd375b0d79279cdfa8b
   languageName: node
   linkType: hard
 
@@ -12571,7 +14124,7 @@ __metadata:
   version: 0.0.0-use.local
   resolution: "integration-tests@workspace:compiler/integration-tests"
   dependencies:
-    "@noir-lang/backend_barretenberg": "workspace:*"
+    "@aztec/bb.js": 0.66.0
     "@noir-lang/noir_js": "workspace:*"
     "@noir-lang/noir_wasm": "workspace:*"
     "@nomicfoundation/hardhat-chai-matchers": ^2.0.0
@@ -13230,7 +14783,7 @@ __metadata:
   languageName: node
   linkType: hard
 
-"jest-worker@npm:^29.1.2":
+"jest-worker@npm:^29.1.2, jest-worker@npm:^29.4.3":
   version: 29.7.0
   resolution: "jest-worker@npm:29.7.0"
   dependencies:
@@ -13748,6 +15301,13 @@ __metadata:
   languageName: node
   linkType: hard
 
+"lilconfig@npm:^3.1.1":
+  version: 3.1.2
+  resolution: "lilconfig@npm:3.1.2"
+  checksum: 4e8b83ddd1d0ad722600994e6ba5d858ddca14f0587aa6b9c8185e17548149b5e13d4d583d811e9e9323157fa8c6a527e827739794c7502b59243c58e210b8c3
+  languageName: node
+  linkType: hard
+
 "lines-and-columns@npm:^1.1.6":
   version: 1.2.4
   resolution: "lines-and-columns@npm:1.2.4"
@@ -14450,6 +16010,20 @@ __metadata:
   languageName: node
   linkType: hard
 
+"mdn-data@npm:2.0.28":
+  version: 2.0.28
+  resolution: "mdn-data@npm:2.0.28"
+  checksum: f51d587a6ebe8e426c3376c74ea6df3e19ec8241ed8e2466c9c8a3904d5d04397199ea4f15b8d34d14524b5de926d8724ae85207984be47e165817c26e49e0aa
+  languageName: node
+  linkType: hard
+
+"mdn-data@npm:2.0.30":
+  version: 2.0.30
+  resolution: "mdn-data@npm:2.0.30"
+  checksum: d6ac5ac7439a1607df44b22738ecf83f48e66a0874e4482d6424a61c52da5cde5750f1d1229b6f5fa1b80a492be89465390da685b11f97d62b8adcc6e88189aa
+  languageName: node
+  linkType: hard
+
 "mdurl@npm:^1.0.0":
   version: 1.0.1
   resolution: "mdurl@npm:1.0.1"
@@ -15537,6 +17111,13 @@ __metadata:
   languageName: node
   linkType: hard
 
+"node-releases@npm:^2.0.18":
+  version: 2.0.18
+  resolution: "node-releases@npm:2.0.18"
+  checksum: ef55a3d853e1269a6d6279b7692cd6ff3e40bc74947945101138745bfdc9a5edabfe72cb19a31a8e45752e1910c4c65c77d931866af6357f242b172b7283f5b3
+  languageName: node
+  linkType: hard
+
 "nopt@npm:^7.0.0":
   version: 7.2.0
   resolution: "nopt@npm:7.2.0"
@@ -16265,6 +17846,13 @@ __metadata:
   languageName: node
   linkType: hard
 
+"picocolors@npm:^1.0.1, picocolors@npm:^1.1.0":
+  version: 1.1.0
+  resolution: "picocolors@npm:1.1.0"
+  checksum: a64d653d3a188119ff45781dfcdaeedd7625583f45280aea33fcb032c7a0d3959f2368f9b192ad5e8aade75b74dbd954ffe3106c158509a45e4c18ab379a2acd
+  languageName: node
+  linkType: hard
+
 "picomatch@npm:^2.0.4, picomatch@npm:^2.2.1, picomatch@npm:^2.2.2, picomatch@npm:^2.2.3, picomatch@npm:^2.3.1":
   version: 2.3.1
   resolution: "picomatch@npm:2.3.1"
@@ -16346,17 +17934,43 @@ __metadata:
   languageName: node
   linkType: hard
 
+"postcss-calc@npm:^9.0.1":
+  version: 9.0.1
+  resolution: "postcss-calc@npm:9.0.1"
+  dependencies:
+    postcss-selector-parser: ^6.0.11
+    postcss-value-parser: ^4.2.0
+  peerDependencies:
+    postcss: ^8.2.2
+  checksum: 7327ed83bfec544ab8b3e38353baa72ff6d04378b856db4ad82dbd68ce0b73668867ef182b5d4025f9dd9aa9c64aacc50cd1bd9db8d8b51ccc4cb97866b9d72b
+  languageName: node
+  linkType: hard
+
 "postcss-colormin@npm:^5.3.1":
   version: 5.3.1
   resolution: "postcss-colormin@npm:5.3.1"
   dependencies:
-    browserslist: ^4.21.4
+    browserslist: ^4.21.4
+    caniuse-api: ^3.0.0
+    colord: ^2.9.1
+    postcss-value-parser: ^4.2.0
+  peerDependencies:
+    postcss: ^8.2.15
+  checksum: e5778baab30877cd1f51e7dc9d2242a162aeca6360a52956acd7f668c5bc235c2ccb7e4df0370a804d65ebe00c5642366f061db53aa823f9ed99972cebd16024
+  languageName: node
+  linkType: hard
+
+"postcss-colormin@npm:^6.1.0":
+  version: 6.1.0
+  resolution: "postcss-colormin@npm:6.1.0"
+  dependencies:
+    browserslist: ^4.23.0
     caniuse-api: ^3.0.0
-    colord: ^2.9.1
+    colord: ^2.9.3
     postcss-value-parser: ^4.2.0
   peerDependencies:
-    postcss: ^8.2.15
-  checksum: e5778baab30877cd1f51e7dc9d2242a162aeca6360a52956acd7f668c5bc235c2ccb7e4df0370a804d65ebe00c5642366f061db53aa823f9ed99972cebd16024
+    postcss: ^8.4.31
+  checksum: 55a1525de345d953bc7f32ecaa5ee6275ef0277c27d1f97ff06a1bd1a2fedf7f254e36dc1500621f1df20c25a6d2485a74a0b527d8ff74eb90726c76efe2ac8e
   languageName: node
   linkType: hard
 
@@ -16372,6 +17986,18 @@ __metadata:
   languageName: node
   linkType: hard
 
+"postcss-convert-values@npm:^6.1.0":
+  version: 6.1.0
+  resolution: "postcss-convert-values@npm:6.1.0"
+  dependencies:
+    browserslist: ^4.23.0
+    postcss-value-parser: ^4.2.0
+  peerDependencies:
+    postcss: ^8.4.31
+  checksum: 43e9f66af9bdec3c76695f9dde36885abc01f662c370c490b45d895459caab2c5792f906f3ddad107129133e41485a65634da7f699eef916a636e47f6a37a299
+  languageName: node
+  linkType: hard
+
 "postcss-discard-comments@npm:^5.1.2":
   version: 5.1.2
   resolution: "postcss-discard-comments@npm:5.1.2"
@@ -16381,6 +18007,15 @@ __metadata:
   languageName: node
   linkType: hard
 
+"postcss-discard-comments@npm:^6.0.2":
+  version: 6.0.2
+  resolution: "postcss-discard-comments@npm:6.0.2"
+  peerDependencies:
+    postcss: ^8.4.31
+  checksum: c1731ccc8d1e3d910412a61395988d3033365e6532d9e5432ad7c74add8c9dcb0af0c03d4e901bf0d2b59ea4e7297a0c77a547ff2ed1b1cc065559cc0de43b4e
+  languageName: node
+  linkType: hard
+
 "postcss-discard-duplicates@npm:^5.1.0":
   version: 5.1.0
   resolution: "postcss-discard-duplicates@npm:5.1.0"
@@ -16390,6 +18025,15 @@ __metadata:
   languageName: node
   linkType: hard
 
+"postcss-discard-duplicates@npm:^6.0.3":
+  version: 6.0.3
+  resolution: "postcss-discard-duplicates@npm:6.0.3"
+  peerDependencies:
+    postcss: ^8.4.31
+  checksum: 308e3fb84c35e4703532de1efa5d6e8444cc5f167d0e40f42d7ea3fa3a37d9d636fd10729847d078e0c303eee16f8548d14b6f88a3fce4e38a2b452648465175
+  languageName: node
+  linkType: hard
+
 "postcss-discard-empty@npm:^5.1.1":
   version: 5.1.1
   resolution: "postcss-discard-empty@npm:5.1.1"
@@ -16399,6 +18043,15 @@ __metadata:
   languageName: node
   linkType: hard
 
+"postcss-discard-empty@npm:^6.0.3":
+  version: 6.0.3
+  resolution: "postcss-discard-empty@npm:6.0.3"
+  peerDependencies:
+    postcss: ^8.4.31
+  checksum: bad305572faa066026a295faab37e718cee096589ab827b19c990c55620b2b2a1ce9f0145212651737a66086db01b2676c1927bbb8408c5f9cb42686d5959f00
+  languageName: node
+  linkType: hard
+
 "postcss-discard-overridden@npm:^5.1.0":
   version: 5.1.0
   resolution: "postcss-discard-overridden@npm:5.1.0"
@@ -16408,6 +18061,15 @@ __metadata:
   languageName: node
   linkType: hard
 
+"postcss-discard-overridden@npm:^6.0.2":
+  version: 6.0.2
+  resolution: "postcss-discard-overridden@npm:6.0.2"
+  peerDependencies:
+    postcss: ^8.4.31
+  checksum: a38e0fe7a36f83cb9b73c1ba9ee2a48cf93c69ec0ea5753935824ffb71e958e58ae0393171c0f3d0014a397469d09bbb0d56bb5ab80f0280722967e2e273aebb
+  languageName: node
+  linkType: hard
+
 "postcss-discard-unused@npm:^5.1.0":
   version: 5.1.0
   resolution: "postcss-discard-unused@npm:5.1.0"
@@ -16419,6 +18081,17 @@ __metadata:
   languageName: node
   linkType: hard
 
+"postcss-discard-unused@npm:^6.0.5":
+  version: 6.0.5
+  resolution: "postcss-discard-unused@npm:6.0.5"
+  dependencies:
+    postcss-selector-parser: ^6.0.16
+  peerDependencies:
+    postcss: ^8.4.31
+  checksum: 7962640773240186de38125f142a6555b7f9b2493c4968e0f0b11c6629b2bf43ac70b9fc4ee78aa732d82670ad8bf802b2febc9a9864b022eb68530eded26836
+  languageName: node
+  linkType: hard
+
 "postcss-loader@npm:^7.0.0, postcss-loader@npm:^7.3.3":
   version: 7.3.3
   resolution: "postcss-loader@npm:7.3.3"
@@ -16445,6 +18118,18 @@ __metadata:
   languageName: node
   linkType: hard
 
+"postcss-merge-idents@npm:^6.0.3":
+  version: 6.0.3
+  resolution: "postcss-merge-idents@npm:6.0.3"
+  dependencies:
+    cssnano-utils: ^4.0.2
+    postcss-value-parser: ^4.2.0
+  peerDependencies:
+    postcss: ^8.4.31
+  checksum: b45780d6d103b8e45a580032747ee6e1842f81863672341a6b4961397e243ca896217bf1f3ee732376a766207d5f610ba8924cf08cf6d5bbd4b093133fd05d70
+  languageName: node
+  linkType: hard
+
 "postcss-merge-longhand@npm:^5.1.7":
   version: 5.1.7
   resolution: "postcss-merge-longhand@npm:5.1.7"
@@ -16457,6 +18142,18 @@ __metadata:
   languageName: node
   linkType: hard
 
+"postcss-merge-longhand@npm:^6.0.5":
+  version: 6.0.5
+  resolution: "postcss-merge-longhand@npm:6.0.5"
+  dependencies:
+    postcss-value-parser: ^4.2.0
+    stylehacks: ^6.1.1
+  peerDependencies:
+    postcss: ^8.4.31
+  checksum: 9ae5acf47dc0c1f494684ae55672d55bba7f5ee11c9c0f266aabd7c798e9f7394c6096363cd95685fd21ef088740389121a317772cf523ca22c915009bca2617
+  languageName: node
+  linkType: hard
+
 "postcss-merge-rules@npm:^5.1.4":
   version: 5.1.4
   resolution: "postcss-merge-rules@npm:5.1.4"
@@ -16471,6 +18168,20 @@ __metadata:
   languageName: node
   linkType: hard
 
+"postcss-merge-rules@npm:^6.1.1":
+  version: 6.1.1
+  resolution: "postcss-merge-rules@npm:6.1.1"
+  dependencies:
+    browserslist: ^4.23.0
+    caniuse-api: ^3.0.0
+    cssnano-utils: ^4.0.2
+    postcss-selector-parser: ^6.0.16
+  peerDependencies:
+    postcss: ^8.4.31
+  checksum: 43f60a1c88806491cf752ae7871676de0e7a2a9d6d2fc6bc894068cc35a910a63d30f7c7d79545e0926c8b3a9ec583e5e8357203c40b5bad5ff58133b0c900f6
+  languageName: node
+  linkType: hard
+
 "postcss-minify-font-values@npm:^5.1.0":
   version: 5.1.0
   resolution: "postcss-minify-font-values@npm:5.1.0"
@@ -16482,6 +18193,17 @@ __metadata:
   languageName: node
   linkType: hard
 
+"postcss-minify-font-values@npm:^6.1.0":
+  version: 6.1.0
+  resolution: "postcss-minify-font-values@npm:6.1.0"
+  dependencies:
+    postcss-value-parser: ^4.2.0
+  peerDependencies:
+    postcss: ^8.4.31
+  checksum: 985e4dd2f89220a4442a822aad7dff016ab58a9dbb7bbca9d01c2d07d5a1e7d8c02e1c6e836abb4c9b4e825b4b80d99ee1f5899e74bf0d969095037738e6e452
+  languageName: node
+  linkType: hard
+
 "postcss-minify-gradients@npm:^5.1.1":
   version: 5.1.1
   resolution: "postcss-minify-gradients@npm:5.1.1"
@@ -16495,6 +18217,19 @@ __metadata:
   languageName: node
   linkType: hard
 
+"postcss-minify-gradients@npm:^6.0.3":
+  version: 6.0.3
+  resolution: "postcss-minify-gradients@npm:6.0.3"
+  dependencies:
+    colord: ^2.9.3
+    cssnano-utils: ^4.0.2
+    postcss-value-parser: ^4.2.0
+  peerDependencies:
+    postcss: ^8.4.31
+  checksum: 89b95088c3830f829f6d4636d1be4d4f13300bf9f1577c48c25169c81e11ec0026760b9abb32112b95d2c622f09d3b737f4d2975a7842927ccb567e1002ef7b3
+  languageName: node
+  linkType: hard
+
 "postcss-minify-params@npm:^5.1.4":
   version: 5.1.4
   resolution: "postcss-minify-params@npm:5.1.4"
@@ -16508,6 +18243,19 @@ __metadata:
   languageName: node
   linkType: hard
 
+"postcss-minify-params@npm:^6.1.0":
+  version: 6.1.0
+  resolution: "postcss-minify-params@npm:6.1.0"
+  dependencies:
+    browserslist: ^4.23.0
+    cssnano-utils: ^4.0.2
+    postcss-value-parser: ^4.2.0
+  peerDependencies:
+    postcss: ^8.4.31
+  checksum: 1e1cc3057d9bcc532c70e40628e96e3aea0081d8072dffe983a270a8cd59c03ac585e57d036b70e43d4ee725f274a05a6a8efac5a715f448284e115c13f82a46
+  languageName: node
+  linkType: hard
+
 "postcss-minify-selectors@npm:^5.2.1":
   version: 5.2.1
   resolution: "postcss-minify-selectors@npm:5.2.1"
@@ -16519,6 +18267,17 @@ __metadata:
   languageName: node
   linkType: hard
 
+"postcss-minify-selectors@npm:^6.0.4":
+  version: 6.0.4
+  resolution: "postcss-minify-selectors@npm:6.0.4"
+  dependencies:
+    postcss-selector-parser: ^6.0.16
+  peerDependencies:
+    postcss: ^8.4.31
+  checksum: 150221a84422ca7627c67ee691ee51e0fe2c3583c8108801e9fc93d3be8b538c2eb04fcfdc908270d7eeaeaf01594a20b81311690a873efccb8a23aeafe1c354
+  languageName: node
+  linkType: hard
+
 "postcss-modules-extract-imports@npm:^3.0.0":
   version: 3.0.0
   resolution: "postcss-modules-extract-imports@npm:3.0.0"
@@ -16572,6 +18331,15 @@ __metadata:
   languageName: node
   linkType: hard
 
+"postcss-normalize-charset@npm:^6.0.2":
+  version: 6.0.2
+  resolution: "postcss-normalize-charset@npm:6.0.2"
+  peerDependencies:
+    postcss: ^8.4.31
+  checksum: 5b8aeb17d61578a8656571cd5d5eefa8d4ee7126a99a41fdd322078002a06f2ae96f649197b9c01067a5f3e38a2e4b03e0e3fda5a0ec9e3d7ad056211ce86156
+  languageName: node
+  linkType: hard
+
 "postcss-normalize-display-values@npm:^5.1.0":
   version: 5.1.0
   resolution: "postcss-normalize-display-values@npm:5.1.0"
@@ -16583,6 +18351,17 @@ __metadata:
   languageName: node
   linkType: hard
 
+"postcss-normalize-display-values@npm:^6.0.2":
+  version: 6.0.2
+  resolution: "postcss-normalize-display-values@npm:6.0.2"
+  dependencies:
+    postcss-value-parser: ^4.2.0
+  peerDependencies:
+    postcss: ^8.4.31
+  checksum: da30a9394b0e4a269ccad8d240693a6cd564bcc60e24db67caee00f70ddfbc070ad76faed64c32e6eec9ed02e92565488b7879d4fd6c40d877c290eadbb0bb28
+  languageName: node
+  linkType: hard
+
 "postcss-normalize-positions@npm:^5.1.1":
   version: 5.1.1
   resolution: "postcss-normalize-positions@npm:5.1.1"
@@ -16594,6 +18373,17 @@ __metadata:
   languageName: node
   linkType: hard
 
+"postcss-normalize-positions@npm:^6.0.2":
+  version: 6.0.2
+  resolution: "postcss-normalize-positions@npm:6.0.2"
+  dependencies:
+    postcss-value-parser: ^4.2.0
+  peerDependencies:
+    postcss: ^8.4.31
+  checksum: 44fb77583fae4d71b76e38226cf770570876bcf5af6940dc9aeac7a7e2252896b361e0249044766cff8dad445f925378f06a005d6541597573c20e599a62b516
+  languageName: node
+  linkType: hard
+
 "postcss-normalize-repeat-style@npm:^5.1.1":
   version: 5.1.1
   resolution: "postcss-normalize-repeat-style@npm:5.1.1"
@@ -16605,6 +18395,17 @@ __metadata:
   languageName: node
   linkType: hard
 
+"postcss-normalize-repeat-style@npm:^6.0.2":
+  version: 6.0.2
+  resolution: "postcss-normalize-repeat-style@npm:6.0.2"
+  dependencies:
+    postcss-value-parser: ^4.2.0
+  peerDependencies:
+    postcss: ^8.4.31
+  checksum: bebdac63bec6777ead3e265fc12527b261cf8d0da1b7f0abb12bda86fd53b7058e4afe392210ac74dac012e413bb1c2a46a1138c89f82b8bf70b81711f620f8c
+  languageName: node
+  linkType: hard
+
 "postcss-normalize-string@npm:^5.1.0":
   version: 5.1.0
   resolution: "postcss-normalize-string@npm:5.1.0"
@@ -16616,6 +18417,17 @@ __metadata:
   languageName: node
   linkType: hard
 
+"postcss-normalize-string@npm:^6.0.2":
+  version: 6.0.2
+  resolution: "postcss-normalize-string@npm:6.0.2"
+  dependencies:
+    postcss-value-parser: ^4.2.0
+  peerDependencies:
+    postcss: ^8.4.31
+  checksum: 5e8e253c528b542accafc142846fb33643c342a787c86e5b68c6287c7d8f63c5ae7d4d3fc28e3daf80821cc26a91add135e58bdd62ff9c735fca65d994898c7d
+  languageName: node
+  linkType: hard
+
 "postcss-normalize-timing-functions@npm:^5.1.0":
   version: 5.1.0
   resolution: "postcss-normalize-timing-functions@npm:5.1.0"
@@ -16627,6 +18439,17 @@ __metadata:
   languageName: node
   linkType: hard
 
+"postcss-normalize-timing-functions@npm:^6.0.2":
+  version: 6.0.2
+  resolution: "postcss-normalize-timing-functions@npm:6.0.2"
+  dependencies:
+    postcss-value-parser: ^4.2.0
+  peerDependencies:
+    postcss: ^8.4.31
+  checksum: 1970f5aad04be11f99d51c59e27debb6fd7b49d0fa4a8879062b42c82113f8e520a284448727add3b54de85deefb8bd5fe554f618406586e9ad8fc9d060609f1
+  languageName: node
+  linkType: hard
+
 "postcss-normalize-unicode@npm:^5.1.1":
   version: 5.1.1
   resolution: "postcss-normalize-unicode@npm:5.1.1"
@@ -16639,6 +18462,18 @@ __metadata:
   languageName: node
   linkType: hard
 
+"postcss-normalize-unicode@npm:^6.1.0":
+  version: 6.1.0
+  resolution: "postcss-normalize-unicode@npm:6.1.0"
+  dependencies:
+    browserslist: ^4.23.0
+    postcss-value-parser: ^4.2.0
+  peerDependencies:
+    postcss: ^8.4.31
+  checksum: 69ef35d06242061f0c504c128b83752e0f8daa30ebb26734de7d090460910be0b2efd8b17b1d64c3c85b95831a041faad9ad0aaba80e239406a79cfad3d63568
+  languageName: node
+  linkType: hard
+
 "postcss-normalize-url@npm:^5.1.0":
   version: 5.1.0
   resolution: "postcss-normalize-url@npm:5.1.0"
@@ -16651,6 +18486,17 @@ __metadata:
   languageName: node
   linkType: hard
 
+"postcss-normalize-url@npm:^6.0.2":
+  version: 6.0.2
+  resolution: "postcss-normalize-url@npm:6.0.2"
+  dependencies:
+    postcss-value-parser: ^4.2.0
+  peerDependencies:
+    postcss: ^8.4.31
+  checksum: bef51a18bbfee4fbf0381fec3c91e6c0dace36fca053bbd5f228e653d2732b6df3985525d79c4f7fc89f840ed07eb6d226e9d7503ecdc6f16d6d80cacae9df33
+  languageName: node
+  linkType: hard
+
 "postcss-normalize-whitespace@npm:^5.1.1":
   version: 5.1.1
   resolution: "postcss-normalize-whitespace@npm:5.1.1"
@@ -16662,6 +18508,17 @@ __metadata:
   languageName: node
   linkType: hard
 
+"postcss-normalize-whitespace@npm:^6.0.2":
+  version: 6.0.2
+  resolution: "postcss-normalize-whitespace@npm:6.0.2"
+  dependencies:
+    postcss-value-parser: ^4.2.0
+  peerDependencies:
+    postcss: ^8.4.31
+  checksum: 6081eb3a4b305749eec02c00a95c2d236336a77ee636bb1d939f18d5dfa5ba82b7cf7fa072e83f9133d0bc984276596af3fe468bdd67c742ce69e9c63dbc218d
+  languageName: node
+  linkType: hard
+
 "postcss-ordered-values@npm:^5.1.3":
   version: 5.1.3
   resolution: "postcss-ordered-values@npm:5.1.3"
@@ -16674,6 +18531,18 @@ __metadata:
   languageName: node
   linkType: hard
 
+"postcss-ordered-values@npm:^6.0.2":
+  version: 6.0.2
+  resolution: "postcss-ordered-values@npm:6.0.2"
+  dependencies:
+    cssnano-utils: ^4.0.2
+    postcss-value-parser: ^4.2.0
+  peerDependencies:
+    postcss: ^8.4.31
+  checksum: c3d96177b4ffa43754e835e30c40043cc75ab1e95eb6c55ac8723eb48c13a12e986250e63d96619bbbd1a098876a1c0c1b3b7a8e1de1108a009cf7aa0beac834
+  languageName: node
+  linkType: hard
+
 "postcss-reduce-idents@npm:^5.2.0":
   version: 5.2.0
   resolution: "postcss-reduce-idents@npm:5.2.0"
@@ -16685,6 +18554,17 @@ __metadata:
   languageName: node
   linkType: hard
 
+"postcss-reduce-idents@npm:^6.0.3":
+  version: 6.0.3
+  resolution: "postcss-reduce-idents@npm:6.0.3"
+  dependencies:
+    postcss-value-parser: ^4.2.0
+  peerDependencies:
+    postcss: ^8.4.31
+  checksum: 1feff316838f947386c908f50807cf1b9589fd09b8e8df633a01f2640af5492833cc892448938ceba10ab96826c44767b8f2e1569d587579423f2db81202f7c7
+  languageName: node
+  linkType: hard
+
 "postcss-reduce-initial@npm:^5.1.2":
   version: 5.1.2
   resolution: "postcss-reduce-initial@npm:5.1.2"
@@ -16697,6 +18577,18 @@ __metadata:
   languageName: node
   linkType: hard
 
+"postcss-reduce-initial@npm:^6.1.0":
+  version: 6.1.0
+  resolution: "postcss-reduce-initial@npm:6.1.0"
+  dependencies:
+    browserslist: ^4.23.0
+    caniuse-api: ^3.0.0
+  peerDependencies:
+    postcss: ^8.4.31
+  checksum: 39e4034ffbf62a041b66944c5cebc4b17f656e76b97568f7f6230b0b886479e5c75b02ae4ba48c472cb0bde47489f9ed1fe6110ae8cff0d7b7165f53c2d64a12
+  languageName: node
+  linkType: hard
+
 "postcss-reduce-transforms@npm:^5.1.0":
   version: 5.1.0
   resolution: "postcss-reduce-transforms@npm:5.1.0"
@@ -16708,6 +18600,27 @@ __metadata:
   languageName: node
   linkType: hard
 
+"postcss-reduce-transforms@npm:^6.0.2":
+  version: 6.0.2
+  resolution: "postcss-reduce-transforms@npm:6.0.2"
+  dependencies:
+    postcss-value-parser: ^4.2.0
+  peerDependencies:
+    postcss: ^8.4.31
+  checksum: c424cc554eb5d253b7687b64925a13fc16759f058795d223854f5a20d9bca641b5f25d0559d03287e63f07a4629c24ac78156adcf604483fcad3c51721da0a08
+  languageName: node
+  linkType: hard
+
+"postcss-selector-parser@npm:^6.0.11, postcss-selector-parser@npm:^6.0.16":
+  version: 6.1.2
+  resolution: "postcss-selector-parser@npm:6.1.2"
+  dependencies:
+    cssesc: ^3.0.0
+    util-deprecate: ^1.0.2
+  checksum: ce9440fc42a5419d103f4c7c1847cb75488f3ac9cbe81093b408ee9701193a509f664b4d10a2b4d82c694ee7495e022f8f482d254f92b7ffd9ed9dea696c6f84
+  languageName: node
+  linkType: hard
+
 "postcss-selector-parser@npm:^6.0.2, postcss-selector-parser@npm:^6.0.4, postcss-selector-parser@npm:^6.0.5, postcss-selector-parser@npm:^6.0.9":
   version: 6.0.13
   resolution: "postcss-selector-parser@npm:6.0.13"
@@ -16718,7 +18631,7 @@ __metadata:
   languageName: node
   linkType: hard
 
-"postcss-sort-media-queries@npm:^4.2.1, postcss-sort-media-queries@npm:^4.4.1":
+"postcss-sort-media-queries@npm:^4.2.1":
   version: 4.4.1
   resolution: "postcss-sort-media-queries@npm:4.4.1"
   dependencies:
@@ -16729,6 +18642,17 @@ __metadata:
   languageName: node
   linkType: hard
 
+"postcss-sort-media-queries@npm:^5.2.0":
+  version: 5.2.0
+  resolution: "postcss-sort-media-queries@npm:5.2.0"
+  dependencies:
+    sort-css-media-queries: 2.2.0
+  peerDependencies:
+    postcss: ^8.4.23
+  checksum: d4a976a64b53234762cc35c06ce97c1684bd7a64ead17e84c2047676c7307945be7c005235e6aac7c4620e1f835d6ba1a7dcf018ab7fe0a47657c62c96ad9f35
+  languageName: node
+  linkType: hard
+
 "postcss-svgo@npm:^5.1.0":
   version: 5.1.0
   resolution: "postcss-svgo@npm:5.1.0"
@@ -16741,6 +18665,18 @@ __metadata:
   languageName: node
   linkType: hard
 
+"postcss-svgo@npm:^6.0.3":
+  version: 6.0.3
+  resolution: "postcss-svgo@npm:6.0.3"
+  dependencies:
+    postcss-value-parser: ^4.2.0
+    svgo: ^3.2.0
+  peerDependencies:
+    postcss: ^8.4.31
+  checksum: 1a7d1c8dea555884a7791e28ec2c22ea92331731067584ff5a23042a0e615f88fefde04e1140f11c262a728ef9fab6851423b40b9c47f9ae05353bd3c0ff051a
+  languageName: node
+  linkType: hard
+
 "postcss-unique-selectors@npm:^5.1.1":
   version: 5.1.1
   resolution: "postcss-unique-selectors@npm:5.1.1"
@@ -16752,6 +18688,17 @@ __metadata:
   languageName: node
   linkType: hard
 
+"postcss-unique-selectors@npm:^6.0.4":
+  version: 6.0.4
+  resolution: "postcss-unique-selectors@npm:6.0.4"
+  dependencies:
+    postcss-selector-parser: ^6.0.16
+  peerDependencies:
+    postcss: ^8.4.31
+  checksum: b09df9943b4e858e88b30f3d279ce867a0490df806f1f947d286b0a4e95ba923f1229c385e5bf365f4f124f1edccda41ec18ccad4ba8798d829279d6dc971203
+  languageName: node
+  linkType: hard
+
 "postcss-value-parser@npm:^4.1.0, postcss-value-parser@npm:^4.2.0":
   version: 4.2.0
   resolution: "postcss-value-parser@npm:4.2.0"
@@ -16768,6 +18715,15 @@ __metadata:
   languageName: node
   linkType: hard
 
+"postcss-zindex@npm:^6.0.2":
+  version: 6.0.2
+  resolution: "postcss-zindex@npm:6.0.2"
+  peerDependencies:
+    postcss: ^8.4.31
+  checksum: 394119e47b0fb098dc53d1bcf71b5500ab29605fe106526b2e81290bff179174ee00a82a4d4be5a42d4ef4138e8a3d6aabeef3b06cf7cb15b851848c8585d53b
+  languageName: node
+  linkType: hard
+
 "postcss@npm:^8.4.14, postcss@npm:^8.4.17, postcss@npm:^8.4.21, postcss@npm:^8.4.26":
   version: 8.4.32
   resolution: "postcss@npm:8.4.32"
@@ -16779,6 +18735,17 @@ __metadata:
   languageName: node
   linkType: hard
 
+"postcss@npm:^8.4.24, postcss@npm:^8.4.38":
+  version: 8.4.47
+  resolution: "postcss@npm:8.4.47"
+  dependencies:
+    nanoid: ^3.3.7
+    picocolors: ^1.1.0
+    source-map-js: ^1.2.1
+  checksum: f78440a9d8f97431dd2ab1ab8e1de64f12f3eff38a3d8d4a33919b96c381046a314658d2de213a5fa5eb296b656de76a3ec269fdea27f16d5ab465b916a0f52c
+  languageName: node
+  linkType: hard
+
 "prelude-ls@npm:^1.2.1":
   version: 1.2.1
   resolution: "prelude-ls@npm:1.2.1"
@@ -17266,6 +19233,17 @@ __metadata:
   languageName: node
   linkType: hard
 
+"react-loadable@npm:@docusaurus/react-loadable@6.0.0":
+  version: 6.0.0
+  resolution: "@docusaurus/react-loadable@npm:6.0.0"
+  dependencies:
+    "@types/react": "*"
+  peerDependencies:
+    react: "*"
+  checksum: 4c32061b2fc10689d5d8ba11ead71b69e4c8a55fcfeafb551a6747b1a7b496c4f2d8dbb5d023f5cafc2a9aea9d14582bdb324d11e6f9b8c3049d45b74439203f
+  languageName: node
+  linkType: hard
+
 "react-router-config@npm:^5.1.1":
   version: 5.1.1
   resolution: "react-router-config@npm:5.1.1"
@@ -18175,7 +20153,7 @@ __metadata:
   languageName: node
   linkType: hard
 
-"schema-utils@npm:^4.0.0, schema-utils@npm:^4.2.0":
+"schema-utils@npm:^4.0.0, schema-utils@npm:^4.0.1, schema-utils@npm:^4.2.0":
   version: 4.2.0
   resolution: "schema-utils@npm:4.2.0"
   dependencies:
@@ -18647,6 +20625,16 @@ __metadata:
   languageName: node
   linkType: hard
 
+"snake-case@npm:^3.0.4":
+  version: 3.0.4
+  resolution: "snake-case@npm:3.0.4"
+  dependencies:
+    dot-case: ^3.0.4
+    tslib: ^2.0.3
+  checksum: 0a7a79900bbb36f8aaa922cf111702a3647ac6165736d5dc96d3ef367efc50465cac70c53cd172c382b022dac72ec91710608e5393de71f76d7142e6fd80e8a3
+  languageName: node
+  linkType: hard
+
 "sockjs@npm:^0.3.24":
   version: 0.3.24
   resolution: "sockjs@npm:0.3.24"
@@ -18703,6 +20691,20 @@ __metadata:
   languageName: node
   linkType: hard
 
+"sort-css-media-queries@npm:2.2.0":
+  version: 2.2.0
+  resolution: "sort-css-media-queries@npm:2.2.0"
+  checksum: c090c9a27be40f3e50f5f9bc9d85a8af0e2c5152565eca34bdb028d952749bce169bc5abef21a5a385ca6221a0869640c9faf58f082ac46de9085ebdb506291f
+  languageName: node
+  linkType: hard
+
+"source-map-js@npm:^1.0.1, source-map-js@npm:^1.2.1":
+  version: 1.2.1
+  resolution: "source-map-js@npm:1.2.1"
+  checksum: 4eb0cd997cdf228bc253bcaff9340afeb706176e64868ecd20efbe6efea931465f43955612346d6b7318789e5265bdc419bc7669c1cebe3db0eb255f57efa76b
+  languageName: node
+  linkType: hard
+
 "source-map-js@npm:^1.0.2":
   version: 1.0.2
   resolution: "source-map-js@npm:1.0.2"
@@ -19072,6 +21074,18 @@ __metadata:
   languageName: node
   linkType: hard
 
+"stylehacks@npm:^6.1.1":
+  version: 6.1.1
+  resolution: "stylehacks@npm:6.1.1"
+  dependencies:
+    browserslist: ^4.23.0
+    postcss-selector-parser: ^6.0.16
+  peerDependencies:
+    postcss: ^8.4.31
+  checksum: 7bef69822280a23817caa43969de76d77ba34042e9f1f7baaeda8f22b1d8c20f1f839ad028552c169e158e387830f176feccd0324b07ef6ec657cba1dd0b2466
+  languageName: node
+  linkType: hard
+
 "superstruct@npm:^1.0.3":
   version: 1.0.3
   resolution: "superstruct@npm:1.0.3"
@@ -19137,6 +21151,23 @@ __metadata:
   languageName: node
   linkType: hard
 
+"svgo@npm:^3.0.2, svgo@npm:^3.2.0":
+  version: 3.3.2
+  resolution: "svgo@npm:3.3.2"
+  dependencies:
+    "@trysound/sax": 0.2.0
+    commander: ^7.2.0
+    css-select: ^5.1.0
+    css-tree: ^2.3.1
+    css-what: ^6.1.0
+    csso: ^5.0.5
+    picocolors: ^1.0.0
+  bin:
+    svgo: ./bin/svgo
+  checksum: a3f8aad597dec13ab24e679c4c218147048dc1414fe04e99447c5f42a6e077b33d712d306df84674b5253b98c9b84dfbfb41fdd08552443b04946e43d03e054e
+  languageName: node
+  linkType: hard
+
 "synckit@npm:^0.8.6":
   version: 0.8.8
   resolution: "synckit@npm:0.8.8"
@@ -19750,7 +21781,7 @@ __metadata:
   languageName: node
   linkType: hard
 
-"typescript@npm:5.4.2, typescript@npm:^5.4.2":
+"typescript@npm:^5.4.2":
   version: 5.4.2
   resolution: "typescript@npm:5.4.2"
   bin:
@@ -19760,7 +21791,7 @@ __metadata:
   languageName: node
   linkType: hard
 
-"typescript@patch:typescript@5.4.2#~builtin<compat/typescript>, typescript@patch:typescript@^5.4.2#~builtin<compat/typescript>":
+"typescript@patch:typescript@^5.4.2#~builtin<compat/typescript>":
   version: 5.4.2
   resolution: "typescript@patch:typescript@npm%3A5.4.2#~builtin<compat/typescript>::version=5.4.2&hash=f3b441"
   bin:
@@ -20155,6 +22186,20 @@ __metadata:
   languageName: node
   linkType: hard
 
+"update-browserslist-db@npm:^1.1.0":
+  version: 1.1.1
+  resolution: "update-browserslist-db@npm:1.1.1"
+  dependencies:
+    escalade: ^3.2.0
+    picocolors: ^1.1.0
+  peerDependencies:
+    browserslist: ">= 4.21.0"
+  bin:
+    update-browserslist-db: cli.js
+  checksum: 2ea11bd2562122162c3e438d83a1f9125238c0844b6d16d366e3276d0c0acac6036822dc7df65fc5a89c699cdf9f174acf439c39bedf3f9a2f3983976e4b4c3e
+  languageName: node
+  linkType: hard
+
 "update-check@npm:1.5.4":
   version: 1.5.4
   resolution: "update-check@npm:1.5.4"